diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 15c44aed22a46638543af94ca08ac8c5a99798c5..311f3952aa0433fcbf2a36c7ebfdbf241b2b5427 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,38 +1,19 @@ job1: script: - - echo $PWD - - echo $USER - - echo $OAI_USER - - echo $OAI_EXTRA_ARGS - - echo $NFS_SHARE_DIR - - 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` - - echo $git_head - - tmp=`git show-ref --head | grep $git_head` - - tmp=(${tmp///// }) - - git_branch=${tmp[@]:(-1)} - - echo $git_branch - - source oaienv - - echo $OPENAIR_DIR - - NFS_TEST_RESULTS_DIR=$NFS_SHARE_DIR/$git_branch/$git_head - - EXTERNAL_SHARE_RESULTS_DIR=$EXTERNAL_SHARE_DIR/$git_branch/$git_head - - echo $NFS_TEST_RESULTS_DIR - - echo $EXTERNAL_SHARE_RESULTS_DIR - - 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 -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 -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 - - sshpass -p "$OAI_PASS" rsync -az -e "ssh -o StrictHostKeyChecking=no " --rsync-path="mkdir -p $EXTERNAL_SHARE_DIR && rsync" $OPENAIR_DIR/cmake_targets/autotests/log $OAI_USER@localhost:$EXTERNAL_SHARE_DIR - - cat $OPENAIR_DIR/cmake_targets/autotests/log/results_autotests.xml + - date + - pwd + - echo $OAI_USER + - echo $OAI_PASS + - echo $OAI_TEST_CASE_GROUP + - echo $MACHINELIST + - echo $MACHINELISTGENERIC + - echo $RESULT_DIR + - echo $NRUNS_LTE_SOFTMODEM + - source oaienv + - rm -rf cmake_targets/autotests/log + - mkdir cmake_targets/autotests/log + - cd cmake_targets/autotests/v2 + - python main.py + - date only: - - triggers + - triggers diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt index 81ddf3750309b94118758a5e037a29698af7906e..94ff4b239a4a91c6359f687d5b2248e57d604c96 100644 --- a/cmake_targets/CMakeLists.txt +++ b/cmake_targets/CMakeLists.txt @@ -37,11 +37,6 @@ set (OPENAIR_BIN_DIR ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}) project (OpenAirInterface) -#add_definitions("-DEMIT_ASN_DEBUG=1") -add_subdirectory(${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/lms7002m lms7002m) -add_subdirectory(${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/lmsSDR lmsSDR) -add_subdirectory(${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/Si5351C Si5351C) - ########################################### # macros to define options as there is numerous options in oai ################################################ @@ -512,7 +507,7 @@ set(HWLIB_BLADERF_SOURCE add_library(oai_bladerfdevif MODULE ${HWLIB_BLADERF_SOURCE} ) include_directories("${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/") -set (option_HWLMSSDRLIB_lib "-l LMS_SDR -l LMS7002M -l Si5351C") + set(HWLIB_LMSSDR_SOURCE ${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/lms_lib.cpp ) @@ -559,16 +554,14 @@ elseif (${RF_BOARD} STREQUAL "OAI_BLADERF") elseif (${RF_BOARD} STREQUAL "OAI_LMSSDR") include_directories("${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB") - include_directories("${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/lmsSDR") - include_directories("${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/lms7002m") - include_directories("${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/Si5351C") - include_directories("${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/lmsSDR/LMS_StreamBoard") + include_directories("/usr/local/include/lime") + include_directories("/usr/include/lime") LINK_DIRECTORIES("/usr/lib/x86_64-linux-gnu") LINK_DIRECTORIES("${CMAKE_CURRENT_BINARY_DIR}/lmsSDR") LINK_DIRECTORIES("${CMAKE_CURRENT_BINARY_DIR}/lms7002m") LINK_DIRECTORIES("${CMAKE_CURRENT_BINARY_DIR}/Si5351C") set(HW_SOURCE ${HW_SOURCE} ${OPENAIR_TARGETS}/ARCH/LMSSDR/USERSPACE/LIB/lms_lib.cpp) - set(option_HW_lib "-lLMS_SDR -lLMS7002M -lSi5351C -rdynamic -ldl") + set(option_HW_lib "-lLimeSuite -rdynamic -ldl") elseif (${RF_BOARD} STREQUAL "CPRIGW") set(HW_SOURCE ${HW_SOURCE} @@ -1691,7 +1684,7 @@ endif() # Atlas is required by some packages, but not found in pkg-config if(EXISTS "/usr/include/atlas/cblas.h") include_directories("/usr/include/atlas") - list(APPEND ATLAS_LIBRARIES lapack cblas atlas) + list(APPEND ATLAS_LIBRARIES cblas atlas lapack) else() message("No Blas/Atlas libs found, some targets will fail") endif() @@ -1845,14 +1838,6 @@ Message("-- HW_SOURCE=${HW_SOURCE}") Message("-- option_TP_lib=${option_TP_lib}") Message("-- TRANSPORT_SOURCE=${TRANSPORT_SOURCE}") -if (${RF_BOARD} STREQUAL "OAI_LMSSDR") - add_dependencies(lte-softmodem LMS7002M LMS_SDR Si5351C) - add_dependencies(lte-softmodem-nos1 LMS7002M LMS_SDR Si5351C) - add_dependencies(rrh_gw LMS7002M LMS_SDR Si5351C) -endif (${RF_BOARD} STREQUAL "OAI_LMSSDR") - - - # USIM process ################# #add_executable(usim diff --git a/cmake_targets/autotests/test_case_list.xml b/cmake_targets/autotests/test_case_list.xml index bf2a1ed36c929ee19188c90aebad5031c74b5c84..7f2847a5ead260c11eff47904d2f08c868d9a6dd 100644 --- a/cmake_targets/autotests/test_case_list.xml +++ b/cmake_targets/autotests/test_case_list.xml @@ -13,7 +13,7 @@ 36000 010141 0102+ 010301 010303 010304 010305 0104+ 015508 015511 015520 015523 015518 015519 015520 015521 015522 015523 015602 015605 015818 015819 015820 015821 015822 015823 016102 016105 016502 016505 017002 017005 018002 018005 018502 018505 025514 025517 025520 025523 025518 025519 025520 025521 025522 025523 3 - amerique mozart hutch starsky stevens calisson superserver + nano mozart hutch starsky stevens calisson superserver compilation Build oaisim.Rel8 diff --git a/cmake_targets/autotests/v2/actions/alu_epc.bash b/cmake_targets/autotests/v2/actions/alu_epc.bash new file mode 100644 index 0000000000000000000000000000000000000000..b2106693bd1c14f9a2f3f65695d748f4cec0f0b4 --- /dev/null +++ b/cmake_targets/autotests/v2/actions/alu_epc.bash @@ -0,0 +1,2 @@ +sudo /opt/ltebox/tools/stop_ltebox || true +sudo /opt/ltebox/tools/start_ltebox diff --git a/cmake_targets/autotests/v2/actions/alu_epc_stop.bash b/cmake_targets/autotests/v2/actions/alu_epc_stop.bash new file mode 100644 index 0000000000000000000000000000000000000000..ca91a27ab1a594ed22b04958b86144207356968d --- /dev/null +++ b/cmake_targets/autotests/v2/actions/alu_epc_stop.bash @@ -0,0 +1 @@ +sudo /opt/ltebox/tools/stop_ltebox diff --git a/cmake_targets/autotests/v2/actions/alu_hss.bash b/cmake_targets/autotests/v2/actions/alu_hss.bash new file mode 100644 index 0000000000000000000000000000000000000000..ded1e352ce8dde0f861a2d2b5608e60b8fbbd282 --- /dev/null +++ b/cmake_targets/autotests/v2/actions/alu_hss.bash @@ -0,0 +1,2 @@ +sudo /opt/ltebox/tools/stop_ltebox || true +sudo /opt/hss_sim0609/starthss_real diff --git a/cmake_targets/autotests/v2/actions/bandrich.txt b/cmake_targets/autotests/v2/actions/bandrich.txt new file mode 100644 index 0000000000000000000000000000000000000000..8533750c5b1e2633ce8b0d41e7c22257ae596218 --- /dev/null +++ b/cmake_targets/autotests/v2/actions/bandrich.txt @@ -0,0 +1,136 @@ +The configuration for the bandrich in the test setup is a bit hackish. + +Here come some notes explaining what we do here. + +To get /dev/bandrich.data and /dev/bandrich.control (so that you don't need +to look for which /dev/ttyUSBx are used by your dongle, and always use +the same files, no matter what), add a udev file: + + /etc/udev/rules.d/bandrich.rules + +containing lines: + + SUBSYSTEM=="tty", ENV{ID_VENDOR_ID}=="1a8d", ENV{ID_MODEL_ID}=="100d", ENV{ID_SERIAL_SHORT}=="357473040068155", ENV{ID_USB_INTERFACE_NUM}=="00", SYMLINK+="bandrich.data", MODE="0666" + SUBSYSTEM=="tty", ENV{ID_VENDOR_ID}=="1a8d", ENV{ID_MODEL_ID}=="100d", ENV{ID_SERIAL_SHORT}=="357473040068155", ENV{ID_USB_INTERFACE_NUM}=="02", SYMLINK+="bandrich.control", MODE="0666" + +Change vendor_id/model_id/serial/interface num to match yours. +Use lsusb -v to find values. + +At first we used /dev/ttyUSB2 linked to /dev/bandrich for both data (in +the wvdial configuration file) and control (in the python code, opening +/dev/bandrich the standard unix way and read and write into it, with no +special libusb commands). + +But it turned out that using /dev/ttyUSB2 for data gives bad throughput +results. We tested downlink UDP at 15Mb/s but the maximum throughput for +a 5MHz cell was around 13, and we had a lot of packets lost at the iperf's +UDP level. Radio was looking fine (all packets acked correctly), so it was +not a radio problem. The dongle in a windows machine was working fine, +15Mbs/s. Using the wvdial configuration file from test setup v1 gave also +good results. The only difference was the use of /dev/ttyUSB0 instead of +/dev/ttyUSB2. Using /dev/ttyUSB0 solved the throughput issue. + +But using /dev/ttyUSB0 for control in the pyton code did not work. The +output was incorrect. + +So we decided to have /dev/bandrich.data linked to /dev/ttyUSB0 for data +(wvdial) and /dev/bandrich.control linked to /dev/ttyUSB2 for control +(in python code). + +It may not be the correct way to go, but it seems to do the trick so far. + +Your device may need some other solution. + +Here, we get, as result of lsusb -v: + + [SNIP] + Bus 003 Device 009: ID 1a8d:100d BandRich, Inc. 4G LTE adapter + Device Descriptor: + bLength 18 + bDescriptorType 1 + bcdUSB 2.00 + bDeviceClass 0 (Defined at Interface level) + bDeviceSubClass 0 + bDeviceProtocol 0 + bMaxPacketSize0 64 + idVendor 0x1a8d BandRich, Inc. + idProduct 0x100d 4G LTE adapter + bcdDevice 0.00 + iManufacturer 10 BandRich, Inc. + iProduct 9 BandLuxe HSPA-LTE Adapter + iSerial 11 357473040068155 + [SNIP] + +You can also run: + + udevadm monitor + +and unplug/replug the dongle. It will print some information. + +The command: + + udevadm info --export-db + +is also important to get the right identifier to put in ENV{}. (It also +gives the correct value.) + +Here is extracted what we have for our dongle: + + P: /devices/pci0000:00/0000:00:1a.0/usb3/3-1/3-1.2/3-1.2:1.2/ttyUSB2/tty/ttyUSB2 + N: ttyUSB2 + S: bandrich + S: serial/by-id/usb-BandRich__Inc._BandLuxe_HSPA-LTE_Adapter_357473040068155-if02-port0 + S: serial/by-path/pci-0000:00:1a.0-usb-0:1.2:1.2-port0 + E: DEVLINKS=/dev/bandrich /dev/serial/by-id/usb-BandRich__Inc._BandLuxe_HSPA-LTE_Adapter_357473040068155-if02-port0 /dev/serial/by-path/pci-0000:00:1a.0-usb-0:1.2:1.2-port0 + E: DEVNAME=/dev/ttyUSB2 + E: DEVPATH=/devices/pci0000:00/0000:00:1a.0/usb3/3-1/3-1.2/3-1.2:1.2/ttyUSB2/tty/ttyUSB2 + E: ID_BUS=usb + E: ID_MM_CANDIDATE=1 + E: ID_MODEL=BandLuxe_HSPA-LTE_Adapter + E: ID_MODEL_ENC=BandLuxe\x20HSPA-LTE\x20Adapter + E: ID_MODEL_FROM_DATABASE=4G LTE adapter + E: ID_MODEL_ID=100d + E: ID_PATH=pci-0000:00:1a.0-usb-0:1.2:1.2 + E: ID_PATH_TAG=pci-0000_00_1a_0-usb-0_1_2_1_2 + E: ID_REVISION=0000 + E: ID_SERIAL=BandRich__Inc._BandLuxe_HSPA-LTE_Adapter_357473040068155 + E: ID_SERIAL_SHORT=357473040068155 + E: ID_TYPE=generic + E: ID_USB_DRIVER=option + E: ID_USB_INTERFACES=:ffffff:020600:0a0000:080650: + E: ID_USB_INTERFACE_NUM=02 + E: ID_VENDOR=BandRich__Inc. + E: ID_VENDOR_ENC=BandRich\x2c\x20Inc. + E: ID_VENDOR_FROM_DATABASE=BandRich, Inc. + E: ID_VENDOR_ID=1a8d + E: MAJOR=188 + E: MINOR=2 + E: SUBSYSTEM=tty + E: USEC_INITIALIZED=672068596 + +You can also run: + + udevadm info -a -p /sys/bus/usb-serial/devices/ttyUSB0 + udevadm info -a -p /sys/bus/usb-serial/devices/ttyUSB2 + +Note: after creating the udev files, you need to unplug/replug your +dongle for /dev/bandrich.data and /dev/bandrich.control to appear. + +Note: the mode 0666 is for everyone to access the dongle (no need for + root privileges). If you prefer you can set it to 0600 (only root) + or 0660 (root and group). + +Then you need to configure pppd, to get correct 'route' information when +you run wvdial. + +The file /etc/ppp/peers/wvdial should have the following content: + + noauth + name wvdial + usepeerdns + defaultroute + replacedefaultroute + +The file wvdial.bandrich.conf has been created by copying some information +found on the Internet. Its content may not be fully correct. Adapt to your +situation. It seems to work here. diff --git a/cmake_targets/autotests/v2/actions/client_tcp.bash b/cmake_targets/autotests/v2/actions/client_tcp.bash new file mode 100644 index 0000000000000000000000000000000000000000..1079f9aee87d7d2ed6cd10e2b0973e675af30fb2 --- /dev/null +++ b/cmake_targets/autotests/v2/actions/client_tcp.bash @@ -0,0 +1,2 @@ +echo $SERVER_IP +timeout -s 9 20s iperf -c $SERVER_IP -i1 diff --git a/cmake_targets/autotests/v2/actions/client_udp.bash b/cmake_targets/autotests/v2/actions/client_udp.bash new file mode 100644 index 0000000000000000000000000000000000000000..00151aa1f8e1347b59ba2ccf4a26f90d0c29fff2 --- /dev/null +++ b/cmake_targets/autotests/v2/actions/client_udp.bash @@ -0,0 +1,3 @@ +echo $SERVER_IP +echo $UDP_BANDWIDTH +timeout -s 9 20s iperf -c $SERVER_IP -i1 -u -b $UDP_BANDWIDTH diff --git a/cmake_targets/autotests/v2/actions/clone_repository.bash b/cmake_targets/autotests/v2/actions/clone_repository.bash new file mode 100644 index 0000000000000000000000000000000000000000..2f1769a623c9e169ec3c3a8ff5c3147257d1281d --- /dev/null +++ b/cmake_targets/autotests/v2/actions/clone_repository.bash @@ -0,0 +1,6 @@ +sudo rm -rf /tmp/oai_test_setup +mkdir /tmp/oai_test_setup +cd /tmp/oai_test_setup +git clone $REPOSITORY_URL oai +cd oai +git checkout $COMMIT_ID diff --git a/cmake_targets/autotests/v2/actions/compilation.bash b/cmake_targets/autotests/v2/actions/compilation.bash new file mode 100644 index 0000000000000000000000000000000000000000..44966616fa397eb57e92d5115c45c4319f5335f6 --- /dev/null +++ b/cmake_targets/autotests/v2/actions/compilation.bash @@ -0,0 +1,9 @@ +cd /tmp/oai_test_setup/oai +source oaienv +cd cmake_targets +rm -rf log +mkdir -p log +echo $BUILD_ARGUMENTS +./build_oai $BUILD_ARGUMENTS +echo $BUILD_OUTPUT +ls $BUILD_OUTPUT diff --git a/cmake_targets/autotests/v2/actions/execution.bash b/cmake_targets/autotests/v2/actions/execution.bash new file mode 100644 index 0000000000000000000000000000000000000000..0e05014888ccb5cefc1900e79d3df3622bc2dbcb --- /dev/null +++ b/cmake_targets/autotests/v2/actions/execution.bash @@ -0,0 +1,4 @@ +cd /tmp/oai_test_setup/oai +source oaienv +echo $EXEC $EXEC_ARGS +$EXEC $EXEC_ARGS diff --git a/cmake_targets/autotests/v2/actions/execution_compile.bash b/cmake_targets/autotests/v2/actions/execution_compile.bash new file mode 100644 index 0000000000000000000000000000000000000000..6791e93b0d678f9ab46ebbbe65f6a1e60701fe9a --- /dev/null +++ b/cmake_targets/autotests/v2/actions/execution_compile.bash @@ -0,0 +1,8 @@ +cd /tmp/oai_test_setup/oai +source oaienv +cd cmake_targets +rm -rf log +mkdir -p log +bash -c "$PRE_BUILD" +$BUILD_PROG $BUILD_ARGUMENTS +bash -c "$PRE_EXEC" diff --git a/cmake_targets/autotests/v2/actions/modem.py b/cmake_targets/autotests/v2/actions/modem.py new file mode 100644 index 0000000000000000000000000000000000000000..a6c49fa9bfdc35e6d00596243fd7283c0b9fa486 --- /dev/null +++ b/cmake_targets/autotests/v2/actions/modem.py @@ -0,0 +1,103 @@ +import sys, os, select, re, time + +def quit(r): + sys.stdout.flush() + os._exit(r) + +class ModemResponse: + def __init__(self, retcode, retstring): + self.ret = retcode + self.data = retstring + +class Modem: + def open(self): + self.i = os.open(self.devname, os.O_RDONLY) + self.o = os.open(self.devname, os.O_WRONLY) + #clear output of modem, if any is pending (not sure of this) + while True: + (ri, ro, re) = select.select([self.i], [], [self.i], 0) + if len(ri) == 0: + break + l = os.read(self.i, 65536) + print "WARNING: modem had unread data: '" + \ + l.replace('\r', '\\r') + "'" + + def __init__(self, devname): + self.devname = devname + self.i = -1 + self.o = -1 + self.open() + + def send(self, s): + print "DEBUG: SEND TO MODEM: '" + s + "'" + os.write(self.o, s+"\r") + + def recv(self): + return os.read(self.i, 65536) + + def wait(self): + ok = '\r\nOK\r\n' + error = '\r\nERROR\r\n' + cme_error = '\r\nCME ERROR:[^\r]*\r\n' + no_carrier = '\r\nNO CARRIER\r\n' + l = '' + while True: + l = l + self.recv() + print "DEBUG: CURRENT MODEM RESPONSE: '" + \ + l.replace('\r','\\r').replace('\n','\\n') + "'" + + #AT returned 'things' are "\r\nXXXX\r\n", look for that. + #Check if last one matches 'ok', 'error' or 'cme_error'. + #(Hopefully this is enough and no other reply is possible.) + #This code accepts invalid responses from modem, ie. all + #that does not fit in the 'findall' is thrashed away, maybe + #we want to do something in this case? + + res = re.findall('\r\n[^\r]*\r\n', l) + if len(res) == 0: + print "DEBUG: NO MATCH: wait for more input from modem" + continue + last_res = res[len(res)-1] + print "DEBUG: CURRENT LAST LINE: '" + \ + last_res.replace('\r','\\r').replace('\n','\\n')+"'" + if re.match(ok, last_res) != None: + return ModemResponse(True, l) + if ( re.match(error, last_res) != None or + re.match(cme_error, last_res) != None or + re.match(no_carrier, last_res) != None): + return ModemResponse(False, l) + #TODO purge? + #re.purge() + + def modem_reset_cycle(self): + #close all + os.close(self.i) + os.close(self.o) + self.i = -1 + self.o = -1 + + print "DEBUG: RESET CYCLE: wait for modem to go away" + #wait for file descriptor to go away + while True: + try: + test = os.open(self.devname, os.O_RDONLY) + os.close(test) + time.sleep(0.1) + except BaseException, e: + break + print "DEBUG: RESET CYCLE: modem has gone away" + + print "DEBUG: RESET CYCLE: wait for modem to come back" + #wait for file descriptor to be back, try to open it over and over + #TODO: use inotify here? (it's not in basic python as it seems) + while True: + try: + test = os.open(self.devname, os.O_RDONLY) + os.close(test) + break + except BaseException, e: + time.sleep(0.1) + print "DEBUG: RESET CYCLE: modem is back" + + #back to business + self.open() diff --git a/cmake_targets/autotests/v2/actions/run_enb.bash b/cmake_targets/autotests/v2/actions/run_enb.bash new file mode 100644 index 0000000000000000000000000000000000000000..1a4c5368a7453f83b446afcc92a69a1744610995 --- /dev/null +++ b/cmake_targets/autotests/v2/actions/run_enb.bash @@ -0,0 +1,10 @@ +#enable control+C reception (to be refined if it does not work) +stty isig intr ^C + +cd /tmp/oai_test_setup/oai +source oaienv +cd cmake_targets/lte_build_oai/build +ulimit -c unlimited +sudo rm -f core +#sudo -E ./lte-softmodem -O $OPENAIR_DIR/cmake_targets/autotests/v2/config/enb.band7.tm1.usrpb210.conf +sudo -E ./lte-softmodem -O /tmp/enb.conf diff --git a/cmake_targets/autotests/v2/actions/server_tcp.bash b/cmake_targets/autotests/v2/actions/server_tcp.bash new file mode 100644 index 0000000000000000000000000000000000000000..3e9c4aafc46571fade57dd844c3764b726443495 --- /dev/null +++ b/cmake_targets/autotests/v2/actions/server_tcp.bash @@ -0,0 +1,4 @@ +stty isig intr ^C + +#timeout -s 9 20s iperf -s -i1 +iperf -s -i1 diff --git a/cmake_targets/autotests/v2/actions/server_udp.bash b/cmake_targets/autotests/v2/actions/server_udp.bash new file mode 100644 index 0000000000000000000000000000000000000000..22fba07092449f754b99370e74e34b0f1e06d09b --- /dev/null +++ b/cmake_targets/autotests/v2/actions/server_udp.bash @@ -0,0 +1,4 @@ +stty isig intr ^C + +#timeout -s 9 20s iperf -s -i1 -u +iperf -s -i1 -u diff --git a/cmake_targets/autotests/v2/actions/start_bandrich.bash b/cmake_targets/autotests/v2/actions/start_bandrich.bash new file mode 100644 index 0000000000000000000000000000000000000000..e562dfc29be777b4c09e9e87cb53d620533b7dc3 --- /dev/null +++ b/cmake_targets/autotests/v2/actions/start_bandrich.bash @@ -0,0 +1,24 @@ +#enable control+C reception (to be refined if it does not work) +stty isig intr ^C + +#If /dev/bandrich is not present when we start the test, what to do? +#The following commented lines are an attempt at solving this. +#This is not satisfying, so we rather do nothing. + +##the UE got stuck once, I had to run usb_modeswitch by hand. +##So at this point, if /dev/bandrich does not exist, maybe the UE is +##stuck for whatever reason. Let's forcefully run usb_modeswitch. +#if [ ! -e /dev/bandrich ]; then sudo usb_modeswitch -v 1a8d -p 1000 -I -W -K; true; fi +# +##wait for /dev/bandrich (TODO: use inotify?) +##may fail if the bandrich is in a bad state +#while [ ! -e /dev/bandrich ]; do sleep 1; done + +cd /tmp/oai_test_setup/oai +source oaienv +cd cmake_targets/autotests/v2/actions +python start_bandrich.py + +sudo wvdial -C wvdial.bandrich.conf || true + +python stop_bandrich.py diff --git a/cmake_targets/autotests/v2/actions/start_bandrich.py b/cmake_targets/autotests/v2/actions/start_bandrich.py new file mode 100644 index 0000000000000000000000000000000000000000..698694df052d2dda034f422ac5d1fa70ea62a3dc --- /dev/null +++ b/cmake_targets/autotests/v2/actions/start_bandrich.py @@ -0,0 +1,55 @@ +import time + +from modem import quit, Modem + +try: + modem = Modem("/dev/bandrich.control") + + #test that modem is there + print "INFO: check modem's presence" + modem.send('AT') + if modem.wait().ret != True: + print "ERROR: no modem?" + quit(1) + + #activate the modem, be brutal and reset it too! + print "INFO: reset and activate the modem" + modem.send('AT+CFUN=1,1') + if modem.wait().ret != True: + print "ERROR: failed asking modem for activation" + quit(1) + + #modem has gone! wait for it to pop up again + modem.modem_reset_cycle() + + #wait for modem to be connected + #timeout after one minute + print "INFO: wait for modem to be connected (timeout: one minute)" + start_time = time.time() + while True: + modem.send('AT+CGATT?') + r = modem.wait() + if r.ret != True: + print "ERROR: failed checking attachment status of modem" + quit(1) + if "+CGATT: 1" in r.data: + break + if not "CGATT: 0" in r.data: + print "ERROR: bad data when checking attachment status of modem" + quit(1) + time.sleep(0.1) + if time.time() > start_time + 60: + print "ERROR: modem not connected after one minute, close modem" + modem.send('AT+CFUN=4') + r = modem.wait() + if r.ret != True: + print "ERROR: closing modem failed" + quit(1) + + print "INFO: modem is connected" + +except BaseException, e: + print "ERROR: " + str(e) + quit(1) + +quit(0) diff --git a/cmake_targets/autotests/v2/actions/stop_bandrich.py b/cmake_targets/autotests/v2/actions/stop_bandrich.py new file mode 100644 index 0000000000000000000000000000000000000000..d539faa9f8a85b46e3e3852a38ecf51df0a903bc --- /dev/null +++ b/cmake_targets/autotests/v2/actions/stop_bandrich.py @@ -0,0 +1,29 @@ +import time + +from modem import quit, Modem + +try: + modem = Modem("/dev/bandrich.control") + + #test that modem is there + print "INFO: check modem's presence" + modem.send('AT') + r = modem.wait() + if r.ret != True and "NO CARRIER" not in r.data: + print "ERROR: no modem?" + quit(1) + if "NO CARRIER" in r.data: + print "WARNING: 'NO CARRIER' detected, not sure if handled correctly" + + #deactivate the modem + print "INFO: deactivate the modem" + modem.send('AT+CFUN=4') + if modem.wait().ret != True: + print "ERROR: failed asking modem for deactivation" + quit(1) + +except BaseException, e: + print "ERROR: " + str(e) + quit(1) + +quit(0) diff --git a/cmake_targets/autotests/v2/actions/wvdial.bandrich.conf b/cmake_targets/autotests/v2/actions/wvdial.bandrich.conf new file mode 100644 index 0000000000000000000000000000000000000000..d3146e3a2af6e6d56a8cb15f58a7731bdfb65d2b --- /dev/null +++ b/cmake_targets/autotests/v2/actions/wvdial.bandrich.conf @@ -0,0 +1,36 @@ +[Dialer Defaults] +Modem = /dev/bandrich.data +ISDN = off +Modem Type = Analog Modem +Baud = 9600 +Init = ATZ +Init2 = AT+CPIN? +Init3 = AT+CGREG? +Init4 = AT+COPS? +Init5 = AT+CSQ +Init6 = +Init7 = AT+CGATT=1 +Init8 = +Init9 = +Phone = *99***1# +Phone1 = +Phone2 = +Phone3 = +Phone4 = +Dial Prefix = +Dial Attempts = 1 +Dial Command = ATM1L3DT +Ask Password = off +Password = '' +Username = ImaginLab +Auto Reconnect = off +Abort on Busy = off +Carrier Check = on +Check Def Route = on +Abort on No Dialtone = on +Stupid Mode = on +Idle Seconds = 0 +Auto DNS = on +;Minimize = off +;Dock = off +;Do NOT edit this file by hand! diff --git a/cmake_targets/autotests/v2/alu_test.py b/cmake_targets/autotests/v2/alu_test.py new file mode 100644 index 0000000000000000000000000000000000000000..7992ce7f3ca460654a7d577073309116f4471e03 --- /dev/null +++ b/cmake_targets/autotests/v2/alu_test.py @@ -0,0 +1,389 @@ +import threading, os, re + +from utils import quickshell, log, TestFailed, do_tests +from task import Task, WAITLOG_SUCCESS + +class alu_test: + def __init__(self, + epc, enb, ue, + openair, + user, password, + log_subdir, + env): + self.epc_machine = epc + self.enb_machine = enb + self.ue_machine = ue + self.openair_dir = openair + self.oai_user = user + self.oai_password = password + self.env = env + + self.task_hss = None + self.task_enb = None + self.task_ue = None + + self.logdir = openair + '/cmake_targets/autotests/log/' + log_subdir + quickshell('mkdir -p ' + self.logdir) + + #event object used to wait for several tasks at once + self.event = threading.Event() + + ########################################################################## + # finish + ########################################################################## + def finish(self): + #brutally kill tasks still running + #TODO: call 'wait', some processes may still be there as zombies + if self.task_hss != None and self.task_hss.alive(): + self.task_hss.kill() + if self.task_enb != None and self.task_enb.alive(): + self.task_enb.kill() + if self.task_ue != None and self.task_ue.alive(): + self.task_ue.kill() + + ########################################################################## + # start_epc + ########################################################################## + def start_epc(self): + #launch HSS, wait for prompt + log("INFO: ALU test: run HSS") + self.task_hss = Task("actions/alu_hss.bash", + "alu_hss", + self.epc_machine, + self.oai_user, + self.oai_password, + self.env, + self.logdir + "/alu_hss." + self.epc_machine, + event=self.event) + self.task_hss.waitlog('S6AS_SIM-> ') + + #then launch EPC, wait for connection on HSS side + log("INFO: ALU test: run EPC") + task_epc = Task("actions/alu_epc.bash", + "ALU EPC", + self.epc_machine, + self.oai_user, + self.oai_password, + self.env, + self.logdir + "/alu_epc." + self.epc_machine) + ret = task_epc.wait() + if ret != 0: + log("ERROR: EPC start failure"); + raise TestFailed() + self.task_hss.waitlog('Connected\n') + + ########################################################################## + # stop_epc + ########################################################################## + def stop_epc(self): + #stop EPC, wait for disconnection on HSS side + log("INFO: ALU test: stop EPC") + task_epc = Task("actions/alu_epc_stop.bash", + "alu_epc_stop", + self.epc_machine, + self.oai_user, + self.oai_password, + self.env, + self.logdir + "/alu_epc_stop." + self.epc_machine) + ret = task_epc.wait() + if ret != 0: + log("ERROR: ALU test: ALU EPC stop failed") + raise TestFailed() + self.task_hss.waitlog('Disconnected\n') + + log("INFO: ALU test: stop HSS") + self.task_hss.sendnow("exit\n") + ret = self.task_hss.wait() + if ret != 0: + log("ERROR: ALU test: ALU HSS failed") + raise TestFailed() + + ########################################################################## + # compile_enb + ########################################################################## + def compile_enb(self, build_arguments): + log("INFO: ALU test: compile softmodem") + envcomp = list(self.env) + envcomp.append('BUILD_ARGUMENTS="' + build_arguments + '"') + #we don't care about BUILD_OUTPUT but required (TODO: change that) + envcomp.append('BUILD_OUTPUT=/') + logdir = self.logdir + "/compile_log" + remote_files = "'/tmp/oai_test_setup/oai/cmake_targets/log/*'" + post_action = "mkdir -p "+ logdir + \ + " && sshpass -p " + self.oai_password + \ + " scp -r " + self.oai_user + \ + "@" + self.enb_machine + ":" + remote_files + " " + logdir + \ + " || true" + task = Task("actions/compilation.bash", + "compile_softmodem", + self.enb_machine, + self.oai_user, + self.oai_password, + envcomp, + self.logdir + "/compile_softmodem." + self.enb_machine, + post_action=post_action) + ret = task.wait() + if ret != 0: + log("ERROR: softmodem compilation failure"); + raise TestFailed() + task.postaction() + + ########################################################################## + # start_enb + ########################################################################## + def start_enb(self, config_file): + #copy wanted configuration file + quickshell("sshpass -p " + self.oai_password + + " scp config/" + config_file + " " + + self.oai_user + "@" + self.enb_machine + ":/tmp/enb.conf") + + #run softmodem + log("INFO: ALU test: run softmodem with configuration file " + + config_file) + self.task_enb = Task("actions/run_enb.bash", + "run_softmodem", + self.enb_machine, + self.oai_user, + self.oai_password, + self.env, + self.logdir + "/run_softmodem." + self.enb_machine, + event=self.event) + self.task_enb.waitlog('got sync') + + ########################################################################## + # stop_enb + ########################################################################## + def stop_enb(self): + log("INFO: ALU test: stop softmodem") + self.task_enb.sendnow("%c" % 3) + ret = self.task_enb.wait() + if ret != 0: + log("ERROR: ALU test: softmodem failed") + #not sure if we have to quit here or not + #os._exit(1) + + ########################################################################## + # start_bandrich_ue + ########################################################################## + def start_bandrich_ue(self): + log("INFO: ALU test: start bandrich UE") + self.task_ue = Task("actions/start_bandrich.bash", + "start_bandrich", + self.ue_machine, + self.oai_user, + self.oai_password, + self.env, + self.logdir + "/start_bandrich." + self.ue_machine, + event=self.event) + self.task_ue.waitlog("local IP address", event=self.event) + self.event.wait() + + #at this point one task has died or we have the line in the log + if self.task_ue.waitlog_state != WAITLOG_SUCCESS: + log("ERROR: ALU test: bandrich UE did not connect") + raise TestFailed() + + self.event.clear() + + if ( not self.task_enb.alive() or + not self.task_hss.alive() or + not self.task_ue.alive()): + log("ERROR: ALU test: eNB, HSS or UE task died") + raise TestFailed() + + #get bandrich UE IP + l = open(self.task_ue.logfile, "r").read() + self.bandrich_ue_ip = re.search("local IP address (.*)\n", l) \ + .groups()[0] + log("INFO: ALU test: bandrich UE IP address: " + self.bandrich_ue_ip) + + ########################################################################## + # stop_bandrich_ue + ########################################################################## + def stop_bandrich_ue(self): + log("INFO: ALU test: stop bandrich UE") + self.task_ue.sendnow("%c" % 3) + ret = self.task_ue.wait() + if ret != 0: + log("ERROR: ALU test: task bandrich UE failed") + #not sure if we have to quit here or not + #os._exit(1) + + ########################################################################## + # _do_traffic (internal function, do not call out of the class) + ########################################################################## + def _do_traffic(self, name, + server_code, server_machine, server_ip, + client_code, client_machine, + waitlog, + server_logfile, client_logfile, + udp_bandwidth=None): + log("INFO: ALU test: run traffic: " + name) + + log("INFO: ALU test: launch server") + task_traffic_server = Task("actions/" + server_code + ".bash", + server_logfile, + server_machine, + self.oai_user, + self.oai_password, + self.env, + self.logdir + "/" + server_logfile + "." + server_machine, + event=self.event) + task_traffic_server.waitlog(waitlog) + + env = list(self.env) + if udp_bandwidth != None: + env.append("UDP_BANDWIDTH=" + udp_bandwidth) + env.append("SERVER_IP=" + server_ip) + + log("INFO: ALU test: launch client") + task_traffic_client = Task("actions/" + client_code + ".bash", + client_logfile, + client_machine, + self.oai_user, + self.oai_password, + env, + self.logdir + "/" + client_logfile + "." + client_machine, + event=self.event) + log("INFO: ALU test: wait for client to finish (or some error)") + + self.event.wait() + log("DEBUG: event.wait() done") + + if ( not self.task_enb.alive() or + not self.task_hss.alive() or + not self.task_ue.alive()): + log("ERROR: unexpected task exited, test failed, kill all") + if task_traffic_client.alive(): + task_traffic_client.kill() + if self.task_enb.alive(): + self.task_enb.kill() + if self.task_ue.alive(): + self.task_ue.kill() + + ret = task_traffic_client.wait() + if ret != 0: + log("ERROR: ALU test: downlink traffic failed") + #not sure if we have to quit here or not + #os._exit(1) + + #stop downlink server + #log("INFO: ALU test: stop server (kill ssh connection)") + #task_traffic_server.kill() + log("INFO: ALU test: stop server (ctrl+z then kill -9 %1)") + task_traffic_server.sendnow("%ckill -9 %%1 || true\n" % 26) + log("INFO: ALU test: wait for server to quit") + task_traffic_server.wait() + + self.event.clear() + + if ( not self.task_enb.alive() or + not self.task_hss.alive() or + not self.task_ue.alive()): + log("ERROR: ALU test: eNB, HSS or UE task died") + raise TestFailed() + + ########################################################################## + # dl_tcp + ########################################################################## + def dl_tcp(self): + self._do_traffic("bandrich downlink TCP", + "server_tcp", self.ue_machine, self.bandrich_ue_ip, + "client_tcp", self.epc_machine, + "Server listening on TCP port 5001", + "bandrich_downlink_tcp_server", + "bandrich_downlink_tcp_client") + + ########################################################################## + # ul_tcp + ########################################################################## + def ul_tcp(self): + self._do_traffic("bandrich uplink TCP", + "server_tcp", self.epc_machine, "192.172.0.1", + "client_tcp", self.ue_machine, + "Server listening on TCP port 5001", + "bandrich_uplink_tcp_server", + "bandrich_uplink_tcp_client") + + ########################################################################## + # dl_udp + ########################################################################## + def dl_udp(self, bandwidth): + self._do_traffic("bandrich downlink UDP", + "server_udp", self.ue_machine, self.bandrich_ue_ip, + "client_udp", self.epc_machine, + "Server listening on UDP port 5001", + "bandrich_downlink_udp_server", + "bandrich_downlink_udp_client", + udp_bandwidth=bandwidth) + + ########################################################################## + # ul_udp + ########################################################################## + def ul_udp(self, bandwidth): + self._do_traffic("bandrich uplink UDP", + "server_udp", self.epc_machine, "192.172.0.1", + "client_udp", self.ue_machine, + "Server listening on UDP port 5001", + "bandrich_uplink_udp_server", + "bandrich_uplink_udp_client", + udp_bandwidth=bandwidth) + +############################################################################## +# run_b210_alu +############################################################################## + +def run_b210_alu(tests, openair_dir, oai_user, oai_password, env): + if not do_tests(tests['b210']['alu']): + return + + #compile eNB + + alu = alu_test(epc='amerique', enb='hutch', ue='stevens', + openair=openair_dir, + user=oai_user, password=oai_password, + log_subdir='enb_tests/b210_alu/compile_enb', + env=env) + + try: + alu.compile_enb("--eNB -w USRP -x -c --disable-cpu-affinity") + except BaseException, e: + log("ERROR: ALU test failed: eNB compilation failed: " + str(e)) + return + + #run tests + + udp_dl_bandwidth = { "5" : "15M", + "10" : "30M", + "20" : "60M" } + + udp_ul_bandwidth = { "5" : "7M", + "10" : "15M", + "20" : "15M" } + + for bw in ('5', '10', '20'): + if do_tests(tests['b210']['alu'][bw]): + log("INFO: ALU test: run tests for bandwidth " + bw + " MHz") + ctest = tests['b210']['alu'][bw] + alu = alu_test(epc='amerique', enb='hutch', ue='stevens', + openair=openair_dir, + user=oai_user, password=oai_password, + log_subdir='enb_tests/b210_alu/' + bw, + env=env) + try: + alu.start_epc() + alu.start_enb("enb.band7.tm1.usrpb210." + bw + "MHz.conf") + if do_tests(ctest['bandrich']): + alu.start_bandrich_ue() + if do_tests(ctest['bandrich']['tcp']['dl']): alu.dl_tcp() + if do_tests(ctest['bandrich']['tcp']['ul']): alu.ul_tcp() + if do_tests(ctest['bandrich']['udp']['dl']): + alu.dl_udp(udp_dl_bandwidth[bw]) + if do_tests(ctest['bandrich']['udp']['ul']): + alu.ul_udp(udp_ul_bandwidth[bw]) + alu.stop_bandrich_ue() + alu.stop_enb() + alu.stop_epc() + except BaseException, e: + log("ERROR: ALU test failed: " + str(e)) + alu.finish() diff --git a/cmake_targets/autotests/v2/config/enb.band7.tm1.usrpb210.10MHz.conf b/cmake_targets/autotests/v2/config/enb.band7.tm1.usrpb210.10MHz.conf new file mode 100644 index 0000000000000000000000000000000000000000..3b15799eb7fe0b2524c24ff68d3a995d22eb1c2c --- /dev/null +++ b/cmake_targets/autotests/v2/config/enb.band7.tm1.usrpb210.10MHz.conf @@ -0,0 +1,175 @@ +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 = "92"; + + ////////// Physical parameters: + + component_carriers = ( + { + node_function = "eNodeB_3GPP"; + 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_antenna_ports = 1; + 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 = -24; + 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 = -96; + pusch_alpha = "AL1"; + pucch_p0_Nominal = -103; + 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 = -104; + 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; + + ue_TransmissionMode = 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 = "192.168.12.26"; + ipv6 = "192:168:30::17"; + active = "yes"; + preference = "ipv4"; + } + ); + + NETWORK_INTERFACES : + { + + ENB_INTERFACE_NAME_FOR_S1_MME = "eth0"; + ENB_IPV4_ADDRESS_FOR_S1_MME = "192.168.12.19/24"; + ENB_INTERFACE_NAME_FOR_S1U = "eth0"; + ENB_IPV4_ADDRESS_FOR_S1U = "192.168.12.19/24"; + ENB_PORT_FOR_S1U = 2152; # Spec 2152 + }; + + 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"; + }; + } +); diff --git a/cmake_targets/autotests/v2/config/enb.band7.tm1.usrpb210.20MHz.conf b/cmake_targets/autotests/v2/config/enb.band7.tm1.usrpb210.20MHz.conf new file mode 100644 index 0000000000000000000000000000000000000000..869c7f05f1bb3006c3f8c9b11ec10d7ab7f77ffa --- /dev/null +++ b/cmake_targets/autotests/v2/config/enb.band7.tm1.usrpb210.20MHz.conf @@ -0,0 +1,175 @@ +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 = "92"; + + ////////// Physical parameters: + + component_carriers = ( + { + node_function = "eNodeB_3GPP"; + 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_antenna_ports = 1; + 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 = -24; + 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 = -96; + pusch_alpha = "AL1"; + pucch_p0_Nominal = -103; + 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 = -104; + 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; + + ue_TransmissionMode = 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 = "192.168.12.26"; + ipv6 = "192:168:30::17"; + active = "yes"; + preference = "ipv4"; + } + ); + + NETWORK_INTERFACES : + { + + ENB_INTERFACE_NAME_FOR_S1_MME = "eth0"; + ENB_IPV4_ADDRESS_FOR_S1_MME = "192.168.12.19/24"; + ENB_INTERFACE_NAME_FOR_S1U = "eth0"; + ENB_IPV4_ADDRESS_FOR_S1U = "192.168.12.19/24"; + ENB_PORT_FOR_S1U = 2152; # Spec 2152 + }; + + 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"; + }; + } +); diff --git a/cmake_targets/autotests/v2/config/enb.band7.tm1.usrpb210.5MHz.conf b/cmake_targets/autotests/v2/config/enb.band7.tm1.usrpb210.5MHz.conf new file mode 100644 index 0000000000000000000000000000000000000000..d3c1a5354a377a8c570c76735104919c2db32ae1 --- /dev/null +++ b/cmake_targets/autotests/v2/config/enb.band7.tm1.usrpb210.5MHz.conf @@ -0,0 +1,175 @@ +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 = "92"; + + ////////// Physical parameters: + + component_carriers = ( + { + node_function = "eNodeB_3GPP"; + 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 = 25; + Nid_cell_mbsfn = 0; + nb_antenna_ports = 1; + 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 = -24; + 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 = -96; + pusch_alpha = "AL1"; + pucch_p0_Nominal = -103; + 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 = -104; + 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; + + ue_TransmissionMode = 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 = "192.168.12.26"; + ipv6 = "192:168:30::17"; + active = "yes"; + preference = "ipv4"; + } + ); + + NETWORK_INTERFACES : + { + + ENB_INTERFACE_NAME_FOR_S1_MME = "eth0"; + ENB_IPV4_ADDRESS_FOR_S1_MME = "192.168.12.19/24"; + ENB_INTERFACE_NAME_FOR_S1U = "eth0"; + ENB_IPV4_ADDRESS_FOR_S1U = "192.168.12.19/24"; + ENB_PORT_FOR_S1U = 2152; # Spec 2152 + }; + + 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"; + }; + } +); diff --git a/cmake_targets/autotests/v2/connection.py b/cmake_targets/autotests/v2/connection.py new file mode 100644 index 0000000000000000000000000000000000000000..1952b8b72f713ff2eb7cff44802b6b18fc138f63 --- /dev/null +++ b/cmake_targets/autotests/v2/connection.py @@ -0,0 +1,104 @@ +import os, subprocess, time, fcntl, termios, tty, signal, thread + +from utils import log + +class connection: + def __init__(self, description, host, user, password): + self.description = description + self.host = host + self.user = user + self.password = password + self.sendlock = thread.allocate_lock() + + try: + (pid, fd) = os.forkpty() + except BaseException, e: + log("ERROR: forkpty for '" + description + "': " + e) + (pid, fd) = (-1, -1) + + if pid == -1: + log("ERROR: creating connection for '" + description + "'") + os._exit(1) + + # child process, run ssh + if pid == 0: + try: + os.execvp('sshpass', ['sshpass', '-p', password, + 'ssh', user + '@' + host]) + except BaseException, e: + log("ERROR: execvp for '" + description + "': " + e) + log("ERROR: execvp failed for '" + description + "'") + os._exit(1) + + # parent process + # make the TTY raw to avoid getting input printed and no ^M + try: + tty.setraw(fd, termios.TCSANOW) + except BaseException, e: + log("ERROR: failed configuring TTY: " + str(e)) + os._exit(1) + +# try: +# fcntl.fcntl(fd, fcntl.F_SETFL, +# fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NONBLOCK) +# except: +# log("ERROR: fcntl failed for '" + description + "'") +# os._exit(1) + + self.pid = pid + self.fd = fd + self.active = True + self.retcode = -1 + + def send(self, string): + if self.active == False: + log("ERROR: send: child is dead for '" + self.description + "'") + return -1 + + try: + (pid, out) = os.waitpid(self.pid, os.WNOHANG) + except BaseException, e: + log("ERROR: send: waitpid failed for '" + self.description + + "': " + str(e)) + (pid, out) = (self.pid, 1) + if pid != 0: + log("ERROR: send: child process dead for '" + + self.description + "'") + try: + os.close(self.fd) + except BaseException, e: + #we don't care about errors at this point + pass + self.active = False + self.retcode = out + return -1 + + self.sendlock.acquire() + + length = len(string) + while length != 0: + try: + ret = os.write(self.fd, string) + except BaseException, e: + log("ERROR: send fails for '" + self.description + "': " + + str(e)) + os._exit(1) + + if ret == 0: + log("ERROR: send: write returns 0 for '" + + self.description + "'") + os._exit(1) + + length = length - ret + string = string[ret:] + + self.sendlock.release() + + return 0 + + def kill(self, signal=signal.SIGTERM): + log("INFO: kill connection '" + self.description + "'") + try: + os.kill(self.pid, signal) + except BaseException, e: + log("ERROR: connection.kill: " + str(e)) diff --git a/cmake_targets/autotests/v2/machine_list.py b/cmake_targets/autotests/v2/machine_list.py new file mode 100644 index 0000000000000000000000000000000000000000..dc41c504fe56695e5071372eca0e289ab72aa561 --- /dev/null +++ b/cmake_targets/autotests/v2/machine_list.py @@ -0,0 +1,79 @@ +import threading, os + +from utils import log + +class MachineWaiterThread(threading.Thread): + def __init__(self, machine, tasks): + threading.Thread.__init__(self) + self.machine = machine + self.tasks = tasks + + def run(self): + try: + for task in self.tasks: + ret = task.wait() + if ret != 0: + log("ERROR: task '" + task.description + "' failed " + + "on machine " + self.machine.name) + task.postaction() + self.machine.unbusy() + except BaseException, e: + log("ERROR: MachineWaiterThread: " + str(e)) + os._exit(1) + +class Machine(): + def __init__(self, machine, cond): + self.name = machine + self.free = True + self.cond = cond + def busy(self, tasks): + waiter = MachineWaiterThread(self, tasks) + waiter.start() + def unbusy(self): + self.cond.acquire() + self.free = True + self.cond.notify() + self.cond.release() + +class MachineList(): + def __init__(self, list): + self.list = [] + self.cond = threading.Condition() + for m in list: + self.list.append(Machine(m, self.cond)) + + def get_free_machine(self): + try: + self.cond.acquire() + while True: + free_machine = None + for m in self.list: + if m.free == True: + free_machine = m + break + if free_machine != None: + break + self.cond.wait() + free_machine.free = False + self.cond.release() + except BaseException, e: + log("ERROR: machine_list: " + str(e)) + os._exit(1) + return free_machine + + def wait_all_free(self): + try: + self.cond.acquire() + while True: + all_free = True + for m in self.list: + if m.free == False: + all_free = False + break + if all_free == True: + break + self.cond.wait() + self.cond.release() + except BaseException, e: + log("ERROR: machine_list: " + str(e)) + os._exit(1) diff --git a/cmake_targets/autotests/v2/main.py b/cmake_targets/autotests/v2/main.py new file mode 100644 index 0000000000000000000000000000000000000000..6cf3b97c3608579706058f0ba465c84f86fbb734 --- /dev/null +++ b/cmake_targets/autotests/v2/main.py @@ -0,0 +1,687 @@ +#!/usr/bin/python + +import os, re, sys, time, threading, thread +import xml.etree.ElementTree as ET + +from utils import test_in_list, quickshell, log +from task import Task, WAITLOG_SUCCESS, WAITLOG_FAILURE +from machine_list import MachineList + +oai_user = os.environ.get('OAI_USER') +oai_password = os.environ.get('OAI_PASS') +requested_tests = os.environ.get('OAI_TEST_CASE_GROUP') +machines = os.environ.get('MACHINELIST') +generic_machines = os.environ.get('MACHINELISTGENERIC') +result_dir = os.environ.get('RESULT_DIR') +nruns_softmodem = os.environ.get('NRUNS_LTE_SOFTMODEM') +openair_dir = os.environ.get('OPENAIR_DIR') + +some_undef = False +if (oai_user == None) : + log("variable OAI_USER is not defined") + some_undef = True +if (oai_password == None) : + log("variable OAI_PASS is not defined") + some_undef = True +if (requested_tests == None) : + log("variable OAI_TEST_CASE_GROUP is not defined") + some_undef = True +if (machines == None) : + log("variable MACHINELIST is not defined") + some_undef = True +if (generic_machines == None) : + log("variable MACHINELISTGENERIC is not defined") + some_undef = True +if (result_dir == None) : + log("variable RESULT_DIR is not defined") + some_undef = True +if (nruns_softmodem == None) : + log("variable NRUNS_LTE_SOFTMODEM is not defined") + some_undef = True +if (openair_dir == None) : + log("variable OPENAIR_DIR is not defined") + some_undef = True +if (some_undef == True): + os._exit(1) + +requested_tests = requested_tests .replace('"','') +machines = machines .replace('"','') +generic_machines = generic_machines .replace('"','') + +xml_test_file = os.environ.get('OPENAIR_DIR') + \ + "/cmake_targets/autotests/test_case_list.xml" + +xmlTree = ET.parse(xml_test_file) +xmlRoot = xmlTree.getroot() + +exclusion_tests=xmlRoot.findtext('TestCaseExclusionList',default='') +all_tests=xmlRoot.findall('testCase') + +exclusion_tests=exclusion_tests.split() +requested_tests=requested_tests.split() + +#check that exclusion tests are well formatted +#(6 digits or less than 6 digits followed by +) +for test in exclusion_tests: + if (not re.match('^[0-9]{6}$', test) and + not re.match('^[0-9]{1,5}\+$', test)): + log("ERROR: exclusion test is invalidly formatted: " + test) + os._exit(1) + +#check that requested tests are well formatted +#(6 digits or less than 6 digits followed by +) +#be verbose +for test in requested_tests: + if (re.match('^[0-9]{6}$', test) or + re.match('^[0-9]{1,5}\+$', test)): + log("INFO: test group/case requested: " + test) + else: + log("ERROR: requested test is invalidly formatted: " + test) + os._exit(1) + +#get the list of tests to be done +todo_tests=[] +for test in all_tests: + if (test_in_list(test.get('id'), requested_tests) and + not test_in_list(test.get('id'), exclusion_tests)): + log("INFO: test will be run: " + test.get('id')) + todo_tests.append(test) + else: + log("INFO: test will be skipped: " + test.get('id')) + +#get commit ID to use +commit_id = quickshell("git rev-parse --verify HEAD").replace('\n','') +if (len(commit_id) != 20*2): + log("ERROR: bad commit '" + commit_id + "'") +log("INFO: test for commit " + commit_id) + +#get repository URL +repository_url = quickshell("git config remote.origin.url").replace('\n','') +log("INFO: repository URL: " + repository_url) + +#prepare environment for tasks +env = [] +env.append("REPOSITORY_URL=" + repository_url) +env.append("COMMIT_ID=" + commit_id) + +#clone repository on all machines in the test setup +tasks=[] +for machine in machines.split(): + tasks.append(Task("actions/clone_repository.bash", + "clone repository on " + machine, + machine, + oai_user, + oai_password, + env, + openair_dir + "/cmake_targets/autotests/log/clone." \ + + machine)) +for task in tasks: + log("INFO: wait for task: " + task.description) + ret = task.wait() + if ret != 0 or not "TEST_SETUP_SUCCESS" in open(task.logfile).read(): + log("ERROR: task failed: " + task.description) + os._exit(1) + +############################################################################## +# run compilation tests # +############################################################################## + +machine_list = MachineList(generic_machines.split()) + +for test in todo_tests: + action = test.findtext('class') + if action != 'compilation': + continue + id = test.get('id') + machine = machine_list.get_free_machine() + log("INFO: start " + action + " test " + id + " on machine " + + machine.name) + tasks = [] + runenv = list(env) + runenv.append('OPENAIR_DIR=/tmp/oai_test_setup/oai') + runenv.append('BUILD_ARGUMENTS="' + + test.findtext('compile_prog_args') + + '"') + runenv.append('BUILD_OUTPUT="' + + test.findtext('compile_prog_out') + .replace('\n','') + + '"') + logdir = openair_dir +"/cmake_targets/autotests/log/"+ id +"/compile_log" + remote_files = "'/tmp/oai_test_setup/oai/cmake_targets/log/*'" + post_action = "mkdir -p "+ logdir + \ + " && sshpass -p " + oai_password + " scp -r " + oai_user + \ + "@" + machine.name + ":" + remote_files + " " + logdir + \ + " || true" + tasks.append(Task("actions/" + action + ".bash", + action + " of test " + id + " on " + machine.name, + machine.name, + oai_user, + oai_password, + runenv, + openair_dir + "/cmake_targets/autotests/log/" + + id + "." + + machine.name, + post_action=post_action)) + machine.busy(tasks) + +############################################################################## +# run execution tests # +############################################################################## + +class ExecutionThread(threading.Thread): + def __init__(self, id, machine, test): + threading.Thread.__init__(self) + self.machine = machine + self.id = id + self.test = test + + def run(self): + id = self.id + machine = self.machine + test = self.test + + # step 1: compile + + log("INFO: start compilation of test " + id + " on machine " + + machine.name) + tasks = [] + runenv = list(env) + runenv.append('OPENAIR_DIR=/tmp/oai_test_setup/oai') + runenv.append('PRE_BUILD="' + + test.findtext('pre_compile_prog') + + '"') + runenv.append('BUILD_PROG="' + + test.findtext('compile_prog') + + '"') + runenv.append('BUILD_ARGUMENTS="' + + test.findtext('compile_prog_args') + + '"') + runenv.append('PRE_EXEC="' + + test.findtext('pre_exec') + " " + + test.findtext('pre_exec_args') + + '"') + logdir = openair_dir +"/cmake_targets/autotests/log/"+ id + \ + "/compile_log" + remote_files = "'/tmp/oai_test_setup/oai/cmake_targets/log/*'" + post_action = "mkdir -p "+ logdir + \ + " && sshpass -p " + oai_password + \ + " scp -r " + oai_user + "@" + machine.name + ":" + \ + remote_files + " " + logdir + \ + " || true" + task = Task("actions/execution_compile.bash", + "compilation of test " + id + " on " + machine.name, + machine.name, + oai_user, + oai_password, + runenv, + openair_dir + "/cmake_targets/autotests/log/" + + id + "_compile." + + machine.name, + post_action=post_action) + ret = task.wait() + task.postaction() + if ret != 0: + log("ERROR: compilation of test " + id + " failed: " + str(ret)) + machine.unbusy() + return + + #step 2: run all tests + + nruns = test.findtext('nruns') + args = test.findtext('main_exec_args') + i = 0 + for arg in args.splitlines(): + i = i+1 + runenv2 = list(runenv) + runenv2.append('OPENAIR_TARGETS=/tmp/oai_test_setup/oai/targets') + runenv2.append('EXEC="' + + test.findtext('main_exec') + + '"') + runenv2.append('EXEC_ARGS="' + arg + '"') + for run in range(int(nruns)): + log("INFO: start execution of test " + id + " case " + + str(i) + " run " + str(run) + " on machine " + + machine.name) + task =Task("actions/execution.bash", + "execution of test " + id + " on " + machine.name, + machine.name, + oai_user, + oai_password, + runenv2, + openair_dir + "/cmake_targets/autotests/log/" + + id + "_case_" + str(i) + "_run_" + str(run) + + "." + machine.name) + ret = task.wait() + if ret != 0: + log("ERROR: execution of test " +id+ " failed: " + + str(ret)) + + machine.unbusy() + +for test in todo_tests: + action = test.findtext('class') + if action != 'execution': + continue + id = test.get('id') + machine = machine_list.get_free_machine() + ExecutionThread(id, machine, test).start() + +#wait for compilation/execution tests to be finished +#log only if some compilation/execution tests are actually done +for test in todo_tests: + action = test.findtext('class') + if action == 'execution' or action == 'compilation': + log("INFO: requested compilation/execution tests " + + "have been launched, waiting for completion") + break +machine_list.wait_all_free() + +############################################################################## +# run eNB softmodem tests # +############################################################################## + +tests = { + 'b210' : { + 'alu' : { + '5' : { + 'bandrich' : { + 'tcp' : { 'ul': False, 'dl' : False }, + 'udp' : { 'ul': False, 'dl' : False }}, + 'sony' : { + 'tcp' : { 'ul': False, 'dl' : False }, + 'udp' : { 'ul': False, 'dl' : False }}}, + '10' : { + 'bandrich' : { + 'tcp' : { 'ul': False, 'dl' : False }, + 'udp' : { 'ul': False, 'dl' : False }}, + 'sony' : { + 'tcp' : { 'ul': False, 'dl' : False }, + 'udp' : { 'ul': False, 'dl' : False }}}, + '20' : { + 'bandrich' : { + 'tcp' : { 'ul': False, 'dl' : False }, + 'udp' : { 'ul': False, 'dl' : False }}, + 'sony' : { + 'tcp' : { 'ul': False, 'dl' : False }, + 'udp' : { 'ul': False, 'dl' : False }}}}, + 'openair-cn' : {} + }, + 'x310' : { + 'alu' : {}, + 'openair-cn' : {} + }, + 'exmimo2' : { + 'alu' : {}, + 'openair-cn' : {} + } +} + +todo_tests_ids = [] +for test in todo_tests: + todo_tests_ids.append(test.get('id')) + +for test in todo_tests_ids: + if test=='015500':tests['b210']['alu'][ '5']['bandrich']['udp']['ul']=True + if test=='015501':tests['b210']['alu']['10']['bandrich']['udp']['ul']=True + if test=='015502':tests['b210']['alu']['20']['bandrich']['udp']['ul']=True + if test=='015503':tests['b210']['alu'][ '5']['bandrich']['udp']['dl']=True + if test=='015504':tests['b210']['alu']['10']['bandrich']['udp']['dl']=True + if test=='015505':tests['b210']['alu']['20']['bandrich']['udp']['dl']=True + if test=='015506':log('WARNING: skip test ' + test) #TODO + if test=='015507':log('WARNING: skip test ' + test) #TODO + if test=='015508':log('WARNING: skip test ' + test) #TODO + if test=='015509':log('WARNING: skip test ' + test) #TODO + if test=='015510':log('WARNING: skip test ' + test) #TODO + if test=='015511':log('WARNING: skip test ' + test) #TODO + if test=='015512':tests['b210']['alu'][ '5']['bandrich']['tcp']['ul']=True + if test=='015513':tests['b210']['alu']['10']['bandrich']['tcp']['ul']=True + if test=='015514':tests['b210']['alu']['20']['bandrich']['tcp']['ul']=True + if test=='015515':tests['b210']['alu'][ '5']['bandrich']['tcp']['dl']=True + if test=='015516':tests['b210']['alu']['10']['bandrich']['tcp']['dl']=True + if test=='015517':tests['b210']['alu']['20']['bandrich']['tcp']['dl']=True + if test=='015518':log('WARNING: skip test ' + test) #TODO + if test=='015519':log('WARNING: skip test ' + test) #TODO + if test=='015520':log('WARNING: skip test ' + test) #TODO + if test=='015521':log('WARNING: skip test ' + test) #TODO + if test=='015522':log('WARNING: skip test ' + test) #TODO + if test=='015523':log('WARNING: skip test ' + test) #TODO + + if test=='015600':log('WARNING: skip test ' + test) #TODO + if test=='015601':log('WARNING: skip test ' + test) #TODO + if test=='015602':log('WARNING: skip test ' + test) #TODO + if test=='015603':log('WARNING: skip test ' + test) #TODO + if test=='015604':log('WARNING: skip test ' + test) #TODO + if test=='015605':log('WARNING: skip test ' + test) #TODO + + if test=='015700':log('WARNING: skip test ' + test) #TODO + if test=='015701':log('WARNING: skip test ' + test) #TODO + if test=='015702':log('WARNING: skip test ' + test) #TODO + if test=='015703':log('WARNING: skip test ' + test) #TODO + if test=='015704':log('WARNING: skip test ' + test) #TODO + if test=='015705':log('WARNING: skip test ' + test) #TODO + + if test=='015800':log('WARNING: skip test ' + test) #TODO + if test=='015801':log('WARNING: skip test ' + test) #TODO + if test=='015802':log('WARNING: skip test ' + test) #TODO + if test=='015803':log('WARNING: skip test ' + test) #TODO + if test=='015804':log('WARNING: skip test ' + test) #TODO + if test=='015805':log('WARNING: skip test ' + test) #TODO + if test=='015806':log('WARNING: skip test ' + test) #TODO + if test=='015807':log('WARNING: skip test ' + test) #TODO + if test=='015808':log('WARNING: skip test ' + test) #TODO + if test=='015809':log('WARNING: skip test ' + test) #TODO + if test=='015810':log('WARNING: skip test ' + test) #TODO + if test=='015811':log('WARNING: skip test ' + test) #TODO + if test=='015812':log('WARNING: skip test ' + test) #TODO + if test=='015813':log('WARNING: skip test ' + test) #TODO + if test=='015814':log('WARNING: skip test ' + test) #TODO + if test=='015815':log('WARNING: skip test ' + test) #TODO + if test=='015816':log('WARNING: skip test ' + test) #TODO + if test=='015817':log('WARNING: skip test ' + test) #TODO + if test=='015818':log('WARNING: skip test ' + test) #TODO + if test=='015819':log('WARNING: skip test ' + test) #TODO + if test=='015820':log('WARNING: skip test ' + test) #TODO + if test=='015821':log('WARNING: skip test ' + test) #TODO + if test=='015822':log('WARNING: skip test ' + test) #TODO + if test=='015823':log('WARNING: skip test ' + test) #TODO + + if test=='016000':log('WARNING: skip test ' + test) #TODO + if test=='016001':log('WARNING: skip test ' + test) #TODO + if test=='016002':log('WARNING: skip test ' + test) #TODO + if test=='016003':log('WARNING: skip test ' + test) #TODO + if test=='016004':log('WARNING: skip test ' + test) #TODO + if test=='016005':log('WARNING: skip test ' + test) #TODO + + if test=='016100':log('WARNING: skip test ' + test) #TODO + if test=='016101':log('WARNING: skip test ' + test) #TODO + if test=='016102':log('WARNING: skip test ' + test) #TODO + if test=='016103':log('WARNING: skip test ' + test) #TODO + if test=='016104':log('WARNING: skip test ' + test) #TODO + if test=='016105':log('WARNING: skip test ' + test) #TODO + + if test=='016300':log('WARNING: skip test ' + test) #TODO + if test=='016301':log('WARNING: skip test ' + test) #TODO + if test=='016302':log('WARNING: skip test ' + test) #TODO + if test=='016303':log('WARNING: skip test ' + test) #TODO + if test=='016304':log('WARNING: skip test ' + test) #TODO + if test=='016305':log('WARNING: skip test ' + test) #TODO + + if test=='016500':log('WARNING: skip test ' + test) #TODO + if test=='016501':log('WARNING: skip test ' + test) #TODO + if test=='016502':log('WARNING: skip test ' + test) #TODO + if test=='016503':log('WARNING: skip test ' + test) #TODO + if test=='016504':log('WARNING: skip test ' + test) #TODO + if test=='016505':log('WARNING: skip test ' + test) #TODO + + if test=='017000':log('WARNING: skip test ' + test) #TODO + if test=='017001':log('WARNING: skip test ' + test) #TODO + if test=='017002':log('WARNING: skip test ' + test) #TODO + if test=='017003':log('WARNING: skip test ' + test) #TODO + if test=='017004':log('WARNING: skip test ' + test) #TODO + if test=='017005':log('WARNING: skip test ' + test) #TODO + + if test=='017500':log('WARNING: skip test ' + test) #TODO + if test=='017501':log('WARNING: skip test ' + test) #TODO + if test=='017502':log('WARNING: skip test ' + test) #TODO + if test=='017503':log('WARNING: skip test ' + test) #TODO + if test=='017504':log('WARNING: skip test ' + test) #TODO + if test=='017505':log('WARNING: skip test ' + test) #TODO + + if test=='018000':log('WARNING: skip test ' + test) #TODO + if test=='018001':log('WARNING: skip test ' + test) #TODO + if test=='018002':log('WARNING: skip test ' + test) #TODO + if test=='018003':log('WARNING: skip test ' + test) #TODO + if test=='018004':log('WARNING: skip test ' + test) #TODO + if test=='018005':log('WARNING: skip test ' + test) #TODO + + if test=='018500':log('WARNING: skip test ' + test) #TODO + if test=='018501':log('WARNING: skip test ' + test) #TODO + if test=='018502':log('WARNING: skip test ' + test) #TODO + if test=='018503':log('WARNING: skip test ' + test) #TODO + if test=='018504':log('WARNING: skip test ' + test) #TODO + if test=='018505':log('WARNING: skip test ' + test) #TODO + + if test=='025500':log('WARNING: skip test ' + test) #TODO + if test=='025501':log('WARNING: skip test ' + test) #TODO + if test=='025502':log('WARNING: skip test ' + test) #TODO + if test=='025503':log('WARNING: skip test ' + test) #TODO + if test=='025504':log('WARNING: skip test ' + test) #TODO + if test=='025505':log('WARNING: skip test ' + test) #TODO + if test=='025506':log('WARNING: skip test ' + test) #TODO + if test=='025507':log('WARNING: skip test ' + test) #TODO + if test=='025508':log('WARNING: skip test ' + test) #TODO + if test=='025509':log('WARNING: skip test ' + test) #TODO + if test=='025510':log('WARNING: skip test ' + test) #TODO + if test=='025511':log('WARNING: skip test ' + test) #TODO + if test=='025512':log('WARNING: skip test ' + test) #TODO + if test=='025513':log('WARNING: skip test ' + test) #TODO + if test=='025514':log('WARNING: skip test ' + test) #TODO + if test=='025515':log('WARNING: skip test ' + test) #TODO + if test=='025516':log('WARNING: skip test ' + test) #TODO + if test=='025517':log('WARNING: skip test ' + test) #TODO + if test=='025518':log('WARNING: skip test ' + test) #TODO + if test=='025519':log('WARNING: skip test ' + test) #TODO + if test=='025520':log('WARNING: skip test ' + test) #TODO + if test=='025521':log('WARNING: skip test ' + test) #TODO + if test=='025522':log('WARNING: skip test ' + test) #TODO + if test=='025523':log('WARNING: skip test ' + test) #TODO + + if test=='025700':log('WARNING: skip test ' + test) #TODO + if test=='025701':log('WARNING: skip test ' + test) #TODO + if test=='025702':log('WARNING: skip test ' + test) #TODO + if test=='025703':log('WARNING: skip test ' + test) #TODO + if test=='025704':log('WARNING: skip test ' + test) #TODO + if test=='025705':log('WARNING: skip test ' + test) #TODO + +from alu_test import run_b210_alu + +#B210 ALU tests + +run_b210_alu(tests, openair_dir, oai_user, oai_password, env) + +#for test in todo_tests: +# action = test.findtext('class') +# if action != 'lte-softmodem': +# continue +# if not "start_ltebox" in test.findtext('EPC_main_exec'): +# continue +# id = test.get('id') +# log("INFO: Running ALU test " + id) +# logdir = openair_dir + "/cmake_targets/autotests/log/" + id +# quickshell("mkdir -p " + logdir) +# epc_machine = test.findtext('EPC') +# enb_machine = test.findtext('eNB') +# ue_machine = test.findtext('UE') +# +# #event object used to wait for several tasks at once +# event = threading.Event() +# +# #launch HSS, wait for prompt +# log("INFO: " + id + ": run HSS") +# task_hss = Task("actions/alu_hss.bash", +# "ALU HSS", +# epc_machine, +# oai_user, +# oai_password, +# env, +# logdir + "/alu_hss." + epc_machine, event=event) +# task_hss.waitlog('S6AS_SIM-> ') +# +# #then launch EPC, wait for connection on HSS side +# log("INFO: " + id + ": run EPC") +# task = Task("actions/alu_epc.bash", +# "ALU EPC", +# epc_machine, +# oai_user, +# oai_password, +# env, +# logdir + "/alu_epc." + epc_machine) +# ret = task.wait() +# if ret != 0: +# log("ERROR: EPC start failure"); +# os._exit(1) +# task_hss.waitlog('Connected\n') +# +# #compile softmodem +# log("INFO: " + id + ": compile softmodem") +# envcomp = list(env) +# envcomp.append('BUILD_ARGUMENTS="' + +# test.findtext('eNB_compile_prog_args') + '"') +# #we don't care about BUILD_OUTPUT but it's required (TODO: change that) +# envcomp.append('BUILD_OUTPUT=/') +# task = Task("actions/compilation.bash", +# "compile softmodem", +# enb_machine, +# oai_user, +# oai_password, +# envcomp, +# logdir + "/compile_softmodem." + enb_machine) +# ret = task.wait() +# if ret != 0: +# log("ERROR: softmodem compilation failure"); +# os._exit(1) +# +## #copy wanted configuration file +## quickshell("sshpass -p " + oai_password + +## " scp config/enb.band7.tm1.usrpb210.conf " + +## oai_user + "@" + enb_machine + ":/tmp/enb.conf") +# +# #run softmodem +# log("INFO: " + id + ": run softmodem") +# task_enb = Task("actions/run_enb.bash", +# "run softmodem", +# enb_machine, +# oai_user, +# oai_password, +# env, +# logdir + "/run_softmodem." + enb_machine, event=event) +# task_enb.waitlog('got sync') +# +# #start UE +# log("INFO: " + id + ": start bandrich UE") +# task_ue = Task("actions/start_bandrich.bash", +# "start bandrich UE", +# ue_machine, +# oai_user, +# oai_password, +# env, +# logdir + "/start_bandrich." + ue_machine, event=event) +# task_ue.waitlog("local IP address", event=event) +# +# event.wait() +# +# #at this point one task has died or we have the line in the log +# if task_ue.waitlog_state != WAITLOG_SUCCESS: +# log("ERROR: " + id + ": bandrich UE did not connect") +# os._exit(1) +# +# event.clear() +# +# if ( not task_enb.alive() or +# not task_hss.alive() or +# not task_ue.alive()): +# log("ERROR: " + id + ": eNB or UE tasks died") +# os._exit(1) +# +# #get bandrich UE IP +# l = open(task_ue.logfile, "r").read() +# ue_ip = re.search("local IP address (.*)\n", l).groups()[0] +# log("INFO: " + id + ": bandrich UE IP address: " + ue_ip) +# +# #run traffic +# log("INFO: " + id + ": run downlink TCP traffic") +# +# log("INFO: " + id + ": launch server") +# task_traffic_ue = Task("actions/downlink_bandrich.bash", +# "start iperf on bandrich UE as server", +# ue_machine, +# oai_user, +# oai_password, +# env, +# logdir + "/downlink_bandrich." + ue_machine, +# event=event) +# task_traffic_ue.waitlog("Server listening on TCP port 5001") +# +# log("INFO: " + id + ": launch client") +# envepc = list(env) +# envepc.append("UE_IP=" + ue_ip) +# task = Task("actions/downlink_epc.bash", +# "start iperf on EPC as client", +# epc_machine, +# oai_user, +# oai_password, +# envepc, +# logdir + "/downlink_epc." + epc_machine, event=event) +# log("INFO: " + id + ": wait for client (or some error)") +# +# event.wait() +# log("DEBUG: event.wait() done") +# +# if ( not task_enb.alive() or +# not task_hss.alive() or +# not task_ue.alive()): +# log("ERROR: unexpected task exited, test failed, kill all") +# if task.alive(): +# task.kill() +# if task_enb.alive(): +# task_enb.kill() +# if task_ue.alive(): +# task_ue.kill() +# +# ret = task.wait() +# if ret != 0: +# log("ERROR: " + id + ": downlink traffic failed") +# #not sure if we have to quit here or not +# #os._exit(1) +# +# #stop downlink server +# log("INFO: " + id + ": stop server (kill ssh connection)") +# task_traffic_ue.kill() +# log("INFO: " + id + ": wait for server to quit") +# task_traffic_ue.wait() +# +# #stop UE +# log("INFO: " + id + ": stop bandrich UE") +# task_ue.sendnow("%c" % 3) +# ret = task_ue.wait() +# if ret != 0: +# log("ERROR: " + id + ": task bandrich UE failed") +# #not sure if we have to quit here or not +# #os._exit(1) +# +# #stop softmodem +# log("INFO: " + id + ": stop softmodem") +# task_enb.sendnow("%c" % 3) +# ret = task_enb.wait() +# if ret != 0: +# log("ERROR: " + id + ": softmodem failed") +# #not sure if we have to quit here or not +# #os._exit(1) +# +# #stop EPC, wait for disconnection on HSS side +# log("INFO: " + id + ": stop EPC") +# task = Task("actions/alu_epc_stop.bash", +# "ALU EPC stop", +# epc_machine, +# oai_user, +# oai_password, +# env, +# logdir + "/alu_epc_stop." + epc_machine) +# ret = task.wait() +# if ret != 0: +# log("ERROR: " + id + ": ALU EPC stop failed") +# os._exit(1) +# task_hss.waitlog('Disconnected\n') +# +# log("INFO: " + id + ": stop HSS") +# task_hss.sendnow("exit\n") +# ret = task_hss.wait() +# if ret != 0: +# log("ERROR: " + id + ": ALU HSS failed") +# os._exit(1) + +import utils +log(utils.GREEN + "GOODBYE" + utils.RESET) +#os._exit(0) + +#run lte softmodem tests diff --git a/cmake_targets/autotests/v2/task.py b/cmake_targets/autotests/v2/task.py new file mode 100644 index 0000000000000000000000000000000000000000..68293e33e497bb604f83ced591c39b2034ade5ab --- /dev/null +++ b/cmake_targets/autotests/v2/task.py @@ -0,0 +1,370 @@ +import os, time, threading, sys, os, errno, select +from connection import connection + +import utils +from utils import log + +#this class is to communicate between reader and sender threads +#the reader increments a count each time it receives the prompt +#and wakes up the sender +#it also indicates when it exits so the sender can exit too +#the sender (calling get) waits for the count to be greated than passed +#argument or if reader exited +#it returns argument+1 if things okay, -1 if reader exited +class Counter: + def __init__(self): + self.count = 0 + self.cond = threading.Condition() + + def inc(self): + self.cond.acquire() + self.count = self.count + 1 + self.cond.notify() + self.cond.release() + + def set(self, value): + self.cond.acquire() + self.count = value + self.cond.notify() + self.cond.release() + + def get(self, current): + self.cond.acquire() + while True: + if self.count == -1: + ret = -1 + break + if self.count >= current + 1: + ret = current + 1 + break + self.cond.wait() + self.cond.release() + return ret + +#this class is used for the main application to wait for some specific +#output from the remote program (typically the ALU HSS prompt, indicating +#it is ready and we can proceed further) +#(too much classes...) +class ProducerConsumer: + def __init__(self): + self.count = 0 + self.cond = threading.Condition() + + def add(self, v): + self.cond.acquire() + self.count = self.count + v + self.cond.notify() + self.cond.release() + + def set(self, v): + self.cond.acquire() + self.count = v + self.cond.notify() + self.cond.release() + + def get(self, old): + self.cond.acquire() + while True: + if self.count == -1: + ret = -1 + break + if self.count > old: + ret = self.count + break + self.cond.wait() + self.cond.release() + return ret + +#this thread gets input from the child process of the task +#it removes the prompts it gets (be carefully to use a prompt +#that will not be output of any command otherwise you dead) +class ReaderThread(threading.Thread): + def __init__(self, fdin, logfile, prompt, prompt_counter, producer): + threading.Thread.__init__(self) + self.fdin = fdin + self.logfile = logfile + self.prompt_counter = prompt_counter + self.prompt = prompt + self.promptsize = len(prompt) + self.stack = "" + self.stacksize = 0 + self.producer = producer + + def run(self): + try: + outfile = open(self.logfile, "w") + except BaseException, e: + log("ERROR: ReaderThread: " + self.logfile + ": " + str(e)) + os._exit(1) + while True: + try: + (a, b, c) = select.select([ self.fdin ], [], [ self.fdin ]) + except BaseException, e: + log("ERROR: ReaderThread: " + self.logfile + + ": select failed: " + str(e)) + os._exit(1) + try: + z = os.read(self.fdin, 1024) + except OSError, e: + if e.errno == errno.EIO: + #pipe has died, quit the thread + break + else: + log("ERROR: ReaderThread: " + self.logfile + + ": unhandled error: " + str(e)) + except BaseException, e: + log("ERROR: ReaderThread: " + self.logfile + + ": unhandled error: " + str(e)) + break + try: + produced = 0 + #this part is to remove the prompt + for x in z: + if x == self.prompt[self.stacksize]: + self.stack = self.stack + x + self.stacksize = self.stacksize + 1 + if self.stacksize == self.promptsize: + self.prompt_counter.inc() + self.stack = "" + self.stacksize = 0 + else: + outfile.write(self.stack) + outfile.write(x) + produced = produced + len(self.stack) + len(x) + self.stack = "" + self.stacksize = 0 + outfile.flush() + self.producer.add(produced) + except BaseException, e: + log("ERROR: ReaderThread: " + self.logfile + ": " + str(e)) + os._exit(1) + try: + outfile.close() + except BaseException, e: + log("ERROR: ReaderThread: " + self.logfile + ": " + str(e)) + os._exit(1) + #close the pipe, don't care about errors + try: + os.close(self.fdin) + except: + pass + #signal sender to quit + self.prompt_counter.set(-1) + self.producer.set(-1) + +class SenderQuit(Exception): + pass + +#this thread sends commands to the child process of the task +#it waits for the prompt between each command +#'event' is used for the main thread to wait for one of several tasks +#to quit, meaning error or end-of-test +class SenderThread(threading.Thread): + def __init__(self, fdout, prompt_counter, connection, env, action, + description, prompt, event=None): + threading.Thread.__init__(self) + self.fdin = fdout + self.prompt_counter = prompt_counter + self.connection = connection + self.env = env + self.action = action + self.description = description + self.prompt = prompt + self.count = 0 + self.event = event + self.alive = True + + def wait_prompt(self): + self.count = self.prompt_counter.get(self.count) + if self.count == -1: + raise SenderQuit() + + def _run(self): + self.connection.send('export PS1=' + self.prompt + '\n') + self.wait_prompt() + self.connection.send('set +o emacs\n') + self.wait_prompt() + self.connection.send('echo\n') + self.wait_prompt() + self.connection.send('echo\n') + self.wait_prompt() + self.connection.send("echo -e '" + utils.GREEN + + '---------------------------------------------' + + utils.RESET + "'\n") + self.wait_prompt() + self.connection.send('echo\n') + self.wait_prompt() + self.connection.send("echo -n -e '" + utils.YELLOW + + "COMMANDS START: " + + utils.RESET + "'\n") + self.wait_prompt() + self.connection.send('date\n') + self.wait_prompt() + + for l in self.env: + self.connection.send('export ' + l + '\n') + self.wait_prompt() + + with open(self.action) as f: + for line in f: + self.connection.send("echo -n -e '" + utils.GREEN + + "RUNNING: " + utils.RESET + "'\n") + self.wait_prompt() + self.connection.send("echo '" + + line.replace('\n','') + .replace("'", "'\\''") + "'\n") + self.wait_prompt() + self.connection.send(line) + self.wait_prompt() + self.connection.send("if [ $? != 0 ]; then " + + "echo -e '" + utils.RED + + "TEST_SETUP_ERROR: " + utils.RESET + + "last command failed, exiting'; " + + "date; exit 1; fi\n") + self.wait_prompt() + + self.connection.send("echo -n -e '" + utils.YELLOW + + "COMMANDS DONE: " + + utils.RESET + "'\n") + self.wait_prompt() + self.connection.send('date\n') + self.wait_prompt() + self.connection.send("echo -e '" + utils.GREEN + + "TEST_SETUP_SUCCESS" + utils.RESET + "'\n") + self.wait_prompt() + self.connection.send('exit\n') + + def run(self): + try: + self._run() + except SenderQuit: + log("WARNING: '" + self.description + "' exits too early?") + pass + except BaseException, e: + log("ERROR: task failed: " + str(e)) + log("ERROR: action is: " + self.action) + log("ERROR: description is: " + self.description) + os._exit(1) + + self.alive = False + + if self.event != None: + self.event.set() + +WAITLOG_RUNNING = 0 +WAITLOG_SUCCESS = 1 +WAITLOG_FAILURE = 2 + +class WaitlogFailed(Exception): + pass + +#'event' is used by main thread to wait for any of several threads to quit. +#'Task' passes it the 'SenderThread' above, which sets it when it finishes. +class Task: + def __init__(self, action, description, machine, user, password, env, + logfile, post_action = None, event=None): + self.action = action + self.description = description + self.machine = machine + self.user = user + self.password = password + self.post_action = post_action + self.producer = ProducerConsumer() + self.logfile = logfile + + prompt = "__OAI_TEST_SETUP_PROMPT__:" + prompt_counter = Counter() + + self.connection = connection(description, machine, user, password) + + self.reader = ReaderThread(self.connection.fd, logfile, prompt, + prompt_counter, self.producer) + self.reader.start() + + self.sender = SenderThread(self.connection.fd, prompt_counter, + self.connection, env, action, description, + prompt, event) + self.sender.start() + + def wait(self, timeout=-1): + if self.connection.active == False: + return self.connection.retcode + try: + (pid, ret) = os.waitpid(self.connection.pid, 0) + except KeyboardInterrupt, e: + log("ERROR: ctrl+c catched! " + str(e)) + os._exit(1) + except BaseException, e: + log("ERROR: " + str(e)) + os._exit(1) + self.sender.join() + self.reader.join() + return ret + + #this function should not be called, it is used internally by 'waitlog' + #in mode 'background thread' + #TODO: join() the thread at some point + def _waitlog_thread(self, task, s): + consumed = 0 + while True: + consumed = task.producer.get(consumed) + if consumed == -1: + log("ERROR: string '" + s + "' not found in logfile " + + task.logfile) + task.waitlog_state = WAITLOG_FAILURE + task.waitlog_event.set() + return + if s in open(task.logfile).read(): + task.waitlog_state = WAITLOG_SUCCESS + task.waitlog_event.set() + return + + #two ways to wait for a string in the log file: + # - blocking way + # - background thread, using an Event to signal success/failure + def waitlog(self, s, event=None): + if event != None: + self.waitlog_state = WAITLOG_RUNNING + self.waitlog_event = event + self.waitlog_thread = \ + threading.Thread(target=self._waitlog_thread, + args=(self, s)) + self.waitlog_thread.start() + return + + #TODO: optimize, do not process all the file at each wakeup + consumed = 0 + while True: + consumed = self.producer.get(consumed) + if consumed == -1: + log("ERROR: string '" + s + "' not found in logfile " + + self.logfile) + raise WaitlogFailed() + if s in open(self.logfile).read(): + return + + def sendnow(self, x): + self.connection.send(x) + + def alive(self): + return self.sender.alive + + def kill(self): + self.connection.kill() + #put some error log in logfile, for verbosity + try: + f = open(self.logfile, "a+") + f.write("\n\n" + utils.RED + "TEST_SETUP_ERROR: " + utils.RESET + + "task killed by test setup\n\n"); + close(f) + except BaseException, e: + pass + + def postaction(self): + if self.post_action != None: + out = utils.quickshell(self.post_action) + if len(out): + log("INFO: task '" + self.description + + "' post_action '" + self.post_action + "' says: ") + for l in out.splitlines(): + log("INFO: " + l) diff --git a/cmake_targets/autotests/v2/utils.py b/cmake_targets/autotests/v2/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..e54bd458050f269483959b81dcfe66702e9efdc5 --- /dev/null +++ b/cmake_targets/autotests/v2/utils.py @@ -0,0 +1,84 @@ +import subprocess, os, thread, sys, time + +#logging facitiliy +#TODO: simplify (a first version redefined stdout, then we replaced 'print' +#instead, keeping stuff as is) +class Logger: + def __init__(self, stream): + self.stream = stream + self.start_of_line = True + self.lock = thread.allocate_lock() + openair_dir = os.environ.get('OPENAIR_DIR') + if openair_dir == None: + print "FATAL: no OPENAIR_DIR" + os._exit(1) + try: + self.logfile = open(openair_dir + + "/cmake_targets/autotests/log/python.stdout", "w") + except BaseException, e: + print "FATAL: cannot create log file" + print e + os._exit(1) + def put(self, data): + self.stream.write(data) + self.logfile.write(data) + def write(self, data): + self.lock.acquire() + for c in data: + if self.start_of_line: + self.start_of_line = False + t = time.strftime("%H:%M:%S", time.localtime()) + ": " + self.stream.write(t) + self.logfile.write(t) + self.put(c) + if c == '\n': + self.start_of_line = True + self.stream.flush() + self.logfile.flush() + self.lock.release() +logger = Logger(sys.stdout) +def log(x): + logger.write(x + "\n") + +#check if given test is in list +#it is in list if one of the strings in 'list' is at the beginning of 'test' +def test_in_list(test, list): + for check in list: + check=check.replace('+','') + if (test.startswith(check)): + return True + return False + +#run a local command in a shell +def quickshell(command): + process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT) + (retout, reterr) = process.communicate() + if (process.returncode != 0): + log("ERROR: shell command failed: " + command) + if len(retout): + log("ERROR: command says: ") + for l in retout.splitlines(): + log("ERROR: " + l) + os._exit(1) + return retout + +RED="\x1b[31m" +GREEN="\x1b[32m" +YELLOW="\x1b[33m" +RESET="\x1b[m" + +#an exception raised when a test fails +class TestFailed(Exception): + pass + +#this function returns True if a test in 'x' is set to True +#to be used as: if do_tests(tests['b210']['alu']) ... +def do_tests(x): + if type(x) == list: + for v in x: + if do_tests(v): return True + return False + if type(x) == dict: return do_tests(x.values()) + if x == True: return True + return False diff --git a/cmake_targets/build_oai b/cmake_targets/build_oai index 0a64c0a672b416bdb2ed991ce60d051c42c3a026..b6f2d2c6c562496cbb459114cd323fb49a63cfed 100755 --- a/cmake_targets/build_oai +++ b/cmake_targets/build_oai @@ -661,9 +661,9 @@ function main() { CMakeFiles/nasmesh/nasmesh.ko $dbin/nasmesh.ko #oai_nw_drv - compilations \ - $oaisim_build_dir oai_nw_drv \ - CMakeFiles/oai_nw_drv/oai_nw_drv.ko $dbin/oai_nw_drv.ko + #compilations \ + # $oaisim_build_dir oai_nw_drv \ + # CMakeFiles/oai_nw_drv/oai_nw_drv.ko $dbin/oai_nw_drv.ko fi cmake_file=$DIR/oaisim_mme_build_oai/CMakeLists.txt diff --git a/cmake_targets/tools/init_nas_s1 b/cmake_targets/tools/init_nas_s1 new file mode 100644 index 0000000000000000000000000000000000000000..5f27c5283741a122fadce4cb0c94ca0b05af58bd --- /dev/null +++ b/cmake_targets/tools/init_nas_s1 @@ -0,0 +1,71 @@ +#!/bin/bash + +#WARNING: this file may not work properly, be sure to know what you +#do when using it + +#/* +# * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more +# * contributor license agreements. See the NOTICE file distributed with +# * this work for additional information regarding copyright ownership. +# * The OpenAirInterface Software Alliance licenses this file to You under +# * the OAI Public License, Version 1.0 (the "License"); you may not use this file +# * except in compliance with the License. +# * You may obtain a copy of the License at +# * +# * http://www.openairinterface.org/?page_id=698 +# * +# * Unless required by applicable law or agreed to in writing, software +# * distributed under the License is distributed on an "AS IS" BASIS, +# * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# * See the License for the specific language governing permissions and +# * limitations under the License. +# *------------------------------------------------------------------------------- +# * For more information about the OpenAirInterface (OAI) Software Alliance: +# * contact@openairinterface.org +# */ + +################################################################################ +# file init_nas_s1 +# brief loads the ue_ip module and sets up IP for the UE +# you may want to edit it to fit your settings (replace oip0 by oipX for +# instance) +# author Florian Kaltenberger +# +####################################### + +LTEIF=oip0 +#OPENAIR_DIR=/home/oai/svn-oai/openair4G + +load_module() { + mod_name=${1##*/} + mod_name=${mod_name%.*} + if awk "/$mod_name/ {found=1 ;exit} END {if (found!=1) exit 1}" /proc/modules + then + echo "module $mod_name already loaded: I remove it first" + sudo rmmod $mod_name + fi + echo loading $mod_name + sudo insmod $1 +} + +load_module $OPENAIR_DIR/targets/bin/ue_ip.ko + +if [ "$1" = "UE" ]; then + echo "bring up oip0 interface for UE" + ifconfig oip0 up +fi + +ip route flush cache +sleep 1 +sysctl -w net.ipv4.conf.all.log_martians=1 +echo "Disabling reverse path filtering" +sysctl -w net.ipv4.conf.all.rp_filter=0 +ip route flush cache + +# Check table 200 lte in /etc/iproute2/rt_tables +fgrep lte /etc/iproute2/rt_tables > /dev/null +if [ $? -ne 0 ]; then + echo "200 lte " >> /etc/iproute2/rt_tables +fi +ip rule add fwmark 1 table lte +ip route add default dev $LTEIF table lte diff --git a/common/utils/T/T_messages.txt b/common/utils/T/T_messages.txt index d1807080bcc1b5f370b91d5cd0c76759f0bacfd5..85441722b0ecd78f72fffcedf04b9be67451b829 100644 --- a/common/utils/T/T_messages.txt +++ b/common/utils/T/T_messages.txt @@ -1938,3 +1938,82 @@ ID = VCD_FUNCTION_RECV_IF5 DESC = VCD function RECV_IF5 GROUP = ALL:VCD:ENB:VCD_FUNCTION FORMAT = int,value + +################# +#### UE LOGS #### +################# +#general logs +ID = UE_MASTER_TICK + DESC = UE master tick - one tick per ms, to be used as "reference clock", mostly for ticktime view + GROUP = ALL:GENERAL:UE + FORMAT = int,eNB_ID : int,frame : int,subframe + +#PHY logs +ID = UE_PHY_UL_TICK + DESC = UE uplink tick - one tick per ms at start of uplink processing + GROUP = ALL:PHY:GRAPHIC:UE + FORMAT = int,eNB_ID : int,frame : int,subframe +ID = UE_PHY_DL_TICK + DESC = UE downlink tick - one tick per ms at start of downlink processing + GROUP = ALL:PHY:GRAPHIC:UE + FORMAT = int,eNB_ID : int,frame : int,subframe +ID = UE_PHY_DLSCH_UE_DCI + DESC = UE downlink UE specific DCI as sent by the PHY layer + GROUP = ALL:PHY:GRAPHIC:UE + FORMAT = int,eNB_ID : int,frame : int,subframe : int,UE_id : int,rnti : int,dci_format : int,harq_pid : int,mcs : int,TBS +ID = UE_PHY_DLSCH_UE_ACK + DESC = UE downlink UE ACK as seen by the PHY layer in process_HARQ_feedback + GROUP = ALL:PHY:GRAPHIC:UE + FORMAT = int,eNB_ID : int,frame : int,subframe : int,UE_id : int,rnti : int,harq_pid +ID = UE_PHY_DLSCH_UE_NACK + DESC = UE downlink UE NACK as seen by the PHY layer in process_HARQ_feedback + GROUP = ALL:PHY:GRAPHIC:UE + FORMAT = int,eNB_ID : int,frame : int,subframe : int,UE_id : int,rnti : int,harq_pid +ID = UE_PHY_ULSCH_UE_DCI + DESC = UE uplink UE specific DCI as sent by the PHY layer + GROUP = ALL:PHY:GRAPHIC:UE + FORMAT = int,eNB_ID : int,frame : int,subframe : int,UE_id : int,rnti : int,harq_pid : int,mcs : int,round : int,first_rb : int,nb_rb : int,TBS +ID = UE_PHY_ULSCH_UE_ACK + DESC = UE uplink UE ACK as seen by the PHY layer + GROUP = ALL:PHY:GRAPHIC:UE + FORMAT = int,eNB_ID : int,frame : int,subframe : int,UE_id : int,rnti : int,harq_pid +ID = UE_PHY_ULSCH_UE_NACK + DESC = UE uplink UE NACK as seen by the PHY layer + GROUP = ALL:PHY:GRAPHIC:UE + FORMAT = int,eNB_ID : int,frame : int,subframe : int,UE_id : int,rnti : int,harq_pid +ID = UE_PHY_INPUT_SIGNAL + DESC = UE received signal in the time domain for a duration of 1ms + GROUP = ALL:PHY:GRAPHIC:HEAVY:UE + FORMAT = int,eNB_ID : int,frame : int,subframe : int,antenna : buffer,rxdata +ID = UE_PHY_DL_CHANNEL_ESTIMATE + DESC = UE channel estimation in the time domain + GROUP = ALL:PHY:GRAPHIC:HEAVY:UE + FORMAT = int,eNB_ID : int,UE_ID : int,frame : int,subframe : int,antenna : buffer,chest_t +ID = UE_PHY_PDCCH_IQ + DESC = UE PDCCH received IQ data + GROUP = ALL:PHY:GRAPHIC:HEAVY:UE + FORMAT = int,nb_rb : int,NB_RB_DL : int,symbols_per_tti : buffer,rxdataF_comp +ID = UE_PHY_PDCCH_ENERGY + DESC = UE PDSCH 1 energy and threshold + GROUP = ALL:PHY:GRAPHIC:HEAVY:UE + FORMAT = int,eNB_ID : int,UE_ID : int,frame : int,subframe : int,pdcch_ch_level00 : int,pdcch_ch_level01 : int,pdcch_ch_level10: int,pdcch_ch_level11 +ID = UE_PHY_PDSCH_IQ + DESC = UE PDSCH received IQ data + GROUP = ALL:PHY:GRAPHIC:HEAVY:UE + FORMAT = int,eNB_ID : int,UE_ID : int,frame : int,subframe : int,nb_rb : int,N_RB_UL : int,symbols_per_tti : buffer,pusch_comp +ID = UE_PHY_PDSCH_ENERGY + DESC = UE PDSCH 1 energy and threshold + GROUP = ALL:PHY:GRAPHIC:HEAVY:UE + FORMAT = int,eNB_ID : int,UE_ID : int,frame : int,subframe : int,pdsch_ch_level00 : int,pdsch_ch_level01 : int,pdsch_ch_level10: int,pdsch_ch_level11 +ID = UE_PHY_PUSCH_TX_POWER + DESC = UE PUSCH tx power + GROUP = ALL:PHY:GRAPHIC:HEAVY:UE + FORMAT = int,eNB_ID : int,UE_id : int,frame : int,subframe : int,p0_pusch : int,ampl: int,g_pusch: int,pl: int,nb_rb +ID = UE_PHY_PUCCH_TX_POWER + DESC = UE PDSCH 1 energy and threshold + GROUP = ALL:PHY:GRAPHIC:HEAVY:UE + FORMAT = int,eNB_ID : int,UE_id : int,frame : int,subframe : int,p0_pucch : int,ampl: int,g_pucch: int,pl +ID = UE_PHY_MEAS + DESC = UE PHY measurements + GROUP = ALL:PHY:GRAPHIC:HEAVY:UE + FORMAT = int,eNB_ID : int,UE_ID : int,frame : int,subframe : int,rsrp : int,rssi : int,snr: int,rx_power: int,noise_power: int,w_cqi: int,freq_offset diff --git a/common/utils/T/tracer/Makefile b/common/utils/T/tracer/Makefile index 71f1d25f9251b375dd5f57d88b59d78f979b3b11..f6c65f64000e6da238d14d843d1fe36e8325eda2 100644 --- a/common/utils/T/tracer/Makefile +++ b/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 macpdu2wireshark +all: record replay extract_config textlog enb ue vcd macpdu2wireshark record: utils.o record.o database.o config.o $(CC) $(CFLAGS) -o record $^ $(LIBS) @@ -26,6 +26,11 @@ enb: utils.o enb.o database.o event.o handler.o config.o \ filter/filter.a $(CC) $(CFLAGS) -o enb $^ $(LIBS) +ue: utils.o ue.o database.o event.o handler.o config.o \ + event_selector.o view/view.a gui/gui.a logger/logger.a \ + filter/filter.a + $(CC) $(CFLAGS) -o ue $^ $(LIBS) + vcd: utils.o vcd.o database.o event.o handler.o config.o \ event_selector.o view/view.a gui/gui.a logger/logger.a \ filter/filter.a diff --git a/common/utils/T/tracer/enb.c b/common/utils/T/tracer/enb.c index 14e1da35c01138067e8ddf0926e645e555922afb..27d8630fd8d53f8f84f3235fee5cebe36a2c3dc2 100644 --- a/common/utils/T/tracer/enb.c +++ b/common/utils/T/tracer/enb.c @@ -349,6 +349,36 @@ static void enb_main_gui(enb_gui *e, gui *g, event_handler *h, void *database, logger_add_view(l, v); e->ul_mcs_logger = l; + /* UE x DL PHY (truly: DCI) throughput */ + col = new_container(g, VERTICAL); + widget_add_child(g, line, col, -1); + w = new_xy_plot(g, 70, 10, "DL PHY [0]", 35); + w2 = new_textarea(g, 70, 11, 64); + xy_plot_set_range(g, w, 0, 1000, 0, 100000); + xy_plot_set_tick_type(g, w, XY_PLOT_SCROLL_TICK); + widget_add_child(g, col, w2, -1); + widget_add_child(g, col, w, -1); + container_set_child_growable(g, col, w, 1); + l = new_throughputlog(h, database, "ENB_PHY_DL_TICK", "frame", "subframe", + "ENB_PHY_DLSCH_UE_DCI", "TBS"); + v = new_view_scrolltti(10, g, w, new_color(g, "#0c0c72"), w2); + logger_add_view(l, v); + + /* UE x UL PHY (truly: DCI) throughput */ + col = new_container(g, VERTICAL); + widget_add_child(g, line, col, -1); + w = new_xy_plot(g, 70, 10, "UL PHY [0]", 35); + w2 = new_textarea(g, 70, 11, 64); + xy_plot_set_range(g, w, 0, 1000, 0, 100000); + xy_plot_set_tick_type(g, w, XY_PLOT_SCROLL_TICK); + widget_add_child(g, col, w2, -1); + widget_add_child(g, col, w, -1); + container_set_child_growable(g, col, w, 1); + l = new_throughputlog(h, database, "ENB_PHY_DL_TICK", "frame", "subframe", + "ENB_PHY_ULSCH_UE_DCI", "TBS"); + v = new_view_scrolltti(10, g, w, new_color(g, "#0c0c72"), w2); + logger_add_view(l, v); + /* downlink/uplink UE DCIs */ widget_add_child(g, top_container, new_label(g,"DL/UL TICK/DCI/ACK/NACK [all UEs]"), -1); diff --git a/common/utils/T/tracer/ue.c b/common/utils/T/tracer/ue.c new file mode 100644 index 0000000000000000000000000000000000000000..5709a4e79e06c82f2baa3a90b8cea683c768471c --- /dev/null +++ b/common/utils/T/tracer/ue.c @@ -0,0 +1,876 @@ +#include +#include +#include +#include +#include +#include +#include "database.h" +#include "event.h" +#include "handler.h" +#include "logger/logger.h" +#include "view/view.h" +#include "gui/gui.h" +#include "filter/filter.h" +#include "utils.h" +#include "../T_defs.h" +#include "event_selector.h" +#include "openair_logo.h" +#include "config.h" + +typedef struct { + view *phyview; + view *macview; + view *rlcview; + view *pdcpview; + view *rrcview; + view *legacy; + widget *current_ue_label; + widget *prev_ue_button; + widget *next_ue_button; + widget *pdsch_iq_ue_xy_plot; + widget *dl_estimate_ue_xy_plot; + widget *pdcch_energy_ue_xy_plot; + widget *pdsch_energy_ue_xy_plot; + widget *pdcch_iq_ue_xy_plot; + widget *dl_ul_harq_ue_label; + widget *dl_mcs_xy_plot; + widget *ul_mcs_xy_plot; + widget *pusch_power_xy_plot; + widget *pucch_power_xy_plot; + widget *phy_meas_xy_plot; + logger *pdsch_iq_ue_logger; + logger *dl_estimate_ue_logger; + logger *pdcch_iq_ue_logger; + logger *dl_dci_logger[8]; + logger *dl_ack_logger[8]; + logger *dl_nack_logger[8]; + logger *ul_dci_logger[8]; + logger *ul_dci_retransmission_logger[8]; + logger *ul_ack_logger[8]; + logger *ul_nack_logger[8]; + logger *dl_mcs_logger; + logger *ul_mcs_logger; + logger *pusch_power_logger; + logger *pusch_ampl_logger; + logger *pucch_power_logger; + logger *pucch_ampl_logger; + logger *pdcch_energy_logger; + logger *pdsch_energy_logger; + logger *phy_meas_logger; +} ue_gui; + +typedef struct { + int socket; + int *is_on; + int nevents; + pthread_mutex_t lock; + ue_gui *e; + int ue; /* what UE is displayed in the UE specific views */ + void *database; +} ue_data; + +void is_on_changed(void *_d) +{ + ue_data *d = _d; + char t; + + if (pthread_mutex_lock(&d->lock)) abort(); + + if (d->socket == -1) goto no_connection; + + t = 1; + if (socket_send(d->socket, &t, 1) == -1 || + socket_send(d->socket, &d->nevents, sizeof(int)) == -1 || + socket_send(d->socket, d->is_on, d->nevents * sizeof(int)) == -1) + goto connection_dies; + +no_connection: + if (pthread_mutex_unlock(&d->lock)) abort(); + return; + +connection_dies: + close(d->socket); + d->socket = -1; + if (pthread_mutex_unlock(&d->lock)) abort(); +} + +void usage(void) +{ + printf( +"options:\n" +" -d this option is mandatory\n" +" -on turn log ON for given GROUP or ID\n" +" -off turn log OFF for given GROUP or ID\n" +" -ON turn all logs ON\n" +" -OFF turn all logs OFF\n" +" note: you may pass several -on/-off/-ON/-OFF,\n" +" they will be processed in order\n" +" by default, all is off\n" +" -ip connect to given IP address (default %s)\n" +" -p connect to given port (default %d)\n" +" -debug-gui activate GUI debug logs\n", + DEFAULT_REMOTE_IP, + DEFAULT_REMOTE_PORT + ); + exit(1); +} + +static void *gui_thread(void *_g) +{ + gui *g = _g; + gui_loop(g); + return NULL; +} + +static filter *ticktime_filter(void *database, char *event, int i, int ue) +{ + /* filter is "harq_pid == i && UE_id == 0 && eNB_id == 0" */ + return + filter_and( + filter_eq(filter_evarg(database, event, "harq_pid"), filter_int(i)), + filter_and( + filter_eq(filter_evarg(database, event, "UE_id"), filter_int(ue)), + filter_eq(filter_evarg(database, event, "eNB_ID"), filter_int(0)))); +} + +static void set_current_ue(gui *g, ue_data *e, int ue) +{ + int i; + char s[256]; + + sprintf(s, "[UE %d] ", ue); + label_set_text(g, e->e->current_ue_label, s); + sprintf(s, "PDSCH IQ [UE %d]", ue); + xy_plot_set_title(g, e->e->pdsch_iq_ue_xy_plot, s); + sprintf(s, "DL estimated channel [UE %d]", ue); + xy_plot_set_title(g, e->e->dl_estimate_ue_xy_plot, s); + sprintf(s, "PDCCH energy [UE %d]", ue); + xy_plot_set_title(g, e->e->pdcch_energy_ue_xy_plot, s); + sprintf(s, "PDSCH energy [UE %d]", ue); + xy_plot_set_title(g, e->e->pdsch_energy_ue_xy_plot, s); + sprintf(s, "PDCCH IQ [UE %d]", ue); + xy_plot_set_title(g, e->e->pdcch_iq_ue_xy_plot, s); + sprintf(s, "DL/UL HARQ (x8) [UE %d]", ue); + label_set_text(g, e->e->dl_ul_harq_ue_label, s); + sprintf(s, "DL MCS [UE %d]", ue); + xy_plot_set_title(g, e->e->dl_mcs_xy_plot, s); + sprintf(s, "UL MCS [UE %d]", ue); + xy_plot_set_title(g, e->e->ul_mcs_xy_plot, s); + sprintf(s, "PUSCH POWER [UE %d]", ue); + xy_plot_set_title(g, e->e->pusch_power_xy_plot, s); + sprintf(s, "PUCCH POWER [UE %d]", ue); + xy_plot_set_title(g, e->e->pucch_power_xy_plot, s); + sprintf(s, "PHY Measurements [UE %d]", ue); + xy_plot_set_title(g, e->e->phy_meas_xy_plot, s); + + logger_set_filter(e->e->pdsch_iq_ue_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_PDSCH_IQ", "UE_ID"), + filter_int(ue))); + logger_set_filter(e->e->dl_estimate_ue_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_DL_CHANNEL_ESTIMATE", "UE_ID"), + filter_int(ue))); + logger_set_filter(e->e->pdcch_energy_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_PDCCH_ENERGY", "UE_ID"), + filter_int(ue))); + logger_set_filter(e->e->pdsch_energy_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_PDSCH_ENERGY", "UE_ID"), + filter_int(ue))); + logger_set_filter(e->e->phy_meas_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_MEAS", "UE_ID"), + filter_int(ue))); + /*logger_set_filter(e->pucch1_energy_ue_energy_logger, + filter_eq( + filter_evarg(e->database, "ENB_PHY_PUCCH_1_ENERGY", "UE_ID"), + filter_int(ue)));*/ + /*logger_set_filter(e->e->pdcch_iq_ue_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_PDCCH_IQ", "UE_ID"), + filter_int(ue)));*/ + for (i = 0; i < 8; i++) { + logger_set_filter(e->e->dl_dci_logger[i], + ticktime_filter(e->database, "UE_PHY_DLSCH_UE_DCI", i, ue)); + logger_set_filter(e->e->dl_ack_logger[i], + ticktime_filter(e->database, "UE_PHY_DLSCH_UE_ACK", i, ue)); + logger_set_filter(e->e->dl_nack_logger[i], + ticktime_filter(e->database, "UE_PHY_DLSCH_UE_NACK", i, ue)); + logger_set_filter(e->e->ul_dci_logger[i], + ticktime_filter(e->database, "UE_PHY_ULSCH_UE_DCI", i, ue)); + /*logger_set_filter(e->ul_dci_retransmission_logger[i], + ticktime_filter(e->database, + "ENB_PHY_ULSCH_UE_NO_DCI_RETRANSMISSION", i, ue));*/ + logger_set_filter(e->e->ul_ack_logger[i], + ticktime_filter(e->database, "UE_PHY_ULSCH_UE_ACK", i, ue)); + logger_set_filter(e->e->ul_nack_logger[i], + ticktime_filter(e->database, "UE_PHY_ULSCH_UE_NACK", i, ue)); + } + logger_set_filter(e->e->dl_mcs_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_DLSCH_UE_DCI", "UE_id"), + filter_int(ue))); + logger_set_filter(e->e->ul_mcs_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_ULSCH_UE_DCI", "UE_id"), + filter_int(ue))); + logger_set_filter(e->e->pusch_power_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_PUSCH_TX_POWER", "UE_id"), + filter_int(ue))); + logger_set_filter(e->e->pusch_ampl_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_PUSCH_TX_POWER", "UE_id"), + filter_int(ue))); + logger_set_filter(e->e->pucch_power_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_PUCCH_TX_POWER", "UE_id"), + filter_int(ue))); + logger_set_filter(e->e->pucch_ampl_logger, + filter_eq( + filter_evarg(e->database, "UE_PHY_PUCCH_TX_POWER", "UE_id"), + filter_int(ue))); +} + +static void click(void *private, gui *g, + char *notification, widget *w, void *notification_data) +{ + int *d = notification_data; + int button = d[0]; + ue_data *ed = private; + ue_gui *e = ed->e; + int ue = ed->ue; + + if (button != 1) return; + if (w == e->prev_ue_button) { ue--; if (ue < 0) ue = 0; } + if (w == e->next_ue_button) ue++; + + if (pthread_mutex_lock(&ed->lock)) abort(); + if (ue != ed->ue) { + set_current_ue(g, ed, ue); + ed->ue = ue; + } + if (pthread_mutex_unlock(&ed->lock)) abort(); +} + +static void ue_main_gui(ue_gui *e, gui *g, event_handler *h, void *database, + ue_data *ed) +{ + widget *main_window; + widget *top_container; + widget *line, *col; + widget *logo; + widget *input_signal_plot; + logger *input_signal_log; + view *input_signal_view; + widget *timeline_plot; + logger *timelog; + view *timeview; + view *subview; + widget *text; + view *textview; + int i; + widget *w, *w2; + view *v; + logger *l; + + main_window = new_toplevel_window(g, 1200, 900, "eNB tracer"); + top_container = new_container(g, VERTICAL); + widget_add_child(g, main_window, top_container, -1); + + line = new_container(g, HORIZONTAL); + widget_add_child(g, top_container, line, -1); + logo = new_image(g, openair_logo_png, openair_logo_png_len); + + /* logo + prev/next UE buttons */ + col = new_container(g, VERTICAL); + widget_add_child(g, col, logo, -1); + w = new_container(g, HORIZONTAL); + widget_add_child(g, col, w, -1); + w2 = new_label(g, ""); + widget_add_child(g, w, w2, -1); + e->current_ue_label = w2; + /* TODO: use button widget, not label widget */ + w2 = new_label(g, " [prev UE] "); + widget_add_child(g, w, w2, -1); + label_set_clickable(g, w2, 1); + e->prev_ue_button = w2; + w2 = new_label(g, " [next UE] "); + widget_add_child(g, w, w2, -1); + label_set_clickable(g, w2, 1); + e->next_ue_button = w2; + widget_add_child(g, line, col, -1); + + input_signal_plot = new_xy_plot(g, 256, 55, "input signal", 20); + widget_add_child(g, line, input_signal_plot, -1); + xy_plot_set_range(g, input_signal_plot, 0, 7680*10, 20, 70); + input_signal_log = new_framelog(h, database, + "UE_PHY_INPUT_SIGNAL", "subframe", "rxdata"); + /* a skip value of 10 means to process 1 frame over 10, that is + * more or less 10 frames per second + */ + framelog_set_skip(input_signal_log, 10); + input_signal_view = new_view_xy(7680*10, 10, + g, input_signal_plot, new_color(g, "#0c0c72"), XY_LOOP_MODE); + logger_add_view(input_signal_log, input_signal_view); + + /* UE x PDSCH IQ data */ + w = new_xy_plot(g, 55, 55, "", 50); + e->pdsch_iq_ue_xy_plot = w; + widget_add_child(g, line, w, -1); + xy_plot_set_range(g, w, -500, 500, -500, 500); + l = new_iqlog(h, database, "UE_PHY_PDSCH_IQ", "nb_rb", + "N_RB_UL", "symbols_per_tti", "pusch_comp"); + v = new_view_xy(100*12*14,10,g,w,new_color(g,"#000"),XY_FORCED_MODE); + logger_add_view(l, v); + e->pdsch_iq_ue_logger = l; + + /* UE x estimated DL channel */ + w = new_xy_plot(g, 280, 55, "", 50); + e->dl_estimate_ue_xy_plot = w; + widget_add_child(g, line, w, -1); + xy_plot_set_range(g, w, 0, 512*10, -10, 80); + l = new_framelog(h, database, + "UE_PHY_DL_CHANNEL_ESTIMATE", "subframe", "chest_t"); + //framelog_set_skip(input_signal_log, 10); + framelog_set_update_only_at_sf9(l, 0); + v = new_view_xy(512*10, 10, g, w, new_color(g, "#0c0c72"), XY_LOOP_MODE); + logger_add_view(l, v); + e->dl_estimate_ue_logger = l; + + /* PHY Meas */ + w = new_xy_plot(g, 128, 55, "", 50); + e->phy_meas_xy_plot = w; + widget_add_child(g, line, w, -1); + xy_plot_set_range(g, w, 0, 1024*10, -130, 35); + /*l = new_ticked_ttilog(h, database,"UE_PHY_DL_TICK", "frame", "subframe","UE_PHY_MEAS", "rssi", 0, -1); + v = new_view_tti(10, g, w, new_color(g, "#720c0c")); + logger_add_view(l, v); + e->phy_meas_logger = l;*/ + l = new_ticked_ttilog(h, database,"UE_PHY_DL_TICK", "frame", "subframe","UE_PHY_MEAS", "rsrp", 0, -1); + v = new_view_tti(10, g, w, new_color(g, "#0c0c72")); + logger_add_view(l, v); + e->phy_meas_logger = l; + l = new_ticked_ttilog(h, database,"UE_PHY_DL_TICK", "frame", "subframe","UE_PHY_MEAS", "snr", 0, -1); + v = new_view_tti(10, g, w, new_color(g, "#0c720c")); + logger_add_view(l, v); + e->phy_meas_logger = l; + + /* UE x PDSCH energy */ + w = new_xy_plot(g, 128, 55, "", 50); + e->pdsch_energy_ue_xy_plot = w; + widget_add_child(g, line, w, -1); + xy_plot_set_range(g, w, 0, 1024*10, -10, 80); + l = new_ttilog(h, database, + "UE_PHY_PDSCH_ENERGY", "frame", "subframe", "pdsch_ch_level00", 1); + v = new_view_tti(10, g, w, new_color(g, "#ff0000")); + logger_add_view(l, v); + e->pdsch_energy_logger = l; + l = new_ttilog(h, database, + "UE_PHY_PDSCH_ENERGY", "frame", "subframe", "pdsch_ch_level01", 1); + v = new_view_tti(10, g, w, new_color(g, "#00ff00")); + logger_add_view(l, v); + e->pdsch_energy_logger = l; + l = new_ttilog(h, database, + "UE_PHY_PDSCH_ENERGY", "frame", "subframe", "pdsch_ch_level10", 1); + v = new_view_tti(10, g, w, new_color(g, "#0f0f0f")); + logger_add_view(l, v); + e->pdsch_energy_logger = l; + l = new_ttilog(h, database, + "UE_PHY_PDSCH_ENERGY", "frame", "subframe", "pdsch_ch_level11", 1); + v = new_view_tti(10, g, w, new_color(g, "#0000ff")); + logger_add_view(l, v); + e->pdsch_energy_logger = l; + + /* UE x PDCCH energy */ + w = new_xy_plot(g, 128, 55, "", 50); + e->pdcch_energy_ue_xy_plot = w; + widget_add_child(g, line, w, -1); + xy_plot_set_range(g, w, 0, 1024*10, -10, 80); + l = new_ttilog(h, database, + "UE_PHY_PDCCH_ENERGY", "frame", "subframe", "pdcch_ch_level00", 1); + v = new_view_tti(10, g, w, new_color(g, "#ff0000")); + logger_add_view(l, v); + e->pdcch_energy_logger = l; + l = new_ttilog(h, database, + "UE_PHY_PDCCH_ENERGY", "frame", "subframe", "pdcch_ch_level01", 1); + v = new_view_tti(10, g, w, new_color(g, "#00ff00")); + logger_add_view(l, v); + e->pdcch_energy_logger = l; + l = new_ttilog(h, database, + "UE_PHY_PDCCH_ENERGY", "frame", "subframe", "pdcch_ch_level10", 1); + v = new_view_tti(10, g, w, new_color(g, "#0f0f0f")); + logger_add_view(l, v); + e->pdcch_energy_logger = l; + l = new_ttilog(h, database, + "UE_PHY_PDCCH_ENERGY", "frame", "subframe", "pdcch_ch_level11", 1); + v = new_view_tti(10, g, w, new_color(g, "#0000ff")); + logger_add_view(l, v); + e->pdcch_energy_logger = l; + + /* UE x PDCCH IQ data */ + w = new_xy_plot(g, 55, 55, "", 50); + e->pdcch_iq_ue_xy_plot = w; + widget_add_child(g, line, w, -1); + xy_plot_set_range(g, w, -100, 100, -100, 100); + l = new_iqlog(h, database, "UE_PHY_PDCCH_IQ", "nb_rb", + "NB_RB_DL", "symbols_per_tti", "rxdataF_comp"); + v = new_view_xy(100*12*14,10,g,w,new_color(g,"#000"),XY_FORCED_MODE); + logger_add_view(l, v); + e->pdcch_iq_ue_logger = l; + + /* UE x PDCCH IQ data */ + /*w = new_xy_plot(g, 55, 55, "", 50); + e->pdcch_iq_ue_xy_plot = w; + widget_add_child(g, line, w, -1); + xy_plot_set_range(g, w, -2000, 2000, -2000, 2000); + l = new_iqdotlog(h, database, "UE_PHY_PDCCH_IQ", "I", "Q"); + v = new_view_xy(500, 10, g, w, new_color(g,"#000"), XY_LOOP_MODE); + logger_add_view(l, v); + e->pdcch_iq_ue_logger = l;*/ + + /* UE x DL mcs */ + line = new_container(g, HORIZONTAL); + widget_add_child(g, top_container, line, -1); + w = new_xy_plot(g, 128, 55, "", 20); + xy_plot_set_range(g, w, 0, 1024*10, -2, 30); + e->dl_mcs_xy_plot = w; + widget_add_child(g, line, w, -1); + l = new_ticked_ttilog(h, database, "UE_PHY_DL_TICK", "frame", "subframe", + "UE_PHY_DLSCH_UE_DCI", "mcs", 0, -1); + v = new_view_tti(10, g, w, new_color(g, "#0c0c72")); + logger_add_view(l, v); + e->dl_mcs_logger = l; + + /* UE x UL mcs */ + w = new_xy_plot(g, 128, 55, "", 20); + xy_plot_set_range(g, w, 0, 1024*10, -2, 30); + e->ul_mcs_xy_plot = w; + widget_add_child(g, line, w, -1); + l = new_ticked_ttilog(h, database, "UE_PHY_UL_TICK", "frame", "subframe", + "UE_PHY_ULSCH_UE_DCI", "mcs", 0, -1); + v = new_view_tti(10, g, w, new_color(g, "#0c0c72")); + logger_add_view(l, v); + e->ul_mcs_logger = l; + + /* UE x PUSCH TX Power */ +// line = new_container(g, HORIZONTAL); +// widget_add_child(g, top_container, line, -1); + w = new_xy_plot(g, 128, 55, "", 20); + e->pusch_power_xy_plot = w; + widget_add_child(g, line, w, -1); + xy_plot_set_range(g, w, 0, 1024*10, -30, 50); + l = new_ttilog(h, database, + "UE_PHY_PUSCH_TX_POWER", "frame", "subframe", "p0_pusch", 0); + v = new_view_tti(10, g, w, new_color(g, "#0c0c72")); + logger_add_view(l, v); + e->pusch_power_logger = l; + l = new_ttilog(h, database, + "UE_PHY_PUSCH_TX_POWER", "frame", "subframe", "ampl", 1); + v = new_view_tti(10, g, w, new_color(g, "#720c0c")); + logger_add_view(l, v); + e->pusch_ampl_logger = l; + + /* UE x PUCCH TX Power */ +// line = new_container(g, HORIZONTAL); +// widget_add_child(g, top_container, line, -1); + w = new_xy_plot(g, 128, 55, "", 20); + e->pucch_power_xy_plot = w; + widget_add_child(g, line, w, -1); + xy_plot_set_range(g, w, 0, 1024*10, -30, 50); + l = new_ttilog(h, database, + "UE_PHY_PUCCH_TX_POWER", "frame", "subframe", "p0_pucch", 0); + v = new_view_tti(10, g, w, new_color(g, "#0c0c72")); + logger_add_view(l, v); + e->pucch_power_logger = l; + l = new_ttilog(h, database, + "UE_PHY_PUCCH_TX_POWER", "frame", "subframe", "ampl", 1); + v = new_view_tti(10, g, w, new_color(g, "#720c0c")); + logger_add_view(l, v); + e->pucch_ampl_logger = l; + + + /* downlink/uplink UE DCIs */ + widget_add_child(g, top_container, + new_label(g,"DL/UL TICK/DCI/ACK/NACK [all UEs]"), -1); + line = new_container(g, HORIZONTAL); + widget_add_child(g, top_container, line, -1); + timeline_plot = new_timeline(g, 512, 8, 5); + widget_add_child(g, line, timeline_plot, -1); + container_set_child_growable(g, line, timeline_plot, 1); + for (i = 0; i < 8; i++) + timeline_set_subline_background_color(g, timeline_plot, i, + new_color(g, i==0 || i==4 ? "#aaf" : "#eee")); + timeview = new_view_time(3600, 10, g, timeline_plot); + /* DL tick logging */ + timelog = new_timelog(h, database, "UE_PHY_DL_TICK"); + subview = new_subview_time(timeview, 0, new_color(g, "#77c"), 3600*1000); + logger_add_view(timelog, subview); + /* DL DCI logging */ + timelog = new_timelog(h, database, "UE_PHY_DLSCH_UE_DCI"); + subview = new_subview_time(timeview, 1, new_color(g, "#228"), 3600*1000); + logger_add_view(timelog, subview); + /* DL ACK */ + timelog = new_timelog(h, database, "UE_PHY_DLSCH_UE_ACK"); + subview = new_subview_time(timeview, 2, new_color(g, "#282"), 3600*1000); + logger_add_view(timelog, subview); + /* DL NACK */ + timelog = new_timelog(h, database, "UE_PHY_DLSCH_UE_NACK"); + subview = new_subview_time(timeview, 3, new_color(g, "#f22"), 3600*1000); + logger_add_view(timelog, subview); + + /* UL tick logging */ + timelog = new_timelog(h, database, "UE_PHY_UL_TICK"); + subview = new_subview_time(timeview, 4, new_color(g, "#77c"), 3600*1000); + logger_add_view(timelog, subview); + /* UL DCI logging */ + timelog = new_timelog(h, database, "UE_PHY_ULSCH_UE_DCI"); + subview = new_subview_time(timeview, 5, new_color(g, "#228"), 3600*1000); + logger_add_view(timelog, subview); + /* UL retransmission without DCI logging */ + //timelog = new_timelog(h,database,"ENB_PHY_ULSCH_UE_NO_DCI_RETRANSMISSION"); + //subview = new_subview_time(timeview, 5, new_color(g, "#f22"), 3600*1000); + //logger_add_view(timelog, subview); + /* UL ACK */ + timelog = new_timelog(h, database, "UE_PHY_ULSCH_UE_ACK"); + subview = new_subview_time(timeview, 6, new_color(g, "#282"), 3600*1000); + logger_add_view(timelog, subview); + /* UL NACK */ + timelog = new_timelog(h, database, "UE_PHY_ULSCH_UE_NACK"); + subview = new_subview_time(timeview, 7, new_color(g, "#f22"), 3600*1000); + logger_add_view(timelog, subview); + + /* harq processes' ticktime view */ + e->dl_ul_harq_ue_label = new_label(g, ""); + widget_add_child(g, top_container, e->dl_ul_harq_ue_label, -1); + line = new_container(g, HORIZONTAL); + widget_add_child(g, top_container, line, -1); + timeline_plot = new_timeline(g, 512, 2*8+2, 3); + widget_add_child(g, line, timeline_plot, -1); + container_set_child_growable(g, line, timeline_plot, 1); + for (i = 0; i < 2*8+2; i++) + timeline_set_subline_background_color(g, timeline_plot, i, + new_color(g, i==0 || i==9 ? "#ddd" : (i%9)&1 ? "#e6e6e6" : "#eee")); + timeview = new_view_ticktime(10, g, timeline_plot); + ticktime_set_tick(timeview, + new_ticklog(h, database, "UE_MASTER_TICK", "frame", "subframe")); + /* tick */ + timelog = new_ticklog(h, database, "UE_MASTER_TICK", "frame", "subframe"); + /* tick on DL view */ + subview = new_subview_ticktime(timeview, 0, new_color(g,"#bbb"), 3600*1000); + logger_add_view(timelog, subview); + /* tick on UL view */ + subview = new_subview_ticktime(timeview, 9, new_color(g,"#bbb"), 3600*1000); + logger_add_view(timelog, subview); + /* DL DCI */ + for (i = 0; i < 8; i++) { + timelog = new_ticklog(h, database, "UE_PHY_DLSCH_UE_DCI", + "frame", "subframe"); + subview = new_subview_ticktime(timeview, i+1, + new_color(g,"#55f"), 3600*1000); + logger_add_view(timelog, subview); + e->dl_dci_logger[i] = timelog; + } + /* DL ACK */ + for (i = 0; i < 8; i++) { + timelog = new_ticklog(h, database, "UE_PHY_DLSCH_UE_ACK", + "frame", "subframe"); + subview = new_subview_ticktime(timeview, i+1, + new_color(g,"#282"), 3600*1000); + logger_add_view(timelog, subview); + e->dl_ack_logger[i] = timelog; + } + /* DL NACK */ + for (i = 0; i < 8; i++) { + timelog = new_ticklog(h, database, "UE_PHY_DLSCH_UE_NACK", + "frame", "subframe"); + subview = new_subview_ticktime(timeview, i+1, + new_color(g,"#f22"), 3600*1000); + logger_add_view(timelog, subview); + e->dl_nack_logger[i] = timelog; + } + /* UL DCI/retransmission without DCI */ + for (i = 0; i < 8; i++) { + /* first transmission */ + timelog = new_ticklog(h, database, "UE_PHY_ULSCH_UE_DCI", + "frame", "subframe"); + subview = new_subview_ticktime(timeview, i+9+1, + new_color(g,"#55f"), 3600*1000); + logger_add_view(timelog, subview); + e->ul_dci_logger[i] = timelog; + /* retransmission */ + + timelog = new_ticklog(h, database, + "ENB_PHY_ULSCH_UE_NO_DCI_RETRANSMISSION", "frame", "subframe"); + subview = new_subview_ticktime(timeview, i+9+1, + new_color(g,"#99f"), 3600*1000); + logger_add_view(timelog, subview); + e->ul_dci_retransmission_logger[i] = timelog; + + } + + /* UL ACK */ + for (i = 0; i < 8; i++) { + timelog = new_ticklog(h, database, "UE_PHY_ULSCH_UE_ACK", + "frame", "subframe"); + subview = new_subview_ticktime(timeview, i+9+1, + new_color(g,"#282"), 3600*1000); + logger_add_view(timelog, subview); + e->ul_ack_logger[i] = timelog; + } + /* UL NACK */ + for (i = 0; i < 8; i++) { + timelog = new_ticklog(h, database, "UE_PHY_ULSCH_UE_NACK", + "frame", "subframe"); + subview = new_subview_ticktime(timeview, i+9+1, + new_color(g,"#f22"), 3600*1000); + logger_add_view(timelog, subview); + e->ul_nack_logger[i] = timelog; + } + +#if 1 + /* phy/mac/rlc/pdcp/rrc textlog */ + line = new_container(g, HORIZONTAL); + widget_add_child(g, top_container, line, -1); + container_set_child_growable(g, top_container, line, 1); + + /* phy */ + col = new_container(g, VERTICAL); + widget_add_child(g, line, col, -1); + container_set_child_growable(g, line, col, 1); + widget_add_child(g, col, new_label(g, "PHY"), -1); + text = new_textlist(g, 100, 10, new_color(g, "#afa")); + widget_add_child(g, col, text, -1); + container_set_child_growable(g, col, text, 1); + textview = new_view_textlist(10000, 10, g, text); + e->phyview = textview; + + /* mac */ + col = new_container(g, VERTICAL); + widget_add_child(g, line, col, -1); + container_set_child_growable(g, line, col, 1); + widget_add_child(g, col, new_label(g, "MAC"), -1); + text = new_textlist(g, 100, 10, new_color(g, "#adf")); + widget_add_child(g, col, text, -1); + container_set_child_growable(g, col, text, 1); + textview = new_view_textlist(10000, 10, g, text); + e->macview = textview; + + line = new_container(g, HORIZONTAL); + widget_add_child(g, top_container, line, -1); + container_set_child_growable(g, top_container, line, 1); + + /* rlc */ + col = new_container(g, VERTICAL); + widget_add_child(g, line, col, -1); + container_set_child_growable(g, line, col, 1); + widget_add_child(g, col, new_label(g, "RLC"), -1); + text = new_textlist(g, 100, 10, new_color(g, "#aff")); + widget_add_child(g, col, text, -1); + container_set_child_growable(g, col, text, 1); + textview = new_view_textlist(10000, 10, g, text); + e->rlcview = textview; + + /* pdcp */ + col = new_container(g, VERTICAL); + widget_add_child(g, line, col, -1); + container_set_child_growable(g, line, col, 1); + widget_add_child(g, col, new_label(g, "PDCP"), -1); + text = new_textlist(g, 100, 10, new_color(g, "#ed9")); + widget_add_child(g, col, text, -1); + container_set_child_growable(g, col, text, 1); + textview = new_view_textlist(10000, 10, g, text); + e->pdcpview = textview; + + line = new_container(g, HORIZONTAL); + widget_add_child(g, top_container, line, -1); + container_set_child_growable(g, top_container, line, 1); + + /* rrc */ + col = new_container(g, VERTICAL); + widget_add_child(g, line, col, -1); + container_set_child_growable(g, line, col, 1); + widget_add_child(g, col, new_label(g, "RRC"), -1); + text = new_textlist(g, 100, 10, new_color(g, "#fdb")); + widget_add_child(g, col, text, -1); + container_set_child_growable(g, col, text, 1); + textview = new_view_textlist(10000, 10, g, text); + e->rrcview = textview; + + /* legacy logs (LOG_I, LOG_D, ...) */ + widget_add_child(g, top_container, new_label(g, "LEGACY"), -1); + text = new_textlist(g, 100, 10, new_color(g, "#eeb")); + widget_add_child(g, top_container, text, -1); + container_set_child_growable(g, top_container, text, 1); + e->legacy = new_view_textlist(10000, 10, g, text); +#endif + + set_current_ue(g, ed, 0); + register_notifier(g, "click", e->prev_ue_button, click, ed); + register_notifier(g, "click", e->next_ue_button, click, ed); +} + +void view_add_log(view *v, char *log, event_handler *h, void *database, + int *is_on) +{ + logger *textlog; + char *name, *desc; + + database_get_generic_description(database, + event_id_from_name(database, log), &name, &desc); + textlog = new_textlog(h, database, name, desc); + logger_add_view(textlog, v); + free(name); + free(desc); + + on_off(database, log, is_on, 1); +} + +int main(int n, char **v) +{ + extern int volatile gui_logd; + char *database_filename = NULL; + void *database; + char *ip = DEFAULT_REMOTE_IP; + int port = DEFAULT_REMOTE_PORT; + char **on_off_name; + int *on_off_action; + int on_off_n = 0; + int *is_on; + int number_of_events; + int i; + event_handler *h; + gui *g; + ue_gui eg; + ue_data ue_data; + + /* write on a socket fails if the other end is closed and we get SIGPIPE */ + if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) abort(); + + on_off_name = malloc(n * sizeof(char *)); if (on_off_name == NULL) abort(); + on_off_action = malloc(n * sizeof(int)); if (on_off_action == NULL) abort(); + + 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], "-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; } + if (!strcmp(v[i], "-on")) { if (i > n-2) usage(); + on_off_name[on_off_n]=v[++i]; on_off_action[on_off_n++]=1; continue; } + if (!strcmp(v[i], "-off")) { if (i > n-2) usage(); + on_off_name[on_off_n]=v[++i]; on_off_action[on_off_n++]=0; continue; } + if (!strcmp(v[i], "-ON")) + { on_off_name[on_off_n]=NULL; on_off_action[on_off_n++]=1; continue; } + if (!strcmp(v[i], "-OFF")) + { on_off_name[on_off_n]=NULL; on_off_action[on_off_n++]=0; continue; } + if (!strcmp(v[i], "-debug-gui")) { gui_logd = 1; continue; } + usage(); + } + + if (database_filename == NULL) { + printf("ERROR: provide a database file (-d)\n"); + exit(1); + } + + database = parse_database(database_filename); + + load_config_file(database_filename); + + number_of_events = number_of_ids(database); + is_on = calloc(number_of_events, sizeof(int)); + if (is_on == NULL) abort(); + + h = new_handler(database); + + g = gui_init(); + new_thread(gui_thread, g); + + ue_data.ue = 0; + ue_data.e = ⪚ + ue_data.database = database; + + ue_main_gui(&eg, g, h, database, &ue_data); + + for (i = 0; i < number_of_events; i++) { + logger *textlog; + char *name, *desc; + database_get_generic_description(database, i, &name, &desc); + if (!strncmp(name, "LEGACY_", 7)) { + textlog = new_textlog(h, database, name, desc); + logger_add_view(textlog, eg.legacy); + } + free(name); + free(desc); + } + + on_off(database, "UE_MASTER_TICK", is_on, 1); + on_off(database, "UE_PHY_UL_TICK", is_on, 1); + on_off(database, "UE_PHY_DL_TICK", is_on, 1); + on_off(database, "UE_PHY_DLSCH_UE_DCI", is_on, 1); + on_off(database, "UE_PHY_DLSCH_UE_ACK", is_on, 1); + on_off(database, "UE_PHY_DLSCH_UE_NACK", is_on, 1); + on_off(database, "UE_PHY_ULSCH_UE_DCI", is_on, 1); + on_off(database, "UE_PHY_ULSCH_UE_ACK", is_on, 1); + on_off(database, "UE_PHY_ULSCH_UE_NACK", is_on, 1); + on_off(database, "UE_PHY_INPUT_SIGNAL", is_on, 1); + on_off(database, "UE_PHY_DL_CHANNEL_ESTIMATE", is_on, 1); + on_off(database, "UE_PHY_PDCCH_IQ", is_on, 1); + on_off(database, "UE_PHY_PDCCH_ENERGY", is_on, 1); + on_off(database, "UE_PHY_PDSCH_IQ", is_on, 1); + on_off(database, "UE_PHY_PDSCH_ENERGY", is_on, 1); + on_off(database, "UE_PHY_PUSCH_TX_POWER", is_on, 1); + on_off(database, "UE_PHY_PUCCH_TX_POWER", is_on, 1); + on_off(database, "UE_PHY_MEAS", is_on, 1); + + on_off(database, "LEGACY_GROUP_INFO", is_on, 1); + on_off(database, "LEGACY_GROUP_ERROR", is_on, 1); + on_off(database, "LEGACY_GROUP_WARNING", is_on, 1); + + view_add_log(eg.phyview, "UE_PHY_UL_TICK", h, database, is_on); + view_add_log(eg.phyview, "UE_PHY_DL_TICK", h, database, is_on); + view_add_log(eg.phyview, "UE_PHY_DLSCH_UE_DCI", h, database, is_on); + view_add_log(eg.phyview, "UE_PHY_DLSCH_UE_ACK", h, database, is_on); + view_add_log(eg.phyview, "UE_PHY_DLSCH_UE_NACK",h, database, is_on); + view_add_log(eg.phyview, "UE_PHY_ULSCH_UE_DCI", h, database, is_on); + view_add_log(eg.phyview, "UE_PHY_ULSCH_UE_ACK", h, database, is_on); + view_add_log(eg.phyview, "UE_PHY_ULSCH_UE_NACK", h, database, is_on); + + + + /* deactivate those two by default, they are a bit heavy */ + //on_off(database, "ENB_MAC_UE_UL_SDU_WITH_DATA", is_on, 0); + //on_off(database, "ENB_MAC_UE_UL_PDU_WITH_DATA", is_on, 0); + + for (i = 0; i < on_off_n; i++) + on_off(database, on_off_name[i], is_on, on_off_action[i]); + + ue_data.socket = -1; + ue_data.is_on = is_on; + ue_data.nevents = number_of_events; + if (pthread_mutex_init(&ue_data.lock, NULL)) abort(); + setup_event_selector(g, database, is_on, is_on_changed, &ue_data); + +restart: + clear_remote_config(); + ue_data.socket = connect_to(ip, port); + + /* send the first message - activate selected traces */ + is_on_changed(&ue_data); + + /* read messages */ + while (1) { + char v[T_BUFFER_MAX]; + event e; + e = get_event(ue_data.socket, v, database); + if (e.type == -1) goto restart; + if (pthread_mutex_lock(&ue_data.lock)) abort(); + handle_event(h, e); + if (pthread_mutex_unlock(&ue_data.lock)) abort(); + } + + return 0; +} diff --git a/common/utils/itti/intertask_interface.c b/common/utils/itti/intertask_interface.c index 387c23e1ccb5c34ec9c9b1fcc8c635d4cc4acac5..28267900af58f195988ae35aed5a98cc66e2349e 100644 --- a/common/utils/itti/intertask_interface.c +++ b/common/utils/itti/intertask_interface.c @@ -81,13 +81,13 @@ #define ITTI_DEBUG_ISSUES (1<<5) #define ITTI_DEBUG_MP_STATISTICS (1<<6) -const int itti_debug = ITTI_DEBUG_ISSUES | ITTI_DEBUG_MP_STATISTICS; +const int itti_debug = (ITTI_DEBUG_ISSUES | ITTI_DEBUG_MP_STATISTICS); /* Don't flush if using RTAI */ #ifdef RTAI # define ITTI_DEBUG(m, x, args...) do { if ((m) & itti_debug) rt_log_debug (x, ##args); } while(0); #else -# define ITTI_DEBUG(m, x, args...) do { if ((m) & itti_debug) fprintf(stdout, "[ITTI][D]"x, ##args); fflush (stdout); } while(0); +# define ITTI_DEBUG(m, x, args...) do { if ((m) & itti_debug) {fprintf(stdout, "[ITTI][D]"x, ##args); fflush (stdout);} } while(0); #endif #define ITTI_ERROR(x, args...) do { fprintf(stdout, "[ITTI][E]"x, ##args); fflush (stdout); } while(0); diff --git a/common/utils/itti/itti_types.h b/common/utils/itti/itti_types.h index 8cf0d7a58146e4da8dbc73897658f95f5b1d6551..e5bbf448308cbaba0976c63bb819c81f38882274 100644 --- a/common/utils/itti/itti_types.h +++ b/common/utils/itti/itti_types.h @@ -71,7 +71,5 @@ typedef struct { #define INSTANCE_DEFAULT (UINT16_MAX - 1) #define INSTANCE_ALL (UINT16_MAX) -typedef uint16_t instance_t; - #endif diff --git a/openair1/PHY/CODING/TESTBENCH/ltetest.c b/openair1/PHY/CODING/TESTBENCH/ltetest.c index bb4c136af0aa8c6c6ea6184cd27b5779d44eac8c..6bc5e2526430336465824f72a9ac26d866536ccc 100644 --- a/openair1/PHY/CODING/TESTBENCH/ltetest.c +++ b/openair1/PHY/CODING/TESTBENCH/ltetest.c @@ -256,6 +256,7 @@ int test_logmap8(LTE_eNB_DLSCH_t *dlsch_eNB, &PHY_vars_UE->lte_frame_parms, PHY_vars_UE->dlsch_ue[0][0], PHY_vars_UE->dlsch_ue[0][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid], + frame, subframe, PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid, num_pdcch_symbols,1); diff --git a/openair1/PHY/INIT/lte_init.c b/openair1/PHY/INIT/lte_init.c index 17338d85b531b89f7d8993689b3ef3340bd8fc56..f6f8d8f858cfc5e9c8a46927a0555b47456081c2 100644 --- a/openair1/PHY/INIT/lte_init.c +++ b/openair1/PHY/INIT/lte_init.c @@ -29,7 +29,7 @@ #include "LAYER2/MAC/extern.h" #include "MBSFN-SubframeConfigList.h" #include "UTIL/LOG/vcd_signal_dumper.h" -//#define DEBUG_PHY +#define DEBUG_PHY #include "assertions.h" #include @@ -211,7 +211,7 @@ void phy_config_sib2_eNB(uint8_t Mod_id, if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_oneFrame) { fp->MBSFN_config[i].fourFrames_flag = 0; fp->MBSFN_config[i].mbsfn_SubframeConfig = mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]; // 6-bit subframe configuration - LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is %ld\n", i, + LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is %d\n", i, fp->MBSFN_config[i].mbsfn_SubframeConfig); } else if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_fourFrames) { // 24-bit subframe configuration fp->MBSFN_config[i].fourFrames_flag = 1; @@ -220,7 +220,7 @@ void phy_config_sib2_eNB(uint8_t Mod_id, (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[1]<<8)| (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[2]<<16); - LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is %ld\n", i, + LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is %d\n", i, fp->MBSFN_config[i].mbsfn_SubframeConfig); } } @@ -331,7 +331,7 @@ void phy_config_sib2_ue(uint8_t Mod_id,int CC_id, if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_oneFrame) { fp->MBSFN_config[i].fourFrames_flag = 0; fp->MBSFN_config[i].mbsfn_SubframeConfig = mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]; // 6-bit subframe configuration - LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is %ld\n", i, + LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is %d\n", i, fp->MBSFN_config[i].mbsfn_SubframeConfig); } else if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_fourFrames) { // 24-bit subframe configuration fp->MBSFN_config[i].fourFrames_flag = 1; @@ -340,7 +340,7 @@ void phy_config_sib2_ue(uint8_t Mod_id,int CC_id, (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[1]<<8)| (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[2]<<16); - LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is %ld\n", i, + LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is %d\n", i, fp->MBSFN_config[i].mbsfn_SubframeConfig); } } @@ -357,7 +357,7 @@ void phy_config_sib13_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,int mbsfn_Area_ LTE_DL_FRAME_PARMS *fp = &PHY_vars_UE_g[Mod_id][CC_id]->frame_parms; - LOG_I(PHY,"[UE%d] Applying MBSFN_Area_id %d for index %d\n",Mod_id,mbsfn_AreaId_r9,mbsfn_Area_idx); + LOG_I(PHY,"[UE%d] Applying MBSFN_Area_id %ld for index %d\n",Mod_id,mbsfn_AreaId_r9,mbsfn_Area_idx); if (mbsfn_Area_idx == 0) { fp->Nid_cell_mbsfn = (uint16_t)mbsfn_AreaId_r9; @@ -376,7 +376,7 @@ void phy_config_sib13_eNB(uint8_t Mod_id,int CC_id,int mbsfn_Area_idx, LTE_DL_FRAME_PARMS *fp = &PHY_vars_eNB_g[Mod_id][CC_id]->frame_parms; - LOG_I(PHY,"[eNB%d] Applying MBSFN_Area_id %d for index %d\n",Mod_id,mbsfn_AreaId_r9,mbsfn_Area_idx); + LOG_I(PHY,"[eNB%d] Applying MBSFN_Area_id %ld for index %d\n",Mod_id,mbsfn_AreaId_r9,mbsfn_Area_idx); if (mbsfn_Area_idx == 0) { fp->Nid_cell_mbsfn = (uint16_t)mbsfn_AreaId_r9; @@ -398,7 +398,7 @@ void phy_config_dedicated_eNB_step2(PHY_VARS_eNB *eNB) physicalConfigDedicated = eNB->physicalConfigDedicated[UE_id]; if (physicalConfigDedicated != NULL) { - LOG_I(PHY,"[eNB %d] Frame %d: Sent physicalConfigDedicated=%p for UE %d\n",eNB->Mod_id,physicalConfigDedicated,UE_id); + LOG_I(PHY,"[eNB %d] Sent physicalConfigDedicated=%p for UE %d\n",eNB->Mod_id,physicalConfigDedicated,UE_id); LOG_D(PHY,"------------------------------------------------------------------------\n"); if (physicalConfigDedicated->pdsch_ConfigDedicated) { @@ -653,7 +653,7 @@ void phy_config_dedicated_eNB(uint8_t Mod_id, int8_t UE_id = find_ue(rnti,eNB); if (UE_id == -1) { - LOG_E( PHY, "[eNB %"PRIu8"] find_ue() returns -1\n"); + LOG_E( PHY, "[eNB %"PRIu8"] find_ue() returns -1\n", Mod_id); return; } @@ -684,6 +684,7 @@ void phy_config_dedicated_eNB(uint8_t Mod_id, break; case AntennaInfoDedicated__transmissionMode_tm7: lte_gold_ue_spec_port5(eNB->lte_gold_uespec_port5_table[0],eNB->frame_parms.Nid_cell,rnti); + eNB->do_precoding = 1; eNB->transmission_mode[UE_id] = 7; break; default: @@ -725,13 +726,13 @@ void phy_config_dedicated_scell_eNB(uint8_t Mod_id, if ((dl_CarrierFreq_r10>=36000) && (dl_CarrierFreq_r10<=36199)) { carrier_freq_local = 1900000000 + (dl_CarrierFreq_r10-36000)*100000; //band 33 from 3GPP 36.101 v 10.9 Table 5.7.3-1 - LOG_I(PHY,"[eNB %d] Frame %d: Configured SCell %d to frequency %d (ARFCN %d) for UE %d\n",Mod_id,/*eNB->frame*/0,CC_id,carrier_freq_local,dl_CarrierFreq_r10,UE_id); + LOG_I(PHY,"[eNB %d] Frame %d: Configured SCell %d to frequency %d (ARFCN %ld) for UE %d\n",Mod_id,/*eNB->frame*/0,CC_id,carrier_freq_local,dl_CarrierFreq_r10,UE_id); } else if ((dl_CarrierFreq_r10>=6150) && (dl_CarrierFreq_r10<=6449)) { carrier_freq_local = 832000000 + (dl_CarrierFreq_r10-6150)*100000; //band 20 from 3GPP 36.101 v 10.9 Table 5.7.3-1 // this is actually for the UL only, but we use it for DL too, since there is no TDD mode for this band - LOG_I(PHY,"[eNB %d] Frame %d: Configured SCell %d to frequency %d (ARFCN %d) for UE %d\n",Mod_id,/*eNB->frame*/0,CC_id,carrier_freq_local,dl_CarrierFreq_r10,UE_id); + LOG_I(PHY,"[eNB %d] Frame %d: Configured SCell %d to frequency %d (ARFCN %ld) for UE %d\n",Mod_id,/*eNB->frame*/0,CC_id,carrier_freq_local,dl_CarrierFreq_r10,UE_id); } else { - LOG_E(PHY,"[eNB %d] Frame %d: ARFCN %d of SCell %d for UE %d not supported\n",Mod_id,/*eNB->frame*/0,dl_CarrierFreq_r10,CC_id,UE_id); + LOG_E(PHY,"[eNB %d] Frame %d: ARFCN %ld of SCell %d for UE %d not supported\n",Mod_id,/*eNB->frame*/0,dl_CarrierFreq_r10,CC_id,UE_id); } if (physicalConfigDedicatedSCell_r10) { @@ -1062,7 +1063,8 @@ int phy_init_lte_ue(PHY_VARS_UE *ue, // create shortcuts LTE_DL_FRAME_PARMS* const fp = &ue->frame_parms; LTE_UE_COMMON* const common_vars = &ue->common_vars; - LTE_UE_PDSCH** const pdsch_vars = ue->pdsch_vars; + LTE_UE_PDSCH** const pdsch_vars_th0 = ue->pdsch_vars[0]; + LTE_UE_PDSCH** const pdsch_vars_th1 = ue->pdsch_vars[1]; LTE_UE_PDSCH** const pdsch_vars_SI = ue->pdsch_vars_SI; LTE_UE_PDSCH** const pdsch_vars_ra = ue->pdsch_vars_ra; LTE_UE_PDSCH** const pdsch_vars_mch = ue->pdsch_vars_MCH; @@ -1115,32 +1117,37 @@ int phy_init_lte_ue(PHY_VARS_UE *ue, // init RX buffers common_vars->rxdata = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) ); - common_vars->rxdataF = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) ); - common_vars->rxdataF2 = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) ); + common_vars->common_vars_rx_data_per_thread[0].rxdataF = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) ); + common_vars->common_vars_rx_data_per_thread[1].rxdataF = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) ); for (i=0; inb_antennas_rx; i++) { common_vars->rxdata[i] = (int32_t*) malloc16_clear( (fp->samples_per_tti*10+2048)*sizeof(int32_t) ); - common_vars->rxdataF[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->ofdm_symbol_size*14) ); - common_vars->rxdataF2[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->ofdm_symbol_size*fp->symbols_per_tti*10) ); + common_vars->common_vars_rx_data_per_thread[0].rxdataF[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->ofdm_symbol_size*14) ); + common_vars->common_vars_rx_data_per_thread[1].rxdataF[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->ofdm_symbol_size*14) ); } } // Channel estimates for (eNB_id=0; eNB_id<7; eNB_id++) { - common_vars->dl_ch_estimates[eNB_id] = (int32_t**)malloc16_clear(8*sizeof(int32_t*)); - common_vars->dl_ch_estimates_time[eNB_id] = (int32_t**)malloc16_clear(8*sizeof(int32_t*)); + common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates[eNB_id] = (int32_t**)malloc16_clear(8*sizeof(int32_t*)); + common_vars->common_vars_rx_data_per_thread[1].dl_ch_estimates[eNB_id] = (int32_t**)malloc16_clear(8*sizeof(int32_t*)); + common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates_time[eNB_id] = (int32_t**)malloc16_clear(8*sizeof(int32_t*)); + common_vars->common_vars_rx_data_per_thread[1].dl_ch_estimates_time[eNB_id] = (int32_t**)malloc16_clear(8*sizeof(int32_t*)); for (i=0; inb_antennas_rx; i++) for (j=0; j<4; j++) { int idx = (j<<1) + i; - common_vars->dl_ch_estimates[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->symbols_per_tti*(fp->ofdm_symbol_size+LTE_CE_FILTER_LENGTH) ); - common_vars->dl_ch_estimates_time[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 ); + common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->symbols_per_tti*(fp->ofdm_symbol_size+LTE_CE_FILTER_LENGTH) ); + common_vars->common_vars_rx_data_per_thread[1].dl_ch_estimates[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->symbols_per_tti*(fp->ofdm_symbol_size+LTE_CE_FILTER_LENGTH) ); + common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates_time[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 ); + common_vars->common_vars_rx_data_per_thread[1].dl_ch_estimates_time[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 ); } } // DLSCH for (eNB_id=0; eNB_idn_connected_eNB; eNB_id++) { - pdsch_vars[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH)); + pdsch_vars_th0[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH)); + pdsch_vars_th1[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH)); pdsch_vars_SI[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH)); pdsch_vars_ra[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH)); pdsch_vars_mch[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH)); @@ -1149,25 +1156,43 @@ int phy_init_lte_ue(PHY_VARS_UE *ue, pbch_vars[eNB_id] = (LTE_UE_PBCH *)malloc16_clear(sizeof(LTE_UE_PBCH)); if (abstraction_flag == 0) { - phy_init_lte_ue__PDSCH( pdsch_vars[eNB_id], fp ); + phy_init_lte_ue__PDSCH( pdsch_vars_th0[eNB_id], fp ); + phy_init_lte_ue__PDSCH( pdsch_vars_th1[eNB_id], fp ); - pdsch_vars[eNB_id]->llr_shifts = (uint8_t*)malloc16_clear(7*2*fp->N_RB_DL*12); - pdsch_vars[eNB_id]->llr_shifts_p = pdsch_vars[eNB_id]->llr_shifts; - pdsch_vars[eNB_id]->dl_ch_mag1 = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) ); - pdsch_vars[eNB_id]->dl_ch_magb1 = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) ); - pdsch_vars[eNB_id]->llr[1] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) ); + // thread 0 + pdsch_vars_th0[eNB_id]->llr_shifts = (uint8_t*)malloc16_clear(7*2*fp->N_RB_DL*12); + pdsch_vars_th0[eNB_id]->llr_shifts_p = pdsch_vars_th0[eNB_id]->llr_shifts; + pdsch_vars_th0[eNB_id]->dl_ch_mag1 = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) ); + pdsch_vars_th0[eNB_id]->dl_ch_magb1 = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) ); + pdsch_vars_th0[eNB_id]->llr[1] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) ); for (k=0; k<8; k++) - pdsch_vars[eNB_id]->rxdataF_comp1[k] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) ); + pdsch_vars_th0[eNB_id]->rxdataF_comp1[k] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) ); + + // thread 1 + pdsch_vars_th1[eNB_id]->llr_shifts = (uint8_t*)malloc16_clear(7*2*fp->N_RB_DL*12); + pdsch_vars_th1[eNB_id]->llr_shifts_p = pdsch_vars_th1[eNB_id]->llr_shifts; + pdsch_vars_th1[eNB_id]->dl_ch_mag1 = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) ); + pdsch_vars_th1[eNB_id]->dl_ch_magb1 = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) ); + pdsch_vars_th1[eNB_id]->llr[1] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) ); + + for (k=0; k<8; k++) + pdsch_vars_th1[eNB_id]->rxdataF_comp1[k] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) ); for (i=0; inb_antennas_rx; i++) for (j=0; j<4; j++) { int idx = (j<<1)+i; - pdsch_vars[eNB_id]->dl_ch_mag1[idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) ); - pdsch_vars[eNB_id]->dl_ch_magb1[idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) ); + pdsch_vars_th0[eNB_id]->dl_ch_mag1[idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) ); + pdsch_vars_th0[eNB_id]->dl_ch_magb1[idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) ); + + pdsch_vars_th1[eNB_id]->dl_ch_mag1[idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) ); + pdsch_vars_th1[eNB_id]->dl_ch_magb1[idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) ); for (k=0; k<8; k++) - pdsch_vars[eNB_id]->rxdataF_comp1[idx][k] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->N_RB_DL*12*14) ); + { + pdsch_vars_th0[eNB_id]->rxdataF_comp1[idx][k] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->N_RB_DL*12*14) ); + pdsch_vars_th1[eNB_id]->rxdataF_comp1[idx][k] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->N_RB_DL*12*14) ); + } } phy_init_lte_ue__PDSCH( pdsch_vars_SI[eNB_id], fp ); @@ -1224,14 +1249,17 @@ int phy_init_lte_ue(PHY_VARS_UE *ue, // initialization for the last instance of pdsch_vars (used for MU-MIMO) - pdsch_vars[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) ); + pdsch_vars_th0[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) ); + pdsch_vars_th1[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) ); pdsch_vars_SI[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) ); pdsch_vars_ra[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) ); if (abstraction_flag == 0) { - phy_init_lte_ue__PDSCH( pdsch_vars[eNB_id], fp ); - pdsch_vars[eNB_id]->llr[1] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) ); + phy_init_lte_ue__PDSCH( pdsch_vars_th0[eNB_id], fp ); + pdsch_vars_th0[eNB_id]->llr[1] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) ); + phy_init_lte_ue__PDSCH( pdsch_vars_th1[eNB_id], fp ); + pdsch_vars_th1[eNB_id]->llr[1] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) ); } else { //abstraction == 1 ue->sinr_dB = (double*) malloc16_clear( fp->N_RB_DL*12*sizeof(double) ); } @@ -1304,49 +1332,54 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB, common_vars->txdataF[eNB_id] = (int32_t **)malloc16(NB_ANTENNA_PORTS_ENB*sizeof(int32_t*)); common_vars->txdataF_BF[eNB_id] = (int32_t **)malloc16(fp->nb_antennas_tx*sizeof(int32_t*)); - for (i=0; i<14; i++) { - common_vars->txdataF[eNB_id][i] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*fp->symbols_per_tti*10*sizeof(int32_t) ); + if (eNB->node_function != NGFI_RRU_IF5) { + for (i=0; inb_antenna_ports_eNB || i==5) { + common_vars->txdataF[eNB_id][i] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*fp->symbols_per_tti*10*sizeof(int32_t) ); #ifdef DEBUG_PHY - msg("[openair][LTE_PHY][INIT] lte_common_vars->txdataF[%d][%d] = %p (%d bytes)\n", - eNB_id,i,common_vars->txdataF[eNB_id][i], - fp->ofdm_symbol_size*fp->symbols_per_tti*10*sizeof(int32_t)); + printf("[openair][LTE_PHY][INIT] common_vars->txdataF[%d][%d] = %p (%lu bytes)\n", + eNB_id,i,common_vars->txdataF[eNB_id][i], + fp->ofdm_symbol_size*fp->symbols_per_tti*10*sizeof(int32_t)); #endif + } + } } - for (i=0; inb_antennas_tx; i++) { common_vars->txdataF_BF[eNB_id][i] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*sizeof(int32_t) ); if (eNB->node_function != NGFI_RCC_IF4p5) - common_vars->txdata[eNB_id][i] = (int32_t*)malloc16_clear(fp->samples_per_tti*10*sizeof(int32_t) ); + + // Allocate 10 subframes of I/Q TX signal data (time) if not + common_vars->txdata[eNB_id][i] = (int32_t*)malloc16_clear( fp->samples_per_tti*10*sizeof(int32_t) ); #ifdef DEBUG_PHY - msg("[openair][LTE_PHY][INIT] lte_common_vars->txdataF_BF[%d][%d] = %p (%d bytes)\n", - eNB_id,i,common_vars->txdataF_BF[eNB_id][i], - fp->ofdm_symbol_size*sizeof(int32_t)); - msg("[openair][LTE_PHY][INIT] lte_common_vars->txdata[%d][%d] = %p\n",eNB_id,i,common_vars->txdata[eNB_id][i]); + printf("[openair][LTE_PHY][INIT] common_vars->txdata[%d][%d] = %p (%lu bytes)\n",eNB_id,i,common_vars->txdata[eNB_id][i], + fp->samples_per_tti*10*sizeof(int32_t)); #endif } - for (i=0; i<14; i++) { // 14 is the total number of antenna ports - common_vars->beam_weights[eNB_id][i] = (int32_t **)malloc16_clear(fp->nb_antennas_tx*sizeof(int32_t*)); - for (j=0; jnb_antennas_tx; j++) { - common_vars->beam_weights[eNB_id][i][j] = (int32_t *)malloc16_clear(fp->ofdm_symbol_size*sizeof(int32_t)); - // antenna ports 0-3 are mapped on antennas 0-3 - // antenna port 4 is mapped on antenna 0 - // antenna ports 5-14 are mapped on all antennas - if (((i<4) && (i==j)) || ((i==4) && (j==0))) { - for (re=0; reofdm_symbol_size; re++) - common_vars->beam_weights[eNB_id][i][j][re] = 0x00007fff; - } - else if (i>4) { - for (re=0; reofdm_symbol_size; re++) - common_vars->beam_weights[eNB_id][i][j][re] = 0x00007fff/fp->nb_antennas_tx; - } + for (i=0; inb_antenna_ports_eNB || i==5) { + common_vars->beam_weights[eNB_id][i] = (int32_t **)malloc16_clear(fp->nb_antennas_tx*sizeof(int32_t*)); + for (j=0; jnb_antennas_tx; j++) { + common_vars->beam_weights[eNB_id][i][j] = (int32_t *)malloc16_clear(fp->ofdm_symbol_size*sizeof(int32_t)); + // antenna ports 0-3 are mapped on antennas 0-3 + // antenna port 4 is mapped on antenna 0 + // antenna ports 5-14 are mapped on all antennas + if (((i<4) && (i==j)) || ((i==4) && (j==0))) { + for (re=0; reofdm_symbol_size; re++) + common_vars->beam_weights[eNB_id][i][j][re] = 0x00007fff; + } + else if (i>4) { + for (re=0; reofdm_symbol_size; re++) + common_vars->beam_weights[eNB_id][i][j][re] = 0x00007fff/fp->nb_antennas_tx; + } #ifdef DEBUG_PHY - msg("[openair][LTE_PHY][INIT] lte_common_vars->beam_weights[%d][%d][%d] = %p (%d bytes)\n", - eNB_id,i,j,common_vars->beam_weights[eNB_id][i][j], - fp->ofdm_symbol_size*sizeof(int32_t)); + msg("[openair][LTE_PHY][INIT] lte_common_vars->beam_weights[%d][%d][%d] = %p (%d bytes)\n", + eNB_id,i,j,common_vars->beam_weights[eNB_id][i][j], + fp->ofdm_symbol_size*sizeof(int32_t)); #endif - } + } + } } // RX vars @@ -1358,17 +1391,25 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB, for (i=0; inb_antennas_rx; i++) { if (eNB->node_function != NGFI_RCC_IF4p5) { + // allocate 2 subframes of I/Q signal data (time) if not an RCC (no time-domain signals) common_vars->rxdata[eNB_id][i] = (int32_t*)malloc16_clear( fp->samples_per_tti*10*sizeof(int32_t) ); - common_vars->rxdata_7_5kHz[eNB_id][i] = (int32_t*)malloc16_clear( fp->samples_per_tti*sizeof(int32_t) ); + + if (eNB->node_function != NGFI_RRU_IF5) + // allocate 2 subframes of I/Q signal data (time, 7.5 kHz offset) + common_vars->rxdata_7_5kHz[eNB_id][i] = (int32_t*)malloc16_clear( 2*fp->samples_per_tti*2*sizeof(int32_t) ); + } + if (eNB->node_function != NGFI_RRU_IF5) + // allocate 2 subframes of I/Q signal data (frequency) + common_vars->rxdataF[eNB_id][i] = (int32_t*)malloc16_clear(sizeof(int32_t)*(2*fp->ofdm_symbol_size*fp->symbols_per_tti) ); #ifdef DEBUG_PHY - printf("[openair][LTE_PHY][INIT] common_vars->rxdata[%d][%d] = %p\n",eNB_id,i,common_vars->rxdata[eNB_id][i]); - printf("[openair][LTE_PHY][INIT] common_vars->rxdata_7_5kHz[%d][%d] = %p\n",eNB_id,i,common_vars->rxdata_7_5kHz[eNB_id][i]); + printf("[openair][LTE_PHY][INIT] common_vars->rxdata[%d][%d] = %p (%lu bytes)\n",eNB_id,i,common_vars->rxdata[eNB_id][i],fp->samples_per_tti*10*sizeof(int32_t)); + if (eNB->node_function != NGFI_RRU_IF5) + printf("[openair][LTE_PHY][INIT] common_vars->rxdata_7_5kHz[%d][%d] = %p (%lu bytes)\n",eNB_id,i,common_vars->rxdata_7_5kHz[eNB_id][i],fp->samples_per_tti*2*sizeof(int32_t)); #endif - } common_vars->rxdataF[eNB_id][i] = (int32_t*)malloc16_clear(sizeof(int32_t)*(fp->ofdm_symbol_size*fp->symbols_per_tti) ); } - if (eNB->node_function != NGFI_RRU_IF4p5) { + if ((eNB->node_function != NGFI_RRU_IF4p5)&&(eNB->node_function != NGFI_RRU_IF5)) { // Channel estimates for SRS for (UE_id=0; UE_idsync_corr[eNB_id] = (uint32_t*)malloc16_clear( LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*sizeof(uint32_t)*fp->samples_per_tti ); } - } else { //UPLINK abstraction = 1 + } // abstraction_flag = 0 + else { //UPLINK abstraction = 1 eNB->sinr_dB = (double*) malloc16_clear( fp->N_RB_DL*12*sizeof(double) ); } } //eNB_id @@ -1391,7 +1433,7 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB, if (abstraction_flag==0) { - if (eNB->node_function != NGFI_RRU_IF4p5) { + if ((eNB->node_function != NGFI_RRU_IF4p5)&&(eNB->node_function != NGFI_RRU_IF5)) { generate_ul_ref_sigs_rx(); // SRS @@ -1405,7 +1447,7 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB, // ULSCH VARS, skip if NFGI_RRU_IF4 - if (eNB->node_function!=NGFI_RRU_IF4p5) + if ((eNB->node_function!=NGFI_RRU_IF4p5)&&(eNB->node_function != NGFI_RRU_IF5)) prach_vars->prachF = (int16_t*)malloc16_clear( 1024*2*sizeof(int16_t) ); /* number of elements of an array X is computed as sizeof(X) / sizeof(X[0]) */ @@ -1418,7 +1460,7 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB, #endif } - if (eNB->node_function != NGFI_RRU_IF4p5) { + if ((eNB->node_function != NGFI_RRU_IF4p5)&&(eNB->node_function != NGFI_RRU_IF5)) { AssertFatal(fp->nb_antennas_rx <= sizeof(prach_vars->prach_ifft) / sizeof(prach_vars->prach_ifft[0]), "nb_antennas_rx too large"); for (i=0; inb_antennas_rx; i++) { diff --git a/openair1/PHY/INIT/lte_parms.c b/openair1/PHY/INIT/lte_parms.c index cd879b1a90e6634ef02de54d2adea067e6bdb7ee..f0c63df9e6c2caebc13fd5e7b7366c80dc44518a 100644 --- a/openair1/PHY/INIT/lte_parms.c +++ b/openair1/PHY/INIT/lte_parms.c @@ -22,6 +22,23 @@ #include "defs.h" #include "log.h" +uint16_t dl_S_table_normal[10]={3,9,10,11,12,3,9,10,11,6}; +uint16_t dl_S_table_extended[10]={3,8,9,10,3,8,9,5,0,0}; + +void set_S_config(LTE_DL_FRAME_PARMS *fp) { + + int X = fp->srsX; + + fp->ul_symbols_in_S_subframe=(1+X); + + if ((fp->Ncp==EXTENDED) && (fp->tdd_config_S>7)) + AssertFatal(1==0,"Illegal S subframe configuration for Extended Prefix mode\n"); + + fp->dl_symbols_in_S_subframe = (fp->Ncp==NORMAL)?dl_S_table_normal[fp->tdd_config_S] : dl_S_table_extended[fp->tdd_config_S]; + + +} + int init_frame_parms(LTE_DL_FRAME_PARMS *frame_parms,uint8_t osf) { @@ -29,7 +46,7 @@ int init_frame_parms(LTE_DL_FRAME_PARMS *frame_parms,uint8_t osf) LOG_I(PHY,"Initializing frame parms for N_RB_DL %d, Ncp %d, osf %d\n",frame_parms->N_RB_DL,frame_parms->Ncp,osf); - if (frame_parms->Ncp==1) { + if (frame_parms->Ncp==EXTENDED) { frame_parms->nb_prefix_samples0=512; frame_parms->nb_prefix_samples = 512; frame_parms->symbols_per_tti = 12; @@ -37,8 +54,10 @@ int init_frame_parms(LTE_DL_FRAME_PARMS *frame_parms,uint8_t osf) frame_parms->nb_prefix_samples0 = 160; frame_parms->nb_prefix_samples = 144; frame_parms->symbols_per_tti = 14; + } + switch(osf) { case 1: log2_osf = 0; @@ -167,6 +186,8 @@ int init_frame_parms(LTE_DL_FRAME_PARMS *frame_parms,uint8_t osf) printf("lte_parms.c: Setting N_RB_DL to %d, ofdm_symbol_size %d\n",frame_parms->N_RB_DL, frame_parms->ofdm_symbol_size); + if (frame_parms->frame_type == TDD) set_S_config(frame_parms); + // frame_parms->tdd_config=3; return(0); } diff --git a/openair1/PHY/LTE_ESTIMATION/defs.h b/openair1/PHY/LTE_ESTIMATION/defs.h index 3af9c2471f140cacdb0a84d8829d976cba237be8..08615119ef613667c78ac6b63aafc3355d79aeef 100644 --- a/openair1/PHY/LTE_ESTIMATION/defs.h +++ b/openair1/PHY/LTE_ESTIMATION/defs.h @@ -34,7 +34,7 @@ */ /*!\brief Timing drift hysterisis in samples*/ -#define SYNCH_HYST 1 +#define SYNCH_HYST 2 /*! \brief This function is used for time-frequency scanning prior to complete cell search. It scans @@ -180,6 +180,7 @@ This function computes the time domain channel response, finds the peak and adju void lte_adjust_synch(LTE_DL_FRAME_PARMS *frame_parms, PHY_VARS_UE *phy_vars_ue, module_id_t eNb_id, + uint8_t subframe, unsigned char clear, short coef); @@ -187,7 +188,8 @@ void lte_adjust_synch(LTE_DL_FRAME_PARMS *frame_parms, void lte_ue_measurements(PHY_VARS_UE *phy_vars_ue, unsigned int subframe_offset, unsigned char N0_symbol, - unsigned char abstraction_flag); + unsigned char abstraction_flag, + uint8_t subframe); //! \brief This function performance RSRP/RSCP measurements void ue_rrc_measurements(PHY_VARS_UE *phy_vars_ue, diff --git a/openair1/PHY/LTE_ESTIMATION/lte_adjust_sync.c b/openair1/PHY/LTE_ESTIMATION/lte_adjust_sync.c index 8f9b9cc047638c58e5c70d36ecea40088d4f2ca7..cefa6fd99f91d083914a111642649ab270800680 100644 --- a/openair1/PHY/LTE_ESTIMATION/lte_adjust_sync.c +++ b/openair1/PHY/LTE_ESTIMATION/lte_adjust_sync.c @@ -34,6 +34,7 @@ void lte_adjust_synch(LTE_DL_FRAME_PARMS *frame_parms, PHY_VARS_UE *ue, unsigned char eNB_id, + uint8_t subframe, unsigned char clear, short coef) { @@ -48,7 +49,7 @@ void lte_adjust_synch(LTE_DL_FRAME_PARMS *frame_parms, ncoef = 32767 - coef; #ifdef DEBUG_PHY - LOG_D(PHY,"frame %d: rx_offset (before) = %d\n",ue->proc.proc_rxtx[0].frame_rx,ue->rx_offset); + LOG_D(PHY,"AbsSubframe %d.%d: rx_offset (before) = %d\n",ue->proc.proc_rxtx[0].frame_rx%1024,subframe,ue->rx_offset); #endif //DEBUG_PHY @@ -57,8 +58,8 @@ void lte_adjust_synch(LTE_DL_FRAME_PARMS *frame_parms, temp = 0; for (aa=0; aanb_antennas_rx; aa++) { - Re = ((int16_t*)ue->common_vars.dl_ch_estimates_time[eNB_id][aa])[(i<<2)]; - Im = ((int16_t*)ue->common_vars.dl_ch_estimates_time[eNB_id][aa])[1+(i<<2)]; + Re = ((int16_t*)ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates_time[eNB_id][aa])[(i<<2)]; + Im = ((int16_t*)ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates_time[eNB_id][aa])[1+(i<<2)]; temp += (Re*Re/2) + (Im*Im/2); } @@ -74,13 +75,15 @@ void lte_adjust_synch(LTE_DL_FRAME_PARMS *frame_parms, else max_pos_fil = ((max_pos_fil * coef) + (max_pos * ncoef)) >> 15; + // do not filter to have proactive timing adjustment + max_pos_fil = max_pos; - diff = max_pos_fil - frame_parms->nb_prefix_samples/8; + diff = max_pos_fil - (frame_parms->nb_prefix_samples>>3); - if ( diff > SYNCH_HYST ) - ue->rx_offset++; - else if (diff < -SYNCH_HYST) - ue->rx_offset--; + if ( abs(diff) < SYNCH_HYST ) + ue->rx_offset = 0; + else + ue->rx_offset = diff; if ( ue->rx_offset < 0 ) ue->rx_offset += FRAME_LENGTH_COMPLEX_SAMPLES; @@ -91,8 +94,8 @@ void lte_adjust_synch(LTE_DL_FRAME_PARMS *frame_parms, #ifdef DEBUG_PHY - LOG_D(PHY,"frame %d: rx_offset (after) = %d : max_pos = %d,max_pos_fil = %d (peak %d)\n", - ue->proc.proc_rxtx[0].frame_rx,ue->rx_offset,max_pos,max_pos_fil,temp); + LOG_D(PHY,"AbsSubframe %d.%d: rx_offset (after) = %d : max_pos = %d,max_pos_fil = %d (peak %d) target_pos %d \n", + ue->proc.proc_rxtx[0].frame_rx,subframe,ue->rx_offset,max_pos,max_pos_fil,temp,(frame_parms->nb_prefix_samples>>3)); #endif //DEBUG_PHY VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH, VCD_FUNCTION_OUT); diff --git a/openair1/PHY/LTE_ESTIMATION/lte_dl_bf_channel_estimation.c b/openair1/PHY/LTE_ESTIMATION/lte_dl_bf_channel_estimation.c index 0b220c2c391897a8f5283c450fa75ab5d42232b0..df6a55eaf35560a90f619b01e824e145cea2e212 100644 --- a/openair1/PHY/LTE_ESTIMATION/lte_dl_bf_channel_estimation.c +++ b/openair1/PHY/LTE_ESTIMATION/lte_dl_bf_channel_estimation.c @@ -70,9 +70,9 @@ int lte_dl_bf_channel_estimation(PHY_VARS_UE *phy_vars_ue, else rballoc = dlsch0_harq->rb_alloc_even; - rxdataF = phy_vars_ue->common_vars.rxdataF; + rxdataF = phy_vars_ue->common_vars.common_vars_rx_data_per_thread[(Ns>>1)&0x1].rxdataF; - dl_bf_ch_estimates = phy_vars_ue->pdsch_vars[eNB_id]->dl_bf_ch_estimates; + dl_bf_ch_estimates = phy_vars_ue->pdsch_vars[(Ns>>1)&0x1][eNB_id]->dl_bf_ch_estimates; beamforming_mode = phy_vars_ue->transmission_mode[eNB_id]>6 ? phy_vars_ue->transmission_mode[eNB_id] : 0; if (phy_vars_ue->high_speed_flag == 0) // use second channel estimate position for temporary storage diff --git a/openair1/PHY/LTE_ESTIMATION/lte_dl_channel_estimation.c b/openair1/PHY/LTE_ESTIMATION/lte_dl_channel_estimation.c index 45ed0f11c0d1a359fd19db11ccbf019a68091e4b..b34331eb8d4614d3a13b83c9583b722d89b0d649 100644 --- a/openair1/PHY/LTE_ESTIMATION/lte_dl_channel_estimation.c +++ b/openair1/PHY/LTE_ESTIMATION/lte_dl_channel_estimation.c @@ -25,6 +25,7 @@ #include "defs.h" #include "PHY/defs.h" #include "filt96_32.h" +#include "T.h" //#define DEBUG_CH int lte_dl_channel_estimation(PHY_VARS_UE *ue, @@ -43,12 +44,14 @@ int lte_dl_channel_estimation(PHY_VARS_UE *ue, int ch_offset,symbol_offset; // unsigned int n; // int i; + static int interpolateS11S12 = 1; uint16_t Nid_cell = (eNB_offset == 0) ? ue->frame_parms.Nid_cell : ue->measurements.adj_cell_id[eNB_offset-1]; uint8_t nushift,pilot1,pilot2,pilot3; - int **dl_ch_estimates=ue->common_vars.dl_ch_estimates[eNB_offset]; - int **rxdataF=ue->common_vars.rxdataF; + int **dl_ch_estimates =ue->common_vars.common_vars_rx_data_per_thread[(Ns>>1)&0x1].dl_ch_estimates[eNB_offset]; + int **dl_ch_estimates_previous=ue->common_vars.common_vars_rx_data_per_thread[((Ns>>1)+1)&0x1].dl_ch_estimates[eNB_offset]; + int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[(Ns>>1)&0x1].rxdataF; if (ue->frame_parms.Ncp == 0) { // normal prefix pilot1 = 4; @@ -637,13 +640,19 @@ int lte_dl_channel_estimation(PHY_VARS_UE *ue, if (symbol == 0) { // printf("Interpolating %d->0\n",4-ue->frame_parms.Ncp); // dl_ch_prev = (int16_t *)&dl_ch_estimates[(p<<1)+aarx][(4-ue->frame_parms.Ncp)*(ue->frame_parms.ofdm_symbol_size)]; - dl_ch_prev = (int16_t *)&dl_ch_estimates[(p<<1)+aarx][pilot3*(ue->frame_parms.ofdm_symbol_size)]; + if(((Ns>>1)!=0) || ( ((Ns>>1)==0) && interpolateS11S12)) + { + //LOG_D(PHY,"Interpolate s11-->s0 to get s12 and s13 Ns %d \n", Ns); + dl_ch_prev = (int16_t *)&dl_ch_estimates_previous[(p<<1)+aarx][pilot3*(ue->frame_parms.ofdm_symbol_size)]; - multadd_complex_vector_real_scalar(dl_ch_prev,21845,dl_ch_prev+(2*(ue->frame_parms.ofdm_symbol_size)),1,ue->frame_parms.ofdm_symbol_size); - multadd_complex_vector_real_scalar(dl_ch,10923,dl_ch_prev+(2*(ue->frame_parms.ofdm_symbol_size)),0,ue->frame_parms.ofdm_symbol_size); + multadd_complex_vector_real_scalar(dl_ch_prev,21845,dl_ch_prev+(2*(ue->frame_parms.ofdm_symbol_size)),1,ue->frame_parms.ofdm_symbol_size); + multadd_complex_vector_real_scalar(dl_ch,10923,dl_ch_prev+(2*(ue->frame_parms.ofdm_symbol_size)),0,ue->frame_parms.ofdm_symbol_size); - multadd_complex_vector_real_scalar(dl_ch_prev,10923,dl_ch_prev+(2*((ue->frame_parms.ofdm_symbol_size)<<1)),1,ue->frame_parms.ofdm_symbol_size); - multadd_complex_vector_real_scalar(dl_ch,21845,dl_ch_prev+(2*((ue->frame_parms.ofdm_symbol_size)<<1)),0,ue->frame_parms.ofdm_symbol_size); + multadd_complex_vector_real_scalar(dl_ch_prev,10923,dl_ch_prev+(2*((ue->frame_parms.ofdm_symbol_size)<<1)),1,ue->frame_parms.ofdm_symbol_size); + multadd_complex_vector_real_scalar(dl_ch,21845,dl_ch_prev+(2*((ue->frame_parms.ofdm_symbol_size)<<1)),0,ue->frame_parms.ofdm_symbol_size); + } + + interpolateS11S12 = 1; } // this is 1/3,2/3 combination for pilots spaced by 3 symbols else if (symbol == pilot1) { dl_ch_prev = (int16_t *)&dl_ch_estimates[(p<<1)+aarx][0]; @@ -692,6 +701,38 @@ int lte_dl_channel_estimation(PHY_VARS_UE *ue, multadd_complex_vector_real_scalar(dl_ch_prev,21845,dl_ch_prev+(2*(ue->frame_parms.ofdm_symbol_size)<<1),1,ue->frame_parms.ofdm_symbol_size); multadd_complex_vector_real_scalar(dl_ch,10923,dl_ch_prev+(2*((ue->frame_parms.ofdm_symbol_size)<<1)),0,ue->frame_parms.ofdm_symbol_size); } // pilot spacing 3 symbols (1/3,2/3 combination) + + if((ue->rx_offset_diff !=0) && ((Ns>>1) == 9)) + { + //LOG_D(PHY,"Extrapolate s7-->s11 to get s12 and s13 Ns %d\n", Ns); + interpolateS11S12 = 0; + //LOG_E(PHY,"Interpolate s7--s11 s12 s13 pilot 3 Ns %d l %d symbol %d \n", Ns, l, symbol); + int16_t *dlChEst_ofdm11 = (int16_t *)&dl_ch_estimates[(p<<1)+aarx][pilot3*(ue->frame_parms.ofdm_symbol_size)]; + int16_t *dlChEst_ofdm7 = (int16_t *)&dl_ch_estimates[(p<<1)+aarx][pilot2*(ue->frame_parms.ofdm_symbol_size)]; + + // interpolate ofdm s12: 5/4*ofdms11 + -1/4*ofdms7 5/4 q1.15 40960 -1/4 q1.15 8192 + int16_t *dlChEst_ofdm12 = (int16_t *)&dl_ch_estimates[(p<<1)+aarx][12*ue->frame_parms.ofdm_symbol_size]; + for(int i=0; i<(2*ue->frame_parms.ofdm_symbol_size); i++) + { + int64_t tmp_mult = 0; + tmp_mult = ((int64_t)dlChEst_ofdm11[i] * 40960 - (int64_t)dlChEst_ofdm7[i] * 8192); + + tmp_mult = tmp_mult >> 15; + dlChEst_ofdm12[i] = tmp_mult; + } + + // interpolate ofdm s13: 3/2*ofdms11 + -1/2*ofdms7 3/2 q1.15 49152 1/2 q1.15 16384 + int16_t *dlChEst_ofdm13 = (int16_t *)&dl_ch_estimates[(p<<1)+aarx][13*ue->frame_parms.ofdm_symbol_size]; + for(int i=0; i<(2*ue->frame_parms.ofdm_symbol_size); i++) + { + int64_t tmp_mult = 0; + tmp_mult = ((int64_t)dlChEst_ofdm11[i] * 49152 - (int64_t)dlChEst_ofdm7[i] * 16384); + + tmp_mult = tmp_mult >> 15; + dlChEst_ofdm13[i] = tmp_mult; + } + } + } } @@ -733,11 +774,17 @@ int lte_dl_channel_estimation(PHY_VARS_UE *ue, // do ifft of channel estimate for (aarx=0; aarxframe_parms.nb_antennas_rx; aarx++) for (p=0; pframe_parms.nb_antenna_ports_eNB; p++) { - if (ue->common_vars.dl_ch_estimates[eNB_offset][(p<<1)+aarx]) - idft((int16_t*) &ue->common_vars.dl_ch_estimates[eNB_offset][(p<<1)+aarx][8], - (int16_t*) ue->common_vars.dl_ch_estimates_time[eNB_offset][(p<<1)+aarx],1); + if (ue->common_vars.common_vars_rx_data_per_thread[(Ns>>1)&0x1].dl_ch_estimates[eNB_offset][(p<<1)+aarx]) + idft((int16_t*) &ue->common_vars.common_vars_rx_data_per_thread[(Ns>>1)&0x1].dl_ch_estimates[eNB_offset][(p<<1)+aarx][8], + (int16_t*) ue->common_vars.common_vars_rx_data_per_thread[(Ns>>1)&0x1].dl_ch_estimates_time[eNB_offset][(p<<1)+aarx],1); } +#if T_TRACER + T(T_UE_PHY_DL_CHANNEL_ESTIMATE, T_INT(eNB_id), T_INT(ue->Mod_id), + T_INT(ue->proc.proc_rxtx[(Ns>>1)&1].frame_rx%1024), T_INT(ue->proc.proc_rxtx[(Ns>>1)&1].subframe_rx), + T_INT(0), T_BUFFER(&ue->common_vars.common_vars_rx_data_per_thread[(Ns>>1)&0x1].dl_ch_estimates_time[eNB_offset][0][0], 512 * 4)); +#endif + return(0); } diff --git a/openair1/PHY/LTE_ESTIMATION/lte_dl_mbsfn_channel_estimation.c b/openair1/PHY/LTE_ESTIMATION/lte_dl_mbsfn_channel_estimation.c index 271187b4474eea1491834e878ff83fe8ba1b30f1..2ce0e45b14988c390b70a36f0dc5821f0da5047f 100644 --- a/openair1/PHY/LTE_ESTIMATION/lte_dl_mbsfn_channel_estimation.c +++ b/openair1/PHY/LTE_ESTIMATION/lte_dl_mbsfn_channel_estimation.c @@ -44,8 +44,8 @@ int lte_dl_mbsfn_channel_estimation(PHY_VARS_UE *ue, // unsigned int n; // int i; - int **dl_ch_estimates=ue->common_vars.dl_ch_estimates[0]; - int **rxdataF=ue->common_vars.rxdataF; + int **dl_ch_estimates=ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[0]; + int **rxdataF=ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF; ch_offset = (l*(ue->frame_parms.ofdm_symbol_size)); symbol_offset = ch_offset;//phy_vars_ue->lte_frame_parms.ofdm_symbol_size*l; @@ -734,31 +734,31 @@ int lte_dl_mbsfn_channel_estimation(PHY_VARS_UE *ue, // do ifft of channel estimate for (aa=0; aaframe_parms.nb_antennas_rx*ue->frame_parms.nb_antennas_tx; aa++) { - if (ue->common_vars.dl_ch_estimates[eNB_offset][aa]) { + if (ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_offset][aa]) { switch (ue->frame_parms.N_RB_DL) { case 6: - idft128((int16_t*) &ue->common_vars.dl_ch_estimates[eNB_offset][aa][8], - (int16_t*) ue->common_vars.dl_ch_estimates_time[eNB_offset][aa], + idft128((int16_t*) &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_offset][aa][8], + (int16_t*) ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates_time[eNB_offset][aa], 1); break; case 25: - idft512((int16_t*) &ue->common_vars.dl_ch_estimates[eNB_offset][aa][8], - (int16_t*) ue->common_vars.dl_ch_estimates_time[eNB_offset][aa], + idft512((int16_t*) &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_offset][aa][8], + (int16_t*) ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates_time[eNB_offset][aa], 1); break; case 50: - idft1024((int16_t*) &ue->common_vars.dl_ch_estimates[eNB_offset][aa][8], - (int16_t*) ue->common_vars.dl_ch_estimates_time[eNB_offset][aa], + idft1024((int16_t*) &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_offset][aa][8], + (int16_t*) ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates_time[eNB_offset][aa], 1); break; case 75: - idft1536((int16_t*) &ue->common_vars.dl_ch_estimates[eNB_offset][aa][8], - (int16_t*) ue->common_vars.dl_ch_estimates_time[eNB_offset][aa], + idft1536((int16_t*) &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_offset][aa][8], + (int16_t*) ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates_time[eNB_offset][aa], 1); break; case 100: - idft2048((int16_t*) &ue->common_vars.dl_ch_estimates[eNB_offset][aa][8], - (int16_t*) ue->common_vars.dl_ch_estimates_time[eNB_offset][aa], + idft2048((int16_t*) &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_offset][aa][8], + (int16_t*) ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates_time[eNB_offset][aa], 1); break; default: diff --git a/openair1/PHY/LTE_ESTIMATION/lte_sync_time.c b/openair1/PHY/LTE_ESTIMATION/lte_sync_time.c index 6c7399fcbec215509cd49a20cfaa2a4360c244b9..e6551033f31fc1891dda98b0401cc1da959b63b4 100644 --- a/openair1/PHY/LTE_ESTIMATION/lte_sync_time.c +++ b/openair1/PHY/LTE_ESTIMATION/lte_sync_time.c @@ -510,14 +510,15 @@ int lte_sync_time_eNB(int32_t **rxdata, ///rx data in time domain // perform a time domain correlation using the oversampled sync sequence - unsigned int n, ar, peak_val, peak_pos, mean_val; + unsigned int n, ar, peak_val, peak_pos; + uint64_t mean_val; int result; short *primary_synch_time; int eNB_id = frame_parms->Nid_cell%3; // msg("[SYNC TIME] Calling sync_time_eNB(%p,%p,%d,%d)\n",rxdata,frame_parms,eNB_id,length); if (sync_corr_eNB == NULL) { - msg("[SYNC TIME] sync_corr_eNB not yet allocated! Exiting.\n"); + LOG_E(PHY,"[SYNC TIME] sync_corr_eNB not yet allocated! Exiting.\n"); return(-1); } @@ -535,7 +536,7 @@ int lte_sync_time_eNB(int32_t **rxdata, ///rx data in time domain break; default: - msg("[SYNC TIME] Illegal eNB_id!\n"); + LOG_E(PHY,"[SYNC TIME] Illegal eNB_id!\n"); return (-1); } @@ -567,7 +568,7 @@ int lte_sync_time_eNB(int32_t **rxdata, ///rx data in time domain peak_val); } */ - mean_val += (sync_corr_eNB[n]>>10); + mean_val += sync_corr_eNB[n]; if (sync_corr_eNB[n]>peak_val) { peak_val = sync_corr_eNB[n]; @@ -575,17 +576,15 @@ int lte_sync_time_eNB(int32_t **rxdata, ///rx data in time domain } } + mean_val/=length; + *peak_val_out = peak_val; - if (peak_val <= (40*mean_val)) { -#ifdef DEBUG_PHY - msg("[SYNC TIME] No peak found (%u,%u,%u,%u)\n",peak_pos,peak_val,mean_val,40*mean_val); -#endif + if (peak_val <= (40*(uint32_t)mean_val)) { + LOG_D(PHY,"[SYNC TIME] No peak found (%u,%u,%u,%u)\n",peak_pos,peak_val,mean_val,40*mean_val); return(-1); } else { -#ifdef DEBUG_PHY - msg("[SYNC TIME] Peak found at pos %u, val = %u, mean_val = %u\n",peak_pos,peak_val,mean_val); -#endif + LOG_D(PHY,"[SYNC TIME] Peak found at pos %u, val = %u, mean_val = %u\n",peak_pos,peak_val,mean_val); return(peak_pos); } diff --git a/openair1/PHY/LTE_ESTIMATION/lte_ue_measurements.c b/openair1/PHY/LTE_ESTIMATION/lte_ue_measurements.c index 90ebd07f60f2f45f1f64779ba601c8e3b98040f2..db8fe548a295382ddebbd2a143236183ae7077b7 100644 --- a/openair1/PHY/LTE_ESTIMATION/lte_ue_measurements.c +++ b/openair1/PHY/LTE_ESTIMATION/lte_ue_measurements.c @@ -32,7 +32,8 @@ #define k1 ((long long int) 1000) #define k2 ((long long int) (1024-k1)) -//#define DEBUG_MEAS +//#define DEBUG_MEAS_RRC +//#define DEBUG_MEAS_UE #ifdef USER_MODE void print_shorts(char *s,short *x) @@ -165,23 +166,30 @@ int8_t set_RSRQ_filtered(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index,float rs } void ue_rrc_measurements(PHY_VARS_UE *ue, - uint8_t subframe, - uint8_t abstraction_flag) + uint8_t slot, + uint8_t abstraction_flag) { - int aarx,rb; + uint8_t subframe = slot>>1; + int aarx,rb,n; int16_t *rxF,*rxF_pss,*rxF_sss; uint16_t Nid_cell = ue->frame_parms.Nid_cell; uint8_t eNB_offset,nu,l,nushift,k; uint16_t off; + uint8_t isPss; // indicate if this is a slot for extracting PSS + uint8_t isSss; // indicate if this is a slot for extracting SSS + int32_t pss_ext[4][72]; // contain the extracted 6*12 REs for mapping the PSS + int32_t sss_ext[4][72]; // contain the extracted 6*12 REs for mapping the SSS + int32_t (*xss_ext)[72]; // point to either pss_ext or sss_ext for common calculation + int16_t *re,*im; // real and imag part of each 32-bit xss_ext[][] value for (eNB_offset = 0; eNB_offset<1+ue->measurements.n_adj_cells; eNB_offset++) { if (eNB_offset==0) { ue->measurements.rssi = 0; - ue->measurements.n0_power_tot = 0; + //ue->measurements.n0_power_tot = 0; if (abstraction_flag == 0) { if ((ue->frame_parms.frame_type == FDD) && @@ -189,9 +197,8 @@ void ue_rrc_measurements(PHY_VARS_UE *ue, if (ue->frame_parms.Ncp==NORMAL) { for (aarx=0; aarxframe_parms.nb_antennas_rx; aarx++) { - - rxF_sss = (int16_t *)&ue->common_vars.rxdataF[aarx][(5*ue->frame_parms.ofdm_symbol_size)]; - rxF_pss = (int16_t *)&ue->common_vars.rxdataF[aarx][(6*ue->frame_parms.ofdm_symbol_size)]; + rxF_sss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(5*ue->frame_parms.ofdm_symbol_size)]; + rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(6*ue->frame_parms.ofdm_symbol_size)]; //-ve spectrum from SSS @@ -216,7 +223,7 @@ void ue_rrc_measurements(PHY_VARS_UE *ue, ue->measurements.n0_power[aarx] += (((int32_t)rxF_pss[2+66]*rxF_pss[2+66])+((int32_t)rxF_pss[2+65]*rxF_pss[2+65])); // ue->measurements.n0_power[aarx] += (((int32_t)rxF_pss[2+64]*rxF_pss[2+64])+((int32_t)rxF_pss[2+63]*rxF_pss[2+63])); // printf("pss32 %d\n",ue->measurements.n0_power[aarx]); //-ve spectrum from PSS - rxF_pss = (int16_t *)&ue->common_vars.rxdataF[aarx][(7*ue->frame_parms.ofdm_symbol_size)]; + rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(7*ue->frame_parms.ofdm_symbol_size)]; // ue->measurements.n0_power[aarx] += (((int32_t)rxF_pss[-72]*rxF_pss[-72])+((int32_t)rxF_pss[-71]*rxF_pss[-71])); // printf("pssm36 %d\n",ue->measurements.n0_power[aarx]); ue->measurements.n0_power[aarx] += (((int32_t)rxF_pss[-70]*rxF_pss[-70])+((int32_t)rxF_pss[-69]*rxF_pss[-69])); @@ -225,23 +232,73 @@ void ue_rrc_measurements(PHY_VARS_UE *ue, // ue->measurements.n0_power[aarx] += (((int32_t)rxF_pss[-64]*rxF_pss[-64])+((int32_t)rxF_pss[-63]*rxF_pss[-63])); // printf("pssm32 %d\n",ue->measurements.n0_power[aarx]); ue->measurements.n0_power_dB[aarx] = (unsigned short) dB_fixed(ue->measurements.n0_power[aarx]/12); - ue->measurements.n0_power_tot += ue->measurements.n0_power[aarx]; + ue->measurements.n0_power_tot /*+=*/ = ue->measurements.n0_power[aarx]; } ue->measurements.n0_power_tot_dB = (unsigned short) dB_fixed(ue->measurements.n0_power_tot/(12*aarx)); ue->measurements.n0_power_tot_dBm = ue->measurements.n0_power_tot_dB - ue->rx_total_gain_dB - dB_fixed(ue->frame_parms.ofdm_symbol_size); - } + } else { + LOG_E(PHY, "Not yet implemented: noise power calculation when prefix length = EXTENDED\n"); + } } - else if ((ue->frame_parms.frame_type == TDD) && - (subframe == 0)) { // TDD SSS, compute noise in DTX REs + else if ((ue->frame_parms.frame_type == TDD) && + ((slot == 2) || (slot == 12) || (slot == 1) || (slot == 11))) { // TDD PSS/SSS, compute noise in DTX REs // 2016-09-29 wilson fix incorrect noise power calculation + +#if 1 // fixing REs extraction in noise power calculation + + // check if this slot has a PSS or SSS sequence + if ((slot == 2) || (slot == 12)) { + isPss = 1; + } else { + isPss = 0; + } + if ((slot == 1) || (slot == 11)) { + isSss = 1; + } else { + isSss = 0; + } + if (isPss) { + pss_only_extract(ue, pss_ext); + xss_ext = pss_ext; + } + + if (isSss) { + sss_only_extract(ue, sss_ext); + xss_ext = sss_ext; + } + + // calculate noise power + int num_tot=0; // number of REs totally used in calculating noise power + for (aarx=0; aarxframe_parms.nb_antennas_rx; aarx++) { + + int num_per_rx=0; // number of REs used in caluclaing noise power for this RX antenna + ue->measurements.n0_power[aarx] = 0; + for (n=2; n<70; n++) { // skip the 2 REs next to PDSCH, i.e. n={0,1,70,71} + if (n==5) {n=67;} + + re = (int16_t*)(&(xss_ext[aarx][n])); + im = re+1; + ue->measurements.n0_power[aarx] += (*re)*(*re) + (*im)*(*im); + num_per_rx++; + num_tot++; + } + + ue->measurements.n0_power_dB[aarx] = (unsigned short) dB_fixed(ue->measurements.n0_power[aarx]/(num_per_rx)); + ue->measurements.n0_power_tot /*+=*/ = ue->measurements.n0_power[aarx]; + } + + ue->measurements.n0_power_tot_dB = (unsigned short) dB_fixed(ue->measurements.n0_power_tot/(num_tot)); + ue->measurements.n0_power_tot_dBm = ue->measurements.n0_power_tot_dB - ue->rx_total_gain_dB - dB_fixed(ue->frame_parms.ofdm_symbol_size); + +#else if (ue->frame_parms.Ncp==NORMAL) { for (aarx=0; aarxframe_parms.nb_antennas_rx; aarx++) { - rxF_sss = (int16_t *)&ue->common_vars.rxdataF[aarx][(6*ue->frame_parms.ofdm_symbol_size)]; + rxF_sss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(6*ue->frame_parms.ofdm_symbol_size)]; // note this is a dummy pointer, the pss is not really there! // in FDD the pss is in the symbol after the sss, but not in TDD - rxF_pss = (int16_t *)&ue->common_vars.rxdataF[aarx][(7*ue->frame_parms.ofdm_symbol_size)]; + rxF_pss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(7*ue->frame_parms.ofdm_symbol_size)]; //-ve spectrum from SSS // ue->measurements.n0_power[aarx] = (((int32_t)rxF_pss[-72]*rxF_pss[-72])+((int32_t)rxF_pss[-71]*rxF_pss[-71])); @@ -263,8 +320,9 @@ void ue_rrc_measurements(PHY_VARS_UE *ue, ue->measurements.n0_power_tot_dBm = ue->measurements.n0_power_tot_dB - ue->rx_total_gain_dB - dB_fixed(ue->frame_parms.ofdm_symbol_size); - } - } + } +#endif + } } } // recompute nushift with eNB_offset corresponding to adjacent eNB on which to perform channel estimation @@ -286,13 +344,13 @@ void ue_rrc_measurements(PHY_VARS_UE *ue, for (l=0,nu=0; l<=(4-ue->frame_parms.Ncp); l+=(4-ue->frame_parms.Ncp),nu=3) { k = (nu + nushift)%6; -#ifdef DEBUG_MEAS +#ifdef DEBUG_MEAS_RRC LOG_I(PHY,"[UE %d] Frame %d subframe %d Doing ue_rrc_measurements rsrp/rssi (Nid_cell %d, nushift %d, eNB_offset %d, k %d, l %d)\n",ue->Mod_id,ue->proc.proc_rxtx[subframe&1].frame_rx,subframe,Nid_cell,nushift, eNB_offset,k,l); #endif for (aarx=0; aarxframe_parms.nb_antennas_rx; aarx++) { - rxF = (int16_t *)&ue->common_vars.rxdataF[aarx][(l*ue->frame_parms.ofdm_symbol_size)]; + rxF = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aarx][(l*ue->frame_parms.ofdm_symbol_size)]; off = (ue->frame_parms.first_carrier_offset+k)<<1; if (l==(4-ue->frame_parms.Ncp)) { @@ -364,7 +422,7 @@ void ue_rrc_measurements(PHY_VARS_UE *ue, } -#ifdef DEBUG_MEAS +#ifdef DEBUG_MEAS_RRC // if (slot == 0) { @@ -398,7 +456,8 @@ void ue_rrc_measurements(PHY_VARS_UE *ue, void lte_ue_measurements(PHY_VARS_UE *ue, unsigned int subframe_offset, unsigned char N0_symbol, - unsigned char abstraction_flag) + unsigned char abstraction_flag, + uint8_t subframe) { @@ -448,7 +507,7 @@ void lte_ue_measurements(PHY_VARS_UE *ue, for (aarx=0; aarxnb_antennas_rx; aarx++) { for (aatx=0; aatxnb_antenna_ports_eNB; aatx++) { ue->measurements.rx_spatial_power[eNB_id][aatx][aarx] = - (signal_energy_nodc(&ue->common_vars.dl_ch_estimates[eNB_id][(aatx<<1) + aarx][0], + (signal_energy_nodc(&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][(aatx<<1) + aarx][0], (N_RB_DL*12))); //- ue->measurements.n0_power[aarx]; @@ -498,10 +557,14 @@ void lte_ue_measurements(PHY_VARS_UE *ue, ue->measurements.wideband_cqi_tot[eNB_id] = dB_fixed2(ue->measurements.rx_power_tot[eNB_id],ue->measurements.n0_power_tot); ue->measurements.wideband_cqi_avg[eNB_id] = dB_fixed2(ue->measurements.rx_power_avg[eNB_id],ue->measurements.n0_power_avg); ue->measurements.rx_rssi_dBm[eNB_id] = ue->measurements.rx_power_avg_dB[eNB_id] - ue->rx_total_gain_dB; -#ifdef DEBUG_MEAS - LOG_I(PHY,"[eNB %d] lte_ue_measurements: RSSI %d dBm, RSSI (digital) %d dB\n", - eNB_id,ue->measurements.rx_rssi_dBm[eNB_id], - ue->measurements.rx_power_avg_dB[eNB_id]); +#ifdef DEBUG_MEAS_UE + LOG_D(PHY,"[eNB %d] RSSI %d dBm, RSSI (digital) %d dB, WBandCQI %d dB, rxPwrAvg %d, n0PwrAvg %d\n", + eNB_id, + ue->measurements.rx_rssi_dBm[eNB_id], + ue->measurements.rx_power_avg_dB[eNB_id], + ue->measurements.wideband_cqi_avg[eNB_id], + ue->measurements.rx_power_avg[eNB_id], + ue->measurements.n0_power_avg); #endif } @@ -512,8 +575,8 @@ void lte_ue_measurements(PHY_VARS_UE *ue, // cqi/pmi information for (aarx=0; aarxnb_antennas_rx; aarx++) { - dl_ch0 = &ue->common_vars.dl_ch_estimates[eNB_id][aarx][4]; - dl_ch1 = &ue->common_vars.dl_ch_estimates[eNB_id][2+aarx][4]; + dl_ch0 = &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][aarx][4]; + dl_ch1 = &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][2+aarx][4]; for (subband=0; subbandcommon_vars.dl_ch_estimates[eNB_id][aarx][4]; - dl_ch1_128 = (__m128i *)&ue->common_vars.dl_ch_estimates[eNB_id][2+aarx][4]; + dl_ch0_128 = (__m128i *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][aarx][4]; + dl_ch1_128 = (__m128i *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][2+aarx][4]; #elif defined(__arm__) int32x4_t pmi128_re,pmi128_im,mmtmpPMI0,mmtmpPMI1,mmtmpPMI0b,mmtmpPMI1b; - dl_ch0_128 = (int16x8_t *)&ue->common_vars.dl_ch_estimates[eNB_id][aarx][4]; - dl_ch1_128 = (int16x8_t *)&ue->common_vars.dl_ch_estimates[eNB_id][2+aarx][4]; + dl_ch0_128 = (int16x8_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][aarx][4]; + dl_ch1_128 = (int16x8_t *)&ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][2+aarx][4]; #endif for (subband=0; subbandnb_antennas_rx; aarx++) { - dl_ch0 = &ue->common_vars.dl_ch_estimates[eNB_id][aarx][4]; + dl_ch0 = &ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][aarx][4]; for (subband=0; subband<7; subband++) { diff --git a/openair1/PHY/LTE_ESTIMATION/lte_ul_channel_estimation.c b/openair1/PHY/LTE_ESTIMATION/lte_ul_channel_estimation.c index d2bc2e27c0750b7e68a97c461f4fac2d29f1e519..4fef74dd1cc2bb1a714b42081793001fd008f9cd 100644 --- a/openair1/PHY/LTE_ESTIMATION/lte_ul_channel_estimation.c +++ b/openair1/PHY/LTE_ESTIMATION/lte_ul_channel_estimation.c @@ -720,10 +720,11 @@ int32_t lte_srs_channel_estimation(LTE_DL_FRAME_PARMS *frame_parms, //write_output("eNB_srs.m","srs_eNB",common_vars->srs,(frame_parms->ofdm_symbol_size),1,1); mult_cpx_conj_vector((int16_t*) &common_vars->rxdataF[eNB_id][aa][2*frame_parms->ofdm_symbol_size*symbol], - (int16_t*) srs_vars->srs, - (int16_t*) srs_vars->srs_ch_estimates[eNB_id][aa], - frame_parms->ofdm_symbol_size, - 15); + (int16_t*) srs_vars->srs, + (int16_t*) srs_vars->srs_ch_estimates[eNB_id][aa], + frame_parms->ofdm_symbol_size, + 15, + 0); //msg("SRS channel estimation cmult out\n"); #ifdef USER_MODE diff --git a/openair1/PHY/LTE_TRANSPORT/dci.c b/openair1/PHY/LTE_TRANSPORT/dci.c index 75583678176047ce1cb1f32484e9c5a6718675d5..49fe90bf15c0f58668d8e12f010aa4b46a2fe842 100644 --- a/openair1/PHY/LTE_TRANSPORT/dci.c +++ b/openair1/PHY/LTE_TRANSPORT/dci.c @@ -41,6 +41,7 @@ #include "PHY/sse_intrin.h" #include "assertions.h" +#include "T.h" //#define DEBUG_DCI_ENCODING 1 //#define DEBUG_DCI_DECODING 1 @@ -1684,6 +1685,7 @@ int32_t avgP[4]; int32_t rx_pdcch(LTE_UE_COMMON *common_vars, LTE_UE_PDCCH **pdcch_vars, LTE_DL_FRAME_PARMS *frame_parms, + uint32_t frame, uint8_t subframe, uint8_t eNB_id, MIMO_mode_t mimo_mode, @@ -1703,16 +1705,16 @@ int32_t rx_pdcch(LTE_UE_COMMON *common_vars, for (s=0; srxdataF, - common_vars->dl_ch_estimates[eNB_id+1], //add 1 to eNB_id to compensate for the shifted B/F'd pilots from the SeNB + pdcch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, + common_vars->common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id+1], //add 1 to eNB_id to compensate for the shifted B/F'd pilots from the SeNB pdcch_vars[eNB_id]->rxdataF_ext, pdcch_vars[eNB_id]->dl_ch_estimates_ext, s, high_speed_flag, frame_parms); #ifdef MU_RECEIVER - pdcch_extract_rbs_single(common_vars->rxdataF, - common_vars->dl_ch_estimates[eNB_id_i - 1],//subtract 1 to eNB_id_i to compensate for the non-shifted pilots from the PeNB + pdcch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, + common_vars->common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id_i - 1],//subtract 1 to eNB_id_i to compensate for the non-shifted pilots from the PeNB pdcch_vars[eNB_id_i]->rxdataF_ext,//shift by two to simulate transmission from a second antenna pdcch_vars[eNB_id_i]->dl_ch_estimates_ext,//shift by two to simulate transmission from a second antenna s, @@ -1720,16 +1722,16 @@ int32_t rx_pdcch(LTE_UE_COMMON *common_vars, frame_parms); #endif //MU_RECEIVER } else if (frame_parms->nb_antenna_ports_eNB>1) { - pdcch_extract_rbs_dual(common_vars->rxdataF, - common_vars->dl_ch_estimates[eNB_id], + pdcch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, + common_vars->common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id], pdcch_vars[eNB_id]->rxdataF_ext, pdcch_vars[eNB_id]->dl_ch_estimates_ext, s, high_speed_flag, frame_parms); } else { - pdcch_extract_rbs_single(common_vars->rxdataF, - common_vars->dl_ch_estimates[eNB_id], + pdcch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, + common_vars->common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id], pdcch_vars[eNB_id]->rxdataF_ext, pdcch_vars[eNB_id]->dl_ch_estimates_ext, s, @@ -1754,7 +1756,10 @@ int32_t rx_pdcch(LTE_UE_COMMON *common_vars, LOG_I(PHY,"subframe %d: pdcch log2_maxh = %d (%d,%d)\n",subframe,log2_maxh,avgP[0],avgs); #endif - +#if T_TRACER + T(T_UE_PHY_PDCCH_ENERGY, T_INT(eNB_id), T_INT(0), T_INT(frame%1024), T_INT(subframe), + T_INT(avgP[0]), T_INT(avgP[1]), T_INT(avgP[2]), T_INT(avgP[3])); +#endif for (s=0; srxdataF_ext, pdcch_vars[eNB_id]->dl_ch_estimates_ext, @@ -1851,6 +1856,7 @@ int32_t rx_pdcch(LTE_UE_COMMON *common_vars, /*#ifdef DEBUG_PHY write_output("llr8_seq.m","llr8",&pdcch_vars[eNB_id]->llr[s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,4); #endif*/ + #ifdef MU_RECEIVER } @@ -1858,6 +1864,12 @@ int32_t rx_pdcch(LTE_UE_COMMON *common_vars, } +#if T_TRACER + T(T_UE_PHY_PDCCH_IQ, T_INT(frame_parms->N_RB_DL), T_INT(frame_parms->N_RB_DL), + T_INT(n_pdcch_symbols), + T_BUFFER(pdcch_vars[eNB_id]->rxdataF_comp, frame_parms->N_RB_DL*12*n_pdcch_symbols* 4)); +#endif + // decode pcfich here n_pdcch_symbols = rx_pcfich(frame_parms, subframe, @@ -2651,6 +2663,7 @@ int get_nCCE_offset_l1(int *CCE_table, void dci_decoding_procedure0(LTE_UE_PDCCH **pdcch_vars, int do_common, + dci_detect_mode_t mode, uint8_t subframe, DCI_ALLOC_t *dci_alloc, int16_t eNB_id, @@ -2692,6 +2705,11 @@ void dci_decoding_procedure0(LTE_UE_PDCCH **pdcch_vars, return; } + if (mode == NO_DCI) { + LOG_D(PHY, "skip DCI decoding: expect no DCIs at subframe %d\n", subframe); + return; + } + if (do_common == 1) { nb_candidates = (L2==4) ? 4 : 2; Yk=0; @@ -2842,7 +2860,7 @@ void dci_decoding_procedure0(LTE_UE_PDCCH **pdcch_vars, *dci_cnt = *dci_cnt+1; } else if (crc==pdcch_vars[eNB_id]->crnti) { - if ((format_c == format0)&&((dci_decoded_output[0]&0x80)==0)) {// check if pdu is format 0 or 1A + if ((mode&UL_DCI)&&(format_c == format0)&&((dci_decoded_output[0]&0x80)==0)) {// check if pdu is format 0 or 1A if (*format0_found == 0) { dci_alloc[*dci_cnt].format = format0; *format0_found = 1; @@ -2923,6 +2941,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, uint8_t format1_size_bits=0,format1_size_bytes=0; uint8_t format2_size_bits=0,format2_size_bytes=0; uint8_t format2A_size_bits=0,format2A_size_bytes=0; + dci_detect_mode_t mode = dci_detect_mode_select(&ue->frame_parms,subframe); switch (frame_parms->N_RB_DL) { case 6: @@ -3125,7 +3144,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, // 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_decoding_procedure0(pdcch_vars,1,mode,subframe, dci_alloc, eNB_id, frame_parms, @@ -3153,7 +3172,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, // 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_decoding_procedure0(pdcch_vars,1,mode,subframe, dci_alloc, eNB_id, frame_parms, @@ -3185,7 +3204,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, #ifdef DEBUG_DCI_DECODING printf("[DCI search] doing common search/format0 aggregation 8\n"); #endif - dci_decoding_procedure0(pdcch_vars,1,subframe, + dci_decoding_procedure0(pdcch_vars,1,mode,subframe, dci_alloc, eNB_id, frame_parms, @@ -3213,7 +3232,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, // Now check common search spaces at aggregation 8 (SI_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_decoding_procedure0(pdcch_vars,1,mode,subframe, dci_alloc, eNB_id, frame_parms, @@ -3246,7 +3265,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, // Now check UE_SPEC format0/1A ue_spec search spaces at aggregation 8 // printf("[DCI search] Format 0/1A aggregation 8\n"); - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3275,7 +3294,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, // printf("[DCI search] Format 0 aggregation 4\n"); // Now check UE_SPEC format 0 search spaces at aggregation 4 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3308,7 +3327,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, // printf("[DCI search] Format 0 aggregation 2\n"); // Now check UE_SPEC format 0 search spaces at aggregation 2 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3337,7 +3356,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, // printf("[DCI search] Format 0 aggregation 4\n"); // Now check UE_SPEC format 0 search spaces at aggregation 1 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3371,7 +3390,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, if ((tmode < 3) || (tmode == 7)) { // Now check UE_SPEC format 1 search spaces at aggregation 1 old_dci_cnt=dci_cnt; - dci_decoding_procedure0(pdcch_vars,0,subframe, + dci_decoding_procedure0(pdcch_vars,0,mode,subframe, dci_alloc, eNB_id, frame_parms, @@ -3402,7 +3421,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, // Now check UE_SPEC format 1 search spaces at aggregation 2 old_dci_cnt=dci_cnt; - dci_decoding_procedure0(pdcch_vars,0,subframe, + dci_decoding_procedure0(pdcch_vars,0,mode,subframe, dci_alloc, eNB_id, frame_parms, @@ -3434,7 +3453,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, // Now check UE_SPEC format 1 search spaces at aggregation 4 old_dci_cnt=dci_cnt; - dci_decoding_procedure0(pdcch_vars,0,subframe, + dci_decoding_procedure0(pdcch_vars,0,mode,subframe, dci_alloc, eNB_id, frame_parms, @@ -3466,7 +3485,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, //#ifdef ALL_AGGREGATION // Now check UE_SPEC format 1 search spaces at aggregation 8 old_dci_cnt=dci_cnt; - dci_decoding_procedure0(pdcch_vars,0,subframe, + dci_decoding_procedure0(pdcch_vars,0,mode,subframe, dci_alloc, eNB_id, frame_parms, @@ -3500,7 +3519,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, // Now check UE_SPEC format 2A_2A search spaces at aggregation 1 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3531,7 +3550,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, return(dci_cnt); // Now check UE_SPEC format 2 search spaces at aggregation 2 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3562,7 +3581,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, return(dci_cnt); // Now check UE_SPEC format 2_2A search spaces at aggregation 4 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3594,7 +3613,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, //#ifdef ALL_AGGREGATION // Now check UE_SPEC format 2_2A search spaces at aggregation 8 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3620,7 +3639,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, } else if (tmode == 4) { // Now check UE_SPEC format 2_2A search spaces at aggregation 1 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3651,7 +3670,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, return(dci_cnt); // Now check UE_SPEC format 2 search spaces at aggregation 2 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3682,7 +3701,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, return(dci_cnt); // Now check UE_SPEC format 2_2A search spaces at aggregation 4 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3714,7 +3733,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, //#ifdef ALL_AGGREGATION // Now check UE_SPEC format 2_2A search spaces at aggregation 8 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3743,7 +3762,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, #ifdef DEBUG_DCI_DECODING LOG_I(PHY," MU-MIMO check UE_SPEC format 1E_2A_M10PRB\n"); #endif - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3775,7 +3794,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, return(dci_cnt); // Now check UE_SPEC format 1E_2A_M10PRB search spaces aggregation 2 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3806,7 +3825,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, return(dci_cnt); // Now check UE_SPEC format 1E_2A_M10PRB search spaces aggregation 4 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, @@ -3839,7 +3858,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue, //#ifdef ALL_AGGREGATION // Now check UE_SPEC format 1E_2A_M10PRB search spaces at aggregation 8 - dci_decoding_procedure0(pdcch_vars,0, + dci_decoding_procedure0(pdcch_vars,0,mode, subframe, dci_alloc, eNB_id, diff --git a/openair1/PHY/LTE_TRANSPORT/dci_tools.c b/openair1/PHY/LTE_TRANSPORT/dci_tools.c index 1dfbc9d7df4f5b322c7f460f679817c3522cdcbc..b262dbccf90de727c6af5aa173ed66684218ee3f 100644 --- a/openair1/PHY/LTE_TRANSPORT/dci_tools.c +++ b/openair1/PHY/LTE_TRANSPORT/dci_tools.c @@ -1061,8 +1061,8 @@ int generate_eNB_dlsch_params_from_dci(int frame, // 36-213 sec.7.1.7.2 p.26 I_mcs = mcs; } else { - if (harq_pid>1) { - LOG_E(PHY,"ERROR: Format 1A: harq_pid > 1\n"); + if (harq_pid>=8) { + LOG_E(PHY,"ERROR: Format 1A: harq_pid=%d >= 8\n", harq_pid); return(-1); } @@ -1206,7 +1206,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, } if (harq_pid>=8) { - LOG_E(PHY,"ERROR: Format 1: harq_pid >= 8\n"); + LOG_E(PHY,"ERROR: Format 1: harq_pid=%d >= 8\n", harq_pid); return(-1); } @@ -1270,12 +1270,6 @@ int generate_eNB_dlsch_params_from_dci(int frame, dlsch0_harq->TBS = TBStable[get_I_TBS(dlsch0_harq->mcs)][NPRB-1]; } - else - { - LOG_E(PHY,"DL Received HarqReTx round=%d mcs=%d rballoc=%d rv=%d \n", - dlsch0_harq->round,mcs,rballoc,rv); - } - dlsch[0]->current_harq_pid = harq_pid; dlsch[0]->harq_ids[subframe] = harq_pid; @@ -1335,7 +1329,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, tpmi = ((DCI2_1_5MHz_4A_FDD_t *)dci_pdu)->tpmi; } } else { - LOG_E(PHY,"eNB: subframe %d UE %x, Format2 DCI: unsupported number of TX antennas %d\n",frame_parms->nb_antennas_tx); + LOG_E(PHY,"eNB: subframe %d UE %x, Format2 DCI: unsupported number of TX antennas %d\n",subframe,rnti,frame_parms->nb_antennas_tx); } break; @@ -1386,7 +1380,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, tpmi = ((DCI2_5MHz_4A_FDD_t *)dci_pdu)->tpmi; } } else { - LOG_E(PHY,"eNB: subframe %d UE %x, Format2 DCI: unsupported number of TX antennas %d\n",frame_parms->nb_antennas_tx); + LOG_E(PHY,"eNB: subframe %d UE %x, Format2 DCI: unsupported number of TX antennas %d\n",subframe,rnti,frame_parms->nb_antennas_tx); } break; @@ -1437,7 +1431,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, tpmi = ((DCI2_10MHz_4A_FDD_t *)dci_pdu)->tpmi; } } else { - LOG_E(PHY,"eNB: subframe %d UE %x, Format2 DCI: unsupported number of TX antennas %d\n",frame_parms->nb_antennas_tx); + LOG_E(PHY,"eNB: subframe %d UE %x, Format2 DCI: unsupported number of TX antennas %d\n",subframe,rnti,frame_parms->nb_antennas_tx); } break; @@ -1488,7 +1482,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, tpmi = ((DCI2_20MHz_4A_FDD_t *)dci_pdu)->tpmi; } } else { - LOG_E(PHY,"eNB: subframe %d UE %x, Format2 DCI: unsupported number of TX antennas %d\n",frame_parms->nb_antennas_tx); + LOG_E(PHY,"eNB: subframe %d UE %x, Format2 DCI: unsupported number of TX antennas %d\n",subframe,rnti,frame_parms->nb_antennas_tx); } break; @@ -1496,7 +1490,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, if (harq_pid>=8) { - LOG_E(PHY,"ERROR: Format 2_2A: harq_pid >= 8\n"); + LOG_E(PHY,"ERROR: Format 2_2A: harq_pid=%d >= 8\n", harq_pid); return(-1); } @@ -1693,7 +1687,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, tpmi = ((DCI2A_1_5MHz_4A_FDD_t *)dci_pdu)->tpmi; } } else { - LOG_E(PHY,"eNB: subframe %d UE %x, Format2A DCI: unsupported number of TX antennas %d\n",frame_parms->nb_antennas_tx); + LOG_E(PHY,"eNB: subframe %d UE %x, Format2A DCI: unsupported number of TX antennas %d\n",subframe,rnti,frame_parms->nb_antennas_tx); } break; @@ -1742,7 +1736,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, tpmi = ((DCI2A_5MHz_4A_FDD_t *)dci_pdu)->tpmi; } } else { - LOG_E(PHY,"eNB: subframe %d UE %x, Format2A DCI: unsupported number of TX antennas %d\n",frame_parms->nb_antennas_tx); + LOG_E(PHY,"eNB: subframe %d UE %x, Format2A DCI: unsupported number of TX antennas %d\n",subframe,rnti,frame_parms->nb_antennas_tx); } break; @@ -1791,7 +1785,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, tpmi = ((DCI2A_10MHz_4A_FDD_t *)dci_pdu)->tpmi; } } else { - LOG_E(PHY,"eNB: subframe %d UE %x, Format2A DCI: unsupported number of TX antennas %d\n",frame_parms->nb_antennas_tx); + LOG_E(PHY,"eNB: subframe %d UE %x, Format2A DCI: unsupported number of TX antennas %d\n",subframe,rnti,frame_parms->nb_antennas_tx); } break; @@ -1840,7 +1834,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, tpmi = ((DCI2A_20MHz_4A_FDD_t *)dci_pdu)->tpmi; } } else { - LOG_E(PHY,"eNB: subframe %d UE %x, Format2A DCI: unsupported number of TX antennas %d\n",frame_parms->nb_antennas_tx); + LOG_E(PHY,"eNB: subframe %d UE %x, Format2A DCI: unsupported number of TX antennas %d\n",subframe,rnti,frame_parms->nb_antennas_tx); } break; @@ -1848,7 +1842,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, if (harq_pid>=8) { - LOG_E(PHY,"ERROR: Format 2_2A: harq_pid >= 8\n"); + LOG_E(PHY,"ERROR: Format 2_2A: harq_pid=%d >= 8\n", harq_pid); return(-1); } @@ -2117,7 +2111,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, if (harq_pid>=8) { - LOG_E(PHY,"ERROR: Format 2_2A: harq_pid >= 8\n"); + LOG_E(PHY,"ERROR: Format 2_2A: harq_pid=%d >= 8\n", harq_pid); return(-1); } @@ -2279,7 +2273,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, if (harq_pid>=8) { - LOG_E(PHY,"ERROR: Format 2_2A: harq_pid >= 8\n"); + LOG_E(PHY,"ERROR: Format 2_2A: harq_pid=%d >= 8\n", harq_pid); return(-1); } @@ -2450,7 +2444,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, if (harq_pid>=8) { - LOG_E(PHY,"ERROR: Format 2_2A: harq_pid >= 8\n"); + LOG_E(PHY,"ERROR: Format 2_2A: harq_pid=%d >= 8\n", harq_pid); return(-1); } @@ -2528,7 +2522,7 @@ int generate_eNB_dlsch_params_from_dci(int frame, harq_pid = ((DCI1E_5MHz_2A_M10PRB_TDD_t *)dci_pdu)->harq_pid; if (harq_pid>=8) { - LOG_E(PHY,"ERROR: Format 1E_2A_M10PRB: harq_pid >= 8\n"); + LOG_E(PHY,"ERROR: Format 1E_2A_M10PRB: harq_pid=%d >= 8\n", harq_pid); return(-1); } @@ -3121,7 +3115,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) if (frame_parms->nb_antennas_tx == 2) { switch(frame_parms->N_RB_DL) { case 6: - LOG_D(PHY,"DCI format2 2 antennas (TDD 1.5 MHz), rnti %x (%x): rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d, dai %d, tbswap %d, tpmi %d\n", + LOG_D(PHY,"DCI format2 2 antennas (TDD 1.5 MHz), rnti %x (%x): rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, TPC %d, dai %d, tbswap %d, tpmi %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_1_5MHz_2A_TDD_t *)&dci->dci_pdu[0])->rballoc, @@ -3140,7 +3134,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 25: - LOG_D(PHY,"DCI format2 2 antennas (TDD 5 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d, dai %d, tb_swap %d, tpmi %d\n", + LOG_D(PHY,"DCI format2 2 antennas (TDD 5 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, TPC %d, dai %d, tb_swap %d, tpmi %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_5MHz_2A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3159,7 +3153,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 50: - LOG_D(PHY,"DCI format2 2 antennas (TDD 10 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d, dai %d\n", + LOG_D(PHY,"DCI format2 2 antennas (TDD 10 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, TPC %d, dai %d, tb_swap %d, tpmi %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_10MHz_2A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3178,7 +3172,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 100: - LOG_D(PHY,"DCI format2 2 antennas (TDD 20 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d, dai %d, tb_swap %d, tpmi %d\n", + LOG_D(PHY,"DCI format2 2 antennas (TDD 20 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, TPC %d, dai %d, tb_swap %d, tpmi %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_20MHz_2A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3204,7 +3198,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) } else if (frame_parms->nb_antennas_tx == 4) { switch(frame_parms->N_RB_DL) { case 6: - LOG_D(PHY,"DCI format2 2 antennas (TDD 1.5 MHz), rnti %x (%x): rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d, dai %d, tbswap %d, tpmi %d\n", + LOG_D(PHY,"DCI format2 2 antennas (TDD 1.5 MHz), rnti %x (%x): rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, TPC %d, dai %d, tbswap %d, tpmi %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_1_5MHz_4A_TDD_t *)&dci->dci_pdu[0])->rballoc, @@ -3223,7 +3217,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 25: - LOG_D(PHY,"DCI format2 2 antennas (TDD 5 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d, dai %d, tb_swap %d, tpmi %d\n", + LOG_D(PHY,"DCI format2 2 antennas (TDD 5 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, TPC %d, dai %d, tb_swap %d, tpmi %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_5MHz_4A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3242,7 +3236,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 50: - LOG_D(PHY,"DCI format2 2 antennas (TDD 10 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d, dai %d\n", + LOG_D(PHY,"DCI format2 2 antennas (TDD 10 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, TPC %d, dai %d, tb_swap %d, tpmi %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_10MHz_4A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3261,7 +3255,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 100: - LOG_D(PHY,"DCI format2 2 antennas (TDD 20 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d, dai %d, tb_swap %d, tpmi %d\n", + LOG_D(PHY,"DCI format2 2 antennas (TDD 20 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, TPC %d, dai %d, tb_swap %d, tpmi %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_20MHz_4A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3306,7 +3300,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 25: - LOG_D(PHY,"DCI format2 2 antennas (FDD, 5 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d\n", + LOG_D(PHY,"DCI format2 2 antennas (FDD, 5 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, tb_swap %d, tpmi %d, TPC %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_5MHz_2A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3324,7 +3318,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 50: - LOG_D(PHY,"DCI format2 2 antennas (FDD, 10 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d\n", + LOG_D(PHY,"DCI format2 2 antennas (FDD, 10 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, tb_swap %d, tpmi %d, TPC %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_10MHz_2A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3342,7 +3336,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 100: - LOG_D(PHY,"DCI format2 2 antennas (FDD, 20 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d\n", + LOG_D(PHY,"DCI format2 2 antennas (FDD, 20 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, tb_swap %d, tpmi %d, TPC %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_20MHz_2A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3385,7 +3379,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 25: - LOG_D(PHY,"DCI format2 4 antennas (FDD, 5 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d\n", + LOG_D(PHY,"DCI format2 4 antennas (FDD, 5 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, tb_swap %d, tpmi %d, TPC %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_5MHz_4A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3403,7 +3397,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 50: - LOG_D(PHY,"DCI format2 4 antennas (FDD, 10 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d\n", + LOG_D(PHY,"DCI format2 4 antennas (FDD, 10 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, tb_swap %d, tpmi %d, TPC %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_10MHz_4A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3421,7 +3415,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 100: - LOG_D(PHY,"DCI format2 4 antennas (FDD, 20 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d, harq_pid %d, ndi %d, RV %d, TPC %d\n", + LOG_D(PHY,"DCI format2 4 antennas (FDD, 20 MHz), rnti %x (%x): rah %d, rb_alloc %x, mcs %d|%d, harq_pid %d, ndi %d|%d, RV %d|%d, tb_swap %d, tpmi %d, TPC %d\n", dci->rnti, ((uint32_t*)&dci->dci_pdu)[0], ((DCI2_20MHz_4A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3476,7 +3470,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 25: - LOG_D(PHY,"DCI format2A 2 antennas (FDD 5 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d\n", + LOG_D(PHY,"DCI format2A 2 antennas (FDD 5 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_5MHz_2A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3494,7 +3488,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 50: - LOG_D(PHY,"DCI format2A 2 antennas (FDD 10 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d\n", + LOG_D(PHY,"DCI format2A 2 antennas (FDD 10 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_10MHz_2A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3512,7 +3506,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 100: - LOG_D(PHY,"DCI format2A 2 antennas (FDD 20 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d\n", + LOG_D(PHY,"DCI format2A 2 antennas (FDD 20 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_20MHz_2A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3537,7 +3531,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) } else if (frame_parms->nb_antenna_ports_eNB == 4) { switch(frame_parms->N_RB_DL) { case 6: - LOG_D(PHY,"DCI format2A 4 antennas (TDD 1.5 MHz), rnti %x (%llx): rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d, tpmi %d\n", + LOG_D(PHY,"DCI format2A 4 antennas (TDD 1.5 MHz), rnti %x (%"PRIu64"): rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d, tpmi %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_1_5MHz_4A_TDD_t *)&dci->dci_pdu[0])->rballoc, @@ -3556,7 +3550,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 25: - LOG_D(PHY,"DCI format2A 4 antennas (TDD 5 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d, tpmi %d\n", + LOG_D(PHY,"DCI format2A 4 antennas (TDD 5 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d, tpmi %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_5MHz_4A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3575,7 +3569,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 50: - LOG_D(PHY,"DCI format2A 4 antennas (TDD 10 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d, tpmi %d\n", + LOG_D(PHY,"DCI format2A 4 antennas (TDD 10 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d, tpmi %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_10MHz_4A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3594,7 +3588,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 100: - LOG_D(PHY,"DCI format2A 4 antennas (TDD 20 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d, tpmi %d\n", + LOG_D(PHY,"DCI format2A 4 antennas (TDD 20 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, TPC %d, dai %d, tbswap %d, tpmi %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_20MHz_4A_TDD_t *)&dci->dci_pdu[0])->rah, @@ -3638,7 +3632,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 25: - LOG_D(PHY,"DCI format2A 2 antennas (FDD, 5 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, TPC %d\n", + LOG_D(PHY,"DCI format2A 2 antennas (FDD, 5 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, TPC %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_5MHz_2A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3655,7 +3649,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 50: - LOG_D(PHY,"DCI format2A 2 antennas (FDD, 10 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, TPC %d\n", + LOG_D(PHY,"DCI format2A 2 antennas (FDD, 10 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, TPC %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_10MHz_2A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3672,7 +3666,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 100: - LOG_D(PHY,"DCI format2A 2 antennas (FDD, 20 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, TPC %d\n", + LOG_D(PHY,"DCI format2A 2 antennas (FDD, 20 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, TPC %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_20MHz_2A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3697,7 +3691,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) switch(frame_parms->N_RB_DL) { case 6: - LOG_D(PHY,"DCI format2A 4 antennas (FDD, 1.5 MHz), rnti %x (%llx): rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, tpmi %d, TPC %d\n", + LOG_D(PHY,"DCI format2A 4 antennas (FDD, 1.5 MHz), rnti %x (%"PRIu64"): rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, tpmi %d, TPC %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_1_5MHz_4A_FDD_t *)&dci->dci_pdu[0])->rballoc, @@ -3714,7 +3708,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 25: - LOG_D(PHY,"DCI format2A 4 antennas (FDD, 5 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, tpmi %d, TPC %d\n", + LOG_D(PHY,"DCI format2A 4 antennas (FDD, 5 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, tpmi %d, TPC %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_5MHz_4A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3732,7 +3726,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 50: - LOG_D(PHY,"DCI format2A 4 antennas (FDD, 5 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, tpmi %d, TPC %d\n", + LOG_D(PHY,"DCI format2A 4 antennas (FDD, 5 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, tpmi %d, TPC %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_10MHz_4A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3750,7 +3744,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci) break; case 100: - LOG_D(PHY,"DCI format2A 4 antennas (FDD, 5 MHz), rnti %x (%llx): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, tpmi %d, TPC %d\n", + LOG_D(PHY,"DCI format2A 4 antennas (FDD, 5 MHz), rnti %x (%"PRIu64"): rah %d, rb_alloc %x, mcs1 %d, mcs2 %d, harq_pid %d, ndi1 %d, ndi2 %d, RV1 %d, RV2 %d, tb_swap %d, tpmi %d, TPC %d\n", dci->rnti, ((uint64_t*)&dci->dci_pdu)[0], ((DCI2A_20MHz_4A_FDD_t *)&dci->dci_pdu[0])->rah, @@ -3818,7 +3812,8 @@ int generate_ue_dlsch_params_from_dci(int frame, uint16_t si_rnti, uint16_t ra_rnti, uint16_t p_rnti, - uint8_t beamforming_mode) + uint8_t beamforming_mode, + uint16_t tc_rnti) { uint8_t harq_pid=0; @@ -3832,11 +3827,29 @@ int generate_ue_dlsch_params_from_dci(int frame, uint8_t TPC=0; uint8_t NPRB=0,tbswap=0,tpmi=0; uint8_t Ngap; + uint8_t dai=0; LTE_UE_DLSCH_t *dlsch0=NULL,*dlsch1=NULL; LTE_DL_UE_HARQ_t *dlsch0_harq,*dlsch1_harq; #ifdef DEBUG_DCI - LOG_D(PHY,"dci_tools.c: Filling ue dlsch params -> rnti %x, dci_format %d\n",rnti,dci_format); + LOG_D(PHY,"dci_tools.c: Filling ue dlsch params -> rnti %x, SFN/SF %d/%d, dci_format %s\n", + rnti, + frame%1024, + subframe, + (dci_format==format0? "Format 0":( + dci_format==format1? "format 1":( + dci_format==format1A? "format 1A":( + dci_format==format1B? "format 1B":( + dci_format==format1C? "format 1C":( + dci_format==format1D? "format 1D":( + dci_format==format1E_2A_M10PRB? "format 1E_2A_M10PRB":( + dci_format==format2? "format 2":( + dci_format==format2A? "format 2A":( + dci_format==format2B? "format 2B":( + dci_format==format2C? "format 2C":( + dci_format==format2D? "format 2D":( + dci_format==format3? "format 3": "UNKNOWN" + )))))))))))))); #endif switch (dci_format) { @@ -3858,6 +3871,7 @@ int generate_ue_dlsch_params_from_dci(int frame, ndi = ((DCI1A_1_5MHz_TDD_1_6_t *)dci_pdu)->ndi; TPC = ((DCI1A_1_5MHz_TDD_1_6_t *)dci_pdu)->TPC; harq_pid = ((DCI1A_1_5MHz_TDD_1_6_t *)dci_pdu)->harq_pid; + dai = ((DCI1A_1_5MHz_TDD_1_6_t *)dci_pdu)->dai; // printf("TDD 1A: mcs %d, rballoc %x,rv %d, TPC %d\n",mcs,rballoc,rv,TPC); } else { vrb_type = ((DCI1A_1_5MHz_FDD_t *)dci_pdu)->vrb_type; @@ -3877,15 +3891,14 @@ int generate_ue_dlsch_params_from_dci(int frame, NPRB = (TPC&1) + 2; } else { - if (harq_pid>1) { - LOG_E(PHY,"Format 1A: harq_pid > 1\n"); + if (harq_pid>=8) { + LOG_E(PHY,"Format 1A: harq_pid=%d >= 8\n", harq_pid); return(-1); } dlsch0_harq = dlsch[0]->harq_processes[harq_pid]; NPRB = RIV2nb_rb_LUT6[rballoc]; dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3]; - dlsch[0]->g_pucch += delta_PUCCH_lut[TPC&3]; } if (vrb_type == LOCALIZED) { @@ -3914,6 +3927,7 @@ int generate_ue_dlsch_params_from_dci(int frame, ndi = ((DCI1A_5MHz_TDD_1_6_t *)dci_pdu)->ndi; TPC = ((DCI1A_5MHz_TDD_1_6_t *)dci_pdu)->TPC; harq_pid = ((DCI1A_5MHz_TDD_1_6_t *)dci_pdu)->harq_pid; + dai = ((DCI1A_5MHz_TDD_1_6_t *)dci_pdu)->dai; //printf("TDD 1A: mcs %d, rballoc %x,rv %d, TPC %d\n",mcs,rballoc,rv,TPC); } else { vrb_type = ((DCI1A_5MHz_FDD_t *)dci_pdu)->vrb_type; @@ -3933,15 +3947,14 @@ int generate_ue_dlsch_params_from_dci(int frame, dlsch0_harq = dlsch[0]->harq_processes[harq_pid]; } else { - //if (harq_pid>1) { - // LOG_E(PHY,"Format 1A: harq_pid > 1\n"); - // return(-1); - //} + if (harq_pid>=8) { + LOG_E(PHY,"Format 1A: harq_pid=%d >= 8\n", harq_pid); + return(-1); + } dlsch0_harq = dlsch[0]->harq_processes[harq_pid]; NPRB = RIV2nb_rb_LUT25[rballoc]; dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3]; - dlsch[0]->g_pucch += delta_PUCCH_lut[TPC&3]; } if (vrb_type == LOCALIZED) { @@ -3967,6 +3980,7 @@ int generate_ue_dlsch_params_from_dci(int frame, ndi = ((DCI1A_10MHz_TDD_1_6_t *)dci_pdu)->ndi; TPC = ((DCI1A_10MHz_TDD_1_6_t *)dci_pdu)->TPC; harq_pid = ((DCI1A_10MHz_TDD_1_6_t *)dci_pdu)->harq_pid; + dai = ((DCI1A_10MHz_TDD_1_6_t *)dci_pdu)->dai; // printf("TDD 1A: mcs %d, rballoc %x,rv %d, TPC %d\n",mcs,rballoc,rv,TPC); } else { vrb_type = ((DCI1A_10MHz_FDD_t *)dci_pdu)->vrb_type; @@ -3986,15 +4000,14 @@ int generate_ue_dlsch_params_from_dci(int frame, NPRB = (TPC&1) + 2; } else { - if (harq_pid>1) { - LOG_E(PHY,"Format 1A: harq_pid > 1\n"); + if (harq_pid>=8) { + LOG_E(PHY,"Format 1A: harq_pid=%d >= 8\n", harq_pid); return(-1); } dlsch0_harq = dlsch[0]->harq_processes[harq_pid]; NPRB = RIV2nb_rb_LUT50[rballoc]; dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3]; - dlsch[0]->g_pucch += delta_PUCCH_lut[TPC&3]; } if (vrb_type == LOCALIZED) { @@ -4034,6 +4047,7 @@ int generate_ue_dlsch_params_from_dci(int frame, ndi = ((DCI1A_20MHz_TDD_1_6_t *)dci_pdu)->ndi; TPC = ((DCI1A_20MHz_TDD_1_6_t *)dci_pdu)->TPC; harq_pid = ((DCI1A_20MHz_TDD_1_6_t *)dci_pdu)->harq_pid; + dai = ((DCI1A_20MHz_TDD_1_6_t *)dci_pdu)->dai; // printf("TDD 1A: mcs %d, rballoc %x,rv %d, TPC %d\n",mcs,rballoc,rv,TPC); } else { vrb_type = ((DCI1A_20MHz_FDD_t *)dci_pdu)->vrb_type; @@ -4053,15 +4067,14 @@ int generate_ue_dlsch_params_from_dci(int frame, NPRB = (TPC&1) + 2; } else { - if (harq_pid>1) { - LOG_E(PHY,"Format 1A: harq_pid > 1\n"); + if (harq_pid>=8) { + LOG_E(PHY,"Format 1A: harq_pid=%d >= 8\n", harq_pid); return(-1); } dlsch0_harq = dlsch[0]->harq_processes[harq_pid]; NPRB = RIV2nb_rb_LUT100[rballoc]; dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3]; - dlsch[0]->g_pucch += delta_PUCCH_lut[TPC&3]; } if (vrb_type == LOCALIZED) { @@ -4114,6 +4127,17 @@ int generate_ue_dlsch_params_from_dci(int frame, return(-1); } + if((mcs>28) && ( (dlsch0_harq->round == 0) || (rnti==si_rnti) || (rnti==p_rnti) || (rnti==ra_rnti) )) + { + // DCI false detection + return(-1); + } + if((rv!=0) && (dlsch0_harq->round == 0) && (rnti != si_rnti) && (rnti != p_rnti) && (rnti != ra_rnti)) + { + // DCI false detection + return(-1); + } + // change the mcs limit from 7 to 8, supported by MAC /* if (mcs > 10) { LOG_E(PHY,"Format 1A: subframe %d unlikely mcs for format 1A (%d), TPC %d rv %d\n",subframe,mcs,TPC,rv); @@ -4139,16 +4163,9 @@ int generate_ue_dlsch_params_from_dci(int frame, dlsch0_harq->mimo_mode = frame_parms->mode1_flag == 1 ?SISO : ALAMOUTI; dlsch0_harq->dl_power_off = 1; //no power offset - LOG_D(PHY,"UE (%x/%d): Subframe %d Format1A DCI: ndi %d, old_ndi %d (first tx %d) harq_status %d, round %d\n", - dlsch[0]->rnti, - harq_pid, - subframe, - ndi, - dlsch0_harq->DCINdi, - dlsch0_harq->first_tx, - dlsch0_harq->status, - dlsch0_harq->round); - if ((ndi!=dlsch0_harq->DCINdi)|| // DCI has been toggled or this is the first transmission + dlsch[0]->active = 1; // fix no DLSCH decoding for downlink retransmission + + if ((ndi!=dlsch0_harq->DCINdi) || // DCI has been toggled or this is the first transmission (dlsch0_harq->first_tx==1)) { dlsch0_harq->round = 0; @@ -4156,15 +4173,46 @@ int generate_ue_dlsch_params_from_dci(int frame, //LOG_I(PHY,"[PDSCH %x/%d] Format 1A DCI First TX: Clearing flag\n"); dlsch0_harq->first_tx = 0; } - } + } else if (dlsch0_harq->round == 0) { // duplicated PDSCH received. possibly eNB missed the previous DL ACK/NACK feedback - dlsch0_harq->DCINdi = ndi; + // skip PDSCH decoding + dlsch[0]->active = 0; + // report ACK back to eNB for this duplicated PDSCH + dlsch0_harq->status = SCH_IDLE; + dlsch0_harq->round = 0; + dlsch[0]->harq_ack[subframe].ack = 1; + dlsch[0]->harq_ack[subframe].harq_id = harq_pid; + dlsch[0]->harq_ack[subframe].send_harq_status = 1; + LOG_D(PHY,"UE (%x/%d): Format1A DCI: Duplicated PDSCH. Setting ACK for subframe %d (pid %d, round 0)\n", + dlsch[0]->rnti,harq_pid, subframe,harq_pid); + } + + LOG_D(PHY,"UE (%x/%d): SFN/SF %4d/%1d Format1A DCI: dai %d, ndi %d, old_ndi %d (first tx %d), harq_status %d, round %d\n", + rnti, + harq_pid, + frame % 1024, + subframe, + dai, + ndi, + dlsch0_harq->DCINdi, + dlsch0_harq->first_tx, + dlsch0_harq->status, + dlsch0_harq->round); + + if (rnti == tc_rnti) { + dlsch0_harq->DCINdi = (uint8_t)-1; + LOG_D(PHY,"UE (%x/%d): Format1A DCI: C-RNTI is temporary. Set NDI = %d and to be ignored\n", + rnti,harq_pid,dlsch0_harq->DCINdi); + } else { + dlsch0_harq->DCINdi = ndi; + } + dlsch[0]->harq_ack[subframe].vDAI_DL = dai+1; // this a retransmission if(dlsch0_harq->round) { // compare old TBS to new TBS - if(dlsch0_harq->TBS != TBStable[get_I_TBS(mcs)][NPRB-1]) + if((mcs<29) && (dlsch0_harq->TBS != TBStable[get_I_TBS(mcs)][NPRB-1])) { // this is an eNB issue // retransmisison but old and new TBS are different !!! @@ -4174,17 +4222,21 @@ int generate_ue_dlsch_params_from_dci(int frame, } } - dlsch0_harq->mcs = mcs; + if(mcs<29) + { + dlsch0_harq->mcs = mcs; + } + if ((rnti==si_rnti) || (rnti==p_rnti) || (rnti==ra_rnti)) { dlsch0_harq->TBS = TBStable[mcs][NPRB-1]; dlsch0_harq->Qm = 2; } else { + if(mcs < 29) dlsch0_harq->TBS = TBStable[get_I_TBS(mcs)][NPRB-1]; dlsch0_harq->Qm = get_Qm(mcs); } dlsch[0]->rnti = rnti; - dlsch[0]->active = 1; dlsch0 = dlsch[0]; //printf("Format 1A: harq_pid %d, nb_rb %d, round %d\n",harq_pid,dlsch0_harq->nb_rb,dlsch0_harq->round); break; @@ -4410,14 +4462,27 @@ int generate_ue_dlsch_params_from_dci(int frame, break; } + dlsch0_harq = dlsch[0]->harq_processes[harq_pid]; + if (harq_pid>=8) { - LOG_E(PHY,"Format 1: harq_pid >= 8\n"); + LOG_E(PHY,"Format 1: harq_pid=%d >= 8\n", harq_pid); return(-1); } - dlsch0_harq = dlsch[0]->harq_processes[harq_pid]; + if((mcs>28) && (dlsch0_harq->round == 0) ) + { + // DCI false detection + return(-1); + } + + if((rv!=0) && (dlsch0_harq->round == 0) ) + { + // DCI false detection + return(-1); + } + + dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3]; - dlsch[0]->g_pucch += delta_PUCCH_lut[TPC&3]; dlsch[0]->current_harq_pid = harq_pid; dlsch[0]->harq_ack[subframe].harq_id = harq_pid; @@ -4441,9 +4506,6 @@ int generate_ue_dlsch_params_from_dci(int frame, return(-1); } - // printf("NPRB %d\n",NPRB); - dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3]; - dlsch[0]->g_pucch += delta_PUCCH_lut[TPC&3]; if (TPC!=1) LOG_D(PHY,"format1 TPC %d, dlsch0_harq->delta_PUCCH %d\n",TPC,dlsch0_harq->delta_PUCCH); @@ -4467,19 +4529,9 @@ int generate_ue_dlsch_params_from_dci(int frame, dlsch[0]->harq_ack[subframe].send_harq_status = 1; if (dlsch0_harq->first_tx==1) { - LOG_D(PHY,"[PDSCH %x/%d] Format 1 DCI First TX: Clearing flag\n"); + LOG_D(PHY,"[PDSCH %x/%d] Format 1 DCI First TX: Clearing flag\n",rnti,harq_pid); dlsch0_harq->first_tx = 0; } - } else if (dlsch0_harq->status == SCH_IDLE) { // we got an Ndi = 0 for a previously decoded process, - // this happens if either another harq process in the same - // is NAK or an ACK was not received - - dlsch[0]->harq_ack[subframe].ack = 1; - dlsch[0]->harq_ack[subframe].harq_id = harq_pid; - dlsch[0]->harq_ack[subframe].send_harq_status = 1; - dlsch[0]->active = 0; - // printf("Got NDI=0 for correctly decoded SDU (harq_pid %d) subframe %d\n",harq_pid,subframe); - return(0); } dlsch0_harq->mcs = mcs; @@ -4729,7 +4781,7 @@ int generate_ue_dlsch_params_from_dci(int frame, } if (harq_pid>=8) { - LOG_E(PHY,"Format 2_2A: harq_pid >= 8\n"); + LOG_E(PHY,"Format 2_2A: harq_pid=%d >= 8\n", harq_pid); return(-1); } @@ -4776,7 +4828,6 @@ int generate_ue_dlsch_params_from_dci(int frame, dlsch0_harq->mcs = mcs1; dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3]; - dlsch[0]->g_pucch += delta_PUCCH_lut[TPC&3]; /* if (dlsch0_harq->mcs>20) { printf("dci_tools.c: mcs > 20 disabled for now (asked %d)\n",dlsch0_harq->mcs); @@ -5143,7 +5194,7 @@ int generate_ue_dlsch_params_from_dci(int frame, if (harq_pid>=8) { - LOG_E(PHY,"ERROR: Format 2_2A: harq_pid >= 8\n"); + LOG_E(PHY,"ERROR: Format 2_2A: harq_pid=%d >= 8\n", harq_pid); return(-1); } @@ -5196,9 +5247,7 @@ int generate_ue_dlsch_params_from_dci(int frame, // printf("NPRB %d\n",NPRB); dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3]; - dlsch0->g_pucch += delta_PUCCH_lut[TPC&3]; dlsch1_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3]; - dlsch1->g_pucch += delta_PUCCH_lut[TPC&3]; dlsch0_harq->mcs = mcs1; dlsch1_harq->mcs = mcs2; @@ -5239,7 +5288,7 @@ int generate_ue_dlsch_params_from_dci(int frame, dlsch0_harq->DCINdi = ndi1; if (dlsch0_harq->first_tx==1) { - LOG_D(PHY,"[PDSCH %x/%d] Format 2A DCI First TX0: Clearing flag\n"); + LOG_D(PHY,"[PDSCH %x/%d] Format 2A DCI First TX0: Clearing flag\n",rnti,harq_pid); dlsch0_harq->first_tx = 0; } } else if (dlsch0_harq->status == SCH_IDLE) { // we got an Ndi = 0 for a previously decoded process, @@ -5407,7 +5456,7 @@ int generate_ue_dlsch_params_from_dci(int frame, harq_pid = ((DCI1E_5MHz_2A_M10PRB_TDD_t *)dci_pdu)->harq_pid; if (harq_pid>=8) { - LOG_E(PHY,"Format 1E_2A_M10PRB: harq_pid >= 8\n"); + LOG_E(PHY,"Format 1E_2A_M10PRB: harq_pid=%d >= 8\n", harq_pid); return(-1); } @@ -5449,7 +5498,6 @@ int generate_ue_dlsch_params_from_dci(int frame, dlsch0_harq->mcs = ((DCI1E_5MHz_2A_M10PRB_TDD_t *)dci_pdu)->mcs; dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[((DCI1E_5MHz_2A_M10PRB_TDD_t *)dci_pdu)->TPC&3]; - dlsch[0]->g_pucch += delta_PUCCH_lut[TPC&3]; @@ -5572,11 +5620,14 @@ int generate_ue_dlsch_params_from_dci(int frame, #ifdef DEBUG_DCI if (dlsch[0] && (dlsch[0]->rnti != 0xffff)) { - printf("dci_format:%d Abssubframe: %d.%d \n",dci_format,frame,subframe); + printf("dci_format:%d Abssubframe: %d.%d \n",dci_format,frame%1024,subframe); printf("PDSCH dlsch0 UE: rnti %x\n",dlsch[0]->rnti); printf("PDSCH dlsch0 UE: NBRB %d\n",dlsch0_harq->nb_rb); printf("PDSCH dlsch0 UE: rballoc %x\n",dlsch0_harq->rb_alloc_even[0]); printf("PDSCH dlsch0 UE: harq_pid %d\n",harq_pid); + printf("PDSCH dlsch0 UE: tpc %d\n",TPC); + printf("PDSCH dlsch0 UE: g %d\n",dlsch[0]->g_pucch); + printf("PDSCH dlsch0 UE: round %d\n",dlsch0_harq->round); printf("PDSCH dlsch0 UE: DCINdi %d\n",dlsch0_harq->DCINdi); printf("PDSCH dlsch0 UE: rvidx %d\n",dlsch0_harq->rvidx); printf("PDSCH dlsch0 UE: TBS %d\n",dlsch0_harq->TBS); @@ -5585,7 +5636,16 @@ int generate_ue_dlsch_params_from_dci(int frame, } #endif - dlsch[0]->active=1; +#if T_TRACER + if( (dlsch[0]->rnti != si_rnti) && (dlsch[0]->rnti != ra_rnti) && (dlsch[0]->rnti != p_rnti)) + { + T(T_UE_PHY_DLSCH_UE_DCI, T_INT(0), T_INT(frame%1024), T_INT(subframe), T_INT(0), + T_INT(dlsch[0]->rnti), T_INT(dci_format), + T_INT(harq_pid), + T_INT(dlsch0_harq->mcs), + T_INT(dlsch0_harq->TBS)); + } +#endif // compute DL power control parameters computeRhoA_UE(pdsch_config_dedicated, dlsch[0],dlsch0_harq->dl_power_off); @@ -5606,8 +5666,11 @@ uint8_t subframe2harq_pid(LTE_DL_FRAME_PARMS *frame_parms,uint32_t frame,uint8_t printf("dci_tools.c: subframe2_harq_pid, subframe %d for FDD \n",subframe); #endif */ + + uint8_t ret = 255; + if (frame_parms->frame_type == FDD) { - return(((frame<<1)+subframe)&7); + ret = (((frame<<1)+subframe)&7); } else { switch (frame_parms->tdd_config) { @@ -5620,17 +5683,17 @@ uint8_t subframe2harq_pid(LTE_DL_FRAME_PARMS *frame_parms,uint32_t frame,uint8_t switch (subframe) { case 2: case 3: - return(subframe-2); + ret = (subframe-2); break; case 7: case 8: - return(subframe-5); + ret = (subframe-5); break; default: LOG_E(PHY,"subframe2_harq_pid, Illegal subframe %d for TDD mode %d\n",subframe,frame_parms->tdd_config); - return(255); + ret = (255); break; } @@ -5640,72 +5703,78 @@ uint8_t subframe2harq_pid(LTE_DL_FRAME_PARMS *frame_parms,uint32_t frame,uint8_t if ((subframe!=2) && (subframe!=7)) { LOG_E(PHY,"subframe2_harq_pid, Illegal subframe %d for TDD mode %d\n",subframe,frame_parms->tdd_config); mac_xface->macphy_exit("subframe2_harq_pid, Illegal subframe"); - return(255); + ret = (255); } - return(subframe/7); + ret = (subframe/7); break; case 3: if ((subframe<2) || (subframe>4)) { LOG_E(PHY,"subframe2_harq_pid, Illegal subframe %d for TDD mode %d\n",subframe,frame_parms->tdd_config); - return(255); + ret = (255); } - return(subframe-2); + ret = (subframe-2); break; case 4: if ((subframe<2) || (subframe>3)) { LOG_E(PHY,"subframe2_harq_pid, Illegal subframe %d for TDD mode %d\n",subframe,frame_parms->tdd_config); - return(255); + ret = (255); } - return(subframe-2); + ret = (subframe-2); break; case 5: if (subframe!=2) { LOG_E(PHY,"subframe2_harq_pid, Illegal subframe %d for TDD mode %d\n",subframe,frame_parms->tdd_config); - return(255); + ret = (255); } - return(subframe-2); + ret = (subframe-2); break; default: LOG_E(PHY,"subframe2_harq_pid, Unsupported TDD mode %d\n",frame_parms->tdd_config); - return(255); + ret = (255); } } - return(255); + if (ret == 255) { + LOG_E(PHY, "invalid harq_pid(%d) at SFN/SF = %d/%d\n", ret, frame, subframe); + mac_xface->macphy_exit("invalid harq_pid"); + } + return ret; } uint8_t pdcch_alloc2ul_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t n) { + uint8_t ul_subframe = 255; if ((frame_parms->frame_type == TDD) && (frame_parms->tdd_config == 1) && ((n==1)||(n==6))) // tdd_config 0,1 SF 1,5 - return((n+6)%10); + ul_subframe = ((n+6)%10); else if ((frame_parms->frame_type == TDD) && (frame_parms->tdd_config == 6) && ((n==0)||(n==1)||(n==5)||(n==6))) - return((n+7)%10); + ul_subframe = ((n+7)%10); else if ((frame_parms->frame_type == TDD) && (frame_parms->tdd_config == 6) && (n==9)) // tdd_config 6 SF 9 - return((n+5)%10); + ul_subframe = ((n+5)%10); else - return((n+4)%10); + ul_subframe = ((n+4)%10); + LOG_D(PHY, "subframe %d: PUSCH subframe = %d\n", n, ul_subframe); + return ul_subframe; } uint8_t ul_subframe2pdcch_alloc_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t n) { - if ((frame_parms->frame_type == TDD) && (frame_parms->tdd_config == 1) && ((n==7)||(n==2))) // tdd_config 0,1 SF 1,5 @@ -5725,21 +5794,25 @@ uint8_t ul_subframe2pdcch_alloc_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t uint32_t pdcch_alloc2ul_frame(LTE_DL_FRAME_PARMS *frame_parms,uint32_t frame, uint8_t n) { + uint32_t ul_frame = 255; if ((frame_parms->frame_type == TDD) && (frame_parms->tdd_config == 1) && ((n==1)||(n==6))) // tdd_config 0,1 SF 1,5 - return(frame + (n==1 ? 0 : 1)); + ul_frame = (frame + (n==1 ? 0 : 1)); else if ((frame_parms->frame_type == TDD) && (frame_parms->tdd_config == 6) && ((n==0)||(n==1)||(n==5)||(n==6))) - return(frame + (n>=5 ? 1 : 0)); + ul_frame = (frame + (n>=5 ? 1 : 0)); else if ((frame_parms->frame_type == TDD) && (frame_parms->tdd_config == 6) && (n==9)) // tdd_config 6 SF 9 - return(frame+1); + ul_frame = (frame+1); else - return(frame+(n>=6 ? 1 : 0)); + ul_frame = (frame+(n>=6 ? 1 : 0)); + + LOG_D(PHY, "frame %d subframe %d: PUSCH frame = %d\n", frame, n, ul_frame); + return ul_frame; } @@ -5866,36 +5939,38 @@ uint8_t sinr2cqi(double sinr,uint8_t trans_mode) { // int flag_LA=0; + uint8_t retValue = 0; + if(flag_LA==0) { // Ideal Channel Estimation if (sinr<=-4.89) - return(0); + retValue = (0); else if (sinr < -3.53) - return(3); + retValue = (3); else if (sinr <= -1.93) - return(4); + retValue = (4); else if (sinr <= -0.43) - return(5); + retValue = (5); else if (sinr <= 1.11) - return(6); + retValue = (6); else if (sinr <= 3.26) - return(7); - else if (sinr <= 5) - return(8); - else if (sinr <= 7) - return(9); - else if (sinr <= 9) - return(10); - else if (sinr <= 11) - return(11); - else if (sinr <= 13) - return(12); + retValue = (7); + else if (sinr <= 5.0) + retValue = (8); + else if (sinr <= 7.0) + retValue = (9); + else if (sinr <= 9.0) + retValue = (10); + else if (sinr <= 11.0) + retValue = (11); + else if (sinr <= 13.0) + retValue = (12); else if (sinr <= 15.5) - return(13); + retValue = (13); else if (sinr <= 17.5) - return(14); - else if (sinr > 19.5) - return(15); + retValue = (14); + else + retValue = (15); } else { int h=0; int trans_mode_tmp; @@ -5909,11 +5984,12 @@ uint8_t sinr2cqi(double sinr,uint8_t trans_mode) for(h=0; h<16; h++) { if(sinr<=sinr_to_cqi[trans_mode_tmp][h]) - return(h); + retValue = (h); } } - return(0); + LOG_D(PHY, "sinr=%f trans_mode=%d cqi=%d\n", sinr, trans_mode, retValue); + return retValue; } //uint32_t fill_subband_cqi(PHY_MEASUREMENTS *meas,uint8_t eNB_id) { // @@ -6249,7 +6325,7 @@ int generate_ue_ulsch_params_from_dci(void *dci_pdu, uint8_t transmission_mode = ue->transmission_mode[eNB_id]; ANFBmode_t AckNackFBMode; LTE_UE_ULSCH_t *ulsch = ue->ulsch[eNB_id]; - // LTE_UE_DLSCH_t **dlsch = ue->dlsch[0]; + LTE_UE_DLSCH_t **dlsch = ue->dlsch[0]; PHY_MEASUREMENTS *meas = &ue->measurements; LTE_DL_FRAME_PARMS *frame_parms = &ue->frame_parms; // uint32_t current_dlsch_cqi = ue->current_dlsch_cqi[eNB_id]; @@ -6264,12 +6340,15 @@ int generate_ue_ulsch_params_from_dci(void *dci_pdu, } uint32_t cqi_req; - uint32_t dai=0; + uint32_t dai=3; uint32_t cshift; uint32_t TPC; uint32_t ndi; uint32_t mcs; uint32_t rballoc,RIV_max; + uint16_t* RIV2first_rb_LUT; + uint16_t* RIV2nb_rb_LUT; + // uint32_t hopping; // uint32_t type; @@ -6315,8 +6394,8 @@ int generate_ue_ulsch_params_from_dci(void *dci_pdu, } RIV_max = RIV_max6; - ulsch->harq_processes[harq_pid]->first_rb = RIV2first_rb_LUT6[rballoc]; - ulsch->harq_processes[harq_pid]->nb_rb = RIV2nb_rb_LUT6[rballoc]; + RIV2first_rb_LUT = RIV2first_rb_LUT6; + RIV2nb_rb_LUT = RIV2nb_rb_LUT6; break; @@ -6343,8 +6422,8 @@ int generate_ue_ulsch_params_from_dci(void *dci_pdu, } RIV_max = RIV_max25; - ulsch->harq_processes[harq_pid]->first_rb = RIV2first_rb_LUT25[rballoc]; - ulsch->harq_processes[harq_pid]->nb_rb = RIV2nb_rb_LUT25[rballoc]; + RIV2first_rb_LUT = RIV2first_rb_LUT25; + RIV2nb_rb_LUT = RIV2nb_rb_LUT25; // printf("***********rballoc %d, first_rb %d, nb_rb %d (dci %p)\n",rballoc,ulsch->harq_processes[harq_pid]->first_rb,ulsch->harq_processes[harq_pid]->nb_rb,dci_pdu); break; @@ -6371,8 +6450,8 @@ int generate_ue_ulsch_params_from_dci(void *dci_pdu, } RIV_max = RIV_max50; - ulsch->harq_processes[harq_pid]->first_rb = RIV2first_rb_LUT50[rballoc]; - ulsch->harq_processes[harq_pid]->nb_rb = RIV2nb_rb_LUT50[rballoc]; + RIV2first_rb_LUT = RIV2first_rb_LUT50; + RIV2nb_rb_LUT = RIV2nb_rb_LUT50; break; @@ -6399,8 +6478,8 @@ int generate_ue_ulsch_params_from_dci(void *dci_pdu, } RIV_max = RIV_max100; - ulsch->harq_processes[harq_pid]->first_rb = RIV2first_rb_LUT100[rballoc]; - ulsch->harq_processes[harq_pid]->nb_rb = RIV2nb_rb_LUT100[rballoc]; + RIV2first_rb_LUT = RIV2first_rb_LUT100; + RIV2nb_rb_LUT = RIV2nb_rb_LUT100; // printf("rb_alloc (20 MHz dci) %d\n",rballoc); break; @@ -6432,6 +6511,8 @@ int generate_ue_ulsch_params_from_dci(void *dci_pdu, } ulsch->harq_processes[harq_pid]->TPC = TPC; + ulsch->harq_processes[harq_pid]->first_rb = RIV2first_rb_LUT[rballoc]; + ulsch->harq_processes[harq_pid]->nb_rb = RIV2nb_rb_LUT[rballoc]; if (ue->ul_power_control_dedicated[eNB_id].accumulationEnabled == 1) { LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d subframe %d: f_pusch (ACC) %d, adjusting by %d (TPC %d)\n", @@ -7063,6 +7144,13 @@ int generate_ue_ulsch_params_from_dci(void *dci_pdu, // ulsch->harq_processes[harq_pid]->V_UL_DAI = dai+1; } + dlsch[0]->harq_ack[subframe].vDAI_UL = dai+1; + + LOG_D(PHY, "[PUSCH %d] Format0 DCI %s, CQI_req=%d, cshift=%d, TPC=%d, DAI=%d, vDAI_UL[sf#%d]=%d, NDI=%d, MCS=%d, RBalloc=%d, first_rb=%d, harq_pid=%d, nb_rb=%d, subframe_scheduling_flag=%d\n", + harq_pid, + (frame_parms->frame_type == TDD? "TDD" : "FDD"), + cqi_req, cshift, TPC, dai, subframe, dlsch[0]->harq_ack[subframe].vDAI_UL, ndi, mcs, rballoc, ulsch->harq_processes[harq_pid]->first_rb, harq_pid, ulsch->harq_processes[harq_pid]->nb_rb, ulsch->harq_processes[harq_pid]->subframe_scheduling_flag); + ulsch->beta_offset_cqi_times8 = beta_cqi[ue->pusch_config_dedicated[eNB_id].betaOffset_CQI_Index];//18; ulsch->beta_offset_ri_times8 = beta_ri[ue->pusch_config_dedicated[eNB_id].betaOffset_RI_Index];//10; ulsch->beta_offset_harqack_times8 = beta_ack[ue->pusch_config_dedicated[eNB_id].betaOffset_ACK_Index];//16; @@ -7071,50 +7159,51 @@ int generate_ue_ulsch_params_from_dci(void *dci_pdu, ulsch->srs_active = use_srs; ulsch->bundling = 1-AckNackFBMode; - if (ulsch->harq_processes[harq_pid]->round == 0) { - if ((rnti >= cba_rnti) && (rnti < p_rnti)) - ulsch->harq_processes[harq_pid]->status = CBA_ACTIVE; - else - ulsch->harq_processes[harq_pid]->status = ACTIVE; - - ulsch->harq_processes[harq_pid]->rvidx = 0; - ulsch->harq_processes[harq_pid]->mcs = mcs; + if ((rnti >= cba_rnti) && (rnti < p_rnti)) + ulsch->harq_processes[harq_pid]->status = CBA_ACTIVE; + else + ulsch->harq_processes[harq_pid]->status = ACTIVE; - // ulsch->harq_processes[harq_pid]->calibration_flag =0; - if (ulsch->harq_processes[harq_pid]->mcs < 29) - ulsch->harq_processes[harq_pid]->TBS = TBStable[get_I_TBS_UL(ulsch->harq_processes[harq_pid]->mcs)][ulsch->harq_processes[harq_pid]->nb_rb-1]; - else - LOG_E(PHY,"Fatal: mcs > 28!!! and round == 0\n"); + ulsch->harq_processes[harq_pid]->rvidx = 0; - /* - else if (ulsch->harq_processes[harq_pid]->mcs == 29) { - ulsch->harq_processes[harq_pid]->mcs = 4; - ulsch->harq_processes[harq_pid]->TBS = TBStable[get_I_TBS_UL(ulsch->harq_processes[harq_pid]->mcs)][ulsch->harq_processes[harq_pid]->nb_rb-1]; - // ulsch->harq_processes[harq_pid]->calibration_flag =1; - // printf("Auto-Calibration (UE): mcs %d, TBS %d, nb_rb %d\n",ulsch->harq_processes[harq_pid]->mcs,ulsch->harq_processes[harq_pid]->TBS,ulsch->harq_processes[harq_pid]->nb_rb); - }*/ - ulsch->harq_processes[harq_pid]->Msc_initial = 12*ulsch->harq_processes[harq_pid]->nb_rb; - ulsch->harq_processes[harq_pid]->Nsymb_initial = ulsch->Nsymb_pusch; - ulsch->harq_processes[harq_pid]->round = 0; - - // a Ndi=1 automatically acknowledges previous PUSCH transmission - if (ue->ulsch_Msg3_active[eNB_id] == 1) - ue->ulsch_Msg3_active[eNB_id] = 0; + // ulsch->harq_processes[harq_pid]->calibration_flag =0; + if (mcs < 29) { + ulsch->harq_processes[harq_pid]->mcs = mcs; + // ulsch->harq_processes[harq_pid]->round = 0; } else { - // printf("Ndi = 0 : Setting RVidx from mcs %d\n",((DCI0_5MHz_TDD_1_6_t *)dci_pdu)->mcs); - if (mcs>28) ulsch->harq_processes[harq_pid]->rvidx = mcs - 28; - - // ulsch->harq_processes[harq_pid]->round++; + ulsch->harq_processes[harq_pid]->rvidx = mcs - 28; + if (ulsch->harq_processes[harq_pid]->round == 0) { + LOG_W(PHY,"PUSCH::mcs = %d and DCI0::mcs(%d) > 28 and round == %d\n", ulsch->harq_processes[harq_pid]->mcs, mcs, ulsch->harq_processes[harq_pid]->round); + } else { + LOG_D(PHY,"PUSCH::mcs = %d and DCI0::mcs(%d) > 28 and round == %d\n", ulsch->harq_processes[harq_pid]->mcs, mcs, ulsch->harq_processes[harq_pid]->round); + } + //LOG_E(PHY,"Fatal: mcs(%d) > 28!!! and round == 0\n", mcs); } + ulsch->harq_processes[harq_pid]->TBS = TBStable[get_I_TBS_UL(ulsch->harq_processes[harq_pid]->mcs)][ulsch->harq_processes[harq_pid]->nb_rb-1]; - LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d, subframe %d : Programming PUSCH with n_DMRS2 %d (cshift %d), nb_rb %d, first_rb %d, mcs %d, round %d, rv %d\n", - ue->Mod_id,harq_pid,proc->frame_rx,subframe,ulsch->harq_processes[harq_pid]->n_DMRS2,cshift,ulsch->harq_processes[harq_pid]->nb_rb,ulsch->harq_processes[harq_pid]->first_rb, - ulsch->harq_processes[harq_pid]->mcs,ulsch->harq_processes[harq_pid]->round,ulsch->harq_processes[harq_pid]->rvidx); - - // ulsch->n_DMRS2 = ((DCI0_5MHz_TDD_1_6_t *)dci_pdu)->cshift; - - #ifdef DEBUG_DCI - printf("Format 0 DCI : ulsch (ue): AbsSubframe %d.%d\n",proc->frame_rx,subframe); + /* + else if (ulsch->harq_processes[harq_pid]->mcs == 29) { + ulsch->harq_processes[harq_pid]->mcs = 4; + ulsch->harq_processes[harq_pid]->TBS = TBStable[get_I_TBS_UL(ulsch->harq_processes[harq_pid]->mcs)][ulsch->harq_processes[harq_pid]->nb_rb-1]; + // ulsch->harq_processes[harq_pid]->calibration_flag =1; + // printf("Auto-Calibration (UE): mcs %d, TBS %d, nb_rb %d\n",ulsch->harq_processes[harq_pid]->mcs,ulsch->harq_processes[harq_pid]->TBS,ulsch->harq_processes[harq_pid]->nb_rb); + }*/ + ulsch->harq_processes[harq_pid]->Msc_initial = 12*ulsch->harq_processes[harq_pid]->nb_rb; + ulsch->harq_processes[harq_pid]->Nsymb_initial = ulsch->Nsymb_pusch; + + // a Ndi=1 automatically acknowledges previous PUSCH transmission + if (ue->ulsch_Msg3_active[eNB_id] == 1) + ue->ulsch_Msg3_active[eNB_id] = 0; + + LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d, subframe %d : Programming PUSCH with n_DMRS2 %d (cshift %d), nb_rb %d, first_rb %d, mcs %d, round %d, rv %d, ulsch_ue_Msg3_active %d\n", + ue->Mod_id,harq_pid, + proc->frame_rx,subframe,ulsch->harq_processes[harq_pid]->n_DMRS2,cshift,ulsch->harq_processes[harq_pid]->nb_rb,ulsch->harq_processes[harq_pid]->first_rb, + ulsch->harq_processes[harq_pid]->mcs,ulsch->harq_processes[harq_pid]->round,ulsch->harq_processes[harq_pid]->rvidx, ue->ulsch_Msg3_active[eNB_id]); + + // ulsch->n_DMRS2 = ((DCI0_5MHz_TDD_1_6_t *)dci_pdu)->cshift; + + #ifdef DEBUG_DCI + printf("Format 0 DCI : ulsch (ue): AbsSubframe %d.%d\n",proc->frame_rx%1024,subframe); printf("Format 0 DCI : ulsch (ue): NBRB %d\n",ulsch->harq_processes[harq_pid]->nb_rb); printf("Format 0 DCI :ulsch (ue): first_rb %d\n",ulsch->harq_processes[harq_pid]->first_rb); printf("Format 0 DCI :ulsch (ue): rballoc %d\n",rballoc); @@ -7122,14 +7211,14 @@ int generate_ue_ulsch_params_from_dci(void *dci_pdu, printf("Format 0 DCI :ulsch (ue): first_tx %d\n",ulsch->harq_processes[harq_pid]->first_tx); printf("Format 0 DCI :ulsch (ue): DCINdi %d\n",ulsch->harq_processes[harq_pid]->DCINdi); printf("Format 0 DCI :ulsch (ue): round %d\n",ulsch->harq_processes[harq_pid]->round); - printf("Format 0 DCI :ulsch (ue): TBS %d\n",ulsch->harq_processes[harq_pid]->TBS); + //printf("Format 0 DCI :ulsch (ue): TBS %d\n",ulsch->harq_processes[harq_pid]->TBS); printf("Format 0 DCI :ulsch (ue): mcs %d\n",ulsch->harq_processes[harq_pid]->mcs); - printf("Format 0 DCI :ulsch (ue): O %d\n",ulsch->O); - printf("Format 0 DCI :ulsch (ue): cqiReq %d\n",cqi_req); - if (frame_parms->frame_type == TDD) - printf("Format 0 DCI :ulsch (ue): O_ACK/DAI %d/%d\n",ulsch->harq_processes[harq_pid]->O_ACK,dai); - else - printf("Format 0 DCI :ulsch (ue): O_ACK %d\n",ulsch->harq_processes[harq_pid]->O_ACK); + //printf("Format 0 DCI :ulsch (ue): O %d\n",ulsch->O); + //printf("Format 0 DCI :ulsch (ue): cqiReq %d\n",cqi_req); + //if (frame_parms->frame_type == TDD) + // printf("Format 0 DCI :ulsch (ue): O_ACK/DAI %d/%d\n",ulsch->harq_processes[harq_pid]->O_ACK,dai); + //else + // printf("Format 0 DCI :ulsch (ue): O_ACK %d\n",ulsch->harq_processes[harq_pid]->O_ACK); printf("Format 0 DCI :ulsch (ue): Nsymb_pusch %d\n",ulsch->Nsymb_pusch); printf("Format 0 DCI :ulsch (ue): cshift %d\n",ulsch->harq_processes[harq_pid]->n_DMRS2); @@ -7784,12 +7873,12 @@ int generate_eNB_ulsch_params_from_dci(PHY_VARS_eNB *eNB, } -double sinr_eff_cqi_calc(PHY_VARS_UE *ue, uint8_t eNB_id) +double sinr_eff_cqi_calc(PHY_VARS_UE *ue, uint8_t eNB_id, uint8_t subframe) { uint8_t transmission_mode = ue->transmission_mode[eNB_id]; PHY_MEASUREMENTS *meas = &ue->measurements; LTE_DL_FRAME_PARMS *frame_parms = &ue->frame_parms; - int32_t **dl_channel_est = ue->common_vars.dl_ch_estimates[eNB_id]; + int32_t **dl_channel_est = ue->common_vars.common_vars_rx_data_per_thread[subframe &0x1].dl_ch_estimates[eNB_id]; double *s_dB; s_dB = ue->sinr_CQI_dB; // LTE_UE_ULSCH_t *ulsch = ue->ulsch[eNB_id]; diff --git a/openair1/PHY/LTE_TRANSPORT/defs.h b/openair1/PHY/LTE_TRANSPORT/defs.h index b6bbe09b31dcead2d2197ef17d9b34ffa2fee886..8e17697ff48896aa21c1404128046a95f6167cbd 100644 --- a/openair1/PHY/LTE_TRANSPORT/defs.h +++ b/openair1/PHY/LTE_TRANSPORT/defs.h @@ -675,12 +675,16 @@ typedef struct { typedef struct { /// HARQ process id uint8_t harq_id; - /// ACK bits (after decoding) + /// ACK bits (after decoding) 0:NACK / 1:ACK / 2:DTX uint8_t ack; /// send status (for PUCCH) uint8_t send_harq_status; /// nCCE (for PUCCH) uint8_t nCCE; + /// DAI value detected from DCI1/1a/1b/1d/2/2a/2b/2c. 0xff indicates not touched + uint8_t vDAI_DL; + /// DAI value detected from DCI0/4. 0xff indicates not touched + uint8_t vDAI_UL; } harq_status_t; typedef struct { diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c b/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c index 08279188639a026527a514c2327188aa266d8bc9..8ec2a40d8de12b481fd90ad783595698de551dcb 100644 --- a/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c +++ b/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c @@ -118,7 +118,6 @@ LTE_eNB_DLSCH_t *new_eNB_dlsch(unsigned char Kmimo,unsigned char Mdlharq,uint32_ unsigned char exit_flag = 0,i,j,r,aa,layer; int re; unsigned char bw_scaling =1; - uint8_t nb_antennas_tx = frame_parms->nb_antennas_tx; switch (N_RB_DL) { case 6: diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_decoding.c b/openair1/PHY/LTE_TRANSPORT/dlsch_decoding.c index 4a80110b22fbd86bbdbeb23d49fab26c3747347a..9629502cecd0300a6fc00f7c284d10d9fd484c00 100644 --- a/openair1/PHY/LTE_TRANSPORT/dlsch_decoding.c +++ b/openair1/PHY/LTE_TRANSPORT/dlsch_decoding.c @@ -159,6 +159,7 @@ uint32_t dlsch_decoding(PHY_VARS_UE *phy_vars_ue, LTE_DL_FRAME_PARMS *frame_parms, LTE_UE_DLSCH_t *dlsch, LTE_DL_UE_HARQ_t *harq_process, + uint8_t frame, uint8_t subframe, uint8_t harq_pid, uint8_t is_crnti, @@ -241,6 +242,11 @@ uint32_t dlsch_decoding(PHY_VARS_UE *phy_vars_ue, return(dlsch->max_turbo_iterations); } + if (dlsch->harq_ack[subframe].ack != 2) { + LOG_D(PHY, "[UE %d] DLSCH @ SF%d : ACK bit is %d instead of DTX even before PDSCH is decoded!\n", + phy_vars_ue->Mod_id, subframe, dlsch->harq_ack[subframe].ack); + } + if (llr8_flag == 0) { //#ifdef __AVX2__ #if 0 @@ -609,10 +615,20 @@ uint32_t dlsch_decoding(PHY_VARS_UE *phy_vars_ue, //printf("CRC failed, segment %d\n",r); err_flag = 1; } + } + int32_t frame_rx_prev = frame; + int32_t subframe_rx_prev = subframe - 1; + if (subframe_rx_prev < 0) { + frame_rx_prev--; + subframe_rx_prev += 10; } + frame_rx_prev = frame_rx_prev%1024; if (err_flag == 1) { + LOG_D(PHY,"[UE %d] DLSCH: Setting NAK for SFN/SF %d/%d (pid %d, round %d, subframe %d)\n", + phy_vars_ue->Mod_id, frame_rx_prev, subframe_rx_prev, harq_pid, harq_process->round, subframe); + dlsch->harq_ack[subframe].ack = 0; dlsch->harq_ack[subframe].harq_id = harq_pid; dlsch->harq_ack[subframe].send_harq_status = 1; @@ -631,6 +647,9 @@ uint32_t dlsch_decoding(PHY_VARS_UE *phy_vars_ue, return((1+dlsch->max_turbo_iterations)); } else { + LOG_D(PHY,"[UE %d] DLSCH: Setting ACK for SFN/SF %d/%d (pid %d, round %d, subframe %d)\n", + phy_vars_ue->Mod_id, frame_rx_prev, subframe_rx_prev, harq_pid, harq_process->round, subframe); + harq_process->status = SCH_IDLE; harq_process->round = 0; dlsch->harq_ack[subframe].ack = 1; @@ -640,6 +659,7 @@ uint32_t dlsch_decoding(PHY_VARS_UE *phy_vars_ue, { LOG_D(PHY,"[UE %d] DLSCH: Setting ACK for subframe %d (pid %d, round %d, TBS %d)\n",phy_vars_ue->Mod_id,subframe,harq_pid,harq_process->round,harq_process->TBS); } + //LOG_D(PHY,"[UE %d] DLSCH: Setting ACK for subframe %d (pid %d, round %d)\n",phy_vars_ue->Mod_id,subframe,harq_pid,harq_process->round); } diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c index 33d798576871a02d75ee81e59e8c4cbe09f7e7b9..7d14e8aca716942346e5c6b1d930321aee1e0221 100644 --- a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c +++ b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c @@ -35,7 +35,7 @@ #include "defs.h" #include "extern.h" #include "PHY/sse_intrin.h" - +#include "T.h" #ifndef USER_MODE #define NOCYGWIN_STATIC static @@ -74,6 +74,7 @@ int rx_pdsch(PHY_VARS_UE *ue, PDSCH_t type, unsigned char eNB_id, unsigned char eNB_id_i, //if this == ue->n_connected_eNB, we assume MU interference + uint32_t frame, uint8_t subframe, unsigned char symbol, unsigned char first_symbol_flag, @@ -112,7 +113,7 @@ int rx_pdsch(PHY_VARS_UE *ue, break; case PDSCH: - pdsch_vars = &ue->pdsch_vars[eNB_id]; + pdsch_vars = &ue->pdsch_vars[subframe&0x1][eNB_id]; dlsch = ue->dlsch[eNB_id]; dlsch0_harq = dlsch[0]->harq_processes[harq_pid]; dlsch1_harq = dlsch[1]->harq_processes[harq_pid]; @@ -120,7 +121,7 @@ int rx_pdsch(PHY_VARS_UE *ue, break; default: - LOG_E(PHY,"[UE %d][FATAL] Frame %d subframe %d: Unknown PDSCH format %d\n",ue->proc.proc_rxtx[0].frame_rx,subframe,type); + LOG_E(PHY,"[UE][FATAL] Frame %d subframe %d: Unknown PDSCH format %d\n",ue->proc.proc_rxtx[0].frame_rx,subframe,type); return(-1); break; } @@ -162,8 +163,8 @@ int rx_pdsch(PHY_VARS_UE *ue, #ifdef DEBUG_DLSCH_MOD LOG_I(PHY,"dlsch: using pmi %x (%p), rb_alloc %x\n",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc),dlsch[0],dlsch0_harq->rb_alloc_even[0]); #endif - nb_rb = dlsch_extract_rbs_dual(common_vars->rxdataF, - common_vars->dl_ch_estimates[eNB_id], + nb_rb = dlsch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, + common_vars->common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id], pdsch_vars[eNB_id]->rxdataF_ext, pdsch_vars[eNB_id]->dl_ch_estimates_ext, dlsch0_harq->pmi_alloc, @@ -176,8 +177,8 @@ int rx_pdsch(PHY_VARS_UE *ue, if (dual_stream_flag==1) { if (eNB_id_in_connected_eNB) - nb_rb = dlsch_extract_rbs_dual(common_vars->rxdataF, - common_vars->dl_ch_estimates[eNB_id_i], + nb_rb = dlsch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, + common_vars->common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id_i], pdsch_vars[eNB_id_i]->rxdataF_ext, pdsch_vars[eNB_id_i]->dl_ch_estimates_ext, dlsch0_harq->pmi_alloc, @@ -188,8 +189,8 @@ int rx_pdsch(PHY_VARS_UE *ue, ue->high_speed_flag, frame_parms); else - nb_rb = dlsch_extract_rbs_dual(common_vars->rxdataF, - common_vars->dl_ch_estimates[eNB_id], + nb_rb = dlsch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, + common_vars->common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id], pdsch_vars[eNB_id_i]->rxdataF_ext, pdsch_vars[eNB_id_i]->dl_ch_estimates_ext, dlsch0_harq->pmi_alloc, @@ -201,8 +202,8 @@ int rx_pdsch(PHY_VARS_UE *ue, frame_parms); } } else if (beamforming_mode==0) { //else if nb_antennas_ports_eNB==1 && beamforming_mode == 0 - nb_rb = dlsch_extract_rbs_single(common_vars->rxdataF, - common_vars->dl_ch_estimates[eNB_id], + nb_rb = dlsch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, + common_vars->common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id], pdsch_vars[eNB_id]->rxdataF_ext, pdsch_vars[eNB_id]->dl_ch_estimates_ext, dlsch0_harq->pmi_alloc, @@ -215,8 +216,8 @@ int rx_pdsch(PHY_VARS_UE *ue, if (dual_stream_flag==1) { if (eNB_id_in_connected_eNB) - nb_rb = dlsch_extract_rbs_single(common_vars->rxdataF, - common_vars->dl_ch_estimates[eNB_id_i], + nb_rb = dlsch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, + common_vars->common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id_i], pdsch_vars[eNB_id_i]->rxdataF_ext, pdsch_vars[eNB_id_i]->dl_ch_estimates_ext, dlsch0_harq->pmi_alloc, @@ -227,8 +228,8 @@ int rx_pdsch(PHY_VARS_UE *ue, ue->high_speed_flag, frame_parms); - nb_rb = dlsch_extract_rbs_single(common_vars->rxdataF, - common_vars->dl_ch_estimates[eNB_id], + nb_rb = dlsch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, + common_vars->common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id], pdsch_vars[eNB_id_i]->rxdataF_ext, pdsch_vars[eNB_id_i]->dl_ch_estimates_ext, dlsch0_harq->pmi_alloc, @@ -240,7 +241,7 @@ int rx_pdsch(PHY_VARS_UE *ue, frame_parms); } } else if (beamforming_mode==7) { //else if beamforming_mode == 7 - nb_rb = dlsch_extract_rbs_TM7(common_vars->rxdataF, + nb_rb = dlsch_extract_rbs_TM7(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, pdsch_vars[eNB_id]->dl_bf_ch_estimates, pdsch_vars[eNB_id]->rxdataF_ext, pdsch_vars[eNB_id]->dl_bf_ch_estimates_ext, @@ -297,6 +298,13 @@ int rx_pdsch(PHY_VARS_UE *ue, // avgs = cmax(avgs,avg[(aarx<<1)+aatx]); +#if T_TRACER + if (type == PDSCH) + { + T(T_UE_PHY_PDSCH_ENERGY, T_INT(eNB_id), T_INT(0), T_INT(frame%1024), T_INT(subframe), + T_INT(avg[0]), T_INT(avg[1]), T_INT(avg[2]), T_INT(avg[3])); + } +#endif pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2)+1; // + log2_approx(frame_parms->nb_antenna_ports_eNB-1) //-1 because log2_approx counts the number of bits @@ -825,6 +833,15 @@ int rx_pdsch(PHY_VARS_UE *ue, return(-1); break; } + +#if T_TRACER + T(T_UE_PHY_PDSCH_IQ, T_INT(eNB_id), T_INT(ue->Mod_id), T_INT(frame%1024), + T_INT(subframe), T_INT(nb_rb), + T_INT(frame_parms->N_RB_UL), T_INT(frame_parms->symbols_per_tti), + T_BUFFER(&pdsch_vars[eNB_id]->rxdataF_comp0[eNB_id][0], + 2 * /* ulsch[UE_id]->harq_processes[harq_pid]->nb_rb */ frame_parms->N_RB_UL *12*frame_parms->symbols_per_tti*2)); +#endif + return(0); } @@ -5144,7 +5161,7 @@ unsigned short dlsch_extract_rbs_TM7(int **rxdataF, #ifdef USER_MODE -void dump_dlsch2(PHY_VARS_UE *ue,uint8_t eNB_id,uint16_t coded_bits_per_codeword,int round) +void dump_dlsch2(PHY_VARS_UE *ue,uint8_t eNB_id,uint8_t subframe,uint16_t coded_bits_per_codeword,int round) { unsigned int nsymb = (ue->frame_parms.Ncp == 0) ? 14 : 12; @@ -5153,50 +5170,50 @@ void dump_dlsch2(PHY_VARS_UE *ue,uint8_t eNB_id,uint16_t coded_bits_per_codeword sprintf(fname,"dlsch%d_rxF_r%d_ext0.m",eNB_id,round); sprintf(vname,"dl%d_rxF_r%d_ext0",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->rxdataF_ext[0],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->rxdataF_ext[0],12*N_RB_DL*nsymb,1,1); if (ue->frame_parms.nb_antennas_rx >1) { sprintf(fname,"dlsch%d_rxF_r%d_ext1.m",eNB_id,round); sprintf(vname,"dl%d_rxF_r%d_ext1",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->rxdataF_ext[1],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->rxdataF_ext[1],12*N_RB_DL*nsymb,1,1); } sprintf(fname,"dlsch%d_ch_r%d_ext00.m",eNB_id,round); sprintf(vname,"dl%d_ch_r%d_ext00",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->dl_ch_estimates_ext[0],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->dl_ch_estimates_ext[0],12*N_RB_DL*nsymb,1,1); if (ue->transmission_mode[eNB_id]==7){ sprintf(fname,"dlsch%d_bf_ch_r%d.m",eNB_id,round); sprintf(vname,"dl%d_bf_ch_r%d",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->dl_bf_ch_estimates[0],512*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->dl_bf_ch_estimates[0],512*nsymb,1,1); //write_output(fname,vname,phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->dl_bf_ch_estimates[0],512,1,1); sprintf(fname,"dlsch%d_bf_ch_r%d_ext00.m",eNB_id,round); sprintf(vname,"dl%d_bf_ch_r%d_ext00",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->dl_bf_ch_estimates_ext[0],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->dl_bf_ch_estimates_ext[0],12*N_RB_DL*nsymb,1,1); } if (ue->frame_parms.nb_antennas_rx == 2) { sprintf(fname,"dlsch%d_ch_r%d_ext01.m",eNB_id,round); sprintf(vname,"dl%d_ch_r%d_ext01",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->dl_ch_estimates_ext[1],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->dl_ch_estimates_ext[1],12*N_RB_DL*nsymb,1,1); } if (ue->frame_parms.nb_antenna_ports_eNB == 2) { sprintf(fname,"dlsch%d_ch_r%d_ext10.m",eNB_id,round); sprintf(vname,"dl%d_ch_r%d_ext10",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->dl_ch_estimates_ext[2],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->dl_ch_estimates_ext[2],12*N_RB_DL*nsymb,1,1); if (ue->frame_parms.nb_antennas_rx == 2) { sprintf(fname,"dlsch%d_ch_r%d_ext11.m",eNB_id,round); sprintf(vname,"dl%d_ch_r%d_ext11",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->dl_ch_estimates_ext[3],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->dl_ch_estimates_ext[3],12*N_RB_DL*nsymb,1,1); } } sprintf(fname,"dlsch%d_rxF_r%d_uespec0.m",eNB_id,round); sprintf(vname,"dl%d_rxF_r%d_uespec0",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->rxdataF_uespec_pilots[0],12*N_RB_DL,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->rxdataF_uespec_pilots[0],12*N_RB_DL,1,1); /* write_output("dlsch%d_ch_ext01.m","dl01_ch0_ext",pdsch_vars[eNB_id]->dl_ch_estimates_ext[1],12*N_RB_DL*nsymb,1,1); @@ -5205,26 +5222,26 @@ void dump_dlsch2(PHY_VARS_UE *ue,uint8_t eNB_id,uint16_t coded_bits_per_codeword */ sprintf(fname,"dlsch%d_r%d_rho.m",eNB_id,round); sprintf(vname,"dl_rho_r%d_%d",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->dl_ch_rho_ext[0],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->dl_ch_rho_ext[0],12*N_RB_DL*nsymb,1,1); sprintf(fname,"dlsch%d_rxF_r%d_comp0.m",eNB_id,round); sprintf(vname,"dl%d_rxF_r%d_comp0",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->rxdataF_comp0[0],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->rxdataF_comp0[0],12*N_RB_DL*nsymb,1,1); if (ue->frame_parms.nb_antenna_ports_eNB == 2) { sprintf(fname,"dlsch%d_rxF_r%d_comp1.m",eNB_id,round); sprintf(vname,"dl%d_rxF_r%d_comp1",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->rxdataF_comp1[0][round],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->rxdataF_comp1[0][round],12*N_RB_DL*nsymb,1,1); } sprintf(fname,"dlsch%d_rxF_r%d_llr.m",eNB_id,round); sprintf(vname,"dl%d_r%d_llr",eNB_id,round); - write_output(fname,vname, ue->pdsch_vars[eNB_id]->llr[0],coded_bits_per_codeword,1,0); + write_output(fname,vname, ue->pdsch_vars[subframe&0x1][eNB_id]->llr[0],coded_bits_per_codeword,1,0); sprintf(fname,"dlsch%d_r%d_mag1.m",eNB_id,round); sprintf(vname,"dl%d_r%d_mag1",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->dl_ch_mag0[0],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->dl_ch_mag0[0],12*N_RB_DL*nsymb,1,1); sprintf(fname,"dlsch%d_r%d_mag2.m",eNB_id,round); sprintf(vname,"dl%d_r%d_mag2",eNB_id,round); - write_output(fname,vname,ue->pdsch_vars[eNB_id]->dl_ch_magb0[0],12*N_RB_DL*nsymb,1,1); + write_output(fname,vname,ue->pdsch_vars[subframe&0x1][eNB_id]->dl_ch_magb0[0],12*N_RB_DL*nsymb,1,1); // printf("log2_maxh = %d\n",ue->pdsch_vars[eNB_id]->log2_maxh); } diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c b/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c index d6e680344be663c9d330249ae627eb3006f51920..1875ada878a6d5ba6c7842133039051216237b9d 100644 --- a/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c +++ b/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c @@ -595,7 +595,7 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB, int use2ndpilots = (frame_parms->mode1_flag==1)?1:0; - uint32_t tti_offset,aa; + uint32_t tti_offset; //,aa; uint8_t re; uint8_t qam64_table_offset_re = 0; uint8_t qam64_table_offset_im = 0; diff --git a/openair1/PHY/LTE_TRANSPORT/group_hopping.c b/openair1/PHY/LTE_TRANSPORT/group_hopping.c index bbd908b34abba06b02b3ec996109cb7f2e461c54..9cbdfad39ff0bff094be640bfe584d77631d99c6 100644 --- a/openair1/PHY/LTE_TRANSPORT/group_hopping.c +++ b/openair1/PHY/LTE_TRANSPORT/group_hopping.c @@ -118,7 +118,8 @@ void generate_nPRS(LTE_DL_FRAME_PARMS *frame_parms) uint16_t next = 0; uint8_t ns=0; - uint32_t fss_pusch = frame_parms->Nid_cell + frame_parms->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH; + uint32_t fss_pucch = (frame_parms->Nid_cell) % 30; + uint32_t fss_pusch = (fss_pucch + frame_parms->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH) % 30; x2 = (32*(uint32_t)(frame_parms->Nid_cell/30)) + fss_pusch; #ifdef DEBUG_GROUPHOP diff --git a/openair1/PHY/LTE_TRANSPORT/if4_tools.c b/openair1/PHY/LTE_TRANSPORT/if4_tools.c old mode 100644 new mode 100755 index 68bf46da789e1c42d32ea55c2e9f40d56ae6e3c5..924eef11b97a562a4fa7913b9db80ee54c63294e --- a/openair1/PHY/LTE_TRANSPORT/if4_tools.c +++ b/openair1/PHY/LTE_TRANSPORT/if4_tools.c @@ -32,16 +32,20 @@ #include "PHY/defs.h" #include "PHY/TOOLS/alaw_lut.h" +#include "PHY/extern.h" +#include "SCHED/defs.h" -#include "targets/ARCH/ETHERNET/USERSPACE/LIB/if_defs.h" +//#include "targets/ARCH/ETHERNET/USERSPACE/LIB/if_defs.h" +#include "targets/ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.h" #include "UTIL/LOG/vcd_signal_dumper.h" void send_IF4p5(PHY_VARS_eNB *eNB, int frame, int subframe, uint16_t packet_type, int k) { LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms; - int32_t **txdataF = eNB->common_vars.txdataF[0]; - int32_t **rxdataF = eNB->common_vars.rxdataF[0]; - int16_t **rxsigF = eNB->prach_vars.rxsigF; - void *tx_buffer = eNB->ifbuffer.tx; + int32_t **txdataF = (eNB->CC_id==0) ? eNB->common_vars.txdataF[0] : PHY_vars_eNB_g[0][0]->common_vars.txdataF[0]; + int32_t **rxdataF = eNB->common_vars.rxdataF[0]; + int16_t **rxsigF = eNB->prach_vars.rxsigF; + void *tx_buffer = eNB->ifbuffer.tx[subframe&1]; + void *tx_buffer_prach = eNB->ifbuffer.tx_prach; uint16_t symbol_id=0, element_id=0; uint16_t db_fulllength, db_halflength; @@ -49,31 +53,44 @@ void send_IF4p5(PHY_VARS_eNB *eNB, int frame, int subframe, uint16_t packet_type uint16_t *data_block=NULL, *i=NULL; - VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4, 1 ); + IF4p5_header_t *packet_header=NULL; + eth_state_t *eth = (eth_state_t*) (eNB->ifdevice.priv); + int nsym = fp->symbols_per_tti; + + if (eNB->CC_id==0) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4, 1 ); if (packet_type == IF4p5_PDLFFT) { + if (subframe_select(fp,subframe)==SF_S) + nsym=fp->dl_symbols_in_S_subframe; + db_fulllength = 12*fp->N_RB_DL; db_halflength = (db_fulllength)>>1; slotoffsetF = (subframe)*(fp->ofdm_symbol_size)*((fp->Ncp==1) ? 12 : 14) + 1; blockoffsetF = slotoffsetF + fp->ofdm_symbol_size - db_halflength - 1; - IF4p5_header_t *dl_header = (IF4p5_header_t *)(tx_buffer + MAC_HEADER_SIZE_BYTES); - data_block = (uint16_t*)(tx_buffer + MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t); - gen_IF4p5_dl_header(dl_header, frame, subframe); + if (eth->flags == ETH_RAW_IF4p5_MODE) { + packet_header = (IF4p5_header_t *)(tx_buffer + MAC_HEADER_SIZE_BYTES); + data_block = (uint16_t*)(tx_buffer + MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t); + } else { + packet_header = (IF4p5_header_t *)(tx_buffer); + data_block = (uint16_t*)(tx_buffer + sizeof_IF4p5_header_t); + } + gen_IF4p5_dl_header(packet_header, frame, subframe); - for (symbol_id=0; symbol_idsymbols_per_tti; symbol_id++) { + for (symbol_id=0; symbol_idCC_id==1) LOG_I(PHY,"DL_IF4p5: CC_id %d : frame %d, subframe %d, symbol %d\n",eNB->CC_id,frame,subframe,symbol_id); for (element_id=0; element_idCC_id][blockoffsetF+element_id]; data_block[element_id] = ((uint16_t) lin2alaw[*i]) | (lin2alaw[*(i+1)]<<8); - i = (uint16_t*) &txdataF[0][slotoffsetF+element_id]; + i = (uint16_t*) &txdataF[eNB->CC_id][slotoffsetF+element_id]; data_block[element_id+db_halflength] = ((uint16_t) lin2alaw[*i]) | (lin2alaw[*(i+1)]<<8); } - dl_header->frame_status &= ~(0x000f<<26); - dl_header->frame_status |= (symbol_id&0x000f)<<26; + packet_header->frame_status &= ~(0x000f<<26); + packet_header->frame_status |= (symbol_id&0x000f)<<26; if ((eNB->ifdevice.trx_write_func(&eNB->ifdevice, symbol_id, @@ -87,58 +104,92 @@ void send_IF4p5(PHY_VARS_eNB *eNB, int frame, int subframe, uint16_t packet_type slotoffsetF += fp->ofdm_symbol_size; blockoffsetF += fp->ofdm_symbol_size; } - } else if (packet_type == IF4p5_PULFFT) { + } else if ((packet_type == IF4p5_PULFFT)|| + (packet_type == IF4p5_PULTICK)){ db_fulllength = 12*fp->N_RB_UL; db_halflength = (db_fulllength)>>1; slotoffsetF = 1; blockoffsetF = slotoffsetF + fp->ofdm_symbol_size - db_halflength - 1; - IF4p5_header_t *ul_header = (IF4p5_header_t *)(tx_buffer + MAC_HEADER_SIZE_BYTES); - data_block = (uint16_t*)(tx_buffer + MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t); - - gen_IF4p5_ul_header(ul_header, frame, subframe); - - for (symbol_id=0; symbol_idsymbols_per_tti; symbol_id++) { - - for (element_id=0; element_idul_symbols_in_S_subframe; + slotoffsetF += (fp->ofdm_symbol_size*(fp->symbols_per_tti-nsym)); + blockoffsetF += (fp->ofdm_symbol_size*(fp->symbols_per_tti-nsym)); + } - i = (uint16_t*) &rxdataF[0][slotoffsetF+element_id]; - data_block[element_id+db_halflength] = ((uint16_t) lin2alaw[*i]) | (lin2alaw[*(i+1)]<<8); - } - - ul_header->frame_status &= ~(0x000f<<26); - ul_header->frame_status |= (symbol_id&0x000f)<<26; - + if (eth->flags == ETH_RAW_IF4p5_MODE) { + packet_header = (IF4p5_header_t *)(tx_buffer + MAC_HEADER_SIZE_BYTES); + data_block = (uint16_t*)(tx_buffer + MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t); + } else { + packet_header = (IF4p5_header_t *)(tx_buffer); + data_block = (uint16_t*)(tx_buffer + sizeof_IF4p5_header_t); + } + gen_IF4p5_ul_header(packet_header, packet_type, frame, subframe); + + if (packet_type == IF4p5_PULFFT) { + for (symbol_id=fp->symbols_per_tti-nsym; symbol_idsymbols_per_tti; symbol_id++) { + LOG_D(PHY,"IF4p5_PULFFT: frame %d, subframe %d, symbol %d\n",frame,subframe,symbol_id); + for (element_id=0; element_idframe_status &= ~(0x000f<<26); + packet_header->frame_status |= (symbol_id&0x000f)<<26; + + if ((eNB->ifdevice.trx_write_func(&eNB->ifdevice, + symbol_id, + &tx_buffer, + db_fulllength, + 1, + IF4p5_PULFFT)) < 0) { + perror("ETHERNET write for IF4p5_PULFFT\n"); + } + + slotoffsetF += fp->ofdm_symbol_size; + blockoffsetF += fp->ofdm_symbol_size; + } + } + else { if ((eNB->ifdevice.trx_write_func(&eNB->ifdevice, - symbol_id, - &tx_buffer, - db_fulllength, - 1, - IF4p5_PULFFT)) < 0) { - perror("ETHERNET write for IF4p5_PULFFT\n"); + 0, + &tx_buffer, + 0, + 1, + IF4p5_PULTICK)) < 0) { + perror("ETHERNET write for IF4p5_PULFFT\n"); } - - slotoffsetF += fp->ofdm_symbol_size; - blockoffsetF += fp->ofdm_symbol_size; - } + } } else if (packet_type == IF4p5_PRACH) { // FIX: hard coded prach samples length - db_fulllength = 840*2; - - IF4p5_header_t *prach_header = (IF4p5_header_t *)(tx_buffer + MAC_HEADER_SIZE_BYTES); - data_block = (uint16_t*)(tx_buffer + MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t); + LOG_D(PHY,"IF4p5_PRACH: frame %d, subframe %d\n",frame,subframe); + db_fulllength = PRACH_HARD_CODED_NUM_SAMPLES; + + if (eth->flags == ETH_RAW_IF4p5_MODE) { + packet_header = (IF4p5_header_t *)(tx_buffer_prach + MAC_HEADER_SIZE_BYTES); + data_block = (uint16_t*)(tx_buffer + MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t); + } else { + packet_header = (IF4p5_header_t *)(tx_buffer_prach); + data_block = (uint16_t*)(tx_buffer_prach + sizeof_IF4p5_header_t); + } + gen_IF4p5_prach_header(packet_header, frame, subframe); + + if (eth->flags == ETH_RAW_IF4p5_MODE) { + memcpy((int16_t*)(tx_buffer_prach + MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t), + (&rxsigF[0][k]), + PRACH_BLOCK_SIZE_BYTES); + } else { + memcpy((int16_t*)(tx_buffer_prach + sizeof_IF4p5_header_t), + (&rxsigF[0][k]), + PRACH_BLOCK_SIZE_BYTES); + } - gen_IF4p5_prach_header(prach_header, frame, subframe); - - memcpy((int16_t*)(tx_buffer + MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t), - (&rxsigF[0][k]), - db_fulllength*sizeof(int16_t)); - if ((eNB->ifdevice.trx_write_func(&eNB->ifdevice, symbol_id, - &tx_buffer, + &tx_buffer_prach, db_fulllength, 1, IF4p5_PRACH)) < 0) { @@ -148,7 +199,7 @@ void send_IF4p5(PHY_VARS_eNB *eNB, int frame, int subframe, uint16_t packet_type AssertFatal(1==0, "send_IF4p5 - Unknown packet_type %x", packet_type); } - VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4, 0 ); + if (eNB->CC_id==0) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4, 0 ); return; } @@ -163,8 +214,9 @@ void recv_IF4p5(PHY_VARS_eNB *eNB, int *frame, int *subframe, uint16_t *packet_t uint16_t element_id; uint16_t db_fulllength, db_halflength; int slotoffsetF=0, blockoffsetF=0; + eth_state_t *eth = (eth_state_t*) (eNB->ifdevice.priv); - VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4, 1 ); + if (eNB->CC_id==0) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4, 1 ); if (eNB->node_function == NGFI_RRU_IF4p5) { db_fulllength = (12*fp->N_RB_DL); @@ -183,17 +235,28 @@ void recv_IF4p5(PHY_VARS_eNB *eNB, int *frame, int *subframe, uint16_t *packet_t 0) < 0) { perror("ETHERNET read"); } - - packet_header = (IF4p5_header_t*) (rx_buffer+MAC_HEADER_SIZE_BYTES); - data_block = (uint16_t*) (rx_buffer+MAC_HEADER_SIZE_BYTES+sizeof_IF4p5_header_t); + if (eth->flags == ETH_RAW_IF4p5_MODE) { + packet_header = (IF4p5_header_t*) (rx_buffer+MAC_HEADER_SIZE_BYTES); + data_block = (uint16_t*) (rx_buffer+MAC_HEADER_SIZE_BYTES+sizeof_IF4p5_header_t); + } else { + packet_header = (IF4p5_header_t*) (rx_buffer); + data_block = (uint16_t*) (rx_buffer+sizeof_IF4p5_header_t); + } + + + *frame = ((packet_header->frame_status)>>6)&0xffff; - *subframe = ((packet_header->frame_status)>>22)&0x000f; + *subframe = ((packet_header->frame_status)>>22)&0x000f; + + *packet_type = packet_header->sub_type; if (*packet_type == IF4p5_PDLFFT) { *symbol_number = ((packet_header->frame_status)>>26)&0x000f; + LOG_D(PHY,"DL_IF4p5: CC_id %d : frame %d, subframe %d, symbol %d\n",eNB->CC_id,*frame,*subframe,*symbol_number); + slotoffsetF = (*symbol_number)*(fp->ofdm_symbol_size) + (*subframe)*(fp->ofdm_symbol_size)*((fp->Ncp==1) ? 12 : 14) + 1; blockoffsetF = slotoffsetF + fp->ofdm_symbol_size - db_halflength - 1; @@ -210,6 +273,8 @@ void recv_IF4p5(PHY_VARS_eNB *eNB, int *frame, int *subframe, uint16_t *packet_t } else if (*packet_type == IF4p5_PULFFT) { *symbol_number = ((packet_header->frame_status)>>26)&0x000f; + if (eNB->CC_id==1) LOG_I(PHY,"UL_IF4p5: CC_id %d : frame %d, subframe %d, symbol %d\n",eNB->CC_id,*frame,*subframe,*symbol_number); + slotoffsetF = (*symbol_number)*(fp->ofdm_symbol_size) + 1; blockoffsetF = slotoffsetF + fp->ofdm_symbol_size - db_halflength - 1; @@ -224,18 +289,27 @@ void recv_IF4p5(PHY_VARS_eNB *eNB, int *frame, int *subframe, uint16_t *packet_t } } else if (*packet_type == IF4p5_PRACH) { + if (eNB->CC_id==1) LOG_I(PHY,"PRACH_IF4p5: CC_id %d : frame %d, subframe %d, symbol %d\n",eNB->CC_id,*frame,*subframe); + // FIX: hard coded prach samples length - db_fulllength = 840*2; - - memcpy((&rxsigF[0][0]), - (int16_t*) (rx_buffer+MAC_HEADER_SIZE_BYTES+sizeof_IF4p5_header_t), - db_fulllength*sizeof(int16_t)); - + db_fulllength = PRACH_HARD_CODED_NUM_SAMPLES; + + if (eth->flags == ETH_RAW_IF4p5_MODE) { + memcpy((&rxsigF[0][0]), + (int16_t*) (rx_buffer+MAC_HEADER_SIZE_BYTES+sizeof_IF4p5_header_t), + PRACH_BLOCK_SIZE_BYTES); + } else { + memcpy((&rxsigF[0][0]), + (int16_t*) (rx_buffer+sizeof_IF4p5_header_t), + PRACH_BLOCK_SIZE_BYTES); + } + } else if (*packet_type == IF4p5_PULTICK) { + } else { AssertFatal(1==0, "recv_IF4p5 - Unknown packet_type %x", *packet_type); } - VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4, 0 ); + if (eNB->CC_id==0) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4, 0 ); return; } @@ -253,10 +327,10 @@ void gen_IF4p5_dl_header(IF4p5_header_t *dl_packet, int frame, int subframe) { } -void gen_IF4p5_ul_header(IF4p5_header_t *ul_packet, int frame, int subframe) { +void gen_IF4p5_ul_header(IF4p5_header_t *ul_packet, uint16_t packet_subtype, int frame, int subframe) { ul_packet->type = IF4p5_PACKET_TYPE; - ul_packet->sub_type = IF4p5_PULFFT; + ul_packet->sub_type = packet_subtype; ul_packet->rsvd = 0; @@ -282,6 +356,18 @@ void gen_IF4p5_prach_header(IF4p5_header_t *prach_packet, int frame, int subfram void malloc_IF4p5_buffer(PHY_VARS_eNB *eNB) { // Keep the size large enough - eNB->ifbuffer.tx = malloc(RAW_IF4p5_PRACH_SIZE_BYTES); - eNB->ifbuffer.rx = malloc(RAW_IF4p5_PRACH_SIZE_BYTES); + eth_state_t *eth = (eth_state_t*) (eNB->ifdevice.priv); + int i; + + if (eth->flags == ETH_RAW_IF4p5_MODE) { + for (i=0;i<10;i++) + eNB->ifbuffer.tx[i] = malloc(RAW_IF4p5_PRACH_SIZE_BYTES); + eNB->ifbuffer.tx_prach = malloc(RAW_IF4p5_PRACH_SIZE_BYTES); + eNB->ifbuffer.rx = malloc(RAW_IF4p5_PRACH_SIZE_BYTES); + } else { + for (i=0;i<10;i++) + eNB->ifbuffer.tx[i] = malloc(UDP_IF4p5_PRACH_SIZE_BYTES); + eNB->ifbuffer.tx_prach = malloc(UDP_IF4p5_PRACH_SIZE_BYTES); + eNB->ifbuffer.rx = malloc(UDP_IF4p5_PRACH_SIZE_BYTES); + } } diff --git a/openair1/PHY/LTE_TRANSPORT/if4_tools.h b/openair1/PHY/LTE_TRANSPORT/if4_tools.h index 1f78e7f77afea2f8bdb43fc988fe36e239d0cf62..e2d4f1f7de0b6cb413eb4479664ebabd0fc53db7 100644 --- a/openair1/PHY/LTE_TRANSPORT/if4_tools.h +++ b/openair1/PHY/LTE_TRANSPORT/if4_tools.h @@ -37,6 +37,7 @@ #define IF4p5_PULFFT 0x0019 #define IF4p5_PDLFFT 0x0020 #define IF4p5_PRACH 0x0021 +#define IF4p5_PULTICK 0x0022 struct IF4p5_header { /// Type @@ -55,7 +56,7 @@ typedef struct IF4p5_header IF4p5_header_t; void gen_IF4p5_dl_header(IF4p5_header_t*, int, int); -void gen_IF4p5_ul_header(IF4p5_header_t*, int, int); +void gen_IF4p5_ul_header(IF4p5_header_t*, uint16_t, int, int); void gen_IF4p5_prach_header(IF4p5_header_t*, int, int); diff --git a/openair1/PHY/LTE_TRANSPORT/if5_tools.c b/openair1/PHY/LTE_TRANSPORT/if5_tools.c index 7be4c8d1df9051e0e86adaa59e91019bf1318a52..5b1c8347053e5bd0e1a1c5709f053bc8f2430eff 100644 --- a/openair1/PHY/LTE_TRANSPORT/if5_tools.c +++ b/openair1/PHY/LTE_TRANSPORT/if5_tools.c @@ -21,11 +21,11 @@ /*! \file PHY/LTE_TRANSPORT/if5_tools.c * \brief -* \author S. Sandeep Kumar, Raymond Knopp +* \author S. Sandeep Kumar, Raymond Knopp, Tien-Thinh Nguyen * \date 2016 * \version 0.1 * \company Eurecom -* \email: ee13b1025@iith.ac.in, knopp@eurecom.fr +* \email: ee13b1025@iith.ac.in, knopp@eurecom.fr, tien-thinh.nguyen@eurecom.fr * \note * \warning */ @@ -34,13 +34,21 @@ #include "targets/ARCH/ETHERNET/USERSPACE/LIB/if_defs.h" #include "UTIL/LOG/vcd_signal_dumper.h" +//#define DEBUG_DL_MOBIPASS +//#define DEBUG_UL_MOBIPASS +#define SUBFRAME_SKIP_NUM_MOBIPASS 8 +int dummy_cnt = 0; +int subframe_skip_extra = 0; +int start_flag = 1; +int offset_cnt = 1; void send_IF5(PHY_VARS_eNB *eNB, openair0_timestamp proc_timestamp, int subframe, uint8_t *seqno, uint16_t packet_type) { LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms; int32_t *txp[fp->nb_antennas_tx], *rxp[fp->nb_antennas_rx]; int32_t *tx_buffer=NULL; + int8_t dummy_buffer[fp->samples_per_tti*2]; uint16_t packet_id=0, i=0; uint32_t spp_eth = (uint32_t) eNB->ifdevice.openair0_cfg->samples_per_packet; @@ -89,17 +97,18 @@ void send_IF5(PHY_VARS_eNB *eNB, openair0_timestamp proc_timestamp, int subframe } } else if (packet_type == IF5_MOBIPASS) { - uint16_t db_fulllength=640; + uint16_t db_fulllength = PAYLOAD_MOBIPASS_NUM_SAMPLES; __m128i *data_block=NULL, *data_block_head=NULL; __m128i *txp128; __m128i t0, t1; - tx_buffer = memalign(16, MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t + db_fulllength*sizeof(int16_t)); + // tx_buffer = memalign(16, MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t + db_fulllength*sizeof(int16_t)); + tx_buffer = malloc(MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t + db_fulllength*sizeof(int16_t)); IF5_mobipass_header_t *header = (IF5_mobipass_header_t *)((uint8_t *)tx_buffer + MAC_HEADER_SIZE_BYTES); - data_block_head = (__m128i *)((uint8_t *)tx_buffer + MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t + 4); - + data_block_head = (__m128i *)((uint8_t *)tx_buffer + MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t); + header->flags = 0; header->fifo_status = 0; header->seqno = *seqno; @@ -110,14 +119,14 @@ void send_IF5(PHY_VARS_eNB *eNB, openair0_timestamp proc_timestamp, int subframe txp128 = (__m128i *) txp[0]; for (packet_id=0; packet_idsamples_per_tti/db_fulllength; packet_id++) { - header->time_stamp = (uint32_t)(proc_timestamp + packet_id*db_fulllength); + header->time_stamp = htonl((uint32_t)(proc_timestamp + packet_id*db_fulllength)); data_block = data_block_head; for (i=0; i>2; i+=2) { t0 = _mm_srai_epi16(*txp128++, 4); t1 = _mm_srai_epi16(*txp128++, 4); - - *data_block++ = _mm_packs_epi16(t0, t1); +// *data_block++ = _mm_packs_epi16(t0, t1); + _mm_storeu_si128(data_block++, _mm_packs_epi16(t0, t1)); } // Write the packet to the fronthaul @@ -129,18 +138,38 @@ void send_IF5(PHY_VARS_eNB *eNB, openair0_timestamp proc_timestamp, int subframe IF5_MOBIPASS)) < 0) { perror("ETHERNET write for IF5_MOBIPASS\n"); } - +#ifdef DEBUG_DL_MOBIPASS + if ((subframe==0)&&(dummy_cnt == 100)) { + memcpy((void*)&dummy_buffer[packet_id*db_fulllength*2],(void*)data_block_head,db_fulllength*2); + } +#endif header->seqno += 1; } *seqno = header->seqno; - + +#ifdef DEBUG_DL_MOBIPASS + uint8_t txe; + txe = dB_fixed(signal_energy(txp[0],fp->samples_per_tti)); + if (txe > 0){ + LOG_D(PHY,"[Mobipass] frame:%d, subframe:%d, energy %d\n", (proc_timestamp/(10*fp->samples_per_tti))&1023,subframe, txe); + } +#endif } else { AssertFatal(1==0, "send_IF5 - Unknown packet_type %x", packet_type); } free(tx_buffer); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF5, 0 ); - +#ifdef DEBUG_DL_MOBIPASS + if(subframe==0) { + if (dummy_cnt==100) { + write_output("txsigmb.m","txs",(void*)dummy_buffer, fp->samples_per_tti,1, 5); + exit(-1); + } else { + dummy_cnt++; + } + } +#endif return; } @@ -151,6 +180,8 @@ void recv_IF5(PHY_VARS_eNB *eNB, openair0_timestamp *proc_timestamp, int subfram int32_t *txp[fp->nb_antennas_tx], *rxp[fp->nb_antennas_rx]; uint16_t packet_id=0, i=0; + int8_t dummy_buffer_rx[fp->samples_per_tti*2]; + uint8_t rxe; int32_t spp_eth = (int32_t) eNB->ifdevice.openair0_cfg->samples_per_packet; int32_t spsf = (int32_t) eNB->ifdevice.openair0_cfg->samples_per_frame/10; @@ -202,7 +233,128 @@ void recv_IF5(PHY_VARS_eNB *eNB, openair0_timestamp *proc_timestamp, int subfram } else if (packet_type == IF5_MOBIPASS) { - + uint16_t db_fulllength = PAYLOAD_MOBIPASS_NUM_SAMPLES; + openair0_timestamp timestamp_mobipass[fp->samples_per_tti/db_fulllength]; + int lower_offset = 0; + int upper_offset = 70000; + int subframe_skip = 0; + int reset_flag = 0; + int32_t *rx_buffer=NULL; + __m128i *data_block=NULL, *data_block_head=NULL; + __m128i *rxp128; + __m128i r0, r1; + + //rx_buffer = memalign(16, MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t + db_fulllength*sizeof(int16_t)); + rx_buffer = malloc(MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t + db_fulllength*sizeof(int16_t)); + IF5_mobipass_header_t *header = (IF5_mobipass_header_t *)((uint8_t *)rx_buffer + MAC_HEADER_SIZE_BYTES); + data_block_head = (__m128i *)((uint8_t *)rx_buffer + MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t); + + rxp[0] = (void*)&eNB->common_vars.rxdata[0][0][subframe*eNB->frame_parms.samples_per_tti]; + rxp128 = (__m128i *) (rxp[0]); + + eNB_proc_t *proc = &eNB->proc; +/* + // while(packet_idsamples_per_tti/db_fulllength) { + data_block = data_block_head; + + eNB->ifdevice.trx_read_func(&eNB->ifdevice, + &ts0, + (void**)&rx_buffer, + db_fulllength, + 1 + ); + + if ((header->seqno == 1)&&(first_packet==1)) { + first_packet = 0; //ignore the packets before synchnorization + packet_id = 0; + ts_offset = ntohl(ts0); + } + if (first_packet==0) { + packet_cnt++; + ts = ntohl(ts0); + packet_id = (ts-ts_offset)/db_fulllength; + packet_id = packet_id % (fp->samples_per_tti/db_fulllength); + + printf("[IF5_tools]packet_id:%d\n", packet_id); + // if (ts_stored == 0) { + // ts_stored = 1; + *proc_timestamp = ntohl(ts - (packet_id*db_fulllength)); + // } + rxp[0] = (void*)&eNB->common_vars.rxdata[0][0][(subframe*eNB->frame_parms.samples_per_tti)+packet_id*db_fulllength]; + rxp128 = (__m128i *) (rxp[0]); + + for (i=0; i>2; i+=2) { + r0 = _mm_loadu_si128(data_block++); + *rxp128++ =_mm_slli_epi16(_mm_srai_epi16(_mm_unpacklo_epi8(r0,r0),8),4); + *rxp128++ =_mm_slli_epi16(_mm_srai_epi16(_mm_unpackhi_epi8(r0,r0),8),4); + } + } + // }//end while +*/ + + + packet_id=0; + while(packet_idsamples_per_tti/db_fulllength) { + data_block = data_block_head; + + eNB->ifdevice.trx_read_func(&eNB->ifdevice, + ×tamp_mobipass[packet_id], + (void**)&rx_buffer, + db_fulllength, + 1 + ); +#ifdef DEBUG_UL_MOBIPASS + if (((proc->timestamp_tx + lower_offset) > ntohl(timestamp_mobipass[packet_id])) || ((proc->timestamp_tx + upper_offset) < ntohl(timestamp_mobipass[packet_id]))) { + //ignore the packet + subframe_skip_extra = (subframe_skip_extra + 1)%67; + LOG_D("[Mobipass] ignored packet, id:[%d,%d], proc->timestamp_tx:%llu, proc->timestamp_rx:%llu, seqno:%d\n", packet_id,subframe_skip_extra, proc->timestamp_tx, ntohl(timestamp_mobipass[packet_id]), header->seqno); + } +#endif + //skip SUBFRAME_SKIP_NUM_MOBIPASS additional UL packets + if ((start_flag == 1) && (subframe_skip < SUBFRAME_SKIP_NUM_MOBIPASS)){ + subframe_skip++; + offset_cnt = header->seqno; + } else { + if ((offset_cnt != header->seqno) && (start_flag == 0) && (proc->first_rx > 3)){ +#ifdef DEBUG_UL_MOBIPASS + LOG_D(PHY,"[Mobipass] Reset sequence number, offset_cnt:%d, header->seqno:%d, packet_id:%d\n", offset_cnt, header->seqno, packet_id); +#endif + reset_flag=1; + } + if ((reset_flag == 1) && (proc->first_rx > 3 ) && (start_flag == 0) && (packet_id == 0)) { + packet_id = 1; + reset_flag = 0; + } + start_flag = 0; + + //store rxdata and increase packet_id + rxp[0] = (void*)&eNB->common_vars.rxdata[0][0][(subframe*eNB->frame_parms.samples_per_tti)+packet_id*db_fulllength]; + rxp128 = (__m128i *) (rxp[0]); + for (i=0; i>2; i+=2) { + r0 = _mm_loadu_si128(data_block++); + *rxp128++ =_mm_slli_epi16(_mm_srai_epi16(_mm_unpacklo_epi8(r0,r0),8),4); + *rxp128++ =_mm_slli_epi16(_mm_srai_epi16(_mm_unpackhi_epi8(r0,r0),8),4); + } + packet_id++; + offset_cnt = (header->seqno+1)&255; + } + }//end while + + *proc_timestamp = ntohl(timestamp_mobipass[0]); +#ifdef DEBUG_UL_MOBIPASS + LOG_I(PHY,"[Mobipass][Recv_MOBIPASS] timestamp: %llu\n ", *proc_timestamp); +if (eNB->CC_id>0) { + rxe = dB_fixed(signal_energy(rxp[0],fp->samples_per_tti)); + if (rxe > 0){ + LOG_I(PHY,"[Mobipass] frame:%d, subframe:%d, energy %d\n", (*proc_timestamp/(10*fp->samples_per_tti))&1023,subframe, rxe); +// write_output("rxsigmb.m","rxs",(void*)dummy_buffer_rx, fp->samples_per_tti,1, 5); +// exit(-1); + } +} +#endif + + + } else { AssertFatal(1==0, "recv_IF5 - Unknown packet_type %x", packet_type); } diff --git a/openair1/PHY/LTE_TRANSPORT/initial_sync.c b/openair1/PHY/LTE_TRANSPORT/initial_sync.c index 75c558f52cba6042ce5249c83aae7924cc5fe513..c29562b6cdbc3e40cce3d0d8f54515f12368dd88 100644 --- a/openair1/PHY/LTE_TRANSPORT/initial_sync.c +++ b/openair1/PHY/LTE_TRANSPORT/initial_sync.c @@ -83,12 +83,12 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode) lte_ue_measurements(ue, ue->rx_offset, 0, - 0); + 0,0); if (ue->frame_parms.frame_type == TDD) { ue_rrc_measurements(ue, - 1, + 2, 0); } else { diff --git a/openair1/PHY/LTE_TRANSPORT/pbch.c b/openair1/PHY/LTE_TRANSPORT/pbch.c index 8f6489861bcbba82daa2599e3927b86076be4fd9..e28e179b07a3b21bee4b60e6005d5d19a1617312 100644 --- a/openair1/PHY/LTE_TRANSPORT/pbch.c +++ b/openair1/PHY/LTE_TRANSPORT/pbch.c @@ -900,8 +900,8 @@ uint16_t rx_pbch(LTE_UE_COMMON *lte_ue_common_vars, #ifdef DEBUG_PBCH msg("[PBCH] starting extract\n"); #endif - pbch_extract(lte_ue_common_vars->rxdataF, - lte_ue_common_vars->dl_ch_estimates[eNB_id], + pbch_extract(lte_ue_common_vars->common_vars_rx_data_per_thread[0].rxdataF, + lte_ue_common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates[eNB_id], lte_ue_pbch_vars->rxdataF_ext, lte_ue_pbch_vars->dl_ch_estimates_ext, symbol, diff --git a/openair1/PHY/LTE_TRANSPORT/pcfich.c b/openair1/PHY/LTE_TRANSPORT/pcfich.c index 08a3d80904fb886948898cd227f45842f0e56d42..3b141372f03dd0e12e7077c69903c0033862b9e2 100644 --- a/openair1/PHY/LTE_TRANSPORT/pcfich.c +++ b/openair1/PHY/LTE_TRANSPORT/pcfich.c @@ -191,7 +191,7 @@ void generate_pcfich(uint8_t num_pdcch_symbols, // mapping nsymb = (frame_parms->Ncp==0) ? 14:12; - symbol_offset = (uint32_t)frame_parms->ofdm_symbol_size*((subframe*nsymb)); + symbol_offset = (uint32_t)frame_parms->ofdm_symbol_size*(subframe*nsymb); re_offset = frame_parms->first_carrier_offset; // loop over 4 quadruplets and lookup REGs diff --git a/openair1/PHY/LTE_TRANSPORT/phich.c b/openair1/PHY/LTE_TRANSPORT/phich.c index 989567ca3498d075237a8b50982460748ab7cf69..b46c4167061a35147a9f3d8a94d3b83d89a5f39f 100644 --- a/openair1/PHY/LTE_TRANSPORT/phich.c +++ b/openair1/PHY/LTE_TRANSPORT/phich.c @@ -142,125 +142,134 @@ unsigned char subframe2_ul_harq(LTE_DL_FRAME_PARMS *frame_parms,unsigned char su uint8_t phich_frame2_pusch_frame(LTE_DL_FRAME_PARMS *frame_parms,frame_t frame,uint8_t subframe) { + uint8_t pusch_frame = 255; if (frame_parms->frame_type == FDD) { - return((subframe<4) ? (frame - 1) : frame); + pusch_frame = ((subframe<4) ? (frame - 1) : frame); } else { // Note this is not true, but it doesn't matter, the frame number is irrelevant for TDD! - return(frame); + pusch_frame = (frame); } + + LOG_D(PHY, "frame %d subframe %d: PUSCH frame = %d\n", frame, subframe, pusch_frame); + return pusch_frame; } uint8_t phich_subframe2_pusch_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t subframe) { + uint8_t pusch_subframe = 255; if (frame_parms->frame_type == FDD) - return(subframe<4 ? (subframe+6) : (subframe-4)); + return subframe < 4 ? subframe + 6 : subframe - 4; switch (frame_parms->tdd_config) { case 0: if (subframe == 0) - return(3); + pusch_subframe = (3); else if (subframe == 5) { - return (8); + pusch_subframe = (8); } else if (subframe == 6) - return (2); + pusch_subframe = (2); else if (subframe == 1) - return (7); + pusch_subframe = (7); else { LOG_E(PHY, "phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n", subframe,frame_parms->tdd_config); - return(0); + pusch_subframe = (0); } break; case 1: if (subframe == 6) - return(2); + pusch_subframe = (2); else if (subframe == 9) - return (3); + pusch_subframe = (3); else if (subframe == 1) - return (7); + pusch_subframe = (7); else if (subframe == 4) - return (8); + pusch_subframe = (8); else { LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n", subframe,frame_parms->tdd_config); - return(0); + pusch_subframe = (0); } break; case 2: if (subframe == 8) - return(2); + pusch_subframe = (2); else if (subframe == 3) - return (7); + pusch_subframe = (7); else { LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n", subframe,frame_parms->tdd_config); - return(0); + pusch_subframe = (0); } break; case 3: if ( (subframe == 8) || (subframe == 9) ) { - return(subframe-6); + pusch_subframe = (subframe-6); } else if (subframe==0) - return(4); + pusch_subframe = (4); else { LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n", subframe,frame_parms->tdd_config); - return(0); + pusch_subframe = (0); } break; case 4: if ( (subframe == 8) || (subframe == 9) ) { - return(subframe-6); + pusch_subframe = (subframe-6); } else { LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n", subframe,frame_parms->tdd_config); - return(0); + pusch_subframe = (0); } break; case 5: if (subframe == 8) { - return(2); + pusch_subframe = (2); } else { LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n", subframe,frame_parms->tdd_config); - return(0); + pusch_subframe = (0); } break; case 6: if (subframe == 6) { - return(2); + pusch_subframe = (2); } else if (subframe == 9) { - return(3); + pusch_subframe = (3); } else if (subframe == 0) { - return(4); + pusch_subframe = (4); } else if (subframe == 1) { - return(7); + pusch_subframe = (7); } else if (subframe == 5) { - return(8); + pusch_subframe = (8); } else { LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n", subframe,frame_parms->tdd_config); - return(0); + pusch_subframe = (0); } break; + default: + LOG_E(PHY, "no implementation for TDD UL/DL-config = %d!\n", frame_parms->tdd_config); + pusch_subframe = (0); } - return(0); + LOG_D(PHY, "subframe %d: PUSCH subframe = %d\n", subframe, pusch_subframe); + return pusch_subframe; } int check_pcfich(LTE_DL_FRAME_PARMS *frame_parms,uint16_t reg) @@ -1110,6 +1119,16 @@ void rx_phich(PHY_VARS_UE *ue, nseq_PHICH = ((ulsch->harq_processes[harq_pid]->first_rb/Ngroup_PHICH) + ulsch->harq_processes[harq_pid]->n_DMRS)%(2*NSF_PHICH); } else { + LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d subframe %d PHICH RX %s\n", + ue->Mod_id, + harq_pid, + proc->frame_rx, + subframe, + (ulsch->harq_processes[harq_pid]->status==SCH_IDLE? "SCH_IDLE" : + (ulsch->harq_processes[harq_pid]->status==ACTIVE? "ACTIVE" : + (ulsch->harq_processes[harq_pid]->status==CBA_ACTIVE? "CBA_ACTIVE": + (ulsch->harq_processes[harq_pid]->status==DISABLED? "DISABLED" : "UNKNOWN"))))); + return; } @@ -1374,13 +1393,13 @@ void rx_phich(PHY_VARS_UE *ue, } } else { //#ifdef DEBUG_PHICH - LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d subframe %d PHICH, received NAK (%d) nseq %d, ngroup %d\n", + LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d subframe %d PHICH, received NAK (%d) nseq %d, ngroup %d (Mlimit %d)\n", ue->Mod_id,harq_pid, - proc->frame_rx, + proc->frame_rx%1024, subframe, HI16, nseq_PHICH, - ngroup_PHICH, + ngroup_PHICH,ulsch->harq_processes[harq_pid]->round+1, ulsch->Mlimit); //#endif @@ -1414,7 +1433,10 @@ void rx_phich(PHY_VARS_UE *ue, //LOG_I(PHY,"[HARQ-UL harqId: %d] PHICH NACK ==> subframe_scheduling_flag = %d round: %d\n", harq_pid, ulsch->harq_processes[harq_pid]->subframe_scheduling_flag,ulsch->harq_processes[harq_pid]->round); } } - +#if T_TRACER + T(T_UE_PHY_ULSCH_UE_NACK, T_INT(eNB_id), T_INT(proc->frame_rx%1024), T_INT(subframe), T_INT(ue->Mod_id), T_INT(ulsch->rnti), + T_INT(harq_pid)); +#endif } else { //ACK if (ue->ulsch_Msg3_active[eNB_id] == 1) { @@ -1428,7 +1450,7 @@ void rx_phich(PHY_VARS_UE *ue, //#ifdef PHICH_DEBUG LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d subframe %d PHICH, received ACK (%d) nseq %d, ngroup %d\n\n", ue->Mod_id,harq_pid, - proc->frame_rx, + proc->frame_rx%1024, subframe, HI16, nseq_PHICH,ngroup_PHICH); //#endif @@ -1449,7 +1471,11 @@ void rx_phich(PHY_VARS_UE *ue, // inform MAC? ue->ulsch_Msg3_active[eNB_id] = 0; - //LOG_I(PHY,"[HARQ-UL harqId: %d] PHICH ACK ==> subframe_scheduling_flag = %d round: %d\n", harq_pid, ulsch->harq_processes[harq_pid]->subframe_scheduling_flag, ulsch->harq_processes[harq_pid]->round); +#if T_TRACER + T(T_UE_PHY_ULSCH_UE_ACK, T_INT(eNB_id), T_INT(proc->frame_rx%1024), T_INT(subframe), T_INT(ue->Mod_id), T_INT(ulsch->rnti), + T_INT(harq_pid)); +#endif + } } diff --git a/openair1/PHY/LTE_TRANSPORT/pmch.c b/openair1/PHY/LTE_TRANSPORT/pmch.c index 1a2838e5cfa3aa86839c9a56e4f4ed95dc60e8c9..3bd327588316856414ef781e1bf5fc9ff5b48767 100644 --- a/openair1/PHY/LTE_TRANSPORT/pmch.c +++ b/openair1/PHY/LTE_TRANSPORT/pmch.c @@ -74,7 +74,7 @@ void dump_mch(PHY_VARS_UE *ue,uint8_t eNB_id,uint16_t coded_bits_per_codeword,in write_output(fname,vname,ue->pdsch_vars_MCH[eNB_id]->dl_ch_magb0[0],12*N_RB_DL*nsymb_pmch,1,1); write_output("mch00_ch0.m","pmch00_ch0", - &(ue->common_vars.dl_ch_estimates[eNB_id][0][0]), + &(ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][0][0]), ue->frame_parms.ofdm_symbol_size*12,1,1); write_output("rxsig_mch.m","rxs_mch", @@ -969,8 +969,8 @@ int rx_pmch(PHY_VARS_UE *ue, //printf("*********************mch: symbol %d\n",symbol); - mch_extract_rbs(common_vars->rxdataF, - common_vars->dl_ch_estimates[eNB_id], + mch_extract_rbs(common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF, + common_vars->common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id], pdsch_vars[eNB_id]->rxdataF_ext, pdsch_vars[eNB_id]->dl_ch_estimates_ext, symbol, diff --git a/openair1/PHY/LTE_TRANSPORT/prach.c b/openair1/PHY/LTE_TRANSPORT/prach.c index 33780a7defc05282a7f465088aa8c188a206b26f..489fdb0f71dae676914243a7d93c2ed59f4eb8eb 100644 --- a/openair1/PHY/LTE_TRANSPORT/prach.c +++ b/openair1/PHY/LTE_TRANSPORT/prach.c @@ -1185,9 +1185,7 @@ void rx_prach(PHY_VARS_eNB *eNB, break; } - if (eNB->frame_parms.threequarter_fs == 1) - Ncp=(Ncp*3)>>2; - + // Adjust CP length based on UL bandwidth switch (eNB->frame_parms.N_RB_UL) { case 6: Ncp>>=4; @@ -1208,6 +1206,11 @@ void rx_prach(PHY_VARS_eNB *eNB, case 75: Ncp=(Ncp*3)>>2; break; + + case 100: + if (eNB->frame_parms.threequarter_fs == 1) + Ncp=(Ncp*3)>>2; + break; } diff --git a/openair1/PHY/LTE_TRANSPORT/proto.h b/openair1/PHY/LTE_TRANSPORT/proto.h index 94aa21c7178362ace62b4161521e3f44472796e5..a9674ca21e44518062fb23822f1ca41b17404ad6 100644 --- a/openair1/PHY/LTE_TRANSPORT/proto.h +++ b/openair1/PHY/LTE_TRANSPORT/proto.h @@ -1138,6 +1138,7 @@ void dlsch_scale_channel(int32_t **dl_ch_estimates_ext, @param dlsch_llr Pointer to LLR values computed by dlsch_demodulation @param lte_frame_parms Pointer to frame descriptor @param dlsch Pointer to DLSCH descriptor + @param frame Frame number @param subframe Subframe number @param num_pdcch_symbols Number of PDCCH symbols @param is_crnti indicates if PDSCH belongs to a CRNTI (necessary for parallelizing decoding threads) @@ -1149,6 +1150,7 @@ uint32_t dlsch_decoding(PHY_VARS_UE *phy_vars_ue, LTE_DL_FRAME_PARMS *lte_frame_parms, LTE_UE_DLSCH_t *dlsch, LTE_DL_UE_HARQ_t *harq_process, + uint8_t frame, uint8_t subframe, uint8_t harq_pid, uint8_t is_crnti, @@ -1179,6 +1181,7 @@ int32_t rx_pdsch(PHY_VARS_UE *phy_vars_ue, PDSCH_t type, uint8_t eNB_id, uint8_t eNB_id_i, + uint32_t frame, uint8_t subframe, uint8_t symbol, uint8_t first_symbol_flag, @@ -1189,11 +1192,39 @@ int32_t rx_pdsch(PHY_VARS_UE *phy_vars_ue, int32_t rx_pdcch(LTE_UE_COMMON *lte_ue_common_vars, LTE_UE_PDCCH **lte_ue_pdcch_vars, LTE_DL_FRAME_PARMS *frame_parms, + uint32_t frame, uint8_t subframe, uint8_t eNB_id, MIMO_mode_t mimo_mode, uint32_t high_speed_flag, uint8_t is_secondary_ue); + +/*! \brief Extract PSS and SSS resource elements + @param phy_vars_ue Pointer to UE variables + @param[out] pss_ext contain the PSS signals after the extraction + @param[out] sss_ext contain the SSS signals after the extraction + @returns 0 on success +*/ +int pss_sss_extract(PHY_VARS_UE *phy_vars_ue, + int32_t pss_ext[4][72], + int32_t sss_ext[4][72]); + +/*! \brief Extract only PSS resource elements + @param phy_vars_ue Pointer to UE variables + @param[out] pss_ext contain the PSS signals after the extraction + @returns 0 on success +*/ +int pss_only_extract(PHY_VARS_UE *phy_vars_ue, + int32_t pss_ext[4][72]); + +/*! \brief Extract only SSS resource elements + @param phy_vars_ue Pointer to UE variables + @param[out] sss_ext contain the SSS signals after the extraction + @returns 0 on success +*/ +int sss_only_extract(PHY_VARS_UE *phy_vars_ue, + int32_t sss_ext[4][72]); + /*! \brief Performs detection of SSS to find cell ID and other framing parameters (FDD/TDD, normal/extended prefix) @param phy_vars_ue Pointer to UE variables @param tot_metric Pointer to variable containing maximum metric under framing hypothesis (to be compared to other hypotheses @@ -1499,7 +1530,8 @@ int generate_ue_dlsch_params_from_dci(int frame, uint16_t si_rnti, uint16_t ra_rnti, uint16_t p_rnti, - uint8_t beamforming_mode); + uint8_t beamforming_mode, + uint16_t tc_rnti); int32_t generate_eNB_dlsch_params_from_dci(int frame, uint8_t subframe, @@ -1538,7 +1570,8 @@ int32_t generate_ue_ulsch_params_from_rar(PHY_VARS_UE *phy_vars_ue, UE_rxtx_proc_t *proc, uint8_t eNB_id); double sinr_eff_cqi_calc(PHY_VARS_UE *phy_vars_ue, - uint8_t eNB_id); + uint8_t eNB_id, + uint8_t subframe); uint8_t sinr2cqi(double sinr,uint8_t trans_mode); diff --git a/openair1/PHY/LTE_TRANSPORT/pucch.c b/openair1/PHY/LTE_TRANSPORT/pucch.c index 34e64dfd5f74b325cbc68747c3e63b1962508cc0..db671f048c9d066c5413742e0b94ab51d6b37816 100644 --- a/openair1/PHY/LTE_TRANSPORT/pucch.c +++ b/openair1/PHY/LTE_TRANSPORT/pucch.c @@ -555,6 +555,7 @@ void generate_pucch2x(int32_t **txdataF, N_UL_symb = (fp->Ncp==0) ? 7 : 6; data_ind = 0; zptr = z; + nprime = 0; for (ns=(subframe<<1),u=u0,v=v0; ns<(2+(subframe<<1)); ns++,u=u1,v=v1) { if ((ns&1) == 0) diff --git a/openair1/PHY/LTE_TRANSPORT/sss.c b/openair1/PHY/LTE_TRANSPORT/sss.c index 320d7ac75ad7604b964a075a58ae10b4ebda761b..85398edddba052105db304a77176aabe9987724a 100644 --- a/openair1/PHY/LTE_TRANSPORT/sss.c +++ b/openair1/PHY/LTE_TRANSPORT/sss.c @@ -146,9 +146,10 @@ int pss_ch_est(PHY_VARS_UE *ue, } -int pss_sss_extract(PHY_VARS_UE *ue, +int _do_pss_sss_extract(PHY_VARS_UE *ue, int32_t pss_ext[4][72], - int32_t sss_ext[4][72]) + int32_t sss_ext[4][72], + uint8_t doPss, uint8_t doSss) // add flag to indicate extracting only PSS, only SSS, or both { @@ -162,7 +163,7 @@ int pss_sss_extract(PHY_VARS_UE *ue, int rx_offset = frame_parms->ofdm_symbol_size-3*12; uint8_t pss_symb,sss_symb; - int32_t **rxdataF = ue->common_vars.rxdataF; + int32_t **rxdataF = ue->common_vars.common_vars_rx_data_per_thread[0].rxdataF; if (frame_parms->frame_type == FDD) { pss_symb = 6-frame_parms->Ncp; @@ -191,8 +192,8 @@ int pss_sss_extract(PHY_VARS_UE *ue, } for (i=0; i<12; i++) { - pss_rxF_ext[i]=pss_rxF[i]; - sss_rxF_ext[i]=sss_rxF[i]; + if (doPss) {pss_rxF_ext[i]=pss_rxF[i];} + if (doSss) {sss_rxF_ext[i]=sss_rxF[i];} } pss_rxF+=12; @@ -206,6 +207,28 @@ int pss_sss_extract(PHY_VARS_UE *ue, return(0); } +int pss_sss_extract(PHY_VARS_UE *phy_vars_ue, + int32_t pss_ext[4][72], + int32_t sss_ext[4][72]) +{ + return _do_pss_sss_extract(phy_vars_ue, pss_ext, sss_ext, 1 /* doPss */, 1 /* doSss */); +} + +int pss_only_extract(PHY_VARS_UE *phy_vars_ue, + int32_t pss_ext[4][72]) +{ + static int32_t dummy[4][72]; + return _do_pss_sss_extract(phy_vars_ue, pss_ext, dummy, 1 /* doPss */, 0 /* doSss */); +} + + +int sss_only_extract(PHY_VARS_UE *phy_vars_ue, + int32_t sss_ext[4][72]) +{ + static int32_t dummy[4][72]; + return _do_pss_sss_extract(phy_vars_ue, dummy, sss_ext, 0 /* doPss */, 1 /* doSss */); +} + int16_t phase_re[7] = {16383, 25101, 30791, 32767, 30791, 25101, 16383}; int16_t phase_im[7] = {-28378, -21063, -11208, 0, 11207, 21062, 28377}; diff --git a/openair1/PHY/LTE_TRANSPORT/uci_tools.c b/openair1/PHY/LTE_TRANSPORT/uci_tools.c index 37c5dc1432ef818de613c74f757880b5754409d8..467b1bbc9a82824aa25d4f198a634584d2063608 100644 --- a/openair1/PHY/LTE_TRANSPORT/uci_tools.c +++ b/openair1/PHY/LTE_TRANSPORT/uci_tools.c @@ -581,6 +581,7 @@ void print_CQI(void *o,UCI_format_t uci_format,unsigned char eNB_id,int N_RB_DL) switch(uci_format) { case wideband_cqi_rank1_2A: #ifdef DEBUG_UCI + LOG_D(PHY,"[PRINT CQI] flat_LA %d\n", flag_LA); switch(N_RB_DL) { case 6: LOG_I(PHY,"[PRINT CQI] wideband_cqi rank 1: eNB %d, cqi %d\n",eNB_id, diff --git a/openair1/PHY/LTE_TRANSPORT/ulsch_coding.c b/openair1/PHY/LTE_TRANSPORT/ulsch_coding.c index 4559aaa326bd620137d0e6184db2b0cd222c6757..9571ea6cd52823d8409a2781bdd1c2ab5fc7c6e4 100644 --- a/openair1/PHY/LTE_TRANSPORT/ulsch_coding.c +++ b/openair1/PHY/LTE_TRANSPORT/ulsch_coding.c @@ -190,7 +190,7 @@ LTE_UE_ULSCH_t *new_ue_ulsch(unsigned char N_RB_UL, uint8_t abstraction_flag) return(ulsch); } - LOG_E(PHY,"new_ue_ulsch exit flag, size of %d , %d\n",exit_flag, sizeof(LTE_UE_ULSCH_t)); + LOG_E(PHY,"new_ue_ulsch exit flag, size of %d , %zu\n",exit_flag, sizeof(LTE_UE_ULSCH_t)); free_ue_ulsch(ulsch); return(NULL); @@ -234,7 +234,7 @@ uint32_t ulsch_encoding(uint8_t *a, PHY_MEASUREMENTS *meas = &ue->measurements; LTE_UE_ULSCH_t *ulsch=ue->ulsch[eNB_id]; LTE_UE_DLSCH_t **dlsch = ue->dlsch[eNB_id]; - uint16_t rnti; + uint16_t rnti = 0xffff; if (!ulsch) { LOG_E(PHY,"Null ulsch ptr %p\n",ulsch); @@ -260,6 +260,7 @@ uint32_t ulsch_encoding(uint8_t *a, // fill CQI/PMI information if (ulsch->O>0) { + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ULSCH_ENCODING_FILL_CQI, VCD_FUNCTION_IN); rnti = ue->pdcch_vars[eNB_id]->crnti; fill_CQI(ulsch,meas,0,harq_pid,ue->frame_parms.N_RB_DL,rnti, tmode,ue->sinr_eff); @@ -271,6 +272,7 @@ uint32_t ulsch_encoding(uint8_t *a, //LOG_I(PHY,"XXX saving pmi for DL %x\n",pmi2hex_2Ar1(((wideband_cqi_rank1_2A_5MHz *)ulsch->o)->pmi)); dlsch[0]->pmi_alloc = ((wideband_cqi_rank1_2A_5MHz *)ulsch->o)->pmi; } + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ULSCH_ENCODING_FILL_CQI, VCD_FUNCTION_OUT); } if (ulsch->O<=32) { @@ -469,6 +471,16 @@ uint32_t ulsch_encoding(uint8_t *a, Q_ACK = Qprime * Q_m; Qprime_ACK = Qprime; + LOG_D(PHY,"UE (%x/%d) O_ACK %d, Mcs_initial %d, Nsymb_initial %d, beta_offset_harqack*8 %d, sum Kr %d, Qprime_ACK %d, Q_ACK %d\n", + rnti, harq_pid, + ulsch->harq_processes[harq_pid]->O_ACK, + ulsch->harq_processes[harq_pid]->Msc_initial, + ulsch->harq_processes[harq_pid]->Nsymb_initial, + ulsch->beta_offset_harqack_times8, + sumKr, + Qprime_ACK, + Q_ACK); + // Compute Q_cqi, assume O>11, p. 26 36-212 if (control_only_flag == 0) { diff --git a/openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c b/openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c index 68f3abc094cfa6aa06a2434e4516b882ea2a3238..8edb1eaf9460443a4ebe58ceba7776c42a696ad2 100644 --- a/openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c +++ b/openair1/PHY/LTE_TRANSPORT/ulsch_decoding.c @@ -1440,7 +1440,7 @@ unsigned int ulsch_decoding(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, j2+=Q_m; } - + /* To be improved according to alignment of j2 #if defined(__x86_64__)||defined(__i386__) #ifndef __AVX2__ for (iprime=0; iprimee[iprime]) = *((int16x8_t *)&y[j2]); -#endif +#endif + */ + int16_t *yp,*ep; + for (iprime=0,yp=&y[j2],ep=&ulsch_harq->e[0]; + iprimeulsch_demultiplexing_stats); // printf("after ACKNAK2 c[%d] = %p (iprime %d, G %d)\n",0,ulsch_harq->c[0],iprime,G); diff --git a/openair1/PHY/MODULATION/beamforming.c b/openair1/PHY/MODULATION/beamforming.c index 6557a47ee7a35c6d31ea267cdb7762c0ffede9d5..88ac12b0a711a71bac32e18f0de528cfccd425f5 100644 --- a/openair1/PHY/MODULATION/beamforming.c +++ b/openair1/PHY/MODULATION/beamforming.c @@ -63,28 +63,30 @@ int beam_precoding(int32_t **txdataF, // clear txdata_BF[aa][re] for each call of ue_spec_beamforming memset(txdataF_BF[aa],0,sizeof(int32_t)*(frame_parms->ofdm_symbol_size)); - for (p=0; p<14; p++) { - //if (p==0 || p==1 || p==5 || p>7) - // mult_cpx_conj_vector((int16_t*)txdataF[p], (int16_t*)beam_weights[p][aa], (int16_t*)txdataF_BF[aa], frame_parms->ofdm_symbol_size, 15); - for (re=0;reofdm_symbol_size;re++) { - if ((p==0 || p==1 || p==5 || p>=7) && txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re]!=0) { - ((int16_t*)&txdataF_BF[aa][re])[0] += (int16_t)((((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[0]*((int16_t*)&beam_weights[p][aa][re])[0])>>15); - ((int16_t*)&txdataF_BF[aa][re])[0] -= (int16_t)((((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[1]*((int16_t*)&beam_weights[p][aa][re])[1])>>15); - ((int16_t*)&txdataF_BF[aa][re])[1] += (int16_t)((((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[0]*((int16_t*)&beam_weights[p][aa][re])[1])>>15); - ((int16_t*)&txdataF_BF[aa][re])[1] += (int16_t)((((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[1]*((int16_t*)&beam_weights[p][aa][re])[0])>>15); + for (p=0; pnb_antenna_ports_eNB || p==5) { + multadd_cpx_vector((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size],(int16_t*)beam_weights[p][aa], (int16_t*)txdataF_BF[aa], 0, frame_parms->ofdm_symbol_size, 15); + //mult_cpx_conj_vector((int16_t*)beam_weights[p][aa], (int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size], (int16_t*)txdataF_BF[aa], frame_parms->ofdm_symbol_size, 15, 1); - /* - printf("beamforming.c:txdataF[%d][%d]=%d+j%d, beam_weights[%d][%d][%d]=%d+j%d,txdata_BF[%d][%d]=%d+j%d\n", - p,slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re, - ((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[0], - ((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[1], - p,aa,re, - ((int16_t*)&beam_weights[p][aa][re])[0],((int16_t*)&beam_weights[p][aa][re])[1], - aa,re, - ((int16_t*)&txdataF_BF[aa][re])[0], - ((int16_t*)&txdataF_BF[aa][re])[1]); - */ - } + // if check version + /*for (re=0;reofdm_symbol_size;re++) { + if (txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re]!=0) { + ((int16_t*)&txdataF_BF[aa][re])[0] += (int16_t)((((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[0]*((int16_t*)&beam_weights[p][aa][re])[0])>>15); + ((int16_t*)&txdataF_BF[aa][re])[0] -= (int16_t)((((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[1]*((int16_t*)&beam_weights[p][aa][re])[1])>>15); + ((int16_t*)&txdataF_BF[aa][re])[1] += (int16_t)((((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[0]*((int16_t*)&beam_weights[p][aa][re])[1])>>15); + ((int16_t*)&txdataF_BF[aa][re])[1] += (int16_t)((((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[1]*((int16_t*)&beam_weights[p][aa][re])[0])>>15); + + printf("beamforming.c:txdataF[%d][%d]=%d+j%d, beam_weights[%d][%d][%d]=%d+j%d,txdata_BF[%d][%d]=%d+j%d\n", + p,slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re, + ((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[0], + ((int16_t*)&txdataF[p][slot_offset_F+symbol*frame_parms->ofdm_symbol_size+re])[1], + p,aa,re, + ((int16_t*)&beam_weights[p][aa][re])[0],((int16_t*)&beam_weights[p][aa][re])[1], + aa,re, + ((int16_t*)&txdataF_BF[aa][re])[0], + ((int16_t*)&txdataF_BF[aa][re])[1]); + } + }*/ } } return 0; diff --git a/openair1/PHY/MODULATION/compute_bf_weights.c b/openair1/PHY/MODULATION/compute_bf_weights.c index 32a91c11f50706718e3c75823ec48a67c6d9806c..4ef8e88ca6652433efbad3ce761463bd41836325 100644 --- a/openair1/PHY/MODULATION/compute_bf_weights.c +++ b/openair1/PHY/MODULATION/compute_bf_weights.c @@ -1,11 +1,12 @@ #include #include +#include #include "PHY/impl_defs_lte.h" int f_read(char *calibF_fname, int nb_ant, int nb_freq, int32_t **tdd_calib_coeffs){ FILE *calibF_fd; - int i,j,l,calibF_e; + int i,j,calibF_e; calibF_fd = fopen(calibF_fname,"r"); @@ -14,7 +15,7 @@ int f_read(char *calibF_fname, int nb_ant, int nb_freq, int32_t **tdd_calib_coef for(i=0;itxdataF[eNB_id]; + int aa, l, slot_offset, slot_offsetF; + int32_t **txdataF = eNB_common_vars->txdataF[eNB_id]; int32_t **txdataF_BF = eNB_common_vars->txdataF_BF[eNB_id]; - int32_t **txdata = eNB_common_vars->txdata[eNB_id]; - - slot_offset = (next_slot)*(frame_parms->samples_per_tti>>1); + int32_t **txdata = eNB_common_vars->txdata[eNB_id]; + slot_offset = (next_slot)*(frame_parms->samples_per_tti>>1); + slot_offsetF = (next_slot)*(frame_parms->ofdm_symbol_size)*((frame_parms->Ncp==EXTENDED) ? 6 : 7); //printf("Thread %d starting ... aa %d (%llu)\n",omp_get_thread_num(),aa,rdtsc()); for (l=0; lsymbols_per_tti>>1; l++) { @@ -302,13 +300,13 @@ void do_OFDM_mod_symbol(LTE_eNB_COMMON *eNB_common_vars, int eNB_id, uint16_t ne //printf("do_OFDM_mod_l, slot=%d, l=%d, NUMBER_OF_OFDM_CARRIERS=%d,OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES=%d\n",next_slot, l,NUMBER_OF_OFDM_CARRIERS,OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_BEAM_PRECODING,1); - beam_precoding(txdataF,txdataF_BF,frame_parms,eNB_common_vars->beam_weights[eNB_id],next_slot,l,aa); + if (do_precoding==1) beam_precoding(txdataF,txdataF_BF,frame_parms,eNB_common_vars->beam_weights[eNB_id],next_slot,l,aa); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_BEAM_PRECODING,0); //PMCH case not implemented... - if (frame_parms->Ncp == 1) - PHY_ofdm_mod(txdataF_BF[aa], // input + if (frame_parms->Ncp == EXTENDED) + PHY_ofdm_mod((do_precoding == 1)?txdataF_BF[aa]:&txdataF[aa][slot_offsetF+l*frame_parms->ofdm_symbol_size], // input &txdata[aa][slot_offset+l*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES], // output frame_parms->ofdm_symbol_size, 1, // number of symbols @@ -316,7 +314,7 @@ void do_OFDM_mod_symbol(LTE_eNB_COMMON *eNB_common_vars, int eNB_id, uint16_t ne CYCLIC_PREFIX); else { if (l==0) { - PHY_ofdm_mod(txdataF_BF[aa], // input + PHY_ofdm_mod((do_precoding==1)?txdataF_BF[aa]:&txdataF[aa][slot_offsetF+l*frame_parms->ofdm_symbol_size], // input &txdata[aa][slot_offset], // output frame_parms->ofdm_symbol_size, 1, // number of symbols @@ -324,7 +322,7 @@ void do_OFDM_mod_symbol(LTE_eNB_COMMON *eNB_common_vars, int eNB_id, uint16_t ne CYCLIC_PREFIX); } else { - PHY_ofdm_mod(txdataF_BF[aa], // input + PHY_ofdm_mod((do_precoding==1)?txdataF_BF[aa]:&txdataF[aa][slot_offsetF+l*frame_parms->ofdm_symbol_size], // input &txdata[aa][slot_offset+OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES0+(l-1)*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES], // output frame_parms->ofdm_symbol_size, 1, // number of symbols diff --git a/openair1/PHY/MODULATION/slot_fep.c b/openair1/PHY/MODULATION/slot_fep.c index 94de0d3cbcae958fc5fd50d99186736a2f209973..3a3b3b4c0d48ed810ba7c1236314b7e994c2a24f 100644 --- a/openair1/PHY/MODULATION/slot_fep.c +++ b/openair1/PHY/MODULATION/slot_fep.c @@ -109,18 +109,12 @@ int slot_fep(PHY_VARS_UE *ue, for (aa=0; aanb_antennas_rx; aa++) { - memset(&common_vars->rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],0,frame_parms->ofdm_symbol_size*sizeof(int)); + memset(&common_vars->common_vars_rx_data_per_thread[(Ns>>1)&0x1].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],0,frame_parms->ofdm_symbol_size*sizeof(int)); rx_offset = sample_offset + slot_offset + nb_prefix_samples0 + subframe_offset - SOFFSET; // Align with 256 bit // rx_offset = rx_offset&0xfffffff8; -#ifdef DEBUG_FEP - // if (ue->frame <100) - printf("slot_fep: frame %d: slot %d, symbol %d, nb_prefix_samples %d, nb_prefix_samples0 %d, slot_offset %d, subframe_offset %d, sample_offset %d,rx_offset %d\n", ue->proc.proc_rxtx[(Ns>>1)&1].frame_rx,Ns, symbol, - nb_prefix_samples,nb_prefix_samples0,slot_offset,subframe_offset,sample_offset,rx_offset); -#endif - if (l==0) { if (rx_offset > (frame_length_samples - frame_parms->ofdm_symbol_size)) @@ -133,12 +127,12 @@ int slot_fep(PHY_VARS_UE *ue, (void *)&common_vars->rxdata[aa][rx_offset % frame_length_samples], frame_parms->ofdm_symbol_size*sizeof(int)); dft((int16_t *)tmp_dft_in, - (int16_t *)&common_vars->rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1); + (int16_t *)&common_vars->common_vars_rx_data_per_thread[(Ns>>1)&0x1].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1); } else { // use dft input from RX buffer directly start_meas(&ue->rx_dft_stats); dft((int16_t *)&common_vars->rxdata[aa][(rx_offset) % frame_length_samples], - (int16_t *)&common_vars->rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1); + (int16_t *)&common_vars->common_vars_rx_data_per_thread[(Ns>>1)&0x1].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1); stop_meas(&ue->rx_dft_stats); } @@ -148,8 +142,8 @@ int slot_fep(PHY_VARS_UE *ue, #ifdef DEBUG_FEP // if (ue->frame <100) - printf("slot_fep: frame %d: slot %d, symbol %d, nb_prefix_samples %d, nb_prefix_samples0 %d, slot_offset %d, subframe_offset %d, sample_offset %d,rx_offset %d\n", ue->proc.proc_rxtx[(Ns>>1)&1].frame_rx,Ns, symbol, - nb_prefix_samples,nb_prefix_samples0,slot_offset,subframe_offset,sample_offset,rx_offset); + LOG_I(PHY,"slot_fep: frame %d: slot %d, symbol %d, nb_prefix_samples %d, nb_prefix_samples0 %d, slot_offset %d, subframe_offset %d, sample_offset %d,rx_offset %d, frame_length_samples %d\n", ue->proc.proc_rxtx[(Ns>>1)&1].frame_rx,Ns, symbol, + nb_prefix_samples,nb_prefix_samples0,slot_offset,subframe_offset,sample_offset,rx_offset,frame_length_samples); #endif if (rx_offset > (frame_length_samples - frame_parms->ofdm_symbol_size)) @@ -164,11 +158,11 @@ int slot_fep(PHY_VARS_UE *ue, (void *)&common_vars->rxdata[aa][(rx_offset) % frame_length_samples], frame_parms->ofdm_symbol_size*sizeof(int)); dft((int16_t *)tmp_dft_in, - (int16_t *)&common_vars->rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1); + (int16_t *)&common_vars->common_vars_rx_data_per_thread[(Ns>>1)&0x1].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1); } else { // use dft input from RX buffer directly dft((int16_t *)&common_vars->rxdata[aa][(rx_offset) % frame_length_samples], - (int16_t *)&common_vars->rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1); + (int16_t *)&common_vars->common_vars_rx_data_per_thread[(Ns>>1)&0x1].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1); } stop_meas(&ue->rx_dft_stats); @@ -176,6 +170,10 @@ int slot_fep(PHY_VARS_UE *ue, } + #ifdef DEBUG_FEP + // if (ue->frame <100) + printf("slot_fep: frame %d: symbol %d rx_offset %d\n", ue->proc.proc_rxtx[(Ns>>1)&1].frame_rx, symbol,rx_offset); + #endif } if (ue->perfect_ce == 0) { @@ -211,7 +209,7 @@ int slot_fep(PHY_VARS_UE *ue, if (l==(4-frame_parms->Ncp)) { start_meas(&ue->dlsch_freq_offset_estimation_stats); - lte_est_freq_offset(common_vars->dl_ch_estimates[0], + lte_est_freq_offset(common_vars->common_vars_rx_data_per_thread[(Ns>>1)&0x1].dl_ch_estimates[0], frame_parms, l, &common_vars->freq_offset, diff --git a/openair1/PHY/MODULATION/slot_fep_mbsfn.c b/openair1/PHY/MODULATION/slot_fep_mbsfn.c index 850ea47916d62fcc52ba9184caf84fc36ae707b5..bead242dd8b9608a53e83a44fd9bec00aaaa1fcb 100644 --- a/openair1/PHY/MODULATION/slot_fep_mbsfn.c +++ b/openair1/PHY/MODULATION/slot_fep_mbsfn.c @@ -109,14 +109,14 @@ int slot_fep_mbsfn(PHY_VARS_UE *ue, #endif for (aa=0; aanb_antennas_rx; aa++) { - memset(&common_vars->rxdataF[aa][frame_parms->ofdm_symbol_size*l],0,frame_parms->ofdm_symbol_size*sizeof(int)); + memset(&common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aa][frame_parms->ofdm_symbol_size*l],0,frame_parms->ofdm_symbol_size*sizeof(int)); if (l==0) { start_meas(&ue->rx_dft_stats); dft((int16_t *)&common_vars->rxdata[aa][(sample_offset + nb_prefix_samples0 + subframe_offset - SOFFSET) % frame_length_samples], - (int16_t *)&common_vars->rxdataF[aa][frame_parms->ofdm_symbol_size*l],1); + (int16_t *)&common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aa][frame_parms->ofdm_symbol_size*l],1); stop_meas(&ue->rx_dft_stats); } else { if ((sample_offset + @@ -134,7 +134,7 @@ int slot_fep_mbsfn(PHY_VARS_UE *ue, (frame_parms->ofdm_symbol_size+nb_prefix_samples)*(l-1) + subframe_offset- SOFFSET) % frame_length_samples], - (int16_t *)&common_vars->rxdataF[aa][frame_parms->ofdm_symbol_size*l],1); + (int16_t *)&common_vars->common_vars_rx_data_per_thread[subframe&0x1].rxdataF[aa][frame_parms->ofdm_symbol_size*l],1); stop_meas(&ue->rx_dft_stats); } } diff --git a/openair1/PHY/MODULATION/slot_fep_ul.c b/openair1/PHY/MODULATION/slot_fep_ul.c index b0798965807c1a8ac8511f775fded7dd2bff0615..e05f5361de0d21de4e198d91e6c5c34c724e475c 100644 --- a/openair1/PHY/MODULATION/slot_fep_ul.c +++ b/openair1/PHY/MODULATION/slot_fep_ul.c @@ -79,10 +79,10 @@ int slot_fep_ul(LTE_DL_FRAME_PARMS *frame_parms, if (no_prefix) { // subframe_offset = frame_parms->ofdm_symbol_size * frame_parms->symbols_per_tti * (Ns>>1); - slot_offset = frame_parms->ofdm_symbol_size * (frame_parms->symbols_per_tti>>1) * (Ns%2); + slot_offset = frame_parms->ofdm_symbol_size * (frame_parms->symbols_per_tti>>1) * (Ns&1); } else { // subframe_offset = frame_parms->samples_per_tti * (Ns>>1); - slot_offset = (frame_parms->samples_per_tti>>1) * (Ns%2); + slot_offset = (frame_parms->samples_per_tti>>1) * (Ns&1); } if (l<0 || l>=7-frame_parms->Ncp) { @@ -108,18 +108,22 @@ int slot_fep_ul(LTE_DL_FRAME_PARMS *frame_parms, 1 ); } else { + rx_offset += (frame_parms->ofdm_symbol_size+nb_prefix_samples)*l; + /* should never happen for eNB if(rx_offset > (frame_length_samples - frame_parms->ofdm_symbol_size)) { memcpy((void *)&eNB_common_vars->rxdata_7_5kHz[eNB_id][aa][frame_length_samples], (void *)&eNB_common_vars->rxdata_7_5kHz[eNB_id][aa][0], frame_parms->ofdm_symbol_size*sizeof(int)); } + */ - if( (rx_offset & 7) != 0){ + // check for 256-bit alignment of input buffer and do DFT directly, else do via intermediate buffer + if( (rx_offset & 15) != 0){ memcpy((void *)&tmp_dft_in, - (void *)&eNB_common_vars->rxdata_7_5kHz[eNB_id][aa][(rx_offset % frame_length_samples)], - frame_parms->ofdm_symbol_size*sizeof(int)); + (void *)&eNB_common_vars->rxdata_7_5kHz[eNB_id][aa][(rx_offset % frame_length_samples)], + frame_parms->ofdm_symbol_size*sizeof(int)); dft( (short *) tmp_dft_in, (short*) &eNB_common_vars->rxdataF[eNB_id][aa][frame_parms->ofdm_symbol_size*symbol], 1 diff --git a/openair1/PHY/TOOLS/cmult_vv.c b/openair1/PHY/TOOLS/cmult_vv.c index cefa972061efb6d54b8eafe337e30094493d94d1..9d5079f52b6ad938e83d9f55762f01f515639a24 100644 --- a/openair1/PHY/TOOLS/cmult_vv.c +++ b/openair1/PHY/TOOLS/cmult_vv.c @@ -27,6 +27,7 @@ #if defined(__x86_64__) || defined(__i386__) int16_t conjug[8]__attribute__((aligned(16))) = {-1,1,-1,1,-1,1,-1,1} ; +int16_t conjug2[8]__attribute__((aligned(16))) = {1,-1,1,-1,1,-1,1,-1} ; #define simd_q15_t __m128i #define simdshort_q15_t __m64 #elif defined(__arm__) @@ -41,7 +42,8 @@ int mult_cpx_conj_vector(int16_t *x1, int16_t *x2, int16_t *y, uint32_t N, - int output_shift) + int output_shift, + int madd) { // Multiply elementwise the complex conjugate of x1 with x2. // x1 - input 1 in the format |Re0 Im0 Re1 Im1|,......,|Re(N-2) Im(N-2) Re(N-1) Im(N-1)| @@ -55,6 +57,8 @@ int mult_cpx_conj_vector(int16_t *x1, // N - the size f the vectors (this function does N cpx mpy. WARNING: N>=4; // // output_shift - shift to be applied to generate output + // + // madd - add the output to y uint32_t i; // loop counter @@ -88,7 +92,11 @@ int mult_cpx_conj_vector(int16_t *x1, tmp_im = _mm_srai_epi32(tmp_im,output_shift); tmpy0 = _mm_unpacklo_epi32(tmp_re,tmp_im); tmpy1 = _mm_unpackhi_epi32(tmp_re,tmp_im); - *y_128 = _mm_packs_epi32(tmpy0,tmpy1); + if (madd==0) + *y_128 = _mm_packs_epi32(tmpy0,tmpy1); + else + *y_128 += _mm_packs_epi32(tmpy0,tmpy1); + #elif defined(__arm__) tmp_re = vmull_s16(((simdshort_q15_t *)x1_128)[0], ((simdshort_q15_t*)x2_128)[0]); @@ -110,7 +118,10 @@ int mult_cpx_conj_vector(int16_t *x1, tmp_re = vqshlq_s32(tmp_re,shift); tmp_im = vqshlq_s32(tmp_im,shift); tmpy = vzip_s16(vmovn_s32(tmp_re),vmovn_s32(tmp_im)); - *y_128 = vcombine_s16(tmpy.val[0],tmpy.val[1]); + if (madd==0) + *y_128 = vcombine_s16(tmpy.val[0],tmpy.val[1]); + else + *y_128 += vcombine_s16(tmpy.val[0],tmpy.val[1]); #endif x1_128++; x2_128++; @@ -124,3 +135,81 @@ int mult_cpx_conj_vector(int16_t *x1, return(0); } +int multadd_cpx_vector(int16_t *x1, + int16_t *x2, + int16_t *y, + uint8_t zero_flag, + uint32_t N, + int output_shift) +{ + // Multiply elementwise the complex conjugate of x1 with x2. + // x1 - input 1 in the format |Re0 Im0 Re1 Im1|,......,|Re(N-2) Im(N-2) Re(N-1) Im(N-1)| + // We assume x1 with a dinamic of 15 bit maximum + // + // x2 - input 2 in the format |Re0 Im0 Re1 Im1|,......,|Re(N-2) Im(N-2) Re(N-1) Im(N-1)| + // We assume x2 with a dinamic of 14 bit maximum + /// + // y - output in the format |Re0 Im0 Re1 Im1|,......,|Re(N-2) Im(N-2) Re(N-1) Im(N-1)| + // + // zero_flag - Set output (y) to zero prior to disable accumulation + // + // N - the size f the vectors (this function does N cpx mpy. WARNING: N>=4; + // + // output_shift - shift to be applied to generate output + + uint32_t i; // loop counter + + simd_q15_t *x1_128; + simd_q15_t *x2_128; + simd_q15_t *y_128; +#if defined(__x86_64__) || defined(__i386__) + simd_q15_t tmp_re,tmp_im; + simd_q15_t tmpy0,tmpy1; +#elif defined(__arm__) + int32x4_t tmp_re,tmp_im; + int32x4_t tmp_re1,tmp_im1; + int16x4x2_t tmpy; + int32x4_t shift = vdupq_n_s32(-output_shift); +#endif + + x1_128 = (simd_q15_t *)&x1[0]; + x2_128 = (simd_q15_t *)&x2[0]; + y_128 = (simd_q15_t *)&y[0]; + + + // we compute 4 cpx multiply for each loop + for(i=0; i<(N>>2); i++) { +#if defined(__x86_64__) || defined(__i386__) + tmp_re = _mm_sign_epi16(*x1_128,*(__m128i*)&conjug2[0]); + tmp_re = _mm_madd_epi16(tmp_re,*x2_128); + tmp_im = _mm_shufflelo_epi16(*x1_128,_MM_SHUFFLE(2,3,0,1)); + tmp_im = _mm_shufflehi_epi16(tmp_im,_MM_SHUFFLE(2,3,0,1)); + tmp_im = _mm_madd_epi16(tmp_im,*x2_128); + tmp_re = _mm_srai_epi32(tmp_re,output_shift); + tmp_im = _mm_srai_epi32(tmp_im,output_shift); + tmpy0 = _mm_unpacklo_epi32(tmp_re,tmp_im); + //print_ints("unpack lo:",&tmpy0[i]); + tmpy1 = _mm_unpackhi_epi32(tmp_re,tmp_im); + //print_ints("unpack hi:",&tmpy1[i]); + + if (zero_flag == 1) + *y_128 = _mm_packs_epi32(tmpy0,tmpy1); + else + *y_128 = _mm_adds_epi16(*y_128,_mm_packs_epi32(tmpy0,tmpy1)); + //print_shorts("*y_128:",&y_128[i]); + +#elif defined(__arm__) + + msg("mult_cpx_vector not implemented for __arm__"); +#endif + x1_128++; + x2_128++; + y_128++; + } + + + _mm_empty(); + _m_empty(); + + return(0); +} diff --git a/openair1/PHY/TOOLS/defs.h b/openair1/PHY/TOOLS/defs.h index 453efc028a4bf94eb2c5cd0bd0752fd53c7574e7..8f0ae402bf62dfbebd7cfa06e2162486366b0e74 100644 --- a/openair1/PHY/TOOLS/defs.h +++ b/openair1/PHY/TOOLS/defs.h @@ -116,13 +116,34 @@ int rotate_cpx_vector(int16_t *x, @param y - output in the format |Re0 Im0 Re1 Im1|,......,|Re(N-2) Im(N-2) Re(N-1) Im(N-1)| @param N - the size f the vectors (this function does N cpx mpy. WARNING: N>=4; @param output_shift - shift to be applied to generate output + @param madd - if not zero result is added to output */ int mult_cpx_conj_vector(int16_t *x1, int16_t *x2, int16_t *y, uint32_t N, - int output_shift); + int output_shift, + int madd); + +/*! + Element-wise multiplication and accumulation of two complex vectors x1 and x2. + @param x1 - input 1 in the format |Re0 Im0 Re1 Im1|,......,|Re(N-2) Im(N-2) Re(N-1) Im(N-1)| + We assume x1 with a dinamic of 15 bit maximum + @param x2 - input 2 in the format |Re0 Im0 Re1 Im1|,......,|Re(N-2) Im(N-2) Re(N-1) Im(N-1)| + We assume x2 with a dinamic of 14 bit maximum + @param y - output in the format |Re0 Im0 Re1 Im1|,......,|Re(N-2) Im(N-2) Re(N-1) Im(N-1)| + @param zero_flag Set output (y) to zero prior to accumulation + @param N - the size f the vectors (this function does N cpx mpy. WARNING: N>=4; + @param output_shift - shift to be applied to generate output +*/ + +int multadd_cpx_vector(int16_t *x1, + int16_t *x2, + int16_t *y, + uint8_t zero_flag, + uint32_t N, + int output_shift); // lte_dfts.c void init_fft(uint16_t size, diff --git a/openair1/PHY/TOOLS/lte_phy_scope.c b/openair1/PHY/TOOLS/lte_phy_scope.c index 768dedddf548c9275605742c12b80acc61dcd324..bc67b2095c8de5248c4619a4ae13c4239790b9cd 100644 --- a/openair1/PHY/TOOLS/lte_phy_scope.c +++ b/openair1/PHY/TOOLS/lte_phy_scope.c @@ -559,15 +559,15 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form, bit_pdcch = (float*) calloc(12*frame_parms->N_RB_DL*num_pdcch_symbols*2,sizeof(float)); rxsig_t = (int16_t**) phy_vars_ue->common_vars.rxdata; - chest_t = (int16_t**) phy_vars_ue->common_vars.dl_ch_estimates_time[eNB_id]; - chest_f = (int16_t**) phy_vars_ue->common_vars.dl_ch_estimates[eNB_id]; + chest_t = (int16_t**) phy_vars_ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates_time[eNB_id]; + chest_f = (int16_t**) phy_vars_ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id]; pbch_llr = (int8_t*) phy_vars_ue->pbch_vars[eNB_id]->llr; pbch_comp = (int16_t*) phy_vars_ue->pbch_vars[eNB_id]->rxdataF_comp[0]; pdcch_llr = (int8_t*) phy_vars_ue->pdcch_vars[eNB_id]->llr; pdcch_comp = (int16_t*) phy_vars_ue->pdcch_vars[eNB_id]->rxdataF_comp[0]; - pdsch_llr = (int16_t*) phy_vars_ue->pdsch_vars[eNB_id]->llr[0]; // stream 0 + pdsch_llr = (int16_t*) phy_vars_ue->pdsch_vars[subframe&0x1][eNB_id]->llr[0]; // stream 0 // pdsch_llr = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars_SI[eNB_id]->llr[0]; // stream 0 - pdsch_comp = (int16_t*) phy_vars_ue->pdsch_vars[eNB_id]->rxdataF_comp0[0]; + pdsch_comp = (int16_t*) phy_vars_ue->pdsch_vars[subframe&0x1][eNB_id]->rxdataF_comp0[0]; // Received signal in time domain of receive antenna 0 if (rxsig_t != NULL) { diff --git a/openair1/PHY/defs.h b/openair1/PHY/defs.h index 9c72bc433ef621ff1619a8eb8e96d1c18b72ecb4..89da99460adfe156901bded4ac71097ea2ec50b4 100644 --- a/openair1/PHY/defs.h +++ b/openair1/PHY/defs.h @@ -241,10 +241,16 @@ typedef struct eNB_proc_t_s { openair0_timestamp timestamp_tx; /// subframe to act upon for reception int subframe_rx; + /// symbol mask for IF4p5 reception per subframe + uint32_t symbol_mask[10]; /// subframe to act upon for PRACH int subframe_prach; /// frame to act upon for reception int frame_rx; + /// frame to act upon for transmission + int frame_tx; + /// frame offset for secondary eNBs (to correct for frame asynchronism at startup) + int frame_offset; /// frame to act upon for PRACH int frame_prach; /// \internal This variable is protected by \ref mutex_fep. @@ -259,6 +265,8 @@ typedef struct eNB_proc_t_s { /// \brief Instance count for rx processing thread. /// \internal This variable is protected by \ref mutex_prach. int instance_cnt_prach; + // instance count for over-the-air eNB synchronization + int instance_cnt_synch; /// \internal This variable is protected by \ref mutex_asynch_rxtx. int instance_cnt_asynch_rxtx; /// pthread structure for FH processing thread @@ -283,6 +291,8 @@ typedef struct eNB_proc_t_s { pthread_attr_t attr_single; /// pthread attributes for prach processing thread pthread_attr_t attr_prach; + /// pthread attributes for over-the-air synch thread + pthread_attr_t attr_synch; /// pthread attributes for asynchronous RX thread pthread_attr_t attr_asynch_rxtx; /// scheduling parameters for parallel fep thread @@ -297,6 +307,8 @@ typedef struct eNB_proc_t_s { struct sched_param sched_param_single; /// scheduling parameters for prach thread struct sched_param sched_param_prach; + /// scheduling parameters for over-the-air synchronization thread + struct sched_param sched_param_synch; /// scheduling parameters for asynch_rxtx thread struct sched_param sched_param_asynch_rxtx; /// pthread structure for parallel fep thread @@ -307,6 +319,8 @@ typedef struct eNB_proc_t_s { pthread_t pthread_te; /// pthread structure for PRACH thread pthread_t pthread_prach; + /// pthread structure for eNB synch thread + pthread_t pthread_synch; /// condition variable for parallel fep thread pthread_cond_t cond_fep; /// condition variable for parallel turbo-decoder thread @@ -317,6 +331,8 @@ typedef struct eNB_proc_t_s { pthread_cond_t cond_FH; /// condition variable for PRACH processing thread; pthread_cond_t cond_prach; + // condition variable for over-the-air eNB synchronization + pthread_cond_t cond_synch; /// condition variable for asynch RX/TX thread pthread_cond_t cond_asynch_rxtx; /// mutex for parallel fep thread @@ -329,6 +345,8 @@ typedef struct eNB_proc_t_s { pthread_mutex_t mutex_FH; /// mutex for PRACH thread pthread_mutex_t mutex_prach; + // mutex for over-the-air eNB synchronization + pthread_mutex_t mutex_synch; /// mutex for asynch RX/TX thread pthread_mutex_t mutex_asynch_rxtx; /// parameters for turbo-decoding worker thread @@ -346,6 +364,8 @@ typedef struct eNB_proc_t_s { /// Context data structure for RX/TX portion of subframe processing typedef struct { + /// index of the current UE RX/TX proc + int proc_id; /// Component Carrier index uint8_t CC_id; /// timestamp transmitted to HW @@ -416,8 +436,15 @@ typedef struct PHY_VARS_eNB_s { int single_thread_flag; openair0_rf_map rf_map; int abstraction_flag; - void (*do_prach)(struct PHY_VARS_eNB_s *eNB); - void (*fep)(struct PHY_VARS_eNB_s *eNB); + openair0_timestamp ts_offset; + // indicator for synchronization state of eNB + int in_synch; + // indicator for master/slave (RRU) + int is_slave; + // indicator for precoding function (eNB,3GPP_eNB_BBU) + int do_precoding; + void (*do_prach)(struct PHY_VARS_eNB_s *eNB,int frame,int subframe); + void (*fep)(struct PHY_VARS_eNB_s *eNB,eNB_rxtx_proc_t *proc); int (*td)(struct PHY_VARS_eNB_s *eNB,int UE_id,int harq_pid,int llr8_flag); int (*te)(struct PHY_VARS_eNB_s *,uint8_t *,uint8_t,LTE_eNB_DLSCH_t *,int,uint8_t,time_stats_t *,time_stats_t *,time_stats_t *); void (*proc_uespec_rx)(struct PHY_VARS_eNB_s *eNB,eNB_rxtx_proc_t *proc,const relaying_type_t r_type); @@ -677,7 +704,7 @@ typedef struct { LTE_DL_FRAME_PARMS frame_parms_before_ho; LTE_UE_COMMON common_vars; - LTE_UE_PDSCH *pdsch_vars[NUMBER_OF_CONNECTED_eNB_MAX+1]; + LTE_UE_PDSCH *pdsch_vars[2][NUMBER_OF_CONNECTED_eNB_MAX+1]; 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]; @@ -774,6 +801,7 @@ typedef struct { uint8_t prach_PreambleIndex; // uint8_t prach_timer; int rx_offset; /// Timing offset + int rx_offset_diff; /// Timing adjustment for ofdm symbol0 on HW USRP int timing_advance; ///timing advance signalled from eNB int hw_timing_advance; int N_TA_offset; ///timing offset used in TDD diff --git a/openair1/PHY/impl_defs_lte.h b/openair1/PHY/impl_defs_lte.h index 7a30bff6abefa8ae8b0f4599cce5da4c9919994d..f6daccfbe0a98bcd43b1dee567d1f3306c669be2 100644 --- a/openair1/PHY/impl_defs_lte.h +++ b/openair1/PHY/impl_defs_lte.h @@ -504,6 +504,8 @@ typedef struct { uint8_t tdd_config; /// TDD S-subframe configuration (0-9) uint8_t tdd_config_S; + /// srs extra symbol flag for TDD + uint8_t srsX; /// indicates if node is a UE (NODE=2) or eNB (PRIMARY_CH=0). uint8_t node_id; /// Frequency index of CBMIMO1 card @@ -542,11 +544,15 @@ typedef struct { uint32_t samples_per_tti; /// Number of OFDM/SC-FDMA symbols in one subframe (to be modified to account for potential different in UL/DL) uint16_t symbols_per_tti; + /// Number of OFDM symbols in DL portion of S-subframe + uint16_t dl_symbols_in_S_subframe; + /// Number of SC-FDMA symbols in UL portion of S-subframe + uint16_t ul_symbols_in_S_subframe; /// Number of Physical transmit antennas in node uint8_t nb_antennas_tx; /// Number of Receive antennas in node uint8_t nb_antennas_rx; - /// Number of Logical transmit antenna ports in eNodeB + /// Number of common transmit antenna ports in eNodeB (1 or 2) uint8_t nb_antenna_ports_eNB; /// PRACH_CONFIG PRACH_CONFIG_COMMON prach_config_common; @@ -778,6 +784,26 @@ typedef struct { #endif } LTE_eNB_PUSCH; +typedef struct { + + /// \brief Holds the received data in the frequency domain. + /// - first index: rx antenna [0..nb_antennas_rx[ + /// - second index: symbol [0..28*ofdm_symbol_size[ + int32_t **rxdataF; + + /// \brief Hold the channel estimates in frequency domain. + /// - first index: eNB id [0..6] (hard coded) + /// - second index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx + /// - third index: samples? [0..symbols_per_tti*(ofdm_symbol_size+LTE_CE_FILTER_LENGTH)[ + int32_t **dl_ch_estimates[7]; + + /// \brief Hold the channel estimates in time domain (used for tracking). + /// - first index: eNB id [0..6] (hard coded) + /// - second index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx + /// - third index: samples? [0..2*ofdm_symbol_size[ + int32_t **dl_ch_estimates_time[7]; +}LTE_UE_COMMON_PER_THREAD; + typedef struct { /// \brief Holds the transmit data in time domain. /// For IFFT_FPGA this points to the same memory as PHY_vars->tx_vars[a].TX_DMA_BUFFER. @@ -789,29 +815,15 @@ typedef struct { /// - first index: tx antenna [0..nb_antennas_tx[ /// - second index: sample [0..FRAME_LENGTH_COMPLEX_SAMPLES_NO_PREFIX[ int32_t **txdataF; + /// \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: rx antenna [0..nb_antennas_rx[ /// - second index: sample [0..FRAME_LENGTH_COMPLEX_SAMPLES+2048[ int32_t **rxdata; - /// \brief Holds the received data in the frequency domain. - /// - first index: rx antenna [0..nb_antennas_rx[ - /// - second index: symbol [0..28*ofdm_symbol_size[ - int32_t **rxdataF; - /// \brief ?. - /// - first index: rx antenna [0..nb_antennas_rx[ - /// - second index: ? [0..20*ofdm_symbol_size*symbols_per_tti[ - int32_t **rxdataF2; - /// \brief Hold the channel estimates in frequency domain. - /// - first index: eNB id [0..6] (hard coded) - /// - second index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx - /// - third index: samples? [0..symbols_per_tti*(ofdm_symbol_size+LTE_CE_FILTER_LENGTH)[ - int32_t **dl_ch_estimates[7]; - /// \brief Hold the channel estimates in time domain (used for tracking). - /// - first index: eNB id [0..6] (hard coded) - /// - second index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx - /// - third index: samples? [0..2*ofdm_symbol_size[ - int32_t **dl_ch_estimates_time[7]; + + LTE_UE_COMMON_PER_THREAD common_vars_rx_data_per_thread[2]; + /// holds output of the sync correlator int32_t *sync_corr; /// estimated frequency offset (in radians) for all subcarriers @@ -994,6 +1006,8 @@ typedef struct { uint8_t num_pdcch_symbols; /// Allocated CRNTI for UE uint16_t crnti; + /// 1: the allocated crnti is Temporary C-RNTI / 0: otherwise + uint8_t crnti_is_temporary; /// Total number of PDU errors (diagnostic mode) uint32_t dci_errors; /// Total number of PDU received @@ -1098,6 +1112,14 @@ typedef enum { typedef enum {SF_DL, SF_UL, SF_S} lte_subframe_t; -#endif - +typedef enum { + /// do not detect any DCIs in the current subframe + NO_DCI = 0x0, + /// detect only downlink DCIs in the current subframe + UL_DCI = 0x1, + /// detect only uplink DCIs in the current subframe + DL_DCI = 0x2, + /// detect both uplink and downlink DCIs in the current subframe + UL_DL_DCI = 0x3} dci_detect_mode_t; +#endif diff --git a/openair1/PHY/impl_defs_top.h b/openair1/PHY/impl_defs_top.h index 79e684215c7f815d1542670a44680b7cbec1f68f..dd09749fbf16bddde06e7b3b7418e87b2ca37ff1 100644 --- a/openair1/PHY/impl_defs_top.h +++ b/openair1/PHY/impl_defs_top.h @@ -177,7 +177,7 @@ #define DMA_BLKS_PER_SLOT (SLOT_LENGTH_BYTES/2048) // Number of DMA blocks per slot #define SLOT_TIME_NS (SLOT_LENGTH_SAMPLES*(1e3)/7.68) // slot time in ns -#define NB_ANTENNA_PORTS_ENB 14 // total number of eNB antenna ports +#define NB_ANTENNA_PORTS_ENB 6 // total number of eNB antenna ports #ifdef EXMIMO #define TARGET_RX_POWER 55 // Target digital power for the AGC diff --git a/openair1/SCHED/defs.h b/openair1/SCHED/defs.h index 2490a4035c14cafd2c7c708f24a9e47073a5e569..5fd5009f1f9c51409b0d04efc89e031caabd7ec4 100644 --- a/openair1/SCHED/defs.h +++ b/openair1/SCHED/defs.h @@ -182,7 +182,7 @@ void phy_procedures_eNB_uespec_RX(PHY_VARS_eNB *phy_vars_eNB,eNB_rxtx_proc_t *pr @param phy_vars_eNB Pointer to eNB variables on which to act @param abstraction_flag Indicator of PHY abstraction */ -void phy_procedures_eNB_common_RX(PHY_VARS_eNB *phy_vars_eNB); +void phy_procedures_eNB_common_RX(PHY_VARS_eNB *phy_vars_eNB,eNB_rxtx_proc_t *proc); /*! \brief Scheduling for eNB TX procedures in TDD S-subframes. @param phy_vars_eNB Pointer to eNB variables on which to act @@ -212,6 +212,13 @@ void prach_procedures(PHY_VARS_eNB *eNB); lte_subframe_t subframe_select(LTE_DL_FRAME_PARMS *frame_parms,uint8_t subframe); +/*! \brief Function to compute which type of DCIs to detect in the given subframe + @param frame_parms Pointer to DL frame parameter descriptor + @param subframe Subframe index + @returns DCI detetion mode type (no DCIs, uplink DCIs, downlink DCIs, both uplink and downlink DCIs) + */ +dci_detect_mode_t dci_detect_mode_select(LTE_DL_FRAME_PARMS *frame_parms,uint8_t subframe); + /*! \brief Function to compute subframe type as a function of Frame type and TDD Configuration (implements Table 4.2.2 from 36.211, p.11 from version 8.6) and subframe index. Same as subframe_select, except that it uses the Mod_id and is provided as a service to the MAC scheduler. @param Mod_id Index of eNB @param CC_id Component Carrier Index @@ -300,6 +307,18 @@ uint8_t pdcch_alloc2ul_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t n); */ uint8_t get_ack(LTE_DL_FRAME_PARMS *frame_parms,harq_status_t *harq_ack,uint8_t subframe,uint8_t *o_ACK); +/*! \brief Reset ACK/NACK information + @param frame_parms Pointer to DL frame parameter descriptor + @param harq_ack Pointer to dlsch_ue harq_ack status descriptor + @param subframe Subframe for UE transmission (n in 36.213) + @param o_ACK Pointer to ACK/NAK payload for PUCCH/PUSCH + @returns status indicator for PUCCH/PUSCH transmission +*/ +uint8_t reset_ack(LTE_DL_FRAME_PARMS *frame_parms, + harq_status_t *harq_ack, + unsigned char subframe, + unsigned char *o_ACK); + /*! \brief Compute UL ACK subframe from DL subframe. This is used to retrieve corresponding DLSCH HARQ pid at eNB upon reception of ACK/NAK information on PUCCH/PUSCH. Derived from Table 10.1-1 in 36.213 (p. 69 in version 8.6) @param frame_parms Pointer to DL frame parameter descriptor @param subframe Subframe for UE transmission (n in 36.213) @@ -366,6 +385,7 @@ subframe n-4 which is acknowledged in subframe n (for FDD) according to n1_pucch TDD, this routine computes the complex procedure described in Section 10.1 of 36.213 (through tables 10.1-1,10.1-2) @param phy_vars_ue Pointer to UE variables @param proc Pointer to RXn-TXnp4 proc information +@param harq_ack Pointer to dlsch_ue harq_ack status descriptor @param eNB_id Index of eNB @param b Pointer to PUCCH payload (b[0],b[1]) @param SR 1 means there's a positive SR in parallel to ACK/NAK @@ -373,6 +393,7 @@ TDD, this routine computes the complex procedure described in Section 10.1 of 36 */ uint16_t get_n1_pucch(PHY_VARS_UE *phy_vars_ue, UE_rxtx_proc_t *proc, + harq_status_t *harq_ack, uint8_t eNB_id, uint8_t *b, uint8_t SR); @@ -431,7 +452,7 @@ UE_MODE_t get_ue_mode(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index); @param pucch_fmt Format of PUCCH that is being transmitted @returns Transmit power */ -int8_t pucch_power_cntl(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t subframe,uint8_t eNB_id,PUCCH_FMT_t pucch_fmt); +int16_t pucch_power_cntl(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t subframe,uint8_t eNB_id,PUCCH_FMT_t pucch_fmt); /*! \brief This function implements the power control mechanism for PUCCH from 36.213. @param phy_vars_ue PHY variables @@ -488,7 +509,7 @@ int get_ue_active_harq_pid(uint8_t Mod_id,uint8_t CC_id,uint16_t rnti,int frame, void dump_dlsch(PHY_VARS_UE *phy_vars_ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t subframe,uint8_t harq_pid); void dump_dlsch_SI(PHY_VARS_UE *phy_vars_ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t subframe); void dump_dlsch_ra(PHY_VARS_UE *phy_vars_ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t subframe); -void dump_dlsch2(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint16_t coded_bits_per_codeword,int round); +void dump_dlsch2(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint8_t subframe, uint16_t coded_bits_per_codeword,int round); /*@}*/ diff --git a/openair1/SCHED/phy_procedures_lte_common.c b/openair1/SCHED/phy_procedures_lte_common.c index 239a5e2f8d136adb0d3ec5b95e700363550686d4..c787ea0773c3f6ac2621fba6af20e809dcb7eb53 100644 --- a/openair1/SCHED/phy_procedures_lte_common.c +++ b/openair1/SCHED/phy_procedures_lte_common.c @@ -320,85 +320,128 @@ unsigned char ul_ACK_subframe2_M(LTE_DL_FRAME_PARMS *frame_parms,unsigned char s } // This function implements table 10.1-1 of 36-213, p. 69 -uint8_t get_ack(LTE_DL_FRAME_PARMS *frame_parms, +// return the number 'Nbundled' +uint8_t get_reset_ack(LTE_DL_FRAME_PARMS *frame_parms, harq_status_t *harq_ack, unsigned char subframe, - unsigned char *o_ACK) + unsigned char *o_ACK, + uint8_t do_reset) // 1 to reset ACK/NACK status : 0 otherwise { - - uint8_t status=0; - uint8_t subframe_dl; + uint8_t subframe_ul=0xff, subframe_dl0=0xff, subframe_dl1=0xff; // printf("get_ack: SF %d\n",subframe); if (frame_parms->frame_type == FDD) { if (subframe < 4) - subframe_dl = subframe + 6; + subframe_dl0 = subframe + 6; else - subframe_dl = subframe - 4; + subframe_dl0 = subframe - 4; - o_ACK[0] = harq_ack[subframe_dl].ack; - status = harq_ack[subframe_dl].send_harq_status; + o_ACK[0] = harq_ack[subframe_dl0].ack; + status = harq_ack[subframe_dl0].send_harq_status; //printf("get_ack: Getting ACK/NAK for PDSCH (subframe %d) => %d\n",subframe_dl,o_ACK[0]); } else { switch (frame_parms->tdd_config) { case 1: - if (subframe == 2) { // ACK subframes 5 (forget 6) - o_ACK[0] = harq_ack[5].ack; - status = harq_ack[5].send_harq_status; + if (subframe == 2) { // ACK subframes 5,6 + subframe_ul = 6; + subframe_dl0 = 5; + subframe_dl1 = 6; } else if (subframe == 3) { // ACK subframe 9 - o_ACK[0] = harq_ack[9].ack; - status = harq_ack[9].send_harq_status; + subframe_ul = 9; + subframe_dl0 = 9; + subframe_dl1 = 0xff; } else if (subframe == 4) { // nothing - status = 0; - } else if (subframe == 7) { // ACK subframes 0 (forget 1) - o_ACK[0] = harq_ack[0].ack; - status = harq_ack[0].send_harq_status; + subframe_ul = 0xff; + subframe_dl0 = 0xff; // invalid subframe number indicates ACK/NACK is not needed + subframe_dl1 = 0xff; + } else if (subframe == 7) { // ACK subframes 0,1 + subframe_ul = 1; + subframe_dl0 = 0; + subframe_dl1 = 1; } else if (subframe == 8) { // ACK subframes 4 - o_ACK[0] = harq_ack[4].ack; - status = harq_ack[4].send_harq_status; + subframe_ul = 4; + subframe_dl0 = 4; + subframe_dl1 = 0xff; } else { LOG_E(PHY,"phy_procedures_lte.c: get_ack, illegal subframe %d for tdd_config %d\n", subframe,frame_parms->tdd_config); return(0); } + // report ACK/NACK status + o_ACK[0] = 1; + status = 0; + if ((subframe_dl0 < 10) && (harq_ack[subframe_dl0].send_harq_status)) { + o_ACK[0] &= harq_ack[subframe_dl0].ack; + status = harq_ack[subframe_dl0].send_harq_status; + } + if ((subframe_dl1 < 10) && (harq_ack[subframe_dl1].send_harq_status)) { + o_ACK[0] &= harq_ack[subframe_dl1].ack; + status = harq_ack[subframe_dl1].send_harq_status; + } + // report status = Nbundled + if (!status) { + o_ACK[0] = 0; + } else { + if (harq_ack[subframe_ul].vDAI_UL < 0xff) { + status = harq_ack[subframe_ul].vDAI_UL; + } + } + + if (!do_reset && (subframe_ul < 10)) { + if ((subframe_dl0 < 10) && (subframe_dl1 < 10)) { + LOG_D(PHY,"ul-sf#%d vDAI_UL[sf#%d]=%d Nbundled=%d: dlsf#%d ACK=%d harq_status=%d vDAI_DL=%d, dlsf#%d ACK=%d harq_status=%d vDAI_DL=%d, o_ACK[0]=%d status=%d\n", + subframe, subframe_ul, harq_ack[subframe_ul].vDAI_UL, status, + subframe_dl0, harq_ack[subframe_dl0].ack, harq_ack[subframe_dl0].send_harq_status, harq_ack[subframe_dl0].vDAI_DL, + subframe_dl1, harq_ack[subframe_dl1].ack, harq_ack[subframe_dl1].send_harq_status, harq_ack[subframe_dl1].vDAI_DL, + o_ACK[0], status); + } else if (subframe_dl0 < 10) { + LOG_D(PHY,"ul-sf#%d vDAI_UL[sf#%d]=%d Nbundled=%d: dlsf#%d ACK=%d status=%d vDAI_DL=%d, o_ACK[0]=%d status=%d\n", + subframe, subframe_ul, harq_ack[subframe_ul].vDAI_UL, status, + subframe_dl0, harq_ack[subframe_dl0].ack, harq_ack[subframe_dl0].send_harq_status, harq_ack[subframe_dl0].vDAI_DL, + o_ACK[0], status); + }else if (subframe_dl1 < 10) { + LOG_D(PHY,"ul-sf#%d vDAI_UL[sf#%d]=%d Nbundled=%d: dlsf#%d ACK=%d status=%d vDAI_DL=%d, o_ACK[0]=%d status=%d\n", + subframe, subframe_ul, harq_ack[subframe_ul].vDAI_UL, status, + subframe_dl1, harq_ack[subframe_dl1].ack, harq_ack[subframe_dl1].send_harq_status, harq_ack[subframe_dl1].vDAI_DL, + o_ACK[0], status); + } + } + + // reset ACK/NACK status + if (do_reset) { + LOG_D(PHY,"ul-sf#%d ACK/NACK status resetting @ dci0-sf#%d, dci1x/2x-sf#%d, dci1x/2x-sf#%d\n", subframe, subframe_ul, subframe_dl0, subframe_dl1); + if (subframe_ul < 10) { + harq_ack[subframe_ul].vDAI_UL = 0xff; + } + if (subframe_dl0 < 10) { + harq_ack[subframe_dl0].vDAI_DL = 0xff; + harq_ack[subframe_dl0].ack = 2; + harq_ack[subframe_dl0].send_harq_status = 0; + } + if (subframe_dl1 < 10) { + harq_ack[subframe_dl1].vDAI_DL = 0xff; + harq_ack[subframe_dl1].ack = 2; + harq_ack[subframe_dl1].send_harq_status = 0; + } + } + break; case 3: if (subframe == 2) { // ACK subframes 5 and 6 - if (harq_ack[5].send_harq_status == 1) { - o_ACK[0] = harq_ack[5].ack; - - if (harq_ack[6].send_harq_status == 1) - o_ACK[1] = harq_ack[6].ack; - } else if (harq_ack[6].send_harq_status == 1) - o_ACK[0] = harq_ack[6].ack; - - status = harq_ack[5].send_harq_status + (harq_ack[6].send_harq_status<<1); + subframe_dl0 = 5; + subframe_dl1 = 6; //printf("Subframe 2, TDD config 3: harq_ack[5] = %d (%d),harq_ack[6] = %d (%d)\n",harq_ack[5].ack,harq_ack[5].send_harq_status,harq_ack[6].ack,harq_ack[6].send_harq_status); } else if (subframe == 3) { // ACK subframes 7 and 8 - if (harq_ack[7].send_harq_status == 1) { - o_ACK[0] = harq_ack[7].ack; - - if (harq_ack[8].send_harq_status == 1) - o_ACK[1] = harq_ack[8].ack; - } else if (harq_ack[8].send_harq_status == 1) - o_ACK[0] = harq_ack[8].ack; - - status = harq_ack[7].send_harq_status + (harq_ack[8].send_harq_status<<1); + subframe_dl0 = 7; + subframe_dl1 = 8; //printf("Subframe 3, TDD config 3: harq_ack[7] = %d,harq_ack[8] = %d\n",harq_ack[7].ack,harq_ack[8].ack); //printf("status %d : o_ACK (%d,%d)\n", status,o_ACK[0],o_ACK[1]); } else if (subframe == 4) { // ACK subframes 9 and 0 - if (harq_ack[9].send_harq_status == 1) { - o_ACK[0] = harq_ack[9].ack; - - if (harq_ack[0].send_harq_status == 1) - o_ACK[1] = harq_ack[0].ack; - } else if (harq_ack[0].send_harq_status == 1) - o_ACK[0] = harq_ack[0].ack; - - status = harq_ack[9].send_harq_status + (harq_ack[0].send_harq_status<<1); + subframe_dl0 = 9; + subframe_dl1 = 0; //printf("Subframe 4, TDD config 3: harq_ack[9] = %d,harq_ack[0] = %d\n",harq_ack[9].ack,harq_ack[0].ack); } else { LOG_E(PHY,"phy_procedures_lte.c: get_ack, illegal subframe %d for tdd_config %d\n", @@ -406,6 +449,25 @@ uint8_t get_ack(LTE_DL_FRAME_PARMS *frame_parms, return(0); } + // report ACK/NACK status + if (harq_ack[subframe_dl0].send_harq_status == 1) { + o_ACK[0] = harq_ack[subframe_dl0].ack; + + if (harq_ack[subframe_dl1].send_harq_status == 1) + o_ACK[1] = harq_ack[subframe_dl1].ack; + } else if (harq_ack[subframe_dl1].send_harq_status == 1) + o_ACK[0] = harq_ack[subframe_dl1].ack; + + status = harq_ack[subframe_dl0].send_harq_status + (harq_ack[subframe_dl1].send_harq_status<<1); + + if (do_reset) { + // reset ACK/NACK status + harq_ack[subframe_dl0].ack = 2; + harq_ack[subframe_dl1].ack = 2; + harq_ack[subframe_dl0].send_harq_status = 0; + harq_ack[subframe_dl1].send_harq_status = 0; + } + break; } @@ -416,6 +478,24 @@ uint8_t get_ack(LTE_DL_FRAME_PARMS *frame_parms, return(status); } +uint8_t get_ack(LTE_DL_FRAME_PARMS *frame_parms, + harq_status_t *harq_ack, + unsigned char subframe, + unsigned char *o_ACK) +{ + return get_reset_ack(frame_parms, harq_ack, subframe, o_ACK, 0); +} + +uint8_t reset_ack(LTE_DL_FRAME_PARMS *frame_parms, + harq_status_t *harq_ack, + unsigned char subframe, + unsigned char *o_ACK) +{ + return get_reset_ack(frame_parms, harq_ack, subframe, o_ACK, 1); +} + + + uint8_t Np6[4]= {0,1,3,5}; uint8_t Np15[4]= {0,3,8,13}; uint8_t Np25[4]= {0,5,13,22}; @@ -518,6 +598,34 @@ lte_subframe_t subframe_select(LTE_DL_FRAME_PARMS *frame_parms,unsigned char sub } } +dci_detect_mode_t dci_detect_mode_select(LTE_DL_FRAME_PARMS *frame_parms,uint8_t subframe) +{ + dci_detect_mode_t ret = 0; + + static dci_detect_mode_t Table_8_2_3gpp_36_213[][10] = { + //subf0 , subf1 , subf2 , subf3 , subf4 , subf5 , subf6 , subf7 , subf8 , subf9 + {UL_DL_DCI, UL_DL_DCI , NO_DCI , NO_DCI , NO_DCI , UL_DL_DCI , UL_DL_DCI , NO_DCI, NO_DCI , NO_DCI }, // tdd0 + {DL_DCI , UL_DL_DCI , NO_DCI , NO_DCI , UL_DL_DCI , DL_DCI , UL_DL_DCI , NO_DCI, NO_DCI , UL_DL_DCI }, // tdd1 + {DL_DCI , DL_DCI , NO_DCI , UL_DL_DCI , DL_DCI , DL_DCI , DL_DCI , NO_DCI, UL_DL_DCI , DL_DCI }, // tdd2 + {UL_DL_DCI, DL_DCI , NO_DCI , NO_DCI , NO_DCI , DL_DCI , DL_DCI , DL_DCI, UL_DL_DCI , UL_DL_DCI }, // tdd3 + {DL_DCI , DL_DCI , NO_DCI , NO_DCI , DL_DCI , DL_DCI , DL_DCI , DL_DCI, UL_DL_DCI , UL_DL_DCI }, // tdd4 + {DL_DCI , DL_DCI , NO_DCI , DL_DCI , DL_DCI , DL_DCI , DL_DCI , DL_DCI, UL_DL_DCI , DL_DCI }, // tdd5 + {UL_DL_DCI, UL_DL_DCI , NO_DCI , NO_DCI , NO_DCI , UL_DL_DCI , UL_DL_DCI , NO_DCI, NO_DCI , UL_DL_DCI }}; // tdd6 + + + DevAssert(subframe>=0 && subframe<=9); + DevAssert((frame_parms->tdd_config)>=0 && (frame_parms->tdd_config)<=6); + + if (frame_parms->frame_type == FDD) { + ret = UL_DL_DCI; + } else { + ret = Table_8_2_3gpp_36_213[frame_parms->tdd_config][subframe]; + } + + LOG_D(PHY, "subframe %d: detect UL_DCI=%d, detect DL_DCI=%d\n", subframe, (ret & UL_DCI)>0, (ret & DL_DCI)>0); + return ret; +} + lte_subframe_t get_subframe_direction(uint8_t Mod_id,uint8_t CC_id,uint8_t subframe) { diff --git a/openair1/SCHED/phy_procedures_lte_eNb.c b/openair1/SCHED/phy_procedures_lte_eNb.c index 12827d973425dbe5f1c963ca163d98da3b70fd1e..cad508c7c225d7bc90d5b6a1316b5a89096d1cc4 100644 --- a/openair1/SCHED/phy_procedures_lte_eNb.c +++ b/openair1/SCHED/phy_procedures_lte_eNb.c @@ -788,7 +788,7 @@ void generate_eNB_dlsch_params(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,DCI_ALLOC eNB->dlsch[(uint8_t)UE_id][0]->nCCE[subframe] = dci_alloc->firstCCE; - LOG_D(PHY,"[eNB %"PRIu8"] Frame %d subframe %d : CCE resource for ue DCI (PDSCH %"PRIx16") => %"PRIu8"/%u\n",eNB->Mod_id,frame,subframe, + LOG_D(PHY,"[eNB %"PRIu8"] Frame %d subframe %d : CCE resource for ue DCI (PDSCH %"PRIx16") => %"PRIu8"\n",eNB->Mod_id,frame,subframe, dci_alloc->rnti,eNB->dlsch[(uint8_t)UE_id][0]->nCCE[subframe]); #if defined(SMBV) @@ -900,7 +900,7 @@ void pdsch_procedures(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,LTE_eNB_DLSCH_t *d int i; LOG_D(PHY, - "[eNB %"PRIu8"][PDSCH %"PRIx16"/%"PRIu8"] Frame %d, subframe %d: Generating PDSCH/DLSCH with input size = %"PRIu16", G %d, nb_rb %"PRIu16", mcs %"PRIu8", pmi_alloc %"PRIx16", rv %"PRIu8" (round %"PRIu8")\n", + "[eNB %"PRIu8"][PDSCH %"PRIx16"/%"PRIu8"] Frame %d, subframe %d: Generating PDSCH/DLSCH with input size = %"PRIu16", G %d, nb_rb %"PRIu16", mcs %"PRIu8", pmi_alloc %"PRIx64", rv %"PRIu8" (round %"PRIu8")\n", eNB->Mod_id, dlsch->rnti,harq_pid, frame, subframe, input_buffer_length, get_G(fp, @@ -1146,7 +1146,7 @@ void phy_procedures_eNB_TX(PHY_VARS_eNB *eNB, LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms; DCI_ALLOC_t *dci_alloc=(DCI_ALLOC_t *)NULL; - int offset = proc == &eNB->proc.proc_rxtx[0] ? 0 : 1; + int offset = eNB->CC_id;//proc == &eNB->proc.proc_rxtx[0] ? 0 : 1; #if defined(SMBV) // counts number of allocations in subframe @@ -2032,8 +2032,8 @@ void prach_procedures(PHY_VARS_eNB *eNB) { T_INT(preamble_max), T_INT(preamble_energy_max), T_INT(preamble_delay_list[preamble_max])); if (eNB->mac_enabled==1) { - uint8_t update_TA=4; - + uint8_t update_TA = 4; + uint8_t update_TA2 = 1; switch (fp->N_RB_DL) { case 6: update_TA = 16; @@ -2047,8 +2047,11 @@ void prach_procedures(PHY_VARS_eNB *eNB) { update_TA = 2; break; + case 75: + update_TA = 3; + update_TA2 = 2; case 100: - update_TA = 1; + update_TA = 1; break; } @@ -2056,7 +2059,7 @@ void prach_procedures(PHY_VARS_eNB *eNB) { eNB->CC_id, frame, preamble_max, - preamble_delay_list[preamble_max]*update_TA, + preamble_delay_list[preamble_max]*update_TA/update_TA2, 0,subframe,0); } @@ -2670,7 +2673,7 @@ void init_te_thread(PHY_VARS_eNB *eNB,pthread_attr_t *attr_te) { } -void eNB_fep_full_2thread(PHY_VARS_eNB *eNB) { +void eNB_fep_full_2thread(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc_rxtx) { eNB_proc_t *proc = &eNB->proc; @@ -2716,28 +2719,27 @@ void eNB_fep_full_2thread(PHY_VARS_eNB *eNB) { -void eNB_fep_full(PHY_VARS_eNB *eNB) { +void eNB_fep_full(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc_rxtx) { - eNB_proc_t *proc = &eNB->proc; int l; LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms; VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_SLOT_FEP,1); start_meas(&eNB->ofdm_demod_stats); - remove_7_5_kHz(eNB,proc->subframe_rx<<1); - remove_7_5_kHz(eNB,1+(proc->subframe_rx<<1)); + remove_7_5_kHz(eNB,proc_rxtx->subframe_rx<<1); + remove_7_5_kHz(eNB,1+(proc_rxtx->subframe_rx<<1)); for (l=0; lsymbols_per_tti/2; l++) { slot_fep_ul(fp, &eNB->common_vars, l, - proc->subframe_rx<<1, + (proc_rxtx->subframe_rx)<<1, 0, 0 ); slot_fep_ul(fp, &eNB->common_vars, l, - 1+(proc->subframe_rx<<1), + 1+((proc_rxtx->subframe_rx)<<1), 0, 0 ); @@ -2748,11 +2750,11 @@ void eNB_fep_full(PHY_VARS_eNB *eNB) { if (eNB->node_function == NGFI_RRU_IF4p5) { /// **** send_IF4 of rxdataF to RCC (no prach now) **** /// - send_IF4p5(eNB, proc->frame_rx, proc->subframe_rx, IF4p5_PULFFT, 0); + send_IF4p5(eNB, proc_rxtx->frame_rx, proc_rxtx->subframe_rx, IF4p5_PULFFT, 0); } } -void eNB_fep_rru_if5(PHY_VARS_eNB *eNB) { +void eNB_fep_rru_if5(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc_rxtx) { eNB_proc_t *proc=&eNB->proc; uint8_t seqno=0; @@ -2764,17 +2766,17 @@ void eNB_fep_rru_if5(PHY_VARS_eNB *eNB) { } -void do_prach(PHY_VARS_eNB *eNB) { +void do_prach(PHY_VARS_eNB *eNB,int frame,int subframe) { eNB_proc_t *proc = &eNB->proc; LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms; // check if we have to detect PRACH first - if (is_prach_subframe(fp,proc->frame_rx,proc->subframe_rx)>0) { + if (is_prach_subframe(fp,frame,subframe)>0) { /* accept some delay in processing - up to 5ms */ int i; for (i = 0; i < 10 && proc->instance_cnt_prach == 0; i++) { - LOG_W(PHY,"[eNB] Frame %d Subframe %d, eNB PRACH thread busy (IC %d)!!\n", proc->frame_rx,proc->subframe_rx,proc->instance_cnt_prach); + LOG_W(PHY,"[eNB] Frame %d Subframe %d, eNB PRACH thread busy (IC %d)!!\n", frame,subframe,proc->instance_cnt_prach); usleep(500); } if (proc->instance_cnt_prach == 0) { @@ -2784,15 +2786,15 @@ void do_prach(PHY_VARS_eNB *eNB) { // wake up thread for PRACH RX if (pthread_mutex_lock(&proc->mutex_prach) != 0) { - LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB PRACH thread %d (IC %d)\n", proc->instance_cnt_prach ); + LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB PRACH thread %d (IC %d)\n", proc->thread_index, proc->instance_cnt_prach); exit_fun( "error locking mutex_prach" ); return; } ++proc->instance_cnt_prach; // set timing for prach thread - proc->frame_prach = proc->frame_rx; - proc->subframe_prach = proc->subframe_rx; + proc->frame_prach = frame; + proc->subframe_prach = subframe; // the thread can now be woken up if (pthread_cond_signal(&proc->cond_prach) != 0) { @@ -2806,28 +2808,34 @@ void do_prach(PHY_VARS_eNB *eNB) { } -void phy_procedures_eNB_common_RX(PHY_VARS_eNB *eNB){ +void phy_procedures_eNB_common_RX(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc){ - eNB_proc_t *proc = &eNB->proc; + // eNB_proc_t *proc = &eNB->proc; LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms; const int subframe = proc->subframe_rx; const int frame = proc->frame_rx; int offset = (eNB->single_thread_flag==1) ? 0 : (subframe&1); - if ((fp->frame_type == TDD) && (subframe_select(fp,subframe)!=SF_UL)) return; - VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_FRAME_NUMBER_RX0_ENB+offset, proc->frame_rx ); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SUBFRAME_NUMBER_RX0_ENB+offset, proc->subframe_rx ); - VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_COMMON+offset, 1 ); - + + if ((fp->frame_type == TDD) && (subframe_select(fp,subframe)!=SF_UL)) { + + if (eNB->node_function == NGFI_RRU_IF4p5) { + /// **** in TDD during DL send_IF4 of ULTICK to RCC **** /// + send_IF4p5(eNB, proc->frame_rx, proc->subframe_rx, IF4p5_PULTICK, 0); + } + return; + } + + + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_COMMON+offset, 1 ); start_meas(&eNB->phy_proc_rx); LOG_D(PHY,"[eNB %d] Frame %d: Doing phy_procedures_eNB_common_RX(%d)\n",eNB->Mod_id,frame,subframe); - if (eNB->fep) eNB->fep(eNB); - - if (eNB->do_prach) eNB->do_prach(eNB); + if (eNB->fep) eNB->fep(eNB,proc); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_COMMON+offset, 0 ); } @@ -2847,7 +2855,7 @@ void phy_procedures_eNB_uespec_RX(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,const const int subframe = proc->subframe_rx; const int frame = proc->frame_rx; - int offset = (proc == &eNB->proc.proc_rxtx[0]) ? 0 : 1; + int offset = eNB->CC_id;//(proc == &eNB->proc.proc_rxtx[0]) ? 0 : 1; if ((fp->frame_type == TDD) && (subframe_select(fp,subframe)!=SF_UL)) return; diff --git a/openair1/SCHED/phy_procedures_lte_ue.c b/openair1/SCHED/phy_procedures_lte_ue.c index 1c6aa6b20cdc3c7f03653dc83c8c719c07ec50cf..7d061f60bfcbfc75041ad838f41b1e04c6b960f4 100644 --- a/openair1/SCHED/phy_procedures_lte_ue.c +++ b/openair1/SCHED/phy_procedures_lte_ue.c @@ -66,6 +66,8 @@ fifo_dump_emos_UE emos_dump_UE; #include "PHY/CODING/extern.h" +#include "T.h" + #define DLSCH_RB_ALLOC 0x1fbf // skip DC RB (total 23/25 RBs) #define DLSCH_RB_ALLOC_12 0x0aaa // skip DC RB (total 23/25 RBs) @@ -97,20 +99,20 @@ void dump_dlsch(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t subf subframe, ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id]); - write_output("rxsigF0.m","rxsF0", ue->common_vars.rxdataF[0],2*nsymb*ue->frame_parms.ofdm_symbol_size,2,1); - write_output("rxsigF0_ext.m","rxsF0_ext", ue->pdsch_vars[0]->rxdataF_ext[0],2*nsymb*ue->frame_parms.ofdm_symbol_size,1,1); - write_output("dlsch00_ch0_ext.m","dl00_ch0_ext", ue->pdsch_vars[0]->dl_ch_estimates_ext[0],300*nsymb,1,1); + write_output("rxsigF0.m","rxsF0", ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[0],2*nsymb*ue->frame_parms.ofdm_symbol_size,2,1); + write_output("rxsigF0_ext.m","rxsF0_ext", ue->pdsch_vars[subframe&0x1][0]->rxdataF_ext[0],2*nsymb*ue->frame_parms.ofdm_symbol_size,1,1); + write_output("dlsch00_ch0_ext.m","dl00_ch0_ext", ue->pdsch_vars[subframe&0x1][0]->dl_ch_estimates_ext[0],300*nsymb,1,1); /* write_output("dlsch01_ch0_ext.m","dl01_ch0_ext",pdsch_vars[0]->dl_ch_estimates_ext[1],300*12,1,1); write_output("dlsch10_ch0_ext.m","dl10_ch0_ext",pdsch_vars[0]->dl_ch_estimates_ext[2],300*12,1,1); write_output("dlsch11_ch0_ext.m","dl11_ch0_ext",pdsch_vars[0]->dl_ch_estimates_ext[3],300*12,1,1); write_output("dlsch_rho.m","dl_rho",pdsch_vars[0]->rho[0],300*12,1,1); */ - write_output("dlsch_rxF_comp0.m","dlsch0_rxF_comp0", ue->pdsch_vars[0]->rxdataF_comp0[0],300*12,1,1); - write_output("dlsch_rxF_llr.m","dlsch_llr", ue->pdsch_vars[0]->llr[0],coded_bits_per_codeword,1,0); + write_output("dlsch_rxF_comp0.m","dlsch0_rxF_comp0", ue->pdsch_vars[subframe&0x1][0]->rxdataF_comp0[0],300*12,1,1); + write_output("dlsch_rxF_llr.m","dlsch_llr", ue->pdsch_vars[subframe&0x1][0]->llr[0],coded_bits_per_codeword,1,0); - write_output("dlsch_mag1.m","dlschmag1",ue->pdsch_vars[0]->dl_ch_mag0,300*12,1,1); - write_output("dlsch_mag2.m","dlschmag2",ue->pdsch_vars[0]->dl_ch_magb0,300*12,1,1); + write_output("dlsch_mag1.m","dlschmag1",ue->pdsch_vars[subframe&0x1][0]->dl_ch_mag0,300*12,1,1); + write_output("dlsch_mag2.m","dlschmag2",ue->pdsch_vars[subframe&0x1][0]->dl_ch_magb0,300*12,1,1); } void dump_dlsch_SI(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t subframe) @@ -139,7 +141,7 @@ void dump_dlsch_SI(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t s write_output("rxsig0.m","rxs0", &ue->common_vars.rxdata[0][subframe*ue->frame_parms.samples_per_tti],ue->frame_parms.samples_per_tti,1,1); - write_output("rxsigF0.m","rxsF0", ue->common_vars.rxdataF[0],nsymb*ue->frame_parms.ofdm_symbol_size,1,1); + write_output("rxsigF0.m","rxsF0", ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[0],nsymb*ue->frame_parms.ofdm_symbol_size,1,1); write_output("rxsigF0_ext.m","rxsF0_ext", ue->pdsch_vars_SI[0]->rxdataF_ext[0],2*nsymb*ue->frame_parms.ofdm_symbol_size,1,1); write_output("dlsch00_ch0_ext.m","dl00_ch0_ext", ue->pdsch_vars_SI[0]->dl_ch_estimates_ext[0],ue->frame_parms.N_RB_DL*12*nsymb,1,1); /* @@ -205,9 +207,6 @@ unsigned int get_tx_amp(int power_dBm, int power_max_dBm, int N_RB_UL, int nb_rb int gain_dB = power_dBm - power_max_dBm; double gain_lin; - if (gain_dB < -20) - return(AMP/10); - gain_lin = pow(10,.1*gain_dB); if ((nb_rb >0) && (nb_rb <= N_RB_UL)) { return((int)(AMP*sqrt(gain_lin*N_RB_UL/(double)nb_rb))); @@ -243,7 +242,7 @@ void dump_dlsch_ra(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t s ue->pdcch_vars[eNB_id]->num_pdcch_symbols, coded_bits_per_codeword); - write_output("rxsigF0.m","rxsF0", ue->common_vars.rxdataF[0],2*12*ue->frame_parms.ofdm_symbol_size,2,1); + write_output("rxsigF0.m","rxsF0", ue->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[0],2*12*ue->frame_parms.ofdm_symbol_size,2,1); write_output("rxsigF0_ext.m","rxsF0_ext", ue->pdsch_vars_ra[0]->rxdataF_ext[0],2*12*ue->frame_parms.ofdm_symbol_size,1,1); write_output("dlsch00_ch0_ext.m","dl00_ch0_ext", ue->pdsch_vars_ra[0]->dl_ch_estimates_ext[0],300*nsymb,1,1); /* @@ -266,7 +265,7 @@ void phy_reset_ue(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index) // This flushes ALL DLSCH and ULSCH harq buffers of ALL connected eNBs...add the eNB_index later // for more flexibility - uint8_t i,j,k; + uint8_t i,j,k,s; PHY_VARS_UE *ue = PHY_vars_UE_g[Mod_id][CC_id]; //[NUMBER_OF_CONNECTED_eNB_MAX][2]; @@ -276,6 +275,13 @@ void phy_reset_ue(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index) if(ue->dlsch[i][j]) { for(k=0; kdlsch[i][j]->harq_processes[k]; k++) { ue->dlsch[i][j]->harq_processes[k]->status = SCH_IDLE; + for (s=0; s<10; s++) { + // reset ACK/NACK bit to DTX for all subframes s = 0..9 + ue->dlsch[i][j]->harq_ack[s].ack = 2; + ue->dlsch[i][j]->harq_ack[s].send_harq_status = 0; + ue->dlsch[i][j]->harq_ack[s].vDAI_UL = 0xff; + ue->dlsch[i][j]->harq_ack[s].vDAI_DL = 0xff; + } } } } @@ -301,7 +307,9 @@ void ra_failed(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index) // if contention resolution fails, go back to PRACH PHY_vars_UE_g[Mod_id][CC_id]->UE_mode[eNB_index] = PRACH; - LOG_E(PHY,"[UE %d] Random-access procedure fails, going back to PRACH, setting SIStatus = 0 and State RRC_IDLE\n",Mod_id); + PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[eNB_index]->crnti_is_temporary = 0; + PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[eNB_index]->crnti = 0; + LOG_E(PHY,"[UE %d] Random-access procedure fails, going back to PRACH, setting SIStatus = 0, discard temporary C-RNTI and State RRC_IDLE\n",Mod_id); //mac_xface->macphy_exit(""); } @@ -310,8 +318,9 @@ void ra_succeeded(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index) int i; - LOG_I(PHY,"[UE %d][RAPROC] Random-access procedure succeeded\n",Mod_id); + LOG_I(PHY,"[UE %d][RAPROC] Random-access procedure succeeded. Set C-RNTI = Temporary C-RNTI\n",Mod_id); + PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[eNB_index]->crnti_is_temporary = 0; PHY_vars_UE_g[Mod_id][CC_id]->ulsch_Msg3_active[eNB_index] = 0; PHY_vars_UE_g[Mod_id][CC_id]->UE_mode[eNB_index] = PUSCH; @@ -337,7 +346,9 @@ void process_timing_advance_rar(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint16_t ti #ifdef DEBUG_PHY_PROC - LOG_I(PHY,"[UE %d] AbsoluteSubFrame %d.%d, received (rar) timing_advance %d, HW timing advance %d\n",ue->Mod_id,proc->frame_rx, proc->subframe_rx, ue->timing_advance); + /* TODO: fix this log, what is 'HW timing advance'? */ + /*LOG_I(PHY,"[UE %d] AbsoluteSubFrame %d.%d, received (rar) timing_advance %d, HW timing advance %d\n",ue->Mod_id,proc->frame_rx, proc->subframe_rx, ue->timing_advance);*/ + LOG_I(PHY,"[UE %d] AbsoluteSubFrame %d.%d, received (rar) timing_advance %d\n",ue->Mod_id,proc->frame_rx, proc->subframe_rx, ue->timing_advance); #endif } @@ -728,6 +739,7 @@ void get_cqipmiri_params(PHY_VARS_UE *ue,uint8_t eNB_id) uint16_t get_n1_pucch(PHY_VARS_UE *ue, UE_rxtx_proc_t *proc, + harq_status_t *harq_ack, uint8_t eNB_id, uint8_t *b, uint8_t SR) @@ -737,7 +749,8 @@ uint16_t get_n1_pucch(PHY_VARS_UE *ue, uint8_t nCCE0,nCCE1,harq_ack1,harq_ack0; ANFBmode_t bundling_flag; uint16_t n1_pucch0=0,n1_pucch1=0; - int subframe_offset; + static uint8_t candidate_dl[9]; // which downlink(s) the current ACK/NACK is associating to + uint8_t last_dl=0xff; // the last downlink with valid DL-DCI. for calculating the PUCCH resource index int sf; int M; // clear this, important for case where n1_pucch selection is not used @@ -775,41 +788,71 @@ uint16_t get_n1_pucch(PHY_VARS_UE *ue, M=1; // This is the offset for a particular subframe (2,3,4) => (0,2,4) - if (subframe == 2) { // ACK subframes 5 (forget 6) - subframe_offset = 5; + if (subframe == 2) { // ACK subframes 5,6 + candidate_dl[0] = 6; + candidate_dl[1] = 5; M=2; } else if (subframe == 3) { // ACK subframe 9 - subframe_offset = 9; - } else if (subframe == 7) { // ACK subframes 0 (forget 1) - subframe_offset = 0; + candidate_dl[0] = 9; + } else if (subframe == 7) { // ACK subframes 0,1 + candidate_dl[0] = 1; + candidate_dl[1] = 0; M=2; } else if (subframe == 8) { // ACK subframes 4 - subframe_offset = 4; + candidate_dl[0] = 4; } else { LOG_E(PHY,"[UE%d] : Frame %d phy_procedures_lte.c: get_n1pucch, illegal subframe %d for tdd_config %d\n", ue->Mod_id,proc->frame_tx,subframe,frame_parms->tdd_config); return(0); } + // checking which downlink candidate is the last downlink with valid DL-DCI + int k; + for (k=0;k0) { + last_dl = candidate_dl[k]; + break; + } + } + if (last_dl >= 10) { + LOG_E(PHY,"[UE%d] : Frame %d phy_procedures_lte.c: get_n1pucch, illegal subframe %d for tdd_config %d\n", + ue->Mod_id,proc->frame_tx,last_dl,frame_parms->tdd_config); + return (0); + } + + LOG_D(PHY,"SFN/SF %d/%d calculating n1_pucch0 from last_dl=%d\n", + proc->frame_tx%1024, + proc->subframe_tx, + last_dl); // i=0 - nCCE0 = ue->pdcch_vars[eNB_id]->nCCE[subframe_offset]; + nCCE0 = ue->pdcch_vars[eNB_id]->nCCE[last_dl]; n1_pucch0 = get_Np(frame_parms->N_RB_DL,nCCE0,0) + nCCE0+ frame_parms->pucch_config_common.n1PUCCH_AN; - // set ACK/NAK to values if not DTX - if (ue->dlsch[eNB_id][0]->harq_ack[subframe_offset].send_harq_status>0) // n-6 // subframe 5 is to be ACK/NAKed - harq_ack0 = ue->dlsch[eNB_id][0]->harq_ack[subframe_offset].ack; - + harq_ack0 = b[0]; if (harq_ack0!=2) { // DTX - if (SR == 0) { // last paragraph pg 68 from 36.213 (v8.6), m=0 - b[0]=(M==2) ? 1-harq_ack0 : harq_ack0; - b[1]=harq_ack0; // in case we use pucch format 1b (subframes 2,7) + if (frame_parms->frame_type == FDD ) { + if (SR == 0) { // last paragraph pg 68 from 36.213 (v8.6), m=0 + b[0]=(M==2) ? 1-harq_ack0 : harq_ack0; + b[1]=harq_ack0; // in case we use pucch format 1b (subframes 2,7) ue->pucch_sel[subframe] = 0; - return(n1_pucch0); - } else { // SR and only 0 or 1 ACKs (first 2 entries in Table 7.3-1 of 36.213) - b[0]=harq_ack0; + return(n1_pucch0); + } else { // SR and only 0 or 1 ACKs (first 2 entries in Table 7.3-1 of 36.213) + b[0]=harq_ack0; return(ue->scheduling_request_config[eNB_id].sr_PUCCH_ResourceIndex); + } + } else { + if (SR == 0) { + b[0] = harq_ack0; + b[1] = harq_ack0; + ue->pucch_sel[subframe] = 0; + return(n1_pucch0); + } else { + b[0] = harq_ack0; + b[1] = harq_ack0; + return(ue->scheduling_request_config[eNB_id].sr_PUCCH_ResourceIndex); + } } } @@ -823,20 +866,20 @@ uint16_t get_n1_pucch(PHY_VARS_UE *ue, harq_ack1 = 2; // DTX harq_ack0 = 2; // DTX // This is the offset for a particular subframe (2,3,4) => (0,2,4) - subframe_offset = (subframe-2)<<1; + last_dl = (subframe-2)<<1; // i=0 - nCCE0 = ue->pdcch_vars[eNB_id]->nCCE[5+subframe_offset]; + nCCE0 = ue->pdcch_vars[eNB_id]->nCCE[5+last_dl]; n1_pucch0 = get_Np(frame_parms->N_RB_DL,nCCE0,0) + nCCE0+ frame_parms->pucch_config_common.n1PUCCH_AN; // i=1 - nCCE1 = ue->pdcch_vars[eNB_id]->nCCE[(6+subframe_offset)%10]; + nCCE1 = ue->pdcch_vars[eNB_id]->nCCE[(6+last_dl)%10]; n1_pucch1 = get_Np(frame_parms->N_RB_DL,nCCE1,1) + nCCE1 + frame_parms->pucch_config_common.n1PUCCH_AN; // set ACK/NAK to values if not DTX - if (ue->dlsch[eNB_id][0]->harq_ack[(6+subframe_offset)%10].send_harq_status>0) // n-6 // subframe 6 is to be ACK/NAKed - harq_ack1 = ue->dlsch[eNB_id][0]->harq_ack[(6+subframe_offset)%10].ack; + if (ue->dlsch[eNB_id][0]->harq_ack[(6+last_dl)%10].send_harq_status>0) // n-6 // subframe 6 is to be ACK/NAKed + harq_ack1 = ue->dlsch[eNB_id][0]->harq_ack[(6+last_dl)%10].ack; - if (ue->dlsch[eNB_id][0]->harq_ack[5+subframe_offset].send_harq_status>0) // n-6 // subframe 5 is to be ACK/NAKed - harq_ack0 = ue->dlsch[eNB_id][0]->harq_ack[5+subframe_offset].ack; + if (ue->dlsch[eNB_id][0]->harq_ack[5+last_dl].send_harq_status>0) // n-6 // subframe 5 is to be ACK/NAKed + harq_ack0 = ue->dlsch[eNB_id][0]->harq_ack[5+last_dl].ack; if (harq_ack1!=2) { // n-6 // subframe 6,8,0 and maybe 5,7,9 is to be ACK/NAKed @@ -897,7 +940,7 @@ uint16_t get_n1_pucch(PHY_VARS_UE *ue, } // switch tdd_config } - LOG_E(PHY,"[UE%d] : Frame %d phy_procedures_lte.c: get_n1pucch, exit without proper return\n",proc->frame_tx); + LOG_E(PHY,"[UE%d] : Frame %d phy_procedures_lte.c: get_n1pucch, exit without proper return\n", ue->Mod_id, proc->frame_tx); return(-1); } @@ -934,7 +977,7 @@ uint16_t get_n1_pucch(PHY_VARS_UE *ue, */ #endif -void ulsch_common_procedures(PHY_VARS_UE *ue, UE_rxtx_proc_t *proc) { +void ulsch_common_procedures(PHY_VARS_UE *ue, UE_rxtx_proc_t *proc, uint8_t empty_subframe) { int aa; LTE_DL_FRAME_PARMS *frame_parms=&ue->frame_parms; @@ -971,6 +1014,37 @@ void ulsch_common_procedures(PHY_VARS_UE *ue, UE_rxtx_proc_t *proc) { #else //this is the normal case ulsch_start = (frame_parms->samples_per_tti*subframe_tx)-ue->N_TA_offset; //-ue->timing_advance; #endif //else EXMIMO + +#if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR) + if (empty_subframe) + { +//#if 1 + overflow = ulsch_start - 9*frame_parms->samples_per_tti; + for (aa=0; aanb_antennas_tx; aa++) { + + memset(&ue->common_vars.txdata[aa][ulsch_start],0,4*cmin(frame_parms->samples_per_tti*LTE_NUMBER_OF_SUBFRAMES_PER_FRAME,ulsch_start+frame_parms->samples_per_tti)); + + if (overflow> 0) + memset(&ue->common_vars.txdata[aa][0],0,4*overflow); + } +/*#else + overflow = ulsch_start - 9*frame_parms->samples_per_tti; + for (aa=0; aanb_antennas_tx; aa++) { + for (k=ulsch_start; ksamples_per_tti*LTE_NUMBER_OF_SUBFRAMES_PER_FRAME,ulsch_start+frame_parms->samples_per_tti); k++) { + ((short*)ue->common_vars.txdata[aa])[2*k] = 0; + ((short*)ue->common_vars.txdata[aa])[2*k+1] = 0; + } + + for (k=0; kcommon_vars.txdata[aa])[2*k] = 0; + ((short*)ue->common_vars.txdata[aa])[2*k+1] = 0; + } + } +#endif*/ + return; + } +#endif + if ((frame_tx%100) == 0) LOG_D(PHY,"[UE %d] Frame %d, subframe %d: ulsch_start = %d (rxoff %d, HW TA %d, timing advance %d, TA_offset %d\n", ue->Mod_id,frame_tx,subframe_tx, @@ -1082,7 +1156,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_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); + LOG_D(PHY,"Got prach_resources for eNB %d address %p, RRCCommon %p\n",eNB_id,ue->prach_resources[eNB_id],UE_mac_inst[ue->Mod_id].radioResourceConfigCommon); LOG_D(PHY,"Prach resources %p\n",ue->prach_resources[eNB_id]); } } @@ -1194,7 +1268,6 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB int Mod_id = ue->Mod_id; int CC_id = ue->CC_id; uint8_t Msg3_flag=0; - uint8_t ack_status=0; uint16_t first_rb, nb_rb; unsigned int input_buffer_length; int i; @@ -1202,6 +1275,8 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB int tx_amp; uint8_t ulsch_input_buffer[5477] __attribute__ ((aligned(32))); uint8_t access_mode; + uint8_t Nbundled=0; + uint8_t ack_status=0; VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX_ULSCH_UESPEC,VCD_FUNCTION_IN); @@ -1245,6 +1320,49 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB } } + if (ue->ulsch[eNB_id]->harq_processes[harq_pid]->subframe_scheduling_flag == 1) { + + uint8_t isBad = 0; + if (ue->frame_parms.N_RB_UL <= ue->ulsch[eNB_id]->harq_processes[harq_pid]->first_rb) { + LOG_D(PHY,"Invalid PUSCH first_RB=%d for N_RB_UL=%d\n", + ue->ulsch[eNB_id]->harq_processes[harq_pid]->first_rb, + ue->frame_parms.N_RB_UL); + isBad = 1; + } + if (ue->frame_parms.N_RB_UL < ue->ulsch[eNB_id]->harq_processes[harq_pid]->nb_rb) { + LOG_D(PHY,"Invalid PUSCH num_RB=%d for N_RB_UL=%d\n", + ue->ulsch[eNB_id]->harq_processes[harq_pid]->nb_rb, + ue->frame_parms.N_RB_UL); + isBad = 1; + } + if (0 > ue->ulsch[eNB_id]->harq_processes[harq_pid]->first_rb) { + LOG_D(PHY,"Invalid PUSCH first_RB=%d\n", + ue->ulsch[eNB_id]->harq_processes[harq_pid]->first_rb); + isBad = 1; + } + if (0 >= ue->ulsch[eNB_id]->harq_processes[harq_pid]->nb_rb) { + LOG_D(PHY,"Invalid PUSCH num_RB=%d\n", + ue->ulsch[eNB_id]->harq_processes[harq_pid]->nb_rb); + isBad = 1; + } + if (ue->frame_parms.N_RB_UL < (ue->ulsch[eNB_id]->harq_processes[harq_pid]->nb_rb + ue->ulsch[eNB_id]->harq_processes[harq_pid]->first_rb)) { + LOG_D(PHY,"Invalid PUSCH num_RB=%d + first_RB=%d for N_RB_UL=%d\n", + ue->ulsch[eNB_id]->harq_processes[harq_pid]->nb_rb, + ue->ulsch[eNB_id]->harq_processes[harq_pid]->first_rb, + ue->frame_parms.N_RB_UL); + isBad = 1; + } + if ((0 > ue->ulsch[eNB_id]->harq_processes[harq_pid]->rvidx) || + (3 < ue->ulsch[eNB_id]->harq_processes[harq_pid]->rvidx)) { + LOG_D(PHY,"Invalid PUSCH RV index=%d\n", ue->ulsch[eNB_id]->harq_processes[harq_pid]->rvidx); + isBad = 1; + } + + if (isBad) { + LOG_D(PHY,"Skip PUSCH generation!\n"); + ue->ulsch[eNB_id]->harq_processes[harq_pid]->subframe_scheduling_flag = 0; + } + } if (ue->ulsch[eNB_id]->harq_processes[harq_pid]->subframe_scheduling_flag == 1) { ue->generate_ul_signal[eNB_id] = 1; @@ -1254,7 +1372,7 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB LOG_D(PHY,"Generating PUSCH (Abssubframe: %d.%d): harq-Id: %d, round: %d, MaxReTrans: %d \n",frame_tx,subframe_tx,harq_pid,ue->ulsch[eNB_id]->harq_processes[harq_pid]->round,ue->ulsch[eNB_id]->Mlimit); if (ue->ulsch[eNB_id]->harq_processes[harq_pid]->round >= (ue->ulsch[eNB_id]->Mlimit - 1)) { - LOG_D(PHY,"PUSCH MAX Retransmission acheived ==> send last pusch (%d) \n"); + LOG_D(PHY,"PUSCH MAX Retransmission achieved ==> send last pusch\n"); ue->ulsch[eNB_id]->harq_processes[harq_pid]->subframe_scheduling_flag = 0; ue->ulsch[eNB_id]->harq_processes[harq_pid]->round = 0; } @@ -1263,7 +1381,7 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB ue->dlsch[eNB_id][0]->harq_ack, subframe_tx, ue->ulsch[eNB_id]->o_ACK); - + Nbundled = ack_status; first_rb = ue->ulsch[eNB_id]->harq_processes[harq_pid]->first_rb; nb_rb = ue->ulsch[eNB_id]->harq_processes[harq_pid]->nb_rb; @@ -1283,6 +1401,22 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB { ue->ulsch[eNB_id]->harq_processes[harq_pid]->O_ACK = 0; } + +#if T_TRACER + if(ue->ulsch[eNB_id]->o_ACK[0]) + { + LOG_I(PHY,"PUSCH ACK\n"); + T(T_UE_PHY_DLSCH_UE_ACK, T_INT(eNB_id), T_INT(frame_tx%1024), T_INT(subframe_tx), T_INT(Mod_id), T_INT(ue->dlsch[eNB_id][0]->rnti), + T_INT(ue->dlsch[eNB_id][0]->current_harq_pid)); + } + else + { + LOG_I(PHY,"PUSCH NACK\n"); + T(T_UE_PHY_DLSCH_UE_NACK, T_INT(eNB_id), T_INT(frame_tx%1024), T_INT(subframe_tx), T_INT(Mod_id), T_INT(ue->dlsch[eNB_id][0]->rnti), + T_INT(ue->dlsch[eNB_id][0]->current_harq_pid)); + } +#endif + LOG_D(PHY,"[UE %d][PDSCH %x] Frame %d subframe %d Generating ACK (%d,%d) for %d bits on PUSCH\n", Mod_id, ue->ulsch[eNB_id]->rnti, @@ -1292,8 +1426,8 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB } #ifdef DEBUG_PHY_PROC - LOG_D(PHY, - "[UE %d][PUSCH %d] Frame %d subframe %d Generating PUSCH : first_rb %d, nb_rb %d, round %d, mcs %d, rv %d, cyclic_shift %d (cyclic_shift_common %d,n_DMRS2 %d,n_PRS %d), ACK (%d,%d), O_ACK %d\n", + LOG_D(PHY, + "[UE %d][PUSCH %d] Frame %d subframe %d Generating PUSCH : first_rb %d, nb_rb %d, round %d, mcs %d, rv %d, cyclic_shift %d (cyclic_shift_common %d,n_DMRS2 %d,n_PRS %d), ACK (%d,%d), O_ACK %d, bundling %d\n", Mod_id,harq_pid,frame_tx,subframe_tx, first_rb,nb_rb, ue->ulsch[eNB_id]->harq_processes[harq_pid]->round, @@ -1306,7 +1440,8 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB ue->ulsch[eNB_id]->harq_processes[harq_pid]->n_DMRS2, ue->frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.nPRS[subframe_tx<<1], ue->ulsch[eNB_id]->o_ACK[0],ue->ulsch[eNB_id]->o_ACK[1], - ue->ulsch[eNB_id]->harq_processes[harq_pid]->O_ACK); + ue->ulsch[eNB_id]->harq_processes[harq_pid]->O_ACK, + ue->ulsch[eNB_id]->bundling); #endif @@ -1408,8 +1543,8 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB ue, harq_pid, eNB_id, - ue->transmission_mode[eNB_id],0, - 0)!=0) { // Nbundled, to be updated!!!! + ue->transmission_mode[eNB_id],0, + Nbundled)!=0) { LOG_E(PHY,"ulsch_coding.c: FATAL ERROR: returning\n"); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX, VCD_FUNCTION_OUT); stop_meas(&ue->phy_proc_tx); @@ -1443,6 +1578,10 @@ void ue_ulsch_uespec_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB nb_rb); #else tx_amp = AMP; +#endif +#if T_TRACER + T(T_UE_PHY_PUSCH_TX_POWER, T_INT(eNB_id),T_INT(Mod_id), T_INT(frame_tx%1024), T_INT(subframe_tx),T_INT(ue->tx_power_dBm[subframe_tx]), + T_INT(tx_amp),T_INT(ue->ulsch[eNB_id]->f_pusch),T_INT(get_PL(Mod_id,0,eNB_id)),T_INT(nb_rb)); #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[subframe_tx],ue->tx_power_max_dBm, tx_amp); @@ -1569,7 +1708,8 @@ void ue_pucch_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin int Mod_id = ue->Mod_id; int CC_id = ue->CC_id; int tx_amp; - int8_t Po_PUCCH; + int16_t Po_PUCCH; + uint8_t ack_status=0; VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX_PUCCH,VCD_FUNCTION_IN); @@ -1588,6 +1728,7 @@ void ue_pucch_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin if(ue->ulsch[eNB_id]->harq_processes[harq_pid]->subframe_scheduling_flag) { LOG_D(PHY,"PUSCH is programmed on this subframe [pid %d] AbsSuframe %d.%d ==> Skip PUCCH transmission \n",harq_pid,frame_tx,subframe_tx); + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX_PUCCH,VCD_FUNCTION_OUT); return; } @@ -1633,18 +1774,24 @@ void ue_pucch_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin SR_payload=0; } - if (get_ack(&ue->frame_parms, - ue->dlsch[eNB_id][0]->harq_ack, - subframe_tx,pucch_ack_payload) > 0) { + ack_status = get_ack(&ue->frame_parms, + ue->dlsch[eNB_id][0]->harq_ack, + subframe_tx,pucch_ack_payload); + if (ack_status > 0) { // we need to transmit ACK/NAK in this subframe ue->generate_ul_signal[eNB_id] = 1; + if ((frame_parms->frame_type == TDD) && (SR_payload>0)) { + format = pucch_format1b; + } + n1_pucch = get_n1_pucch(ue, - proc, - eNB_id, - pucch_ack_payload, - SR_payload); + proc, + ue->dlsch[eNB_id][0]->harq_ack, + eNB_id, + pucch_ack_payload, + SR_payload); if (ue->mac_enabled == 1) { Po_PUCCH = pucch_power_cntl(ue,proc,subframe_tx,eNB_id,format); @@ -1663,29 +1810,51 @@ void ue_pucch_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin #else tx_amp = AMP; #endif - +#if T_TRACER + T(T_UE_PHY_PUCCH_TX_POWER, T_INT(eNB_id),T_INT(Mod_id), T_INT(frame_tx%1024), T_INT(subframe_tx),T_INT(ue->tx_power_dBm[subframe_tx]), + T_INT(tx_amp),T_INT(ue->dlsch[eNB_id][0]->g_pucch),T_INT(get_PL(ue->Mod_id,ue->CC_id,eNB_id))); +#endif if (SR_payload>0) { - LOG_D(PHY,"[UE %d][SR %x] Frame %d subframe %d Generating PUCCH 1a/1b payload %d,%d (with SR for PUSCH), an_srs_simultanous %d, shorten_pucch %d, n1_pucch %d, Po_PUCCH, amp %d\n", + LOG_D(PHY,"[UE %d][SR %x] AbsSubFrame %d.%d Generating PUCCH %s payload %d,%d (with SR for PUSCH), an_srs_simultanous %d, shorten_pucch %d, n1_pucch %d, Po_PUCCH %d, amp %d\n", Mod_id, ue->dlsch[eNB_id][0]->rnti, - frame_parms->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission, - isShortenPucch, - frame_tx, subframe_tx, + frame_tx % 1024, subframe_tx, + (format == pucch_format1a? "1a": ( + format == pucch_format1b? "1b" : "??")), pucch_ack_payload[0],pucch_ack_payload[1], + frame_parms->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission, + isShortenPucch, ue->scheduling_request_config[eNB_id].sr_PUCCH_ResourceIndex, Po_PUCCH, tx_amp); } else { - LOG_D(PHY,"[UE %d][PDSCH %x] Frame %d subframe %d Generating PUCCH 1a/1b, an_srs_simultanous %d, shorten_pucch %d, n1_pucch %d, b[0]=%d,b[1]=%d (SR_Payload %d), Po_PUCCH %d, amp %d\n", + LOG_D(PHY,"[UE %d][PDSCH %x] AbsSubFrame %d.%d rx_offset_diff: %d, Generating PUCCH %s, an_srs_simultanous %d, shorten_pucch %d, n1_pucch %d, b[0]=%d,b[1]=%d (SR_Payload %d), Po_PUCCH %d, amp %d\n", Mod_id, ue->dlsch[eNB_id][0]->rnti, - frame_tx, subframe_tx, + frame_tx, subframe_tx,ue->rx_offset_diff, + (format == pucch_format1a? "1a": ( + format == pucch_format1b? "1b" : "??")), frame_parms->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission, isShortenPucch, n1_pucch,pucch_ack_payload[0],pucch_ack_payload[1],SR_payload, Po_PUCCH, tx_amp); } + +#if T_TRACER + if(pucch_ack_payload[0]) + { + LOG_I(PHY,"PUCCH ACK\n"); + T(T_UE_PHY_DLSCH_UE_ACK, T_INT(eNB_id), T_INT(frame_tx%1024), T_INT(subframe_tx), T_INT(Mod_id), T_INT(ue->dlsch[eNB_id][0]->rnti), + T_INT(ue->dlsch[eNB_id][0]->current_harq_pid)); + } + else + { + LOG_I(PHY,"PUCCH NACK\n"); + T(T_UE_PHY_DLSCH_UE_NACK, T_INT(eNB_id), T_INT(frame_tx%1024), T_INT(subframe_tx), T_INT(Mod_id), T_INT(ue->dlsch[eNB_id][0]->rnti), + T_INT(ue->dlsch[eNB_id][0]->current_harq_pid)); + } +#endif if (abstraction_flag == 0) { @@ -1729,6 +1898,10 @@ void ue_pucch_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin 1); #else tx_amp = AMP; +#endif +#if T_TRACER + T(T_UE_PHY_PUCCH_TX_POWER, T_INT(eNB_id),T_INT(Mod_id), T_INT(frame_tx%1024), T_INT(subframe_tx),T_INT(ue->tx_power_dBm[subframe_tx]), + T_INT(tx_amp),T_INT(ue->dlsch[eNB_id][0]->g_pucch),T_INT(get_PL(ue->Mod_id,ue->CC_id,eNB_id))); #endif LOG_D(PHY,"[UE %d][SR %x] Frame %d subframe %d Generating PUCCH 1 (SR for PUSCH), an_srs_simultanous %d, shorten_pucch %d, n1_pucch %d, Po_PUCCH %d\n", Mod_id, @@ -1793,6 +1966,10 @@ void ue_pucch_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin 1); #else tx_amp = AMP; +#endif +#if T_TRACER + T(T_UE_PHY_PUCCH_TX_POWER, T_INT(eNB_id),T_INT(Mod_id), T_INT(frame_tx%1024), T_INT(subframe_tx),T_INT(ue->tx_power_dBm[subframe_tx]), + T_INT(tx_amp),T_INT(ue->dlsch[eNB_id][0]->g_pucch),T_INT(get_PL(ue->Mod_id,ue->CC_id,eNB_id))); #endif LOG_D(PHY,"[UE %d][RNTI %x] AbsSubFrame %d.%d Generating PUCCH 2 (CQI), n2_pucch %d, Po_PUCCH %d, isShortenPucch %d, amp %d\n", Mod_id, @@ -1833,7 +2010,10 @@ void ue_pucch_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin } ue->tx_power_dBm[subframe_tx] = Po_PUCCH; ue->tx_total_RE[subframe_tx] = 12; - +#if T_TRACER + T(T_UE_PHY_PUCCH_TX_POWER, T_INT(eNB_id),T_INT(Mod_id), T_INT(frame_tx%1024), T_INT(subframe_tx),T_INT(ue->tx_power_dBm[subframe_tx]), + T_INT(tx_amp),T_INT(ue->dlsch[eNB_id][0]->g_pucch),T_INT(get_PL(ue->Mod_id,ue->CC_id,eNB_id))); +#endif #if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR) tx_amp = get_tx_amp(Po_PUCCH, ue->tx_power_max_dBm, @@ -1869,22 +2049,29 @@ void ue_pucch_procedures(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin ue->generate_ul_signal[eNB_id] = 1; } } + + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX_PUCCH,VCD_FUNCTION_OUT); + } void phy_procedures_UE_TX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uint8_t abstraction_flag,runmode_t mode,relaying_type_t r_type) { LTE_DL_FRAME_PARMS *frame_parms=&ue->frame_parms; - int32_t ulsch_start=0; + //int32_t ulsch_start=0; int subframe_tx = proc->subframe_tx; int frame_tx = proc->frame_tx; unsigned int aa; - + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX,VCD_FUNCTION_IN); +#if T_TRACER + T(T_UE_PHY_UL_TICK, T_INT(ue->Mod_id), T_INT(frame_tx%1024), T_INT(subframe_tx)); +#endif + ue->generate_ul_signal[eNB_id] = 0; start_meas(&ue->phy_proc_tx); @@ -1978,25 +2165,7 @@ void phy_procedures_UE_TX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,ui if (abstraction_flag == 0) { - - if (ue->generate_ul_signal[eNB_id] == 1 ) - { - ulsch_common_procedures(ue,proc); - } - else { // no uplink so clear signal buffer instead -#if defined(EXMIMO) || defined(OAI_USRP) || defined(OAI_BLADERF) || defined(OAI_LMSSDR)//this is the EXPRESS MIMO case - ulsch_start = (ue->rx_offset+subframe_tx*frame_parms->samples_per_tti- - ue->hw_timing_advance- - ue->timing_advance- - ue->N_TA_offset+5)%(LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*frame_parms->samples_per_tti); -#else //this is the normal case - ulsch_start = (frame_parms->samples_per_tti*subframe_tx)-ue->N_TA_offset; //-ue->timing_advance; -#endif //else EXMIMO - for (aa=0; aanb_antennas_tx; aa++) { - memset(&ue->common_vars.txdata[aa][ulsch_start],0,frame_parms->samples_per_tti<<2); - } - } - + ulsch_common_procedures(ue,proc, (ue->generate_ul_signal[eNB_id] == 0)); } // mode != PRACH @@ -2014,6 +2183,17 @@ void phy_procedures_UE_TX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,ui ue->generate_prach=0; } + // reset DL ACK/NACK status + reset_ack(&ue->frame_parms, + ue->dlsch[eNB_id][0]->harq_ack, + subframe_tx, + ue->ulsch[eNB_id]->o_ACK); + + reset_ack(&ue->frame_parms, + ue->dlsch_SI[eNB_id]->harq_ack, + subframe_tx, + ue->ulsch[eNB_id]->o_ACK); + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_TX, VCD_FUNCTION_OUT); stop_meas(&ue->phy_proc_tx); @@ -2042,7 +2222,11 @@ void phy_procedures_UE_S_TX(PHY_VARS_UE *ue,uint8_t eNB_id,uint8_t abstraction_f } } -void ue_measurement_procedures(uint16_t l, PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uint8_t eNB_id,uint8_t abstraction_flag,runmode_t mode) +void ue_measurement_procedures( + uint16_t l, // symbol index of each slot [0..6] + PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uint8_t eNB_id, + uint16_t slot, // slot index of each radio frame [0..19] + uint8_t abstraction_flag,runmode_t mode) { LTE_DL_FRAME_PARMS *frame_parms=&ue->frame_parms; @@ -2059,13 +2243,25 @@ void ue_measurement_procedures(uint16_t l, PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, lte_ue_measurements(ue, (subframe_rx*frame_parms->samples_per_tti+ue->rx_offset)%(frame_parms->samples_per_tti*LTE_NUMBER_OF_SUBFRAMES_PER_FRAME), (subframe_rx == 1) ? 1 : 0, - 0); + 0,subframe_rx); } else { lte_ue_measurements(ue, 0, 0, - 1); + 1, + subframe_rx); } +#if T_TRACER + if(slot == 0) + T(T_UE_PHY_MEAS, T_INT(eNB_id), T_INT(ue->Mod_id), T_INT(proc->frame_rx%1024), T_INT(proc->subframe_rx), + T_INT((int)(10*log10(ue->measurements.rsrp[0])-ue->rx_total_gain_dB)), + T_INT((int)ue->measurements.rx_rssi_dBm[0]), + T_INT((int)(ue->measurements.rx_power_avg_dB[0] - ue->measurements.n0_power_avg_dB)), + T_INT((int)ue->measurements.rx_power_avg_dB[0]), + T_INT((int)ue->measurements.n0_power_avg_dB), + T_INT((int)ue->measurements.wideband_cqi_avg[0]), + T_INT((int)ue->common_vars.freq_offset)); +#endif } if (l==(6-ue->frame_parms.Ncp)) { @@ -2074,16 +2270,16 @@ void ue_measurement_procedures(uint16_t l, PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_RRC_MEASUREMENTS, VCD_FUNCTION_IN); ue_rrc_measurements(ue, - subframe_rx, + slot, abstraction_flag); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_RRC_MEASUREMENTS, VCD_FUNCTION_OUT); if (abstraction_flag==1) - ue->sinr_eff = sinr_eff_cqi_calc(ue, 0); + ue->sinr_eff = sinr_eff_cqi_calc(ue, 0, subframe_rx); } - if ((subframe_rx==0) && (l==(4-frame_parms->Ncp))) { + if ((subframe_rx==0) && (slot == 0) && (l==(4-frame_parms->Ncp))) { // AGC @@ -2106,6 +2302,7 @@ void ue_measurement_procedures(uint16_t l, PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, lte_adjust_synch(&ue->frame_parms, ue, eNB_id, + subframe_rx, 0, 16384); } @@ -2378,7 +2575,7 @@ void ue_pbch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc, uin } else if (((frame_tx & 0x03FF) != (proc->frame_rx & 0x03FF))) { //(pbch_tx_ant != ue->frame_parms.nb_antennas_tx)) { - LOG_D(PHY,"[UE %d] frame %d, subframe %d: Re-adjusting frame counter (PBCH ant_tx=%d, frame_rx=%d, frame%1024=%d, phase %d).\n", + LOG_D(PHY,"[UE %d] frame %d, subframe %d: Re-adjusting frame counter (PBCH ant_tx=%d, frame_rx=%d, frame%%1024=%d, phase %d).\n", ue->Mod_id, proc->frame_rx, subframe_rx, @@ -2482,6 +2679,7 @@ int ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint rx_pdcch(&ue->common_vars, ue->pdcch_vars, &ue->frame_parms, + proc->frame_rx, subframe_rx, eNB_id, (ue->frame_parms.mode1_flag == 1) ? SISO : ALAMOUTI, @@ -2556,9 +2754,7 @@ int ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint #endif - LOG_D(PHY,"[UE %d] Frame %d, subframe %d, Mode %s: DCI found %i\n",ue->Mod_id,frame_rx,subframe_rx,mode_string[ue->UE_mode[eNB_id]],dci_cnt); - - + LOG_D(PHY,"[UE %d] AbsSubFrame %d.%d, Mode %s: DCI found %i\n",ue->Mod_id,frame_rx%1024,subframe_rx,mode_string[ue->UE_mode[eNB_id]],dci_cnt); ue->pdcch_vars[eNB_id]->dci_received += dci_cnt; @@ -2587,7 +2783,7 @@ int ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint - // dump_dci(&ue->frame_parms, &dci_alloc_rx[i]); + //dump_dci(&ue->frame_parms, &dci_alloc_rx[i]); if ((ue->UE_mode[eNB_id] > PRACH) && (generate_ue_dlsch_params_from_dci(frame_rx, subframe_rx, @@ -2600,7 +2796,17 @@ int ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint SI_RNTI, 0, P_RNTI, - ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id])==0)) { + ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id], + ue->pdcch_vars[eNB_id]->crnti_is_temporary? ue->pdcch_vars[eNB_id]->crnti: 0)==0)) { + + // update TPC for PUCCH + if((dci_alloc_rx[i].format == format1) || + (dci_alloc_rx[i].format == format1A) || + (dci_alloc_rx[i].format == format2) || + (dci_alloc_rx[i].format == format2A)) + { + ue->dlsch[eNB_id][0]->g_pucch += ue->dlsch[eNB_id][0]->harq_processes[ue->dlsch[eNB_id][0]->current_harq_pid]->delta_PUCCH; + } ue->dlsch_received[eNB_id]++; @@ -2644,7 +2850,8 @@ int ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint SI_RNTI, 0, P_RNTI, - ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id])==0) { + ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id], + 0)==0) { ue->dlsch_SI_received[eNB_id]++; @@ -2674,7 +2881,8 @@ int ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint SI_RNTI, 0, P_RNTI, - ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id])==0) { + ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id], + 0)==0) { ue->dlsch_p_received[eNB_id]++; @@ -2709,7 +2917,8 @@ int ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint SI_RNTI, ue->prach_resources[eNB_id]->ra_RNTI, P_RNTI, - ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id])==0) { + ue->transmission_mode[eNB_id]<7?0:ue->transmission_mode[eNB_id], + 0)==0) { ue->dlsch_ra_received[eNB_id]++; @@ -2742,6 +2951,20 @@ int ue_pdcch_procedures(uint8_t eNB_id,PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint eNB_id, 0)==0)) { +#if T_TRACER + LTE_DL_FRAME_PARMS *frame_parms = &ue->frame_parms; + uint8_t harq_pid = subframe2harq_pid(frame_parms, + pdcch_alloc2ul_frame(frame_parms,proc->frame_rx,proc->subframe_rx), + pdcch_alloc2ul_subframe(frame_parms,proc->subframe_rx)); + + T(T_UE_PHY_ULSCH_UE_DCI, T_INT(eNB_id), T_INT(proc->frame_rx%1024), T_INT(proc->subframe_rx), T_INT(ue->Mod_id), + T_INT(dci_alloc_rx[i].rnti), T_INT(harq_pid), + T_INT(ue->ulsch[eNB_id]->harq_processes[harq_pid]->mcs), + T_INT(ue->ulsch[eNB_id]->harq_processes[harq_pid]->round), + T_INT(ue->ulsch[eNB_id]->harq_processes[harq_pid]->first_rb), + T_INT(ue->ulsch[eNB_id]->harq_processes[harq_pid]->nb_rb), + T_INT(ue->ulsch[eNB_id]->harq_processes[harq_pid]->TBS)); +#endif #ifdef DEBUG_PHY_PROC LOG_D(PHY,"[UE %d] Generate UE ULSCH C_RNTI format 0 (subframe %d)\n",ue->Mod_id,subframe_rx); #endif @@ -2871,6 +3094,7 @@ void ue_pmch_procedures(PHY_VARS_UE *ue, UE_rxtx_proc_t *proc,int eNB_id,int abs &ue->frame_parms, ue->dlsch_MCH[0], ue->dlsch_MCH[0]->harq_processes[0], + frame_rx, subframe_rx, 0, 0,1); @@ -2895,7 +3119,8 @@ void ue_pmch_procedures(PHY_VARS_UE *ue, UE_rxtx_proc_t *proc,int eNB_id,int abs ue->dlsch_mtch_errors[sync_area][0]++; LOG_D(PHY,"[UE %d] Frame %d, subframe %d: PMCH in error (%d,%d), not passing to L2 (TBS %d, iter %d,G %d)\n", - frame_rx,subframe_rx, + ue->Mod_id, + frame_rx,subframe_rx, ue->dlsch_mcch_errors[sync_area][0], ue->dlsch_mtch_errors[sync_area][0], ue->dlsch_MCH[0]->harq_processes[0]->TBS>>3, @@ -2957,7 +3182,7 @@ void ue_pdsch_procedures(PHY_VARS_UE *ue, UE_rxtx_proc_t *proc, int eNB_id, PDSC if (dlsch0 && (!dlsch1)) { harq_pid = dlsch0->current_harq_pid; - LOG_D(PHY,"[UE %d] PDSCH active in subframe %d (%d), harq_pid %d\n",ue->Mod_id,subframe_rx,harq_pid); + LOG_D(PHY,"[UE %d] PDSCH active in subframe %d, harq_pid %d\n",ue->Mod_id,subframe_rx,harq_pid); if ((pdsch==PDSCH) && (ue->transmission_mode[eNB_id] == 5) && @@ -2994,6 +3219,7 @@ void ue_pdsch_procedures(PHY_VARS_UE *ue, UE_rxtx_proc_t *proc, int eNB_id, PDSC pdsch, eNB_id, eNB_id_i, + proc->frame_rx, subframe_rx, // subframe, m, first_symbol_flag, @@ -3046,6 +3272,9 @@ void process_rar(PHY_VARS_UE *ue, UE_rxtx_proc_t *proc, int eNB_id, runmode_t mo ue->pdcch_vars[eNB_id]->crnti, timing_advance); + // remember this c-rnti is still a tc-rnti + ue->pdcch_vars[eNB_id]->crnti_is_temporary = 1; + //timing_advance = 0; process_timing_advance_rar(ue,proc,timing_advance); @@ -3117,7 +3346,7 @@ void ue_dlsch_procedures(PHY_VARS_UE *ue, pdsch_vars = ue->pdsch_vars_p[eNB_id]; break; case PDSCH: - pdsch_vars = ue->pdsch_vars[eNB_id]; + pdsch_vars = ue->pdsch_vars[subframe_rx&0x1][eNB_id]; break; case PMCH: case PDSCH1: @@ -3174,6 +3403,7 @@ void ue_dlsch_procedures(PHY_VARS_UE *ue, &ue->frame_parms, dlsch0, dlsch0->harq_processes[harq_pid], + frame_rx, subframe_rx, harq_pid, pdsch==PDSCH?1:0, @@ -3233,6 +3463,7 @@ void ue_dlsch_procedures(PHY_VARS_UE *ue, mac_xface->ue_send_sdu(ue->Mod_id, CC_id, frame_rx, + subframe_rx, dlsch0->harq_processes[dlsch0->current_harq_pid]->b, dlsch0->harq_processes[dlsch0->current_harq_pid]->TBS>>3, eNB_id); @@ -3308,10 +3539,17 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin int frame_rx = proc->frame_rx; int subframe_rx = proc->subframe_rx; - + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_UE_RX, VCD_FUNCTION_IN); +#if T_TRACER + T(T_UE_PHY_DL_TICK, T_INT(ue->Mod_id), T_INT(frame_rx%1024), T_INT(subframe_rx)); +#endif + + T(T_UE_PHY_INPUT_SIGNAL, T_INT(ue->Mod_id), T_INT(frame_rx%1024), T_INT(subframe_rx), T_INT(0), + T_BUFFER(&ue->common_vars.rxdata[0][subframe_rx*ue->frame_parms.samples_per_tti], + ue->frame_parms.samples_per_tti * 4)); start_meas(&ue->phy_proc_rx); @@ -3333,7 +3571,7 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin #ifdef DEBUG_PHY_PROC - LOG_D(PHY,"[%s %d] Frame %d subframe %d: Doing phy_procedures_UE_RX (%d)\n", + LOG_D(PHY,"[%s %d] Frame %d subframe %d: Doing phy_procedures_UE_RX\n", (r_type == multicast_relay) ? "RN/UE" : "UE", ue->Mod_id,frame_rx, subframe_rx); #endif @@ -3372,14 +3610,14 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin slot_fep(ue, l, (subframe_rx<<1), - ue->rx_offset, + 0, 0, 0); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP, VCD_FUNCTION_OUT); stop_meas(&ue->ofdm_demod_stats); } - ue_measurement_procedures(l-1,ue,proc,eNB_id,abstraction_flag,mode); + ue_measurement_procedures(l-1,ue,proc,eNB_id,(subframe_rx<<1),abstraction_flag,mode); if ((l==pilot1) || ((pmch_flag==1)&(l==l2))) { LOG_D(PHY,"[UE %d] Frame %d: Calling pdcch procedures (eNB %d)\n",ue->Mod_id,frame_rx,eNB_id); @@ -3392,7 +3630,7 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin } } // for l=1..l2 - ue_measurement_procedures(l-1,ue,proc,eNB_id,abstraction_flag,mode); + ue_measurement_procedures(l-1,ue,proc,eNB_id,(subframe_rx<<1),abstraction_flag,mode); // If this is PMCH, call procedures and return if (pmch_flag == 1) { @@ -3403,7 +3641,7 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin slot_fep(ue, 0, 1+(subframe_rx<<1), - ue->rx_offset, + 0, 0, 0); @@ -3476,14 +3714,14 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin slot_fep(ue, l, 1+(subframe_rx<<1), - ue->rx_offset, + 0, 0, 0); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SLOT_FEP, VCD_FUNCTION_OUT); stop_meas(&ue->ofdm_demod_stats); } - ue_measurement_procedures(l-1,ue,proc,eNB_id,abstraction_flag,mode); + ue_measurement_procedures(l-1,ue,proc,eNB_id,1+(subframe_rx<<1),abstraction_flag,mode); } // for l=1..l2 @@ -3494,7 +3732,7 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin slot_fep(ue, 0, (next_subframe_rx<<1), - ue->rx_offset, + 0, 0, 0); } @@ -3528,10 +3766,6 @@ int phy_procedures_UE_RX(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uin VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDSCH_PROC, VCD_FUNCTION_OUT); } - else { - // printf("PDSCH inactive in subframe %d\n",subframe_rx-1); - ue->dlsch[eNB_id][0]->harq_ack[subframe_rx].send_harq_status = 0; - } // do procedures for SI-RNTI if ((ue->dlsch_SI[eNB_id]) && (ue->dlsch_SI[eNB_id]->active == 1)) { diff --git a/openair1/SCHED/pucch_pc.c b/openair1/SCHED/pucch_pc.c index 2795fe65a931d0c0f3c88764e59ac37b54876938..e19d3ad8c4cf3863421f9eae0b36c05be8b55bde 100644 --- a/openair1/SCHED/pucch_pc.c +++ b/openair1/SCHED/pucch_pc.c @@ -34,10 +34,10 @@ #include "PHY/LTE_TRANSPORT/proto.h" #include "PHY/extern.h" -int8_t pucch_power_cntl(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t subframe,uint8_t eNB_id,PUCCH_FMT_t pucch_fmt) +int16_t pucch_power_cntl(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t subframe,uint8_t eNB_id,PUCCH_FMT_t pucch_fmt) { - int8_t Po_PUCCH; + int16_t Po_PUCCH; //uint8_t harq_pid; // P_pucch = P_opucch+ PL + h(nCQI,nHARQ) + delta_pucchF(pucch_fmt) + g(i)) diff --git a/openair1/SCHED/pusch_pc.c b/openair1/SCHED/pusch_pc.c index fca0fdc441aa26e3c0a1af6484b5595229b04548..6e3c600c76067e37462692030cb55774403e6beb 100644 --- a/openair1/SCHED/pusch_pc.c +++ b/openair1/SCHED/pusch_pc.c @@ -103,13 +103,13 @@ int16_t get_hundred_times_delta_IF_mac(module_id_t module_idP, uint8_t CC_id, rn int16_t get_hundred_times_delta_IF(PHY_VARS_UE *ue,uint8_t eNB_id,uint8_t harq_pid) { - uint32_t Nre = ue->ulsch[eNB_id]->harq_processes[harq_pid]->Nsymb_initial * + uint32_t Nre = 2*ue->ulsch[eNB_id]->harq_processes[harq_pid]->Nsymb_initial * ue->ulsch[eNB_id]->harq_processes[harq_pid]->nb_rb*12; if (Nre==0) return(0); - uint32_t MPR_x100 = 100*ue->ulsch[eNB_id]->harq_processes[harq_pid]->sumKr/Nre; + uint32_t MPR_x100 = 100*ue->ulsch[eNB_id]->harq_processes[harq_pid]->TBS/Nre; // Note: MPR=is the effective spectral efficiency of the PUSCH // FK 20140908 sumKr is only set after the ulsch_encoding @@ -137,7 +137,7 @@ void pusch_power_cntl(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uint8_ proc->subframe_tx); uint8_t nb_rb = ue->ulsch[eNB_id]->harq_processes[harq_pid]->nb_rb; - int8_t PL; + int16_t PL; // P_pusch = 10*log10(nb_rb + P_opusch(j)+ alpha(u)*PL + delta_TF(i) + f(i)) @@ -174,8 +174,8 @@ void pusch_power_cntl(PHY_VARS_UE *ue,UE_rxtx_proc_t *proc,uint8_t eNB_id,uint8_ else if (ue->ulsch[eNB_id]->PHR > 40) ue->ulsch[eNB_id]->PHR = 40; - LOG_D(PHY,"[UE %d][PUSCH %d] frame %d, subframe %d: Po_PUSCH %d dBm : tx power %d, Po_NOMINAL_PUSCH %d,log10(NPRB) %f,PHR %d, PL %d, alpha*PL %f,delta_IF %f,f_pusch %d\n", - ue->Mod_id,harq_pid,proc->frame_tx,proc->subframe_tx, + LOG_D(PHY,"[UE %d][PUSCH %d] AbsSubframe %d.%d: nb_rb: %d, Po_PUSCH %d dBm : tx power %d, Po_NOMINAL_PUSCH %d,log10(NPRB) %f,PHR %d, PL %d, alpha*PL %f,delta_IF %f,f_pusch %d\n", + ue->Mod_id,harq_pid,proc->frame_tx,proc->subframe_tx,nb_rb, ue->ulsch[eNB_id]->Po_PUSCH, ue->tx_power_max_dBm, ue->frame_parms.ul_power_control_config_common.p0_NominalPUSCH, diff --git a/openair1/SIMULATION/LTE_PHY/dlsim.c b/openair1/SIMULATION/LTE_PHY/dlsim.c index f9a8acfa85cbcd5ffac2014489e83e62472c2e48..62b4063d298eacfe89f66e70831181dbab1d2d53 100644 --- a/openair1/SIMULATION/LTE_PHY/dlsim.c +++ b/openair1/SIMULATION/LTE_PHY/dlsim.c @@ -1812,6 +1812,11 @@ int main(int argc, char **argv) eNB->common_vars.beam_weights[0][0][aa][re] = 0x00007fff/eNB->frame_parms.nb_antennas_tx; } + if (transmission_mode<7) + eNB->do_precoding=0; + else + eNB->do_precoding=1; + eNB->mac_enabled=1; if (two_thread_flag == 0) { eNB->te = dlsch_encoding; @@ -2409,12 +2414,14 @@ int main(int argc, char **argv) do_OFDM_mod_symbol(&eNB->common_vars, eNB_id, (subframe*2), - &eNB->frame_parms); + &eNB->frame_parms, + eNB->do_precoding); do_OFDM_mod_symbol(&eNB->common_vars, eNB_id, (subframe*2)+1, - &eNB->frame_parms); + &eNB->frame_parms, + eNB->do_precoding); stop_meas(&eNB->ofdm_mod_stats); @@ -2502,34 +2509,34 @@ int main(int argc, char **argv) //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); + write_output("rxsigF0.m","rxsF0", &UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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("rxsigF1.m","rxsF1", UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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,subframe,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); @@ -2587,7 +2594,7 @@ int main(int argc, char **argv) write_output(fname,vname, &UE->common_vars.rxdata[0][0],10*UE->frame_parms.samples_per_tti,1,1); sprintf(fname,"rxsigF0_r%d.m",round); sprintf(vname,"rxs0F_r%d",round); - write_output(fname,vname, &UE->common_vars.rxdataF[0][0],UE->frame_parms.ofdm_symbol_size*nsymb,1,1); + write_output(fname,vname, &UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[0][0],UE->frame_parms.ofdm_symbol_size*nsymb,1,1); if (UE->frame_parms.nb_antennas_rx>1) { sprintf(fname,"rxsig1_r%d.m",round); @@ -2595,20 +2602,20 @@ int main(int argc, char **argv) write_output(fname,vname, UE->common_vars.rxdata[1],UE->frame_parms.samples_per_tti,1,1); sprintf(fname,"rxsigF1_r%d.m",round); sprintf(vname,"rxs1F_r%d.m",round); - write_output(fname,vname, UE->common_vars.rxdataF[1],UE->frame_parms.ofdm_symbol_size*nsymb,1,1); + write_output(fname,vname, UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[1],UE->frame_parms.ofdm_symbol_size*nsymb,1,1); } sprintf(fname,"dlsch00_r%d.m",round); sprintf(vname,"dl00_r%d",round); write_output(fname,vname, - &(UE->common_vars.dl_ch_estimates[eNB_id][0][0]), + &(UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][0][0]), UE->frame_parms.ofdm_symbol_size*nsymb,1,1); if (UE->frame_parms.nb_antennas_rx>1) { sprintf(fname,"dlsch01_r%d.m",round); sprintf(vname,"dl01_r%d",round); write_output(fname,vname, - &(UE->common_vars.dl_ch_estimates[eNB_id][1][0]), + &(UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][1][0]), UE->frame_parms.ofdm_symbol_size*nsymb/2,1,1); } @@ -2616,7 +2623,7 @@ int main(int argc, char **argv) sprintf(fname,"dlsch10_r%d.m",round); sprintf(vname,"dl10_r%d",round); write_output(fname,vname, - &(UE->common_vars.dl_ch_estimates[eNB_id][2][0]), + &(UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][2][0]), UE->frame_parms.ofdm_symbol_size*nsymb/2,1,1); } @@ -2624,12 +2631,12 @@ int main(int argc, char **argv) sprintf(fname,"dlsch11_r%d.m",round); sprintf(vname,"dl11_r%d",round); write_output(fname,vname, - &(UE->common_vars.dl_ch_estimates[eNB_id][3][0]), + &(UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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,subframe,coded_bits_per_codeword,round); //write_output("dlsch_e.m","e",eNB->dlsch[0][0]->harq_processes[0]->e,coded_bits_per_codeword,1,4); //write_output("dlsch_ber_bit.m","ber_bit",uncoded_ber_bit,coded_bits_per_codeword,1,0); diff --git a/openair1/SIMULATION/LTE_PHY/dlsim_tm7.c b/openair1/SIMULATION/LTE_PHY/dlsim_tm7.c index 66dea185de1a039af9cdda09e6660961af5837f6..874af41f45c3c4cb9cb951c6eb543f0503a47f6f 100644 --- a/openair1/SIMULATION/LTE_PHY/dlsim_tm7.c +++ b/openair1/SIMULATION/LTE_PHY/dlsim_tm7.c @@ -3104,24 +3104,24 @@ PMI_FEEDBACK: for(aa=0; aanb_antenna_ports_eNB; aa++) { for (aarx=0; aarxnb_antennas_rx; aarx++) { for (i=0; iN_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)( + ((int16_t *) UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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); //printf("x=%d,AMP=%d\n",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)( + ((int16_t *) UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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); if (transmission_mode == 7){ //this should include the BF weights! Will not work for a random channel if (UE->high_speed_flag==0) { - ((int16_t *)UE->pdsch_vars[0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i]=(int16_t)( + ((int16_t *)UE->pdsch_vars[subframe&0x1][0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i]=(int16_t)( eNB2UE[round]->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].x*AMP); - ((int16_t *)UE->pdsch_vars[0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+1]=(int16_t)( + ((int16_t *)UE->pdsch_vars[subframe&0x1][0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+1]=(int16_t)( eNB2UE[round]->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].y*AMP); //printf("**,x=%d,AMP=%d\n",eNB2UE[round]->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].x,AMP); } else { - ((int16_t *)UE->pdsch_vars[0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size)*2]=(int16_t)( + ((int16_t *)UE->pdsch_vars[subframe&0x1][0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size)*2]=(int16_t)( eNB2UE[round]->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].x*AMP); - ((int16_t *)UE->pdsch_vars[0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+1+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size)*2]=(int16_t)( + ((int16_t *)UE->pdsch_vars[subframe&0x1][0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+1+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size)*2]=(int16_t)( eNB2UE[round]->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].y*AMP); } @@ -3134,15 +3134,15 @@ PMI_FEEDBACK: for(aa=0; aanb_antenna_ports_eNB; aa++) { for (aarx=0; aarxnb_antennas_rx; aarx++) { for (i=0; iN_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; + ((int16_t *) UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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.common_vars_rx_data_per_thread[subframe&0x1].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 (transmission_mode == 7) { if (UE->high_speed_flag==0){ - ((int16_t *) UE->pdsch_vars[0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i]=(short)(AMP); - ((int16_t *) UE->pdsch_vars[0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+1]=0/2; + ((int16_t *) UE->pdsch_vars[subframe&0x1][0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i]=(short)(AMP); + ((int16_t *) UE->pdsch_vars[subframe&0x1][0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+1]=0/2; } else { - ((int16_t *) UE->pdsch_vars[0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size)*2]=(short)(AMP); - ((int16_t *) UE->pdsch_vars[0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+1+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size)*2]=0/2; + ((int16_t *) UE->pdsch_vars[subframe&0x1][0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size)*2]=(short)(AMP); + ((int16_t *) UE->pdsch_vars[subframe&0x1][0]->dl_bf_ch_estimates[(aa<<1)+aarx])[2*i+1+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size)*2]=0/2; } } } @@ -3199,6 +3199,7 @@ PMI_FEEDBACK: rx_pdcch(&UE->common_vars, UE->pdcch_vars, &UE->frame_parms, + 0, // frame subframe, 0, (UE->frame_parms.mode1_flag == 1) ? SISO : ALAMOUTI, @@ -3405,6 +3406,7 @@ PMI_FEEDBACK: PDSCH, eNB_id, eNB_id_i, + 0, // frame subframe, m, (m==UE->pdcch_vars[0]->num_pdcch_symbols)?1:0, @@ -3430,6 +3432,7 @@ PMI_FEEDBACK: PDSCH, eNB_id, eNB_id_i, + 0, // frame subframe, m, 0, @@ -3455,6 +3458,7 @@ PMI_FEEDBACK: PDSCH, eNB_id, eNB_id_i, + 0, // frame subframe, m, 0, @@ -3481,34 +3485,34 @@ PMI_FEEDBACK: //write_output("rxsig0.m","rxs0", &UE->common_vars.rxdata[0][0],10*UE->frame_parms.samples_per_tti,1,1); write_output("rxsig0.m","rxs0", &UE->common_vars.rxdata[0][subframe*UE->frame_parms.samples_per_tti],UE->frame_parms.samples_per_tti,1,1); //write_output("rxsigF0.m","rxsF0", &UE->common_vars.rxdataF[0][subframe*nsymb*eNB->frame_parms.ofdm_symbol_size],UE->frame_parms.ofdm_symbol_size*nsymb,1,1); - write_output("rxsigF0.m","rxsF0", &UE->common_vars.rxdataF[0][0],UE->frame_parms.ofdm_symbol_size*nsymb,1,1); + write_output("rxsigF0.m","rxsF0", &UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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("rxsigF1.m","rxsF1", UE->common_vars..common_vars_rx_data_per_thread[subframe&0x1]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->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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,subframe,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); @@ -3531,8 +3535,8 @@ PMI_FEEDBACK: if (trials==0 && round==0 && transmission_mode>=5 && transmission_mode<7) { for (iii=0; iiipdsch_vars[eNB_id]->pmi_ext[iii]),(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])); + fprintf(csv_fd,"%x,%x,",(UE->pdsch_vars[subframe&0x1][eNB_id]->pmi_ext[iii]),(UE->pdsch_vars[eNB_id]->pmi_ext[iii])); + printf("%x ",(UE->pdsch_vars[subframe&0x1][eNB_id]->pmi_ext[iii])); } } } @@ -3556,7 +3560,7 @@ PMI_FEEDBACK: // calculate uncoded BLER uncoded_ber=0; for (i=0;idlsch[0][0]->harq_processes[0]->e[i] != (UE->pdsch_vars[0]->llr[0][i]<0)) { + if (eNB->dlsch[0][0]->harq_processes[0]->e[i] != (UE->pdsch_vars[subframe&0x1][0]->llr[0][i]<0)) { uncoded_ber_bit[i] = 1; uncoded_ber++; } @@ -3575,14 +3579,14 @@ PMI_FEEDBACK: 0, UE->dlsch[0][cw], coded_bits_per_codeword, - UE->pdsch_vars[eNB_id]->llr[cw], + UE->pdsch_vars[subframe&0x1][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->pdsch_vars[subframe&0x1][eNB_id]->llr[cw], &UE->frame_parms, UE->dlsch[0][cw], UE->dlsch[0][cw]->harq_processes[UE->dlsch[0][cw]->current_harq_pid], @@ -3683,7 +3687,7 @@ PMI_FEEDBACK: write_output(fname,vname, &UE->common_vars.rxdata[0][0],10*UE->frame_parms.samples_per_tti,1,1); sprintf(fname,"rxsigF0_r%d.m",round); sprintf(vname,"rxs0F_r%d",round); - write_output(fname,vname, &UE->common_vars.rxdataF[0][0],2*UE->frame_parms.ofdm_symbol_size*nsymb,2,1); + write_output(fname,vname, &UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[0][0],2*UE->frame_parms.ofdm_symbol_size*nsymb,2,1); if (UE->frame_parms.nb_antennas_rx>1) { sprintf(fname,"rxsig1_r%d.m",round); @@ -3691,20 +3695,20 @@ PMI_FEEDBACK: write_output(fname,vname, UE->common_vars.rxdata[1],UE->frame_parms.samples_per_tti,1,1); sprintf(fname,"rxsig1F_r%d.m",round); sprintf(vname,"rxs1F_r%d.m",round); - write_output(fname,vname, UE->common_vars.rxdataF[1],2*UE->frame_parms.ofdm_symbol_size*nsymb,2,1); + write_output(fname,vname, UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[1],2*UE->frame_parms.ofdm_symbol_size*nsymb,2,1); } sprintf(fname,"dlsch00_r%d.m",round); sprintf(vname,"dl00_r%d",round); write_output(fname,vname, - &(UE->common_vars.dl_ch_estimates[eNB_id][0][0]), + &(UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][0][0]), UE->frame_parms.ofdm_symbol_size*nsymb,1,1); if (UE->frame_parms.nb_antennas_rx>1) { sprintf(fname,"dlsch01_r%d.m",round); sprintf(vname,"dl01_r%d",round); write_output(fname,vname, - &(UE->common_vars.dl_ch_estimates[eNB_id][1][0]), + &(UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][1][0]), UE->frame_parms.ofdm_symbol_size*nsymb/2,1,1); } @@ -3712,7 +3716,7 @@ PMI_FEEDBACK: sprintf(fname,"dlsch10_r%d.m",round); sprintf(vname,"dl10_r%d",round); write_output(fname,vname, - &(UE->common_vars.dl_ch_estimates[eNB_id][2][0]), + &(UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[eNB_id][2][0]), UE->frame_parms.ofdm_symbol_size*nsymb/2,1,1); } @@ -3720,12 +3724,12 @@ PMI_FEEDBACK: sprintf(fname,"dlsch11_r%d.m",round); sprintf(vname,"dl11_r%d",round); write_output(fname,vname, - &(UE->common_vars.dl_ch_estimates[eNB_id][3][0]), + &(UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].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,subframe,coded_bits_per_codeword,round); /* write_output("dlsch_e.m","e",eNB->dlsch[0][0]->harq_processes[0]->e,coded_bits_per_codeword,1,4); write_output("dlsch_ber_bit.m","ber_bit",uncoded_ber_bit,coded_bits_per_codeword,1,0); diff --git a/openair1/SIMULATION/LTE_PHY/mbmssim.c b/openair1/SIMULATION/LTE_PHY/mbmssim.c index 7849dec1ab4448b5eddc6ed8f1fc975975e1b74d..fb2fa506ac20f01aedc334f9283ca4836f75b895 100644 --- a/openair1/SIMULATION/LTE_PHY/mbmssim.c +++ b/openair1/SIMULATION/LTE_PHY/mbmssim.c @@ -447,8 +447,8 @@ int main(int argc, char **argv) for(aa=0; aanb_antennas_tx; aa++) { for (aarx=0; aarxnb_antennas_rx; aarx++) { for (i=0; iN_RB_DL*12; i++) { - ((int16_t *) UE->common_vars.dl_ch_estimates[k][(aa<<1)+aarx])[2*i+(l*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)(eNB2UE->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*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)(eNB2UE->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].y*AMP); + ((int16_t *) UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[k][(aa<<1)+aarx])[2*i+(l*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)(eNB2UE->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].x*AMP); + ((int16_t *) UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[k][(aa<<1)+aarx])[2*i+1+(l*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)(eNB2UE->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].y*AMP); } } } @@ -492,6 +492,7 @@ int main(int argc, char **argv) &UE->frame_parms, UE->dlsch_MCH[0], UE->dlsch_MCH[0]->harq_processes[0], + trials, subframe, 0,0,0); diff --git a/openair1/SIMULATION/LTE_PHY/pbchsim.c b/openair1/SIMULATION/LTE_PHY/pbchsim.c index 83906d73226dd476f2a2a6b472cf0403fb8984de..806a206a2bd851800126a929b7a9f51bfa14dec9 100644 --- a/openair1/SIMULATION/LTE_PHY/pbchsim.c +++ b/openair1/SIMULATION/LTE_PHY/pbchsim.c @@ -932,6 +932,7 @@ int main(int argc, char **argv) lte_ue_measurements(UE, 0, 1, + 0, 0); /* if (trial%100 == 0) { @@ -963,7 +964,7 @@ int main(int argc, char **argv) //sprintf(vname,"dl_ch00_%d",l); //write_output(fname,vname,&(common_vars->dl_ch_estimates[0][frame_parms->ofdm_symbol_size*(l%6)]),frame_parms->ofdm_symbol_size,1,1); - lte_est_freq_offset(UE->common_vars.dl_ch_estimates[0], + lte_est_freq_offset(UE->common_vars.common_vars_rx_data_per_thread[/*subframe*/0&0x1].dl_ch_estimates[0], &UE->frame_parms, l, &freq_offset, @@ -1051,13 +1052,13 @@ int main(int argc, char **argv) if (n_frames==1) { - write_output("H00.m","h00",&(UE->common_vars.dl_ch_estimates[0][0][0]),((frame_parms->Ncp==0)?7:6)*(eNB->frame_parms.ofdm_symbol_size),1,1); + write_output("H00.m","h00",&(UE->common_vars.common_vars_rx_data_per_thread[/*subframe*/0&0x1].dl_ch_estimates[0][0][0]),((frame_parms->Ncp==0)?7:6)*(eNB->frame_parms.ofdm_symbol_size),1,1); if (n_tx==2) - write_output("H10.m","h10",&(UE->common_vars.dl_ch_estimates[0][2][0]),((frame_parms->Ncp==0)?7:6)*(eNB->frame_parms.ofdm_symbol_size),1,1); + write_output("H10.m","h10",&(UE->common_vars.common_vars_rx_data_per_thread[/*subframe*/0&0x1].dl_ch_estimates[0][2][0]),((frame_parms->Ncp==0)?7:6)*(eNB->frame_parms.ofdm_symbol_size),1,1); write_output("rxsig0.m","rxs0", UE->common_vars.rxdata[0],FRAME_LENGTH_COMPLEX_SAMPLES,1,1); - write_output("rxsigF0.m","rxsF0", UE->common_vars.rxdataF[0],NUMBER_OF_OFDM_CARRIERS*2*((frame_parms->Ncp==0)?14:12),2,1); + write_output("rxsigF0.m","rxsF0", UE->common_vars.common_vars_rx_data_per_thread[/*subframe*/0&0x1].rxdataF[0],NUMBER_OF_OFDM_CARRIERS*2*((frame_parms->Ncp==0)?14:12),2,1); write_output("PBCH_rxF0_ext.m","pbch0_ext",UE->pbch_vars[0]->rxdataF_ext[0],12*4*6,1,1); write_output("PBCH_rxF0_comp.m","pbch0_comp",UE->pbch_vars[0]->rxdataF_comp[0],12*4*6,1,1); write_output("PBCH_rxF_llr.m","pbch_llr",UE->pbch_vars[0]->llr,(frame_parms->Ncp==0) ? 1920 : 1728,1,4); diff --git a/openair1/SIMULATION/LTE_PHY/pdcchsim.c b/openair1/SIMULATION/LTE_PHY/pdcchsim.c index 04b9d304b39d21be6cefb42d997d2b2bda9c99d2..1ba79bdb0a4182ff10a2c5ae3609025310704381 100644 --- a/openair1/SIMULATION/LTE_PHY/pdcchsim.c +++ b/openair1/SIMULATION/LTE_PHY/pdcchsim.c @@ -1060,9 +1060,9 @@ int main(int argc, char **argv) for(aa=0; aanb_antennas_tx; aa++) { for (aarx=0; aarxnb_antennas_rx; aarx++) { for (i=0; iN_RB_DL*12; i++) { - ((int16_t *) UE->common_vars.dl_ch_estimates[k][(aa<<1)+aarx])[2*i+(l*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)( + ((int16_t *) UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[k][(aa<<1)+aarx])[2*i+(l*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)( eNB2UE->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*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)( + ((int16_t *) UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[k][(aa<<1)+aarx])[2*i+1+(l*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(int16_t)( eNB2UE->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].y*AMP); } } @@ -1072,8 +1072,8 @@ int main(int argc, char **argv) for(aa=0; aanb_antenna_ports_eNB; aa++) { for (aarx=0; aarxnb_antennas_rx; aarx++) { for (i=0; iN_RB_DL*12; i++) { - ((int16_t *) UE->common_vars.dl_ch_estimates[0][(aa<<1)+aarx])[2*i+(l*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*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=0/2; + ((int16_t *) UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[0][(aa<<1)+aarx])[2*i+(l*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(short)(AMP); + ((int16_t *) UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[0][(aa<<1)+aarx])[2*i+1+(l*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=0/2; } } } @@ -1091,6 +1091,7 @@ int main(int argc, char **argv) rx_pdcch(&UE->common_vars, UE->pdcch_vars, &UE->frame_parms, + trial, subframe, 0, (UE->frame_parms.mode1_flag == 1) ? SISO : ALAMOUTI, @@ -1211,17 +1212,17 @@ int main(int argc, char **argv) write_output("txsig1.m","txs1", txdata[1],FRAME_LENGTH_COMPLEX_SAMPLES,1,1); write_output("rxsig0.m","rxs0", UE->common_vars.rxdata[0],10*frame_parms->samples_per_tti,1,1); - write_output("rxsigF0.m","rxsF0", UE->common_vars.rxdataF[0],NUMBER_OF_OFDM_CARRIERS*2*((frame_parms->Ncp==0)?14:12),2,1); + write_output("rxsigF0.m","rxsF0", UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[0],NUMBER_OF_OFDM_CARRIERS*2*((frame_parms->Ncp==0)?14:12),2,1); if (n_rx>1) { write_output("rxsig1.m","rxs1", UE->common_vars.rxdata[1],10*frame_parms->samples_per_tti,1,1); - write_output("rxsigF1.m","rxsF1", UE->common_vars.rxdataF[1],NUMBER_OF_OFDM_CARRIERS*2*((frame_parms->Ncp==0)?14:12),2,1); + write_output("rxsigF1.m","rxsF1", UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF[1],NUMBER_OF_OFDM_CARRIERS*2*((frame_parms->Ncp==0)?14:12),2,1); } - write_output("H00.m","h00",&(UE->common_vars.dl_ch_estimates[0][0][0]),((frame_parms->Ncp==0)?7:6)*(eNB->frame_parms.ofdm_symbol_size),1,1); + write_output("H00.m","h00",&(UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[0][0][0]),((frame_parms->Ncp==0)?7:6)*(eNB->frame_parms.ofdm_symbol_size),1,1); if (n_tx==2) - write_output("H10.m","h10",&(UE->common_vars.dl_ch_estimates[0][2][0]),((frame_parms->Ncp==0)?7:6)*(eNB->frame_parms.ofdm_symbol_size),1,1); + write_output("H10.m","h10",&(UE->common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[0][2][0]),((frame_parms->Ncp==0)?7:6)*(eNB->frame_parms.ofdm_symbol_size),1,1); write_output("pdcch_rxF_ext0.m","pdcch_rxF_ext0",UE->pdcch_vars[eNb_id]->rxdataF_ext[0],3*12*UE->frame_parms.N_RB_DL,1,1); write_output("pdcch_rxF_comp0.m","pdcch0_rxF_comp0",UE->pdcch_vars[eNb_id]->rxdataF_comp[0],4*12*UE->frame_parms.N_RB_DL,1,1); diff --git a/openair1/SIMULATION/LTE_PHY/syncsim.c b/openair1/SIMULATION/LTE_PHY/syncsim.c index 7e94122e68468090d756dd45caed7d248f579299..6e74f7bc01f2181a09c44dbddf5c522b43a0c710 100644 --- a/openair1/SIMULATION/LTE_PHY/syncsim.c +++ b/openair1/SIMULATION/LTE_PHY/syncsim.c @@ -1490,6 +1490,7 @@ int main(int argc, char **argv) rx_pdcch(&PHY_vars_UE[UE_idx]->lte_ue_common_vars, PHY_vars_UE[UE_idx]->lte_ue_pdcch_vars, &PHY_vars_UE[UE_idx]->lte_frame_parms, + frame, subframe, 0, (PHY_vars_UE[UE_idx]->lte_frame_parms.mode1_flag == 1) ? SISO : ALAMOUTI, @@ -1534,6 +1535,7 @@ int main(int argc, char **argv) PDSCH, 0, 1, + frame, subframe, // subframe, l, // symbol (l==PHY_vars_UE[UE_idx]->lte_ue_pdcch_vars[0]->num_pdcch_symbols)?1:0, // first_symbol_flag @@ -1564,6 +1566,7 @@ int main(int argc, char **argv) PDSCH, 0, 1, + frame, subframe, // subframe, l, // symbol 0, // first_symbol_flag @@ -1588,6 +1591,7 @@ int main(int argc, char **argv) PDSCH, 0, 1, + frame, subframe, // subframe, l, // symbol 0, // first_symbol_flag @@ -1618,6 +1622,7 @@ int main(int argc, char **argv) PDSCH, 0, 1, + frame, subframe, // subframe, l, // symbol 0, // first_symbol_flag @@ -1651,6 +1656,7 @@ int main(int argc, char **argv) PHY_vars_UE[UE_idx]->lte_ue_pdsch_vars[0]->llr[0], &PHY_vars_UE[UE_idx]->lte_frame_parms, PHY_vars_UE[UE_idx]->dlsch_ue[0][0], + frame, subframe, 0, PHY_vars_UE[UE_idx]->lte_ue_pdcch_vars[0]->num_pdcch_symbols); @@ -1677,9 +1683,9 @@ int main(int argc, char **argv) frame_parms, PHY_vars_UE[0]->lte_ue_pdcch_vars[0]->num_pdcch_symbols, (int16_t**)PHY_vars_UE[0]->lte_ue_common_vars.dl_ch_estimates_time, - (int16_t**)PHY_vars_UE[0]->lte_ue_common_vars.dl_ch_estimates[0], + (int16_t**)PHY_vars_UE[0]->lte_ue_common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[0], (int16_t**)PHY_vars_UE[0]->lte_ue_common_vars.rxdata, - (int16_t**)PHY_vars_UE[0]->lte_ue_common_vars.rxdataF, + (int16_t**)PHY_vars_UE[0]->lte_ue_common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF, (int16_t*)PHY_vars_UE[0]->lte_ue_pdcch_vars[0]->rxdataF_comp[0], (int16_t*)PHY_vars_UE[0]->lte_ue_pdsch_vars[0]->rxdataF_comp[0], (int16_t*)PHY_vars_UE[0]->lte_ue_pdsch_vars[1]->rxdataF_comp[0], @@ -1693,9 +1699,9 @@ int main(int argc, char **argv) frame_parms, PHY_vars_UE[1]->lte_ue_pdcch_vars[0]->num_pdcch_symbols, (int16_t**)PHY_vars_UE[1]->lte_ue_common_vars.dl_ch_estimates_time, - (int16_t**)PHY_vars_UE[1]->lte_ue_common_vars.dl_ch_estimates[0], + (int16_t**)PHY_vars_UE[1]->lte_ue_common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[0], (int16_t**)PHY_vars_UE[1]->lte_ue_common_vars.rxdata, - (int16_t**)PHY_vars_UE[1]->lte_ue_common_vars.rxdataF, + (int16_t**)PHY_vars_UE[1]->lte_ue_common_vars.common_vars_rx_data_per_thread[subframe&0x1].rxdataF, (int16_t*)PHY_vars_UE[1]->lte_ue_pdcch_vars[0]->rxdataF_comp[0], (int16_t*)PHY_vars_UE[1]->lte_ue_pdsch_vars[0]->rxdataF_comp[0], (int16_t*)PHY_vars_UE[1]->lte_ue_pdsch_vars[3]->rxdataF_comp[0], @@ -1712,10 +1718,10 @@ int main(int argc, char **argv) if (n_frames==1) { - write_output("H00.m","h00",&(PHY_vars_UE[0]->lte_ue_common_vars.dl_ch_estimates[0][0][0]),((frame_parms->Ncp==0)?7:6)*(PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size),1,1); + write_output("H00.m","h00",&(PHY_vars_UE[0]->lte_ue_common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[0][0][0]),((frame_parms->Ncp==0)?7:6)*(PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size),1,1); if (n_tx==2) - write_output("H10.m","h10",&(PHY_vars_UE[0]->lte_ue_common_vars.dl_ch_estimates[0][2][0]),((frame_parms->Ncp==0)?7:6)*(PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size),1,1); + write_output("H10.m","h10",&(PHY_vars_UE[0]->lte_ue_common_vars.common_vars_rx_data_per_thread[subframe&0x1].dl_ch_estimates[0][2][0]),((frame_parms->Ncp==0)?7:6)*(PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size),1,1); write_output("rxsig0.m","rxs0", PHY_vars_UE[0]->lte_ue_common_vars.rxdata[0],FRAME_LENGTH_COMPLEX_SAMPLES,1,1); write_output("rxsigF0.m","rxsF0", PHY_vars_UE[0]->lte_ue_common_vars.rxdataF[0],NUMBER_OF_OFDM_CARRIERS*LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*nsymb,2,1); @@ -1733,7 +1739,7 @@ int main(int argc, char **argv) PHY_vars_UE[0]->lte_ue_pdcch_vars[0]->num_pdcch_symbols, 0); - dump_dlsch2(PHY_vars_UE[0],0,coded_bits_per_codeword); + dump_dlsch2(PHY_vars_UE[0],0,0,coded_bits_per_codeword); } } else { diff --git a/openair1/SIMULATION/LTE_PHY/ulsim.c b/openair1/SIMULATION/LTE_PHY/ulsim.c index cf9e5aaa30ae9e42a850d2111626471ec2111f96..55c6b8387eef3df727539536679b6d4a6a8fa00a 100644 --- a/openair1/SIMULATION/LTE_PHY/ulsim.c +++ b/openair1/SIMULATION/LTE_PHY/ulsim.c @@ -1175,7 +1175,7 @@ int main(int argc, char **argv) eNB->td = (parallel_flag == 1) ? ulsch_decoding_data_2thread : ulsch_decoding_data; eNB->do_prach = NULL; - phy_procedures_eNB_common_RX(eNB); + phy_procedures_eNB_common_RX(eNB,proc_rxtx); phy_procedures_eNB_uespec_RX(eNB,proc_rxtx,no_relay); diff --git a/openair2/COMMON/commonDef.h b/openair2/COMMON/commonDef.h index cfd5d68e40a9a92d8b09b533f316430c00373c99..b1ec47449af1a7f0da1fa7257c16db49ad7eda6d 100644 --- a/openair2/COMMON/commonDef.h +++ b/openair2/COMMON/commonDef.h @@ -43,6 +43,13 @@ Description Contains global common definitions #include #include +/* boolean_t is also defined in openair2/COMMON/platform_types.h + * let's protect potential redefinition + */ + +#ifndef _BOOLEAN_T_DEFINED_ +#define _BOOLEAN_T_DEFINED_ + typedef signed char boolean_t; #if !defined(TRUE) @@ -55,6 +62,8 @@ typedef signed char boolean_t; #define BOOL_NOT(b) (b^TRUE) +#endif /* _BOOLEAN_T_DEFINED_ */ + #define NAS_UE_ID_FMT "0x%06x" /****************************************************************************/ diff --git a/openair2/COMMON/platform_types.h b/openair2/COMMON/platform_types.h index 256ed45b5dfa7441ca22bd386d25e25eb64fc34b..45d7774afad0bf382481a644c4fbb4536f243a2a 100644 --- a/openair2/COMMON/platform_types.h +++ b/openair2/COMMON/platform_types.h @@ -40,6 +40,13 @@ //----------------------------------------------------------------------------- // GENERIC TYPES //----------------------------------------------------------------------------- + +/* boolean_t is also defined in openair2/COMMON/commonDef.h, + * let's protect potential redefinition + */ +#ifndef _BOOLEAN_T_DEFINED_ +#define _BOOLEAN_T_DEFINED_ + typedef signed char boolean_t; #if !defined(TRUE) @@ -52,6 +59,8 @@ typedef signed char boolean_t; #define BOOL_NOT(b) (b^TRUE) +#endif /* _BOOLEAN_T_DEFINED_ */ + //----------------------------------------------------------------------------- // GENERIC ACCESS STRATUM TYPES //----------------------------------------------------------------------------- diff --git a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c index b9cad28278ba60fab4a54d0ce5535d6f5ea5c6d1..e353f5fde72d65725154084e1520cec23bb1e6b7 100644 --- a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c +++ b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac.c @@ -30,6 +30,7 @@ #include "flexran_agent_extern.h" #include "flexran_agent_common.h" #include "flexran_agent_mac_internal.h" +#include "flexran_agent_net_comm.h" #include "LAYER2/MAC/proto.h" #include "LAYER2/MAC/flexran_agent_mac_proto.h" @@ -60,14 +61,11 @@ int flexran_agent_mac_handle_stats(mid_t mod_id, const void *params, Protocol__F // TODO: Must resolve conflicts among stats requests int i; - void *buffer; - int size; err_code_t err_code; xid_t xid; uint32_t usec_interval, sec_interval; //TODO: We do not deal with multiple CCs at the moment and eNB id is 0 - int cc_id = 0; int enb_id = mod_id; //eNB_MAC_INST *eNB = &eNB_mac_inst[enb_id]; @@ -250,15 +248,15 @@ int flexran_agent_mac_stats_request(mid_t mod_id, Protocol__FlexHeader *header; int i; - if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_STATS_REQUEST, &header) != 0) - goto error; - Protocol__FlexStatsRequest *stats_request_msg; stats_request_msg = malloc(sizeof(Protocol__FlexStatsRequest)); if(stats_request_msg == NULL) goto error; - protocol__flex_stats_request__init(stats_request_msg); + + if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_STATS_REQUEST, &header) != 0) + goto error; + stats_request_msg->header = header; stats_request_msg->type = report_config->report_type; @@ -375,20 +373,19 @@ int flexran_agent_mac_stats_reply(mid_t mod_id, Protocol__FlexranMessage **msg) { Protocol__FlexHeader *header; int i, j, k; - int cc_id = 0; int enb_id = mod_id; //eNB_MAC_INST *eNB = &eNB_mac_inst[enb_id]; //UE_list_t *eNB_UE_list= &eNB->UE_list; - - if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_STATS_REPLY, &header) != 0) - goto error; - Protocol__FlexStatsReply *stats_reply_msg; stats_reply_msg = malloc(sizeof(Protocol__FlexStatsReply)); if (stats_reply_msg == NULL) goto error; protocol__flex_stats_reply__init(stats_reply_msg); + + if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_STATS_REPLY, &header) != 0) + goto error; + stats_reply_msg->header = header; stats_reply_msg->n_ue_report = report_config->nr_ue; @@ -419,7 +416,7 @@ int flexran_agent_mac_stats_reply(mid_t mod_id, elem = (uint32_t *) malloc(sizeof(uint32_t)*ue_report[i]->n_bsr); if (elem == NULL) goto error; - for (j = 0; j++; j < ue_report[i]->n_bsr) { + for (j = 0; j < ue_report[i]->n_bsr; j++) { // NN: we need to know the cc_id here, consider the first one elem[j] = flexran_get_ue_bsr (enb_id, i, j); } @@ -472,7 +469,7 @@ int flexran_agent_mac_stats_reply(mid_t mod_id, /* Check flag for creation of MAC CE buffer status report */ if (report_config->ue_report_type[i].ue_report_flags & PROTOCOL__FLEX_UE_STATS_TYPE__FLUST_MAC_CE_BS) { // TODO: Fill in the actual MAC CE buffer status report - ue_report[i]->pending_mac_ces = (flexran_get_MAC_CE_bitmap_TA(enb_id,i,0) | (0 << 1) | (0 << 2) | (0 << 3)) & 15; /* Use as bitmap. Set one or more of the; /* Use as bitmap. Set one or more of the + ue_report[i]->pending_mac_ces = (flexran_get_MAC_CE_bitmap_TA(enb_id,i,0) | (0 << 1) | (0 << 2) | (0 << 3)) & 15; /* Use as bitmap. Set one or more of the PROTOCOL__FLEX_CE_TYPE__FLPCET_ values found in stats_common.pb-c.h. See flex_ce_type in FlexRAN specification */ @@ -802,6 +799,8 @@ int flexran_agent_mac_destroy_stats_reply(Protocol__FlexranMessage *msg) { } free(dl_report->csi_report[j]->a31csi->sb_cqi); break; + default: + break; } free(dl_report->csi_report[j]); @@ -856,8 +855,6 @@ int flexran_agent_mac_sr_info(mid_t mod_id, const void *params, Protocol__Flexra Protocol__FlexHeader *header; int i; const int xid = *((int *)params); - if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_UL_SR_INFO, &header) != 0) - goto error; Protocol__FlexUlSrInfo *ul_sr_info_msg; ul_sr_info_msg = malloc(sizeof(Protocol__FlexUlSrInfo)); @@ -866,6 +863,9 @@ int flexran_agent_mac_sr_info(mid_t mod_id, const void *params, Protocol__Flexra } protocol__flex_ul_sr_info__init(ul_sr_info_msg); + if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_UL_SR_INFO, &header) != 0) + goto error; + ul_sr_info_msg->header = header; ul_sr_info_msg->has_sfn_sf = 1; ul_sr_info_msg->sfn_sf = flexran_get_sfn_sf(mod_id); @@ -923,8 +923,6 @@ int flexran_agent_mac_sf_trigger(mid_t mod_id, const void *params, Protocol__Fle Protocol__FlexHeader *header; int i,j; const int xid = *((int *)params); - if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_SF_TRIGGER, &header) != 0) - goto error; Protocol__FlexSfTrigger *sf_trigger_msg; sf_trigger_msg = malloc(sizeof(Protocol__FlexSfTrigger)); @@ -933,6 +931,9 @@ int flexran_agent_mac_sf_trigger(mid_t mod_id, const void *params, Protocol__Fle } protocol__flex_sf_trigger__init(sf_trigger_msg); + if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_SF_TRIGGER, &header) != 0) + goto error; + frame_t frame; sub_frame_t subframe; @@ -975,8 +976,8 @@ int flexran_agent_mac_sf_trigger(mid_t mod_id, const void *params, Protocol__Fle dl_info[i]->rnti = flexran_get_ue_crnti(mod_id, i); dl_info[i]->has_rnti = 1; /*Fill in the right id of this round's HARQ process for this UE*/ - int harq_id; - int harq_status; + unsigned char harq_id; + unsigned char harq_status; flexran_get_harq(mod_id, UE_PCCID(mod_id,i), i, frame, subframe, &harq_id, &harq_status); dl_info[i]->harq_process_id = harq_id; dl_info[i]->has_harq_process_id = 1; @@ -1060,10 +1061,7 @@ int flexran_agent_mac_sf_trigger(mid_t mod_id, const void *params, Protocol__Fle for (i = 0; i < sf_trigger_msg->n_dl_info; i++) { free(sf_trigger_msg->dl_info[i]->harq_status); } - free(sf_trigger_msg->dl_info); - for (i = 0; i < sf_trigger_msg->n_ul_info; i++) { - free(sf_trigger_msg->ul_info[i]->reception_status); - } + free(sf_trigger_msg->dl_info); free(sf_trigger_msg->ul_info); free(sf_trigger_msg); } @@ -1230,9 +1228,9 @@ int flexran_agent_mac_handle_dl_mac_config(mid_t mod_id, const void *params, Pro *msg = NULL; return 2; - error: - *msg = NULL; - return -1; + // error: + //*msg = NULL; + //return -1; } void flexran_agent_init_mac_agent(mid_t mod_id) { @@ -1252,7 +1250,7 @@ void flexran_agent_send_sr_info(mid_t mod_id) { int size; Protocol__FlexranMessage *msg; void *data; - int priority; + int priority = 0; err_code_t err_code; int xid = 0; @@ -1282,7 +1280,7 @@ void flexran_agent_send_sf_trigger(mid_t mod_id) { int size; Protocol__FlexranMessage *msg; void *data; - int priority; + int priority = 0; err_code_t err_code; int xid = 0; @@ -1310,13 +1308,11 @@ void flexran_agent_send_sf_trigger(mid_t mod_id) { void flexran_agent_send_update_mac_stats(mid_t mod_id) { - Protocol__FlexranMessage *current_report = NULL, *msg; + Protocol__FlexranMessage *current_report = NULL; void *data; int size; err_code_t err_code; - int priority; - - mac_stats_updates_context_t stats_context = mac_stats_context[mod_id]; + int priority = 0; if (pthread_mutex_lock(mac_stats_context[mod_id].mutex)) { goto error; @@ -1437,7 +1433,7 @@ err_code_t flexran_agent_destroy_cont_mac_stats_update(mid_t mod_id) { flexran_agent_destroy_flexran_message(mac_stats_context[mod_id].prev_stats_reply); free(mac_stats_context[mod_id].mutex); - mac_agent_registered[mod_id] = NULL; + mac_agent_registered[mod_id] = 0; return 1; } diff --git a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_defs.h b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_defs.h index bb6aed1d8e9fadda1a37339fa993635b39de7956..9ec8594f88e567643f566145bb4dc2a0268a616c 100644 --- a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_defs.h +++ b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_defs.h @@ -63,8 +63,8 @@ typedef struct { /// Notify the controller for a state change of a particular UE, by sending the proper /// UE state change message (ACTIVATION, DEACTIVATION, HANDOVER) - void (*flexran_agent_notify_ue_state_change)(mid_t mod_id, uint32_t rnti, - uint32_t state_change); + int (*flexran_agent_notify_ue_state_change)(mid_t mod_id, uint32_t rnti, + uint8_t state_change); void *dl_scheduler_loaded_lib; diff --git a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c index a63225e657cc725f42124ccf60fcfafb228c7f45..1fa9852487d6922ba211be4e7affddcedbf3339a 100644 --- a/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c +++ b/openair2/ENB_APP/CONTROL_MODULES/MAC/flexran_agent_mac_internal.c @@ -29,6 +29,7 @@ #include #include +#include "flexran_agent_common_internal.h" #include "flexran_agent_mac_internal.h" Protocol__FlexranMessage * flexran_agent_generate_diff_mac_stats_report(Protocol__FlexranMessage *new_message, @@ -49,11 +50,6 @@ Protocol__FlexranMessage * flexran_agent_generate_diff_mac_stats_report(Protocol old_report = old_message->stats_reply_msg; new_report = new_message->stats_reply_msg; - /*Flags to designate changes in various levels of the message*/ - int stats_had_changes = 0; - int ue_had_change = 0; - int cell_had_change = 0; - /*See how many and which UE reports should be included in the final stats message*/ int n_ue_report = 0; int ue_found = 0; @@ -101,23 +97,6 @@ Protocol__FlexranMessage * flexran_agent_generate_diff_mac_stats_report(Protocol } cell_found = 0; } - - /*TODO: create the reply message based on the findings*/ - /*Create ue report list*/ - if (n_ue_report > 0) { - ue_report = malloc(sizeof(Protocol__FlexUeStatsReport *)); - for (i = 0; i 0) { - cell_report = malloc(sizeof(Protocol__FlexCellStatsReport *)); - for (i = 0; i 0 || n_ue_report > 0) { /*Create header*/ @@ -128,11 +107,30 @@ Protocol__FlexranMessage * flexran_agent_generate_diff_mac_stats_report(Protocol } stats_reply_msg = malloc(sizeof(Protocol__FlexStatsReply)); protocol__flex_stats_reply__init(stats_reply_msg); + stats_reply_msg->header = header; + + /*TODO: create the reply message based on the findings*/ + /*Create ue report list*/ stats_reply_msg->n_ue_report = n_ue_report; - stats_reply_msg->ue_report = ue_report; + if (n_ue_report > 0) { + ue_report = malloc(sizeof(Protocol__FlexUeStatsReport *)); + for (i = 0; iue_report = ue_report; + } + + /*Create cell report list*/ stats_reply_msg->n_cell_report = n_cell_report; - stats_reply_msg->cell_report = cell_report; + if (n_cell_report > 0) { + cell_report = malloc(sizeof(Protocol__FlexCellStatsReport *)); + for (i = 0; icell_report = cell_report; + } + msg = malloc(sizeof(Protocol__FlexranMessage)); if(msg == NULL) goto error; @@ -270,7 +268,7 @@ Protocol__FlexUlCqiReport * copy_ul_cqi_report(Protocol__FlexUlCqiReport * origi ul_report = malloc(sizeof(Protocol__FlexUlCqi *) * full_ul_report->n_cqi_meas); if(ul_report == NULL) goto error; - for(i = 0; i++; i < full_ul_report->n_cqi_meas) { + for(i = 0; i < full_ul_report->n_cqi_meas; i++) { ul_report[i] = malloc(sizeof(Protocol__FlexUlCqi)); if(ul_report[i] == NULL) goto error; @@ -597,22 +595,22 @@ int parse_mac_config(mid_t mod_id, yaml_parser_t *parser) { goto error; } // Check the types of subsystems offered and handle their values accordingly - if (strcmp(event.data.scalar.value, "dl_scheduler") == 0) { + if (strcmp((char *) event.data.scalar.value, "dl_scheduler") == 0) { LOG_D(ENB_APP, "This is for the dl_scheduler subsystem\n"); // Call the proper handler if (parse_dl_scheduler_config(mod_id, parser) == -1) { LOG_D(ENB_APP, "An error occured\n"); goto error; } - } else if (strcmp(event.data.scalar.value, "ul_scheduler") == 0) { + } else if (strcmp((char *) event.data.scalar.value, "ul_scheduler") == 0) { // Call the proper handler LOG_D(ENB_APP, "This is for the ul_scheduler subsystem\n"); goto error; // TODO - } else if (strcmp(event.data.scalar.value, "ra_scheduler") == 0) { + } else if (strcmp((char *) event.data.scalar.value, "ra_scheduler") == 0) { // Call the proper handler // TODO - } else if (strcmp(event.data.scalar.value, "page_scheduler") == 0) { + } else if (strcmp((char *) event.data.scalar.value, "page_scheduler") == 0) { // Call the proper handler // TODO } else { @@ -665,20 +663,20 @@ int parse_dl_scheduler_config(mid_t mod_id, yaml_parser_t *parser) { goto error; } // Check what key needs to be set - if (strcmp(event.data.scalar.value, "behavior") == 0) { + if (strcmp((char *) event.data.scalar.value, "behavior") == 0) { LOG_I(ENB_APP, "Time to set the behavior attribute\n"); yaml_event_delete(&event); if (!yaml_parser_parse(parser, &event)) { goto error; } if (event.type == YAML_SCALAR_EVENT) { - if (load_dl_scheduler_function(mod_id, event.data.scalar.value) == -1) { + if (load_dl_scheduler_function(mod_id, (char *) event.data.scalar.value) == -1) { goto error; } } else { goto error; } - } else if (strcmp(event.data.scalar.value, "parameters") == 0) { + } else if (strcmp((char *) event.data.scalar.value, "parameters") == 0) { LOG_D(ENB_APP, "Now it is time to set the parameters for this subsystem\n"); if (parse_dl_scheduler_parameters(mod_id, parser) == -1) { goto error; @@ -731,7 +729,7 @@ int parse_dl_scheduler_parameters(mid_t mod_id, yaml_parser_t *parser) { if (mac_agent_registered[mod_id]) { LOG_D(ENB_APP, "Setting parameter %s\n", event.data.scalar.value); param = dlsym(agent_mac_xface[mod_id]->dl_scheduler_loaded_lib, - event.data.scalar.value); + (char *) event.data.scalar.value); if (param == NULL) { goto error; } diff --git a/openair2/ENB_APP/enb_app.c b/openair2/ENB_APP/enb_app.c index 3734bc4a2b11d9c66ab09b074dbffa78216f591b..60415aad868e3a8807172e9077a17b2eafb4ee6a 100644 --- a/openair2/ENB_APP/enb_app.c +++ b/openair2/ENB_APP/enb_app.c @@ -410,7 +410,7 @@ void *eNB_app_task(void *args_p) break; case TIMER_HAS_EXPIRED: - LOG_I(ENB_APP, " Received %s: timer_id %d\n", msg_name, TIMER_HAS_EXPIRED(msg_p).timer_id); + LOG_I(ENB_APP, " Received %s: timer_id %ld\n", msg_name, TIMER_HAS_EXPIRED(msg_p).timer_id); if (TIMER_HAS_EXPIRED (msg_p).timer_id == enb_register_retry_timer_id) { /* Restart the registration process */ diff --git a/openair2/ENB_APP/enb_config.c b/openair2/ENB_APP/enb_config.c index 80e80bcb00419b4c146bb36bc1162b99b496268b..1841d8e9a90631517f995bf73f78ea57134666a6 100644 --- a/openair2/ENB_APP/enb_config.c +++ b/openair2/ENB_APP/enb_config.c @@ -344,7 +344,7 @@ void enb_config_display(void) #if defined(FLEXRAN_AGENT_SB_IF) printf( "\nFLEXRAN AGENT CONFIG : \n\n"); printf( "\tInterface name: \t%s:\n",enb_properties.properties[i]->flexran_agent_interface_name); - printf( "\tInterface IP Address: \t%s:\n",enb_properties.properties[i]->flexran_agent_ipv4_address); + // printf( "\tInterface IP Address: \t%s:\n",enb_properties.properties[i]->flexran_agent_ipv4_address); printf( "\tInterface PORT: \t%d:\n\n",enb_properties.properties[i]->flexran_agent_port); printf( "\tCache directory: \t%s:\n",enb_properties.properties[i]->flexran_agent_cache); @@ -2380,7 +2380,7 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP) enb_properties.properties[enb_properties_index]->rrh_gw_config[j].rawif5_mobipass = 1; } else {//if (strcmp(preference, "no") == 0) enb_properties.properties[enb_properties_index]->rrh_gw_config[j].udp = 1; - enb_properties.properties[enb_properties_index]->rrh_gw_config[j].raw = 1; + enb_properties.properties[enb_properties_index]->rrh_gw_config[j].raw = 1; } if (strcmp(rf_preference, "exmimo") == 0) { @@ -2494,10 +2494,10 @@ const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP) enb_properties.properties[enb_properties_index]->flexran_agent_interface_name = strdup(flexran_agent_interface_name); cidr = flexran_agent_ipv4_address; address = strtok(cidr, "/"); - enb_properties.properties[enb_properties_index]->flexran_agent_ipv4_address = strdup(address); - /* if (address) { + //enb_properties.properties[enb_properties_index]->flexran_agent_ipv4_address = strdup(address); + if (address) { IPV4_STR_ADDR_TO_INT_NWBO (address, enb_properties.properties[enb_properties_index]->flexran_agent_ipv4_address, "BAD IP ADDRESS FORMAT FOR eNB Agent !\n" ); - }*/ + } enb_properties.properties[enb_properties_index]->flexran_agent_port = flexran_agent_port; enb_properties.properties[enb_properties_index]->flexran_agent_cache = strdup(flexran_agent_cache); diff --git a/openair2/ENB_APP/flexran_agent.c b/openair2/ENB_APP/flexran_agent.c index beca1062bd6aa0fbd82a20ad5a0c39c0d0dfa899..0dcacd4b81a6d64da85524cb42619c4937330583 100644 --- a/openair2/ENB_APP/flexran_agent.c +++ b/openair2/ENB_APP/flexran_agent.c @@ -30,6 +30,8 @@ #include "log.h" #include "flexran_agent.h" #include "flexran_agent_mac_defs.h" +#include "flexran_agent_mac.h" +#include "flexran_agent_mac_internal.h" #include "flexran_agent_extern.h" @@ -38,6 +40,8 @@ #include "flexran_agent_net_comm.h" #include "flexran_agent_async.h" +#include + //#define TEST_TIMER flexran_agent_instance_t flexran_agent[NUM_MAX_ENB]; @@ -64,11 +68,10 @@ void *flexran_agent_task(void *args){ void *data; int size; err_code_t err_code; - int priority; + int priority = 0; MessageDef *msg_p = NULL; const char *msg_name = NULL; - instance_t instance; int result; struct flexran_agent_timer_element_s * elem = NULL; @@ -79,7 +82,6 @@ void *flexran_agent_task(void *args){ itti_receive_msg (TASK_FLEXRAN_AGENT, &msg_p); DevAssert(msg_p != NULL); msg_name = ITTI_MSG_NAME (msg_p); - instance = ITTI_MSG_INSTANCE (msg_p); switch (ITTI_MSG_ID(msg_p)) { case TERMINATE_MESSAGE: @@ -212,9 +214,8 @@ int flexran_agent_start(mid_t mod_id, const Enb_properties_array_t* enb_properti strcpy(local_cache, DEFAULT_FLEXRAN_AGENT_CACHE); } - if (enb_properties->properties[mod_id]->flexran_agent_ipv4_address != NULL) { - strncpy(in_ip, enb_properties->properties[mod_id]->flexran_agent_ipv4_address, sizeof(in_ip) ); - in_ip[sizeof(in_ip) - 1] = 0; // terminate string + if (enb_properties->properties[mod_id]->flexran_agent_ipv4_address != 0) { + inet_ntop(AF_INET, &(enb_properties->properties[mod_id]->flexran_agent_ipv4_address), in_ip, INET_ADDRSTRLEN); } else { strcpy(in_ip, DEFAULT_FLEXRAN_AGENT_IPv4_ADDRESS ); } @@ -237,7 +238,7 @@ int flexran_agent_start(mid_t mod_id, const Enb_properties_array_t* enb_properti channel_container_init = 1; } /*Create the async channel info*/ - flexran_agent_instance_t *channel_info = flexran_agent_async_channel_info(mod_id, in_ip, in_port); + flexran_agent_async_channel_t *channel_info = flexran_agent_async_channel_info(mod_id, in_ip, in_port); /*Create a channel using the async channel info*/ channel_id = flexran_agent_create_channel((void *) channel_info, diff --git a/openair2/ENB_APP/flexran_agent_common.c b/openair2/ENB_APP/flexran_agent_common.c index 2ccca6602b5d8f2fd60a4f3f37b3f71dd01b6476..22793f16b490d46ec9eec1da737c6e78ad3121b2 100644 --- a/openair2/ENB_APP/flexran_agent_common.c +++ b/openair2/ENB_APP/flexran_agent_common.c @@ -32,6 +32,7 @@ #include "flexran_agent_common.h" #include "flexran_agent_common_internal.h" #include "flexran_agent_extern.h" +#include "flexran_agent_net_comm.h" #include "PHY/extern.h" #include "log.h" @@ -110,14 +111,16 @@ int flexran_agent_hello(mid_t mod_id, const void *params, Protocol__FlexranMessa Protocol__FlexHeader *header; /*TODO: Need to set random xid or xid from received hello message*/ xid_t xid = 1; - if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_HELLO, &header) != 0) - goto error; Protocol__FlexHello *hello_msg; hello_msg = malloc(sizeof(Protocol__FlexHello)); if(hello_msg == NULL) goto error; protocol__flex_hello__init(hello_msg); + + if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_HELLO, &header) != 0) + goto error; + hello_msg->header = header; *msg = malloc(sizeof(Protocol__FlexranMessage)); @@ -163,14 +166,16 @@ int flexran_agent_echo_request(mid_t mod_id, const void* params, Protocol__Flexr Protocol__FlexHeader *header; /*TODO: Need to set a random xid*/ xid_t xid = 1; - if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_ECHO_REQUEST, &header) != 0) - goto error; - Protocol__FlexEchoRequest *echo_request_msg; + Protocol__FlexEchoRequest *echo_request_msg = NULL; echo_request_msg = malloc(sizeof(Protocol__FlexEchoRequest)); if(echo_request_msg == NULL) goto error; protocol__flex_echo_request__init(echo_request_msg); + + if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_ECHO_REQUEST, &header) != 0) + goto error; + echo_request_msg->header = header; *msg = malloc(sizeof(Protocol__FlexranMessage)); @@ -217,15 +222,16 @@ int flexran_agent_echo_reply(mid_t mod_id, const void *params, Protocol__Flexran Protocol__FlexEchoRequest *echo_req = input->echo_request_msg; xid = (echo_req->header)->xid; - Protocol__FlexHeader *header; - if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_ECHO_REPLY, &header) != 0) - goto error; - - Protocol__FlexEchoReply *echo_reply_msg; + Protocol__FlexEchoReply *echo_reply_msg = NULL; echo_reply_msg = malloc(sizeof(Protocol__FlexEchoReply)); if(echo_reply_msg == NULL) goto error; protocol__flex_echo_reply__init(echo_reply_msg); + + Protocol__FlexHeader *header; + if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_ECHO_REPLY, &header) != 0) + goto error; + echo_reply_msg->header = header; *msg = malloc(sizeof(Protocol__FlexranMessage)); @@ -299,7 +305,7 @@ int flexran_agent_destroy_ue_config_reply(Protocol__FlexranMessage *msg) { if(msg->msg_case != PROTOCOL__FLEXRAN_MESSAGE__MSG_UE_CONFIG_REPLY_MSG) goto error; free(msg->ue_config_reply_msg->header); - int i, j; + int i; Protocol__FlexUeConfigReply *reply = msg->ue_config_reply_msg; for(i = 0; i < reply->n_ue_config;i++){ @@ -376,7 +382,7 @@ int flexran_agent_destroy_lc_config_request(Protocol__FlexranMessage *msg) { } // call this function to start a nanosecond-resolution timer -struct timespec timer_start(){ +struct timespec timer_start(void) { struct timespec start_time; clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start_time); return start_time; @@ -395,11 +401,7 @@ int flexran_agent_control_delegation(mid_t mod_id, const void *params, Protocol_ Protocol__FlexranMessage *input = (Protocol__FlexranMessage *)params; Protocol__FlexControlDelegation *control_delegation_msg = input->control_delegation_msg; - uint32_t delegation_type = control_delegation_msg->delegation_type; - - int i; - - struct timespec vartime = timer_start(); + // struct timespec vartime = timer_start(); //Write the payload lib into a file in the cache and load the lib char lib_name[120]; @@ -413,16 +415,15 @@ int flexran_agent_control_delegation(mid_t mod_id, const void *params, Protocol_ fwrite(control_delegation_msg->payload.data, control_delegation_msg->payload.len, 1, f); fclose(f); - long time_elapsed_nanos = timer_end(vartime); + // long time_elapsed_nanos = timer_end(vartime); *msg = NULL; return 0; - error: - return -1; } int flexran_agent_destroy_control_delegation(Protocol__FlexranMessage *msg) { /*TODO: Dealocate memory for a dynamically allocated control delegation message*/ + return 0; } int flexran_agent_reconfiguration(mid_t mod_id, const void *params, Protocol__FlexranMessage **msg) { @@ -437,6 +438,7 @@ int flexran_agent_reconfiguration(mid_t mod_id, const void *params, Protocol__Fl int flexran_agent_destroy_agent_reconfiguration(Protocol__FlexranMessage *msg) { /*TODO: Dealocate memory for a dynamically allocated agent reconfiguration message*/ + return 0; } @@ -474,7 +476,7 @@ int flexran_get_current_time_ms (mid_t mod_id, int subframe_flag){ unsigned int flexran_get_current_frame (mid_t mod_id) { - #warning "SFN will not be in [0-1023] when oaisim is used" + // #warning "SFN will not be in [0-1023] when oaisim is used" return ((eNB_MAC_INST *)enb[mod_id])->frame; } @@ -637,7 +639,6 @@ int flexran_get_active_CC(mid_t mod_id, mid_t ue_id) { int flexran_get_current_RI(mid_t mod_id, mid_t ue_id, int CC_id) { LTE_eNB_UE_stats *eNB_UE_stats = NULL; - int pCCid = UE_PCCID(mod_id,ue_id); rnti_t rnti = flexran_get_ue_crnti(mod_id,ue_id); eNB_UE_stats = mac_xface->get_eNB_UE_stats(mod_id,CC_id,rnti); @@ -679,7 +680,8 @@ int flexran_get_tpc(mid_t mod_id, mid_t ue_id) { return tpc; } -int flexran_get_harq(const mid_t mod_id, const uint8_t CC_id, const mid_t ue_id, const int frame, const uint8_t subframe, int *id, int *round) { //flag_id_status = 0 then id, else status +int flexran_get_harq(const mid_t mod_id, const uint8_t CC_id, const mid_t ue_id, const int frame, const uint8_t subframe, + unsigned char *id, unsigned char *round) { //flag_id_status = 0 then id, else status /*TODO: Add int TB in function parameters to get the status of the second TB. This can be done to by editing in * get_ue_active_harq_pid function in line 272 file: phy_procedures_lte_eNB.c to add * DLSCH_ptr = PHY_vars_eNB_g[Mod_id][CC_id]->dlsch_eNB[(uint32_t)UE_id][1];*/ @@ -701,7 +703,7 @@ int flexran_get_harq(const mid_t mod_id, const uint8_t CC_id, const mid_t ue_id, /* } */ /* return 0; */ - return round; + return *round; } int flexran_get_p0_pucch_dbm(mid_t mod_id, mid_t ue_id, int CC_id) { @@ -922,15 +924,11 @@ int flexran_get_special_subframe_assignment(mid_t mod_id, int CC_id) { } int flexran_get_ra_ResponseWindowSize(mid_t mod_id, int CC_id) { - Enb_properties_array_t *enb_properties; - enb_properties = enb_config_get(); - return enb_properties->properties[mod_id]->rach_raResponseWindowSize[CC_id]; + return enb_config_get()->properties[mod_id]->rach_raResponseWindowSize[CC_id]; } int flexran_get_mac_ContentionResolutionTimer(mid_t mod_id, int CC_id) { - Enb_properties_array_t *enb_properties; - enb_properties = enb_config_get(); - return enb_properties->properties[mod_id]->rach_macContentionResolutionTimer[CC_id]; + return enb_config_get()->properties[mod_id]->rach_macContentionResolutionTimer[CC_id]; } int flexran_get_duplex_mode(mid_t mod_id, int CC_id) { @@ -969,16 +967,19 @@ int flexran_get_num_pdcch_symb(mid_t mod_id, int CC_id) { int flexran_get_time_alignment_timer(mid_t mod_id, mid_t ue_id) { - struct rrc_eNB_ue_context_s* ue_context_p = NULL; - uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); - - ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); - if(ue_context_p != NULL) { - if(ue_context_p->ue_context.mac_MainConfig != NULL) - return ue_context_p->ue_context.mac_MainConfig->timeAlignmentTimerDedicated; - } - else - return -1; + struct rrc_eNB_ue_context_s* ue_context_p = NULL; + uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); + + ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); + if(ue_context_p != NULL) { + if(ue_context_p->ue_context.mac_MainConfig != NULL) { + return ue_context_p->ue_context.mac_MainConfig->timeAlignmentTimerDedicated; + } else { + return -1; + } + } else { + return -1; + } } int flexran_get_meas_gap_config(mid_t mod_id, mid_t ue_id) { @@ -1040,12 +1041,14 @@ int flexran_get_half_duplex(mid_t ue_id) { // halfduplex = 1; //} //return halfduplex; + return 0; } int flexran_get_intra_sf_hopping(mid_t ue_id) { //TODO:Get proper value //temp = (((UE_RRC_INST *)enb_ue_rrc[ue_id])->UECap->UE_EUTRA_Capability->featureGroupIndicators->buf); //return (0 & ( 1 << (31))); + return 0; } int flexran_get_type2_sb_1(mid_t ue_id) { @@ -1053,11 +1056,13 @@ int flexran_get_type2_sb_1(mid_t ue_id) { //uint8_t temp = 0; //temp = (((UE_RRC_INST *)enb_ue_rrc[ue_id])->UECap->UE_EUTRA_Capability->featureGroupIndicators->buf); //return (temp & ( 1 << (11))); + return 0; } int flexran_get_ue_category(mid_t ue_id) { //TODO:Get proper value //return (((UE_RRC_INST *)enb_ue_rrc[ue_id])->UECap->UE_EUTRA_Capability->ue_Category); + return 0; } int flexran_get_res_alloc_type1(mid_t ue_id) { @@ -1065,35 +1070,41 @@ int flexran_get_res_alloc_type1(mid_t ue_id) { //uint8_t temp = 0; //temp = (((UE_RRC_INST *)enb_ue_rrc[ue_id])->UECap->UE_EUTRA_Capability->featureGroupIndicators->buf); //return (temp & ( 1 << (30))); + return 0; } int flexran_get_ue_transmission_mode(mid_t mod_id, mid_t ue_id) { - struct rrc_eNB_ue_context_s* ue_context_p = NULL; - uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); - - ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); - - if(ue_context_p != NULL) { - if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ - return ue_context_p->ue_context.physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode; - } - } - else - return -1; + struct rrc_eNB_ue_context_s* ue_context_p = NULL; + uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); + + ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); + + if(ue_context_p != NULL) { + if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ + return ue_context_p->ue_context.physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode; + } else { + return -1; + } + } else { + return -1; + } } int flexran_get_tti_bundling(mid_t mod_id, mid_t ue_id) { - struct rrc_eNB_ue_context_s* ue_context_p = NULL; - uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); - - ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); - if(ue_context_p != NULL) { - if(ue_context_p->ue_context.mac_MainConfig != NULL){ - return ue_context_p->ue_context.mac_MainConfig->ul_SCH_Config->ttiBundling; - } - } - else - return -1; + struct rrc_eNB_ue_context_s* ue_context_p = NULL; + uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); + + ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); + if(ue_context_p != NULL) { + if(ue_context_p->ue_context.mac_MainConfig != NULL){ + return ue_context_p->ue_context.mac_MainConfig->ul_SCH_Config->ttiBundling; + } else { + return -1; + } + } + else { + return -1; + } } int flexran_get_maxHARQ_TX(mid_t mod_id, mid_t ue_id) { @@ -1110,45 +1121,52 @@ int flexran_get_maxHARQ_TX(mid_t mod_id, mid_t ue_id) { } int flexran_get_beta_offset_ack_index(mid_t mod_id, mid_t ue_id) { - struct rrc_eNB_ue_context_s* ue_context_p = NULL; - uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); - - ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); - if(ue_context_p != NULL) { - if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ - return ue_context_p->ue_context.physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_ACK_Index; - } - } - else - return -1; + struct rrc_eNB_ue_context_s* ue_context_p = NULL; + uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); + + ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); + if(ue_context_p != NULL) { + if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ + return ue_context_p->ue_context.physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_ACK_Index; + } else { + return -1; + } + } else { + return -1; + } } int flexran_get_beta_offset_ri_index(mid_t mod_id, mid_t ue_id) { - struct rrc_eNB_ue_context_s* ue_context_p = NULL; - uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); - - ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); - if(ue_context_p != NULL) { - if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ - return ue_context_p->ue_context.physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_RI_Index; - } - } - else - return -1; + struct rrc_eNB_ue_context_s* ue_context_p = NULL; + uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); + + ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); + if(ue_context_p != NULL) { + if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ + return ue_context_p->ue_context.physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_RI_Index; + } else { + return -1; + } + } else { + return -1; + } } int flexran_get_beta_offset_cqi_index(mid_t mod_id, mid_t ue_id) { - struct rrc_eNB_ue_context_s* ue_context_p = NULL; - uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); - - ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); - if(ue_context_p != NULL) { - if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ - return ue_context_p->ue_context.physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_CQI_Index; - } - } - else - return -1; + struct rrc_eNB_ue_context_s* ue_context_p = NULL; + uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); + + ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); + if(ue_context_p != NULL) { + if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ + return ue_context_p->ue_context.physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_CQI_Index; + } else { + return -1; + } + } + else { + return -1; + } } int flexran_get_simultaneous_ack_nack_cqi(mid_t mod_id, mid_t ue_id) { @@ -1185,32 +1203,39 @@ int flexran_get_aperiodic_cqi_rep_mode(mid_t mod_id,mid_t ue_id) { } int flexran_get_tdd_ack_nack_feedback(mid_t mod_id, mid_t ue_id) { - struct rrc_eNB_ue_context_s* ue_context_p = NULL; - uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); - - ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); + // TODO: This needs fixing + return -1; - if(ue_context_p != NULL) { - if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ - return ue_context_p->ue_context.physicalConfigDedicated->pucch_ConfigDedicated->tdd_AckNackFeedbackMode; - } - } - else - return -1; + /* struct rrc_eNB_ue_context_s* ue_context_p = NULL; */ + /* uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); */ + + /* ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); */ + + /* if(ue_context_p != NULL) { */ + /* if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ */ + /* return ue_context_p->ue_context.physicalConfigDedicated->pucch_ConfigDedicated->tdd_AckNackFeedbackMode; */ + /* } else { */ + /* return -1; */ + /* } */ + /* } else { */ + /* return -1; */ + /* } */ } int flexran_get_ack_nack_repetition_factor(mid_t mod_id, mid_t ue_id) { - struct rrc_eNB_ue_context_s* ue_context_p = NULL; - uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); - - ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); - if(ue_context_p != NULL) { - if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ - return ue_context_p->ue_context.physicalConfigDedicated->pucch_ConfigDedicated->ackNackRepetition.choice.setup.repetitionFactor; - } - } - else - return -1; + struct rrc_eNB_ue_context_s* ue_context_p = NULL; + uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); + + ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); + if(ue_context_p != NULL) { + if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ + return ue_context_p->ue_context.physicalConfigDedicated->pucch_ConfigDedicated->ackNackRepetition.choice.setup.repetitionFactor; + } else { + return -1; + } + } else { + return -1; + } } int flexran_get_extended_bsr_size(mid_t mod_id, mid_t ue_id) { @@ -1233,23 +1258,26 @@ int flexran_get_extended_bsr_size(mid_t mod_id, mid_t ue_id) { } int flexran_get_ue_transmission_antenna(mid_t mod_id, mid_t ue_id) { - struct rrc_eNB_ue_context_s* ue_context_p = NULL; - uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); - - ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); - - if(ue_context_p != NULL) { - if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ - if(ue_context_p->ue_context.physicalConfigDedicated->antennaInfo->choice.explicitValue.ue_TransmitAntennaSelection.choice.setup == AntennaInfoDedicated__ue_TransmitAntennaSelection__setup_closedLoop) - return 2; - else if(ue_context_p->ue_context.physicalConfigDedicated->antennaInfo->choice.explicitValue.ue_TransmitAntennaSelection.choice.setup == AntennaInfoDedicated__ue_TransmitAntennaSelection__setup_openLoop) - return 1; - else - return 0; - } - } - else - return -1; + struct rrc_eNB_ue_context_s* ue_context_p = NULL; + uint32_t rntiP = flexran_get_ue_crnti(mod_id,ue_id); + + ue_context_p = rrc_eNB_get_ue_context(&eNB_rrc_inst[mod_id],rntiP); + + if(ue_context_p != NULL) { + if(ue_context_p->ue_context.physicalConfigDedicated != NULL){ + if(ue_context_p->ue_context.physicalConfigDedicated->antennaInfo->choice.explicitValue.ue_TransmitAntennaSelection.choice.setup == AntennaInfoDedicated__ue_TransmitAntennaSelection__setup_closedLoop) { + return 2; + } else if(ue_context_p->ue_context.physicalConfigDedicated->antennaInfo->choice.explicitValue.ue_TransmitAntennaSelection.choice.setup == AntennaInfoDedicated__ue_TransmitAntennaSelection__setup_openLoop) { + return 1; + } else { + return 0; + } + } else { + return -1; + } + } else { + return -1; + } } int flexran_get_lcg(mid_t ue_id, mid_t lc_id) { @@ -1265,10 +1293,13 @@ int flexran_get_lcg(mid_t ue_id, mid_t lc_id) { int flexran_get_direction(mid_t ue_id, mid_t lc_id) { /*TODO: fill with the value for the rest of LCID*/ - if(lc_id == DCCH | lc_id == DCCH1) + if(lc_id == DCCH || lc_id == DCCH1) { return 2; - else if(lc_id == DTCH) + } else if(lc_id == DTCH) { return 1; + } else { + return -1; + } } int flexran_agent_ue_state_change(mid_t mod_id, uint32_t rnti, uint8_t state_change) { @@ -1276,8 +1307,7 @@ int flexran_agent_ue_state_change(mid_t mod_id, uint32_t rnti, uint8_t state_cha Protocol__FlexranMessage *msg; Protocol__FlexHeader *header; void *data; - int priority; - err_code_t err_code; + int priority = 0; int xid = 0; @@ -1461,14 +1491,14 @@ int flexran_agent_ue_state_change(mid_t mod_id, uint32_t rnti, uint8_t state_cha data = flexran_agent_pack_message(msg, &size); /*Send sr info using the MAC channel of the eNB*/ if (flexran_agent_msg_send(mod_id, FLEXRAN_AGENT_DEFAULT, data, size, priority)) { - err_code = PROTOCOL__FLEXRAN_ERR__MSG_ENQUEUING; goto error; } LOG_D(FLEXRAN_AGENT,"sent message with size %d\n", size); - return; + return 0; error: LOG_D(FLEXRAN_AGENT, "Could not send UE state message\n"); + return -1; } @@ -1481,15 +1511,17 @@ int flexran_agent_lc_config_reply(mid_t mod_id, const void *params, Protocol__Fl xid = (lc_config_request_msg->header)->xid; int i, j; - Protocol__FlexHeader *header; - if(flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_GET_LC_CONFIG_REPLY, &header) != 0) - goto error; Protocol__FlexLcConfigReply *lc_config_reply_msg; lc_config_reply_msg = malloc(sizeof(Protocol__FlexLcConfigReply)); if(lc_config_reply_msg == NULL) goto error; protocol__flex_lc_config_reply__init(lc_config_reply_msg); + + Protocol__FlexHeader *header; + if(flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_GET_LC_CONFIG_REPLY, &header) != 0) + goto error; + lc_config_reply_msg->header = header; lc_config_reply_msg->n_lc_ue_config = flexran_get_num_ues(mod_id); @@ -1606,15 +1638,16 @@ int flexran_agent_ue_config_reply(mid_t mod_id, const void *params, Protocol__Fl int i; - Protocol__FlexHeader *header; - if(flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_GET_UE_CONFIG_REPLY, &header) != 0) - goto error; - Protocol__FlexUeConfigReply *ue_config_reply_msg; ue_config_reply_msg = malloc(sizeof(Protocol__FlexUeConfigReply)); if(ue_config_reply_msg == NULL) goto error; protocol__flex_ue_config_reply__init(ue_config_reply_msg); + + Protocol__FlexHeader *header; + if(flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_GET_UE_CONFIG_REPLY, &header) != 0) + goto error; + ue_config_reply_msg->header = header; ue_config_reply_msg->n_ue_config = flexran_get_num_ues(mod_id); @@ -1805,16 +1838,16 @@ int flexran_agent_enb_config_request(mid_t mod_id, const void* params, Protocol_ Protocol__FlexHeader *header; xid_t xid = 1; - if(flexran_create_header(xid,PROTOCOL__FLEX_TYPE__FLPT_GET_ENB_CONFIG_REQUEST, &header) != 0) - goto error; Protocol__FlexEnbConfigRequest *enb_config_request_msg; enb_config_request_msg = malloc(sizeof(Protocol__FlexEnbConfigRequest)); - if(enb_config_request_msg == NULL) goto error; - protocol__flex_enb_config_request__init(enb_config_request_msg); + + if(flexran_create_header(xid,PROTOCOL__FLEX_TYPE__FLPT_GET_ENB_CONFIG_REQUEST, &header) != 0) + goto error; + enb_config_request_msg->header = header; *msg = malloc(sizeof(Protocol__FlexranMessage)); @@ -1846,19 +1879,19 @@ int flexran_agent_enb_config_reply(mid_t mod_id, const void *params, Protocol__F Protocol__FlexEnbConfigRequest *enb_config_req_msg = input->enb_config_request_msg; xid = (enb_config_req_msg->header)->xid; - int i, j, k; - int cc_id = 0; + int i, j; int enb_id = mod_id; - Protocol__FlexHeader *header; - if(flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_GET_ENB_CONFIG_REPLY, &header) != 0) - goto error; - - Protocol__FlexEnbConfigReply *enb_config_reply_msg; + Protocol__FlexEnbConfigReply *enb_config_reply_msg; enb_config_reply_msg = malloc(sizeof(Protocol__FlexEnbConfigReply)); if(enb_config_reply_msg == NULL) goto error; protocol__flex_enb_config_reply__init(enb_config_reply_msg); + + Protocol__FlexHeader *header; + if(flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_GET_ENB_CONFIG_REPLY, &header) != 0) + goto error; + enb_config_reply_msg->header = header; enb_config_reply_msg->enb_id = mod_id; diff --git a/openair2/ENB_APP/flexran_agent_common.h b/openair2/ENB_APP/flexran_agent_common.h index 56a52cd0b674480425fbace461cd23a838780615..a4ee53067cd2731d30337c42a58e50a7c39dbee3 100644 --- a/openair2/ENB_APP/flexran_agent_common.h +++ b/openair2/ENB_APP/flexran_agent_common.h @@ -72,7 +72,7 @@ int flexran_agent_deserialize_message(void *data, int size, Protocol__FlexranMes /* Serialize message and then destroy the input flexran msg. Should be called when protocol message is created dynamically */ void * flexran_agent_pack_message(Protocol__FlexranMessage *msg, - uint32_t * size); + int * size); /* Calls destructor of the given message */ err_code_t flexran_agent_destroy_flexran_message(Protocol__FlexranMessage *msg); @@ -271,7 +271,7 @@ int flexran_get_tpc(mid_t mod_id, mid_t ue_id); a designated frame and subframe. Returns 0 for success. The id and the status of the HARQ process are stored in id and status respectively */ int flexran_get_harq(const mid_t mod_id, const uint8_t CC_id, const mid_t ue_id, - const int frame, const uint8_t subframe, int *id, int *round); + const int frame, const uint8_t subframe, unsigned char *id, unsigned char *round); /* Uplink power control management*/ int flexran_get_p0_pucch_dbm(mid_t mod_id, mid_t ue_id, int CC_id); diff --git a/openair2/ENB_APP/flexran_agent_common_internal.c b/openair2/ENB_APP/flexran_agent_common_internal.c index 3026190863e4cd32469b84d03f8c3874b52d2b6a..e735b2748b955c98c4666fe68828360229d1fc89 100644 --- a/openair2/ENB_APP/flexran_agent_common_internal.c +++ b/openair2/ENB_APP/flexran_agent_common_internal.c @@ -38,13 +38,12 @@ int apply_reconfiguration_policy(mid_t mod_id, const char *policy, size_t policy yaml_event_t event; int done = 0; - int mapping_started = 0; LOG_I(ENB_APP, "Time to apply a new policy \n"); yaml_parser_initialize(&parser); - yaml_parser_set_input_string(&parser, policy, strlen(policy)); + yaml_parser_set_input_string(&parser, (unsigned char *) policy, strlen(policy)); while (!done) { if (!yaml_parser_parse(&parser, &event)) @@ -52,39 +51,40 @@ int apply_reconfiguration_policy(mid_t mod_id, const char *policy, size_t policy switch (event.type) { case YAML_STREAM_START_EVENT: + break; case YAML_STREAM_END_EVENT: + break; case YAML_DOCUMENT_START_EVENT: + break; case YAML_DOCUMENT_END_EVENT: break; case YAML_MAPPING_START_EVENT: - mapping_started = 1; break; case YAML_MAPPING_END_EVENT: - mapping_started = 0; break; case YAML_SCALAR_EVENT: // Check the system name and call the proper handler - if (strcmp(event.data.scalar.value, "mac") == 0) { + if (strcmp((char *) event.data.scalar.value, "mac") == 0) { LOG_D(ENB_APP, "This is intended for the mac system\n"); // Call the mac handler if (parse_mac_config(mod_id, &parser) == -1) { goto error; } - } else if (strcmp(event.data.scalar.value, "rlc") == 0) { + } else if (strcmp((char *) event.data.scalar.value, "rlc") == 0) { // Call the RLC handler LOG_D(ENB_APP, "This is intended for the rlc system\n"); // TODO : Just skip it for now if (skip_system_section(&parser) == -1) { goto error; } - } else if (strcmp(event.data.scalar.value, "pdcp") == 0) { + } else if (strcmp((char *) event.data.scalar.value, "pdcp") == 0) { // Call the PDCP handler LOG_D(ENB_APP, "This is intended for the pdcp system\n"); // TODO : Just skip it for now if (skip_system_section(&parser) == -1) { goto error; } - } else if (strcmp(event.data.scalar.value, "rrc") == 0) { + } else if (strcmp((char *) event.data.scalar.value, "rrc") == 0) { // Call the RRC handler LOG_D(ENB_APP, "This is intended for the rrc system\n"); // TODO : Just skip it for now @@ -159,8 +159,9 @@ int skip_system_section(yaml_parser_t *parser) { if (skip_subsystem_section(parser) == -1) { goto error; } + default: + break; } - done = (event.type == YAML_SEQUENCE_END_EVENT); yaml_event_delete(&event); @@ -199,7 +200,7 @@ int skip_subsystem_section(yaml_parser_t *parser) { goto error; } // Check what key needs to be set - if (strcmp(event.data.scalar.value, "behavior") == 0) { + if (strcmp((char *) event.data.scalar.value, "behavior") == 0) { LOG_D(ENB_APP, "Skipping the behavior attribute\n"); yaml_event_delete(&event); if (!yaml_parser_parse(parser, &event)) { @@ -210,7 +211,7 @@ int skip_subsystem_section(yaml_parser_t *parser) { } else { goto error; } - } else if (strcmp(event.data.scalar.value, "parameters") == 0) { + } else if (strcmp((char *) event.data.scalar.value, "parameters") == 0) { LOG_D(ENB_APP, "Skipping the parameters for this subsystem\n"); if (skip_subsystem_parameters_config(parser) == -1) { goto error; @@ -235,8 +236,6 @@ int skip_subsystem_section(yaml_parser_t *parser) { int skip_subsystem_parameters_config(yaml_parser_t *parser) { yaml_event_t event; - void *param; - int done = 0; int mapping_started = 0; @@ -299,10 +298,10 @@ int skip_parameter_modification(yaml_parser_t *parser) { is_array = 1; break; case YAML_SCALAR_EVENT: - if ((strcmp(event.data.scalar.tag, YAML_INT_TAG) == 0) || - (strcmp(event.data.scalar.tag, YAML_FLOAT_TAG) == 0) || - (strcmp(event.data.scalar.tag, YAML_STR_TAG) == 0) || - (strcmp(event.data.scalar.tag, YAML_BOOL_TAG) == 0)) { + if ((strcmp((char *) event.data.scalar.tag, YAML_INT_TAG) == 0) || + (strcmp((char *) event.data.scalar.tag, YAML_FLOAT_TAG) == 0) || + (strcmp((char *) event.data.scalar.tag, YAML_STR_TAG) == 0) || + (strcmp((char *) event.data.scalar.tag, YAML_BOOL_TAG) == 0)) { // Do nothing } else { // No other type is supported at the moment, so it should be considered an error @@ -351,14 +350,14 @@ int apply_parameter_modification(void *parameter, yaml_parser_t *parser) { is_array = 1; break; case YAML_SCALAR_EVENT: - if (strcmp(event.data.scalar.tag, YAML_INT_TAG) == 0) { - ((int *) parameter)[i] = strtol(event.data.scalar.value, &endptr, 10); - } else if (strcmp(event.data.scalar.tag, YAML_FLOAT_TAG) == 0) { - ((float *) parameter)[i] = strtof(event.data.scalar.value, &endptr); - } else if (strcmp(event.data.scalar.tag, YAML_STR_TAG) == 0) { - strncpy(&((char *) parameter)[i], event.data.scalar.value, event.data.scalar.length); - } else if (strcmp(event.data.scalar.tag, YAML_BOOL_TAG) == 0) { - if (strcmp(event.data.scalar.value, "true") == 0) { + if (strcmp((char *) event.data.scalar.tag, YAML_INT_TAG) == 0) { + ((int *) parameter)[i] = strtol((char *) event.data.scalar.value, &endptr, 10); + } else if (strcmp((char *) event.data.scalar.tag, YAML_FLOAT_TAG) == 0) { + ((float *) parameter)[i] = strtof((char *) event.data.scalar.value, &endptr); + } else if (strcmp((char *) event.data.scalar.tag, YAML_STR_TAG) == 0) { + strncpy(&((char *) parameter)[i], (char *) event.data.scalar.value, event.data.scalar.length); + } else if (strcmp((char *) event.data.scalar.tag, YAML_BOOL_TAG) == 0) { + if (strcmp((char *) event.data.scalar.value, "true") == 0) { ((int *) parameter)[i] = 1; } else { ((int *) parameter)[i] = 0; diff --git a/openair2/ENB_APP/flexran_agent_handler.c b/openair2/ENB_APP/flexran_agent_handler.c index 4967e4692334d0b8fe86a379be929c99e854f5ac..4326ab6be03241df516c82d6f2f27129f2a2599a 100644 --- a/openair2/ENB_APP/flexran_agent_handler.c +++ b/openair2/ENB_APP/flexran_agent_handler.c @@ -73,12 +73,12 @@ flexran_agent_message_destruction_callback message_destruction_callback[] = { flexran_agent_destroy_agent_reconfiguration, }; -static const char *flexran_agent_direction2String[] = { - "", /* not_set */ - "originating message", /* originating message */ - "successfull outcome", /* successfull outcome */ - "unsuccessfull outcome", /* unsuccessfull outcome */ -}; +/* static const char *flexran_agent_direction2String[] = { */ +/* "", /\* not_set *\/ */ +/* "originating message", /\* originating message *\/ */ +/* "successfull outcome", /\* successfull outcome *\/ */ +/* "unsuccessfull outcome", /\* unsuccessfull outcome *\/ */ +/* }; */ Protocol__FlexranMessage* flexran_agent_handle_message (mid_t mod_id, @@ -123,7 +123,7 @@ error: void * flexran_agent_pack_message(Protocol__FlexranMessage *msg, - uint32_t * size){ + int * size){ void * buffer; err_code_t err_code = PROTOCOL__FLEXRAN_ERR__NO_ERR; @@ -181,7 +181,7 @@ Protocol__FlexranMessage* flexran_agent_process_timeout(long timer_id, void* tim error: LOG_E(FLEXRAN_AGENT, "can't get the timer element\n"); - return TIMER_ELEMENT_NOT_FOUND; + return NULL; } err_code_t flexran_agent_destroy_flexran_message(Protocol__FlexranMessage *msg) { diff --git a/openair2/LAYER2/MAC/config.c b/openair2/LAYER2/MAC/config.c index e4252ed50049afbc0f19362697f10e11956fe301..b5d613e4ae4d8e392602a64d4a03cd8752d2e990 100644 --- a/openair2/LAYER2/MAC/config.c +++ b/openair2/LAYER2/MAC/config.c @@ -183,22 +183,26 @@ rrc_mac_config_req( logicalChannelConfig->ul_SpecificParameters->bucketSizeDuration; // set the max bucket size if (logicalChannelConfig->ul_SpecificParameters->logicalChannelGroup != NULL) { UE_mac_inst[Mod_idP].scheduling_info.LCGID[logicalChannelIdentity]=*logicalChannelConfig->ul_SpecificParameters->logicalChannelGroup; - LOG_D(MAC,"[CONFIG][UE %d] LCID %d is attached to the LCGID %d\n",Mod_idP,logicalChannelIdentity,*logicalChannelConfig->ul_SpecificParameters->logicalChannelGroup); + LOG_D(MAC,"[CONFIG][UE %d] LCID %ld is attached to the LCGID %ld\n",Mod_idP,logicalChannelIdentity,*logicalChannelConfig->ul_SpecificParameters->logicalChannelGroup); } else { UE_mac_inst[Mod_idP].scheduling_info.LCGID[logicalChannelIdentity] = MAX_NUM_LCGID; } UE_mac_inst[Mod_idP].scheduling_info.LCID_buffer_remain[logicalChannelIdentity] = 0; } else { - LOG_E(MAC,"[CONFIG][UE %d] LCID %d NULL ul_SpecificParameters\n",Mod_idP,logicalChannelIdentity); + LOG_E(MAC,"[CONFIG][UE %d] LCID %ld NULL ul_SpecificParameters\n",Mod_idP,logicalChannelIdentity); mac_xface->macphy_exit("NULL ul_SpecificParameters"); } } else { - if (logicalChannelConfig) - UE_list->UE_template[CC_idP][UE_id].lcgidmap[logicalChannelIdentity] = *logicalChannelConfig->ul_SpecificParameters->logicalChannelGroup; - else - UE_list->UE_template[CC_idP][UE_id].lcgidmap[logicalChannelIdentity] = 0; + if (UE_id == -1) { + LOG_E(MAC,"%s:%d:%s: ERROR, UE_id == -1\n", __FILE__, __LINE__, __FUNCTION__); + } else { + if (logicalChannelConfig) + UE_list->UE_template[CC_idP][UE_id].lcgidmap[logicalChannelIdentity] = *logicalChannelConfig->ul_SpecificParameters->logicalChannelGroup; + else + UE_list->UE_template[CC_idP][UE_id].lcgidmap[logicalChannelIdentity] = 0; + } } } @@ -296,7 +300,10 @@ rrc_mac_config_req( if (physicalConfigDedicated != NULL) { if (eNB_flagP==1) { - mac_xface->phy_config_dedicated_eNB(Mod_idP, CC_idP, UE_RNTI(Mod_idP, UE_id), physicalConfigDedicated); + if (UE_id == -1) + LOG_E(MAC,"%s:%d:%s: ERROR, UE_id == -1\n", __FILE__, __LINE__, __FUNCTION__); + else + mac_xface->phy_config_dedicated_eNB(Mod_idP, CC_idP, UE_RNTI(Mod_idP, UE_id), physicalConfigDedicated); } else { mac_xface->phy_config_dedicated_ue(Mod_idP,0,eNB_index,physicalConfigDedicated); UE_mac_inst[Mod_idP].physicalConfigDedicated=physicalConfigDedicated; // for SR proc @@ -308,7 +315,10 @@ rrc_mac_config_req( if (sCellToAddMod_r10 != NULL) { if (eNB_flagP==1) { - mac_xface->phy_config_dedicated_scell_eNB(Mod_idP,UE_RNTI(Mod_idP,UE_id),sCellToAddMod_r10,1); + if (UE_id == -1) + LOG_E(MAC,"%s:%d:%s: ERROR, UE_id == -1\n", __FILE__, __LINE__, __FUNCTION__); + else + mac_xface->phy_config_dedicated_scell_eNB(Mod_idP,UE_RNTI(Mod_idP,UE_id),sCellToAddMod_r10,1); } else { //#warning "phy_config_dedicated_scell_ue is empty" diff --git a/openair2/LAYER2/MAC/defs.h b/openair2/LAYER2/MAC/defs.h index 15c0f3fb0e826dcbba8486d31483ceb0decdca61..63501128ef41359cdddb3f9dadaf87eeb67c3fdf 100644 --- a/openair2/LAYER2/MAC/defs.h +++ b/openair2/LAYER2/MAC/defs.h @@ -145,6 +145,9 @@ /*!\brief minimum MAC data needed for transmitting 1 min RLC PDU size + 1 byte MAC subHeader */ #define MIN_MAC_HDR_RLC_SIZE (1 + MIN_RLC_PDU_SIZE) +/*!\brief maximum number of slices / groups */ +#define MAX_NUM_SLICES 4 + /* * eNB part */ diff --git a/openair2/LAYER2/MAC/eNB_scheduler.c b/openair2/LAYER2/MAC/eNB_scheduler.c index c5dc8c88b04465ab71f69033ae2cd83cdb753acb..1a61c669480e7fe35b6af6d80e885d27cc9dc1da 100644 --- a/openair2/LAYER2/MAC/eNB_scheduler.c +++ b/openair2/LAYER2/MAC/eNB_scheduler.c @@ -99,7 +99,7 @@ void eNB_dlsch_ulsch_scheduler(module_id_t module_idP,uint8_t cooperation_flag, int result; #endif DCI_PDU *DCI_pdu[MAX_NUM_CCs]; - int CC_id,i,next_i; + int CC_id,i; //,next_i; UE_list_t *UE_list=&eNB_mac_inst[module_idP].UE_list; rnti_t rnti; void *DLSCH_dci=NULL; @@ -121,17 +121,27 @@ void eNB_dlsch_ulsch_scheduler(module_id_t module_idP,uint8_t cooperation_flag, memset(eNB_mac_inst[module_idP].common_channels[CC_id].vrb_map,0,100); } + // clear DCI and BCCH contents before scheduling + for (CC_id=0; CC_idNum_common_dci = 0; + DCI_pdu[CC_id]->Num_ue_spec_dci = 0; +#ifdef Rel10 + eNB_mac_inst[module_idP].common_channels[CC_id].mcch_active =0; +#endif + eNB_mac_inst[module_idP].frame = frameP; + eNB_mac_inst[module_idP].subframe = subframeP; + } + // refresh UE list based on UEs dropped by PHY in previous subframe - i = UE_list->head; + for (i = 0; i < NUMBER_OF_UE_MAX; i++) { + if (UE_list->active[i] != TRUE) continue; - while (i>=0) { rnti = UE_RNTI(module_idP, i); CC_id = UE_PCCID(module_idP, i); if ((frameP==0)&&(subframeP==0)) - LOG_I(MAC,"UE rnti %x : %s\n", rnti, - UE_list->UE_sched_ctrl[i].ul_out_of_sync==0 ? "in synch" : "out of sync"); - - next_i= UE_list->next[i]; + LOG_I(MAC,"UE rnti %x : %s, PHR %d dB\n", rnti, + UE_list->UE_sched_ctrl[i].ul_out_of_sync==0 ? "in synch" : "out of sync", + UE_list->UE_template[CC_id][i].phr_info); PHY_vars_eNB_g[module_idP][CC_id]->pusch_stats_bsr[i][(frameP*10)+subframeP]=-63; if (i==UE_list->head) @@ -253,15 +263,13 @@ void eNB_dlsch_ulsch_scheduler(module_id_t module_idP,uint8_t cooperation_flag, // check threshold if (UE_list->UE_sched_ctrl[i].ul_failure_timer > 200) { // inform RRC of failure and clear timer - LOG_I(MAC,"UE %d rnti %x: UL Failure after repeated PDCCH orders: Triggering RRC \n",i,rnti,UE_list->UE_sched_ctrl[i].ul_failure_timer); + LOG_I(MAC,"UE %d rnti %x: UL Failure after repeated PDCCH orders: Triggering RRC \n",i,rnti); mac_eNB_rrc_ul_failure(module_idP,CC_id,frameP,subframeP,rnti); UE_list->UE_sched_ctrl[i].ul_failure_timer=0; UE_list->UE_sched_ctrl[i].ul_out_of_sync=1; } } } // ul_failure_timer>0 - - i = next_i; } #if defined(ENABLE_ITTI) @@ -318,22 +326,6 @@ void eNB_dlsch_ulsch_scheduler(module_id_t module_idP,uint8_t cooperation_flag, #endif - // clear DCI and BCCH contents before scheduling - for (CC_id=0; CC_idNum_common_dci = 0; - DCI_pdu[CC_id]->Num_ue_spec_dci = 0; - - -#ifdef Rel10 - eNB_mac_inst[module_idP].common_channels[CC_id].mcch_active =0; -#endif - - eNB_mac_inst[module_idP].frame = frameP; - eNB_mac_inst[module_idP].subframe = subframeP; - - - } - /* #ifndef DISABLE_SF_TRIGGER */ /* //Send subframe trigger to the controller */ /* if (mac_agent_registered[module_idP]) { */ diff --git a/openair2/LAYER2/MAC/eNB_scheduler_RA.c b/openair2/LAYER2/MAC/eNB_scheduler_RA.c index e24281b89aeb985a17310d33cb805df5fd20cb18..991f8bfbfa55061de2eab1fdf2216bbc20fe4cbd 100644 --- a/openair2/LAYER2/MAC/eNB_scheduler_RA.c +++ b/openair2/LAYER2/MAC/eNB_scheduler_RA.c @@ -73,7 +73,7 @@ void schedule_RA(module_id_t module_idP,frame_t frameP, sub_frame_t subframeP,un unsigned char i,harq_pid,round; int16_t rrc_sdu_length; unsigned char lcid,offset; - module_id_t UE_id= UE_INDEX_INVALID; + int UE_id = -1; unsigned short TBsize = -1; unsigned short msg4_padding,msg4_post_padding,msg4_header; uint8_t *vrb_map; @@ -266,6 +266,7 @@ void schedule_RA(module_id_t module_idP,frame_t frameP, sub_frame_t subframeP,un // check for Msg4 Message UE_id = find_UE_id(module_idP,RA_template->rnti); + if (UE_id == -1) { printf("%s:%d:%s: FATAL ERROR\n", __FILE__, __LINE__, __FUNCTION__); abort(); } if (Is_rrc_registered == 1) { @@ -709,7 +710,10 @@ void schedule_RA(module_id_t module_idP,frame_t frameP, sub_frame_t subframeP,un RA_template->RA_dci_size_bits2, RA_template->RA_dci_fmt2, 0); +printf("MAC: msg4 retransmission for rnti %x (round %d) fsf %d/%d\n", RA_template->rnti, round, frameP, subframeP); } +else +printf("MAC: msg4 retransmission for rnti %x (round %d) fsf %d/%d CCE allocation failed!\n", RA_template->rnti, round, frameP, subframeP); LOG_W(MAC,"[eNB %d][RAPROC] CC_id %d Frame %d, subframeP %d: Msg4 not acknowledged, adding ue specific dci (rnti %x) for RA (Msg4 Retransmission)\n", module_idP,CC_id,frameP,subframeP,RA_template->rnti); } else { @@ -718,6 +722,7 @@ void schedule_RA(module_id_t module_idP,frame_t frameP, sub_frame_t subframeP,un remove UE instance across all the layers: mac_xface->cancel_RA(); } */ +printf("MAC: msg4 acknowledged for rnti %x fsf %d/%d, let's configure it\n", RA_template->rnti, frameP, subframeP); LOG_I(MAC,"[eNB %d][RAPROC] CC_id %d Frame %d, subframeP %d : Msg4 acknowledged\n",module_idP,CC_id,frameP,subframeP); RA_template->wait_ack_Msg4=0; RA_template->RA_active=FALSE; @@ -746,14 +751,26 @@ void initiate_ra_proc(module_id_t module_idP, int CC_id,frame_t frameP, uint16_t VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_INITIATE_RA_PROC,0); for (i=0; i= 1024 && RA_template[i].rnti < 60000)); + if (loop == 100) { printf("%s:%d:%s: FATAL ERROR! contact the authors\n", __FILE__, __LINE__, __FUNCTION__); abort(); } RA_template[i].RA_rnti = 1+subframeP+(10*f_id); RA_template[i].preamble_index = preamble_index; LOG_D(MAC,"[eNB %d][RAPROC] CC_id %d Frame %d Activating RAR generation for process %d, rnti %x, RA_active %d\n", @@ -763,6 +780,8 @@ void initiate_ra_proc(module_id_t module_idP, int CC_id,frame_t frameP, uint16_t return; } } + + LOG_E(MAC,"[eNB %d][RAPROC] FAILURE: CC_id %d Frame %d Initiating RA procedure for preamble index %d\n",module_idP,CC_id,frameP,preamble_index); } void cancel_ra_proc(module_id_t module_idP, int CC_id, frame_t frameP, rnti_t rnti) diff --git a/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c b/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c index 399fd701cec13119ab204a843398391a41f326fb..3933fe3f8dea5eae172fdc5db8a329732023df98 100644 --- a/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c +++ b/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c @@ -442,7 +442,7 @@ schedule_ue_spec( // unsigned char rballoc_sub_UE[MAX_NUM_CCs][NUMBER_OF_UE_MAX][N_RBG_MAX]; // uint16_t pre_nb_available_rbs[MAX_NUM_CCs][NUMBER_OF_UE_MAX]; int mcs; - uint16_t min_rb_unit[MAX_NUM_CCs]; + int min_rb_unit[MAX_NUM_CCs]; eNB_MAC_INST *eNB = &eNB_mac_inst[module_idP]; UE_list_t *UE_list = &eNB->UE_list; LTE_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]; @@ -453,9 +453,11 @@ schedule_ue_spec( UE_sched_ctrl *ue_sched_ctl; int i; +#if 0 if (UE_list->head==-1) { return; } +#endif start_meas(&eNB->schedule_dlsch); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_SCHEDULE_DLSCH,VCD_FUNCTION_IN); @@ -814,15 +816,15 @@ schedule_ue_spec( if (rlc_status.bytes_in_buffer > 0) { // There is DCCH to transmit LOG_D(MAC,"[eNB %d] Frame %d, DL-DCCH->DLSCH CC_id %d, Requesting %d bytes from RLC (RRC message)\n", module_idP,frameP,CC_id,TBS-header_len_dcch); - sdu_lengths[0] += mac_rlc_data_req( - module_idP, - rnti, - module_idP, - frameP, - ENB_FLAG_YES, - MBMS_FLAG_NO, - DCCH, - (char *)&dlsch_buffer[sdu_lengths[0]]); + sdu_lengths[0] = mac_rlc_data_req( + module_idP, + rnti, + module_idP, + frameP, + ENB_FLAG_YES, + MBMS_FLAG_NO, + DCCH, + (char *)&dlsch_buffer[0]); T(T_ENB_MAC_UE_DL_SDU, T_INT(module_idP), T_INT(CC_id), T_INT(rnti), T_INT(frameP), T_INT(subframeP), T_INT(harq_pid), T_INT(DCCH), T_INT(sdu_lengths[0])); @@ -847,7 +849,7 @@ schedule_ue_spec( sdu_length_total = 0; } } - + // check for DCCH1 and update header information (assume 2 byte sub-header) if (TBS-ta_len-header_len_dcch-sdu_length_total > 0 ) { rlc_status = mac_rlc_status_ind( @@ -860,9 +862,10 @@ schedule_ue_spec( DCCH+1, (TBS-ta_len-header_len_dcch-sdu_length_total)); // transport block set size less allocations for timing advance and // DCCH SDU + sdu_lengths[num_sdus] = 0; if (rlc_status.bytes_in_buffer > 0) { - LOG_D(MAC,"[eNB %d], Frame %d, DCCH1->DLSCH, CC_id %d, Requesting %d bytes from RLC (RRC message)\n", + LOG_I(MAC,"[eNB %d], Frame %d, DCCH1->DLSCH, CC_id %d, Requesting %d bytes from RLC (RRC message)\n", module_idP,frameP,CC_id,TBS-header_len_dcch-sdu_length_total); sdu_lengths[num_sdus] += mac_rlc_data_req( module_idP, @@ -872,7 +875,7 @@ schedule_ue_spec( ENB_FLAG_YES, MBMS_FLAG_NO, DCCH+1, - (char *)&dlsch_buffer[sdu_lengths[num_sdus]]); + (char *)&dlsch_buffer[sdu_length_total]); T(T_ENB_MAC_UE_DL_SDU, T_INT(module_idP), T_INT(CC_id), T_INT(rnti), T_INT(frameP), T_INT(subframeP), T_INT(harq_pid), T_INT(DCCH+1), T_INT(sdu_lengths[num_sdus])); @@ -1650,7 +1653,10 @@ fill_DLSCH_dci( break; case 3: - LOG_D(MAC,"[eNB %d] CC_id %d Adding Format 2A UE %d spec DCI for %d PRBS (rb alloc: %x) \n", + /* TODO: fix log, what is 'rb alloc'? */ + /*LOG_D(MAC,"[eNB %d] CC_id %d Adding Format 2A UE %d spec DCI for %d PRBS (rb alloc: %x) \n", + module_idP, CC_id, UE_id, nb_rb);*/ + LOG_D(MAC,"[eNB %d] CC_id %d Adding Format 2A UE %d spec DCI for %d PRBS\n", module_idP, CC_id, UE_id, nb_rb); if (PHY_vars_eNB_g[module_idP][CC_id]->frame_parms.frame_type == TDD) { diff --git a/openair2/LAYER2/MAC/eNB_scheduler_primitives.c b/openair2/LAYER2/MAC/eNB_scheduler_primitives.c index ffd9630648d1dd18811f67ee5da965cbd7d14931..9dfd2f095b230ae3d7595120622b12ab13235c4b 100644 --- a/openair2/LAYER2/MAC/eNB_scheduler_primitives.c +++ b/openair2/LAYER2/MAC/eNB_scheduler_primitives.c @@ -107,18 +107,17 @@ DCI_PDU *get_dci_sdu(module_id_t module_idP, int CC_id,frame_t frameP, sub_frame int find_UE_id(module_id_t mod_idP, rnti_t rntiP) //------------------------------------------------------------------------------ { - int UE_id; UE_list_t *UE_list = &eNB_mac_inst[mod_idP].UE_list; - for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id]) { + for (UE_id = 0; UE_id < NUMBER_OF_UE_MAX; UE_id++) { + if (UE_list->active[UE_id] != TRUE) continue; if (UE_list->UE_template[UE_PCCID(mod_idP,UE_id)][UE_id].rnti==rntiP) { return(UE_id); } } return(-1); - } //------------------------------------------------------------------------------ @@ -235,21 +234,17 @@ void dump_ue_list(UE_list_t *listP, int ul_flag) int add_new_ue(module_id_t mod_idP, int cc_idP, rnti_t rntiP,int harq_pidP) { int UE_id; - int j; + int i, j; UE_list_t *UE_list = &eNB_mac_inst[mod_idP].UE_list; LOG_D(MAC,"[eNB %d, CC_id %d] Adding UE with rnti %x (next avail %d, num_UEs %d)\n",mod_idP,cc_idP,rntiP,UE_list->avail,UE_list->num_UEs); dump_ue_list(UE_list,0); - if (UE_list->avail>=0) { - UE_id = UE_list->avail; - AssertFatal( UE_id < NUMBER_OF_UE_MAX, "BAD UE_id %u > NUMBER_OF_UE_MAX",UE_id ); - UE_list->avail = UE_list->next[UE_list->avail]; - UE_list->next[UE_id] = UE_list->head; - UE_list->next_ul[UE_id] = UE_list->head_ul; - UE_list->head = UE_id; - UE_list->head_ul = UE_id; + for (i = 0; i < NUMBER_OF_UE_MAX; i++) { + if (UE_list->active[i] == TRUE) continue; +printf("MAC: new UE id %d rnti %x\n", i, rntiP); + UE_id = i; UE_list->UE_template[cc_idP][UE_id].rnti = rntiP; UE_list->UE_template[cc_idP][UE_id].configured = FALSE; UE_list->numactiveCCs[UE_id] = 1; @@ -273,6 +268,7 @@ int add_new_ue(module_id_t mod_idP, int cc_idP, rnti_t rntiP,int harq_pidP) return(UE_id); } +printf("MAC: cannot add new UE for rnti %x\n", rntiP); LOG_E(MAC,"error in add_new_ue(), could not find space in UE_list, Dumping UE list\n"); dump_ue_list(UE_list,0); return(-1); @@ -282,23 +278,27 @@ int add_new_ue(module_id_t mod_idP, int cc_idP, rnti_t rntiP,int harq_pidP) int rrc_mac_remove_ue(module_id_t mod_idP,rnti_t rntiP) //------------------------------------------------------------------------------ { - - int prev,i, ret=-1; - - + int i; UE_list_t *UE_list = &eNB_mac_inst[mod_idP].UE_list; int UE_id = find_UE_id(mod_idP,rntiP); - int pCC_id = UE_PCCID(mod_idP,UE_id); + int pCC_id; if (UE_id == -1) { +printf("MAC: cannot remove UE rnti %x\n", rntiP); LOG_W(MAC,"rrc_mac_remove_ue: UE %x not found\n", rntiP); - mac_phy_remove_ue(mod_idP,rntiP); + mac_phy_remove_ue(mod_idP, rntiP); return 0; } + pCC_id = UE_PCCID(mod_idP,UE_id); + +printf("MAC: remove UE %d rnti %x\n", UE_id, rntiP); LOG_I(MAC,"Removing UE %d from Primary CC_id %d (rnti %x)\n",UE_id,pCC_id, rntiP); dump_ue_list(UE_list,0); + UE_list->active[UE_id] = FALSE; + UE_list->num_UEs--; + // clear all remaining pending transmissions UE_list->UE_template[pCC_id][UE_id].bsr_info[LCGID0] = 0; UE_list->UE_template[pCC_id][UE_id].bsr_info[LCGID1] = 0; @@ -313,58 +313,13 @@ int rrc_mac_remove_ue(module_id_t mod_idP,rnti_t rntiP) eNB_dlsch_info[mod_idP][pCC_id][UE_id].rnti = NOT_A_RNTI; eNB_dlsch_info[mod_idP][pCC_id][UE_id].status = S_DL_NONE; - prev = UE_list->head; - - for (i=UE_list->head; i>=0; i=UE_list->next[i]) { - if (i == UE_id) { - // link prev to next in Active list - if (i==UE_list->head) { - UE_list->head = UE_list->next[i]; - } else { - UE_list->next[prev] = UE_list->next[i]; - } - - // add UE id (i)to available - UE_list->next[i] = UE_list->avail; - UE_list->avail = i; - UE_list->active[i] = FALSE; - UE_list->num_UEs--; - ret=0; - break; - } - - prev=i; - } - - // do the same for UL - prev = UE_list->head_ul; - - for (i=UE_list->head_ul; i>=0; i=UE_list->next_ul[i]) { - if (i == UE_id) { - // link prev to next in Active list - if (i==UE_list->head_ul) { - UE_list->head_ul = UE_list->next_ul[i]; - } else { - UE_list->next_ul[prev] = UE_list->next_ul[i]; - } - - // add UE id (i)to available - UE_list->next_ul[i] = UE_list->avail; - ret = 0; - break; - } - - prev=i; - } - mac_phy_remove_ue(mod_idP,rntiP); // check if this has an RA process active RA_TEMPLATE *RA_template; for (i=0;iRA_active == TRUE) && - (RA_template->rnti == rntiP)){ + if (RA_template->rnti == rntiP){ RA_template->RA_active=FALSE; RA_template->generate_rar=0; RA_template->generate_Msg4=0; @@ -372,18 +327,11 @@ int rrc_mac_remove_ue(module_id_t mod_idP,rnti_t rntiP) RA_template->timing_offset=0; RA_template->RRC_timer=20; RA_template->rnti = 0; - break; + //break; } } - if (ret == 0) { - return (0); - } - - LOG_E(MAC,"error in mac_remove_ue(), could not find previous to %d in UE_list, should never happen, Dumping UE list\n",UE_id); - dump_ue_list(UE_list,0); - mac_xface->macphy_exit("mac_remove_ue: Problem in UE_list"); - return(-1); + return 0; } @@ -791,7 +739,8 @@ int get_min_rb_unit(module_id_t module_id, uint8_t CC_id) default: min_rb_unit=2; - LOG_W(MAC,"[eNB %d] N_DL_RB %d unknown for CC_id %d, setting min_rb_unit to 2\n", module_id, CC_id); + LOG_W(MAC,"[eNB %d] N_DL_RB %d unknown for CC_id %d, setting min_rb_unit to 2\n", + module_id, frame_parms->N_RB_DL, CC_id); break; } @@ -1095,7 +1044,7 @@ try_again: 1<dci_alloc[j].L, nCCE,nCCE_max,DCI_pdu->num_pdcch_symbols); } - dump_CCE_table(CCE_table,nCCE_max,subframeP,dci_alloc->rnti,dci_alloc->L); + //dump_CCE_table(CCE_table,nCCE_max,subframeP,dci_alloc->rnti,dci_alloc->L); goto failed; } diff --git a/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c b/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c index c37224fbfb8e54effc0811311719b1ec1e522c0a..3fd1ba6508826ca661ea81ff467c32a52df9bb54 100644 --- a/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c +++ b/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c @@ -333,7 +333,7 @@ void rx_sdu(const module_id_t enb_mod_idP, if (UE_id < 0) { memcpy(&eNB->common_channels[CC_idP].RA_template[ii].cont_res_id[0],payload_ptr,6); - LOG_I(MAC,"[eNB %d][RAPROC] CC_id %d Frame %d CCCH: Received Msg3: length %d, offset %d\n", + LOG_I(MAC,"[eNB %d][RAPROC] CC_id %d Frame %d CCCH: Received Msg3: length %d, offset %ld\n", enb_mod_idP,CC_idP,frameP,rx_lengths[i],payload_ptr-sduP); if ((UE_id=add_new_ue(enb_mod_idP,CC_idP,eNB->common_channels[CC_idP].RA_template[ii].rnti,harq_pidP)) == -1 ) { @@ -343,7 +343,7 @@ void rx_sdu(const module_id_t enb_mod_idP, LOG_I(MAC,"[eNB %d][RAPROC] CC_id %d Frame %d Added user with rnti %x => UE %d\n", enb_mod_idP,CC_idP,frameP,eNB->common_channels[CC_idP].RA_template[ii].rnti,UE_id); } else { - LOG_I(MAC,"[eNB %d][RAPROC] CC_id %d Frame %d CCCH: Received Msg3 from already registered UE %d: length %d, offset %d\n", + LOG_I(MAC,"[eNB %d][RAPROC] CC_id %d Frame %d CCCH: Received Msg3 from already registered UE %d: length %d, offset %ld\n", enb_mod_idP,CC_idP,frameP,UE_id,rx_lengths[i],payload_ptr-sduP); // kill RA procedure } @@ -433,7 +433,7 @@ void rx_sdu(const module_id_t enb_mod_idP, if (UE_id != -1) { // adjust buffer occupancy of the correponding logical channel group - LOG_D(MAC,"[eNB %d] CC_id %d Frame %d : ULSCH -> UL-DTCH, received %d bytes from UE %d for lcid %d, removing from LCGID %d, %d\n", + LOG_D(MAC,"[eNB %d] CC_id %d Frame %d : ULSCH -> UL-DTCH, received %d bytes from UE %d for lcid %d, removing from LCGID %ld, %d\n", enb_mod_idP,CC_idP,frameP, rx_lengths[i], UE_id,rx_lcids[i], UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]], UE_list->UE_template[CC_idP][UE_id].ul_buffer_info[UE_list->UE_template[CC_idP][UE_id].lcgidmap[rx_lcids[i]]]); @@ -568,7 +568,7 @@ unsigned char *parse_ulsch_header(unsigned char *mac_header, } } - LOG_D(MAC,"[eNB] sdu %d lcid %d tb_length %d length %d (offset now %d)\n", + LOG_D(MAC,"[eNB] sdu %d lcid %d tb_length %d length %d (offset now %ld)\n", num_sdus,lcid,tb_length, length,mac_header_ptr-mac_header); rx_lcids[num_sdus] = lcid; rx_lengths[num_sdus] = length; @@ -751,6 +751,39 @@ void schedule_ulsch_rnti(module_id_t module_idP, continue; } + /* let's drop the UE if get_eNB_UE_stats returns NULL when calling it with any of the UE's active UL CCs */ + /* TODO: refine? */ + drop_ue = 0; + for (n=0; nnumactiveULCCs[UE_id]; n++) { + CC_id = UE_list->ordered_ULCCids[n][UE_id]; + if (mac_xface->get_eNB_UE_stats(module_idP,CC_id,rnti) == NULL) { + LOG_W(MAC,"[eNB %d] frame %d subframe %d, UE %d/%x CC %d: no PHY context\n", module_idP,frameP,subframeP,UE_id,rnti,CC_id); + drop_ue = 1; + break; + } + } + if (drop_ue == 1) { +/* we can't come here, ulsch_scheduler_pre_processor won't put in the list a UE with no PHY context */ +abort(); + /* TODO: this is a hack. Sometimes the UE has no PHY context but + * is still present in the MAC with 'ul_failure_timer' = 0 and + * 'ul_out_of_sync' = 0. It seems wrong and the UE stays there forever. Let's + * start an UL out of sync procedure in this case. + * The root cause of this problem has to be found and corrected. + * In the meantime, this hack... + */ + if (UE_list->UE_sched_ctrl[UE_id].ul_failure_timer == 0 && + UE_list->UE_sched_ctrl[UE_id].ul_out_of_sync == 0) { + LOG_W(MAC,"[eNB %d] frame %d subframe %d, UE %d/%x CC %d: UE in weird state, let's put it 'out of sync'\n", + module_idP,frameP,subframeP,UE_id,rnti,CC_id); + // inform RRC of failure and clear timer + mac_eNB_rrc_ul_failure(module_idP,CC_id,frameP,subframeP,rnti); + UE_list->UE_sched_ctrl[UE_id].ul_failure_timer=0; + UE_list->UE_sched_ctrl[UE_id].ul_out_of_sync=1; + } + continue; + } + // loop over all active UL CC_ids for this UE for (n=0; nnumactiveULCCs[UE_id]; n++) { // This is the actual CC_id in the list @@ -758,15 +791,6 @@ void schedule_ulsch_rnti(module_id_t module_idP, frame_parms = mac_xface->get_lte_frame_parms(module_idP,CC_id); eNB_UE_stats = mac_xface->get_eNB_UE_stats(module_idP,CC_id,rnti); - if (eNB_UE_stats==NULL) { - LOG_W(MAC,"[eNB %d] frame %d subframe %d, UE %d/%x CC %d: no PHY context\n", module_idP,frameP,subframeP,UE_id,rnti,CC_id); - drop_ue=1; - continue; // mac_xface->macphy_exit("[MAC][eNB] Cannot find eNB_UE_stats\n"); - } - - if (drop_ue==1) - continue; - if (CCE_allocation_infeasible(module_idP,CC_id,0,subframeP,aggregation,rnti)) { LOG_W(MAC,"[eNB %d] frame %d subframe %d, UE %d/%x CC %d: not enough nCCE\n", module_idP,frameP,subframeP,UE_id,rnti,CC_id); continue; // break; @@ -882,6 +906,12 @@ void schedule_ulsch_rnti(module_id_t module_idP, T_INT(subframeP), T_INT(harq_pid), T_INT(mcs), T_INT(first_rb[CC_id]), T_INT(rb_table[rb_table_index]), T_INT(TBS), T_INT(ndi)); + if (mac_eNB_get_rrc_status(module_idP,rnti) < RRC_CONNECTED) + LOG_I(MAC,"[eNB %d][PUSCH %d/%x] CC_id %d Frame %d subframeP %d Scheduled UE %d (mcs %d, first rb %d, nb_rb %d, rb_table_index %d, TBS %d, harq_pid %d)\n", + module_idP,harq_pid,rnti,CC_id,frameP,subframeP,UE_id,mcs, + first_rb[CC_id],rb_table[rb_table_index], + rb_table_index,TBS,harq_pid); + // bad indices : 20 (40 PRB), 21 (45 PRB), 22 (48 PRB) // increment for next UE allocation first_rb[CC_id]+=rb_table[rb_table_index]; @@ -891,12 +921,6 @@ void schedule_ulsch_rnti(module_id_t module_idP, if (UE_id == UE_list->head) VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE0_SCHEDULED,UE_sched_ctrl->ul_scheduled); - if (mac_eNB_get_rrc_status(module_idP,rnti) < RRC_CONNECTED) - LOG_I(MAC,"[eNB %d][PUSCH %d/%x] CC_id %d Frame %d subframeP %d Scheduled UE %d (mcs %d, first rb %d, nb_rb %d, rb_table_index %d, TBS %d, harq_pid %d)\n", - module_idP,harq_pid,rnti,CC_id,frameP,subframeP,UE_id,mcs, - first_rb[CC_id],rb_table[rb_table_index], - rb_table_index,TBS,harq_pid); - // adjust total UL buffer status by TBS, wait for UL sdus to do final update LOG_D(MAC,"[eNB %d] CC_id %d UE %d/%x : adjusting ul_total_buffer, old %d, TBS %d\n", module_idP,CC_id,UE_id,rnti,UE_template->ul_total_buffer,TBS); if (UE_template->ul_total_buffer > TBS) diff --git a/openair2/LAYER2/MAC/flexran_agent_mac_proto.h b/openair2/LAYER2/MAC/flexran_agent_mac_proto.h index 060e8ab6ca3f2114b4d98ace3b2cafcee58789e2..6757500dc2cc7175e48ea11c0ccb93d310904bf7 100644 --- a/openair2/LAYER2/MAC/flexran_agent_mac_proto.h +++ b/openair2/LAYER2/MAC/flexran_agent_mac_proto.h @@ -21,7 +21,7 @@ /*! \file flexran_agent_mac_proto.h * \brief MAC functions for FlexRAN agent - * \author Xenofon Foukas + * \author Xenofon Foukas and Navid Nikaein * \date 2016 * \email: x.foukas@sms.ed.ac.uk * \version 0.1 @@ -36,6 +36,145 @@ #include "header.pb-c.h" #include "flexran.pb-c.h" +/* + * slice specific scheduler + */ +typedef void (*slice_scheduler)(module_id_t mod_id, + int slice_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info); + + + +/* + * top level flexran scheduler used by the eNB scheduler + */ +void flexran_schedule_ue_spec_default(mid_t mod_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info); +/* + * slice specific scheduler for embb + */ +void +flexran_schedule_ue_spec_embb(mid_t mod_id, + int slice_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info); +/* + * slice specific scheduler for urllc + */ +void +flexran_schedule_ue_spec_urllc(mid_t mod_id, + int slice_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info); + +/* + * slice specific scheduler for mmtc + */ +void +flexran_schedule_ue_spec_mmtc(mid_t mod_id, + int slice_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info); +/* + * slice specific scheduler for best effort traffic + */ +void +flexran_schedule_ue_spec_be(mid_t mod_id, + int slice_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info); + +/* + * common flexran scheduler function + */ +void +flexran_schedule_ue_spec_common(mid_t mod_id, + int slice_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info); + +uint16_t flexran_nb_rbs_allowed_slice(float rb_percentage, + int total_rbs); + +int flexran_slice_member(int UE_id, + int slice_id); + +int flexran_slice_maxmcs(int slice_id) ; + +void _store_dlsch_buffer (module_id_t Mod_id, + int slice_id, + frame_t frameP, + sub_frame_t subframeP); + + +void _assign_rbs_required (module_id_t Mod_id, + int slice_id, + frame_t frameP, + sub_frame_t subframe, + uint16_t nb_rbs_required[MAX_NUM_CCs][NUMBER_OF_UE_MAX], + uint16_t nb_rbs_allowed_slice[MAX_NUM_CCs][MAX_NUM_SLICES], + int min_rb_unit[MAX_NUM_CCs]); + +int _maxround(module_id_t Mod_id, + uint16_t rnti, + int frame, + sub_frame_t subframe, + uint8_t ul_flag ); + +int _maxcqi(module_id_t Mod_id, + int32_t UE_id); + +void _sort_UEs (module_id_t Mod_idP, + int frameP, + sub_frame_t subframeP); + +void _dlsch_scheduler_pre_processor (module_id_t Mod_id, + int slice_id, + frame_t frameP, + sub_frame_t subframeP, + int N_RBG[MAX_NUM_CCs], + int *mbsfn_flag); + +void _dlsch_scheduler_pre_processor_reset (int module_idP, + int UE_id, + uint8_t CC_id, + int frameP, + int subframeP, + int N_RBG, + uint16_t nb_rbs_required[MAX_NUM_CCs][NUMBER_OF_UE_MAX], + uint16_t nb_rbs_required_remaining[MAX_NUM_CCs][NUMBER_OF_UE_MAX], + uint16_t nb_rbs_allowed_slice[MAX_NUM_CCs][MAX_NUM_SLICES], + unsigned char rballoc_sub[MAX_NUM_CCs][N_RBG_MAX], + unsigned char MIMO_mode_indicator[MAX_NUM_CCs][N_RBG_MAX]); + +void _dlsch_scheduler_pre_processor_allocate (module_id_t Mod_id, + int UE_id, + uint8_t CC_id, + int N_RBG, + int transmission_mode, + int min_rb_unit, + uint8_t N_RB_DL, + uint16_t nb_rbs_required[MAX_NUM_CCs][NUMBER_OF_UE_MAX], + uint16_t nb_rbs_required_remaining[MAX_NUM_CCs][NUMBER_OF_UE_MAX], + unsigned char rballoc_sub[MAX_NUM_CCs][N_RBG_MAX], + unsigned char MIMO_mode_indicator[MAX_NUM_CCs][N_RBG_MAX]); + /* * Default scheduler used by the eNB agent */ @@ -46,17 +185,17 @@ void flexran_schedule_ue_spec_default(mid_t mod_id, uint32_t frame, uint32_t sub * Data plane function for applying the DL decisions of the scheduler */ void flexran_apply_dl_scheduling_decisions(mid_t mod_id, uint32_t frame, uint32_t subframe, int *mbsfn_flag, - const Protocol__FlexranMessage *dl_scheduling_info); + Protocol__FlexranMessage *dl_scheduling_info); /* * Data plane function for applying the UE specific DL decisions of the scheduler */ void flexran_apply_ue_spec_scheduling_decisions(mid_t mod_id, uint32_t frame, uint32_t subframe, int *mbsfn_flag, - uint32_t n_dl_ue_data, const Protocol__FlexDlData **dl_ue_data); + uint32_t n_dl_ue_data, Protocol__FlexDlData **dl_ue_data); /* * Data plane function for filling the DCI structure */ -void flexran_fill_oai_dci(mid_t mod_id, uint32_t CC_id, uint32_t rnti, const Protocol__FlexDlDci *dl_dci); +void flexran_fill_oai_dci(mid_t mod_id, uint32_t CC_id, uint32_t rnti, Protocol__FlexDlDci *dl_dci); #endif diff --git a/openair2/LAYER2/MAC/flexran_agent_scheduler_dataplane.c b/openair2/LAYER2/MAC/flexran_agent_scheduler_dataplane.c index ff3ef32bd6db47dca8b8e8d90ad0d3a8b1a199f3..c9956bd9ce937c055c4b75913e3e72226a87ace6 100644 --- a/openair2/LAYER2/MAC/flexran_agent_scheduler_dataplane.c +++ b/openair2/LAYER2/MAC/flexran_agent_scheduler_dataplane.c @@ -56,12 +56,11 @@ #include "SIMULATION/TOOLS/defs.h" // for taus - void flexran_apply_dl_scheduling_decisions(mid_t mod_id, uint32_t frame, uint32_t subframe, int *mbsfn_flag, - const Protocol__FlexranMessage *dl_scheduling_info) { + Protocol__FlexranMessage *dl_scheduling_info) { Protocol__FlexDlMacConfig *mac_config = dl_scheduling_info->dl_mac_config_msg; @@ -89,33 +88,26 @@ void flexran_apply_ue_spec_scheduling_decisions(mid_t mod_id, uint32_t subframe, int *mbsfn_flag, uint32_t n_dl_ue_data, - const Protocol__FlexDlData **dl_ue_data) { + Protocol__FlexDlData **dl_ue_data) { uint8_t CC_id; int UE_id; - int N_RBG[MAX_NUM_CCs]; - unsigned char aggregation; mac_rlc_status_resp_t rlc_status; unsigned char ta_len=0; unsigned char header_len = 0, header_len_tmp = 0; unsigned char sdu_lcids[11],offset,num_sdus=0; - uint16_t nb_rb,nb_rb_temp,total_nb_available_rb[MAX_NUM_CCs],nb_available_rb; + uint16_t nb_rb; uint16_t TBS,j,sdu_lengths[11],rnti,padding=0,post_padding=0; unsigned char dlsch_buffer[MAX_DLSCH_PAYLOAD_BYTES]; unsigned char round = 0; unsigned char harq_pid = 0; - + // LTE_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]; LTE_eNB_UE_stats *eNB_UE_stats = NULL; uint16_t sdu_length_total = 0; - int mcs; - uint16_t min_rb_unit[MAX_NUM_CCs]; short ta_update = 0; eNB_MAC_INST *eNB = &eNB_mac_inst[mod_id]; UE_list_t *UE_list = &eNB->UE_list; - LTE_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]; - int32_t normalized_rx_power, target_rx_power; - int32_t tpc=1; - static int32_t tpc_accumulated=0; + // static int32_t tpc_accumulated=0; UE_sched_ctrl *ue_sched_ctl; int last_sdu_header_len = 0; @@ -135,7 +127,7 @@ void flexran_apply_ue_spec_scheduling_decisions(mid_t mod_id, dl_dci = dl_data->dl_dci; CC_id = dl_data->serv_cell_index; - frame_parms[CC_id] = mac_xface->get_lte_frame_parms(mod_id, CC_id); + // frame_parms[CC_id] = mac_xface->get_lte_frame_parms(mod_id, CC_id); rnti = dl_data->rnti; UE_id = find_ue(rnti, PHY_vars_eNB_g[mod_id][CC_id]); @@ -357,20 +349,19 @@ void flexran_apply_ue_spec_scheduling_decisions(mid_t mod_id, eNB_UE_stats->dlsch_mcs1 = dl_dci->mcs[0]; //Fill the proper DCI of OAI - fill_oai_dci(mod_id, CC_id, rnti, dl_dci); + flexran_fill_oai_dci(mod_id, CC_id, rnti, dl_dci); } } - -void fill_oai_dci(mid_t mod_id, uint32_t CC_id, uint32_t rnti, - const Protocol__FlexDlDci *dl_dci) { +void flexran_fill_oai_dci(mid_t mod_id, uint32_t CC_id, uint32_t rnti, + Protocol__FlexDlDci *dl_dci) { void *DLSCH_dci = NULL; DCI_PDU *DCI_pdu; - unsigned char round = 0; unsigned char harq_pid = 0; + // unsigned char round = 0; LTE_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]; - int size_bits, size_bytes; + int size_bits = 0, size_bytes = 0; eNB_MAC_INST *eNB = &eNB_mac_inst[mod_id]; UE_list_t *UE_list = &eNB->UE_list; LTE_eNB_UE_stats *eNB_UE_stats = NULL; @@ -380,7 +371,7 @@ void fill_oai_dci(mid_t mod_id, uint32_t CC_id, uint32_t rnti, uint32_t format; harq_pid = dl_dci->harq_process; - round = dl_dci->rv[0]; + // round = dl_dci->rv[0]; // Note this code is for a specific DCI format DLSCH_dci = (void *)UE_list->UE_template[CC_id][UE_id].DLSCH_DCI[harq_pid]; diff --git a/openair2/LAYER2/MAC/flexran_agent_scheduler_dlsch_ue.c b/openair2/LAYER2/MAC/flexran_agent_scheduler_dlsch_ue.c index 8975465e77b11ade441f6da867c9621c4048cbe8..3af246a5d5be3e547ce533b5655ee7266d648c53 100644 --- a/openair2/LAYER2/MAC/flexran_agent_scheduler_dlsch_ue.c +++ b/openair2/LAYER2/MAC/flexran_agent_scheduler_dlsch_ue.c @@ -56,6 +56,7 @@ #include "header.pb-c.h" #include "flexran.pb-c.h" #include "flexran_agent_mac.h" +#include #include "SIMULATION/TOOLS/defs.h" // for taus @@ -65,915 +66,292 @@ #define ENABLE_MAC_PAYLOAD_DEBUG +/** + * Local variables to support slicing + * + */ -//------------------------------------------------------------------------------ -void -flexran_schedule_ue_spec_default(mid_t mod_id, - uint32_t frame, - uint32_t subframe, - int *mbsfn_flag, - Protocol__FlexranMessage **dl_info) -//------------------------------------------------------------------------------ -{ - uint8_t CC_id; - int UE_id; - int N_RBG[MAX_NUM_CCs]; - unsigned char aggregation; - mac_rlc_status_resp_t rlc_status; - unsigned char header_len = 0, header_len_tmp = 0, ta_len = 0; - uint16_t nb_rb, nb_rb_temp, total_nb_available_rb[MAX_NUM_CCs], nb_available_rb; - uint16_t TBS, j, rnti, padding=0, post_padding=0; - unsigned char round = 0; - unsigned char harq_pid = 0; - void *DLSCH_dci = NULL; - uint16_t sdu_length_total = 0; - int mcs, mcs_tmp; - uint16_t min_rb_unit[MAX_NUM_CCs]; - eNB_MAC_INST *eNB = &eNB_mac_inst[mod_id]; - /* TODO: Must move the helper structs to scheduler implementation */ - UE_list_t *UE_list = &eNB->UE_list; - int32_t normalized_rx_power, target_rx_power; - int32_t tpc = 1; - static int32_t tpc_accumulated=0; - UE_sched_ctrl *ue_sched_ctl; - Protocol__FlexDlData *dl_data[NUM_MAX_UE]; - int num_ues_added = 0; - int channels_added = 0; +/*!\brief UE ULSCH scheduling states*/ +typedef enum { + MIN_SLICE_STRATEGY = 0, + SLICE_MASK, + UEID_TO_SLICEID, + MAX_SLICE_STRATEGY +} SLICING_STRATEGY; - Protocol__FlexDlDci *dl_dci; - Protocol__FlexRlcPdu *rlc_pdus[11]; - uint32_t *ce_bitmap; - Protocol__FlexRlcPdu **rlc_pdu; - int num_tb; - uint32_t ce_flags = 0; +// this assumes a max of of 16 UE per eNB/CC +#define SLICE0_MASK 0x000f +#define SLICE1_MASK 0x00f0 +#define SLICE2_MASK 0x0f00 +#define SLICE3_MASK 0xf000 - uint8_t rballoc_sub[25]; - int i; - uint32_t data_to_request; - uint32_t dci_tbs; - uint8_t ue_has_transmission = 0; - uint32_t ndi; - - flexran_agent_mac_create_empty_dl_config(mod_id, dl_info); - - if (UE_list->head==-1) { - return; - } - - start_meas(&eNB->schedule_dlsch); - VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_SCHEDULE_DLSCH,VCD_FUNCTION_IN); - //weight = get_ue_weight(module_idP,UE_id); - aggregation = 2; // set to the maximum aggregation level +// number of active slices for past and current time +int n_active_slices = 1; +int n_active_slices_current = 1; - for (CC_id=0; CC_idcommon_channels[CC_id].vrb_map[i] != 0) - total_nb_available_rb[CC_id]--; - - N_RBG[CC_id] = flexran_get_N_RBG(mod_id, CC_id); +// ue to slice mapping +int slicing_strategy = UEID_TO_SLICEID; +int slicing_strategy_current = UEID_TO_SLICEID; - // store the global enb stats: - eNB->eNB_stats[CC_id].num_dlactive_UEs = UE_list->num_UEs; - eNB->eNB_stats[CC_id].available_prbs = total_nb_available_rb[CC_id]; - eNB->eNB_stats[CC_id].total_available_prbs += total_nb_available_rb[CC_id]; - eNB->eNB_stats[CC_id].dlsch_bytes_tx=0; - eNB->eNB_stats[CC_id].dlsch_pdus_tx=0; - } +// RB share for each slice for past and current time +float slice_percentage[MAX_NUM_SLICES] = {1.0, 0.0, 0.0, 0.0}; +float slice_percentage_current[MAX_NUM_SLICES] = {1.0, 0.0, 0.0, 0.0}; +float total_slice_percentage = 0; - VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_PREPROCESSOR,VCD_FUNCTION_IN); +// MAX MCS for each slice for past and current time +int slice_maxmcs[MAX_NUM_SLICES] = {28, 28, 28, 28}; +int slice_maxmcs_current[MAX_NUM_SLICES] = {28, 28, 28, 28}; - start_meas(&eNB->schedule_dlsch_preprocessor); - _dlsch_scheduler_pre_processor(mod_id, - frame, - subframe, - N_RBG, - mbsfn_flag); - stop_meas(&eNB->schedule_dlsch_preprocessor); - VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_PREPROCESSOR,VCD_FUNCTION_OUT); +int update_dl_scheduler[MAX_NUM_SLICES] = {1, 0, 0, 0}; +int update_dl_scheduler_current[MAX_NUM_SLICES] = {1, 0, 0, 0}; - for (CC_id=0; CC_id0) - continue; +// pointer to the slice specific scheduler +slice_scheduler slice_sched[MAX_NUM_SLICES] = {0}; - for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id]) { - rnti = flexran_get_ue_crnti(mod_id, UE_id); - ue_sched_ctl = &UE_list->UE_sched_ctrl[UE_id]; - if (rnti==NOT_A_RNTI) { - LOG_D(MAC,"Cannot find rnti for UE_id %d (num_UEs %d)\n", UE_id,UE_list->num_UEs); - // mac_xface->macphy_exit("Cannot find rnti for UE_id"); - continue; - } +/** + * preprocessor functions for scheduling + * + */ - if (flexran_get_ue_crnti(mod_id, UE_id) == NOT_A_RNTI) { - LOG_D(MAC,"[eNB] Cannot find UE\n"); - // mac_xface->macphy_exit("[MAC][eNB] Cannot find eNB_UE_stats\n"); - continue; - } - if ((ue_sched_ctl->pre_nb_available_rbs[CC_id] == 0) || // no RBs allocated - CCE_allocation_infeasible(mod_id, CC_id, 0, subframe, aggregation, rnti)) { - LOG_D(MAC,"[eNB %d] Frame %d : no RB allocated for UE %d on CC_id %d: continue \n", - mod_id, frame, UE_id, CC_id); - //if(mac_xface->get_transmission_mode(module_idP,rnti)==5) - continue; //to next user (there might be rbs availiable for other UEs in TM5 - // else - // break; - } +// This function stores the downlink buffer for all the logical channels +void _store_dlsch_buffer (module_id_t Mod_id, + int slice_id, + frame_t frameP, + sub_frame_t subframeP) +{ - if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { - set_ue_dai (subframe, - flexran_get_subframe_assignment(mod_id, CC_id), - UE_id, - CC_id, - UE_list); - //TODO: update UL DAI after DLSCH scheduling - //set_ul_DAI(mod_id, UE_id, CC_id, frame, subframe,frame_parms); - } + int UE_id,i; + rnti_t rnti; + mac_rlc_status_resp_t rlc_status; + UE_list_t *UE_list = &eNB_mac_inst[Mod_id].UE_list; + UE_TEMPLATE *UE_template; - channels_added = 0; + for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id]) { + + if (flexran_slice_member(UE_id, slice_id) == 0) + continue; + + UE_template = &UE_list->UE_template[UE_PCCID(Mod_id,UE_id)][UE_id]; - // After this point all the UEs will be scheduled - dl_data[num_ues_added] = (Protocol__FlexDlData *) malloc(sizeof(Protocol__FlexDlData)); - protocol__flex_dl_data__init(dl_data[num_ues_added]); - dl_data[num_ues_added]->has_rnti = 1; - dl_data[num_ues_added]->rnti = rnti; - dl_data[num_ues_added]->n_rlc_pdu = 0; - dl_data[num_ues_added]->has_serv_cell_index = 1; - dl_data[num_ues_added]->serv_cell_index = CC_id; - - nb_available_rb = ue_sched_ctl->pre_nb_available_rbs[CC_id]; - flexran_get_harq(mod_id, CC_id, UE_id, frame, subframe, &harq_pid, &round); - sdu_length_total=0; - mcs = cqi_to_mcs[flexran_get_ue_wcqi(mod_id, UE_id)]; + // clear logical channel interface variables + UE_template->dl_buffer_total = 0; + UE_template->dl_pdus_total = 0; -#ifdef EXMIMO + for(i=0; i< MAX_NUM_LCID; i++) { + UE_template->dl_buffer_info[i]=0; + UE_template->dl_pdus_in_buffer[i]=0; + UE_template->dl_buffer_head_sdu_creation_time[i]=0; + UE_template->dl_buffer_head_sdu_remaining_size_to_send[i]=0; + } - if (mac_xface->get_transmission_mode(mod_id, CC_id, rnti) == 5) { - mcs = cqi_to_mcs[flexran_get_ue_wcqi(mod_id, UE_id)]; - mcs = cmin(mcs,16); - } + rnti = UE_RNTI(Mod_id,UE_id); -#endif + for(i=0; i< MAX_NUM_LCID; i++) { // loop over all the logical channels - // initializing the rb allocation indicator for each UE - for(j = 0; j < flexran_get_N_RBG(mod_id, CC_id); j++) { - UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j] = 0; - rballoc_sub[j] = 0; - } + rlc_status = mac_rlc_status_ind(Mod_id,rnti, Mod_id,frameP,ENB_FLAG_YES,MBMS_FLAG_NO,i,0 ); + UE_template->dl_buffer_info[i] = rlc_status.bytes_in_buffer; //storing the dlsch buffer for each logical channel + UE_template->dl_pdus_in_buffer[i] = rlc_status.pdus_in_buffer; + UE_template->dl_buffer_head_sdu_creation_time[i] = rlc_status.head_sdu_creation_time ; + UE_template->dl_buffer_head_sdu_creation_time_max = cmax(UE_template->dl_buffer_head_sdu_creation_time_max, + rlc_status.head_sdu_creation_time ); + UE_template->dl_buffer_head_sdu_remaining_size_to_send[i] = rlc_status.head_sdu_remaining_size_to_send; + UE_template->dl_buffer_head_sdu_is_segmented[i] = rlc_status.head_sdu_is_segmented; + UE_template->dl_buffer_total += UE_template->dl_buffer_info[i];//storing the total dlsch buffer + UE_template->dl_pdus_total += UE_template->dl_pdus_in_buffer[i]; - /* LOG_D(MAC,"[eNB %d] Frame %d: Scheduling UE %d on CC_id %d (rnti %x, harq_pid %d, round %d, rb %d, cqi %d, mcs %d, rrc %d)\n", */ - /* mod_id, frame, UE_id, CC_id, rnti, harq_pid, round, nb_available_rb, */ - /* eNB_UE_stats->DL_cqi[0], mcs, */ - /* UE_list->eNB_UE_stats[CC_id][UE_id].rrc_status); */ +#ifdef DEBUG_eNB_SCHEDULER - dl_dci = (Protocol__FlexDlDci*) malloc(sizeof(Protocol__FlexDlDci)); - protocol__flex_dl_dci__init(dl_dci); - dl_data[num_ues_added]->dl_dci = dl_dci; + /* note for dl_buffer_head_sdu_remaining_size_to_send[i] : + * 0 if head SDU has not been segmented (yet), else remaining size not already segmented and sent + */ + if (UE_template->dl_buffer_info[i]>0) + LOG_D(MAC, + "[eNB %d][SLICE %d] Frame %d Subframe %d : RLC status for UE %d in LCID%d: total of %d pdus and size %d, head sdu queuing time %d, remaining size %d, is segmeneted %d \n", + Mod_id, slice_id,frameP, subframeP, UE_id, + i, UE_template->dl_pdus_in_buffer[i],UE_template->dl_buffer_info[i], + UE_template->dl_buffer_head_sdu_creation_time[i], + UE_template->dl_buffer_head_sdu_remaining_size_to_send[i], + UE_template->dl_buffer_head_sdu_is_segmented[i] + ); - - dl_dci->has_rnti = 1; - dl_dci->rnti = rnti; - dl_dci->has_harq_process = 1; - dl_dci->harq_process = harq_pid; - - /* process retransmission */ +#endif - if (round > 0) { + } - if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { - UE_list->UE_template[CC_id][UE_id].DAI++; - update_ul_dci(mod_id, CC_id, rnti, UE_list->UE_template[CC_id][UE_id].DAI); - LOG_D(MAC,"DAI update: CC_id %d subframeP %d: UE %d, DAI %d\n", - CC_id, subframe,UE_id,UE_list->UE_template[CC_id][UE_id].DAI); - } + //#ifdef DEBUG_eNB_SCHEDULER + if ( UE_template->dl_buffer_total>0) + LOG_D(MAC,"[eNB %d] Frame %d Subframe %d : RLC status for UE %d : total DL buffer size %d and total number of pdu %d \n", + Mod_id, frameP, subframeP, UE_id, + UE_template->dl_buffer_total, + UE_template->dl_pdus_total + ); - mcs = UE_list->UE_template[CC_id][UE_id].mcs[harq_pid]; + //#endif + } +} - // get freq_allocation - nb_rb = UE_list->UE_template[CC_id][UE_id].nb_rb[harq_pid]; - - /*TODO: Must add this to FlexRAN agent API */ - dci_tbs = mac_xface->get_TBS_DL(mcs, nb_rb); - if (nb_rb <= nb_available_rb) { - - if(nb_rb == ue_sched_ctl->pre_nb_available_rbs[CC_id]) { - for(j = 0; j < flexran_get_N_RBG(mod_id, CC_id); j++) { // for indicating the rballoc for each sub-band - UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j] = ue_sched_ctl->rballoc_sub_UE[CC_id][j]; - } - } else { - nb_rb_temp = nb_rb; - j = 0; +// This function returns the estimated number of RBs required by each UE for downlink scheduling +void _assign_rbs_required (module_id_t Mod_id, + int slice_id, + frame_t frameP, + sub_frame_t subframe, + uint16_t nb_rbs_required[MAX_NUM_CCs][NUMBER_OF_UE_MAX], + uint16_t nb_rbs_allowed_slice[MAX_NUM_CCs][MAX_NUM_SLICES], + int min_rb_unit[MAX_NUM_CCs]) +{ - while((nb_rb_temp > 0) && (j < flexran_get_N_RBG(mod_id, CC_id))) { - if(ue_sched_ctl->rballoc_sub_UE[CC_id][j] == 1) { - UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j] = ue_sched_ctl->rballoc_sub_UE[CC_id][j]; - - if((j == flexran_get_N_RBG(mod_id, CC_id) - 1) && - ((flexran_get_N_RB_DL(mod_id, CC_id) == 25)|| - (flexran_get_N_RB_DL(mod_id, CC_id) == 50))) { - nb_rb_temp = nb_rb_temp - min_rb_unit[CC_id]+1; - } else { - nb_rb_temp = nb_rb_temp - min_rb_unit[CC_id]; - } - } - j = j + 1; - } - } - nb_available_rb -= nb_rb; - aggregation = process_ue_cqi(mod_id, UE_id); - - PHY_vars_eNB_g[mod_id][CC_id]->mu_mimo_mode[UE_id].pre_nb_available_rbs = nb_rb; - PHY_vars_eNB_g[mod_id][CC_id]->mu_mimo_mode[UE_id].dl_pow_off = ue_sched_ctl->dl_pow_off[CC_id]; - - for(j=0; j < flexran_get_N_RBG(mod_id, CC_id); j++) { - PHY_vars_eNB_g[mod_id][CC_id]->mu_mimo_mode[UE_id].rballoc_sub[j] = UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j]; - rballoc_sub[j] = UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j]; - } + rnti_t rnti; + uint16_t TBS = 0; + LTE_eNB_UE_stats *eNB_UE_stats[MAX_NUM_CCs]; + int UE_id,n,i,j,CC_id,pCCid,tmp; + UE_list_t *UE_list = &eNB_mac_inst[Mod_id].UE_list; + // UE_TEMPLATE *UE_template; - // Keep the old NDI, do not toggle - ndi = UE_list->UE_template[CC_id][UE_id].oldNDI[harq_pid]; - tpc = UE_list->UE_template[CC_id][UE_id].oldTPC[harq_pid]; - UE_list->UE_template[CC_id][UE_id].mcs[harq_pid] = mcs; + // clear rb allocations across all CC_ids + for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id]) { + + if (flexran_slice_member(UE_id, slice_id) == 0) + continue; + + pCCid = UE_PCCID(Mod_id,UE_id); + rnti = UE_list->UE_template[pCCid][UE_id].rnti; - ue_has_transmission = 1; - num_ues_added++; - } else { - LOG_D(MAC,"[eNB %d] Frame %d CC_id %d : don't schedule UE %d, its retransmission takes more resources than we have\n", - mod_id, frame, CC_id, UE_id); - ue_has_transmission = 0; - } - //End of retransmission - } else { /* This is a potentially new SDU opportunity */ - rlc_status.bytes_in_buffer = 0; - // Now check RLC information to compute number of required RBs - // get maximum TBS size for RLC request - //TBS = mac_xface->get_TBS(eNB_UE_stats->DL_cqi[0]<<1,nb_available_rb); - TBS = mac_xface->get_TBS_DL(mcs, nb_available_rb); - dci_tbs = TBS; + //update CQI information across component carriers + for (n=0; nnumactiveCCs[UE_id]; n++) { + CC_id = UE_list->ordered_CCids[n][UE_id]; + eNB_UE_stats[CC_id] = mac_xface->get_eNB_UE_stats(Mod_id,CC_id,rnti); + eNB_UE_stats[CC_id]->dlsch_mcs1=cqi_to_mcs[flexran_get_ue_wcqi(Mod_id, UE_id)]; + } - // check first for RLC data on DCCH - // add the length for all the control elements (timing adv, drx, etc) : header + payload + // provide the list of CCs sorted according to MCS + for (i=0; inumactiveCCs[UE_id]; i++) { + for (j=i+1; jnumactiveCCs[UE_id]; j++) { + DevAssert( j < MAX_NUM_CCs ); - ta_len = (ue_sched_ctl->ta_update!=0) ? 2 : 0; - - dl_data[num_ues_added]->n_ce_bitmap = 2; - dl_data[num_ues_added]->ce_bitmap = (uint32_t *) malloc(sizeof(uint32_t) * 2); - - if (ta_len > 0) { - ce_flags |= PROTOCOL__FLEX_CE_TYPE__FLPCET_TA; - } + if (eNB_UE_stats[UE_list->ordered_CCids[i][UE_id]]->dlsch_mcs1 > + eNB_UE_stats[UE_list->ordered_CCids[j][UE_id]]->dlsch_mcs1) { + tmp = UE_list->ordered_CCids[i][UE_id]; + UE_list->ordered_CCids[i][UE_id] = UE_list->ordered_CCids[j][UE_id]; + UE_list->ordered_CCids[j][UE_id] = tmp; + } + } + } - /*TODO: Add other flags if DRX and other CE are required*/ - - // Add the control element flags to the flexran message - dl_data[num_ues_added]->ce_bitmap[0] = ce_flags; - dl_data[num_ues_added]->ce_bitmap[1] = ce_flags; + /* NN --> RK + * check the index of UE_template" + */ + if (UE_list->UE_template[pCCid][UE_id].dl_buffer_total> 0) { + LOG_D(MAC,"[preprocessor] assign RB for UE %d\n",UE_id); - // TODO : Need to prioritize DRBs - // Loop through the UE logical channels (DCCH, DCCH1, DTCH for now) - for (j = 1; j < NB_RB_MAX; j++) { - header_len+=3; + for (i=0; inumactiveCCs[UE_id]; i++) { + CC_id = UE_list->ordered_CCids[i][UE_id]; + eNB_UE_stats[CC_id] = mac_xface->get_eNB_UE_stats(Mod_id,CC_id,rnti); - // Need to see if we have space for data from this channel - if (dci_tbs - ta_len - header_len - sdu_length_total > 0) { - LOG_D(MAC, "[TEST]Requested %d bytes from RLC buffer on channel %d during first call\n", dci_tbs-ta_len-header_len); - //If we have space, we need to see how much data we can request at most (if any available) - rlc_status = mac_rlc_status_ind(mod_id, - rnti, - mod_id, - frame, - ENB_FLAG_YES, - MBMS_FLAG_NO, - j, - (dci_tbs-ta_len-header_len)); // transport block set size + if (eNB_UE_stats[CC_id]->dlsch_mcs1==0) { + nb_rbs_required[CC_id][UE_id] = 4; // don't let the TBS get too small + } else { + nb_rbs_required[CC_id][UE_id] = min_rb_unit[CC_id]; + } - //If data are available in channel j - if (rlc_status.bytes_in_buffer > 0) { - LOG_D(MAC, "[TEST]Have %d bytes in DCCH buffer during first call\n", rlc_status.bytes_in_buffer); - //Fill in as much as possible - data_to_request = cmin(dci_tbs-ta_len-header_len, rlc_status.bytes_in_buffer); - if (data_to_request < 128) { //The header will be one byte less - header_len--; - } - /* if (j == 1 || j == 2) { */ - /* data_to_request+=0; - /* } */ - LOG_D(MAC, "[TEST]Will request %d from channel %d\n", data_to_request, j); - rlc_pdus[channels_added] = (Protocol__FlexRlcPdu *) malloc(sizeof(Protocol__FlexRlcPdu)); - protocol__flex_rlc_pdu__init(rlc_pdus[channels_added]); - rlc_pdus[channels_added]->n_rlc_pdu_tb = 2; - rlc_pdus[channels_added]->rlc_pdu_tb = (Protocol__FlexRlcPduTb **) malloc(sizeof(Protocol__FlexRlcPduTb *) * 2); - rlc_pdus[channels_added]->rlc_pdu_tb[0] = (Protocol__FlexRlcPduTb *) malloc(sizeof(Protocol__FlexRlcPduTb)); - protocol__flex_rlc_pdu_tb__init(rlc_pdus[channels_added]->rlc_pdu_tb[0]); - rlc_pdus[channels_added]->rlc_pdu_tb[0]->has_logical_channel_id = 1; - rlc_pdus[channels_added]->rlc_pdu_tb[0]->logical_channel_id = j; - rlc_pdus[channels_added]->rlc_pdu_tb[0]->has_size = 1; - rlc_pdus[channels_added]->rlc_pdu_tb[0]->size = data_to_request; - rlc_pdus[channels_added]->rlc_pdu_tb[1] = (Protocol__FlexRlcPduTb *) malloc(sizeof(Protocol__FlexRlcPduTb)); - protocol__flex_rlc_pdu_tb__init(rlc_pdus[channels_added]->rlc_pdu_tb[1]); - rlc_pdus[channels_added]->rlc_pdu_tb[1]->has_logical_channel_id = 1; - rlc_pdus[channels_added]->rlc_pdu_tb[1]->logical_channel_id = j; - rlc_pdus[channels_added]->rlc_pdu_tb[1]->has_size = 1; - rlc_pdus[channels_added]->rlc_pdu_tb[1]->size = data_to_request; - dl_data[num_ues_added]->n_rlc_pdu++; - channels_added++; - //Set this to the max value that we might request - sdu_length_total += data_to_request; - } else { - //Take back the assumption of a header for this channel - header_len -= 3; - } //End rlc_status.bytes_in_buffer <= 0 - } //end of if dci_tbs - ta_len - header_len > 0 - } // End of iterating the logical channels - - // Add rlc_pdus to the dl_data message - dl_data[num_ues_added]->rlc_pdu = (Protocol__FlexRlcPdu **) malloc(sizeof(Protocol__FlexRlcPdu *) * - dl_data[num_ues_added]->n_rlc_pdu); - for (i = 0; i < dl_data[num_ues_added]->n_rlc_pdu; i++) { - dl_data[num_ues_added]->rlc_pdu[i] = rlc_pdus[i]; - } - - // there is a payload - if (( dl_data[num_ues_added]->n_rlc_pdu > 0)) { - // Now compute number of required RBs for total sdu length - // Assume RAH format 2 - // adjust header lengths - header_len_tmp = header_len; + TBS = mac_xface->get_TBS_DL(eNB_UE_stats[CC_id]->dlsch_mcs1,nb_rbs_required[CC_id][UE_id]); + nb_rbs_allowed_slice[CC_id][slice_id] = flexran_nb_rbs_allowed_slice(slice_percentage[slice_id], + flexran_get_N_RB_DL(Mod_id, CC_id)); + LOG_D(MAC,"[preprocessor] start RB assignement for UE %d CC_id %d dl buffer %d (RB unit %d, MCS %d, TBS %d) \n", + UE_id, CC_id, UE_list->UE_template[pCCid][UE_id].dl_buffer_total, + nb_rbs_required[CC_id][UE_id],eNB_UE_stats[CC_id]->dlsch_mcs1,TBS); - if (header_len == 2 || header_len == 3) { //Only one SDU, remove length field - header_len = 1; - } else { //Remove length field from the last SDU - header_len--; - } + /* calculating required number of RBs for each UE */ + while (TBS < UE_list->UE_template[pCCid][UE_id].dl_buffer_total) { + nb_rbs_required[CC_id][UE_id] += min_rb_unit[CC_id]; - mcs_tmp = mcs; - if (mcs_tmp == 0) { - nb_rb = 4; // don't let the TBS get too small - } else { - nb_rb=min_rb_unit[CC_id]; + if (nb_rbs_required[CC_id][UE_id] > nb_rbs_allowed_slice[CC_id][slice_id]) { + TBS = mac_xface->get_TBS_DL(eNB_UE_stats[CC_id]->dlsch_mcs1, nb_rbs_allowed_slice[CC_id][slice_id]); + nb_rbs_required[CC_id][UE_id] = nb_rbs_allowed_slice[CC_id][slice_id]; + break; } - LOG_D(MAC,"[TEST]The initial number of resource blocks was %d\n", nb_rb); - LOG_D(MAC,"[TEST] The initial mcs was %d\n", mcs_tmp); + TBS = mac_xface->get_TBS_DL(eNB_UE_stats[CC_id]->dlsch_mcs1,nb_rbs_required[CC_id][UE_id]); + } // end of while - TBS = mac_xface->get_TBS_DL(mcs_tmp, nb_rb); - LOG_D(MAC,"[TEST]The TBS during rate matching was %d\n", TBS); + LOG_D(MAC,"[eNB %d][SLICE %d] Frame %d: UE %d on CC %d: RB unit %d, nb_required RB %d (TBS %d, mcs %d)\n", + Mod_id, slice_id,frameP,UE_id, CC_id, min_rb_unit[CC_id], nb_rbs_required[CC_id][UE_id], TBS, eNB_UE_stats[CC_id]->dlsch_mcs1); + } + } + } +} - while (TBS < (sdu_length_total + header_len + ta_len)) { - nb_rb += min_rb_unit[CC_id]; // - LOG_D(MAC, "[TEST]Had to increase the number of RBs\n"); - if (nb_rb > nb_available_rb) { // if we've gone beyond the maximum number of RBs - // (can happen if N_RB_DL is odd) - TBS = mac_xface->get_TBS_DL(mcs_tmp, nb_available_rb); - nb_rb = nb_available_rb; - break; - } +// This function scans all CC_ids for a particular UE to find the maximum round index of its HARQ processes +int _maxround(module_id_t Mod_id,uint16_t rnti,int frame,sub_frame_t subframe,uint8_t ul_flag ) +{ - TBS = mac_xface->get_TBS_DL(mcs_tmp, nb_rb); - } + uint8_t round,round_max=0,UE_id; + int CC_id; + UE_list_t *UE_list = &eNB_mac_inst[Mod_id].UE_list; - if(nb_rb == ue_sched_ctl->pre_nb_available_rbs[CC_id]) { - LOG_D(MAC, "[TEST]We had the exact number of rbs. Time to fill the rballoc subband\n"); - for(j = 0; j < flexran_get_N_RBG(mod_id, CC_id); j++) { // for indicating the rballoc for each sub-band - UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j] = ue_sched_ctl->rballoc_sub_UE[CC_id][j]; - } - } else { - nb_rb_temp = nb_rb; - j = 0; - LOG_D(MAC, "[TEST]Will only partially fill the bitmap\n"); - while((nb_rb_temp > 0) && (j < flexran_get_N_RBG(mod_id, CC_id))) { - if(ue_sched_ctl->rballoc_sub_UE[CC_id][j] == 1) { - UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j] = ue_sched_ctl->rballoc_sub_UE[CC_id][j]; - if ((j == flexran_get_N_RBG(mod_id, CC_id) - 1) && - ((flexran_get_N_RB_DL(mod_id, CC_id) == 25)|| - (flexran_get_N_RB_DL(mod_id, CC_id) == 50))) { - nb_rb_temp = nb_rb_temp - min_rb_unit[CC_id] + 1; - } else { - nb_rb_temp = nb_rb_temp - min_rb_unit[CC_id]; - } - } - j = j+1; - } - } - - PHY_vars_eNB_g[mod_id][CC_id]->mu_mimo_mode[UE_id].pre_nb_available_rbs = nb_rb; - PHY_vars_eNB_g[mod_id][CC_id]->mu_mimo_mode[UE_id].dl_pow_off = ue_sched_ctl->dl_pow_off[CC_id]; + for (CC_id=0; CC_idmu_mimo_mode[UE_id].rballoc_sub[j] = UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j]; - } + UE_id = find_UE_id(Mod_id,rnti); + round = UE_list->UE_sched_ctrl[UE_id].round[CC_id]; + if (round > round_max) { + round_max = round; + } + } - // decrease mcs until TBS falls below required length - while ((TBS > (sdu_length_total + header_len + ta_len)) && (mcs_tmp > 0)) { - mcs_tmp--; - TBS = mac_xface->get_TBS_DL(mcs_tmp, nb_rb); - } + return round_max; +} - // if we have decreased too much or we don't have enough RBs, increase MCS - while ((TBS < (sdu_length_total + header_len + ta_len)) && - ((( ue_sched_ctl->dl_pow_off[CC_id] > 0) && (mcs_tmp < 28)) || ( (ue_sched_ctl->dl_pow_off[CC_id]==0) && (mcs_tmp <= 15)))) { - mcs_tmp++; - TBS = mac_xface->get_TBS_DL(mcs_tmp, nb_rb); - } +// This function scans all CC_ids for a particular UE to find the maximum DL CQI +int _maxcqi(module_id_t Mod_id,int32_t UE_id) +{ - dci_tbs = TBS; - mcs = mcs_tmp; + LTE_eNB_UE_stats *eNB_UE_stats = NULL; + UE_list_t *UE_list = &eNB_mac_inst[Mod_id].UE_list; + int CC_id,n; + int CQI = 0; - aggregation = process_ue_cqi(mod_id,UE_id); - dl_dci->has_aggr_level = 1; - dl_dci->aggr_level = aggregation; - - UE_list->UE_template[CC_id][UE_id].nb_rb[harq_pid] = nb_rb; + for (n=0; nnumactiveCCs[UE_id]; n++) { + CC_id = UE_list->ordered_CCids[n][UE_id]; + eNB_UE_stats = mac_xface->get_eNB_UE_stats(Mod_id,CC_id,UE_RNTI(Mod_id,UE_id)); - if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { - UE_list->UE_template[CC_id][UE_id].DAI++; - // printf("DAI update: subframeP %d: UE %d, DAI %d\n",subframeP,UE_id,UE_list->UE_template[CC_id][UE_id].DAI); - //#warning only for 5MHz channel - update_ul_dci(mod_id, CC_id, rnti, UE_list->UE_template[CC_id][UE_id].DAI); - } + if (eNB_UE_stats==NULL) { + mac_xface->macphy_exit("maxcqi: could not get eNB_UE_stats\n"); + return 0; // not reached + } - // do PUCCH power control - // this is the normalized RX power - normalized_rx_power = flexran_get_p0_pucch_dbm(mod_id,UE_id, CC_id); //eNB_UE_stats->Po_PUCCH_dBm; - target_rx_power = flexran_get_p0_nominal_pucch(mod_id, CC_id) + 10; //mac_xface->get_target_pucch_rx_power(mod_id, CC_id) + 10; + if (eNB_UE_stats->DL_cqi[0] > CQI) { + CQI = eNB_UE_stats->DL_cqi[0]; + } + } - // this assumes accumulated tpc - // make sure that we are only sending a tpc update once a frame, otherwise the control loop will freak out - int32_t framex10psubframe = UE_list->UE_template[CC_id][UE_id].pucch_tpc_tx_frame*10+UE_list->UE_template[CC_id][UE_id].pucch_tpc_tx_subframe; + return(CQI); +} - if (((framex10psubframe+10)<=(frame*10+subframe)) || //normal case - ((framex10psubframe>(frame*10+subframe)) && (((10240-framex10psubframe+frame*10+subframe)>=10)))) //frame wrap-around - if (flexran_get_p0_pucch_status(mod_id, UE_id, CC_id) == 1) { - flexran_update_p0_pucch(mod_id, UE_id, CC_id); - - UE_list->UE_template[CC_id][UE_id].pucch_tpc_tx_frame = frame; - UE_list->UE_template[CC_id][UE_id].pucch_tpc_tx_subframe = subframe; - if (normalized_rx_power>(target_rx_power+1)) { - tpc = 0; //-1 - tpc_accumulated--; - } else if (normalized_rx_power<(target_rx_power-1)) { - tpc = 2; //+1 - tpc_accumulated++; - } else { - tpc = 1; //0 - } - LOG_D(MAC,"[eNB %d] DLSCH scheduler: frame %d, subframe %d, harq_pid %d, tpc %d, accumulated %d, normalized/target rx power %d/%d\n", - mod_id, frame, subframe, harq_pid, tpc, - tpc_accumulated, normalized_rx_power, target_rx_power); - } // Po_PUCCH has been updated - else { - tpc = 1; //0 - } // time to do TPC update - else { - tpc = 1; //0 - } - for(i=0; iframe_parms.N_RBG; i++) { - rballoc_sub[i] = UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][i]; - } +// This fuction sorts the UE in order their dlsch buffer and CQI +void _sort_UEs (module_id_t Mod_idP, + int frameP, + sub_frame_t subframeP) +{ - // Toggle NDI - LOG_D(MAC,"CC_id %d Frame %d, subframeP %d: Toggling Format1 NDI for UE %d (rnti %x/%d) oldNDI %d\n", - CC_id, frame, subframe, UE_id, - UE_list->UE_template[CC_id][UE_id].rnti,harq_pid, UE_list->UE_template[CC_id][UE_id].oldNDI[harq_pid]); - UE_list->UE_template[CC_id][UE_id].oldNDI[harq_pid]= 1 - UE_list->UE_template[CC_id][UE_id].oldNDI[harq_pid]; - ndi = UE_list->UE_template[CC_id][UE_id].oldNDI[harq_pid]; - - UE_list->UE_template[CC_id][UE_id].mcs[harq_pid] = mcs; - UE_list->UE_template[CC_id][UE_id].oldTPC[harq_pid] = tpc; - // Increase the pointer for the number of scheduled UEs - num_ues_added++; - ue_has_transmission = 1; - } else { // There is no data from RLC or MAC header, so don't schedule - ue_has_transmission = 0; - } - } // End of new scheduling - - // If we has transmission or retransmission - if (ue_has_transmission) { - switch (mac_xface->get_transmission_mode(mod_id, CC_id, rnti)) { - case 1: - case 2: - default: - dl_dci->has_res_alloc = 1; - dl_dci->res_alloc = 0; - dl_dci->has_vrb_format = 1; - dl_dci->vrb_format = PROTOCOL__FLEX_VRB_FORMAT__FLVRBF_LOCALIZED; - dl_dci->has_format = 1; - dl_dci->format = PROTOCOL__FLEX_DCI_FORMAT__FLDCIF_1; - dl_dci->has_rb_bitmap = 1; - dl_dci->rb_bitmap = allocate_prbs_sub(nb_rb, rballoc_sub); - dl_dci->has_rb_shift = 1; - dl_dci->rb_shift = 0; - dl_dci->n_ndi = 1; - dl_dci->ndi = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_ndi); - dl_dci->ndi[0] = ndi; - dl_dci->n_rv = 1; - dl_dci->rv = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_rv); - dl_dci->rv[0] = round & 3; - dl_dci->has_tpc = 1; - dl_dci->tpc = tpc; - dl_dci->n_mcs = 1; - dl_dci->mcs = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_mcs); - dl_dci->mcs[0] = mcs; - dl_dci->n_tbs_size = 1; - dl_dci->tbs_size = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_tbs_size); - dl_dci->tbs_size[0] = dci_tbs; - if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { - dl_dci->has_dai = 1; - dl_dci->dai = (UE_list->UE_template[CC_id][UE_id].DAI-1)&3; - } - break; - case 3: - dl_dci->has_res_alloc = 1; - dl_dci->res_alloc = 0; - dl_dci->has_vrb_format = 1; - dl_dci->vrb_format = PROTOCOL__FLEX_VRB_FORMAT__FLVRBF_LOCALIZED; - dl_dci->has_format = 1; - dl_dci->format = PROTOCOL__FLEX_DCI_FORMAT__FLDCIF_2A; - dl_dci->has_rb_bitmap = 1; - dl_dci->rb_bitmap = allocate_prbs_sub(nb_rb, rballoc_sub); - dl_dci->has_rb_shift = 1; - dl_dci->rb_shift = 0; - dl_dci->n_ndi = 2; - dl_dci->ndi = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_ndi); - dl_dci->ndi[0] = ndi; - dl_dci->ndi[1] = ndi; - dl_dci->n_rv = 2; - dl_dci->rv = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_rv); - dl_dci->rv[0] = round & 3; - dl_dci->rv[1] = round & 3; - dl_dci->has_tpc = 1; - dl_dci->tpc = tpc; - dl_dci->n_mcs = 2; - dl_dci->mcs = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_mcs); - dl_dci->mcs[0] = mcs; - dl_dci->mcs[1] = mcs; - dl_dci->n_tbs_size = 2; - dl_dci->tbs_size = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_tbs_size); - dl_dci->tbs_size[0] = dci_tbs; - dl_dci->tbs_size[1] = dci_tbs; - if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { - dl_dci->has_dai = 1; - dl_dci->dai = (UE_list->UE_template[CC_id][UE_id].DAI-1)&3; - } - break; - case 4: - dl_dci->has_res_alloc = 1; - dl_dci->res_alloc = 0; - dl_dci->has_vrb_format = 1; - dl_dci->vrb_format = PROTOCOL__FLEX_VRB_FORMAT__FLVRBF_LOCALIZED; - dl_dci->has_format = 1; - dl_dci->format = PROTOCOL__FLEX_DCI_FORMAT__FLDCIF_2A; - dl_dci->has_rb_bitmap = 1; - dl_dci->rb_bitmap = allocate_prbs_sub(nb_rb, rballoc_sub); - dl_dci->has_rb_shift = 1; - dl_dci->rb_shift = 0; - dl_dci->n_ndi = 2; - dl_dci->ndi = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_ndi); - dl_dci->ndi[0] = ndi; - dl_dci->ndi[1] = ndi; - dl_dci->n_rv = 2; - dl_dci->rv = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_rv); - dl_dci->rv[0] = round & 3; - dl_dci->rv[1] = round & 3; - dl_dci->has_tpc = 1; - dl_dci->tpc = tpc; - dl_dci->n_mcs = 2; - dl_dci->mcs = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_mcs); - dl_dci->mcs[0] = mcs; - dl_dci->mcs[1] = mcs; - dl_dci->n_tbs_size = 2; - dl_dci->tbs_size = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_tbs_size); - dl_dci->tbs_size[0] = dci_tbs; - dl_dci->tbs_size[1] = dci_tbs; - if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { - dl_dci->has_dai = 1; - dl_dci->dai = (UE_list->UE_template[CC_id][UE_id].DAI-1)&3; - } - break; - case 5: - dl_dci->has_res_alloc = 1; - dl_dci->res_alloc = 0; - dl_dci->has_vrb_format = 1; - dl_dci->vrb_format = PROTOCOL__FLEX_VRB_FORMAT__FLVRBF_LOCALIZED; - dl_dci->has_format = 1; - dl_dci->format = PROTOCOL__FLEX_DCI_FORMAT__FLDCIF_1D; - dl_dci->has_rb_bitmap = 1; - dl_dci->rb_bitmap = allocate_prbs_sub(nb_rb, rballoc_sub); - dl_dci->has_rb_shift = 1; - dl_dci->rb_shift = 0; - dl_dci->n_ndi = 1; - dl_dci->ndi = 1; - dl_dci->ndi[0] = ndi; - dl_dci->n_rv = 1; - dl_dci->rv = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_rv); - dl_dci->rv[0] = round & 3; - dl_dci->has_tpc = 1; - dl_dci->tpc = tpc; - dl_dci->n_mcs = 1; - dl_dci->mcs = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_mcs); - dl_dci->mcs[0] = mcs; - dl_dci->n_tbs_size = 1; - dl_dci->tbs_size = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_tbs_size); - dl_dci->tbs_size[0] = dci_tbs; - if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { - dl_dci->has_dai = 1; - dl_dci->dai = (UE_list->UE_template[CC_id][UE_id].DAI-1)&3; - } - - if(ue_sched_ctl->dl_pow_off[CC_id] == 2) { - ue_sched_ctl->dl_pow_off[CC_id] = 1; - } - - dl_dci->has_dl_power_offset = 1; - dl_dci->dl_power_offset = ue_sched_ctl->dl_pow_off[CC_id]; - dl_dci->has_precoding_info = 1; - dl_dci->precoding_info = 5; // Is this right?? - - break; - case 6: - dl_dci->has_res_alloc = 1; - dl_dci->res_alloc = 0; - dl_dci->has_vrb_format = 1; - dl_dci->vrb_format = PROTOCOL__FLEX_VRB_FORMAT__FLVRBF_LOCALIZED; - dl_dci->has_format = 1; - dl_dci->format = PROTOCOL__FLEX_DCI_FORMAT__FLDCIF_1D; - dl_dci->has_rb_bitmap = 1; - dl_dci->rb_bitmap = allocate_prbs_sub(nb_rb, rballoc_sub); - dl_dci->has_rb_shift = 1; - dl_dci->rb_shift = 0; - dl_dci->n_ndi = 1; - dl_dci->ndi = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_ndi); - dl_dci->ndi[0] = ndi; - dl_dci->n_rv = 1; - dl_dci->rv = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_rv); - dl_dci->rv[0] = round & 3; - dl_dci->has_tpc = 1; - dl_dci->tpc = tpc; - dl_dci->n_mcs = 1; - dl_dci->mcs = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_mcs); - dl_dci->mcs[0] = mcs; - if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { - dl_dci->has_dai = 1; - dl_dci->dai = (UE_list->UE_template[CC_id][UE_id].DAI-1)&3; - } - - dl_dci->has_dl_power_offset = 1; - dl_dci->dl_power_offset = ue_sched_ctl->dl_pow_off[CC_id]; - dl_dci->has_precoding_info = 1; - dl_dci->precoding_info = 5; // Is this right?? - break; - } - } - - if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { - - /* TODO */ - //set_ul_DAI(mod_id, UE_id, CC_id, frame, subframe, frame_parms); - } - } // UE_id loop - } // CC_id loop - - // Add all the dl_data elements to the flexran message - (*dl_info)->dl_mac_config_msg->n_dl_ue_data = num_ues_added; - (*dl_info)->dl_mac_config_msg->dl_ue_data = (Protocol__FlexDlData **) malloc(sizeof(Protocol__FlexDlData *) * num_ues_added); - for (i = 0; i < num_ues_added; i++) { - (*dl_info)->dl_mac_config_msg->dl_ue_data[i] = dl_data[i]; - } - - stop_meas(&eNB->schedule_dlsch); - VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_SCHEDULE_DLSCH,VCD_FUNCTION_OUT); -} - -// This function stores the downlink buffer for all the logical channels -void _store_dlsch_buffer (module_id_t Mod_id, - frame_t frameP, - sub_frame_t subframeP) -{ - - int UE_id,i; - rnti_t rnti; - mac_rlc_status_resp_t rlc_status; - UE_list_t *UE_list = &eNB_mac_inst[Mod_id].UE_list; - UE_TEMPLATE *UE_template; - - for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id]) { - - UE_template = &UE_list->UE_template[UE_PCCID(Mod_id,UE_id)][UE_id]; - - // clear logical channel interface variables - UE_template->dl_buffer_total = 0; - UE_template->dl_pdus_total = 0; - - for(i=0; i< MAX_NUM_LCID; i++) { - UE_template->dl_buffer_info[i]=0; - UE_template->dl_pdus_in_buffer[i]=0; - UE_template->dl_buffer_head_sdu_creation_time[i]=0; - UE_template->dl_buffer_head_sdu_remaining_size_to_send[i]=0; - } - - rnti = UE_RNTI(Mod_id,UE_id); - - for(i=0; i< MAX_NUM_LCID; i++) { // loop over all the logical channels - - rlc_status = mac_rlc_status_ind(Mod_id,rnti, Mod_id,frameP,ENB_FLAG_YES,MBMS_FLAG_NO,i,0 ); - UE_template->dl_buffer_info[i] = rlc_status.bytes_in_buffer; //storing the dlsch buffer for each logical channel - UE_template->dl_pdus_in_buffer[i] = rlc_status.pdus_in_buffer; - UE_template->dl_buffer_head_sdu_creation_time[i] = rlc_status.head_sdu_creation_time ; - UE_template->dl_buffer_head_sdu_creation_time_max = cmax(UE_template->dl_buffer_head_sdu_creation_time_max, - rlc_status.head_sdu_creation_time ); - UE_template->dl_buffer_head_sdu_remaining_size_to_send[i] = rlc_status.head_sdu_remaining_size_to_send; - UE_template->dl_buffer_head_sdu_is_segmented[i] = rlc_status.head_sdu_is_segmented; - UE_template->dl_buffer_total += UE_template->dl_buffer_info[i];//storing the total dlsch buffer - UE_template->dl_pdus_total += UE_template->dl_pdus_in_buffer[i]; - -#ifdef DEBUG_eNB_SCHEDULER - - /* note for dl_buffer_head_sdu_remaining_size_to_send[i] : - * 0 if head SDU has not been segmented (yet), else remaining size not already segmented and sent - */ - if (UE_template->dl_buffer_info[i]>0) - LOG_D(MAC, - "[eNB %d] Frame %d Subframe %d : RLC status for UE %d in LCID%d: total of %d pdus and size %d, head sdu queuing time %d, remaining size %d, is segmeneted %d \n", - Mod_id, frameP, subframeP, UE_id, - i, UE_template->dl_pdus_in_buffer[i],UE_template->dl_buffer_info[i], - UE_template->dl_buffer_head_sdu_creation_time[i], - UE_template->dl_buffer_head_sdu_remaining_size_to_send[i], - UE_template->dl_buffer_head_sdu_is_segmented[i] - ); - -#endif - - } - - //#ifdef DEBUG_eNB_SCHEDULER - if ( UE_template->dl_buffer_total>0) - LOG_D(MAC,"[eNB %d] Frame %d Subframe %d : RLC status for UE %d : total DL buffer size %d and total number of pdu %d \n", - Mod_id, frameP, subframeP, UE_id, - UE_template->dl_buffer_total, - UE_template->dl_pdus_total - ); - - //#endif - } -} - - -// This function returns the estimated number of RBs required by each UE for downlink scheduling -void _assign_rbs_required (module_id_t Mod_id, - frame_t frameP, - sub_frame_t subframe, - uint16_t nb_rbs_required[MAX_NUM_CCs][NUMBER_OF_UE_MAX], - int min_rb_unit[MAX_NUM_CCs]) -{ - - - rnti_t rnti; - uint16_t TBS = 0; - LTE_eNB_UE_stats *eNB_UE_stats[MAX_NUM_CCs]; - int UE_id,n,i,j,CC_id,pCCid,tmp; - UE_list_t *UE_list = &eNB_mac_inst[Mod_id].UE_list; - // UE_TEMPLATE *UE_template; - - // clear rb allocations across all CC_ids - for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id]) { - pCCid = UE_PCCID(Mod_id,UE_id); - rnti = UE_list->UE_template[pCCid][UE_id].rnti; - - //update CQI information across component carriers - for (n=0; nnumactiveCCs[UE_id]; n++) { - CC_id = UE_list->ordered_CCids[n][UE_id]; - eNB_UE_stats[CC_id] = mac_xface->get_eNB_UE_stats(Mod_id,CC_id,rnti); - eNB_UE_stats[CC_id]->dlsch_mcs1=cqi_to_mcs[flexran_get_ue_wcqi(Mod_id, UE_id)]; - } - - // provide the list of CCs sorted according to MCS - for (i=0; inumactiveCCs[UE_id]; i++) { - for (j=i+1; jnumactiveCCs[UE_id]; j++) { - DevAssert( j < MAX_NUM_CCs ); - - if (eNB_UE_stats[UE_list->ordered_CCids[i][UE_id]]->dlsch_mcs1 > - eNB_UE_stats[UE_list->ordered_CCids[j][UE_id]]->dlsch_mcs1) { - tmp = UE_list->ordered_CCids[i][UE_id]; - UE_list->ordered_CCids[i][UE_id] = UE_list->ordered_CCids[j][UE_id]; - UE_list->ordered_CCids[j][UE_id] = tmp; - } - } - } - - /* NN --> RK - * check the index of UE_template" - */ - if (UE_list->UE_template[pCCid][UE_id].dl_buffer_total> 0) { - LOG_D(MAC,"[preprocessor] assign RB for UE %d\n",UE_id); - - for (i=0; inumactiveCCs[UE_id]; i++) { - CC_id = UE_list->ordered_CCids[i][UE_id]; - eNB_UE_stats[CC_id] = mac_xface->get_eNB_UE_stats(Mod_id,CC_id,rnti); - - if (eNB_UE_stats[CC_id]->dlsch_mcs1==0) { - nb_rbs_required[CC_id][UE_id] = 4; // don't let the TBS get too small - } else { - nb_rbs_required[CC_id][UE_id] = min_rb_unit[CC_id]; - } - - TBS = mac_xface->get_TBS_DL(eNB_UE_stats[CC_id]->dlsch_mcs1,nb_rbs_required[CC_id][UE_id]); - - LOG_D(MAC,"[preprocessor] start RB assignement for UE %d CC_id %d dl buffer %d (RB unit %d, MCS %d, TBS %d) \n", - UE_id, CC_id, UE_list->UE_template[pCCid][UE_id].dl_buffer_total, - nb_rbs_required[CC_id][UE_id],eNB_UE_stats[CC_id]->dlsch_mcs1,TBS); - - /* calculating required number of RBs for each UE */ - while (TBS < UE_list->UE_template[pCCid][UE_id].dl_buffer_total) { - nb_rbs_required[CC_id][UE_id] += min_rb_unit[CC_id]; - - if (nb_rbs_required[CC_id][UE_id] > flexran_get_N_RB_DL(Mod_id, CC_id)) { - TBS = mac_xface->get_TBS_DL(eNB_UE_stats[CC_id]->dlsch_mcs1, flexran_get_N_RB_DL(Mod_id, CC_id)); - nb_rbs_required[CC_id][UE_id] = flexran_get_N_RB_DL(Mod_id, CC_id); - break; - } - - TBS = mac_xface->get_TBS_DL(eNB_UE_stats[CC_id]->dlsch_mcs1,nb_rbs_required[CC_id][UE_id]); - } // end of while - - LOG_D(MAC,"[eNB %d] Frame %d: UE %d on CC %d: RB unit %d, nb_required RB %d (TBS %d, mcs %d)\n", - Mod_id, frameP,UE_id, CC_id, min_rb_unit[CC_id], nb_rbs_required[CC_id][UE_id], TBS, eNB_UE_stats[CC_id]->dlsch_mcs1); - } - } - } -} - -// This function scans all CC_ids for a particular UE to find the maximum round index of its HARQ processes -int _maxround(module_id_t Mod_id,uint16_t rnti,int frame,sub_frame_t subframe,uint8_t ul_flag ) -{ - - uint8_t round,round_max=0,UE_id; - int CC_id; - UE_list_t *UE_list = &eNB_mac_inst[Mod_id].UE_list; - - for (CC_id=0; CC_idUE_sched_ctrl[UE_id].round[CC_id]; - if (round > round_max) { - round_max = round; - } - } - - return round_max; -} - -// This function scans all CC_ids for a particular UE to find the maximum DL CQI -int _maxcqi(module_id_t Mod_id,int32_t UE_id) -{ - - LTE_eNB_UE_stats *eNB_UE_stats = NULL; - UE_list_t *UE_list = &eNB_mac_inst[Mod_id].UE_list; - int CC_id,n; - int CQI = 0; - - for (n=0; nnumactiveCCs[UE_id]; n++) { - CC_id = UE_list->ordered_CCids[n][UE_id]; - eNB_UE_stats = mac_xface->get_eNB_UE_stats(Mod_id,CC_id,UE_RNTI(Mod_id,UE_id)); - - if (eNB_UE_stats==NULL) { - mac_xface->macphy_exit("maxcqi: could not get eNB_UE_stats\n"); - return 0; // not reached - } - - if (eNB_UE_stats->DL_cqi[0] > CQI) { - CQI = eNB_UE_stats->DL_cqi[0]; - } - } - - return(CQI); -} - - -// This fuction sorts the UE in order their dlsch buffer and CQI -void _sort_UEs (module_id_t Mod_idP, - int frameP, - sub_frame_t subframeP) -{ - - - int UE_id1,UE_id2; - int pCC_id1,pCC_id2; - int cqi1,cqi2,round1,round2; - int i=0,ii=0;//,j=0; - rnti_t rnti1,rnti2; + int UE_id1,UE_id2; + int pCC_id1,pCC_id2; + int cqi1,cqi2,round1,round2; + int i=0,ii=0;//,j=0; + rnti_t rnti1,rnti2; UE_list_t *UE_list = &eNB_mac_inst[Mod_idP].UE_list; @@ -1024,35 +402,170 @@ void _sort_UEs (module_id_t Mod_idP, } } -// This function assigns pre-available RBS to each UE in specified sub-bands before scheduling is done -void _dlsch_scheduler_pre_processor (module_id_t Mod_id, - frame_t frameP, - sub_frame_t subframeP, - int N_RBG[MAX_NUM_CCs], - int *mbsfn_flag) -{ - - unsigned char rballoc_sub[MAX_NUM_CCs][N_RBG_MAX], harq_pid=0, total_ue_count; - unsigned char MIMO_mode_indicator[MAX_NUM_CCs][N_RBG_MAX]; - int UE_id, i; - unsigned char round = 0; - uint16_t ii,j; - uint16_t nb_rbs_required[MAX_NUM_CCs][NUMBER_OF_UE_MAX]; - uint16_t nb_rbs_required_remaining[MAX_NUM_CCs][NUMBER_OF_UE_MAX]; - uint16_t nb_rbs_required_remaining_1[MAX_NUM_CCs][NUMBER_OF_UE_MAX]; - uint16_t average_rbs_per_user[MAX_NUM_CCs] = {0}; - rnti_t rnti; - int min_rb_unit[MAX_NUM_CCs]; - uint16_t r1=0; - uint8_t CC_id; - UE_list_t *UE_list = &eNB_mac_inst[Mod_id].UE_list; - LTE_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs] = {0}; +void _dlsch_scheduler_pre_processor_allocate (module_id_t Mod_id, + int UE_id, + uint8_t CC_id, + int N_RBG, + int transmission_mode, + int min_rb_unit, + uint8_t N_RB_DL, + uint16_t nb_rbs_required[MAX_NUM_CCs][NUMBER_OF_UE_MAX], + uint16_t nb_rbs_required_remaining[MAX_NUM_CCs][NUMBER_OF_UE_MAX], + unsigned char rballoc_sub[MAX_NUM_CCs][N_RBG_MAX], + unsigned char MIMO_mode_indicator[MAX_NUM_CCs][N_RBG_MAX]) { + int i; + UE_list_t *UE_list=&eNB_mac_inst[Mod_id].UE_list; + UE_sched_ctrl *ue_sched_ctl = &UE_list->UE_sched_ctrl[UE_id]; - int transmission_mode = 0; - UE_sched_ctrl *ue_sched_ctl; + for(i=0; irballoc_sub_UE[CC_id][i] == 0) && + (nb_rbs_required_remaining[CC_id][UE_id]>0) && + (ue_sched_ctl->pre_nb_available_rbs[CC_id] < nb_rbs_required[CC_id][UE_id])) { + + // if this UE is not scheduled for TM5 + if (ue_sched_ctl->dl_pow_off[CC_id] != 0 ) { + + if ((i == N_RBG-1) && ((N_RB_DL == 25) || (N_RB_DL == 50))) { + rballoc_sub[CC_id][i] = 1; + ue_sched_ctl->rballoc_sub_UE[CC_id][i] = 1; + MIMO_mode_indicator[CC_id][i] = 1; + if (transmission_mode == 5 ) { + ue_sched_ctl->dl_pow_off[CC_id] = 1; + } + nb_rbs_required_remaining[CC_id][UE_id] = nb_rbs_required_remaining[CC_id][UE_id] - min_rb_unit+1; + ue_sched_ctl->pre_nb_available_rbs[CC_id] = ue_sched_ctl->pre_nb_available_rbs[CC_id] + min_rb_unit - 1; + } else { + if (nb_rbs_required_remaining[CC_id][UE_id] >= min_rb_unit){ + rballoc_sub[CC_id][i] = 1; + ue_sched_ctl->rballoc_sub_UE[CC_id][i] = 1; + MIMO_mode_indicator[CC_id][i] = 1; + if (transmission_mode == 5 ) { + ue_sched_ctl->dl_pow_off[CC_id] = 1; + } + nb_rbs_required_remaining[CC_id][UE_id] = nb_rbs_required_remaining[CC_id][UE_id] - min_rb_unit; + ue_sched_ctl->pre_nb_available_rbs[CC_id] = ue_sched_ctl->pre_nb_available_rbs[CC_id] + min_rb_unit; + } + } + } // dl_pow_off[CC_id][UE_id] ! = 0 + } + } +} + +void _dlsch_scheduler_pre_processor_reset (int module_idP, + int UE_id, + uint8_t CC_id, + int frameP, + int subframeP, + int N_RBG, + uint16_t nb_rbs_required[MAX_NUM_CCs][NUMBER_OF_UE_MAX], + uint16_t nb_rbs_required_remaining[MAX_NUM_CCs][NUMBER_OF_UE_MAX], + uint16_t nb_rbs_allowed_slice[MAX_NUM_CCs][MAX_NUM_SLICES], + unsigned char rballoc_sub[MAX_NUM_CCs][N_RBG_MAX], + unsigned char MIMO_mode_indicator[MAX_NUM_CCs][N_RBG_MAX]) { + int i,j; + UE_list_t *UE_list=&eNB_mac_inst[module_idP].UE_list; + UE_sched_ctrl *ue_sched_ctl = &UE_list->UE_sched_ctrl[UE_id]; + uint8_t *vrb_map = eNB_mac_inst[module_idP].common_channels[CC_id].vrb_map; + int RBGsize = PHY_vars_eNB_g[module_idP][CC_id]->frame_parms.N_RB_DL/N_RBG; +#ifdef SF05_LIMIT + //int subframe05_limit=0; + int sf05_upper=-1,sf05_lower=-1; +#endif + // LTE_eNB_UE_stats *eNB_UE_stats = mac_xface->get_eNB_UE_stats(module_idP,CC_id,rnti); + + flexran_update_TA(module_idP, UE_id, CC_id); + + if (UE_id==0) { + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE0_TIMING_ADVANCE,ue_sched_ctl->ta_update); + } + nb_rbs_required[CC_id][UE_id]=0; + ue_sched_ctl->pre_nb_available_rbs[CC_id] = 0; + ue_sched_ctl->dl_pow_off[CC_id] = 2; + nb_rbs_required_remaining[CC_id][UE_id] = 0; + for (i=0; irballoc_sub_UE[CC_id][i] = 0; + rballoc_sub[CC_id][i] = 0; +#ifdef SF05_LIMIT + // for avoiding 6+ PRBs around DC in subframe 0-5 (avoid excessive errors) + + if ((subframeP==0 || subframeP==5) && + (i>=sf05_lower && i<=sf05_upper)) + rballoc_sub[CC_id][i]=1; +#endif + // for SI-RNTI,RA-RNTI and P-RNTI allocations + for (j=0;j0) // If this CC is allocated for MBSFN skip it here continue; @@ -1065,7 +578,8 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, UE_id = i; // Initialize scheduling information for all active UEs - + //if (flexran_slice_member(UE_id, slice_id) == 0) + //continue; _dlsch_scheduler_pre_processor_reset(Mod_id, UE_id, CC_id, @@ -1074,6 +588,7 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, N_RBG[CC_id], nb_rbs_required, nb_rbs_required_remaining, + nb_rbs_allowed_slice, rballoc_sub, MIMO_mode_indicator); @@ -1081,10 +596,10 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, } // Store the DLSCH buffer for each logical channel - _store_dlsch_buffer (Mod_id,frameP,subframeP); + _store_dlsch_buffer (Mod_id,slice_id,frameP,subframeP); // Calculate the number of RBs required by each UE on the basis of logical channel's buffer - _assign_rbs_required (Mod_id,frameP,subframeP,nb_rbs_required,min_rb_unit); + _assign_rbs_required (Mod_id,slice_id, frameP,subframeP,nb_rbs_required,nb_rbs_allowed_slice,min_rb_unit); // Sorts the user on the basis of dlsch logical channel buffer and CQI _sort_UEs (Mod_id,frameP,subframeP); @@ -1099,7 +614,10 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, if (UE_list->UE_sched_ctrl[i].ul_out_of_sync == 1) continue; UE_id = i; - + + if (flexran_slice_member(UE_id, slice_id) == 0) + continue; + // if there is no available harq_process, skip the UE if (UE_list->UE_sched_ctrl[UE_id].harq_pid[CC_id]<0) continue; @@ -1107,6 +625,7 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, for (ii=0; ii < UE_num_active_CC(UE_list,UE_id); ii++) { CC_id = UE_list->ordered_CCids[ii][UE_id]; ue_sched_ctl = &UE_list->UE_sched_ctrl[UE_id]; + ue_sched_ctl->max_allowed_rbs[CC_id]=nb_rbs_allowed_slice[CC_id][slice_id]; flexran_get_harq(Mod_id, CC_id, UE_id, frameP, subframeP, &harq_pid, &round); average_rbs_per_user[CC_id]=0; @@ -1137,8 +656,8 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, if (total_ue_count == 0) { average_rbs_per_user[CC_id] = 0; - } else if( (min_rb_unit[CC_id] * total_ue_count) <= (frame_parms[CC_id]->N_RB_DL) ) { - average_rbs_per_user[CC_id] = (uint16_t) floor(frame_parms[CC_id]->N_RB_DL/total_ue_count); + } else if( (min_rb_unit[CC_id] * total_ue_count) <= nb_rbs_allowed_slice[CC_id][slice_id] ) { + average_rbs_per_user[CC_id] = (uint16_t) floor(nb_rbs_allowed_slice[CC_id][slice_id]/total_ue_count); } else { average_rbs_per_user[CC_id] = min_rb_unit[CC_id]; // consider the total number of use that can be scheduled UE } @@ -1149,7 +668,10 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, // extend nb_rbs_required to capture per LCID RB required for(i=UE_list->head; i>=0; i=UE_list->next[i]) { rnti = UE_RNTI(Mod_id,i); - + + if (flexran_slice_member(i, slice_id) == 0) + continue; + for (ii=0; iiordered_CCids[ii][i]; @@ -1169,6 +691,10 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, for(r1=0; r1<2; r1++) { for(i=UE_list->head; i>=0; i=UE_list->next[i]) { + + if (flexran_slice_member(i, slice_id) == 0) + continue; + for (ii=0; iiordered_CCids[ii][i]; @@ -1194,8 +720,11 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, if (total_ue_count > 0 ) { for(i=UE_list->head; i>=0; i=UE_list->next[i]) { UE_id = i; - - for (ii=0; iiordered_CCids[ii][UE_id]; ue_sched_ctl = &UE_list->UE_sched_ctrl[UE_id]; flexran_get_harq(Mod_id, CC_id, UE_id, frameP, subframeP, &harq_pid, &round); @@ -1234,6 +763,9 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, for(i=UE_list->head; i>=0; i=UE_list->next[i]) { UE_id = i; ue_sched_ctl = &UE_list->UE_sched_ctrl[UE_id]; + + if (flexran_slice_member(UE_id, slice_id) == 0) + continue; for (ii=0; iiordered_CCids[ii][UE_id]; @@ -1250,7 +782,8 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, } //PHY_vars_eNB_g[Mod_id]->mu_mimo_mode[UE_id].pre_nb_available_rbs = pre_nb_available_rbs[CC_id][UE_id]; - LOG_D(MAC,"Total RBs allocated for UE%d = %d\n",UE_id,ue_sched_ctl->pre_nb_available_rbs[CC_id]); + LOG_D(MAC,"[eNB %d][SLICE %d] Total RBs allocated for UE%d = %d\n", + Mod_id, slice_id, UE_id,ue_sched_ctl->pre_nb_available_rbs[CC_id]); } } } @@ -1258,134 +791,921 @@ void _dlsch_scheduler_pre_processor (module_id_t Mod_id, #define SF05_LIMIT 1 -void _dlsch_scheduler_pre_processor_reset (int module_idP, - int UE_id, - uint8_t CC_id, - int frameP, - int subframeP, - int N_RBG, - uint16_t nb_rbs_required[MAX_NUM_CCs][NUMBER_OF_UE_MAX], - uint16_t nb_rbs_required_remaining[MAX_NUM_CCs][NUMBER_OF_UE_MAX], - unsigned char rballoc_sub[MAX_NUM_CCs][N_RBG_MAX], - unsigned char MIMO_mode_indicator[MAX_NUM_CCs][N_RBG_MAX]) { - int i,j; - UE_list_t *UE_list=&eNB_mac_inst[module_idP].UE_list; - UE_sched_ctrl *ue_sched_ctl = &UE_list->UE_sched_ctrl[UE_id]; - rnti_t rnti = UE_RNTI(module_idP,UE_id); - uint8_t *vrb_map = eNB_mac_inst[module_idP].common_channels[CC_id].vrb_map; - int RBGsize = PHY_vars_eNB_g[module_idP][CC_id]->frame_parms.N_RB_DL/N_RBG; -#ifdef SF05_LIMIT - //int subframe05_limit=0; - int sf05_upper=-1,sf05_lower=-1; -#endif - LTE_eNB_UE_stats *eNB_UE_stats = mac_xface->get_eNB_UE_stats(module_idP,CC_id,rnti); - - flexran_update_TA(module_idP, UE_id, CC_id); +/* + * Main scheduling functions to support slicing + * + */ - if (UE_id==0) { - VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_UE0_TIMING_ADVANCE,ue_sched_ctl->ta_update); - } - nb_rbs_required[CC_id][UE_id]=0; - ue_sched_ctl->pre_nb_available_rbs[CC_id] = 0; - ue_sched_ctl->dl_pow_off[CC_id] = 2; - nb_rbs_required_remaining[CC_id][UE_id] = 0; +void +flexran_schedule_ue_spec_default(mid_t mod_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info) +//------------------------------------------------------------------------------ +{ + int i=0; + + flexran_agent_mac_create_empty_dl_config(mod_id, dl_info); + + for (i = 0; i < n_active_slices; i++) { + + // Load any updated functions + if (update_dl_scheduler[i] > 0 ) { + slice_sched[i] = dlsym(NULL, dl_scheduler_type[i]); + update_dl_scheduler[i] = 0; + update_dl_scheduler_current[i] = 0; + slice_percentage_current[i]= slice_percentage[i]; + total_slice_percentage+=slice_percentage[i]; + LOG_N(MAC,"update dl scheduler slice %d\n", i); + } + + // check if the number of slices has changed, and log + if (n_active_slices_current != n_active_slices ){ + if ((n_active_slices > 0) && (n_active_slices <= MAX_NUM_SLICES)) { + LOG_N(MAC,"[eNB %d]frame %d subframe %d: number of active slices has changed: %d-->%d\n", + mod_id, frame, subframe, n_active_slices_current, n_active_slices); + n_active_slices_current = n_active_slices; + } else { + LOG_W(MAC,"invalid number of slices %d, revert to the previous value %d\n",n_active_slices, n_active_slices_current); + n_active_slices = n_active_slices_current; + } + } + + // check if the slice rb share has changed, and log the console + if (slice_percentage_current[i] != slice_percentage[i]){ + if ((slice_percentage[i] >= 0.0) && (slice_percentage[i] <= 1.0)){ + if ((total_slice_percentage - slice_percentage_current[i] + slice_percentage[i]) <= 1.0) { + total_slice_percentage=total_slice_percentage - slice_percentage_current[i] + slice_percentage[i]; + LOG_N(MAC,"[eNB %d][SLICE %d] frame %d subframe %d: total percentage %f, slice RB percentage has changed: %f-->%f\n", + mod_id, i, frame, subframe, total_slice_percentage, slice_percentage_current[i], slice_percentage[i]); + slice_percentage_current[i] = slice_percentage[i]; + } else { + LOG_W(MAC,"[eNB %d][SLICE %d] invalid total RB share (%f->%f), revert the previous value (%f->%f)\n", + mod_id,i, + total_slice_percentage, + total_slice_percentage - slice_percentage_current[i] + slice_percentage[i], + slice_percentage[i],slice_percentage_current[i]); + slice_percentage[i]= slice_percentage_current[i]; -#ifdef SF05_LIMIT - switch (N_RBG) { - case 6: - sf05_lower=0; - sf05_upper=5; - break; - case 8: - sf05_lower=2; - sf05_upper=5; - break; - case 13: - sf05_lower=4; - sf05_upper=7; - break; - case 17: - sf05_lower=7; - sf05_upper=9; - break; - case 25: - sf05_lower=11; - sf05_upper=13; - break; - } -#endif - // Initialize Subbands according to VRB map - for (i=0; irballoc_sub_UE[CC_id][i] = 0; - rballoc_sub[CC_id][i] = 0; -#ifdef SF05_LIMIT - // for avoiding 6+ PRBs around DC in subframe 0-5 (avoid excessive errors) + } + } else { + LOG_W(MAC,"[eNB %d][SLICE %d] invalid slice RB share, revert the previous value (%f->%f)\n",mod_id, i, slice_percentage[i],slice_percentage_current[i]); + slice_percentage[i]= slice_percentage_current[i]; - if ((subframeP==0 || subframeP==5) && - (i>=sf05_lower && i<=sf05_upper)) - rballoc_sub[CC_id][i]=1; -#endif - // for SI-RNTI,RA-RNTI and P-RNTI allocations - for (j=0;j= 0) && (slice_maxmcs[i] < 29)){ + LOG_N(MAC,"[eNB %d][SLICE %d] frame %d subframe %d: slice MAX MCS has changed: %d-->%d\n", + mod_id, i, frame, subframe, slice_maxmcs_current[i], slice_maxmcs[i]); + slice_maxmcs_current[i] = slice_maxmcs[i]; + } else { + LOG_W(MAC,"[eNB %d][SLICE %d] invalid slice max mcs %d, revert the previous value %d\n",mod_id, i, slice_percentage[i],slice_percentage[i]); + slice_maxmcs[i]= slice_maxmcs_current[i]; + } + } + + // check if a new scheduler, and log the console + if (update_dl_scheduler_current[i] != update_dl_scheduler[i]){ + LOG_N(MAC,"[eNB %d][SLICE %d] frame %d subframe %d: DL scheduler for this slice is updated: %s \n", + mod_id, i, frame, subframe, dl_scheduler_type[i]); + update_dl_scheduler_current[i] = update_dl_scheduler[i]; + } + + // Run each enabled slice-specific schedulers one by one + //LOG_N(MAC,"[eNB %d]frame %d subframe %d slice %d: calling the scheduler\n", mod_id, frame, subframe,i); + slice_sched[i](mod_id, i, frame, subframe, mbsfn_flag,dl_info); + } + } +uint16_t flexran_nb_rbs_allowed_slice(float rb_percentage, int total_rbs){ + return (uint16_t) floor(rb_percentage * total_rbs); +} -void _dlsch_scheduler_pre_processor_allocate (module_id_t Mod_id, - int UE_id, - uint8_t CC_id, - int N_RBG, - int transmission_mode, - int min_rb_unit, - uint8_t N_RB_DL, - uint16_t nb_rbs_required[MAX_NUM_CCs][NUMBER_OF_UE_MAX], - uint16_t nb_rbs_required_remaining[MAX_NUM_CCs][NUMBER_OF_UE_MAX], - unsigned char rballoc_sub[MAX_NUM_CCs][N_RBG_MAX], - unsigned char MIMO_mode_indicator[MAX_NUM_CCs][N_RBG_MAX]) { +int flexran_slice_maxmcs(int slice_id) { + return slice_maxmcs[slice_id]; +} + +int flexran_slice_member(int UE_id, int slice_id){ + // group membership definition + int slice_member = 0 ; + + if ((slice_id < 0) || (slice_id > n_active_slices)) + LOG_W(MAC,"out of range slice id %d\n",slice_id); + + switch (slicing_strategy) { + case SLICE_MASK: + switch (slice_id){ + case 0: + if (SLICE0_MASK&UE_id){ + slice_member=1; + } + break; + case 1: + if (SLICE1_MASK&UE_id){ + slice_member=1; + } + break; + case 2: + if (SLICE2_MASK&UE_id){ + slice_member=1; + } + break; + case 3: + if (SLICE3_MASK&UE_id){ + slice_member=1; + } + break; + default : + LOG_W(MAC,"unknown slice_id %d\n", slice_id); + break; + + } + break; + case UEID_TO_SLICEID: + default: + if ((UE_id % n_active_slices) == slice_id){ + slice_member= 1; // this ue is a member of this slice + } + break; + } + + return slice_member; +} +/* more aggressive rb and mcs allocation with medium priority and the traffic qci */ +void +flexran_schedule_ue_spec_embb(mid_t mod_id, + int slice_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info) + +{ + flexran_schedule_ue_spec_common(mod_id, + slice_id, + frame, + subframe, + mbsfn_flag, + dl_info); + +} +/* more conservative mcs allocation with high priority and the traffic qci */ +void +flexran_schedule_ue_spec_urllc(mid_t mod_id, + int slice_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info) + +{ + flexran_schedule_ue_spec_common(mod_id, + slice_id, + frame, + subframe, + mbsfn_flag, + dl_info); + +} +/* constant rb allocation with low mcs with low priority and given the UE capabilities */ +void +flexran_schedule_ue_spec_mmtc(mid_t mod_id, + int slice_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info) + +{ + + flexran_schedule_ue_spec_common(mod_id, + slice_id, + frame, + subframe, + mbsfn_flag, + dl_info); + +} +/* regular rb and mcs allocation with low priority */ +void +flexran_schedule_ue_spec_be(mid_t mod_id, + int slice_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info) + +{ + + flexran_schedule_ue_spec_common(mod_id, + slice_id, + frame, + subframe, + mbsfn_flag, + dl_info); + +} + +//------------------------------------------------------------------------------ +void +flexran_schedule_ue_spec_common(mid_t mod_id, + int slice_id, + uint32_t frame, + uint32_t subframe, + int *mbsfn_flag, + Protocol__FlexranMessage **dl_info) +//------------------------------------------------------------------------------ +{ + uint8_t CC_id; + int UE_id; + int N_RBG[MAX_NUM_CCs]; + unsigned char aggregation; + mac_rlc_status_resp_t rlc_status; + unsigned char header_len = 0, ta_len = 0; + uint16_t nb_rb, nb_rb_temp, total_nb_available_rb[MAX_NUM_CCs], nb_available_rb; + uint16_t TBS, j, rnti; + unsigned char round = 0; + unsigned char harq_pid = 0; + uint16_t sdu_length_total = 0; + int mcs, mcs_tmp; + uint16_t min_rb_unit[MAX_NUM_CCs]; + eNB_MAC_INST *eNB = &eNB_mac_inst[mod_id]; + /* TODO: Must move the helper structs to scheduler implementation */ + UE_list_t *UE_list = &eNB->UE_list; + int32_t normalized_rx_power, target_rx_power; + int32_t tpc = 1; + static int32_t tpc_accumulated=0; + UE_sched_ctrl *ue_sched_ctl; + + Protocol__FlexDlData *dl_data[NUM_MAX_UE]; + int num_ues_added = 0; + int channels_added = 0; + + Protocol__FlexDlDci *dl_dci; + Protocol__FlexRlcPdu *rlc_pdus[11]; + uint32_t ce_flags = 0; + + uint8_t rballoc_sub[25]; int i; - UE_list_t *UE_list=&eNB_mac_inst[Mod_id].UE_list; - UE_sched_ctrl *ue_sched_ctl = &UE_list->UE_sched_ctrl[UE_id]; + uint32_t data_to_request; + uint32_t dci_tbs; + uint8_t ue_has_transmission = 0; + uint32_t ndi; + + flexran_agent_mac_create_empty_dl_config(mod_id, dl_info); + + if (UE_list->head==-1) { + return; + } + + start_meas(&eNB->schedule_dlsch); + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_SCHEDULE_DLSCH,VCD_FUNCTION_IN); - for(i=0; icommon_channels[CC_id].vrb_map[i] != 0) + total_nb_available_rb[CC_id]--; + + N_RBG[CC_id] = flexran_get_N_RBG(mod_id, CC_id); + + // store the global enb stats: + eNB->eNB_stats[CC_id].num_dlactive_UEs = UE_list->num_UEs; + eNB->eNB_stats[CC_id].available_prbs = total_nb_available_rb[CC_id]; + eNB->eNB_stats[CC_id].total_available_prbs += total_nb_available_rb[CC_id]; + eNB->eNB_stats[CC_id].dlsch_bytes_tx=0; + eNB->eNB_stats[CC_id].dlsch_pdus_tx=0; + } + + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_PREPROCESSOR,VCD_FUNCTION_IN); + + start_meas(&eNB->schedule_dlsch_preprocessor); + _dlsch_scheduler_pre_processor(mod_id, + slice_id, + frame, + subframe, + N_RBG, + mbsfn_flag); + stop_meas(&eNB->schedule_dlsch_preprocessor); + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_PREPROCESSOR,VCD_FUNCTION_OUT); + + for (CC_id=0; CC_id0) + continue; + + for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id]) { + rnti = flexran_get_ue_crnti(mod_id, UE_id); + ue_sched_ctl = &UE_list->UE_sched_ctrl[UE_id]; + + if (flexran_slice_member(UE_id, slice_id) == 0) + continue; + + if (rnti==NOT_A_RNTI) { + LOG_D(MAC,"Cannot find rnti for UE_id %d (num_UEs %d)\n", UE_id,UE_list->num_UEs); + // mac_xface->macphy_exit("Cannot find rnti for UE_id"); + continue; + } + + if (flexran_get_ue_crnti(mod_id, UE_id) == NOT_A_RNTI) { + LOG_D(MAC,"[eNB] Cannot find UE\n"); + // mac_xface->macphy_exit("[MAC][eNB] Cannot find eNB_UE_stats\n"); + continue; + } + + if ((ue_sched_ctl->pre_nb_available_rbs[CC_id] == 0) || // no RBs allocated + CCE_allocation_infeasible(mod_id, CC_id, 0, subframe, aggregation, rnti)) { + LOG_D(MAC,"[eNB %d] Frame %d : no RB allocated for UE %d on CC_id %d: continue \n", + mod_id, frame, UE_id, CC_id); + //if(mac_xface->get_transmission_mode(module_idP,rnti)==5) + continue; //to next user (there might be rbs availiable for other UEs in TM5 + // else + // break; + } + + if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { + set_ue_dai (subframe, + flexran_get_subframe_assignment(mod_id, CC_id), + UE_id, + CC_id, + UE_list); + //TODO: update UL DAI after DLSCH scheduling + //set_ul_DAI(mod_id, UE_id, CC_id, frame, subframe,frame_parms); + } + + channels_added = 0; + + // After this point all the UEs will be scheduled + dl_data[num_ues_added] = (Protocol__FlexDlData *) malloc(sizeof(Protocol__FlexDlData)); + protocol__flex_dl_data__init(dl_data[num_ues_added]); + dl_data[num_ues_added]->has_rnti = 1; + dl_data[num_ues_added]->rnti = rnti; + dl_data[num_ues_added]->n_rlc_pdu = 0; + dl_data[num_ues_added]->has_serv_cell_index = 1; + dl_data[num_ues_added]->serv_cell_index = CC_id; + + nb_available_rb = ue_sched_ctl->pre_nb_available_rbs[CC_id]; + flexran_get_harq(mod_id, CC_id, UE_id, frame, subframe, &harq_pid, &round); + sdu_length_total=0; + mcs = cqi_to_mcs[flexran_get_ue_wcqi(mod_id, UE_id)]; + mcs = cmin(mcs,flexran_slice_maxmcs(slice_id)); +#ifdef EXMIMO + + if (mac_xface->get_transmission_mode(mod_id, CC_id, rnti) == 5) { + mcs = cqi_to_mcs[flexran_get_ue_wcqi(mod_id, UE_id)]; + mcs = cmin(mcs,16); + } + +#endif + + // initializing the rb allocation indicator for each UE + for(j = 0; j < flexran_get_N_RBG(mod_id, CC_id); j++) { + UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j] = 0; + rballoc_sub[j] = 0; + } + + /* LOG_D(MAC,"[eNB %d] Frame %d: Scheduling UE %d on CC_id %d (rnti %x, harq_pid %d, round %d, rb %d, cqi %d, mcs %d, rrc %d)\n", */ + /* mod_id, frame, UE_id, CC_id, rnti, harq_pid, round, nb_available_rb, */ + /* eNB_UE_stats->DL_cqi[0], mcs, */ + /* UE_list->eNB_UE_stats[CC_id][UE_id].rrc_status); */ + + dl_dci = (Protocol__FlexDlDci*) malloc(sizeof(Protocol__FlexDlDci)); + protocol__flex_dl_dci__init(dl_dci); + dl_data[num_ues_added]->dl_dci = dl_dci; + + + dl_dci->has_rnti = 1; + dl_dci->rnti = rnti; + dl_dci->has_harq_process = 1; + dl_dci->harq_process = harq_pid; + + /* process retransmission */ + + if (round > 0) { + + if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { + UE_list->UE_template[CC_id][UE_id].DAI++; + update_ul_dci(mod_id, CC_id, rnti, UE_list->UE_template[CC_id][UE_id].DAI); + LOG_D(MAC,"DAI update: CC_id %d subframeP %d: UE %d, DAI %d\n", + CC_id, subframe,UE_id,UE_list->UE_template[CC_id][UE_id].DAI); + } + + mcs = UE_list->UE_template[CC_id][UE_id].mcs[harq_pid]; + + // get freq_allocation + nb_rb = UE_list->UE_template[CC_id][UE_id].nb_rb[harq_pid]; + + /*TODO: Must add this to FlexRAN agent API */ + dci_tbs = mac_xface->get_TBS_DL(mcs, nb_rb); + + if (nb_rb <= nb_available_rb) { + + if(nb_rb == ue_sched_ctl->pre_nb_available_rbs[CC_id]) { + for(j = 0; j < flexran_get_N_RBG(mod_id, CC_id); j++) { // for indicating the rballoc for each sub-band + UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j] = ue_sched_ctl->rballoc_sub_UE[CC_id][j]; + } + } else { + nb_rb_temp = nb_rb; + j = 0; + + while((nb_rb_temp > 0) && (j < flexran_get_N_RBG(mod_id, CC_id))) { + if(ue_sched_ctl->rballoc_sub_UE[CC_id][j] == 1) { + UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j] = ue_sched_ctl->rballoc_sub_UE[CC_id][j]; + + if((j == flexran_get_N_RBG(mod_id, CC_id) - 1) && + ((flexran_get_N_RB_DL(mod_id, CC_id) == 25)|| + (flexran_get_N_RB_DL(mod_id, CC_id) == 50))) { + nb_rb_temp = nb_rb_temp - min_rb_unit[CC_id]+1; + } else { + nb_rb_temp = nb_rb_temp - min_rb_unit[CC_id]; + } + } + j = j + 1; + } + } + + nb_available_rb -= nb_rb; + aggregation = process_ue_cqi(mod_id, UE_id); + + PHY_vars_eNB_g[mod_id][CC_id]->mu_mimo_mode[UE_id].pre_nb_available_rbs = nb_rb; + PHY_vars_eNB_g[mod_id][CC_id]->mu_mimo_mode[UE_id].dl_pow_off = ue_sched_ctl->dl_pow_off[CC_id]; + + for(j=0; j < flexran_get_N_RBG(mod_id, CC_id); j++) { + PHY_vars_eNB_g[mod_id][CC_id]->mu_mimo_mode[UE_id].rballoc_sub[j] = UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j]; + rballoc_sub[j] = UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j]; + } + + // Keep the old NDI, do not toggle + ndi = UE_list->UE_template[CC_id][UE_id].oldNDI[harq_pid]; + tpc = UE_list->UE_template[CC_id][UE_id].oldTPC[harq_pid]; + UE_list->UE_template[CC_id][UE_id].mcs[harq_pid] = mcs; + + ue_has_transmission = 1; + num_ues_added++; + } else { + LOG_D(MAC,"[eNB %d] Frame %d CC_id %d : don't schedule UE %d, its retransmission takes more resources than we have\n", + mod_id, frame, CC_id, UE_id); + ue_has_transmission = 0; + } + //End of retransmission + } else { /* This is a potentially new SDU opportunity */ + rlc_status.bytes_in_buffer = 0; + // Now check RLC information to compute number of required RBs + // get maximum TBS size for RLC request + //TBS = mac_xface->get_TBS(eNB_UE_stats->DL_cqi[0]<<1,nb_available_rb); + TBS = mac_xface->get_TBS_DL(mcs, nb_available_rb); + dci_tbs = TBS; + + // check first for RLC data on DCCH + // add the length for all the control elements (timing adv, drx, etc) : header + payload + + ta_len = (ue_sched_ctl->ta_update!=0) ? 2 : 0; + + dl_data[num_ues_added]->n_ce_bitmap = 2; + dl_data[num_ues_added]->ce_bitmap = (uint32_t *) malloc(sizeof(uint32_t) * 2); + + if (ta_len > 0) { + ce_flags |= PROTOCOL__FLEX_CE_TYPE__FLPCET_TA; + } + + /*TODO: Add other flags if DRX and other CE are required*/ + + // Add the control element flags to the flexran message + dl_data[num_ues_added]->ce_bitmap[0] = ce_flags; + dl_data[num_ues_added]->ce_bitmap[1] = ce_flags; + + // TODO : Need to prioritize DRBs + // Loop through the UE logical channels (DCCH, DCCH1, DTCH for now) + for (j = 1; j < NB_RB_MAX; j++) { + header_len+=3; + + // Need to see if we have space for data from this channel + if (dci_tbs - ta_len - header_len - sdu_length_total > 0) { + LOG_D(MAC, "[TEST]Requested %d bytes from RLC buffer on channel %d during first call\n", dci_tbs-ta_len-header_len); + //If we have space, we need to see how much data we can request at most (if any available) + rlc_status = mac_rlc_status_ind(mod_id, + rnti, + mod_id, + frame, + ENB_FLAG_YES, + MBMS_FLAG_NO, + j, + (dci_tbs-ta_len-header_len)); // transport block set size + + //If data are available in channel j + if (rlc_status.bytes_in_buffer > 0) { + LOG_D(MAC, "[TEST]Have %d bytes in DCCH buffer during first call\n", rlc_status.bytes_in_buffer); + //Fill in as much as possible + data_to_request = cmin(dci_tbs-ta_len-header_len, rlc_status.bytes_in_buffer); + if (data_to_request < 128) { //The header will be one byte less + header_len--; + } + /* if (j == 1 || j == 2) { + data_to_request+=0; + } */ + LOG_D(MAC, "[TEST]Will request %d from channel %d\n", data_to_request, j); + rlc_pdus[channels_added] = (Protocol__FlexRlcPdu *) malloc(sizeof(Protocol__FlexRlcPdu)); + protocol__flex_rlc_pdu__init(rlc_pdus[channels_added]); + rlc_pdus[channels_added]->n_rlc_pdu_tb = 2; + rlc_pdus[channels_added]->rlc_pdu_tb = (Protocol__FlexRlcPduTb **) malloc(sizeof(Protocol__FlexRlcPduTb *) * 2); + rlc_pdus[channels_added]->rlc_pdu_tb[0] = (Protocol__FlexRlcPduTb *) malloc(sizeof(Protocol__FlexRlcPduTb)); + protocol__flex_rlc_pdu_tb__init(rlc_pdus[channels_added]->rlc_pdu_tb[0]); + rlc_pdus[channels_added]->rlc_pdu_tb[0]->has_logical_channel_id = 1; + rlc_pdus[channels_added]->rlc_pdu_tb[0]->logical_channel_id = j; + rlc_pdus[channels_added]->rlc_pdu_tb[0]->has_size = 1; + rlc_pdus[channels_added]->rlc_pdu_tb[0]->size = data_to_request; + rlc_pdus[channels_added]->rlc_pdu_tb[1] = (Protocol__FlexRlcPduTb *) malloc(sizeof(Protocol__FlexRlcPduTb)); + protocol__flex_rlc_pdu_tb__init(rlc_pdus[channels_added]->rlc_pdu_tb[1]); + rlc_pdus[channels_added]->rlc_pdu_tb[1]->has_logical_channel_id = 1; + rlc_pdus[channels_added]->rlc_pdu_tb[1]->logical_channel_id = j; + rlc_pdus[channels_added]->rlc_pdu_tb[1]->has_size = 1; + rlc_pdus[channels_added]->rlc_pdu_tb[1]->size = data_to_request; + dl_data[num_ues_added]->n_rlc_pdu++; + channels_added++; + //Set this to the max value that we might request + sdu_length_total += data_to_request; + } else { + //Take back the assumption of a header for this channel + header_len -= 3; + } //End rlc_status.bytes_in_buffer <= 0 + } //end of if dci_tbs - ta_len - header_len > 0 + } // End of iterating the logical channels + + // Add rlc_pdus to the dl_data message + dl_data[num_ues_added]->rlc_pdu = (Protocol__FlexRlcPdu **) malloc(sizeof(Protocol__FlexRlcPdu *) * + dl_data[num_ues_added]->n_rlc_pdu); + for (i = 0; i < dl_data[num_ues_added]->n_rlc_pdu; i++) { + dl_data[num_ues_added]->rlc_pdu[i] = rlc_pdus[i]; + } + + // there is a payload + if (( dl_data[num_ues_added]->n_rlc_pdu > 0)) { + // Now compute number of required RBs for total sdu length + // Assume RAH format 2 + // adjust header lengths + + if (header_len == 2 || header_len == 3) { //Only one SDU, remove length field + header_len = 1; + } else { //Remove length field from the last SDU + header_len--; + } + + mcs_tmp = mcs; + if (mcs_tmp == 0) { + nb_rb = 4; // don't let the TBS get too small + } else { + nb_rb=min_rb_unit[CC_id]; + } + + LOG_D(MAC,"[TEST]The initial number of resource blocks was %d\n", nb_rb); + LOG_D(MAC,"[TEST] The initial mcs was %d\n", mcs_tmp); + + TBS = mac_xface->get_TBS_DL(mcs_tmp, nb_rb); + LOG_D(MAC,"[TEST]The TBS during rate matching was %d\n", TBS); + + while (TBS < (sdu_length_total + header_len + ta_len)) { + nb_rb += min_rb_unit[CC_id]; // + LOG_D(MAC, "[TEST]Had to increase the number of RBs\n"); + if (nb_rb > nb_available_rb) { // if we've gone beyond the maximum number of RBs + // (can happen if N_RB_DL is odd) + TBS = mac_xface->get_TBS_DL(mcs_tmp, nb_available_rb); + nb_rb = nb_available_rb; + break; + } + + TBS = mac_xface->get_TBS_DL(mcs_tmp, nb_rb); + } + + if(nb_rb == ue_sched_ctl->pre_nb_available_rbs[CC_id]) { + LOG_D(MAC, "[TEST]We had the exact number of rbs. Time to fill the rballoc subband\n"); + for(j = 0; j < flexran_get_N_RBG(mod_id, CC_id); j++) { // for indicating the rballoc for each sub-band + UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j] = ue_sched_ctl->rballoc_sub_UE[CC_id][j]; + } + } else { + nb_rb_temp = nb_rb; + j = 0; + LOG_D(MAC, "[TEST]Will only partially fill the bitmap\n"); + while((nb_rb_temp > 0) && (j < flexran_get_N_RBG(mod_id, CC_id))) { + if(ue_sched_ctl->rballoc_sub_UE[CC_id][j] == 1) { + UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j] = ue_sched_ctl->rballoc_sub_UE[CC_id][j]; + if ((j == flexran_get_N_RBG(mod_id, CC_id) - 1) && + ((flexran_get_N_RB_DL(mod_id, CC_id) == 25)|| + (flexran_get_N_RB_DL(mod_id, CC_id) == 50))) { + nb_rb_temp = nb_rb_temp - min_rb_unit[CC_id] + 1; + } else { + nb_rb_temp = nb_rb_temp - min_rb_unit[CC_id]; + } + } + j = j+1; + } + } + + PHY_vars_eNB_g[mod_id][CC_id]->mu_mimo_mode[UE_id].pre_nb_available_rbs = nb_rb; + PHY_vars_eNB_g[mod_id][CC_id]->mu_mimo_mode[UE_id].dl_pow_off = ue_sched_ctl->dl_pow_off[CC_id]; + + for(j = 0; j < flexran_get_N_RBG(mod_id, CC_id); j++) { + PHY_vars_eNB_g[mod_id][CC_id]->mu_mimo_mode[UE_id].rballoc_sub[j] = UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][j]; + } + + // decrease mcs until TBS falls below required length + while ((TBS > (sdu_length_total + header_len + ta_len)) && (mcs_tmp > 0)) { + mcs_tmp--; + TBS = mac_xface->get_TBS_DL(mcs_tmp, nb_rb); + } + + // if we have decreased too much or we don't have enough RBs, increase MCS + while ((TBS < (sdu_length_total + header_len + ta_len)) && + ((( ue_sched_ctl->dl_pow_off[CC_id] > 0) && (mcs_tmp < 28)) || ( (ue_sched_ctl->dl_pow_off[CC_id]==0) && (mcs_tmp <= 15)))) { + mcs_tmp++; + TBS = mac_xface->get_TBS_DL(mcs_tmp, nb_rb); + } + + dci_tbs = TBS; + mcs = mcs_tmp; + + aggregation = process_ue_cqi(mod_id,UE_id); + dl_dci->has_aggr_level = 1; + dl_dci->aggr_level = aggregation; + + UE_list->UE_template[CC_id][UE_id].nb_rb[harq_pid] = nb_rb; + + if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { + UE_list->UE_template[CC_id][UE_id].DAI++; + // printf("DAI update: subframeP %d: UE %d, DAI %d\n",subframeP,UE_id,UE_list->UE_template[CC_id][UE_id].DAI); + //#warning only for 5MHz channel + update_ul_dci(mod_id, CC_id, rnti, UE_list->UE_template[CC_id][UE_id].DAI); + } + + // do PUCCH power control + // this is the normalized RX power + normalized_rx_power = flexran_get_p0_pucch_dbm(mod_id,UE_id, CC_id); //eNB_UE_stats->Po_PUCCH_dBm; + target_rx_power = flexran_get_p0_nominal_pucch(mod_id, CC_id) + 10; //mac_xface->get_target_pucch_rx_power(mod_id, CC_id) + 10; + + // this assumes accumulated tpc + // make sure that we are only sending a tpc update once a frame, otherwise the control loop will freak out + int32_t framex10psubframe = UE_list->UE_template[CC_id][UE_id].pucch_tpc_tx_frame*10+UE_list->UE_template[CC_id][UE_id].pucch_tpc_tx_subframe; + + if (((framex10psubframe+10)<=(frame*10+subframe)) || //normal case + ((framex10psubframe>(frame*10+subframe)) && (((10240-framex10psubframe+frame*10+subframe)>=10)))) //frame wrap-around + if (flexran_get_p0_pucch_status(mod_id, UE_id, CC_id) == 1) { + flexran_update_p0_pucch(mod_id, UE_id, CC_id); + + UE_list->UE_template[CC_id][UE_id].pucch_tpc_tx_frame = frame; + UE_list->UE_template[CC_id][UE_id].pucch_tpc_tx_subframe = subframe; + if (normalized_rx_power>(target_rx_power+1)) { + tpc = 0; //-1 + tpc_accumulated--; + } else if (normalized_rx_power<(target_rx_power-1)) { + tpc = 2; //+1 + tpc_accumulated++; + } else { + tpc = 1; //0 + } + LOG_D(MAC,"[eNB %d] DLSCH scheduler: frame %d, subframe %d, harq_pid %d, tpc %d, accumulated %d, normalized/target rx power %d/%d\n", + mod_id, frame, subframe, harq_pid, tpc, + tpc_accumulated, normalized_rx_power, target_rx_power); + } // Po_PUCCH has been updated + else { + tpc = 1; //0 + } // time to do TPC update + else { + tpc = 1; //0 + } - if((rballoc_sub[CC_id][i] == 0) && - (ue_sched_ctl->rballoc_sub_UE[CC_id][i] == 0) && - (nb_rbs_required_remaining[CC_id][UE_id]>0) && - (ue_sched_ctl->pre_nb_available_rbs[CC_id] < nb_rbs_required[CC_id][UE_id])) { + for(i=0; iframe_parms.N_RBG; i++) { + rballoc_sub[i] = UE_list->UE_template[CC_id][UE_id].rballoc_subband[harq_pid][i]; + } - // if this UE is not scheduled for TM5 - if (ue_sched_ctl->dl_pow_off[CC_id] != 0 ) { + // Toggle NDI + LOG_D(MAC,"CC_id %d Frame %d, subframeP %d: Toggling Format1 NDI for UE %d (rnti %x/%d) oldNDI %d\n", + CC_id, frame, subframe, UE_id, + UE_list->UE_template[CC_id][UE_id].rnti,harq_pid, UE_list->UE_template[CC_id][UE_id].oldNDI[harq_pid]); + UE_list->UE_template[CC_id][UE_id].oldNDI[harq_pid]= 1 - UE_list->UE_template[CC_id][UE_id].oldNDI[harq_pid]; + ndi = UE_list->UE_template[CC_id][UE_id].oldNDI[harq_pid]; + + UE_list->UE_template[CC_id][UE_id].mcs[harq_pid] = mcs; + UE_list->UE_template[CC_id][UE_id].oldTPC[harq_pid] = tpc; - if ((i == N_RBG-1) && ((N_RB_DL == 25) || (N_RB_DL == 50))) { - rballoc_sub[CC_id][i] = 1; - ue_sched_ctl->rballoc_sub_UE[CC_id][i] = 1; - MIMO_mode_indicator[CC_id][i] = 1; - if (transmission_mode == 5 ) { + // Increase the pointer for the number of scheduled UEs + num_ues_added++; + ue_has_transmission = 1; + } else { // There is no data from RLC or MAC header, so don't schedule + ue_has_transmission = 0; + } + } // End of new scheduling + + // If we has transmission or retransmission + if (ue_has_transmission) { + switch (mac_xface->get_transmission_mode(mod_id, CC_id, rnti)) { + case 1: + case 2: + default: + dl_dci->has_res_alloc = 1; + dl_dci->res_alloc = 0; + dl_dci->has_vrb_format = 1; + dl_dci->vrb_format = PROTOCOL__FLEX_VRB_FORMAT__FLVRBF_LOCALIZED; + dl_dci->has_format = 1; + dl_dci->format = PROTOCOL__FLEX_DCI_FORMAT__FLDCIF_1; + dl_dci->has_rb_bitmap = 1; + dl_dci->rb_bitmap = allocate_prbs_sub(nb_rb, rballoc_sub); + dl_dci->has_rb_shift = 1; + dl_dci->rb_shift = 0; + dl_dci->n_ndi = 1; + dl_dci->ndi = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_ndi); + dl_dci->ndi[0] = ndi; + dl_dci->n_rv = 1; + dl_dci->rv = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_rv); + dl_dci->rv[0] = round & 3; + dl_dci->has_tpc = 1; + dl_dci->tpc = tpc; + dl_dci->n_mcs = 1; + dl_dci->mcs = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_mcs); + dl_dci->mcs[0] = mcs; + dl_dci->n_tbs_size = 1; + dl_dci->tbs_size = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_tbs_size); + dl_dci->tbs_size[0] = dci_tbs; + if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { + dl_dci->has_dai = 1; + dl_dci->dai = (UE_list->UE_template[CC_id][UE_id].DAI-1)&3; + } + break; + case 3: + dl_dci->has_res_alloc = 1; + dl_dci->res_alloc = 0; + dl_dci->has_vrb_format = 1; + dl_dci->vrb_format = PROTOCOL__FLEX_VRB_FORMAT__FLVRBF_LOCALIZED; + dl_dci->has_format = 1; + dl_dci->format = PROTOCOL__FLEX_DCI_FORMAT__FLDCIF_2A; + dl_dci->has_rb_bitmap = 1; + dl_dci->rb_bitmap = allocate_prbs_sub(nb_rb, rballoc_sub); + dl_dci->has_rb_shift = 1; + dl_dci->rb_shift = 0; + dl_dci->n_ndi = 2; + dl_dci->ndi = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_ndi); + dl_dci->ndi[0] = ndi; + dl_dci->ndi[1] = ndi; + dl_dci->n_rv = 2; + dl_dci->rv = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_rv); + dl_dci->rv[0] = round & 3; + dl_dci->rv[1] = round & 3; + dl_dci->has_tpc = 1; + dl_dci->tpc = tpc; + dl_dci->n_mcs = 2; + dl_dci->mcs = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_mcs); + dl_dci->mcs[0] = mcs; + dl_dci->mcs[1] = mcs; + dl_dci->n_tbs_size = 2; + dl_dci->tbs_size = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_tbs_size); + dl_dci->tbs_size[0] = dci_tbs; + dl_dci->tbs_size[1] = dci_tbs; + if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { + dl_dci->has_dai = 1; + dl_dci->dai = (UE_list->UE_template[CC_id][UE_id].DAI-1)&3; + } + break; + case 4: + dl_dci->has_res_alloc = 1; + dl_dci->res_alloc = 0; + dl_dci->has_vrb_format = 1; + dl_dci->vrb_format = PROTOCOL__FLEX_VRB_FORMAT__FLVRBF_LOCALIZED; + dl_dci->has_format = 1; + dl_dci->format = PROTOCOL__FLEX_DCI_FORMAT__FLDCIF_2A; + dl_dci->has_rb_bitmap = 1; + dl_dci->rb_bitmap = allocate_prbs_sub(nb_rb, rballoc_sub); + dl_dci->has_rb_shift = 1; + dl_dci->rb_shift = 0; + dl_dci->n_ndi = 2; + dl_dci->ndi = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_ndi); + dl_dci->ndi[0] = ndi; + dl_dci->ndi[1] = ndi; + dl_dci->n_rv = 2; + dl_dci->rv = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_rv); + dl_dci->rv[0] = round & 3; + dl_dci->rv[1] = round & 3; + dl_dci->has_tpc = 1; + dl_dci->tpc = tpc; + dl_dci->n_mcs = 2; + dl_dci->mcs = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_mcs); + dl_dci->mcs[0] = mcs; + dl_dci->mcs[1] = mcs; + dl_dci->n_tbs_size = 2; + dl_dci->tbs_size = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_tbs_size); + dl_dci->tbs_size[0] = dci_tbs; + dl_dci->tbs_size[1] = dci_tbs; + if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { + dl_dci->has_dai = 1; + dl_dci->dai = (UE_list->UE_template[CC_id][UE_id].DAI-1)&3; + } + break; + case 5: + dl_dci->has_res_alloc = 1; + dl_dci->res_alloc = 0; + dl_dci->has_vrb_format = 1; + dl_dci->vrb_format = PROTOCOL__FLEX_VRB_FORMAT__FLVRBF_LOCALIZED; + dl_dci->has_format = 1; + dl_dci->format = PROTOCOL__FLEX_DCI_FORMAT__FLDCIF_1D; + dl_dci->has_rb_bitmap = 1; + dl_dci->rb_bitmap = allocate_prbs_sub(nb_rb, rballoc_sub); + dl_dci->has_rb_shift = 1; + dl_dci->rb_shift = 0; + dl_dci->n_ndi = 1; + dl_dci->ndi[0] = ndi; + dl_dci->n_rv = 1; + dl_dci->rv = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_rv); + dl_dci->rv[0] = round & 3; + dl_dci->has_tpc = 1; + dl_dci->tpc = tpc; + dl_dci->n_mcs = 1; + dl_dci->mcs = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_mcs); + dl_dci->mcs[0] = mcs; + dl_dci->n_tbs_size = 1; + dl_dci->tbs_size = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_tbs_size); + dl_dci->tbs_size[0] = dci_tbs; + if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { + dl_dci->has_dai = 1; + dl_dci->dai = (UE_list->UE_template[CC_id][UE_id].DAI-1)&3; + } + + if(ue_sched_ctl->dl_pow_off[CC_id] == 2) { ue_sched_ctl->dl_pow_off[CC_id] = 1; - } - nb_rbs_required_remaining[CC_id][UE_id] = nb_rbs_required_remaining[CC_id][UE_id] - min_rb_unit+1; - ue_sched_ctl->pre_nb_available_rbs[CC_id] = ue_sched_ctl->pre_nb_available_rbs[CC_id] + min_rb_unit - 1; - } else { - if (nb_rbs_required_remaining[CC_id][UE_id] >= min_rb_unit){ - rballoc_sub[CC_id][i] = 1; - ue_sched_ctl->rballoc_sub_UE[CC_id][i] = 1; - MIMO_mode_indicator[CC_id][i] = 1; - if (transmission_mode == 5 ) { - ue_sched_ctl->dl_pow_off[CC_id] = 1; - } - nb_rbs_required_remaining[CC_id][UE_id] = nb_rbs_required_remaining[CC_id][UE_id] - min_rb_unit; - ue_sched_ctl->pre_nb_available_rbs[CC_id] = ue_sched_ctl->pre_nb_available_rbs[CC_id] + min_rb_unit; } + + dl_dci->has_dl_power_offset = 1; + dl_dci->dl_power_offset = ue_sched_ctl->dl_pow_off[CC_id]; + dl_dci->has_precoding_info = 1; + dl_dci->precoding_info = 5; // Is this right?? + + break; + case 6: + dl_dci->has_res_alloc = 1; + dl_dci->res_alloc = 0; + dl_dci->has_vrb_format = 1; + dl_dci->vrb_format = PROTOCOL__FLEX_VRB_FORMAT__FLVRBF_LOCALIZED; + dl_dci->has_format = 1; + dl_dci->format = PROTOCOL__FLEX_DCI_FORMAT__FLDCIF_1D; + dl_dci->has_rb_bitmap = 1; + dl_dci->rb_bitmap = allocate_prbs_sub(nb_rb, rballoc_sub); + dl_dci->has_rb_shift = 1; + dl_dci->rb_shift = 0; + dl_dci->n_ndi = 1; + dl_dci->ndi = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_ndi); + dl_dci->ndi[0] = ndi; + dl_dci->n_rv = 1; + dl_dci->rv = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_rv); + dl_dci->rv[0] = round & 3; + dl_dci->has_tpc = 1; + dl_dci->tpc = tpc; + dl_dci->n_mcs = 1; + dl_dci->mcs = (uint32_t *) malloc(sizeof(uint32_t) * dl_dci->n_mcs); + dl_dci->mcs[0] = mcs; + if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { + dl_dci->has_dai = 1; + dl_dci->dai = (UE_list->UE_template[CC_id][UE_id].DAI-1)&3; + } + + dl_dci->has_dl_power_offset = 1; + dl_dci->dl_power_offset = ue_sched_ctl->dl_pow_off[CC_id]; + dl_dci->has_precoding_info = 1; + dl_dci->precoding_info = 5; // Is this right?? + break; } - } // dl_pow_off[CC_id][UE_id] ! = 0 - } - } + } + + if (flexran_get_duplex_mode(mod_id, CC_id) == PROTOCOL__FLEX_DUPLEX_MODE__FLDM_TDD) { + + /* TODO */ + //set_ul_DAI(mod_id, UE_id, CC_id, frame, subframe, frame_parms); + } + } // UE_id loop + } // CC_id loop + + // Add all the dl_data elements to the flexran message + int offset = (*dl_info)->dl_mac_config_msg->n_dl_ue_data; + (*dl_info)->dl_mac_config_msg->n_dl_ue_data += num_ues_added; + if ( num_ues_added > 0 ){ + (*dl_info)->dl_mac_config_msg->dl_ue_data = (Protocol__FlexDlData **) realloc( (*dl_info)->dl_mac_config_msg->dl_ue_data, + sizeof(Protocol__FlexDlData *) * ((*dl_info)->dl_mac_config_msg->n_dl_ue_data)); + if ((*dl_info)->dl_mac_config_msg->dl_ue_data == NULL ){ + LOG_E(MAC, "Request for memory reallocation failed\n"); + return; + } + for (i = 0; i < num_ues_added; i++) { + (*dl_info)->dl_mac_config_msg->dl_ue_data[offset+i] = dl_data[i]; + } + } + + stop_meas(&eNB->schedule_dlsch); + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_SCHEDULE_DLSCH,VCD_FUNCTION_OUT); } diff --git a/openair2/LAYER2/MAC/main.c b/openair2/LAYER2/MAC/main.c index 203bd3f36f8a9e24b75bce6627a33bc9ac63f436..d812ec0087a892f0144e11c2172f79f83eecce2d 100644 --- a/openair2/LAYER2/MAC/main.c +++ b/openair2/LAYER2/MAC/main.c @@ -127,11 +127,11 @@ int mac_top_init(int eMBMS_active, char *uecap_xer, uint8_t cba_group_active, ui UE_mac_inst = (UE_MAC_INST*)malloc16(NB_UE_INST*sizeof(UE_MAC_INST)); if (UE_mac_inst == NULL) { - LOG_C(MAC,"[MAIN] Can't ALLOCATE %d Bytes for %d UE_MAC_INST with size %d \n",NB_UE_INST*sizeof(UE_MAC_INST),NB_UE_INST,sizeof(UE_MAC_INST)); + LOG_C(MAC,"[MAIN] Can't ALLOCATE %zu Bytes for %d UE_MAC_INST with size %zu \n",NB_UE_INST*sizeof(UE_MAC_INST),NB_UE_INST,sizeof(UE_MAC_INST)); mac_xface->macphy_exit("[MAC][MAIN] not enough memory for UEs \n"); } - LOG_D(MAC,"[MAIN] ALLOCATE %d Bytes for %d UE_MAC_INST @ %p\n",NB_UE_INST*sizeof(UE_MAC_INST),NB_UE_INST,UE_mac_inst); + LOG_D(MAC,"[MAIN] ALLOCATE %zu Bytes for %d UE_MAC_INST @ %p\n",NB_UE_INST*sizeof(UE_MAC_INST),NB_UE_INST,UE_mac_inst); bzero(UE_mac_inst,NB_UE_INST*sizeof(UE_MAC_INST)); @@ -148,10 +148,10 @@ int mac_top_init(int eMBMS_active, char *uecap_xer, uint8_t cba_group_active, ui eNB_mac_inst = (eNB_MAC_INST*)malloc16(NB_eNB_INST*sizeof(eNB_MAC_INST)); if (eNB_mac_inst == NULL) { - LOG_D(MAC,"[MAIN] can't ALLOCATE %d Bytes for %d eNB_MAC_INST with size %d \n",NB_eNB_INST*sizeof(eNB_MAC_INST*),NB_eNB_INST,sizeof(eNB_MAC_INST)); + LOG_D(MAC,"[MAIN] can't ALLOCATE %zu Bytes for %d eNB_MAC_INST with size %zu \n",NB_eNB_INST*sizeof(eNB_MAC_INST*),NB_eNB_INST,sizeof(eNB_MAC_INST)); mac_xface->macphy_exit("[MAC][MAIN] not enough memory for eNB \n"); } else { - LOG_D(MAC,"[MAIN] ALLOCATE %d Bytes for %d eNB_MAC_INST @ %p\n",sizeof(eNB_MAC_INST),NB_eNB_INST,eNB_mac_inst); + LOG_D(MAC,"[MAIN] ALLOCATE %zu Bytes for %d eNB_MAC_INST @ %p\n",sizeof(eNB_MAC_INST),NB_eNB_INST,eNB_mac_inst); bzero(eNB_mac_inst,NB_eNB_INST*sizeof(eNB_MAC_INST)); } } else { diff --git a/openair2/LAYER2/MAC/pre_processor.c b/openair2/LAYER2/MAC/pre_processor.c index ed12d322c10d43a7a1cd7eb3b34288b401fdf979..e7bfb348ee7879efa59ad2193c7a3019db86ff74 100644 --- a/openair2/LAYER2/MAC/pre_processor.c +++ b/openair2/LAYER2/MAC/pre_processor.c @@ -29,6 +29,9 @@ */ +#define _GNU_SOURCE +#include + #include "assertions.h" #include "PHY/defs.h" #include "PHY/extern.h" @@ -62,6 +65,17 @@ #endif */ +/* this function checks that get_eNB_UE_stats returns + * a non-NULL pointer for all CCs for a given UE + */ +static int phy_stats_exist(module_id_t Mod_id, int rnti) +{ + int CC_id; + for (CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++) + if (mac_xface->get_eNB_UE_stats(Mod_id, CC_id, rnti) == NULL) + return 0; + return 1; +} // This function stores the downlink buffer for all the logical channels void store_dlsch_buffer (module_id_t Mod_id, @@ -75,7 +89,8 @@ void store_dlsch_buffer (module_id_t Mod_id, UE_list_t *UE_list = &eNB_mac_inst[Mod_id].UE_list; UE_TEMPLATE *UE_template; - for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id]) { + for (UE_id = 0; UE_id < NUMBER_OF_UE_MAX; UE_id++) { + if (UE_list->active[UE_id] != TRUE) continue; UE_template = &UE_list->UE_template[UE_PCCID(Mod_id,UE_id)][UE_id]; @@ -155,10 +170,16 @@ void assign_rbs_required (module_id_t Mod_id, LTE_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]; // clear rb allocations across all CC_ids - for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id]) { + for (UE_id = 0; UE_id < NUMBER_OF_UE_MAX; UE_id++) { + if (UE_list->active[UE_id] != TRUE) continue; + pCCid = UE_PCCID(Mod_id,UE_id); rnti = UE_list->UE_template[pCCid][UE_id].rnti; + /* skip UE not present in PHY (for any of its active CCs) */ + if (!phy_stats_exist(Mod_id, rnti)) + continue; + //update CQI information across component carriers for (n=0; nnumactiveCCs[UE_id]; n++) { @@ -262,7 +283,7 @@ int maxround(module_id_t Mod_id,uint16_t rnti,int frame,sub_frame_t subframe,uin } // This function scans all CC_ids for a particular UE to find the maximum DL CQI - +// it returns -1 if the UE is not found in PHY layer (get_eNB_UE_stats gives NULL) int maxcqi(module_id_t Mod_id,int32_t UE_id) { @@ -276,8 +297,9 @@ int maxcqi(module_id_t Mod_id,int32_t UE_id) eNB_UE_stats = mac_xface->get_eNB_UE_stats(Mod_id,CC_id,UE_RNTI(Mod_id,UE_id)); if (eNB_UE_stats==NULL) { - mac_xface->macphy_exit("maxcqi: could not get eNB_UE_stats\n"); - return 0; // not reached + /* the UE may have been removed in the PHY layer, don't exit */ + //mac_xface->macphy_exit("maxcqi: could not get eNB_UE_stats\n"); + return -1; } if (eNB_UE_stats->DL_cqi[0] > CQI) { @@ -288,13 +310,124 @@ int maxcqi(module_id_t Mod_id,int32_t UE_id) return(CQI); } +struct sort_ue_dl_params { + int Mod_idP; + int frameP; + int subframeP; +}; +static int ue_dl_compare(const void *_a, const void *_b, void *_params) +{ + struct sort_ue_dl_params *params = _params; + UE_list_t *UE_list = &eNB_mac_inst[params->Mod_idP].UE_list; + + int UE_id1 = *(const int *)_a; + int UE_id2 = *(const int *)_b; + + int rnti1 = UE_RNTI(params->Mod_idP, UE_id1); + int pCC_id1 = UE_PCCID(params->Mod_idP, UE_id1); + int round1 = maxround(params->Mod_idP, rnti1, params->frameP, params->subframeP, 1); + + int rnti2 = UE_RNTI(params->Mod_idP, UE_id2); + int pCC_id2 = UE_PCCID(params->Mod_idP, UE_id2); + int round2 = maxround(params->Mod_idP, rnti2, params->frameP, params->subframeP, 1); + + int cqi1 = maxcqi(params->Mod_idP, UE_id1); + int cqi2 = maxcqi(params->Mod_idP, UE_id2); + + if (round1 > round2) return -1; + if (round1 < round2) return 1; + + if (UE_list->UE_template[pCC_id1][UE_id1].dl_buffer_info[1] + UE_list->UE_template[pCC_id1][UE_id1].dl_buffer_info[2] > + UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_info[1] + UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_info[2]) + return -1; + if (UE_list->UE_template[pCC_id1][UE_id1].dl_buffer_info[1] + UE_list->UE_template[pCC_id1][UE_id1].dl_buffer_info[2] < + UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_info[1] + UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_info[2]) + return 1; + + if (UE_list->UE_template[pCC_id1][UE_id1].dl_buffer_head_sdu_creation_time_max > + UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_head_sdu_creation_time_max) + return -1; + if (UE_list->UE_template[pCC_id1][UE_id1].dl_buffer_head_sdu_creation_time_max < + UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_head_sdu_creation_time_max) + return 1; + + if (UE_list->UE_template[pCC_id1][UE_id1].dl_buffer_total > + UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_total) + return -1; + if (UE_list->UE_template[pCC_id1][UE_id1].dl_buffer_total < + UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_total) + return 1; + + if (cqi1 > cqi2) return -1; + if (cqi1 < cqi2) return 1; + + return 0; +#if 0 + /* The above order derives from the following. */ + if(round2 > round1) { // Check first if one of the UEs has an active HARQ process which needs service and swap order + swap_UEs(UE_list,UE_id1,UE_id2,0); + } else if (round2 == round1) { + // RK->NN : I guess this is for fairness in the scheduling. This doesn't make sense unless all UEs have the same configuration of logical channels. This should be done on the sum of all information that has to be sent. And still it wouldn't ensure fairness. It should be based on throughput seen by each UE or maybe using the head_sdu_creation_time, i.e. swap UEs if one is waiting longer for service. + // for(j=0;jUE_template[pCC_id1][UE_id1].dl_buffer_info[1] + UE_list->UE_template[pCC_id1][UE_id1].dl_buffer_info[2]) < + (UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_info[1] + UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_info[2]) ) { + swap_UEs(UE_list,UE_id1,UE_id2,0); + } else if (UE_list->UE_template[pCC_id1][UE_id1].dl_buffer_head_sdu_creation_time_max < + UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_head_sdu_creation_time_max ) { + swap_UEs(UE_list,UE_id1,UE_id2,0); + } else if (UE_list->UE_template[pCC_id1][UE_id1].dl_buffer_total < + UE_list->UE_template[pCC_id2][UE_id2].dl_buffer_total ) { + swap_UEs(UE_list,UE_id1,UE_id2,0); + } else if (cqi1 < cqi2) { + swap_UEs(UE_list,UE_id1,UE_id2,0); + } + } +#endif +} // This fuction sorts the UE in order their dlsch buffer and CQI void sort_UEs (module_id_t Mod_idP, int frameP, sub_frame_t subframeP) { + int i; + int list[NUMBER_OF_UE_MAX]; + int list_size = 0; + int rnti; + struct sort_ue_dl_params params = { Mod_idP, frameP, subframeP }; + + UE_list_t *UE_list = &eNB_mac_inst[Mod_idP].UE_list; + + for (i = 0; i < NUMBER_OF_UE_MAX; i++) { + rnti = UE_RNTI(Mod_idP, i); + if (rnti == NOT_A_RNTI) + continue; + if (UE_list->UE_sched_ctrl[i].ul_out_of_sync == 1) + continue; + if (!phy_stats_exist(Mod_idP, rnti)) + continue; + list[list_size] = i; + list_size++; + } + + qsort_r(list, list_size, sizeof(int), ue_dl_compare, ¶ms); + + if (list_size) { + for (i = 0; i < list_size-1; i++) + UE_list->next[list[i]] = list[i+1]; + UE_list->next[list[list_size-1]] = -1; + UE_list->head = list[0]; + } else { + UE_list->head = -1; + } + +#if 0 int UE_id1,UE_id2; @@ -315,6 +448,8 @@ void sort_UEs (module_id_t Mod_idP, continue; if (UE_list->UE_sched_ctrl[UE_id1].ul_out_of_sync == 1) continue; + if (!phy_stats_exist(Mod_idP, rnti1)) + continue; pCC_id1 = UE_PCCID(Mod_idP,UE_id1); cqi1 = maxcqi(Mod_idP,UE_id1); // round1 = maxround(Mod_idP,rnti1,frameP,subframeP,0); @@ -325,6 +460,8 @@ void sort_UEs (module_id_t Mod_idP, continue; if (UE_list->UE_sched_ctrl[UE_id2].ul_out_of_sync == 1) continue; + if (!phy_stats_exist(Mod_idP, rnti2)) + continue; cqi2 = maxcqi(Mod_idP,UE_id2); round2 = maxround(Mod_idP,rnti2,frameP,subframeP,0); //mac_xface->get_ue_active_harq_pid(Mod_id,rnti2,subframe,&harq_pid2,&round2,0); pCC_id2 = UE_PCCID(Mod_idP,UE_id2); @@ -354,6 +491,7 @@ void sort_UEs (module_id_t Mod_idP, } } } +#endif } @@ -407,7 +545,9 @@ void dlsch_scheduler_pre_processor (module_id_t Mod_id, min_rb_unit[CC_id]=get_min_rb_unit(Mod_id,CC_id); - for (i=UE_list->head; i>=0; i=UE_list->next[i]) { + for (i = 0; i < NUMBER_OF_UE_MAX; i++) { + if (UE_list->active[i] != TRUE) continue; + UE_id = i; // Initialize scheduling information for all active UEs @@ -453,11 +593,9 @@ void dlsch_scheduler_pre_processor (module_id_t Mod_id, continue; if (UE_list->UE_sched_ctrl[i].ul_out_of_sync == 1) continue; - UE_id = i; - - // if there is no available harq_process, skip the UE - if (UE_list->UE_sched_ctrl[UE_id].harq_pid[CC_id]<0) + if (!phy_stats_exist(Mod_id, rnti)) continue; + UE_id = i; for (ii=0; iiordered_CCids[ii][UE_id]; @@ -465,6 +603,10 @@ void dlsch_scheduler_pre_processor (module_id_t Mod_id, harq_pid = ue_sched_ctl->harq_pid[CC_id]; round = ue_sched_ctl->round[CC_id]; + // if there is no available harq_process, skip the UE + if (UE_list->UE_sched_ctrl[UE_id].harq_pid[CC_id]<0) + continue; + average_rbs_per_user[CC_id]=0; frame_parms[CC_id] = mac_xface->get_lte_frame_parms(Mod_id,CC_id); @@ -506,6 +648,13 @@ void dlsch_scheduler_pre_processor (module_id_t Mod_id, for(i=UE_list->head; i>=0; i=UE_list->next[i]) { rnti = UE_RNTI(Mod_id,i); + if(rnti == NOT_A_RNTI) + continue; + if (UE_list->UE_sched_ctrl[i].ul_out_of_sync == 1) + continue; + if (!phy_stats_exist(Mod_id, rnti)) + continue; + for (ii=0; iiordered_CCids[ii][i]; @@ -564,6 +713,8 @@ void dlsch_scheduler_pre_processor (module_id_t Mod_id, continue; if (UE_list->UE_sched_ctrl[UE_id].ul_out_of_sync == 1) continue; + if (!phy_stats_exist(Mod_id, rnti)) + continue; transmission_mode = mac_xface->get_transmission_mode(Mod_id,CC_id,rnti); // mac_xface->get_ue_active_harq_pid(Mod_id,CC_id,rnti,frameP,subframeP,&harq_pid,&round,0); @@ -610,6 +761,8 @@ void dlsch_scheduler_pre_processor (module_id_t Mod_id, continue; if (UE_list->UE_sched_ctrl[UE_id2].ul_out_of_sync == 1) continue; + if (!phy_stats_exist(Mod_idP, rnti2)) + continue; eNB_UE_stats2 = mac_xface->get_eNB_UE_stats(Mod_id,CC_id,rnti2); //mac_xface->get_ue_active_harq_pid(Mod_id,CC_id,rnti2,frameP,subframeP,&harq_pid2,&round2,0); @@ -758,7 +911,13 @@ void dlsch_scheduler_pre_processor_reset (int module_idP, int sf05_upper=-1,sf05_lower=-1; #endif LTE_eNB_UE_stats *eNB_UE_stats = mac_xface->get_eNB_UE_stats(module_idP,CC_id,rnti); + if (eNB_UE_stats == NULL) return; + // initialize harq_pid and round + + if (eNB_UE_stats == NULL) + return; + mac_xface->get_ue_active_harq_pid(module_idP,CC_id,rnti, frameP,subframeP, &ue_sched_ctl->harq_pid[CC_id], @@ -791,7 +950,10 @@ void dlsch_scheduler_pre_processor_reset (int module_idP, break; case 100: - ue_sched_ctl->ta_update = eNB_UE_stats->timing_advance_update/16; + if (PHY_vars_eNB_g[module_idP][CC_id]->frame_parms.threequarter_fs == 0) + ue_sched_ctl->ta_update = eNB_UE_stats->timing_advance_update/16; + else + ue_sched_ctl->ta_update = eNB_UE_stats->timing_advance_update/12; break; } // clear the update in case PHY does not have a new measurement after timer expiry @@ -971,6 +1133,9 @@ void ulsch_scheduler_pre_processor(module_id_t module_idP, if (UE_list->UE_sched_ctrl[i].ul_out_of_sync == 1) continue; + if (!phy_stats_exist(module_idP, rnti)) + continue; + UE_id = i; for (n=0; nnumactiveULCCs[UE_id]; n++) { @@ -1021,6 +1186,8 @@ void ulsch_scheduler_pre_processor(module_id_t module_idP, continue; if (UE_list->UE_sched_ctrl[i].ul_out_of_sync == 1) continue; + if (!phy_stats_exist(module_idP, rnti)) + continue; UE_id = i; @@ -1051,6 +1218,8 @@ void ulsch_scheduler_pre_processor(module_id_t module_idP, continue; if (UE_list->UE_sched_ctrl[i].ul_out_of_sync == 1) continue; + if (!phy_stats_exist(module_idP, rnti)) + continue; UE_id = i; @@ -1108,7 +1277,8 @@ void assign_max_mcs_min_rb(module_id_t module_idP,int frameP, sub_frame_t subfra LTE_DL_FRAME_PARMS *frame_parms; - for (i=UE_list->head_ul; i>=0; i=UE_list->next_ul[i]) { + for (i = 0; i < NUMBER_OF_UE_MAX; i++) { + if (UE_list->active[i] != TRUE) continue; rnti = UE_RNTI(module_idP,i); @@ -1116,6 +1286,8 @@ void assign_max_mcs_min_rb(module_id_t module_idP,int frameP, sub_frame_t subfra continue; if (UE_list->UE_sched_ctrl[i].ul_out_of_sync == 1) continue; + if (!phy_stats_exist(module_idP, rnti)) + continue; if (UE_list->UE_sched_ctrl[i].phr_received == 1) mcs = 20; // if we've received the power headroom information the UE, we can go to maximum mcs @@ -1199,10 +1371,103 @@ void assign_max_mcs_min_rb(module_id_t module_idP,int frameP, sub_frame_t subfra } } +struct sort_ue_ul_params { + int module_idP; + int frameP; + int subframeP; +}; + +static int ue_ul_compare(const void *_a, const void *_b, void *_params) +{ + struct sort_ue_ul_params *params = _params; + UE_list_t *UE_list = &eNB_mac_inst[params->module_idP].UE_list; + + int UE_id1 = *(const int *)_a; + int UE_id2 = *(const int *)_b; + + int rnti1 = UE_RNTI(params->module_idP, UE_id1); + int pCCid1 = UE_PCCID(params->module_idP, UE_id1); + int round1 = maxround(params->module_idP, rnti1, params->frameP, params->subframeP, 1); + + int rnti2 = UE_RNTI(params->module_idP, UE_id2); + int pCCid2 = UE_PCCID(params->module_idP, UE_id2); + int round2 = maxround(params->module_idP, rnti2, params->frameP, params->subframeP, 1); + + if (round1 > round2) return -1; + if (round1 < round2) return 1; + + if (UE_list->UE_template[pCCid1][UE_id1].ul_buffer_info[LCGID0] > UE_list->UE_template[pCCid2][UE_id2].ul_buffer_info[LCGID0]) + return -1; + if (UE_list->UE_template[pCCid1][UE_id1].ul_buffer_info[LCGID0] < UE_list->UE_template[pCCid2][UE_id2].ul_buffer_info[LCGID0]) + return 1; + + if (UE_list->UE_template[pCCid1][UE_id1].ul_total_buffer > UE_list->UE_template[pCCid2][UE_id2].ul_total_buffer) + return -1; + if (UE_list->UE_template[pCCid1][UE_id1].ul_total_buffer < UE_list->UE_template[pCCid2][UE_id2].ul_total_buffer) + return 1; + + if (UE_list->UE_template[pCCid1][UE_id1].pre_assigned_mcs_ul > UE_list->UE_template[pCCid2][UE_id2].pre_assigned_mcs_ul) + return -1; + if (UE_list->UE_template[pCCid1][UE_id1].pre_assigned_mcs_ul < UE_list->UE_template[pCCid2][UE_id2].pre_assigned_mcs_ul) + return 1; + + return 0; + +#if 0 + /* The above order derives from the following. + * The last case is not handled: "if (UE_list->UE_template[pCCid2][UE_id2].ul_total_buffer > 0 )" + * I don't think it makes a big difference. + */ + if(round2 > round1) { + swap_UEs(UE_list,UE_id1,UE_id2,1); + } else if (round2 == round1) { + if (UE_list->UE_template[pCCid1][UE_id1].ul_buffer_info[LCGID0] < UE_list->UE_template[pCCid2][UE_id2].ul_buffer_info[LCGID0]) { + swap_UEs(UE_list,UE_id1,UE_id2,1); + } else if (UE_list->UE_template[pCCid1][UE_id1].ul_total_buffer < UE_list->UE_template[pCCid2][UE_id2].ul_total_buffer) { + swap_UEs(UE_list,UE_id1,UE_id2,1); + } else if (UE_list->UE_template[pCCid1][UE_id1].pre_assigned_mcs_ul < UE_list->UE_template[pCCid2][UE_id2].pre_assigned_mcs_ul) { + if (UE_list->UE_template[pCCid2][UE_id2].ul_total_buffer > 0 ) { + swap_UEs(UE_list,UE_id1,UE_id2,1); + } + } + } +#endif +} void sort_ue_ul (module_id_t module_idP,int frameP, sub_frame_t subframeP) { + int i; + int list[NUMBER_OF_UE_MAX]; + int list_size = 0; + int rnti; + struct sort_ue_ul_params params = { module_idP, frameP, subframeP }; + UE_list_t *UE_list = &eNB_mac_inst[module_idP].UE_list; + + for (i = 0; i < NUMBER_OF_UE_MAX; i++) { + rnti = UE_RNTI(module_idP, i); + if (rnti == NOT_A_RNTI) + continue; + if (UE_list->UE_sched_ctrl[i].ul_out_of_sync == 1) + continue; + if (!phy_stats_exist(module_idP, rnti)) + continue; + list[list_size] = i; + list_size++; + } + + qsort_r(list, list_size, sizeof(int), ue_ul_compare, ¶ms); + + if (list_size) { + for (i = 0; i < list_size-1; i++) + UE_list->next_ul[list[i]] = list[i+1]; + UE_list->next_ul[list[list_size-1]] = -1; + UE_list->head_ul = list[0]; + } else { + UE_list->head_ul = -1; + } + +#if 0 int UE_id1,UE_id2; int pCCid1,pCCid2; int round1,round2; @@ -1224,6 +1489,8 @@ void sort_ue_ul (module_id_t module_idP,int frameP, sub_frame_t subframeP) continue; if (UE_list->UE_sched_ctrl[i].ul_out_of_sync == 1) continue; + if (!phy_stats_exist(module_idP, rnti1)) + continue; pCCid1 = UE_PCCID(module_idP,UE_id1); round1 = maxround(module_idP,rnti1,frameP,subframeP,1); @@ -1235,6 +1502,8 @@ void sort_ue_ul (module_id_t module_idP,int frameP, sub_frame_t subframeP) continue; if (UE_list->UE_sched_ctrl[UE_id2].ul_out_of_sync == 1) continue; + if (!phy_stats_exist(module_idP, rnti2)) + continue; pCCid2 = UE_PCCID(module_idP,UE_id2); round2 = maxround(module_idP,rnti2,frameP,subframeP,1); @@ -1254,4 +1523,5 @@ void sort_ue_ul (module_id_t module_idP,int frameP, sub_frame_t subframeP) } } } +#endif } diff --git a/openair2/LAYER2/MAC/proto.h b/openair2/LAYER2/MAC/proto.h index 9454f3da802d2a1d04b5054caf65e3d4522cb67d..5da2367cefa11c66c32aa45d13da8e902a132afb 100644 --- a/openair2/LAYER2/MAC/proto.h +++ b/openair2/LAYER2/MAC/proto.h @@ -402,7 +402,7 @@ void ue_decode_si(module_id_t module_idP, int CC_id,frame_t frame, uint8_t CH_in 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); +void ue_send_sdu(module_id_t module_idP, uint8_t CC_id,frame_t frame, sub_frame_t subframe, uint8_t *sdu,uint16_t sdu_len,uint8_t CH_index); #ifdef Rel10 diff --git a/openair2/LAYER2/MAC/ue_procedures.c b/openair2/LAYER2/MAC/ue_procedures.c index cdac22c486a283af5514f9f55883c9c2fa3466de..6d304051d4c06c59a0de7dbbdca623e3d1b841c8 100644 --- a/openair2/LAYER2/MAC/ue_procedures.c +++ b/openair2/LAYER2/MAC/ue_procedures.c @@ -189,7 +189,7 @@ unsigned char *parse_header(unsigned char *mac_header, } #ifdef DEBUG_HEADER_PARSING - LOG_D(MAC,"[UE] sdu %d lcid %d length %d (offset now %d)\n", + LOG_D(MAC,"[UE] sdu %d lcid %d length %d (offset now %ld)\n", num_sdus,lcid,length,mac_header_ptr-mac_header); #endif rx_lcids[num_sdus] = lcid; @@ -229,7 +229,7 @@ unsigned char *parse_header(unsigned char *mac_header, } #ifdef DEBUG_HEADER_PARSING - LOG_D(MAC,"[UE] ce %d lcid %d (offset now %d)\n",num_ces,lcid,mac_header_ptr-mac_header); + LOG_D(MAC,"[UE] ce %d lcid %d (offset now %ld)\n",num_ces,lcid,mac_header_ptr-mac_header); #endif } } @@ -333,6 +333,7 @@ ue_send_sdu( module_id_t module_idP, uint8_t CC_id, frame_t frameP, + sub_frame_t subframeP, uint8_t* sdu, uint16_t sdu_len, uint8_t eNB_index @@ -365,7 +366,7 @@ ue_send_sdu( #endif #if defined(ENABLE_MAC_PAYLOAD_DEBUG) - LOG_T(MAC,"[eNB %d] First 32 bytes of DLSCH : \n"); + LOG_T(MAC,"[UE %d] First 32 bytes of DLSCH : \n", module_idP); for (i=0; i<32; i++) { LOG_T(MAC,"%x.",sdu[i]); @@ -385,7 +386,7 @@ ue_send_sdu( module_idP,frameP,payload_ptr[0],payload_ptr[1],payload_ptr[2],payload_ptr[3],payload_ptr[4],payload_ptr[5]); if (UE_mac_inst[module_idP].RA_active == 1) { - LOG_I(MAC,"[UE %d][RAPROC] Frame %d : Clearing RA_active flag\n"); + LOG_I(MAC,"[UE %d][RAPROC] Frame %d : Clearing RA_active flag\n", module_idP, frameP); UE_mac_inst[module_idP].RA_active=0; // check if RA procedure has finished completely (no contention) tx_sdu = &UE_mac_inst[module_idP].CCCH_pdu.payload[3]; @@ -401,7 +402,7 @@ ue_send_sdu( return; } - LOG_I(MAC,"[UE %d][RAPROC] Frame %d : Clearing contention resolution timer\n"); + LOG_I(MAC,"[UE %d][RAPROC] Frame %d : Clearing contention resolution timer\n", module_idP, frameP); UE_mac_inst[module_idP].RA_contention_resolution_timer_active = 0; mac_xface->ra_succeeded(module_idP,CC_id,eNB_index); } @@ -451,7 +452,7 @@ ue_send_sdu( #endif mac_rrc_data_ind(module_idP, CC_id, - frameP,0, // unknown subframe + frameP,subframeP, UE_mac_inst[module_idP].crnti, CCCH, (uint8_t*)payload_ptr, @@ -741,7 +742,7 @@ int ue_query_mch(module_id_t module_idP, uint8_t CC_id, uint32_t frameP, uint32_ mcch_period = 32<<(UE_mac_inst[module_idP].mbsfn_AreaInfo[0]->mcch_Config_r9.mcch_RepetitionPeriod_r9); LOG_D(MAC, - "[UE %d] Frame %d subframe %d: Checking MBSFN Sync Area %d/%d with SF allocation %d/%d for MCCH and MTCH (mbsfn period %d, mcch period %d,mac sched period (%d,%d))\n", + "[UE %d] Frame %d subframe %d: Checking MBSFN Sync Area %d/%d with SF allocation %d/%d for MCCH and MTCH (mbsfn period %d, mcch period %d,mac sched period (%d,%ld))\n", module_idP,frameP, subframe,i,UE_mac_inst[module_idP].num_active_mbsfn_area, j,UE_mac_inst[module_idP].num_sf_allocation_pattern,mbsfn_period,mcch_period, mch_scheduling_period,UE_mac_inst[module_idP].mbsfn_SubframeConfig[j]->radioframeAllocationOffset); @@ -1053,7 +1054,7 @@ unsigned char generate_ulsch_header(uint8_t *mac_header, last_size=1; *((POWER_HEADROOM_CMD *)ce_ptr)=(*power_headroom); ce_ptr+=sizeof(POWER_HEADROOM_CMD); - LOG_D(MAC, "phr header size %d\n",sizeof(POWER_HEADROOM_CMD)); + LOG_D(MAC, "phr header size %zu\n",sizeof(POWER_HEADROOM_CMD)); } if (crnti) { @@ -1249,7 +1250,7 @@ unsigned char generate_ulsch_header(uint8_t *mac_header, } #ifdef DEBUG_HEADER_PARSING - LOG_T(MAC," [UE %d] header : ", crnti); + LOG_T(MAC," [UE] header : "); for (i=0; i<((unsigned char*)mac_header_ptr - mac_header); i++) { LOG_T(MAC,"%2x.",mac_header[i]); @@ -1886,8 +1887,7 @@ if (UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] == LCID_NOT_EMPTY) ulsch_buffer[payload_offset+sdu_length_total+j] = (char)(taus()&0xff); } } - LOG_D(MAC,"[UE %d][SR] Gave SDU to PHY, clearing any scheduling request\n", - module_idP,payload_offset, sdu_length_total); + LOG_D(MAC,"[UE %d][SR] Gave SDU to PHY, clearing any scheduling request\n", module_idP); UE_mac_inst[module_idP].scheduling_info.SR_pending=0; UE_mac_inst[module_idP].scheduling_info.SR_COUNTER=0; @@ -1900,7 +1900,7 @@ if (UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] == LCID_NOT_EMPTY) // Reset ReTx BSR Timer UE_mac_inst[module_idP].scheduling_info.retxBSR_SF = get_sf_retxBSRTimer(UE_mac_inst[module_idP].scheduling_info.retxBSR_Timer); - LOG_D(MAC,"[UE %d] MAC ReTx BSR Timer Reset =%d\n", + LOG_D(MAC,"[UE %d] MAC ReTx BSR Timer Reset =%d\n", module_idP, UE_mac_inst[module_idP].scheduling_info.retxBSR_SF); // Reset Periodic Timer except when BSR is truncated @@ -1909,7 +1909,7 @@ if (UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] == LCID_NOT_EMPTY) UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF = get_sf_periodicBSRTimer(UE_mac_inst[module_idP].scheduling_info.periodicBSR_Timer); LOG_D(MAC,"[UE %d] MAC Periodic BSR Timer Reset =%d\n", - UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF); + module_idP, UE_mac_inst[module_idP].scheduling_info.periodicBSR_SF); } @@ -1922,7 +1922,7 @@ if (UE_mac_inst[module_idP].scheduling_info.LCID_status[lcid] == LCID_NOT_EMPTY) if (opt_enabled) { trace_pdu(0, ulsch_buffer, buflen, module_idP, 3, UE_mac_inst[module_idP].crnti, UE_mac_inst[module_idP].txFrame, UE_mac_inst[module_idP].txSubframe, 0, 0); - LOG_D(OPT,"[UE %d][ULSCH] Frame %d trace pdu for rnti %x with size %d\n", + LOG_D(OPT,"[UE %d][ULSCH] Frame %d subframe %d trace pdu for rnti %x with size %d\n", module_idP, UE_mac_inst[module_idP].txFrame, UE_mac_inst[module_idP].txSubframe, UE_mac_inst[module_idP].crnti, buflen); } } @@ -2064,7 +2064,7 @@ ue_scheduler( //return(RRC_OK); } - LOG_I(MAC,"Frame %d: Contention resolution timer %d/%d\n",txFrameP,UE_mac_inst[module_idP].RA_contention_resolution_cnt, + LOG_I(MAC,"Frame %d: Contention resolution timer %d/%ld\n",txFrameP,UE_mac_inst[module_idP].RA_contention_resolution_cnt, ((1+rach_ConfigCommon->ra_SupervisionInfo.mac_ContentionResolutionTimer)<<3)); UE_mac_inst[module_idP].RA_contention_resolution_cnt++; diff --git a/openair2/LAYER2/PDCP_v10.1.0/pdcp.c b/openair2/LAYER2/PDCP_v10.1.0/pdcp.c index 2ff2d90de96660627be67b0c79711cfc5e4635bf..4c67f80e207a84f42a56ed0d7cafbed9f7a1b26c 100644 --- a/openair2/LAYER2/PDCP_v10.1.0/pdcp.c +++ b/openair2/LAYER2/PDCP_v10.1.0/pdcp.c @@ -28,6 +28,8 @@ */ #define PDCP_C +//#define DEBUG_PDCP_FIFO_FLUSH_SDU + #ifndef USER_MODE #include #endif @@ -160,7 +162,7 @@ boolean_t pdcp_data_req( if (modeP == PDCP_TRANSMISSION_MODE_TRANSPARENT) { LOG_D(PDCP, " [TM] Asking for a new mem_block of size %d\n",sdu_buffer_sizeP); - pdcp_pdu_p = get_free_mem_block(sdu_buffer_sizeP); + pdcp_pdu_p = get_free_mem_block(sdu_buffer_sizeP, __func__); if (pdcp_pdu_p != NULL) { memcpy(&pdcp_pdu_p->data[0], sdu_buffer_pP, sdu_buffer_sizeP); @@ -201,7 +203,7 @@ boolean_t pdcp_data_req( /* * Allocate a new block for the new PDU (i.e. PDU header and SDU payload) */ - pdcp_pdu_p = get_free_mem_block(pdcp_pdu_size); + pdcp_pdu_p = get_free_mem_block(pdcp_pdu_size, __func__); if (pdcp_pdu_p != NULL) { /* @@ -255,12 +257,12 @@ boolean_t pdcp_data_req( * Validate incoming sequence number, there might be a problem with PDCP initialization */ if (current_sn > pdcp_calculate_max_seq_num_for_given_size(pdcp_p->seq_num_size)) { - LOG_E(PDCP, PROTOCOL_PDCP_CTXT_FMT" Generated sequence number (%lu) is greater than a sequence number could ever be!\n"\ + LOG_E(PDCP, PROTOCOL_PDCP_CTXT_FMT" Generated sequence number (%"PRIu16") is greater than a sequence number could ever be!\n"\ "There must be a problem with PDCP initialization, ignoring this PDU...\n", PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP,pdcp_p), current_sn); - free_mem_block(pdcp_pdu_p); + free_mem_block(pdcp_pdu_p, __func__); if (ctxt_pP->enb_flag == ENB_FLAG_NO) { stop_meas(&eNB_pdcp_stats[ctxt_pP->module_id].data_req); @@ -510,7 +512,7 @@ pdcp_data_ind( PROTOCOL_CTXT_FMT"Could not get PDCP instance key 0x%"PRIx64"\n", PROTOCOL_CTXT_ARGS(ctxt_pP), key); - free_mem_block(sdu_buffer_pP); + free_mem_block(sdu_buffer_pP, __func__); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_IND,VCD_FUNCTION_OUT); return FALSE; } @@ -567,7 +569,7 @@ pdcp_data_ind( PROTOCOL_PDCP_CTXT_FMT"Incoming (from RLC) SDU is short of size (size:%d)! Ignoring...\n", PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP, pdcp_p), sdu_buffer_sizeP); - free_mem_block(sdu_buffer_pP); + free_mem_block(sdu_buffer_pP, __func__); if (ctxt_pP->enb_flag) { stop_meas(&eNB_pdcp_stats[ctxt_pP->module_id].data_ind); @@ -598,7 +600,7 @@ pdcp_data_ind( */ #if 0 LOG_D(PDCP, "Ignoring PDU...\n"); - free_mem_block(sdu_buffer); + free_mem_block(sdu_buffer, __func__); return FALSE; #else //LOG_W(PDCP, "Delivering out-of-order SDU to upper layer...\n"); @@ -645,9 +647,9 @@ pdcp_data_ind( rb_id, sdu_buffer_sizeP - pdcp_header_len - pdcp_tailer_len, (uint8_t*)&sdu_buffer_pP->data[pdcp_header_len]); - free_mem_block(sdu_buffer_pP); + free_mem_block(sdu_buffer_pP, __func__); - // free_mem_block(new_sdu); + // free_mem_block(new_sdu, __func__); if (ctxt_pP->enb_flag) { stop_meas(&eNB_pdcp_stats[ctxt_pP->module_id].data_ind); } else { @@ -722,7 +724,7 @@ pdcp_data_ind( ctime, (const char*)(&sdu_buffer_pP->data[payload_offset]), sdu_buffer_sizeP - payload_offset ) == 0 ) { - free_mem_block(sdu_buffer_pP); + free_mem_block(sdu_buffer_pP, __func__); if (ctxt_pP->enb_flag) { stop_meas(&eNB_pdcp_stats[ctxt_pP->module_id].data_ind); @@ -739,7 +741,7 @@ pdcp_data_ind( if (otg_enabled==1) { LOG_D(OTG,"Discarding received packed\n"); - free_mem_block(sdu_buffer_pP); + free_mem_block(sdu_buffer_pP, __func__); if (ctxt_pP->enb_flag) { stop_meas(&eNB_pdcp_stats[ctxt_pP->module_id].data_ind); @@ -794,7 +796,7 @@ pdcp_data_ind( #endif if (FALSE == packet_forwarded) { - new_sdu_p = get_free_mem_block(sdu_buffer_sizeP - payload_offset + sizeof (pdcp_data_ind_header_t)); + new_sdu_p = get_free_mem_block(sdu_buffer_sizeP - payload_offset + sizeof (pdcp_data_ind_header_t), __func__); if (new_sdu_p) { if (pdcp_p->rlc_mode == RLC_MODE_AM ) { @@ -806,6 +808,7 @@ pdcp_data_ind( */ memset(new_sdu_p->data, 0, sizeof (pdcp_data_ind_header_t)); ((pdcp_data_ind_header_t *) new_sdu_p->data)->data_size = sdu_buffer_sizeP - payload_offset; + AssertFatal((sdu_buffer_sizeP - payload_offset >= 0), "invalid PDCP SDU size!"); // Here there is no virtualization possible // set ((pdcp_data_ind_header_t *) new_sdu_p->data)->inst for IP layer here @@ -820,6 +823,11 @@ pdcp_data_ind( ((pdcp_data_ind_header_t*) new_sdu_p->data)->inst = ctxt_pP->module_id - oai_emulation.info.first_enb_local; #endif } +#ifdef DEBUG_PDCP_FIFO_FLUSH_SDU + static uint32_t pdcp_inst = 0; + ((pdcp_data_ind_header_t*) new_sdu_p->data)->inst = pdcp_inst++; + LOG_D(PDCP, "inst=%d size=%d\n", ((pdcp_data_ind_header_t*) new_sdu_p->data)->inst, ((pdcp_data_ind_header_t *) new_sdu_p->data)->data_size); +#endif memcpy(&new_sdu_p->data[sizeof (pdcp_data_ind_header_t)], \ &sdu_buffer_pP->data[payload_offset], \ @@ -828,7 +836,7 @@ pdcp_data_ind( /* Print octets of incoming data in hexadecimal form */ LOG_D(PDCP, "Following content has been received from RLC (%d,%d)(PDCP header has already been removed):\n", - sdu_buffer_sizeP - payload_offset + sizeof(pdcp_data_ind_header_t), + sdu_buffer_sizeP - payload_offset + (int)sizeof(pdcp_data_ind_header_t), sdu_buffer_sizeP - payload_offset); //util_print_hex_octets(PDCP, &new_sdu_p->data[sizeof (pdcp_data_ind_header_t)], sdu_buffer_sizeP - payload_offset); //util_flush_hex_octets(PDCP, &new_sdu_p->data[sizeof (pdcp_data_ind_header_t)], sdu_buffer_sizeP - payload_offset); @@ -856,7 +864,7 @@ pdcp_data_ind( #endif - free_mem_block(sdu_buffer_pP); + free_mem_block(sdu_buffer_pP, __func__); if (ctxt_pP->enb_flag) { stop_meas(&eNB_pdcp_stats[ctxt_pP->module_id].data_ind); @@ -1206,7 +1214,7 @@ rrc_pdcp_config_asn1_req ( } if (lc_id == 1 || lc_id == 2) { - LOG_E(RLC, PROTOCOL_CTXT_FMT" logicalChannelIdentity = %d is invalid in RRC message when adding DRB!\n", PROTOCOL_CTXT_ARGS(ctxt_pP), lc_id); + LOG_E(RLC, PROTOCOL_CTXT_FMT" logicalChannelIdentity = %ld is invalid in RRC message when adding DRB!\n", PROTOCOL_CTXT_ARGS(ctxt_pP), lc_id); continue; } @@ -1304,7 +1312,7 @@ rrc_pdcp_config_asn1_req ( break; default: - LOG_W(PDCP,"[MOD_id %u/%u][RB %u] unknown drb_toaddmod->PDCP_Config->headerCompression->present \n", + LOG_W(PDCP,PROTOCOL_PDCP_CTXT_FMT"[RB %ld] unknown drb_toaddmod->PDCP_Config->headerCompression->present \n", PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP,pdcp_p), drb_id); break; } @@ -1337,7 +1345,7 @@ rrc_pdcp_config_asn1_req ( h_rc = hashtable_get(pdcp_coll_p, key, (void**)&pdcp_p); if (h_rc != HASH_TABLE_OK) { - LOG_E(PDCP, PROTOCOL_CTXT_FMT" PDCP REMOVE FAILED drb_id %u\n", + LOG_E(PDCP, PROTOCOL_CTXT_FMT" PDCP REMOVE FAILED drb_id %ld\n", PROTOCOL_CTXT_ARGS(ctxt_pP), drb_id); continue; @@ -1741,7 +1749,7 @@ rrc_pdcp_config_req ( pdcp_p->cipheringAlgorithm, pdcp_p->integrityProtAlgorithm ); } else { - LOG_W(PDCP,"[%s %d] bad security mode %d", security_modeP); + LOG_W(PDCP,PROTOCOL_PDCP_CTXT_FMT" bad security mode %d", PROTOCOL_PDCP_CTXT_ARGS(ctxt_pP,pdcp_p), security_modeP); } break; diff --git a/openair2/LAYER2/PDCP_v10.1.0/pdcp_control_primitive.c b/openair2/LAYER2/PDCP_v10.1.0/pdcp_control_primitive.c index d584cb1e64561167f84bc43c7e2a90888e68e33b..795cb2e80aa3056a6581bc56470a6fb31039a818 100644 --- a/openair2/LAYER2/PDCP_v10.1.0/pdcp_control_primitive.c +++ b/openair2/LAYER2/PDCP_v10.1.0/pdcp_control_primitive.c @@ -44,7 +44,7 @@ configure_pdcp_req (struct pdcp_entity *pdcpP, void *rlcP, uint8_t rlc_sap_typeP //----------------------------------------------------------------------------- mem_block *mb; - mb = get_free_mem_block (sizeof (struct cpdcp_primitive)); + mb = get_free_mem_block (sizeof (struct cpdcp_primitive), __func__); ((struct cpdcp_primitive *) mb->data)->type = CPDCP_CONFIG_REQ; ((struct cpdcp_primitive *) mb->data)->primitive.config_req.rlc_sap = rlcP; ((struct cpdcp_primitive *) mb->data)->primitive.config_req.rlc_type_sap = rlc_sap_typeP; diff --git a/openair2/LAYER2/PDCP_v10.1.0/pdcp_fifo.c b/openair2/LAYER2/PDCP_v10.1.0/pdcp_fifo.c index eb78a4ca7c493c9e354fc174b41005d464d8ae3a..e380bc6098bd6e7e98d8d6bb5558435e6fb2fc89 100644 --- a/openair2/LAYER2/PDCP_v10.1.0/pdcp_fifo.c +++ b/openair2/LAYER2/PDCP_v10.1.0/pdcp_fifo.c @@ -31,6 +31,7 @@ #define PDCP_FIFO_C #define PDCP_DEBUG 1 +//#define DEBUG_PDCP_FIFO_FLUSH_SDU #ifndef OAI_EMU extern int otg_enabled; @@ -40,6 +41,7 @@ extern int otg_enabled; #include "pdcp_primitives.h" #ifdef USER_MODE +#include #include #include #include @@ -59,6 +61,7 @@ extern int otg_enabled; #include "UTIL/LOG/log.h" #include "UTIL/OTG/otg_tx.h" #include "UTIL/FIFO/pad_list.h" +#include "UTIL/LOG/vcd_signal_dumper.h" #include "platform_constants.h" #include "msc.h" @@ -88,6 +91,21 @@ extern Packet_OTG_List_t *otg_pdcp_buffer; # include "gtpv1u_eNB_task.h" #endif +/* Prevent de-queueing the same PDCP SDU from the queue twice + * by multiple threads. This has happened in TDD when thread-odd + * is flushing a PDCP SDU after UE_RX() processing; whereas + * thread-even is at a special-subframe, skips the UE_RX() process + * and goes straight to the PDCP SDU flushing. The 2nd flushing + * dequeues the same SDU again causing unexpected behavior. + * + * comment out the MACRO below to disable this protection + */ +#define PDCP_SDU_FLUSH_LOCK + +#ifdef PDCP_SDU_FLUSH_LOCK +static pthread_mutex_t mtex = PTHREAD_MUTEX_INITIALIZER; +#endif + pdcp_data_req_header_t pdcp_read_header_g; //----------------------------------------------------------------------------- @@ -95,6 +113,42 @@ int pdcp_fifo_flush_sdus(const protocol_ctxt_t* const ctxt_pP) { //----------------------------------------------------------------------------- +//#if defined(PDCP_USE_NETLINK) && defined(LINUX) + int ret = 0; +//#endif + +#ifdef DEBUG_PDCP_FIFO_FLUSH_SDU +#define THREAD_NAME_LEN 16 + static char threadname[THREAD_NAME_LEN]; + ret = pthread_getname_np(pthread_self(), threadname, THREAD_NAME_LEN); + if (ret != 0) + { + perror("pthread_getname_np : "); + exit_fun("Error getting thread name"); + } +#undef THREAD_NAME_LEN +#endif + +#ifdef PDCP_SDU_FLUSH_LOCK + ret = pthread_mutex_trylock(&mtex); + if (ret == EBUSY) { +#ifdef DEBUG_PDCP_FIFO_FLUSH_SDU + LOG_W(PDCP, "[%s] at SFN/SF=%d/%d wait for PDCP FIFO to be unlocked\n", + threadname, ctxt_pP->frame, ctxt_pP->subframe); +#endif + if (pthread_mutex_lock(&mtex)) { + exit_fun("PDCP_SDU_FLUSH_LOCK lock error!"); + } +#ifdef DEBUG_PDCP_FIFO_FLUSH_SDU + LOG_I(PDCP, "[%s] at SFN/SF=%d/%d PDCP FIFO is unlocked\n", + threadname, ctxt_pP->frame, ctxt_pP->subframe); +#endif + } else if (ret != 0) { + exit_fun("PDCP_SDU_FLUSH_LOCK trylock error!"); + } + +#endif + mem_block_t *sdu_p = list_get_head (&pdcp_sdu_list); int bytes_wrote = 0; int pdcp_nb_sdu_sent = 0; @@ -103,15 +157,19 @@ int pdcp_fifo_flush_sdus(const protocol_ctxt_t* const ctxt_pP) //MessageDef *message_p = NULL; #endif -#if defined(PDCP_USE_NETLINK) && defined(LINUX) - int ret = 0; -#endif - + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH, 1 ); while (sdu_p && cont) { +#ifdef DEBUG_PDCP_FIFO_FLUSH_SDU + LOG_D(PDCP, "[%s] SFN/SF=%d/%d inst=%d size=%d\n", + threadname, ctxt_pP->frame, ctxt_pP->subframe, + ((pdcp_data_ind_header_t*) sdu_p->data)->inst, + ((pdcp_data_ind_header_t *) sdu_p->data)->data_size); +#else #if ! defined(OAI_EMU) ((pdcp_data_ind_header_t *)(sdu_p->data))->inst = 0; #endif +#endif #if defined(LINK_ENB_PDCP_TO_GTPV1U) @@ -126,7 +184,7 @@ int pdcp_fifo_flush_sdus(const protocol_ctxt_t* const ctxt_pP) ((pdcp_data_ind_header_t *)(sdu_p->data))->data_size); list_remove_head (&pdcp_sdu_list); - free_mem_block (sdu_p); + free_mem_block (sdu_p, __func__); cont = 1; pdcp_nb_sdu_sent += 1; sdu_p = list_get_head (&pdcp_sdu_list); @@ -175,6 +233,7 @@ int pdcp_fifo_flush_sdus(const protocol_ctxt_t* const ctxt_pP) if (!pdcp_output_header_bytes_to_write) { // continue with sdu pdcp_output_sdu_bytes_to_write = ((pdcp_data_ind_header_t *) sdu_p->data)->data_size; + AssertFatal(pdcp_output_sdu_bytes_to_write >= 0, "invalid data_size!"); #ifdef PDCP_USE_RT_FIFO bytes_wrote = rtf_put (PDCP2PDCP_USE_RT_FIFO, &(sdu->data[sizeof (pdcp_data_ind_header_t)]), pdcp_output_sdu_bytes_to_write); @@ -184,7 +243,11 @@ int pdcp_fifo_flush_sdus(const protocol_ctxt_t* const ctxt_pP) #ifdef LINUX memcpy(NLMSG_DATA(nas_nlh_tx)+sizeof(pdcp_data_ind_header_t), &(sdu_p->data[sizeof (pdcp_data_ind_header_t)]), pdcp_output_sdu_bytes_to_write); nas_nlh_tx->nlmsg_len += pdcp_output_sdu_bytes_to_write; + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_UE_PDCP_FLUSH_SIZE, pdcp_output_sdu_bytes_to_write); + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH_BUFFER, 1 ); ret = sendmsg(nas_sock_fd,&nas_msg_tx,0); + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH_BUFFER, 0 ); + VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_UE_PDCP_FLUSH_ERR, ret ); if (ret<0) { LOG_E(PDCP, "[PDCP_FIFOS] sendmsg returns %d (errno: %d)\n", ret, errno); @@ -238,17 +301,22 @@ int pdcp_fifo_flush_sdus(const protocol_ctxt_t* const ctxt_pP) ((pdcp_data_ind_header_t *)(sdu_p->data))->rb_id); list_remove_head (&pdcp_sdu_list); - free_mem_block (sdu_p); + free_mem_block (sdu_p, __func__); cont = 1; pdcp_nb_sdu_sent += 1; sdu_p = list_get_head (&pdcp_sdu_list); + } else { + LOG_D(PDCP, "1 skip free_mem_block: pdcp_output_sdu_bytes_to_write = %d\n", pdcp_output_sdu_bytes_to_write); + AssertFatal(pdcp_output_sdu_bytes_to_write > 0, "pdcp_output_sdu_bytes_to_write cannot be negative!"); } } else { - LOG_W(PDCP, "RADIO->IP SEND SDU CONGESTION!\n"); + LOG_W(PDCP, "2: RADIO->IP SEND SDU CONGESTION!\n"); } } else { - LOG_W(PDCP, "RADIO->IP SEND SDU CONGESTION!\n"); + LOG_W(PDCP, "3: RADIO->IP SEND SDU CONGESTION!\n"); } + } else { + LOG_D(PDCP, "4 skip free_mem_block: bytes_wrote = %d\n", bytes_wrote); } } else { // continue writing sdu @@ -266,15 +334,20 @@ int pdcp_fifo_flush_sdus(const protocol_ctxt_t* const ctxt_pP) if (!pdcp_output_sdu_bytes_to_write) { // OK finish with this SDU //PRINT_RB_SEND_OUTPUT_SDU ("[PDCP] RADIO->IP SEND SDU\n"); list_remove_head (&pdcp_sdu_list); - free_mem_block (sdu_p); + free_mem_block (sdu_p, __func__); cont = 1; pdcp_nb_sdu_sent += 1; sdu_p = list_get_head (&pdcp_sdu_list); // LOG_D(PDCP, "rb sent a sdu from rab\n"); + } else { + LOG_D(PDCP, "5 skip free_mem_block: pdcp_output_sdu_bytes_to_write = %d\n", pdcp_output_sdu_bytes_to_write); } + } else { + LOG_D(PDCP, "6 skip free_mem_block: bytes_wrote = %d\n", bytes_wrote); } } } + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH, 0 ); #ifdef PDCP_USE_RT_FIFO @@ -295,6 +368,10 @@ int pdcp_fifo_flush_sdus(const protocol_ctxt_t* const ctxt_pP) #endif //PDCP_USE_RT_FIFO +#ifdef PDCP_SDU_FLUSH_LOCK + if (pthread_mutex_unlock(&mtex)) exit_fun("PDCP_SDU_FLUSH_LOCK unlock error!"); +#endif + return pdcp_nb_sdu_sent; } @@ -429,7 +506,10 @@ int pdcp_fifo_read_input_sdus (const protocol_ctxt_t* const ctxt_pP) int rlc_data_req_flag = 3; while ((len > 0) && (rlc_data_req_flag !=0)) { + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ, 1 ); + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ_BUFFER, 1 ); len = recvmsg(nas_sock_fd, &nas_msg_rx, 0); + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ_BUFFER, 0 ); if (len<=0) { // nothing in pdcp NAS socket @@ -497,7 +577,7 @@ int pdcp_fifo_read_input_sdus (const protocol_ctxt_t* const ctxt_pP) ctxt.enb_flag = ctxt_cpy.enb_flag; #ifdef PDCP_DEBUG - LOG_I(PDCP, "[PDCP][NETLINK] pdcp_read_header_g.rb_id = %d\n", pdcp_read_header_g.rb_id); + LOG_D(PDCP, "[PDCP][NETLINK] pdcp_read_header_g.rb_id = %d\n", pdcp_read_header_g.rb_id); #endif if (ctxt_cpy.enb_flag) { @@ -707,6 +787,7 @@ int pdcp_fifo_read_input_sdus (const protocol_ctxt_t* const ctxt_pP) } } } + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ, 0 ); } return len; diff --git a/openair2/LAYER2/PDCP_v10.1.0/pdcp_util.c b/openair2/LAYER2/PDCP_v10.1.0/pdcp_util.c index fd339b627764b3157589e7b78c48bed7a677893e..eac42cb1297c8958a580f70c57685903f223b5ad 100644 --- a/openair2/LAYER2/PDCP_v10.1.0/pdcp_util.c +++ b/openair2/LAYER2/PDCP_v10.1.0/pdcp_util.c @@ -62,7 +62,7 @@ void util_print_hex_octets(comp_name_t component, unsigned char* data, unsigned */ if (octet_index != 0 && (octet_index + 1) % 16 == 0) { LOG_T(component, " |\n"); - LOG_T(component, " %03d |", octet_index); + LOG_T(component, " %03lu |", octet_index); } } diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am.c index ded7dc078393adc116d0c0e1ddf5861da94872b9..4051a88ef2976da6f625e280329d0ba6cb2af71e 100644 --- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am.c +++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am.c @@ -223,7 +223,7 @@ void config_req_rlc_am_asn1 ( PROTOCOL_RLC_AM_MSC_ARGS(ctxt_pP, l_rlc_p)); LOG_D(RLC, - PROTOCOL_RLC_AM_CTXT_FMT"ILLEGAL CONFIG_REQ (max_retx_threshold=%d poll_pdu=%d poll_byte=%d t_poll_retransmit=%d t_reord=%d t_status_prohibit=%d), RLC-AM NOT CONFIGURED\n", + PROTOCOL_RLC_AM_CTXT_FMT"ILLEGAL CONFIG_REQ (max_retx_threshold=%ld poll_pdu=%ld poll_byte=%ld t_poll_retransmit=%ld t_reord=%ld t_status_prohibit=%ld), RLC-AM NOT CONFIGURED\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,l_rlc_p), config_am_pP->ul_AM_RLC.maxRetxThreshold, config_am_pP->ul_AM_RLC.pollPDU, @@ -523,7 +523,7 @@ rlc_am_rx ( switch (rlc->protocol_state) { case RLC_NULL_STATE: - LOG_N(RLC, PROTOCOL_RLC_AM_CTXT_FMT" ERROR MAC_DATA_IND IN RLC_NULL_STATE\n", arg_pP); + LOG_N(RLC, PROTOCOL_RLC_AM_CTXT_FMT" ERROR MAC_DATA_IND IN RLC_NULL_STATE\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP, rlc)); list_free (&data_indP.data); break; @@ -532,7 +532,7 @@ rlc_am_rx ( break; default: - LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT" TX UNKNOWN PROTOCOL STATE 0x%02X\n", rlc, rlc->protocol_state); + LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT" TX UNKNOWN PROTOCOL STATE 0x%02X\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP, rlc), rlc->protocol_state); } } @@ -557,6 +557,15 @@ rlc_am_mac_status_indication ( status_resp.head_sdu_is_segmented = 0; status_resp.rlc_info.rlc_protocol_state = rlc->protocol_state; + /* TODO: remove this hack. Problem is: there is a race. + * UE comes. SRB2 is configured via message to RRC. + * At some point the RLC AM is created but not configured yet. + * At this moment (I think) MAC calls mac_rlc_status_ind + * which calls this function. But the init was not finished yet + * and we have a crash below when testing mem_block != NULL. + */ + if (rlc->input_sdus == NULL) return status_resp; + if (rlc->last_frame_status_indication != ctxt_pP->frame) { rlc_am_check_timer_poll_retransmit(ctxt_pP, rlc); rlc_am_check_timer_reordering(ctxt_pP, rlc); @@ -1280,7 +1289,7 @@ rlc_am_data_req ( l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].mem_block, l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].flags.segmented); l_rlc_p->stat_tx_pdcp_sdu_discarded += 1; l_rlc_p->stat_tx_pdcp_bytes_discarded += ((struct rlc_am_data_req *) (sdu_pP->data))->data_size; - free_mem_block (sdu_pP); + free_mem_block (sdu_pP, __func__); #if STOP_ON_IP_TRAFFIC_OVERLOAD AssertFatal(0, PROTOCOL_RLC_AM_CTXT_FMT" RLC_AM_DATA_REQ size %d Bytes, SDU DROPPED, INPUT BUFFER OVERFLOW NB SDU %d current_sdu_index=%d next_sdu_index=%d \n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,l_rlc_p), diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_in_sdu.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_in_sdu.c index a767e94dc7b43224814161dafd8a7a5a711a3bd5..0f0b0e75e1b70f24862309c86ac5c48ccfe5bde0 100644 --- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_in_sdu.c +++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_in_sdu.c @@ -42,7 +42,7 @@ void rlc_am_free_in_sdu( { if (index_in_bufferP <= RLC_AM_SDU_CONTROL_BUFFER_SIZE) { if (rlcP->input_sdus[index_in_bufferP].mem_block != NULL) { - free_mem_block(rlcP->input_sdus[index_in_bufferP].mem_block); + free_mem_block(rlcP->input_sdus[index_in_bufferP].mem_block, __func__); rlcP->input_sdus[index_in_bufferP].mem_block = NULL; rlcP->nb_sdu_no_segmented -= 1; rlcP->input_sdus[index_in_bufferP].sdu_remaining_size = 0; @@ -81,7 +81,7 @@ rlc_am_free_in_sdu_data( { if (index_in_bufferP <= RLC_AM_SDU_CONTROL_BUFFER_SIZE) { if (rlcP->input_sdus[index_in_bufferP].mem_block != NULL) { - free_mem_block(rlcP->input_sdus[index_in_bufferP].mem_block); + free_mem_block(rlcP->input_sdus[index_in_bufferP].mem_block, __func__); rlcP->input_sdus[index_in_bufferP].mem_block = NULL; rlcP->input_sdus[index_in_bufferP].sdu_remaining_size = 0; rlcP->nb_sdu_no_segmented -= 1; diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_init.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_init.c index a7cf302d06758ee5f41f6631c817960ba8b4759c..cb03e28c4b457d8e9ce39344dbe32213f5d3bb26 100644 --- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_init.c +++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_init.c @@ -54,11 +54,11 @@ rlc_am_init( // rlc_pP->pdu_retrans_buffer = calloc(1, (uint16_t)((unsigned int)RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE*(unsigned int)sizeof(rlc_am_tx_data_pdu_management_t))); rlc_pP->pdu_retrans_buffer = calloc(1, (uint32_t)((unsigned int)RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE*(unsigned int)sizeof( rlc_am_tx_data_pdu_management_t))); - LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[AM INIT] input_sdus[] = %p element size=%d\n", + LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[AM INIT] input_sdus[] = %p element size=%zu\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), rlc_pP->input_sdus, sizeof(rlc_am_tx_sdu_management_t)); - LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[AM INIT] pdu_retrans_buffer[] = %p element size=%d\n", + LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[AM INIT] pdu_retrans_buffer[] = %p element size=%zu\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), rlc_pP->pdu_retrans_buffer, sizeof(rlc_am_tx_data_pdu_management_t)); @@ -152,7 +152,7 @@ rlc_am_cleanup( if (rlc_pP->output_sdu_in_construction != NULL) { - free_mem_block(rlc_pP->output_sdu_in_construction); + free_mem_block(rlc_pP->output_sdu_in_construction, __func__); rlc_pP->output_sdu_in_construction = NULL; } @@ -161,7 +161,7 @@ rlc_am_cleanup( if (rlc_pP->input_sdus != NULL) { for (i=0; i < RLC_AM_SDU_CONTROL_BUFFER_SIZE; i++) { if (rlc_pP->input_sdus[i].mem_block != NULL) { - free_mem_block(rlc_pP->input_sdus[i].mem_block); + free_mem_block(rlc_pP->input_sdus[i].mem_block, __func__); rlc_pP->input_sdus[i].mem_block = NULL; } } @@ -175,7 +175,7 @@ rlc_am_cleanup( if (rlc_pP->pdu_retrans_buffer != NULL) { for (i=0; i < RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE; i++) { if (rlc_pP->pdu_retrans_buffer[i].mem_block != NULL) { - free_mem_block(rlc_pP->pdu_retrans_buffer[i].mem_block); + free_mem_block(rlc_pP->pdu_retrans_buffer[i].mem_block, __func__); rlc_pP->pdu_retrans_buffer[i].mem_block = NULL; } } diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_reassembly.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_reassembly.c index d13b89f1dcadfd864e98d99586695ae3c39613a4..873e51fbfe395c0e6aa48909a11c46830d682a59 100644 --- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_reassembly.c +++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_reassembly.c @@ -55,7 +55,7 @@ rlc_am_reassembly ( lengthP); if (rlc_pP->output_sdu_in_construction == NULL) { - rlc_pP->output_sdu_in_construction = get_free_mem_block (RLC_SDU_MAX_SIZE); + rlc_pP->output_sdu_in_construction = get_free_mem_block (RLC_SDU_MAX_SIZE, __func__); rlc_pP->output_sdu_size_to_write = 0; assert(rlc_pP->output_sdu_in_construction != NULL); } @@ -197,7 +197,7 @@ rlc_am_send_sdu ( LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND_SDU] ERROR SIZE <= 0 ... DO NOTHING, SET SDU SIZE TO 0\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP)); //msg("[RLC_AM][MOD %d] Freeing mem_block ...\n", rlc_pP->module_id); - //free_mem_block (rlc_pP->output_sdu_in_construction); + //free_mem_block (rlc_pP->output_sdu_in_construction, __func__); AssertFatal(3==4, PROTOCOL_RLC_AM_CTXT_FMT" SEND SDU REQUESTED %d bytes", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), @@ -397,5 +397,5 @@ rlc_am_reassemble_pdu( } } - free_mem_block(tb_pP); + free_mem_block(tb_pP, __func__); } diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_receiver.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_receiver.c index d0b023833ad24b7fa9fe877d41b6cf446c7740bf..d783684893565fa74cf32aef762d604823d706a9 100644 --- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_receiver.c +++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_receiver.c @@ -346,7 +346,7 @@ rlc_am_receive_process_data_pdu ( if (rlc_am_rx_list_insert_pdu(ctxt_pP, rlc_pP,tb_pP) < 0) { rlc_pP->stat_rx_data_pdu_dropped += 1; rlc_pP->stat_rx_data_bytes_dropped += tb_size_in_bytesP; - free_mem_block (tb_pP); + free_mem_block (tb_pP, __func__); LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[PROCESS RX PDU] PDU DISCARDED, STATUS REQUESTED:\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP)); rlc_pP->status_requested = 1; @@ -437,12 +437,12 @@ rlc_am_receive_process_data_pdu ( } else { rlc_pP->stat_rx_data_pdu_out_of_window += 1; rlc_pP->stat_rx_data_bytes_out_of_window += tb_size_in_bytesP; - free_mem_block (tb_pP); + free_mem_block (tb_pP, __func__); LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[PROCESS RX PDU] PDU OUT OF RX WINDOW, DISCARDED, STATUS REQUESTED:\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP)); rlc_pP->status_requested = 1; } } else { - free_mem_block (tb_pP); + free_mem_block (tb_pP, __func__); } } diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_retransmit.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_retransmit.c index 445014c62cee82613eb65feb872548445fba69c2..7fb801b33d717c6d686c2eb8985a07399c7d71a5 100644 --- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_retransmit.c +++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_retransmit.c @@ -143,7 +143,7 @@ void rlc_am_ack_pdu ( if ((rlc_pP->pdu_retrans_buffer[snP].flags.ack == 0) && (mb_p != NULL)) { //if (mb_pP != NULL) { - free_mem_block(mb_p); + free_mem_block(mb_p, __func__); rlc_pP->pdu_retrans_buffer[snP].mem_block = NULL; LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[ACK-PDU] ACK PDU SN %05d previous retx_count %d \n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), @@ -235,7 +235,7 @@ void rlc_am_ack_pdu ( snP); if (mb_p != NULL) { - free_mem_block(mb_p); + free_mem_block(mb_p, __func__); rlc_pP->pdu_retrans_buffer[snP].mem_block = NULL; } @@ -275,7 +275,7 @@ mem_block_t* rlc_am_retransmit_get_copy ( rlc_am_tx_data_pdu_management_t *pdu_mngt = &rlc_pP->pdu_retrans_buffer[snP % RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE]; int size = pdu_mngt->header_and_payload_size + sizeof(struct mac_tb_req); - mem_block_t* mb_copy = get_free_mem_block(size); + mem_block_t* mb_copy = get_free_mem_block(size, __func__); memcpy(mb_copy->data, mb_original_p->data, size); rlc_am_pdu_sn_10_t *pdu_p = (rlc_am_pdu_sn_10_t*) (&mb_copy->data[sizeof(struct mac_tb_req)]); @@ -343,7 +343,7 @@ mem_block_t* rlc_am_retransmit_get_subsegment( mem_block_t* mb_original_p = rlc_pP->pdu_retrans_buffer[snP].mem_block; if (mb_original_p != NULL) { - mem_block_t* mb_sub_segment_p = get_free_mem_block(*sizeP + sizeof(struct mac_tb_req)); + mem_block_t* mb_sub_segment_p = get_free_mem_block(*sizeP + sizeof(struct mac_tb_req), __func__); rlc_am_pdu_sn_10_t* pdu_original_p = (rlc_am_pdu_sn_10_t*) (&mb_original_p->data[sizeof(struct mac_tb_req)]); rlc_am_pdu_sn_10_t* pdu_sub_segment_p = (rlc_am_pdu_sn_10_t*) (&mb_sub_segment_p->data[sizeof(struct mac_tb_req)]); rlc_am_pdu_info_t pdu_info; @@ -646,7 +646,7 @@ mem_block_t* rlc_am_retransmit_get_subsegment( // fill the segment pdu_p with Lis and data //--------------------------------------------------------------- LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[RE-SEGMENT] fill the segment pdu_p with Lis and data, test_num_li %d\n", - test_num_li); + PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), test_num_li); if (test_num_li > 0) { pdu_sub_segment_p->b1 = pdu_sub_segment_p->b1 | 0x04; // set E bit @@ -678,12 +678,12 @@ mem_block_t* rlc_am_retransmit_get_subsegment( *sizeP = *sizeP - 1; } - LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[RB %u][RE-SEGMENT] ADD LI %d\n", + LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[RE-SEGMENT] ADD LI %d\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), test_li_list[fill_num_li]); } } else { - LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[RB %u][RE-SEGMENT] ADD NO LI\n", + LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[RE-SEGMENT] ADD NO LI\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP)); fill_payload_p = (uint8_t*)e_li_sub_segment; } diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_rx_list.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_rx_list.c index 3c983805c7425f75ec5a7e1787e263166eb9a753..a9f0bdbf7e64e82155decfd4d8cd205415a99e45 100644 --- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_rx_list.c +++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_rx_list.c @@ -62,7 +62,6 @@ rlc_am_rx_list_insert_pdu( if (pdu_info_previous_cursor_p->sn == pdu_info_p->sn) { if (pdu_info_p->rf != pdu_info_previous_cursor_p->rf) { LOG_N(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[INSERT PDU] LINE %d RX PDU SN %04d WRONG RF -> DROPPED (vr(mr) < vr(r) and sn >= vr(r))\n", - ctxt_pP->frame, PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), __LINE__, pdu_info_p->sn); diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_segment.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_segment.c index f2a12112c490b5d15564718952055ed2289a1391..893588d65e28fbc7651b7ef36bfec7e424309a67 100644 --- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_segment.c +++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_segment.c @@ -197,7 +197,7 @@ void rlc_am_segment_10 ( data_pdu_size); } - if (!(pdu_mem_p = get_free_mem_block (data_pdu_size + sizeof(struct mac_tb_req)))) { + if (!(pdu_mem_p = get_free_mem_block (data_pdu_size + sizeof(struct mac_tb_req), __func__))) { LOG_C(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEGMENT] ERROR COULD NOT GET NEW PDU, EXIT\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP)); RLC_AM_MUTEX_UNLOCK(&rlc_pP->lock_input_sdus); @@ -366,7 +366,7 @@ void rlc_am_segment_10 ( // free SDU rlc_pP->sdu_buffer_occupancy -= sdu_mngt_p->sdu_remaining_size; rlc_am_free_in_sdu_data(ctxt_pP, rlc_pP, rlc_pP->current_sdu_index); - //free_mem_block (rlc_pP->input_sdus[rlc_pP->current_sdu_index]); + //free_mem_block (rlc_pP->input_sdus[rlc_pP->current_sdu_index], __func__); //rlc_pP->input_sdus[rlc_pP->current_sdu_index] = NULL; //rlc_pP->nb_sdu -= 1; rlc_pP->current_sdu_index = (rlc_pP->current_sdu_index + 1) % RLC_AM_SDU_CONTROL_BUFFER_SIZE; @@ -445,7 +445,7 @@ void rlc_am_segment_10 ( sdu_mngt_p->sdu_remaining_size = 0; rlc_am_free_in_sdu_data(ctxt_pP, rlc_pP, rlc_pP->current_sdu_index); - //free_mem_block (rlc_pP->input_sdus[rlc_pP->current_sdu_index]); + //free_mem_block (rlc_pP->input_sdus[rlc_pP->current_sdu_index], __func__); //rlc_pP->input_sdus[rlc_pP->current_sdu_index] = NULL; //rlc_pP->nb_sdu -= 1; rlc_pP->current_sdu_index = (rlc_pP->current_sdu_index + 1) % RLC_AM_SDU_CONTROL_BUFFER_SIZE; diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_status_report.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_status_report.c index efbd29350cf925269bcf027d5bcf2203f9a61a8d..d687bf8606f31ad4ec3b3c8bad31886e49286f53 100644 --- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_status_report.c +++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_status_report.c @@ -370,7 +370,7 @@ rlc_am_receive_process_control_pdu( *first_byte_ppP = (uint8_t*)((uint64_t)*first_byte_ppP + initial_pdu_size - *tb_size_in_bytes_pP); - free_mem_block(tb_pP); + free_mem_block(tb_pP, __func__); rlc_am_tx_buffer_display(ctxt_pP, rlc_pP, NULL); } //----------------------------------------------------------------------------- @@ -730,7 +730,7 @@ end_push_nack: __LINE__, pdu_size); #endif - tb_p = get_free_mem_block(sizeof(struct mac_tb_req) + pdu_size); + tb_p = get_free_mem_block(sizeof(struct mac_tb_req) + pdu_size, __func__); memset(tb_p->data, 0, sizeof(struct mac_tb_req) + pdu_size); //estimation only ((struct mac_tb_req*)(tb_p->data))->tb_size = pdu_size; ((struct mac_tb_req*)(tb_p->data))->data_ptr = (uint8_t*)&(tb_p->data[sizeof(struct mac_tb_req)]); diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_test.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_test.c index e03741707e838a4bf74c796d949d29f24d6495b1..8e201a949b84796288ee65a9b5797d4528495131 100644 --- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_test.c +++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_test.c @@ -516,7 +516,7 @@ void rlc_am_v9_3_0_test_send_sdu(rlc_am_entity_t *am_txP, int sdu_indexP) //----------------------------------------------------------------------------- { mem_block_t *sdu; - sdu = get_free_mem_block (strlen(g_sdus[sdu_indexP]) + 1 + sizeof (struct rlc_am_data_req_alloc)); + sdu = get_free_mem_block (strlen(g_sdus[sdu_indexP]) + 1 + sizeof (struct rlc_am_data_req_alloc), __func__); if (sdu != NULL) { // PROCESS OF COMPRESSION HERE: @@ -561,7 +561,7 @@ void rlc_am_v9_3_0_test_mac_rlc_loop (struct mac_data_ind *data_indP, struct ma *tx_packetsP = *tx_packetsP + 1; if (*drop_countP == 0) { - tb_dst = get_free_mem_block(sizeof (mac_rlc_max_rx_header_size_t) + tb_size); + tb_dst = get_free_mem_block(sizeof (mac_rlc_max_rx_header_size_t) + tb_size, __func__); if (tb_dst != NULL) { ((struct mac_tb_ind *) (tb_dst->data))->first_bit = 0; @@ -585,7 +585,7 @@ void rlc_am_v9_3_0_test_mac_rlc_loop (struct mac_data_ind *data_indP, struct ma *dropped_tx_packetsP = *dropped_tx_packetsP + 1; } - free_mem_block(tb_src); + free_mem_block(tb_src, __func__); if (data_indP->no_tb > 0) { printf("[RLC-LOOP] Exchange %d TBs\n",data_indP->no_tb); @@ -673,13 +673,13 @@ void rlc_am_v9_3_0_test_data_ind (module_id_t module_idP, rb_id_t rb_idP, sdu_si assert(g_send_sdu_ids[g_send_id_read_index[rb_idP]][rb_idP^1] == i); g_send_id_read_index[rb_idP] += 1; - free_mem_block(sduP); + free_mem_block(sduP, __func__); return; } } printf("[FRAME %05d][RLC][MOD %d][RB %d] RX UNKNOWN SDU %04d bytes\n",g_frame,module_idP, rb_idP, sizeP); - free_mem_block(sduP); + free_mem_block(sduP, __func__); assert(1==2); } //----------------------------------------------------------------------------- diff --git a/openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm.c b/openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm.c index d854e435e1b316914222d9eba4565fc42185f042..6e495bcefff56c3f43faec496998e2d6e49844f8 100644 --- a/openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm.c +++ b/openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm.c @@ -51,7 +51,7 @@ rlc_tm_send_sdu ( length_in_bytes = (length_in_bitsP + 7) >> 3; if (rlc_pP->output_sdu_in_construction == NULL) { - rlc_pP->output_sdu_in_construction = get_free_mem_block (length_in_bytes); + rlc_pP->output_sdu_in_construction = get_free_mem_block (length_in_bytes, __func__); } if ((rlc_pP->output_sdu_in_construction)) { @@ -97,7 +97,7 @@ rlc_tm_no_segment ( sdu_mngt_p = ((struct rlc_tm_tx_sdu_management *) (rlc_pP->input_sdus[rlc_pP->current_sdu_index]->data)); - if (!(pdu_p = get_free_mem_block (((rlc_pP->rlc_pdu_size + 7) >> 3) + sizeof (struct rlc_tm_tx_data_pdu_struct) + GUARD_CRC_LIH_SIZE))) { + if (!(pdu_p = get_free_mem_block (((rlc_pP->rlc_pdu_size + 7) >> 3) + sizeof (struct rlc_tm_tx_data_pdu_struct) + GUARD_CRC_LIH_SIZE, __func__))) { LOG_D(RLC, PROTOCOL_RLC_TM_CTXT_FMT"[SEGMENT] ERROR COULD NOT GET NEW PDU, EXIT\n", PROTOCOL_RLC_TM_CTXT_ARGS(ctxt_pP, rlc_pP)); return; @@ -116,7 +116,7 @@ rlc_tm_no_segment ( list_add_tail_eurecom (pdu_p, &rlc_pP->pdus_to_mac_layer); rlc_pP->buffer_occupancy -= (sdu_mngt_p->sdu_size >> 3); - free_mem_block (rlc_pP->input_sdus[rlc_pP->current_sdu_index]); + free_mem_block (rlc_pP->input_sdus[rlc_pP->current_sdu_index], __func__); rlc_pP->input_sdus[rlc_pP->current_sdu_index] = NULL; rlc_pP->current_sdu_index = (rlc_pP->current_sdu_index + 1) % rlc_pP->size_input_sdus_buffer; rlc_pP->nb_sdu -= 1; @@ -142,7 +142,7 @@ rlc_tm_rx ( ((struct rlc_tm_rx_pdu_management *) (tb_p->data))->first_byte = first_byte_p; rlc_tm_send_sdu (ctxt_pP, rlc_p, (((struct mac_tb_ind *) (tb_p->data))->error_indication), first_byte_p, data_indP.tb_size); - free_mem_block (tb_p); + free_mem_block (tb_p, __func__); } } @@ -235,6 +235,6 @@ rlc_tm_data_req ( rlc_p->input_sdus[rlc_p->next_sdu_index] = sdu_pP; rlc_p->next_sdu_index = (rlc_p->next_sdu_index + 1) % rlc_p->size_input_sdus_buffer; } else { - free_mem_block (sdu_pP); + free_mem_block (sdu_pP, __func__); } } diff --git a/openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm_init.c b/openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm_init.c index 4d75f3ee30cbd24b086d9728715f886945bb35eb..8ddea705cdc5acfb0949653089e7c81245688bbd 100644 --- a/openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm_init.c +++ b/openair2/LAYER2/RLC/TM_v9.3.0/rlc_tm_init.c @@ -82,7 +82,7 @@ void rlc_tm_init ( rlcP->size_input_sdus_buffer = 16; if ((rlcP->input_sdus_alloc == NULL) && (rlcP->size_input_sdus_buffer > 0)) { - rlcP->input_sdus_alloc = get_free_mem_block (rlcP->size_input_sdus_buffer * sizeof (void *)); + rlcP->input_sdus_alloc = get_free_mem_block (rlcP->size_input_sdus_buffer * sizeof (void *), __func__); rlcP->input_sdus = (mem_block_t **) (rlcP->input_sdus_alloc->data); memset (rlcP->input_sdus, 0, rlcP->size_input_sdus_buffer * sizeof (void *)); } @@ -114,17 +114,17 @@ rlc_tm_cleanup ( if (rlcP->input_sdus_alloc) { for (index = 0; index < rlcP->size_input_sdus_buffer; index++) { if (rlcP->input_sdus[index]) { - free_mem_block (rlcP->input_sdus[index]); + free_mem_block (rlcP->input_sdus[index], __func__); } } - free_mem_block (rlcP->input_sdus_alloc); + free_mem_block (rlcP->input_sdus_alloc, __func__); rlcP->input_sdus_alloc = NULL; } // RX SIDE if ((rlcP->output_sdu_in_construction)) { - free_mem_block (rlcP->output_sdu_in_construction); + free_mem_block (rlcP->output_sdu_in_construction, __func__); } memset(rlcP, 0, sizeof(rlc_tm_entity_t)); diff --git a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_control_primitives.c b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_control_primitives.c index 057be0000d45125d1cb9c454d98df2ae2de92b39..bda2b884581d885c96fcdccfa7ea45b1df3756a8 100644 --- a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_control_primitives.c +++ b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_control_primitives.c @@ -150,7 +150,7 @@ void config_req_rlc_um_asn1 ( break; default: - LOG_E(RLC,PROTOCOL_RLC_UM_CTXT_FMT" [CONFIGURE] RB %u INVALID UL sn_FieldLength %d, RLC NOT CONFIGURED\n", + LOG_E(RLC,PROTOCOL_RLC_UM_CTXT_FMT" [CONFIGURE] RB %u INVALID UL sn_FieldLength %ld, RLC NOT CONFIGURED\n", PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_p), rlc_p->rb_id, ul_rlc_pP->sn_FieldLength); @@ -178,7 +178,7 @@ void config_req_rlc_um_asn1 ( break; default: - LOG_E(RLC,PROTOCOL_RLC_UM_CTXT_FMT" [CONFIGURE] RB %u INVALID DL sn_FieldLength %d, RLC NOT CONFIGURED\n", + LOG_E(RLC,PROTOCOL_RLC_UM_CTXT_FMT" [CONFIGURE] RB %u INVALID DL sn_FieldLength %ld, RLC NOT CONFIGURED\n", PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_p), rlc_p->rb_id, dl_rlc_pP->sn_FieldLength); @@ -197,7 +197,7 @@ void config_req_rlc_um_asn1 ( if (dl_rlc_pP->t_Reorderingt_Reordering]; } else { - LOG_E(RLC,PROTOCOL_RLC_UM_CTXT_FMT" [CONFIGURE] RB %u INVALID T_Reordering %d, RLC NOT CONFIGURED\n", + LOG_E(RLC,PROTOCOL_RLC_UM_CTXT_FMT" [CONFIGURE] RB %u INVALID T_Reordering %ld, RLC NOT CONFIGURED\n", PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_p), rlc_p->rb_id, dl_rlc_pP->t_Reordering); @@ -334,13 +334,13 @@ rlc_um_cleanup ( list_free (&rlc_pP->pdus_from_mac_layer); if ((rlc_pP->output_sdu_in_construction)) { - free_mem_block (rlc_pP->output_sdu_in_construction); + free_mem_block (rlc_pP->output_sdu_in_construction, __func__); } if (rlc_pP->dar_buffer) { for (index = 0; index < 1024; index++) { if (rlc_pP->dar_buffer[index]) { - free_mem_block (rlc_pP->dar_buffer[index]); + free_mem_block (rlc_pP->dar_buffer[index], __func__); } } diff --git a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_dar.c b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_dar.c index fb83446e63bab8a41b1dad84d832b941f3d12050..4255464e3a220b4c2f5227bf47b63f5fcfd47b0b 100644 --- a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_dar.c +++ b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_dar.c @@ -130,6 +130,7 @@ int rlc_um_read_length_indicators(unsigned char**data_ppP, rlc_um_e_li_t* e_liP, unsigned int e2 = 0; unsigned int li2 = 0; *num_li_pP = 0; + int pdu_size = *data_size_pP; while ((continue_loop)) { //msg("[RLC_UM] e_liP->b1 = %02X\n", e_liP->b1); @@ -147,13 +148,39 @@ int rlc_um_read_length_indicators(unsigned char**data_ppP, rlc_um_e_li_t* e_liP, *data_size_pP = *data_size_pP - li2 - 1; *num_li_pP = *num_li_pP +1; + if (!(*data_size_pP >= 0)) LOG_E(RLC, "Invalid data_size=%d! (pdu_size=%d loop=%d e1=%d e2=%d li2=%d e_liP=%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x)\n", + *data_size_pP, pdu_size, continue_loop, e1, e2, li2, + (e_liP-(continue_loop-1)+0)->b1, + (e_liP-(continue_loop-1)+0)->b2, + (e_liP-(continue_loop-1)+0)->b3, + (e_liP-(continue_loop-1)+1)->b1, + (e_liP-(continue_loop-1)+1)->b2, + (e_liP-(continue_loop-1)+1)->b3, + (e_liP-(continue_loop-1)+2)->b1, + (e_liP-(continue_loop-1)+2)->b2, + (e_liP-(continue_loop-1)+2)->b3); + // AssertFatal(*data_size_pP >= 0, "Invalid data_size!"); + if (e2 == 0) { continue_loop = 0; } else { e_liP++; + continue_loop++; } } else { + if (!(*data_size_pP >= 0)) LOG_E(RLC, "Invalid data_size=%d! (pdu_size=%d loop=%d e1=%d li1=%d e_liP=%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x)\n", + *data_size_pP, pdu_size, continue_loop, e1, li1, + (e_liP-(continue_loop-1)+0)->b1, + (e_liP-(continue_loop-1)+0)->b2, + (e_liP-(continue_loop-1)+0)->b3, + (e_liP-(continue_loop-1)+1)->b1, + (e_liP-(continue_loop-1)+1)->b2, + (e_liP-(continue_loop-1)+1)->b3, + (e_liP-(continue_loop-1)+2)->b1, + (e_liP-(continue_loop-1)+2)->b2, + (e_liP-(continue_loop-1)+2)->b3); continue_loop = 0; + // AssertFatal(*data_size_pP >= 0, "Invalid data_size!"); } if (*num_li_pP >= RLC_UM_SEGMENT_NB_MAX_LI_PER_PDU) { @@ -162,7 +189,15 @@ int rlc_um_read_length_indicators(unsigned char**data_ppP, rlc_um_e_li_t* e_liP, } *data_ppP = *data_ppP + (((*num_li_pP*3) +1) >> 1); - return 0; + if (*data_size_pP > 0) { + return 0; + } else if (*data_size_pP == 0) { + LOG_W(RLC, "Last RLC SDU size is zero!\n"); + return -1; + } else { + LOG_W(RLC, "Last RLC SDU size is negative %d!\n", *data_size_pP); + return -1; + } } //----------------------------------------------------------------------------- void @@ -273,6 +308,9 @@ rlc_um_try_reassembly( __LINE__); #endif } + AssertFatal(size >= 0, "invalid size!"); + AssertFatal((e==0) || (e==1), "invalid e!"); + AssertFatal((fi >= 0) && (fi <= 3), "invalid fi!"); if (e == RLC_E_FIXED_PART_DATA_FIELD_FOLLOW) { switch (fi) { @@ -362,8 +400,9 @@ rlc_um_try_reassembly( break; default: - AssertFatal( 0 , PROTOCOL_RLC_UM_CTXT_FMT" TRY REASSEMBLY SHOULD NOT GO HERE (%s:%u)\n", + AssertFatal( 0 , PROTOCOL_RLC_UM_CTXT_FMT" fi=%d! TRY REASSEMBLY SHOULD NOT GO HERE (%s:%u)\n", PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP, rlc_pP), + fi, __FILE__, __LINE__); } @@ -504,8 +543,9 @@ rlc_um_try_reassembly( // data_p is already ok, done by last loop above rlc_um_reassembly (ctxt_pP, rlc_pP, data_p, size); } else { - AssertFatal( 0 !=0, PROTOCOL_RLC_UM_CTXT_FMT" SHOULD NOT GO HERE (%s:%u)\n", + AssertFatal( 0 !=0, PROTOCOL_RLC_UM_CTXT_FMT" size=%d! SHOULD NOT GO HERE (%s:%u)\n", PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP, rlc_pP), + size, __FILE__, __LINE__); //rlc_pP->stat_rx_data_pdu_dropped += 1; @@ -534,6 +574,12 @@ rlc_um_try_reassembly( __LINE__); #endif } + } else { + rlc_pP->stat_rx_data_pdu_dropped += 1; + rlc_pP->stat_rx_data_bytes_dropped += tb_ind_p->size; + rlc_pP->reassembly_missing_sn_detected = 1; + + LOG_W(RLC, "[SN %d] Bad RLC header! Discard this RLC PDU (size=%d)\n", sn, size); } } @@ -544,7 +590,7 @@ rlc_um_try_reassembly( __FILE__, __LINE__); #endif - free_mem_block(rlc_pP->dar_buffer[sn]); + free_mem_block(rlc_pP->dar_buffer[sn], __func__); rlc_pP->dar_buffer[sn] = NULL; } else { rlc_pP->last_reassemblied_missing_sn = sn; @@ -618,7 +664,7 @@ rlc_um_start_timer_reordering( rlc_pP->t_reordering.ms_time_out); #endif } else { - LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[T-REORDERING] NOT STARTED, CAUSE CONFIGURED 0 ms\n", + LOG_T(RLC, PROTOCOL_RLC_UM_CTXT_FMT"[T-REORDERING] NOT STARTED, CAUSE CONFIGURED 0 ms\n", PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_pP)); } } @@ -957,7 +1003,7 @@ rlc_um_receive_process_dar ( } else if (rlc_pP->rx_sn_length == 5) { sn = pdu_pP->b1 & 0x1F; } else { - free_mem_block(pdu_mem_pP); + free_mem_block(pdu_mem_pP, __func__); } RLC_UM_MUTEX_LOCK(&rlc_pP->lock_dar_buffer, ctxt_pP, rlc_pP); @@ -982,7 +1028,7 @@ rlc_um_receive_process_dar ( #endif rlc_pP->stat_rx_data_pdu_out_of_window += 1; rlc_pP->stat_rx_data_bytes_out_of_window += tb_sizeP; - free_mem_block(pdu_mem_pP); + free_mem_block(pdu_mem_pP, __func__); pdu_mem_pP = NULL; RLC_UM_MUTEX_UNLOCK(&rlc_pP->lock_dar_buffer); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_UM_RECEIVE_PROCESS_DAR, VCD_FUNCTION_OUT); @@ -1001,7 +1047,7 @@ rlc_um_receive_process_dar ( //discard the PDU rlc_pP->stat_rx_data_pdus_duplicate += 1; rlc_pP->stat_rx_data_bytes_duplicate += tb_sizeP; - free_mem_block(pdu_mem_pP); + free_mem_block(pdu_mem_pP, __func__); pdu_mem_pP = NULL; RLC_UM_MUTEX_UNLOCK(&rlc_pP->lock_dar_buffer); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_UM_RECEIVE_PROCESS_DAR, VCD_FUNCTION_OUT); @@ -1017,7 +1063,7 @@ rlc_um_receive_process_dar ( sn); #endif mem_block_t *pdu = rlc_um_remove_pdu_from_dar_buffer(ctxt_pP, rlc_pP, sn); - free_mem_block(pdu); + free_mem_block(pdu, __func__); } rlc_um_store_pdu_in_dar_buffer(ctxt_pP, rlc_pP, pdu_mem_pP, sn); diff --git a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_reassembly.c b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_reassembly.c index f8c6fdeabe50c364b2a65e05e1bba864b1f26afe..0805d708ca99fb01cb5eaea8197c52d52755a4a1 100644 --- a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_reassembly.c +++ b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_reassembly.c @@ -69,7 +69,7 @@ rlc_um_reassembly (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP if (rlc_pP->output_sdu_in_construction == NULL) { // msg("[RLC_UM_LITE] Getting mem_block ...\n"); - rlc_pP->output_sdu_in_construction = get_free_mem_block (sdu_max_size); + rlc_pP->output_sdu_in_construction = get_free_mem_block (sdu_max_size, __func__); rlc_pP->output_sdu_size_to_write = 0; } diff --git a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_receiver.c b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_receiver.c index 585ceacb9bdfa13b838caa52dd5021aa8e04f7a8..3f083a77a881bc069c6597a9a7ec280dc50d69b2 100644 --- a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_receiver.c +++ b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_receiver.c @@ -83,7 +83,7 @@ rlc_um_display_rx_window( LOG_T(RLC, "\n"); } - LOG_T(RLC, "%s%s| %04d |", RLC_FG_COLOR_DEFAULT, RLC_NORMAL_VIDEO, sn); + LOG_T(RLC, "%s%s| %04lu |", RLC_FG_COLOR_DEFAULT, RLC_NORMAL_VIDEO, sn); } strcpy(color, RLC_FG_COLOR_DEFAULT); diff --git a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_segment.c b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_segment.c index 5ce681723e729e475104dcb45e6ad80dc5c722dd..bae9bd8d80535e3bfc253b7f272e99b3ff96f81c 100644 --- a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_segment.c +++ b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_segment.c @@ -115,7 +115,7 @@ rlc_um_segment_10 (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP #endif } - if (!(pdu_mem_p = get_free_mem_block (data_pdu_size + sizeof(struct mac_tb_req)))) { + if (!(pdu_mem_p = get_free_mem_block (data_pdu_size + sizeof(struct mac_tb_req), __func__))) { #if TRACE_RLC_UM_SEGMENT LOG_E(RLC, PROTOCOL_RLC_UM_CTXT_FMT" ERROR COULD NOT GET NEW PDU, EXIT\n", PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_pP)); @@ -291,7 +291,7 @@ rlc_um_segment_10 (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP // free SDU rlc_pP->buffer_occupancy -= sdu_mngt_p->sdu_remaining_size; sdu_in_buffer = list_remove_head(&rlc_pP->input_sdus); - free_mem_block (sdu_in_buffer); + free_mem_block (sdu_in_buffer, __func__); sdu_in_buffer = list_get_head(&rlc_pP->input_sdus); sdu_mngt_p = NULL; @@ -356,7 +356,7 @@ rlc_um_segment_10 (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP // free SDU rlc_pP->buffer_occupancy -= sdu_mngt_p->sdu_remaining_size; sdu_in_buffer = list_remove_head(&rlc_pP->input_sdus); - free_mem_block (sdu_in_buffer); + free_mem_block (sdu_in_buffer, __func__); sdu_in_buffer = list_get_head(&rlc_pP->input_sdus); sdu_mngt_p = NULL; @@ -380,7 +380,7 @@ rlc_um_segment_10 (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP // free SDU rlc_pP->buffer_occupancy -= sdu_mngt_p->sdu_remaining_size; sdu_in_buffer = list_remove_head(&rlc_pP->input_sdus); - free_mem_block (sdu_in_buffer); + free_mem_block (sdu_in_buffer, __func__); sdu_in_buffer = list_get_head(&rlc_pP->input_sdus); sdu_mngt_p = NULL; @@ -503,7 +503,7 @@ rlc_um_segment_5 (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP) #endif } - if (!(pdu_mem_p = get_free_mem_block (data_pdu_size + sizeof(struct mac_tb_req)))) { + if (!(pdu_mem_p = get_free_mem_block (data_pdu_size + sizeof(struct mac_tb_req), __func__))) { #if TRACE_RLC_UM_SEGMENT LOG_E(RLC, PROTOCOL_RLC_UM_CTXT_FMT" ERROR COULD NOT GET NEW PDU, EXIT\n", PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_pP)); @@ -679,7 +679,7 @@ rlc_um_segment_5 (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP) // free SDU rlc_pP->buffer_occupancy -= sdu_mngt_p->sdu_remaining_size; sdu_in_buffer = list_remove_head(&rlc_pP->input_sdus); - free_mem_block (sdu_in_buffer); + free_mem_block (sdu_in_buffer, __func__); sdu_in_buffer = list_get_head(&rlc_pP->input_sdus); sdu_mngt_p = NULL; @@ -743,7 +743,7 @@ rlc_um_segment_5 (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP) // free SDU rlc_pP->buffer_occupancy -= sdu_mngt_p->sdu_remaining_size; sdu_in_buffer = list_remove_head(&rlc_pP->input_sdus); - free_mem_block (sdu_in_buffer); + free_mem_block (sdu_in_buffer, __func__); sdu_in_buffer = list_get_head(&rlc_pP->input_sdus); sdu_mngt_p = NULL; @@ -765,7 +765,7 @@ rlc_um_segment_5 (const protocol_ctxt_t* const ctxt_pP, rlc_um_entity_t *rlc_pP) // free SDU rlc_pP->buffer_occupancy -= sdu_mngt_p->sdu_remaining_size; sdu_in_buffer = list_remove_head(&rlc_pP->input_sdus); - free_mem_block (sdu_in_buffer); + free_mem_block (sdu_in_buffer, __func__); sdu_in_buffer = list_get_head(&rlc_pP->input_sdus); sdu_mngt_p = NULL; } diff --git a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_test.c b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_test.c index 92f18e72d7629e228aa4627dc850b3493d7888d5..fced6efbf92bff76713c998974b19897185dd659 100644 --- a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_test.c +++ b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_test.c @@ -301,7 +301,7 @@ void rlc_um_v9_3_0_test_send_sdu(rlc_um_entity_t *um_txP, int sdu_indexP) //----------------------------------------------------------------------------- { mem_block_t *sdu; - sdu = get_free_mem_block (strlen(g_sdus[sdu_indexP]) + 1 + sizeof (struct rlc_um_data_req_alloc)); + sdu = get_free_mem_block (strlen(g_sdus[sdu_indexP]) + 1 + sizeof (struct rlc_um_data_req_alloc), __func__); if (sdu != NULL) { // PROCESS OF COMPRESSION HERE: @@ -405,12 +405,12 @@ void rlc_um_v9_3_0_test_mac_rlc_loop (struct mac_data_ind* data_indP, struct ma *tx_packetsP = *tx_packetsP + 1; if (*drop_countP == 0) { - tb_dst = get_free_mem_block(sizeof (mac_rlc_max_rx_header_size_t) + tb_size); + tb_dst = get_free_mem_block(sizeof (mac_rlc_max_rx_header_size_t) + tb_size, __func__); memset(tb_dst->data, 0, sizeof (mac_rlc_max_rx_header_size_t) + tb_size); if (tb_dst != NULL) { //printf("[RLC-LOOP] Testing tb_dst (1)\n"); - check_free_mem_block(tb_dst); + check_free_mem_block(tb_dst, __func__); tb_dst->next = NULL; ((struct mac_tb_ind *) (tb_dst->data))->first_bit = 0; ((struct mac_tb_ind *) (tb_dst->data))->data_ptr = &tb_dst->data[sizeof (mac_rlc_max_rx_header_size_t)]; @@ -424,7 +424,7 @@ void rlc_um_v9_3_0_test_mac_rlc_loop (struct mac_data_ind* data_indP, struct ma list_add_tail_eurecom(tb_dst, &data_indP->data); data_indP->no_tb += 1; //printf("[RLC-LOOP] Testing tb_dst (2)\n"); - check_free_mem_block(tb_dst); + check_free_mem_block(tb_dst, __func__); } else { printf("Out of memory error\n"); exit(-1); @@ -437,9 +437,9 @@ void rlc_um_v9_3_0_test_mac_rlc_loop (struct mac_data_ind* data_indP, struct ma //printf("[RLC-LOOP] Testing tb_src\n"); - check_free_mem_block(tb_src); + check_free_mem_block(tb_src, __func__); - free_mem_block(tb_src); + free_mem_block(tb_src, __func__); if (data_indP->no_tb > 0) { printf("[RLC-LOOP] Exchange %d TBs\n",data_indP->no_tb); @@ -578,13 +578,13 @@ void rlc_um_v9_3_0_test_data_ind (module_id_t module_idP, rb_id_t rb_idP, sdu_si assert(g_send_sdu_ids[g_send_id_read_index[rb_idP]][rb_idP^1] == i); g_send_id_read_index[rb_idP] += 1; - free_mem_block(sduP); + free_mem_block(sduP, __func__); return; } } printf("[FRAME %05d][RLC][MOD %d][RB %d] RX UNKNOWN SDU %04d bytes\n",g_frame,module_idP, rb_idP, sizeP); - free_mem_block(sduP); + free_mem_block(sduP, __func__); assert(1==2); } else { for (i = 0; i < 37; i++) { @@ -592,13 +592,13 @@ void rlc_um_v9_3_0_test_data_ind (module_id_t module_idP, rb_id_t rb_idP, sdu_si printf("[FRAME %05d][RLC][MOD %02d][RB %02d] RX SDU %d %04d bytes\n",g_frame,module_idP, rb_idP, i, sizeP); assert(TEST_MAX_SEND_SDU > g_send_id_read_index[rb_idP]); g_send_id_read_index[rb_idP] += 1; - free_mem_block(sduP); + free_mem_block(sduP, __func__); return; } } printf("[FRAME %05d][RLC][MOD %d][RB %d] RX UNKNOWN SDU %04d bytes\n",g_frame,module_idP, rb_idP, sizeP); - free_mem_block(sduP); + free_mem_block(sduP, __func__); return; } } diff --git a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_very_simple_test.c b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_very_simple_test.c index ef6ca75be90435a9d9001dd49e2c9007dd48901d..9934fd3a588e2d7f921005a0226ba9fa18ae2322 100644 --- a/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_very_simple_test.c +++ b/openair2/LAYER2/RLC/UM_v9.3.0/rlc_um_very_simple_test.c @@ -44,7 +44,7 @@ rlc_um_test_send_sdu (rlc_um_entity_t* rlcP, uint32_t frame, unsigned int s switch (sdu_typeP) { case RLC_UM_TEST_SDU_TYPE_TCPIP: - sdu_mem = get_free_mem_block (strlen(tcip_sdu)+ 1 + sizeof (struct rlc_um_data_req_alloc)); + sdu_mem = get_free_mem_block (strlen(tcip_sdu)+ 1 + sizeof (struct rlc_um_data_req_alloc), __func__); if (sdu_mem != NULL) { memset (sdu_mem->data, 0, sizeof (struct rlc_um_data_req_alloc)); @@ -59,7 +59,7 @@ rlc_um_test_send_sdu (rlc_um_entity_t* rlcP, uint32_t frame, unsigned int s break; case RLC_UM_TEST_SDU_TYPE_VOIP: - sdu_mem = get_free_mem_block (strlen(voip_sdu)+ 1 + sizeof (struct rlc_um_data_req_alloc)); + sdu_mem = get_free_mem_block (strlen(voip_sdu)+ 1 + sizeof (struct rlc_um_data_req_alloc), __func__); if (sdu_mem != NULL) { memset (sdu_mem->data, 0, sizeof (struct rlc_um_data_req_alloc)); @@ -74,7 +74,7 @@ rlc_um_test_send_sdu (rlc_um_entity_t* rlcP, uint32_t frame, unsigned int s break; case RLC_UM_TEST_SDU_TYPE_SMALL: - sdu_mem = get_free_mem_block (strlen(very_small_sdu)+ 1 + sizeof (struct rlc_um_data_req_alloc)); + sdu_mem = get_free_mem_block (strlen(very_small_sdu)+ 1 + sizeof (struct rlc_um_data_req_alloc), __func__); if (sdu_mem != NULL) { memset (sdu_mem->data, 0, sizeof (struct rlc_um_data_req_alloc)); diff --git a/openair2/LAYER2/RLC/rlc.c b/openair2/LAYER2/RLC/rlc.c index 3fe5c6cb41619508e4f615898b1b38a475062163..96057231a6596f07fc23ed124a902f34f1e534a5 100644 --- a/openair2/LAYER2/RLC/rlc.c +++ b/openair2/LAYER2/RLC/rlc.c @@ -71,7 +71,7 @@ void rlc_util_print_hex_octets(comp_name_t componentP, unsigned char* dataP, con LOG_T(componentP, " |\n"); } - LOG_T(componentP, " %04d |", octet_index); + LOG_T(componentP, " %04lu |", octet_index); } /* @@ -413,7 +413,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP, switch (rlc_mode) { case RLC_MODE_NONE: - free_mem_block(sdu_pP); + free_mem_block(sdu_pP, __func__); LOG_E(RLC, PROTOCOL_CTXT_FMT" Received RLC_MODE_NONE as rlc_type for rb_id %u\n", PROTOCOL_CTXT_ARGS(ctxt_pP), rb_idP); @@ -424,7 +424,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP, #ifdef DEBUG_RLC_DATA_REQ msg("RLC_MODE_AM\n"); #endif - new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_am_data_req_alloc)); + new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_am_data_req_alloc), __func__); if (new_sdu_p != NULL) { // PROCESS OF COMPRESSION HERE: @@ -435,7 +435,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP, ((struct rlc_am_data_req *) (new_sdu_p->data))->conf = confirmP; ((struct rlc_am_data_req *) (new_sdu_p->data))->mui = muiP; ((struct rlc_am_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_am_data_req_alloc); - free_mem_block(sdu_pP); + free_mem_block(sdu_pP, __func__); rlc_am_data_req(ctxt_pP, &rlc_union_p->rlc.am, new_sdu_p); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT); return RLC_OP_STATUS_OK; @@ -447,7 +447,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP, break; case RLC_MODE_UM: - new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_um_data_req_alloc)); + new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_um_data_req_alloc), __func__); if (new_sdu_p != NULL) { // PROCESS OF COMPRESSION HERE: @@ -456,11 +456,11 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP, ((struct rlc_um_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP; ((struct rlc_um_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_um_data_req_alloc); - free_mem_block(sdu_pP); + free_mem_block(sdu_pP, __func__); rlc_um_data_req(ctxt_pP, &rlc_union_p->rlc.um, new_sdu_p); - //free_mem_block(new_sdu); + //free_mem_block(new_sdu, __func__); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT); return RLC_OP_STATUS_OK; } else { @@ -471,7 +471,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP, break; case RLC_MODE_TM: - new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_tm_data_req_alloc)); + new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_tm_data_req_alloc), __func__); if (new_sdu_p != NULL) { // PROCESS OF COMPRESSION HERE: @@ -480,7 +480,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP, ((struct rlc_tm_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP; ((struct rlc_tm_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_tm_data_req_alloc); - free_mem_block(sdu_pP); + free_mem_block(sdu_pP, __func__); rlc_tm_data_req(ctxt_pP, &rlc_union_p->rlc.tm, new_sdu_p); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT); return RLC_OP_STATUS_OK; @@ -493,7 +493,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP, break; default: - free_mem_block(sdu_pP); + free_mem_block(sdu_pP, __func__); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT); return RLC_OP_STATUS_INTERNAL_ERROR; @@ -505,7 +505,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP, if (sdu_pP != NULL) { if (sdu_sizeP > 0) { LOG_I(RLC,"received a packet with size %d for MBMS \n", sdu_sizeP); - new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_um_data_req_alloc)); + new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_um_data_req_alloc), __func__); if (new_sdu_p != NULL) { // PROCESS OF COMPRESSION HERE: @@ -513,10 +513,10 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP, memcpy (&new_sdu_p->data[sizeof (struct rlc_um_data_req_alloc)], &sdu_pP->data[0], sdu_sizeP); ((struct rlc_um_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP; ((struct rlc_um_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_um_data_req_alloc); - free_mem_block(sdu_pP); + free_mem_block(sdu_pP, __func__); rlc_um_data_req(ctxt_pP, &rlc_union_p->rlc.um, new_sdu_p); - //free_mem_block(new_sdu); + //free_mem_block(new_sdu, __func__); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT); return RLC_OP_STATUS_OK; } else { @@ -537,7 +537,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP, } else /* MBMS_flag != 0 */ { - free_mem_block(sdu_pP); + free_mem_block(sdu_pP, __func__); LOG_E(RLC, "MBMS_flag != 0 while Rel10 is not defined...\n"); //handle_event(ERROR,"FILE %s FONCTION rlc_data_req() LINE %s : parameter module_id out of bounds :%d\n", __FILE__, __LINE__, module_idP); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT); diff --git a/openair2/LAYER2/RLC/rlc_mac.c b/openair2/LAYER2/RLC/rlc_mac.c index d59b187dc763ea19dca362597393309fb1e03969..d43a90ed6a5d5d982f3a9d26ec094d9597182fd1 100644 --- a/openair2/LAYER2/RLC/rlc_mac.c +++ b/openair2/LAYER2/RLC/rlc_mac.c @@ -57,7 +57,7 @@ struct mac_data_ind mac_rlc_deserialize_tb ( list_init(&data_ind.data, NULL); while (num_tbP > 0) { - tb_p = get_free_mem_block(sizeof (mac_rlc_max_rx_header_size_t) + tb_sizeP); + tb_p = get_free_mem_block(sizeof (mac_rlc_max_rx_header_size_t) + tb_sizeP, __func__); if (tb_p != NULL) { ((struct mac_tb_ind *) (tb_p->data))->first_bit = 0; @@ -110,7 +110,7 @@ tbs_size_t mac_rlc_serialize_tb (char* buffer_pP, list_t transport_blocksP) #endif memcpy(&buffer_pP[tbs_size], &((struct mac_tb_req *) (tb_p->data))->data_ptr[0], tb_size); tbs_size = tbs_size + tb_size; - free_mem_block(tb_p); + free_mem_block(tb_p, __func__); } } diff --git a/openair2/LAYER2/RLC/rlc_rrc.c b/openair2/LAYER2/RLC/rlc_rrc.c index 9ef8bd87005280f712203fb4ac8ce9780ade675a..8304752e8e2b91811afc03185099cdaff7e0724e 100644 --- a/openair2/LAYER2/RLC/rlc_rrc.c +++ b/openair2/LAYER2/RLC/rlc_rrc.c @@ -99,7 +99,7 @@ rlc_op_status_t rrc_rlc_config_asn1_req (const protocol_ctxt_t * const ctxt_pP rb_id = srb2add_listP->list.array[cnt]->srb_Identity; lc_id = rb_id; - LOG_D(RLC, "Adding SRB %d, rb_id %d\n",srb2add_listP->list.array[cnt]->srb_Identity,rb_id); + LOG_D(RLC, "Adding SRB %ld, rb_id %d\n",srb2add_listP->list.array[cnt]->srb_Identity,rb_id); srb_toaddmod_p = srb2add_listP->list.array[cnt]; if (srb_toaddmod_p->rlc_Config) { @@ -259,7 +259,7 @@ rlc_op_status_t rrc_rlc_config_asn1_req (const protocol_ctxt_t * const ctxt_pP continue; } - LOG_D(RLC, "Adding DRB %d, lc_id %d\n",drb_id,lc_id); + LOG_D(RLC, "Adding DRB %ld, lc_id %d\n",drb_id,lc_id); if (drb_toaddmod_p->rlc_Config) { @@ -325,7 +325,7 @@ rlc_op_status_t rrc_rlc_config_asn1_req (const protocol_ctxt_t * const ctxt_pP break; default: - LOG_W(RLC, PROTOCOL_CTXT_FMT"[RB %u] unknown drb_toaddmod_p->rlc_Config->present \n", + LOG_W(RLC, PROTOCOL_CTXT_FMT"[RB %ld] unknown drb_toaddmod_p->rlc_Config->present \n", PROTOCOL_CTXT_ARGS(ctxt_pP), drb_id); } @@ -786,7 +786,7 @@ rlc_op_status_t rrc_rlc_data_req ( //----------------------------------------------------------------------------- mem_block_t* sdu; - sdu = get_free_mem_block(sdu_sizeP); + sdu = get_free_mem_block(sdu_sizeP, __func__); if (sdu != NULL) { memcpy (sdu->data, sduP, sdu_sizeP); diff --git a/openair2/PHY_INTERFACE/defs.h b/openair2/PHY_INTERFACE/defs.h index 156b9091b7f82d7e9ccda1a490b995599e02574c..497325205491c028ec944dc80d68b929e24b1bea 100644 --- a/openair2/PHY_INTERFACE/defs.h +++ b/openair2/PHY_INTERFACE/defs.h @@ -152,7 +152,7 @@ typedef struct { 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); + void (*ue_send_sdu)(module_id_t Mod_id,uint8_t CC_id,frame_t frameP,sub_frame_t subframe,uint8_t *sdu,uint16_t sdu_len,uint8_t CH_index); #ifdef Rel10 /// Send a received MCH sdu to MAC diff --git a/openair2/RRC/LITE/MESSAGES/asn1_msg.c b/openair2/RRC/LITE/MESSAGES/asn1_msg.c index 5f9a8e0e2a735284cf8b0616ef4f512429a71405..b4290e8b9de4c61219a8580f9b67f7a9d881c5ae 100644 --- a/openair2/RRC/LITE/MESSAGES/asn1_msg.c +++ b/openair2/RRC/LITE/MESSAGES/asn1_msg.c @@ -99,7 +99,7 @@ int errno; # endif #endif -#define XER_PRINT +//#define XER_PRINT extern Enb_properties_array_t enb_properties; typedef struct xer_sprint_string_s { diff --git a/openair2/RRC/LITE/defs.h b/openair2/RRC/LITE/defs.h index 0b0fd6b73fa73097e1fd3e385d1d015254986aa3..47f8a0080adf5311a20c92d9c21312e64dbcd764 100644 --- a/openair2/RRC/LITE/defs.h +++ b/openair2/RRC/LITE/defs.h @@ -102,6 +102,14 @@ # include "intertask_interface.h" #endif +/* TODO: be sure this include is correct. + * It solves a problem of compilation of the RRH GW, + * issue #186. + */ +#if !defined(ENABLE_ITTI) +# include "as_message.h" +#endif + #if defined(ENABLE_USE_MME) # include "commonDef.h" #endif diff --git a/openair2/RRC/LITE/rrc_UE.c b/openair2/RRC/LITE/rrc_UE.c index 38d7121860b5c06c7bb8357623c1e8d769b4ea4e..a6290f1f3cbcd57b80ebb8b34bb84d5e29b53f37 100644 --- a/openair2/RRC/LITE/rrc_UE.c +++ b/openair2/RRC/LITE/rrc_UE.c @@ -98,7 +98,7 @@ extern UE_MAC_INST *UE_mac_inst; extern void *bigphys_malloc(int); #endif -#define XER_PRINT +//#define XER_PRINT extern int8_t dB_fixed2(uint32_t x,uint32_t y); @@ -545,7 +545,7 @@ int rrc_ue_decode_ccch( const protocol_ctxt_t* const ctxt_pP, const SRB_INFO* co #endif if ((dec_rval.code != RC_OK) && (dec_rval.consumed==0)) { - LOG_E(RRC,"[UE %d] Frame %d : Failed to decode DL-CCCH-Message (%d bytes)\n",ctxt_pP->module_id,dec_rval.consumed); + LOG_E(RRC,"[UE %d] Frame %d : Failed to decode DL-CCCH-Message (%zu bytes)\n",ctxt_pP->module_id,ctxt_pP->frame,dec_rval.consumed); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH, VCD_FUNCTION_OUT); return -1; } @@ -799,15 +799,15 @@ rrc_ue_process_measConfig( ind = measConfig->measObjectToAddModList->list.array[i]->measObjectId; if (UE_rrc_inst[ctxt_pP->module_id].MeasObj[eNB_index][ind-1]) { - LOG_D(RRC,"Modifying measurement object %d\n",ind); + LOG_D(RRC,"Modifying measurement object %ld\n",ind); memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].MeasObj[eNB_index][ind-1], (char*)measObj, sizeof(MeasObjectToAddMod_t)); } else { - LOG_I(RRC,"Adding measurement object %d\n",ind); + LOG_I(RRC,"Adding measurement object %ld\n",ind); if (measObj->measObject.present == MeasObjectToAddMod__measObject_PR_measObjectEUTRA) { - LOG_I(RRC,"EUTRA Measurement : carrierFreq %d, allowedMeasBandwidth %d,presenceAntennaPort1 %d, neighCellConfig %d\n", + LOG_I(RRC,"EUTRA Measurement : carrierFreq %ld, allowedMeasBandwidth %ld,presenceAntennaPort1 %d, neighCellConfig %d\n", measObj->measObject.choice.measObjectEUTRA.carrierFreq, measObj->measObject.choice.measObjectEUTRA.allowedMeasBandwidth, measObj->measObject.choice.measObjectEUTRA.presenceAntennaPort1, @@ -866,12 +866,12 @@ rrc_ue_process_measConfig( ind = measConfig->reportConfigToAddModList->list.array[i]->reportConfigId; if (UE_rrc_inst[ctxt_pP->module_id].ReportConfig[eNB_index][ind-1]) { - LOG_I(RRC,"Modifying Report Configuration %d\n",ind-1); + LOG_I(RRC,"Modifying Report Configuration %ld\n",ind-1); memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].ReportConfig[eNB_index][ind-1], (char*)measConfig->reportConfigToAddModList->list.array[i], sizeof(ReportConfigToAddMod_t)); } else { - LOG_D(RRC,"Adding Report Configuration %d %p \n",ind-1,measConfig->reportConfigToAddModList->list.array[i]); + LOG_D(RRC,"Adding Report Configuration %ld %p \n",ind-1,measConfig->reportConfigToAddModList->list.array[i]); UE_rrc_inst[ctxt_pP->module_id].ReportConfig[eNB_index][ind-1] = measConfig->reportConfigToAddModList->list.array[i]; } } @@ -901,12 +901,12 @@ rrc_ue_process_measConfig( ind = measConfig->measIdToAddModList->list.array[i]->measId; if (UE_rrc_inst[ctxt_pP->module_id].MeasId[eNB_index][ind-1]) { - LOG_D(RRC,"Modifying Measurement ID %d\n",ind-1); + LOG_D(RRC,"Modifying Measurement ID %ld\n",ind-1); memcpy((char*)UE_rrc_inst[ctxt_pP->module_id].MeasId[eNB_index][ind-1], (char*)measConfig->measIdToAddModList->list.array[i], sizeof(MeasIdToAddMod_t)); } else { - LOG_D(RRC,"Adding Measurement ID %d %p\n",ind-1,measConfig->measIdToAddModList->list.array[i]); + LOG_D(RRC,"Adding Measurement ID %ld %p\n",ind-1,measConfig->measIdToAddModList->list.array[i]); UE_rrc_inst[ctxt_pP->module_id].MeasId[eNB_index][ind-1] = measConfig->measIdToAddModList->list.array[i]; } } @@ -938,13 +938,11 @@ rrc_ue_process_measConfig( UE_rrc_inst[ctxt_pP->module_id].filter_coeff_rsrq = 1./pow(2, (*UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index]->quantityConfigEUTRA->filterCoefficientRSRQ)/4); - LOG_I(RRC,"[UE %d] set rsrp-coeff for eNB %d: %d rsrq-coeff: %d rsrp_factor: %f rsrq_factor: %f \n", + LOG_I(RRC,"[UE %d] set rsrp-coeff for eNB %d: %ld rsrq-coeff: %ld rsrp_factor: %f rsrq_factor: %f \n", ctxt_pP->module_id, eNB_index, // UE_rrc_inst[ue_mod_idP].Info[eNB_index].UE_index, *UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index]->quantityConfigEUTRA->filterCoefficientRSRP, *UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[eNB_index]->quantityConfigEUTRA->filterCoefficientRSRQ, UE_rrc_inst[ctxt_pP->module_id].filter_coeff_rsrp, - UE_rrc_inst[ctxt_pP->module_id].filter_coeff_rsrp, - UE_rrc_inst[ctxt_pP->module_id].filter_coeff_rsrp, UE_rrc_inst[ctxt_pP->module_id].filter_coeff_rsrq); } @@ -1467,7 +1465,7 @@ rrc_ue_process_radioResourceConfigDedicated( UE_rrc_inst[ctxt_pP->module_id].DRB_config[eNB_index][DRB_id] = radioResourceConfigDedicated->drb_ToAddModList->list.array[i]; rrc_ue_establish_drb(ctxt_pP->module_id,ctxt_pP->frame,eNB_index,radioResourceConfigDedicated->drb_ToAddModList->list.array[i]); // MAC/PHY Configuration - LOG_I(RRC, "[FRAME %05d][RRC_UE][MOD %02d][][--- MAC_CONFIG_REQ (DRB %d eNB %d) --->][MAC_UE][MOD %02d][]\n", + LOG_I(RRC, "[FRAME %05d][RRC_UE][MOD %02d][][--- MAC_CONFIG_REQ (DRB %ld eNB %d) --->][MAC_UE][MOD %02d][]\n", ctxt_pP->frame, ctxt_pP->module_id, radioResourceConfigDedicated->drb_ToAddModList->list.array[i]->drb_Identity, eNB_index, @@ -1619,7 +1617,7 @@ rrc_ue_process_securityModeCommand( h_rc = hashtable_get(pdcp_coll_p, key, (void**) &pdcp_p); if (h_rc == HASH_TABLE_OK) { - LOG_D(RRC, "PDCP_COLL_KEY_VALUE() returns valid key = %d\n", key); + LOG_D(RRC, "PDCP_COLL_KEY_VALUE() returns valid key = %ld\n", key); LOG_D(RRC, "driving kRRCenc, kRRCint and kUPenc from KeNB=" "%02x%02x%02x%02x" @@ -1656,7 +1654,7 @@ rrc_ue_process_securityModeCommand( securityMode); } } else { - LOG_W(RRC, "Could not get PDCP instance where key=0x%\n", key); + LOG_W(RRC, "Could not get PDCP instance where key=0x%ld\n", key); } #endif //#if defined(ENABLE_SECURITY) @@ -1702,7 +1700,7 @@ rrc_ue_process_securityModeCommand( #endif #ifdef USER_MODE - LOG_D(RRC, "securityModeComplete Encoded %d bits (%d bytes)\n", enc_rval.encoded, (enc_rval.encoded+7)/8); + LOG_D(RRC, "securityModeComplete Encoded %zd bits (%zd bytes)\n", enc_rval.encoded, (enc_rval.encoded+7)/8); #endif for (i = 0; i < (enc_rval.encoded + 7) / 8; i++) { @@ -1807,7 +1805,7 @@ rrc_ue_process_ueCapabilityEnquiry( #endif #ifdef USER_MODE - LOG_D(RRC,"UECapabilityInformation Encoded %d bits (%d bytes)\n",enc_rval.encoded,(enc_rval.encoded+7)/8); + LOG_D(RRC,"UECapabilityInformation Encoded %zd bits (%zd bytes)\n",enc_rval.encoded,(enc_rval.encoded+7)/8); #endif for (i = 0; i < (enc_rval.encoded + 7) / 8; i++) { @@ -2218,7 +2216,7 @@ rrc_ue_decode_dcch( if (UE_rrc_inst[ctxt_pP->module_id].HandoverInfoUe.targetCellId != dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.mobilityControlInfo->targetPhysCellId) { LOG_W(RRC, - "[UE %d] Frame %d: Handover target (%d) is different from RSRP measured target (%d)..\n", + "[UE %d] Frame %d: Handover target (%ld) is different from RSRP measured target (%ld)..\n", ctxt_pP->module_id, ctxt_pP->frame, dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration.criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8.mobilityControlInfo->targetPhysCellId, @@ -3134,7 +3132,8 @@ static void dump_sib2( SystemInformationBlockType2_t *sib2 ) LOG_I( RRC, "radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.ackNackSRS_SimultaneousTransmission : %d\n", sib2->radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.ackNackSRS_SimultaneousTransmission ); LOG_I( RRC, "radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.srs_MaxUpPts : %ld\n", - sib2->radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.srs_MaxUpPts ); + /* TODO: check that it's okay to access [0] */ + sib2->radioResourceConfigCommon.soundingRS_UL_ConfigCommon.choice.setup.srs_MaxUpPts[0] ); } // uplinkPowerControlCommon @@ -3378,7 +3377,7 @@ uint64_t arfcn_to_freq(long arfcn) { else if (arfcn <45590) // Band 43 return((uint64_t)3600000000 + ((arfcn-43950)*100000)); else { - LOG_E(RRC,"Unknown EARFCN %d\n",arfcn); + LOG_E(RRC,"Unknown EARFCN %ld\n",arfcn); exit(1); } } @@ -3393,19 +3392,20 @@ static void dump_sib5( SystemInformationBlockType5_t *sib5 ) for (i=0;idl_CarrierFreq), ifcfInfo->dl_CarrierFreq); - LOG_I(RRC," Q_RXLevMin : %d\n", ifcfInfo->q_RxLevMin); - LOG_I(RRC," P_max : %d\n",ifcfInfo->p_Max); - LOG_I(RRC," T_ReselectionEUTRA : %d\n",ifcfInfo->t_ReselectionEUTRA); + LOG_I(RRC," Q_RXLevMin : %ld\n", ifcfInfo->q_RxLevMin); + if (ifcfInfo->p_Max != NULL) + LOG_I(RRC," P_max : %ld\n", *ifcfInfo->p_Max); + LOG_I(RRC," T_ReselectionEUTRA : %ld\n",ifcfInfo->t_ReselectionEUTRA); if (ifcfInfo->t_ReselectionEUTRA_SF) { - LOG_I(RRC," t_ReselectionEUTRA_SF.sf_Medium %d, t_ReselectionEUTRA_SF.sf_High %d", + LOG_I(RRC," t_ReselectionEUTRA_SF.sf_Medium %ld, t_ReselectionEUTRA_SF.sf_High %ld", ifcfInfo->t_ReselectionEUTRA_SF->sf_Medium, ifcfInfo->t_ReselectionEUTRA_SF->sf_High); } - LOG_I(RRC," threshX_High : %d\n",ifcfInfo->threshX_High); - LOG_I(RRC," threshX_Low : %d\n",ifcfInfo->threshX_Low); + LOG_I(RRC," threshX_High : %ld\n",ifcfInfo->threshX_High); + LOG_I(RRC," threshX_Low : %ld\n",ifcfInfo->threshX_Low); switch(ifcfInfo->allowedMeasBandwidth) { case AllowedMeasBandwidth_mbw6: LOG_I(RRC," AllowedMeasBandwidth : 6\n"); @@ -3431,7 +3431,7 @@ static void dump_sib5( SystemInformationBlockType5_t *sib5 ) else LOG_I(RRC," PresenceAntennaPort1 : False\n"); if (ifcfInfo->cellReselectionPriority) { - LOG_I(RRC," CellReselectionPriority : %d\n", + LOG_I(RRC," CellReselectionPriority : %ld\n", *ifcfInfo->cellReselectionPriority); } LOG_I(RRC," NeighCellConfig : "); @@ -3444,29 +3444,29 @@ static void dump_sib5( SystemInformationBlockType5_t *sib5 ) if (ifcfInfo->interFreqNeighCellList) { for (j=0;jinterFreqNeighCellList->list.count;j++) { - LOG_I(RRC," Cell %d\n"); - LOG_I(RRC," PhysCellId : %d\n",ifcfInfo->interFreqNeighCellList->list.array[j]->physCellId); - LOG_I(RRC," Q_OffsetRange : %d\n",ifcfInfo->interFreqNeighCellList->list.array[j]->q_OffsetCell); + LOG_I(RRC," Cell %d\n", j); + LOG_I(RRC," PhysCellId : %ld\n",ifcfInfo->interFreqNeighCellList->list.array[j]->physCellId); + LOG_I(RRC," Q_OffsetRange : %ld\n",ifcfInfo->interFreqNeighCellList->list.array[j]->q_OffsetCell); } } if (ifcfInfo->interFreqBlackCellList) { for (j=0;jinterFreqBlackCellList->list.count;j++) { - LOG_I(RRC," Cell %d\n"); - LOG_I(RRC," PhysCellId start: %d\n",ifcfInfo->interFreqBlackCellList->list.array[j]->start); + LOG_I(RRC," Cell %d\n", j); + LOG_I(RRC," PhysCellId start: %ld\n",ifcfInfo->interFreqBlackCellList->list.array[j]->start); if (ifcfInfo->interFreqBlackCellList->list.array[i]->range) { - LOG_I(RRC," PhysCellId Range : %d\n",ifcfInfo->interFreqBlackCellList->list.array[j]->range); + LOG_I(RRC," PhysCellId Range : %ld\n",*ifcfInfo->interFreqBlackCellList->list.array[j]->range); } } } #ifdef Rel10 if (ifcfInfo->ext1 && ifcfInfo->ext1->q_QualMin_r9) - LOG_I(RRC," Q_QualMin_r9 : %d\n",*ifcfInfo->ext1->q_QualMin_r9); + LOG_I(RRC," Q_QualMin_r9 : %ld\n",*ifcfInfo->ext1->q_QualMin_r9); if (ifcfInfo->ext1 && ifcfInfo->ext1->threshX_Q_r9) { - LOG_I(RRC," threshX_HighQ_r9 : %d\n",ifcfInfo->ext1->threshX_Q_r9->threshX_HighQ_r9); - LOG_I(RRC," threshX_LowQ_r9: %d\n",ifcfInfo->ext1->threshX_Q_r9->threshX_LowQ_r9); + LOG_I(RRC," threshX_HighQ_r9 : %ld\n",ifcfInfo->ext1->threshX_Q_r9->threshX_HighQ_r9); + LOG_I(RRC," threshX_LowQ_r9: %ld\n",ifcfInfo->ext1->threshX_Q_r9->threshX_LowQ_r9); } #endif } @@ -3786,7 +3786,7 @@ void ue_meas_filtering( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB_ ctxt_pP->frame, 10*log10(mac_xface->get_RSSI(ctxt_pP->module_id,0))-mac_xface->get_rx_total_gain_dB(ctxt_pP->module_id,0), 10*log10(mac_xface->get_RSSI(ctxt_pP->module_id,0))); - LOG_D(RRC,"[UE %d] Frame %d: Meas RSRP: eNB_offset: %d rsrp_coef: %3.1f filter_coef: %d before L3 filtering: rsrp: %3.1f after L3 filtering: rsrp: %3.1f \n ", + LOG_D(RRC,"[UE %d] Frame %d: Meas RSRP: eNB_offset: %d rsrp_coef: %3.1f filter_coef: %ld before L3 filtering: rsrp: %3.1f after L3 filtering: rsrp: %3.1f \n ", ctxt_pP->module_id, ctxt_pP->frame, eNB_offset,a, *UE_rrc_inst->QuantityConfig[0]->quantityConfigEUTRA->filterCoefficientRSRP, @@ -3886,7 +3886,7 @@ static void rrc_ue_generate_MeasurementReport(protocol_ctxt_t* const ctxt_pP, ui if (pframe!=ctxt_pP->frame) { pframe=ctxt_pP->frame; - LOG_D(RRC, "[UE %d] Frame %d: doing MeasReport: servingCell(%d) targetCell(%d) rsrp_s(%ld) rsrq_s(%ld) rsrp_t(%ld) rsrq_t(%ld) \n", + LOG_D(RRC, "[UE %d] Frame %d: doing MeasReport: servingCell(%ld) targetCell(%ld) rsrp_s(%ld) rsrq_s(%ld) rsrp_t(%ld) rsrq_t(%ld) \n", ctxt_pP->module_id, ctxt_pP->frame, cellId, @@ -4041,7 +4041,7 @@ static uint8_t check_trigger_meas_event( uint8_t currentCellIndex = mac_xface->frame_parms->Nid_cell; uint8_t tmp_offset; - LOG_I(RRC,"[UE %d] ofn(%d) ocn(%d) hys(%d) ofs(%d) ocs(%d) a3_offset(%d) ttt(%d) rssi %3.1f\n", + LOG_I(RRC,"[UE %d] ofn(%ld) ocn(%ld) hys(%ld) ofs(%ld) ocs(%ld) a3_offset(%ld) ttt(%ld) rssi %3.1f\n", ue_mod_idP, ofn,ocn,hys,ofs,ocs,a3_offset,ttt, 10*log10(mac_xface->get_RSSI(ue_mod_idP,0))-mac_xface->get_rx_total_gain_dB(ue_mod_idP,0)); @@ -4068,7 +4068,7 @@ static uint8_t check_trigger_meas_event( if (UE_rrc_inst->measTimer[ue_cnx_index][meas_index][tmp_offset] >= ttt) { UE_rrc_inst->HandoverInfoUe.targetCellId = get_adjacent_cell_id(ue_mod_idP,tmp_offset); //WARNING!!!...check this! - LOG_D(RRC,"[UE %d] Frame %d eNB %d: Handover triggered: targetCellId: %d currentCellId: %d eNB_offset: %d rsrp source: %3.1f rsrp target: %3.1f\n", \ + LOG_D(RRC,"[UE %d] Frame %d eNB %d: Handover triggered: targetCellId: %ld currentCellId: %d eNB_offset: %d rsrp source: %3.1f rsrp target: %3.1f\n", \ ue_mod_idP, frameP, eNB_index, UE_rrc_inst->HandoverInfoUe.targetCellId,ue_cnx_index,eNB_offset, (dB_fixed_times10(UE_rrc_inst[ue_mod_idP].rsrp_db[0])/10.0)-mac_xface->get_rx_total_gain_dB(ue_mod_idP,0)-dB_fixed(mac_xface->frame_parms->N_RB_DL*12), @@ -4112,7 +4112,7 @@ int decode_MCCH_Message( const protocol_ctxt_t* const ctxt_pP, const uint8_t eNB Sdu_len); if ((dec_rval.code != RC_OK) && (dec_rval.consumed==0)) { - LOG_E(RRC,"[UE %d] Failed to decode MCCH__MESSAGE (%d bits)\n", + LOG_E(RRC,"[UE %d] Failed to decode MCCH__MESSAGE (%lu bits)\n", ctxt_pP->module_id, dec_rval.consumed); //free the memory @@ -4393,8 +4393,14 @@ void *rrc_ue_task( void *args_p ) case NAS_CELL_SELECTION_REQ: ue_mod_id = 0; /* TODO force ue_mod_id to first UE, NAS UE not virtualized yet */ - LOG_D(RRC, "[UE %d] Received %s: state %d, plmnID %d, rat %x\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id), - NAS_CELL_SELECTION_REQ (msg_p).plmnID, NAS_CELL_SELECTION_REQ (msg_p).rat); + LOG_D(RRC, "[UE %d] Received %s: state %d, plmnID (%d%d%d.%d%d%d), rat %x\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id), + NAS_CELL_SELECTION_REQ (msg_p).plmnID.MCCdigit1, + NAS_CELL_SELECTION_REQ (msg_p).plmnID.MCCdigit2, + NAS_CELL_SELECTION_REQ (msg_p).plmnID.MCCdigit3, + NAS_CELL_SELECTION_REQ (msg_p).plmnID.MNCdigit1, + NAS_CELL_SELECTION_REQ (msg_p).plmnID.MNCdigit2, + NAS_CELL_SELECTION_REQ (msg_p).plmnID.MNCdigit3, + NAS_CELL_SELECTION_REQ (msg_p).rat); if (rrc_get_state(ue_mod_id) == RRC_STATE_INACTIVE) { // have a look at MAC/main.c void dl_phy_sync_success(...) @@ -4457,8 +4463,16 @@ void *rrc_ue_task( void *args_p ) break; case NAS_CONN_ESTABLI_REQ: - LOG_D(RRC, "[UE %d] Received %s: cause %d, type %d, s_tmsi %d, plmnID %d\n", ue_mod_id, msg_name, NAS_CONN_ESTABLI_REQ (msg_p).cause, - NAS_CONN_ESTABLI_REQ (msg_p).type, NAS_CONN_ESTABLI_REQ (msg_p).s_tmsi, NAS_CONN_ESTABLI_REQ (msg_p).plmnID); + LOG_D(RRC, "[UE %d] Received %s: cause %d, type %d, s_tmsi (mme code %"PRIu8", m-tmsi %"PRIu32"), plmnID (%d%d%d.%d%d%d)\n", ue_mod_id, msg_name, NAS_CONN_ESTABLI_REQ (msg_p).cause, + NAS_CONN_ESTABLI_REQ (msg_p).type, + NAS_CONN_ESTABLI_REQ (msg_p).s_tmsi.MMEcode, + NAS_CONN_ESTABLI_REQ (msg_p).s_tmsi.m_tmsi, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit1, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit2, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit3, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit1, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit2, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit3); //PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, ENB_FLAG_NO, NOT_A_RNTI, 0, 0); PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, NOT_A_RNTI, 0, 0, 0); diff --git a/openair2/RRC/LITE/rrc_common.c b/openair2/RRC/LITE/rrc_common.c index 67ee4053d0d846427d63be8fb99359b342798a91..b039ecd8de2c20f91d47ea4490bb107362bfb24a 100644 --- a/openair2/RRC/LITE/rrc_common.c +++ b/openair2/RRC/LITE/rrc_common.c @@ -484,7 +484,8 @@ rrc_rx_tx( if (UE_rrc_inst[ctxt_pP->module_id].Info[enb_indexP].T304_cnt == 0) { UE_rrc_inst[ctxt_pP->module_id].Info[enb_indexP].T304_active = 0; UE_rrc_inst[ctxt_pP->module_id].HandoverInfoUe.measFlag = 1; - LOG_E(RRC,"[UE %d] Handover failure..initiating connection re-establishment procedure... \n"); + LOG_E(RRC,"[UE %d] Handover failure..initiating connection re-establishment procedure... \n", + ctxt_pP->module_id); //Implement 36.331, section 5.3.5.6 here VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_RX_TX,VCD_FUNCTION_OUT); return(RRC_Handover_failed); diff --git a/openair2/RRC/LITE/rrc_eNB.c b/openair2/RRC/LITE/rrc_eNB.c index d279764528de3cee992bad917a43bb3b1fdd9bb0..8b5b012ff1a7178a2a8dcf9a49ea1211abd09020 100644 --- a/openair2/RRC/LITE/rrc_eNB.c +++ b/openair2/RRC/LITE/rrc_eNB.c @@ -96,7 +96,7 @@ #if defined(FLEXRAN_AGENT_SB_IF) #include "flexran_agent_extern.h" #endif -#define XER_PRINT +//#define XER_PRINT #ifdef PHY_EMUL extern EMULATION_VARS *Emul_vars; @@ -304,14 +304,14 @@ init_SI( // SIB13 for (i = 0; i < eNB_rrc_inst[ctxt_pP->module_id].carrier[CC_id].sib13->mbsfn_AreaInfoList_r9.list.count; i++) { - LOG_D(RRC, PROTOCOL_RRC_CTXT_FMT" SIB13 contents for MBSFN sync area %d/2 (partial)\n", + LOG_D(RRC, PROTOCOL_RRC_CTXT_FMT" SIB13 contents for MBSFN sync area %d/%d (partial)\n", PROTOCOL_RRC_CTXT_ARGS(ctxt_pP), i, eNB_rrc_inst[ctxt_pP->module_id].carrier[CC_id].sib13->mbsfn_AreaInfoList_r9.list.count); - LOG_D(RRC, PROTOCOL_RRC_CTXT_FMT" MCCH Repetition Period: %d (just index number, not real value)\n", + LOG_D(RRC, PROTOCOL_RRC_CTXT_FMT" MCCH Repetition Period: %ld (just index number, not real value)\n", PROTOCOL_RRC_CTXT_ARGS(ctxt_pP), eNB_rrc_inst[ctxt_pP->module_id].carrier[CC_id].sib13->mbsfn_AreaInfoList_r9.list.array[i]->mcch_Config_r9.mcch_RepetitionPeriod_r9); - LOG_D(RRC, PROTOCOL_RRC_CTXT_FMT" MCCH Offset: %d\n", + LOG_D(RRC, PROTOCOL_RRC_CTXT_FMT" MCCH Offset: %ld\n", PROTOCOL_RRC_CTXT_ARGS(ctxt_pP), eNB_rrc_inst[ctxt_pP->module_id].carrier[CC_id].sib13->mbsfn_AreaInfoList_r9.list.array[i]->mcch_Config_r9.mcch_Offset_r9); } @@ -394,7 +394,7 @@ init_MCCH( eNB_rrc_inst[enb_mod_idP].carrier[CC_id].MCCH_MESSAGE[sync_area], sync_area); LOG_D(RRC, "[eNB %d] MCCH_MESSAGE contents for Sync Area %d (partial)\n", enb_mod_idP, sync_area); - LOG_D(RRC, "[eNB %d] CommonSF_AllocPeriod_r9 %d\n", enb_mod_idP, + LOG_D(RRC, "[eNB %d] CommonSF_AllocPeriod_r9 %ld\n", enb_mod_idP, eNB_rrc_inst[enb_mod_idP].carrier[CC_id].mcch_message->commonSF_AllocPeriod_r9); LOG_D(RRC, "[eNB %d] CommonSF_Alloc_r9.list.count (number of MBSFN Subframe Pattern) %d\n", @@ -598,7 +598,7 @@ rrc_eNB_get_next_free_ue_context( RB_FOREACH(ue_context_p, rrc_ue_tree_s, &(eNB_rrc_inst[ctxt_pP->module_id].rrc_ue_head)) { if (ue_context_p->ue_context.random_ue_identity == ue_identityP) { LOG_D(RRC, - PROTOCOL_RRC_CTXT_UE_FMT" Cannot create new UE context, already exist rand UE id 0x%x, uid %u\n", + PROTOCOL_RRC_CTXT_UE_FMT" Cannot create new UE context, already exist rand UE id 0x%"PRIx64", uid %u\n", PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP), ue_identityP, ue_context_p->local_uid); @@ -690,7 +690,7 @@ rrc_eNB_free_mem_UE_context( { int i; LOG_T(RRC, - PROTOCOL_RRC_CTXT_UE_FMT" Clearing UE context 0x%x (free internal structs)\n", + PROTOCOL_RRC_CTXT_UE_FMT" Clearing UE context 0x%p (free internal structs)\n", PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP), ue_context_pP); #ifdef Rel10 @@ -1310,7 +1310,7 @@ rrc_eNB_generate_dedicatedRRCConnectionReconfiguration(const protocol_ctxt_t* co ASN_SEQUENCE_ADD(&(*DRB_configList2)->list, DRB_config); //ue_context_pP->ue_context.DRB_configList2[drb_identity_index] = &(*DRB_configList); - LOG_I(RRC,"EPS ID %d, DRB ID %d (index %d), QCI %d, priority %d, LCID %d LCGID %d \n", + LOG_I(RRC,"EPS ID %ld, DRB ID %ld (index %d), QCI %d, priority %ld, LCID %ld LCGID %ld \n", *DRB_config->eps_BearerIdentity, DRB_config->drb_Identity, i, ue_context_pP->ue_context.e_rab[i].param.qos.qci, @@ -1703,7 +1703,7 @@ rrc_eNB_generate_defaultRRCConnectionReconfiguration(const protocol_ctxt_t* cons if (*physicalConfigDedicated) { if ((*physicalConfigDedicated)->antennaInfo) { (*physicalConfigDedicated)->antennaInfo->choice.explicitValue.transmissionMode = rrc_inst->configuration.ue_TransmissionMode[0]; - LOG_D(RRC,"Setting transmission mode to %d+1\n",rrc_inst->configuration.ue_TransmissionMode[0]); + LOG_D(RRC,"Setting transmission mode to %ld+1\n",rrc_inst->configuration.ue_TransmissionMode[0]); if (rrc_inst->configuration.ue_TransmissionMode[0]==AntennaInfoDedicated__transmissionMode_tm3) { (*physicalConfigDedicated)->antennaInfo->choice.explicitValue.codebookSubsetRestriction= CALLOC(1,sizeof(AntennaInfoDedicated__codebookSubsetRestriction_PR)); @@ -2265,8 +2265,8 @@ rrc_eNB_process_MeasurementReport( } #ifdef Rel10 - LOG_I(RRC, "RSRP of Source %d\n", measResults2->measResultPCell.rsrpResult); - LOG_I(RRC, "RSRQ of Source %d\n", measResults2->measResultPCell.rsrqResult); + LOG_I(RRC, "RSRP of Source %ld\n", measResults2->measResultPCell.rsrpResult); + LOG_I(RRC, "RSRQ of Source %ld\n", measResults2->measResultPCell.rsrqResult); #else LOG_I(RRC, "RSRP of Source %d\n", measResults2->measResultServCell.rsrpResult); LOG_I(RRC, "RSRQ of Source %d\n", measResults2->measResultServCell.rsrqResult); @@ -2368,7 +2368,7 @@ rrc_eNB_generate_HandoverPreparationInformation( ue_context_target_p->ue_id_rnti = ue_context_pP->ue_context.rnti; // LG: should not be the same ue_context_target_p->ue_context.rnti = ue_context_target_p->ue_id_rnti; // idem LOG_N(RRC, - "[eNB %d] Frame %d : Emulate sending HandoverPreparationInformation msg from eNB source %d to eNB target %d: source UE_id %x target UE_id %x source_modId: %d target_modId: %d\n", + "[eNB %d] Frame %d : Emulate sending HandoverPreparationInformation msg from eNB source %d to eNB target %ld: source UE_id %x target UE_id %x source_modId: %d target_modId: %d\n", ctxt_pP->module_id, ctxt_pP->frame, eNB_rrc_inst[ctxt_pP->module_id].carrier[0] /* CROUX TBC */.physCellId, @@ -2395,7 +2395,7 @@ rrc_eNB_generate_HandoverPreparationInformation( ue_context_target_p->ue_context.handover_info->ueid_t = ue_context_target_p->ue_context.rnti; } else { - LOG_E(RRC, "\nError in obtaining free UE id in target eNB %l for handover \n", targetPhyId); + LOG_E(RRC, "\nError in obtaining free UE id in target eNB %ld for handover \n", targetPhyId); } } else { @@ -3160,7 +3160,7 @@ rrc_eNB_generate_RRCConnectionReconfiguration_handover( memset((void *)mobilityInfo, 0, sizeof(*mobilityInfo)); mobilityInfo->targetPhysCellId = (PhysCellId_t) two_tier_hexagonal_cellIds[ue_context_pP->ue_context.handover_info->modid_t]; - LOG_D(RRC, "[eNB %d] Frame %d: handover preparation: targetPhysCellId: %d mod_id: %d ue: %x \n", + LOG_D(RRC, "[eNB %d] Frame %d: handover preparation: targetPhysCellId: %ld mod_id: %d ue: %x \n", ctxt_pP->module_id, ctxt_pP->frame, mobilityInfo->targetPhysCellId, @@ -3254,7 +3254,8 @@ rrc_eNB_generate_RRCConnectionReconfiguration_handover( (void *)rrc_inst->sps_Config[ue_mod_idP], sizeof(SPS_Config_t)); */ - LOG_I(RRC, "[eNB %d] Frame %d: adding new UE\n"); + LOG_I(RRC, "[eNB %d] Frame %d: adding new UE\n", + ctxt_pP->module_id, ctxt_pP->frame); //Idx = (ue_mod_idP * NB_RB_MAX) + DCCH; Idx = DCCH; // SRB1 @@ -3549,9 +3550,10 @@ rrc_eNB_process_RRCConnectionReconfigurationComplete( ctxt_pP->frame, ue_context_pP->ue_context.primaryCC_id); } else { - LOG_W(RRC,"[eNB %d] Frame %d CC %d : invalide SRB identity %d\n", + LOG_W(RRC,"[eNB %d] Frame %d CC %d : invalide SRB identity %ld\n", ctxt_pP->module_id, ctxt_pP->frame, + ue_context_pP->ue_context.primaryCC_id, SRB_configList->list.array[i]->srb_Identity); } } @@ -4189,9 +4191,11 @@ rrc_eNB_decode_ccch( * the current one must be removed from MAC/PHY (zombie UE) */ if ((ue_context_p = rrc_eNB_ue_context_random_exist(ctxt_pP, random_value))) { -//#warning "TODO: random_exist: remove UE from MAC/PHY (how?)" - // AssertFatal(0 == 1, "TODO: remove UE from MAC/PHY (how?)"); + LOG_W(RRC, "new UE rnti %x (coming with random value) is already there as UE %x, removing %x from MAC/PHY\n", + ctxt_pP->rnti, ue_context_p->ue_context.rnti, ctxt_pP->rnti); + rrc_mac_remove_ue(ctxt_pP->module_id, ctxt_pP->rnti); ue_context_p = NULL; + return 0; } else { ue_context_p = rrc_eNB_get_next_free_ue_context(ctxt_pP, random_value); } @@ -4202,9 +4206,8 @@ rrc_eNB_decode_ccch( m_tmsi_t m_tmsi = BIT_STRING_to_uint32(&s_TMSI.m_TMSI); random_value = (((uint64_t)mme_code) << 32) | m_tmsi; if ((ue_context_p = rrc_eNB_ue_context_stmsi_exist(ctxt_pP, mme_code, m_tmsi))) { - - //#warning "TODO: stmsi_exist: remove UE from MAC/PHY (how?)" LOG_I(RRC," S-TMSI exists, ue_context_p %p, old rnti %x => %x\n",ue_context_p,ue_context_p->ue_context.rnti,ctxt_pP->rnti); + rrc_mac_remove_ue(ctxt_pP->module_id, ue_context_p->ue_context.rnti); stmsi_received=1; /* replace rnti in the context */ /* for that, remove the context from the RB tree */ @@ -4216,10 +4219,8 @@ rrc_eNB_decode_ccch( /* reset timers */ ue_context_p->ue_context.ul_failure_timer = 0; ue_context_p->ue_context.ue_release_timer = 0; - // AssertFatal(0 == 1, "TODO: remove UE from MAC/PHY (how?)"); - // ue_context_p = NULL; } else { - LOG_I(RRC," S-TMSI doesn't exist, setting Initialue_identity_s_TMSI.m_tmsi to %x => %x\n",ue_context_p,m_tmsi); + LOG_I(RRC," S-TMSI doesn't exist, setting Initialue_identity_s_TMSI.m_tmsi to %p => %x\n",ue_context_p,m_tmsi); ue_context_p = rrc_eNB_get_next_free_ue_context(ctxt_pP, NOT_A_RANDOM_UE_IDENTITY); if (ue_context_p == NULL) LOG_E(RRC, "%s:%d:%s: rrc_eNB_get_next_free_ue_context returned NULL\n", __FILE__, __LINE__, __FUNCTION__); @@ -4228,7 +4229,8 @@ rrc_eNB_decode_ccch( ue_context_p->ue_context.Initialue_identity_s_TMSI.mme_code = mme_code; ue_context_p->ue_context.Initialue_identity_s_TMSI.m_tmsi = m_tmsi; } else { - break; + /* TODO: do we have to break here? */ + //break; } } @@ -4256,7 +4258,7 @@ rrc_eNB_decode_ccch( } LOG_D(RRC, - PROTOCOL_RRC_CTXT_UE_FMT" UE context: %X\n", + PROTOCOL_RRC_CTXT_UE_FMT" UE context: %p\n", PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP), ue_context_p); @@ -4266,14 +4268,14 @@ rrc_eNB_decode_ccch( #if defined(ENABLE_ITTI) ue_context_p->ue_context.establishment_cause = rrcConnectionRequest->establishmentCause; if (stmsi_received==0) - LOG_I(RRC, PROTOCOL_RRC_CTXT_UE_FMT" Accept new connection from UE random UE identity (0x%" PRIx64 ") MME code %u TMSI %u cause %u\n", + LOG_I(RRC, PROTOCOL_RRC_CTXT_UE_FMT" Accept new connection from UE random UE identity (0x%" PRIx64 ") MME code %u TMSI %u cause %ld\n", PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP), ue_context_p->ue_context.random_ue_identity, ue_context_p->ue_context.Initialue_identity_s_TMSI.mme_code, ue_context_p->ue_context.Initialue_identity_s_TMSI.m_tmsi, ue_context_p->ue_context.establishment_cause); else - LOG_I(RRC, PROTOCOL_RRC_CTXT_UE_FMT" Accept new connection from UE MME code %u TMSI %u cause %u\n", + LOG_I(RRC, PROTOCOL_RRC_CTXT_UE_FMT" Accept new connection from UE MME code %u TMSI %u cause %ld\n", PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP), ue_context_p->ue_context.Initialue_identity_s_TMSI.mme_code, ue_context_p->ue_context.Initialue_identity_s_TMSI.m_tmsi, @@ -4463,7 +4465,7 @@ rrc_eNB_decode_dcch( } if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) { - LOG_E(RRC, PROTOCOL_RRC_CTXT_UE_FMT" Failed to decode UL-DCCH (%d bytes)\n", + LOG_E(RRC, PROTOCOL_RRC_CTXT_UE_FMT" Failed to decode UL-DCCH (%zu bytes)\n", PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP), dec_rval.consumed); return -1; @@ -4530,13 +4532,13 @@ rrc_eNB_decode_dcch( if (ue_context_p->ue_context.Status == RRC_RECONFIGURED){ dedicated_DRB = 1; LOG_I(RRC, - PROTOCOL_RRC_CTXT_UE_FMT" UE State = RRC_RECONFIGURED (dedicated DRB, xid %d)\n", + PROTOCOL_RRC_CTXT_UE_FMT" UE State = RRC_RECONFIGURED (dedicated DRB, xid %ld)\n", PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP),ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.rrc_TransactionIdentifier); }else { dedicated_DRB = 0; ue_context_p->ue_context.Status = RRC_RECONFIGURED; LOG_I(RRC, - PROTOCOL_RRC_CTXT_UE_FMT" UE State = RRC_RECONFIGURED (default DRB, xid %d)\n", + PROTOCOL_RRC_CTXT_UE_FMT" UE State = RRC_RECONFIGURED (default DRB, xid %ld)\n", PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP),ul_dcch_msg->message.choice.c1.choice.rrcConnectionReconfigurationComplete.rrc_TransactionIdentifier); } rrc_eNB_process_RRCConnectionReconfigurationComplete( @@ -4784,6 +4786,7 @@ rrc_eNB_decode_dcch( #ifdef XER_PRINT xer_fprint(stdout, &asn_DEF_UL_DCCH_Message, (void *)ul_dcch_msg); #endif + LOG_I(RRC, "got UE capabilities for UE %x\n", ctxt_pP->rnti); dec_rval = uper_decode(NULL, &asn_DEF_UE_EUTRA_Capability, (void **)&UE_EUTRA_Capability, @@ -4794,7 +4797,7 @@ rrc_eNB_decode_dcch( choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list. array[0]->ueCapabilityRAT_Container.size, 0, 0); //#ifdef XER_PRINT - xer_fprint(stdout, &asn_DEF_UE_EUTRA_Capability, (void *)UE_EUTRA_Capability); + //xer_fprint(stdout, &asn_DEF_UE_EUTRA_Capability, (void *)UE_EUTRA_Capability); //#endif #if defined(ENABLE_USE_MME) diff --git a/openair2/RRC/LITE/rrc_eNB_S1AP.c b/openair2/RRC/LITE/rrc_eNB_S1AP.c index a3dc9f47a17ebfbd2313e25bc11f0f4ab919f9d5..8984eb933c60c1e959e9cad9b5bd5c9c9b90c390 100644 --- a/openair2/RRC/LITE/rrc_eNB_S1AP.c +++ b/openair2/RRC/LITE/rrc_eNB_S1AP.c @@ -115,7 +115,7 @@ rrc_eNB_S1AP_get_ue_ids( (hash_key_t)eNB_ue_s1ap_id, result2); if (h_rc != HASH_TABLE_OK) { - LOG_E(S1AP, "[eNB %u] Error while hashtable_insert in s1ap_id2_s1ap_ids eNB_ue_s1ap_id %u\n", + LOG_E(S1AP, "[eNB %ld] Error while hashtable_insert in s1ap_id2_s1ap_ids eNB_ue_s1ap_id %"PRIu32"\n", rrc_instance_pP - eNB_rrc_inst, eNB_ue_s1ap_id); } } @@ -308,7 +308,7 @@ rrc_eNB_process_security( changed = TRUE; } - LOG_I (RRC, "[eNB %d][UE %x] Selected security algorithms (%x): %x, %x, %s\n", + LOG_I (RRC, "[eNB %d][UE %x] Selected security algorithms (%p): %x, %x, %s\n", ctxt_pP->module_id, ue_context_pP->ue_context.rnti, security_capabilities_pP, @@ -774,8 +774,8 @@ rrc_eNB_process_S1AP_DOWNLINK_NAS( ue_initial_id = S1AP_DOWNLINK_NAS (msg_p).ue_initial_id; eNB_ue_s1ap_id = S1AP_DOWNLINK_NAS (msg_p).eNB_ue_s1ap_id; ue_context_p = rrc_eNB_get_ue_context_from_s1ap_ids(instance, ue_initial_id, eNB_ue_s1ap_id); - srb_id = ue_context_p->ue_context.Srb2.Srb_info.Srb_id; - + + LOG_I(RRC, "[eNB %d] Received %s: ue_initial_id %d, eNB_ue_s1ap_id %d\n", instance, msg_name, @@ -822,6 +822,9 @@ rrc_eNB_process_S1AP_DOWNLINK_NAS( } else { PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, ENB_FLAG_YES, ue_context_p->ue_context.rnti, 0, 0); + srb_id = ue_context_p->ue_context.Srb2.Srb_info.Srb_id; + + /* Is it the first income from S1AP ? */ if (ue_context_p->ue_context.eNB_ue_s1ap_id == 0) { ue_context_p->ue_context.eNB_ue_s1ap_id = S1AP_DOWNLINK_NAS (msg_p).eNB_ue_s1ap_id; @@ -1005,7 +1008,7 @@ int rrc_eNB_process_S1AP_UE_CTXT_MODIFICATION_REQ(MessageDef *msg_p, const char /* Can not associate this message to an UE index, send a failure to S1AP and discard it! */ MessageDef *msg_fail_p; - LOG_W(RRC, "[eNB %d] In S1AP_UE_CTXT_MODIFICATION_REQ: unknown UE from eNB_ue_s1ap_id (%d) for eNB %d\n", instance, eNB_ue_s1ap_id); + LOG_W(RRC, "[eNB %d] In S1AP_UE_CTXT_MODIFICATION_REQ: unknown UE from eNB_ue_s1ap_id (%d)\n", instance, eNB_ue_s1ap_id); msg_fail_p = itti_alloc_new_message (TASK_RRC_ENB, S1AP_UE_CTXT_MODIFICATION_FAIL); S1AP_UE_CTXT_MODIFICATION_FAIL (msg_fail_p).eNB_ue_s1ap_id = eNB_ue_s1ap_id; diff --git a/openair2/UTIL/ASYNC_IF/link_manager.c b/openair2/UTIL/ASYNC_IF/link_manager.c index 1c9fb72bfe3f79d9636fd2808799b09af85e51ab..235acef2471eb52c7c2bd6c30f25f79f8b1d93ff 100644 --- a/openair2/UTIL/ASYNC_IF/link_manager.c +++ b/openair2/UTIL/ASYNC_IF/link_manager.c @@ -61,9 +61,9 @@ static void *link_manager_sender_thread(void *_manager) return NULL; -error: - LOG_E(MAC, "%s: error\n", __FUNCTION__); - return NULL; + //error: + //LOG_E(MAC, "%s: error\n", __FUNCTION__); + //return NULL; } /* that thread receives messages from the link and puts them in the queue */ @@ -118,7 +118,6 @@ link_manager_t *create_link_manager( // Make the async interface threads real-time //#ifndef LOWLATENCY struct sched_param sched_param_recv_thread; - struct sched_param sched_param_send_thread; sched_param_recv_thread.sched_priority = sched_get_priority_max(SCHED_RR) - 1; pthread_attr_setschedparam(&attr, &sched_param_recv_thread); diff --git a/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/inc/liblfds700.h b/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/inc/liblfds700.h index fdda50cefba67824e61c23fd2229129637d324ff..4f83d8d9a0b6ee440276a66f2adf712306221c42 100644 --- a/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/inc/liblfds700.h +++ b/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/inc/liblfds700.h @@ -4,9 +4,9 @@ #define LIBLFDS700_H /***** pragmas on *****/ - #pragma warning( disable : 4324 ) // TRD : 4324 disables MSVC warnings for structure alignment padding due to alignment specifiers +// #pragma warning( disable : 4324 ) // TRD : 4324 disables MSVC warnings for structure alignment padding due to alignment specifiers - #pragma prefast( disable : 28113 28182 28183, "blah" ) +// #pragma prefast( disable : 28113 28182 28183, "blah" ) /***** includes *****/ #include "liblfds700/lfds700_porting_abstraction_layer_compiler.h" @@ -25,7 +25,7 @@ #include "liblfds700/lfds700_stack.h" /***** pragmas off *****/ - #pragma warning( default : 4324 ) +// #pragma warning( default : 4324 ) #endif diff --git a/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/inc/liblfds700/lfds700_misc.h b/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/inc/liblfds700/lfds700_misc.h index 014f72dac533b8cdcf902ef69bae8adbca39a425..79eb3e7e5a7b0c2270acef279cd718fbfd567284 100644 --- a/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/inc/liblfds700/lfds700_misc.h +++ b/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/inc/liblfds700/lfds700_misc.h @@ -175,7 +175,7 @@ void lfds700_misc_prng_init( struct lfds700_misc_prng_state *ps ); void lfds700_misc_query( enum lfds700_misc_query query_type, void *query_input, void *query_output ); /***** public in-line functions *****/ -#pragma prefast( disable : 28112, "blah" ) +// #pragma prefast( disable : 28112, "blah" ) static LFDS700_PAL_INLINE void lfds700_misc_force_store() { diff --git a/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/src/lfds700_ringbuffer/lfds700_ringbuffer_cleanup.c b/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/src/lfds700_ringbuffer/lfds700_ringbuffer_cleanup.c index 447c93041e36e8b626d2da09610b94c919efd61d..8ab44e46b5d52040062926c2a5ea93a72b3e2387 100644 --- a/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/src/lfds700_ringbuffer/lfds700_ringbuffer_cleanup.c +++ b/openair2/UTIL/LFDS/liblfds7.0.0/liblfds700/src/lfds700_ringbuffer/lfds700_ringbuffer_cleanup.c @@ -31,7 +31,7 @@ void lfds700_ringbuffer_cleanup( struct lfds700_ringbuffer_state *rs, /****************************************************************************/ -#pragma warning( disable : 4100 ) +//#pragma warning( disable : 4100 ) static void lfds700_ringbuffer_internal_queue_element_cleanup_callback( struct lfds700_queue_state *qs, struct lfds700_queue_element *qe, enum lfds700_misc_flag dummy_element_flag ) { @@ -54,14 +54,14 @@ static void lfds700_ringbuffer_internal_queue_element_cleanup_callback( struct l return; } -#pragma warning( default : 4100 ) +//#pragma warning( default : 4100 ) /****************************************************************************/ -#pragma warning( disable : 4100 ) +//#pragma warning( disable : 4100 ) static void lfds700_ringbuffer_internal_freelist_element_cleanup_callback( struct lfds700_freelist_state *fs, struct lfds700_freelist_element *fe ) { @@ -82,5 +82,5 @@ static void lfds700_ringbuffer_internal_freelist_element_cleanup_callback( struc return; } -#pragma warning( default : 4100 ) +//#pragma warning( default : 4100 ) diff --git a/openair2/UTIL/LISTS/list.c b/openair2/UTIL/LISTS/list.c index 33b880d297d036bb65073c57b61b23a439c05732..7040aeeef7fa6221f21ecf85e2976b09bf0628fa 100644 --- a/openair2/UTIL/LISTS/list.c +++ b/openair2/UTIL/LISTS/list.c @@ -59,7 +59,7 @@ list_free (list_t * listP) mem_block_t *le; while ((le = list_remove_head (listP))) { - free_mem_block (le); + free_mem_block (le, __func__); } } //----------------------------------------------------------------------------- diff --git a/openair2/UTIL/LISTS/list2.c b/openair2/UTIL/LISTS/list2.c index 4a8de24b513a402a72586b6b86cd9cd15734a529..abd9d2aacce6b139df6ef993ec70cf4a82ff3137 100644 --- a/openair2/UTIL/LISTS/list2.c +++ b/openair2/UTIL/LISTS/list2.c @@ -75,7 +75,7 @@ list2_free (list2_t * listP) mem_block_t *le; while ((le = list2_remove_head (listP))) { - free_mem_block (le); + free_mem_block (le, __func__); } } diff --git a/openair2/UTIL/LOG/vcd_signal_dumper.c b/openair2/UTIL/LOG/vcd_signal_dumper.c index 34fc8e97b8a8ede096c68451f891725ff7c91cd3..96f173833ae9d911070280faed4b13ca6a986f85 100644 --- a/openair2/UTIL/LOG/vcd_signal_dumper.c +++ b/openair2/UTIL/LOG/vcd_signal_dumper.c @@ -98,6 +98,7 @@ const char* eurecomVariablesNames[] = { "rxcnt", "trx_ts", "trx_tst", + "trx_write_flags", "tx_ts", "rx_ts", "hw_cnt_rx", @@ -174,8 +175,12 @@ const char* eurecomVariablesNames[] = { "ue0_SFN5", "ue0_SFN6", "ue0_SFN7", + "ue_pdcp_flush_size", + "ue_pdcp_flush_err", "ue0_trx_read_ns", "ue0_trx_write_ns", + "ue0_trx_read_ns_missing", + "ue0_trx_write_ns_missing" }; const char* eurecomFunctionsNames[] = { @@ -192,7 +197,8 @@ const char* eurecomFunctionsNames[] = { "ue_thread_rxtx1", "trx_read_sf9", "trx_write_sf9", - "ue_signal_cond_rxtx", + "ue_signal_cond_rxtx0", + "ue_signal_cond_rxtx1", "ue_wait_cond_rxtx0", "ue_wait_cond_rxtx1", "ue_lock_mutex_rxtx_for_cond_wait0", @@ -283,6 +289,9 @@ const char* eurecomFunctionsNames[] = { "phy_ue_generate_prach", "phy_ue_ulsch_modulation", "phy_ue_ulsch_encoding", +#if 1 // add for debugging losing PDSCH immediately before and after reporting CQI + "phy_ue_ulsch_encoding_fill_cqi", +#endif "phy_ue_ulsch_scrambling", "phy_eNB_dlsch_modulation", "phy_eNB_dlsch_encoding", @@ -338,6 +347,10 @@ const char* eurecomFunctionsNames[] = { "pdcp_data_ind", "pdcp_apply_security", "pdcp_validate_security", + "pdcp_fifo_read", + "pdcp_fifo_read_buffer", + "pdcp_fifo_flush", + "pdcp_fifo_flush_buffer", /* RRC signals */ "rrc_rx_tx", "rrc_mac_config_req", diff --git a/openair2/UTIL/LOG/vcd_signal_dumper.h b/openair2/UTIL/LOG/vcd_signal_dumper.h index 0d1c507b749b5b5583c5f40e3957571f843327e8..e1bcff39fcb63c69aed24ff5a1da9e26830284a1 100644 --- a/openair2/UTIL/LOG/vcd_signal_dumper.h +++ b/openair2/UTIL/LOG/vcd_signal_dumper.h @@ -70,6 +70,7 @@ typedef enum { VCD_SIGNAL_DUMPER_VARIABLES_RXCNT, VCD_SIGNAL_DUMPER_VARIABLES_TRX_TS, VCD_SIGNAL_DUMPER_VARIABLES_TRX_TST, + VCD_SIGNAL_DUMPER_VARIABLES_TRX_WRITE_FLAGS, VCD_SIGNAL_DUMPER_VARIABLES_TX_TS, VCD_SIGNAL_DUMPER_VARIABLES_RX_TS, VCD_SIGNAL_DUMPER_VARIABLES_RX_HWCNT, @@ -146,8 +147,12 @@ typedef enum { VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN5, VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN6, VCD_SIGNAL_DUMPER_VARIABLES_UE0_SFN7, + VCD_SIGNAL_DUMPER_VARIABLES_UE_PDCP_FLUSH_SIZE, + VCD_SIGNAL_DUMPER_VARIABLES_UE_PDCP_FLUSH_ERR, VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_READ_NS, VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_WRITE_NS, + VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_READ_NS_MISSING, + VCD_SIGNAL_DUMPER_VARIABLES_UE0_TRX_WRITE_NS_MISSING, VCD_SIGNAL_DUMPER_VARIABLES_LAST, VCD_SIGNAL_DUMPER_VARIABLES_END = VCD_SIGNAL_DUMPER_VARIABLES_LAST, } vcd_signal_dump_variables; @@ -166,7 +171,8 @@ typedef enum { VCD_SIGNAL_DUMPER_FUNCTIONS_UE_THREAD_RXTX1, VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ_SF9, VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_SF9, - VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SIGNAL_COND_RXTX, + VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SIGNAL_COND_RXTX0, + VCD_SIGNAL_DUMPER_FUNCTIONS_UE_SIGNAL_COND_RXTX1, VCD_SIGNAL_DUMPER_FUNCTIONS_UE_WAIT_COND_RXTX0, VCD_SIGNAL_DUMPER_FUNCTIONS_UE_WAIT_COND_RXTX1, VCD_SIGNAL_DUMPER_FUNCTIONS_UE_LOCK_MUTEX_RXTX_FOR_COND_WAIT0, @@ -257,6 +263,9 @@ typedef enum { VCD_SIGNAL_DUMPER_FUNCTIONS_UE_GENERATE_PRACH, VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ULSCH_MODULATION, VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ULSCH_ENCODING, +#if 1 // add for debugging losing PDSCH immediately before and after reporting CQI + VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ULSCH_ENCODING_FILL_CQI, +#endif VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ULSCH_SCRAMBLING, VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_MODULATION, VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, @@ -311,6 +320,10 @@ typedef enum { VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_DATA_IND, VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_APPLY_SECURITY, VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_VALIDATE_SECURITY, + VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ, + VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_READ_BUFFER, + VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH, + VCD_SIGNAL_DUMPER_FUNCTIONS_PDCP_FIFO_FLUSH_BUFFER, /* RRC signals */ VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_RX_TX, diff --git a/openair2/UTIL/MEM/mem_block.c b/openair2/UTIL/MEM/mem_block.c index 8a5f5fd22314d286a14cc17dbb2ff8178348c789..150f19b71c631c8911133c6723e773014e30e4a8 100644 --- a/openair2/UTIL/MEM/mem_block.c +++ b/openair2/UTIL/MEM/mem_block.c @@ -55,7 +55,7 @@ static pthread_mutex_t mtex = PTHREAD_MUTEX_INITIALIZER; //#define DEBUG_MEM_MNGT_ALLOC //----------------------------------------------------------------------------- #if defined(USER_MODE) && defined(DEBUG_MEM_MNGT_ALLOC) -uint32_t counters[11] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; +uint32_t counters[14] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; #endif //----------------------------------------------------------------------------- /* @@ -173,7 +173,7 @@ pool_buffer_clean (void *arg) } //----------------------------------------------------------------------------- void -free_mem_block (mem_block_t * leP) +free_mem_block (mem_block_t * leP, const char* caller) { //----------------------------------------------------------------------------- @@ -197,6 +197,11 @@ free_mem_block (mem_block_t * leP) list_add_tail_eurecom (leP, &mem_block_var.mem_lists[leP->pool_id]); #ifdef DEBUG_MEM_MNGT_ALLOC counters[leP->pool_id] -= 1; + msg ("[%s][MEM_MNGT][INFO] after pool[%2d] freed: counters = {%2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d}\n", + caller, leP->pool_id, + counters[0],counters[1],counters[2],counters[3],counters[4], + counters[5],counters[6],counters[7],counters[8],counters[9], + counters[10],counters[11]); #endif leP = NULL; // this prevent from freeing the block twice } else { @@ -210,7 +215,7 @@ free_mem_block (mem_block_t * leP) //----------------------------------------------------------------------------- mem_block_t * -get_free_mem_block (uint32_t sizeP) +get_free_mem_block (uint32_t sizeP, const char* caller) { //----------------------------------------------------------------------------- mem_block_t *le = NULL; @@ -242,11 +247,19 @@ get_free_mem_block (uint32_t sizeP) if ((le = list_remove_head (&mem_block_var.mem_lists[pool_selected]))) { #ifdef DEBUG_MEM_MNGT_ALLOC counters[pool_selected] += 1; + msg ("[%s][MEM_MNGT][INFO] after pool[%2d] allocated: counters = {%2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d}\n", + caller, + pool_selected, + counters[0],counters[1],counters[2],counters[3],counters[4], + counters[5],counters[6],counters[7],counters[8],counters[9], + counters[10],counters[11]); #endif #ifdef DEBUG_MEM_MNGT_ALLOC_SIZE msg ("[MEM_MNGT][INFO] ALLOC MEM_BLOCK SIZE %d bytes pool %d (%p)\n", sizeP, pool_selected,le); #endif + AssertFatal(le->pool_id == pool_selected, "Unexpected pool ID!"); + #ifdef MEMBLOCK_BIG_LOCK if (pthread_mutex_unlock(&mtex)) abort(); #endif @@ -263,6 +276,7 @@ get_free_mem_block (uint32_t sizeP) #endif } while (pool_selected++ < 12); + LOG_E(PHY, "[MEM_MNGT][ERROR][FATAL] failed allocating MEM_BLOCK size %d byes (pool_selected=%d size=%d)\n", sizeP, pool_selected, size); display_mem_load(); mac_xface->macphy_exit("[MEM_MNGT][ERROR][FATAL] get_free_mem_block failed"); @@ -287,6 +301,13 @@ get_free_copy_mem_block (void) if ((le = list_remove_head (&mem_block_var.mem_lists[MEM_MNGT_POOL_ID_COPY]))) { #ifdef DEBUG_MEM_MNGT_ALLOC_SIZE msg ("[MEM_MNGT][INFO] ALLOC COPY MEM BLOCK (%p)\n",le); +#endif +#ifdef DEBUG_MEM_MNGT_ALLOC + counters[MEM_MNGT_POOL_ID_COPY] += 1; + msg ("[MEM_MNGT][INFO] pool counters = {%2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d}\n", + counters[0],counters[1],counters[2],counters[3],counters[4], + counters[5],counters[6],counters[7],counters[8],counters[9], + counters[10],counters[11]); #endif return le; } else { diff --git a/openair2/UTIL/MEM/mem_block.h b/openair2/UTIL/MEM/mem_block.h index 8164dcf51cae3a007d19b60f684b889d07bcf7d3..c3a2f5dff21735e286c2cbb9f85bfcb174ab7b67 100644 --- a/openair2/UTIL/MEM/mem_block.h +++ b/openair2/UTIL/MEM/mem_block.h @@ -55,8 +55,8 @@ typedef struct mem_block_t { public_mem_block(void *pool_buffer_init (void);) public_mem_block(void *pool_buffer_clean (void *arg);) -public_mem_block(void free_mem_block (mem_block_t * leP);) -public_mem_block(mem_block_t* get_free_mem_block (uint32_t sizeP);) +public_mem_block(void free_mem_block (mem_block_t * leP, const char* caller);) +public_mem_block(mem_block_t* get_free_mem_block (uint32_t sizeP, const char* caller);) public_mem_block(mem_block_t *get_free_copy_mem_block (void);) public_mem_block(mem_block_t *get_free_copy_mem_block_up (void);) public_mem_block(mem_block_t *copy_mem_block (mem_block_t * leP, mem_block_t * destP);) diff --git a/openair2/UTIL/MEM/mem_mngt.c b/openair2/UTIL/MEM/mem_mngt.c index 64503d8cb7b7a4f7d4991a803be406ab23bdd84c..9f4f57cdd2c77332e5fc9f24b98e6a0d5f37b586 100644 --- a/openair2/UTIL/MEM/mem_mngt.c +++ b/openair2/UTIL/MEM/mem_mngt.c @@ -161,7 +161,7 @@ pool_buffer_clean (void *arg) } //----------------------------------------------------------------------------- void -free_mem_block (mem_block_t * leP) +free_mem_block (mem_block_t * leP, __func__) { //----------------------------------------------------------------------------- @@ -171,10 +171,10 @@ free_mem_block (mem_block_t * leP) } #ifdef DEBUG_MEM_MNGT_FREE - msg ("[MEM_MNGT][FREE] free_mem_block() %p pool: %d\n", leP, leP->pool_id); + msg ("[MEM_MNGT][FREE] free_mem_block() %p pool: %d\n", leP, leP->pool_id, __func__); #endif #ifdef DEBUG_MEM_MNGT_ALLOC - check_free_mem_block (leP); + check_free_mem_block (leP, __func__); #endif if (leP->pool_id <= MEM_MNGT_POOL_ID_COPY) { @@ -184,14 +184,14 @@ free_mem_block (mem_block_t * leP) #endif leP = NULL; // this prevent from freeing the block twice } else { - msg ("[MEM_MNGT][FREE] ERROR free_mem_block() unknown pool_id : %d\n", leP->pool_id); + msg ("[MEM_MNGT][FREE] ERROR free_mem_block() unknown pool_id : %d\n", leP->pool_id, __func__); } } //----------------------------------------------------------------------------- mem_block_t * -get_free_mem_block (uint16_t sizeP) +get_free_mem_block (uint16_t sizeP, __func__) { //----------------------------------------------------------------------------- mem_block_t *le = NULL; @@ -414,7 +414,7 @@ check_mem_area (void *arg) //----------------------------------------------------------------------------- void -check_free_mem_block (mem_block_t * leP) +check_free_mem_block (mem_block_t * leP, __func__) { //----------------------------------------------------------------------------- int block_index; diff --git a/openair2/UTIL/OMG/common.c b/openair2/UTIL/OMG/common.c index fc41e5dd3a311849fa7d9a4e60feb3500c672223..f1c850e689a82c1a276cbc190ddaa943227470a4 100644 --- a/openair2/UTIL/OMG/common.c +++ b/openair2/UTIL/OMG/common.c @@ -199,7 +199,11 @@ display_node_list (node_list * node_vector) //use a python script to postprocess the positions, check the // support: view node mobility of one node during the entire simulation OR only one snapshot - LOG_F(OMG,"%d; %.3f; %.3f; %.3f\n", + /* TODO: this LOG_F generates a warning, below is a fix that removes a %.3f, maybe it's not the correct fix */ + /*LOG_F(OMG,"%d; %.3f; %.3f; %.3f\n", + tmp->node->id, + tmp->node->x_pos, tmp->node->y_pos);*/ + LOG_F(OMG,"%d; %.3f; %.3f\n", tmp->node->id, tmp->node->x_pos, tmp->node->y_pos); diff --git a/openair2/UTIL/OPT/probe.c b/openair2/UTIL/OPT/probe.c index 1c6b8e814bca524fa040d610501b6e9b106d2ed5..711436d2cd1ca9d703ce01e6fb4008f61720a1ab 100644 --- a/openair2/UTIL/OPT/probe.c +++ b/openair2/UTIL/OPT/probe.c @@ -159,7 +159,7 @@ static void *opt_listener_thread(void *arg) pthread_exit(NULL); } else { /* Normal read -> discard PDU */ - LOG_D(OPT, "Incoming data received from: %s:%u with length %d\n", + LOG_D(OPT, "Incoming data received from: %s:%u with length %zd\n", inet_ntoa(opt_listener.address.sin_addr), ntohs(opt_listener.address.sin_port), ret); } @@ -198,7 +198,9 @@ int opt_create_listener_socket(char *ip_address, uint16_t port) ret = bind(opt_listener.sd, (struct sockaddr*) &opt_listener.address, sizeof(opt_listener.address)); if (ret != 0) { - LOG_E(OPT, "Failed to bind socket to (%s:%u): %s\n", strerror(errno)); + LOG_E(OPT, "Failed to bind socket to (%s:%u): %s\n", + inet_ntoa(opt_listener.address.sin_addr), + ntohs(opt_listener.address.sin_port), strerror(errno)); opt_type = OPT_NONE; close(opt_listener.sd); opt_listener.sd = -1; @@ -358,7 +360,7 @@ static void SendFrame(guint8 radioType, guint8 direction, guint8 rntiType, (const struct sockaddr *)&g_serv_addr, sizeof(g_serv_addr)); if (bytesSent != frameOffset) { - LOG_W(OPT, "sendto() failed (not a thread-safe func)- expected %d bytes, got %d (errno=%d)\n", + LOG_W(OPT, "sendto() failed (not a thread-safe func)- expected %d bytes, got %ld (errno=%d)\n", frameOffset, bytesSent, errno); //exit(1); } diff --git a/openair2/UTIL/OSA/osa_stream_eea.c b/openair2/UTIL/OSA/osa_stream_eea.c index 6aef6d2588ad26d22d15f44da7dbe7ab29dd7935..58bae091d88ae759c8589b9a3efbedccbf84e89b 100644 --- a/openair2/UTIL/OSA/osa_stream_eea.c +++ b/openair2/UTIL/OSA/osa_stream_eea.c @@ -27,6 +27,7 @@ #include #include #include +#include #include "UTIL/LOG/log.h" diff --git a/openair2/UTIL/OTG/otg_kpi.c b/openair2/UTIL/OTG/otg_kpi.c index a056fe245633f14a4b3bb9764646b793041553a1..3f24d01ce6642b2ac656992e2ff9522e6c961166 100644 --- a/openair2/UTIL/OTG/otg_kpi.c +++ b/openair2/UTIL/OTG/otg_kpi.c @@ -216,7 +216,7 @@ void average_total_jitter(void) } } - LOG_I(OTG,"average_jitter_dl %d average_jitter_ul %lf \n",otg_info->average_jitter_dl,otg_info->average_jitter_ul ); + LOG_I(OTG,"average_jitter_dl %lf average_jitter_ul %lf \n",otg_info->average_jitter_dl,otg_info->average_jitter_ul ); // otg_info->average_jitter_dl/= (float)NB_UE_INST; // otg_info->average_jitter_ul/= (float)NB_UE_INST; } diff --git a/openair2/UTIL/OTG/otg_rx.c b/openair2/UTIL/OTG/otg_rx.c index 95cf19c1bd719a731636bc5cb0a98273e2f77e88..824439e8737284345a53ba14ae92267f0bae3bde 100644 --- a/openair2/UTIL/OTG/otg_rx.c +++ b/openair2/UTIL/OTG/otg_rx.c @@ -106,8 +106,10 @@ int otg_rx_pkt(const int dst_instanceP, const int ctime, const char * const buff if (dst_instance != dst_instanceP) { //#warning "LG: TODO think about multicast traffic" - LOG_W(OTG,"[SRC %d][DST %d] [FLOW_idx %d][APP TYPE %d] RX INFO pkt at time %d: flag 0x %x, seq number %d, tx time %d, size (hdr %d, pdcp %d) not for dest instance %u\n", - dst_instanceP); + /* TODO: fix this LOG, a lot of missing parameters, replaced by a simple basic version */ + /*LOG_W(OTG,"[SRC %d][DST %d] [FLOW_idx %d][APP TYPE %d] RX INFO pkt at time %d: flag 0x %x, seq number %d, tx time %d, size (hdr %d, pdcp %d) not for dest instance %u\n", + dst_instanceP);*/ + LOG_W(OTG,"dst_instance != dst_instanceP\n"); } if(otg_hdr_rx->traffic_type > MAX_NUM_APPLICATION) { @@ -246,7 +248,7 @@ int otg_rx_pkt(const int dst_instanceP, const int ctime, const char * const buff ctime - otg_hdr_rx->time, nb_loss_pkts); - LOG_I(OTG,"INFO LATENCY :: [SRC %d][DST %d] radio access %.2f (tx time %d, ctime %d), OWD:%.2f (ms):\n", + LOG_I(OTG,"INFO LATENCY :: [SRC %d][DST %d] radio access %.2f (tx time %d, ctime %d), OWD:%d (ms):\n", src_instance, dst_instance, otg_multicast_info->radio_access_delay[src_instance][dst_instance], diff --git a/openair2/UTIL/OTG/otg_tx.c b/openair2/UTIL/OTG/otg_tx.c index bdf8137cfa42c07159e0a156c9983d9324504ff5..d1ad2b2ed30e088ae687c3cef03812a21d3b2c56 100644 --- a/openair2/UTIL/OTG/otg_tx.c +++ b/openair2/UTIL/OTG/otg_tx.c @@ -305,10 +305,10 @@ unsigned char *packet_gen( otg_info->tx_num_pkt[src_instance][dst_instance][otg_info->traffic_type[src_instance][dst_instance]]+=1; if (size!=strlen(payload)) - LOG_E(OTG,"[%d][%d] [0x %x] The expected packet size does not match the payload size : size %d, strlen %d, seq_num %d packet: |%s|%s| \n", + LOG_E(OTG,"[%d][%d] [0x %x] The expected packet size does not match the payload size : size %d, strlen %zu, seq_num %d packet: |%s|%s| \n", src_instance, dst_instance, flag, size, strlen(payload), seq_num, header, payload); else - LOG_D(OTG,"[%d][%d] 0x %x][m2m Aggre %d][Flow %d][Type %d/%s] TX INFO pkt at time %d Size= [payload %d] [Total %d] with seq num %d, state=%d : |%s|%s| \n", + LOG_D(OTG,"[%d][%d] 0x %x][m2m Aggre %d][Flow %d][Type %d/%s] TX INFO pkt at time %d Size= [payload %d] [Total %zu] with seq num %d, state=%d : |%s|%s| \n", src_instance, dst_instance, flag, otg_info->m2m_aggregation[src_instance][dst_instance], otg_info->flow_id[src_instance][dst_instance], @@ -335,7 +335,7 @@ unsigned char *packet_gen( otg_info->seq_num_background[src_instance][dst_instance]+=1; if (otg_info->size_background[src_instance][dst_instance]!=strlen(payload)) - LOG_E(OTG,"[%d][%d] [0x %x] The expected packet size does not match the payload size : size %d, strlen %d, seq num %d, packet |%s|%s| \n", + LOG_E(OTG,"[%d][%d] [0x %x] The expected packet size does not match the payload size : size %d, strlen %zu, seq num %d, packet |%s|%s| \n", src_instance, dst_instance, flag, @@ -345,7 +345,7 @@ unsigned char *packet_gen( header, payload); else - LOG_D(OTG,"[%d][%d][%s][0x %x] TX INFO pkt at time %d size is %d with seq num %d, state=%d : |%s|%s| \n", + LOG_D(OTG,"[%d][%d][0x %x][%d] TX INFO pkt at time %s size is %d with seq num %d, state=%d : |%s|%s| \n", src_instance, dst_instance, flag, @@ -459,10 +459,10 @@ unsigned char *packet_gen_multicast( otg_multicast_info->tx_num_bytes[src_instance][dst_instance][app]); if (size!=strlen(payload)) - LOG_E(OTG,"[src %d][dst %d] The expected packet size does not match the payload size : size %d, strlen %d \n", + LOG_E(OTG,"[src %d][dst %d] The expected packet size does not match the payload size : size %d, strlen %zu \n", src_instance, dst_instance, size, strlen(payload)); else { - LOG_I(OTG,"[src %d][dst %d]TX INFO pkt at time %d Size= [payload %d] [Total %d] with seq num %d: |%s|%s| \n", + LOG_I(OTG,"[src %d][dst %d]TX INFO pkt at time %d Size= [payload %d] [Total %zu] with seq num %d: |%s|%s| \n", src_instance, dst_instance, ctime, @@ -838,7 +838,7 @@ unsigned int header_size(const int hdr_size) if (hdr_size>(sizeof(otg_hdr_info_t) + sizeof(otg_hdr_t))) size-=(sizeof(otg_hdr_info_t) + sizeof(otg_hdr_t)); else - LOG_W(OTG,"OTG Header not included inside packet header (OTG header:%d, Header%d)\n", hdr_size, sizeof(otg_hdr_info_t) + sizeof(otg_hdr_t) ); + LOG_W(OTG,"OTG Header not included inside packet header (OTG header:%d, Header%zu)\n", hdr_size, sizeof(otg_hdr_info_t) + sizeof(otg_hdr_t) ); return(size); @@ -1211,7 +1211,7 @@ void init_predef_traffic( break; case M2M_TRAFFIC : /* example of M2M traffic */ - LOG_I(OTG," M2M_TRAFFIC, src = %d, dst = %d \n", i, j, g_otg->application_type[i][j][k]); + LOG_I(OTG," M2M_TRAFFIC, src = %d, dst = %d, application type = %d\n", i, j, g_otg->application_type[i][j][k]); g_otg->trans_proto[i][j][k] = TCP; g_otg->ip_v[i][j][k] = IPV4; g_otg->pu_size_pkts[i][j][k]=50; @@ -2015,7 +2015,7 @@ void state_management( && (otg_info->state_transition_prob[src_instance][dst_instance][application]<=1)) && (otg_info->c_holding_time_off[src_instance][dst_instance]>=g_otg->holding_time_off_pe[src_instance][dst_instance])) { otg_info->state[src_instance][dst_instance][application]=PE_STATE; - LOG_I(OTG,"[%d][%d][Appli id %d][Agg Level=%d] NEW STATE:: OFF-->PE \n", src_instance, dst_instance,application, g_otg->aggregation_level[src_instance][dst_instance]); + LOG_I(OTG,"[%d][%d][Appli id %d][Agg Level=%d] NEW STATE:: OFF-->PE \n", src_instance, dst_instance,application, g_otg->aggregation_level[src_instance][dst_instance][application]); otg_info->state_transition_prob[src_instance][dst_instance][application]=uniform_dist(0,1); } else { diff --git a/openair2/UTIL/TIMER/umts_timer.c b/openair2/UTIL/TIMER/umts_timer.c index ff21ce8e840a1d3e5f5bf5057f08ab819d18d6d1..9978419fb8f99761c59da05277eb659634ea3ab3 100644 --- a/openair2/UTIL/TIMER/umts_timer.c +++ b/openair2/UTIL/TIMER/umts_timer.c @@ -54,7 +54,7 @@ umts_timer_check_time_out (list2_t * atimer_listP, uint32_t current_frame_tick_m mem_unit = list2_remove_head (atimer_listP); (*(timer->proc)) (timer->protocol, timer->timer_id); - free_mem_block (mem_unit); + free_mem_block (mem_unit, __func__); mem_unit = atimer_listP->head; } else { @@ -74,7 +74,7 @@ umts_timer_delete_timer (list2_t * atimer_listP, void *timer_idP) while ((mem_unit)) { if (((struct timer_unit *) (mem_unit->data))->timer_id == timer_idP) { list2_remove_element (mem_unit, atimer_listP); - free_mem_block (mem_unit); + free_mem_block (mem_unit, __func__); return; } @@ -93,7 +93,7 @@ umts_add_timer_list_up (list2_t * atimer_listP, void (*procP) (void *, void *), int32_t remaining_time; uint8_t inserted = 0; - mb = get_free_mem_block (sizeof (struct timer_unit)); + mb = get_free_mem_block (sizeof (struct timer_unit), __func__); ((struct timer_unit *) (mb->data))->proc = procP; ((struct timer_unit *) (mb->data))->protocol = protocolP; ((struct timer_unit *) (mb->data))->timer_id = timer_idP; @@ -166,7 +166,7 @@ umts_stop_all_timers_except (list2_t * atimer_listP, void (*procP) (void *, void mem_unit_to_delete = mem_unit; mem_unit = mem_unit->next; list2_remove_element (mem_unit_to_delete, atimer_listP); - free_mem_block (mem_unit_to_delete); + free_mem_block (mem_unit_to_delete, __func__); } else { mem_unit = mem_unit->next; } diff --git a/openair3/COMMON/as_message.h b/openair3/COMMON/as_message.h deleted file mode 120000 index 3bfc76865acee46a60802c21105d4fa1822373d0..0000000000000000000000000000000000000000 --- a/openair3/COMMON/as_message.h +++ /dev/null @@ -1 +0,0 @@ -../../openair2/COMMON/as_message.h \ No newline at end of file diff --git a/openair3/COMMON/as_message.h b/openair3/COMMON/as_message.h new file mode 100644 index 0000000000000000000000000000000000000000..30810a325eace63c944b947bfb8c0a6487094e80 --- /dev/null +++ b/openair3/COMMON/as_message.h @@ -0,0 +1,578 @@ +/* + * Copyright (c) 2015, EURECOM (www.eurecom.fr) + * 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 THE COPYRIGHT HOLDERS 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 THE COPYRIGHT OWNER 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. + * + * The views and conclusions contained in the software and documentation are those + * of the authors and should not be interpreted as representing official policies, + * either expressed or implied, of the FreeBSD Project. + */ + + +/***************************************************************************** + +Source as_message.h + +Version 0.1 + +Date 2012/10/18 + +Product NAS stack + +Subsystem Application Programming Interface + +Author Frederic Maurel + +Description Defines the messages supported by the Access Stratum sublayer + protocol (usually RRC and S1AP for E-UTRAN) and functions used + to encode and decode + +*****************************************************************************/ +#ifndef __AS_MESSAGE_H__ +#define __AS_MESSAGE_H__ + +#include "commonDef.h" +#include "networkDef.h" + +/****************************************************************************/ +/********************* G L O B A L C O N S T A N T S *******************/ +/****************************************************************************/ + +/* + * -------------------------------------------------------------------------- + * Access Stratum message types + * -------------------------------------------------------------------------- + */ +#define AS_REQUEST 0x0100 +#define AS_RESPONSE 0x0200 +#define AS_INDICATION 0x0400 +#define AS_CONFIRM 0x0800 + +/* + * -------------------------------------------------------------------------- + * Access Stratum message identifiers + * -------------------------------------------------------------------------- + */ + +/* Broadcast information */ +#define AS_BROADCAST_INFO 0x01 +#define AS_BROADCAST_INFO_IND (AS_BROADCAST_INFO | AS_INDICATION) + +/* Cell information relevant for cell selection processing */ +#define AS_CELL_INFO 0x02 +#define AS_CELL_INFO_REQ (AS_CELL_INFO | AS_REQUEST) +#define AS_CELL_INFO_CNF (AS_CELL_INFO | AS_CONFIRM) +#define AS_CELL_INFO_IND (AS_CELL_INFO | AS_INDICATION) + +/* Paging information */ +#define AS_PAGING 0x03 +#define AS_PAGING_REQ (AS_PAGING | AS_REQUEST) +#define AS_PAGING_IND (AS_PAGING | AS_INDICATION) + +/* NAS signalling connection establishment */ +#define AS_NAS_ESTABLISH 0x04 +#define AS_NAS_ESTABLISH_REQ (AS_NAS_ESTABLISH | AS_REQUEST) +#define AS_NAS_ESTABLISH_IND (AS_NAS_ESTABLISH | AS_INDICATION) +#define AS_NAS_ESTABLISH_RSP (AS_NAS_ESTABLISH | AS_RESPONSE) +#define AS_NAS_ESTABLISH_CNF (AS_NAS_ESTABLISH | AS_CONFIRM) + +/* NAS signalling connection release */ +#define AS_NAS_RELEASE 0x05 +#define AS_NAS_RELEASE_REQ (AS_NAS_RELEASE | AS_REQUEST) +#define AS_NAS_RELEASE_IND (AS_NAS_RELEASE | AS_INDICATION) + +/* Uplink information transfer */ +#define AS_UL_INFO_TRANSFER 0x06 +#define AS_UL_INFO_TRANSFER_REQ (AS_UL_INFO_TRANSFER | AS_REQUEST) +#define AS_UL_INFO_TRANSFER_CNF (AS_UL_INFO_TRANSFER | AS_CONFIRM) +#define AS_UL_INFO_TRANSFER_IND (AS_UL_INFO_TRANSFER | AS_INDICATION) + +/* Downlink information transfer */ +#define AS_DL_INFO_TRANSFER 0x07 +#define AS_DL_INFO_TRANSFER_REQ (AS_DL_INFO_TRANSFER | AS_REQUEST) +#define AS_DL_INFO_TRANSFER_CNF (AS_DL_INFO_TRANSFER | AS_CONFIRM) +#define AS_DL_INFO_TRANSFER_IND (AS_DL_INFO_TRANSFER | AS_INDICATION) + +/* Radio Access Bearer establishment */ +#define AS_RAB_ESTABLISH 0x08 +#define AS_RAB_ESTABLISH_REQ (AS_RAB_ESTABLISH | AS_REQUEST) +#define AS_RAB_ESTABLISH_IND (AS_RAB_ESTABLISH | AS_INDICATION) +#define AS_RAB_ESTABLISH_RSP (AS_RAB_ESTABLISH | AS_RESPONSE) +#define AS_RAB_ESTABLISH_CNF (AS_RAB_ESTABLISH | AS_CONFIRM) + +/* Radio Access Bearer release */ +#define AS_RAB_RELEASE 0x09 +#define AS_RAB_RELEASE_REQ (AS_RAB_RELEASE | AS_REQUEST) +#define AS_RAB_RELEASE_IND (AS_RAB_RELEASE | AS_INDICATION) + +/* NAS Cause */ +#define EPS_SERVICES_AND_NON_EPS_SERVICES_NOT_ALLOWED (8) +#define EPS_SERVICES_NOT_ALLOWED (7) +#define PLMN_NOT_ALLOWED (11) +#define TRACKING_AREA_NOT_ALLOWED (12) +#define ROAMING_NOT_ALLOWED_IN_THIS_TRACKING_AREA (13) +#define EPS_SERVICES_NOT_ALLOWED_IN_THIS_PLMN (14) +#define NO_SUITABLE_CELLS_IN_TRACKING_AREA (15) +#define NETWORK_FAILURE (17) +#define ESM_FAILURE (19) + +typedef enum nas_cause_s { + NAS_CAUSE_EPS_SERVICES_AND_NON_EPS_SERVICES_NOT_ALLOWED = EPS_SERVICES_AND_NON_EPS_SERVICES_NOT_ALLOWED, + NAS_CAUSE_EPS_SERVICES_NOT_ALLOWED = EPS_SERVICES_NOT_ALLOWED, + NAS_CAUSE_PLMN_NOT_ALLOWED = PLMN_NOT_ALLOWED, + NAS_CAUSE_TRACKING_AREA_NOT_ALLOWED = TRACKING_AREA_NOT_ALLOWED, + NAS_CAUSE_ROAMING_NOT_ALLOWED_IN_THIS_TRACKING_AREA = ROAMING_NOT_ALLOWED_IN_THIS_TRACKING_AREA, + NAS_CAUSE_EPS_SERVICES_NOT_ALLOWED_IN_THIS_PLMN = EPS_SERVICES_NOT_ALLOWED_IN_THIS_PLMN, + NAS_CAUSE_NO_SUITABLE_CELLS_IN_TRACKING_AREA = NO_SUITABLE_CELLS_IN_TRACKING_AREA, + NAS_CAUSE_NETWORK_FAILURE = NETWORK_FAILURE, + NAS_CAUSE_ESM_FAILURE = ESM_FAILURE +} nas_cause_t; + +/* + * -------------------------------------------------------------------------- + * Access Stratum message global parameters + * -------------------------------------------------------------------------- + */ + +/* Error code */ +typedef enum nas_error_code_s { + AS_SUCCESS = 1, /* Success code, transaction is going on */ + AS_TERMINATED_NAS, /* Transaction terminated by NAS */ + AS_TERMINATED_AS, /* Transaction terminated by AS */ + AS_FAILURE /* Failure code */ +} nas_error_code_t; + +/* Core network domain */ +typedef enum core_network_s { + AS_PS = 1, /* Packet-Switched */ + AS_CS /* Circuit-Switched */ +} core_network_t; + +/* SAE Temporary Mobile Subscriber Identity */ +typedef struct as_stmsi_s { + uint8_t MMEcode; /* MME code that allocated the GUTI */ + uint32_t m_tmsi; /* M-Temporary Mobile Subscriber Identity */ +} as_stmsi_t; + +/* Dedicated NAS information */ +typedef struct as_nas_info_s { + uint32_t length; /* Length of the NAS information data */ + Byte_t* data; /* Dedicated NAS information data container */ +} as_nas_info_t; + +/* Radio Access Bearer identity */ +typedef uint8_t as_rab_id_t; + +/****************************************************************************/ +/************************ G L O B A L T Y P E S ************************/ +/****************************************************************************/ + +/* + * -------------------------------------------------------------------------- + * Broadcast information + * -------------------------------------------------------------------------- + */ + +/* + * AS->NAS - Broadcast information indication + * AS may asynchronously report to NAS available PLMNs within specific + * location area + */ +typedef struct broadcast_info_ind_s { +#define PLMN_LIST_MAX_SIZE 6 + PLMN_LIST_T(PLMN_LIST_MAX_SIZE) plmnIDs; /* List of PLMN identifiers */ + ci_t cellID; /* Identity of the cell serving the listed PLMNs */ + tac_t tac; /* Code of the tracking area the cell belongs to */ +} broadcast_info_ind_t; + +/* + * -------------------------------------------------------------------------- + * Cell information relevant for cell selection processing + * -------------------------------------------------------------------------- + */ + +/* Radio access technologies supported by the network */ +#define AS_GSM (1 << NET_ACCESS_GSM) +#define AS_COMPACT (1 << NET_ACCESS_COMPACT) +#define AS_UTRAN (1 << NET_ACCESS_UTRAN) +#define AS_EGPRS (1 << NET_ACCESS_EGPRS) +#define AS_HSDPA (1 << NET_ACCESS_HSDPA) +#define AS_HSUPA (1 << NET_ACCESS_HSUPA) +#define AS_HSDUPA (1 << NET_ACCESS_HSDUPA) +#define AS_EUTRAN (1 << NET_ACCESS_EUTRAN) + +/* + * NAS->AS - Cell Information request + * NAS request AS to search for a suitable cell belonging to the selected + * PLMN to camp on. + */ +typedef struct cell_info_req_s { + plmn_t plmnID; /* Selected PLMN identity */ + Byte_t rat; /* Bitmap - set of radio access technologies */ +} cell_info_req_t; + +/* + * AS->NAS - Cell Information confirm + * AS search for a suitable cell and respond to NAS. If found, the cell + * is selected to camp on. + */ +typedef struct cell_info_cnf_s { + uint8_t errCode; /* Error code */ + ci_t cellID; /* Identity of the cell serving the selected PLMN */ + tac_t tac; /* Code of the tracking area the cell belongs to */ + AcT_t rat; /* Radio access technology supported by the cell */ + uint8_t rsrq; /* Reference signal received quality */ + uint8_t rsrp; /* Reference signal received power */ +} cell_info_cnf_t; + +/* + * AS->NAS - Cell Information indication + * AS may change cell selection if a more suitable cell is found. + */ +typedef struct cell_info_ind_s { + ci_t cellID; /* Identity of the new serving cell */ + tac_t tac; /* Code of the tracking area the cell belongs to */ +} cell_info_ind_t; + +/* + * -------------------------------------------------------------------------- + * Paging information + * -------------------------------------------------------------------------- + */ + +/* Paging cause */ +typedef enum paging_cause_s { + AS_CONNECTION_ESTABLISH, /* Establish NAS signalling connection */ + AS_EPS_ATTACH, /* Perform local detach and initiate EPS + * attach procedure */ + AS_CS_FALLBACK /* Inititate CS fallback procedure */ +} paging_cause_t; + +/* + * NAS->AS - Paging Information request + * NAS requests the AS that NAS signalling messages or user data is pending + * to be sent. + */ +typedef struct paging_req_s { + as_stmsi_t s_tmsi; /* UE identity */ + uint8_t CN_domain; /* Core network domain */ +} paging_req_t; + +/* + * AS->NAS - Paging Information indication + * AS reports to the NAS that appropriate procedure has to be initiated. + */ +typedef struct paging_ind_s { + paging_cause_t cause; /* Paging cause */ +} paging_ind_t; + +/* + * -------------------------------------------------------------------------- + * NAS signalling connection establishment + * -------------------------------------------------------------------------- + */ + +/* Cause of RRC connection establishment */ +typedef enum as_cause_s { + AS_CAUSE_UNKNOWN = 0, + AS_CAUSE_EMERGENCY = NET_ESTABLISH_CAUSE_EMERGENCY, + AS_CAUSE_HIGH_PRIO = NET_ESTABLISH_CAUSE_HIGH_PRIO, + AS_CAUSE_MT_ACCESS = NET_ESTABLISH_CAUSE_MT_ACCESS, + AS_CAUSE_MO_SIGNAL = NET_ESTABLISH_CAUSE_MO_SIGNAL, + AS_CAUSE_MO_DATA = NET_ESTABLISH_CAUSE_MO_DATA, + AS_CAUSE_V1020 = NET_ESTABLISH_CAUSE_V1020 +} as_cause_t; + +/* Type of the call associated to the RRC connection establishment */ +typedef enum as_call_type_s { + AS_TYPE_ORIGINATING_SIGNAL = NET_ESTABLISH_TYPE_ORIGINATING_SIGNAL, + AS_TYPE_EMERGENCY_CALLS = NET_ESTABLISH_TYPE_EMERGENCY_CALLS, + AS_TYPE_ORIGINATING_CALLS = NET_ESTABLISH_TYPE_ORIGINATING_CALLS, + AS_TYPE_TERMINATING_CALLS = NET_ESTABLISH_TYPE_TERMINATING_CALLS, + AS_TYPE_MO_CS_FALLBACK = NET_ESTABLISH_TYPE_MO_CS_FALLBACK +} as_call_type_t; + +/* + * NAS->AS - NAS signalling connection establishment request + * NAS requests the AS to perform the RRC connection establishment procedure + * to transfer initial NAS message to the network while UE is in IDLE mode. + */ +typedef struct nas_establish_req_s { + as_cause_t cause; /* RRC connection establishment cause */ + as_call_type_t type; /* RRC associated call type */ + as_stmsi_t s_tmsi; /* UE identity */ + plmn_t plmnID; /* Selected PLMN identity */ + as_nas_info_t initialNasMsg; /* Initial NAS message to transfer */ +} nas_establish_req_t; + +/* + * AS->NAS - NAS signalling connection establishment indication + * AS transfers the initial NAS message to the NAS. + */ +typedef struct nas_establish_ind_s { + uint32_t UEid; /* UE lower layer identifier */ + tac_t tac; /* Code of the tracking area the initiating + * UE belongs to */ + as_cause_t asCause; /* Establishment cause */ + as_nas_info_t initialNasMsg; /* Initial NAS message to transfer */ +} nas_establish_ind_t; + +/* + * NAS->AS - NAS signalling connection establishment response + * NAS responds to the AS that initial answer message has to be provided to + * the UE. + */ +typedef struct nas_establish_rsp_s { + uint32_t UEid; /* UE lower layer identifier */ + as_stmsi_t s_tmsi; /* UE identity */ + nas_error_code_t errCode; /* Transaction status */ + as_nas_info_t nasMsg; /* NAS message to transfer */ + uint32_t nas_ul_count; /* UL NAS COUNT */ + uint16_t selected_encryption_algorithm; + uint16_t selected_integrity_algorithm; +} nas_establish_rsp_t; + +/* + * AS->NAS - NAS signalling connection establishment confirm + * AS transfers the initial answer message to the NAS. + */ +typedef struct nas_establish_cnf_s { + uint32_t UEid; /* UE lower layer identifier */ + nas_error_code_t errCode; /* Transaction status */ + as_nas_info_t nasMsg; /* NAS message to transfer */ + uint32_t ul_nas_count; + uint16_t selected_encryption_algorithm; + uint16_t selected_integrity_algorithm; +} nas_establish_cnf_t; + +/* + * -------------------------------------------------------------------------- + * NAS signalling connection release + * -------------------------------------------------------------------------- + */ + +/* Release cause */ +typedef enum release_cause_s { + AS_AUTHENTICATION_FAILURE = 1, /* Authentication procedure failed */ + AS_DETACH /* Detach requested */ +} release_cause_t; + +/* + * NAS->AS - NAS signalling connection release request + * NAS requests the termination of the connection with the UE. + */ +typedef struct nas_release_req_s { + uint32_t UEid; /* UE lower layer identifier */ + as_stmsi_t s_tmsi; /* UE identity */ + release_cause_t cause; /* Release cause */ +} nas_release_req_t; + +/* + * AS->NAS - NAS signalling connection release indication + * AS reports that connection has been terminated by the network. + */ +typedef struct nas_release_ind_s { + release_cause_t cause; /* Release cause */ +} nas_release_ind_t; + +/* + * -------------------------------------------------------------------------- + * NAS information transfer + * -------------------------------------------------------------------------- + */ + +/* + * NAS->AS - Uplink data transfer request + * NAS requests the AS to transfer uplink information to the NAS that + * operates at the network side. + */ +typedef struct ul_info_transfer_req_s { + uint32_t UEid; /* UE lower layer identifier */ + as_stmsi_t s_tmsi; /* UE identity */ + as_nas_info_t nasMsg; /* Uplink NAS message */ +} ul_info_transfer_req_t; + +/* + * AS->NAS - Uplink data transfer confirm + * AS immediately notifies the NAS whether uplink information has been + * successfully sent to the network or not. + */ +typedef struct ul_info_transfer_cnf_s { + uint32_t UEid; /* UE lower layer identifier */ + nas_error_code_t errCode; /* Transaction status */ +} ul_info_transfer_cnf_t; + +/* + * AS->NAS - Uplink data transfer indication + * AS delivers the uplink information message to the NAS that operates + * at the network side. + */ +typedef struct ul_info_transfer_ind_s { + uint32_t UEid; /* UE lower layer identifier */ + as_nas_info_t nasMsg; /* Uplink NAS message */ +} ul_info_transfer_ind_t; + +/* + * NAS->AS - Downlink data transfer request + * NAS requests the AS to transfer downlink information to the NAS that + * operates at the UE side. + */ +typedef ul_info_transfer_req_t dl_info_transfer_req_t; + +/* + * AS->NAS - Downlink data transfer confirm + * AS immediately notifies the NAS whether downlink information has been + * successfully sent to the network or not. + */ +typedef ul_info_transfer_cnf_t dl_info_transfer_cnf_t; + +/* + * AS->NAS - Downlink data transfer indication + * AS delivers the downlink information message to the NAS that operates + * at the UE side. + */ +typedef ul_info_transfer_ind_t dl_info_transfer_ind_t; + +/* + * -------------------------------------------------------------------------- + * Radio Access Bearer establishment + * -------------------------------------------------------------------------- + */ + +/* TODO: Quality of Service parameters */ +typedef struct {} as_qos_t; + +/* + * NAS->AS - Radio access bearer establishment request + * NAS requests the AS to allocate transmission resources to radio access + * bearer initialized at the network side. + */ +typedef struct rab_establish_req_s { + as_stmsi_t s_tmsi; /* UE identity */ + as_rab_id_t rabID; /* Radio access bearer identity */ + as_qos_t QoS; /* Requested Quality of Service */ +} rab_establish_req_t; + +/* + * AS->NAS - Radio access bearer establishment indication + * AS notifies the NAS that specific radio access bearer has to be setup. + */ +typedef struct rab_establish_ind_s { + as_rab_id_t rabID; /* Radio access bearer identity */ +} rab_establish_ind_t; + +/* + * NAS->AS - Radio access bearer establishment response + * NAS responds to AS whether the specified radio access bearer has been + * successfully setup or not. + */ +typedef struct rab_establish_rsp_s { + as_stmsi_t s_tmsi; /* UE identity */ + as_rab_id_t rabID; /* Radio access bearer identity */ + nas_error_code_t errCode; /* Transaction status */ +} rab_establish_rsp_t; + +/* + * AS->NAS - Radio access bearer establishment confirm + * AS notifies NAS whether the specified radio access bearer has been + * successfully setup at the UE side or not. + */ +typedef struct rab_establish_cnf_s { + as_rab_id_t rabID; /* Radio access bearer identity */ + nas_error_code_t errCode; /* Transaction status */ +} rab_establish_cnf_t; + +/* + * -------------------------------------------------------------------------- + * Radio Access Bearer release + * -------------------------------------------------------------------------- + */ + +/* + * NAS->AS - Radio access bearer release request + * NAS requests the AS to release transmission resources previously allocated + * to specific radio access bearer at the network side. + */ +typedef struct rab_release_req_s { + as_stmsi_t s_tmsi; /* UE identity */ + as_rab_id_t rabID; /* Radio access bearer identity */ +} rab_release_req_t; + +/* + * AS->NAS - Radio access bearer release indication + * AS notifies NAS that specific radio access bearer has been released. + */ +typedef struct rab_release_ind_s { + as_rab_id_t rabID; /* Radio access bearer identity */ +} rab_release_ind_t; + +/* + * -------------------------------------------------------------------------- + * Structure of the AS messages handled by the network sublayer + * -------------------------------------------------------------------------- + */ +typedef struct as_message_s { + uint16_t msgID; + union { + broadcast_info_ind_t broadcast_info_ind; + cell_info_req_t cell_info_req; + cell_info_cnf_t cell_info_cnf; + cell_info_ind_t cell_info_ind; + paging_req_t paging_req; + paging_ind_t paging_ind; + nas_establish_req_t nas_establish_req; + nas_establish_ind_t nas_establish_ind; + nas_establish_rsp_t nas_establish_rsp; + nas_establish_cnf_t nas_establish_cnf; + nas_release_req_t nas_release_req; + nas_release_ind_t nas_release_ind; + ul_info_transfer_req_t ul_info_transfer_req; + ul_info_transfer_cnf_t ul_info_transfer_cnf; + ul_info_transfer_ind_t ul_info_transfer_ind; + dl_info_transfer_req_t dl_info_transfer_req; + dl_info_transfer_cnf_t dl_info_transfer_cnf; + dl_info_transfer_ind_t dl_info_transfer_ind; + rab_establish_req_t rab_establish_req; + rab_establish_ind_t rab_establish_ind; + rab_establish_rsp_t rab_establish_rsp; + rab_establish_cnf_t rab_establish_cnf; + rab_release_req_t rab_release_req; + rab_release_ind_t rab_release_ind; + } __attribute__((__packed__)) msg; +} as_message_t; + +/****************************************************************************/ +/******************** G L O B A L V A R I A B L E S ********************/ +/****************************************************************************/ + +/****************************************************************************/ +/****************** E X P O R T E D F U N C T I O N S ******************/ +/****************************************************************************/ + +int as_message_decode(const char* buffer, as_message_t* msg, int length); + +int as_message_encode(char* buffer, as_message_t* msg, int length); + +/* Implemented in the network_api.c body file */ +int as_message_send(as_message_t* as_msg); + +#endif /* __AS_MESSAGE_H__*/ diff --git a/openair3/GTPV1-U/nw-gtpv1u/src/NwGtpv1u.c b/openair3/GTPV1-U/nw-gtpv1u/src/NwGtpv1u.c index a64694c0de151cdcd9249cf16702c4ab1cbe6d55..cd59028ce37dc5d45441ac0a5f3154cb9e3d846c 100644 --- a/openair3/GTPV1-U/nw-gtpv1u/src/NwGtpv1u.c +++ b/openair3/GTPV1-U/nw-gtpv1u/src/NwGtpv1u.c @@ -410,7 +410,7 @@ nwGtpv1uDestroyTunnelEndPoint( NwGtpv1uStackT *thiz, NwGtpv1uTunnelEndPointT *pRemovedTeid; if(pUlpReq->apiInfo.destroyTunnelEndPointInfo.hStackSessionHandle) { - GTPU_DEBUG( "Destroying Tunnel end-point '%x'", + GTPU_DEBUG( "Destroying Tunnel end-point '%lx'", pUlpReq->apiInfo.destroyTunnelEndPointInfo.hStackSessionHandle); pRemovedTeid = RB_REMOVE(NwGtpv1uTunnelEndPointIdentifierMap, &(thiz->teidMap), (NwGtpv1uTunnelEndPointT *)( @@ -423,7 +423,7 @@ nwGtpv1uDestroyTunnelEndPoint( NwGtpv1uStackT *thiz, (NwGtpv1uTunnelEndPointT *) pUlpReq->apiInfo.destroyTunnelEndPointInfo.hStackSessionHandle); } else { - GTPU_WARNING("Non-existent Tunnel end-point handle '%x'", + GTPU_WARNING("Non-existent Tunnel end-point handle '%lx'", pUlpReq->apiInfo.destroyTunnelEndPointInfo.hStackSessionHandle); } diff --git a/openair3/INTERTASK_INTERFACE b/openair3/INTERTASK_INTERFACE deleted file mode 120000 index 4bc54522d8ea289234614619607e5c8e9d228c42..0000000000000000000000000000000000000000 --- a/openair3/INTERTASK_INTERFACE +++ /dev/null @@ -1 +0,0 @@ -../common/utils/itti \ No newline at end of file diff --git a/openair3/NAS/COMMON/API/NETWORK/as_message.h b/openair3/NAS/COMMON/API/NETWORK/as_message.h deleted file mode 120000 index ef8d3686fd6b2b4f53bde09c5085a41cb523c0f0..0000000000000000000000000000000000000000 --- a/openair3/NAS/COMMON/API/NETWORK/as_message.h +++ /dev/null @@ -1 +0,0 @@ -../../../../../openair2/COMMON/as_message.h \ No newline at end of file diff --git a/openair3/NAS/COMMON/API/NETWORK/as_message.h b/openair3/NAS/COMMON/API/NETWORK/as_message.h new file mode 100644 index 0000000000000000000000000000000000000000..30810a325eace63c944b947bfb8c0a6487094e80 --- /dev/null +++ b/openair3/NAS/COMMON/API/NETWORK/as_message.h @@ -0,0 +1,578 @@ +/* + * Copyright (c) 2015, EURECOM (www.eurecom.fr) + * 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 THE COPYRIGHT HOLDERS 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 THE COPYRIGHT OWNER 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. + * + * The views and conclusions contained in the software and documentation are those + * of the authors and should not be interpreted as representing official policies, + * either expressed or implied, of the FreeBSD Project. + */ + + +/***************************************************************************** + +Source as_message.h + +Version 0.1 + +Date 2012/10/18 + +Product NAS stack + +Subsystem Application Programming Interface + +Author Frederic Maurel + +Description Defines the messages supported by the Access Stratum sublayer + protocol (usually RRC and S1AP for E-UTRAN) and functions used + to encode and decode + +*****************************************************************************/ +#ifndef __AS_MESSAGE_H__ +#define __AS_MESSAGE_H__ + +#include "commonDef.h" +#include "networkDef.h" + +/****************************************************************************/ +/********************* G L O B A L C O N S T A N T S *******************/ +/****************************************************************************/ + +/* + * -------------------------------------------------------------------------- + * Access Stratum message types + * -------------------------------------------------------------------------- + */ +#define AS_REQUEST 0x0100 +#define AS_RESPONSE 0x0200 +#define AS_INDICATION 0x0400 +#define AS_CONFIRM 0x0800 + +/* + * -------------------------------------------------------------------------- + * Access Stratum message identifiers + * -------------------------------------------------------------------------- + */ + +/* Broadcast information */ +#define AS_BROADCAST_INFO 0x01 +#define AS_BROADCAST_INFO_IND (AS_BROADCAST_INFO | AS_INDICATION) + +/* Cell information relevant for cell selection processing */ +#define AS_CELL_INFO 0x02 +#define AS_CELL_INFO_REQ (AS_CELL_INFO | AS_REQUEST) +#define AS_CELL_INFO_CNF (AS_CELL_INFO | AS_CONFIRM) +#define AS_CELL_INFO_IND (AS_CELL_INFO | AS_INDICATION) + +/* Paging information */ +#define AS_PAGING 0x03 +#define AS_PAGING_REQ (AS_PAGING | AS_REQUEST) +#define AS_PAGING_IND (AS_PAGING | AS_INDICATION) + +/* NAS signalling connection establishment */ +#define AS_NAS_ESTABLISH 0x04 +#define AS_NAS_ESTABLISH_REQ (AS_NAS_ESTABLISH | AS_REQUEST) +#define AS_NAS_ESTABLISH_IND (AS_NAS_ESTABLISH | AS_INDICATION) +#define AS_NAS_ESTABLISH_RSP (AS_NAS_ESTABLISH | AS_RESPONSE) +#define AS_NAS_ESTABLISH_CNF (AS_NAS_ESTABLISH | AS_CONFIRM) + +/* NAS signalling connection release */ +#define AS_NAS_RELEASE 0x05 +#define AS_NAS_RELEASE_REQ (AS_NAS_RELEASE | AS_REQUEST) +#define AS_NAS_RELEASE_IND (AS_NAS_RELEASE | AS_INDICATION) + +/* Uplink information transfer */ +#define AS_UL_INFO_TRANSFER 0x06 +#define AS_UL_INFO_TRANSFER_REQ (AS_UL_INFO_TRANSFER | AS_REQUEST) +#define AS_UL_INFO_TRANSFER_CNF (AS_UL_INFO_TRANSFER | AS_CONFIRM) +#define AS_UL_INFO_TRANSFER_IND (AS_UL_INFO_TRANSFER | AS_INDICATION) + +/* Downlink information transfer */ +#define AS_DL_INFO_TRANSFER 0x07 +#define AS_DL_INFO_TRANSFER_REQ (AS_DL_INFO_TRANSFER | AS_REQUEST) +#define AS_DL_INFO_TRANSFER_CNF (AS_DL_INFO_TRANSFER | AS_CONFIRM) +#define AS_DL_INFO_TRANSFER_IND (AS_DL_INFO_TRANSFER | AS_INDICATION) + +/* Radio Access Bearer establishment */ +#define AS_RAB_ESTABLISH 0x08 +#define AS_RAB_ESTABLISH_REQ (AS_RAB_ESTABLISH | AS_REQUEST) +#define AS_RAB_ESTABLISH_IND (AS_RAB_ESTABLISH | AS_INDICATION) +#define AS_RAB_ESTABLISH_RSP (AS_RAB_ESTABLISH | AS_RESPONSE) +#define AS_RAB_ESTABLISH_CNF (AS_RAB_ESTABLISH | AS_CONFIRM) + +/* Radio Access Bearer release */ +#define AS_RAB_RELEASE 0x09 +#define AS_RAB_RELEASE_REQ (AS_RAB_RELEASE | AS_REQUEST) +#define AS_RAB_RELEASE_IND (AS_RAB_RELEASE | AS_INDICATION) + +/* NAS Cause */ +#define EPS_SERVICES_AND_NON_EPS_SERVICES_NOT_ALLOWED (8) +#define EPS_SERVICES_NOT_ALLOWED (7) +#define PLMN_NOT_ALLOWED (11) +#define TRACKING_AREA_NOT_ALLOWED (12) +#define ROAMING_NOT_ALLOWED_IN_THIS_TRACKING_AREA (13) +#define EPS_SERVICES_NOT_ALLOWED_IN_THIS_PLMN (14) +#define NO_SUITABLE_CELLS_IN_TRACKING_AREA (15) +#define NETWORK_FAILURE (17) +#define ESM_FAILURE (19) + +typedef enum nas_cause_s { + NAS_CAUSE_EPS_SERVICES_AND_NON_EPS_SERVICES_NOT_ALLOWED = EPS_SERVICES_AND_NON_EPS_SERVICES_NOT_ALLOWED, + NAS_CAUSE_EPS_SERVICES_NOT_ALLOWED = EPS_SERVICES_NOT_ALLOWED, + NAS_CAUSE_PLMN_NOT_ALLOWED = PLMN_NOT_ALLOWED, + NAS_CAUSE_TRACKING_AREA_NOT_ALLOWED = TRACKING_AREA_NOT_ALLOWED, + NAS_CAUSE_ROAMING_NOT_ALLOWED_IN_THIS_TRACKING_AREA = ROAMING_NOT_ALLOWED_IN_THIS_TRACKING_AREA, + NAS_CAUSE_EPS_SERVICES_NOT_ALLOWED_IN_THIS_PLMN = EPS_SERVICES_NOT_ALLOWED_IN_THIS_PLMN, + NAS_CAUSE_NO_SUITABLE_CELLS_IN_TRACKING_AREA = NO_SUITABLE_CELLS_IN_TRACKING_AREA, + NAS_CAUSE_NETWORK_FAILURE = NETWORK_FAILURE, + NAS_CAUSE_ESM_FAILURE = ESM_FAILURE +} nas_cause_t; + +/* + * -------------------------------------------------------------------------- + * Access Stratum message global parameters + * -------------------------------------------------------------------------- + */ + +/* Error code */ +typedef enum nas_error_code_s { + AS_SUCCESS = 1, /* Success code, transaction is going on */ + AS_TERMINATED_NAS, /* Transaction terminated by NAS */ + AS_TERMINATED_AS, /* Transaction terminated by AS */ + AS_FAILURE /* Failure code */ +} nas_error_code_t; + +/* Core network domain */ +typedef enum core_network_s { + AS_PS = 1, /* Packet-Switched */ + AS_CS /* Circuit-Switched */ +} core_network_t; + +/* SAE Temporary Mobile Subscriber Identity */ +typedef struct as_stmsi_s { + uint8_t MMEcode; /* MME code that allocated the GUTI */ + uint32_t m_tmsi; /* M-Temporary Mobile Subscriber Identity */ +} as_stmsi_t; + +/* Dedicated NAS information */ +typedef struct as_nas_info_s { + uint32_t length; /* Length of the NAS information data */ + Byte_t* data; /* Dedicated NAS information data container */ +} as_nas_info_t; + +/* Radio Access Bearer identity */ +typedef uint8_t as_rab_id_t; + +/****************************************************************************/ +/************************ G L O B A L T Y P E S ************************/ +/****************************************************************************/ + +/* + * -------------------------------------------------------------------------- + * Broadcast information + * -------------------------------------------------------------------------- + */ + +/* + * AS->NAS - Broadcast information indication + * AS may asynchronously report to NAS available PLMNs within specific + * location area + */ +typedef struct broadcast_info_ind_s { +#define PLMN_LIST_MAX_SIZE 6 + PLMN_LIST_T(PLMN_LIST_MAX_SIZE) plmnIDs; /* List of PLMN identifiers */ + ci_t cellID; /* Identity of the cell serving the listed PLMNs */ + tac_t tac; /* Code of the tracking area the cell belongs to */ +} broadcast_info_ind_t; + +/* + * -------------------------------------------------------------------------- + * Cell information relevant for cell selection processing + * -------------------------------------------------------------------------- + */ + +/* Radio access technologies supported by the network */ +#define AS_GSM (1 << NET_ACCESS_GSM) +#define AS_COMPACT (1 << NET_ACCESS_COMPACT) +#define AS_UTRAN (1 << NET_ACCESS_UTRAN) +#define AS_EGPRS (1 << NET_ACCESS_EGPRS) +#define AS_HSDPA (1 << NET_ACCESS_HSDPA) +#define AS_HSUPA (1 << NET_ACCESS_HSUPA) +#define AS_HSDUPA (1 << NET_ACCESS_HSDUPA) +#define AS_EUTRAN (1 << NET_ACCESS_EUTRAN) + +/* + * NAS->AS - Cell Information request + * NAS request AS to search for a suitable cell belonging to the selected + * PLMN to camp on. + */ +typedef struct cell_info_req_s { + plmn_t plmnID; /* Selected PLMN identity */ + Byte_t rat; /* Bitmap - set of radio access technologies */ +} cell_info_req_t; + +/* + * AS->NAS - Cell Information confirm + * AS search for a suitable cell and respond to NAS. If found, the cell + * is selected to camp on. + */ +typedef struct cell_info_cnf_s { + uint8_t errCode; /* Error code */ + ci_t cellID; /* Identity of the cell serving the selected PLMN */ + tac_t tac; /* Code of the tracking area the cell belongs to */ + AcT_t rat; /* Radio access technology supported by the cell */ + uint8_t rsrq; /* Reference signal received quality */ + uint8_t rsrp; /* Reference signal received power */ +} cell_info_cnf_t; + +/* + * AS->NAS - Cell Information indication + * AS may change cell selection if a more suitable cell is found. + */ +typedef struct cell_info_ind_s { + ci_t cellID; /* Identity of the new serving cell */ + tac_t tac; /* Code of the tracking area the cell belongs to */ +} cell_info_ind_t; + +/* + * -------------------------------------------------------------------------- + * Paging information + * -------------------------------------------------------------------------- + */ + +/* Paging cause */ +typedef enum paging_cause_s { + AS_CONNECTION_ESTABLISH, /* Establish NAS signalling connection */ + AS_EPS_ATTACH, /* Perform local detach and initiate EPS + * attach procedure */ + AS_CS_FALLBACK /* Inititate CS fallback procedure */ +} paging_cause_t; + +/* + * NAS->AS - Paging Information request + * NAS requests the AS that NAS signalling messages or user data is pending + * to be sent. + */ +typedef struct paging_req_s { + as_stmsi_t s_tmsi; /* UE identity */ + uint8_t CN_domain; /* Core network domain */ +} paging_req_t; + +/* + * AS->NAS - Paging Information indication + * AS reports to the NAS that appropriate procedure has to be initiated. + */ +typedef struct paging_ind_s { + paging_cause_t cause; /* Paging cause */ +} paging_ind_t; + +/* + * -------------------------------------------------------------------------- + * NAS signalling connection establishment + * -------------------------------------------------------------------------- + */ + +/* Cause of RRC connection establishment */ +typedef enum as_cause_s { + AS_CAUSE_UNKNOWN = 0, + AS_CAUSE_EMERGENCY = NET_ESTABLISH_CAUSE_EMERGENCY, + AS_CAUSE_HIGH_PRIO = NET_ESTABLISH_CAUSE_HIGH_PRIO, + AS_CAUSE_MT_ACCESS = NET_ESTABLISH_CAUSE_MT_ACCESS, + AS_CAUSE_MO_SIGNAL = NET_ESTABLISH_CAUSE_MO_SIGNAL, + AS_CAUSE_MO_DATA = NET_ESTABLISH_CAUSE_MO_DATA, + AS_CAUSE_V1020 = NET_ESTABLISH_CAUSE_V1020 +} as_cause_t; + +/* Type of the call associated to the RRC connection establishment */ +typedef enum as_call_type_s { + AS_TYPE_ORIGINATING_SIGNAL = NET_ESTABLISH_TYPE_ORIGINATING_SIGNAL, + AS_TYPE_EMERGENCY_CALLS = NET_ESTABLISH_TYPE_EMERGENCY_CALLS, + AS_TYPE_ORIGINATING_CALLS = NET_ESTABLISH_TYPE_ORIGINATING_CALLS, + AS_TYPE_TERMINATING_CALLS = NET_ESTABLISH_TYPE_TERMINATING_CALLS, + AS_TYPE_MO_CS_FALLBACK = NET_ESTABLISH_TYPE_MO_CS_FALLBACK +} as_call_type_t; + +/* + * NAS->AS - NAS signalling connection establishment request + * NAS requests the AS to perform the RRC connection establishment procedure + * to transfer initial NAS message to the network while UE is in IDLE mode. + */ +typedef struct nas_establish_req_s { + as_cause_t cause; /* RRC connection establishment cause */ + as_call_type_t type; /* RRC associated call type */ + as_stmsi_t s_tmsi; /* UE identity */ + plmn_t plmnID; /* Selected PLMN identity */ + as_nas_info_t initialNasMsg; /* Initial NAS message to transfer */ +} nas_establish_req_t; + +/* + * AS->NAS - NAS signalling connection establishment indication + * AS transfers the initial NAS message to the NAS. + */ +typedef struct nas_establish_ind_s { + uint32_t UEid; /* UE lower layer identifier */ + tac_t tac; /* Code of the tracking area the initiating + * UE belongs to */ + as_cause_t asCause; /* Establishment cause */ + as_nas_info_t initialNasMsg; /* Initial NAS message to transfer */ +} nas_establish_ind_t; + +/* + * NAS->AS - NAS signalling connection establishment response + * NAS responds to the AS that initial answer message has to be provided to + * the UE. + */ +typedef struct nas_establish_rsp_s { + uint32_t UEid; /* UE lower layer identifier */ + as_stmsi_t s_tmsi; /* UE identity */ + nas_error_code_t errCode; /* Transaction status */ + as_nas_info_t nasMsg; /* NAS message to transfer */ + uint32_t nas_ul_count; /* UL NAS COUNT */ + uint16_t selected_encryption_algorithm; + uint16_t selected_integrity_algorithm; +} nas_establish_rsp_t; + +/* + * AS->NAS - NAS signalling connection establishment confirm + * AS transfers the initial answer message to the NAS. + */ +typedef struct nas_establish_cnf_s { + uint32_t UEid; /* UE lower layer identifier */ + nas_error_code_t errCode; /* Transaction status */ + as_nas_info_t nasMsg; /* NAS message to transfer */ + uint32_t ul_nas_count; + uint16_t selected_encryption_algorithm; + uint16_t selected_integrity_algorithm; +} nas_establish_cnf_t; + +/* + * -------------------------------------------------------------------------- + * NAS signalling connection release + * -------------------------------------------------------------------------- + */ + +/* Release cause */ +typedef enum release_cause_s { + AS_AUTHENTICATION_FAILURE = 1, /* Authentication procedure failed */ + AS_DETACH /* Detach requested */ +} release_cause_t; + +/* + * NAS->AS - NAS signalling connection release request + * NAS requests the termination of the connection with the UE. + */ +typedef struct nas_release_req_s { + uint32_t UEid; /* UE lower layer identifier */ + as_stmsi_t s_tmsi; /* UE identity */ + release_cause_t cause; /* Release cause */ +} nas_release_req_t; + +/* + * AS->NAS - NAS signalling connection release indication + * AS reports that connection has been terminated by the network. + */ +typedef struct nas_release_ind_s { + release_cause_t cause; /* Release cause */ +} nas_release_ind_t; + +/* + * -------------------------------------------------------------------------- + * NAS information transfer + * -------------------------------------------------------------------------- + */ + +/* + * NAS->AS - Uplink data transfer request + * NAS requests the AS to transfer uplink information to the NAS that + * operates at the network side. + */ +typedef struct ul_info_transfer_req_s { + uint32_t UEid; /* UE lower layer identifier */ + as_stmsi_t s_tmsi; /* UE identity */ + as_nas_info_t nasMsg; /* Uplink NAS message */ +} ul_info_transfer_req_t; + +/* + * AS->NAS - Uplink data transfer confirm + * AS immediately notifies the NAS whether uplink information has been + * successfully sent to the network or not. + */ +typedef struct ul_info_transfer_cnf_s { + uint32_t UEid; /* UE lower layer identifier */ + nas_error_code_t errCode; /* Transaction status */ +} ul_info_transfer_cnf_t; + +/* + * AS->NAS - Uplink data transfer indication + * AS delivers the uplink information message to the NAS that operates + * at the network side. + */ +typedef struct ul_info_transfer_ind_s { + uint32_t UEid; /* UE lower layer identifier */ + as_nas_info_t nasMsg; /* Uplink NAS message */ +} ul_info_transfer_ind_t; + +/* + * NAS->AS - Downlink data transfer request + * NAS requests the AS to transfer downlink information to the NAS that + * operates at the UE side. + */ +typedef ul_info_transfer_req_t dl_info_transfer_req_t; + +/* + * AS->NAS - Downlink data transfer confirm + * AS immediately notifies the NAS whether downlink information has been + * successfully sent to the network or not. + */ +typedef ul_info_transfer_cnf_t dl_info_transfer_cnf_t; + +/* + * AS->NAS - Downlink data transfer indication + * AS delivers the downlink information message to the NAS that operates + * at the UE side. + */ +typedef ul_info_transfer_ind_t dl_info_transfer_ind_t; + +/* + * -------------------------------------------------------------------------- + * Radio Access Bearer establishment + * -------------------------------------------------------------------------- + */ + +/* TODO: Quality of Service parameters */ +typedef struct {} as_qos_t; + +/* + * NAS->AS - Radio access bearer establishment request + * NAS requests the AS to allocate transmission resources to radio access + * bearer initialized at the network side. + */ +typedef struct rab_establish_req_s { + as_stmsi_t s_tmsi; /* UE identity */ + as_rab_id_t rabID; /* Radio access bearer identity */ + as_qos_t QoS; /* Requested Quality of Service */ +} rab_establish_req_t; + +/* + * AS->NAS - Radio access bearer establishment indication + * AS notifies the NAS that specific radio access bearer has to be setup. + */ +typedef struct rab_establish_ind_s { + as_rab_id_t rabID; /* Radio access bearer identity */ +} rab_establish_ind_t; + +/* + * NAS->AS - Radio access bearer establishment response + * NAS responds to AS whether the specified radio access bearer has been + * successfully setup or not. + */ +typedef struct rab_establish_rsp_s { + as_stmsi_t s_tmsi; /* UE identity */ + as_rab_id_t rabID; /* Radio access bearer identity */ + nas_error_code_t errCode; /* Transaction status */ +} rab_establish_rsp_t; + +/* + * AS->NAS - Radio access bearer establishment confirm + * AS notifies NAS whether the specified radio access bearer has been + * successfully setup at the UE side or not. + */ +typedef struct rab_establish_cnf_s { + as_rab_id_t rabID; /* Radio access bearer identity */ + nas_error_code_t errCode; /* Transaction status */ +} rab_establish_cnf_t; + +/* + * -------------------------------------------------------------------------- + * Radio Access Bearer release + * -------------------------------------------------------------------------- + */ + +/* + * NAS->AS - Radio access bearer release request + * NAS requests the AS to release transmission resources previously allocated + * to specific radio access bearer at the network side. + */ +typedef struct rab_release_req_s { + as_stmsi_t s_tmsi; /* UE identity */ + as_rab_id_t rabID; /* Radio access bearer identity */ +} rab_release_req_t; + +/* + * AS->NAS - Radio access bearer release indication + * AS notifies NAS that specific radio access bearer has been released. + */ +typedef struct rab_release_ind_s { + as_rab_id_t rabID; /* Radio access bearer identity */ +} rab_release_ind_t; + +/* + * -------------------------------------------------------------------------- + * Structure of the AS messages handled by the network sublayer + * -------------------------------------------------------------------------- + */ +typedef struct as_message_s { + uint16_t msgID; + union { + broadcast_info_ind_t broadcast_info_ind; + cell_info_req_t cell_info_req; + cell_info_cnf_t cell_info_cnf; + cell_info_ind_t cell_info_ind; + paging_req_t paging_req; + paging_ind_t paging_ind; + nas_establish_req_t nas_establish_req; + nas_establish_ind_t nas_establish_ind; + nas_establish_rsp_t nas_establish_rsp; + nas_establish_cnf_t nas_establish_cnf; + nas_release_req_t nas_release_req; + nas_release_ind_t nas_release_ind; + ul_info_transfer_req_t ul_info_transfer_req; + ul_info_transfer_cnf_t ul_info_transfer_cnf; + ul_info_transfer_ind_t ul_info_transfer_ind; + dl_info_transfer_req_t dl_info_transfer_req; + dl_info_transfer_cnf_t dl_info_transfer_cnf; + dl_info_transfer_ind_t dl_info_transfer_ind; + rab_establish_req_t rab_establish_req; + rab_establish_ind_t rab_establish_ind; + rab_establish_rsp_t rab_establish_rsp; + rab_establish_cnf_t rab_establish_cnf; + rab_release_req_t rab_release_req; + rab_release_ind_t rab_release_ind; + } __attribute__((__packed__)) msg; +} as_message_t; + +/****************************************************************************/ +/******************** G L O B A L V A R I A B L E S ********************/ +/****************************************************************************/ + +/****************************************************************************/ +/****************** E X P O R T E D F U N C T I O N S ******************/ +/****************************************************************************/ + +int as_message_decode(const char* buffer, as_message_t* msg, int length); + +int as_message_encode(char* buffer, as_message_t* msg, int length); + +/* Implemented in the network_api.c body file */ +int as_message_send(as_message_t* as_msg); + +#endif /* __AS_MESSAGE_H__*/ diff --git a/openair3/NAS/COMMON/API/NETWORK/nas_message.c b/openair3/NAS/COMMON/API/NETWORK/nas_message.c index b571c17d3872a5a07fc97c3b055402096d108dcd..c61ad6532f94f34fb55a5242249220df6b95a12e 100644 --- a/openair3/NAS/COMMON/API/NETWORK/nas_message.c +++ b/openair3/NAS/COMMON/API/NETWORK/nas_message.c @@ -53,6 +53,8 @@ Description Defines the layer 3 messages supported by the NAS sublayer #include "secu_defs.h" #include "emmData.h" +//#define DEBUG_NAS_MESSAGE + /****************************************************************************/ /**************** E X T E R N A L D E F I N I T I O N S ****************/ /****************************************************************************/ @@ -521,7 +523,7 @@ int nas_message_encode( /* Compute the NAS message authentication code */ LOG_TRACE(DEBUG, "offset %d = %d - %d, hdr encode = %d, length = %d bytes = %d", - offset, size, sizeof(uint8_t), + offset, size, (int)sizeof(uint8_t), size, length, bytes); uint32_t mac = _nas_message_get_mac( buffer + offset, @@ -990,12 +992,12 @@ static int _nas_message_decrypt( case NAS_SECURITY_ALGORITHMS_EEA1: { if (direction == SECU_DIRECTION_UPLINK) { - count = 0x00000000 || - ((emm_security_context->ul_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->ul_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->ul_count.seq_num & 0x000000FF); } else { - count = 0x00000000 || - ((emm_security_context->dl_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->dl_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->dl_count.seq_num & 0x000000FF); } @@ -1024,12 +1026,12 @@ static int _nas_message_decrypt( case NAS_SECURITY_ALGORITHMS_EEA2: { if (direction == SECU_DIRECTION_UPLINK) { - count = 0x00000000 || - ((emm_security_context->ul_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->ul_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->ul_count.seq_num & 0x000000FF); } else { - count = 0x00000000 || - ((emm_security_context->dl_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->dl_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->dl_count.seq_num & 0x000000FF); } @@ -1152,12 +1154,12 @@ static int _nas_message_encrypt( case NAS_SECURITY_ALGORITHMS_EEA1: { if (direction == SECU_DIRECTION_UPLINK) { - count = 0x00000000 || - ((emm_security_context->ul_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->ul_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->ul_count.seq_num & 0x000000FF); } else { - count = 0x00000000 || - ((emm_security_context->dl_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->dl_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->dl_count.seq_num & 0x000000FF); } @@ -1183,12 +1185,12 @@ static int _nas_message_encrypt( case NAS_SECURITY_ALGORITHMS_EEA2: { if (direction == SECU_DIRECTION_UPLINK) { - count = 0x00000000 || - ((emm_security_context->ul_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->ul_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->ul_count.seq_num & 0x000000FF); } else { - count = 0x00000000 || - ((emm_security_context->dl_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->dl_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->dl_count.seq_num & 0x000000FF); } @@ -1294,15 +1296,17 @@ static uint32_t _nas_message_get_mac( uint32_t count; uint32_t *mac32; +#ifdef DEBUG_NAS_MESSAGE int i,bytes = 0; +#endif if (direction == SECU_DIRECTION_UPLINK) { - count = 0x00000000 || - ((emm_security_context->ul_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->ul_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->ul_count.seq_num & 0x000000FF); } else { - count = 0x00000000 || - ((emm_security_context->dl_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->dl_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->dl_count.seq_num & 0x000000FF); } @@ -1312,6 +1316,7 @@ static uint32_t _nas_message_get_mac( (direction == SECU_DIRECTION_UPLINK) ? emm_security_context->ul_count.seq_num:emm_security_context->dl_count.seq_num, count); +#ifdef DEBUG_NAS_MESSAGE fprintf(stderr, "\n[NAS]\t"); for (i=0; i < length; i++) { @@ -1331,6 +1336,7 @@ static uint32_t _nas_message_get_mac( fprintf(stderr, "\n"); fflush(stderr); +#endif stream_cipher.key = emm_security_context->knas_int.value; stream_cipher.key_length = AUTH_KNAS_INT_SIZE; @@ -1363,12 +1369,12 @@ static uint32_t _nas_message_get_mac( uint32_t *mac32; if (direction == SECU_DIRECTION_UPLINK) { - count = 0x00000000 || - ((emm_security_context->ul_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->ul_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->ul_count.seq_num & 0x000000FF); } else { - count = 0x00000000 || - ((emm_security_context->dl_count.overflow && 0x0000FFFF) << 8) || + count = 0x00000000 | + ((emm_security_context->dl_count.overflow & 0x0000FFFF) << 8) | (emm_security_context->dl_count.seq_num & 0x000000FF); } diff --git a/openair3/NAS/COMMON/UTIL/nas_log.h b/openair3/NAS/COMMON/UTIL/nas_log.h index 1889bd801d801df27d5a7912180d3839211d485b..c6e0fbcd80b494d458a7ed420e9d0e2ccf862901 100644 --- a/openair3/NAS/COMMON/UTIL/nas_log.h +++ b/openair3/NAS/COMMON/UTIL/nas_log.h @@ -131,7 +131,7 @@ do { do { \ nas_log_func_indent -= 2; \ LOG_D(NAS, " %s:%d %*sLeaving %s(rc = %ld)\n", __FILE__, __LINE__, nas_log_func_indent, "", \ - __FUNCTION__, (long) rETURNcODE); \ + __FUNCTION__, (long) (rETURNcODE)); \ return (rETURNcODE); \ } while (0) @@ -146,7 +146,7 @@ extern int nas_log_func_indent; # define LOG_FUNC_RETURN(rETURNcODE) \ do { \ LOG_TRACE(FUNC_OUT, "Leaving %s(rc = %ld)", __FUNCTION__, \ - (long) rETURNcODE); \ + (long) (rETURNcODE)); \ return (rETURNcODE); \ } while(0) diff --git a/openair3/NAS/COMMON/commonDef.h b/openair3/NAS/COMMON/commonDef.h deleted file mode 120000 index 19553e9b6485b5e512d086e2f72abf1a1f387b97..0000000000000000000000000000000000000000 --- a/openair3/NAS/COMMON/commonDef.h +++ /dev/null @@ -1 +0,0 @@ -../../../openair2/COMMON/commonDef.h \ No newline at end of file diff --git a/openair3/NAS/COMMON/commonDef.h b/openair3/NAS/COMMON/commonDef.h new file mode 100644 index 0000000000000000000000000000000000000000..64216b009465119c56e0d357dab48875b7c4be08 --- /dev/null +++ b/openair3/NAS/COMMON/commonDef.h @@ -0,0 +1,342 @@ +/* + * Copyright (c) 2015, EURECOM (www.eurecom.fr) + * 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 THE COPYRIGHT HOLDERS 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 THE COPYRIGHT OWNER 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. + * + * The views and conclusions contained in the software and documentation are those + * of the authors and should not be interpreted as representing official policies, + * either expressed or implied, of the FreeBSD Project. + */ +/* + +Source commonDef.h + +Version 0.1 + +Date 2012/02/27 + +Product NAS stack + +Subsystem include + +Author Frederic Maurel + +Description Contains global common definitions + +*****************************************************************************/ +#ifndef __COMMONDEF_H__ +#define __COMMONDEF_H__ + +#include +#include +#include + +typedef signed char boolean_t; + +#if !defined(TRUE) +#define TRUE (boolean_t)0x01 +#endif + +#if !defined(FALSE) +#define FALSE (boolean_t)0x00 +#endif + +#define BOOL_NOT(b) (b^TRUE) + +#define NAS_UE_ID_FMT "0x%06x" + +/****************************************************************************/ +/********************* G L O B A L C O N S T A N T S *******************/ +/****************************************************************************/ + +#define RETURNok (0) +#define RETURNerror (-1) + +/* + * Name of the environment variable which defines the default directory + * where the NAS application is executed and where are located files + * where non-volatile data are stored + */ +#define DEFAULT_NAS_PATH "PWD" + +/****************************************************************************/ +/************************ G L O B A L T Y P E S ************************/ +/****************************************************************************/ + +/* +----------------------------------------------------------------------------- + Standard data type definitions +----------------------------------------------------------------------------- +*/ +typedef int8_t SByte_t; /* 8 bit signed integer */ +typedef uint8_t Byte_t; /* 8 bit unsigned integer */ + + +/* +----------------------------------------------------------------------------- + Common NAS data type definitions +----------------------------------------------------------------------------- +*/ + +typedef uint8_t Stat_t; /* Registration status */ +typedef uint16_t lac_t; /* Location Area Code */ +typedef uint8_t rac_t; /* Routing Area Code */ +typedef uint16_t tac_t; /* Tracking Area Code */ +typedef uint32_t ci_t; /* Cell Identifier */ +typedef uint8_t AcT_t; /* Access Technology */ + +/* + * International Mobile Subscriber Identity + */ +typedef struct { + Byte_t length; + union { + struct { + Byte_t digit2:4; + Byte_t digit1:4; + Byte_t digit4:4; + Byte_t digit3:4; + Byte_t digit6:4; + Byte_t digit5:4; + Byte_t digit8:4; + Byte_t digit7:4; + Byte_t digit10:4; + Byte_t digit9:4; + Byte_t digit12:4; + Byte_t digit11:4; + Byte_t digit14:4; + Byte_t digit13:4; +#define EVEN_PARITY 0 +#define ODD_PARITY 1 + Byte_t parity:4; + Byte_t digit15:4; + } num; +#define IMSI_SIZE 8 + Byte_t value[IMSI_SIZE]; + } u; +} imsi_t; + +#define NAS_IMSI2STR(iMsI_t_PtR,iMsI_sTr, MaXlEn) \ + {\ + int l_offset = 0;\ + int l_ret = 0;\ + l_ret = snprintf(iMsI_sTr + l_offset, MaXlEn - l_offset, "%u%u%u%u%u",\ + iMsI_t_PtR->u.num.digit1, iMsI_t_PtR->u.num.digit2,\ + iMsI_t_PtR->u.num.digit3, iMsI_t_PtR->u.num.digit4,\ + iMsI_t_PtR->u.num.digit5);\ + if ((iMsI_t_PtR->u.num.digit6 != 0xf) && (l_ret > 0)) {\ + l_offset += l_ret;\ + l_ret = snprintf(iMsI_sTr + l_offset, MaXlEn - l_offset, "%u", iMsI_t_PtR->u.num.digit6);\ + }\ + if (l_ret > 0) {\ + l_offset += l_ret;\ + l_ret = snprintf(iMsI_sTr + l_offset, MaXlEn - l_offset, "%u%u%u%u%u%u%u%u",\ + iMsI_t_PtR->u.num.digit7, iMsI_t_PtR->u.num.digit8,\ + iMsI_t_PtR->u.num.digit9, iMsI_t_PtR->u.num.digit10,\ + iMsI_t_PtR->u.num.digit11, iMsI_t_PtR->u.num.digit12,\ + iMsI_t_PtR->u.num.digit13, iMsI_t_PtR->u.num.digit14);\ + }\ + if ((iMsI_t_PtR->u.num.digit15 != 0xf) && (l_ret > 0)) {\ + l_offset += l_ret;\ + l_ret = snprintf(iMsI_sTr + l_offset, MaXlEn - l_offset, "%u", iMsI_t_PtR->u.num.digit15);\ + }\ + } + +/* + * Mobile subscriber dialing number + */ +typedef struct { + Byte_t ext:1; + /* Type Of Number */ +#define MSISDN_TON_UNKNOWKN 0b000 +#define MSISDN_TON_INTERNATIONAL 0b001 +#define MSISDN_TON_NATIONAL 0b010 +#define MSISDN_TON_NETWORK 0b011 +#define MSISDN_TON_SUBCRIBER 0b100 +#define MSISDN_TON_ABBREVIATED 0b110 +#define MSISDN_TON_RESERVED 0b111 + Byte_t ton:3; + /* Numbering Plan Identification */ +#define MSISDN_NPI_UNKNOWN 0b0000 +#define MSISDN_NPI_ISDN_TELEPHONY 0b0001 +#define MSISDN_NPI_GENERIC 0b0010 +#define MSISDN_NPI_DATA 0b0011 +#define MSISDN_NPI_TELEX 0b0100 +#define MSISDN_NPI_MARITIME_MOBILE 0b0101 +#define MSISDN_NPI_LAND_MOBILE 0b0110 +#define MSISDN_NPI_ISDN_MOBILE 0b0111 +#define MSISDN_NPI_PRIVATE 0b1110 +#define MSISDN_NPI_RESERVED 0b1111 + Byte_t npi:4; + /* Dialing Number */ + struct { + Byte_t lsb:4; + Byte_t msb:4; +#define MSISDN_DIGIT_SIZE 10 + } digit[MSISDN_DIGIT_SIZE]; +} msisdn_t; + +/* + * International Mobile Equipment Identity + */ +typedef imsi_t imei_t; + +/* + * Public Land Mobile Network identifier + * PLMN = BCD encoding (Mobile Country Code + Mobile Network Code) + */ +typedef struct { + Byte_t MCCdigit2:4; + Byte_t MCCdigit1:4; + Byte_t MNCdigit3:4; + Byte_t MCCdigit3:4; + Byte_t MNCdigit2:4; + Byte_t MNCdigit1:4; +} plmn_t; + +/* + * Location Area Identification + */ +typedef struct { + plmn_t plmn; /* + */ + lac_t lac; /* Location Area Code */ +} lai_t; + +/* + * GPRS Routing Area Identification + */ +typedef struct { + plmn_t plmn; /* + */ + lac_t lac; /* Location Area Code */ + rac_t rac; /* Routing Area Code */ +} RAI_t; + +/* + * EPS Tracking Area Identification + */ +typedef struct { + plmn_t plmn; /* + */ + tac_t tac; /* Tracking Area Code */ +} tai_t; + +/* + * EPS Globally Unique MME Identity + */ +typedef struct { + plmn_t plmn; /* + */ + uint16_t MMEgid; /* MME group identifier */ + uint8_t MMEcode; /* MME code */ +} gummei_t; + +/* + * EPS Globally Unique Temporary UE Identity + */ +typedef struct { + gummei_t gummei; /* Globally Unique MME Identity */ + uint32_t m_tmsi; /* M-Temporary Mobile Subscriber Identity */ +} GUTI_t; +#define GUTI2STR(GuTi_PtR, GuTi_StR, MaXlEn) \ + {\ + int l_offset = 0;\ + int l_ret = 0;\ + l_ret += snprintf(GuTi_StR + l_offset,MaXlEn-l_offset, "%03u.",\ + GuTi_PtR->gummei.plmn.MCCdigit3 * 100 +\ + GuTi_PtR->gummei.plmn.MCCdigit2 * 10 +\ + GuTi_PtR->gummei.plmn.MCCdigit1);\ + if (l_ret > 0) {\ + l_offset += l_ret;\ + } else {\ + l_offset = MaXlEn;\ + }\ + if (GuTi_PtR->gummei.plmn.MNCdigit1 != 0xf) {\ + l_ret += snprintf(GuTi_StR + l_offset,MaXlEn-l_offset, "%03u|%04x|%02x|%08x",\ + GuTi_PtR->gummei.plmn.MNCdigit3 * 100 +\ + GuTi_PtR->gummei.plmn.MNCdigit2 * 10 +\ + GuTi_PtR->gummei.plmn.MNCdigit1,\ + GuTi_PtR->gummei.MMEgid,\ + GuTi_PtR->gummei.MMEcode,\ + GuTi_PtR->m_tmsi);\ + } else {\ + l_ret += snprintf(GuTi_StR + l_offset,MaXlEn-l_offset, "%02u|%04x|%02x|%08x",\ + GuTi_PtR->gummei.plmn.MNCdigit2 * 10 +\ + GuTi_PtR->gummei.plmn.MNCdigit1,\ + GuTi_PtR->gummei.MMEgid,\ + GuTi_PtR->gummei.MMEcode,\ + GuTi_PtR->m_tmsi);\ + }\ + } + + + + +/* Checks PLMN validity */ +#define PLMN_IS_VALID(plmn) (((plmn).MCCdigit1 & \ + (plmn).MCCdigit2 & \ + (plmn).MCCdigit3) != 0x0F) + +/* Checks TAC validity */ +#define TAC_IS_VALID(tac) (((tac) != 0x0000) && ((tac) != 0xFFF0)) + +/* Checks TAI validity */ +#define TAI_IS_VALID(tai) (PLMN_IS_VALID((tai).plmn) && \ + TAC_IS_VALID((tai).tac)) +/* + * A list of PLMNs + */ +#define PLMN_LIST_T(SIZE) struct {Byte_t n_plmns; plmn_t plmn[SIZE];} + +/* + * A list of TACs + */ +#define TAC_LIST_T(SIZE) struct {Byte_t n_tacs; TAC_t tac[SIZE];} + +/* + * A list of TAIs + */ +#define TAI_LIST_T(SIZE) struct {Byte_t n_tais; tai_t tai[SIZE];} + +/* + * User notification callback, executed whenever a change of data with + * respect of network information (e.g. network registration and/or + * location change, new PLMN becomes available) is notified by the + * EPS Mobility Management sublayer + */ +typedef int (*emm_indication_callback_t) (Stat_t, tac_t, ci_t, AcT_t, + const char*, size_t); + +typedef enum eps_protocol_discriminator_e { + /* Protocol discriminator identifier for EPS Mobility Management */ + EPS_MOBILITY_MANAGEMENT_MESSAGE = 0x7, + + /* Protocol discriminator identifier for EPS Session Management */ + EPS_SESSION_MANAGEMENT_MESSAGE = 0x2, +} eps_protocol_discriminator_t; + +/****************************************************************************/ +/******************** G L O B A L V A R I A B L E S ********************/ +/****************************************************************************/ + +/****************************************************************************/ +/****************** E X P O R T E D F U N C T I O N S ******************/ +/****************************************************************************/ + +#endif /* __COMMONDEF_H__*/ diff --git a/openair3/NAS/COMMON/networkDef.h b/openair3/NAS/COMMON/networkDef.h deleted file mode 120000 index 2648b55e992973fc58c9c2c0e12b99733fba0010..0000000000000000000000000000000000000000 --- a/openair3/NAS/COMMON/networkDef.h +++ /dev/null @@ -1 +0,0 @@ -../../../openair2/COMMON/networkDef.h \ No newline at end of file diff --git a/openair3/NAS/COMMON/networkDef.h b/openair3/NAS/COMMON/networkDef.h new file mode 100644 index 0000000000000000000000000000000000000000..46716bee24714ab2273744c4634a0924d9320207 --- /dev/null +++ b/openair3/NAS/COMMON/networkDef.h @@ -0,0 +1,278 @@ +/* + * Copyright (c) 2015, EURECOM (www.eurecom.fr) + * 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 THE COPYRIGHT HOLDERS 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 THE COPYRIGHT OWNER 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. + * + * The views and conclusions contained in the software and documentation are those + * of the authors and should not be interpreted as representing official policies, + * either expressed or implied, of the FreeBSD Project. + */ + +/***************************************************************************** + +Source networkDef.h + +Version 0.1 + +Date 2012/09/21 + +Product NAS stack + +Subsystem include + +Author Frederic Maurel + +Description Contains network's global definitions + +*****************************************************************************/ +#ifndef __NETWORKDEF_H__ +#define __NETWORKDEF_H__ + +/****************************************************************************/ +/********************* G L O B A L C O N S T A N T S *******************/ +/****************************************************************************/ + +/* + * ---------------------- + * Network selection mode + * ---------------------- + */ +#define NET_PLMN_AUTO 0 +#define NET_PLMN_MANUAL 1 + +/* + * --------------------------- + * Network registration status + * --------------------------- + */ +/* not registered, not currently searching an operator to register to */ +#define NET_REG_STATE_OFF 0 +/* registered, home network */ +#define NET_REG_STATE_HN 1 +/* not registered, currently trying to attach or searching an operator + * to register to */ +#define NET_REG_STATE_ON 2 +/* registration denied */ +#define NET_REG_STATE_DENIED 3 +/* unknown (e.g. out of GERAN/UTRAN/E-UTRAN coverage) */ +#define NET_REG_STATE_UNKNOWN 4 +/* registered, roaming */ +#define NET_REG_STATE_ROAMING 5 +/* registered for "SMS only", home network */ +#define NET_REG_STATE_SMS_HN 6 +/* registered, for "SMS only", roaming */ +#define NET_REG_STATE_SMS_ROAMING 7 +/* attached for emergency bearer services only (applicable to UTRAN) */ +#define NET_REG_STATE_EMERGENCY 8 + +/* + * ------------------------------------ + * Network access technology indicators + * ------------------------------------ + */ +#define NET_ACCESS_UNAVAILABLE (-1) /* Not available */ +#define NET_ACCESS_GSM 0 /* GSM */ +#define NET_ACCESS_COMPACT 1 /* GSM Compact */ +#define NET_ACCESS_UTRAN 2 /* UTRAN */ +#define NET_ACCESS_EGPRS 3 /* GSM w/EGPRS */ +#define NET_ACCESS_HSDPA 4 /* UTRAN w/HSDPA */ +#define NET_ACCESS_HSUPA 5 /* UTRAN w/HSUPA */ +#define NET_ACCESS_HSDUPA 6 /* UTRAN w/HSDPA and HSUPA */ +#define NET_ACCESS_EUTRAN 7 /* E-UTRAN */ + +/* + * --------------------------------------- + * Network operator representation formats + * --------------------------------------- + */ +#define NET_FORMAT_LONG 0 /* long format alphanumeric */ +#define NET_FORMAT_SHORT 1 /* short format alphanumeric */ +#define NET_FORMAT_NUM 2 /* numeric format */ + +#define NET_FORMAT_MAX_SIZE NET_FORMAT_LONG_SIZE + +/* + * ----------------------------- + * Network operator availability + * ----------------------------- + */ +#define NET_OPER_UNKNOWN 0 /* unknown operator */ +#define NET_OPER_AVAILABLE 1 /* available operator */ +#define NET_OPER_CURRENT 2 /* currently selected operator */ +#define NET_OPER_FORBIDDEN 3 /* forbidden operator */ + +/* + * -------------------------------------- + * Network connection establishment cause + * -------------------------------------- + */ +#define NET_ESTABLISH_CAUSE_EMERGENCY 0x01 +#define NET_ESTABLISH_CAUSE_HIGH_PRIO 0x02 +#define NET_ESTABLISH_CAUSE_MT_ACCESS 0x03 +#define NET_ESTABLISH_CAUSE_MO_SIGNAL 0x04 +#define NET_ESTABLISH_CAUSE_MO_DATA 0x05 +#define NET_ESTABLISH_CAUSE_V1020 0x06 + +/* + * -------------------------------------- + * Network connection establishment type + * -------------------------------------- + */ +#define NET_ESTABLISH_TYPE_ORIGINATING_SIGNAL 0x10 +#define NET_ESTABLISH_TYPE_EMERGENCY_CALLS 0x20 +#define NET_ESTABLISH_TYPE_ORIGINATING_CALLS 0x30 +#define NET_ESTABLISH_TYPE_TERMINATING_CALLS 0x40 +#define NET_ESTABLISH_TYPE_MO_CS_FALLBACK 0x50 + +/* + * ------------------- + * PDN connection type + * ------------------- + */ +#define NET_PDN_TYPE_IPV4 (0 + 1) +#define NET_PDN_TYPE_IPV6 (1 + 1) +#define NET_PDN_TYPE_IPV4V6 (2 + 1) + +/****************************************************************************/ +/************************ G L O B A L T Y P E S ************************/ +/****************************************************************************/ + +/* + * --------------------- + * PDN connection status + * --------------------- + */ +typedef enum { + /* MT = The Mobile Terminal, NW = The Network */ + NET_PDN_MT_DEFAULT_ACT = 1, /* MT has activated a PDN connection */ + NET_PDN_NW_DEFAULT_DEACT, /* NW has deactivated a PDN connection */ + NET_PDN_MT_DEFAULT_DEACT, /* MT has deactivated a PDN connection */ + NET_PDN_NW_DEDICATED_ACT, /* NW has activated an EPS bearer context */ + NET_PDN_MT_DEDICATED_ACT, /* MT has activated an EPS bearer context */ + NET_PDN_NW_DEDICATED_DEACT, /* NW has deactivated an EPS bearer context */ + NET_PDN_MT_DEDICATED_DEACT, /* MT has deactivated an EPS bearer context */ +} network_pdn_state_t; + +/* + * --------------------------- + * Network operator identifier + * --------------------------- + */ +typedef struct { +#define NET_FORMAT_LONG_SIZE 16 /* Long alphanumeric format */ +#define NET_FORMAT_SHORT_SIZE 8 /* Short alphanumeric format */ +#define NET_FORMAT_NUM_SIZE 6 /* Numeric format (PLMN identifier */ + union { + unsigned char alpha_long[NET_FORMAT_LONG_SIZE+1]; + unsigned char alpha_short[NET_FORMAT_SHORT_SIZE+1]; + unsigned char num[NET_FORMAT_NUM_SIZE+1]; + } id; +} network_plmn_t; + +/* + * ------------------------------- + * EPS bearer level QoS parameters + * ------------------------------- + */ +typedef struct { + int gbrUL; /* Guaranteed Bit Rate for uplink */ + int gbrDL; /* Guaranteed Bit Rate for downlink */ + int mbrUL; /* Maximum Bit Rate for uplink */ + int mbrDL; /* Maximum Bit Rate for downlink */ + int qci; /* QoS Class Identifier */ +} network_qos_t; + +/* + * ----------------------------- + * IPv4 packet filter parameters + * ----------------------------- + */ +typedef struct { + unsigned char protocol; /* Protocol identifier */ + unsigned char tos; /* Type of service */ +#define NET_PACKET_FILTER_IPV4_ADDR_SIZE 4 + unsigned char addr[NET_PACKET_FILTER_IPV4_ADDR_SIZE]; + unsigned char mask[NET_PACKET_FILTER_IPV4_ADDR_SIZE]; +} network_ipv4_data_t; + +/* + * ----------------------------- + * IPv6 packet filter parameters + * ----------------------------- + */ +typedef struct { + unsigned char nh; /* Next header type */ + unsigned char tf; /* Traffic class */ +#define NET_PACKET_FILTER_IPV6_ADDR_SIZE 16 + unsigned char addr[NET_PACKET_FILTER_IPV6_ADDR_SIZE]; + unsigned char mask[NET_PACKET_FILTER_IPV6_ADDR_SIZE]; + unsigned int ipsec; /* IPSec security parameter index */ + unsigned int fl; /* Flow label */ +} network_ipv6_data_t; + +/* + * ------------- + * Packet Filter + * ------------- + */ +typedef struct { + unsigned char id; /* Packet filter identifier */ +#define NET_PACKET_FILTER_DOWNLINK 0x01 +#define NET_PACKET_FILTER_UPLINK 0x02 +#define NET_PACKET_FILTER_BIDIR 0x03 + unsigned char dir; /* Packet filter direction */ + unsigned char precedence; /* Evaluation precedence */ + union { + network_ipv4_data_t ipv4; + network_ipv6_data_t ipv6; + } data; + unsigned short lport; /* Local (UE) port number */ + unsigned short rport; /* Remote (network) port number */ +} network_pkf_t; + +/* + * --------------------- + * Traffic Flow Template + * --------------------- + */ +typedef struct { + int n_pkfs; +#define NET_PACKET_FILTER_MAX 16 + network_pkf_t* pkf[NET_PACKET_FILTER_MAX]; +} network_tft_t; + +/* + * User notification callback, executed whenever a change of status with + * respect of PDN connection or EPS bearer context is notified by the EPS + * Session Management sublayer + */ +typedef int (*esm_indication_callback_t) (int, network_pdn_state_t); + +/****************************************************************************/ +/******************** G L O B A L V A R I A B L E S ********************/ +/****************************************************************************/ + +/****************************************************************************/ +/****************** E X P O R T E D F U N C T I O N S ******************/ +/****************************************************************************/ + +#endif /* __NETWORKDEF_H__*/ diff --git a/openair3/NAS/UE/EMM/IdleMode.c b/openair3/NAS/UE/EMM/IdleMode.c index 74c09a8a3dfbfac371aaa67a3c701c90f20ccbb8..a5a2c3070894305392cc2ef0b760f49837d1f9b6 100644 --- a/openair3/NAS/UE/EMM/IdleMode.c +++ b/openair3/NAS/UE/EMM/IdleMode.c @@ -807,8 +807,7 @@ int emm_proc_plmn_selection_end(int found, tac_t tac, ci_t ci, AcT_t rat) if (is_forbidden) { /* The selected cell is known not to be able to provide normal * service */ - LOG_TRACE(INFO, "EMM-IDLE - UE may camp on this acceptable cell ", - "for limited services"); + LOG_TRACE(INFO, "EMM-IDLE - UE may camp on this acceptable cell for limited services"); /* Save the index of the first forbidden PLMN */ if (_emm_plmn_list.fplmn < 0) { @@ -819,8 +818,7 @@ int emm_proc_plmn_selection_end(int found, tac_t tac, ci_t ci, AcT_t rat) } else { /* A suitable cell has been found and the PLMN or tracking area * is not in the forbidden list */ - LOG_TRACE(INFO, "EMM-IDLE - UE may camp on this suitable cell ", - "for normal services"); + LOG_TRACE(INFO, "EMM-IDLE - UE may camp on this suitable cell for normal services"); _emm_plmn_list.fplmn = -1; _emm_plmn_list.param[index].stat = NET_OPER_CURRENT; emm_sap.primitive = EMMREG_REGISTER_CNF; @@ -905,7 +903,10 @@ int emm_proc_plmn_selection_end(int found, tac_t tac, ci_t ci, AcT_t rat) * Or terminate the PLMN selection procedure */ if (!select_next_plmn) { - if (!(_emm_plmn_list.fplmn) < 0) { // FIXME this comparison makes no sense (bool < 0) + /* TODO: be sure of this fix */ + LOG_TRACE(WARNING, "%s:%d:%s: be sure!!\n", __FILE__, __LINE__, __FUNCTION__); + //if (!(_emm_plmn_list.fplmn) < 0) { // FIXME this comparison makes no sense (bool < 0) + if (!(_emm_plmn_list.fplmn < 0)) { // FIXME this comparison makes no sense (bool < 0) /* There were one or more PLMNs which were available and allowable, * but an LR failure made registration on those PLMNs unsuccessful * or an entry in any of the forbidden area lists prevented a diff --git a/openair3/S1AP/s1ap_eNB_handlers.c b/openair3/S1AP/s1ap_eNB_handlers.c index c6deccebcdafc81d5f0a47efa4fc62551d13c310..3896cf37aecd19e01efde832bc4f981c6461ea72 100644 --- a/openair3/S1AP/s1ap_eNB_handlers.c +++ b/openair3/S1AP/s1ap_eNB_handlers.c @@ -205,7 +205,7 @@ int s1ap_eNB_handle_message(uint32_t assoc_id, int32_t stream, if (message.procedureCode > sizeof(messages_callback) / (3 * sizeof( s1ap_message_decoded_callback)) || (message.direction > S1AP_PDU_PR_unsuccessfulOutcome)) { - S1AP_ERROR("[SCTP %d] Either procedureCode %d or direction %d exceed expected\n", + S1AP_ERROR("[SCTP %d] Either procedureCode %ld or direction %d exceed expected\n", assoc_id, message.procedureCode, message.direction); return -1; } @@ -214,7 +214,7 @@ int s1ap_eNB_handle_message(uint32_t assoc_id, int32_t stream, * This can mean not implemented or no procedure for eNB (wrong direction). */ if (messages_callback[message.procedureCode][message.direction-1] == NULL) { - S1AP_ERROR("[SCTP %d] No handler for procedureCode %d in %s\n", + S1AP_ERROR("[SCTP %d] No handler for procedureCode %ld in %s\n", assoc_id, message.procedureCode, s1ap_direction2String[message.direction]); return -1; @@ -452,10 +452,10 @@ int s1ap_eNB_handle_error_indication(uint32_t assoc_id, return -1; } if ( s1_error_indication_p->presenceMask & S1AP_ERRORINDICATIONIES_MME_UE_S1AP_ID_PRESENT) { - S1AP_WARN("Received S1 Error indication MME UE S1AP ID 0x%x\n", s1_error_indication_p->mme_ue_s1ap_id); + S1AP_WARN("Received S1 Error indication MME UE S1AP ID 0x%lx\n", s1_error_indication_p->mme_ue_s1ap_id); } if ( s1_error_indication_p->presenceMask & S1AP_ERRORINDICATIONIES_ENB_UE_S1AP_ID_PRESENT) { - S1AP_WARN("Received S1 Error indication eNB UE S1AP ID 0x%x\n", s1_error_indication_p->eNB_UE_S1AP_ID); + S1AP_WARN("Received S1 Error indication eNB UE S1AP ID 0x%lx\n", s1_error_indication_p->eNB_UE_S1AP_ID); } if ( s1_error_indication_p->presenceMask & S1AP_ERRORINDICATIONIES_CAUSE_PRESENT) { @@ -710,7 +710,7 @@ int s1ap_eNB_handle_initial_context_request(uint32_t assoc_id, if ((ue_desc_p = s1ap_eNB_get_ue_context(mme_desc_p->s1ap_eNB_instance, initialContextSetupRequest_p->eNB_UE_S1AP_ID)) == NULL) { S1AP_ERROR("[SCTP %d] Received initial context setup request for non " - "existing UE context 0x%06x\n", assoc_id, + "existing UE context 0x%06lx\n", assoc_id, initialContextSetupRequest_p->eNB_UE_S1AP_ID); return -1; } @@ -835,7 +835,7 @@ int s1ap_eNB_handle_ue_context_release_command(uint32_t assoc_id, if ((ue_desc_p = s1ap_eNB_get_ue_context(mme_desc_p->s1ap_eNB_instance, enb_ue_s1ap_id)) == NULL) { S1AP_ERROR("[SCTP %d] Received UE context release command for non " - "existing UE context 0x%06x\n", + "existing UE context 0x%06lx\n", assoc_id, enb_ue_s1ap_id); /*MessageDef *msg_complete_p; @@ -900,7 +900,7 @@ int s1ap_eNB_handle_e_rab_setup_request(uint32_t assoc_id, if ((ue_desc_p = s1ap_eNB_get_ue_context(mme_desc_p->s1ap_eNB_instance, s1ap_E_RABSetupRequest->eNB_UE_S1AP_ID)) == NULL) { S1AP_ERROR("[SCTP %d] Received initial context setup request for non " - "existing UE context 0x%06x\n", assoc_id, + "existing UE context 0x%06lx\n", assoc_id, s1ap_E_RABSetupRequest->eNB_UE_S1AP_ID); return -1; } @@ -915,7 +915,7 @@ int s1ap_eNB_handle_e_rab_setup_request(uint32_t assoc_id, ue_desc_p->rx_stream = stream; if ( ue_desc_p->mme_ue_s1ap_id != s1ap_E_RABSetupRequest->mme_ue_s1ap_id){ - S1AP_WARN("UE context mme_ue_s1ap_id is different form that of the message (%d != %d)", + S1AP_WARN("UE context mme_ue_s1ap_id is different form that of the message (%d != %ld)", ue_desc_p->mme_ue_s1ap_id, s1ap_E_RABSetupRequest->mme_ue_s1ap_id); } diff --git a/openair3/S1AP/s1ap_eNB_nas_procedures.c b/openair3/S1AP/s1ap_eNB_nas_procedures.c index def09a6cb3deb7b67e9bd783506d19cf3e9961c4..426f38004a845942a24378bbd9106cbc2264f0ba 100644 --- a/openair3/S1AP/s1ap_eNB_nas_procedures.c +++ b/openair3/S1AP/s1ap_eNB_nas_procedures.c @@ -288,9 +288,13 @@ int s1ap_eNB_handle_nas_downlink(const uint32_t assoc_id, downlink_NAS_transport_p->eNB_UE_S1AP_ID, downlink_NAS_transport_p->mme_ue_s1ap_id); - S1AP_ERROR("[SCTP %d] Received NAS downlink message for non existing UE context eNB_UE_S1AP_ID: 0x%"PRIx32" %u\n", + /* TODO: fix this log - the original version is suspicious (twice downlink_NAS_transport_p->eNB_UE_S1AP_ID?) */ + /*S1AP_ERROR("[SCTP %d] Received NAS downlink message for non existing UE context eNB_UE_S1AP_ID: 0x%"PRIx32" %u\n", assoc_id, downlink_NAS_transport_p->eNB_UE_S1AP_ID, + downlink_NAS_transport_p->eNB_UE_S1AP_ID);*/ + S1AP_ERROR("[SCTP %d] Received NAS downlink message for non existing UE context eNB_UE_S1AP_ID: 0x%lx\n", + assoc_id, downlink_NAS_transport_p->eNB_UE_S1AP_ID); return -1; } @@ -311,7 +315,7 @@ int s1ap_eNB_handle_nas_downlink(const uint32_t assoc_id, } else { /* We already have a mme ue s1ap id check the received is the same */ if (ue_desc_p->mme_ue_s1ap_id != downlink_NAS_transport_p->mme_ue_s1ap_id) { - S1AP_ERROR("[SCTP %d] Mismatch in MME UE S1AP ID (0x%"PRIx32" != 0x%"PRIx32")\n", + S1AP_ERROR("[SCTP %d] Mismatch in MME UE S1AP ID (0x%lx != 0x%"PRIx32"\n", assoc_id, downlink_NAS_transport_p->mme_ue_s1ap_id, ue_desc_p->mme_ue_s1ap_id @@ -579,7 +583,7 @@ int s1ap_eNB_initial_ctxt_resp( new_item->transportLayerAddress.size = initial_ctxt_resp_p->e_rabs[i].eNB_addr.length; new_item->transportLayerAddress.bits_unused = 0; - S1AP_DEBUG("initial_ctxt_resp_p: e_rab ID %d, enb_addr %d.%d.%d.%d, SIZE %d \n", + S1AP_DEBUG("initial_ctxt_resp_p: e_rab ID %ld, enb_addr %d.%d.%d.%d, SIZE %d \n", new_item->e_RAB_ID, new_item->transportLayerAddress.buf[0], new_item->transportLayerAddress.buf[1], @@ -778,7 +782,7 @@ int s1ap_eNB_e_rab_setup_resp(instance_t instance, new_item->transportLayerAddress.size = e_rab_setup_resp_p->e_rabs[i].eNB_addr.length; new_item->transportLayerAddress.bits_unused = 0; - S1AP_DEBUG("e_rab_setup_resp: e_rab ID %d, teid %u, enb_addr %d.%d.%d.%d, SIZE %d\n", + S1AP_DEBUG("e_rab_setup_resp: e_rab ID %ld, teid %u, enb_addr %d.%d.%d.%d, SIZE %d\n", new_item->e_RAB_ID, e_rab_setup_resp_p->e_rabs[i].gtp_teid, new_item->transportLayerAddress.buf[0], diff --git a/openair3/UDP/udp_eNB_task.c b/openair3/UDP/udp_eNB_task.c index b11f51e5fd538983808170e0dc412dcd5e7b4448..b8b6b897a79c4d4924810869fd6819059c75ad3b 100644 --- a/openair3/UDP/udp_eNB_task.c +++ b/openair3/UDP/udp_eNB_task.c @@ -379,7 +379,7 @@ void *udp_eNB_task(void *args_p) sizeof(struct sockaddr_in)); if (bytes_written != udp_data_req_p->buffer_length) { - LOG_E(UDP_, "There was an error while writing to socket %u rc %d" + LOG_E(UDP_, "There was an error while writing to socket %d rc %zd" "(%d:%s) May be normal if GTPU kernel module loaded on same host (may NF_DROP IP packet)\n", udp_sd, bytes_written, errno, strerror(errno)); } diff --git a/targets/ARCH/COMMON/common_lib.h b/targets/ARCH/COMMON/common_lib.h index a366b54023bd86ab8bbe882e21ab9eb274e457ad..2eb0a506be8f840c34ac5de1cb7f7a5ca9763fc3 100644 --- a/targets/ARCH/COMMON/common_lib.h +++ b/targets/ARCH/COMMON/common_lib.h @@ -135,6 +135,14 @@ typedef struct { double offset; } rx_gain_calib_table_t; +/*! \brief Clock source types */ +typedef enum { + //! This tells the underlying hardware to use the internal reference + internal=0, + //! This tells the underlying hardware to use the external reference + external=1 +} clock_source_t; + /*! \brief RF frontend parameters set by application */ typedef struct { //! Module ID for this configuration @@ -187,6 +195,8 @@ typedef struct { double rx_bw; //! TX bandwidth in Hz double tx_bw; + //! clock source + clock_source_t clock_source; //! Auto calibration flag int autocal[4]; //! rf devices work with x bits iqs when oai have its own iq format @@ -238,8 +248,10 @@ typedef struct { typedef struct { - //! Tx buffer for if device - void *tx; + //! Tx buffer for if device, keep one per subframe now to allow multithreading + void *tx[10]; + //! Tx buffer (PRACH) for if device + void *tx_prach; //! Rx buffer for if device void *rx; } if_buffer_t; diff --git a/targets/ARCH/ETHERNET/USERSPACE/LIB/eth_raw.c b/targets/ARCH/ETHERNET/USERSPACE/LIB/eth_raw.c index 1f8bab415c9998abc1d7809e7764ab01b6b5158a..5815f2b1a66797cadd6544bbfab7f6a0dce398c7 100644 --- a/targets/ARCH/ETHERNET/USERSPACE/LIB/eth_raw.c +++ b/targets/ARCH/ETHERNET/USERSPACE/LIB/eth_raw.c @@ -21,7 +21,7 @@ /*! \file ethernet_lib.c * \brief API to stream I/Q samples over standard ethernet - * \author add alcatel Katerina Trilyraki, Navid Nikaein, Pedro Dinis, Lucio Ferreira, Raymond Knopp + * \author add alcatel Katerina Trilyraki, Navid Nikaein, Pedro Dinis, Lucio Ferreira, Raymond Knopp, Tien-Thinh Nguyen * \date 2015 * \version 0.2 * \company Eurecom @@ -45,18 +45,16 @@ #include "common_lib.h" #include "ethernet_lib.h" -#define DEBUG 0 +//#define DEBUG 0 -struct sockaddr_ll dest_addr[MAX_INST]; -struct sockaddr_ll local_addr[MAX_INST]; -int addr_len[MAX_INST]; -struct ifreq if_index[MAX_INST]; +//struct sockaddr_ll dest_addr[MAX_INST]; +//struct sockaddr_ll local_addr[MAX_INST]; +//int addr_len[MAX_INST]; +//struct ifreq if_index[MAX_INST]; int eth_socket_init_raw(openair0_device *device) { - int i = 0; eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; const char *local_mac, *remote_mac; int sock_dom=0; int sock_type=0; @@ -78,30 +76,33 @@ int eth_socket_init_raw(openair0_device *device) { sock_dom=AF_PACKET; sock_type=SOCK_RAW; sock_proto=IPPROTO_RAW; - if ((eth->sockfd[Mod_id] = socket(sock_dom, sock_type, sock_proto)) == -1) { + if ((eth->sockfd = socket(sock_dom, sock_type, sock_proto)) == -1) { perror("ETHERNET: Error opening RAW socket"); exit(0); } /* initialize destination address */ - for (i=0; i< MAX_INST; i++) { - bzero((void *)&(local_addr[i]), sizeof(struct sockaddr_ll)); - bzero((void *)&(if_index[i]), sizeof(struct ifreq)); - } + bzero((void *)&(eth->local_addr_ll), sizeof(struct sockaddr_ll)); + bzero((void *)&(eth->if_index), sizeof(struct ifreq)); + /* Get the index of the interface to send on */ - strcpy(if_index[Mod_id].ifr_name,eth->if_name[Mod_id]); - if (ioctl(eth->sockfd[Mod_id], SIOCGIFINDEX, &(if_index[Mod_id])) < 0) + strcpy(eth->if_index.ifr_name,eth->if_name); + if (ioctl(eth->sockfd, SIOCGIFINDEX, &(eth->if_index)) < 0) perror("SIOCGIFINDEX"); - local_addr[Mod_id].sll_family = AF_PACKET; - local_addr[Mod_id].sll_ifindex = if_index[Mod_id].ifr_ifindex; + eth->local_addr_ll.sll_family = AF_PACKET; + eth->local_addr_ll.sll_ifindex = eth->if_index.ifr_ifindex; /* hear traffic from specific protocol*/ - local_addr[Mod_id].sll_protocol = htons((short)device->openair0_cfg->my_port); - local_addr[Mod_id].sll_halen = ETH_ALEN; - local_addr[Mod_id].sll_pkttype = PACKET_OTHERHOST; - addr_len[Mod_id] = sizeof(struct sockaddr_ll); + if (eth->flags == ETH_RAW_IF5_MOBIPASS) { + eth->local_addr_ll.sll_protocol = htons(0xbffe); + } else{ + eth->local_addr_ll.sll_protocol = htons((short)device->openair0_cfg->my_port); + } + eth->local_addr_ll.sll_halen = ETH_ALEN; + eth->local_addr_ll.sll_pkttype = PACKET_OTHERHOST; + eth->addr_len = sizeof(struct sockaddr_ll); - if (bind(eth->sockfd[Mod_id],(struct sockaddr *)&local_addr[Mod_id],addr_len[Mod_id])<0) { + if (bind(eth->sockfd,(struct sockaddr *)ð->local_addr_ll,eth->addr_len)<0) { perror("ETHERNET: Cannot bind to socket"); exit(0); } @@ -114,7 +115,7 @@ int eth_socket_init_raw(openair0_device *device) { } else { eth->eh.ether_type = htons((short)device->openair0_cfg->my_port); } - printf("[%s] binding mod_%d to hardware address %x:%x:%x:%x:%x:%x\n",((device->host_type == BBU_HOST) ? "BBU": "RRH"),Mod_id,eth->eh.ether_shost[0],eth->eh.ether_shost[1],eth->eh.ether_shost[2],eth->eh.ether_shost[3],eth->eh.ether_shost[4],eth->eh.ether_shost[5]); + printf("[%s] binding to hardware address %x:%x:%x:%x:%x:%x\n",((device->host_type == BBU_HOST) ? "BBU": "RRH"),eth->eh.ether_shost[0],eth->eh.ether_shost[1],eth->eh.ether_shost[2],eth->eh.ether_shost[3],eth->eh.ether_shost[4],eth->eh.ether_shost[5]); return 0; } @@ -124,7 +125,6 @@ int trx_eth_write_raw(openair0_device *device, openair0_timestamp timestamp, voi int bytes_sent=0; eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; int sendto_flag =0; int i=0; //sendto_flag|=flags; @@ -157,7 +157,7 @@ int trx_eth_write_raw(openair0_device *device, openair0_timestamp timestamp, voi bytes_sent); #endif /* Send packet */ - bytes_sent += send(eth->sockfd[Mod_id], + bytes_sent += send(eth->sockfd, buff2, RAW_PACKET_SIZE_BYTES(nsamps), sendto_flag); @@ -195,7 +195,6 @@ int trx_eth_write_raw_IF4p5(openair0_device *device, openair0_timestamp timestam int bytes_sent = 0; eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; ssize_t packet_size; @@ -203,6 +202,8 @@ int trx_eth_write_raw_IF4p5(openair0_device *device, openair0_timestamp timestam packet_size = RAW_IF4p5_PDLFFT_SIZE_BYTES(nblocks); } else if (flags == IF4p5_PULFFT) { packet_size = RAW_IF4p5_PULFFT_SIZE_BYTES(nblocks); + } else if (flags == IF4p5_PULTICK) { + packet_size = RAW_IF4p5_PULTICK_SIZE_BYTES; } else if (flags == IF5_MOBIPASS) { packet_size = RAW_IF5_MOBIPASS_SIZE_BYTES; } else { @@ -214,7 +215,7 @@ int trx_eth_write_raw_IF4p5(openair0_device *device, openair0_timestamp timestam memcpy(buff[0], (void*)ð->eh, MAC_HEADER_SIZE_BYTES); - bytes_sent = send(eth->sockfd[Mod_id], + bytes_sent = send(eth->sockfd, buff[0], packet_size, 0); @@ -238,7 +239,6 @@ int trx_eth_read_raw(openair0_device *device, openair0_timestamp *timestamp, voi int bytes_received=0; int i=0; eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; int rcvfrom_flag =0; eth->rx_nsamps=nsamps; @@ -256,7 +256,7 @@ int trx_eth_read_raw(openair0_device *device, openair0_timestamp *timestamp, voi bytes_received=0; while(bytes_received < RAW_PACKET_SIZE_BYTES(nsamps)) { - bytes_received +=recv(eth->sockfd[Mod_id], + bytes_received +=recv(eth->sockfd, buff2, RAW_PACKET_SIZE_BYTES(nsamps), rcvfrom_flag); @@ -300,13 +300,15 @@ int trx_eth_read_raw_IF4p5(openair0_device *device, openair0_timestamp *timestam int nblocks = nsamps; int bytes_received=0; eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; ssize_t packet_size = MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t; IF4p5_header_t *test_header = (IF4p5_header_t*)(buff[0] + MAC_HEADER_SIZE_BYTES); +#ifdef DEBUG + printf("Reading from device %p, eth %p, sockfd %d\n",device,eth,eth->sockfd); +#endif - bytes_received = recv(eth->sockfd[Mod_id], + bytes_received = recv(eth->sockfd, buff[0], packet_size, MSG_PEEK); @@ -315,7 +317,12 @@ int trx_eth_read_raw_IF4p5(openair0_device *device, openair0_timestamp *timestam perror("ETHERNET IF4p5 READ (header): "); exit(-1); } - +#ifdef DEBUG + for (int i=0;isub_type; if (test_header->sub_type == IF4p5_PDLFFT) { @@ -328,7 +335,7 @@ int trx_eth_read_raw_IF4p5(openair0_device *device, openair0_timestamp *timestam while(bytes_received < packet_size) { - bytes_received = recv(eth->sockfd[Mod_id], + bytes_received = recv(eth->sockfd, buff[0], packet_size, 0); @@ -347,10 +354,81 @@ int trx_eth_read_raw_IF4p5(openair0_device *device, openair0_timestamp *timestam } +int trx_eth_read_raw_IF5_mobipass(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc) { + // Read nblocks info from packet itself + + int nblocks = nsamps; + int bytes_received=0; + eth_state_t *eth = (eth_state_t*)device->priv; + + ssize_t packet_size = 28; //MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t ; +// ssize_t packet_size = MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t + 640*sizeof(int16_t); + + bytes_received = recv(eth->sockfd, + buff[0], + packet_size, + MSG_PEEK); + + if (bytes_received ==-1) { + eth->num_rx_errors++; + perror("[MOBIPASS]ETHERNET IF5 READ (header): "); + exit(-1); + } + + IF5_mobipass_header_t *test_header = (IF5_mobipass_header_t*)((uint8_t *)buff[0] + MAC_HEADER_SIZE_BYTES); + *timestamp = test_header->time_stamp; + packet_size = MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t + 640*sizeof(int16_t); + + while(bytes_received < packet_size) { + bytes_received = recv(eth->sockfd, + buff[0], + packet_size, + 0); + if (bytes_received ==-1) { + eth->num_rx_errors++; + perror("[MOBIPASS] ETHERNET IF5 READ (payload): "); + exit(-1); + } else { + eth->rx_actual_nsamps = bytes_received>>1; + eth->rx_count++; + } + } + + eth->rx_nsamps = nsamps; + return(bytes_received); + + +/* + if (bytes_received > 0) { + while(bytes_received < packet_size) { + bytes_received = recv(eth->sockfd, + buff[0], + packet_size, + 0); + if (bytes_received ==-1) { + eth->num_rx_errors++; + perror("ETHERNET IF5_MOBIPASS READ (payload): "); + exit(-1); + } else { + eth->rx_actual_nsamps = bytes_received>>1; + eth->rx_count++; + } + } + if (bytes_received == packet_size){ + IF5_mobipass_header_t *test_header = (IF5_mobipass_header_t*)((uint8_t *)buff[0] + MAC_HEADER_SIZE_BYTES); + *timestamp = test_header->time_stamp; + } + + eth->rx_nsamps = nsamps; + } + + return(bytes_received); +*/ +} + int eth_set_dev_conf_raw(openair0_device *device) { - int Mod_id = device->Mod_id; eth_state_t *eth = (eth_state_t*)device->priv; void *msg; ssize_t msg_len; @@ -366,7 +444,7 @@ int eth_set_dev_conf_raw(openair0_device *device) { memcpy(msg,(void*)ð->eh,MAC_HEADER_SIZE_BYTES); memcpy((msg+MAC_HEADER_SIZE_BYTES),(void*)device->openair0_cfg,sizeof(openair0_config_t)); - if (send(eth->sockfd[Mod_id], + if (send(eth->sockfd, msg, msg_len, 0)==-1) { @@ -382,7 +460,6 @@ int eth_set_dev_conf_raw(openair0_device *device) { int eth_set_dev_conf_raw_IF4p5(openair0_device *device) { // use for cc_id info - int Mod_id = device->Mod_id; eth_state_t *eth = (eth_state_t*)device->priv; void *msg; ssize_t msg_len; @@ -398,7 +475,7 @@ int eth_set_dev_conf_raw_IF4p5(openair0_device *device) { memcpy(msg,(void*)ð->eh,MAC_HEADER_SIZE_BYTES); memcpy((msg+MAC_HEADER_SIZE_BYTES),(void*)device->openair0_cfg,sizeof(openair0_config_t)); - if (send(eth->sockfd[Mod_id], + if (send(eth->sockfd, msg, msg_len, 0)==-1) { @@ -413,7 +490,6 @@ int eth_set_dev_conf_raw_IF4p5(openair0_device *device) { int eth_get_dev_conf_raw(openair0_device *device) { eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; void *msg; ssize_t msg_len; @@ -421,7 +497,7 @@ int eth_get_dev_conf_raw(openair0_device *device) { msg_len = MAC_HEADER_SIZE_BYTES + sizeof(openair0_config_t); /* RRH receives from BBU openair0_config_t */ - if (recv(eth->sockfd[Mod_id], + if (recv(eth->sockfd, msg, msg_len, 0)==-1) { @@ -433,7 +509,7 @@ int eth_get_dev_conf_raw(openair0_device *device) { memcpy(eth->eh.ether_dhost,(msg+ETH_ALEN),ETH_ALEN); //memcpy((void*)&device->openair0_cfg,(msg + MAC_HEADER_SIZE_BYTES), sizeof(openair0_config_t)); device->openair0_cfg=(openair0_config_t *)(msg + MAC_HEADER_SIZE_BYTES); - printf("[%s] binding mod_%d to hardware address %x:%x:%x:%x:%x:%x hardware address %x:%x:%x:%x:%x:%x\n",((device->host_type == BBU_HOST) ? "BBU": "RRH"),Mod_id,eth->eh.ether_shost[0],eth->eh.ether_shost[1],eth->eh.ether_shost[2],eth->eh.ether_shost[3],eth->eh.ether_shost[4],eth->eh.ether_shost[5],eth->eh.ether_dhost[0],eth->eh.ether_dhost[1],eth->eh.ether_dhost[2],eth->eh.ether_dhost[3],eth->eh.ether_dhost[4],eth->eh.ether_dhost[5]); + printf("[%s] binding mod to hardware address %x:%x:%x:%x:%x:%x hardware address %x:%x:%x:%x:%x:%x\n",((device->host_type == BBU_HOST) ? "BBU": "RRH"),eth->eh.ether_shost[0],eth->eh.ether_shost[1],eth->eh.ether_shost[2],eth->eh.ether_shost[3],eth->eh.ether_shost[4],eth->eh.ether_shost[5],eth->eh.ether_dhost[0],eth->eh.ether_dhost[1],eth->eh.ether_dhost[2],eth->eh.ether_dhost[3],eth->eh.ether_dhost[4],eth->eh.ether_dhost[5]); return 0; } @@ -443,7 +519,6 @@ int eth_get_dev_conf_raw_IF4p5(openair0_device *device) { // use for cc_id info eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; void *msg; ssize_t msg_len; @@ -451,7 +526,7 @@ int eth_get_dev_conf_raw_IF4p5(openair0_device *device) { msg_len = MAC_HEADER_SIZE_BYTES + sizeof(openair0_config_t); /* RRH receives from BBU openair0_config_t */ - if (recv(eth->sockfd[Mod_id], + if (recv(eth->sockfd, msg, msg_len, 0)==-1) { @@ -463,7 +538,7 @@ int eth_get_dev_conf_raw_IF4p5(openair0_device *device) { memcpy(eth->eh.ether_dhost,(msg+ETH_ALEN),ETH_ALEN); //memcpy((void*)&device->openair0_cfg,(msg + MAC_HEADER_SIZE_BYTES), sizeof(openair0_config_t)); //device->openair0_cfg=(openair0_config_t *)(msg + MAC_HEADER_SIZE_BYTES); - printf("[%s] binding mod_%d to hardware address %x:%x:%x:%x:%x:%x hardware address %x:%x:%x:%x:%x:%x\n",((device->host_type == BBU_HOST) ? "BBU": "RRH"),Mod_id,eth->eh.ether_shost[0],eth->eh.ether_shost[1],eth->eh.ether_shost[2],eth->eh.ether_shost[3],eth->eh.ether_shost[4],eth->eh.ether_shost[5],eth->eh.ether_dhost[0],eth->eh.ether_dhost[1],eth->eh.ether_dhost[2],eth->eh.ether_dhost[3],eth->eh.ether_dhost[4],eth->eh.ether_dhost[5]); + printf("[%s] binding mod to hardware address %x:%x:%x:%x:%x:%x hardware address %x:%x:%x:%x:%x:%x\n",((device->host_type == BBU_HOST) ? "BBU": "RRH"),eth->eh.ether_shost[0],eth->eh.ether_shost[1],eth->eh.ether_shost[2],eth->eh.ether_shost[3],eth->eh.ether_shost[4],eth->eh.ether_shost[5],eth->eh.ether_dhost[0],eth->eh.ether_dhost[1],eth->eh.ether_dhost[2],eth->eh.ether_dhost[3],eth->eh.ether_dhost[4],eth->eh.ether_dhost[5]); return 0; } diff --git a/targets/ARCH/ETHERNET/USERSPACE/LIB/eth_udp.c b/targets/ARCH/ETHERNET/USERSPACE/LIB/eth_udp.c index 6ee1b879d1e90783aeea54b21584dd2a849ead2a..898382cf6a480ebea27429f4c6a1f5592c632140 100644 --- a/targets/ARCH/ETHERNET/USERSPACE/LIB/eth_udp.c +++ b/targets/ARCH/ETHERNET/USERSPACE/LIB/eth_udp.c @@ -47,9 +47,9 @@ #include "ethernet_lib.h" #define DEBUG 0 -struct sockaddr_in dest_addr[MAX_INST]; -struct sockaddr_in local_addr[MAX_INST]; -int addr_len[MAX_INST]; +//struct sockaddr_in dest_addr[MAX_INST]; +//struct sockaddr_in local_addr[MAX_INST]; +//int addr_len[MAX_INST]; uint16_t pck_seq_num = 1; @@ -58,9 +58,7 @@ uint16_t pck_seq_num_prev=0; int eth_socket_init_udp(openair0_device *device) { - int i = 0; eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; char str_local[INET_ADDRSTRLEN]; char str_remote[INET_ADDRSTRLEN]; const char *local_ip, *remote_ip; @@ -89,43 +87,42 @@ int eth_socket_init_udp(openair0_device *device) { sock_type=SOCK_DGRAM; sock_proto=IPPROTO_UDP; - if ((eth->sockfd[Mod_id] = socket(sock_dom, sock_type, sock_proto)) == -1) { + if ((eth->sockfd = socket(sock_dom, sock_type, sock_proto)) == -1) { perror("ETHERNET: Error opening socket"); exit(0); } /* initialize addresses */ - for (i=0; i< MAX_INST; i++) { - bzero((void *)&(dest_addr[i]), sizeof(dest_addr[i])); - bzero((void *)&(local_addr[i]), sizeof(local_addr[i])); - } + bzero((void *)&(eth->dest_addr), sizeof(eth->dest_addr)); + bzero((void *)&(eth->local_addr), sizeof(eth->local_addr)); + - addr_len[Mod_id] = sizeof(struct sockaddr_in); + eth->addr_len = sizeof(struct sockaddr_in); - dest_addr[Mod_id].sin_family = AF_INET; - inet_pton(AF_INET,remote_ip,&(dest_addr[Mod_id].sin_addr.s_addr)); - dest_addr[Mod_id].sin_port=htons(remote_port); - inet_ntop(AF_INET, &(dest_addr[Mod_id].sin_addr), str_remote, INET_ADDRSTRLEN); + eth->dest_addr.sin_family = AF_INET; + inet_pton(AF_INET,remote_ip,&(eth->dest_addr.sin_addr.s_addr)); + eth->dest_addr.sin_port=htons(remote_port); + inet_ntop(AF_INET, &(eth->dest_addr.sin_addr), str_remote, INET_ADDRSTRLEN); - local_addr[Mod_id].sin_family = AF_INET; - inet_pton(AF_INET,local_ip,&(local_addr[Mod_id].sin_addr.s_addr)); - local_addr[Mod_id].sin_port=htons(local_port); - inet_ntop(AF_INET, &(local_addr[Mod_id].sin_addr), str_local, INET_ADDRSTRLEN); + eth->local_addr.sin_family = AF_INET; + inet_pton(AF_INET,local_ip,&(eth->local_addr.sin_addr.s_addr)); + eth->local_addr.sin_port=htons(local_port); + inet_ntop(AF_INET, &(eth->local_addr.sin_addr), str_local, INET_ADDRSTRLEN); /* set reuse address flag */ - if (setsockopt(eth->sockfd[Mod_id], SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int))) { + if (setsockopt(eth->sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int))) { perror("ETHERNET: Cannot set SO_REUSEADDR option on socket"); exit(0); } /* want to receive -> so bind */ - if (bind(eth->sockfd[Mod_id],(struct sockaddr *)&local_addr[Mod_id],addr_len[Mod_id])<0) { + if (bind(eth->sockfd,(struct sockaddr *)ð->local_addr,eth->addr_len)<0) { perror("ETHERNET: Cannot bind to socket"); exit(0); } else { - printf("[%s] binding mod_%d to %s:%d\n","RRH",Mod_id,str_local,ntohs(local_addr[Mod_id].sin_port)); + printf("[%s] binding to %s:%d\n","RRH",str_local,ntohs(eth->local_addr.sin_port)); } return 0; @@ -135,54 +132,62 @@ int trx_eth_read_udp_IF4p5(openair0_device *device, openair0_timestamp *timestam // Read nblocks info from packet itself int nblocks = nsamps; - int bytes_received=0; + int bytes_received=-1; eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; - + ssize_t packet_size = sizeof_IF4p5_header_t; IF4p5_header_t *test_header = (IF4p5_header_t*)(buff[0]); - - - bytes_received = recvfrom(eth->sockfd[Mod_id], - buff[0], - packet_size, - 0, - (struct sockaddr *)&dest_addr[Mod_id], - (socklen_t *)&addr_len[Mod_id]); - - if (bytes_received ==-1) { - eth->num_rx_errors++; - perror("ETHERNET IF4p5 READ (header): "); - exit(-1); - } - - *timestamp = test_header->sub_type; - if (test_header->sub_type == IF4p5_PDLFFT) { - packet_size = UDP_IF4p5_PDLFFT_SIZE_BYTES(nblocks); - } else if (test_header->sub_type == IF4p5_PULFFT) { - packet_size = UDP_IF4p5_PULFFT_SIZE_BYTES(nblocks); - } else { - packet_size = UDP_IF4p5_PRACH_SIZE_BYTES; - } - - - while(bytes_received < packet_size) { - bytes_received = recvfrom(eth->sockfd[Mod_id], - buff[0], - packet_size, - 0, - (struct sockaddr *)&dest_addr[Mod_id], - (socklen_t *)&addr_len[Mod_id]); + int block_cnt=0; + int again_cnt=0; + packet_size = max(UDP_IF4p5_PRACH_SIZE_BYTES, max(UDP_IF4p5_PULFFT_SIZE_BYTES(nblocks), UDP_IF4p5_PDLFFT_SIZE_BYTES(nblocks))); + + while(bytes_received == -1) { + again: + bytes_received = recvfrom(eth->sockfd, + buff[0], + packet_size, + 0, + (struct sockaddr *)ð->dest_addr, + (socklen_t *)ð->addr_len); if (bytes_received ==-1) { eth->num_rx_errors++; - perror("ETHERNET IF4p5 READ (payload): "); - exit(-1); + if (errno == EAGAIN) { + /* + again_cnt++; + usleep(10); + if (again_cnt == 1000) { + perror("ETHERNET IF4p5 READ (EAGAIN): "); + exit(-1); + } else { + printf("AGAIN AGAIN AGAIN AGAIN AGAIN AGAIN AGAIN AGAIN AGAIN AGAIN AGAIN AGAIN \n"); + goto again; + } + */ + printf("Lost IF4p5 connection with %s\n", inet_ntoa(eth->dest_addr.sin_addr)); + exit(-1); + } else if (errno == EWOULDBLOCK) { + block_cnt++; + usleep(10); + if (block_cnt == 1000) { + perror("ETHERNET IF4p5 READ (EWOULDBLOCK): "); + exit(-1); + } else { + printf("BLOCK BLOCK BLOCK BLOCK BLOCK BLOCK BLOCK BLOCK BLOCK BLOCK BLOCK BLOCK \n"); + goto again; + } + } else { + perror("ETHERNET IF4p5 READ"); + printf("(%s):\n", strerror(errno)); + exit(-1); + } } else { - eth->rx_actual_nsamps = bytes_received>>1; + *timestamp = test_header->sub_type; + eth->rx_actual_nsamps = bytes_received>>1; eth->rx_count++; } } + //printf("size of third %d subtype %d frame %d subframe %d symbol %d \n", bytes_received, test_header->sub_type, ((test_header->frame_status)>>6)&0xffff, ((test_header->frame_status)>>22)&0x000f, ((test_header->frame_status)>>26)&0x000f) ; eth->rx_nsamps = nsamps; return(bytes_received); @@ -194,7 +199,6 @@ int trx_eth_write_udp_IF4p5(openair0_device *device, openair0_timestamp timestam int bytes_sent = 0; eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; ssize_t packet_size; @@ -202,6 +206,8 @@ int trx_eth_write_udp_IF4p5(openair0_device *device, openair0_timestamp timestam packet_size = UDP_IF4p5_PDLFFT_SIZE_BYTES(nblocks); } else if (flags == IF4p5_PULFFT) { packet_size = UDP_IF4p5_PULFFT_SIZE_BYTES(nblocks); + } else if (flags == IF4p5_PULTICK) { + packet_size = UDP_IF4p5_PULTICK_SIZE_BYTES; } else if (flags == IF4p5_PRACH) { packet_size = UDP_IF4p5_PRACH_SIZE_BYTES; } else { @@ -211,12 +217,12 @@ int trx_eth_write_udp_IF4p5(openair0_device *device, openair0_timestamp timestam eth->tx_nsamps = nblocks; - bytes_sent = sendto(eth->sockfd[Mod_id], + bytes_sent = sendto(eth->sockfd, buff[0], packet_size, 0, - (struct sockaddr*)&dest_addr[Mod_id], - addr_len[Mod_id]); + (struct sockaddr*)ð->dest_addr, + eth->addr_len); if (bytes_sent == -1) { eth->num_tx_errors++; @@ -234,7 +240,6 @@ int trx_eth_write_udp(openair0_device *device, openair0_timestamp timestamp, voi int bytes_sent=0; eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; int sendto_flag =0; int i=0; //sendto_flag|=flags; @@ -268,12 +273,12 @@ int trx_eth_write_udp(openair0_device *device, openair0_timestamp timestamp, voi bytes_sent); #endif /* Send packet */ - bytes_sent += sendto(eth->sockfd[Mod_id], + bytes_sent += sendto(eth->sockfd, buff2, UDP_PACKET_SIZE_BYTES(nsamps), sendto_flag, - (struct sockaddr*)&dest_addr[Mod_id], - addr_len[Mod_id]); + (struct sockaddr*)ð->dest_addr, + eth->addr_len); if ( bytes_sent == -1) { eth->num_tx_errors++; @@ -291,7 +296,7 @@ int trx_eth_write_udp(openair0_device *device, openair0_timestamp timestamp, voi eth->tx_actual_nsamps=bytes_sent>>2; eth->tx_count++; pck_seq_num++; - if ( pck_seq_num > MAX_PACKET_SEQ_NUM(nsamps,76800) ) pck_seq_num = 1; + if ( pck_seq_num > MAX_PACKET_SEQ_NUM(nsamps,device->openair0_cfg->samples_per_frame) ) pck_seq_num = 1; } } /* tx buffer values restored */ @@ -309,7 +314,6 @@ int trx_eth_read_udp(openair0_device *device, openair0_timestamp *timestamp, voi int bytes_received=0; eth_state_t *eth = (eth_state_t*)device->priv; // openair0_timestamp prev_timestamp = -1; - int Mod_id = device->Mod_id; int rcvfrom_flag =0; int block_cnt=0; int again_cnt=0; @@ -338,12 +342,12 @@ int trx_eth_read_udp(openair0_device *device, openair0_timestamp *timestamp, voi UDP_PACKET_SIZE_BYTES(nsamps) - bytes_received, bytes_received); #endif - bytes_received +=recvfrom(eth->sockfd[Mod_id], + bytes_received +=recvfrom(eth->sockfd, buff2, UDP_PACKET_SIZE_BYTES(nsamps), rcvfrom_flag, - (struct sockaddr *)&dest_addr[Mod_id], - (socklen_t *)&addr_len[Mod_id]); + (struct sockaddr *)ð->dest_addr, + (socklen_t *)ð->addr_len); if (bytes_received ==-1) { eth->num_rx_errors++; @@ -389,7 +393,7 @@ int trx_eth_read_udp(openair0_device *device, openair0_timestamp *timestamp, voi /* get the packet sequence number from packet's header */ pck_seq_num_cur = *(uint16_t *)buff2; //printf("cur=%d prev=%d buff=%d\n",pck_seq_num_cur,pck_seq_num_prev,*(uint16_t *)(buff2)); - if ( ( pck_seq_num_cur != (pck_seq_num_prev + 1) ) && !((pck_seq_num_prev==75) && (pck_seq_num_cur==1 ))){ + if ( ( pck_seq_num_cur != (pck_seq_num_prev + 1) ) && !((pck_seq_num_prev==MAX_PACKET_SEQ_NUM(nsamps,device->openair0_cfg->samples_per_frame)) && (pck_seq_num_cur==1 )) && !((pck_seq_num_prev==1) && (pck_seq_num_cur==1))) { printf("out of order packet received1! %d|%d|%d\n",pck_seq_num_cur,pck_seq_num_prev,(int)*timestamp); } VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_RX_SEQ_NUM,pck_seq_num_cur); @@ -412,7 +416,6 @@ int trx_eth_read_udp(openair0_device *device, openair0_timestamp *timestamp, voi int eth_set_dev_conf_udp(openair0_device *device) { - int Mod_id = device->Mod_id; eth_state_t *eth = (eth_state_t*)device->priv; void *msg; ssize_t msg_len; @@ -425,9 +428,10 @@ int eth_set_dev_conf_udp(openair0_device *device) { msg=malloc(sizeof(openair0_config_t)); msg_len=sizeof(openair0_config_t); memcpy(msg,(void*)device->openair0_cfg,msg_len); - - if (sendto(eth->sockfd[Mod_id],msg,msg_len,0,(struct sockaddr *)&dest_addr[Mod_id],addr_len[Mod_id])==-1) { - perror("ETHERNET: "); + + if (sendto(eth->sockfd,msg,msg_len,0,(struct sockaddr *)ð->dest_addr,eth->addr_len)==-1) { + perror("ETHERNET: sendto conf_udp"); + printf("addr_len : %d, msg_len %d\n",eth->addr_len,msg_len); exit(0); } @@ -437,7 +441,6 @@ int eth_set_dev_conf_udp(openair0_device *device) { int eth_get_dev_conf_udp(openair0_device *device) { eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; char str1[INET_ADDRSTRLEN],str[INET_ADDRSTRLEN]; void *msg; ssize_t msg_len; @@ -445,31 +448,31 @@ int eth_get_dev_conf_udp(openair0_device *device) { msg=malloc(sizeof(openair0_config_t)); msg_len=sizeof(openair0_config_t); - inet_ntop(AF_INET, &(local_addr[Mod_id].sin_addr), str, INET_ADDRSTRLEN); - inet_ntop(AF_INET, &(dest_addr[Mod_id].sin_addr), str1, INET_ADDRSTRLEN); + inet_ntop(AF_INET, &(eth->local_addr.sin_addr), str, INET_ADDRSTRLEN); + inet_ntop(AF_INET, &(eth->dest_addr.sin_addr), str1, INET_ADDRSTRLEN); /* RRH receives from BBU openair0_config_t */ - if (recvfrom(eth->sockfd[Mod_id], + if (recvfrom(eth->sockfd, msg, msg_len, 0, - (struct sockaddr *)&dest_addr[Mod_id], - (socklen_t *)&addr_len[Mod_id])==-1) { - perror("ETHERNET: "); + (struct sockaddr *)ð->dest_addr, + (socklen_t *)ð->addr_len)==-1) { + perror("ETHERNET: recv_from conf_udp"); exit(0); } device->openair0_cfg=(openair0_config_t *)msg; /* get remote ip address and port */ - /* inet_ntop(AF_INET, &(dest_addr[Mod_id].sin_addr), str1, INET_ADDRSTRLEN); */ - /* device->openair0_cfg->remote_port =ntohs(dest_addr[Mod_id].sin_port); */ + /* inet_ntop(AF_INET, &(eth->dest_addr.sin_addr), str1, INET_ADDRSTRLEN); */ + /* device->openair0_cfg->remote_port =ntohs(eth->dest_addr.sin_port); */ /* device->openair0_cfg->remote_addr =str1; */ /* /\* restore local ip address and port *\/ */ - /* inet_ntop(AF_INET, &(local_addr[Mod_id].sin_addr), str, INET_ADDRSTRLEN); */ - /* device->openair0_cfg->my_port =ntohs(local_addr[Mod_id].sin_port); */ + /* inet_ntop(AF_INET, &(eth->local_addr.sin_addr), str, INET_ADDRSTRLEN); */ + /* device->openair0_cfg->my_port =ntohs(eth->local_addr.sin_port); */ /* device->openair0_cfg->my_addr =str; */ - /* printf("[RRH] mod_%d socket %d connected to BBU %s:%d %s:%d\n", Mod_id, eth->sockfd[Mod_id],str1, device->openair0_cfg->remote_port, str, device->openair0_cfg->my_port); */ + /* printf("[RRH] mod_%d socket %d connected to BBU %s:%d %s:%d\n", Mod_id, eth->sockfd,str1, device->openair0_cfg->remote_port, str, device->openair0_cfg->my_port); */ return 0; } diff --git a/targets/ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.c b/targets/ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.c index 1880719c508ac95e63576f1ad34868d93a69116f..6f93ba4853d3fa209246871d57abf65f62f3493a 100644 --- a/targets/ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.c +++ b/targets/ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.c @@ -45,117 +45,114 @@ #include "common_lib.h" #include "ethernet_lib.h" -int num_devices_eth = 0; -struct sockaddr_in dest_addr[MAX_INST]; -int dest_addr_len[MAX_INST]; - - int trx_eth_start(openair0_device *device) { - eth_state_t *eth = (eth_state_t*)device->priv; - - /* initialize socket */ - if (eth->flags == ETH_RAW_MODE) { - printf("Setting ETHERNET to ETH_RAW_IF5_MODE\n"); - if (eth_socket_init_raw(device)!=0) return -1; - /* RRH gets openair0 device configuration - BBU sets openair0 device configuration*/ - if (device->host_type == BBU_HOST) { - if(eth_set_dev_conf_raw(device)!=0) return -1; - } else { - if(eth_get_dev_conf_raw(device)!=0) return -1; - } - /* adjust MTU wrt number of samples per packet */ - if(ethernet_tune (device,MTU_SIZE,RAW_PACKET_SIZE_BYTES(device->openair0_cfg->samples_per_packet))!=0) return -1; - if(ethernet_tune (device,RCV_TIMEOUT,999999)!=0) return -1; - } else if (eth->flags == ETH_RAW_IF4p5_MODE) { - - printf("Setting ETHERNET to ETH_RAW_IF4p5_MODE\n"); - if (eth_socket_init_raw(device)!=0) return -1; - /* RRH gets openair0 device configuration - BBU sets openair0 device configuration*/ - if (device->host_type == BBU_HOST) { - if(eth_set_dev_conf_raw_IF4p5(device)!=0) return -1; - } else { - if(eth_get_dev_conf_raw_IF4p5(device)!=0) return -1; - } - /* adjust MTU wrt number of samples per packet */ - if(ethernet_tune (device,MTU_SIZE,RAW_IF4p5_PRACH_SIZE_BYTES)!=0) return -1; - - if(ethernet_tune (device,RCV_TIMEOUT,999999)!=0) return -1; - } else if (eth->flags == ETH_UDP_IF4p5_MODE) { - printf("Setting ETHERNET to UDP_IF4p5_MODE\n"); - if (eth_socket_init_udp(device)!=0) return -1; - if (device->host_type == BBU_HOST) { - if(eth_set_dev_conf_udp(device)!=0) return -1; - } else { - if(eth_get_dev_conf_udp(device)!=0) return -1; - } - } else if (eth->flags == ETH_RAW_IF5_MOBIPASS) { - printf("Setting ETHERNET to RAW_IF5_MODE\n"); - if (eth_socket_init_raw(device)!=0) return -1; + eth_state_t *eth = (eth_state_t*)device->priv; + + /* initialize socket */ + if (eth->flags == ETH_RAW_MODE) { + printf("Setting ETHERNET to ETH_RAW_IF5_MODE\n"); + if (eth_socket_init_raw(device)!=0) return -1; + /* RRH gets openair0 device configuration - BBU sets openair0 device configuration*/ + if (device->host_type == BBU_HOST) { + if(eth_set_dev_conf_raw(device)!=0) return -1; } else { - if (eth_socket_init_udp(device)!=0) return -1; - /* RRH gets openair0 device configuration - BBU sets openair0 device configuration*/ - if (device->host_type == BBU_HOST) { - if(eth_set_dev_conf_udp(device)!=0) return -1; - } else { - if(eth_get_dev_conf_udp(device)!=0) return -1; - } + if(eth_get_dev_conf_raw(device)!=0) return -1; } - /* apply additional configuration */ - if(ethernet_tune (device, SND_BUF_SIZE,2000000000)!=0) return -1; - if(ethernet_tune (device, RCV_BUF_SIZE,2000000000)!=0) return -1; - - return 0; + /* adjust MTU wrt number of samples per packet */ + if(ethernet_tune (device,MTU_SIZE,RAW_PACKET_SIZE_BYTES(device->openair0_cfg->samples_per_packet))!=0) return -1; + if(ethernet_tune (device,RCV_TIMEOUT,999999)!=0) return -1; + } else if (eth->flags == ETH_RAW_IF4p5_MODE) { + + printf("Setting ETHERNET to ETH_RAW_IF4p5_MODE\n"); + if (eth_socket_init_raw(device)!=0) return -1; + /* RRH gets openair0 device configuration - BBU sets openair0 device configuration*/ + if (device->host_type == BBU_HOST) { + if(eth_set_dev_conf_raw_IF4p5(device)!=0) return -1; + } else { + if(eth_get_dev_conf_raw_IF4p5(device)!=0) return -1; + } + /* adjust MTU wrt number of samples per packet */ + if(ethernet_tune (device,MTU_SIZE,RAW_IF4p5_PRACH_SIZE_BYTES)!=0) return -1; + + if(ethernet_tune (device,RCV_TIMEOUT,999999)!=0) return -1; + } else if (eth->flags == ETH_UDP_IF4p5_MODE) { + printf("Setting ETHERNET to UDP_IF4p5_MODE\n"); + if (eth_socket_init_udp(device)!=0) return -1; + if (device->host_type == BBU_HOST) { + if(eth_set_dev_conf_udp(device)!=0) return -1; + } else { + if(eth_get_dev_conf_udp(device)!=0) return -1; + } + } else if (eth->flags == ETH_RAW_IF5_MOBIPASS) { + printf("Setting ETHERNET to RAW_IF5_MODE\n"); + if (eth_socket_init_raw(device)!=0) return -1; + if(ethernet_tune (device,RCV_TIMEOUT,999999)!=0) return -1; + + } else { + printf("Setting ETHERNET to UDP_IF5_MODE\n"); + if (eth_socket_init_udp(device)!=0) return -1; + /* RRH gets openair0 device configuration - BBU sets openair0 device configuration*/ + if (device->host_type == BBU_HOST) { + if(eth_set_dev_conf_udp(device)!=0) return -1; + } else { + if(eth_get_dev_conf_udp(device)!=0) return -1; + } + } + /* apply additional configuration */ + if(ethernet_tune (device, SND_BUF_SIZE,2000000000)!=0) return -1; + if(ethernet_tune (device, RCV_BUF_SIZE,2000000000)!=0) return -1; + + return 0; } void trx_eth_end(openair0_device *device) { - eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; - /* destroys socket only for the processes that call the eth_end fuction-- shutdown() for beaking the pipe */ - if ( close(eth->sockfd[Mod_id]) <0 ) { - perror("ETHERNET: Failed to close socket"); - exit(0); - } else { - printf("[%s] socket for mod_id %d has been successfully closed.\n",(device->host_type == BBU_HOST)? "BBU":"RRH",Mod_id); - } - + eth_state_t *eth = (eth_state_t*)device->priv; + /* destroys socket only for the processes that call the eth_end fuction-- shutdown() for beaking the pipe */ + if ( close(eth->sockfd) <0 ) { + perror("ETHERNET: Failed to close socket"); + exit(0); + } else { + printf("[%s] socket has been successfully closed.\n",(device->host_type == BBU_HOST)? "BBU":"RRH"); + } } int trx_eth_request(openair0_device *device, void *msg, ssize_t msg_len) { - int Mod_id = device->Mod_id; - eth_state_t *eth = (eth_state_t*)device->priv; - - /* BBU sends a message to RRH */ - if (sendto(eth->sockfd[Mod_id],msg,msg_len,0,(struct sockaddr *)&dest_addr[Mod_id],dest_addr_len[Mod_id])==-1) { - perror("ETHERNET: "); - exit(0); - } - - return 0; + eth_state_t *eth = (eth_state_t*)device->priv; + + /* BBU sends a message to RRH */ + + if (sendto(eth->sockfd,msg,msg_len,0,(struct sockaddr *)ð->dest_addr,eth->addr_len)==-1) { + perror("ETHERNET: "); + exit(0); + } + return 0; } int trx_eth_reply(openair0_device *device, void *msg, ssize_t msg_len) { - eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id = device->Mod_id; - - /* RRH receives from BBU a message */ - if (recvfrom(eth->sockfd[Mod_id], - msg, - msg_len, - 0, - (struct sockaddr *)&dest_addr[Mod_id], - (socklen_t *)&dest_addr_len[Mod_id])==-1) { - perror("ETHERNET: "); - exit(0); - } + eth_state_t *eth = (eth_state_t*)device->priv; + + /* RRH receives from BBU a message */ + + if (recvfrom(eth->sockfd, + msg, + msg_len, + 0, + (struct sockaddr *)ð->dest_addr, + (socklen_t *)ð->addr_len)==-1) { + perror("ETHERNET: recv_from in trx_eth_reply "); + exit(0); + } + + - return 0; + return 0; } @@ -182,236 +179,233 @@ int trx_eth_reset_stats(openair0_device* device) { int ethernet_tune(openair0_device *device, unsigned int option, int value) { - - eth_state_t *eth = (eth_state_t*)device->priv; - int Mod_id=device->Mod_id; - struct timeval timeout; - struct ifreq ifr; - char system_cmd[256]; - // char* if_name=DEFAULT_IF; - // struct in_addr ia; - // struct if_nameindex *ids; - int ret=0; - // int i=0; - - /****************** socket level options ************************/ - switch(option) { - case SND_BUF_SIZE: /* transmit socket buffer size */ - if (setsockopt(eth->sockfd[Mod_id], - SOL_SOCKET, - SO_SNDBUF, - &value,sizeof(value))) { - perror("[ETHERNET] setsockopt()"); - } else { - printf("send buffer size= %d bytes\n",value); - } - break; - - case RCV_BUF_SIZE: /* receive socket buffer size */ - if (setsockopt(eth->sockfd[Mod_id], - SOL_SOCKET, - SO_RCVBUF, - &value,sizeof(value))) { - perror("[ETHERNET] setsockopt()"); - } else { - printf("receive bufffer size= %d bytes\n",value); - } - break; - - case RCV_TIMEOUT: - timeout.tv_sec = value/1000000; - timeout.tv_usec = value%1000000;//less than rt_period? - if (setsockopt(eth->sockfd[Mod_id], - SOL_SOCKET, - SO_RCVTIMEO, - (char *)&timeout,sizeof(timeout))) { - perror("[ETHERNET] setsockopt()"); - } else { - printf( "receive timeout= %u usec\n",(unsigned int)timeout.tv_usec); - } - break; - - case SND_TIMEOUT: - timeout.tv_sec = value/1000000000; - timeout.tv_usec = value%1000000000;//less than rt_period? - if (setsockopt(eth->sockfd[Mod_id], - SOL_SOCKET, - SO_SNDTIMEO, - (char *)&timeout,sizeof(timeout))) { - perror("[ETHERNET] setsockopt()"); - } else { - printf( "send timeout= %d,%d sec\n",(int)timeout.tv_sec,(int)timeout.tv_usec); - } - break; - - + + eth_state_t *eth = (eth_state_t*)device->priv; + struct timeval timeout; + struct ifreq ifr; + char system_cmd[256]; + // char* if_name=DEFAULT_IF; + // struct in_addr ia; + // struct if_nameindex *ids; + int ret=0; + // int i=0; + + /****************** socket level options ************************/ + switch(option) { + case SND_BUF_SIZE: /* transmit socket buffer size */ + if (setsockopt(eth->sockfd, + SOL_SOCKET, + SO_SNDBUF, + &value,sizeof(value))) { + perror("[ETHERNET] setsockopt()"); + } else { + printf("send buffer size= %d bytes\n",value); + } + break; + + case RCV_BUF_SIZE: /* receive socket buffer size */ + if (setsockopt(eth->sockfd, + SOL_SOCKET, + SO_RCVBUF, + &value,sizeof(value))) { + perror("[ETHERNET] setsockopt()"); + } else { + printf("receive bufffer size= %d bytes\n",value); + } + break; + + case RCV_TIMEOUT: + timeout.tv_sec = value/1000000; + timeout.tv_usec = value%1000000;//less than rt_period? + if (setsockopt(eth->sockfd, + SOL_SOCKET, + SO_RCVTIMEO, + (char *)&timeout,sizeof(timeout))) { + perror("[ETHERNET] setsockopt()"); + } else { + printf( "receive timeout= %u usec\n",(unsigned int)timeout.tv_usec); + } + break; + + case SND_TIMEOUT: + timeout.tv_sec = value/1000000000; + timeout.tv_usec = value%1000000000;//less than rt_period? + if (setsockopt(eth->sockfd, + SOL_SOCKET, + SO_SNDTIMEO, + (char *)&timeout,sizeof(timeout))) { + perror("[ETHERNET] setsockopt()"); + } else { + printf( "send timeout= %d,%d sec\n",(int)timeout.tv_sec,(int)timeout.tv_usec); + } + break; + + /******************* interface level options *************************/ - case MTU_SIZE: /* change MTU of the eth interface */ - ifr.ifr_addr.sa_family = AF_INET; - strncpy(ifr.ifr_name,eth->if_name[Mod_id], sizeof(ifr.ifr_name)); - ifr.ifr_mtu =value; - if (ioctl(eth->sockfd[Mod_id],SIOCSIFMTU,(caddr_t)&ifr) < 0 ) - perror ("[ETHERNET] Can't set the MTU"); - else - printf("[ETHERNET] %s MTU size has changed to %d\n",eth->if_name[Mod_id],ifr.ifr_mtu); - break; - - case TX_Q_LEN: /* change TX queue length of eth interface */ - ifr.ifr_addr.sa_family = AF_INET; - strncpy(ifr.ifr_name,eth->if_name[Mod_id], sizeof(ifr.ifr_name)); - ifr.ifr_qlen =value; - if (ioctl(eth->sockfd[Mod_id],SIOCSIFTXQLEN,(caddr_t)&ifr) < 0 ) - perror ("[ETHERNET] Can't set the txqueuelen"); - else - printf("[ETHERNET] %s txqueuelen size has changed to %d\n",eth->if_name[Mod_id],ifr.ifr_qlen); - break; - + case MTU_SIZE: /* change MTU of the eth interface */ + ifr.ifr_addr.sa_family = AF_INET; + strncpy(ifr.ifr_name,eth->if_name, sizeof(ifr.ifr_name)); + ifr.ifr_mtu =value; + if (ioctl(eth->sockfd,SIOCSIFMTU,(caddr_t)&ifr) < 0 ) + perror ("[ETHERNET] Can't set the MTU"); + else + printf("[ETHERNET] %s MTU size has changed to %d\n",eth->if_name,ifr.ifr_mtu); + break; + + case TX_Q_LEN: /* change TX queue length of eth interface */ + ifr.ifr_addr.sa_family = AF_INET; + strncpy(ifr.ifr_name,eth->if_name, sizeof(ifr.ifr_name)); + ifr.ifr_qlen =value; + if (ioctl(eth->sockfd,SIOCSIFTXQLEN,(caddr_t)&ifr) < 0 ) + perror ("[ETHERNET] Can't set the txqueuelen"); + else + printf("[ETHERNET] %s txqueuelen size has changed to %d\n",eth->if_name,ifr.ifr_qlen); + break; + /******************* device level options *************************/ - case COALESCE_PAR: - ret=snprintf(system_cmd,sizeof(system_cmd),"ethtool -C %s rx-usecs %d",eth->if_name[Mod_id],value); - if (ret > 0) { - ret=system(system_cmd); - if (ret == -1) { - fprintf (stderr,"[ETHERNET] Can't start shell to execute %s %s",system_cmd, strerror(errno)); - } else { - printf ("[ETHERNET] status of %s is %i\n",WEXITSTATUS(ret)); - } - printf("[ETHERNET] Coalesce parameters %s\n",system_cmd); - } else { - perror("[ETHERNET] Can't set coalesce parameters\n"); - } - break; - - case PAUSE_PAR: - if (value==1) ret=snprintf(system_cmd,sizeof(system_cmd),"ethtool -A %s autoneg off rx off tx off",eth->if_name[Mod_id]); - else if (value==0) ret=snprintf(system_cmd,sizeof(system_cmd),"ethtool -A %s autoneg on rx on tx on",eth->if_name[Mod_id]); - else break; - if (ret > 0) { - ret=system(system_cmd); - if (ret == -1) { - fprintf (stderr,"[ETHERNET] Can't start shell to execute %s %s",system_cmd, strerror(errno)); - } else { - printf ("[ETHERNET] status of %s is %i\n",WEXITSTATUS(ret)); - } - printf("[ETHERNET] Pause parameters %s\n",system_cmd); - } else { - perror("[ETHERNET] Can't set pause parameters\n"); - } - break; - - case RING_PAR: - ret=snprintf(system_cmd,sizeof(system_cmd),"ethtool -G %s val %d",eth->if_name[Mod_id],value); - if (ret > 0) { - ret=system(system_cmd); - if (ret == -1) { - fprintf (stderr,"[ETHERNET] Can't start shell to execute %s %s",system_cmd, strerror(errno)); - } else { - printf ("[ETHERNET] status of %s is %i\n",WEXITSTATUS(ret)); - } - printf("[ETHERNET] Ring parameters %s\n",system_cmd); - } else { - perror("[ETHERNET] Can't set ring parameters\n"); - } - break; - - default: - break; + case COALESCE_PAR: + ret=snprintf(system_cmd,sizeof(system_cmd),"ethtool -C %s rx-usecs %d",eth->if_name,value); + if (ret > 0) { + ret=system(system_cmd); + if (ret == -1) { + fprintf (stderr,"[ETHERNET] Can't start shell to execute %s %s",system_cmd, strerror(errno)); + } else { + printf ("[ETHERNET] status of %s is %i\n",WEXITSTATUS(ret)); + } + printf("[ETHERNET] Coalesce parameters %s\n",system_cmd); + } else { + perror("[ETHERNET] Can't set coalesce parameters\n"); } - - return 0; -} - - - -int transport_init(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t * eth_params ) { - - eth_state_t *eth = (eth_state_t*)malloc(sizeof(eth_state_t)); - memset(eth, 0, sizeof(eth_state_t)); - - if (eth_params->transp_preference == 1) { - eth->flags = ETH_RAW_MODE; - } else if (eth_params->transp_preference == 0) { - eth->flags = ETH_UDP_MODE; - } else if (eth_params->transp_preference == 3) { - eth->flags = ETH_RAW_IF4p5_MODE; - } else if (eth_params->transp_preference == 2) { - eth->flags = ETH_UDP_IF4p5_MODE; - } else if (eth_params->transp_preference == 4) { - eth->flags = ETH_RAW_IF5_MOBIPASS; + break; + + case PAUSE_PAR: + if (value==1) ret=snprintf(system_cmd,sizeof(system_cmd),"ethtool -A %s autoneg off rx off tx off",eth->if_name); + else if (value==0) ret=snprintf(system_cmd,sizeof(system_cmd),"ethtool -A %s autoneg on rx on tx on",eth->if_name); + else break; + if (ret > 0) { + ret=system(system_cmd); + if (ret == -1) { + fprintf (stderr,"[ETHERNET] Can't start shell to execute %s %s",system_cmd, strerror(errno)); + } else { + printf ("[ETHERNET] status of %s is %i\n",WEXITSTATUS(ret)); + } + printf("[ETHERNET] Pause parameters %s\n",system_cmd); } else { - printf("transport_init: Unknown transport preference %d - default to RAW", eth_params->transp_preference); - eth->flags = ETH_RAW_MODE; + perror("[ETHERNET] Can't set pause parameters\n"); } - - printf("[ETHERNET]: Initializing openair0_device for %s ...\n", ((device->host_type == BBU_HOST) ? "BBU": "RRH")); - device->Mod_id = num_devices_eth++; - device->transp_type = ETHERNET_TP; - device->trx_start_func = trx_eth_start; - device->trx_request_func = trx_eth_request; - device->trx_reply_func = trx_eth_reply; - device->trx_get_stats_func = trx_eth_get_stats; - device->trx_reset_stats_func = trx_eth_reset_stats; - device->trx_end_func = trx_eth_end; - device->trx_stop_func = trx_eth_stop; - device->trx_set_freq_func = trx_eth_set_freq; - device->trx_set_gains_func = trx_eth_set_gains; - - if (eth->flags == ETH_RAW_MODE) { - device->trx_write_func = trx_eth_write_raw; - device->trx_read_func = trx_eth_read_raw; - } else if (eth->flags == ETH_UDP_MODE) { - device->trx_write_func = trx_eth_write_udp; - device->trx_read_func = trx_eth_read_udp; - } else if (eth->flags == ETH_RAW_IF4p5_MODE) { - device->trx_write_func = trx_eth_write_raw_IF4p5; - device->trx_read_func = trx_eth_read_raw_IF4p5; - } else if (eth->flags == ETH_UDP_IF4p5_MODE) { - device->trx_write_func = trx_eth_write_udp_IF4p5; - device->trx_read_func = trx_eth_read_udp_IF4p5; - } else if (eth->flags == ETH_RAW_IF5_MOBIPASS) { - device->trx_write_func = trx_eth_write_raw_IF4p5; - device->trx_read_func = trx_eth_read_raw_IF4p5; + break; + + case RING_PAR: + ret=snprintf(system_cmd,sizeof(system_cmd),"ethtool -G %s val %d",eth->if_name,value); + if (ret > 0) { + ret=system(system_cmd); + if (ret == -1) { + fprintf (stderr,"[ETHERNET] Can't start shell to execute %s %s",system_cmd, strerror(errno)); + } else { + printf ("[ETHERNET] status of %s is %i\n",WEXITSTATUS(ret)); + } + printf("[ETHERNET] Ring parameters %s\n",system_cmd); } else { - //device->trx_write_func = trx_eth_write_udp_IF4p5; - //device->trx_read_func = trx_eth_read_udp_IF4p5; + perror("[ETHERNET] Can't set ring parameters\n"); } + break; - eth->if_name[device->Mod_id] = eth_params->local_if_name; - device->priv = eth; + default: + break; + } + + return 0; +} - /* device specific */ - openair0_cfg[0].iq_rxrescale = 15;//rescale iqs - openair0_cfg[0].iq_txshift = eth_params->iq_txshift;// shift - openair0_cfg[0].tx_sample_advance = eth_params->tx_sample_advance; - /* RRH does not have any information to make this configuration atm */ - if (device->host_type == BBU_HOST) { - /*Note scheduling advance values valid only for case 7680000 */ - switch ((int)openair0_cfg[0].sample_rate) { - case 30720000: - openair0_cfg[0].samples_per_packet = 3840; - break; - case 23040000: - openair0_cfg[0].samples_per_packet = 2880; - break; - case 15360000: - openair0_cfg[0].samples_per_packet = 1920; - break; - case 7680000: - openair0_cfg[0].samples_per_packet = 960; - break; - case 1920000: - openair0_cfg[0].samples_per_packet = 240; - break; - default: - printf("Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate); - exit(-1); - break; - } - } +int transport_init(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t * eth_params ) { - device->openair0_cfg=&openair0_cfg[0]; - return 0; + eth_state_t *eth = (eth_state_t*)malloc(sizeof(eth_state_t)); + memset(eth, 0, sizeof(eth_state_t)); + + if (eth_params->transp_preference == 1) { + eth->flags = ETH_RAW_MODE; + } else if (eth_params->transp_preference == 0) { + eth->flags = ETH_UDP_MODE; + } else if (eth_params->transp_preference == 3) { + eth->flags = ETH_RAW_IF4p5_MODE; + } else if (eth_params->transp_preference == 2) { + eth->flags = ETH_UDP_IF4p5_MODE; + } else if (eth_params->transp_preference == 4) { + eth->flags = ETH_RAW_IF5_MOBIPASS; + } else { + printf("transport_init: Unknown transport preference %d - default to RAW", eth_params->transp_preference); + eth->flags = ETH_RAW_MODE; + } + + printf("[ETHERNET]: Initializing openair0_device for %s ...\n", ((device->host_type == BBU_HOST) ? "BBU": "RRH")); + device->Mod_id = 0;//num_devices_eth++; + device->transp_type = ETHERNET_TP; + device->trx_start_func = trx_eth_start; + device->trx_request_func = trx_eth_request; + device->trx_reply_func = trx_eth_reply; + device->trx_get_stats_func = trx_eth_get_stats; + device->trx_reset_stats_func = trx_eth_reset_stats; + device->trx_end_func = trx_eth_end; + device->trx_stop_func = trx_eth_stop; + device->trx_set_freq_func = trx_eth_set_freq; + device->trx_set_gains_func = trx_eth_set_gains; + + if (eth->flags == ETH_RAW_MODE) { + device->trx_write_func = trx_eth_write_raw; + device->trx_read_func = trx_eth_read_raw; + } else if (eth->flags == ETH_UDP_MODE) { + device->trx_write_func = trx_eth_write_udp; + device->trx_read_func = trx_eth_read_udp; + } else if (eth->flags == ETH_RAW_IF4p5_MODE) { + device->trx_write_func = trx_eth_write_raw_IF4p5; + device->trx_read_func = trx_eth_read_raw_IF4p5; + } else if (eth->flags == ETH_UDP_IF4p5_MODE) { + device->trx_write_func = trx_eth_write_udp_IF4p5; + device->trx_read_func = trx_eth_read_udp_IF4p5; + } else if (eth->flags == ETH_RAW_IF5_MOBIPASS) { + device->trx_write_func = trx_eth_write_raw_IF4p5; + device->trx_read_func = trx_eth_read_raw_IF5_mobipass; + } else { + //device->trx_write_func = trx_eth_write_udp_IF4p5; + //device->trx_read_func = trx_eth_read_udp_IF4p5; + } + + eth->if_name = eth_params->local_if_name; + device->priv = eth; + + /* device specific */ + openair0_cfg[0].iq_rxrescale = 15;//rescale iqs + openair0_cfg[0].iq_txshift = eth_params->iq_txshift;// shift + openair0_cfg[0].tx_sample_advance = eth_params->tx_sample_advance; + + /* RRH does not have any information to make this configuration atm */ + if (device->host_type == BBU_HOST) { + /*Note scheduling advance values valid only for case 7680000 */ + switch ((int)openair0_cfg[0].sample_rate) { + case 30720000: + openair0_cfg[0].samples_per_packet = 3840; + break; + case 23040000: + openair0_cfg[0].samples_per_packet = 2880; + break; + case 15360000: + openair0_cfg[0].samples_per_packet = 1920; + break; + case 7680000: + openair0_cfg[0].samples_per_packet = 960; + break; + case 1920000: + openair0_cfg[0].samples_per_packet = 240; + break; + default: + printf("Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate); + exit(-1); + break; + } + } + device->openair0_cfg=&openair0_cfg[0]; + return 0; } diff --git a/targets/ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.h b/targets/ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.h index c23528196858821027245a42672a0a6db3ca25df..9f555beaa9dea29bc862ed5a54953051eff09496 100644 --- a/targets/ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.h +++ b/targets/ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.h @@ -55,11 +55,23 @@ typedef struct { /*!\brief socket file desc */ - int sockfd[MAX_INST]; + int sockfd; /*!\brief interface name */ - char *if_name[MAX_INST]; + char *if_name; /*!\brief buffer size */ unsigned int buffer_size; + /*!\brief destination address for UDP socket*/ + struct sockaddr_in dest_addr; + /*!\brief local address for UDP socket*/ + struct sockaddr_in local_addr; + /*!\brief address length for both UDP and RAW socket*/ + int addr_len; + /*!\brief destination address for RAW socket*/ + struct sockaddr_ll dest_addr_ll; + /*!\brief local address for RAW socket*/ + struct sockaddr_ll local_addr_ll; + /*!\brief inteface index for RAW socket*/ + struct ifreq if_index; /*!\brief timeout ms */ unsigned int rx_timeout_ms; /*!\brief timeout ms */ @@ -218,6 +230,7 @@ int trx_eth_write_raw(openair0_device *device, openair0_timestamp timestamp, voi int trx_eth_read_raw(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc); int trx_eth_write_raw_IF4p5(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps,int cc, int flags); int trx_eth_read_raw_IF4p5(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc); +int trx_eth_read_raw_IF5_mobipass(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc); int trx_eth_write_udp_IF4p5(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps,int cc, int flags); int trx_eth_read_udp_IF4p5(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc); int eth_get_dev_conf_raw(openair0_device *device); diff --git a/targets/ARCH/ETHERNET/USERSPACE/LIB/if_defs.h b/targets/ARCH/ETHERNET/USERSPACE/LIB/if_defs.h index e96282a7113ef4c6d9ccee73cd0182b1386b3334..5fdb962b09019470b6f5840f5bbacd890df1b2ee 100644 --- a/targets/ARCH/ETHERNET/USERSPACE/LIB/if_defs.h +++ b/targets/ARCH/ETHERNET/USERSPACE/LIB/if_defs.h @@ -56,15 +56,19 @@ // Packet sizes for IF4p5 interface format #define DATA_BLOCK_SIZE_BYTES(scaled_nblocks) (sizeof(uint16_t)*scaled_nblocks) -#define PRACH_BLOCK_SIZE_BYTES (sizeof(int16_t)*839*2) // FIX hard coded prach size (uncompressed) +#define PRACH_HARD_CODED_NUM_SAMPLES (839*2) +#define PRACH_BLOCK_SIZE_BYTES (sizeof(int16_t)*PRACH_HARD_CODED_NUM_SAMPLES) // FIX hard coded prach size #define RAW_IF4p5_PDLFFT_SIZE_BYTES(nblocks) (MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t + DATA_BLOCK_SIZE_BYTES(nblocks)) #define RAW_IF4p5_PULFFT_SIZE_BYTES(nblocks) (MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t + DATA_BLOCK_SIZE_BYTES(nblocks)) +#define RAW_IF4p5_PULTICK_SIZE_BYTES (MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t) #define RAW_IF4p5_PRACH_SIZE_BYTES (MAC_HEADER_SIZE_BYTES + sizeof_IF4p5_header_t + PRACH_BLOCK_SIZE_BYTES) #define UDP_IF4p5_PDLFFT_SIZE_BYTES(nblocks) (sizeof_IF4p5_header_t + DATA_BLOCK_SIZE_BYTES(nblocks)) #define UDP_IF4p5_PULFFT_SIZE_BYTES(nblocks) (sizeof_IF4p5_header_t + DATA_BLOCK_SIZE_BYTES(nblocks)) +#define UDP_IF4p5_PULTICK_SIZE_BYTES (sizeof_IF4p5_header_t) #define UDP_IF4p5_PRACH_SIZE_BYTES (sizeof_IF4p5_header_t + PRACH_BLOCK_SIZE_BYTES) // Mobipass packet sizes #define RAW_IF5_MOBIPASS_BLOCK_SIZE_BYTES 1280 #define RAW_IF5_MOBIPASS_SIZE_BYTES (MAC_HEADER_SIZE_BYTES + sizeof_IF5_mobipass_header_t + RAW_IF5_MOBIPASS_BLOCK_SIZE_BYTES) +#define PAYLOAD_MOBIPASS_NUM_SAMPLES 640 diff --git a/targets/ARCH/EXMIMO/BITSTREAM/exmimo2_prom.cfi b/targets/ARCH/EXMIMO/BITSTREAM/exmimo2_prom.cfi index a4f200dfc2f3c3d07c9f9252d037c7a9d26afbe5..f49f521e9147ee76d327c907335c124ee95fb3f8 100644 --- a/targets/ARCH/EXMIMO/BITSTREAM/exmimo2_prom.cfi +++ b/targets/ARCH/EXMIMO/BITSTREAM/exmimo2_prom.cfi @@ -1,11 +1,11 @@ -# PROMGEN: Xilinx Prom Generator P.20131013 -# Copyright (c) 1995-2013 Xilinx, Inc. All rights reserved. +# PROMGEN: Xilinx Prom Generator O.76xd +# Copyright (c) 1995-2011 Xilinx, Inc. All rights reserved. -SOFTWARE_VERSION P.20131013 -DATE 6/16/2015 - 16:10 -SOURCE /homes/maatalla/openair/openair0/express-mimo2/backup_houssem/express-mimo2/grlib-gpl-1.1.0-b4113/designs/express-mimo2/exmimo2_prom.mcs +SOFTWARE_VERSION O.76xd +DATE 1/ 3/2017 - 11:49 +SOURCE /homes/kaltenbe/Devel/openair/openairinterface5g/targets/ARCH/EXMIMO/BITSTREAM/exmimo2_prom.mcs DEVICE 8192K DATA_WIDTH 4 FILL_DATA 0xFF -SIGNATURE 0x41521D58 +SIGNATURE 0x416AB633 START_ADDRESS 0x00000000 END_ADDRESS 0x00406577 DIRECTION_UP "express-mimo2.bit" 6slx150tfgg900 diff --git a/targets/ARCH/EXMIMO/BITSTREAM/exmimo2_prom.mcs b/targets/ARCH/EXMIMO/BITSTREAM/exmimo2_prom.mcs index 8cbd9481a37483452b8f077384991f647de6876f..8bc7817f0989d315639b5ebc196c15baef1bb46a 100644 --- a/targets/ARCH/EXMIMO/BITSTREAM/exmimo2_prom.mcs +++ b/targets/ARCH/EXMIMO/BITSTREAM/exmimo2_prom.mcs @@ -17,8 +17,8 @@ :1000F0000000000000000000000000000000000000 :1001000000000000000000000000000000000000EF :1001100000000000000000000000000000000000DF -:1001200000000000000000000000000000000201CC -:1001300000000000000000000000000000000000BF +:10012000000000000000000000000000000082014C +:1001300000008001004000000000000000000000FE :1001400000000000000000000000000000000000AF :10015000000000000000000000000000000000009F :10016000000000000000000000000000000000008F @@ -26,7 +26,7 @@ :10018000000000000000000000000000000000006F :10019000000000000000000000000000000000005F :1001A000000000000000000000000000000000004F -:1001B000208200000000000000000000000000009D +:1001B00000920000000000000000000000000000AD :1001C000000000000000000000000000000000002F :1001D000000000000000000000000000000000001F :1001E000000000000000000000000000000000000F @@ -34,7 +34,7 @@ :1002000000000000000000000000000000000000EE :1002100000000000000000000000000000000000DE :1002200000000000000000000000000000000000CE -:1002300000000800000000000000000000000000B6 +:100230000000080000000000002000000000000096 :1002400000000000000000000000000000000000AE :10025000000000000000000000000000000000009E :10026000000000000000000000000000000000008E @@ -43,12 +43,12 @@ :10029000000000000000000000000000000000005E :1002A000000000000000000000000000000000004E :1002B000000000000000000000000000000000003E -:1002C0000000000000000000080B03000000000018 +:1002C0002800000000000000080B030000000000F0 :1002D000000000000000000000000000000000001E :1002E000000000000000000000000000000000000E -:1002F00000000000000000000000000000000000FE -:10030000200020000000000020000000200000006D -:1003100020000000000000000000000000000000BD +:1002F00000000000000000000000200000000000DE +:10030000000020002000000000000000200000008D +:1003100000000000000000000000000000000000DD :1003200000000000000000000000000000000000CD :1003300000000000000000000000000000000000BD :1003400000000000000000000000000000000000AD @@ -63,9 +63,9 @@ :1003D000000000000000000000000000000000001D :1003E000000000000000000000000000000000000D :1003F00000000000000000000000000000000000FD -:1004000000000000000010020000000000000000DA +:1004000000000000000040080000000000000000A4 :1004100000000000000000000000000000000000DC -:1004200000000000000000000000000000001002BA +:100420000000000000000000000000000000400884 :1004300000000000000000000000000000000000BC :1004400000000000000000000000000000000000AC :10045000100200000000000000000000000000008A @@ -82,7 +82,7 @@ :1005000000000000000000000000000000000000EB :1005100000000000000000000000000000000000DB :1005200000000000000000000000000000000000CB -:1005300000000000000000000000000000000000BB +:1005300000000000000000000000000000030000B8 :1005400000000000000000000000000000000000AB :10055000000000000000000000000000000000009B :10056000000000000000000000000000000000008B @@ -95,10 +95,10 @@ :1005D000000000000000000000000000000000001B :1005E000000000000000000000000000000000000B :1005F00000000000000000000000000000000000FB -:10060000000000000000000000000000C00000002A -:100610000000000000008400000000000000000056 -:1006200000000000000000000000000000000000CA -:100630000000C0000800A000000000000000000052 +:1006000000000000000000000000000000000000EA +:1006100000000000000000000000000000000000DA +:100620000000000000000000000000000000A0002A +:10063000A00000000000A000A000000000000000DA :1006400000000000000000000000000000000000AA :10065000000000000000000000000000000000009A :10066000000000000000000000000000000000008A @@ -111,10 +111,10 @@ :1006D000000000000000000000000000000000001A :1006E000000000000000000000000000000000000A :1006F00000000000000000000000000000000000FA -:1007000000000000000000000000080000000000E1 -:100710000000000000000000000000000000900049 -:100720008200000000000000000000000000000047 -:1007300008000000000000000000000000000000B1 +:1007000000000000000000000000000000000000E9 +:1007100000000000000000000800000000000000D1 +:1007200000000000000004000011000000000004B0 +:1007300000000000000000000000000000000000B9 :1007400000000000000000000000000000000000A9 :100750000000000000000000000000000000000099 :100760000000000000000000000000000000000089 @@ -123,15 +123,15 @@ :100790000000000000000000000000000000000059 :1007A0000000000000000000000000000000000049 :1007B0000000000000000000000000000000000039 -:1007C0000000080000000000000000000000000021 +:1007C0000000000000000000000000000000000029 :1007D0000000000000000000000000000000000019 :1007E0000000000000000000000000000000000009 :1007F00000000000000000000000000000000000F9 :1008000000000000000000000000000000000000E8 -:1008100000000000000000000000000000000000D8 -:1008200008000000000008000000000000000000B8 -:1008300000000000000008000000000000000000B0 -:1008400008000000000000000000000000000000A0 +:1008100000000000000000000000000000000800D0 +:100820000800C0000000A000000000000000080058 +:10083000C0000000000008000800000000000000E8 +:10084000080000000000820000000000000000001E :100850000000000000000000000000000000000098 :100860000000000000000000000000000000000088 :100870000000000000000000000000000000000078 @@ -148,31 +148,31 @@ :1009200000000000000000000000000000000000C7 :1009300000000000000000000000000000000000B7 :1009400000000000000000000000000000000000A7 -:100950004000000000000000000000000000000057 +:100950000000000000000000000000000000000097 :100960000000000000000000000000000000000087 :100970000000000000000000000000000000000077 :100980000000000000000000000000000000000067 :100990000000000000000000000000000000000057 :1009A0000000000000000000000000000000000047 :1009B0000000000000000000000000000000000037 -:1009C0000000000000000000000000000000000324 +:1009C0000000000000000000000000000000000027 :1009D0000000000000000000000000000000000017 :1009E0000000000000000000000000000000000007 :1009F00000000000000000000000000000000000F7 :100A000000000000000000000000000000000000E6 :100A100000000000000000000000000000000000D6 :100A200000000000000000000000000000000000C6 -:100A30008000800000000040000000000000000076 +:100A300080008000000000110000000000000000A5 :100A400000000000000000000000000000000000A6 -:100A50000000000080000000000300000000000013 +:100A50000000000080000000000500000000000011 :100A60000000000000000000000000000000000086 :100A70000000000000000000000000000000000076 :100A80000000000000000000000000000000000066 :100A90000000000000000000000000000000000056 :100AA0000000000000000000000000000000000046 -:100AB0000000020002000000000000000000000032 +:100AB0000000100004000000000000000000000022 :100AC0000000000000000000000000000000000026 -:100AD00000000000C0008200000000410000000093 +:100AD0000000000040008200000000400000000014 :100AE0000000000000000000000000000000000006 :100AF00000000000000000000000000000000000F6 :100B000000000000000000000000000000000000E5 @@ -196,8 +196,8 @@ :100C200000000000000000000000000000000000C4 :100C300000000000000000000005000000000500AA :100C400000000000000000000000000000000000A4 -:100C5000000000000000000000020005004000004D -:100C60000300000000000000000000000000000081 +:100C5000000000000000000000020005000000008D +:100C60004000000000000000000000000000000044 :100C70000000000000000000000000000000000074 :100C80000000000000000000000000000000000064 :100C90000000000000000000000000000000000054 @@ -205,15 +205,15 @@ :100CB0000000000000000000000000000000000034 :100CC0000000000000000000000000000000000024 :100CD0000000000000000000000000000000000014 -:100CE0000000010000000000000000000000000003 +:100CE0000000000000000000000000000000000004 :100CF00000000000000000000000000000000000F4 :100D000000000000000000000000000000000000E3 :100D100000000000000000000000000000000000D3 :100D200000000000000000000000000000000000C3 -:100D30000000000000000000000000008181005061 -:100D40000A00900900000000000000000000000000 +:100D30000000000000000000000000008181009021 +:100D40000900C8430000000000000000000000008F :100D50000000000000000000000000000000818191 -:100D600000500A0090090000000000000000000090 +:100D600000900900C84300000000000000000000DF :100D70000000000000000000000000000000000073 :100D80000000000000000000000000000000000063 :100D90000000000000000000000000000000000053 @@ -235,17 +235,17 @@ :100E90000000000000000000000000000000000052 :100EA0000000000000000000000002000000000040 :100EB00000400000000000000000000000000000F2 -:100EC00000000040032004C00200000000000000F9 +:100EC00000000040030810C0020000000000000005 :100ED00000000200000000000040000000000000D0 -:100EE000000000000040032004C0020000000000D9 +:100EE000000000000040030810C0020000000000E5 :100EF00000000000020000000000004000000000B0 :100F000000000000000000000000000000000000E1 :100F10000000004000000000000000000000000091 :100F20000000310000000000000000000000000090 :100F300000000000000000000000000000000000B1 -:100F40000000000008020020040040100000000023 +:100F4000000000000802000810004010000000002F :100F50000000000000000000000000000000000091 -:100F60000000000000000802002004004010000003 +:100F6000000000000000080200081000401000000F :100F70000000000000000000000000000000000071 :100F80000000000000000000000000000000000061 :100F90000000000000000000000000000000000051 @@ -331,7 +331,7 @@ :10149000000000000000000000000000000000004C :1014A000000000000000000000000000000000003C :1014B000000000000000000000000000000000002C -:1014C0000000000000000000080000000000000014 +:1014C000000000000000000000000000000000001C :1014D000000000000000000000000000000000000C :1014E00000000000000000000000000000000000FC :1014F00000000000000000000000000000000000EC @@ -364,8 +364,8 @@ :1016A000000000000000000000000000000000003A :1016B000000000000000000000000000000000002A :1016C000000000000000000000000000000000001A -:1016D0000000000000000000000000000004000006 -:1016E00000000000000000000000000000000000FA +:1016D000000000000000000000000000000000000A +:1016E00000000000000009000000000000000000F1 :1016F00000000000000000000000000000000000EA :1017000000000000000000000000000000000000D9 :1017100000000000000000000000000000000000C9 @@ -443,7 +443,7 @@ :101B90000000000000020000000000000000000043 :101BA0000000000000000000000000000000000035 :101BB0000000000000000000000000000000000025 -:101BC0000000000000000000000000000000000015 +:101BC0000000000000000000000000000000001005 :101BD0000000000000000000000000000000000005 :101BE00000000000000000000000000000000000F5 :101BF00000000000000000000000000000000000E5 @@ -452,7 +452,7 @@ :101C200000000000000000000000000000000000B4 :101C300000000000000000000000000000000000A4 :101C40000000000000000000000000000000000094 -:101C50000000000000000000000000000000000084 +:101C50000001000000000000000000000000000083 :101C60000000000000000000000000000000000074 :101C70000000000000000000000000000000000064 :101C80000000000000000000000000000000000054 @@ -460,7 +460,7 @@ :101CA0000000000000000000000000000000000034 :101CB0000000000000000000000000000000000024 :101CC0000000000000000000000000000000000014 -:101CD00000004100000000000007000000000000BC +:101CD000000081000000000000070000000000007C :101CE00000000000000000000000000000000000F4 :101CF00000000000000000000000000000000000E4 :101D000000000000000000000000000000000000D3 @@ -534,11 +534,11 @@ :10214000000000000000000000000000000000008F :10215000000000000000000000000000000000007F :10216000000000000000000000000040000000002F -:10217000000000000000000000000000000000005F +:1021700040000000200000000000000000000000FF :10218000000000000000000000000000000000004F -:10219000000000000000000000000000000000003F +:10219000000000002000000000000000000000001F :1021A000000000000000000000000000000000002F -:1021B000000000000000000000000000000000001F +:1021B00000000000000020000000000000000000FF :1021C000000000000000000000000000000000000F :1021D00000000000000000000000000000000000FF :1021E00000000000000000000000000000000000EF @@ -566,10 +566,10 @@ :10234000000000000000000000000000000000008D :10235000000000000000000000000000000000007D :10236000000000000000000000000000000000006D -:10237000000000000000000000000000000000005D +:102370000000000004000000000000000000000059 :10238000000000000000000000000000000000004D :10239000000000000000000000000000000000003D -:1023A000000000000000000000000000000000002D +:1023A000A00000000000000000000000000000008D :1023B000000000000000000000000000000000001D :1023C000000000000000000000000000000000000D :1023D00000000000000000000000000000000000FD @@ -589,7 +589,7 @@ :1024B000000000000000000000000000000000001C :1024C000000000000000000000000000000000000C :1024D00000000000000000000000000000000000FC -:1024E00000000000000000000000000000000000EC +:1024E00000000800000000000000000000000000E4 :1024F00000000000000000000000000000000000DC :1025000000000000000000000000000000000000CB :1025100000000000000000000000000000000000BB @@ -609,15 +609,15 @@ :1025F00000000000000000000000000000000000DB :1026000000000000000000000000000000000000CA :1026100000000000000000000000000000000000BA -:1026200000000000000000000000000000000000AA +:10262000100000000000000000000000000000009A :10263000000000000000000000000000000000009A :10264000000000000000000000000000000000008A :10265000000000000000000000000000000000007A :10266000000000000000000000000000000000006A -:102670000000000000000000000000000004000056 +:102670000000000000000000030000000000000057 :10268000000000000000000000000000000000004A :10269000000000000000000000000000000000003A -:1026A000000000000000000000000000000000002A +:1026A0000000000008000000000000000000000022 :1026B000000000000000000000000000000000001A :1026C000000000000000000000000000000000000A :1026D00000000000000000000000000000000000FA @@ -818,8 +818,8 @@ :1033000000000000000000000000000000000000BD :1033100000000000000000000000000000000000AD :10332000000000000000000000000000000000009D -:10333000000082000000000000000000000000000B -:103340000000000000000000000000000000040079 +:10333000000000000000000000000000000000008D +:10334000000000000000000000000000000000007D :10335000000000000000000000000000000000006D :10336000000000000000000000000000000000005D :10337000000000000000000000000000000000004D @@ -989,39 +989,39 @@ :103DB0000000000000000000000000000000000003 :103DC00000000000000000000000000000000000F3 :103DD00000000000000000000000000000000000E3 -:103DE00000000000000000000000000000000000D3 -:103DF0000000000020000000000020000000000083 -:103E000000000000000000000000000000000000B2 -:103E10000000000020000000000020000002000060 -:103E20000000000000000000000000000000000092 -:103E30000000000000002000000000002000000042 +:103DE0000000000000000000200000002000000093 +:103DF00000002000000000000000000000000000A3 +:103E00000000000000000000200000002000000072 +:103E10000000200000000000000000000002000080 +:103E20000000000000000000000020000000000072 +:103E30000000000000000000000000000000000082 :103E40000000000000000000000000000000000072 :103E50000000000000000000000000000000000062 :103E60000000000000000000000000000000000052 -:103E70000000000000000000000000000000000042 +:103E700040000000000000000000000000000040C2 :103E80000000000000000000000000000000000032 :103E90000000000000000000000000000000000022 :103EA0000000000000000000000000000000000012 :103EB0000000000000000000000000000000000002 :103EC00000000000000000000000000000000000F2 :103ED00000000000000000000000000000000000E2 -:103EE0000000000000000000000000000000004092 -:103EF00000000000000000000000000000000000C2 +:103EE00000000000000000000000000000000200D0 +:103EF00000000000000008000000000000000000BA :103F000000000000000000000000000000000000B1 -:103F10000000000000000040000000000000000061 +:103F1000000000000000021000000000000000008F :103F20000000000000000000000000000000000091 -:103F30000000000000000000004000000000000041 +:103F3000000000000000000002000000000000007F :103F40000000000000000000000000000000000071 -:103F50000040000000000000000000000000000021 +:103F5000020000000000000000000000000000005F :103F60000000000000000000000000000000000051 -:103F70000000000000000000001000000000000031 +:103F70000000000000000000000000000000000041 :103F80000000000000000000000000000000000031 -:103F90000000000000000000001000000000000011 +:103F90000000000000000000000000000000000021 :103FA0000000000000000000000000000000000011 :103FB0000000000000000000000000000000000001 :103FC00000000000000000000000000000000000F1 :103FD00000000000000000000000000000000000E1 -:103FE00000000000000000000000000000000000D1 +:103FE00000000000000000000000000000200000B1 :103FF00000000000000000000000000000000000C1 :1040000000000000000000000000000000000000B0 :1040100000000000000000000000000000000000A0 @@ -1029,7 +1029,7 @@ :104030000000000000000000000000000000000080 :104040000000000000000000000000000000000070 :104050000000000000000000000000000000000060 -:1040600000000000C0000000000000000000000090 +:104060000000000000000000000000000000000050 :104070000000000000000000000000000000000040 :104080000000000000000000000000000000000030 :104090000000000000000000000000000000000020 @@ -1043,15 +1043,15 @@ :10411000000000000000000000000000000000009F :10412000000000000000000000000000000000008F :10413000000000000000000000000000000000007F -:1041400000000000000000000000840000000000EB -:10415000000000000000000000000000000000005F -:104160000000000000000000080000000000000047 +:104140000000A000000000000000000000000000CF +:104150000000000000000800000000000000000057 +:10416000000000000000000000000000000000004F :10417000000000000000000000000000000000003F -:104180000008000000000000000000000000000027 +:10418000000000000000000000000000000000002F :10419000000000000000000000000000000000001F :1041A000000000000000000000000000000000000F :1041B00000000000000000000000000000000000FF -:1041C00000000000000000000000000000000000EF +:1041C00000000800000000000000000000000000E7 :1041D00000000000000000000000000000000000DF :1041E00000000000000000000000000000000000CF :1041F00000000000000000000000000000000000BF @@ -1060,8 +1060,8 @@ :10422000000000000000000000000000000000008E :10423000000000000000000000000000000000007E :1042400000000000000000000000000