merge with harmony

.gitlab-ci.yml

@@ -8,6 +8,8 @@ job1:
    - echo $EXTERNAL_SHARE_DIR
    - echo $SHELL
    - echo $OAI_TEST_CASE_GROUP
+   - echo $MACHINELIST
+   - echo $MACHINELISTGENERIC
    - git rev-parse --abbrev-ref HEAD
    - git_repo=`git config --get remote.origin.url`
    - git_head=`git rev-parse HEAD`
@@ -25,8 +27,8 @@ job1:
    - echo $NRUNS_LTE_SOFTMODEM
    - echo $TIMEOUT_CMD
    - mkdir -p $OPENAIR_DIR/cmake_targets/autotests/log
-   - python $OPENAIR_DIR/cmake_targets/autotests/run_exec_lte-softmodem_tests.py -c -5GRepo $git_repo -5GRepoHeadVersion $git_head -n $NFS_SHARE_DIR -u $OAI_USER -p $OAI_PASS  $OAI_EXTRA_ARGS -g "$OAI_TEST_CASE_GROUP">& $OPENAIR_DIR/cmake_targets/autotests/python_autotest_cleanup.log
+   - python $OPENAIR_DIR/cmake_targets/autotests/run_exec_lte-softmodem_tests.py -c -5GRepo $git_repo -MachineList "$MACHINELIST" -MachineListGeneric "$MACHINELISTGENERIC"  -5GRepoHeadVersion $git_head -n $NFS_SHARE_DIR -u $OAI_USER -p $OAI_PASS  $OAI_EXTRA_ARGS -g "$OAI_TEST_CASE_GROUP">& $OPENAIR_DIR/cmake_targets/autotests/python_autotest_cleanup.log
-   - python $OPENAIR_DIR/cmake_targets/autotests/run_exec_lte-softmodem_tests.py -r -5GRepo $git_repo -5GRepoHeadVersion $git_head -n $NFS_SHARE_DIR -u $OAI_USER -p $OAI_PASS `echo $OAI_EXTRA_ARGS` -g "$OAI_TEST_CASE_GROUP" --nrun_lte_softmodem $NRUNS_LTE_SOFTMODEM --timeout_cmd $TIMEOUT_CMD >& $OPENAIR_DIR/cmake_targets/autotests/python_autotest.log
+   - python $OPENAIR_DIR/cmake_targets/autotests/run_exec_lte-softmodem_tests.py -r -5GRepo $git_repo -MachineList "$MACHINELIST" -MachineListGeneric "$MACHINELISTGENERIC" -5GRepoHeadVersion $git_head -n $NFS_SHARE_DIR -u $OAI_USER -p $OAI_PASS `echo $OAI_EXTRA_ARGS` -g "$OAI_TEST_CASE_GROUP" --nrun_lte_softmodem $NRUNS_LTE_SOFTMODEM --timeout_cmd $TIMEOUT_CMD >& $OPENAIR_DIR/cmake_targets/autotests/python_autotest.log
    - mv $OPENAIR_DIR/cmake_targets/autotests/python_autotest.log $OPENAIR_DIR/cmake_targets/autotests/log/python_autotest.log
    - mv $OPENAIR_DIR/cmake_targets/autotests/python_autotest_cleanup.log $OPENAIR_DIR/cmake_targets/autotests/log/python_autotest_cleanup.log
    - sshpass -p "$OAI_PASS" rsync -az -e "ssh -o StrictHostKeyChecking=no "  --rsync-path="mkdir -p $NFS_TEST_RESULTS_DIR && rsync" $OPENAIR_DIR/cmake_targets/autotests/log $OAI_USER@localhost:$NFS_TEST_RESULTS_DIR

cmake_targets/CMakeLists.txt

@@ -126,6 +126,7 @@ endmacro(add_list_string_option)
 if (CMAKE_BUILD_TYPE STREQUAL "")
    set(CMAKE_BUILD_TYPE "RelWithDebInfo")
 endif()
+message("CMAKE_BUILD_TYPE is ${CMAKE_BUILD_TYPE}")
 add_list_string_option(CMAKE_BUILD_TYPE "RelWithDebInfo" "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel." Debug Release RelWithDebInfo MinSizeRel)
 
 Message("Architecture is ${CMAKE_SYSTEM_PROCESSOR}")
@@ -922,7 +923,14 @@ add_library(SECU_CN ${SECU_CN_SRC})
 
 # Scheduler
 ################################"
-file(GLOB SCHED_SRC ${OPENAIR1_DIR}/SCHED/*.c)
+set(SCHED_SRC 
+  ${OPENAIR1_DIR}/SCHED/phy_procedures_lte_eNb.c
+  ${OPENAIR1_DIR}/SCHED/phy_procedures_lte_ue.c
+  ${OPENAIR1_DIR}/SCHED/phy_procedures_lte_common.c
+  ${OPENAIR1_DIR}/SCHED/phy_mac_stub.c
+  ${OPENAIR1_DIR}/SCHED/pucch_pc.c
+  ${OPENAIR1_DIR}/SCHED/pusch_pc.c
+)
 add_library(SCHED_LIB ${SCHED_SRC})
 
 # Layer 1
@@ -952,6 +960,7 @@ set(PHY_SRC
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pucch.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/prach.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pmch.c
+  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/pch.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/group_hopping.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/srs_modulation.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/drs_modulation.c
@@ -1624,10 +1633,9 @@ target_link_libraries (lte-softmodem -ldl
   RRC_LIB S1AP_LIB S1AP_ENB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB PHY LFDS L2 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ITTI_LIB} ${MIH_LIB} 
   -Wl,--end-group )
 
-
 target_link_libraries (lte-softmodem ${LIBXML2_LIBRARIES})
 target_link_libraries (lte-softmodem pthread m ${CONFIG_LIBRARIES} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp ${option_HW_lib} ${option_TP_lib} ${XFORMS_LIBRARIES} ) 
-target_link_libraries (lte-softmodem ${LIBBOOST_LIBRARIES})
+target_link_libraries (lte-softmodem ${LIBBOOST_LIBRARIES} -lboost_system) #Added manually as it is not found for some reason for USRP
 target_link_libraries (lte-softmodem ${LIB_LMS_LIBRARIES})
 target_link_libraries (lte-softmodem ${T_LIB})
 
@@ -1662,7 +1670,7 @@ target_link_libraries (lte-softmodem-nos1
 
 target_link_libraries (lte-softmodem-nos1 ${LIBXML2_LIBRARIES})
 target_link_libraries (lte-softmodem-nos1 pthread m ${CONFIG_LIBRARIES} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES}  ${option_HW_lib}  ${option_TP_lib} ${XFORMS_LIBRARIES} )
-target_link_libraries (lte-softmodem-nos1 ${LIBBOOST_LIBRARIES})
+target_link_libraries (lte-softmodem-nos1 ${LIBBOOST_LIBRARIES} -lboost_system) #Added manually as it is not found for some reason for USRP
 target_link_libraries (lte-softmodem-nos1  ${LIB_LMS_LIBRARIES})
 target_link_libraries (lte-softmodem-nos1 ${T_LIB})
 
@@ -1685,7 +1693,7 @@ target_link_libraries(rrh_gw
   UTIL LFDS  
   -Wl,--end-group )
 target_link_libraries (rrh_gw rt pthread m )
-target_link_libraries (rrh_gw  ${option_HW_lib} ${option_TP_lib} ${LIBBOOST_LIBRARIES} )
+target_link_libraries (rrh_gw  ${option_HW_lib} ${option_TP_lib} ${LIBBOOST_LIBRARIES} -lboost_system ) #Added manually as it is not found for some reason for USRP
 target_link_libraries (rrh_gw ${LIB_LMS_LIBRARIES})
 target_link_libraries (rrh_gw ${T_LIB})
 

cmake_targets/autotests/README.txt

@@ -16,17 +16,22 @@ Obj.#   Case#   Test#	Description
 01      01      20      Build lte-softmodem.USRP.Rel10
 01      01      21      Build lte-softmodem.EXMIMO.Rel10
 01      01      22      Build lte-softmodem.BLADERF.Rel10
-01      01      23      Build lte-softmodem.ETHERNET.Rel10
+01      01      23      Build lte-softmodem.ETHERNET.Rel10 (RCC)
 01      01      24      Build lte-softmodem.LMSSDR.Rel10
 
 01      01      30      Build (dlsim.Rel10 + ulsim.Rel10 + pucchsim.Rel10 + prachsim.Rel10 + pdcchsim.Rel10 + pbchsim.Rel10 + mbmssim.Rel10
                         secu_knas_encrypt_eia1.Rel10 secu_kenb.Rel10 aes128_ctr_encrypt.Rel10 aes128_ctr_decrypt.Rel10 secu_knas_encrypt_eea2.Rel10
                         secu_knas.Rel10 secu_knas_encrypt_eea1.Rel10 kdf.Rel10 aes128_cmac_encrypt.Rel10 secu_knas_encrypt_eia2.Rel10)
 
-01      01      40      Build RRH Gateway for USRP (Rel 10)
+01      01      40      Build RRH Gateway (time domain) for USRP (Rel 10)
-01      01      41      Build RRH Gateway for EXMIMO  (Rel 10)
+01      01      41      Build RRH Gateway (time domain) for EXMIMO  (Rel 10)
-01      01      42      Build RRH Gateway for BLADERF  (Rel 10)
+01      01      42      Build RRH Gateway (time domain) for BLADERF  (Rel 10)
-01      01      43      Build RRH Gateway for LMSSDR (Rel 10)
+01      01      43      Build RRH Gateway (time domain) for LMSSDR (Rel 10)
+
+01      01      50      Build RRU (NGFI) for USRP (Rel 10) w/ ETHERNET transport
+01      01      51      Build RRU (NGFI) for EXMIMO  (Rel 10) w/ ETHERNET transport
+01      01      52      Build RRU (NGFI) for BLADERF  (Rel 10) w/ ETHERNET transport
+01      01      53      Build RRU (NGFI) for LMSSDR (Rel 10) w/ ETHERNET transport
 
 
 01      02              Run OAISIM-NOS1 Rel10 (TDD + 5MHz/10MHz/20MHz + TM 1,2), and check the operation
@@ -249,4 +254,4 @@ Obj.#   Case#   Test#	Description
 #TODO: Add test cases for 10,20 MHz
 #TODO: Add test cases for TDD/FDD 
 #TODO: Test and compile seperately for Rel8/Rel10
-#TODO: Case03.py eMBMS test case
+#TODO: Case03.py eMBMS test case

cmake_targets/autotests/run_exec_lte-softmodem_tests.py

@@ -313,7 +313,7 @@ def SSHSessionWrapper(machine, username, key_file, password, logdir_remote, logd
 # \param CleanUpAluLteBox program to terminate AlU Bell Labs LTE Box
 # \param ExmimoRfStop String to stop EXMIMO card (specified in test_case_list.xml)
 def cleanOldPrograms(oai, programList, CleanUpAluLteBox, ExmimoRfStop, logdir, logdirOAI5GRepo):
-  cmd = 'killall -9 -q -r ' + programList
+  cmd = 'sudo -E killall -9 -q -r ' + programList
   result = oai.send(cmd, True)
   print "Killing old programs..." + result
   programArray = programList.split()
@@ -1020,6 +1020,13 @@ def handle_testcaseclass_softmodem (testcase, oldprogramList, logdirOAI5GRepo ,
       run_result=0
       run_result_string = ' RUN_'+str(run) + ' = FAIL(Thread_Busy)'
 
+    #If there is Segmentation fault, we mark the test case as failure as most likely eNB crashed
+    cmd = "grep -ilr \"segmentation fault\" " + logdir_local_testcase + " | cat "
+    cmd_out = subprocess.check_output ([cmd], shell=True)
+    if len(cmd_out) !=0:
+      run_result=0
+      run_result_string = ' RUN_'+str(run) + ' = FAIL(SEGFAULT)'
+
     run_result_string = run_result_string + tput_run_string
 
     test_result=test_result & run_result
@@ -1261,7 +1268,8 @@ except KeyError:
    sys.exit(1)
 
 print "Killing zombie ssh sessions from earlier sessions..."
-cmd='ps aux |grep \"/usr/bin/ssh -q -l guptar\"|tr -s \" \" :|cut -f 2 -d :|xargs kill -9 '
+cmd='ps aux |grep \"/usr/bin/ssh -q -l guptar\"| awk \'{print $2}\' | sudo xargs kill -9  '
+
 os.system(cmd)
 
 if flag_start_testcase == False:
@@ -1426,13 +1434,25 @@ for oai in oai_list:
      
       setuplogfile  = logdir  + '/setup_log_' + MachineList[index] + '_.txt'
       setup_script  = locallogdir  + '/setup_script_' + MachineList[index] +  '_.txt'
+
+      #Sometimes git fails so the script below retries in that case
+      localfile = os.path.expandvars('$OPENAIR_DIR/cmake_targets/autotests/tools/git-retry.sh')
+      remotefile = logdir + '/git-retry.sh'
+      paramList=[]
+      port=22
+      paramList.append ( {"operation":'put', "localfile":localfile, "remotefile":remotefile} )
+      sftp_log = os.path.expandvars(locallogdir + '/sftp_module.log')
+      sftp_module (user, pw, MachineList[index], port, paramList, sftp_log)
+
+
       cmd = ' ( \n'
       #cmd = cmd  + 'rm -fR ' +  logdir + '\n'
       #cmd = cmd + 'mkdir -p ' + logdir + '\n'
       cmd = cmd + 'cd '+ logdir   + '\n'
-      cmd = cmd + 'git config --global http.sslVerify false \n' 
+      cmd = cmd + 'sudo apt-get install -y git \n'
-      cmd = cmd + 'git clone  '+ GitOAI5GRepo  +' \n'
+      cmd = cmd + 'chmod 700 ' + logdir + '/git-retry.sh \n' 
-      cmd = cmd + 'git clone '+ GitOpenaircnRepo + ' \n'
+      cmd = cmd + logdir + '/git-retry.sh clone  '+ GitOAI5GRepo  +' \n'
+      cmd = cmd + logdir + '/git-retry.sh clone '+ GitOpenaircnRepo + ' \n'
       cmd = cmd +  'cd ' + logdirOAI5GRepo  + '\n'
       cmd = cmd + 'git checkout ' + GitOAI5GRepoBranch   + '\n'                      
       #cmd = cmd + 'git checkout ' + GitOAI5GHeadVersion   + '\n'

cmake_targets/autotests/tools/git-retry.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+#Simple script to retry git clone in case of failure
+
+REALGIT=/usr/bin/git
+
+RETRIES=10
+DELAY=10
+COUNT=1
+while [ $COUNT -lt $RETRIES ]; do
+  $REALGIT $* >> git-clone-`hostname`-log.txt 2>&1
+  if [ $? -eq 0 ]; then
+    RETRIES=0
+    break
+  fi
+  let COUNT=$COUNT+1
+  sleep $DELAY
+done

cmake_targets/autotests/tools/remove_old_programs.bash

@@ -1,7 +1,32 @@
 #!/bin/bash
 
 #$1 programs to be killed and checked
-var=`ps -A |grep -E -i $1`
+echo "removing old programs..."
+echo "args = $1"
+echo "script name = $0"
+filename=$(basename "$0")
+echo "filename = $filename"
+echo "programs to be killed...$1"
+
+echo "bash PID = $$" 
+pid="$$"
+echo "pid = $pid"
+
+echo "Killing programs now..."
+
+ps -aux |grep -E -i -w "$1"
+
+var=`ps -aux |grep -E -i -w "$1" |awk '{print $2}'| tr '\n' ' ' | sed  "s/$pid/ /"`
+echo "Killing processes...$var"
+#var=`ps -aux |grep -E -i '$1' |awk '{print $2}'| tr '\n' ' ' | sed  "s/$pid/ /"`
+#echo $var 
+if [ -n "$var" ] ; then  sudo  kill -9 $var ; fi
+
+#| sudo xargs kill -9 
+
+echo "checking for old programs..."
+var=`ps -aux |grep -E -i -w '$1' |grep -Ev 'grep' | grep -Ev '$filename'`
+
 echo $var
 if [ -n "$var" ]; then echo 'Match found'; else echo 'Match not found' ;fi 
 

cmake_targets/autotests/tools/run_gdb

@@ -0,0 +1,56 @@
+#!/bin/bash
+
+#arg0 -> Name of executable
+#args[1...N] -> arguments to be passed to executable
+if [ -z "$OPENAIR_DIR" ]
+then
+    echo "OPENAIR_DIR environment not set. Exiting.."
+    exit
+fi 
+
+source $OPENAIR_DIR/cmake_targets/tools/build_helper
+
+args=($*)
+exec_name=${args[0]}
+exe_args=(${args[@]:1})
+gdb_file=$OPENAIR_DIR/targets/bin/gdb_file
+gdb_log=$OPENAIR_DIR/targets/bin/gdb_log.bt
+
+echo "args = ${args[@]}"
+echo "exec_name = $exec_name"
+echo "exe_args = ${exe_args[@]}"
+echo "gdb log file = $gdb_log"
+
+$SUDO rm -fr $gdb_file $gdb_log
+$SUDO touch $gdb_file $gdb_log 
+$SUDO chmod 777  $gdb_file $gdb_log
+
+$SUDO echo "file $exec_name"                  >> $gdb_file
+$SUDO echo "set args ${exe_args[@]}"          >> $gdb_file
+$SUDO echo "run"                              >> $gdb_file
+$SUDO echo "set logging overwrite on"         >> $gdb_file
+$SUDO echo "set logging file $gdb_log"        >> $gdb_file
+$SUDO echo "set logging on"                   >> $gdb_file
+$SUDO echo "set pagination off"               >> $gdb_file
+$SUDO echo "handle SIG33 pass nostop noprint" >> $gdb_file
+$SUDO echo "echo backtrace:\n"                >> $gdb_file
+$SUDO echo "backtrace full"                   >> $gdb_file
+$SUDO echo "echo \n\nVariables:\n"            >> $gdb_file
+$SUDO echo "info variables"                   >> $gdb_file
+$SUDO echo "echo \n\nlocals:\n"               >> $gdb_file
+$SUDO echo "info locals"                      >> $gdb_file
+$SUDO echo "echo \n\nregisters:\n"            >> $gdb_file
+$SUDO echo "info registers"                   >> $gdb_file
+$SUDO echo "echo \n\ncurrent instructions:\n" >> $gdb_file 
+$SUDO echo "x/16i \$pc"                       >> $gdb_file
+$SUDO echo "echo \n\nthreads backtrace:\n"    >> $gdb_file
+$SUDO echo "thread apply all backtrace"       >> $gdb_file
+$SUDO echo "set logging off"                  >> $gdb_file
+$SUDO echo "quit"                             >> $gdb_file
+
+echo "Contents of gdb_file...start"
+$SUDO cat $gdb_file
+echo "Contents of gdb_file...finish"
+
+$SUDO gdb -n -x $gdb_file 2>&1
+

cmake_targets/build_oai

@@ -61,6 +61,7 @@ TEST_CASE_GROUP=""
 BUILD_DOXYGEN=0
 T_TRACER="False"
 DISABLE_HARDWARE_DEPENDENCY="False"
+CMAKE_BUILD_TYPE=""
 trap handle_ctrl_c INT
 
 function print_help() {
@@ -82,7 +83,7 @@ Options
 --install-optional-packages
    Install useful but not mandatory packages such as valgrind
 -g | --run-with-gdb
-   Add debugging symbols to compilation directives
+   Add debugging symbols to compilation directives. It also disables any compiler optimization.
 -h | --help
    Print this help
 --eNB
@@ -170,7 +171,8 @@ function main() {
             shift;;
        -g | --run-with-gdb)
             GDB=1
-            echo_info "Will Compile with gdb symbols"
+            CMAKE_BUILD_TYPE="Debug"
+            echo_info "Will Compile with gdb symbols and disable compiler optimization"
             shift;;
        --eNB)
             eNB=1
@@ -443,6 +445,7 @@ function main() {
     if [ "$NOS1" = "1" ] ; then
 	cat  $DIR/$lte_build_dir/CMakeLists.template >>  $cmake_file
     fi
+    echo "set ( CMAKE_BUILD_TYPE $CMAKE_BUILD_TYPE )" >> $cmake_file
     echo "set ( CFLAGS_PROCESSOR_USER \"$CFLAGS_PROCESSOR_USER\" )" >>  $cmake_file
     echo "set ( XFORMS $XFORMS )"                  >>  $cmake_file
     echo "set ( RRC_ASN1_VERSION \"${REL}\")"      >>  $cmake_file
@@ -568,6 +571,8 @@ function main() {
     cp $OPENAIR_DIR/cmake_targets/tools/init_exmimo2 $dbin
   fi
 
+  # oaisim compilation
+  ###############
   if [ "$oaisim" = "1" ] ; then
     dconf=$OPENAIR_DIR/targets/bin
       if [ "$NOS1" =  "1" ] ; then
@@ -581,6 +586,7 @@ function main() {
     echo_info "Compiling $oaisim_exec ($oaisim_build_dir)"
     cmake_file=$DIR/$oaisim_build_dir/CMakeLists.txt
     cp $DIR/$oaisim_build_dir/CMakeLists.template $cmake_file
+    echo "set ( CMAKE_BUILD_TYPE $CMAKE_BUILD_TYPE )" >> $cmake_file
     echo "set ( CFLAGS_PROCESSOR_USER \"$CFLAGS_PROCESSOR_USER\" )" >>  $cmake_file
     echo "set ( XFORMS $XFORMS )" >>  $cmake_file
     echo "set ( PRINT_STATS $PRINT_STATS )" >>  $cmake_file
@@ -649,9 +655,10 @@ function main() {
 
     cmake_file=$DIR/oaisim_mme_build_oai/CMakeLists.txt
     cp $DIR/oaisim_mme_build_oai/CMakeLists.template $cmake_file
-    echo "set(XFORMS $XFORMS )" >>  $cmake_file
+    echo "set ( CMAKE_BUILD_TYPE $CMAKE_BUILD_TYPE )" >> $cmake_file
-    echo "set(RRC_ASN1_VERSION \"${REL}\")" >>  $cmake_file
+    echo "set ( XFORMS $XFORMS )" >>  $cmake_file
-    echo "set(ENABLE_VCD_FIFO $VCD_TIMING )" >>  $cmake_file
+    echo "set ( RRC_ASN1_VERSION \"${REL}\")" >>  $cmake_file
+    echo "set ( ENABLE_VCD_FIFO $VCD_TIMING )" >>  $cmake_file
     echo "set ( T_TRACER $T_TRACER )"        >>  $cmake_file
     echo 'include(${CMAKE_CURRENT_SOURCE_DIR}/../CMakeLists.txt)' >> $cmake_file
     #[ "$CLEAN" = "1" ] && rm -rf $DIR/oaisim_mme_build_oai/build
@@ -676,13 +683,14 @@ function main() {
      mkdir -p $DIR/$rrh_build_dir/build
      cmake_file=$DIR/$rrh_build_dir/CMakeLists.txt
      echo "cmake_minimum_required(VERSION 2.8)"   >   $cmake_file
-     echo "set(ENABLE_VCD_FIFO $VCD_TIMING )"     >>  $cmake_file
+     echo "set ( CMAKE_BUILD_TYPE $CMAKE_BUILD_TYPE )" >> $cmake_file
-     echo "set(ENABLE_ITTI False )"     		 >>  $cmake_file
+     echo "set ( ENABLE_VCD_FIFO $VCD_TIMING )"     >>  $cmake_file
-     echo "set(RF_BOARD \"${HW}\")"               >>  $cmake_file
+     echo "set ( ENABLE_ITTI False )"     		 >>  $cmake_file
-     echo "set(TRANSP_PRO \"${TP}\")"             >>  $cmake_file
+     echo "set ( RF_BOARD \"${HW}\")"               >>  $cmake_file
-     echo 'set(PACKAGE_NAME "\"rrh_gw\"")'        >>  $cmake_file
+     echo "set ( TRANSP_PRO \"${TP}\")"             >>  $cmake_file
-     echo "set (DEADLINE_SCHEDULER \"${DEADLINE_SCHEDULER_FLAG_USER}\" )"    >>$cmake_file
+     echo 'set ( PACKAGE_NAME "\"rrh_gw\"")'        >>  $cmake_file
-     echo "set (CPU_AFFINITY \"${CPU_AFFINITY_FLAG_USER}\" )"    >>$cmake_file
+     echo "set ( DEADLINE_SCHEDULER \"${DEADLINE_SCHEDULER_FLAG_USER}\" )"    >>$cmake_file
+     echo "set ( CPU_AFFINITY \"${CPU_AFFINITY_FLAG_USER}\" )"    >>$cmake_file
      echo "set ( T_TRACER $T_TRACER )"            >>  $cmake_file
      echo 'include(${CMAKE_CURRENT_SOURCE_DIR}/../CMakeLists.txt)' >> $cmake_file    
      cd $DIR/$rrh_build_dir/build

cmake_targets/tools/build_helper

@@ -318,7 +318,6 @@ check_install_oai_software() {
 	libxml2 \
 	libxml2-dev  \
 	libxslt1-dev \
-	linux-headers-`uname -r` \
 	mscgen  \
 	octave \
 	octave-signal \
@@ -333,7 +332,8 @@ check_install_oai_software() {
 	wget
 
     $SUDO update-alternatives --set liblapack.so /usr/lib/atlas-base/atlas/liblapack.so
-        $SUDO apt-get install libgnutls-dev nettle-dev nettle-bin
+    $SUDO apt-get install libgnutls-dev nettle-dev nettle-bin
+    
     install_asn1c_from_source
 }
 
@@ -341,13 +341,9 @@ install_asn1c_from_source(){
     asn1_install_log=$OPENAIR_DIR/cmake_targets/log/asn1c_install_log.txt
     echo_info "\nInstalling ASN1. The log file for ASN1 installation is here: $asn1_install_log "
     (
-    $SUDO rm -rf /tmp/asn1c-r1516
+    $SUDO rm -rf /tmp/asn1c
-    svn co https://github.com/vlm/asn1c/trunk  /tmp/asn1c-r1516 -r 1516
+    git clone https://gitlab.eurecom.fr/oai/asn1c.git /tmp/asn1c
-    cd /tmp/asn1c-r1516 
+    cd /tmp/asn1c
-    patch -p0 < $OPENAIR_DIR/openair3/S1AP/MESSAGES/ASN1/asn1cpatch.p0 
-    patch -p0 < $OPENAIR_DIR/openair3/S1AP/MESSAGES/ASN1/asn1cpatch_2.p0 
-    patch -p0 < $OPENAIR_DIR/openair2/RRC/LITE/MESSAGES/asn1c/asn1cpatch.p0 
-    patch -p0 < $OPENAIR_DIR/openair3/S1AP/MESSAGES/ASN1/asn1cpatch_3.p0 
     ./configure
     make -j`nproc`
     $SUDO make install

cmake_targets/tools/run_enb_ue_virt_s1

@@ -252,7 +252,7 @@ function main()
   # Check table 200 lte in /etc/iproute2/rt_tables
   fgrep lte /etc/iproute2/rt_tables  > /dev/null
   if [ $? -ne 0 ]; then
-    bash -c echo "200 lte " >> /etc/iproute2/rt_tables
+    echo "200 lte " >> /etc/iproute2/rt_tables
   fi
   ip rule add fwmark 1 table lte 
   ifconfig oip1 up

common/utils/T/.gitignore

@@ -9,4 +9,5 @@ tracer/record
 tracer/replay
 tracer/textlog
 tracer/vcd
+tracer/macpdu2wireshark
 tracee/tracee

common/utils/T/tracer/Makefile

@@ -5,7 +5,7 @@ CFLAGS=-Wall -g -pthread -DT_TRACER -I.
 
 LIBS=-lX11 -lm -lpng -lXft
 
-all: record replay extract_config textlog enb vcd
+all: record replay extract_config textlog enb vcd macpdu2wireshark
 
 record: utils.o record.o database.o config.o
 	$(CC) $(CFLAGS) -o record $^ $(LIBS)
@@ -31,6 +31,10 @@ vcd: utils.o vcd.o database.o event.o handler.o config.o \
          filter/filter.a
 	$(CC) $(CFLAGS) -o vcd $^ $(LIBS)
 
+macpdu2wireshark: macpdu2wireshark.o database.o utils.o handler.o event.o \
+                  config.o
+	$(CC) $(CFLAGS) -o $@ $^ $(LIBS)
+
 .PHONY: all gui/gui.a view/view.a logger/logger.a filter/filter.a
 
 gui/gui.a:
@@ -50,7 +54,7 @@ filter/filter.a:
 
 clean:
 	rm -f *.o core tracer_remote textlog enb vcd record replay
-	rm -f extract_config
+	rm -f extract_config macpdu2wireshark
 	cd gui && make clean
 	cd view && make clean
 	cd logger && make clean

common/utils/T/tracer/macpdu2wireshark.c

@@ -0,0 +1,260 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include "database.h"
+#include "event.h"
+#include "handler.h"
+#include "config.h"
+#include "utils.h"
+#include "packet-mac-lte.h"
+
+#define DEFAULT_IP   "127.0.0.1"
+#define DEFAULT_PORT 9999
+
+typedef struct {
+  int socket;
+  struct sockaddr_in to;
+  OBUF buf;
+  /* ul */
+  int ul_rnti;
+  int ul_frame;
+  int ul_subframe;
+  int ul_data;
+  /* dl */
+  int dl_rnti;
+  int dl_frame;
+  int dl_subframe;
+  int dl_data;
+} ev_data;
+
+void ul(void *_d, event e)
+{
+  ev_data *d = _d;
+  ssize_t ret;
+  int fsf;
+  int i;
+
+  d->buf.osize = 0;
+
+  PUTS(&d->buf, MAC_LTE_START_STRING);
+  PUTC(&d->buf, FDD_RADIO);
+  PUTC(&d->buf, DIRECTION_UPLINK);
+  PUTC(&d->buf, C_RNTI);
+
+  PUTC(&d->buf, MAC_LTE_RNTI_TAG);
+  PUTC(&d->buf, (e.e[d->ul_rnti].i>>8) & 255);
+  PUTC(&d->buf, e.e[d->ul_rnti].i & 255);
+
+  /* for newer version of wireshark? */
+  fsf = (e.e[d->ul_frame].i << 4) + e.e[d->ul_subframe].i;
+  /* for older version? */
+  fsf = e.e[d->ul_subframe].i;
+  PUTC(&d->buf, MAC_LTE_FRAME_SUBFRAME_TAG);
+  PUTC(&d->buf, (fsf>>8) & 255);
+  PUTC(&d->buf, fsf & 255);
+
+  PUTC(&d->buf, MAC_LTE_PAYLOAD_TAG);
+  for (i = 0; i < e.e[d->ul_data].bsize; i++)
+    PUTC(&d->buf, ((char*)e.e[d->ul_data].b)[i]);
+
+  ret = sendto(d->socket, d->buf.obuf, d->buf.osize, 0,
+      (struct sockaddr *)&d->to, sizeof(struct sockaddr_in));
+  if (ret != d->buf.osize) abort();
+}
+
+void dl(void *_d, event e)
+{
+  ev_data *d = _d;
+  ssize_t ret;
+  int fsf;
+  int i;
+
+  d->buf.osize = 0;
+
+  PUTS(&d->buf, MAC_LTE_START_STRING);
+  PUTC(&d->buf, FDD_RADIO);
+  PUTC(&d->buf, DIRECTION_DOWNLINK);
+  PUTC(&d->buf, C_RNTI);
+
+  PUTC(&d->buf, MAC_LTE_RNTI_TAG);
+  PUTC(&d->buf, (e.e[d->dl_rnti].i>>8) & 255);
+  PUTC(&d->buf, e.e[d->dl_rnti].i & 255);
+
+  /* for newer version of wireshark? */
+  fsf = (e.e[d->dl_frame].i << 4) + e.e[d->dl_subframe].i;
+  /* for older version? */
+  fsf = e.e[d->dl_subframe].i;
+  PUTC(&d->buf, MAC_LTE_FRAME_SUBFRAME_TAG);
+  PUTC(&d->buf, (fsf>>8) & 255);
+  PUTC(&d->buf, fsf & 255);
+
+  PUTC(&d->buf, MAC_LTE_PAYLOAD_TAG);
+  for (i = 0; i < e.e[d->dl_data].bsize; i++)
+    PUTC(&d->buf, ((char*)e.e[d->dl_data].b)[i]);
+
+  ret = sendto(d->socket, d->buf.obuf, d->buf.osize, 0,
+      (struct sockaddr *)&d->to, sizeof(struct sockaddr_in));
+  if (ret != d->buf.osize) abort();
+}
+
+void setup_data(ev_data *d, void *database, int ul_id, int dl_id)
+{
+  database_event_format f;
+  int i;
+
+  d->ul_rnti     = -1;
+  d->ul_frame    = -1;
+  d->ul_subframe = -1;
+  d->ul_data     = -1;
+
+  d->dl_rnti     = -1;
+  d->dl_frame    = -1;
+  d->dl_subframe = -1;
+  d->dl_data     = -1;
+
+#define G(var_name, var_type, var) \
+  if (!strcmp(f.name[i], var_name)) { \
+    if (strcmp(f.type[i], var_type)) goto error; \
+    var = i; \
+    continue; \
+  }
+
+  /* ul: rnti, frame, subframe, data */
+  f = get_format(database, ul_id);
+  for (i = 0; i < f.count; i++) {
+    G("rnti",     "int",    d->ul_rnti);
+    G("frame",    "int",    d->ul_frame);
+    G("subframe", "int",    d->ul_subframe);
+    G("data",     "buffer", d->ul_data);
+  }
+  if (d->ul_rnti == -1 || d->ul_frame == -1 || d->ul_subframe == -1 ||
+      d->ul_data == -1) goto error;
+
+  /* dl: rnti, frame, subframe, data */
+  f = get_format(database, dl_id);
+  for (i = 0; i < f.count; i++) {
+    G("rnti",     "int",    d->dl_rnti);
+    G("frame",    "int",    d->dl_frame);
+    G("subframe", "int",    d->dl_subframe);
+    G("data",     "buffer", d->dl_data);
+  }
+  if (d->dl_rnti == -1 || d->dl_frame == -1 || d->dl_subframe == -1 ||
+      d->dl_data == -1) goto error;
+
+#undef G
+
+  return;
+
+error:
+  printf("bad T_messages.txt\n");
+  abort();
+}
+
+void *receiver(void *_d)
+{
+  ev_data *d = _d;
+  int s;
+  char buf[100000];
+
+  s = socket(AF_INET, SOCK_DGRAM, 0);
+  if (s == -1) { perror("socket"); abort(); }
+
+  if (bind(s, (struct sockaddr *)&d->to, sizeof(struct sockaddr_in)) == -1)
+    { perror("bind"); abort(); }
+
+  while (1) {
+    if (recv(s, buf, 100000, 0) <= 0) abort();
+  }
+
+  return 0;
+}
+
+void usage(void)
+{
+  printf(
+"options:\n"
+"    -d <database file>        this option is mandatory\n"
+"    -in <dump file>           read events from this dump file\n"
+"    -ip <IP address>          send packets to this IP address (default %s)\n"
+"    -p <port>                 send packets to this port (default %d)\n",
+  DEFAULT_IP,
+  DEFAULT_PORT
+  );
+  exit(1);
+}
+
+int main(int n, char **v)
+{
+  char *database_filename = NULL;
+  char *input_filename = NULL;
+  void *database;
+  event_handler *h;
+  int in;
+  int i;
+  int ul_id, dl_id;
+  ev_data d;
+  char *ip = DEFAULT_IP;
+  int port = DEFAULT_PORT;
+
+  memset(&d, 0, sizeof(ev_data));
+
+  for (i = 1; i < n; i++) {
+    if (!strcmp(v[i], "-h") || !strcmp(v[i], "--help")) usage();
+    if (!strcmp(v[i], "-d"))
+      { if (i > n-2) usage(); database_filename = v[++i]; continue; }
+    if (!strcmp(v[i], "-in"))
+      { if (i > n-2) usage(); input_filename = v[++i]; continue; }
+    if (!strcmp(v[i], "-ip")) { if (i > n-2) usage(); ip = v[++i]; continue; }
+    if (!strcmp(v[i], "-p")) {if(i>n-2)usage(); port=atoi(v[++i]); continue; }
+    usage();
+  }
+
+  if (database_filename == NULL) {
+    printf("ERROR: provide a database file (-d)\n");
+    exit(1);
+  }
+
+  if (input_filename == NULL) {
+    printf("ERROR: provide an input file (-i)\n");
+    exit(1);
+  }
+
+  in = open(input_filename, O_RDONLY);
+  if (in == -1) { perror(input_filename); return 1; }
+
+  database = parse_database(database_filename);
+  load_config_file(database_filename);
+
+  h = new_handler(database);
+
+  ul_id = event_id_from_name(database, "ENB_MAC_UE_UL_PDU_WITH_DATA");
+  dl_id = event_id_from_name(database, "ENB_MAC_UE_DL_PDU_WITH_DATA");
+  setup_data(&d, database, ul_id, dl_id);
+
+  register_handler_function(h, ul_id, ul, &d);
+  register_handler_function(h, dl_id, dl, &d);
+
+  d.socket = socket(AF_INET, SOCK_DGRAM, 0);
+  if (d.socket == -1) { perror("socket"); exit(1); }
+
+  d.to.sin_family = AF_INET;
+  d.to.sin_port = htons(port);
+  d.to.sin_addr.s_addr = inet_addr(ip);
+
+  new_thread(receiver, &d);
+
+  /* read messages */
+  while (1) {
+    char v[T_BUFFER_MAX];
+    event e;
+    e = get_event(in, v, database);
+    if (e.type == -1) break;
+    if (!(e.type == ul_id || e.type == dl_id)) continue;
+    handle_event(h, e);
+  }
+
+  return 0;
+}

