Merge branch 'integration_2024_w23' into 'develop'

Integration: `2024.w23`

See merge request oai/openairinterface5g!2788

* !2510 NR UE MAC UCI on PUSCH and aperiodic CSI reporting
* !2597 LTTng logger (CTF)
* !2751 synch the USRP time accross devices using the host clock
* !2775 Remove some global variables
* !2779 remove rb_mask_ul from permanent storage for stack local usage
* !2782 USRP: add a T trace to record the RX IQ data on antenna 0
* !2783 build_oai: fix bad options' names
* !2753 Pucch power control

CMakeLists.txt

@@ -284,6 +284,7 @@ add_boolean_option(DEBUG_ASN1 False "Enable ASN1 debug logs" OFF)
 # see common/utils/config.h
 add_boolean_option(TRACE_ASN1C_ENC_DEC OFF "Enable ASN1 encoder/decoder debug traces via OAI logging system" ON)
 add_boolean_option(T_TRACER            True  "Activate the T tracer, a debugging/monitoring framework" ON)
+add_boolean_option(ENABLE_LTTNG        False "Activate the LTTNG tracer, a debugging/monitoring framework" ON)
 add_boolean_option(UE_AUTOTEST_TRACE   False "Activate UE autotest specific logs" ON)
 add_boolean_option(UE_DEBUG_TRACE      False "Activate UE debug trace" ON)
 add_boolean_option(UE_TIMING_TRACE     False "Activate UE timing trace" ON)
@@ -659,6 +660,14 @@ add_library(UTIL
   ${OPENAIR_DIR}/common/utils/time_meas.c
   ${OPENAIR_DIR}/common/utils/time_stat.c
 )
+if (ENABLE_LTTNG)
+  find_package(LTTngUST 2.3.8 EXACT REQUIRED)
+  target_sources(UTIL PRIVATE common/utils/LOG/lttng-tp.c)
+  target_link_libraries(UTIL PUBLIC lttng-ust)
+else()
+  message(STATUS "LTTNG support disabled")
+endif()
+
 pkg_check_modules(cap libcap)
 if (cap_FOUND)
   # see system.c for more info

cmake_targets/build_oai

@@ -124,6 +124,8 @@ Options:
 --disable-cpu-affinity
    Disables CPU Affinity between UHD/TX/RX Threads (Valid only when deadline scheduler is disabled). By defaulT, CPU Affinity is enabled when not using deadline scheduler. It is enabled only with >2 CPUs. For eNB, CPU_0-> Device library (UHD), CPU_1->TX Threads, CPU_2...CPU_MAX->Rx Threads. For UE, CPU_0->Device Library(UHD), CPU_1..CPU_MAX -> All the UE threads
 --enable-cpu-affinity
+--enable-LTTNG
+   Enable LTTNG log. While lttng is enabled, T-Tracer will be disabled
 --disable-T-Tracer
    Disables the T tracer.
 --disable-hardware-dependency
@@ -353,6 +355,11 @@ function main() {
            BUILD_DOXYGEN=1
            echo_info "Will build doxygen support"
            shift;;     
+       --enable-LTTNG)
+            CMAKE_CMD="$CMAKE_CMD -DENABLE_LTTNG=ON -DT_TRACER=OFF"
+            echo_info "Enable LTTNG tracer"
+            USE_LTTNG=1
+            shift 1;;
        --disable-T-Tracer)
             CMAKE_CMD="$CMAKE_CMD -DT_TRACER=False"
             echo_info "Disabling the T tracer"
@@ -414,19 +421,19 @@ function main() {
             grep -sq "Ubuntu 18.04" /etc/os-release && echo_error "Bug in OS with this option, see CMakeLists.txt"
             CMAKE_CMD="$CMAKE_CMD -DSANITIZE_ADDRESS=True"
             shift;;
-        --sanitize-undefined | -fundefined=address)
+        --sanitize-undefined | -fsanitize=undefined)
             CMAKE_CMD="$CMAKE_CMD -DSANITIZE_UNDEFINED=True"
             shift;;
         --sanitize-memory | -fsanitize=memory)
             CMAKE_CMD="$CMAKE_CMD -DSANITIZE_MEMORY=ON -DSANITIZE_ADDRESS=OFF -DSANITIZE_UNDEFINED=OFF"
             shift;;
+        --sanitize-thread | -fsanitize=thread)
+            CMAKE_CMD="$CMAKE_CMD -DSANITIZE_THREAD=True"
+            shift;;
        --trace-asn1c-enc-dec)
             CMAKE_CMD="$CMAKE_CMD -DTRACE_ASN1C_ENC_DEC=ON"
             echo_info "Enabling asn1c internal traces via OAI logging system"
             shift 1;;
-        --sanitize-thread | -fthread=address)
-            CMAKE_CMD="$CMAKE_CMD -DSANITIZE_THREAD=True"
-            shift;;
         -h | --help)
             print_help
             exit 1;;