common/utils/T/tracer/packet-mac-lte.h

@@ -0,0 +1,404 @@
+/* packet-mac-lte.h
+ *
+ * Martin Mathieson
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * This header file may also be distributed under
+ * the terms of the BSD Licence as follows:
+ *
+ * Copyright (C) 2009 Martin Mathieson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE
+ */
+
+//#include "ws_symbol_export.h"
+
+/* radioType */
+#define FDD_RADIO 1
+#define TDD_RADIO 2
+
+/* Direction */
+#define DIRECTION_UPLINK   0
+#define DIRECTION_DOWNLINK 1
+
+/* rntiType */
+#define NO_RNTI     0
+#define P_RNTI      1
+#define RA_RNTI     2
+#define C_RNTI      3
+#define SI_RNTI     4
+#define SPS_RNTI    5
+#define M_RNTI      6
+#define SL_BCH_RNTI 7
+#define SL_RNTI     8
+#define SC_RNTI     9
+#define G_RNTI      10
+
+#if 0
+typedef enum mac_lte_oob_event {
+    ltemac_send_preamble,
+    ltemac_send_sr,
+    ltemac_sr_failure
+} mac_lte_oob_event;
+
+typedef enum mac_lte_dl_retx {
+    dl_retx_no,
+    dl_retx_yes,
+    dl_retx_unknown
+} mac_lte_dl_retx;
+
+typedef enum mac_lte_crc_status {
+    crc_fail = 0,
+    crc_success = 1,
+    crc_high_code_rate = 2,
+    crc_pdsch_lost = 3,
+    crc_duplicate_nonzero_rv = 4,
+    crc_false_dci = 5
+} mac_lte_crc_status;
+
+typedef enum mac_lte_carrier_id {
+    carrier_id_primary,
+    carrier_id_secondary_1,
+    carrier_id_secondary_2,
+    carrier_id_secondary_3,
+    carrier_id_secondary_4
+} mac_lte_carrier_id;
+
+typedef enum mac_lte_ce_mode {
+    no_ce_mode = 0,
+    ce_mode_a = 1,
+    ce_mode_b = 2
+} mac_lte_ce_mode;
+
+typedef enum mac_lte_nb_mode {
+    no_nb_mode = 0,
+    nb_mode = 1
+} mac_lte_nb_mode;
+
+/* Context info attached to each LTE MAC frame */
+typedef struct mac_lte_info
+{
+    /* Needed for decode */
+    guint8          radioType;
+    guint8          direction;
+    guint8          rntiType;
+
+    /* Extra info to display */
+    guint16         rnti;
+    guint16         ueid;
+
+    /* Timing info */
+    guint16         sysframeNumber;
+    guint16         subframeNumber;
+
+    /* Optional field. More interesting for TDD (FDD is always -4 subframeNumber) */
+    gboolean        subframeNumberOfGrantPresent;
+    guint16         subframeNumberOfGrant;
+
+    /* Flag set only if doing PHY-level data test - i.e. there may not be a
+       well-formed MAC PDU so just show as raw data */
+    gboolean        isPredefinedData;
+
+    /* Length of DL PDU or UL grant size in bytes */
+    guint16         length;
+
+    /* 0=newTx, 1=first-retx, etc */
+    guint8          reTxCount;
+    guint8          isPHICHNACK; /* FALSE=PDCCH retx grant, TRUE=PHICH NACK */
+
+    /* UL only.  Indicates if the R10 extendedBSR-Sizes parameter is set */
+    gboolean        isExtendedBSRSizes;
+
+    /* UL only.  Indicates if the R10 simultaneousPUCCH-PUSCH parameter is set for PCell */
+    gboolean        isSimultPUCCHPUSCHPCell;
+
+    /* UL only.  Indicates if the R10 extendedBSR-Sizes parameter is set for PSCell */
+    gboolean        isSimultPUCCHPUSCHPSCell;
+
+    /* Status of CRC check. For UE it is DL only. For eNodeB it is UL
+       only. For an analyzer, it is present for both DL and UL. */
+    gboolean        crcStatusValid;
+    mac_lte_crc_status crcStatus;
+
+    /* Carrier ID */
+    mac_lte_carrier_id   carrierId;
+
+    /* DL only.  Is this known to be a retransmission? */
+    mac_lte_dl_retx dl_retx;
+
+    /* DL only. CE mode to be used for RAR decoding */
+    mac_lte_ce_mode ceMode;
+
+    /* DL and UL. NB-IoT mode of the UE */
+    mac_lte_nb_mode nbMode;
+
+    /* More Physical layer info (see direction above for which side of union to use) */
+    union {
+        struct mac_lte_ul_phy_info
+        {
+            guint8 present;  /* Remaining UL fields are present and should be displayed */
+            guint8 modulation_type;
+            guint8 tbs_index;
+            guint8 resource_block_length;
+            guint8 resource_block_start;
+            guint8 harq_id;
+            gboolean ndi;
+        } ul_info;
+        struct mac_lte_dl_phy_info
+        {
+            guint8 present; /* Remaining DL fields are present and should be displayed */
+            guint8 dci_format;
+            guint8 resource_allocation_type;
+            guint8 aggregation_level;
+            guint8 mcs_index;
+            guint8 redundancy_version_index;
+            guint8 resource_block_length;
+            guint8 harq_id;
+            gboolean ndi;
+            guint8   transport_block;  /* 0..1 */
+        } dl_info;
+    } detailed_phy_info;
+
+    /* Relating to out-of-band events */
+    /* N.B. dissector will only look to these fields if length is 0... */
+    mac_lte_oob_event  oob_event;
+    guint8             rapid;
+    guint8             rach_attempt_number;
+    #define MAX_SRs 20
+    guint16            number_of_srs;
+    guint16            oob_ueid[MAX_SRs];
+    guint16            oob_rnti[MAX_SRs];
+} mac_lte_info;
+
+
+typedef struct mac_lte_tap_info {
+    /* Info from context */
+    guint16  rnti;
+    guint16  ueid;
+    guint8   rntiType;
+    guint8   isPredefinedData;
+    gboolean crcStatusValid;
+    mac_lte_crc_status   crcStatus;
+    guint8   direction;
+
+    guint8   isPHYRetx;
+    guint16  ueInTTI;
+
+    nstime_t mac_lte_time;
+
+    /* Number of bytes (which part is used depends upon context settings) */
+    guint32  single_number_of_bytes;
+    guint32  bytes_for_lcid[11];
+    guint32  sdus_for_lcid[11];
+    guint8   number_of_rars;
+    guint8   number_of_paging_ids;
+
+    /* Number of padding bytes includes padding subheaders and trailing padding */
+    guint16  padding_bytes;
+    guint16  raw_length;
+} mac_lte_tap_info;
+
+
+/* Accessor function to check if a frame was considered to be ReTx */
+int is_mac_lte_frame_retx(packet_info *pinfo, guint8 direction);
+
+#endif
+
+/*****************************************************************/
+/* UDP framing format                                            */
+/* -----------------------                                       */
+/* Several people have asked about dissecting MAC by framing     */
+/* PDUs over IP.  A suggested format over UDP has been created   */
+/* and implemented by this dissector, using the definitions      */
+/* below. A link to an example program showing you how to encode */
+/* these headers and send LTE MAC PDUs on a UDP socket is        */
+/* provided at https://wiki.wireshark.org/MAC-LTE                 */
+/*                                                               */
+/* A heuristic dissecter (enabled by a preference) will          */
+/* recognise a signature at the beginning of these frames.       */
+/*****************************************************************/
+
+
+/* Signature.  Rather than try to define a port for this, or make the
+   port number a preference, frames will start with this string (with no
+   terminating NULL */
+#define MAC_LTE_START_STRING "mac-lte"
+
+/* Fixed fields.  This is followed by the following 3 mandatory fields:
+   - radioType (1 byte)
+   - direction (1 byte)
+   - rntiType (1 byte)
+   (where the allowed values are defined above */
+
+/* Optional fields. Attaching this info to frames will allow you
+   to show you display/filter/plot/add-custom-columns on these fields, so should
+   be added if available.
+   The format is to have the tag, followed by the value (there is no length field,
+   it's implicit from the tag) */
+
+#define MAC_LTE_RNTI_TAG            0x02
+/* 2 bytes, network order */
+
+#define MAC_LTE_UEID_TAG            0x03
+/* 2 bytes, network order */
+
+#define MAC_LTE_FRAME_SUBFRAME_TAG  0x04
+/* 2 bytes, network order, SFN is stored in 12 MSB and SF in 4 LSB */
+
+#define MAC_LTE_PREDEFINED_DATA_TAG 0x05
+/* 1 byte */
+
+#define MAC_LTE_RETX_TAG            0x06
+/* 1 byte */
+
+#define MAC_LTE_CRC_STATUS_TAG      0x07
+/* 1 byte */
+
+#define MAC_LTE_EXT_BSR_SIZES_TAG   0x08
+/* 0 byte */
+
+#define MAC_LTE_SEND_PREAMBLE_TAG   0x09
+/* 2 bytes, RAPID value (1 byte) followed by RACH attempt number (1 byte) */
+
+#define MAC_LTE_CARRIER_ID_TAG      0x0A
+/* 1 byte */
+
+#define MAC_LTE_PHY_TAG             0x0B
+/* variable length, length (1 byte) then depending on direction
+   in UL: modulation type (1 byte), TBS index (1 byte), RB length (1 byte),
+          RB start (1 byte), HARQ id (1 byte), NDI (1 byte)
+   in DL: DCI format (1 byte), resource allocation type (1 byte), aggregation level (1 byte),
+          MCS index (1 byte), redundancy version (1 byte), resource block length (1 byte),
+          HARQ id (1 byte), NDI (1 byte), TB (1 byte), DL reTx (1 byte) */
+
+#define MAC_LTE_SIMULT_PUCCH_PUSCH_PCELL  0x0C
+/* 0 byte */
+
+#define MAC_LTE_SIMULT_PUCCH_PUSCH_PSCELL 0x0D
+/* 0 byte */
+
+#define MAC_LTE_CE_MODE             0x0E
+/* 1 byte containing mac_lte_ce_mode enum value */
+
+#define MAC_LTE_NB_MODE             0x0F
+/* 1 byte containing mac_lte_nb_mode enum value */
+
+/* MAC PDU. Following this tag comes the actual MAC PDU (there is no length, the PDU
+   continues until the end of the frame) */
+#define MAC_LTE_PAYLOAD_TAG 0x01
+
+
+#if 0
+
+/* Type to store parameters for configuring LCID->RLC channel settings for DRB */
+/* Some are optional, and may not be seen (e.g. on reestablishment) */
+typedef struct drb_mapping_t
+{
+    guint16    ueid;                /* Mandatory */
+    guint8     drbid;               /* Mandatory */
+    gboolean   lcid_present;
+    guint8     lcid;                /* Part of LogicalChannelConfig - optional */
+    gboolean   rlcMode_present;
+    guint8     rlcMode;             /* Part of RLC config - optional */
+    gboolean   rlc_ul_ext_li_field; /* Part of RLC config - optional */
+    gboolean   rlc_dl_ext_li_field; /* Part of RLC config - optional */
+    gboolean   rlc_ul_ext_am_sn;    /* Part of RLC config - optional */
+    gboolean   rlc_dl_ext_am_sn;    /* Part of RLC config - optional */
+    gboolean   um_sn_length_present;
+    guint8     um_sn_length;        /* Part of RLC config - optional */
+    gboolean   ul_priority_present;
+    guint8     ul_priority;         /* Part of LogicalChannelConfig - optional */
+    gboolean   pdcp_sn_size_present;
+    guint8     pdcp_sn_size;        /* Part of pdcp-Config - optional */
+} drb_mapping_t;
+
+
+/* Set details of an LCID -> drb channel mapping.  To be called from
+   configuration protocol (e.g. RRC) */
+void set_mac_lte_channel_mapping(drb_mapping_t *drb_mapping);
+
+
+/* Dedicated DRX config. Used to verify that a sensible config is given.
+   Also, beginning to configure MAC with this config and (optionally) show
+   DRX config and state (cycles/timers) attached to each UL/DL PDU! */
+typedef struct drx_config_t {
+    gboolean    configured;
+    guint32     frameNum;
+    guint32     previousFrameNum;
+
+    guint32     onDurationTimer;
+    guint32     inactivityTimer;
+    guint32     retransmissionTimer;
+    guint32     longCycle;
+    guint32     cycleOffset;
+    /* Optional Short cycle */
+    gboolean    shortCycleConfigured;
+    guint32     shortCycle;
+    guint32     shortCycleTimer;
+} drx_config_t;
+
+/* Functions to set/release up dedicated DRX config */
+void set_mac_lte_drx_config(guint16 ueid, drx_config_t *drx_config, packet_info *pinfo);
+void set_mac_lte_drx_config_release(guint16 ueid,  packet_info *pinfo);
+
+/* RRC can tell this dissector which RAPIDs are Group A, Group A&B */
+void set_mac_lte_rapid_ranges(guint groupA, guint all_RA);
+
+/* RRC can indicate whether extended BSR sizes are used */
+void set_mac_lte_extended_bsr_sizes(guint16 ueid, gboolean use_ext_bsr_sizes, packet_info *pinfo);
+
+/* RRC can indicate whether simultaneous PUCCH/PUSCH is used */
+typedef enum {
+    SIMULT_PUCCH_PUSCH_PCELL = 0,
+    SIMULT_PUCCH_PUSCH_PSCELL
+} simult_pucch_pusch_cell_type;
+void set_mac_lte_simult_pucch_pusch(guint16 ueid, simult_pucch_pusch_cell_type cell_type, gboolean use_simult_pucch_pusch, packet_info *pinfo);
+
+/* Functions to be called from outside this module (e.g. in a plugin, where mac_lte_info
+   isn't available) to get/set per-packet data */
+WS_DLL_PUBLIC
+mac_lte_info *get_mac_lte_proto_data(packet_info *pinfo);
+WS_DLL_PUBLIC
+void set_mac_lte_proto_data(packet_info *pinfo, mac_lte_info *p_mac_lte_info);
+
+/* Function to attempt to populate p_mac_lte_info using framing definition above */
+gboolean dissect_mac_lte_context_fields(struct mac_lte_info  *p_mac_lte_info, tvbuff_t *tvb,
+                                        gint *p_offset);
+
+#endif

common/utils/itti/assertions.h

@@ -34,7 +34,7 @@
 #include <platform_types.h>
 #endif
 
-#if defined(ENB_MODE)
+#if defined(ENB_MODE2)
 # define display_backtrace()
 #else
 # include "backtrace.h"
@@ -59,7 +59,7 @@ do {                                                        \
                 "In %s() %s:%d\n" fORMAT,                   \
                 __FUNCTION__, __FILE__, __LINE__, ##aRGS);  \
         aCTION;                                             \
-    }                                                       \
+    }						\
 } while(0)
 
 #define AssertFatal(cOND, fORMAT, aRGS...)          _Assert_(cOND, _Assert_Exit_, fORMAT, ##aRGS)

common/utils/itti/backtrace.c

@@ -44,7 +44,8 @@ void display_backtrace(void)
   size_t size;
   char **strings;
   size_t i;
-
+  char* test=getenv("NO_BACKTRACE");
+  if (test!=0) *((int*)0)=0;
   size = backtrace(array, 10);
   strings = backtrace_symbols(array, size);
 

openair1/PHY/LTE_ESTIMATION/lte_adjust_sync.c

@@ -30,6 +30,8 @@
 #include "PHY/defs.h"
 #include "PHY/extern.h"
 
+#include "UTIL/LOG/vcd_signal_dumper.h"
+
 #define DEBUG_PHY
 
 // Adjust location synchronization point to account for drift
@@ -48,6 +50,8 @@ void lte_adjust_synch(LTE_DL_FRAME_PARMS *frame_parms,
   int diff;
   short Re,Im,ncoef;
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH, VCD_FUNCTION_IN);
+
   ncoef = 32767 - coef;
 
 #ifdef DEBUG_PHY
@@ -98,6 +102,7 @@ void lte_adjust_synch(LTE_DL_FRAME_PARMS *frame_parms,
         ue->proc.proc_rxtx[0].frame_rx,ue->rx_offset,max_pos,max_pos_fil,temp);
 #endif //DEBUG_PHY
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH, VCD_FUNCTION_OUT);
 
 }
 

openair1/PHY/LTE_TRANSPORT/dci.c

@@ -2664,8 +2664,10 @@ void dci_decoding_procedure0(LTE_UE_PDCCH **pdcch_vars,
                              uint8_t mi,
                              uint16_t si_rnti,
                              uint16_t ra_rnti,
+                             uint16_t p_rnti,
                              uint8_t L,
                              uint8_t format_si,
+                             uint8_t format_p,
                              uint8_t format_ra,
                              uint8_t format_c,
                              uint8_t sizeof_bits,
@@ -2797,6 +2799,7 @@ void dci_decoding_procedure0(LTE_UE_PDCCH **pdcch_vars,
 #endif
 
       if (((L>1) && ((crc == si_rnti)||
+		     (crc == p_rnti)||
                      (crc == ra_rnti)))||
           (crc == pdcch_vars[eNB_id]->crnti))   {
         dci_alloc[*dci_cnt].dci_length = sizeof_bits;
@@ -2831,6 +2834,9 @@ void dci_decoding_procedure0(LTE_UE_PDCCH **pdcch_vars,
         if (crc==si_rnti) {
           dci_alloc[*dci_cnt].format     = format_si;
           *dci_cnt = *dci_cnt+1;
+        } else if (crc==p_rnti) {
+          dci_alloc[*dci_cnt].format     = format_p;
+          *dci_cnt = *dci_cnt+1;
         } else if (crc==ra_rnti) {
           dci_alloc[*dci_cnt].format     = format_ra;
           // store first nCCE of group for PUCCH transmission of ACK/NAK
@@ -3118,7 +3124,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
     if (ue->prach_resources[eNB_id])
       ra_rnti = ue->prach_resources[eNB_id]->ra_RNTI;
 
-    // First check common search spaces at aggregation 4 (SI_RNTI and RA_RNTI format 0/1A),
+    // First check common search spaces at aggregation 4 (SI_RNTI, P_RNTI and RA_RNTI format 0/1A),
     // and UE_SPEC format0 (PUSCH) too while we're at it
     dci_decoding_procedure0(pdcch_vars,1,subframe,
                             dci_alloc,
@@ -3127,9 +3133,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             2,
                             format1A,
                             format1A,
+                            format1A,
                             format0,
                             format1A_size_bits,
                             format1A_size_bytes,
@@ -3144,7 +3152,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
         ((format0_found==1)&&(format_c_found==1)))
       return(dci_cnt);
 
-    // Now check common search spaces at aggregation 4 (SI_RNTI and RA_RNTI and C-RNTI format 1C),
+    // Now check common search spaces at aggregation 4 (SI_RNTI,P_RNTI and RA_RNTI and C-RNTI format 1C),
     // and UE_SPEC format0 (PUSCH) too while we're at it
     dci_decoding_procedure0(pdcch_vars,1,subframe,
                             dci_alloc,
@@ -3153,10 +3161,12 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             2,
                             format1C,
                             format1C,
                             format1C,
+                            format1C,
                             format1C_size_bits,
                             format1C_size_bytes,
                             &dci_cnt,
@@ -3170,7 +3180,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
         ((format0_found==1)&&(format_c_found==1)))
       return(dci_cnt);
 
-    // Now check common search spaces at aggregation 8 (SI_RNTI and RA_RNTI format 1A),
+    // Now check common search spaces at aggregation 8 (SI_RNTI,P_RNTI and RA_RNTI format 1A),
     // and UE_SPEC format0 (PUSCH) too while we're at it
     //  printf("[DCI search] doing common search/format0 aggregation 3\n");
 #ifdef DEBUG_DCI_DECODING
@@ -3182,10 +3192,12 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             frame_parms,
                             mi,
                             SI_RNTI,
+			    P_RNTI,
                             ra_rnti,
                             3,
                             format1A,
                             format1A,
+                            format1A,
                             format0,
                             format1A_size_bits,
                             format1A_size_bytes,
@@ -3209,7 +3221,9 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
-                            3,
+			    P_RNTI,
+			    3,
+                            format1C,
                             format1C,
                             format1C,
                             format1C,
@@ -3241,7 +3255,9 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                           mi,
                           SI_RNTI,
                           ra_rnti,
-                          3,
+			  P_RNTI,
+			  3,
+                          format1A,
                           format1A,
                           format1A,
                           format0,
@@ -3268,7 +3284,9 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                           mi,
                           SI_RNTI,
                           ra_rnti,
-                          2,
+			  P_RNTI,
+			  2,
+                          format1A,
                           format1A,
                           format1A,
                           format0,
@@ -3299,9 +3317,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                           mi,
                           SI_RNTI,
                           ra_rnti,
+			  P_RNTI,
                           1,
                           format1A,
                           format1A,
+                          format1A,
                           format0,
                           format0_size_bits,
                           format0_size_bytes,
@@ -3326,9 +3346,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                           mi,
                           SI_RNTI,
                           ra_rnti,
+			  P_RNTI,
                           0,
                           format1A,
                           format1A,
+                          format1A,
                           format0,
                           format0_size_bits,
                           format0_size_bytes,
@@ -3357,9 +3379,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             0,
                             format1A,
                             format1A,
+                            format1A,
                             format1,
                             format1_size_bits,
                             format1_size_bytes,
@@ -3386,9 +3410,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             1,
                             format1A,
                             format1A,
+                            format1A,
                             format1,
                             format1_size_bits,
                             format1_size_bytes,
@@ -3416,7 +3442,9 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
-                            2,
+			    P_RNTI,
+			    2,
+                            format1A,
                             format1A,
                             format1A,
                             format1,
@@ -3446,9 +3474,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             3,
                             format1A,
                             format1A,
+                            format1A,
                             format1,
                             format1_size_bits,
                             format1_size_bytes,
@@ -3479,9 +3509,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             0,
                             format1A,
                             format1A,
+                            format1A,
                             format2A,
                             format2A_size_bits,
                             format2A_size_bytes,
@@ -3508,9 +3540,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             1,
                             format1A,
                             format1A,
+                            format1A,
                             format2A,
                             format2A_size_bits,
                             format2A_size_bytes,
@@ -3537,9 +3571,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             2,
                             format1A,
                             format1A,
+                            format1A,
                             format2A,
                             format2A_size_bits,
                             format2A_size_bytes,
@@ -3567,9 +3603,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             3,
                             format1A,
                             format1A,
+                            format1A,
                             format2A,
                             format2A_size_bits,
                             format2A_size_bytes,
@@ -3591,9 +3629,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             0,
                             format1A,
                             format1A,
+                            format1A,
                             format2,
                             format2_size_bits,
                             format2_size_bytes,
@@ -3620,9 +3660,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             1,
                             format1A,
                             format1A,
+                            format1A,
                             format2,
                             format2_size_bits,
                             format2_size_bytes,
@@ -3649,9 +3691,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             2,
                             format1A,
                             format1A,
+                            format1A,
                             format2,
                             format2_size_bits,
                             format2_size_bytes,
@@ -3679,9 +3723,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             3,
                             format1A,
                             format1A,
+                            format1A,
                             format2,
                             format2_size_bits,
                             format2_size_bytes,
@@ -3706,9 +3752,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             0,
                             format1A,
                             format1A,
+                            format1A,
                             format1E_2A_M10PRB,
                             sizeof_DCI1E_5MHz_2A_M10PRB_TDD_t,
                             sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t),
@@ -3736,9 +3784,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             1,
                             format1A,
                             format1A,
+                            format1A,
                             format1E_2A_M10PRB,
                             sizeof_DCI1E_5MHz_2A_M10PRB_TDD_t,
                             sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t),
@@ -3765,9 +3815,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             2,
                             format1A,
                             format1A,
+                            format1A,
                             format1E_2A_M10PRB,
                             sizeof_DCI1E_5MHz_2A_M10PRB_TDD_t,
                             sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t),
@@ -3796,9 +3848,11 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
                             mi,
                             SI_RNTI,
                             ra_rnti,
+			    P_RNTI,
                             3,
                             format1A,
                             format1A,
+                            format1A,
                             format1E_2A_M10PRB,
                             sizeof_DCI1E_5MHz_2A_M10PRB_TDD_t,
                             sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t),

openair1/PHY/LTE_TRANSPORT/defs.h

@@ -729,6 +729,7 @@ typedef enum {format0,
 typedef enum {
   SI_PDSCH=0,
   RA_PDSCH,
+  P_PDSCH,
   PDSCH,
   PDSCH1,
   PMCH

openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c

@@ -328,7 +328,7 @@ int allocate_REs_in_RB_no_pilots_64QAM_siso(LTE_DL_FRAME_PARMS *frame_parms,
 
     for (x0p=&x0[*jj],tti_offset=symbol_offset+re_offset,re=0; 
 	 re<12; 
-	 re++,x0p+=6,tti_offset++) {
+	 re+=4,x0p+=24,tti_offset+=4) {
       
       qam64_table_offset_re=FOUR[x0p[0]];
       qam64_table_offset_im=FOUR[x0p[1]];
@@ -338,6 +338,33 @@ int allocate_REs_in_RB_no_pilots_64QAM_siso(LTE_DL_FRAME_PARMS *frame_parms,
       qam64_table_offset_im+=x0p[5];
       ((int16_t *)&txdataF[0][tti_offset])[0]=qam_table_s0[qam64_table_offset_re];
       ((int16_t *)&txdataF[0][tti_offset])[1]=qam_table_s0[qam64_table_offset_im];
+
+      qam64_table_offset_re=FOUR[x0p[6]];
+      qam64_table_offset_im=FOUR[x0p[7]];
+      qam64_table_offset_re+=TWO[x0p[8]];
+      qam64_table_offset_im+=TWO[x0p[9]];
+      qam64_table_offset_re+=x0p[10];
+      qam64_table_offset_im+=x0p[11];
+      ((int16_t *)&txdataF[0][tti_offset])[2]=qam_table_s0[qam64_table_offset_re];
+      ((int16_t *)&txdataF[0][tti_offset])[3]=qam_table_s0[qam64_table_offset_im];
+
+      qam64_table_offset_re=FOUR[x0p[12]];
+      qam64_table_offset_im=FOUR[x0p[13]];
+      qam64_table_offset_re+=TWO[x0p[14]];
+      qam64_table_offset_im+=TWO[x0p[15]];
+      qam64_table_offset_re+=x0p[16];
+      qam64_table_offset_im+=x0p[17];
+      ((int16_t *)&txdataF[0][tti_offset])[4]=qam_table_s0[qam64_table_offset_re];
+      ((int16_t *)&txdataF[0][tti_offset])[5]=qam_table_s0[qam64_table_offset_im];
+
+      qam64_table_offset_re=FOUR[x0p[18]];
+      qam64_table_offset_im=FOUR[x0p[19]];
+      qam64_table_offset_re+=TWO[x0p[20]];
+      qam64_table_offset_im+=TWO[x0p[21]];
+      qam64_table_offset_re+=x0p[22];
+      qam64_table_offset_im+=x0p[23];
+      ((int16_t *)&txdataF[0][tti_offset])[6]=qam_table_s0[qam64_table_offset_re];
+      ((int16_t *)&txdataF[0][tti_offset])[7]=qam_table_s0[qam64_table_offset_im];
     }
   }
   else {

openair1/PHY/LTE_TRANSPORT/pch.c

@@ -0,0 +1,61 @@
+/*******************************************************************************
+    OpenAirInterface
+    Copyright(c) 1999 - 2014 Eurecom
+
+    OpenAirInterface is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+
+    OpenAirInterface is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenAirInterface.The full GNU General Public License is
+   included in this distribution in the file called "COPYING". If not,
+   see <http://www.gnu.org/licenses/>.
+
+  Contact Information
+  OpenAirInterface Admin: openair_admin@eurecom.fr
+  OpenAirInterface Tech : openair_tech@eurecom.fr
+  OpenAirInterface Dev  : openair4g-devel@lists.eurecom.fr
+
+  Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
+
+ *******************************************************************************/
+#include "PHY/defs.h"
+#include "PHY/extern.h"
+#include "assertions.h"
+
+const unsigned int Ttab[4] = {32,64,128,256};
+
+// This function implements the initialization of paging parameters for UE (See Section 7, 36.304)
+// It must be called after setting IMSImod1024 during UE startup and after receiving SIB2
+int init_ue_paging_info(PHY_VARS_UE *ue, long defaultPagingCycle, long nB) {
+
+   LTE_DL_FRAME_PARMS *fp = &ue->frame_parms;
+
+   unsigned int T         = Ttab[defaultPagingCycle];
+   unsigned int N         = (nB<=2) ? T : (T>>(nB-2));
+   unsigned int Ns        = (nB<2)  ? (1<<(2-nB)) : 1;
+   unsigned int UE_ID     = ue->IMSImod1024;
+   unsigned int i_s       = (UE_ID/N)%Ns;
+
+   
+   ue->PF = (T/N) * (UE_ID % N);
+
+   // This implements Section 7.2 from 36.304
+   if (Ns==1)
+     ue->PO = (fp->frame_type==FDD) ? 9 : 0; 
+   else if (Ns==2)
+     ue->PO = (fp->frame_type==FDD) ? (4+(5*i_s)) : (5*i_s); 
+   else if (Ns==4)
+     ue->PO = (fp->frame_type==FDD) ? (4*(i_s&1)+(5*(i_s>>1))) : ((i_s&1)+(5*(i_s>>1))); 
+   else
+     AssertFatal(1==0,"init_ue_paging_info: Ns is %d\n",Ns);
+
+   return(0);
+}

openair1/PHY/LTE_TRANSPORT/proto.h

@@ -1339,6 +1339,14 @@ int32_t generate_drs_pusch(PHY_VARS_UE *phy_vars_ue,
   @param frame_parms Pointer to a LTE_DL_FRAME_PARMS structure (eNB or UE)*/
 void init_ul_hopping(LTE_DL_FRAME_PARMS *frame_parms);
 
+
+/*!
+  \brief This function implements the initialization of paging parameters for UE (See Section 7, 36.304).It must be called after setting IMSImod1024 during UE startup and after receiving SIB2
+  @param ue Pointer to UE context
+  @param defaultPagingCycle T from 36.304 (0=32,1=64,2=128,3=256)
+  @param nB nB from 36.304 (0=4T,1=2T,2=T,3=T/2,4=T/4,5=T/8,6=T/16,7=T/32*/
+int init_ue_paging_info(PHY_VARS_UE *ue, long defaultPagingCycle, long nB);
+
 int32_t compareints (const void * a, const void * b);
 
 

openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c

@@ -127,7 +127,7 @@ LTE_eNB_ULSCH_t *new_eNB_ulsch(uint8_t max_turbo_iterations,uint8_t N_RB_UL, uin
     ulsch->Mlimit = 4;
 
     for (i=0; i<8; i++) {
-      //      msg("new_ue_ulsch: Harq process %d\n",i);
+      //      printf("new_ue_ulsch: Harq process %d\n",i);
       ulsch->harq_processes[i] = (LTE_UL_eNB_HARQ_t *)malloc16(sizeof(LTE_UL_eNB_HARQ_t));
 
       if (ulsch->harq_processes[i]) {
@@ -202,11 +202,11 @@ uint8_t extract_cqi_crc(uint8_t *cqi,uint8_t CQI_LENGTH)
   uint8_t crc;
 
   crc = cqi[CQI_LENGTH>>3];
-  //  msg("crc1: %x, shift %d\n",crc,CQI_LENGTH&0x7);
+  //  printf("crc1: %x, shift %d\n",crc,CQI_LENGTH&0x7);
   crc = (crc<<(CQI_LENGTH&0x7));
   // clear crc bits
   //  ((char *)cqi)[CQI_LENGTH>>3] &= 0xff>>(8-(CQI_LENGTH&0x7));
-  //  msg("crc2: %x, cqi0 %x\n",crc,cqi[1+(CQI_LENGTH>>3)]);
+  //  printf("crc2: %x, cqi0 %x\n",crc,cqi[1+(CQI_LENGTH>>3)]);
   crc |= (cqi[1+(CQI_LENGTH>>3)])>>(8-(CQI_LENGTH&0x7));
   // clear crc bits
   //(((char *)cqi)[1+(CQI_LENGTH>>3)]) = 0;
@@ -258,7 +258,7 @@ unsigned int  ulsch_decoding(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,
   //  uint8_t ytag2[6*14*1200],*ytag2_ptr;
   int16_t cseq[6*14*1200];
   int off;
-  int status[20];
+
   int subframe = proc->subframe_rx;
   LTE_UL_eNB_HARQ_t *ulsch_harq;
 
@@ -312,7 +312,7 @@ unsigned int  ulsch_decoding(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,
 
 
 #ifdef DEBUG_ULSCH_DECODING
-  msg("ulsch_decoding (Nid_cell %d, rnti %x, x2 %x): round %d, RV %d, mcs %d, O_RI %d, O_ACK %d, G %d, subframe %d\n",
+  printf("ulsch_decoding (Nid_cell %d, rnti %x, x2 %x): round %d, RV %d, mcs %d, O_RI %d, O_ACK %d, G %d, subframe %d\n",
       frame_parms->Nid_cell,ulsch->rnti,x2,
       ulsch_harq->round,
       ulsch_harq->rvidx,
@@ -401,7 +401,7 @@ unsigned int  ulsch_decoding(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,
   //  Q_ACK = Qprime * Q_m;
   Qprime_ACK = Qprime;
 #ifdef DEBUG_ULSCH_DECODING
-  msg("ulsch_decoding.c: Qprime_ACK %d, Msc_initial %d, Nsymb_initial %d, sumKr %d\n",
+  printf("ulsch_decoding.c: Qprime_ACK %d, Msc_initial %d, Nsymb_initial %d, sumKr %d\n",
       Qprime_ACK,ulsch_harq->Msc_initial,ulsch_harq->Nsymb_initial,sumKr);
 #endif
 
@@ -430,7 +430,7 @@ unsigned int  ulsch_decoding(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,
 
   Q_CQI = Q_m * Qprime;
 #ifdef DEBUG_ULSCH_DECODING
-  msg("ulsch_decoding: G %d, Q_RI %d, Q_CQI %d (L %d, Or1 %d) O_ACK %d\n",G,Q_RI,Q_CQI,L,ulsch_harq->Or1,ulsch_harq->O_ACK);
+  printf("ulsch_decoding: G %d, Q_RI %d, Q_CQI %d (L %d, Or1 %d) O_ACK %d\n",G,Q_RI,Q_CQI,L,ulsch_harq->Or1,ulsch_harq->O_ACK);
 #endif
 
   G = G - Q_RI - Q_CQI;
@@ -531,7 +531,7 @@ unsigned int  ulsch_decoding(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,
     }
 
 #ifdef DEBUG_ULSCH_DECODING
-    msg("ulsch_decoding.c: ACK i %d, r %d, j %d, ColumnSet[j] %d\n",i,r,j,columnset[j]);
+    printf("ulsch_decoding.c: ACK i %d, r %d, j %d, ColumnSet[j] %d\n",i,r,j,columnset[j]);
 #endif
     j=(j+3)&3;
   }
@@ -964,15 +964,15 @@ unsigned int  ulsch_decoding(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,
     }
 
 #ifdef DEBUG_ULSCH_DECODING
-    msg("ulsch_decoding: Or1=%d\n",ulsch_harq->Or1);
+    printf("ulsch_decoding: Or1=%d\n",ulsch_harq->Or1);
 
     for (i=0; i<1+((8+ulsch_harq->Or1)/8); i++)
-      msg("ulsch_decoding: O[%d] %d\n",i,ulsch_harq->o[i]);
+      printf("ulsch_decoding: O[%d] %d\n",i,ulsch_harq->o[i]);
 
     if (ulsch_harq->cqi_crc_status == 1)
-      msg("RX CQI CRC OK (%x)\n",extract_cqi_crc(o_flip,ulsch_harq->Or1));
+      printf("RX CQI CRC OK (%x)\n",extract_cqi_crc(o_flip,ulsch_harq->Or1));
     else
-      msg("RX CQI CRC NOT OK (%x)\n",extract_cqi_crc(o_flip,ulsch_harq->Or1));
+      printf("RX CQI CRC NOT OK (%x)\n",extract_cqi_crc(o_flip,ulsch_harq->Or1));
 
 #endif
   }
@@ -985,6 +985,10 @@ unsigned int  ulsch_decoding(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,
 
   r_offset = 0;
 
+  offset = 0;
+
+  ret = 1;
+
   for (r=0; r<ulsch_harq->C; r++) {
 
     //    printf("before subblock deinterleaving c[%d] = %p\n",r,ulsch_harq->c[r]);
@@ -1010,7 +1014,7 @@ unsigned int  ulsch_decoding(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,
     }
 
 #ifdef DEBUG_ULSCH_DECODING
-    msg("f1 %d, f2 %d, F %d\n",f1f2mat_old[2*iind],f1f2mat_old[1+(2*iind)],(r==0) ? ulsch_harq->F : 0);
+    printf("f1 %d, f2 %d, F %d\n",f1f2mat_old[2*iind],f1f2mat_old[1+(2*iind)],(r==0) ? ulsch_harq->F : 0);
 #endif
 
     memset(&dummy_w[r][0],0,3*(6144+64)*sizeof(short));
@@ -1019,7 +1023,7 @@ unsigned int  ulsch_decoding(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,
                                           (r==0) ? ulsch_harq->F : 0);
 
 #ifdef DEBUG_ULSCH_DECODING
-    msg("Rate Matching Segment %d (coded bits (G) %d,unpunctured/repeated bits %d, Q_m %d, nb_rb %d, Nl %d)...\n",
+    printf("Rate Matching Segment %d (coded bits (G) %d,unpunctured/repeated bits %d, Q_m %d, nb_rb %d, Nl %d)...\n",
         r, G,
         Kr*3,
         Q_m,
@@ -1056,75 +1060,63 @@ unsigned int  ulsch_decoding(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,
                                    &ulsch_harq->d[r][96],
                                    ulsch_harq->w[r]);
     stop_meas(&eNB->ulsch_deinterleaving_stats);
-  }
+  
 
-    for (r=0; r<ulsch_harq->C; r++) {
+    if (ulsch_harq->C == 1)
+      crc_type = CRC24_A;
+    else
+      crc_type = CRC24_B;
+    
+    start_meas(&eNB->ulsch_turbo_decoding_stats);
+    
+    ret = tc(&ulsch_harq->d[r][96],
+	     ulsch_harq->c[r],
+	     Kr,
+	     f1f2mat_old[iind*2],
+	     f1f2mat_old[(iind*2)+1],
+	     ulsch->max_turbo_iterations,//MAX_TURBO_ITERATIONS,
+	     crc_type,
+	     (r==0) ? ulsch_harq->F : 0,
+	     &eNB->ulsch_tc_init_stats,
+	     &eNB->ulsch_tc_alpha_stats,
+	     &eNB->ulsch_tc_beta_stats,
+	     &eNB->ulsch_tc_gamma_stats,
+	     &eNB->ulsch_tc_ext_stats,
+	     &eNB->ulsch_tc_intl1_stats,
+	     &eNB->ulsch_tc_intl2_stats);
+    
+    stop_meas(&eNB->ulsch_turbo_decoding_stats);
+    
 
-      /*      printf("c[%d] : %p\n",r,
+    
-	     ulsch_harq->c[r]);
+  
-      */
-
-      if (ulsch_harq->C == 1)
-        crc_type = CRC24_A;
-      else
-        crc_type = CRC24_B;
-
-      start_meas(&eNB->ulsch_turbo_decoding_stats);
-
-      ret = tc(&ulsch_harq->d[r][96],
-               ulsch_harq->c[r],
-               Kr,
-               f1f2mat_old[iind*2],
-               f1f2mat_old[(iind*2)+1],
-               ulsch->max_turbo_iterations,//MAX_TURBO_ITERATIONS,
-               crc_type,
-               (r==0) ? ulsch_harq->F : 0,
-               &eNB->ulsch_tc_init_stats,
-               &eNB->ulsch_tc_alpha_stats,
-               &eNB->ulsch_tc_beta_stats,
-               &eNB->ulsch_tc_gamma_stats,
-               &eNB->ulsch_tc_ext_stats,
-               &eNB->ulsch_tc_intl1_stats,
-               &eNB->ulsch_tc_intl2_stats);
-
-      stop_meas(&eNB->ulsch_turbo_decoding_stats);
-
-      status[r] = ret;
-
-    }
 
   // Reassembly of Transport block here
-  offset = 0;
 
-  ret = 1;
+    if (ret != (1+ulsch->max_turbo_iterations)) {
-
-  for (r=0; r<ulsch_harq->C; r++) {
-    if (status[r] != (1+ulsch->max_turbo_iterations)) {
       if (r<ulsch_harq->Cminus)
-        Kr = ulsch_harq->Kminus;
+	Kr = ulsch_harq->Kminus;
       else
-        Kr = ulsch_harq->Kplus;
+	Kr = ulsch_harq->Kplus;
-
+      
       Kr_bytes = Kr>>3;
-
+      
       if (r==0) {
-        memcpy(ulsch_harq->b,
+	memcpy(ulsch_harq->b,
-               &ulsch_harq->c[0][(ulsch_harq->F>>3)],
+	       &ulsch_harq->c[0][(ulsch_harq->F>>3)],
-               Kr_bytes - (ulsch_harq->F>>3) - ((ulsch_harq->C>1)?3:0));
+	       Kr_bytes - (ulsch_harq->F>>3) - ((ulsch_harq->C>1)?3:0));
-        offset = Kr_bytes - (ulsch_harq->F>>3) - ((ulsch_harq->C>1)?3:0);
+	offset = Kr_bytes - (ulsch_harq->F>>3) - ((ulsch_harq->C>1)?3:0);
       } else {
-        memcpy(ulsch_harq->b+offset,
+	memcpy(ulsch_harq->b+offset,
-               ulsch_harq->c[r],
+	       ulsch_harq->c[r],
-               Kr_bytes - ((ulsch_harq->C>1)?3:0));
+	       Kr_bytes - ((ulsch_harq->C>1)?3:0));
-        offset += (Kr_bytes- ((ulsch_harq->C>1)?3:0));
+	offset += (Kr_bytes- ((ulsch_harq->C>1)?3:0));
       }
-
+      
-      if (ret != (1+ulsch->max_turbo_iterations))
-        ret = status[r];
     } else {
-      ret = 1+ulsch->max_turbo_iterations;
+      break;
     }
-
+    
   }
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_ENB_ULSCH_DECODING0+harq_pid,0);
@@ -1208,7 +1200,7 @@ int ulsch_abstraction_MIESM(double* sinr_dB,uint8_t TM, uint8_t mcs,uint16_t nrb
     sinr_db1 = sinr_dB[offset*2];
     sinr_db2 = sinr_dB[offset*2+1];
 
-    msg("sinr_db1=%f\n,sinr_db2=%f\n",sinr_db1,sinr_db2);
+    printf("sinr_db1=%f\n,sinr_db2=%f\n",sinr_db1,sinr_db2);
 
     //rounding up for the table lookup
     sinr_db1 *= 10;
@@ -1462,7 +1454,7 @@ int ulsch_abstraction_MIESM(double* sinr_dB,uint8_t TM, uint8_t mcs,uint16_t nrb
     sinr_eff = sinr_eff * beta2_dlsch_MI[TM][mcs];
   }
 
-  msg("SINR_Eff = %e\n",sinr_eff);
+  printf("SINR_Eff = %e\n",sinr_eff);
 
   sinr_eff *= 10;
   sinr_eff = floor(sinr_eff);
@@ -1470,7 +1462,7 @@ int ulsch_abstraction_MIESM(double* sinr_dB,uint8_t TM, uint8_t mcs,uint16_t nrb
   //   sinr_eff += 1;
   // }
   sinr_eff /= 10;
-  msg("sinr_eff after rounding = %f\n",sinr_eff);
+  printf("sinr_eff after rounding = %f\n",sinr_eff);
 
   for (index = 0; index < 16; index++) {
     if(index == 0) {
@@ -1488,10 +1480,10 @@ int ulsch_abstraction_MIESM(double* sinr_dB,uint8_t TM, uint8_t mcs,uint16_t nrb
 #ifdef USER_MODE // need to be adapted for the emulation in the kernel space 
 
   if (uniformrandom() < bler) {
-    msg("abstraction_decoding failed (mcs=%d, sinr_eff=%f, bler=%f)\n",mcs,sinr_eff,bler);
+    printf("abstraction_decoding failed (mcs=%d, sinr_eff=%f, bler=%f)\n",mcs,sinr_eff,bler);
     return(0);
   } else {
-    msg("abstraction_decoding successful (mcs=%d, sinr_eff=%f, bler=%f)\n",mcs,sinr_eff,bler);
+    printf("abstraction_decoding successful (mcs=%d, sinr_eff=%f, bler=%f)\n",mcs,sinr_eff,bler);
     return(1);
   }
 

openair1/PHY/TOOLS/defs.h

@@ -296,10 +296,10 @@ int32_t subcarrier_energy(int32_t *,uint32_t, int32_t* subcarrier_energy, uint16
 */
 int32_t signal_energy_nodc(int32_t *,uint32_t);
 
-/*!\fn double signal_energy_fp(double **, double **,uint32_t, uint32_t,uint32_t);
+/*!\fn double signal_energy_fp(double s_re[2][30720], double s_im[2][30720],uint32_t, uint32_t,uint32_t);
 \brief Computes the signal energy per subcarrier
 */
-double signal_energy_fp(double **s_re, double **s_im, uint32_t nb_antennas, uint32_t length,uint32_t offset);
+double signal_energy_fp(double s_re[2][30720], double s_im[2][30720], uint32_t nb_antennas, uint32_t length,uint32_t offset);
 
 /*!\fn double signal_energy_fp2(struct complex *, uint32_t);
 \brief Computes the signal energy per subcarrier

openair1/PHY/TOOLS/lte_dfts.c

@@ -58,10 +58,10 @@
 #define print_ints(s,x) printf("%s %d %d %d %d\n",s,(x)[0],(x)[1],(x)[2],(x)[3])
 
 
-static int16_t conjugatedft[32] __attribute__((aligned(32))) = {-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1};
+const static int16_t conjugatedft[32] __attribute__((aligned(32))) = {-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1};
 
 
-static int16_t reflip[32]  __attribute__((aligned(32))) = {1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1};
+const static int16_t reflip[32]  __attribute__((aligned(32))) = {1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1};
 
 #if defined(__x86_64__) || defined(__i386__)
 static inline void cmac(__m128i a,__m128i b, __m128i *re32, __m128i *im32) __attribute__((always_inline));
@@ -474,33 +474,33 @@ static inline int16x8_t packed_cmult2(int16x8_t a,int16x8_t b,  int16x8_t b2)
 
 #endif
 
-static int16_t W0s[16]__attribute__((aligned(32))) = {32767,0,32767,0,32767,0,32767,0,32767,0,32767,0,32767,0,32767,0};
+const static int16_t W0s[16]__attribute__((aligned(32))) = {32767,0,32767,0,32767,0,32767,0,32767,0,32767,0,32767,0,32767,0};
 
-static int16_t W13s[16]__attribute__((aligned(32))) = {-16384,-28378,-16384,-28378,-16384,-28378,-16384,-28378,-16384,-28378,-16384,-28378,-16384,-28378,-16384,-28378};
+const static int16_t W13s[16]__attribute__((aligned(32))) = {-16384,-28378,-16384,-28378,-16384,-28378,-16384,-28378,-16384,-28378,-16384,-28378,-16384,-28378,-16384,-28378};
-static int16_t W23s[16]__attribute__((aligned(32))) = {-16384,28378,-16384,28378,-16384,28378,-16384,28378,-16384,28378,-16384,28378,-16384,28378,-16384,28378};
+const static int16_t W23s[16]__attribute__((aligned(32))) = {-16384,28378,-16384,28378,-16384,28378,-16384,28378,-16384,28378,-16384,28378,-16384,28378,-16384,28378};
 
-static int16_t W15s[16]__attribute__((aligned(32))) = {10126,-31163,10126,-31163,10126,-31163,10126,-31163,10126,-31163,10126,-31163,10126,-31163,10126,-31163};
+const static int16_t W15s[16]__attribute__((aligned(32))) = {10126,-31163,10126,-31163,10126,-31163,10126,-31163,10126,-31163,10126,-31163,10126,-31163,10126,-31163};
-static int16_t W25s[16]__attribute__((aligned(32))) = {-26509,-19260,-26509,-19260,-26509,-19260,-26509,-19260,-26509,-19260,-26509,-19260,-26509,-19260,-26509,-19260};
+const static int16_t W25s[16]__attribute__((aligned(32))) = {-26509,-19260,-26509,-19260,-26509,-19260,-26509,-19260,-26509,-19260,-26509,-19260,-26509,-19260,-26509,-19260};
-static int16_t W35s[16]__attribute__((aligned(32))) = {-26510,19260,-26510,19260,-26510,19260,-26510,19260,-26510,19260,-26510,19260,-26510,19260,-26510,19260};
+const static int16_t W35s[16]__attribute__((aligned(32))) = {-26510,19260,-26510,19260,-26510,19260,-26510,19260,-26510,19260,-26510,19260,-26510,19260,-26510,19260};
-static int16_t W45s[16]__attribute__((aligned(32))) = {10126,31163,10126,31163,10126,31163,10126,31163,10126,31163,10126,31163,10126,31163,10126,31163};
+const static int16_t W45s[16]__attribute__((aligned(32))) = {10126,31163,10126,31163,10126,31163,10126,31163,10126,31163,10126,31163,10126,31163,10126,31163};
 
 #if defined(__x86_64__) || defined(__i386__)
-__m128i *W0 = (__m128i *)W0s;
+const __m128i *W0 = (__m128i *)W0s;
-__m128i *W13 = (__m128i *)W13s;
+const __m128i *W13 = (__m128i *)W13s;
-__m128i *W23 = (__m128i *)W23s;
+const __m128i *W23 = (__m128i *)W23s;
-__m128i *W15 = (__m128i *)W15s;
+const __m128i *W15 = (__m128i *)W15s;
-__m128i *W25 = (__m128i *)W25s;
+const __m128i *W25 = (__m128i *)W25s;
-__m128i *W35 = (__m128i *)W35s;
+const __m128i *W35 = (__m128i *)W35s;
-__m128i *W45 = (__m128i *)W45s;
+const __m128i *W45 = (__m128i *)W45s;
 
 #ifdef __AVX2__
-__m256i *W0_256 =  (__m256i *)W0s;
+const __m256i *W0_256 =  (__m256i *)W0s;
-__m256i *W13_256 = (__m256i *)W13s;
+const __m256i *W13_256 = (__m256i *)W13s;
-__m256i *W23_256 = (__m256i *)W23s;
+const __m256i *W23_256 = (__m256i *)W23s;
-__m256i *W15_256 = (__m256i *)W15s;
+const __m256i *W15_256 = (__m256i *)W15s;
-__m256i *W25_256 = (__m256i *)W25s;
+const __m256i *W25_256 = (__m256i *)W25s;
-__m256i *W35_256 = (__m256i *)W35s;
+const __m256i *W35_256 = (__m256i *)W35s;
-__m256i *W45_256 = (__m256i *)W45s;
+const __m256i *W45_256 = (__m256i *)W45s;
 #endif
 
 #elif defined(__arm__)
@@ -512,23 +512,23 @@ int16x8_t *W25 = (int16x8_t *)W25s;
 int16x8_t *W35 = (int16x8_t *)W35s;
 int16x8_t *W45 = (int16x8_t *)W45s;
 #endif
-static int16_t dft_norm_table[16] = {9459,  //12
+const static int16_t dft_norm_table[16] = {9459,  //12
-                                     6689,//24
+					   6689,//24
-                                     5461,//36
+					   5461,//36
-                                     4729,//482
+					   4729,//482
-                                     4230,//60
+					   4230,//60
-                                     23170,//72
+					   23170,//72
-                                     3344,//96
+					   3344,//96
-                                     3153,//108
+					   3153,//108
-                                     2991,//120
+					   2991,//120
-                                     18918,//sqrt(3),//144
+					   18918,//sqrt(3),//144
-                                     18918,//sqrt(3),//180
+					   18918,//sqrt(3),//180
-                                     16384,//2, //192
+					   16384,//2, //192
-                                     18918,//sqrt(3), // 216
+					   18918,//sqrt(3), // 216
-                                     16384,//2, //240
+					   16384,//2, //240
-                                     18918,//sqrt(3), // 288
+					   18918,//sqrt(3), // 288
-                                     14654
+					   14654
-                                    }; //sqrt(5) //300
+}; //sqrt(5) //300
 
 
 #if defined(__x86_64__) || defined(__i386__)
@@ -2036,42 +2036,42 @@ static inline void transpose4_ooff(int16x4_t *x,int16x4_t *y,int off)
 
 // 16-point optimized DFT kernel
 
-int16_t tw16[24] __attribute__((aligned(32))) = { 32767,0,30272,-12540,23169 ,-23170,12539 ,-30273,
+const static int16_t tw16[24] __attribute__((aligned(32))) = { 32767,0,30272,-12540,23169 ,-23170,12539 ,-30273,
                                                   32767,0,23169,-23170,0     ,-32767,-23170,-23170,
                                                   32767,0,12539,-30273,-23170,-23170,-30273,12539
                                                 };
 
-int16_t tw16a[24] __attribute__((aligned(32))) = {32767,0,30272,12540,23169 ,23170,12539 ,30273,
+const static int16_t tw16a[24] __attribute__((aligned(32))) = {32767,0,30272,12540,23169 ,23170,12539 ,30273,
                                                   32767,0,23169,23170,0     ,32767,-23170,23170,
                                                   32767,0,12539,30273,-23170,23170,-30273,-12539
                                                  };
 
-int16_t tw16b[24] __attribute__((aligned(32))) = { 0,32767,-12540,30272,-23170,23169 ,-30273,12539,
+const static int16_t tw16b[24] __attribute__((aligned(32))) = { 0,32767,-12540,30272,-23170,23169 ,-30273,12539,
                                                    0,32767,-23170,23169,-32767,0     ,-23170,-23170,
                                                    0,32767,-30273,12539,-23170,-23170,12539 ,-30273
                                                  };
 
-int16_t tw16c[24] __attribute__((aligned(32))) = { 0,32767,12540,30272,23170,23169 ,30273 ,12539,
+const static int16_t tw16c[24] __attribute__((aligned(32))) = { 0,32767,12540,30272,23170,23169 ,30273 ,12539,
                                                    0,32767,23170,23169,32767,0     ,23170 ,-23170,
                                                    0,32767,30273,12539,23170,-23170,-12539,-30273
                                                  };
 
-int16_t tw16rep[48] __attribute__((aligned(32))) = { 32767,0,30272,-12540,23169 ,-23170,12539 ,-30273,32767,0,30272,-12540,23169 ,-23170,12539 ,-30273,
+const static int16_t tw16rep[48] __attribute__((aligned(32))) = { 32767,0,30272,-12540,23169 ,-23170,12539 ,-30273,32767,0,30272,-12540,23169 ,-23170,12539 ,-30273,
 						     32767,0,23169,-23170,0     ,-32767,-23170,-23170,32767,0,23169,-23170,0     ,-32767,-23170,-23170,
 						     32767,0,12539,-30273,-23170,-23170,-30273,12539,32767,0,12539,-30273,-23170,-23170,-30273,12539
                                                    };
 
-int16_t tw16arep[48] __attribute__((aligned(32))) = {32767,0,30272,12540,23169 ,23170,12539 ,30273,32767,0,30272,12540,23169 ,23170,12539 ,30273,
+const static int16_t tw16arep[48] __attribute__((aligned(32))) = {32767,0,30272,12540,23169 ,23170,12539 ,30273,32767,0,30272,12540,23169 ,23170,12539 ,30273,
 						     32767,0,23169,23170,0     ,32767,-23170,23170,32767,0,23169,23170,0     ,32767,-23170,23170,
 						     32767,0,12539,30273,-23170,23170,-30273,-12539,32767,0,12539,30273,-23170,23170,-30273,-12539
                                                     }; 
 
-int16_t tw16brep[48] __attribute__((aligned(32))) = { 0,32767,-12540,30272,-23170,23169 ,-30273,12539,0,32767,-12540,30272,-23170,23169 ,-30273,12539,
+const static int16_t tw16brep[48] __attribute__((aligned(32))) = { 0,32767,-12540,30272,-23170,23169 ,-30273,12539,0,32767,-12540,30272,-23170,23169 ,-30273,12539,
                                                       0,32767,-23170,23169,-32767,0     ,-23170,-23170,0,32767,-23170,23169,-32767,0     ,-23170,-23170,
                                                       0,32767,-30273,12539,-23170,-23170,12539 ,-30273,0,32767,-30273,12539,-23170,-23170,12539 ,-30273
                                                     };
 
-int16_t tw16crep[48] __attribute__((aligned(32))) = { 0,32767,12540,30272,23170,23169 ,30273 ,12539,0,32767,12540,30272,23170,23169 ,30273 ,12539,
+const static int16_t tw16crep[48] __attribute__((aligned(32))) = { 0,32767,12540,30272,23170,23169 ,30273 ,12539,0,32767,12540,30272,23170,23169 ,30273 ,12539,
 						      0,32767,23170,23169,32767,0     ,23170 ,-23170,0,32767,23170,23169,32767,0     ,23170 ,-23170,
 						      0,32767,30273,12539,23170,-23170,-12539,-30273,0,32767,30273,12539,23170,-23170,-12539,-30273
                                                     };
@@ -2502,7 +2502,7 @@ static inline void idft16_simd256(int16_t *x,int16_t *y)
 
 // 64-point optimized DFT
 
-int16_t tw64[96] __attribute__((aligned(32))) = { 
+const static int16_t tw64[96] __attribute__((aligned(32))) = { 
 32767,0,32609,-3212,32137,-6393,31356,-9512,
 30272,-12540,28897,-15447,27244,-18205,25329,-20788,
 23169,-23170,20787,-25330,18204,-27245,15446,-28898,
@@ -2517,7 +2517,7 @@ int16_t tw64[96] __attribute__((aligned(32))) = {
 -30273,12539,-25330,20787,-18205,27244,-9512,31356
                                                 };
 
-int16_t tw64rep[192] __attribute__((aligned(32))) = { 
+const static int16_t tw64rep[192] __attribute__((aligned(32))) = { 
 32767,0,32609,-3212,32137,-6393,31356,-9512,32767,0,32609,-3212,32137,-6393,31356,-9512,
 30272,-12540,28897,-15447,27244,-18205,25329,-20788,30272,-12540,28897,-15447,27244,-18205,25329,-20788,
 23169,-23170,20787,-25330,18204,-27245,15446,-28898,23169,-23170,20787,-25330,18204,-27245,15446,-28898,
@@ -2532,7 +2532,7 @@ int16_t tw64rep[192] __attribute__((aligned(32))) = {
 -30273,12539,-25330,20787,-18205,27244,-9512,31356,-30273,12539,-25330,20787,-18205,27244,-9512,31356
                                                 };
 
-int16_t tw64a[96] __attribute__((aligned(32))) = { 
+const static int16_t tw64a[96] __attribute__((aligned(32))) = { 
 32767,0,32609,3212,32137,6393,31356,9512,
 30272,12540,28897,15447,27244,18205,25329,20788,
 23169,23170,20787,25330,18204,27245,15446,28898,
@@ -2546,7 +2546,7 @@ int16_t tw64a[96] __attribute__((aligned(32))) = {
 -23170,23170,-28898,15447,-32138,6393,-32610,-3211,
 -30273,-12539,-25330,-20787,-18205,-27244,-9512,-31356
                                                  };
-int16_t tw64arep[192] __attribute__((aligned(32))) = { 
+const static int16_t tw64arep[192] __attribute__((aligned(32))) = { 
 32767,0,32609,3212,32137,6393,31356,9512,32767,0,32609,3212,32137,6393,31356,9512,
 30272,12540,28897,15447,27244,18205,25329,20788,30272,12540,28897,15447,27244,18205,25329,20788,
 23169,23170,20787,25330,18204,27245,15446,28898,23169,23170,20787,25330,18204,27245,15446,28898,
@@ -2561,7 +2561,7 @@ int16_t tw64arep[192] __attribute__((aligned(32))) = {
 -30273,-12539,-25330,-20787,-18205,-27244,-9512,-31356,-30273,-12539,-25330,-20787,-18205,-27244,-9512,-31356
                                                  };
 
-int16_t tw64b[96] __attribute__((aligned(32))) = { 
+const static int16_t tw64b[96] __attribute__((aligned(32))) = { 
 0,32767,-3212,32609,-6393,32137,-9512,31356,
 -12540,30272,-15447,28897,-18205,27244,-20788,25329,
 -23170,23169,-25330,20787,-27245,18204,-28898,15446,
@@ -2576,7 +2576,7 @@ int16_t tw64b[96] __attribute__((aligned(32))) = {
 12539,-30273,20787,-25330,27244,-18205,31356,-9512
                                                  };
 
-int16_t tw64brep[192] __attribute__((aligned(32))) = { 
+const static int16_t tw64brep[192] __attribute__((aligned(32))) = { 
 0,32767,-3212,32609,-6393,32137,-9512,31356,0,32767,-3212,32609,-6393,32137,-9512,31356,
 -12540,30272,-15447,28897,-18205,27244,-20788,25329,-12540,30272,-15447,28897,-18205,27244,-20788,25329,
 -23170,23169,-25330,20787,-27245,18204,-28898,15446,-23170,23169,-25330,20787,-27245,18204,-28898,15446,
@@ -2591,7 +2591,7 @@ int16_t tw64brep[192] __attribute__((aligned(32))) = {
 12539,-30273,20787,-25330,27244,-18205,31356,-9512,12539,-30273,20787,-25330,27244,-18205,31356,-9512
                                                  };
 
-int16_t tw64c[96] __attribute__((aligned(32))) = { 
+const static int16_t tw64c[96] __attribute__((aligned(32))) = { 
 0,32767,3212,32609,6393,32137,9512,31356,
 12540,30272,15447,28897,18205,27244,20788,25329,
 23170,23169,25330,20787,27245,18204,28898,15446,
@@ -2606,7 +2606,7 @@ int16_t tw64c[96] __attribute__((aligned(32))) = {
 -12539,-30273,-20787,-25330,-27244,-18205,-31356,-9512
                                                  };
 
-int16_t tw64crep[192] __attribute__((aligned(32))) = { 
+const static int16_t tw64crep[192] __attribute__((aligned(32))) = { 
 0,32767,3212,32609,6393,32137,9512,31356,0,32767,3212,32609,6393,32137,9512,31356,
 12540,30272,15447,28897,18205,27244,20788,25329,12540,30272,15447,28897,18205,27244,20788,25329,
 23170,23169,25330,20787,27245,18204,28898,15446,23170,23169,25330,20787,27245,18204,28898,15446,

openair1/PHY/TOOLS/signal_energy.c

@@ -255,7 +255,7 @@ int32_t signal_energy_nodc(int32_t *input,uint32_t length)
 }
 
 #endif
-double signal_energy_fp(double **s_re,double **s_im,uint32_t nb_antennas,uint32_t length,uint32_t offset)
+double signal_energy_fp(double s_re[2][30720],double s_im[2][30720],uint32_t nb_antennas,uint32_t length,uint32_t offset)
 {
 
   int32_t aa,i;

openair1/PHY/defs.h

@@ -53,11 +53,6 @@
 # define msg mexPrintf
 #else
 # ifdef OPENAIR2
-#   if ENABLE_RAL
-#     include "collection/hashtable/hashtable.h"
-#     include "COMMON/ral_messages_types.h"
-#     include "UTIL/queue.h"
-#   endif
 #   include "log.h"
 #   define msg(aRGS...) LOG_D(PHY, ##aRGS)
 # else
@@ -132,10 +127,6 @@ static inline void* malloc16_clear( size_t size )
 #include "PHY/TOOLS/defs.h"
 #include "platform_types.h"
 
-#ifdef OPENAIR_LTE
-
-//#include "PHY/LTE_ESTIMATION/defs.h"
-
 #include "PHY/LTE_TRANSPORT/defs.h"
 #include <pthread.h>
 
@@ -178,16 +169,6 @@ typedef struct UE_SCAN_INFO_s {
   int32_t freq_offset_Hz[3][10];
 } UE_SCAN_INFO_t;
 
-#if ENABLE_RAL
-typedef struct ral_threshold_phy_s {
-  SLIST_ENTRY(ral_threshold_phy_s) ral_thresholds;
-  ral_threshold_t                  threshold;
-  ral_th_action_t                  th_action;
-  ral_link_param_t                 link_param;
-  long                             timer_id;
-} ral_threshold_phy_t;
-#endif
-
 /// Top-level PHY Data Structure for RN
 typedef struct {
   /// Module ID indicator for this instance
@@ -612,6 +593,8 @@ typedef struct {
   int is_synchronized;
   /// Data structure for UE process scheduling
   UE_proc_t proc;
+  /// Flag to indicate the UE shouldn't do timing correction at all
+  int no_timing_correction;
   /// \brief Total gain of the TX chain (16-bit baseband I/Q to antenna)
   uint32_t tx_total_gain_dB;
   /// \brief Total gain of the RX chain (antenna to baseband I/Q) This is a function of rx_gain_mode (and the corresponding gain) and the rx_gain of the card.
@@ -623,9 +606,9 @@ typedef struct {
   /// \brief Total gains with bypassed RF gain stage (ExpressMIMO2/Lime)
   uint32_t rx_gain_byp[4];
   /// \brief Current transmit power
-  int8_t tx_power_dBm;
+  int8_t tx_power_dBm[10];
   /// \brief Total number of REs in current transmission
-  int tx_total_RE;
+  int tx_total_RE[10];
   /// \brief Maximum transmit power
   int8_t tx_power_max_dBm;
   /// \brief Number of eNB seen by UE
@@ -645,17 +628,25 @@ typedef struct {
   LTE_UE_PDSCH_FLP *pdsch_vars_flp[NUMBER_OF_CONNECTED_eNB_MAX+1];
   LTE_UE_PDSCH     *pdsch_vars_SI[NUMBER_OF_CONNECTED_eNB_MAX+1];
   LTE_UE_PDSCH     *pdsch_vars_ra[NUMBER_OF_CONNECTED_eNB_MAX+1];
+  LTE_UE_PDSCH     *pdsch_vars_p[NUMBER_OF_CONNECTED_eNB_MAX+1];
   LTE_UE_PDSCH     *pdsch_vars_MCH[NUMBER_OF_CONNECTED_eNB_MAX];
   LTE_UE_PBCH      *pbch_vars[NUMBER_OF_CONNECTED_eNB_MAX];
   LTE_UE_PDCCH     *pdcch_vars[NUMBER_OF_CONNECTED_eNB_MAX];
   LTE_UE_PRACH     *prach_vars[NUMBER_OF_CONNECTED_eNB_MAX];
   LTE_UE_DLSCH_t   *dlsch[NUMBER_OF_CONNECTED_eNB_MAX][2];
   LTE_UE_ULSCH_t   *ulsch[NUMBER_OF_CONNECTED_eNB_MAX];
-  LTE_UE_DLSCH_t   *dlsch_SI[NUMBER_OF_CONNECTED_eNB_MAX],*dlsch_ra[NUMBER_OF_CONNECTED_eNB_MAX];
+  LTE_UE_DLSCH_t   *dlsch_SI[NUMBER_OF_CONNECTED_eNB_MAX];
+  LTE_UE_DLSCH_t   *dlsch_ra[NUMBER_OF_CONNECTED_eNB_MAX];
+  LTE_UE_DLSCH_t   *dlsch_p[NUMBER_OF_CONNECTED_eNB_MAX];
   LTE_UE_DLSCH_t   *dlsch_MCH[NUMBER_OF_CONNECTED_eNB_MAX];
   // This is for SIC in the UE, to store the reencoded data
   LTE_eNB_DLSCH_t  *dlsch_eNB[NUMBER_OF_CONNECTED_eNB_MAX];
 
+  //Paging parameters
+  uint32_t              IMSImod1024;
+  uint32_t              PF;
+  uint32_t              PO;
+
   // For abstraction-purposes only
   uint8_t               sr[10];
   uint8_t               pucch_sel[10];
@@ -710,6 +701,8 @@ typedef struct {
   int dlsch_SI_errors[NUMBER_OF_CONNECTED_eNB_MAX];
   int dlsch_ra_received[NUMBER_OF_CONNECTED_eNB_MAX];
   int dlsch_ra_errors[NUMBER_OF_CONNECTED_eNB_MAX];
+  int dlsch_p_received[NUMBER_OF_CONNECTED_eNB_MAX];
+  int dlsch_p_errors[NUMBER_OF_CONNECTED_eNB_MAX];
   int dlsch_mch_received_sf[MAX_MBSFN_AREA][NUMBER_OF_CONNECTED_eNB_MAX];
   int dlsch_mch_received[NUMBER_OF_CONNECTED_eNB_MAX];
   int dlsch_mcch_received[MAX_MBSFN_AREA][NUMBER_OF_CONNECTED_eNB_MAX];
@@ -833,11 +826,6 @@ typedef struct {
   /// RF and Interface devices per CC
   openair0_device rfdevice; 
 
-#if ENABLE_RAL
-  hash_table_t    *ral_thresholds_timed;
-  SLIST_HEAD(ral_thresholds_gen_poll_s, ral_threshold_phy_t) ral_thresholds_gen_polled[RAL_LINK_PARAM_GEN_MAX];
-  SLIST_HEAD(ral_thresholds_lte_poll_s, ral_threshold_phy_t) ral_thresholds_lte_polled[RAL_LINK_PARAM_LTE_MAX];
-#endif
 } PHY_VARS_UE;
 
 
@@ -849,6 +837,5 @@ typedef struct {
 #include "PHY/LTE_ESTIMATION/defs.h"
 
 #include "SIMULATION/ETH_TRANSPORT/defs.h"
-#endif //OPENAIR_LTE
 
 #endif //  __PHY_DEFS__H__

openair1/PHY/extern.h

@@ -111,7 +111,7 @@ extern double p_qam64[8];
 extern double beta1_dlsch[6][MCS_COUNT];
 extern double beta2_dlsch[6][MCS_COUNT];
 
-extern char eNB_functions[5][20];
+extern char eNB_functions[6][20];
 extern char eNB_timing[2][20];
 
 

openair1/PHY/impl_defs_lte.h

@@ -607,34 +607,34 @@ typedef struct {
   int32_t **txdataF[3];
   /// \brief Holds the received data in time domain.
   /// Should point to the same memory as PHY_vars->rx_vars[a].RX_DMA_BUFFER.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna [0..nb_antennas_rx[
   /// - third index: sample [0..]
   int32_t **rxdata[3];
   /// \brief Holds the last subframe of received data in time domain after removal of 7.5kHz frequency offset.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: secotr id [0..2] (hard coded)
   /// - second index: rx antenna [0..nb_antennas_rx[
   /// - third index: sample [0..samples_per_tti[
   int32_t **rxdata_7_5kHz[3];
   /// \brief Holds the received data in the frequency domain.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna [0..nb_antennas_rx[
   /// - third index: ? [0..2*ofdm_symbol_size*frame_parms->symbols_per_tti[
   int32_t **rxdataF[3];
   /// \brief Holds output of the sync correlator.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: sample [0..samples_per_tti*10[
   uint32_t *sync_corr[3];
 } LTE_eNB_COMMON;
 
 typedef struct {
   /// \brief Hold the channel estimates in frequency domain based on SRS.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index: ? [0..ofdm_symbol_size[
   int32_t **srs_ch_estimates[3];
   /// \brief Hold the channel estimates in time domain based on SRS.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index: ? [0..2*ofdm_symbol_size[
   int32_t **srs_ch_estimates_time[3];
@@ -645,54 +645,54 @@ typedef struct {
 
 typedef struct {
   /// \brief Holds the received data in the frequency domain for the allocated RBs in repeated format.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index: ? [0..2*ofdm_symbol_size[
   /// - third index (definition from phy_init_lte_eNB()): ? [0..24*N_RB_UL*frame_parms->symbols_per_tti[
   /// \warning inconsistent third index definition
   int32_t **rxdataF_ext[3];
   /// \brief Holds the received data in the frequency domain for the allocated RBs in normal format.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index (definition from phy_init_lte_eNB()): ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
   int32_t **rxdataF_ext2[3];
   /// \brief Hold the channel estimates in time domain based on DRS.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index: ? [0..4*ofdm_symbol_size[
   int32_t **drs_ch_estimates_time[3];
   /// \brief Hold the channel estimates in frequency domain based on DRS.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
   int32_t **drs_ch_estimates[3];
   /// \brief Hold the channel estimates for UE0 in case of Distributed Alamouti Scheme.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
   int32_t **drs_ch_estimates_0[3];
   /// \brief Hold the channel estimates for UE1 in case of Distributed Almouti Scheme.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
   int32_t **drs_ch_estimates_1[3];
   /// \brief Holds the compensated signal.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
   int32_t **rxdataF_comp[3];
   /// \brief Hold the compensated data (y)*(h0*) in case of Distributed Alamouti Scheme.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
   int32_t **rxdataF_comp_0[3];
   /// \brief Hold the compensated data (y*)*(h1) in case of Distributed Alamouti Scheme.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
   int32_t **rxdataF_comp_1[3];
   /// \brief ?.
-  /// - first index: eNB id [0..2] (hard coded)
+  /// - first index: sector id [0..2] (hard coded)
   /// - second index: rx antenna id [0..nb_antennas_rx[
   /// - third index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
   int32_t **ul_ch_mag[3];

openair1/PHY/vars.h

@@ -52,10 +52,15 @@ int16_t *primary_synch2_time;
 #include "PHY/CODING/vars.h"
 
 //PHY_VARS *PHY_vars;
+#ifndef OCP_FRAMEWORK
 PHY_VARS_UE ***PHY_vars_UE_g;
 PHY_VARS_eNB ***PHY_vars_eNB_g;
 PHY_VARS_RN **PHY_vars_RN_g;
 LTE_DL_FRAME_PARMS *lte_frame_parms_g;
+#else
+PHY_VARS_UE * PHY_vars_UE_g[MAX_UE][MAX_NUM_CCs]={NULL};
+PHY_VARS_eNB * PHY_vars_eNB_g[MAX_eNB][MAX_NUM_CCs]={NULL};
+#endif
 
 
 unsigned short rev[2048],rev_times4[8192],rev_half[1024];
@@ -139,8 +144,12 @@ double beta2_dlsch[6][MCS_COUNT] = { {2.52163, 0.83231, 0.77472, 1.36536, 1.1682
 
 */
 
+#ifdef OCP_FRAMEWORK
+#include <enums.h>
+#else
 char eNB_functions[6][20]={"eNodeB_3GPP","eNodeB_3GPP_BBU","NGFI_RCC_IF4p5","NGFI_RAI_IF4p5","NGFI_RRU_IF5","NGFI_RRU_IF4p5",};
 char eNB_timing[2][20]={"synch_to_ext_device","synch_to_other"};
+#endif
 
 
 

openair1/SCHED/phy_procedures_lte_ue.c

@@ -718,7 +718,7 @@ void ue_prach_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin
 							   frame_tx,
 							   eNB_id,
 							   subframe_tx);
-      //    LOG_I(PHY,"Got prach_resources for eNB %d address %d, RRCCommon %d\n",eNB_id,ue->prach_resources[eNB_id],UE_mac_inst[Mod_id].radioResourceConfigCommon);
+      LOG_D(PHY,"Got prach_resources for eNB %d address %d, RRCCommon %d\n",eNB_id,ue->prach_resources[eNB_id],UE_mac_inst[ue->Mod_id].radioResourceConfigCommon);
     }
   }
   
@@ -744,17 +744,17 @@ void ue_prach_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin
 	    ue->prach_resources[eNB_id]->ra_RNTI);
       
       if ((ue->mac_enabled==1) && (mode != calib_prach_tx)) {
-	ue->tx_power_dBm = ue->prach_resources[eNB_id]->ra_PREAMBLE_RECEIVED_TARGET_POWER+get_PL(ue->Mod_id,ue->CC_id,eNB_id);
+	ue->tx_power_dBm[subframe_tx] = ue->prach_resources[eNB_id]->ra_PREAMBLE_RECEIVED_TARGET_POWER+get_PL(ue->Mod_id,ue->CC_id,eNB_id);
       }
       else {
-	ue->tx_power_dBm = ue->tx_power_max_dBm;
+	ue->tx_power_dBm[subframe_tx] = ue->tx_power_max_dBm;
 	ue->prach_resources[eNB_id]->ra_PreambleIndex = 19;	      
       }
       
-      ue->tx_total_RE = 96;
+      ue->tx_total_RE[subframe_tx] = 96;
       
 #if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR)
-      ue->prach_vars[eNB_id]->amp = get_tx_amp(ue->tx_power_dBm,
+      ue->prach_vars[eNB_id]->amp = get_tx_amp(ue->tx_power_dBm[subframe_tx],
 					       ue->tx_power_max_dBm,
 					       ue->frame_parms.N_RB_UL,
 					       6);
@@ -766,7 +766,7 @@ void ue_prach_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin
 	      ue->Mod_id,
 	      proc->frame_rx,
 	      proc->subframe_tx,
-	      ue->tx_power_dBm,
+	      ue->tx_power_dBm[subframe_tx],
 	      ue->prach_vars[eNB_id]->amp);
       
       
@@ -778,7 +778,7 @@ void ue_prach_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin
       LOG_D(PHY,"[UE  %d][RAPROC] PRACH PL %d dB, power %d dBm, digital power %d dB (amp %d)\n",
 	    ue->Mod_id,
 	    get_PL(ue->Mod_id,ue->CC_id,eNB_id),
-	    ue->tx_power_dBm,
+	    ue->tx_power_dBm[subframe_tx],
 	    dB_fixed(prach_power),
 	    ue->prach_vars[eNB_id]->amp);
     } else {
@@ -1036,12 +1036,12 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB
     if (abstraction_flag == 0) {
       if (ue->mac_enabled==1) {
 	pusch_power_cntl(ue,proc,eNB_id,1, abstraction_flag);
-	ue->tx_power_dBm = ue->ulsch[eNB_id]->Po_PUSCH;
+	ue->tx_power_dBm[subframe_tx] = ue->ulsch[eNB_id]->Po_PUSCH;
       }
       else {
-	ue->tx_power_dBm = ue->tx_power_max_dBm;
+	ue->tx_power_dBm[subframe_tx] = ue->tx_power_max_dBm;
       }
-      ue->tx_total_RE = nb_rb*12;
+      ue->tx_total_RE[subframe_tx] = nb_rb*12;
       
 #if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR)
       tx_amp = get_tx_amp(ue->tx_power_dBm,
@@ -1052,7 +1052,7 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB
       tx_amp = AMP;
 #endif
       LOG_D(PHY,"[UE  %d][PUSCH %d] Frame %d subframe %d, generating PUSCH, Po_PUSCH: %d dBm (max %d dBm), amp %d\n",
-	    Mod_id,harq_pid,frame_tx,subframe_tx,ue->tx_power_dBm,ue->tx_power_max_dBm, tx_amp);
+	    Mod_id,harq_pid,frame_tx,subframe_tx,ue->tx_power_dBm[subframe_tx],ue->tx_power_max_dBm, tx_amp);
       start_meas(&ue->ulsch_modulation_stats);
       ulsch_modulation(ue->common_vars.txdataF,
 		       tx_amp,
@@ -1156,8 +1156,8 @@ void ue_pucch_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin
     else {
       Po_PUCCH = ue->tx_power_max_dBm;
     }
-    ue->tx_power_dBm = Po_PUCCH;
+    ue->tx_power_dBm[subframe_tx] = Po_PUCCH;
-    ue->tx_total_RE = 12;
+    ue->tx_total_RE[subframe_tx] = 12;
 	    
 #if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR)
     tx_amp = get_tx_amp(Po_PUCCH,
@@ -1220,8 +1220,8 @@ void ue_pucch_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin
     else {
       Po_PUCCH = ue->tx_power_max_dBm;
     }
-    ue->tx_power_dBm = Po_PUCCH;
+    ue->tx_power_dBm[subframe_tx] = Po_PUCCH;
-    ue->tx_total_RE = 12;
+    ue->tx_total_RE[subframe_tx] = 12;
 	    
 #if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR)
     tx_amp =  get_tx_amp(Po_PUCCH,
@@ -1286,7 +1286,7 @@ void phy_procedures_UE_TX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,ui
   //phy_procedures_emos_UE_TX(next_slot);
 #endif
 
-  ue->tx_power_dBm=-127;
+  ue->tx_power_dBm[subframe_tx]=-127;
       
   if (abstraction_flag==0) {
     for (aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
@@ -1391,6 +1391,7 @@ void phy_procedures_UE_TX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,ui
       (ue->frame_parms.prach_config_common.prach_Config_enabled==1)) {
 	
     // check if we have PRACH opportunity
+
     if (is_prach_subframe(&ue->frame_parms,frame_tx,subframe_tx)) {
 
       ue_prach_procedures(ue,proc,eNB_id,abstraction_flag,mode);
@@ -1484,17 +1485,17 @@ void ue_measurement_procedures(uint16_t l, PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,
 #endif
 
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GAIN_CONTROL, VCD_FUNCTION_OUT);
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH, VCD_FUNCTION_IN);
+
     eNB_id = 0;
     
-    if (abstraction_flag == 0)
+    if (abstraction_flag == 0) {
-      lte_adjust_synch(&ue->frame_parms,
+      if (ue->no_timing_correction==0)
-		       ue,
+	lte_adjust_synch(&ue->frame_parms,
-		       eNB_id,
+			 ue,
-		       0,
+			 eNB_id,
-		       16384);
+			 0,
-    
+			 16384);
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH, VCD_FUNCTION_OUT);
+    }      
 
   }
 
@@ -1626,8 +1627,10 @@ void restart_phy(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uint8_t eNB_id,uint8_t ab
   ue->dlsch_fer[eNB_id] = 0;
   ue->dlsch_SI_received[eNB_id] = 0;
   ue->dlsch_ra_received[eNB_id] = 0;
+  ue->dlsch_p_received[eNB_id] = 0;
   ue->dlsch_SI_errors[eNB_id] = 0;
   ue->dlsch_ra_errors[eNB_id] = 0;
+  ue->dlsch_p_errors[eNB_id] = 0;
 
   ue->dlsch_mch_received[eNB_id] = 0;
 
@@ -2026,6 +2029,35 @@ int ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint
       }
     }
 
+    else if ((dci_alloc_rx[i].rnti == P_RNTI) &&
+	     ((dci_alloc_rx[i].format == format1A) || (dci_alloc_rx[i].format == format1C))) {
+
+#ifdef DEBUG_PHY_PROC
+      LOG_D(PHY,"[UE  %d] subframe %d: Found rnti %x, format 1%s, dci_cnt %d\n",ue->Mod_id,subframe_rx,dci_alloc_rx[i].rnti,dci_alloc_rx[i].format==format1A?"A":"C",i);
+#endif
+
+
+      if (generate_ue_dlsch_params_from_dci(frame_rx,
+					    subframe_rx,
+					    (void *)&dci_alloc_rx[i].dci_pdu,
+					    SI_RNTI,
+					    dci_alloc_rx[i].format,
+					    &ue->dlsch_SI[eNB_id],
+					    &ue->frame_parms,
+					    ue->pdsch_config_dedicated,
+					    SI_RNTI,
+					    0,
+					    P_RNTI)==0) {
+
+	ue->dlsch_p_received[eNB_id]++;
+ 
+
+	LOG_D(PHY,"[UE  %d] Frame %d, subframe %d : Generate UE DLSCH P_RNTI format 1%s\n",ue->Mod_id,frame_rx,subframe_rx,dci_alloc_rx[i].format==format1A?"A":"C");
+	//dump_dci(&ue->frame_parms, &dci_alloc_rx[i]);
+
+      }
+    }
+
     else if ((ue->prach_resources[eNB_id]) &&
 	     (dci_alloc_rx[i].rnti == ue->prach_resources[eNB_id]->ra_RNTI) &&
 	     (dci_alloc_rx[i].format == format1A)) {
@@ -2439,6 +2471,9 @@ void ue_dlsch_procedures(PHY_VARS_UE *ue,
     case RA_PDSCH:
       pdsch_vars = ue->pdsch_vars_ra[eNB_id];
       break;
+    case P_PDSCH:
+      pdsch_vars = ue->pdsch_vars_p[eNB_id];
+      break;
     case PDSCH:
       pdsch_vars = ue->pdsch_vars[eNB_id];
       break;
@@ -2556,6 +2591,14 @@ void ue_dlsch_procedures(PHY_VARS_UE *ue,
 				  ue->dlsch_SI[eNB_id]->harq_processes[0]->b,
 				  ue->dlsch_SI[eNB_id]->harq_processes[0]->TBS>>3);
 	  break;
+	case P_PDSCH:
+	  mac_xface->ue_decode_p(ue->Mod_id,
+				 CC_id,
+				 frame_rx,
+				 eNB_id,
+				 ue->dlsch_SI[eNB_id]->harq_processes[0]->b,
+				 ue->dlsch_SI[eNB_id]->harq_processes[0]->TBS>>3);
+	  break;
 	case RA_PDSCH:
 	  process_rar(ue,proc,eNB_id,mode,abstraction_flag);
 	  break;
@@ -2629,6 +2672,8 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin
 
   if (ue->dlsch_SI[eNB_id])
     ue->dlsch_SI[eNB_id]->active = 0;
+  if (ue->dlsch_p[eNB_id])
+    ue->dlsch_p[eNB_id]->active = 0;
   if (ue->dlsch_ra[eNB_id])
     ue->dlsch_ra[eNB_id]->active = 0;
 
@@ -2725,6 +2770,20 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin
 			ue->frame_parms.symbols_per_tti>>1,
 			abstraction_flag);
   }
+
+  // do procedures for SI-RNTI
+  if ((ue->dlsch_p[eNB_id]) && (ue->dlsch_p[eNB_id]->active == 1)) {
+    ue_pdsch_procedures(ue,
+			proc,
+			eNB_id,
+			P_PDSCH,
+			ue->dlsch_p[eNB_id],
+			NULL,
+			ue->pdcch_vars[eNB_id]->num_pdcch_symbols,
+			ue->frame_parms.symbols_per_tti>>1,
+			abstraction_flag);
+  }
+
   // do procedures for RA-RNTI
   if ((ue->dlsch_ra[eNB_id]) && (ue->dlsch_ra[eNB_id]->active == 1)) {
     ue_pdsch_procedures(ue,
@@ -2820,6 +2879,30 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin
 			abstraction_flag);
     ue->dlsch_SI[eNB_id]->active = 0;
   }
+
+  // do procedures for P-RNTI
+  if ((ue->dlsch_p[eNB_id]) && (ue->dlsch_p[eNB_id]->active == 1)) {
+    ue_pdsch_procedures(ue,
+			proc,
+			eNB_id,
+			P_PDSCH,
+			ue->dlsch_p[eNB_id],
+			NULL,
+			1+(ue->frame_parms.symbols_per_tti>>1),
+			ue->frame_parms.symbols_per_tti-1,
+			abstraction_flag);
+
+    ue_dlsch_procedures(ue,
+			proc,
+			eNB_id,
+			P_PDSCH,
+			ue->dlsch_p[eNB_id],
+			NULL,
+			&ue->dlsch_p_errors[eNB_id],
+			mode,
+			abstraction_flag);
+    ue->dlsch_p[eNB_id]->active = 0;
+  }
   // do procedures for RA-RNTI
   if ((ue->dlsch_ra[eNB_id]) && (ue->dlsch_ra[eNB_id]->active == 1)) {
     ue_pdsch_procedures(ue,

openair1/SIMULATION/LTE_PHY/dlsim.c

@@ -129,7 +129,8 @@ void do_OFDM_mod_l(int32_t **txdataF, int32_t **txdata, uint16_t next_slot, LTE_
   
 }
 
-void DL_channel(PHY_VARS_eNB *eNB,PHY_VARS_UE *UE,int subframe,int awgn_flag,double SNR, int tx_lev,int hold_channel,int abstx, int num_rounds, int trials, int round, channel_desc_t *eNB2UE[4], double **s_re,double **s_im,double **r_re,double **r_im,FILE *csv_fd) {
+void DL_channel(PHY_VARS_eNB *eNB,PHY_VARS_UE *UE,int subframe,int awgn_flag,double SNR, int tx_lev,int hold_channel,int abstx, int num_rounds, int trials, int round, channel_desc_t *eNB2UE[4], 
+		double s_re[2][30720*2],double s_im[2][30720*2],double r_re[2][30720*2],double r_im[2][30720*2],FILE *csv_fd) {
 
   int i,u;
   int aa,aarx,aatx;
@@ -1266,7 +1267,7 @@ int main(int argc, char **argv)
   double snr_step=1,input_snr_step=1, snr_int=30;
 
   LTE_DL_FRAME_PARMS *frame_parms;
-  double **s_re,**s_im,**r_re,**r_im;
+  double s_re[2][30720*2],s_im[2][30720*2],r_re[2][30720*2],r_im[2][30720*2];
   double forgetting_factor=0.0; //in [0,1] 0 means a new channel every time, 1 means keep the same channel
 
 
@@ -1798,13 +1799,6 @@ int main(int argc, char **argv)
 
   frame_parms = &eNB->frame_parms;
 
-  s_re = malloc(2*sizeof(double*));
-  s_im = malloc(2*sizeof(double*));
-  r_re = malloc(2*sizeof(double*));
-  r_im = malloc(2*sizeof(double*));
-  //  r_re0 = malloc(2*sizeof(double*));
-  //  r_im0 = malloc(2*sizeof(double*));
-
   nsymb = (eNB->frame_parms.Ncp == 0) ? 14 : 12;
 
   printf("Channel Model= (%s,%d)\n",channel_model_input, channel_model);
@@ -1948,14 +1942,6 @@ int main(int argc, char **argv)
     }
   */
 
-  for (i=0; i<2; i++) {
-    s_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
-    s_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
-    r_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
-    r_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
-  }
-
-
   UE->pdcch_vars[0]->crnti = n_rnti;
 
   // Fill in UL_alloc
@@ -2329,165 +2315,7 @@ int main(int argc, char **argv)
 	    } // common_flag == 0
 	    
 
-	    /*	    
-            num_pdcch_symbols_2 = generate_dci_top(num_ue_spec_dci,
-                                                   num_common_dci,
-                                                   dci_alloc,
-                                                   0,
-                                                   AMP,
-                                                   &eNB->frame_parms,
-                                                   eNB->common_vars.txdataF[eNB_id],
-                                                   subframe);
-	    
-	    if (n_frames==1) printf("Generated DCI, num_pdcch_symbols %d\n",num_pdcch_symbols_2);
 
-            if (num_pdcch_symbols_2 > num_pdcch_symbols) {
-              printf("Error: given num_pdcch_symbols not big enough (%d > %d)\n",num_pdcch_symbols_2,num_pdcch_symbols);
-              exit(-1);
-            }
-
-            for (k=0; k<n_users; k++) {
-              for (int cw=0; cw<Kmimo; cw++) {
-                coded_bits_per_codeword = get_G(&eNB->frame_parms,
-                                                eNB->dlsch[k][cw]->harq_processes[0]->nb_rb,
-                                                eNB->dlsch[k][cw]->harq_processes[0]->rb_alloc,
-                                                get_Qm(eNB->dlsch[k][cw]->harq_processes[0]->mcs),
-                                                eNB->dlsch[k][cw]->harq_processes[0]->Nl,
-                                                num_pdcch_symbols,
-                                                0,subframe);
-
-                tbs = eNB->dlsch[k][cw]->harq_processes[0]->TBS;
-                rate = (double)tbs/(double)coded_bits_per_codeword;
-
-                if ((SNR==snr0) && (trials==0) && (round==0))
-                  printf("User %d, cw %d: Rate = %f (%f bits/dim) (G %d, TBS %d, mod %d, pdcch_sym %d, ndi %d)\n",
-                         k,cw,rate,rate*get_Qm(eNB->dlsch[k][0]->harq_processes[0]->mcs),
-                         coded_bits_per_codeword,
-                         tbs,
-                         get_Qm(eNB->dlsch[k][0]->harq_processes[0]->mcs),
-                         num_pdcch_symbols,
-                         eNB->dlsch[0][0]->harq_processes[0]->round);
-
-                // use the PMI from previous trial
-                if (DLSCH_alloc_pdu2_1E[0].tpmi == 5) {
-                  eNB->dlsch[0][0]->harq_processes[0]->pmi_alloc = quantize_subband_pmi(&UE->measurements,0,eNB->frame_parms.N_RB_DL);
-                  UE->dlsch[0][0]->harq_processes[0]->pmi_alloc = quantize_subband_pmi(&UE->measurements,0,UE->frame_parms.N_RB_DL);
-
-                  if (n_users>1)
-                    eNB->dlsch[1][0]->harq_processes[0]->pmi_alloc = (eNB->dlsch[0][0]->harq_processes[0]->pmi_alloc ^ 0x1555);
-
-                  
-                }
-
-		
-                start_meas(&eNB->dlsch_encoding_stats);
-
-                if (dlsch_encoding(((cw==0) ? input_buffer0[k] : input_buffer1[k]),
-                                   &eNB->frame_parms,
-                                   num_pdcch_symbols,
-                                   eNB->dlsch[k][cw],
-                                   0,subframe,
-                                   &eNB->dlsch_rate_matching_stats,
-                                   &eNB->dlsch_turbo_encoding_stats,
-                                   &eNB->dlsch_interleaving_stats
-                                  )<0)
-                  exit(-1);
-
-                stop_meas(&eNB->dlsch_encoding_stats);
-
-                eNB->dlsch[k][cw]->rnti = (common_flag==0) ? n_rnti+k : SI_RNTI;
-                start_meas(&eNB->dlsch_scrambling_stats);
-                dlsch_scrambling(&eNB->frame_parms,
-                                 0,
-                                 eNB->dlsch[k][cw],
-                                 coded_bits_per_codeword,
-                                 0,
-                                 subframe<<1);
-                stop_meas(&eNB->dlsch_scrambling_stats);
-
-                if (n_frames==1) {
-                  for (s=0; s<eNB->dlsch[k][cw]->harq_processes[0]->C; s++) {
-                    if (s<eNB->dlsch[k][cw]->harq_processes[0]->Cminus)
-                      Kr = eNB->dlsch[k][cw]->harq_processes[0]->Kminus;
-                    else
-                      Kr = eNB->dlsch[k][cw]->harq_processes[0]->Kplus;
-
-                    Kr_bytes = Kr>>3;
-
-                    for (i=0; i<Kr_bytes; i++)
-                      printf("%d : (%x)\n",i,eNB->dlsch[k][cw]->harq_processes[0]->c[s][i]);
-                  }
-                }
-              }
-
-              start_meas(&eNB->dlsch_modulation_stats);
-     
-              re_allocated = dlsch_modulation(eNB->common_vars.txdataF[eNB_id],
-                                              AMP,
-                                              subframe,
-                                              &eNB->frame_parms,
-                                              num_pdcch_symbols,
-                                              eNB->dlsch[k][0],
-                                              (transmission_mode==3)||(transmission_mode==4) ? eNB->dlsch[k][1] : NULL);	      
-              
-              (void)re_allocated;
-
-              stop_meas(&eNB->dlsch_modulation_stats);
-              
-            } //n_users
-
-
-            generate_pilots(eNB,
-                            eNB->common_vars.txdataF[eNB_id],
-                            AMP,
-                            LTE_NUMBER_OF_SUBFRAMES_PER_FRAME);
-
-            start_meas(&eNB->ofdm_mod_stats);
-
-            do_OFDM_mod_l(eNB->common_vars.txdataF[eNB_id],
-                          eNB->common_vars.txdata[eNB_id],
-                          (subframe*2),
-                          &eNB->frame_parms);
-
-            do_OFDM_mod_l(eNB->common_vars.txdataF[eNB_id],
-                          eNB->common_vars.txdata[eNB_id],
-                          (subframe*2)+1,
-                          &eNB->frame_parms);
-
-            stop_meas(&eNB->ofdm_mod_stats);
-            stop_meas(&eNB->phy_proc_tx);
-
-            do_OFDM_mod_l(eNB->common_vars.txdataF[eNB_id],
-                          eNB->common_vars.txdata[eNB_id],
-                          (subframe*2)+2,
-                          &eNB->frame_parms);
-
-            if (n_frames==1) {
-              write_output("txsigF0.m","txsF0", &eNB->common_vars.txdataF[eNB_id][0][subframe*nsymb*eNB->frame_parms.ofdm_symbol_size],
-                           nsymb*eNB->frame_parms.ofdm_symbol_size,1,1);
-
-              if (eNB->frame_parms.nb_antennas_tx>1)
-                write_output("txsigF1.m","txsF1", &eNB->common_vars.txdataF[eNB_id][1][subframe*nsymb*eNB->frame_parms.ofdm_symbol_size],
-                             nsymb*eNB->frame_parms.ofdm_symbol_size,1,1);
-            }
-            tx_lev = 0;
-
-            for (aa=0; aa<eNB->frame_parms.nb_antennas_tx; aa++) {
-              tx_lev += signal_energy(&eNB->common_vars.txdata[eNB_id][aa]
-                                      [subframe*eNB->frame_parms.samples_per_tti],
-                                      eNB->frame_parms.samples_per_tti);
-            }
-
-            tx_lev_dB = (unsigned int) dB_fixed(tx_lev);
-
-            if (n_frames==1) {
-              printf("tx_lev = %d (%d dB)\n",tx_lev,tx_lev_dB);
-              write_output("txsig0.m","txs0", &eNB->common_vars.txdata[eNB_id][0][subframe* eNB->frame_parms.samples_per_tti],
-
-                           eNB->frame_parms.samples_per_tti,1,1);
-            }
-          }
-		*/
           /*
             else {  // Read signal from file
             i=0;
@@ -2533,7 +2361,6 @@ int main(int argc, char **argv)
 			  &eNB->frame_parms);
 	    
 	    stop_meas(&eNB->ofdm_mod_stats);
-	    stop_meas(&eNB->phy_proc_tx);
 	    
 	    // generate next subframe for channel estimation
 	    
@@ -2653,461 +2480,7 @@ int main(int argc, char **argv)
 	  }
 	  
 	  
-	  /*
-	    if (n_frames==1) {
-	    printf("RX level in null symbol %d\n",dB_fixed(signal_energy(&UE->common_vars.rxdata[0][160+OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
-	    printf("RX level in data symbol %d\n",dB_fixed(signal_energy(&UE->common_vars.rxdata[0][160+(2*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES)],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
-	    printf("rx_level Null symbol %f\n",10*log10(signal_energy_fp(r_re,r_im,1,OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2,256+(OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES))));
-	    printf("rx_level data symbol %f\n",10*log10(signal_energy_fp(r_re,r_im,1,OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2,256+(2*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES))));
-	    }
-	    
-	    if (eNB->frame_parms.Ncp == 0) {  // normal prefix
-            pilot1 = 4;
-            pilot2 = 7;
-            pilot3 = 11;
-	    } else { // extended prefix
-            pilot1 = 3;
-            pilot2 = 6;
-            pilot3 = 9;
-	    }
-	    
-	    start_meas(&UE->phy_proc_rx);
 
-          // Inner receiver scheduling for 3 slots
-          for (Ns=(2*subframe); Ns<((2*subframe)+3); Ns++) {
-            for (l=0; l<pilot2; l++) {
-              if (n_frames==1)
-                printf("Ns %d, l %d, l2 %d\n",Ns, l, l+(Ns%2)*pilot2);
-
-
-
-              start_meas(&UE->ofdm_demod_stats);
-              slot_fep(UE,
-                       l,
-                       Ns%20,
-                       0,
-                       0,
-		       0);
-              stop_meas(&UE->ofdm_demod_stats);
-
-              if (UE->perfect_ce==1) {
-                if (awgn_flag==0) {
-                  for(k=0; k<NUMBER_OF_eNB_MAX; k++) {
-                    for(aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
-                      for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
-                        for (i=0; i<frame_parms->N_RB_DL*12; i++) {
-                          ((int16_t *) UE->common_vars.dl_ch_estimates[k][(aa<<1)+aarx])[2*i+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)(
-                                eNB2UE[round]->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].x*AMP);
-                          ((int16_t *) UE->common_vars.dl_ch_estimates[k][(aa<<1)+aarx])[2*i+1+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)(
-                                eNB2UE[round]->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].y*AMP);
-                        }
-                      }
-                    }
-                  }
-                } else {
-                  for(aa=0; aa<frame_parms->nb_antennas_tx; aa++) {
-                    for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
-                      for (i=0; i<frame_parms->N_RB_DL*12; i++) {
-                        ((int16_t *) UE->common_vars.dl_ch_estimates[0][(aa<<1)+aarx])[2*i+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(short)(AMP);
-                        ((int16_t *) UE->common_vars.dl_ch_estimates[0][(aa<<1)+aarx])[2*i+1+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=0/2;
-                      }
-                    }
-                  }
-                }
-              }
-
-
-              if ((Ns==((2*subframe))) && (l==0)) {
-                lte_ue_measurements(UE,
-                                    subframe*UE->frame_parms.samples_per_tti,
-                                    1,
-                                    0);
-
-                if (transmission_mode==5 || transmission_mode==6) {
-                  if (pmi_feedback == 1) {
-                    pmi_feedback = 0;
-                    hold_channel = 1;
-                    goto PMI_FEEDBACK;
-                  }
-                }
-
-              }
-
-
-              if ((Ns==(2*subframe)) && (l==pilot1)) {// process symbols 0,1,2
-
-                if (dci_flag == 1) {
-                  UE->UE_mode[0] = PUSCH;
-                  start_meas(&UE->dlsch_rx_pdcch_stats);
-                  rx_pdcch(&UE->common_vars,
-                           UE->pdcch_vars,
-                           &UE->frame_parms,
-                           subframe,
-                           0,
-                           (UE->frame_parms.mode1_flag == 1) ? SISO : ALAMOUTI,
-                           UE->high_speed_flag,
-                           0);
-                  stop_meas(&UE->dlsch_rx_pdcch_stats);
-                  // overwrite number of pdcch symbols
-                  UE->pdcch_vars[0]->num_pdcch_symbols = num_pdcch_symbols;
-
-                  dci_cnt = dci_decoding_procedure(UE,
-                                                   dci_alloc_rx,1,
-                                                   eNB_id,
-                                                   subframe);
-                  //printf("dci_cnt %d\n",dci_cnt);
-
-                  if (dci_cnt==0) {
-                    dlsch_active = 0;
-
-                    if (round==0) {
-                      dci_errors++;
-                      round=5;
-                      errs[0]++;
-                      //round_trials[0]++;
-
-                      if (n_frames==1)
-                        printf("DCI error trial %d errs[0] %d\n",trials,errs[0]);
-                    }
-
-                    //    for (i=1;i<=round;i++)
-                    //      round_trials[i]--;
-                    //    round=5;
-                  }
-
-                  for (i=0; i<dci_cnt; i++) {
-                    //        printf("Generating dlsch parameters for RNTI %x\n",dci_alloc_rx[i].rnti);
-                    if (round == 0) UE->dlsch[0][0]->harq_processes[UE->dlsch[0][0]->current_harq_pid]->first_tx=1;
-
-                    if ((dci_alloc_rx[i].rnti == n_rnti) &&
-                        (generate_ue_dlsch_params_from_dci(0,
-							   subframe,
-                                                           dci_alloc_rx[i].dci_pdu,
-                                                           dci_alloc_rx[i].rnti,
-                                                           dci_alloc_rx[i].format,
-                                                           UE->dlsch[0],
-                                                           &UE->frame_parms,
-                                                           UE->pdsch_config_dedicated,
-                                                           SI_RNTI,
-                                                           0,
-                                                           P_RNTI)==0)) {
-                      //dump_dci(&UE->frame_parms,&dci_alloc_rx[i]);
-                      coded_bits_per_codeword = get_G(&eNB->frame_parms,
-                                                      UE->dlsch[0][0]->harq_processes[UE->dlsch[0][0]->current_harq_pid]->nb_rb,
-                                                      UE->dlsch[0][0]->harq_processes[UE->dlsch[0][0]->current_harq_pid]->rb_alloc_even,
-                                                      get_Qm(UE->dlsch[0][0]->harq_processes[UE->dlsch[0][0]->current_harq_pid]->mcs),
-                                                      UE->dlsch[0][0]->harq_processes[UE->dlsch[0][0]->current_harq_pid]->Nl,
-                                                      UE->pdcch_vars[0]->num_pdcch_symbols,
-                                                      0,subframe);
-                      printf("num_pdcch_symbols %d, G %d, TBS %d\n",UE->pdcch_vars[0]->num_pdcch_symbols,coded_bits_per_codeword,
-                             UE->dlsch[0][0]->harq_processes[UE->dlsch[0][0]->current_harq_pid]->TBS);
-
-                      dlsch_active = 1;
-                    } else {
-                      dlsch_active = 0;
-
-                      if (round==0) {
-                        dci_errors++;
-                        errs[0]++;
-                        //round_trials[0]++;
-                        round=5;
-
-                        if (n_frames==1)
-                          printf("DCI misdetection trial %d\n",trials);
-
-                      }
-
-                      //      for (i=1;i<=round;i++)
-                      //        round_trials[i]--;
-                      //      round=5;
-                    }
-                  }
-                }  // if dci_flag==1
-                else { //dci_flag == 0
-
-                  UE->pdcch_vars[0]->crnti = n_rnti;
-                  UE->pdcch_vars[0]->num_pdcch_symbols = num_pdcch_symbols;
-
-                  if (round == 0) UE->dlsch[0][0]->harq_processes[0]->first_tx=1;
-
-                  switch (transmission_mode) {
-                  case 1:
-                  case 2:
-                    generate_ue_dlsch_params_from_dci(0,
-						      subframe,
-                                                      &DLSCH_alloc_pdu_1[0],
-                                                      (common_flag==0)? C_RNTI : SI_RNTI,
-                                                      (common_flag==0)? format1 : format1A,
-                                                      UE->dlsch[0],
-                                                      &UE->frame_parms,
-                                                      UE->pdsch_config_dedicated,
-                                                      SI_RNTI,
-                                                      0,
-                                                      P_RNTI);
-                    break;
-
-                  case 3:
-                    //        printf("Rate: TM3 (before) round %d (%d) first_tx %d\n",round,UE->dlsch[0][0]->harq_processes[0]->round,UE->dlsch[0][0]->harq_processes[0]->first_tx);
-                    generate_ue_dlsch_params_from_dci(0,
-						      subframe,
-                                                      &DLSCH_alloc_pdu_1[0],
-                                                      (common_flag==0)? C_RNTI : SI_RNTI,
-                                                      (common_flag==0)? format2A : format1A,
-                                                      UE->dlsch[0],
-                                                      &UE->frame_parms,
-                                                      UE->pdsch_config_dedicated,
-                                                      SI_RNTI,
-                                                      0,
-                                                      P_RNTI);
-                    //        printf("Rate: TM3 (after) round %d (%d) first_tx %d\n",round,UE->dlsch[0][0]->harq_processes[0]->round,UE->dlsch[0][0]->harq_processes[0]->first_tx);
-                    break;
-
-                  case 4:
-                    generate_ue_dlsch_params_from_dci(0,
-						      subframe,
-                                                      &DLSCH_alloc_pdu_1[0],
-                                                      (common_flag==0)? C_RNTI : SI_RNTI,
-                                                      (common_flag==0)? format2 : format1A,
-                                                      UE->dlsch[0],
-                                                      &UE->frame_parms,
-                                                      UE->pdsch_config_dedicated,
-                                                      SI_RNTI,
-                                                      0,
-                                                      P_RNTI);
-                    break;
-
-                  case 5:
-                  case 6:
-                    generate_ue_dlsch_params_from_dci(0,
-						      subframe,
-                                                      &DLSCH_alloc_pdu2_1E[0],
-                                                      C_RNTI,
-                                                      format1E_2A_M10PRB,
-                                                      UE->dlsch[0],
-                                                      &UE->frame_parms,
-                                                      UE->pdsch_config_dedicated,
-                                                      SI_RNTI,
-                                                      0,
-                                                      P_RNTI);
-                    break;
-
-                  }
-
-                  dlsch_active = 1;
-                } // if dci_flag == 1
-              }
-
-              if (dlsch_active == 1) {
-                if ((Ns==(1+(2*subframe))) && (l==0)) {// process PDSCH symbols 1,2,3,4,5,(6 Normal Prefix)
-
-                  if ((transmission_mode == 5) &&
-                      (UE->dlsch[eNB_id][0]->harq_processes[UE->dlsch[0][0]->current_harq_pid]->dl_power_off==0) &&
-                      (UE->use_ia_receiver ==1)) {
-                    dual_stream_UE = 1;
-                  } else {
-                    dual_stream_UE = 0;
-                  }
-
-
-                  start_meas(&UE->dlsch_llr_stats);
-
-                  for (m=UE->pdcch_vars[0]->num_pdcch_symbols;
-                       m<pilot2;
-                       m++) {
-                    if (rx_pdsch(UE,
-                                 PDSCH,
-                                 eNB_id,
-                                 eNB_id_i,
-                                 subframe,
-                                 m,
-                                 (m==UE->pdcch_vars[0]->num_pdcch_symbols)?1:0,
-                                 dual_stream_UE,
-                                 i_mod,
-                                 UE->dlsch[0][0]->current_harq_pid)==-1) {
-                      dlsch_active = 0;
-                      break;
-                    }
-                  }
-
-                  stop_meas(&UE->dlsch_llr_stats);
-                }
-
-                if ((Ns==(1+(2*subframe))) && (l==pilot1)) {
-                  // process symbols (6 Extended Prefix),7,8,9
-                  start_meas(&UE->dlsch_llr_stats);
-
-                  for (m=pilot2;
-                       m<pilot3;
-                       m++) {
-                    if (rx_pdsch(UE,
-                                 PDSCH,
-                                 eNB_id,
-                                 eNB_id_i,
-                                 subframe,
-                                 m,
-                                 0,
-                                 dual_stream_UE,
-                                 i_mod,
-                                 UE->dlsch[0][0]->current_harq_pid)==-1) {
-                      dlsch_active=0;
-                      break;
-                    }
-                  }
-
-                  stop_meas(&UE->dlsch_llr_stats);
-                }
-
-                if ((Ns==(2+(2*subframe))) && (l==0)) { // process symbols 10,11,(12,13 Normal Prefix) do deinterleaving for TTI
-                  start_meas(&UE->dlsch_llr_stats);
-
-                  for (m=pilot3;
-                       m<UE->frame_parms.symbols_per_tti;
-                       m++) {
-                    if (rx_pdsch(UE,
-                                 PDSCH,
-                                 eNB_id,
-                                 eNB_id_i,
-                                 subframe,
-                                 m,
-                                 0,
-                                 dual_stream_UE,
-                                 i_mod,
-                                 UE->dlsch[0][0]->current_harq_pid)==-1) {
-                      dlsch_active=0;
-                      break;
-                    }
-                  }
-
-                  stop_meas(&UE->dlsch_llr_stats);
-                }
-
-                if (test_perf ==0 ) {
-                  if ((n_frames==1) && (Ns==(2+(2*subframe))) && (l==0))  {
-                    write_output("ch0.m","ch0",eNB2UE[0]->ch[0],eNB2UE[0]->channel_length,1,8);
-
-                    if (eNB->frame_parms.nb_antennas_tx>1)
-                      write_output("ch1.m","ch1",eNB2UE[0]->ch[eNB->frame_parms.nb_antennas_rx],eNB2UE[0]->channel_length,1,8);
-
-                    //common vars
-                    write_output("rxsig0.m","rxs0", &UE->common_vars.rxdata[0][0],10*UE->frame_parms.samples_per_tti,1,1);
-                    write_output("rxsigF0.m","rxsF0", &UE->common_vars.rxdataF[0][0],UE->frame_parms.ofdm_symbol_size*nsymb,1,1);
-
-                    if (UE->frame_parms.nb_antennas_rx>1) {
-                      write_output("rxsig1.m","rxs1", UE->common_vars.rxdata[1],UE->frame_parms.samples_per_tti,1,1);
-                      write_output("rxsigF1.m","rxsF1", UE->common_vars.rxdataF[1],UE->frame_parms.ofdm_symbol_size*nsymb,1,1);
-                    }
-
-                    write_output("dlsch00_r0.m","dl00_r0",
-                                 &(UE->common_vars.dl_ch_estimates[eNB_id][0][0]),
-                                 UE->frame_parms.ofdm_symbol_size*nsymb,1,1);
-
-                    if (UE->frame_parms.nb_antennas_rx>1)
-                      write_output("dlsch01_r0.m","dl01_r0",
-                                   &(UE->common_vars.dl_ch_estimates[eNB_id][1][0]),
-                                   UE->frame_parms.ofdm_symbol_size*nsymb,1,1);
-
-                    if (eNB->frame_parms.nb_antennas_tx>1)
-                      write_output("dlsch10_r0.m","dl10_r0",
-                                   &(UE->common_vars.dl_ch_estimates[eNB_id][2][0]),
-                                   UE->frame_parms.ofdm_symbol_size*nsymb,1,1);
-
-                    if ((UE->frame_parms.nb_antennas_rx>1) && (eNB->frame_parms.nb_antennas_tx>1))
-                      write_output("dlsch11_r0.m","dl11_r0",
-                                   &(UE->common_vars.dl_ch_estimates[eNB_id][3][0]),
-                                   UE->frame_parms.ofdm_symbol_size*nsymb/2,1,1);
-
-                    //pdsch_vars
-                    dump_dlsch2(UE,eNB_id,coded_bits_per_codeword,round);
-                    //dump_dlsch2(UE,eNB_id_i,coded_bits_per_codeword);
-                    write_output("dlsch_e.m","e",eNB->dlsch[0][0]->harq_processes[0]->e,coded_bits_per_codeword,1,4);
-
-                    //pdcch_vars
-                    write_output("pdcchF0_ext.m","pdcchF_ext", UE->pdcch_vars[eNB_id]->rxdataF_ext[0],2*3*UE->frame_parms.ofdm_symbol_size,1,1);
-                    write_output("pdcch00_ch0_ext.m","pdcch00_ch0_ext",UE->pdcch_vars[eNB_id]->dl_ch_estimates_ext[0],300*3,1,1);
-
-                    write_output("pdcch_rxF_comp0.m","pdcch0_rxF_comp0",UE->pdcch_vars[eNB_id]->rxdataF_comp[0],4*300,1,1);
-                    write_output("pdcch_rxF_llr.m","pdcch_llr",UE->pdcch_vars[eNB_id]->llr,2400,1,4);
-
-                  }
-                }
-              }
-            }
-          }
-
-          //saving PMI in case of Transmission Mode > 5
-
-          if(abstx) {
-            if (trials==0 && round==0 && transmission_mode>=5) {
-              for (iii=0; iii<NB_RB; iii++) {
-                //fprintf(csv_fd, "%d, %d", (UE->lte_ue_pdsch_vars[eNB_id]->pmi_ext[iii]),(UE->lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[iii]));
-                fprintf(csv_fd,"%x,%x,",(UE->pdsch_vars[eNB_id]->pmi_ext[iii]),(UE->pdsch_vars[eNB_id]->pmi_ext[iii]));
-                printf("%x ",(UE->pdsch_vars[eNB_id]->pmi_ext[iii]));
-              }
-            }
-          }
-
-          for (int cw=Kmimo-1; cw>=0; cw--) {
-            UE->dlsch[0][cw]->rnti = (common_flag==0) ? n_rnti: SI_RNTI;
-            coded_bits_per_codeword = get_G(&eNB->frame_parms,
-                                            eNB->dlsch[0][cw]->harq_processes[0]->nb_rb,
-                                            eNB->dlsch[0][cw]->harq_processes[0]->rb_alloc,
-                                            get_Qm(eNB->dlsch[0][cw]->harq_processes[0]->mcs),
-                                            eNB->dlsch[0][cw]->harq_processes[0]->Nl,
-                                            num_pdcch_symbols,
-                                            0,subframe);
-
-            UE->dlsch[0][cw]->harq_processes[UE->dlsch[0][cw]->current_harq_pid]->G = coded_bits_per_codeword;
-
-
-            // calculate uncoded BLER
-            uncoded_ber=0;
-            for (i=0;i<coded_bits_per_codeword;i++)
-              if (eNB->dlsch[0][0]->harq_processes[0]->e[i] != (UE->pdsch_vars[0]->llr[0][i]<0)) {
-                uncoded_ber_bit[i] = 1;
-                uncoded_ber++;
-              }
-              else
-                uncoded_ber_bit[i] = 0;
-
-            uncoded_ber/=coded_bits_per_codeword;
-            avg_ber += uncoded_ber;
-
-            if (n_frames==1)
-              write_output("uncoded_ber_bit.m","uncoded_ber_bit",uncoded_ber_bit,coded_bits_per_codeword,1,0);
-            
-
-            start_meas(&UE->dlsch_unscrambling_stats);
-            dlsch_unscrambling(&UE->frame_parms,
-                               0,
-                               UE->dlsch[0][cw],
-                               coded_bits_per_codeword,
-                               UE->pdsch_vars[eNB_id]->llr[cw],
-                               0,
-                               subframe<<1);
-            stop_meas(&UE->dlsch_unscrambling_stats);
-
-            start_meas(&UE->dlsch_decoding_stats);
-            ret = dlsch_decoding(UE,
-                                 UE->pdsch_vars[eNB_id]->llr[cw],
-                                 &UE->frame_parms,
-                                 UE->dlsch[0][cw],
-                                 UE->dlsch[0][cw]->harq_processes[UE->dlsch[0][cw]->current_harq_pid],
-                                 subframe,
-                                 UE->dlsch[0][cw]->current_harq_pid,
-                                 1,llr8_flag);
-            stop_meas(&UE->dlsch_decoding_stats);
-
-            if (cw==1) {
-              if (ret <= UE->dlsch[0][cw]->max_turbo_iterations) {
-              } else {
-                errs2[round]++;
-              }
-            }
-          }
-
-	  
-          stop_meas(&UE->phy_proc_rx);
-	  */
 
           if (UE->dlsch_errors[0] == 0) {
 
@@ -3120,45 +2493,7 @@ int main(int argc, char **argv)
             UE->total_TBS[eNB_id] =  UE->total_TBS[eNB_id] + UE->dlsch[eNB_id][0]->harq_processes[UE->dlsch[eNB_id][0]->current_harq_pid]->TBS;
             TB0_active = 0;
 
-            if (UE->dlsch[eNB_id][0]->harq_processes[UE->dlsch[eNB_id][0]->current_harq_pid]->mimo_mode == LARGE_CDD) {   //try to decode second stream using SIC
+               
-              
-              //for (round = 0 ; round < UE->dlsch[eNB_id][0]->harq_processes[UE->dlsch[eNB_id][0]->current_harq_pid]->round ; round++) {
-              // re-encoding of first stream
-              //dlsch0_ue_harq = UE->dlsch[eNB_id][0]->harq_processes[UE->dlsch[eNB_id][0]->current_harq_pid];
-              //dlsch0_eNB_harq = UE->dlsch[eNB_id]->harq_processes[UE->dlsch[eNB_id][0]->current_harq_pid];
-              //dlsch0_eNB_harq->mimo_mode    = LARGE_CDD;
-              //dlsch0_eNB_harq->rb_alloc[0]  = dlsch0_ue_harq->rb_alloc_even[0];
-              //dlsch0_eNB_harq->nb_rb        = dlsch0_ue_harq->nb_rb;
-              //dlsch0_eNB_harq->mcs          = dlsch0_ue_harq->mcs;
-              //dlsch0_eNB_harq->rvidx        = dlsch0_ue_harq->rvidx;
-              //dlsch0_eNB_harq->Nl           = dlsch0_ue_harq->Nl;
-
-              //dlsch0_eNB_harq->TBS          = dlsch0_ue_harq->TBS;
-              //dlsch0_eNB_harq->dl_power_off = dlsch0_ue_harq->dl_power_off;
-              //dlsch0_eNB_harq->status       = dlsch0_ue_harq->status;
-
-              //UE->dlsch[eNB_id]->active       = UE->dlsch[eNB_id][0]->active;
-              //UE->dlsch[eNB_id]->rnti         = UE->dlsch[eNB_id][0]->rnti;
-
-              //dlsch_encoding(UE->dlsch[eNB_id][0]->harq_processes[UE->dlsch[eNB_id][0]->current_harq_pid]->b,
-              //     &UE->frame_parms,
-              //     num_pdcch_symbols,
-              //     UE->dlsch[0],
-              //     0,subframe,
-              //     &UE->dlsch_rate_matching_stats,
-              //     &UE->dlsch_turbo_encoding_stats,
-              //     &UE->dlsch_interleaving_stats
-              //     );
-
-                   //scrambling
-
-              //modulation
-
-              //stripping (from matched filter output?)
-
-              //detection of second stream
-	    }
-              
 	  } // DLSCH received ok
 	  else {
             errs[round]++;
@@ -3449,13 +2784,14 @@ int main(int argc, char **argv)
         printf("eNB TX function statistics (per 1ms subframe)\n\n");
         std_phy_proc_tx = sqrt((double)eNB->phy_proc_tx.diff_square/pow(cpu_freq_GHz,2)/pow(1000,
                                2)/eNB->phy_proc_tx.trials - pow((double)eNB->phy_proc_tx.diff/eNB->phy_proc_tx.trials/cpu_freq_GHz/1000,2));
-        printf("Total PHY proc tx                 :%f us (%d trials)\n",(double)eNB->phy_proc_tx.diff/eNB->phy_proc_tx.trials/cpu_freq_GHz/1000.0,eNB->phy_proc_tx.trials);
-        printf("|__ Statistcs                           std: %fus max: %fus min: %fus median %fus q1 %fus q3 %fus n_dropped: %d packet \n",std_phy_proc_tx, t_tx_max, t_tx_min, tx_median, tx_q1, tx_q3,
-               n_tx_dropped);
         std_phy_proc_tx_ifft = sqrt((double)eNB->ofdm_mod_stats.diff_square/pow(cpu_freq_GHz,2)/pow(1000,
                                     2)/eNB->ofdm_mod_stats.trials - pow((double)eNB->ofdm_mod_stats.diff/eNB->ofdm_mod_stats.trials/cpu_freq_GHz/1000,2));
         printf("OFDM_mod time                     :%f us (%d trials)\n",(double)eNB->ofdm_mod_stats.diff/eNB->ofdm_mod_stats.trials/cpu_freq_GHz/1000.0,eNB->ofdm_mod_stats.trials);
         printf("|__ Statistcs                           std: %fus median %fus q1 %fus q3 %fus \n",std_phy_proc_tx_ifft, tx_ifft_median, tx_ifft_q1, tx_ifft_q3);
+        printf("Total PHY proc tx                 :%f us (%d trials)\n",(double)eNB->phy_proc_tx.diff/eNB->phy_proc_tx.trials/cpu_freq_GHz/1000.0,eNB->phy_proc_tx.trials);
+        printf("|__ Statistcs                           std: %fus max: %fus min: %fus median %fus q1 %fus q3 %fus n_dropped: %d packet \n",std_phy_proc_tx, t_tx_max, t_tx_min, tx_median, tx_q1, tx_q3,
+               n_tx_dropped);
+
         std_phy_proc_tx_mod = sqrt((double)eNB->dlsch_modulation_stats.diff_square/pow(cpu_freq_GHz,2)/pow(1000,
                                    2)/eNB->dlsch_modulation_stats.trials - pow((double)eNB->dlsch_modulation_stats.diff/eNB->dlsch_modulation_stats.trials/cpu_freq_GHz/1000,2));
         printf("DLSCH modulation time             :%f us (%d trials)\n",(double)eNB->dlsch_modulation_stats.diff/eNB->dlsch_modulation_stats.trials/cpu_freq_GHz/1000.0,
@@ -3809,24 +3145,6 @@ int main(int argc, char **argv)
   }
 
 
-  printf("Freeing channel I/O\n");
-
-  for (i=0; i<2; i++) {
-    free(s_re[i]);
-    free(s_im[i]);
-    free(r_re[i]);
-    free(r_im[i]);
-  }
-
-  free(s_re);
-  free(s_im);
-  free(r_re);
-  free(r_im);
-
-  //  lte_sync_time_free();
-
-  //  printf("[MUMIMO] mcs %d, mcsi %d, offset %d, bler %f\n",mcs,mcs_i,offset_mumimo_llr_drange_fix,((double)errs[0])/((double)round_trials[0]));
-
   return(0);
 }
 

openair1/SIMULATION/LTE_PHY/ulsim.c

@@ -188,7 +188,7 @@ int main(int argc, char **argv)
   int **txdata;
 
   LTE_DL_FRAME_PARMS *frame_parms;
-  double **s_re,**s_im,**r_re,**r_im;
+  double s_re[2][30720],s_im[2][30720],r_re[2][30720],r_im[2][30720];
   double forgetting_factor=0.0; //in [0,1] 0 means a new channel every time, 1 means keep the same channel
   double iqim=0.0;
   uint8_t extended_prefix_flag=0;
@@ -583,12 +583,6 @@ int main(int argc, char **argv)
   txdata = UE->common_vars.txdata;
 
 
-  s_re = malloc(2*sizeof(double*));
-  s_im = malloc(2*sizeof(double*));
-  r_re = malloc(2*sizeof(double*));
-  r_im = malloc(2*sizeof(double*));
-  //  r_re0 = malloc(2*sizeof(double*));
-  //  r_im0 = malloc(2*sizeof(double*));
 
   nsymb = (eNB->frame_parms.Ncp == NORMAL) ? 14 : 12;
 
@@ -630,13 +624,6 @@ int main(int argc, char **argv)
     fprintf(csv_fdUL,"data_all%d=[",mcs);
   }
 
-  for (i=0; i<2; i++) {
-    s_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
-    s_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
-    r_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
-    r_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
-  }
-
 
   if (xforms==1) {
     fl_initialize (&argc, argv, NULL, 0, 0);
@@ -1716,22 +1703,6 @@ int main(int argc, char **argv)
   if (test_perf !=0)
     fclose (time_meas_fd);
 
-  printf("Freeing channel I/O\n");
-
-  for (i=0; i<2; i++) {
-    free(s_re[i]);
-    free(s_im[i]);
-    free(r_re[i]);
-    free(r_im[i]);
-  }
-
-  free(s_re);
-  free(s_im);
-  free(r_re);
-  free(r_im);
-
-  //  lte_sync_time_free();
-
   return(0);
 
 }

openair1/SIMULATION/RF/adc.c

@@ -26,8 +26,8 @@
   Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
 
  *******************************************************************************/
-void adc(double **r_re,
+void adc(double r_re[2][30720],
-         double **r_im,
+         double r_im[2][30720],
          unsigned int input_offset,
          unsigned int output_offset,
          unsigned int **output,

openair1/SIMULATION/RF/dac.c

@@ -31,8 +31,8 @@
 #include <stdio.h>
 #include "PHY/TOOLS/defs.h"
 
-void dac(double **s_re,
+void dac(double s_re[2][30720],
-         double **s_im,
+         double s_im[2][30720],
          uint32_t **input,
          uint32_t input_offset,
          uint32_t nb_tx_antennas,
@@ -81,8 +81,8 @@ void dac(double **s_re,
   }
 }
 
-double dac_fixed_gain(double **s_re,
+double dac_fixed_gain(double s_re[2][30720],
-                      double **s_im,
+                      double s_im[2][30720],
                       uint32_t **input,
                       uint32_t input_offset,
                       uint32_t nb_tx_antennas,

openair1/SIMULATION/RF/defs.h

@@ -64,16 +64,16 @@ void rf_rx(double **r_re,
            double IQ_imb_dB,
            double IQ_phase);
 
-void rf_rx_simple(double **r_re,
+void rf_rx_simple(double r_re[2][30720],
-                  double **r_im,
+                  double r_im[2][30720],
                   unsigned int nb_rx_antennas,
                   unsigned int length,
                   double s_time,
                   double rx_gain_dB);
 
 
-void adc(double **r_re,
+void adc(double r_re[2][30720],
-         double **r_im,
+         double r_im[2][30720],
          unsigned int input_offset,
          unsigned int output_offset,
          int **output,
@@ -81,8 +81,8 @@ void adc(double **r_re,
          unsigned int length,
          unsigned char B);
 
-void dac(double **s_re,
+void dac(double s_re[2][30720],
-         double **s_im,
+         double s_im[2][30720],
          int **input,
          unsigned int input_offset,
          unsigned int nb_tx_antennas,
@@ -92,8 +92,8 @@ void dac(double **s_re,
          unsigned int meas_length,
          unsigned int meas_offset);
 
-double dac_fixed_gain(double **s_re,
+double dac_fixed_gain(double s_re[2][30720],
-                      double **s_im,
+                      double s_im[2][30720],
                       int **input,
                       unsigned int input_offset,
                       unsigned int nb_tx_antennas,

openair1/SIMULATION/RF/rf.c

@@ -206,8 +206,8 @@ void rf_rx(double **r_re,
   }
 }
 
-void rf_rx_simple(double **r_re,
+void rf_rx_simple(double r_re[2][30720],
-                  double **r_im,
+                  double r_im[2][30720],
                   unsigned int nb_rx_antennas,
                   unsigned int length,
                   double s_time,

openair1/SIMULATION/TOOLS/defs.h

@@ -219,10 +219,10 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
 int random_channel(channel_desc_t *desc, uint8_t abstraction_flag);
 
 /**\fn void multipath_channel(channel_desc_t *desc,
-           double **tx_sig_re,
+           double tx_sig_re[2][30720],
-           double **tx_sig_im,
+           double tx_sig_im[2][30720],
-           double **rx_sig_re,
+           double rx_sig_re[2][30720],
-           double **rx_sig_im,
+           double rx_sig_im[2][30720],
            uint32_t length,
            uint8_t keep_channel)
 
@@ -237,10 +237,10 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag);
 */
 
 void multipath_channel(channel_desc_t *desc,
-                       double **tx_sig_re,
+                       double tx_sig_re[2][30720],
-                       double **tx_sig_im,
+                       double tx_sig_im[2][30720],
-                       double **rx_sig_re,
+                       double rx_sig_re[2][30720],
-                       double **rx_sig_im,
+                       double rx_sig_im[2][30720],
                        uint32_t length,
                        uint8_t keep_channel);
 /*

openair1/SIMULATION/TOOLS/multipath_channel.c

@@ -44,10 +44,10 @@ uint8_t multipath_channel_nosigconv(channel_desc_t *desc)
 //#define CHANNEL_SSE
 #ifdef CHANNEL_SSE
 void multipath_channel(channel_desc_t *desc,
-                       double **tx_sig_re,
+                       double tx_sig_re[2][30720],
-                       double **tx_sig_im,
+                       double tx_sig_im[2][30720],
-                       double **rx_sig_re,
+                       double rx_sig_re[2][30720],
-                       double **rx_sig_im,
+                       double rx_sig_im[2][30720],
                        uint32_t length,
                        uint8_t keep_channel)
 {
@@ -150,10 +150,10 @@ void multipath_channel(channel_desc_t *desc,
 
 #else
 void multipath_channel(channel_desc_t *desc,
-                       double **tx_sig_re,
+                       double tx_sig_re[2][30720],
-                       double **tx_sig_im,
+                       double tx_sig_im[2][30720],
-                       double **rx_sig_re,
+                       double rx_sig_re[2][30720],
-                       double **rx_sig_im,
+                       double rx_sig_im[2][30720],
                        uint32_t length,
                        uint8_t keep_channel)
 {

openair2/COMMON/s1ap_messages_types.h

@@ -76,7 +76,7 @@
  * the key length is 32 bytes (256 bits)
  */
 #define SECURITY_KEY_LENGTH 32
-
+#ifndef OCP_FRAMEWORK
 typedef enum cell_type_e {
   CELL_MACRO_ENB,
   CELL_HOME_ENB
@@ -107,6 +107,7 @@ typedef enum cn_domain_s {
   CN_DOMAIN_PS = 1,
   CN_DOMAIN_CS = 2
 } cn_domain_t;
+#endif
 
 typedef struct net_ip_address_s {
   unsigned ipv4:1;
@@ -122,6 +123,7 @@ typedef struct ambr_s {
   bitrate_t br_dl;
 } ambr_t;
 
+#ifndef OCP_FRAMEWORK
 typedef enum priority_level_s {
   PRIORITY_LEVEL_SPARE       = 0,
   PRIORITY_LEVEL_HIGHEST     = 1,
@@ -140,6 +142,7 @@ typedef enum pre_emp_vulnerability_e {
   PRE_EMPTION_VULNERABILITY_DISABLED = 1,
   PRE_EMPTION_VULNERABILITY_MAX,
 } pre_emp_vulnerability_t;
+#endif
 
 typedef struct allocation_retention_priority_s {
   priority_level_t        priority_level;

openair2/ENB_APP/enb_config.h

@@ -40,6 +40,7 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <libconfig.h>
 
 #include "commonDef.h"
 #include "platform_types.h"
@@ -49,6 +50,7 @@
 #include "s1ap_messages_types.h"
 #ifdef CMAKER
 #include "SystemInformationBlockType2.h"
+#include "rrc_messages_types.h"
 #else
 #include "RRC/LITE/MESSAGES/SystemInformationBlockType2.h"
 #endif
@@ -116,6 +118,7 @@ typedef struct Enb_properties_s {
    */
   char               *eNB_name;
 
+
   /* Tracking area code */
   uint16_t            tac;
 
@@ -130,6 +133,7 @@ typedef struct Enb_properties_s {
 
   /* Physical parameters */
   int16_t                 nb_cc;
+#ifndef OCP_FRAMEWORK
   eNB_func_t              cc_node_function[1+MAX_NUM_CCs];
   eNB_timing_t            cc_node_timing[1+MAX_NUM_CCs];
   int16_t                 cc_node_synch_ref[1+MAX_NUM_CCs];
@@ -205,6 +209,9 @@ typedef struct Enb_properties_s {
   long                    ue_TimersAndConstants_t311[1+MAX_NUM_CCs];
   long                    ue_TimersAndConstants_n310[1+MAX_NUM_CCs];
   long                    ue_TimersAndConstants_n311[1+MAX_NUM_CCs];
+#else
+   RrcConfigurationReq    RrcReq;
+#endif
 
   long                    srb1_timer_poll_retransmit;
   long                    srb1_timer_reordering;
@@ -234,6 +241,7 @@ typedef struct Enb_properties_s {
   /* List of MME to connect to */
   rrh_gw_config_t       rrh_gw_config[4];
 
+#ifndef OCP_FRAMEWORK
   // otg config
   /* Nb of OTG elements */
   uint8_t            num_otg_elements;
@@ -262,7 +270,7 @@ typedef struct Enb_properties_s {
   int16_t           udp_log_verbosity;
   int16_t           osa_log_level;
   int16_t           osa_log_verbosity;
-
+#endif
 } Enb_properties_t;
 
 typedef struct Enb_properties_array_s {

openair2/LAYER2/MAC/defs.h

@@ -82,6 +82,7 @@
 
 #define BCCH_PAYLOAD_SIZE_MAX 128
 #define CCCH_PAYLOAD_SIZE_MAX 128
+#define PCCH_PAYLOAD_SIZE_MAX 128
 
 #define SCH_PAYLOAD_SIZE_MAX 4096
 /// Logical channel ids from 36-311 (Note BCCH is not specified in 36-311, uses the same as first DRB)
@@ -263,6 +264,10 @@ typedef struct {
 typedef struct {
   uint8_t payload[BCCH_PAYLOAD_SIZE_MAX] ;
 } __attribute__((__packed__))BCCH_PDU;
+/*! \brief BCCH payload */
+typedef struct {
+  uint8_t payload[PCCH_PAYLOAD_SIZE_MAX] ;
+} __attribute__((__packed__))PCCH_PDU;
 
 #ifdef Rel10
 /*! \brief MCCH payload */
@@ -291,6 +296,8 @@ typedef struct {
 #define CCCH_LCHANID 0
 /*!\brief Values of BCCH logical channel */
 #define BCCH 3  // SI 
+/*!\brief Values of PCCH logical channel */
+#define PCCH 4  // Paging 
 /*!\brief Value of CCCH / SRB0 logical channel */
 #define CCCH 0  // srb0
 /*!\brief DCCH / SRB1 logical channel */
@@ -1104,6 +1111,8 @@ typedef struct {
   time_stats_t rx_mch_sdu;
   /// UE BCCH rx processing time including RLC interface (mac_rrc_data_ind) 
   time_stats_t rx_si; 
+  /// UE PCCH rx processing time including RLC interface (mac_rrc_data_ind) 
+  time_stats_t rx_p; 
 } UE_MAC_INST;
 /*! \brief ID of the neighboring cells used for HO*/
 typedef struct {

openair2/LAYER2/MAC/eNB_scheduler_RA.c

@@ -68,6 +68,7 @@
 
 #include "SIMULATION/TOOLS/defs.h" // for taus
 
+#include "T.h"
 
 void schedule_RA(module_id_t module_idP,frame_t frameP, sub_frame_t subframeP,unsigned char Msg3_subframe)
 {
@@ -644,6 +645,9 @@ void schedule_RA(module_id_t module_idP,frame_t frameP, sub_frame_t subframeP,un
 		     &eNB->common_channels[CC_id].CCCH_pdu.payload[0],
 		     rrc_sdu_length);
 	      
+              T(T_ENB_MAC_UE_DL_PDU_WITH_DATA, T_INT(module_idP), T_INT(CC_id), T_INT(RA_template->rnti), T_INT(frameP), T_INT(subframeP),
+                T_INT(0 /*harq_pid always 0?*/), T_BUFFER(&eNB->UE_list.DLSCH_pdu[CC_id][0][UE_id].payload[0], TBsize));
+
 	      if (opt_enabled==1) {
 		trace_pdu(1, (uint8_t *)eNB->UE_list.DLSCH_pdu[CC_id][0][(unsigned char)UE_id].payload[0],
 			  rrc_sdu_length, UE_id, 3, UE_RNTI(module_idP, UE_id),

openair2/LAYER2/MAC/main.c

@@ -480,6 +480,7 @@ int l2_init(LTE_DL_FRAME_PARMS *frame_parms,int eMBMS_active, char *uecap_xer,ui
 
   LOG_I(MAC,"[MAIN] init UE MAC functions \n");
   mac_xface->ue_decode_si              = ue_decode_si;
+  mac_xface->ue_decode_p               = ue_decode_p;
   mac_xface->ue_send_sdu               = ue_send_sdu;
 #ifdef Rel10
   mac_xface->ue_send_mch_sdu           = ue_send_mch_sdu;

openair2/LAYER2/MAC/proto.h

@@ -385,6 +385,8 @@ void mac_out_of_sync_ind(module_id_t module_idP, frame_t frameP, uint16_t CH_ind
 
 void ue_decode_si(module_id_t module_idP, int CC_id,frame_t frame, uint8_t CH_index, void *pdu, uint16_t len);
 
+void ue_decode_p(module_id_t module_idP, int CC_id,frame_t frame, uint8_t CH_index, void *pdu, uint16_t len);
+
 
 void ue_send_sdu(module_id_t module_idP, uint8_t CC_id,frame_t frame, uint8_t *sdu,uint16_t sdu_len,uint8_t CH_index);
 

openair2/LAYER2/MAC/ue_procedures.c

@@ -525,6 +525,41 @@ void ue_decode_si(module_id_t module_idP,int CC_id,frame_t frameP, uint8_t eNB_i
   }
 }
 
+void ue_decode_p(module_id_t module_idP,int CC_id,frame_t frameP, uint8_t eNB_index, void *pdu,uint16_t len)
+{
+
+  start_meas(&UE_mac_inst[module_idP].rx_p);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_PCCH, VCD_FUNCTION_IN);
+
+  LOG_D(MAC,"[UE %d] Frame %d Sending Paging message to RRC (LCID Id %d,len %d)\n",module_idP,frameP,PCCH,len);
+
+  mac_rrc_data_ind(module_idP,
+                   CC_id,
+                   frameP,0, // unknown subframe
+                   P_RNTI,
+                   PCCH,
+                   (uint8_t *)pdu,
+                   len,
+                   ENB_FLAG_NO,
+                   eNB_index,
+                   0);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_PCCH, VCD_FUNCTION_OUT);
+  stop_meas(&UE_mac_inst[module_idP].rx_p);
+  if (opt_enabled == 1) {
+    trace_pdu(0,
+	      (uint8_t *)pdu,
+	      len,
+	      module_idP,
+	      4,
+	      P_RNTI,
+	      UE_mac_inst[module_idP].subframe,
+	      0,
+	      0);
+    LOG_D(OPT,"[UE %d][BCH] Frame %d trace pdu for CC_id %d rnti %x with size %d\n",
+	    module_idP, frameP, CC_id, P_RNTI, len);
+  }
+}
+
 #ifdef Rel10
 unsigned char *parse_mch_header(unsigned char *mac_header,
                                 unsigned char *num_sdu,

openair2/PHY_INTERFACE/defs.h

@@ -146,6 +146,9 @@ typedef struct {
   ///  Send a received SI sdu
   void (*ue_decode_si)(module_id_t Mod_id,int CC_id,frame_t frameP, uint8_t CH_index, void *pdu, uint16_t len);
 
+  ///  Send a received Paging sdu
+  void (*ue_decode_p)(module_id_t Mod_id,int CC_id,frame_t frameP, uint8_t CH_index, void *pdu, uint16_t len);
+
   /// Send a received DLSCH sdu to MAC
   void (*ue_send_sdu)(module_id_t Mod_id,uint8_t CC_id,frame_t frameP,uint8_t *sdu,uint16_t sdu_len,uint8_t CH_index);
 

openair2/RRC/LITE/L2_interface.c

@@ -397,6 +397,10 @@ mac_rrc_data_ind(
 #endif
     }
 
+    if(srb_idP == PCCH) {
+      LOG_D(RRC,"[UE %d] Received SDU for PCCH on SRB %d from eNB %d\n",module_idP,srb_idP,eNB_indexP);
+      decode_PCCH_DLSCH_Message(&ctxt,eNB_indexP,(uint8_t*)sduP,sdu_lenP);
+    }
     if((srb_idP & RAB_OFFSET) == CCCH) {
       if (sdu_lenP>0) {
         LOG_T(RRC,"[UE %d] Received SDU for CCCH on SRB %d from eNB %d\n",module_idP,srb_idP & RAB_OFFSET,eNB_indexP);

openair2/RRC/LITE/MESSAGES/asn1c/asn1cpatch.p0

@@ -1,13 +0,0 @@
-Index: skeletons/per_opentype.c
-===================================================================
---- skeletons/per_opentype.c	(revision 1516)
-+++ skeletons/per_opentype.c	(working copy)
-@@ -277,7 +306,7 @@
- 	(void)constraints;
- 	(void)sptr;
- 
--	while(per_get_few_bits(pd, 24) >= 0);
-+	while(per_get_few_bits(pd, 1 /*24*/) >= 0);
- 
- 	rv.code = RC_OK;
- 	rv.consumed = pd->moved;

openair2/RRC/LITE/proto.h

@@ -357,6 +357,12 @@ int decode_BCCH_DLSCH_Message(
   const uint8_t                rsrq,
   const uint8_t                rsrp );
 
+int decode_PCCH_DLSCH_Message(
+  const protocol_ctxt_t* const ctxt_pP,
+  const uint8_t                eNB_index,
+  uint8_t*               const Sdu,
+  const uint8_t                Sdu_len);
+
 void
 ue_meas_filtering(
   const protocol_ctxt_t* const ctxt_pP,

openair2/RRC/LITE/rrc_UE.c

@@ -58,6 +58,7 @@
 #include "UL-DCCH-Message.h"
 #include "DL-DCCH-Message.h"
 #include "BCCH-DL-SCH-Message.h"
+#include "PCCH-Message.h"
 #ifdef Rel10
 #include "MCCH-Message.h"
 #endif
@@ -2463,6 +2464,39 @@ int decode_BCCH_DLSCH_Message(
   return 0;
 }
 
+//-----------------------------------------------------------------------------
+int decode_PCCH_DLSCH_Message(
+  const protocol_ctxt_t* const ctxt_pP,
+  const uint8_t                eNB_index,
+  uint8_t*               const Sdu,
+  const uint8_t                Sdu_len)
+{
+  PCCH_Message_t *pcch_message = NULL;
+  int i;
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_PCCH, VCD_FUNCTION_IN );
+
+  asn_dec_rval_t dec_rval = uper_decode_complete( NULL,
+                            &asn_DEF_PCCH_Message,
+                            (void **)&pcch_message,
+                            (const void *)Sdu,
+                            Sdu_len );
+
+  if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
+    LOG_E( RRC, "[UE %"PRIu8"] Failed to decode PCCH_MESSAGE (%zu bits)\n",
+           ctxt_pP->module_id,
+           dec_rval.consumed );
+    for (i=0;i<Sdu_len;i++)
+      printf("%02x ",Sdu[i]);
+    printf("\n");
+    // free the memory
+    SEQUENCE_free( &asn_DEF_PCCH_Message, (void*)pcch_message, 1 );
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_PCCH, VCD_FUNCTION_OUT );
+    return -1;
+  }
+
+  return(0);
+}
 
 //-----------------------------------------------------------------------------
 static int decode_SIB1( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_index, const uint8_t rsrq, const uint8_t rsrp )

openair2/RRC/LITE/rrc_eNB.c

@@ -3470,6 +3470,12 @@ openair_rrc_eNB_init(
         PROTOCOL_RRC_CTXT_FMT" Init...\n",
         PROTOCOL_RRC_CTXT_ARGS(&ctxt));
 
+#if OCP_FRAMEWORK
+while ( eNB_rrc_inst == NULL ) {
+  LOG_E(RRC, "eNB_rrc_inst not yet initialized, waiting 1 second\n");
+  sleep(1);
+}
+#endif 
   AssertFatal(eNB_rrc_inst != NULL, "eNB_rrc_inst not initialized!");
   AssertFatal(NUMBER_OF_UE_MAX < (module_id_t)0xFFFFFFFFFFFFFFFF, " variable overflow");
 

openair2/RRC/LITE/rrc_eNB_S1AP.c

@@ -60,6 +60,8 @@
 #endif
 #include "msc.h"
 
+#include "UERadioAccessCapabilityInformation.h"
+
 #include "gtpv1u_eNB_task.h"
 #include "RRC/LITE/rrc_eNB_GTPV1U.h"
 
@@ -584,29 +586,42 @@ void rrc_eNB_send_S1AP_UE_CAPABILITIES_IND(
 //------------------------------------------------------------------------------
 {
   UECapabilityInformation_t *ueCapabilityInformation = &ul_dcch_msg->message.choice.c1.choice.ueCapabilityInformation;
+  /* 4096 is arbitrary, should be big enough */
+  unsigned char buf[4096];
+  unsigned char *buf2;
+  UERadioAccessCapabilityInformation_t rac;
 
-  if ((ueCapabilityInformation->criticalExtensions.present == UECapabilityInformation__criticalExtensions_PR_c1)
+  if (ueCapabilityInformation->criticalExtensions.present != UECapabilityInformation__criticalExtensions_PR_c1
-      && (ueCapabilityInformation->criticalExtensions.choice.c1.present
+      || ueCapabilityInformation->criticalExtensions.choice.c1.present != UECapabilityInformation__criticalExtensions__c1_PR_ueCapabilityInformation_r8) {
-          == UECapabilityInformation__criticalExtensions__c1_PR_ueCapabilityInformation_r8)
+    LOG_E(RRC, "[eNB %d][UE %x] bad UE capabilities\n", ctxt_pP->module_id, ue_context_pP->ue_context.rnti);
-      && (ueCapabilityInformation->criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list.count > 0)) {
+    return;
-    UE_CapabilityRAT_ContainerList_t* ue_CapabilityRAT_ContainerList =
-      &ueCapabilityInformation->criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList;
-    MessageDef *msg_p;
-
-    msg_p = itti_alloc_new_message (TASK_RRC_ENB, S1AP_UE_CAPABILITIES_IND);
-    S1AP_UE_CAPABILITIES_IND (msg_p).eNB_ue_s1ap_id = ue_context_pP->ue_context.eNB_ue_s1ap_id;
-    S1AP_UE_CAPABILITIES_IND (msg_p).ue_radio_cap.length = ue_CapabilityRAT_ContainerList->list.array[0]->ueCapabilityRAT_Container.size;
-    S1AP_UE_CAPABILITIES_IND (msg_p).ue_radio_cap.buffer = ue_CapabilityRAT_ContainerList->list.array[0]->ueCapabilityRAT_Container.buf;
-
-    itti_send_msg_to_task (TASK_S1AP, ctxt_pP->instance, msg_p);
-
-    if (ue_CapabilityRAT_ContainerList->list.count > 1) {
-      LOG_W (RRC,"[eNB %d][UE %x] can only handle 1 UE capability RAT item for now (%d)\n",
-             ctxt_pP->module_id,
-             ue_context_pP->ue_context.rnti,
-             ue_CapabilityRAT_ContainerList->list.count);
-    }
   }
+
+  asn_enc_rval_t ret = uper_encode_to_buffer(&asn_DEF_UECapabilityInformation, ueCapabilityInformation, buf, 4096);
+  if (ret.encoded == -1) abort();
+
+  memset(&rac, 0, sizeof(UERadioAccessCapabilityInformation_t));
+
+  rac.criticalExtensions.present = UERadioAccessCapabilityInformation__criticalExtensions_PR_c1;
+  rac.criticalExtensions.choice.c1.present = UERadioAccessCapabilityInformation__criticalExtensions__c1_PR_ueRadioAccessCapabilityInformation_r8;
+  rac.criticalExtensions.choice.c1.choice.ueRadioAccessCapabilityInformation_r8.ue_RadioAccessCapabilityInfo.buf = buf;
+  rac.criticalExtensions.choice.c1.choice.ueRadioAccessCapabilityInformation_r8.ue_RadioAccessCapabilityInfo.size = (ret.encoded+7)/8;
+  rac.criticalExtensions.choice.c1.choice.ueRadioAccessCapabilityInformation_r8.nonCriticalExtension = NULL;
+
+  /* 8192 is arbitrary, should be big enough */
+  buf2 = malloc16(8192);
+  if (buf2 == NULL) abort();
+  ret = uper_encode_to_buffer(&asn_DEF_UERadioAccessCapabilityInformation, &rac, buf2, 8192);
+  if (ret.encoded == -1) abort();
+
+  MessageDef *msg_p;
+
+  msg_p = itti_alloc_new_message (TASK_RRC_ENB, S1AP_UE_CAPABILITIES_IND);
+  S1AP_UE_CAPABILITIES_IND (msg_p).eNB_ue_s1ap_id = ue_context_pP->ue_context.eNB_ue_s1ap_id;
+  S1AP_UE_CAPABILITIES_IND (msg_p).ue_radio_cap.length = (ret.encoded+7)/8;
+  S1AP_UE_CAPABILITIES_IND (msg_p).ue_radio_cap.buffer = buf2;
+
+  itti_send_msg_to_task (TASK_S1AP, ctxt_pP->instance, msg_p);
 }
 
 //------------------------------------------------------------------------------

openair2/UTIL/LOG/vcd_signal_dumper.c

@@ -293,6 +293,7 @@ const char* eurecomFunctionsNames[] = {
 
   "macxface_out_of_sync_ind",
   "macxface_ue_decode_si",
+  "macxface_ue_decode_pcch",
   "macxface_ue_decode_ccch",
   "macxface_ue_decode_bcch",
   "macxface_ue_send_sdu",

openair2/UTIL/LOG/vcd_signal_dumper.h

@@ -267,6 +267,7 @@ typedef enum {
 
   VCD_SIGNAL_DUMPER_FUNCTIONS_OUT_OF_SYNC_IND,
   VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_SI,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_PCCH,
   VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH,
   VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_BCCH,
   VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SEND_SDU,

openair2/UTIL/OPT/opt.h

@@ -63,12 +63,16 @@ This header file must be included */
 #include "PHY/impl_defs_lte.h"
 #endif
 
+#ifdef OCP_FRAMEWORK
+#include <enums.h>
+#else
 typedef enum trace_mode_e {
   OPT_WIRESHARK,
   OPT_PCAP,
   OPT_TSHARK,
   OPT_NONE
 } trace_mode_t;
+#endif
 
 typedef enum radio_type_e {
   RADIO_TYPE_FDD = 1,

openair3/NAS/UE/API/USIM/usim_api.c

@@ -77,7 +77,8 @@ Description Implements the API used by the NAS layer to read/write
  * Subscriber authentication security key
  */
 #define USIM_API_K_SIZE         16
-#define USIM_API_K_VALUE        "fec86ba6eb707ed08905757b1bb44b8f"
+//#define USIM_API_K_VALUE        "fec86ba6eb707ed08905757b1bb44b8f"
+#define USIM_API_K_VALUE        "8BAF473F2F8FD09487CCCBD7097C6862"
 
 static uint8_t _usim_api_k[USIM_API_K_SIZE];
 

openair3/S1AP/MESSAGES/ASN1/asn1cpatch_2.p0

@@ -1,22 +0,0 @@
---- skeletons/OCTET_STRING.c.orig	2015-04-28 10:40:04.036970492 +0200
-+++ skeletons/OCTET_STRING.c	2015-04-28 10:40:09.619970869 +0200
-@@ -159,7 +159,7 @@
- }
- 
- static struct _stack *
--_new_stack() {
-+_new_stack(void) {
- 	return (struct _stack *)CALLOC(1, sizeof(struct _stack));
- }
- 
---- skeletons/converter-sample.c.orig	2015-04-28 10:40:32.164972391 +0200
-+++ skeletons/converter-sample.c	2015-04-28 10:40:37.140972727 +0200
-@@ -353,7 +353,7 @@
- } DynamicBuffer;
- 
- static void
--buffer_dump() {
-+buffer_dump(void) {
- 	uint8_t *p = DynamicBuffer.data + DynamicBuffer.offset;
- 	uint8_t *e = p + DynamicBuffer.length - (DynamicBuffer.unbits ? 1 : 0);
- 	if(!opt_debug) return;

openair3/S1AP/s1ap_eNB_nas_procedures.c

@@ -668,6 +668,8 @@ int s1ap_eNB_ue_capabilities(instance_t instance,
     return -1;
   }
 
+  free(ue_cap_info_ind_p->ue_radio_cap.buffer);
+
   MSC_LOG_TX_MESSAGE(
     MSC_S1AP_ENB,
     MSC_S1AP_MME,

targets/ARCH/COMMON/common_lib.h

@@ -72,10 +72,13 @@ typedef enum {
   max_gain=0,med_gain,byp_gain
 } rx_gain_t;
 
+#if OCP_FRAMEWORK
+#include <enums.h>
+#else
 typedef enum {
   duplex_mode_TDD=1,duplex_mode_FDD=0
 } duplex_mode_t;
-
+#endif
 
 
 /** @addtogroup _GENERIC_PHY_RF_INTERFACE_
@@ -83,6 +86,9 @@ typedef enum {
  */
 /*!\brief RF device types
  */
+#ifdef OCP_FRAMEWORK
+#include <enums.h>
+#else
 typedef enum {
   MIN_RF_DEV_TYPE = 0,
   /*!\brief device is ExpressMIMO */
@@ -100,6 +106,7 @@ typedef enum {
   MAX_RF_DEV_TYPE
 
 } dev_type_t;
+#endif
 
 /*!\brief transport protocol types
  */

targets/ARCH/ETHERNET/USERSPACE/LIB/eth_udp.c

@@ -208,7 +208,9 @@ int trx_eth_write_udp_IF4p5(openair0_device *device, openair0_timestamp timestam
   if (flags == IF4p5_PDLFFT) {
     packet_size = UDP_IF4p5_PDLFFT_SIZE_BYTES(nblocks);    
   } else if (flags == IF4p5_PULFFT) {
-    packet_size = UDP_IF4p5_PULFFT_SIZE_BYTES(nblocks);    
+    packet_size = UDP_IF4p5_PULFFT_SIZE_BYTES(nblocks); 
+  } else if (flags == IF4p5_PRACH) {  
+    packet_size = UDP_IF4p5_PRACH_SIZE_BYTES;   
   } else {
     printf("trx_eth_write_udp_IF4p5: unknown flags %d\n",flags);
     return(-1);

targets/ARCH/ETHERNET/USERSPACE/LIB/if_defs.h

@@ -45,11 +45,15 @@
 #include "PHY/LTE_TRANSPORT/if5_tools.h"
 
 // ETH transport preference modes
+#ifdef OCP_FRAMEWORK
+#include "enums.h"
+#else
 #define ETH_UDP_MODE        0
 #define ETH_RAW_MODE        1
 #define ETH_UDP_IF4p5_MODE    2
 #define ETH_RAW_IF4p5_MODE    3
 #define ETH_RAW_IF5_MOBIPASS    4    
+#endif
 
 // Time domain RRH packet sizes
 #define MAC_HEADER_SIZE_BYTES (sizeof(struct ether_header))

targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp

@@ -45,7 +45,8 @@
 #include <complex>
 #include <fstream>
 #include <cmath>
-
+#include <time.h>
+#include "UTIL/LOG/log_extern.h"
 #include "common_lib.h"
 #ifdef __SSE4_1__
 #  include <smmintrin.h>
@@ -172,7 +173,13 @@ static void trx_usrp_end(openair0_device *device)
 */ 
 static int trx_usrp_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags)
 {
-  int ret;
+   static long long int loop=0;
+   static long time_min=0, time_max=0, time_avg=0;
+   struct timespec tp_start, tp_end;
+   long time_diff;
+   clock_gettime(CLOCK_MONOTONIC_RAW, &tp_start);
+
+  int ret=0, ret_i=0;
   usrp_state_t *s = (usrp_state_t*)device->priv;
 
   s->tx_md.time_spec = uhd::time_spec_t::from_ticks(timestamp, s->sample_rate);
@@ -196,7 +203,23 @@ static int trx_usrp_write(openair0_device *device, openair0_timestamp timestamp,
   if (ret != nsamps) {
     printf("[xmit] tx samples %d != %d\n",ret,nsamps);
   }
-      
+
+  clock_gettime(CLOCK_MONOTONIC_RAW, &tp_end);
+  time_diff = (tp_end.tv_sec - tp_start.tv_sec) *1E09  + (tp_end.tv_nsec - tp_start.tv_nsec);
+  if  (time_min==0 ||loop==1 || time_min > time_diff)
+    time_min=time_diff;
+  if  (time_max==0 ||loop==1 || time_max < time_diff)
+    time_max=time_diff;
+  if (time_avg ==0 ||loop==1)
+    time_avg= time_diff;
+  else
+    time_avg=(time_diff+time_avg) /2.0;
+
+   //prints statics of uhd every 10 seconds
+   if ( loop % (10 * ((int)device->openair0_cfg[0].sample_rate /(int)nsamps )) ==0)
+     LOG_I(HW,"usrp_write: min(ns)=%d, max(ns)=%d, avg(ns)=%d\n", (int)time_min, (int)time_max,(int)time_avg);
+
+   loop++;
   return ret;
 }
 
@@ -213,6 +236,11 @@ static int trx_usrp_write(openair0_device *device, openair0_timestamp timestamp,
 */
 static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc)
 {
+   static long long int loop=0;
+   static long time_min=0, time_max=0, time_avg=0;
+   struct timespec tp_start, tp_end;
+   long time_diff;
+   clock_gettime(CLOCK_MONOTONIC_RAW, &tp_start);
    usrp_state_t *s = (usrp_state_t*)device->priv;
    int samples_received=0,i,j;
    int nsamps2;  // aligned to upper 32 or 16 byte boundary
@@ -293,6 +321,22 @@ static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp
   s->rx_timestamp = s->rx_md.time_spec.to_ticks(s->sample_rate);
   *ptimestamp = s->rx_timestamp;
 
+  clock_gettime(CLOCK_MONOTONIC_RAW, &tp_end);
+  time_diff = (tp_end.tv_sec - tp_start.tv_sec) *1E09  + (tp_end.tv_nsec - tp_start.tv_nsec);
+  if  (time_min==0 ||loop==1 || time_min > time_diff)
+    time_min=time_diff;
+  if  (time_max==0 ||loop==1 || time_max < time_diff)
+    time_max=time_diff;
+  if (time_avg ==0 ||loop==1)
+    time_avg= time_diff;
+  else
+    time_avg=(time_diff+time_avg) /2.0;
+
+  //prints statics of uhd every 10 seconds
+  if ( loop % (10 * ((int)device->openair0_cfg[0].sample_rate /(int)nsamps )) ==0)
+     LOG_I(HW,"usrp_read: min(ns)=%d, max(ns)=%d, avg(ns)=%d\n", (int)time_min, (int)time_max,(int)time_avg);
+
+  loop++;
   return samples_received;
 }
 
@@ -500,6 +544,7 @@ extern "C" {
     
     // Initialize USRP device
 
+  device->openair0_cfg = openair0_cfg;
 
   std::string args = "type=b200";
 
@@ -523,6 +568,8 @@ extern "C" {
     // workaround for an api problem, master clock has to be set with the constructor not via set_master_clock_rate
     args += boost::str(boost::format(",master_clock_rate=%f") % usrp_master_clock);
     
+    args += ",num_send_frames=256,num_recv_frames=256, send_frame_size=4096, recv_frame_size=4096";
+    
     uhd::device_addrs_t device_adds = uhd::device::find(args);
 
     if(device_adds.size() == 0)
@@ -554,25 +601,25 @@ extern "C" {
     switch ((int)openair0_cfg[0].sample_rate) {
     case 30720000:
             // from usrp_time_offset
-      openair0_cfg[0].samples_per_packet    = 2048;
+      //openair0_cfg[0].samples_per_packet    = 2048;
       openair0_cfg[0].tx_sample_advance     = 15;
       openair0_cfg[0].tx_bw                 = 20e6;
       openair0_cfg[0].rx_bw                 = 20e6;
       break;
     case 15360000:
-      openair0_cfg[0].samples_per_packet    = 2048;
+      //openair0_cfg[0].samples_per_packet    = 2048;
       openair0_cfg[0].tx_sample_advance     = 45;
       openair0_cfg[0].tx_bw                 = 10e6;
       openair0_cfg[0].rx_bw                 = 10e6;
       break;
     case 7680000:
-      openair0_cfg[0].samples_per_packet    = 1024;
+      //openair0_cfg[0].samples_per_packet    = 2048;
       openair0_cfg[0].tx_sample_advance     = 50;
       openair0_cfg[0].tx_bw                 = 5e6;
       openair0_cfg[0].rx_bw                 = 5e6;
       break;
     case 1920000:
-      openair0_cfg[0].samples_per_packet    = 256;
+      //openair0_cfg[0].samples_per_packet    = 2048;
       openair0_cfg[0].tx_sample_advance     = 50;
       openair0_cfg[0].tx_bw                 = 1.25e6;
       openair0_cfg[0].rx_bw                 = 1.25e6;
@@ -585,7 +632,7 @@ extern "C" {
 
   } else {
     printf("Found USRP B200");
-    args += ",num_recv_frames=256" ; 
+    args += ",num_send_frames=256,num_recv_frames=256, send_frame_size=4096, recv_frame_size=4096" ; 
     s->usrp = uhd::usrp::multi_usrp::make(args);
 
     //  s->usrp->set_rx_subdev_spec(rx_subdev);
@@ -611,30 +658,35 @@ extern "C" {
     switch ((int)openair0_cfg[0].sample_rate) {
     case 30720000:
       s->usrp->set_master_clock_rate(30.72e6);
+      //openair0_cfg[0].samples_per_packet    = 1024;
       openair0_cfg[0].tx_sample_advance     = 115;
       openair0_cfg[0].tx_bw                 = 20e6;
       openair0_cfg[0].rx_bw                 = 20e6;
       break;
     case 23040000:
       s->usrp->set_master_clock_rate(23.04e6); //to be checked
+      //openair0_cfg[0].samples_per_packet    = 1024;
       openair0_cfg[0].tx_sample_advance     = 113;
       openair0_cfg[0].tx_bw                 = 20e6;
       openair0_cfg[0].rx_bw                 = 20e6;
       break;
     case 15360000:
       s->usrp->set_master_clock_rate(30.72e06);
+      //openair0_cfg[0].samples_per_packet    = 1024;
       openair0_cfg[0].tx_sample_advance     = 103; 
       openair0_cfg[0].tx_bw                 = 20e6;
       openair0_cfg[0].rx_bw                 = 20e6;
       break;
     case 7680000:
       s->usrp->set_master_clock_rate(30.72e6);
+      //openair0_cfg[0].samples_per_packet    = 1024;
       openair0_cfg[0].tx_sample_advance     = 80;
       openair0_cfg[0].tx_bw                 = 20e6;
       openair0_cfg[0].rx_bw                 = 20e6;
       break;
     case 1920000:
       s->usrp->set_master_clock_rate(30.72e6);
+      //openair0_cfg[0].samples_per_packet    = 1024;
       openair0_cfg[0].tx_sample_advance     = 40;
       openair0_cfg[0].tx_bw                 = 20e6;
       openair0_cfg[0].rx_bw                 = 20e6;
@@ -758,7 +810,8 @@ extern "C" {
   device->trx_stop_func  = trx_usrp_stop;
   device->trx_set_freq_func = trx_usrp_set_freq;
   device->trx_set_gains_func   = trx_usrp_set_gains;
-  
+  device->openair0_cfg = openair0_cfg;
+
   s->sample_rate = openair0_cfg[0].sample_rate;
   // TODO:
   // init tx_forward_nsamps based usrp_time_offset ex

targets/PROJECTS/GENERIC-LTE-EPC/CONF/enb.band7.generic.oaisim.local_no_mme.conf

@@ -24,7 +24,7 @@ eNBs =
     component_carriers = (
       {
         node_function                                         = "eNodeB_3GPP";
-	node_timing                                           = "synch_to_other";
+	node_timing                                           = "synch_to_ext_device";
 	node_synch_ref                                        = 0; 
         frame_type					      = "FDD";
         tdd_config 					      = 3;

targets/PROJECTS/GENERIC-LTE-EPC/CONF/rcc.band7.tm1.100PRB.if4p5.conf

@@ -0,0 +1,191 @@
+Active_eNBs = ( "eNB_Eurecom_LTEBox");
+# Asn1_verbosity, choice in: none, info, annoying
+Asn1_verbosity = "none";
+
+eNBs =
+(
+ {
+    ////////// Identification parameters:
+    eNB_ID    =  0xe00;
+
+    cell_type =  "CELL_MACRO_ENB";
+
+    eNB_name  =  "eNB_Eurecom_LTEBox";
+
+    // Tracking area code, 0x0000 and 0xfffe are reserved values
+    tracking_area_code  =  "1";
+
+    mobile_country_code =  "208";
+
+    mobile_network_code =  "93";
+
+       ////////// Physical parameters:
+
+    component_carriers = (
+      {
+      node_function             = "NGFI_RCC_IF4p5";
+      node_timing               = "synch_to_ext_device";
+      node_synch_ref            = 0;
+      frame_type					      = "FDD";
+      tdd_config 					      = 3;
+      tdd_config_s            			      = 0;
+      prefix_type             			      = "NORMAL";
+      eutra_band              			      = 7;
+      downlink_frequency      			      = 2660000000L;
+      uplink_frequency_offset 			      = -120000000;
+      Nid_cell					      = 0;
+      N_RB_DL                 			      = 100;
+      Nid_cell_mbsfn          			      = 0;
+      nb_antennas_tx          			      = 1;
+      nb_antennas_rx          			      = 1;
+      tx_gain                                            = 90;
+      rx_gain                                            = 125;
+      prach_root              			      = 0;
+      prach_config_index      			      = 0;
+      prach_high_speed        			      = "DISABLE";
+      prach_zero_correlation  			      = 1;
+      prach_freq_offset       			      = 2;
+      pucch_delta_shift       			      = 1;
+      pucch_nRB_CQI           			      = 1;
+      pucch_nCS_AN            			      = 0;
+      pucch_n1_AN             			      = 32;
+      pdsch_referenceSignalPower 			      = -29;
+      pdsch_p_b                  			      = 0;
+      pusch_n_SB                 			      = 1;
+      pusch_enable64QAM          			      = "DISABLE";
+      pusch_hoppingMode                                  = "interSubFrame";
+      pusch_hoppingOffset                                = 0;
+      pusch_groupHoppingEnabled  			      = "ENABLE";
+      pusch_groupAssignment      			      = 0;
+      pusch_sequenceHoppingEnabled		   	      = "DISABLE";
+      pusch_nDMRS1                                       = 1;
+      phich_duration                                     = "NORMAL";
+      phich_resource                                     = "ONESIXTH";
+      srs_enable                                         = "DISABLE";
+      /*  srs_BandwidthConfig                                =;
+      srs_SubframeConfig                                 =;
+      srs_ackNackST                                      =;
+      srs_MaxUpPts                                       =;*/
+
+      pusch_p0_Nominal                                   = -90;
+      pusch_alpha                                        = "AL1";
+      pucch_p0_Nominal                                   = -96;
+      msg3_delta_Preamble                                = 6;
+      pucch_deltaF_Format1                               = "deltaF2";
+      pucch_deltaF_Format1b                              = "deltaF3";
+      pucch_deltaF_Format2                               = "deltaF0";
+      pucch_deltaF_Format2a                              = "deltaF0";
+      pucch_deltaF_Format2b		    	      = "deltaF0";
+
+      rach_numberOfRA_Preambles                          = 64;
+      rach_preamblesGroupAConfig                         = "DISABLE";
+      /*
+      rach_sizeOfRA_PreamblesGroupA                      = ;
+      rach_messageSizeGroupA                             = ;
+      rach_messagePowerOffsetGroupB                      = ;
+      */
+      rach_powerRampingStep                              = 4;
+      rach_preambleInitialReceivedTargetPower            = -108;
+      rach_preambleTransMax                              = 10;
+      rach_raResponseWindowSize                          = 10;
+      rach_macContentionResolutionTimer                  = 48;
+      rach_maxHARQ_Msg3Tx                                = 4;
+
+      pcch_default_PagingCycle                           = 128;
+      pcch_nB                                            = "oneT";
+      bcch_modificationPeriodCoeff			      = 2;
+      ue_TimersAndConstants_t300			      = 1000;
+      ue_TimersAndConstants_t301			      = 1000;
+      ue_TimersAndConstants_t310			      = 1000;
+      ue_TimersAndConstants_t311			      = 10000;
+      ue_TimersAndConstants_n310			      = 20;
+      ue_TimersAndConstants_n311			      = 1;
+
+      }
+    );
+
+
+    srb1_parameters :
+    {
+        # timer_poll_retransmit = (ms) [5, 10, 15, 20,... 250, 300, 350, ... 500]
+        timer_poll_retransmit    = 80;
+
+        # timer_reordering = (ms) [0,5, ... 100, 110, 120, ... ,200]
+        timer_reordering         = 35;
+
+        # timer_reordering = (ms) [0,5, ... 250, 300, 350, ... ,500]
+        timer_status_prohibit    = 0;
+
+        # poll_pdu = [4, 8, 16, 32 , 64, 128, 256, infinity(>10000)]
+        poll_pdu                 =  4;
+
+        # poll_byte = (kB) [25,50,75,100,125,250,375,500,750,1000,1250,1500,2000,3000,infinity(>10000)]
+        poll_byte                =  99999;
+
+        # max_retx_threshold = [1, 2, 3, 4 , 6, 8, 16, 32]
+        max_retx_threshold       =  4;
+    }
+
+    # ------- SCTP definitions
+    SCTP :
+    {
+        # Number of streams to use in input/output
+        SCTP_INSTREAMS  = 2;
+        SCTP_OUTSTREAMS = 2;
+    };
+
+
+    ////////// MME parameters:
+    mme_ip_address      = ( { ipv4       = "127.0.0.3";
+                              ipv6       = "192:168:30::17";
+                              active     = "yes";
+                              preference = "ipv4";
+                            }
+                          );
+
+    NETWORK_INTERFACES :
+    {
+
+        ENB_INTERFACE_NAME_FOR_S1_MME            = "lo";
+        ENB_IPV4_ADDRESS_FOR_S1_MME              = "127.0.0.2/24";
+        ENB_INTERFACE_NAME_FOR_S1U               = "lo";
+        ENB_IPV4_ADDRESS_FOR_S1U                 = "127.0.0.4/24";
+        ENB_PORT_FOR_S1U                         = 2152; # Spec 2152
+    };
+
+    rrh_gw_config = (
+    {			  
+      	local_if_name = "eth0";			  
+   	remote_address = "74:d4:35:cc:8d:15";
+    	local_address = "34:e6:d7:3c:ae:fc";    
+    	local_port = 50000;	#for raw option local port must be the same to remote	       
+    	remote_port = 50000; 
+    	rrh_gw_active = "yes";
+    	tr_preference = "raw_if4p5";
+    	rf_preference = "usrp_b200";
+    	iq_txshift = 4;
+    	tx_sample_advance = 80;	
+    	tx_scheduling_advance = 9; 	                
+    }
+    );  
+
+    log_config :
+    {
+      global_log_level                      ="info";
+      global_log_verbosity                  ="medium";
+      hw_log_level                          ="info";
+      hw_log_verbosity                      ="medium";
+      phy_log_level                         ="info";
+      phy_log_verbosity                     ="medium";
+      mac_log_level                         ="info";
+      mac_log_verbosity                     ="high";
+      rlc_log_level                         ="info";
+      rlc_log_verbosity                     ="medium";
+      pdcp_log_level                        ="info";
+      pdcp_log_verbosity                    ="medium";
+      rrc_log_level                         ="info";
+      rrc_log_verbosity                     ="medium";
+   };
+  }
+);
+

targets/PROJECTS/GENERIC-LTE-EPC/CONF/rcc.band7.tm1.50PRB.if4p5.conf

@@ -0,0 +1,191 @@
+Active_eNBs = ( "eNB_Eurecom_LTEBox");
+# Asn1_verbosity, choice in: none, info, annoying
+Asn1_verbosity = "none";
+
+eNBs =
+(
+ {
+    ////////// Identification parameters:
+    eNB_ID    =  0xe00;
+
+    cell_type =  "CELL_MACRO_ENB";
+
+    eNB_name  =  "eNB_Eurecom_LTEBox";
+
+    // Tracking area code, 0x0000 and 0xfffe are reserved values
+    tracking_area_code  =  "1";
+
+    mobile_country_code =  "208";
+
+    mobile_network_code =  "93";
+
+       ////////// Physical parameters:
+
+    component_carriers = (
+      {
+      node_function             = "NGFI_RCC_IF4p5";
+      node_timing               = "synch_to_ext_device";
+      node_synch_ref            = 0;
+      frame_type					      = "FDD";
+      tdd_config 					      = 3;
+      tdd_config_s            			      = 0;
+      prefix_type             			      = "NORMAL";
+      eutra_band              			      = 7;
+      downlink_frequency      			      = 2660000000L;
+      uplink_frequency_offset 			      = -120000000;
+      Nid_cell					      = 0;
+      N_RB_DL                 			      = 50;
+      Nid_cell_mbsfn          			      = 0;
+      nb_antennas_tx          			      = 1;
+      nb_antennas_rx          			      = 1;
+      tx_gain                                            = 90;
+      rx_gain                                            = 125;
+      prach_root              			      = 0;
+      prach_config_index      			      = 0;
+      prach_high_speed        			      = "DISABLE";
+      prach_zero_correlation  			      = 1;
+      prach_freq_offset       			      = 2;
+      pucch_delta_shift       			      = 1;
+      pucch_nRB_CQI           			      = 1;
+      pucch_nCS_AN            			      = 0;
+      pucch_n1_AN             			      = 32;
+      pdsch_referenceSignalPower 			      = -29;
+      pdsch_p_b                  			      = 0;
+      pusch_n_SB                 			      = 1;
+      pusch_enable64QAM          			      = "DISABLE";
+      pusch_hoppingMode                                  = "interSubFrame";
+      pusch_hoppingOffset                                = 0;
+      pusch_groupHoppingEnabled  			      = "ENABLE";
+      pusch_groupAssignment      			      = 0;
+      pusch_sequenceHoppingEnabled		   	      = "DISABLE";
+      pusch_nDMRS1                                       = 1;
+      phich_duration                                     = "NORMAL";
+      phich_resource                                     = "ONESIXTH";
+      srs_enable                                         = "DISABLE";
+      /*  srs_BandwidthConfig                                =;
+      srs_SubframeConfig                                 =;
+      srs_ackNackST                                      =;
+      srs_MaxUpPts                                       =;*/
+
+      pusch_p0_Nominal                                   = -90;
+      pusch_alpha                                        = "AL1";
+      pucch_p0_Nominal                                   = -96;
+      msg3_delta_Preamble                                = 6;
+      pucch_deltaF_Format1                               = "deltaF2";
+      pucch_deltaF_Format1b                              = "deltaF3";
+      pucch_deltaF_Format2                               = "deltaF0";
+      pucch_deltaF_Format2a                              = "deltaF0";
+      pucch_deltaF_Format2b		    	      = "deltaF0";
+
+      rach_numberOfRA_Preambles                          = 64;
+      rach_preamblesGroupAConfig                         = "DISABLE";
+      /*
+      rach_sizeOfRA_PreamblesGroupA                      = ;
+      rach_messageSizeGroupA                             = ;
+      rach_messagePowerOffsetGroupB                      = ;
+      */
+      rach_powerRampingStep                              = 4;
+      rach_preambleInitialReceivedTargetPower            = -108;
+      rach_preambleTransMax                              = 10;
+      rach_raResponseWindowSize                          = 10;
+      rach_macContentionResolutionTimer                  = 48;
+      rach_maxHARQ_Msg3Tx                                = 4;
+
+      pcch_default_PagingCycle                           = 128;
+      pcch_nB                                            = "oneT";
+      bcch_modificationPeriodCoeff			      = 2;
+      ue_TimersAndConstants_t300			      = 1000;
+      ue_TimersAndConstants_t301			      = 1000;
+      ue_TimersAndConstants_t310			      = 1000;
+      ue_TimersAndConstants_t311			      = 10000;
+      ue_TimersAndConstants_n310			      = 20;
+      ue_TimersAndConstants_n311			      = 1;
+
+      }
+    );
+
+
+    srb1_parameters :
+    {
+        # timer_poll_retransmit = (ms) [5, 10, 15, 20,... 250, 300, 350, ... 500]
+        timer_poll_retransmit    = 80;
+
+        # timer_reordering = (ms) [0,5, ... 100, 110, 120, ... ,200]
+        timer_reordering         = 35;
+
+        # timer_reordering = (ms) [0,5, ... 250, 300, 350, ... ,500]
+        timer_status_prohibit    = 0;
+
+        # poll_pdu = [4, 8, 16, 32 , 64, 128, 256, infinity(>10000)]
+        poll_pdu                 =  4;
+
+        # poll_byte = (kB) [25,50,75,100,125,250,375,500,750,1000,1250,1500,2000,3000,infinity(>10000)]
+        poll_byte                =  99999;
+
+        # max_retx_threshold = [1, 2, 3, 4 , 6, 8, 16, 32]
+        max_retx_threshold       =  4;
+    }
+
+    # ------- SCTP definitions
+    SCTP :
+    {
+        # Number of streams to use in input/output
+        SCTP_INSTREAMS  = 2;
+        SCTP_OUTSTREAMS = 2;
+    };
+
+
+    ////////// MME parameters:
+    mme_ip_address      = ( { ipv4       = "127.0.0.3";
+                              ipv6       = "192:168:30::17";
+                              active     = "yes";
+                              preference = "ipv4";
+                            }
+                          );
+
+    NETWORK_INTERFACES :
+    {
+
+        ENB_INTERFACE_NAME_FOR_S1_MME            = "lo";
+        ENB_IPV4_ADDRESS_FOR_S1_MME              = "127.0.0.2/24";
+        ENB_INTERFACE_NAME_FOR_S1U               = "lo";
+        ENB_IPV4_ADDRESS_FOR_S1U                 = "127.0.0.4/24";
+        ENB_PORT_FOR_S1U                         = 2152; # Spec 2152
+    };
+
+    rrh_gw_config = (
+    {			  
+      	local_if_name = "eth0";			  
+   	remote_address = "74:d4:35:cc:8d:15";
+    	local_address = "34:e6:d7:3c:ae:fc";    
+    	local_port = 50000;	#for raw option local port must be the same to remote	       
+    	remote_port = 50000; 
+    	rrh_gw_active = "yes";
+    	tr_preference = "raw_if4p5";
+    	rf_preference = "usrp_b200";
+    	iq_txshift = 4;
+    	tx_sample_advance = 80;	
+    	tx_scheduling_advance = 9; 	                
+    }
+    );  
+
+    log_config :
+    {
+      global_log_level                      ="info";
+      global_log_verbosity                  ="medium";
+      hw_log_level                          ="info";
+      hw_log_verbosity                      ="medium";
+      phy_log_level                         ="info";
+      phy_log_verbosity                     ="medium";
+      mac_log_level                         ="info";
+      mac_log_verbosity                     ="high";
+      rlc_log_level                         ="info";
+      rlc_log_verbosity                     ="medium";
+      pdcp_log_level                        ="info";
+      pdcp_log_verbosity                    ="medium";
+      rrc_log_level                         ="info";
+      rrc_log_verbosity                     ="medium";
+   };
+  }
+);
+

targets/RT/USER/lte-enb.c

@@ -190,10 +190,10 @@ static inline void thread_top_init(char *thread_name,
 
   if (sched_setattr(0, &attr, flags) < 0 ) {
     perror("[SCHED] eNB tx thread: sched_setattr failed\n");
-    exit(1);
+    exit_fun("Error setting deadline scheduler");
   }
 
-  LOG_I( HW, "[SCHED] eNB RXn-TXnp4 deadline thread (TID %ld) started on CPU %d\n", gettid(), sched_getcpu() );
+  LOG_I( HW, "[SCHED] eNB %s deadline thread (TID %ld) started on CPU %d\n", gettid(), thread_name,sched_getcpu() );
 
 #else //LOW_LATENCY
   int policy, s, j;
@@ -657,7 +657,7 @@ static void* eNB_thread_rxtx( void* param ) {
   return &eNB_thread_rxtx_status;
 }
 
-#if defined(ENABLE_ITTI)
+#if defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
 /* Wait for eNB application initialization to be complete (eNB registration to MME) */
 static void wait_system_ready (char *message, volatile int *start_flag) {
   
@@ -1036,7 +1036,7 @@ void rx_fh_if4p5(PHY_VARS_eNB *eNB,int *frame,int *subframe) {
 
 void rx_fh_slave(PHY_VARS_eNB *eNB,int *frame,int *subframe) {
   // This case is for synchronization to another thread
-  // it just waits for an external event.  The actual rx_rh is handle by the asynchronous RX thread
+  // it just waits for an external event.  The actual rx_fh is handle by the asynchronous RX thread
   eNB_proc_t *proc=&eNB->proc;
 
   if (wait_on_condition(&proc->mutex_FH,&proc->cond_FH,&proc->instance_cnt_FH,"rx_fh_slave") < 0)
@@ -1080,8 +1080,8 @@ int wakeup_rxtx(eNB_proc_t *proc,eNB_rxtx_proc_t *proc_rxtx,LTE_DL_FRAME_PARMS *
   // TS_rx is the last received timestamp (start of 1st slot), TS_tx is the desired 
   // transmitted timestamp of the next TX slot (first).
   // The last (TS_rx mod samples_per_frame) was n*samples_per_tti, 
-  // we want to generate subframe (n+3), so TS_tx = TX_rx+3*samples_per_tti,
+  // we want to generate subframe (n+4), so TS_tx = TX_rx+4*samples_per_tti,
-  // and proc->subframe_tx = proc->subframe_rx+3
+  // and proc->subframe_tx = proc->subframe_rx+4
   proc_rxtx->timestamp_tx = proc->timestamp_rx + (4*fp->samples_per_tti);
   proc_rxtx->frame_rx     = proc->frame_rx;
   proc_rxtx->subframe_rx  = proc->subframe_rx;
@@ -1133,7 +1133,7 @@ void wakeup_slaves(eNB_proc_t *proc) {
 	  break;
       }
     } else {
-      LOG_W( PHY,"[eNB] Frame %d, FH CC_id %d thread busy!! (cnt_FH %i)\n",slave_proc->frame_rx,slave_proc->CC_id, cnt_slave);
+      LOG_W( PHY,"[eNB] Frame %d, slave CC_id %d thread busy!! (cnt_FH %i)\n",slave_proc->frame_rx,slave_proc->CC_id, cnt_slave);
       exit_fun( "FH thread busy" );
       break;
     }             
@@ -1165,7 +1165,7 @@ static void* eNB_thread_FH( void* param ) {
 
   wait_sync("eNB_thread_FH");
 
-#if defined(ENABLE_ITTI)
+#if defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
   if (eNB->node_function < NGFI_RRU_IF5)
     wait_system_ready ("Waiting for eNB application to be ready %s\r", &start_eNB);
 #endif 
@@ -1277,7 +1277,7 @@ static void* eNB_thread_single( void* param ) {
 
   wait_sync("eNB_thread_single");
 
-#if defined(ENABLE_ITTI)
+#if defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
   if (eNB->node_function < NGFI_RRU_IF5)
     wait_system_ready ("Waiting for eNB application to be ready %s\r", &start_eNB);
 #endif 
@@ -1311,6 +1311,7 @@ static void* eNB_thread_single( void* param ) {
       subframe++;
     }      
 
+    LOG_D(PHY,"eNB Fronthaul thread, frame %d, subframe %d\n",frame,subframe);
  
     // synchronization on FH interface, acquire signals/data and block
     if (eNB->rx_fh) eNB->rx_fh(eNB,&frame,&subframe);
@@ -1318,6 +1319,7 @@ static void* eNB_thread_single( void* param ) {
 
     T(T_ENB_MASTER_TICK, T_INT(0), T_INT(proc->frame_rx), T_INT(proc->subframe_rx));
 
+
     // At this point, all information for subframe has been received on FH interface
     // If this proc is to provide synchronization, do so
     wakeup_slaves(proc);
@@ -1552,17 +1554,17 @@ int setup_eNB_buffers(PHY_VARS_eNB **phy_vars_eNB, openair0_config_t *openair0_c
       
       for (i=0; i<frame_parms->nb_antennas_rx; i++) {
 	free(phy_vars_eNB[CC_id]->common_vars.rxdata[0][i]);
-	rxdata[i] = (int32_t*)(32 + malloc16(32+openair0_cfg[phy_vars_eNB[CC_id]->rf_map.card].samples_per_frame*sizeof(int32_t))); // FIXME broken memory allocation
+	rxdata[i] = (int32_t*)(32 + malloc16(32+frame_parms->samples_per_tti*10*sizeof(int32_t))); // FIXME broken memory allocation
 	phy_vars_eNB[CC_id]->common_vars.rxdata[0][i] = rxdata[i]-N_TA_offset; // N_TA offset for TDD         FIXME! N_TA_offset > 16 => access of unallocated memory
-	memset(rxdata[i], 0, openair0_cfg[phy_vars_eNB[CC_id]->rf_map.card].samples_per_frame*sizeof(int32_t));
+	memset(rxdata[i], 0, frame_parms->samples_per_tti*10*sizeof(int32_t));
 	printf("rxdata[%d] @ %p (%p) (N_TA_OFFSET %d)\n", i, phy_vars_eNB[CC_id]->common_vars.rxdata[0][i],rxdata[i],N_TA_offset);      
       }
       
       for (i=0; i<frame_parms->nb_antennas_tx; i++) {
 	free(phy_vars_eNB[CC_id]->common_vars.txdata[0][i]);
-	txdata[i] = (int32_t*)(32 + malloc16(32 + openair0_cfg[phy_vars_eNB[CC_id]->rf_map.card].samples_per_frame*sizeof(int32_t))); // FIXME broken memory allocation
+	txdata[i] = (int32_t*)(32 + malloc16(32 + frame_parms->samples_per_tti*10*sizeof(int32_t))); // FIXME broken memory allocation
 	phy_vars_eNB[CC_id]->common_vars.txdata[0][i] = txdata[i];
-	memset(txdata[i],0, openair0_cfg[phy_vars_eNB[CC_id]->rf_map.card].samples_per_frame*sizeof(int32_t));
+	memset(txdata[i],0, frame_parms->samples_per_tti*10*sizeof(int32_t));
 	printf("txdata[%d] @ %p\n", i, phy_vars_eNB[CC_id]->common_vars.txdata[0][i]);
       }
     }

targets/RT/USER/lte-softmodem.c

@@ -382,7 +382,8 @@ void help (void) {
   printf("  --ue-txgain set UE TX gain\n");
   printf("  --ue-scan_carrier set UE to scan around carrier\n");
   printf("  --loop-memory get softmodem (UE) to loop through memory instead of acquiring from HW\n");
-  printf("  --mmapped-dma sets flag for improved EXMIMO UE performance\n");   
+  printf("  --mmapped-dma sets flag for improved EXMIMO UE performance\n");  
+  printf("  --single-thread runs lte-softmodem in only one thread\n"); 
   printf("  -C Set the downlink frequency for all component carriers\n");
   printf("  -d Enable soft scope and L1 and L2 stats (Xforms)\n");
   printf("  -F Calibrate the EXMIMO borad, available files: exmimo2_2arxg.lime exmimo2_2brxg.lime \n");
@@ -401,6 +402,7 @@ void help (void) {
   printf("  -W Enable L2 wireshark messages on localhost \n");
   printf("  -V Enable VCD (generated file will be located atopenair_dump_eNB.vcd, read it with target/RT/USER/eNB.gtkw\n");
   printf("  -x Set the transmission mode, valid options: 1 \n");
+  printf("  -E Apply three-quarter of sampling frequency, 23.04 Msps to reduce the data rate on USB/PCIe transfers (only valid for 20 MHz)\n");
 #if T_TRACER
   printf("  --T_port [port]    use given port\n");
   printf("  --T_nowait         don't wait for tracer, start immediately\n");

targets/RT/USER/lte-ue.c

@@ -793,6 +793,16 @@ static void *UE_thread_rxn_txnp4(void *arg)
 	UE->UE_mode[0] = PRACH;
       }
     }
+
+    if ((subframe_select( &UE->frame_parms, proc->subframe_tx) == SF_UL) ||
+	(UE->frame_parms.frame_type == FDD) ||
+	(subframe_select( &UE->frame_parms, proc->subframe_tx ) == SF_S)) {
+
+      if (UE->mode != loop_through_memory) {
+	phy_procedures_UE_TX(UE,proc,0,0,normal_txrx,no_relay);
+      }
+    }
+
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_RXTX0+(proc->subframe_rx&1), 0 );
 
     
@@ -967,15 +977,18 @@ void *UE_thread(void *arg) {
       if (start_rx_stream==0) {
 	start_rx_stream=1;
 	if (UE->mode != loop_through_memory) {
-	  LOG_I(PHY,"Resynchronizing RX by %d samples\n",UE->rx_offset);
+
-	  rxs = UE->rfdevice.trx_read_func(&UE->rfdevice,
+	  if (UE->no_timing_correction==0) {
-					   &timestamp,
+	    LOG_I(PHY,"Resynchronizing RX by %d samples\n",UE->rx_offset);
-					   (void**)rxdata,
+	    rxs = UE->rfdevice.trx_read_func(&UE->rfdevice,
-					   UE->rx_offset,
+					     &timestamp,
-					   UE->frame_parms.nb_antennas_rx);
+					     (void**)rxdata,
-	  if (rxs != UE->rx_offset) {
+					     UE->rx_offset,
-	    exit_fun("problem in rx");
+					     UE->frame_parms.nb_antennas_rx);
-	    return &UE_thread_retval;
+	    if (rxs != UE->rx_offset) {
+	      exit_fun("problem in rx");
+	      return &UE_thread_retval;
+	    }
 	  }
 	  UE->rx_offset=0;
 	  UE->proc.proc_rxtx[0].frame_rx++;
@@ -1049,10 +1062,15 @@ void *UE_thread(void *arg) {
 	  int instance_cnt_rxtx = ++proc->instance_cnt_rxtx;
 	  proc->subframe_rx=sf;
 	  proc->subframe_tx=(sf+4)%10;
-	  proc->frame_tx = proc->frame_rx + (proc->subframe_rx>5)?1:0;
+	  proc->frame_tx = proc->frame_rx + ((proc->subframe_rx>5)?1:0);
 	  proc->timestamp_tx = timestamp+(4*UE->frame_parms.samples_per_tti)-UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0;
 
 
+	  if (sf != (timestamp/UE->frame_parms.samples_per_tti)%10) {
+	    LOG_E(PHY,"steady-state UE_thread error : frame_rx %d, subframe_rx %d, frame_tx %d, subframe_tx %d, rx subframe %d\n",proc->frame_rx,proc->subframe_rx,proc->frame_tx,proc->subframe_tx,(timestamp/UE->frame_parms.samples_per_tti)%10);
+	    exit(-1);
+	  }
+
 	  if (pthread_mutex_unlock(&proc->mutex_rxtx) != 0) {
 	    LOG_E( PHY, "[SCHED][UE] error unlocking mutex for UE RX\n" );
 	    exit_fun("nothing to add");

targets/SIMU/USER/channel_sim.c

@@ -437,9 +437,14 @@ void do_UL_sig(channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB_MAX][MAX_N
       txdata = PHY_vars_UE_g[UE_id][CC_id]->common_vars.txdata;
       sf_offset = subframe*frame_parms->samples_per_tti;
       
-      if (((double)PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm +
+      if (((double)PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe] +
 	   UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB) <= -125.0) {
 	// don't simulate a UE that is too weak
+	LOG_D(OCM,"[SIM][UL] UE %d tx_pwr %d dBm (num_RE %d) for subframe %d (sf_offset %d)\n",
+	      UE_id,
+	      PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe],
+	      PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE[subframe],
+	      subframe,sf_offset);	
       } else {
 	
 	tx_pwr = dac_fixed_gain((double**)s_re,
@@ -451,13 +456,13 @@ void do_UL_sig(channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB_MAX][MAX_N
 				sf_offset,
 				frame_parms->ofdm_symbol_size,
 				14,
-				(double)PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm-10*log10((double)PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE),
+				(double)PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe]-10*log10((double)PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE[subframe]),
-				PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE);  // This make the previous argument the total power
+				PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE[subframe]);  // This make the previous argument the total power
 	LOG_D(OCM,"[SIM][UL] UE %d tx_pwr %f dBm (target %d dBm, num_RE %d) for subframe %d (sf_offset %d)\n",
 	      UE_id,
 	      10*log10(tx_pwr),
-	      PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm,
+	      PHY_vars_UE_g[UE_id][CC_id]->tx_power_dBm[subframe],
-	      PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE,
+	      PHY_vars_UE_g[UE_id][CC_id]->tx_total_RE[subframe],
 	      subframe,sf_offset);
        
 	

targets/SIMU/USER/oaisim.c

@@ -139,8 +139,10 @@ node_desc_t *ue_data[NUMBER_OF_UE_MAX];
 
 pthread_cond_t sync_cond;
 pthread_mutex_t sync_mutex;
-int sync_var;
+int sync_var=-1;
 
+pthread_mutex_t subframe_mutex;
+int subframe_eNB_mask=0,subframe_UE_mask=0;
 
 openair0_config_t openair0_cfg[MAX_CARDS];
 uint32_t          downlink_frequency[MAX_NUM_CCs][4];
@@ -451,6 +453,10 @@ typedef enum l2l1_task_state_e {
 
 l2l1_task_state_t l2l1_state = L2L1_WAITTING;
 
+extern openair0_timestamp current_eNB_rx_timestamp[NUMBER_OF_eNB_MAX][MAX_NUM_CCs];
+extern openair0_timestamp current_UE_rx_timestamp[NUMBER_OF_UE_MAX][MAX_NUM_CCs];
+
+
 /*------------------------------------------------------------------------------*/
 void *
 l2l1_task (void *args_p)
@@ -719,6 +725,40 @@ l2l1_task (void *args_p)
 
 	clear_eNB_transport_info (oai_emulation.info.nb_enb_local);
 
+        CC_id=0;
+        int all_done=0;
+        while (all_done==0) {
+          pthread_mutex_lock(&subframe_mutex);
+          int subframe_eNB_mask_local = subframe_eNB_mask;
+          int subframe_UE_mask_local  = subframe_UE_mask;
+          pthread_mutex_unlock(&subframe_mutex);
+          LOG_D(EMU,"Frame %d, Subframe %d: Checking masks %x,%x\n",frame,sf,subframe_eNB_mask,subframe_UE_mask);
+          if ((subframe_eNB_mask_local == ((1<<NB_eNB_INST)-1)) &&
+              (subframe_UE_mask_local == ((1<<NB_UE_INST)-1)))
+             all_done=1;
+          else
+             usleep(500);
+        }
+
+        //clear subframe masks for next round
+        pthread_mutex_lock(&subframe_mutex);
+        subframe_eNB_mask=0;
+        subframe_UE_mask=0;
+        pthread_mutex_unlock(&subframe_mutex);
+
+        // increment timestamps
+        for (eNB_inst = oai_emulation.info.first_enb_local;
+             (eNB_inst
+              < (oai_emulation.info.first_enb_local
+                 + oai_emulation.info.nb_enb_local));
+             eNB_inst++) {
+             current_eNB_rx_timestamp[eNB_inst][CC_id] += PHY_vars_eNB_g[eNB_inst][CC_id]->frame_parms.samples_per_tti;
+        }
+        for (UE_inst = 0; UE_inst<NB_UE_INST;UE_inst++) {
+             current_UE_rx_timestamp[UE_inst][CC_id] += PHY_vars_UE_g[UE_inst][CC_id]->frame_parms.samples_per_tti;
+        }
+
+
         for (eNB_inst = oai_emulation.info.first_enb_local;
              (eNB_inst
               < (oai_emulation.info.first_enb_local
@@ -727,6 +767,7 @@ l2l1_task (void *args_p)
           if (oai_emulation.info.cli_start_enb[eNB_inst] != 0) {
         
 	    T(T_ENB_MASTER_TICK, T_INT(eNB_inst), T_INT(frame % 1024), T_INT(sf));
+	    /*
 	    LOG_D(EMU,
 		  "PHY procedures eNB %d for frame %d, subframe %d TDD %d/%d Nid_cell %d\n",
 		  eNB_inst,
@@ -736,7 +777,7 @@ l2l1_task (void *args_p)
 		  PHY_vars_eNB_g[eNB_inst][0]->frame_parms.tdd_config,
 		  PHY_vars_eNB_g[eNB_inst][0]->frame_parms.Nid_cell);
             
-
+	    */
 #ifdef OPENAIR2
 	    //Application: traffic gen
             update_otg_eNB (eNB_inst, oai_emulation.info.time_ms);
@@ -744,35 +785,8 @@ l2l1_task (void *args_p)
             //IP/OTG to PDCP and PDCP to IP operation
             //        pdcp_run (frame, 1, 0, eNB_inst); //PHY_vars_eNB_g[eNB_id]->Mod_id
 #endif
+           
 
-	    CC_id=0;
-	    // trigger synch event to RAN FH thread for CC_id
-	    eNB_proc_t *proc =  &PHY_vars_eNB_g[eNB_inst][CC_id]->proc;
-
-
-	    if (pthread_mutex_lock(&proc->mutex_FH) != 0) {
-	      LOG_E( PHY, "error locking mutex for FH\n");
-	      exit_fun( "error locking mutex" );
-	      break;
-	    }	    
-	    int cnt_FH       = ++proc->instance_cnt_FH;
-	    proc->frame_rx    = frame;
-            proc->subframe_rx = sf;
-	    proc->timestamp_rx += PHY_vars_eNB_g[eNB_inst][CC_id]->frame_parms.samples_per_tti;
-	    pthread_mutex_unlock( &proc->mutex_FH );
-
-	    if (cnt_FH == 0) {
-	      if (pthread_cond_signal(&proc->cond_FH) != 0) {
-		LOG_E(PHY,"ERROR pthread_cond_signal for eNB FH CCid %d\n",proc->CC_id);
-		exit_fun("ERROR pthread_cond_signal");
-		break;
-	      }
-	    }
-	    else {
-	      LOG_W(PHY,"[eNB] Frame %d, FH CC_id %d thread busy!! (cnt_FH %d)\n",proc->instance_cnt_FH);
-	      exit_fun("FH thread busy");
-              break;
-	    }
 #ifdef PRINT_STATS
 
             if((sf==9) && frame%10==0)
@@ -1099,6 +1113,10 @@ main (int argc, char **argv)
     sinr_dB = -20;
   }
 
+  pthread_cond_init(&sync_cond,NULL);
+  pthread_mutex_init(&sync_mutex, NULL);
+  pthread_mutex_init(&subframe_mutex, NULL);
+
 #ifdef OPENAIR2
   init_omv ();
 #endif
@@ -1116,6 +1134,15 @@ main (int argc, char **argv)
   init_openair2 ();
 
   init_ocm ();
+  
+  // wait for all threads to startup 
+  sleep(3);
+  printf("Sending sync to all threads\n");
+
+  pthread_mutex_lock(&sync_mutex);
+  sync_var=0;
+  pthread_cond_broadcast(&sync_cond);
+  pthread_mutex_unlock(&sync_mutex);
 
 #ifdef SMBV
   // Rohde&Schwarz SMBV100A vector signal generator

targets/SIMU/USER/oaisim_config.c

@@ -456,7 +456,7 @@ int olg_config(void)
    set_comp_log(PHY,  LOG_TRACE, 0x15, 1);
    set_comp_log(PDCP, LOG_DEBUG, 0x15,1);
    set_comp_log(RRC,  LOG_DEBUG, 0x15,1);
-   set_comp_log(OCM,  LOG_ERR, 0x15,20);
+   set_comp_log(OCM,  LOG_DEBUG, 0x15,20);
    set_comp_log(OTG,  LOG_DEBUG, 0x15,1);
    set_comp_log(OMG,  LOG_NOTICE, 0x15,1);
    set_comp_log(OPT,  LOG_ERR, 0x15,1);

targets/SIMU/USER/oaisim_functions.c

@@ -957,6 +957,11 @@ void init_seed(uint8_t set_seed)
   }
 }
 
+openair0_timestamp current_eNB_rx_timestamp[NUMBER_OF_eNB_MAX][MAX_NUM_CCs];
+openair0_timestamp current_UE_rx_timestamp[NUMBER_OF_UE_MAX][MAX_NUM_CCs];
+openair0_timestamp last_eNB_rx_timestamp[NUMBER_OF_eNB_MAX][MAX_NUM_CCs];
+openair0_timestamp last_UE_rx_timestamp[NUMBER_OF_UE_MAX][MAX_NUM_CCs];
+
 int eNB_trx_start(openair0_device *device) {
   return(0);
 }
@@ -990,42 +995,44 @@ int UE_trx_set_gains(openair0_device *device, openair0_config_t *openair0_cfg) {
   return(0);
 }
 
+extern pthread_mutex_t subframe_mutex;
+extern int subframe_eNB_mask,subframe_UE_mask;
+
 int eNB_trx_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
-  return(0);
-}
-
-int UE_trx_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
-  return(0);
-}
-
-int eNB_trx_write(openair0_device *device,openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags) {
 
   int eNB_id = device->Mod_id;
   int CC_id  = device->CC_id;
-  int UE_id;
-  int subframe = (timestamp/PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.samples_per_tti)%10;
 
-  for (UE_id=0;UE_id<=NB_UE_INST;UE_id++) {
+  int subframe;
-    do_DL_sig(eNB2UE,
+  int ready_for_new_subframe=0;
-	      enb_data,
+  int subframe_eNB_mask_local;
-	      ue_data,
+  int sample_count=0;
-	      subframe,
-	      0, //abstraction_flag,
-	      &PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms,
-	      UE_id,
-	      CC_id);
-  }
-  return(0);
-}
 
-int UE_trx_write(openair0_device *device,openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags) {
+  *ptimestamp = last_eNB_rx_timestamp[eNB_id][CC_id];
 
-  int UE_id = device->Mod_id;
+  LOG_D(PHY,"eNB_trx_read nsamps %d TS(%llu,%llu) => subframe %d\n",nsamps,
-  int CC_id  = device->CC_id;
+        (unsigned long long)current_eNB_rx_timestamp[eNB_id][CC_id],
-  int eNB_id;
+        (unsigned long long)last_eNB_rx_timestamp[eNB_id][CC_id],
-  int subframe = (timestamp/PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti)%10;
+	(*ptimestamp/PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.samples_per_tti)%10);
+  // if we're at a subframe boundary generate UL signals for this eNB
 
-  for (eNB_id=0;eNB_id<=NB_eNB_INST;eNB_id++) {
+  while (sample_count<nsamps) {
+    while (current_eNB_rx_timestamp[eNB_id][CC_id]<
+	   (nsamps+last_eNB_rx_timestamp[eNB_id][CC_id])) {
+      LOG_D(EMU,"eNB: current TS %llu, last TS %llu, sleeping\n",current_eNB_rx_timestamp[eNB_id][CC_id],last_eNB_rx_timestamp[eNB_id][CC_id]);
+      usleep(500);
+    }
+
+    // tell top-level we are busy
+    pthread_mutex_lock(&subframe_mutex);
+    subframe_eNB_mask|=(1<<eNB_id);
+    pthread_mutex_unlock(&subframe_mutex); 
+    
+    subframe = (last_eNB_rx_timestamp[eNB_id][CC_id]/PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.samples_per_tti)%10;
+    LOG_D(PHY,"eNB_trx_read generating UL subframe %d (Ts %llu, current TS %llu)\n",
+	  subframe,(unsigned long long)*ptimestamp,
+	  (unsigned long long)current_eNB_rx_timestamp[eNB_id][CC_id]);
+    
     do_UL_sig(UE2eNB,
 	      enb_data,
 	      ue_data,
@@ -1035,8 +1042,87 @@ int UE_trx_write(openair0_device *device,openair0_timestamp timestamp, void **bu
 	      0,  // frame is only used for abstraction
 	      eNB_id,
 	      CC_id);
+  
+
+    last_eNB_rx_timestamp[eNB_id][CC_id] += PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.samples_per_tti;
+    sample_count += PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.samples_per_tti;
   }
-  return(0);
+
+  return(nsamps);
+}
+
+int UE_trx_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
+
+  int UE_id = device->Mod_id;
+  int CC_id  = device->CC_id;
+  int subframe;
+  int ready_for_new_subframe=0;
+  int subframe_UE_mask_local;
+  int sample_count=0;
+  int read_size;
+
+  *ptimestamp = last_UE_rx_timestamp[UE_id][CC_id];
+
+  LOG_D(PHY,"UE_trx_read nsamps %d TS(%llu,%llu)\n",nsamps,
+        (unsigned long long)current_UE_rx_timestamp[UE_id][CC_id],
+        (unsigned long long)last_UE_rx_timestamp[UE_id][CC_id]);
+
+  if (nsamps < PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti)
+    read_size = nsamps;
+  else
+    read_size = PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti;
+
+  while (sample_count<nsamps) {
+    while (current_UE_rx_timestamp[UE_id][CC_id] < 
+	   (last_UE_rx_timestamp[UE_id][CC_id]+read_size)) {
+      LOG_D(EMU,"UE_trx_read : current TS %d, last TS %d, sleeping\n",current_UE_rx_timestamp[UE_id][CC_id],last_UE_rx_timestamp[UE_id][CC_id]);
+      
+      usleep(500);
+    }
+
+    LOG_D(EMU,"UE_trx_read : current TS %d, last TS %d, sleeping\n",current_UE_rx_timestamp[UE_id][CC_id],last_UE_rx_timestamp[UE_id][CC_id]);
+      
+    // tell top-level we are busy 
+    pthread_mutex_lock(&subframe_mutex);
+    subframe_UE_mask|=(1<<UE_id);
+    pthread_mutex_unlock(&subframe_mutex);
+    // if we didn't ask for at least a subframe's worth of samples return
+
+    // otherwise we have one subframe here so generate the received signal
+    subframe = (last_UE_rx_timestamp[UE_id][CC_id]/PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti)%10;
+    if ((last_UE_rx_timestamp[UE_id][CC_id]%PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti) > 0)
+      subframe++;
+
+    last_UE_rx_timestamp[UE_id][CC_id] += read_size;
+    sample_count += read_size;
+ 
+    if (subframe > 9) 
+      return(nsamps);
+
+    LOG_D(PHY,"UE_trx_read generating DL subframe %d (Ts %llu, current TS %llu)\n",
+	  subframe,(unsigned long long)*ptimestamp,
+	  (unsigned long long)current_UE_rx_timestamp[UE_id][CC_id]);    
+    do_DL_sig(eNB2UE,
+	      enb_data,
+	      ue_data,
+	      subframe,
+	      0, //abstraction_flag,
+	      &PHY_vars_UE_g[UE_id][CC_id]->frame_parms,
+	      UE_id,
+	      CC_id);
+  }
+  
+  return(nsamps);
+}
+
+int eNB_trx_write(openair0_device *device,openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags) {
+
+  return(nsamps);
+}
+
+int UE_trx_write(openair0_device *device,openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags) {
+
+  return(nsamps);
 }
 
 void init_devices(void){
@@ -1055,8 +1141,10 @@ void init_devices(void){
       PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.trx_stop_func      = eNB_trx_stop;
       PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.trx_set_freq_func  = eNB_trx_set_freq;
       PHY_vars_eNB_g[eNB_id][CC_id]->rfdevice.trx_set_gains_func = eNB_trx_set_gains;
+      current_eNB_rx_timestamp[eNB_id][CC_id] = PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.samples_per_tti;
+      last_eNB_rx_timestamp[eNB_id][CC_id] = 0;
     }
-    for (UE_id=0;UE_id<NB_eNB_INST;UE_id++) {
+    for (UE_id=0;UE_id<NB_UE_INST;UE_id++) {
       PHY_vars_UE_g[UE_id][CC_id]->rfdevice.Mod_id               = UE_id;
       PHY_vars_UE_g[UE_id][CC_id]->rfdevice.CC_id                = CC_id;
       PHY_vars_UE_g[UE_id][CC_id]->rfdevice.trx_start_func       = UE_trx_start;
@@ -1066,6 +1154,9 @@ void init_devices(void){
       PHY_vars_UE_g[UE_id][CC_id]->rfdevice.trx_stop_func        = UE_trx_stop;
       PHY_vars_UE_g[UE_id][CC_id]->rfdevice.trx_set_freq_func    = UE_trx_set_freq;
       PHY_vars_UE_g[UE_id][CC_id]->rfdevice.trx_set_gains_func   = UE_trx_set_gains;
+      current_UE_rx_timestamp[UE_id][CC_id] = PHY_vars_UE_g[UE_id][CC_id]->frame_parms.samples_per_tti;
+      last_UE_rx_timestamp[UE_id][CC_id] = 0;
+
     }
   }
 }
@@ -1123,7 +1214,11 @@ void init_openair1(void)
   //N_TA_offset
   for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
     for (UE_id=0; UE_id<NB_UE_INST; UE_id++) {
-      PHY_vars_UE_g[UE_id][CC_id]->use_ia_receiver = 0;
+
+      PHY_vars_UE_g[UE_id][CC_id]->use_ia_receiver      = 0;
+      PHY_vars_UE_g[UE_id][CC_id]->mode                 = normal_txrx;
+      PHY_vars_UE_g[UE_id][CC_id]->mac_enabled          = 1;
+      PHY_vars_UE_g[UE_id][CC_id]->no_timing_correction = 1;
 
       if (PHY_vars_UE_g[UE_id][CC_id]->frame_parms.frame_type == TDD) {
         if (PHY_vars_UE_g[UE_id][CC_id]->frame_parms.N_RB_DL == 100)
@@ -1396,7 +1491,7 @@ void update_ocm()
     enb_data[eNB_id]->tx_power_dBm = PHY_vars_eNB_g[eNB_id][0]->frame_parms.pdsch_config_common.referenceSignalPower;
 
   for (UE_id = 0; UE_id < NB_UE_INST; UE_id++)
-    ue_data[UE_id]->tx_power_dBm = PHY_vars_UE_g[UE_id][0]->tx_power_dBm;
+    ue_data[UE_id]->tx_power_dBm = PHY_vars_UE_g[UE_id][0]->tx_power_dBm[0];
 
 
   /* check if the openair channel model is activated used for PHY abstraction : path loss*/
@@ -1450,10 +1545,10 @@ void update_ocm()
             UE2eNB[UE_id][eNB_id][CC_id]->path_loss_dB = -132.24 + sinr_dB - PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.pdsch_config_common.referenceSignalPower;
           }
 
-          LOG_I(OCM,"Path loss from eNB %d to UE %d (CCid %d)=> %f dB (eNB TX %d, SNR %f)\n",eNB_id,UE_id,CC_id,
+          LOG_D(OCM,"Path loss from eNB %d to UE %d (CCid %d)=> %f dB (eNB TX %d, SNR %f)\n",eNB_id,UE_id,CC_id,
                 eNB2UE[eNB_id][UE_id][CC_id]->path_loss_dB,
                 PHY_vars_eNB_g[eNB_id][CC_id]->frame_parms.pdsch_config_common.referenceSignalPower,snr_dB);
-          //      printf("[SIM] Path loss from UE %d to eNB %d => %f dB\n",UE_id,eNB_id,UE2eNB[UE_id][eNB_id]->path_loss_dB);
+        
         }
       }
     }
@@ -1721,3 +1816,14 @@ void init_time()
   td_avg        = TARGET_SF_TIME_NS;
 }
 
+int openair0_transport_load(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t * eth_params) {
+
+	return(0);
+
+
+}
+
+int openair0_device_load(openair0_device *device, openair0_config_t *openair0_cfg) {
+
+	return(0);
+}