@@ -454,6 +461,10 @@ function main() {
   if [ "$INSTALL_EXTERNAL" = "1" ] ; then
     echo_info "Installing packages"
     check_install_oai_software
+    if [ "$USE_LTTNG" = "1" ] ; then
+      echo_info "installing LTTng"
+      install_lttng $1
+    fi
     if [ "$HW" == "OAI_USRP" ] ; then
       echo_info "installing packages for USRP support"
       check_install_usrp_uhd_driver

cmake_targets/tools/build_helper

@@ -704,6 +704,97 @@ install_simde_from_source(){
     $SUDO \cp -rv ../simde /usr/include
 }
 
+install_lttng() {
+    if [[ "$OS_DISTRO" != "ubuntu" ]]; then
+      echo_info "LTTng is supported only for ubuntu at the moment."
+      echo_info $distribution
+      return
+    fi
+
+    set +e
+    $SUDO apt-add-repository ppa:lttng/stable-2.13 -y && apt-get update
+    $SUDO apt-get install -y lttng-tools lttng-modules-dkms liblttng-ust-dev
+    if [[ $? > 0 ]]; then
+      echo "Failed to install LTTng using apt. Installing from source"
+      install_lttng_deps
+      install_lttng_from_source
+    fi
+    set -e
+}
+
+install_lttng_deps() {
+  echo "installing dependencies of LTTng"
+  $SUDO apt-get install uuid-dev libxml2-dev -y
+}
+
+install_lttng_from_source() {
+    echo "installing LTTng from source"
+    install_popt_1_18_from_source
+    install_userspace_rcu
+    install_lttng_ust_2_13_from_source
+    install_lttng_tools_2_13_from_source
+}
+
+install_popt_1_18_from_source() {
+  $SUDO $INSTALLER -y install wget
+  echo_info "\nInstalling popt_1_18."
+  cd $(mktemp -d) &&
+  wget http://ftp.rpm.org/popt/releases/popt-1.x/popt-1.18.tar.gz
+  tar -xf popt-1.18.tar.gz && cd popt-1.18
+  ./configure && make -j16 && $SUDO make install
+}
+
+install_userspace_rcu() {
+    echo_info "\nInstalling U-RCU from source."
+    cd /tmp
+    $SUDO rm -rf /tmp/urcu
+    git clone https://github.com/urcu/userspace-rcu.git /tmp/urcu
+    cd /tmp/urcu
+    git checkout stable-0.12
+    ./bootstrap && ./configure && make
+    $SUDO make install
+    $SUDO ldconfig
+}
+
+
+install_lttng_modules_2_13_from_source() {
+    $SUDO $INSTALLER -y install wget
+    echo_info "\nInstalling LTTng Modules."
+    cd $(mktemp -d) &&
+    wget https://lttng.org/files/lttng-modules/lttng-modules-latest-2.13.tar.bz2 &&
+    tar -xf lttng-modules-latest-2.13.tar.bz2 &&
+    cd lttng-modules-2.13.* &&
+    make &&
+    $SUDO make modules_install &&
+    $SUDO depmod -a
+}
+
+install_lttng_ust_2_13_from_source() {
+    $SUDO $INSTALLER -y install wget
+    echo_info "\nInstalling LTTng UST."
+    cd $(mktemp -d) &&
+    wget https://lttng.org/files/lttng-ust/lttng-ust-latest-2.13.tar.bz2 &&
+    tar -xf lttng-ust-latest-2.13.tar.bz2 &&
+    cd lttng-ust-2.13.* &&
+    ./configure --disable-numa &&
+    make &&
+    $SUDO make install &&
+    $SUDO ldconfig
+}
+
+install_lttng_tools_2_13_from_source() {
+    $SUDO $INSTALLER -y install wget
+    echo_info "\nInstalling LTTng Tools."
+    cd $(mktemp -d) &&
+    wget https://lttng.org/files/lttng-tools/lttng-tools-latest-2.13.tar.bz2 &&
+    tar -xf lttng-tools-latest-2.13.tar.bz2 &&
+    cd lttng-tools-2.13.* &&
+    ./configure &&
+    make &&
+    $SUDO make install &&
+    $SUDO ldconfig
+}
+
 #################################################
 # 2. compile
 ################################################

common/utils/LOG/DOC/log.md

@@ -15,5 +15,6 @@ By default, this facility is included at build-time and activated at run-time. T
 * [runtime usage](rtusage.md)
 * [developer usage](devusage.md)
 * [module architecture](arch.md)
+* [lttng usage](lttng_logs.md)
 
 [oai Wikis home](https://gitlab.eurecom.fr/oai/openairinterface5g/wikis/home)

common/utils/LOG/DOC/lttng_logs.md

+# OAI gNB LTTng Tracing Setup Guide
+
+## Overview
+
+This guide will walk you through setting up tracing for an OpenAirInterface (OAI) gNB (gNodeB) using LTTng (Linux Trace Toolkit Next Generation) and Babeltrace.
+### What is LTTng and Why Use It?
+
+LTTng, or Linux Trace Toolkit Next Generation, is a powerful logging framework designed for Linux systems. It provides low-overhead tracing capabilities, allowing developers to monitor and analyze system behavior in real-time without significant performance impact. LTTng offers several advantages:
+
+- **Low Overhead**: LTTng introduces minimal overhead to the system, making it suitable for use in production environments without affecting system performance.
+
+- **Customizable**: LTTng allows users to define custom tracepoints in their applications, providing fine-grained control over what events to trace and collect.
+
+- **Scalability**: It can scale to large distributed systems, making it suitable for tracing complex software stacks across multiple nodes.
+
+## Prerequisites
+
+- Ubuntu system
+
+Note: only LTTng 2.3.8 is supported.
+
+## Building OAI gNB
+
+1. **Clean and Build OAI gNB with LTTng:**
+
+    1.1  Install Dependencies
+
+    ```bash
+    ./build_oai --ninja -I --clean --enable-LTTNG
+    
+    ```
+    1.2  Build gNB and nrUE
+    ```
+    ./build_oai --ninja --gNB --nrUE -w SIMU --enable-LTTNG
+    ```
+## Setting up LTTng
+
+1. **Start LTTng Session and Relay:**
+
+    ```bash
+    sudo lttng-sessiond -d
+    sudo lttng-relayd -d
+    ```
+
+2. **Create Live LTTng Session:**
+
+    ```bash
+    sudo lttng create my-session --live --set-url=net://127.0.0.1
+    ```
+
+3. **Enable gNB Trace Events:**
+
+    ```bash
+    sudo lttng enable-event --userspace OAI:gNB
+    ```
+
+4. **Start LTTng Tracing:**
+
+    ```bash
+    sudo lttng start
+    ```
+
+## Running the gNB
+
+1. **Run gNB:**
+
+    ```bash
+    ./$binary_path -O $configuration_file PARALLEL_SINGLE_THREAD --rfsimulator.serveraddr server --rfsim --sa -E
+    ```
+
+## Verifying Tracepoints
+
+1. **List Active Tracepoints:**
+
+    ```bash
+    sudo lttng list -u
+    ```
+
+    *Possible Output:*
+
+    ```
+    UST events:
+    -------------
+    
+    PID: 1154722 - Name: /home/firecell/Desktop/FirecellRepos/firecellrd-oai5g-ran/cmake_targets/ran_build/build/nr-softmodem
+          OAI:gNB (loglevel: TRACE_DEBUG_FUNCTION (12)) (type: tracepoint)
+    ```
+
+## Analyzing Traces
+
+1. **Install Babeltrace:**
+
+    ```bash
+    sudo apt-get install babeltrace
+    ```
+
+
+2. **Capture Trace Logs Live:**
+
+    - To learn the full path of the trace session:
+    
+        ```bash
+        babeltrace --input-format=lttng-live net://localhost
+        ```
+
+    - Trace logs using the full path:
+    
+        ```bash
+        babeltrace --input-format=lttng-live net://localhost/host/firecell-XPS-15-9530/my-session
+        ```
+
+    *Possible Output:*
+
+    ```
+    [19:35:32.181608002] (+2.664882127) firecell-XPS-15-9530 OAI:gNB: { cpu_id = 10 }, { MODNAME = "OAI-NR_MAC info", EVENTID = -1, SFN = -1, SLOT = -1, FUNCTION = "gNB_dlsch_ulsch_scheduler", LINE = 246, MSG = "Frame.Slot 0.0\n" }
+    ```
+3. **Capture Trace Logs Offline:**
+
+    - Create an offline trace session with a specified output directory:
+
+        ```bash
+        sudo lttng create offline_session --output=/home/trace_offline/
+        ```
+
+    - Enable gNB trace events:
+
+        ```bash
+        sudo lttng enable-event --userspace OAI:gNB
+        ```
+
+    - Start capturing trace logs:
+
+        ```bash
+        sudo lttng start
+        ```
+
+    - Stop the trace capture:
+
+        ```bash
+        sudo lttng stop
+        ```
+
+    - Destroy the trace session:
+
+        ```bash
+        sudo lttng destroy
+        ```
+
+    - Use Babeltrace to analyze the captured trace logs:
+
+        ```bash
+        sudo babeltrace /home/trace_offline/
+        ```

common/utils/LOG/log.c

@@ -603,6 +603,25 @@ void logRecord_mt(const char *file,
   log_output_memory(c, file,func,line,comp,level,format,args);
   va_end(args);
 }
+#if ENABLE_LTTNG
+void logRecord_lttng(const char *file, const char *func, int line, int comp, int level, const char *format, ...)
+{
+  log_component_t *c = &g_log->log_component[comp];
+  char header[48];
+  char buf[MAX_LOG_TOTAL];
+  va_list args;
+  va_start(args, format);
+  vsnprintf(buf, sizeof(buf) - 1, format, args);
+  va_end(args);
+
+  if (map_int_to_str(log_level_names, level) != NULL)
+    snprintf(header, sizeof(header), "OAI-%s %s", c->name, map_int_to_str(log_level_names, level));
+  else
+    snprintf(header, sizeof(header), "OAI-%s", c->name);
+
+  LOG_FC(header, func, line, buf);
+}
+#endif
 
 void vlogRecord_mt(const char *file,
 		   const char *func,

common/utils/LOG/log.h

@@ -52,6 +52,9 @@
 #endif
 #include <pthread.h>
 #include <common/utils/utils.h>
+#if ENABLE_LTTNG
+#include "lttng-log.h"
+#endif
 /*----------------------------------------------------------------------------*/
 #include <assert.h>
 #ifdef NDEBUG
@@ -234,6 +237,10 @@ void logTerm (void);
 int  isLogInitDone (void);
 void logRecord_mt(const char *file, const char *func, int line,int comp, int level, const char *format, ...) __attribute__ ((format (printf, 6, 7)));
 void vlogRecord_mt(const char *file, const char *func, int line, int comp, int level, const char *format, va_list args );
+#if ENABLE_LTTNG
+void logRecord_lttng(const char *file, const char *func, int line, int comp, int level, const char *format, ...)
+    __attribute__((format(printf, 6, 7)));
+#endif
 void log_dump(int component, void *buffer, int buffsize,int datatype, const char *format, ... );
 int  set_log(int component, int level);
 void set_glog(int level);
@@ -425,9 +432,50 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
 
 /* define variable only used in LOG macro's */
 #define LOG_VAR(A, B) A B
-
-#else /* no T_TRACER */
-
+#else /* T_TRACER */
+#if ENABLE_LTTNG
+#define LOG_E(c, x...)                                                     \
+  do {                                                                     \
+    if (g_log->log_component[c].level >= OAILOG_ERR) {                     \
+      logRecord_lttng(__FILE__, __FUNCTION__, __LINE__, c, OAILOG_ERR, x); \
+    }                                                                      \
+  } while (0)
+#define LOG_W(c, x...)                                                         \
+  do {                                                                         \
+    if (g_log->log_component[c].level >= OAILOG_WARNING) {                     \
+      logRecord_lttng(__FILE__, __FUNCTION__, __LINE__, c, OAILOG_WARNING, x); \
+    }                                                                          \
+  } while (0)
+#define LOG_A(c, x...)                                                          \
+  do {                                                                          \
+    if (g_log->log_component[c].level >= OAILOG_ANALYSIS) {                     \
+      logRecord_lttng(__FILE__, __FUNCTION__, __LINE__, c, OAILOG_ANALYSIS, x); \
+    }                                                                           \
+  } while (0)
+#define LOG_I(c, x...)                                                      \
+  do {                                                                      \
+    if (g_log->log_component[c].level >= OAILOG_INFO) {                     \
+      logRecord_lttng(__FILE__, __FUNCTION__, __LINE__, c, OAILOG_INFO, x); \
+    }                                                                       \
+  } while (0)
+#define LOG_D(c, x...)                                                       \
+  do {                                                                       \
+    if (g_log->log_component[c].level >= OAILOG_DEBUG) {                     \
+      logRecord_lttng(__FILE__, __FUNCTION__, __LINE__, c, OAILOG_DEBUG, x); \
+    }                                                                        \
+  } while (0)
+#define LOG_T(c, x...)                                                       \
+  do {                                                                       \
+    if (g_log->log_component[c].level >= OAILOG_TRACE) {                     \
+      logRecord_lttng(__FILE__, __FUNCTION__, __LINE__, c, OAILOG_TRACE, x); \
+    }                                                                        \
+  } while (0)
+#define LOG_DDUMP(c, b, s, f, x...)                    \
+  do {                                                 \
+    if (g_log->log_component[c].level >= OAILOG_DEBUG) \
+      log_dump(c, b, s, f, x);                         \
+  } while (0)
+#else
 #define LOG_E(c, x...)                                                  \
   do {                                                                  \
     if (g_log->log_component[c].level >= OAILOG_ERR)                    \
@@ -469,6 +517,7 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
     if (g_log->log_component[c].level >= OAILOG_TRACE)                    \
       logRecord_mt(__FILE__, __FUNCTION__, __LINE__, c, OAILOG_TRACE, x); \
   } while (0)
+#endif
 
 #define VLOG(c, l, f, args)                                           \
   do {                                                                \

common/utils/LOG/lttng-log.h

+/*
+ * 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.1  (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 lttng-log.h
+* \brief LTTng Log interface
+* \author Anurag Asokan
+* \date 2024
+* \version 0.5
+* @ingroup util
+
+*/
+
+#ifndef __LTTNG_LOG_H__
+#define __LTTNG_LOG_H__
+#if ENABLE_LTTNG
+#include "lttng-tp.h"
+
+#define LOG_FC(component, func, line, log)                        \
+  do {                                                            \
+    tracepoint(OAI, gNB, component, -1, -1, -1, func, line, log); \
+  } while (0)
+#else
+#define LOG_FC(component, func, line, log)
+#endif
+
+#endif /** __LTTNG_LOG_H__ */

common/utils/LOG/lttng-tp.c

+/*
+ * 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.1  (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 lttng-tp.c
+* \brief Lttng trace implementaion
+* \author Anurag Asokan
+* \date 2024
+* \version 0.5
+* @ingroup util
+
+*/
+//This file is used to define the tracepoints for the lttng tracing.In order to to do linkage with the lttng-tp.h file, we need to define the tracepoints here.
+#define TRACEPOINT_CREATE_PROBES
+#define TRACEPOINT_DEFINE
+
+#include "lttng-tp.h"

common/utils/LOG/lttng-tp.h

+/*
+ * 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.1  (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 lttng-tp.h
+* \brief Lttng tracer implementaion
+* \author Anurag Asokan
+* \date 2024
+* \version 0.5
+* @ingroup util
+
+*/
+
+#ifndef _LTTNG_TP_H
+#define _LTTNG_TP_H
+
+#undef TRACEPOINT_PROVIDER
+#define TRACEPOINT_PROVIDER OAI
+
+#undef TRACEPOINT_INCLUDE
+#define TRACEPOINT_INCLUDE "./common/utils/LOG/lttng-tp.h"
+
+#include <stdbool.h>
+#include <lttng/tracepoint.h>
+
+TRACEPOINT_EVENT(
+    OAI,
+    gNB,
+    TP_ARGS(const char*, log_modName, int, event_id, int, sfn, int, slot, const char*, funcName, int, lineNo, const char*, msg),
+    TP_FIELDS(ctf_string(MODNAME, log_modName) ctf_integer(int32_t, EVENTID, event_id) ctf_integer(int32_t, SFN, sfn)
+                  ctf_integer(int32_t, SLOT, slot) ctf_string(FUNCTION, funcName) ctf_integer(int32_t, LINE, lineNo)
+                      ctf_string(MSG, msg)))
+TRACEPOINT_LOGLEVEL(OAI, gNB, TRACE_DEBUG_FUNCTION)
+
+#endif /* _LTTNG_TP_H */
+
+#include <lttng/tracepoint-event.h>

common/utils/T/T_messages.txt

@@ -4,6 +4,11 @@ ID = ENB_MASTER_TICK
     GROUP = ALL:GENERAL:ENB
     FORMAT = int,eNB_ID : int,frame : int,subframe
 
+ID = USRP_RX_ANT0
+    DESC = RX IQ data as received by USRP driver on antenna 0
+    GROUP = ALL:HEAVY
+    FORMAT = int,timestap : buffer,data
+
 #PHY logs
 ID = ENB_PHY_UL_TICK
     DESC = eNodeB uplink tick - one tick per ms at start of uplink processing

nfapi/open-nFAPI/nfapi/public_inc/fapi_nr_ue_interface.h

@@ -37,18 +37,6 @@
   typedef signed char		   int8_t;
 */
 
-
-typedef struct {
-  uint8_t uci_format;
-  uint8_t uci_channel;
-  uint8_t harq_ack_bits;
-  uint32_t harq_ack;
-  uint8_t csi_bits;
-  uint32_t csi;
-  uint8_t sr_bits;
-  uint32_t sr;
-} fapi_nr_uci_pdu_rel15_t;
-
 typedef enum {
  RLM_no_monitoring = 0,
  RLM_out_of_sync = 1,
@@ -257,10 +245,16 @@ typedef struct
 
 typedef struct
 {
+  // payloads with fixed array size
+  // no place to free the dinamically allocated
+  // vector without L1 implementation
   uint16_t harq_ack_bit_length;
+  uint64_t harq_payload;
   uint16_t csi_part1_bit_length;
+  uint64_t csi_part1_payload;
   uint16_t csi_part2_bit_length;
-  uint8_t  alpha_scaling;
+  uint64_t csi_part2_payload;
+  uint8_t  alpha_scaling; // 0 = 0.5, 1 = 0.65, 2 = 0.8, 3 = 1
   uint8_t  beta_offset_harq_ack;
   uint8_t  beta_offset_csi1;
   uint8_t  beta_offset_csi2;
@@ -355,6 +349,7 @@ typedef struct
   uint8_t  nr_of_symbols;
   uint32_t tbslbrm;
   uint8_t ldpcBaseGraph;
+  uint8_t ulsch_indicator;
   //Optional Data only included if indicated in pduBitmap
   nfapi_nr_ue_pusch_data_t pusch_data;
   nfapi_nr_ue_pusch_uci_t  pusch_uci;

openair1/PHY/NR_ESTIMATION/nr_measurements_gNB.c

@@ -114,10 +114,8 @@ void dump_nr_I0_stats(FILE *fd,PHY_VARS_gNB *gNB) {
 
 }
 
-
-
-void gNB_I0_measurements(PHY_VARS_gNB *gNB,int slot, int first_symb,int num_symb) {
-
+void gNB_I0_measurements(PHY_VARS_gNB *gNB, int slot, int first_symb, int num_symb, uint32_t rb_mask_ul[14][9])
+{
   NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
   NR_gNB_COMMON *common_vars = &gNB->common_vars;
   PHY_MEASUREMENTS_gNB *measurements = &gNB->measurements;
@@ -140,8 +138,8 @@ void gNB_I0_measurements(PHY_VARS_gNB *gNB,int slot, int first_symb,int num_symb
   for (int s=first_symb;s<(first_symb+num_symb);s++) {
     int offset0 = ((slot&3)*frame_parms->symbols_per_slot + s) * frame_parms->ofdm_symbol_size;
     for (rb=0; rb<frame_parms->N_RB_UL; rb++) {
-      if ((gNB->rb_mask_ul[s][rb >> 5] & (1U << (rb & 31))) == 0 && // check that rb was not used in this subframe
-          !(I0_SKIP_DC && rb == frame_parms->N_RB_UL>>1)) {         // skip middle PRB because of artificial noise possibly created by FFT
+      if ((rb_mask_ul[s][rb >> 5] & (1U << (rb & 31))) == 0 && // check that rb was not used in this subframe
+          !(I0_SKIP_DC && rb == frame_parms->N_RB_UL >> 1)) { // skip middle PRB because of artificial noise possibly created by FFT
         int offset = offset0 + (frame_parms->first_carrier_offset + (rb*12))%frame_parms->ofdm_symbol_size;
         nb_symb[rb]++;
         for (int aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
@@ -192,7 +190,6 @@ void gNB_I0_measurements(PHY_VARS_gNB *gNB,int slot, int first_symb,int num_symb
   }
 }
 
-
 // Scope: This function computes the UL SNR from the UL channel estimates
 //
 // Todo:

openair1/PHY/NR_ESTIMATION/nr_ul_estimation.h

@@ -54,7 +54,7 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
 
 void dump_nr_I0_stats(FILE *fd,PHY_VARS_gNB *gNB);
 
-void gNB_I0_measurements(PHY_VARS_gNB *gNB,int slot,int first_symb,int num_symb);
+void gNB_I0_measurements(PHY_VARS_gNB *gNB, int slot, int first_symb, int num_symb, uint32_t rb_mask_ul[14][9]);
 
 void nr_gnb_measurements(PHY_VARS_gNB *gNB,
                          NR_gNB_ULSCH_t *ulsch,

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_llr_computation.c

@@ -38,8 +38,6 @@
 
 //#define DEBUG_LLR_SIC
 
-int16_t nr_zeros[8] __attribute__((aligned(16))) = {0, 0, 0, 0, 0, 0, 0, 0};
-
 //==============================================================================================
 // SINGLE-STREAM
 //==============================================================================================

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_ue.c

@@ -123,6 +123,11 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
   const nfapi_nr_ue_pusch_pdu_t *pusch_pdu = &ulsch_ue->pusch_pdu;
 
   uint32_t tb_size = pusch_pdu->pusch_data.tb_size;
+  AssertFatal(pusch_pdu->pusch_uci.harq_ack_bit_length == 0 &&
+              pusch_pdu->pusch_uci.csi_part1_bit_length == 0 &&
+              pusch_pdu->pusch_uci.csi_part2_bit_length == 0,
+              "UCI on PUSCH not supported at PHY\n");
+
   int start_symbol          = pusch_pdu->start_symbol_index;
   uint16_t ul_dmrs_symb_pos = pusch_pdu->ul_dmrs_symb_pos;
   uint8_t number_of_symbols = pusch_pdu->nr_of_symbols;

openair1/PHY/defs_gNB.h

@@ -622,9 +622,6 @@ typedef struct PHY_VARS_gNB_s {
   /// PUSCH DMRS
   uint32_t ****nr_gold_pusch_dmrs;
 
-  // Mask of occupied RBs, per symbol and PRB
-  uint32_t rb_mask_ul[14][9];
-
   /// PRS sequence
   uint32_t ****nr_gold_prs;
 

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -541,20 +541,20 @@ void nr_fill_indication(PHY_VARS_gNB *gNB, int frame, int slot_rx, int ULSCH_id,
 }
 
 // Function to fill UL RB mask to be used for N0 measurements
-void fill_ul_rb_mask(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
-
+static void fill_ul_rb_mask(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, uint32_t rb_mask_ul[14][9])
+{
   int rb = 0;
   int rb2 = 0;
   int prbpos = 0;
 
   for (int symbol = 0; symbol < 14; symbol++) {
     for (int m = 0; m < 9; m++) {
-      gNB->rb_mask_ul[symbol][m] = 0;
+      rb_mask_ul[symbol][m] = 0;
       for (int i = 0; i < 32; i++) {
         prbpos = (m * 32) + i;
         if (prbpos>gNB->frame_parms.N_RB_UL)
           break;
-        gNB->rb_mask_ul[symbol][m] |= (gNB->ulprbbl[prbpos] > 0 ? 1U : 0) << i;
+        rb_mask_ul[symbol][m] |= (gNB->ulprbbl[prbpos] > 0 ? 1U : 0) << i;
       }
     }
   }
@@ -574,7 +574,7 @@ void fill_ul_rb_mask(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
               rb2 = rb + pucch_pdu->bwp_start +
                     ((symbol < pucch_pdu->start_symbol_index+(pucch_pdu->nr_of_symbols>>1)) || (pucch_pdu->freq_hop_flag == 0) ?
                      pucch_pdu->prb_start : pucch_pdu->second_hop_prb);
-              gNB->rb_mask_ul[symbol][rb2>>5] |= (((uint32_t)1)<<(rb2&31));
+              rb_mask_ul[symbol][rb2>>5] |= (((uint32_t)1)<<(rb2&31));
             }
           }
         }
@@ -599,7 +599,7 @@ void fill_ul_rb_mask(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
           LOG_D(PHY, "symbol %d Filling rb_mask_ul rb_size %d\n", symbol, ulsch_harq->ulsch_pdu.rb_size);
           for (rb = 0; rb < ulsch_harq->ulsch_pdu.rb_size; rb++) {
             rb2 = rb + ulsch_harq->ulsch_pdu.rb_start + ulsch_harq->ulsch_pdu.bwp_start;
-            gNB->rb_mask_ul[symbol][rb2 >> 5] |= 1U << (rb2 & 31);
+            rb_mask_ul[symbol][rb2 >> 5] |= 1U << (rb2 & 31);
           }
         }
       }
@@ -613,14 +613,13 @@ void fill_ul_rb_mask(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx) {
         nfapi_nr_srs_pdu_t *srs_pdu = &srs->srs_pdu;
         for(int symbol = 0; symbol<(1<<srs_pdu->num_symbols); symbol++) {
           for(rb = srs_pdu->bwp_start; rb < (srs_pdu->bwp_start+srs_pdu->bwp_size); rb++) {
-            gNB->rb_mask_ul[gNB->frame_parms.symbols_per_slot - srs_pdu->time_start_position - 1 + symbol][rb >> 5] |= 1U
+            rb_mask_ul[gNB->frame_parms.symbols_per_slot - srs_pdu->time_start_position - 1 + symbol][rb >> 5] |= 1U
                                                                                                                        << (rb & 31);
           }
         }
       }
     }
   }
-
 }
 
 int fill_srs_reported_symbol_list(nfapi_nr_srs_reported_symbol_t *prgs,
@@ -718,8 +717,9 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_UESPEC_RX,1);
   LOG_D(PHY,"phy_procedures_gNB_uespec_RX frame %d, slot %d\n",frame_rx,slot_rx);
-
-  fill_ul_rb_mask(gNB, frame_rx, slot_rx);
+  // Mask of occupied RBs, per symbol and PRB
+  uint32_t rb_mask_ul[14][9];
+  fill_ul_rb_mask(gNB, frame_rx, slot_rx, rb_mask_ul);
 
   int first_symb=0,num_symb=0;
   if (gNB->frame_parms.frame_type == TDD)
@@ -731,7 +731,7 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
     }
   else
     num_symb = NR_NUMBER_OF_SYMBOLS_PER_SLOT;
-  gNB_I0_measurements(gNB,slot_rx,first_symb,num_symb);
+  gNB_I0_measurements(gNB, slot_rx, first_symb, num_symb, rb_mask_ul);
 
   const int soffset = (slot_rx & 3) * gNB->frame_parms.symbols_per_slot * gNB->frame_parms.ofdm_symbol_size;
   int offset = 10 * gNB->frame_parms.ofdm_symbol_size + gNB->frame_parms.first_carrier_offset;

openair1/SCHED_NR/sched_nr.h

@@ -32,7 +32,6 @@
 #include "PHY/NR_TRANSPORT/nr_dci.h"
 #include "phy_frame_config_nr.h"
 
-void fill_ul_rb_mask(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx);
 void nr_set_ssb_first_subcarrier(nfapi_nr_config_request_scf_t *cfg, NR_DL_FRAME_PARMS *fp);
 void phy_procedures_gNB_TX(processingData_L1tx_t *msgTx, int frame_tx, int slot_tx, int do_meas);
 int  phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx);

openair1/SCHED_NR_UE/pucch_uci_ue_nr.c

@@ -186,22 +186,3 @@ void pucch_procedures_ue_nr(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, n
     pucch_vars->active[i] = false;
   }
 }
-
-int      dummy_csi_status = 0;
-uint32_t dummy_csi_payload = 0;
-
-
-/* FFS TODO_NR code that should be removed */
-
-void set_csi_nr(int csi_status, uint32_t csi_payload)
-{
-  dummy_csi_status = csi_status;
-
-  if (dummy_csi_status == 0) {
-    dummy_csi_payload = 0;
-  }
-  else {
-    dummy_csi_payload = csi_payload;
-  }
-}
-

openair1/SCHED_NR_UE/pucch_uci_ue_nr.h

@@ -52,6 +52,4 @@
 
 void pucch_procedures_ue_nr(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_phy_data_tx_t *phy_data, c16_t **txdataF);
 
-void set_csi_nr(int csi_status, uint32_t csi_payload);
-
 #endif /* PUCCH_UCI_UE_NR_H */

openair1/SIMULATION/NR_PHY/pucchsim.c

@@ -629,16 +629,17 @@ int main(int argc, char **argv)
                                                            12);
 
       // set UL mask for pucch allocation
+      uint32_t rb_mask_ul[14][9] = {0};
       for (int s=0;s<frame_parms->symbols_per_slot;s++){
         if (s>=startingSymbolIndex && s<(startingSymbolIndex+nrofSymbols))
           for (int rb=0; rb<N_RB; rb++) {
             int rb2 = rb+startingPRB;
-            gNB->rb_mask_ul[s][rb2>>5] |= (1<<(rb2&31));
+            rb_mask_ul[s][rb2 >> 5] |= (1 << (rb2 & 31));
           }
       }
 
       // noise measurement (all PRBs)
-      gNB_I0_measurements(gNB, nr_slot_tx, 0, gNB->frame_parms.symbols_per_slot);
+      gNB_I0_measurements(gNB, nr_slot_tx, 0, gNB->frame_parms.symbols_per_slot, rb_mask_ul);
 
       if (n_trials==1) printf("noise rxlev %d (%d dB), rxlev pucch %d dB sigma2 %f dB, SNR %f, TX %f, I0 (pucch) %d, I0 (avg) %d\n",rxlev,dB_fixed(rxlev),dB_fixed(rxlev_pucch),sigma2_dB,SNR,10*log10((double)txlev*UE->frame_parms.ofdm_symbol_size/12),gNB->measurements.n0_subband_power_tot_dB[startingPRB],gNB->measurements.n0_subband_power_avg_dB);
       if(format==0){

openair1/SIMULATION/NR_UE_PHY/unit_tests/src/pucch_uci_test.c

@@ -1074,8 +1074,6 @@ int test_csi_dedicated(PHY_VARS_NR_UE *ue, int gNB_id, UE_nr_rxtx_proc_t *proc)
 
   ue->dlsch[proc->thread_id][gNB_id][0]->current_harq_pid = NR_MAX_DLSCH_HARQ_PROCESSES;
 
-  set_csi_nr( 4, 0x0E );
-
   printf("\n  => Test : PUCCH format from dedicated config with CSI alone \n");
 
   if (pucch_procedures_ue_nr(ue, gNB_id, proc, reset_harq) != true) {

openair2/LAYER2/NR_MAC_COMMON/nr_mac.h

@@ -501,6 +501,7 @@ typedef struct{
 } CSI_Meas_bitlen_t;
 
 typedef struct nr_csi_report {
+  NR_CSI_ReportConfigId_t reportConfigId;
   NR_CSI_ReportConfig__reportQuantity_PR reportQuantity_type;
   long periodicity;
   uint16_t offset;
@@ -561,6 +562,7 @@ typedef struct NR_UE_UL_BWP {
   NR_PUSCH_TimeDomainResourceAllocationList_t *tdaList_Common;
   NR_ConfiguredGrantConfig_t *configuredGrantConfig;
   NR_PUSCH_Config_t *pusch_Config;
+  NR_UCI_OnPUSCH_t *uci_onPusch;
   NR_PUCCH_Config_t *pucch_Config;
   NR_PUCCH_ConfigCommon_t *pucch_ConfigCommon;
   NR_SRS_Config_t *srs_Config;

openair2/LAYER2/NR_MAC_COMMON/nr_mac_common.c

@@ -5018,7 +5018,8 @@ void compute_cqi_bitlen(struct NR_CSI_ReportConfig *csi_reportconfig,
 }
 
 //!TODO : same function can be written to handle csi_resources
-void compute_csi_bitlen(NR_CSI_MeasConfig_t *csi_MeasConfig, nr_csi_report_t *csi_report_template) {
+void compute_csi_bitlen(const NR_CSI_MeasConfig_t *csi_MeasConfig, nr_csi_report_t *csi_report_template)
+{
   uint8_t csi_report_id = 0;
   uint8_t nb_resources = 0;
   NR_CSI_ReportConfig__reportQuantity_PR reportQuantity_type;
@@ -5027,7 +5028,7 @@ void compute_csi_bitlen(NR_CSI_MeasConfig_t *csi_MeasConfig, nr_csi_report_t *cs
 
   // for each CSI measurement report configuration (list of CSI-ReportConfig)
   LOG_D(NR_MAC,"Searching %d csi_reports\n",csi_MeasConfig->csi_ReportConfigToAddModList->list.count);
-  for (csi_report_id=0; csi_report_id < csi_MeasConfig->csi_ReportConfigToAddModList->list.count; csi_report_id++){
+  for (csi_report_id = 0; csi_report_id < csi_MeasConfig->csi_ReportConfigToAddModList->list.count; csi_report_id++) {
     struct NR_CSI_ReportConfig *csi_reportconfig = csi_MeasConfig->csi_ReportConfigToAddModList->list.array[csi_report_id];
     // MAC structure for CSI measurement reports (per UE and per report)
     nr_csi_report_t *csi_report = &csi_report_template[csi_report_id];
@@ -5039,7 +5040,7 @@ void compute_csi_bitlen(NR_CSI_MeasConfig_t *csi_MeasConfig, nr_csi_report_t *cs
     int csi_resourceidx = 0;
     while (found_resource == 0 && csi_resourceidx < csi_MeasConfig->csi_ResourceConfigToAddModList->list.count) {
       csi_resourceconfig = csi_MeasConfig->csi_ResourceConfigToAddModList->list.array[csi_resourceidx];
-      if ( csi_resourceconfig->csi_ResourceConfigId == csi_ResourceConfigId)
+      if (csi_resourceconfig->csi_ResourceConfigId == csi_ResourceConfigId)
         found_resource = 1;
       csi_resourceidx++;
     }
@@ -5050,6 +5051,7 @@ void compute_csi_bitlen(NR_CSI_MeasConfig_t *csi_MeasConfig, nr_csi_report_t *cs
 
     reportQuantity_type = csi_reportconfig->reportQuantity.present;
     csi_report->reportQuantity_type = reportQuantity_type;
+    csi_report->reportConfigId = csi_reportconfig->reportConfigId;
 
     // setting the CSI or SSB index list
     if (NR_CSI_ReportConfig__reportQuantity_PR_ssb_Index_RSRP == csi_report->reportQuantity_type) {
@@ -5114,21 +5116,21 @@ void compute_csi_bitlen(NR_CSI_MeasConfig_t *csi_MeasConfig, nr_csi_report_t *cs
   }
 }
 
-uint16_t nr_get_csi_bitlen(nr_csi_report_t *csi_report_template, uint8_t csi_report_id) {
-
+uint16_t nr_get_csi_bitlen(nr_csi_report_t *csi_report)
+{
   uint16_t csi_bitlen = 0;
   uint16_t max_bitlen = 0;
   L1_RSRP_bitlen_t *CSI_report_bitlen = NULL;
   CSI_Meas_bitlen_t *csi_meas_bitlen = NULL;
 
-  if (csi_report_template[csi_report_id].reportQuantity_type == NR_CSI_ReportConfig__reportQuantity_PR_ssb_Index_RSRP ||
-      csi_report_template[csi_report_id].reportQuantity_type == NR_CSI_ReportConfig__reportQuantity_PR_cri_RSRP) {
-    CSI_report_bitlen = &(csi_report_template[csi_report_id].CSI_report_bitlen); // This might need to be moodif for Aperiodic CSI-RS measurements
+  if (csi_report->reportQuantity_type == NR_CSI_ReportConfig__reportQuantity_PR_ssb_Index_RSRP ||
+      csi_report->reportQuantity_type == NR_CSI_ReportConfig__reportQuantity_PR_cri_RSRP) {
+    CSI_report_bitlen = &(csi_report->CSI_report_bitlen); // This might need to be moodif for Aperiodic CSI-RS measurements
     csi_bitlen += ((CSI_report_bitlen->cri_ssbri_bitlen * CSI_report_bitlen->nb_ssbri_cri) +
                    CSI_report_bitlen->rsrp_bitlen +(CSI_report_bitlen->diff_rsrp_bitlen *
                                                     (CSI_report_bitlen->nb_ssbri_cri -1 )));
   } else {
-    csi_meas_bitlen = &(csi_report_template[csi_report_id].csi_meas_bitlen); //This might need to be moodif for Aperiodic CSI-RS measurements
+    csi_meas_bitlen = &(csi_report->csi_meas_bitlen); //This might need to be moodif for Aperiodic CSI-RS measurements
     uint16_t temp_bitlen;
     for (int i = 0; i < 8; i++) {
       temp_bitlen = (csi_meas_bitlen->cri_bitlen+
@@ -5142,7 +5144,6 @@ uint16_t nr_get_csi_bitlen(nr_csi_report_t *csi_report_template, uint8_t csi_rep
     }
     csi_bitlen += max_bitlen;
   }
-
   return csi_bitlen;
 }
 

openair2/LAYER2/NR_MAC_COMMON/nr_mac_common.h

@@ -307,9 +307,9 @@ void compute_cqi_bitlen(struct NR_CSI_ReportConfig *csi_reportconfig,
                         uint8_t ri_restriction,
                         nr_csi_report_t *csi_report);
 
-void compute_csi_bitlen(NR_CSI_MeasConfig_t *csi_MeasConfig, nr_csi_report_t *csi_report_template);
+void compute_csi_bitlen(const NR_CSI_MeasConfig_t *csi_MeasConfig, nr_csi_report_t *csi_report_template);
 
-uint16_t nr_get_csi_bitlen(nr_csi_report_t *csi_report_template, uint8_t csi_report_id);
+uint16_t nr_get_csi_bitlen(nr_csi_report_t *csi_report);
 
 uint16_t compute_PDU_length(uint32_t num_TLV, uint16_t total_length);
 

openair2/LAYER2/NR_MAC_UE/mac_defs.h

@@ -394,7 +394,6 @@ typedef struct {
   int n_harq;
   int n_CCE;
   int N_CCE;
-  int delta_pucch;
   int initial_pucch_id;
 } PUCCH_sched_t;
 
@@ -482,6 +481,19 @@ typedef struct {
   A_SEQUENCE_OF(NR_SearchSpace_t) list_SS;
 } NR_BWP_PDCCH_t;
 
+typedef struct csi_payload {
+  uint32_t part1_payload;
+  uint32_t part2_payload;
+  int p1_bits;
+  int p2_bits;
+} csi_payload_t;
+
+typedef enum {
+  WIDEBAND_ON_PUCCH,
+  SUBBAND_ON_PUCCH,
+  ON_PUSCH
+} CSI_mapping_t;
+
 /*!\brief Top level UE MAC structure */
 typedef struct NR_UE_MAC_INST_s {
   module_id_t ue_id;
@@ -578,7 +590,9 @@ typedef struct NR_UE_MAC_INST_s {
 
   //SIDELINK MAC PARAMETERS
   sl_nr_ue_mac_params_t *SL_MAC_PARAMS;
-
+  // PUCCH closed loop power control state
+  int G_b_f_c;
+  bool pucch_power_control_initialized;
 } NR_UE_MAC_INST_t;
 
 /*@}*/

openair2/LAYER2/NR_MAC_UE/mac_proto.h

@@ -111,6 +111,8 @@ void release_mac_configuration(NR_UE_MAC_INST_t *mac,
 void nr_ue_ul_scheduler(NR_UE_MAC_INST_t *mac, nr_uplink_indication_t *ul_info);
 void nr_ue_dl_scheduler(NR_UE_MAC_INST_t *mac, nr_downlink_indication_t *dl_info);
 
+csi_payload_t nr_ue_aperiodic_csi_reporting(NR_UE_MAC_INST_t *mac, dci_field_t csi_request, int tda, long *K2);
+
 /*! \fn int8_t nr_ue_get_SR(NR_UE_MAC_INST_t *mac, frame_t frame, slot_t slot, NR_SchedulingRequestId_t sr_id);
    \brief This function schedules a positive or negative SR for schedulingRequestID sr_id
           depending on the presence of any active SR and the prohibit timer.
@@ -132,28 +134,26 @@ bool trigger_periodic_scheduling_request(NR_UE_MAC_INST_t *mac,
 
 int nr_get_csi_measurements(NR_UE_MAC_INST_t *mac, frame_t frame, int slot, PUCCH_sched_t *pucch);
 
-uint8_t get_ssb_rsrp_payload(NR_UE_MAC_INST_t *mac,
-                             PUCCH_sched_t *pucch,
-                             struct NR_CSI_ReportConfig *csi_reportconfig,
-                             NR_CSI_ResourceConfigId_t csi_ResourceConfigId,
-                             NR_CSI_MeasConfig_t *csi_MeasConfig);
+csi_payload_t get_ssb_rsrp_payload(NR_UE_MAC_INST_t *mac,
+                                   struct NR_CSI_ReportConfig *csi_reportconfig,
+                                   NR_CSI_ResourceConfigId_t csi_ResourceConfigId,
+                                   NR_CSI_MeasConfig_t *csi_MeasConfig);
+
+csi_payload_t get_csirs_RI_PMI_CQI_payload(NR_UE_MAC_INST_t *mac,
+                                           struct NR_CSI_ReportConfig *csi_reportconfig,
+                                           NR_CSI_ResourceConfigId_t csi_ResourceConfigId,
+                                           NR_CSI_MeasConfig_t *csi_MeasConfig,
+                                           CSI_mapping_t mapping_type);
 
-uint8_t get_csirs_RI_PMI_CQI_payload(NR_UE_MAC_INST_t *mac,
-                                     PUCCH_sched_t *pucch,
+csi_payload_t get_csirs_RSRP_payload(NR_UE_MAC_INST_t *mac,
                                      struct NR_CSI_ReportConfig *csi_reportconfig,
                                      NR_CSI_ResourceConfigId_t csi_ResourceConfigId,
-                                     NR_CSI_MeasConfig_t *csi_MeasConfig);
-
-uint8_t get_csirs_RSRP_payload(NR_UE_MAC_INST_t *mac,
-                               PUCCH_sched_t *pucch,
-                               struct NR_CSI_ReportConfig *csi_reportconfig,
-                               NR_CSI_ResourceConfigId_t csi_ResourceConfigId,
-                               NR_CSI_MeasConfig_t *csi_MeasConfig);
+                                     const NR_CSI_MeasConfig_t *csi_MeasConfig);
 
-uint8_t nr_get_csi_payload(NR_UE_MAC_INST_t *mac,
-                           PUCCH_sched_t *pucch,
-                           int csi_report_id,
-                           NR_CSI_MeasConfig_t *csi_MeasConfig);
+csi_payload_t nr_get_csi_payload(NR_UE_MAC_INST_t *mac,
+                                 int csi_report_id,
+                                 CSI_mapping_t mapping_type,
+                                 NR_CSI_MeasConfig_t *csi_MeasConfig);
 
 uint8_t get_rsrp_index(int rsrp);
 uint8_t get_rsrp_diff_index(int best_rsrp,int current_rsrp);
@@ -217,23 +217,20 @@ int16_t get_pucch_tx_power_ue(NR_UE_MAC_INST_t *mac,
                               uint8_t add_dmrs_flag,
                               uint8_t N_symb_PUCCH,
                               int subframe_number,
-                              int O_uci);
-
-int get_deltatf(uint16_t nb_of_prbs,
-                uint8_t N_symb_PUCCH,
-                uint8_t freq_hop_flag,
-                uint8_t add_dmrs_flag,
-                int N_sc_ctrl_RB,
-                int O_UCI);
+                              int O_uci,
+                              uint16_t start_prb);
 
 int nr_ue_configure_pucch(NR_UE_MAC_INST_t *mac,
                            int slot,
+                           frame_t frame,
                            uint16_t rnti,
                            PUCCH_sched_t *pucch,
                            fapi_nr_ul_config_pucch_pdu *pucch_pdu);
 
 int nr_get_Pcmax(NR_UE_MAC_INST_t *mac, int Qm, bool powerBoostPi2BPSK, int scs, int N_RB_UL, bool is_transform_precoding, int n_prbs, int start_prb);
 
+int get_sum_delta_pucch(NR_UE_MAC_INST_t *mac, int slot, frame_t frame);
+
 /* Random Access */
 
 /* \brief This function schedules the PRACH according to prach_ConfigurationIndex and TS 38.211 tables 6.3.3.2.x
@@ -243,7 +240,7 @@ and fills the PRACH PDU per each FD occasion.
 @param slotP Slot index
 @returns void
 */
-void nr_ue_pucch_scheduler(NR_UE_MAC_INST_t *mac, frame_t frameP, int slotP, void *phy_data);
+void nr_ue_pucch_scheduler(NR_UE_MAC_INST_t *mac, frame_t frameP, int slotP);
 void nr_schedule_csirs_reception(NR_UE_MAC_INST_t *mac, int frame, int slot);
 void nr_schedule_csi_for_im(NR_UE_MAC_INST_t *mac, int frame, int slot);
 
@@ -367,6 +364,7 @@ int nr_config_pusch_pdu(NR_UE_MAC_INST_t *mac,
                         NR_tda_info_t *tda_info,
                         nfapi_nr_ue_pusch_pdu_t *pusch_config_pdu,
                         dci_pdu_rel15_t *dci,
+                        csi_payload_t *csi_report,
                         RAR_grant_t *rar_grant,
                         uint16_t rnti,
                         int ss_type,

openair2/LAYER2/NR_MAC_UE/main_ue_nr.c

@@ -82,6 +82,8 @@ void nr_ue_init_mac(NR_UE_MAC_INST_t *mac)
 
   for (int i = 0; i < NR_MAX_SR_ID; i++)
     memset(&mac->scheduling_info.sr_info[i], 0, sizeof(mac->scheduling_info.sr_info[i]));
+
+  mac->pucch_power_control_initialized = false;
 }
 
 void nr_ue_mac_default_configs(NR_UE_MAC_INST_t *mac)

openair2/LAYER2/NR_MAC_UE/nr_ra_procedures.c

@@ -930,7 +930,6 @@ void prepare_msg4_feedback(NR_UE_MAC_INST_t *mac, int pid, int ack_nack)
   mac->nr_ue_emul_l1.num_harqs = 1;
   PUCCH_sched_t pucch = {.n_CCE = current_harq->n_CCE,
                          .N_CCE = current_harq->N_CCE,
-                         .delta_pucch = current_harq->delta_pucch,
                          .ack_payload = ack_nack,
                          .n_harq = 1};
   current_harq->active = false;
@@ -943,7 +942,7 @@ void prepare_msg4_feedback(NR_UE_MAC_INST_t *mac, int pid, int ack_nack)
   fapi_nr_ul_config_request_pdu_t *pdu = lockGet_ul_config(mac, sched_frame, sched_slot, FAPI_NR_UL_CONFIG_TYPE_PUCCH);
   if (!pdu)
     return;
-  int ret = nr_ue_configure_pucch(mac, sched_slot, mac->ra.t_crnti, &pucch, &pdu->pucch_config_pdu);
+  int ret = nr_ue_configure_pucch(mac, sched_slot, sched_frame, mac->ra.t_crnti, &pucch, &pdu->pucch_config_pdu);
   if (ret != 0)
     remove_ul_config_last_item(pdu);
   release_ul_config(pdu, false);

openair2/LAYER2/NR_MAC_UE/nr_ue_power_procedures.c

@@ -31,6 +31,40 @@
 
 #include "LAYER2/NR_MAC_UE/mac_proto.h"
 
+#define DEFAULT_P0_NOMINAL_PUCCH_0_DBM 0
+#define DEFAULT_DELTA_F_PUCCH_0_DB 0
+
+// TODO: This should be part of mac instance
+/* TS 38.213 9.2.5.2 UE procedure for multiplexing HARQ-ACK/SR and CSI in a PUCCH */
+/* this is a counter of number of pucch format 4 per subframe */
+static int nb_pucch_format_4_in_subframes[LTE_NUMBER_OF_SUBFRAMES_PER_FRAME] = {0};
+
+/* TS 38.211 Table 6.4.1.3.3.2-1: DM-RS positions for PUCCH format 3 and 4 */
+static const int nb_symbols_excluding_dmrs[11][2][2]
+= {
+/*                     No additional DMRS            Additional DMRS   */
+/* PUCCH length      No hopping   hopping         No hopping   hopping */
+/* index                  0          1                 0          1    */
+/*    4     */    {{      3    ,     2   }   ,  {      3     ,    2    }},
+/*    5     */    {{      3    ,     3   }   ,  {      3     ,    3    }},
+/*    6     */    {{      4    ,     4   }   ,  {      4     ,    4    }},
+/*    7     */    {{      5    ,     5   }   ,  {      5     ,    5    }},
+/*    8     */    {{      6    ,     6   }   ,  {      6     ,    6    }},
+/*    9     */    {{      7    ,     7   }   ,  {      7     ,    7    }},
+/*   10     */    {{      8    ,     8   }   ,  {      6     ,    6    }},
+/*   11     */    {{      9    ,     9   }   ,  {      7     ,    7    }},
+/*   12     */    {{     10    ,    10   }   ,  {      8     ,    8    }},
+/*   13     */    {{     11    ,    11   }   ,  {      9     ,    9    }},
+/*   14     */    {{     12    ,    12   }   ,  {     10     ,   10    }},
+};
+
+static int get_deltatf(uint16_t nb_of_prbs,
+                       uint8_t N_symb_PUCCH,
+                       uint8_t freq_hop_flag,
+                       uint8_t add_dmrs_flag,
+                       int N_sc_ctrl_RB,
+                       int O_UCI);
+
 // Implementation of 6.2.4 Configured ransmitted power
 // 3GPP TS 38.101-1 version 16.5.0 Release 16
 // -
@@ -156,3 +190,171 @@ int nr_get_Pcmax(NR_UE_MAC_INST_t *mac, int Qm, bool powerBoostPi2BPSK, int scs,
   }
 }
 
+// This is not entirely correct. In certain k2/k1/k0 settings we might postpone accumulating delta_PUCCH until next HARQ feedback
+// slot. The correct way to do this would be to calculate the K_PUCCH (delta_PUCCH summation window end) for each PUCCH occasion and
+// compare PUCCH transmission symbol with the reception symbol of the DCI containing delta_PUCCH to determine if the delta_PUCCH
+// should be added at each occasion.
+int get_sum_delta_pucch(NR_UE_MAC_INST_t *mac, int slot, frame_t frame)
+{
+  int delta_tpc_sum = 0;
+  for (int i = 0; i < NR_MAX_HARQ_PROCESSES; i++) {
+    if (mac->dl_harq_info[i].active && mac->dl_harq_info[i].ul_slot == slot && mac->dl_harq_info[i].ul_frame == frame) {
+      delta_tpc_sum += mac->dl_harq_info[i].delta_pucch;
+      mac->dl_harq_info[i].delta_pucch = 0;
+    }
+  }
+  return delta_tpc_sum;
+}
+
+// PUCCH Power control according to 38.213 section 7.2.1
+int16_t get_pucch_tx_power_ue(NR_UE_MAC_INST_t *mac,
+                              int scs,
+                              NR_PUCCH_Config_t *pucch_Config,
+                              int sum_delta_pucch,
+                              uint8_t format_type,
+                              uint16_t nb_of_prbs,
+                              uint8_t freq_hop_flag,
+                              uint8_t add_dmrs_flag,
+                              uint8_t N_symb_PUCCH,
+                              int subframe_number,
+                              int O_uci,
+                              uint16_t start_prb)
+{
+  NR_UE_UL_BWP_t *current_UL_BWP = mac->current_UL_BWP;
+  AssertFatal(current_UL_BWP && current_UL_BWP->pucch_ConfigCommon,
+              "Missing configuration: need UL_BWP and pucch_ConfigCommon to calculate PUCCH tx power\n");
+  int PUCCH_POWER_DEFAULT = 0;
+  // p0_nominal is optional
+  int16_t P_O_NOMINAL_PUCCH = DEFAULT_P0_NOMINAL_PUCCH_0_DBM;
+  if (current_UL_BWP->pucch_ConfigCommon->p0_nominal != NULL) {
+    P_O_NOMINAL_PUCCH = *current_UL_BWP->pucch_ConfigCommon->p0_nominal;
+  }
+
+  struct NR_PUCCH_PowerControl *power_config = pucch_Config ? pucch_Config->pucch_PowerControl : NULL;
+
+  if (!power_config)
+    return (PUCCH_POWER_DEFAULT);
+
+  int16_t P_O_UE_PUCCH = 0;
+
+  if (pucch_Config->spatialRelationInfoToAddModList != NULL) {  /* FFS TODO NR */
+    LOG_D(MAC,"PUCCH Spatial relation infos are not yet implemented\n");
+    return (PUCCH_POWER_DEFAULT);
+  }
+
+  int G_b_f_c = 0;
+  if (power_config->p0_Set != NULL) {
+    P_O_UE_PUCCH = power_config->p0_Set->list.array[0]->p0_PUCCH_Value; /* get from index 0 if no spatial relation set */
+  }
+
+  int P_O_PUCCH = P_O_NOMINAL_PUCCH + P_O_UE_PUCCH;
+
+  int16_t delta_F_PUCCH = DEFAULT_DELTA_F_PUCCH_0_DB;
+  long *delta_F_PUCCH_config = NULL;
+  int DELTA_TF;
+  uint16_t N_ref_PUCCH;
+  int N_sc_ctrl_RB = 0;
+
+  /* computing of pucch transmission power adjustment */
+  switch (format_type) {
+    case 0:
+      N_ref_PUCCH = 2;
+      DELTA_TF = 10 * log10(N_ref_PUCCH/N_symb_PUCCH);
+      delta_F_PUCCH_config = power_config->deltaF_PUCCH_f0;
+      break;
+    case 1:
+      N_ref_PUCCH = 14;
+      DELTA_TF = 10 * log10(N_ref_PUCCH/N_symb_PUCCH * O_uci);
+      delta_F_PUCCH_config = power_config->deltaF_PUCCH_f1;
+      break;
+    case 2:
+      N_sc_ctrl_RB = 10;
+      DELTA_TF = get_deltatf(nb_of_prbs, N_symb_PUCCH, freq_hop_flag, add_dmrs_flag, N_sc_ctrl_RB, O_uci);
+      delta_F_PUCCH_config = power_config->deltaF_PUCCH_f2;
+      break;
+    case 3:
+      N_sc_ctrl_RB = 14;
+      DELTA_TF = get_deltatf(nb_of_prbs, N_symb_PUCCH, freq_hop_flag, add_dmrs_flag, N_sc_ctrl_RB, O_uci);
+      delta_F_PUCCH_config = power_config->deltaF_PUCCH_f3;
+      break;
+    case 4:
+      N_sc_ctrl_RB = 14/(nb_pucch_format_4_in_subframes[subframe_number]);
+      DELTA_TF = get_deltatf(nb_of_prbs, N_symb_PUCCH, freq_hop_flag, add_dmrs_flag, N_sc_ctrl_RB, O_uci);
+      delta_F_PUCCH_config = power_config->deltaF_PUCCH_f4;
+      break;
+    default:
+    {
+      LOG_E(MAC,"PUCCH unknown pucch format %d\n", format_type);
+      return (0);
+    }
+  }
+  if (delta_F_PUCCH_config != NULL) {
+    delta_F_PUCCH = *delta_F_PUCCH_config;
+  }
+
+  // PUCCH shall be as specified for QPSK modulated DFT-s-OFDM of equivalent RB allocation (38.101-1)
+  // TODO: P_CMAX for format 2
+  int P_CMAX = nr_get_Pcmax(mac, 2, false, mac->current_UL_BWP->scs, mac->current_UL_BWP->BWPSize, true, 1, start_prb);
+  int P_CMIN = -40; // TODO: minimum TX power, possibly 38.101-1 6.3.1
+  int16_t pathloss = compute_nr_SSB_PL(mac, mac->ssb_measurements.ssb_rsrp_dBm);
+
+  if (power_config->twoPUCCH_PC_AdjustmentStates && *power_config->twoPUCCH_PC_AdjustmentStates > 1) {
+    LOG_E(MAC,"PUCCH power control adjustment states with 2 states not yet implemented\n");
+    return (PUCCH_POWER_DEFAULT);
+  }
+  int M_pucch_component = (10 * log10((double)(pow(2,scs) * nb_of_prbs)));
+
+  int16_t pucch_power_without_g_pucch = P_O_PUCCH + M_pucch_component + pathloss + delta_F_PUCCH + DELTA_TF;
+
+  if (power_config->p0_Set == NULL) {
+    if (mac->pucch_power_control_initialized == false) {
+      // Initialize power control state
+      // Assuming only sending on PCell
+      NR_PRACH_RESOURCES_t* prach_resources = &mac->ra.prach_resources;
+      float DELTA_P_rampup_requested = (prach_resources->RA_PREAMBLE_POWER_RAMPING_COUNTER - 1) * prach_resources->RA_PREAMBLE_POWER_RAMPING_STEP;
+      float DELTA_P_rampup = P_CMAX - (P_O_PUCCH + pathloss + delta_F_PUCCH + DELTA_TF + sum_delta_pucch);
+      DELTA_P_rampup = max(min(0, DELTA_P_rampup), DELTA_P_rampup_requested);
+      mac->G_b_f_c = DELTA_P_rampup + sum_delta_pucch;
+      mac->pucch_power_control_initialized = true;
+    }
+    else {
+      // PUCCH closed loop power control state
+      G_b_f_c = mac->G_b_f_c;
+      if (!((pucch_power_without_g_pucch + G_b_f_c >= P_CMAX && sum_delta_pucch > 0) ||
+        (pucch_power_without_g_pucch + G_b_f_c <= P_CMIN && sum_delta_pucch < 0))) {
+        G_b_f_c += sum_delta_pucch;
+      }
+      mac->G_b_f_c = G_b_f_c;
+    }
+  }
+
+
+  int pucch_power = min(P_CMAX, pucch_power_without_g_pucch + G_b_f_c);
+
+  LOG_D(MAC, "PUCCH ( Tx power : %d dBm ) ( 10Log(...) : %d ) ( from Path Loss : %d ) ( delta_F_PUCCH : %d ) ( DELTA_TF : %d ) ( G_b_f_c : %d ) \n",
+        pucch_power, M_pucch_component, pathloss, delta_F_PUCCH, DELTA_TF, G_b_f_c);
+
+  return pucch_power;
+}
+
+static int get_deltatf(uint16_t nb_of_prbs,
+                       uint8_t N_symb_PUCCH,
+                       uint8_t freq_hop_flag,
+                       uint8_t add_dmrs_flag,
+                       int N_sc_ctrl_RB,
+                       int O_UCI)
+{
+  int DELTA_TF;
+  int O_CRC = compute_pucch_crc_size(O_UCI);
+  int N_symb = N_symb_PUCCH < 4 ? N_symb_PUCCH : nb_symbols_excluding_dmrs[N_symb_PUCCH - 4][add_dmrs_flag][freq_hop_flag];
+  float N_RE = nb_of_prbs * N_sc_ctrl_RB * N_symb;
+  float K1 = 6;
+  if (O_UCI + O_CRC < 12)
+    DELTA_TF = 10 * log10((double)(((K1 * (O_UCI)) / N_RE)));
+  else {
+    float K2 = 2.4;
+    float BPRE = (O_UCI + O_CRC) / N_RE;
+    DELTA_TF = 10 * log10((double)(pow(2, (K2 * BPRE)) - 1));
+  }
+  return DELTA_TF;
+}

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c

@@ -273,7 +273,7 @@ void nr_csi_meas_reporting(int Mod_idP,
       curr_pucch->frame = sched_frame;
       curr_pucch->ul_slot = sched_slot;
       curr_pucch->resource_indicator = res_index;
-      curr_pucch->csi_bits += nr_get_csi_bitlen(UE->csi_report_template, csi_report_id);
+      curr_pucch->csi_bits += nr_get_csi_bitlen(&UE->csi_report_template[csi_report_id]);
       curr_pucch->active = true;
 
       int bwp_start = ul_bwp->BWPStart;

openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c

@@ -60,9 +60,6 @@ static int      nr_pdcp_current_time_last_subframe;
 hash_table_t  *pdcp_coll_p;
 static uint64_t pdcp_optmask;
 
-uint8_t first_dcch = 0;
-uint8_t proto_agent_flag = 0;
-
 static ngran_node_t node_type;
 
 nr_pdcp_entity_t *nr_pdcp_get_rb(nr_pdcp_ue_t *ue, int rb_id, bool srb_flag)

openair2/PHY_INTERFACE/phy_interface_vars.h

@@ -31,14 +31,5 @@
 #endif
 
 
-unsigned int mac_debug;
-
-//MAC_xface *mac_xface;
-
-//MACPHY_PARAMS MACPHY_params;
-
-unsigned int mac_registered;
-
-
 #endif
 

openair3/NAS/NR_UE/nr_nas_msg_sim.c

@@ -53,8 +53,6 @@
 #include "openair3/SECU/nas_stream_eia2.h"
 #include "openair3/UTILS/conversions.h"
 
-uint8_t  *registration_request_buf;
-uint32_t  registration_request_len;
 extern char *baseNetAddress;
 extern uint16_t NB_UE_INST;
 static nr_ue_nas_t nr_ue_nas = {0};
@@ -474,10 +472,10 @@ void generateRegistrationRequest(as_nas_info_t *initialNasMsg, nr_ue_nas_t *nas)
 
   // encode the message
   initialNasMsg->data = malloc16_clear(size * sizeof(Byte_t));
-  registration_request_buf = initialNasMsg->data;
+  nas->registration_request_buf = initialNasMsg->data;
 
   initialNasMsg->length = mm_msg_encode(mm_msg, (uint8_t*)(initialNasMsg->data), size);
-  registration_request_len = initialNasMsg->length;
+  nas->registration_request_len = initialNasMsg->length;
 
 }
 
@@ -591,9 +589,9 @@ static void generateSecurityModeComplete(nr_ue_nas_t *nas, as_nas_info_t *initia
 
   size += fill_imeisv(&mm_msg->fgs_security_mode_complete.fgsmobileidentity, nas->uicc);
 
-  mm_msg->fgs_security_mode_complete.fgsnasmessagecontainer.nasmessagecontainercontents.value  = registration_request_buf;
-  mm_msg->fgs_security_mode_complete.fgsnasmessagecontainer.nasmessagecontainercontents.length = registration_request_len;
-  size += (registration_request_len + 2);
+  mm_msg->fgs_security_mode_complete.fgsnasmessagecontainer.nasmessagecontainercontents.value  = nas->registration_request_buf;
+  mm_msg->fgs_security_mode_complete.fgsnasmessagecontainer.nasmessagecontainercontents.length = nas->registration_request_len;
+  size += (nas->registration_request_len + 2);
 
   // encode the message
   initialNasMsg->data = (Byte_t *)malloc(size * sizeof(Byte_t));

openair3/NAS/NR_UE/nr_nas_msg_sim.h

@@ -102,6 +102,8 @@ typedef struct {
   stream_security_container_t *security_container;
   Guti5GSMobileIdentity_t *guti;
   bool termination_procedure;
+  uint8_t  *registration_request_buf;
+  uint32_t  registration_request_len;
 } nr_ue_nas_t;
 
 typedef enum fgs_protocol_discriminator_e {

radio/USRP/usrp_lib.cpp

@@ -768,6 +768,8 @@ static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp
   s->rx_timestamp = s->rx_md.time_spec.to_ticks(s->sample_rate);
   *ptimestamp = s->rx_timestamp;
 
+  T(T_USRP_RX_ANT0, T_INT(s->rx_timestamp), T_BUFFER(buff[0], samples_received*4));
+
   recplay_state_t *recPlay=device->recplay_state;
 
   if (device->openair0_cfg->recplay_mode == RECPLAY_RECORDMODE) { // record mode
@@ -1012,6 +1014,28 @@ int trx_usrp_reset_stats(openair0_device *device) {
   return(0);
 }
 
+/*! \brief synch the USRP time accross devices using the host clock (ideally syched with PTP, but also NTP works) and assuming all
+ * devices are synched by octoclock */
+static void usrp_sync_pps(usrp_state_t *s)
+{
+  // First, wait for PPS.
+  uhd::time_spec_t time_last_pps = s->usrp->get_time_last_pps();
+
+  while (time_last_pps == s->usrp->get_time_last_pps()) {
+    boost::this_thread::sleep(boost::posix_time::milliseconds(1));
+  }
+
+  // get host time
+  struct timespec tp;
+  if (clock_gettime(CLOCK_TAI, &tp) != 0)
+    LOG_W(PHY, "error getting system time\n");
+  double tai_sec = (double)tp.tv_sec;
+
+  // set USRP time to host time at next pps
+  s->usrp->set_time_next_pps(uhd::time_spec_t(tai_sec));
+  LOG_I(HW, "USRP clock set to %f sec\n", tai_sec);
+}
+
 extern "C" {
   int device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
     LOG_I(HW, "openair0_cfg[0].sdr_addrs == '%s'\n", openair0_cfg[0].sdr_addrs);
@@ -1188,8 +1212,12 @@ extern "C" {
       exit(EXIT_FAILURE);
     }
   } else {
-    s->usrp->set_time_next_pps(uhd::time_spec_t(0.0));
- 
+    if (s->usrp->get_time_source(0) == "external") {
+      usrp_sync_pps(s);
+    } else {
+      s->usrp->set_time_next_pps(uhd::time_spec_t(0.0));
+    }
+
     if (s->usrp->get_clock_source(0) == "external") {
       if (check_ref_locked(s,0)) {
 	LOG_I(HW,"USRP locked to external reference!\n");