Merge branch 'integration_2024_w26b' into 'develop'

Integration: `2024.w26` (part 2)

See merge request oai/openairinterface5g!2823

* !2794 Power control changes
* !2816 Fix test asan errors
* !2820 fix(T): some missing dependencies on T
* !2714 FAPI P5 Refactoring and unitary test creation
* !2819 Prevent unnecessary assertions for invalid DCI at NR UE
* !2825 Do not extract CSI report if PUCCH format 2 CRC check fails in polar decoder
* !2805 GUAMI decoding and storing in RRC UE context fixed

CMakeLists.txt

@@ -723,20 +723,14 @@ target_link_libraries(SCHED_NR_UE_LIB PRIVATE asn1_lte_rrc_hdrs asn1_nr_rrc_hdrs
 
 # nFAPI
 #################################
-set(NFAPI_COMMON_SRC
-  ${NFAPI_DIR}/common/src/debug.c
-  )
-add_library(NFAPI_COMMON_LIB ${NFAPI_COMMON_SRC})
-
-include_directories(${NFAPI_DIR}/common/public_inc)
-
 set(NFAPI_SRC
-  ${NFAPI_DIR}/nfapi/src/nfapi.c
   ${NFAPI_DIR}/nfapi/src/nfapi_p4.c
   ${NFAPI_DIR}/nfapi/src/nfapi_p5.c
   ${NFAPI_DIR}/nfapi/src/nfapi_p7.c
 )
 add_library(NFAPI_LIB ${NFAPI_SRC})
+target_link_libraries(NFAPI_LIB PUBLIC nfapi_common)
+target_link_libraries(NFAPI_LIB PUBLIC nr_fapi_p5)
 
 include_directories(${NFAPI_DIR}/nfapi/public_inc)
 include_directories(${NFAPI_DIR}/nfapi/inc)
@@ -761,7 +755,10 @@ set(NFAPI_VNF_SRC
 )
 add_library(NFAPI_VNF_LIB ${NFAPI_VNF_SRC})
 target_link_libraries(NFAPI_VNF_LIB PRIVATE asn1_lte_rrc_hdrs asn1_nr_rrc_hdrs)
-
+target_link_libraries(NFAPI_VNF_LIB PRIVATE nr_fapi_p5)
+if(OAI_AERIAL)
+  target_compile_definitions(NFAPI_VNF_LIB PRIVATE ENABLE_AERIAL)
+endif()
 include_directories(${NFAPI_DIR}/vnf/public_inc)
 include_directories(${NFAPI_DIR}/vnf/inc)
 
@@ -1457,6 +1454,9 @@ add_library(e1_if
 target_link_libraries(e1_if PRIVATE asn1_nr_rrc_hdrs asn1_lte_rrc_hdrs asn1_f1ap SECURITY ${OPENSSL_LIBRARIES} e1ap GTPV1U)
 
 target_link_libraries(L2_NR PRIVATE f1ap x2ap s1ap ngap nr_rrc e1ap nr_rlc nr_common)
+if(OAI_AERIAL)
+    target_compile_definitions(L2_NR PRIVATE ENABLE_AERIAL)
+endif()
 if(E2_AGENT)
   target_link_libraries(L2_NR PUBLIC e2_agent e2_agent_arg e2_ran_func_du_cucp_cuup)
   target_compile_definitions(L2_NR PRIVATE ${E2AP_VERSION} ${KPM_VERSION} E2_AGENT)
@@ -1968,7 +1968,7 @@ add_dependencies(lte-softmodem oai_iqplayer)
 target_link_libraries(lte-softmodem PRIVATE
   -Wl,--start-group
   lte_rrc nr_rrc s1ap m2ap x2ap m3ap GTPV1U SECURITY UTIL HASHTABLE SCTP_CLIENT MME_APP SCHED_LIB SCHED_RU_LIB
-  PHY_COMMON PHY PHY_RU  L2 L2_LTE NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB MISC_NFAPI_LTE_LIB
+  PHY_COMMON PHY PHY_RU  L2 L2_LTE NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB MISC_NFAPI_LTE_LIB
   ${NAS_UE_LIB} ITTI SIMU SIMU_ETH shlib_loader
   -Wl,--end-group z dl)
 
@@ -2028,7 +2028,7 @@ target_link_libraries(lte-uesoftmodem PRIVATE
   -Wl,--start-group
   lte_rrc nr_rrc s1ap x2ap m2ap m3ap
   SECURITY UTIL HASHTABLE SCTP_CLIENT MME_APP SCHED_RU_LIB SCHED_UE_LIB PHY_COMMON
-  PHY_UE PHY_RU L2_UE L2_LTE SIMU SIMU_ETH NFAPI_COMMON_LIB NFAPI_LIB NFAPI_PNF_LIB NFAPI_USER_LIB MISC_NFAPI_LTE_LIB
+  PHY_UE PHY_RU L2_UE L2_LTE SIMU SIMU_ETH NFAPI_LIB NFAPI_PNF_LIB NFAPI_USER_LIB MISC_NFAPI_LTE_LIB
   ${NAS_UE_LIB} ITTI shlib_loader
   -Wl,--end-group z dl)
 
@@ -2061,13 +2061,11 @@ add_executable(nr-softmodem
   ${OPENAIR1_DIR}/PHY/TOOLS/phy_scope_interface.c
   )
 
-include(${OPENAIR_DIR}/nfapi/CMakeLists.txt)
-
 target_link_libraries(nr-softmodem PRIVATE
   -Wl,--start-group
   UTIL HASHTABLE SCTP_CLIENT SCHED_LIB SCHED_RU_LIB SCHED_NR_LIB PHY_NR PHY PHY_COMMON PHY_NR_COMMON PHY_RU GTPV1U SECURITY
   ITTI ${NAS_UE_LIB} lte_rrc nr_rrc
-  ngap s1ap L2_LTE_NR L2_NR MAC_NR_COMMON NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB SIMU SIMU_ETH
+  ngap s1ap L2_LTE_NR L2_NR MAC_NR_COMMON NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB SIMU SIMU_ETH
   x2ap f1ap m2ap m3ap e1ap shlib_loader
   -Wl,--end-group z dl)
 
@@ -2075,6 +2073,11 @@ target_link_libraries(nr-softmodem PRIVATE pthread m CONFIG_LIB rt sctp)
 target_link_libraries(nr-softmodem PRIVATE ${T_LIB})
 target_link_libraries(nr-softmodem PRIVATE asn1_nr_rrc_hdrs asn1_lte_rrc_hdrs)
 target_link_libraries(nr-softmodem PRIVATE asn1_nr_rrc_hdrs asn1_lte_rrc_hdrs)
+add_boolean_option(OAI_AERIAL OFF "Activate OAI's AERIAL driver" OFF)
+if (OAI_AERIAL)
+  target_compile_definitions(nr-softmodem PUBLIC ENABLE_AERIAL)
+  target_link_libraries(nr-softmodem PUBLIC aerial_lib)
+endif()
 if(E2_AGENT)
   target_compile_definitions(nr-softmodem PRIVATE ${E2AP_VERSION} ${KPM_VERSION} E2_AGENT)
 endif()
@@ -2131,7 +2134,7 @@ add_executable(nr-uesoftmodem
 target_link_libraries(nr-uesoftmodem PRIVATE
   -Wl,--start-group
   nr_rrc SECURITY UTIL HASHTABLE SCHED_RU_LIB SCHED_NR_UE_LIB
-  PHY_COMMON PHY_NR_COMMON PHY_NR_UE NR_L2_UE L2_UE_LTE_NR MAC_NR_COMMON NFAPI_COMMON_LIB NFAPI_LIB NFAPI_PNF_LIB
+  PHY_COMMON PHY_NR_COMMON PHY_NR_UE NR_L2_UE L2_UE_LTE_NR MAC_NR_COMMON NFAPI_LIB NFAPI_PNF_LIB
   NFAPI_USER_LIB MISC_NFAPI_NR_LIB
   ITTI LIB_5GNAS_GNB LIB_NAS_SIMUE ${NAS_SIM_LIB} SIMU SIMU_ETH shlib_loader
   -Wl,--end-group z dl)
@@ -2367,7 +2370,7 @@ if (${T_TRACER})
         params_libconfig oai_usrpdevif oai_bladerfdevif oai_lmssdrdevif oai_iqplayer
         oai_eth_transpro oai_mobipass coding HASHTABLE UTIL OMG_SUMO
         SECURITY SCHED_LIB SCHED_NR_LIB SCHED_RU_LIB SCHED_UE_LIB SCHED_NR_UE_LIB default_sched remote_sched RAL
-        NFAPI_COMMON_LIB NFAPI_LIB NFAPI_PNF_LIB NFAPI_VNF_LIB NFAPI_USER_LIB
+        NFAPI_LIB NFAPI_PNF_LIB NFAPI_VNF_LIB NFAPI_USER_LIB
         MISC_NFAPI_LTE_LIB MISC_NFAPI_NR_LIB
         PHY_COMMON PHY PHY_UE PHY_NR PHY_NR_COMMON PHY_NR_UE PHY_RU PHY_MEX
         L2 L2_LTE L2_NR L2_LTE_NR L2_UE NR_L2_UE L2_UE_LTE_NR MAC_NR_COMMON MAC_UE_NR ngap
@@ -2488,6 +2491,7 @@ endif()
 
 add_subdirectory(common)
 add_subdirectory(doc)
+add_subdirectory(nfapi)
 add_subdirectory(openair1)
 add_subdirectory(openair2)
 add_subdirectory(openair3)

ci-scripts/docker/Dockerfile.unittest.ubuntu22

@@ -37,4 +37,4 @@ WORKDIR /oai-ran
 COPY . .
 
 WORKDIR /oai-ran/build
-RUN cmake -GNinja -DENABLE_TESTS=ON -DCMAKE_BUILD_TYPE=Debug .. && ninja tests
+RUN cmake -GNinja -DENABLE_TESTS=ON -DCMAKE_BUILD_TYPE=Debug -DSANITIZE_ADDRESS=True .. && ninja tests

common/utils/nr/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_library(nr_common nr_common.c)
 target_include_directories(nr_common PUBLIC .)
+target_link_libraries(nr_common PRIVATE UTIL)
 if (ENABLE_TESTS)
   add_subdirectory(tests)
 endif()

common/utils/nr/nr_common.c

@@ -356,8 +356,8 @@ bool compare_relative_ul_channel_bw(int nr_band, int scs, int nb_ul, frame_type_
 
   int band_size_khz = get_supported_bw_mhz(nr_band > 256 ? FR2 : FR1, scs, nb_ul) * 1000;
   float limit = frame_type == TDD ? 0.04 : 0.03;
-  float rel_bw = (float) (2 * band_size_khz) / (float) (nr_bandtable[index].ul_max + nr_bandtable[index].ul_min);
-  return rel_bw <= limit;
+  float rel_bw = (float) (band_size_khz) / (float) (nr_bandtable[index].ul_max - nr_bandtable[index].ul_min);
+  return rel_bw > limit;
 }
 
 uint16_t get_band(uint64_t downlink_frequency, int32_t delta_duplex)

common/utils/telnetsrv/CMakeLists.txt

@@ -36,6 +36,7 @@ add_library(telnetsrv MODULE
 )
 target_link_libraries(telnetsrv PRIVATE history)
 target_link_libraries(telnetsrv PRIVATE asn1_nr_rrc_hdrs asn1_lte_rrc_hdrs)
+target_link_libraries(telnetsrv PRIVATE UTIL)
 
 message(STATUS "Add enb specific telnet functions in libtelnetsrv_enb.so")
 add_library(telnetsrv_enb MODULE

common/utils/threadPool/test/test_thread-pool.c

@@ -46,7 +46,7 @@ void displayList(notifiedFIFO_t *nf)
 struct testData {
   int id;
   int sleepTime;
-  char txt[30];
+  char txt[50];
 };
 
 void processing(void *arg)
@@ -64,21 +64,27 @@ int main()
   logInit();
   notifiedFIFO_t myFifo;
   initNotifiedFIFO(&myFifo);
+  int num_elements_on_queue = 0;
   pushNotifiedFIFO(&myFifo, newNotifiedFIFO_elt(sizeof(struct testData), 1234, NULL, NULL));
+  num_elements_on_queue++;
 
   for (int i = 10; i > 1; i--) {
     pushNotifiedFIFO(&myFifo, newNotifiedFIFO_elt(sizeof(struct testData), 1000 + i, NULL, NULL));
+    num_elements_on_queue++;
   }
 
   displayList(&myFifo);
   notifiedFIFO_elt_t *tmp = pullNotifiedFIFO(&myFifo);
   printf("pulled: %lu\n", tmp->key);
   displayList(&myFifo);
+  delNotifiedFIFO_elt(tmp);
   tmp = pullNotifiedFIFO(&myFifo);
+  num_elements_on_queue--;
   printf("pulled: %lu\n", tmp->key);
   displayList(&myFifo);
   pushNotifiedFIFO(&myFifo, newNotifiedFIFO_elt(sizeof(struct testData), 12345678, NULL, NULL));
   displayList(&myFifo);
+  delNotifiedFIFO_elt(tmp);
 
   do {
     tmp = pollNotifiedFIFO(&myFifo);
@@ -86,9 +92,12 @@ int main()
     if (tmp) {
       printf("pulled: %lu\n", tmp->key);
       displayList(&myFifo);
+      delNotifiedFIFO_elt(tmp);
+      num_elements_on_queue--;
     } else
       printf("Empty list \n");
-  } while (tmp);
+  } while (num_elements_on_queue > 0);
+  AssertFatal(pollNotifiedFIFO(&myFifo) == NULL, "Unexpected extra element on queue\n");
 
   tpool_t pool;
   char params[] = "1,2,3,4,5";
@@ -129,5 +138,6 @@ int main()
          dur / 1000,
          cumulProcessTime / 1000,
          (dur - cumulProcessTime) / (1000 * nb_jobs));
+  abortTpool(&pool);
   return 0;
 }

common/utils/threadPool/thread-pool.h

@@ -336,7 +336,9 @@ static inline int abortTpool(tpool_t *t) {
   thread = t->allthreads;
   while (thread != NULL) {
     pthread_cancel(thread->threadID);
-    thread = thread->next;
+    struct one_thread *next = thread->next;
+    free(thread);
+    thread = next;
   }
 
   return nbRemoved;

nfapi/CMakeLists.txt

@@ -1 +1,3 @@
-include(${OPENAIR_DIR}/nfapi/oai_integration/aerial/CMakeLists.txt)
+add_subdirectory(oai_integration/aerial)
+add_subdirectory(open-nFAPI)
+add_subdirectory(tests)

nfapi/oai_integration/aerial/CMakeLists.txt

@@ -1,20 +1,16 @@
-add_boolean_option(OAI_AERIAL OFF "Activate OAI's AERIAL driver" OFF)
 if (OAI_AERIAL)
     message(STATUS "Building with support for Aerial")
-
-    target_sources(
-            nr-softmodem
-            PRIVATE
-            ${OPENAIR_DIR}/nfapi/oai_integration/aerial/fapi_nvIPC.c
-            ${OPENAIR_DIR}/nfapi/oai_integration/aerial/fapi_vnf_p7.c
-            ${OPENAIR_DIR}/nfapi/oai_integration/aerial/fapi_vnf_p5.c )
+    add_library(aerial_lib
+            fapi_nvIPC.c
+            fapi_vnf_p7.c
+            fapi_vnf_p5.c
+    )
 
     find_library(NVIPC_LIB nvipc REQUIRED)
     if (NOT NVIPC_LIB)
         message(FATAL_ERROR "-- nvipc library not found")
     else ()
         message(STATUS "  nvipc library found in ${NVIPC_LIB}")
-        #add_library(nvipc   STATIC  SHARED IMPORTED GLOBAL)
     endif ()
 
     find_library(NVLOG_LIB nvlog REQUIRED)
@@ -23,11 +19,10 @@ if (OAI_AERIAL)
     else ()
         message(STATUS "  nvlog library found in ${NVLOG_LIB}")
     endif ()
-
-    add_compile_definitions(ENABLE_L2_SLT_RSP)
-    add_compile_definitions(FAPI_BYTE_ORDERING_BIG_ENDIAN)
-    add_compile_definitions(ENABLE_AERIAL)
-    target_link_libraries(nr-softmodem PRIVATE  "${NVLOG_LIB}" "${NVIPC_LIB}")
-else()
+    target_compile_definitions(aerial_lib PUBLIC ENABLE_L2_SLT_RSP ENABLE_AERIAL)
+    target_link_libraries(aerial_lib PRIVATE asn1_lte_rrc_hdrs asn1_nr_rrc_hdrs)
+    target_link_libraries(aerial_lib PRIVATE nr_fapi_p5)
+    target_link_libraries(aerial_lib PRIVATE "${NVLOG_LIB}" "${NVIPC_LIB}")
+else ()
     message(STATUS "No Support for Aerial")
-endif()
+endif ()

nfapi/oai_integration/aerial/fapi_vnf_p5.c

@@ -32,8 +32,9 @@
 #ifdef ENABLE_AERIAL
 #include "fapi_vnf_p5.h"
 #include "fapi_vnf_p7.h"
-#include "nfapi/open-nFAPI/nfapi/src/nfapi_p5.c"
 #include "nfapi/open-nFAPI/vnf/inc/vnf_p7.h"
+#include "nr_fapi.h"
+#include "nr_fapi_p5.h"
 
 extern RAN_CONTEXT_t RC;
 extern UL_RCC_IND_t UL_RCC_INFO;
@@ -621,61 +622,6 @@ int aerial_nfapi_nr_vnf_p7_start(nfapi_vnf_p7_config_t *config)
   return 0;
 }
 
-int fapi_nr_p5_message_pack(void *pMessageBuf, uint32_t messageBufLen, void *pPackedBuf, uint32_t packedBufLen, nfapi_p4_p5_codec_config_t *config){
-
-  nfapi_p4_p5_message_header_t *pMessageHeader = pMessageBuf;
-  uint8_t *pWritePackedMessage = pPackedBuf;
-
-  uint32_t packedMsgLen;
-  //uint16_t packedMsgLen16;
-
-  if (pMessageBuf == NULL || pPackedBuf == NULL) {
-    NFAPI_TRACE(NFAPI_TRACE_ERROR, "P5 Pack supplied pointers are null\n");
-    return -1;
-  }
-  uint8_t *pPackMessageEnd = pPackedBuf + packedBufLen;
-  uint8_t *pPackedLengthField = &pWritePackedMessage[4];
-  uint8_t *pPacketBodyField = &pWritePackedMessage[8];
-  uint8_t *pPacketBodyFieldStart = &pWritePackedMessage[8];
-
-  pack_nr_p5_message_body(pMessageHeader, &pPacketBodyField, pPackMessageEnd, config);
-
-  // PHY API message header
-  push8(1, &pWritePackedMessage, pPackMessageEnd); // Number of messages
-  push8(0, &pWritePackedMessage, pPackMessageEnd); // Opaque handle
-
-  // PHY API Message structure
-  push16(pMessageHeader->message_id, &pWritePackedMessage, pPackMessageEnd); // Message type ID
-
-  if(1==1) {
-    // check for a valid message length
-    packedMsgLen = get_packed_msg_len((uintptr_t)pPacketBodyFieldStart, (uintptr_t)pPacketBodyField);
-    packedMsgLen-=1;
-    if(pMessageHeader->message_id == NFAPI_NR_PHY_MSG_TYPE_START_REQUEST){
-      //START.request doesn't have a body, length is 0
-      packedMsgLen = 0;
-    }else if (packedMsgLen > 0xFFFF || packedMsgLen > packedBufLen) {
-      NFAPI_TRACE(NFAPI_TRACE_ERROR, "Packed message 0x%02x length error %d, buffer supplied %d\n",pMessageHeader->message_id, packedMsgLen, packedBufLen);
-      return -1;
-    } else {
-
-    }
-
-    // Update the message length in the header
-    if(!push32(packedMsgLen, &pPackedLengthField, pPackMessageEnd))
-      return -1;
-
-    // return the packed length
-    return (packedMsgLen);
-  } else {
-    // Failed to pack the meassage
-    NFAPI_TRACE(NFAPI_TRACE_ERROR, "P5 Failed to pack message\n");
-    return -1;
-  }
-
-}
-
-
 int oai_fapi_ul_tti_req(nfapi_nr_ul_tti_request_t *ul_tti_req)
 {
   nfapi_vnf_p7_config_t *p7_config = aerial_vnf.p7_vnfs[0].config;

nfapi/oai_integration/aerial/fapi_vnf_p5.h

@@ -65,7 +65,6 @@ uint8_t aerial_unpack_nr_param_response(uint8_t **ppReadPackedMsg, uint8_t *end,
 uint8_t aerial_unpack_nr_config_response(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
 int aerial_pnf_nr_connection_indication_cb(nfapi_vnf_config_t *config, int p5_idx);
 int aerial_nfapi_nr_vnf_p7_start(nfapi_vnf_p7_config_t *config);
-int fapi_nr_p5_message_pack(void *pMessageBuf, uint32_t messageBufLen, void *pPackedBuf, uint32_t packedBufLen, nfapi_p4_p5_codec_config_t* config);
 
 int oai_fapi_ul_tti_req(nfapi_nr_ul_tti_request_t *ul_tti_req);
 int oai_fapi_ul_dci_req(nfapi_nr_ul_dci_request_t *ul_dci_req);

nfapi/oai_integration/aerial/fapi_vnf_p7.c

@@ -31,7 +31,7 @@
  */
 #ifdef ENABLE_AERIAL
 #include "fapi_vnf_p7.h"
-#include "nfapi/open-nFAPI/nfapi/src/nfapi_p7.c"
+#include "nr_nfapi_p7.h"
 
 extern RAN_CONTEXT_t RC;
 extern UL_RCC_IND_t UL_RCC_INFO;

nfapi/oai_integration/aerial/fapi_vnf_p7.h

@@ -45,6 +45,7 @@
 #include <netinet/in.h>
 #include <arpa/inet.h>
 
+#include "nfapi_interface.h"
 #include "nfapi_nr_interface_scf.h"
 #include "nfapi_vnf_interface.h"
 #include "nfapi_vnf.h"

nfapi/open-nFAPI/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_subdirectory(common)
+add_subdirectory(fapi)

nfapi/open-nFAPI/common/CMakeLists.txt

@@ -0,0 +1,7 @@
+add_library(nfapi_common
+            src/debug.c
+            src/nfapi.c)
+target_include_directories(nfapi_common PUBLIC public_inc/)
+if (OAI_AERIAL)
+    target_compile_definitions(nfapi_common PRIVATE FAPI_BYTE_ORDERING_BIG_ENDIAN)
+endif()

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

@@ -77,8 +77,8 @@ uint8_t unpackarray(uint8_t **ppReadPackedMsg,
                     uint8_t *end,
                     unpack_array_elem_fn fn);
 
-uint32_t pack_dci_payload(uint8_t payload[], uint16_t payloadSizeBits, uint8_t **out, uint8_t *end);
-uint32_t unpack_dci_payload(uint8_t payload[], uint16_t payloadSizeBits, uint8_t **in, uint8_t *end);
+uint32_t pack_dci_payload(uint8_t *payload, uint16_t payloadSizeBits, uint8_t **out, uint8_t *end);
+uint32_t unpack_dci_payload(uint8_t *payload, uint16_t payloadSizeBits, uint8_t **in, uint8_t *end);
 
 uint8_t pack_tl(nfapi_tl_t *tl, uint8_t **ppWritePackedMsg, uint8_t *end);
 uint8_t unpack_tl(uint8_t **ppReadPackedMsg, nfapi_tl_t *tl, uint8_t *end);
@@ -86,6 +86,7 @@ uint8_t unpack_tl(uint8_t **ppReadPackedMsg, nfapi_tl_t *tl, uint8_t *end);
 typedef uint8_t (*pack_tlv_fn)(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
 uint8_t pack_tlv(uint16_t tag, void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end, pack_tlv_fn fn);
 uint8_t pack_nr_tlv(uint16_t tag, void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end, pack_tlv_fn fn);
+uint8_t pack_nr_generic_tlv(uint16_t tag, void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
 
 uint32_t pack_vendor_extension_tlv(nfapi_tl_t *ve, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
 int unpack_vendor_extension_tlv(nfapi_tl_t *tl,
@@ -94,6 +95,8 @@ int unpack_vendor_extension_tlv(nfapi_tl_t *tl,
                                 nfapi_p4_p5_codec_config_t *config,
                                 nfapi_tl_t **ve_tlv);
 
+uint8_t unpack_nr_generic_tlv_list(void *tlv_list, uint8_t tlv_count, uint8_t **ppReadPackedMsg, uint8_t *end);
+
 uint8_t get_tlv_padding(uint16_t tlv_length);
 
 typedef uint8_t (*unpack_tlv_fn)(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
@@ -136,6 +139,50 @@ int unpack_nr_p7_tlv_list(unpack_p7_tlv_t unpack_fns[],
                           nfapi_p7_codec_config_t *config,
                           nfapi_tl_t **ve);
 
+uint8_t pack_pnf_param_general_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_pnf_param_general_value(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint8_t pack_rf_config_info(void *elem, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_rf_config_info(void *elem, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint8_t pack_pnf_phy_info(void *elem, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_pnf_phy_info(void *elem, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint8_t pack_pnf_phy_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_pnf_phy_value(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint8_t pack_phy_rf_config_info(void *elem, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_phy_rf_config_info(void *elem, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint8_t pack_pnf_phy_rf_config_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_pnf_phy_rf_config_value(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint8_t pack_ipv4_address_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_ipv4_address_value(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint8_t pack_ipv6_address_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_ipv6_address_value(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint8_t pack_stop_response(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
+uint8_t unpack_stop_response(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
+
+uint8_t pack_measurement_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
+uint8_t unpack_measurement_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
+
+uint8_t pack_uint32_tlv_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_uint32_tlv_value(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint8_t pack_uint16_tlv_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_uint16_tlv_value(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint8_t pack_int16_tlv_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_int16_tlv_value(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint8_t pack_uint8_tlv_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end);
+uint8_t unpack_uint8_tlv_value(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end);
+
+uint32_t get_packed_msg_len(uintptr_t msgHead, uintptr_t msgEnd);
+
 #if defined(__cplusplus)
 }
 #endif

nfapi/open-nFAPI/fapi/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_library(nr_fapi_p5
+        src/nr_fapi_p5.c
+        src/nr_fapi_p5_utils.c
+)
+target_include_directories(nr_fapi_p5 PUBLIC inc)
+target_link_libraries(nr_fapi_p5 PUBLIC nfapi_common)

nfapi/open-nFAPI/fapi/inc/nr_fapi.h

@@ -0,0 +1,72 @@
+/*
+ * 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 nfapi/open-nFAPI/fapi/inc/nr_fapi.h
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+
+#ifndef OPENAIRINTERFACE_NR_FAPI_H
+#define OPENAIRINTERFACE_NR_FAPI_H
+
+#include "stdint.h"
+#include "string.h"
+#include "nfapi_interface.h"
+#include "nfapi_nr_interface.h"
+#include "nfapi_nr_interface_scf.h"
+#include "nfapi.h"
+#include "nfapi/oai_integration/vendor_ext.h"
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include "assertions.h"
+
+typedef struct {
+  uint8_t num_msg;
+  uint8_t opaque_handle;
+  uint16_t message_id;
+  uint32_t message_length;
+} fapi_message_header_t;
+
+int fapi_nr_p5_message_header_unpack(uint8_t **pMessageBuf,
+                                     uint32_t messageBufLen,
+                                     void *pUnpackedBuf,
+                                     uint32_t unpackedBufLen,
+                                     nfapi_p4_p5_codec_config_t *config);
+
+int fapi_nr_p5_message_pack(void *pMessageBuf,
+                            uint32_t messageBufLen,
+                            void *pPackedBuf,
+                            uint32_t packedBufLen,
+                            nfapi_p4_p5_codec_config_t *config);
+
+int fapi_nr_p5_message_unpack(void *pMessageBuf,
+                              uint32_t messageBufLen,
+                              void *pUnpackedBuf,
+                              uint32_t unpackedBufLen,
+                              nfapi_p4_p5_codec_config_t *config);
+
+int check_nr_fapi_unpack_length(nfapi_nr_phy_msg_type_e msgId, uint32_t unpackedBufLen);
+#endif // OPENAIRINTERFACE_NR_FAPI_H

nfapi/open-nFAPI/fapi/inc/nr_fapi_p5.h

@@ -0,0 +1,55 @@
+/*
+ * 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 nfapi/open-nFAPI/fapi/inc/nr_fapi_p5.h
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+
+#ifndef OPENAIRINTERFACE_NR_FAPI_P5_H
+#define OPENAIRINTERFACE_NR_FAPI_P5_H
+#include "stdint.h"
+#include "nfapi_interface.h"
+
+uint8_t pack_nr_param_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
+uint8_t unpack_nr_param_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
+uint8_t pack_nr_param_response(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
+uint8_t unpack_nr_param_response(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
+uint8_t pack_nr_config_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
+uint8_t unpack_nr_config_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
+uint8_t pack_nr_config_response(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
+uint8_t unpack_nr_config_response(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
+uint8_t pack_nr_start_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
+uint8_t unpack_nr_start_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
+uint8_t pack_nr_start_response(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
+uint8_t unpack_nr_start_response(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
+uint8_t pack_nr_stop_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
+uint8_t unpack_nr_stop_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
+uint8_t pack_nr_stop_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
+uint8_t unpack_nr_stop_indication(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
+uint8_t pack_nr_error_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t *config);
+uint8_t unpack_nr_error_indication(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p4_p5_codec_config_t *config);
+#endif // OPENAIRINTERFACE_NR_FAPI_P5_H

nfapi/open-nFAPI/fapi/inc/nr_fapi_p5_utils.h

@@ -0,0 +1,96 @@
+/*
+ * 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 nfapi/open-nFAPI/fapi/inc/nr_fapi_p5_utils.h
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+
+#ifndef OPENAIRINTERFACE_NR_FAPI_P5_UTILS_H
+#define OPENAIRINTERFACE_NR_FAPI_P5_UTILS_H
+#include "stdio.h"
+#include "stdint.h"
+#include "nr_fapi.h"
+#include "nfapi/oai_integration/vendor_ext.h"
+
+#define EQ_TLV(_tlv_a, _tlv_b)        \
+  do {                                \
+    EQ(_tlv_a.tl.tag, _tlv_b.tl.tag); \
+    EQ(_tlv_a.value, _tlv_b.value);   \
+  } while (0)
+
+#define EQ(_a, _b)      \
+  do {                  \
+    if ((_a) != (_b)) { \
+      return false;     \
+    }                   \
+  } while (0)
+
+#define COPY_TL(_dst_tl, _src_tl)    \
+  do {                               \
+    _dst_tl.tag = _src_tl.tag;       \
+    _dst_tl.length = _src_tl.length; \
+  } while (0)
+
+#define COPY_TLV(_dst, _src)   \
+  do {                         \
+    COPY_TL(_dst.tl, _src.tl); \
+    _dst.value = _src.value;   \
+  } while (0)
+
+void copy_vendor_extension_value(nfapi_vendor_extension_tlv_t *dst, const nfapi_vendor_extension_tlv_t *src);
+
+bool eq_param_request(const nfapi_nr_param_request_scf_t *unpacked_req, const nfapi_nr_param_request_scf_t *req);
+bool eq_param_response(const nfapi_nr_param_response_scf_t *unpacked_req, const nfapi_nr_param_response_scf_t *req);
+bool eq_config_request(const nfapi_nr_config_request_scf_t *unpacked_req, const nfapi_nr_config_request_scf_t *req);
+bool eq_config_response(const nfapi_nr_config_response_scf_t *unpacked_req, const nfapi_nr_config_response_scf_t *req);
+bool eq_start_request(const nfapi_nr_start_request_scf_t *unpacked_req, const nfapi_nr_start_request_scf_t *req);
+bool eq_start_response(const nfapi_nr_start_response_scf_t *unpacked_req, const nfapi_nr_start_response_scf_t *req);
+bool eq_stop_request(const nfapi_nr_stop_request_scf_t *unpacked_req, const nfapi_nr_stop_request_scf_t *req);
+bool eq_stop_indication(const nfapi_nr_stop_indication_scf_t *unpacked_req, const nfapi_nr_stop_indication_scf_t *req);
+bool eq_error_indication(const nfapi_nr_error_indication_scf_t *unpacked_req, const nfapi_nr_error_indication_scf_t *req);
+
+void free_param_request(nfapi_nr_param_request_scf_t *msg);
+void free_param_response(nfapi_nr_param_response_scf_t *msg);
+void free_config_request(nfapi_nr_config_request_scf_t *msg);
+void free_config_response(nfapi_nr_config_response_scf_t *msg);
+void free_start_request(nfapi_nr_start_request_scf_t *msg);
+void free_start_response(nfapi_nr_start_response_scf_t *msg);
+void free_stop_request(nfapi_nr_stop_request_scf_t *msg);
+void free_stop_indication(nfapi_nr_stop_indication_scf_t *msg);
+void free_error_indication(nfapi_nr_error_indication_scf_t *msg);
+
+void copy_param_request(const nfapi_nr_param_request_scf_t *src, nfapi_nr_param_request_scf_t *dst);
+void copy_param_response(const nfapi_nr_param_response_scf_t *src, nfapi_nr_param_response_scf_t *dst);
+void copy_config_request(const nfapi_nr_config_request_scf_t *src, nfapi_nr_config_request_scf_t *dst);
+void copy_config_response(const nfapi_nr_config_response_scf_t *src, nfapi_nr_config_response_scf_t *dst);
+void copy_start_request(const nfapi_nr_start_request_scf_t *src, nfapi_nr_start_request_scf_t *dst);
+void copy_start_response(const nfapi_nr_start_response_scf_t *src, nfapi_nr_start_response_scf_t *dst);
+void copy_stop_request(const nfapi_nr_stop_request_scf_t *src, nfapi_nr_stop_request_scf_t *dst);
+void copy_stop_indication(const nfapi_nr_stop_indication_scf_t *src, nfapi_nr_stop_indication_scf_t *dst);
+void copy_error_indication(const nfapi_nr_error_indication_scf_t *src, nfapi_nr_error_indication_scf_t *dst);
+
+#endif // OPENAIRINTERFACE_NR_FAPI_P5_UTILS_H

nfapi/open-nFAPI/fapi/src/nr_fapi_p5_utils.c

@@ -0,0 +1,971 @@
+/*
+ * 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 nfapi/open-nFAPI/fapi/src/nr_fapi_p5_utils.c
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+#include "nr_fapi_p5_utils.h"
+
+void copy_vendor_extension_value(nfapi_vendor_extension_tlv_t *dst, const nfapi_vendor_extension_tlv_t *src)
+{
+  nfapi_tl_t *dst_tlv = (nfapi_tl_t *)dst;
+  nfapi_tl_t *src_tlv = (nfapi_tl_t *)src;
+
+  switch (dst_tlv->tag) {
+    case VENDOR_EXT_TLV_2_TAG: {
+      vendor_ext_tlv_2 *dst_ve = (vendor_ext_tlv_2 *)dst_tlv;
+      vendor_ext_tlv_2 *src_ve = (vendor_ext_tlv_2 *)src_tlv;
+
+      dst_ve->dummy = src_ve->dummy;
+    } break;
+    case VENDOR_EXT_TLV_1_TAG: {
+      vendor_ext_tlv_1 *dst_ve = (vendor_ext_tlv_1 *)dst_tlv;
+      vendor_ext_tlv_1 *src_ve = (vendor_ext_tlv_1 *)src_tlv;
+
+      dst_ve->dummy = src_ve->dummy;
+    } break;
+  }
+}
+
+bool eq_param_request(const nfapi_nr_param_request_scf_t *unpacked_req, const nfapi_nr_param_request_scf_t *req)
+{
+  EQ(unpacked_req->header.message_id, req->header.message_id);
+  EQ(unpacked_req->header.message_length, req->header.message_length);
+  return true;
+}
+
+bool eq_param_response(const nfapi_nr_param_response_scf_t *unpacked_req, const nfapi_nr_param_response_scf_t *req)
+{
+  EQ(unpacked_req->header.message_id, req->header.message_id);
+  EQ(unpacked_req->header.message_length, req->header.message_length);
+  EQ(unpacked_req->num_tlv, req->num_tlv);
+  EQ(unpacked_req->error_code, req->error_code);
+
+  EQ_TLV(unpacked_req->cell_param.release_capability, req->cell_param.release_capability);
+
+  EQ_TLV(unpacked_req->cell_param.phy_state, req->cell_param.phy_state);
+
+  EQ_TLV(unpacked_req->cell_param.skip_blank_dl_config, req->cell_param.skip_blank_dl_config);
+
+  EQ_TLV(unpacked_req->cell_param.skip_blank_ul_config, req->cell_param.skip_blank_ul_config);
+
+  EQ_TLV(unpacked_req->cell_param.num_config_tlvs_to_report, req->cell_param.num_config_tlvs_to_report);
+
+  for (int i = 0; i < unpacked_req->cell_param.num_config_tlvs_to_report.value; ++i) {
+    EQ_TLV(unpacked_req->cell_param.config_tlvs_to_report_list[i], req->cell_param.config_tlvs_to_report_list[i]);
+  }
+
+  EQ_TLV(unpacked_req->carrier_param.cyclic_prefix, req->carrier_param.cyclic_prefix);
+
+  EQ_TLV(unpacked_req->carrier_param.supported_subcarrier_spacings_dl, req->carrier_param.supported_subcarrier_spacings_dl);
+
+  EQ_TLV(unpacked_req->carrier_param.supported_bandwidth_dl, req->carrier_param.supported_bandwidth_dl);
+
+  EQ_TLV(unpacked_req->carrier_param.supported_subcarrier_spacings_ul, req->carrier_param.supported_subcarrier_spacings_ul);
+
+  EQ_TLV(unpacked_req->carrier_param.supported_bandwidth_ul, req->carrier_param.supported_bandwidth_ul);
+
+  EQ_TLV(unpacked_req->pdcch_param.cce_mapping_type, req->pdcch_param.cce_mapping_type);
+
+  EQ_TLV(unpacked_req->pdcch_param.coreset_outside_first_3_of_ofdm_syms_of_slot,
+         req->pdcch_param.coreset_outside_first_3_of_ofdm_syms_of_slot);
+
+  EQ_TLV(unpacked_req->pdcch_param.coreset_precoder_granularity_coreset, req->pdcch_param.coreset_precoder_granularity_coreset);
+
+  EQ_TLV(unpacked_req->pdcch_param.pdcch_mu_mimo, req->pdcch_param.pdcch_mu_mimo);
+
+  EQ_TLV(unpacked_req->pdcch_param.pdcch_precoder_cycling, req->pdcch_param.pdcch_precoder_cycling);
+
+  EQ_TLV(unpacked_req->pdcch_param.max_pdcch_per_slot, req->pdcch_param.max_pdcch_per_slot);
+
+  EQ_TLV(unpacked_req->pucch_param.pucch_formats, req->pucch_param.pucch_formats);
+
+  EQ_TLV(unpacked_req->pucch_param.max_pucchs_per_slot, req->pucch_param.max_pucchs_per_slot);
+
+  EQ_TLV(unpacked_req->pdsch_param.pdsch_mapping_type, req->pdsch_param.pdsch_mapping_type);
+
+  EQ_TLV(unpacked_req->pdsch_param.pdsch_allocation_types, req->pdsch_param.pdsch_allocation_types);
+
+  EQ_TLV(unpacked_req->pdsch_param.pdsch_vrb_to_prb_mapping, req->pdsch_param.pdsch_vrb_to_prb_mapping);
+
+  EQ_TLV(unpacked_req->pdsch_param.pdsch_cbg, req->pdsch_param.pdsch_cbg);
+
+  EQ_TLV(unpacked_req->pdsch_param.pdsch_dmrs_config_types, req->pdsch_param.pdsch_dmrs_config_types);
+
+  EQ_TLV(unpacked_req->pdsch_param.pdsch_dmrs_max_length, req->pdsch_param.pdsch_dmrs_max_length);
+
+  EQ_TLV(unpacked_req->pdsch_param.pdsch_dmrs_additional_pos, req->pdsch_param.pdsch_dmrs_additional_pos);
+
+  EQ_TLV(unpacked_req->pdsch_param.max_pdsch_tbs_per_slot, req->pdsch_param.max_pdsch_tbs_per_slot);
+
+  EQ_TLV(unpacked_req->pdsch_param.max_number_mimo_layers_pdsch, req->pdsch_param.max_number_mimo_layers_pdsch);
+
+  EQ_TLV(unpacked_req->pdsch_param.supported_max_modulation_order_dl, req->pdsch_param.supported_max_modulation_order_dl);
+
+  EQ_TLV(unpacked_req->pdsch_param.max_mu_mimo_users_dl, req->pdsch_param.max_mu_mimo_users_dl);
+
+  EQ_TLV(unpacked_req->pdsch_param.pdsch_data_in_dmrs_symbols, req->pdsch_param.pdsch_data_in_dmrs_symbols);
+
+  EQ_TLV(unpacked_req->pdsch_param.premption_support, req->pdsch_param.premption_support);
+
+  EQ_TLV(unpacked_req->pdsch_param.pdsch_non_slot_support, req->pdsch_param.pdsch_non_slot_support);
+
+  EQ_TLV(unpacked_req->pusch_param.uci_mux_ulsch_in_pusch, req->pusch_param.uci_mux_ulsch_in_pusch);
+
+  EQ_TLV(unpacked_req->pusch_param.uci_only_pusch, req->pusch_param.uci_only_pusch);
+
+  EQ_TLV(unpacked_req->pusch_param.pusch_frequency_hopping, req->pusch_param.pusch_frequency_hopping);
+
+  EQ_TLV(unpacked_req->pusch_param.pusch_dmrs_config_types, req->pusch_param.pusch_dmrs_config_types);
+
+  EQ_TLV(unpacked_req->pusch_param.pusch_dmrs_max_len, req->pusch_param.pusch_dmrs_max_len);
+
+  EQ_TLV(unpacked_req->pusch_param.pusch_dmrs_additional_pos, req->pusch_param.pusch_dmrs_additional_pos);
+
+  EQ_TLV(unpacked_req->pusch_param.pusch_cbg, req->pusch_param.pusch_cbg);
+
+  EQ_TLV(unpacked_req->pusch_param.pusch_mapping_type, req->pusch_param.pusch_mapping_type);
+
+  EQ_TLV(unpacked_req->pusch_param.pusch_allocation_types, req->pusch_param.pusch_allocation_types);
+
+  EQ_TLV(unpacked_req->pusch_param.pusch_vrb_to_prb_mapping, req->pusch_param.pusch_vrb_to_prb_mapping);
+
+  EQ_TLV(unpacked_req->pusch_param.pusch_max_ptrs_ports, req->pusch_param.pusch_max_ptrs_ports);
+
+  EQ_TLV(unpacked_req->pusch_param.max_pduschs_tbs_per_slot, req->pusch_param.max_pduschs_tbs_per_slot);
+
+  EQ_TLV(unpacked_req->pusch_param.max_number_mimo_layers_non_cb_pusch, req->pusch_param.max_number_mimo_layers_non_cb_pusch);
+
+  EQ_TLV(unpacked_req->pusch_param.supported_modulation_order_ul, req->pusch_param.supported_modulation_order_ul);
+
+  EQ_TLV(unpacked_req->pusch_param.max_mu_mimo_users_ul, req->pusch_param.max_mu_mimo_users_ul);
+
+  EQ_TLV(unpacked_req->pusch_param.dfts_ofdm_support, req->pusch_param.dfts_ofdm_support);
+
+  EQ_TLV(unpacked_req->pusch_param.pusch_aggregation_factor, req->pusch_param.pusch_aggregation_factor);
+
+  EQ_TLV(unpacked_req->prach_param.prach_long_formats, req->prach_param.prach_long_formats);
+
+  EQ_TLV(unpacked_req->prach_param.prach_short_formats, req->prach_param.prach_short_formats);
+
+  EQ_TLV(unpacked_req->prach_param.prach_restricted_sets, req->prach_param.prach_restricted_sets);
+
+  EQ_TLV(unpacked_req->prach_param.max_prach_fd_occasions_in_a_slot, req->prach_param.max_prach_fd_occasions_in_a_slot);
+
+  EQ_TLV(unpacked_req->measurement_param.rssi_measurement_support, req->measurement_param.rssi_measurement_support);
+
+  return true;
+}
+
+bool eq_config_request(const nfapi_nr_config_request_scf_t *unpacked_req, const nfapi_nr_config_request_scf_t *req)
+{
+  EQ(unpacked_req->header.message_id, req->header.message_id);
+  EQ(unpacked_req->header.message_length, req->header.message_length);
+  EQ(unpacked_req->num_tlv, req->num_tlv);
+
+  EQ_TLV(unpacked_req->carrier_config.dl_bandwidth, req->carrier_config.dl_bandwidth);
+
+  EQ_TLV(unpacked_req->carrier_config.dl_frequency, req->carrier_config.dl_frequency);
+
+  for (int i = 0; i < 5; ++i) {
+    EQ_TLV(unpacked_req->carrier_config.dl_k0[i], req->carrier_config.dl_k0[i]);
+
+    EQ_TLV(unpacked_req->carrier_config.dl_grid_size[i], req->carrier_config.dl_grid_size[i]);
+  }
+
+  EQ_TLV(unpacked_req->carrier_config.num_tx_ant, req->carrier_config.num_tx_ant);
+
+  EQ_TLV(unpacked_req->carrier_config.uplink_bandwidth, req->carrier_config.uplink_bandwidth);
+
+  EQ_TLV(unpacked_req->carrier_config.uplink_frequency, req->carrier_config.uplink_frequency);
+
+  for (int i = 0; i < 5; ++i) {
+    EQ_TLV(unpacked_req->carrier_config.ul_k0[i], req->carrier_config.ul_k0[i]);
+
+    EQ_TLV(unpacked_req->carrier_config.ul_grid_size[i], req->carrier_config.ul_grid_size[i]);
+  }
+
+  EQ_TLV(unpacked_req->carrier_config.num_rx_ant, req->carrier_config.num_rx_ant);
+
+  EQ_TLV(unpacked_req->carrier_config.frequency_shift_7p5khz, req->carrier_config.frequency_shift_7p5khz);
+
+  EQ_TLV(unpacked_req->cell_config.phy_cell_id, req->cell_config.phy_cell_id);
+
+  EQ_TLV(unpacked_req->cell_config.frame_duplex_type, req->cell_config.frame_duplex_type);
+
+  EQ_TLV(unpacked_req->ssb_config.ss_pbch_power, req->ssb_config.ss_pbch_power);
+
+  EQ_TLV(unpacked_req->ssb_config.bch_payload, req->ssb_config.bch_payload);
+
+  EQ_TLV(unpacked_req->ssb_config.scs_common, req->ssb_config.scs_common);
+
+  EQ_TLV(unpacked_req->prach_config.prach_sequence_length, req->prach_config.prach_sequence_length);
+
+  EQ_TLV(unpacked_req->prach_config.prach_sub_c_spacing, req->prach_config.prach_sub_c_spacing);
+
+  EQ_TLV(unpacked_req->prach_config.restricted_set_config, req->prach_config.restricted_set_config);
+
+  EQ_TLV(unpacked_req->prach_config.num_prach_fd_occasions, req->prach_config.num_prach_fd_occasions);
+
+  EQ_TLV(unpacked_req->prach_config.prach_ConfigurationIndex, req->prach_config.prach_ConfigurationIndex);
+
+  for (int i = 0; i < unpacked_req->prach_config.num_prach_fd_occasions.value; i++) {
+    nfapi_nr_num_prach_fd_occasions_t unpacked_prach_fd_occasion = unpacked_req->prach_config.num_prach_fd_occasions_list[i];
+    nfapi_nr_num_prach_fd_occasions_t req_prach_fd_occasion = req->prach_config.num_prach_fd_occasions_list[i];
+
+    EQ_TLV(unpacked_prach_fd_occasion.prach_root_sequence_index, req_prach_fd_occasion.prach_root_sequence_index);
+
+    EQ_TLV(unpacked_prach_fd_occasion.num_root_sequences, req_prach_fd_occasion.num_root_sequences);
+
+    EQ_TLV(unpacked_prach_fd_occasion.k1, req_prach_fd_occasion.k1);
+
+    EQ_TLV(unpacked_prach_fd_occasion.prach_zero_corr_conf, req_prach_fd_occasion.prach_zero_corr_conf);
+
+    EQ_TLV(unpacked_prach_fd_occasion.num_unused_root_sequences, req_prach_fd_occasion.num_unused_root_sequences);
+    for (int k = 0; k < unpacked_prach_fd_occasion.num_unused_root_sequences.value; k++) {
+      EQ_TLV(unpacked_prach_fd_occasion.unused_root_sequences_list[k], req_prach_fd_occasion.unused_root_sequences_list[k]);
+    }
+  }
+
+  EQ_TLV(unpacked_req->prach_config.ssb_per_rach, req->prach_config.ssb_per_rach);
+
+  EQ_TLV(unpacked_req->prach_config.prach_multiple_carriers_in_a_band, req->prach_config.prach_multiple_carriers_in_a_band);
+
+  EQ_TLV(unpacked_req->ssb_table.ssb_offset_point_a, req->ssb_table.ssb_offset_point_a);
+
+  EQ_TLV(unpacked_req->ssb_table.ssb_period, req->ssb_table.ssb_period);
+
+  EQ_TLV(unpacked_req->ssb_table.ssb_subcarrier_offset, req->ssb_table.ssb_subcarrier_offset);
+
+  EQ_TLV(unpacked_req->ssb_table.MIB, req->ssb_table.MIB);
+
+  EQ_TLV(unpacked_req->ssb_table.ssb_mask_list[0].ssb_mask, req->ssb_table.ssb_mask_list[0].ssb_mask);
+
+  EQ_TLV(unpacked_req->ssb_table.ssb_mask_list[1].ssb_mask, req->ssb_table.ssb_mask_list[1].ssb_mask);
+
+  for (int i = 0; i < 64; i++) {
+    EQ_TLV(unpacked_req->ssb_table.ssb_beam_id_list[i].beam_id, req->ssb_table.ssb_beam_id_list[i].beam_id);
+  }
+
+  EQ_TLV(unpacked_req->tdd_table.tdd_period, req->tdd_table.tdd_period);
+
+  const uint8_t slotsperframe[5] = {10, 20, 40, 80, 160};
+  // Assuming always CP_Normal, because Cyclic prefix is not included in CONFIG.request 10.02, but is present in 10.04
+  uint8_t cyclicprefix = 1;
+  bool normal_CP = cyclicprefix ? false : true;
+  // 3GPP 38.211 Table 4.3.2.1 & Table 4.3.2.2
+  uint8_t number_of_symbols_per_slot = normal_CP ? 14 : 12;
+
+  for (int i = 0; i < slotsperframe[unpacked_req->ssb_config.scs_common.value]; i++) {
+    for (int k = 0; k < number_of_symbols_per_slot; k++) {
+      EQ_TLV(unpacked_req->tdd_table.max_tdd_periodicity_list[i].max_num_of_symbol_per_slot_list[k].slot_config,
+             req->tdd_table.max_tdd_periodicity_list[i].max_num_of_symbol_per_slot_list[k].slot_config);
+    }
+  }
+
+  EQ_TLV(unpacked_req->measurement_config.rssi_measurement, req->measurement_config.rssi_measurement);
+
+  EQ(unpacked_req->nfapi_config.p7_vnf_address_ipv4.tl.tag, req->nfapi_config.p7_vnf_address_ipv4.tl.tag);
+  for (int i = 0; i < NFAPI_IPV4_ADDRESS_LENGTH; ++i) {
+    EQ(unpacked_req->nfapi_config.p7_vnf_address_ipv4.address[i], req->nfapi_config.p7_vnf_address_ipv4.address[i]);
+  }
+
+  EQ(unpacked_req->nfapi_config.p7_vnf_address_ipv6.tl.tag, req->nfapi_config.p7_vnf_address_ipv6.tl.tag);
+  for (int i = 0; i < NFAPI_IPV6_ADDRESS_LENGTH; ++i) {
+    EQ(unpacked_req->nfapi_config.p7_vnf_address_ipv6.address[i], req->nfapi_config.p7_vnf_address_ipv6.address[i]);
+  }
+
+  EQ_TLV(unpacked_req->nfapi_config.p7_vnf_port, req->nfapi_config.p7_vnf_port);
+
+  EQ_TLV(unpacked_req->nfapi_config.timing_window, req->nfapi_config.timing_window);
+
+  EQ_TLV(unpacked_req->nfapi_config.timing_info_mode, req->nfapi_config.timing_info_mode);
+
+  EQ_TLV(unpacked_req->nfapi_config.timing_info_period, req->nfapi_config.timing_info_period);
+  return true;
+}
+
+static bool eq_config_response_tlv_lists(nfapi_nr_generic_tlv_scf_t *unpacked_list,
+                                         nfapi_nr_generic_tlv_scf_t *req_list,
+                                         uint8_t size)
+{
+  for (int i = 0; i < size; ++i) {
+    nfapi_nr_generic_tlv_scf_t *unpacked_element = &(unpacked_list[i]);
+    nfapi_nr_generic_tlv_scf_t *req_element = &(req_list[i]);
+
+    EQ(unpacked_element->tl.tag, req_element->tl.tag);
+    EQ(unpacked_element->tl.length, req_element->tl.length);
+    // check according to value type
+    switch (unpacked_element->tl.length) {
+      case UINT_8:
+        EQ(unpacked_element->value.u8, req_element->value.u8);
+        break;
+      case UINT_16:
+        EQ(unpacked_element->value.u16, req_element->value.u16);
+        break;
+      case UINT_32:
+        EQ(unpacked_element->value.u32, req_element->value.u32);
+        break;
+      case ARRAY_UINT_16:
+        for (int j = 0; j < 5; ++j) {
+          EQ(unpacked_element->value.array_u16[j], req_element->value.array_u16[j]);
+        }
+        break;
+      default:
+        printf("unknown length %d\n", unpacked_element->tl.length);
+        DevAssert(1 == 0);
+        break;
+    }
+  }
+  return true;
+}
+
+bool eq_config_response(const nfapi_nr_config_response_scf_t *unpacked_req, const nfapi_nr_config_response_scf_t *req)
+{
+  EQ(unpacked_req->header.message_id, req->header.message_id);
+  EQ(unpacked_req->header.message_length, req->header.message_length);
+
+  EQ(unpacked_req->error_code, req->error_code);
+  EQ(unpacked_req->num_invalid_tlvs, req->num_invalid_tlvs);
+  EQ(unpacked_req->num_invalid_tlvs_configured_in_idle, req->num_invalid_tlvs_configured_in_idle);
+  EQ(unpacked_req->num_invalid_tlvs_configured_in_running, req->num_invalid_tlvs_configured_in_running);
+  EQ(unpacked_req->num_missing_tlvs, req->num_missing_tlvs);
+  // compare the list elements
+  EQ(eq_config_response_tlv_lists(unpacked_req->invalid_tlvs_list, req->invalid_tlvs_list, req->num_invalid_tlvs), true);
+  EQ(eq_config_response_tlv_lists(unpacked_req->invalid_tlvs_configured_in_idle_list,
+                                  req->invalid_tlvs_configured_in_idle_list,
+                                  req->num_invalid_tlvs_configured_in_idle),
+     true);
+  EQ(eq_config_response_tlv_lists(unpacked_req->invalid_tlvs_configured_in_running_list,
+                                  req->invalid_tlvs_configured_in_running_list,
+                                  req->num_invalid_tlvs_configured_in_running),
+     true);
+  EQ(eq_config_response_tlv_lists(unpacked_req->missing_tlvs_list, req->missing_tlvs_list, req->num_missing_tlvs), true);
+  return true;
+}
+
+bool eq_start_request(const nfapi_nr_start_request_scf_t *unpacked_req, const nfapi_nr_start_request_scf_t *req)
+{
+  EQ(unpacked_req->header.message_id, req->header.message_id);
+  EQ(unpacked_req->header.message_length, req->header.message_length);
+  return true;
+}
+
+bool eq_start_response(const nfapi_nr_start_response_scf_t *unpacked_req, const nfapi_nr_start_response_scf_t *req)
+{
+  EQ(unpacked_req->header.message_id, req->header.message_id);
+  EQ(unpacked_req->header.message_length, req->header.message_length);
+  EQ(unpacked_req->error_code, req->error_code);
+  return true;
+}
+
+bool eq_stop_request(const nfapi_nr_stop_request_scf_t *unpacked_req, const nfapi_nr_stop_request_scf_t *req)
+{
+  EQ(unpacked_req->header.message_id, req->header.message_id);
+  EQ(unpacked_req->header.message_length, req->header.message_length);
+  return true;
+}
+
+bool eq_stop_indication(const nfapi_nr_stop_indication_scf_t *unpacked_req, const nfapi_nr_stop_indication_scf_t *req)
+{
+  EQ(unpacked_req->header.message_id, req->header.message_id);
+  EQ(unpacked_req->header.message_length, req->header.message_length);
+  return true;
+}
+
+bool eq_error_indication(const nfapi_nr_error_indication_scf_t *unpacked_req, const nfapi_nr_error_indication_scf_t *req)
+{
+  EQ(unpacked_req->header.message_id, req->header.message_id);
+  EQ(unpacked_req->header.message_length, req->header.message_length);
+  EQ(unpacked_req->sfn, req->sfn);
+  EQ(unpacked_req->slot, req->slot);
+  EQ(unpacked_req->message_id, req->message_id);
+  EQ(unpacked_req->error_code, req->error_code);
+  return true;
+}
+
+void free_param_request(nfapi_nr_param_request_scf_t *msg)
+{
+  if (msg->vendor_extension) {
+    free(msg->vendor_extension);
+  }
+}
+
+void free_param_response(nfapi_nr_param_response_scf_t *msg)
+{
+  if (msg->vendor_extension) {
+    free(msg->vendor_extension);
+  }
+
+  if (msg->cell_param.config_tlvs_to_report_list) {
+    free(msg->cell_param.config_tlvs_to_report_list);
+  }
+}
+
+void free_config_request(nfapi_nr_config_request_scf_t *msg)
+{
+  if (msg->vendor_extension) {
+    free(msg->vendor_extension);
+  }
+
+  if (msg->prach_config.num_prach_fd_occasions_list) {
+    for (int i = 0; i < msg->prach_config.num_prach_fd_occasions.value; i++) {
+      nfapi_nr_num_prach_fd_occasions_t *prach_fd_occasion = &(msg->prach_config.num_prach_fd_occasions_list[i]);
+      if (prach_fd_occasion->unused_root_sequences_list) {
+        free(prach_fd_occasion->unused_root_sequences_list);
+      }
+    }
+    free(msg->prach_config.num_prach_fd_occasions_list);
+  }
+  const uint8_t slotsperframe[5] = {10, 20, 40, 80, 160};
+  if (msg->tdd_table.max_tdd_periodicity_list) {
+    for (int i = 0; i < slotsperframe[msg->ssb_config.scs_common.value]; i++) {
+      free(msg->tdd_table.max_tdd_periodicity_list[i].max_num_of_symbol_per_slot_list);
+    }
+    free(msg->tdd_table.max_tdd_periodicity_list);
+  }
+
+  if (msg->pmi_list.pmi_pdu) {
+    free(msg->pmi_list.pmi_pdu);
+  }
+}
+
+void free_config_response(nfapi_nr_config_response_scf_t *msg)
+{
+  if (msg->vendor_extension) {
+    free(msg->vendor_extension);
+  }
+
+  if (msg->invalid_tlvs_list) {
+    free(msg->invalid_tlvs_list);
+  }
+
+  if (msg->invalid_tlvs_configured_in_idle_list) {
+    free(msg->invalid_tlvs_configured_in_idle_list);
+  }
+
+  if (msg->invalid_tlvs_configured_in_running_list) {
+    free(msg->invalid_tlvs_configured_in_running_list);
+  }
+
+  if (msg->missing_tlvs_list) {
+    free(msg->missing_tlvs_list);
+  }
+}
+
+void free_start_request(nfapi_nr_start_request_scf_t *msg)
+{
+  if (msg->vendor_extension) {
+    free(msg->vendor_extension);
+  }
+}
+
+void free_start_response(nfapi_nr_start_response_scf_t *msg)
+{
+  if (msg->vendor_extension) {
+    free(msg->vendor_extension);
+  }
+}
+
+void free_stop_request(nfapi_nr_stop_request_scf_t *msg)
+{
+  if (msg->vendor_extension) {
+    free(msg->vendor_extension);
+  }
+}
+
+void free_stop_indication(nfapi_nr_stop_indication_scf_t *msg)
+{
+  if (msg->vendor_extension) {
+    free(msg->vendor_extension);
+  }
+}
+
+void free_error_indication(nfapi_nr_error_indication_scf_t *msg)
+{
+  if (msg->vendor_extension) {
+    free(msg->vendor_extension);
+  }
+}
+
+void copy_param_request(const nfapi_nr_param_request_scf_t *src, nfapi_nr_param_request_scf_t *dst)
+{
+  dst->header.message_id = src->header.message_id;
+  dst->header.message_length = src->header.message_length;
+  if (src->vendor_extension) {
+    dst->vendor_extension = calloc(1, sizeof(nfapi_vendor_extension_tlv_t));
+    dst->vendor_extension->tag = src->vendor_extension->tag;
+    dst->vendor_extension->length = src->vendor_extension->length;
+    copy_vendor_extension_value(&dst->vendor_extension, &src->vendor_extension);
+  }
+}
+
+void copy_param_response(const nfapi_nr_param_response_scf_t *src, nfapi_nr_param_response_scf_t *dst)
+{
+  dst->header.message_id = src->header.message_id;
+  dst->header.message_length = src->header.message_length;
+  if (src->vendor_extension) {
+    dst->vendor_extension = calloc(1, sizeof(nfapi_vendor_extension_tlv_t));
+    dst->vendor_extension->tag = src->vendor_extension->tag;
+    dst->vendor_extension->length = src->vendor_extension->length;
+    copy_vendor_extension_value(&dst->vendor_extension, &src->vendor_extension);
+  }
+
+  dst->error_code = src->error_code;
+  dst->num_tlv = src->num_tlv;
+
+  COPY_TLV(dst->cell_param.release_capability, src->cell_param.release_capability);
+
+  COPY_TLV(dst->cell_param.phy_state, src->cell_param.phy_state);
+
+  COPY_TLV(dst->cell_param.skip_blank_dl_config, src->cell_param.skip_blank_dl_config);
+
+  COPY_TLV(dst->cell_param.skip_blank_ul_config, src->cell_param.skip_blank_ul_config);
+
+  COPY_TLV(dst->cell_param.num_config_tlvs_to_report, src->cell_param.num_config_tlvs_to_report);
+
+  if (src->cell_param.config_tlvs_to_report_list) {
+    dst->cell_param.config_tlvs_to_report_list =
+        calloc(src->cell_param.num_config_tlvs_to_report.value, sizeof(nfapi_uint8_tlv_t *));
+    for (int i = 0; i < src->cell_param.num_config_tlvs_to_report.value; ++i) {
+      COPY_TLV(dst->cell_param.config_tlvs_to_report_list[i], src->cell_param.config_tlvs_to_report_list[i]);
+    }
+  }
+
+  COPY_TLV(dst->carrier_param.cyclic_prefix, src->carrier_param.cyclic_prefix);
+
+  COPY_TLV(dst->carrier_param.supported_subcarrier_spacings_dl, src->carrier_param.supported_subcarrier_spacings_dl);
+
+  COPY_TLV(dst->carrier_param.supported_bandwidth_dl, src->carrier_param.supported_bandwidth_dl);
+
+  COPY_TLV(dst->carrier_param.supported_subcarrier_spacings_ul, src->carrier_param.supported_subcarrier_spacings_ul);
+
+  COPY_TLV(dst->carrier_param.supported_bandwidth_ul, src->carrier_param.supported_bandwidth_ul);
+
+  COPY_TLV(dst->pdcch_param.cce_mapping_type, src->pdcch_param.cce_mapping_type);
+
+  COPY_TLV(dst->pdcch_param.coreset_outside_first_3_of_ofdm_syms_of_slot,
+           src->pdcch_param.coreset_outside_first_3_of_ofdm_syms_of_slot);
+
+  COPY_TLV(dst->pdcch_param.coreset_precoder_granularity_coreset, src->pdcch_param.coreset_precoder_granularity_coreset);
+
+  COPY_TLV(dst->pdcch_param.pdcch_mu_mimo, src->pdcch_param.pdcch_mu_mimo);
+
+  COPY_TLV(dst->pdcch_param.pdcch_precoder_cycling, src->pdcch_param.pdcch_precoder_cycling);
+
+  COPY_TLV(dst->pdcch_param.max_pdcch_per_slot, src->pdcch_param.max_pdcch_per_slot);
+
+  COPY_TLV(dst->pucch_param.pucch_formats, src->pucch_param.pucch_formats);
+
+  COPY_TLV(dst->pucch_param.max_pucchs_per_slot, src->pucch_param.max_pucchs_per_slot);
+
+  COPY_TLV(dst->pdsch_param.pdsch_mapping_type, src->pdsch_param.pdsch_mapping_type);
+
+  COPY_TLV(dst->pdsch_param.pdsch_allocation_types, src->pdsch_param.pdsch_allocation_types);
+
+  COPY_TLV(dst->pdsch_param.pdsch_vrb_to_prb_mapping, src->pdsch_param.pdsch_vrb_to_prb_mapping);
+
+  COPY_TLV(dst->pdsch_param.pdsch_cbg, src->pdsch_param.pdsch_cbg);
+
+  COPY_TLV(dst->pdsch_param.pdsch_dmrs_config_types, src->pdsch_param.pdsch_dmrs_config_types);
+
+  COPY_TLV(dst->pdsch_param.pdsch_dmrs_max_length, src->pdsch_param.pdsch_dmrs_max_length);
+
+  COPY_TLV(dst->pdsch_param.pdsch_dmrs_additional_pos, src->pdsch_param.pdsch_dmrs_additional_pos);
+
+  COPY_TLV(dst->pdsch_param.max_pdsch_tbs_per_slot, src->pdsch_param.max_pdsch_tbs_per_slot);
+
+  COPY_TLV(dst->pdsch_param.max_number_mimo_layers_pdsch, src->pdsch_param.max_number_mimo_layers_pdsch);
+
+  COPY_TLV(dst->pdsch_param.supported_max_modulation_order_dl, src->pdsch_param.supported_max_modulation_order_dl);
+
+  COPY_TLV(dst->pdsch_param.max_mu_mimo_users_dl, src->pdsch_param.max_mu_mimo_users_dl);
+
+  COPY_TLV(dst->pdsch_param.pdsch_data_in_dmrs_symbols, src->pdsch_param.pdsch_data_in_dmrs_symbols);
+
+  COPY_TLV(dst->pdsch_param.premption_support, src->pdsch_param.premption_support);
+
+  COPY_TLV(dst->pdsch_param.pdsch_non_slot_support, src->pdsch_param.pdsch_non_slot_support);
+
+  COPY_TLV(dst->pusch_param.uci_mux_ulsch_in_pusch, src->pusch_param.uci_mux_ulsch_in_pusch);
+
+  COPY_TLV(dst->pusch_param.uci_only_pusch, src->pusch_param.uci_only_pusch);
+
+  COPY_TLV(dst->pusch_param.pusch_frequency_hopping, src->pusch_param.pusch_frequency_hopping);
+
+  COPY_TLV(dst->pusch_param.pusch_dmrs_config_types, src->pusch_param.pusch_dmrs_config_types);
+
+  COPY_TLV(dst->pusch_param.pusch_dmrs_max_len, src->pusch_param.pusch_dmrs_max_len);
+
+  COPY_TLV(dst->pusch_param.pusch_dmrs_additional_pos, src->pusch_param.pusch_dmrs_additional_pos);
+
+  COPY_TLV(dst->pusch_param.pusch_cbg, src->pusch_param.pusch_cbg);
+
+  COPY_TLV(dst->pusch_param.pusch_mapping_type, src->pusch_param.pusch_mapping_type);
+
+  COPY_TLV(dst->pusch_param.pusch_allocation_types, src->pusch_param.pusch_allocation_types);
+
+  COPY_TLV(dst->pusch_param.pusch_vrb_to_prb_mapping, src->pusch_param.pusch_vrb_to_prb_mapping);
+
+  COPY_TLV(dst->pusch_param.pusch_max_ptrs_ports, src->pusch_param.pusch_max_ptrs_ports);
+
+  COPY_TLV(dst->pusch_param.max_pduschs_tbs_per_slot, src->pusch_param.max_pduschs_tbs_per_slot);
+
+  COPY_TLV(dst->pusch_param.max_number_mimo_layers_non_cb_pusch, src->pusch_param.max_number_mimo_layers_non_cb_pusch);
+
+  COPY_TLV(dst->pusch_param.supported_modulation_order_ul, src->pusch_param.supported_modulation_order_ul);
+
+  COPY_TLV(dst->pusch_param.max_mu_mimo_users_ul, src->pusch_param.max_mu_mimo_users_ul);
+
+  COPY_TLV(dst->pusch_param.dfts_ofdm_support, src->pusch_param.dfts_ofdm_support);
+
+  COPY_TLV(dst->pusch_param.pusch_aggregation_factor, src->pusch_param.pusch_aggregation_factor);
+
+  COPY_TLV(dst->prach_param.prach_long_formats, src->prach_param.prach_long_formats);
+
+  COPY_TLV(dst->prach_param.prach_short_formats, src->prach_param.prach_short_formats);
+
+  COPY_TLV(dst->prach_param.prach_restricted_sets, src->prach_param.prach_restricted_sets);
+
+  COPY_TLV(dst->prach_param.max_prach_fd_occasions_in_a_slot, src->prach_param.max_prach_fd_occasions_in_a_slot);
+
+  COPY_TLV(dst->measurement_param.rssi_measurement_support, src->measurement_param.rssi_measurement_support);
+
+  COPY_TL(dst->nfapi_config.p7_vnf_address_ipv4.tl, src->nfapi_config.p7_vnf_address_ipv4.tl);
+  memcpy(dst->nfapi_config.p7_vnf_address_ipv4.address,
+         src->nfapi_config.p7_vnf_address_ipv4.address,
+         sizeof(dst->nfapi_config.p7_vnf_address_ipv4.address));
+
+  COPY_TL(dst->nfapi_config.p7_vnf_address_ipv6.tl, src->nfapi_config.p7_vnf_address_ipv6.tl);
+  memcpy(dst->nfapi_config.p7_vnf_address_ipv6.address,
+         src->nfapi_config.p7_vnf_address_ipv6.address,
+         sizeof(dst->nfapi_config.p7_vnf_address_ipv6.address));
+
+  COPY_TLV(dst->nfapi_config.p7_vnf_port, src->nfapi_config.p7_vnf_port);
+
+  COPY_TL(dst->nfapi_config.p7_pnf_address_ipv4.tl, src->nfapi_config.p7_pnf_address_ipv4.tl);
+  memcpy(dst->nfapi_config.p7_pnf_address_ipv4.address,
+         src->nfapi_config.p7_pnf_address_ipv4.address,
+         sizeof(dst->nfapi_config.p7_pnf_address_ipv4.address));
+
+  COPY_TL(dst->nfapi_config.p7_pnf_address_ipv6.tl, src->nfapi_config.p7_pnf_address_ipv6.tl);
+  memcpy(dst->nfapi_config.p7_pnf_address_ipv6.address,
+         src->nfapi_config.p7_pnf_address_ipv6.address,
+         sizeof(dst->nfapi_config.p7_pnf_address_ipv6.address));
+
+  COPY_TLV(dst->nfapi_config.p7_pnf_port, src->nfapi_config.p7_pnf_port);
+
+  COPY_TLV(dst->nfapi_config.timing_window, src->nfapi_config.timing_window);
+
+  COPY_TLV(dst->nfapi_config.timing_info_mode, src->nfapi_config.timing_info_mode);
+
+  COPY_TLV(dst->nfapi_config.timing_info_period, src->nfapi_config.timing_info_period);
+
+  COPY_TLV(dst->nfapi_config.dl_tti_timing_offset, src->nfapi_config.dl_tti_timing_offset);
+
+  COPY_TLV(dst->nfapi_config.ul_tti_timing_offset, src->nfapi_config.ul_tti_timing_offset);
+
+  COPY_TLV(dst->nfapi_config.ul_dci_timing_offset, src->nfapi_config.ul_dci_timing_offset);
+
+  COPY_TLV(dst->nfapi_config.tx_data_timing_offset, src->nfapi_config.tx_data_timing_offset);
+}
+
+void copy_config_request(const nfapi_nr_config_request_scf_t *src, nfapi_nr_config_request_scf_t *dst)
+{
+  dst->header.message_id = src->header.message_id;
+  dst->header.message_length = src->header.message_length;
+  if (src->vendor_extension) {
+    dst->vendor_extension = calloc(1, sizeof(nfapi_vendor_extension_tlv_t));
+    dst->vendor_extension->tag = src->vendor_extension->tag;
+    dst->vendor_extension->length = src->vendor_extension->length;
+    copy_vendor_extension_value(&dst->vendor_extension, &src->vendor_extension);
+  }
+
+  dst->num_tlv = src->num_tlv;
+
+  COPY_TLV(dst->carrier_config.dl_bandwidth, src->carrier_config.dl_bandwidth);
+
+  COPY_TLV(dst->carrier_config.dl_frequency, src->carrier_config.dl_frequency);
+
+  for (int i = 0; i < 5; ++i) {
+    COPY_TLV(dst->carrier_config.dl_k0[i], src->carrier_config.dl_k0[i]);
+
+    COPY_TLV(dst->carrier_config.dl_grid_size[i], src->carrier_config.dl_grid_size[i]);
+  }
+
+  COPY_TLV(dst->carrier_config.num_tx_ant, src->carrier_config.num_tx_ant);
+
+  COPY_TLV(dst->carrier_config.uplink_bandwidth, src->carrier_config.uplink_bandwidth);
+
+  COPY_TLV(dst->carrier_config.uplink_frequency, src->carrier_config.uplink_frequency);
+
+  COPY_TLV(dst->carrier_config.uplink_frequency, src->carrier_config.uplink_frequency);
+
+  for (int i = 0; i < 5; ++i) {
+    COPY_TLV(dst->carrier_config.ul_k0[i], src->carrier_config.ul_k0[i]);
+
+    COPY_TLV(dst->carrier_config.ul_grid_size[i], src->carrier_config.ul_grid_size[i]);
+  }
+
+  COPY_TLV(dst->carrier_config.num_rx_ant, src->carrier_config.num_rx_ant);
+
+  COPY_TLV(dst->carrier_config.frequency_shift_7p5khz, src->carrier_config.frequency_shift_7p5khz);
+
+  COPY_TLV(dst->cell_config.phy_cell_id, src->cell_config.phy_cell_id);
+
+  COPY_TLV(dst->cell_config.frame_duplex_type, src->cell_config.frame_duplex_type);
+
+  COPY_TLV(dst->ssb_config.ss_pbch_power, src->ssb_config.ss_pbch_power);
+
+  COPY_TLV(dst->ssb_config.bch_payload, src->ssb_config.bch_payload);
+
+  COPY_TLV(dst->ssb_config.scs_common, src->ssb_config.scs_common);
+
+  COPY_TLV(dst->prach_config.prach_sequence_length, src->prach_config.prach_sequence_length);
+
+  COPY_TLV(dst->prach_config.prach_sub_c_spacing, src->prach_config.prach_sub_c_spacing);
+
+  COPY_TLV(dst->prach_config.restricted_set_config, src->prach_config.restricted_set_config);
+
+  COPY_TLV(dst->prach_config.num_prach_fd_occasions, src->prach_config.num_prach_fd_occasions);
+
+  COPY_TLV(dst->prach_config.prach_ConfigurationIndex, src->prach_config.prach_ConfigurationIndex);
+
+  COPY_TLV(dst->prach_config.prach_ConfigurationIndex, src->prach_config.prach_ConfigurationIndex);
+
+  dst->prach_config.num_prach_fd_occasions_list = (nfapi_nr_num_prach_fd_occasions_t *)malloc(
+      dst->prach_config.num_prach_fd_occasions.value * sizeof(nfapi_nr_num_prach_fd_occasions_t));
+  for (int i = 0; i < dst->prach_config.num_prach_fd_occasions.value; i++) {
+    nfapi_nr_num_prach_fd_occasions_t *src_prach_fd_occasion = &(src->prach_config.num_prach_fd_occasions_list[i]);
+    nfapi_nr_num_prach_fd_occasions_t *dst_prach_fd_occasion = &(dst->prach_config.num_prach_fd_occasions_list[i]);
+
+    COPY_TLV(dst_prach_fd_occasion->prach_root_sequence_index, src_prach_fd_occasion->prach_root_sequence_index);
+
+    COPY_TLV(dst_prach_fd_occasion->num_root_sequences, src_prach_fd_occasion->num_root_sequences);
+
+    COPY_TLV(dst_prach_fd_occasion->k1, src_prach_fd_occasion->k1);
+
+    COPY_TLV(dst_prach_fd_occasion->prach_zero_corr_conf, src_prach_fd_occasion->prach_zero_corr_conf);
+
+    COPY_TLV(dst_prach_fd_occasion->num_unused_root_sequences, src_prach_fd_occasion->num_unused_root_sequences);
+
+    dst_prach_fd_occasion->unused_root_sequences_list =
+        (nfapi_uint8_tlv_t *)malloc(dst_prach_fd_occasion->num_unused_root_sequences.value * sizeof(nfapi_uint8_tlv_t));
+    for (int k = 0; k < dst_prach_fd_occasion->num_unused_root_sequences.value; k++) {
+      COPY_TLV(dst_prach_fd_occasion->unused_root_sequences_list[k], src_prach_fd_occasion->unused_root_sequences_list[k]);
+    }
+  }
+
+  COPY_TLV(dst->prach_config.ssb_per_rach, src->prach_config.ssb_per_rach);
+
+  COPY_TLV(dst->prach_config.prach_multiple_carriers_in_a_band, src->prach_config.prach_multiple_carriers_in_a_band);
+
+  COPY_TLV(dst->ssb_table.ssb_offset_point_a, src->ssb_table.ssb_offset_point_a);
+
+  COPY_TLV(dst->ssb_table.ssb_period, src->ssb_table.ssb_period);
+
+  COPY_TLV(dst->ssb_table.ssb_subcarrier_offset, src->ssb_table.ssb_subcarrier_offset);
+
+  COPY_TLV(dst->ssb_table.MIB, src->ssb_table.MIB);
+
+  COPY_TLV(dst->ssb_table.ssb_mask_list[0].ssb_mask, src->ssb_table.ssb_mask_list[0].ssb_mask);
+
+  COPY_TLV(dst->ssb_table.ssb_mask_list[1].ssb_mask, src->ssb_table.ssb_mask_list[1].ssb_mask);
+
+  for (int i = 0; i < 64; i++) {
+    COPY_TLV(dst->ssb_table.ssb_beam_id_list[i].beam_id, src->ssb_table.ssb_beam_id_list[i].beam_id);
+  }
+
+  COPY_TLV(dst->tdd_table.tdd_period, src->tdd_table.tdd_period);
+
+  const uint8_t slotsperframe[5] = {10, 20, 40, 80, 160};
+  // Assuming always CP_Normal, because Cyclic prefix is not included in CONFIG.request 10.02, but is present in 10.04
+  uint8_t cyclicprefix = 1;
+  bool normal_CP = cyclicprefix ? false : true;
+  // 3GPP 38.211 Table 4.3.2.1 & Table 4.3.2.2
+  uint8_t number_of_symbols_per_slot = normal_CP ? 14 : 12;
+  dst->tdd_table.max_tdd_periodicity_list = (nfapi_nr_max_tdd_periodicity_t *)malloc(slotsperframe[dst->ssb_config.scs_common.value]
+                                                                                     * sizeof(nfapi_nr_max_tdd_periodicity_t));
+
+  for (int i = 0; i < slotsperframe[dst->ssb_config.scs_common.value]; i++) {
+    dst->tdd_table.max_tdd_periodicity_list[i].max_num_of_symbol_per_slot_list =
+        (nfapi_nr_max_num_of_symbol_per_slot_t *)malloc(number_of_symbols_per_slot * sizeof(nfapi_nr_max_num_of_symbol_per_slot_t));
+  }
+  for (int i = 0; i < slotsperframe[dst->ssb_config.scs_common.value]; i++) { // TODO check right number of slots
+    for (int k = 0; k < number_of_symbols_per_slot; k++) { // TODO can change?
+      COPY_TLV(dst->tdd_table.max_tdd_periodicity_list[i].max_num_of_symbol_per_slot_list[k].slot_config,
+               src->tdd_table.max_tdd_periodicity_list[i].max_num_of_symbol_per_slot_list[k].slot_config);
+    }
+  }
+
+  COPY_TLV(dst->measurement_config.rssi_measurement, src->measurement_config.rssi_measurement);
+
+  COPY_TL(dst->nfapi_config.p7_vnf_address_ipv4.tl, src->nfapi_config.p7_vnf_address_ipv4.tl);
+  memcpy(dst->nfapi_config.p7_vnf_address_ipv4.address,
+         src->nfapi_config.p7_vnf_address_ipv4.address,
+         sizeof(dst->nfapi_config.p7_vnf_address_ipv4.address));
+
+  COPY_TL(dst->nfapi_config.p7_vnf_address_ipv6.tl, src->nfapi_config.p7_vnf_address_ipv6.tl);
+  memcpy(dst->nfapi_config.p7_vnf_address_ipv6.address,
+         src->nfapi_config.p7_vnf_address_ipv6.address,
+         sizeof(dst->nfapi_config.p7_vnf_address_ipv6.address));
+
+  COPY_TLV(dst->nfapi_config.p7_vnf_port, src->nfapi_config.p7_vnf_port);
+
+  COPY_TL(dst->nfapi_config.p7_pnf_address_ipv4.tl, src->nfapi_config.p7_pnf_address_ipv4.tl);
+  memcpy(dst->nfapi_config.p7_pnf_address_ipv4.address,
+         src->nfapi_config.p7_pnf_address_ipv4.address,
+         sizeof(dst->nfapi_config.p7_pnf_address_ipv4.address));
+
+  COPY_TL(dst->nfapi_config.p7_pnf_address_ipv6.tl, src->nfapi_config.p7_pnf_address_ipv6.tl);
+  memcpy(dst->nfapi_config.p7_pnf_address_ipv6.address,
+         src->nfapi_config.p7_pnf_address_ipv6.address,
+         sizeof(dst->nfapi_config.p7_pnf_address_ipv6.address));
+
+  COPY_TLV(dst->nfapi_config.p7_pnf_port, src->nfapi_config.p7_pnf_port);
+
+  COPY_TLV(dst->nfapi_config.timing_window, src->nfapi_config.timing_window);
+
+  COPY_TLV(dst->nfapi_config.timing_info_mode, src->nfapi_config.timing_info_mode);
+
+  COPY_TLV(dst->nfapi_config.timing_info_period, src->nfapi_config.timing_info_period);
+
+  COPY_TLV(dst->nfapi_config.dl_tti_timing_offset, src->nfapi_config.dl_tti_timing_offset);
+
+  COPY_TLV(dst->nfapi_config.ul_tti_timing_offset, src->nfapi_config.ul_tti_timing_offset);
+
+  COPY_TLV(dst->nfapi_config.ul_dci_timing_offset, src->nfapi_config.ul_dci_timing_offset);
+
+  COPY_TLV(dst->nfapi_config.tx_data_timing_offset, src->nfapi_config.tx_data_timing_offset);
+}
+
+void copy_config_response(const nfapi_nr_config_response_scf_t *src, nfapi_nr_config_response_scf_t *dst)
+{
+  dst->header.message_id = src->header.message_id;
+  dst->header.message_length = src->header.message_length;
+  if (src->vendor_extension) {
+    dst->vendor_extension = calloc(1, sizeof(nfapi_vendor_extension_tlv_t));
+    dst->vendor_extension->tag = src->vendor_extension->tag;
+    dst->vendor_extension->length = src->vendor_extension->length;
+    copy_vendor_extension_value(&dst->vendor_extension, &src->vendor_extension);
+  }
+
+  dst->error_code = src->error_code;
+  dst->num_invalid_tlvs = src->num_invalid_tlvs;
+  dst->num_invalid_tlvs_configured_in_idle = src->num_invalid_tlvs_configured_in_idle;
+  dst->num_invalid_tlvs_configured_in_running = src->num_invalid_tlvs_configured_in_running;
+  dst->num_missing_tlvs = src->num_missing_tlvs;
+
+  dst->invalid_tlvs_list = (nfapi_nr_generic_tlv_scf_t *)malloc(dst->num_invalid_tlvs * sizeof(nfapi_nr_generic_tlv_scf_t));
+  dst->invalid_tlvs_configured_in_idle_list =
+      (nfapi_nr_generic_tlv_scf_t *)malloc(dst->num_invalid_tlvs_configured_in_idle * sizeof(nfapi_nr_generic_tlv_scf_t));
+  dst->invalid_tlvs_configured_in_running_list =
+      (nfapi_nr_generic_tlv_scf_t *)malloc(dst->num_invalid_tlvs_configured_in_running * sizeof(nfapi_nr_generic_tlv_scf_t));
+  dst->missing_tlvs_list = (nfapi_nr_generic_tlv_scf_t *)malloc(dst->num_missing_tlvs * sizeof(nfapi_nr_generic_tlv_scf_t));
+
+  for (int i = 0; i < dst->num_invalid_tlvs; ++i) {
+    COPY_TLV(dst->invalid_tlvs_list[i], src->invalid_tlvs_list[i]);
+  }
+
+  for (int i = 0; i < dst->num_invalid_tlvs_configured_in_idle; ++i) {
+    COPY_TLV(dst->invalid_tlvs_configured_in_idle_list[i], src->invalid_tlvs_configured_in_idle_list[i]);
+  }
+
+  for (int i = 0; i < dst->num_invalid_tlvs_configured_in_running; ++i) {
+    COPY_TLV(dst->invalid_tlvs_configured_in_running_list[i], src->invalid_tlvs_configured_in_running_list[i]);
+  }
+
+  for (int i = 0; i < dst->num_missing_tlvs; ++i) {
+    COPY_TLV(dst->missing_tlvs_list[i], src->missing_tlvs_list[i]);
+  }
+}
+
+void copy_start_request(const nfapi_nr_start_request_scf_t *src, nfapi_nr_start_request_scf_t *dst)
+{
+  dst->header.message_id = src->header.message_id;
+  dst->header.message_length = src->header.message_length;
+  if (src->vendor_extension) {
+    dst->vendor_extension = calloc(1, sizeof(nfapi_vendor_extension_tlv_t));
+    dst->vendor_extension->tag = src->vendor_extension->tag;
+    dst->vendor_extension->length = src->vendor_extension->length;
+    copy_vendor_extension_value(&dst->vendor_extension, &src->vendor_extension);
+  }
+}
+
+void copy_start_response(const nfapi_nr_start_response_scf_t *src, nfapi_nr_start_response_scf_t *dst)
+{
+  dst->header.message_id = src->header.message_id;
+  dst->header.message_length = src->header.message_length;
+  if (src->vendor_extension) {
+    dst->vendor_extension = calloc(1, sizeof(nfapi_vendor_extension_tlv_t));
+    dst->vendor_extension->tag = src->vendor_extension->tag;
+    dst->vendor_extension->length = src->vendor_extension->length;
+    copy_vendor_extension_value(&dst->vendor_extension, &src->vendor_extension);
+  }
+  dst->error_code = src->error_code;
+}
+
+void copy_stop_request(const nfapi_nr_stop_request_scf_t *src, nfapi_nr_stop_request_scf_t *dst)
+{
+  dst->header.message_id = src->header.message_id;
+  dst->header.message_length = src->header.message_length;
+  if (src->vendor_extension) {
+    dst->vendor_extension = calloc(1, sizeof(nfapi_vendor_extension_tlv_t));
+    dst->vendor_extension->tag = src->vendor_extension->tag;
+    dst->vendor_extension->length = src->vendor_extension->length;
+    copy_vendor_extension_value(&dst->vendor_extension, &src->vendor_extension);
+  }
+}
+
+void copy_stop_indication(const nfapi_nr_stop_indication_scf_t *src, nfapi_nr_stop_indication_scf_t *dst)
+{
+  dst->header.message_id = src->header.message_id;
+  dst->header.message_length = src->header.message_length;
+  if (src->vendor_extension) {
+    dst->vendor_extension = calloc(1, sizeof(nfapi_vendor_extension_tlv_t));
+    dst->vendor_extension->tag = src->vendor_extension->tag;
+    dst->vendor_extension->length = src->vendor_extension->length;
+    copy_vendor_extension_value(&dst->vendor_extension, &src->vendor_extension);
+  }
+}
+
+void copy_error_indication(const nfapi_nr_error_indication_scf_t *src, nfapi_nr_error_indication_scf_t *dst)
+{
+  dst->header.message_id = src->header.message_id;
+  dst->header.message_length = src->header.message_length;
+  if (src->vendor_extension) {
+    dst->vendor_extension = calloc(1, sizeof(nfapi_vendor_extension_tlv_t));
+    dst->vendor_extension->tag = src->vendor_extension->tag;
+    dst->vendor_extension->length = src->vendor_extension->length;
+    copy_vendor_extension_value(&dst->vendor_extension, &src->vendor_extension);
+  }
+
+  dst->sfn = src->sfn;
+  dst->slot = src->slot;
+  dst->message_id = src->message_id;
+  dst->error_code = src->error_code;
+}

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

@@ -359,6 +359,7 @@ typedef struct
   nfapi_nr_ue_ul_beamforming_t beamforming;
   //OAI specific
   int8_t absolute_delta_PUSCH;
+  int16_t tx_power;
   fapi_nr_tx_request_body_t tx_request_body;
 } nfapi_nr_ue_pusch_pdu_t;
 

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

@@ -3981,6 +3981,20 @@ int nfapi_p4_message_unpack(void *pMessageBuf, uint32_t messageBufLen, void *pUn
 int nfapi_p5_message_pack(void *pMessageBuf, uint32_t messageBufLen, void *pPackedBuf, uint32_t packedBufLen, nfapi_p4_p5_codec_config_t* config);
 int nfapi_nr_p5_message_pack(void *pMessageBuf, uint32_t messageBufLen, void *pPackedBuf, uint32_t packedBufLen, nfapi_p4_p5_codec_config_t* config);
 
+/*! \brief Packs a NFAPI P5 message body
+ *  \param header A pointer to the header of the P5 message
+ *  \param ppWritePackedMsg A pointer to the buffer where to pack the P5 message
+ *  \param end Pointer to the end of the packing buffer
+ *  \param config A pointer to the nfapi configuration structure
+ *  \return 0 means success, -1 means failure.
+ *
+ * The function will decode a byte stream pointed to by pMessageBuf into a nfapi p5 message structure pointer to by pUnpackedBuf
+ */
+uint8_t pack_nr_p5_message_body(nfapi_p4_p5_message_header_t* header,
+                                uint8_t** ppWritePackedMsg,
+                                uint8_t* end,
+                                nfapi_p4_p5_codec_config_t* config);
+
 /*! \brief Decodes an NFAPI P5 message header
  *  \param pMessageBuf A pointer to an encoded P5 message header
  *  \param messageBufLen The size of the encoded P5 message header

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

@@ -44,36 +44,36 @@ typedef struct {
 //PHY API message types
 
 typedef enum {
-  NFAPI_NR_PHY_MSG_TYPE_PARAM_REQUEST=  0x00,
-  NFAPI_NR_PHY_MSG_TYPE_PARAM_RESPONSE= 0x01,
-  NFAPI_NR_PHY_MSG_TYPE_CONFIG_REQUEST= 0x02,
-  NFAPI_NR_PHY_MSG_TYPE_CONFIG_RESPONSE=0X03,
-  NFAPI_NR_PHY_MSG_TYPE_START_REQUEST=  0X04,
-  NFAPI_NR_PHY_MSG_TYPE_STOP_REQUEST=   0X05,
-  NFAPI_NR_PHY_MSG_TYPE_STOP_INDICATION=0X06,
-  NFAPI_NR_PHY_MSG_TYPE_ERROR_INDICATION=0X07,
-  NFAPI_NR_PHY_MSG_TYPE_START_RESPONSE=0X010D,
-  NFAPI_NR_PHY_MSG_TYPE_STOP_RESPONSE=0X010F,
-  //RESERVED 0X08 ~ 0X7F
-  NFAPI_NR_PHY_MSG_TYPE_DL_TTI_REQUEST= 0X80,
-  NFAPI_NR_PHY_MSG_TYPE_UL_TTI_REQUEST= 0X81,
-  NFAPI_NR_PHY_MSG_TYPE_SLOT_INDICATION=0X82,
-  NFAPI_NR_PHY_MSG_TYPE_UL_DCI_REQUEST= 0X83,
-  NFAPI_NR_PHY_MSG_TYPE_TX_DATA_REQUEST=0X84, // CHANGED TO 0X84
-  NFAPI_NR_PHY_MSG_TYPE_RX_DATA_INDICATION=0X85,
-  NFAPI_NR_PHY_MSG_TYPE_CRC_INDICATION= 0X86,
-  NFAPI_NR_PHY_MSG_TYPE_UCI_INDICATION= 0X87,
-  NFAPI_NR_PHY_MSG_TYPE_SRS_INDICATION= 0X88,
-  NFAPI_NR_PHY_MSG_TYPE_RACH_INDICATION= 0X89,
-  //RESERVED 0X8a ~ 0xff
+  NFAPI_NR_PHY_MSG_TYPE_PARAM_REQUEST = 0x00,
+  NFAPI_NR_PHY_MSG_TYPE_PARAM_RESPONSE = 0x01,
+  NFAPI_NR_PHY_MSG_TYPE_CONFIG_REQUEST = 0x02,
+  NFAPI_NR_PHY_MSG_TYPE_CONFIG_RESPONSE = 0X03,
+  NFAPI_NR_PHY_MSG_TYPE_START_REQUEST = 0X04,
+  NFAPI_NR_PHY_MSG_TYPE_STOP_REQUEST = 0X05,
+  NFAPI_NR_PHY_MSG_TYPE_STOP_INDICATION = 0X06,
+  NFAPI_NR_PHY_MSG_TYPE_ERROR_INDICATION = 0X07,
+  NFAPI_NR_PHY_MSG_TYPE_START_RESPONSE = 0X0108, // SCF 222.10.04 Section 3.2 Start.Response - 0x108, as of nFAPIv2
+  NFAPI_NR_PHY_MSG_TYPE_STOP_RESPONSE = 0X010F,
+  // RESERVED 0X08 ~ 0X7F
+  NFAPI_NR_PHY_MSG_TYPE_DL_TTI_REQUEST = 0X80,
+  NFAPI_NR_PHY_MSG_TYPE_UL_TTI_REQUEST = 0X81,
+  NFAPI_NR_PHY_MSG_TYPE_SLOT_INDICATION = 0X82,
+  NFAPI_NR_PHY_MSG_TYPE_UL_DCI_REQUEST = 0X83,
+  NFAPI_NR_PHY_MSG_TYPE_TX_DATA_REQUEST = 0X84, // CHANGED TO 0X84
+  NFAPI_NR_PHY_MSG_TYPE_RX_DATA_INDICATION = 0X85,
+  NFAPI_NR_PHY_MSG_TYPE_CRC_INDICATION = 0X86,
+  NFAPI_NR_PHY_MSG_TYPE_UCI_INDICATION = 0X87,
+  NFAPI_NR_PHY_MSG_TYPE_SRS_INDICATION = 0X88,
+  NFAPI_NR_PHY_MSG_TYPE_RACH_INDICATION = 0X89,
+  // RESERVED 0X8a ~ 0xff
   NFAPI_NR_PHY_MSG_TYPE_PNF_PARAM_REQUEST = 0x0100,
   NFAPI_NR_PHY_MSG_TYPE_PNF_PARAM_RESPONSE = 0x0101,
-  NFAPI_NR_PHY_MSG_TYPE_PNF_CONFIG_REQUEST= 0x0102,
-  NFAPI_NR_PHY_MSG_TYPE_PNF_CONFIG_RESPONSE= 0x0103,
-  NFAPI_NR_PHY_MSG_TYPE_PNF_START_REQUEST= 0x0104,
-  NFAPI_NR_PHY_MSG_TYPE_PNF_START_RESPONSE= 0x0105,
-  NFAPI_NR_PHY_MSG_TYPE_PNF_STOP_REQUEST= 0x0106,
-  NFAPI_NR_PHY_MSG_TYPE_PNF_STOP_RESPONSE= 0x0107,
+  NFAPI_NR_PHY_MSG_TYPE_PNF_CONFIG_REQUEST = 0x0102,
+  NFAPI_NR_PHY_MSG_TYPE_PNF_CONFIG_RESPONSE = 0x0103,
+  NFAPI_NR_PHY_MSG_TYPE_PNF_START_REQUEST = 0x0104,
+  NFAPI_NR_PHY_MSG_TYPE_PNF_START_RESPONSE = 0x0105,
+  NFAPI_NR_PHY_MSG_TYPE_PNF_STOP_REQUEST = 0x0106,
+  NFAPI_NR_PHY_MSG_TYPE_PNF_STOP_RESPONSE = 0x0107,
 
   NFAPI_NR_PHY_MSG_TYPE_UL_NODE_SYNC = 0x0180,
   NFAPI_NR_PHY_MSG_TYPE_DL_NODE_SYNC,
@@ -129,7 +129,7 @@ typedef enum {
 #define  NFAPI_NR_PARAM_TLV_PDSCH_DMRS_CONFIG_TYPES_TAG 0x0017
 #define  NFAPI_NR_PARAM_TLV_PDSCH_DMRS_MAX_LENGTH_TAG 0x0018
 #define  NFAPI_NR_PARAM_TLV_PDSCH_DMRS_ADDITIONAL_POS_TAG 0x0019
-#define  NFAPI_NR_PARAM_TLV_MAX_PDSCH_S_YBS_PER_SLOT_TAG 0x001A
+#define NFAPI_NR_PARAM_TLV_MAX_PDSCH_S_TBS_PER_SLOT_TAG 0x001A
 #define  NFAPI_NR_PARAM_TLV_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG 0x001B
 #define  NFAPI_NR_PARAM_TLV_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG 0x001C
 #define  NFAPI_NR_PARAM_TLV_MAX_MU_MIMO_USERS_DL_TAG 0x001D
@@ -577,6 +577,23 @@ typedef struct {
   nfapi_nr_pm_list_t            pmi_list;
 } nfapi_nr_config_request_scf_t;
 
+typedef enum {
+  UINT_8 = sizeof(uint8_t),
+  UINT_16 = sizeof(uint16_t),
+  UINT_32 = sizeof(uint32_t),
+  ARRAY_UINT_16 = 5 * sizeof(uint16_t),
+  UNKNOWN = 0xffff
+} nfapi_nr_config_response_tlv_value_type_t;
+
+typedef struct {
+  nfapi_tl_t tl;
+  union {
+    uint8_t u8;
+    uint16_t u16;
+    uint32_t u32;
+    uint16_t array_u16[5]; // 4 TLVs defined as array ( dlK0, dlGridSize, ulK0, ulGridSize )
+  } value;
+} nfapi_nr_generic_tlv_scf_t;
 
 /* CONFIG.RESPONSE */
 typedef struct {
@@ -586,8 +603,11 @@ typedef struct {
   uint8_t num_invalid_tlvs_configured_in_idle;
   uint8_t num_invalid_tlvs_configured_in_running;
   uint8_t num_missing_tlvs;
-  // TODO: add list of invalid/unsupported TLVs (see Table 3.18)
-   nfapi_vendor_extension_tlv_t  vendor_extension;
+  nfapi_nr_generic_tlv_scf_t* invalid_tlvs_list;
+  nfapi_nr_generic_tlv_scf_t* invalid_tlvs_configured_in_idle_list;
+  nfapi_nr_generic_tlv_scf_t* invalid_tlvs_configured_in_running_list;
+  nfapi_nr_generic_tlv_scf_t* missing_tlvs_list;
+  nfapi_vendor_extension_tlv_t vendor_extension;
 } nfapi_nr_config_response_scf_t;
 
 //------------------------------//
@@ -609,13 +629,21 @@ typedef struct {
 typedef struct {
   nfapi_p4_p5_message_header_t header;
   nfapi_vendor_extension_tlv_t vendor_extension;
-} nfapi_nr_stop_request_t;
-
+} nfapi_nr_stop_request_scf_t;
 
 typedef struct {
   nfapi_p4_p5_message_header_t header;
   nfapi_vendor_extension_tlv_t vendor_extension;
-} nfapi_nr_stop_indication_t;
+} nfapi_nr_stop_indication_scf_t;
+
+typedef struct {
+  nfapi_p4_p5_message_header_t header;
+  uint16_t sfn;
+  uint16_t slot;
+  uint8_t message_id; // Which message received on the PNF has an error
+  uint8_t error_code;
+  nfapi_vendor_extension_tlv_t vendor_extension;
+} nfapi_nr_error_indication_scf_t;
 
 typedef enum {
   NFAPI_NR_STOP_MSG_INVALID_STATE

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

@@ -0,0 +1,89 @@
+/*
+ * 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 nfapi/open-nFAPI/nfapi/public_inc/nr_nfapi_p7.h
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+
+#ifndef OPENAIRINTERFACE_NR_NFAPI_P7_H
+#define OPENAIRINTERFACE_NR_NFAPI_P7_H
+#include "nfapi_interface.h"
+#include "nfapi_nr_interface_scf.h"
+
+uint8_t unpack_nr_slot_indication(uint8_t **ppReadPackedMsg,
+                                  uint8_t *end,
+                                  nfapi_nr_slot_indication_scf_t *msg,
+                                  nfapi_p7_codec_config_t *config);
+
+void *nfapi_p7_allocate(size_t size, nfapi_p7_codec_config_t *config);
+
+uint8_t unpack_nr_srs_indication(uint8_t **ppReadPackedMsg,
+                                 uint8_t *end,
+                                 nfapi_nr_srs_indication_t *pNfapiMsg,
+                                 nfapi_p7_codec_config_t *config);
+
+uint8_t pack_dl_tti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_ul_tti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_ul_dci_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_ue_release_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_ue_release_response(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_nr_slot_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_nr_rx_data_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_nr_crc_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_nr_uci_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_nr_srs_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_nr_rach_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_nr_dl_node_sync(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_nr_ul_node_sync(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t pack_nr_timing_info(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config);
+
+uint8_t unpack_nr_crc_indication(uint8_t **ppReadPackedMsg,
+                                 uint8_t *end,
+                                 nfapi_nr_crc_indication_t *msg,
+                                 nfapi_p7_codec_config_t *config);
+
+uint8_t unpack_nr_uci_indication(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t *config);
+
+uint8_t unpack_nr_rach_indication(uint8_t **ppReadPackedMsg,
+                                  uint8_t *end,
+                                  nfapi_nr_rach_indication_t *msg,
+                                  nfapi_p7_codec_config_t *config);
+
+#endif // OPENAIRINTERFACE_NR_NFAPI_P7_H

nfapi/open-nFAPI/nfapi/src/nfapi_p4.c

@@ -27,15 +27,6 @@
 #include <nfapi.h>
 #include <debug.h>
 
-static uint32_t get_packed_msg_len(uintptr_t msgHead, uintptr_t msgEnd) {
-  if (msgEnd < msgHead) {
-    NFAPI_TRACE(NFAPI_TRACE_ERROR, "get_packed_msg_len: Error in pointers supplied %lu, %lu\n", msgHead, msgEnd);
-    return 0;
-  }
-
-  return (msgEnd - msgHead);
-}
-
 static uint8_t pack_opaque_data_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end) {
   nfapi_opaqaue_data_t *value = (nfapi_opaqaue_data_t *)tlv;
   return pusharray8(value->value, NFAPI_MAX_OPAQUE_DATA, value->length, ppWritePackedMsg, end);

nfapi/open-nFAPI/nfapi/src/nfapi_p7.c

@@ -38,6 +38,7 @@
 #include <nfapi.h>
 #include <debug.h>
 #include "nfapi_nr_interface_scf.h"
+#include "nr_nfapi_p7.h"
 
 extern int nfapi_unpack_p7_vendor_extension(nfapi_p7_message_header_t *header, uint8_t **ppReadPackedMsg, void *user_data);
 extern int nfapi_pack_p7_vendor_extension(nfapi_p7_message_header_t *header, uint8_t **ppWritePackedMsg, void *user_data);
@@ -829,7 +830,7 @@ static uint8_t pack_dl_config_request_body_value(void *tlv, uint8_t **ppWritePac
   return 1;
 }
 
-static uint8_t pack_dl_tti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
+uint8_t pack_dl_tti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
 {
   nfapi_nr_dl_tti_request_t *pNfapiMsg = (nfapi_nr_dl_tti_request_t *)msg;
 
@@ -1658,7 +1659,7 @@ static uint8_t pack_ul_config_request_body_value(void *tlv, uint8_t **ppWritePac
   return 1;
 }
 
-static uint8_t pack_ul_tti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
+uint8_t pack_ul_tti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
 {
   nfapi_nr_ul_tti_request_t *pNfapiMsg = (nfapi_nr_ul_tti_request_t *)msg;
   pNfapiMsg->n_ulcch = 0;
@@ -1987,25 +1988,22 @@ static uint8_t pack_ul_dci_pdu_list_value(void *tlv, uint8_t **ppWritePackedMsg,
   return push16(value->PDUSize, &pPackedLengthField, end);
 }
 
-static uint8_t pack_ul_dci_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) {
+uint8_t pack_ul_dci_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
+{
   nfapi_nr_ul_dci_request_t *pNfapiMsg = (nfapi_nr_ul_dci_request_t *)msg;
 
-  if (!(push16(pNfapiMsg->SFN, ppWritePackedMsg, end) &&
-        push16(pNfapiMsg->Slot, ppWritePackedMsg, end) &&
-        push8(pNfapiMsg->numPdus, ppWritePackedMsg, end)
-       ))
+  if (!(push16(pNfapiMsg->SFN, ppWritePackedMsg, end) && push16(pNfapiMsg->Slot, ppWritePackedMsg, end)
+        && push8(pNfapiMsg->numPdus, ppWritePackedMsg, end)))
     return 0;
 
-  for(int i=0; i<pNfapiMsg->numPdus; i++) {
-    if(!pack_ul_dci_pdu_list_value(&pNfapiMsg->ul_dci_pdu_list[i], ppWritePackedMsg, end))
+  for (int i = 0; i < pNfapiMsg->numPdus; i++) {
+    if (!pack_ul_dci_pdu_list_value(&pNfapiMsg->ul_dci_pdu_list[i], ppWritePackedMsg, end))
       return 0;
   }
 
   return 1;
 }
 
-
-
 static uint8_t pack_hi_dci0_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) {
   nfapi_hi_dci0_request_t *pNfapiMsg = (nfapi_hi_dci0_request_t *)msg;
   return ( push16(pNfapiMsg->sfn_sf, ppWritePackedMsg, end) &&
@@ -2159,10 +2157,15 @@ static uint8_t pack_release_request_body_value(void *tlv, uint8_t **ppWritePacke
   return 1;
 }
 
-static uint8_t pack_ue_release_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) {
+uint8_t pack_ue_release_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
+{
   nfapi_ue_release_request_t *pNfapiMsg = (nfapi_ue_release_request_t *)msg;
   int x = push16(pNfapiMsg->sfn_sf, ppWritePackedMsg, end);
-  int y = pack_tlv(NFAPI_UE_RELEASE_BODY_TAG, &pNfapiMsg->ue_release_request_body, ppWritePackedMsg, end, &pack_release_request_body_value);
+  int y = pack_tlv(NFAPI_UE_RELEASE_BODY_TAG,
+                   &pNfapiMsg->ue_release_request_body,
+                   ppWritePackedMsg,
+                   end,
+                   &pack_release_request_body_value);
   int z = pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config);
   return x && y && z;
 }
@@ -2179,7 +2182,8 @@ static uint8_t pack_nr_ue_release_request(void *msg, uint8_t **ppWritePackedMsg,
          && pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config);
 }
 
-static uint8_t pack_ue_release_response(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) {
+uint8_t pack_ue_release_response(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
+{
   nfapi_ue_release_response_t *pNfapiMsg = (nfapi_ue_release_response_t *)msg;
   int x = push32(pNfapiMsg->error_code, ppWritePackedMsg, end);
   int z = pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config);
@@ -3087,11 +3091,11 @@ static uint8_t pack_nrach_indication(void *msg, uint8_t **ppWritePackedMsg, uint
            pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config));
 }
 
-static uint8_t pack_nr_dl_node_sync(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) {
+uint8_t pack_nr_dl_node_sync(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
+{
   nfapi_nr_dl_node_sync_t *pNfapiMsg = (nfapi_nr_dl_node_sync_t *)msg;
-  return ( push32(pNfapiMsg->t1, ppWritePackedMsg, end) &&
-           pushs32(pNfapiMsg->delta_sfn_slot, ppWritePackedMsg, end) &&
-           pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config));
+  return (push32(pNfapiMsg->t1, ppWritePackedMsg, end) && pushs32(pNfapiMsg->delta_sfn_slot, ppWritePackedMsg, end)
+          && pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config));
 }
 
 static uint8_t pack_dl_node_sync(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) {
@@ -3101,12 +3105,12 @@ static uint8_t pack_dl_node_sync(void *msg, uint8_t **ppWritePackedMsg, uint8_t
            pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config));
 }
 
-static uint8_t pack_nr_ul_node_sync(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) {
+uint8_t pack_nr_ul_node_sync(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
+{
   nfapi_nr_ul_node_sync_t *pNfapiMsg = (nfapi_nr_ul_node_sync_t *)msg;
-  return (push32(pNfapiMsg->t1, ppWritePackedMsg, end) &&
-          push32(pNfapiMsg->t2, ppWritePackedMsg, end) &&
-          push32(pNfapiMsg->t3, ppWritePackedMsg, end) &&
-          pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config));
+  return (push32(pNfapiMsg->t1, ppWritePackedMsg, end) && push32(pNfapiMsg->t2, ppWritePackedMsg, end)
+          && push32(pNfapiMsg->t3, ppWritePackedMsg, end)
+          && pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config));
 }
 
 static uint8_t pack_ul_node_sync(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) {
@@ -3136,40 +3140,37 @@ static uint8_t pack_timing_info(void *msg, uint8_t **ppWritePackedMsg, uint8_t *
           pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config));
 }
 
-static uint8_t pack_nr_timing_info(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) {
+uint8_t pack_nr_timing_info(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
+{
   nfapi_nr_timing_info_t *pNfapiMsg = (nfapi_nr_timing_info_t *)msg;
-  return (push32(pNfapiMsg->last_sfn, ppWritePackedMsg, end) &&
-          push32(pNfapiMsg->last_slot, ppWritePackedMsg, end) &&
-          push32(pNfapiMsg->time_since_last_timing_info, ppWritePackedMsg, end) &&
-          push32(pNfapiMsg->dl_tti_jitter, ppWritePackedMsg, end) &&
-          push32(pNfapiMsg->tx_data_request_jitter, ppWritePackedMsg, end) &&
-          push32(pNfapiMsg->ul_tti_jitter, ppWritePackedMsg, end) &&
-          push32(pNfapiMsg->ul_dci_jitter, ppWritePackedMsg, end) &&
-          pushs32(pNfapiMsg->dl_tti_latest_delay, ppWritePackedMsg, end) &&
-          pushs32(pNfapiMsg->tx_data_request_latest_delay, ppWritePackedMsg, end) &&
-          pushs32(pNfapiMsg->ul_tti_latest_delay, ppWritePackedMsg, end) &&
-          pushs32(pNfapiMsg->ul_dci_latest_delay, ppWritePackedMsg, end) &&
-          pushs32(pNfapiMsg->dl_tti_earliest_arrival, ppWritePackedMsg, end) &&
-          pushs32(pNfapiMsg->tx_data_request_earliest_arrival, ppWritePackedMsg, end) &&
-          pushs32(pNfapiMsg->ul_tti_earliest_arrival, ppWritePackedMsg, end) &&
-          pushs32(pNfapiMsg->ul_dci_earliest_arrival, ppWritePackedMsg, end) &&
-          pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config));
+  return (push32(pNfapiMsg->last_sfn, ppWritePackedMsg, end) && push32(pNfapiMsg->last_slot, ppWritePackedMsg, end)
+          && push32(pNfapiMsg->time_since_last_timing_info, ppWritePackedMsg, end)
+          && push32(pNfapiMsg->dl_tti_jitter, ppWritePackedMsg, end)
+          && push32(pNfapiMsg->tx_data_request_jitter, ppWritePackedMsg, end)
+          && push32(pNfapiMsg->ul_tti_jitter, ppWritePackedMsg, end) && push32(pNfapiMsg->ul_dci_jitter, ppWritePackedMsg, end)
+          && pushs32(pNfapiMsg->dl_tti_latest_delay, ppWritePackedMsg, end)
+          && pushs32(pNfapiMsg->tx_data_request_latest_delay, ppWritePackedMsg, end)
+          && pushs32(pNfapiMsg->ul_tti_latest_delay, ppWritePackedMsg, end)
+          && pushs32(pNfapiMsg->ul_dci_latest_delay, ppWritePackedMsg, end)
+          && pushs32(pNfapiMsg->dl_tti_earliest_arrival, ppWritePackedMsg, end)
+          && pushs32(pNfapiMsg->tx_data_request_earliest_arrival, ppWritePackedMsg, end)
+          && pushs32(pNfapiMsg->ul_tti_earliest_arrival, ppWritePackedMsg, end)
+          && pushs32(pNfapiMsg->ul_dci_earliest_arrival, ppWritePackedMsg, end)
+          && pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config));
 }
 
 //NR UPLINK indication function packing
 
 //SLOT INDICATION
 
-static uint8_t pack_nr_slot_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* config)
+uint8_t pack_nr_slot_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
 {
-	nfapi_nr_slot_indication_scf_t *pNfapiMsg = (nfapi_nr_slot_indication_scf_t*)msg;
+  nfapi_nr_slot_indication_scf_t *pNfapiMsg = (nfapi_nr_slot_indication_scf_t *)msg;
 
-	if (!(push16((uint16_t)pNfapiMsg->sfn , ppWritePackedMsg, end) &&
-		push16((uint16_t)pNfapiMsg->slot , ppWritePackedMsg, end)
-		))
-			return 0;
+  if (!(push16((uint16_t)pNfapiMsg->sfn, ppWritePackedMsg, end) && push16((uint16_t)pNfapiMsg->slot, ppWritePackedMsg, end)))
+    return 0;
 
-return 1;
+  return 1;
 }
 
 //RX DATA INDICATION
@@ -3193,20 +3194,16 @@ static uint8_t pack_nr_rx_data_indication_body(nfapi_nr_rx_data_pdu_t *value, ui
   return 1;
 }
 
-
-static uint8_t pack_nr_rx_data_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* config)
+uint8_t pack_nr_rx_data_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
 {
-  nfapi_nr_rx_data_indication_t *pNfapiMsg = (nfapi_nr_rx_data_indication_t*)msg;
+  nfapi_nr_rx_data_indication_t *pNfapiMsg = (nfapi_nr_rx_data_indication_t *)msg;
 
-  if (!(push16(pNfapiMsg->sfn , ppWritePackedMsg, end) &&
-        push16(pNfapiMsg->slot , ppWritePackedMsg, end) &&
-        push16(pNfapiMsg->number_of_pdus, ppWritePackedMsg, end)
-  ))
+  if (!(push16(pNfapiMsg->sfn, ppWritePackedMsg, end) && push16(pNfapiMsg->slot, ppWritePackedMsg, end)
+        && push16(pNfapiMsg->number_of_pdus, ppWritePackedMsg, end)))
     return 0;
 
-  for (int i = 0; i < pNfapiMsg->number_of_pdus; i++)
-  {
-    if(!pack_nr_rx_data_indication_body(&(pNfapiMsg->pdu_list[i]), ppWritePackedMsg, end))
+  for (int i = 0; i < pNfapiMsg->number_of_pdus; i++) {
+    if (!pack_nr_rx_data_indication_body(&(pNfapiMsg->pdu_list[i]), ppWritePackedMsg, end))
       return 0;
   }
 
@@ -3238,19 +3235,16 @@ static uint8_t pack_nr_crc_indication_body(nfapi_nr_crc_t *value, uint8_t **ppWr
   return 1;
 }
 
-static uint8_t pack_nr_crc_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* config)
+uint8_t pack_nr_crc_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
 {
-  nfapi_nr_crc_indication_t *pNfapiMsg = (nfapi_nr_crc_indication_t*)msg;
+  nfapi_nr_crc_indication_t *pNfapiMsg = (nfapi_nr_crc_indication_t *)msg;
 
-  if (!(push16(pNfapiMsg->sfn , ppWritePackedMsg, end) &&
-        push16(pNfapiMsg->slot , ppWritePackedMsg, end) &&
-        push16(pNfapiMsg->number_crcs, ppWritePackedMsg, end)
-  ))
+  if (!(push16(pNfapiMsg->sfn, ppWritePackedMsg, end) && push16(pNfapiMsg->slot, ppWritePackedMsg, end)
+        && push16(pNfapiMsg->number_crcs, ppWritePackedMsg, end)))
     return 0;
 
-  for (int i = 0; i < pNfapiMsg->number_crcs; i++)
-  {
-    if(!pack_nr_crc_indication_body(&pNfapiMsg->crc_list[i], ppWritePackedMsg, end))
+  for (int i = 0; i < pNfapiMsg->number_crcs; i++) {
+    if (!pack_nr_crc_indication_body(&pNfapiMsg->crc_list[i], ppWritePackedMsg, end))
       return 0;
   }
 
@@ -3366,19 +3360,17 @@ static uint8_t pack_nr_srs_indication_body(nfapi_nr_srs_indication_pdu_t *value,
   return 1;
 }
 
-static uint8_t pack_nr_srs_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* config) {
+uint8_t pack_nr_srs_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
+{
+  nfapi_nr_srs_indication_t *pNfapiMsg = (nfapi_nr_srs_indication_t *)msg;
 
-  nfapi_nr_srs_indication_t *pNfapiMsg = (nfapi_nr_srs_indication_t*)msg;
-
-  if (!(push16(pNfapiMsg->sfn , ppWritePackedMsg, end) &&
-        push16(pNfapiMsg->slot , ppWritePackedMsg, end) &&
-        push16(pNfapiMsg->control_length , ppWritePackedMsg, end) &&
-        push8(pNfapiMsg->number_of_pdus, ppWritePackedMsg, end))) {
+  if (!(push16(pNfapiMsg->sfn, ppWritePackedMsg, end) && push16(pNfapiMsg->slot, ppWritePackedMsg, end)
+        && push16(pNfapiMsg->control_length, ppWritePackedMsg, end) && push8(pNfapiMsg->number_of_pdus, ppWritePackedMsg, end))) {
     return 0;
   }
 
-  for(int i=0; i<pNfapiMsg->number_of_pdus;i++) {
-    if(!pack_nr_srs_indication_body(&(pNfapiMsg->pdu_list[i]),ppWritePackedMsg, end)) {
+  for (int i = 0; i < pNfapiMsg->number_of_pdus; i++) {
+    if (!pack_nr_srs_indication_body(&(pNfapiMsg->pdu_list[i]), ppWritePackedMsg, end)) {
       return 0;
     }
   }
@@ -3412,26 +3404,22 @@ static uint8_t pack_nr_rach_indication_body(void* tlv, uint8_t **ppWritePackedMs
 	return 1;
 }
 
-static uint8_t pack_nr_rach_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* config)
+uint8_t pack_nr_rach_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
 {
-	nfapi_nr_rach_indication_t *pNfapiMsg = (nfapi_nr_rach_indication_t*)msg;
+  nfapi_nr_rach_indication_t *pNfapiMsg = (nfapi_nr_rach_indication_t *)msg;
 
-	if (!(push16(pNfapiMsg->sfn , ppWritePackedMsg, end) &&
-		push16(pNfapiMsg->slot , ppWritePackedMsg, end) &&
-		push8(pNfapiMsg->number_of_pdus, ppWritePackedMsg, end)
-		))
-			return 0;
+  if (!(push16(pNfapiMsg->sfn, ppWritePackedMsg, end) && push16(pNfapiMsg->slot, ppWritePackedMsg, end)
+        && push8(pNfapiMsg->number_of_pdus, ppWritePackedMsg, end)))
+    return 0;
 
-	for(int i=0; i<pNfapiMsg->number_of_pdus;i++)
-	{
-		if(!pack_nr_rach_indication_body(&(pNfapiMsg->pdu_list[i]),ppWritePackedMsg,end))
-		return 0;
-	}
+  for (int i = 0; i < pNfapiMsg->number_of_pdus; i++) {
+    if (!pack_nr_rach_indication_body(&(pNfapiMsg->pdu_list[i]), ppWritePackedMsg, end))
+      return 0;
+  }
 
-return 1;
+  return 1;
 }
 
-
 //UCI INDICATION
 
 static uint8_t pack_nr_uci_pucch_0_1(void* tlv, uint8_t **ppWritePackedMsg, uint8_t *end) {
@@ -3637,28 +3625,25 @@ static uint8_t pack_nr_uci_indication_body(nfapi_nr_uci_t* value, uint8_t **ppWr
   return 1;
 }
 
-static uint8_t pack_nr_uci_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* config)
+uint8_t pack_nr_uci_indication(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config)
 {
-  nfapi_nr_uci_indication_t *pNfapiMsg = (nfapi_nr_uci_indication_t*)msg;
+  nfapi_nr_uci_indication_t *pNfapiMsg = (nfapi_nr_uci_indication_t *)msg;
 
-  if (!push16(pNfapiMsg->sfn , ppWritePackedMsg, end))
+  if (!push16(pNfapiMsg->sfn, ppWritePackedMsg, end))
     return 0;
-  if (!push16(pNfapiMsg->slot , ppWritePackedMsg, end))
+  if (!push16(pNfapiMsg->slot, ppWritePackedMsg, end))
     return 0;
   if (!push16(pNfapiMsg->num_ucis, ppWritePackedMsg, end))
     return 0;
 
-  for (int i = 0; i < pNfapiMsg->num_ucis; i++)
-  {
+  for (int i = 0; i < pNfapiMsg->num_ucis; i++) {
     if (!pack_nr_uci_indication_body(&pNfapiMsg->uci_list[i], ppWritePackedMsg, end))
       return 0;
-
   }
 
   return 1;
 }
 
-
 // Main pack function - public
 
 int nfapi_nr_p7_message_pack(void *pMessageBuf, void *pPackedBuf, uint32_t packedBufLen, nfapi_p7_codec_config_t *config)
@@ -6061,16 +6046,17 @@ static uint8_t unpack_tx_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *
 
 //SLOT INDICATION
 
-static uint8_t unpack_nr_slot_indication(uint8_t **ppReadPackedMsg, uint8_t *end, nfapi_nr_slot_indication_scf_t *msg, nfapi_p7_codec_config_t* config)
+uint8_t unpack_nr_slot_indication(uint8_t **ppReadPackedMsg,
+                                  uint8_t *end,
+                                  nfapi_nr_slot_indication_scf_t *msg,
+                                  nfapi_p7_codec_config_t *config)
 {
-	nfapi_nr_slot_indication_scf_t *pNfapiMsg = (nfapi_nr_slot_indication_scf_t*)msg;
+  nfapi_nr_slot_indication_scf_t *pNfapiMsg = (nfapi_nr_slot_indication_scf_t *)msg;
 
-	if (!(pull16(ppReadPackedMsg, &pNfapiMsg->sfn , end) &&
-		pull16(ppReadPackedMsg, &pNfapiMsg->slot , end)
-		))
-			return 0;
+  if (!(pull16(ppReadPackedMsg, &pNfapiMsg->sfn, end) && pull16(ppReadPackedMsg, &pNfapiMsg->slot, end)))
+    return 0;
 
-return 1;
+  return 1;
 }
 
 //RX DATA INDICATION
@@ -6121,7 +6107,7 @@ static uint8_t unpack_nr_rx_data_indication(uint8_t **ppReadPackedMsg, uint8_t *
 
 //NR CRC INDICATION
 
-static uint8_t unpack_nr_crc_indication_body(nfapi_nr_crc_t *value, uint8_t **ppReadPackedMsg, uint8_t *end)
+uint8_t unpack_nr_crc_indication_body(nfapi_nr_crc_t *value, uint8_t **ppReadPackedMsg, uint8_t *end)
 {
   if (!(pull32(ppReadPackedMsg, &value->handle, end) && pull16(ppReadPackedMsg, &value->rnti, end)
         && pull8(ppReadPackedMsg, &value->harq_id, end) && pull8(ppReadPackedMsg, &value->tb_crc_status, end)
@@ -6147,24 +6133,23 @@ static uint8_t unpack_nr_crc_indication_body(nfapi_nr_crc_t *value, uint8_t **pp
   return 1;
 }
 
-static uint8_t unpack_nr_crc_indication(uint8_t **ppReadPackedMsg, uint8_t *end, nfapi_nr_crc_indication_t *msg, nfapi_p7_codec_config_t* config)
+uint8_t unpack_nr_crc_indication(uint8_t **ppReadPackedMsg,
+                                 uint8_t *end,
+                                 nfapi_nr_crc_indication_t *msg,
+                                 nfapi_p7_codec_config_t *config)
 {
-  nfapi_nr_crc_indication_t *pNfapiMsg = (nfapi_nr_crc_indication_t*)msg;
+  nfapi_nr_crc_indication_t *pNfapiMsg = (nfapi_nr_crc_indication_t *)msg;
 
-  if (!(pull16(ppReadPackedMsg, &pNfapiMsg->sfn , end) &&
-        pull16(ppReadPackedMsg, &pNfapiMsg->slot , end) &&
-        pull16(ppReadPackedMsg, &pNfapiMsg->number_crcs, end)
-  ))
+  if (!(pull16(ppReadPackedMsg, &pNfapiMsg->sfn, end) && pull16(ppReadPackedMsg, &pNfapiMsg->slot, end)
+        && pull16(ppReadPackedMsg, &pNfapiMsg->number_crcs, end)))
     return 0;
 
-  if (pNfapiMsg->number_crcs > 0)
-  {
+  if (pNfapiMsg->number_crcs > 0) {
     pNfapiMsg->crc_list = nfapi_p7_allocate(sizeof(*pNfapiMsg->crc_list) * pNfapiMsg->number_crcs, config);
   }
 
-  for (int i = 0; i < pNfapiMsg->number_crcs; i++)
-  {
-    if(!unpack_nr_crc_indication_body(&pNfapiMsg->crc_list[i], ppReadPackedMsg, end))
+  for (int i = 0; i < pNfapiMsg->number_crcs; i++) {
+    if (!unpack_nr_crc_indication_body(&pNfapiMsg->crc_list[i], ppReadPackedMsg, end))
       return 0;
   }
 
@@ -6276,16 +6261,17 @@ static uint8_t unpack_nr_srs_indication_body(nfapi_nr_srs_indication_pdu_t *valu
   return 1;
 }
 
-static uint8_t unpack_nr_srs_indication(uint8_t **ppReadPackedMsg, uint8_t *end, nfapi_nr_srs_indication_t *pNfapiMsg, nfapi_p7_codec_config_t* config) {
-
-  if (!(pull16(ppReadPackedMsg,&pNfapiMsg->sfn, end) &&
-        pull16(ppReadPackedMsg,&pNfapiMsg->slot, end) &&
-        pull16(ppReadPackedMsg,&pNfapiMsg->control_length, end) &&
-        pull8(ppReadPackedMsg,&pNfapiMsg->number_of_pdus, end))) {
+uint8_t unpack_nr_srs_indication(uint8_t **ppReadPackedMsg,
+                                 uint8_t *end,
+                                 nfapi_nr_srs_indication_t *pNfapiMsg,
+                                 nfapi_p7_codec_config_t *config)
+{
+  if (!(pull16(ppReadPackedMsg, &pNfapiMsg->sfn, end) && pull16(ppReadPackedMsg, &pNfapiMsg->slot, end)
+        && pull16(ppReadPackedMsg, &pNfapiMsg->control_length, end) && pull8(ppReadPackedMsg, &pNfapiMsg->number_of_pdus, end))) {
     return 0;
   }
 
-  for(int i=0; i<pNfapiMsg->number_of_pdus; i++) {
+  for (int i = 0; i < pNfapiMsg->number_of_pdus; i++) {
     if (!unpack_nr_srs_indication_body(&pNfapiMsg->pdu_list[i], ppReadPackedMsg, end)) {
       return 0;
     }
@@ -6318,10 +6304,10 @@ static uint8_t unpack_nr_rach_indication_body(nfapi_nr_prach_indication_pdu_t *v
   return 1;
 }
 
-static uint8_t unpack_nr_rach_indication(uint8_t **ppReadPackedMsg,
-                                         uint8_t *end,
-                                         nfapi_nr_rach_indication_t *msg,
-                                         nfapi_p7_codec_config_t *config)
+uint8_t unpack_nr_rach_indication(uint8_t **ppReadPackedMsg,
+                                  uint8_t *end,
+                                  nfapi_nr_rach_indication_t *msg,
+                                  nfapi_p7_codec_config_t *config)
 {
   nfapi_nr_rach_indication_t *pNfapiMsg = (nfapi_nr_rach_indication_t *)msg;
 
@@ -6609,7 +6595,7 @@ static uint8_t unpack_nr_uci_indication_body(nfapi_nr_uci_t *value,
   return 1;
 }
 
-static uint8_t unpack_nr_uci_indication(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t *config)
+uint8_t unpack_nr_uci_indication(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t *config)
 {
   nfapi_nr_uci_indication_t *pNfapiMsg = (nfapi_nr_uci_indication_t *)msg;
 

nfapi/open-nFAPI/pnf/public_inc/nfapi_pnf_interface.h

@@ -214,21 +214,21 @@ typedef struct nfapi_pnf_config
 	 *  STOP.request. This can be done in the call back. 
 	 */
 	int (*stop_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_stop_request_t* req);
-	int (*nr_stop_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_nr_stop_request_t* req);
+  int (*nr_stop_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_nr_stop_request_scf_t* req);
 
-	/*! A callback for the MEASUREMENT.request
-	 *  \param config A pointer to the pnf configuration
-	 *  \param phy A pointer to the pnf phy configuration
-	 *  \param req A data structure for the decoded MEASUREMENT.request. This will have
-	 *             been allocated on the stack
-	 *  \return not currently used
-	 * 
-	 * 	The client is expected to send the MEASUREMENT.response after receiving the
-	 *  MEASUREMENT.request. This can be done in the call back. 
-	 */
-	int (*measurement_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_measurement_request_t* req);
-	
-	/*! A callback for the RSSI.request
+  /*! A callback for the MEASUREMENT.request
+   *  \param config A pointer to the pnf configuration
+   *  \param phy A pointer to the pnf phy configuration
+   *  \param req A data structure for the decoded MEASUREMENT.request. This will have
+   *             been allocated on the stack
+   *  \return not currently used
+   *
+   * 	The client is expected to send the MEASUREMENT.response after receiving the
+   *  MEASUREMENT.request. This can be done in the call back.
+   */
+  int (*measurement_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_measurement_request_t* req);
+
+  /*! A callback for the RSSI.request
 	 *  \param config A pointer to the pnf configuration
 	 *  \param phy A pointer to the pnf phy configuration
 	 *  \param req A data structure for the decoded RSSI.request. This will have

nfapi/open-nFAPI/pnf/src/pnf.c

@@ -937,75 +937,58 @@ void pnf_handle_stop_request(pnf_t* pnf, void *pRecvMsg, int recvMsgLen)
 	}
 }
 
-void pnf_nr_handle_stop_request(pnf_t* pnf, void *pRecvMsg, int recvMsgLen)
+void pnf_nr_handle_stop_request(pnf_t* pnf, void* pRecvMsg, int recvMsgLen)
 {
-	// ensure it's valid
-	if (pRecvMsg == NULL || pnf == NULL)
-	{
-		NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s: NULL parameters\n", __FUNCTION__);
-	}
-	else
-	{
-		nfapi_nr_stop_request_t req;
+  // ensure it's valid
+  if (pRecvMsg == NULL || pnf == NULL) {
+    NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s: NULL parameters\n", __FUNCTION__);
+  } else {
+    nfapi_nr_stop_request_scf_t req;
 
-		NFAPI_TRACE(NFAPI_TRACE_INFO, "STOP.request received\n");
+    NFAPI_TRACE(NFAPI_TRACE_INFO, "STOP.request received\n");
 
-		nfapi_pnf_config_t* config = &(pnf->_public);
+    nfapi_pnf_config_t* config = &(pnf->_public);
 
-		// unpack the message
-		if (nfapi_nr_p5_message_unpack(pRecvMsg, recvMsgLen, &req, sizeof(req), &config->codec_config) >= 0)
-		{
-			if(config->state == NFAPI_PNF_RUNNING)
-			{
-				nfapi_pnf_phy_config_t* phy = nfapi_pnf_phy_config_find(config, req.header.phy_id);
-				if(phy)
-				{
-					if(phy->state != NFAPI_PNF_PHY_RUNNING)
-					{
-						if(config->nr_stop_req)
-						{
-							(config->nr_stop_req)(config, phy, &req);
-						}
-					}
-					else
-					{
-						nfapi_stop_response_t resp;
-						memset(&resp, 0, sizeof(resp));
-						resp.header.message_id = NFAPI_NR_PHY_MSG_TYPE_STOP_RESPONSE;
-						resp.header.phy_id = req.header.phy_id;
-						resp.error_code = NFAPI_MSG_INVALID_STATE;
-						nfapi_pnf_stop_resp(config, &resp);
-					}
-				}
-				else
-				{
-					nfapi_stop_response_t resp;
-					memset(&resp, 0, sizeof(resp));
-					resp.header.message_id = NFAPI_NR_PHY_MSG_TYPE_STOP_RESPONSE;
-					resp.header.phy_id = req.header.phy_id;
-					resp.error_code = NFAPI_MSG_INVALID_CONFIG;
-					nfapi_pnf_stop_resp(config, &resp);
-				}
-			}
-			else
-			{
-				nfapi_stop_response_t resp;
-				memset(&resp, 0, sizeof(resp));
-				resp.header.message_id = NFAPI_NR_PHY_MSG_TYPE_STOP_RESPONSE;
-				resp.header.phy_id = req.header.phy_id;
-				resp.error_code = NFAPI_MSG_INVALID_STATE;
-				nfapi_pnf_stop_resp(config, &resp);
-			}
-		}
-		else
-		{
-			NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s: Unpack message failed, ignoring\n", __FUNCTION__);
-		}
+    // unpack the message
+    if (nfapi_nr_p5_message_unpack(pRecvMsg, recvMsgLen, &req, sizeof(req), &config->codec_config) >= 0) {
+      if (config->state == NFAPI_PNF_RUNNING) {
+        nfapi_pnf_phy_config_t* phy = nfapi_pnf_phy_config_find(config, req.header.phy_id);
+        if (phy) {
+          if (phy->state != NFAPI_PNF_PHY_RUNNING) {
+            if (config->nr_stop_req) {
+              (config->nr_stop_req)(config, phy, &req);
+            }
+          } else {
+            nfapi_stop_response_t resp;
+            memset(&resp, 0, sizeof(resp));
+            resp.header.message_id = NFAPI_NR_PHY_MSG_TYPE_STOP_RESPONSE;
+            resp.header.phy_id = req.header.phy_id;
+            resp.error_code = NFAPI_MSG_INVALID_STATE;
+            nfapi_pnf_stop_resp(config, &resp);
+          }
+        } else {
+          nfapi_stop_response_t resp;
+          memset(&resp, 0, sizeof(resp));
+          resp.header.message_id = NFAPI_NR_PHY_MSG_TYPE_STOP_RESPONSE;
+          resp.header.phy_id = req.header.phy_id;
+          resp.error_code = NFAPI_MSG_INVALID_CONFIG;
+          nfapi_pnf_stop_resp(config, &resp);
+        }
+      } else {
+        nfapi_stop_response_t resp;
+        memset(&resp, 0, sizeof(resp));
+        resp.header.message_id = NFAPI_NR_PHY_MSG_TYPE_STOP_RESPONSE;
+        resp.header.phy_id = req.header.phy_id;
+        resp.error_code = NFAPI_MSG_INVALID_STATE;
+        nfapi_pnf_stop_resp(config, &resp);
+      }
+    } else {
+      NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s: Unpack message failed, ignoring\n", __FUNCTION__);
+    }
 
-		if(req.vendor_extension)
-			pnf->_public.codec_config.deallocate(req.vendor_extension);
-
-	}
+    if (req.vendor_extension)
+      pnf->_public.codec_config.deallocate(req.vendor_extension);
+  }
 }
 
 void pnf_handle_measurement_request(pnf_t* pnf, void *pRecvMsg, int recvMsgLen)

nfapi/open-nFAPI/vnf/src/vnf.c

@@ -30,6 +30,7 @@
 #ifdef ENABLE_AERIAL
 #include "nfapi/oai_integration/aerial/fapi_nvIPC.h"
 #include "nfapi/oai_integration/aerial/fapi_vnf_p5.h"
+#include "nr_fapi.h"
 #endif
 #include "nfapi/oai_integration/vendor_ext.h"
 

nfapi/tests/CMakeLists.txt

@@ -0,0 +1,4 @@
+if (ENABLE_TESTS)
+    add_subdirectory(p5)
+    add_subdirectory(p7)
+endif ()

nfapi/tests/nr_fapi_test.h

@@ -0,0 +1,98 @@
+/*
+ * 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 nfapi/tests/p5/nr_fapi_test.h
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+
+#ifndef OPENAIRINTERFACE_NR_FAPI_TEST_H
+#define OPENAIRINTERFACE_NR_FAPI_TEST_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#ifndef _STANDALONE_TESTING_
+#include "common/utils/LOG/log.h"
+#endif
+#include "nfapi_nr_interface.h"
+#include "nfapi_nr_interface_scf.h"
+
+#define FILL_TLV(TlV, TaG, VaL) \
+  do {                          \
+    TlV.tl.tag = TaG;           \
+    TlV.value = VaL;            \
+  } while (0)
+
+uint8_t rand8()
+{
+  return (rand() & 0xff);
+}
+uint16_t rand16()
+{
+  return rand8() << 8 | rand8();
+}
+uint32_t rand24()
+{
+  return rand16() << 8 | rand8();
+}
+uint32_t rand32()
+{
+  return rand24() << 8 | rand8();
+}
+uint64_t rand64()
+{
+  return (uint64_t)rand32() << 32 | rand32();
+}
+
+uint8_t rand8_range(uint8_t lower, uint8_t upper)
+{
+  return (rand() % (upper - lower + 1)) + lower;
+}
+
+uint16_t rand16_range(uint16_t lower, uint16_t upper)
+{
+  return (rand() % (upper - lower + 1)) + lower;
+}
+
+int main(int n, char *v[]);
+
+static inline void fapi_test_init_seeded(time_t seed)
+{
+  srand(seed);
+  printf("srand seed is %ld\n", seed);
+  logInit();
+  set_glog(OAILOG_DISABLE);
+}
+
+static inline void fapi_test_init()
+{
+  fapi_test_init_seeded(time(NULL));
+}
+#endif // OPENAIRINTERFACE_NR_FAPI_TEST_H

nfapi/tests/p5/CMakeLists.txt

@@ -0,0 +1,12 @@
+set(Test_Labels fapi p5)
+set(_fapi_p5_messages "param_request;param_response;config_request;config_response;start_request;start_response;stop_request;stop_indication;error_indication")
+
+foreach (fapi_p5_message IN LISTS _fapi_p5_messages)
+    add_executable(nr_fapi_${fapi_p5_message}_test nr_fapi_${fapi_p5_message}_test.c)
+    target_link_libraries(nr_fapi_${fapi_p5_message}_test PUBLIC nr_fapi_p5)
+    target_link_libraries(nr_fapi_${fapi_p5_message}_test PRIVATE pthread UTIL ${T_LIB} minimal_lib)
+    add_dependencies(tests nr_fapi_${fapi_p5_message}_test)
+
+    add_test(nr_fapi_${fapi_p5_message}_test nr_fapi_${fapi_p5_message}_test)
+    set_tests_properties(nr_fapi_${fapi_p5_message}_test PROPERTIES LABELS "${Test_Labels}")
+endforeach ()

nfapi/tests/p5/nr_fapi_config_request_test.c

@@ -0,0 +1,296 @@
+/*
+ * 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 nfapi/tests/p5/nr_fapi_config_request_test.c
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+#include "nfapi/tests/nr_fapi_test.h"
+#include "nr_fapi_p5_utils.h"
+
+void fill_config_request_tlv(nfapi_nr_config_request_scf_t *nfapi_resp)
+{
+  FILL_TLV(nfapi_resp->carrier_config.dl_bandwidth, NFAPI_NR_CONFIG_DL_BANDWIDTH_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->carrier_config.dl_frequency, NFAPI_NR_CONFIG_DL_FREQUENCY_TAG, rand32());
+  nfapi_resp->num_tlv++;
+
+  for (int i = 0; i < 5; ++i) {
+    FILL_TLV(nfapi_resp->carrier_config.dl_k0[i], NFAPI_NR_CONFIG_DL_K0_TAG, rand16());
+  }
+  // these 5 are 1 tlv
+  nfapi_resp->num_tlv++;
+  for (int i = 0; i < 5; ++i) {
+    FILL_TLV(nfapi_resp->carrier_config.dl_grid_size[i], NFAPI_NR_CONFIG_DL_GRID_SIZE_TAG, rand16());
+  }
+  // these 5 are 1 tlv
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->carrier_config.num_tx_ant, NFAPI_NR_CONFIG_NUM_TX_ANT_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->carrier_config.uplink_bandwidth, NFAPI_NR_CONFIG_UPLINK_BANDWIDTH_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->carrier_config.uplink_frequency, NFAPI_NR_CONFIG_UPLINK_FREQUENCY_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  for (int i = 0; i < 5; ++i) {
+    FILL_TLV(nfapi_resp->carrier_config.ul_k0[i], NFAPI_NR_CONFIG_UL_K0_TAG, rand16());
+  }
+  // these 5 are 1 tlv
+  nfapi_resp->num_tlv++;
+  for (int i = 0; i < 5; ++i) {
+    FILL_TLV(nfapi_resp->carrier_config.ul_grid_size[i], NFAPI_NR_CONFIG_UL_GRID_SIZE_TAG, rand16());
+  }
+  // these 5 are 1 tlv
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->carrier_config.num_rx_ant, NFAPI_NR_CONFIG_NUM_RX_ANT_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->carrier_config.frequency_shift_7p5khz, NFAPI_NR_CONFIG_FREQUENCY_SHIFT_7P5KHZ_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->cell_config.phy_cell_id, NFAPI_NR_CONFIG_PHY_CELL_ID_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->cell_config.frame_duplex_type, NFAPI_NR_CONFIG_FRAME_DUPLEX_TYPE_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->ssb_config.ss_pbch_power, NFAPI_NR_CONFIG_SS_PBCH_POWER_TAG, (int32_t)rand32());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->ssb_config.bch_payload, NFAPI_NR_CONFIG_BCH_PAYLOAD_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  // NOTE: MUST be between 0 & 4 ( inclusive ) , since this value is used as index to obtain slots per frame
+  FILL_TLV(nfapi_resp->ssb_config.scs_common, NFAPI_NR_CONFIG_SCS_COMMON_TAG, rand8_range(0, 4));
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->prach_config.prach_sequence_length, NFAPI_NR_CONFIG_PRACH_SEQUENCE_LENGTH_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->prach_config.prach_sub_c_spacing, NFAPI_NR_CONFIG_PRACH_SUB_C_SPACING_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->prach_config.restricted_set_config, NFAPI_NR_CONFIG_RESTRICTED_SET_CONFIG_TAG, rand8());
+  nfapi_resp->num_tlv++;
+  /*Number of RACH frequency domain
+    occasions. Corresponds to the
+    parameter 𝑀𝑀 in [38.211, sec 6.3.3.2]
+    which equals the higher layer
+    parameter msg1FDM
+    Value: 1,2,4,8*/
+  const uint8_t num_prach_fd_ocasions[] = {1, 2, 4, 8};
+  FILL_TLV(nfapi_resp->prach_config.num_prach_fd_occasions,
+           NFAPI_NR_CONFIG_NUM_PRACH_FD_OCCASIONS_TAG,
+           num_prach_fd_ocasions[rand8_range(0, sizeof(num_prach_fd_ocasions) - 1)]);
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->prach_config.prach_ConfigurationIndex, NFAPI_NR_CONFIG_PRACH_CONFIG_INDEX_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  nfapi_resp->prach_config.num_prach_fd_occasions_list = (nfapi_nr_num_prach_fd_occasions_t *)malloc(
+      nfapi_resp->prach_config.num_prach_fd_occasions.value * sizeof(nfapi_nr_num_prach_fd_occasions_t));
+  for (int i = 0; i < nfapi_resp->prach_config.num_prach_fd_occasions.value; i++) {
+    nfapi_nr_num_prach_fd_occasions_t *prach_fd_occasion = &(nfapi_resp->prach_config.num_prach_fd_occasions_list[i]);
+
+    FILL_TLV(prach_fd_occasion->prach_root_sequence_index, NFAPI_NR_CONFIG_PRACH_ROOT_SEQUENCE_INDEX_TAG, rand16());
+    nfapi_resp->num_tlv++;
+
+    FILL_TLV(prach_fd_occasion->num_root_sequences, NFAPI_NR_CONFIG_NUM_ROOT_SEQUENCES_TAG, rand8());
+    nfapi_resp->num_tlv++;
+
+    FILL_TLV(prach_fd_occasion->k1, NFAPI_NR_CONFIG_K1_TAG, rand8());
+    nfapi_resp->num_tlv++;
+
+    FILL_TLV(prach_fd_occasion->prach_zero_corr_conf, NFAPI_NR_CONFIG_PRACH_ZERO_CORR_CONF_TAG, rand8());
+    nfapi_resp->num_tlv++;
+
+    // This doesn't make sense to be more than the total num_root_sequences
+    /* SCF 222.10.02 : Number of unused sequences available
+       for noise estimation per FD occasion. At
+       least one unused root sequence is
+       required per FD occasion.  */
+    if (prach_fd_occasion->num_root_sequences.value != 0) {
+      FILL_TLV(prach_fd_occasion->num_unused_root_sequences,
+               NFAPI_NR_CONFIG_NUM_UNUSED_ROOT_SEQUENCES_TAG,
+               rand8_range(1, prach_fd_occasion->num_root_sequences.value));
+    } else {
+      FILL_TLV(prach_fd_occasion->num_unused_root_sequences, NFAPI_NR_CONFIG_NUM_UNUSED_ROOT_SEQUENCES_TAG, 1);
+    }
+    nfapi_resp->num_tlv++;
+
+    prach_fd_occasion->unused_root_sequences_list =
+        (nfapi_uint8_tlv_t *)malloc(prach_fd_occasion->num_unused_root_sequences.value * sizeof(nfapi_uint8_tlv_t));
+    for (int k = 0; k < prach_fd_occasion->num_unused_root_sequences.value; k++) {
+      FILL_TLV(prach_fd_occasion->unused_root_sequences_list[k], NFAPI_NR_CONFIG_UNUSED_ROOT_SEQUENCES_TAG, rand16());
+      nfapi_resp->num_tlv++;
+    }
+  }
+
+  FILL_TLV(nfapi_resp->prach_config.ssb_per_rach, NFAPI_NR_CONFIG_SSB_PER_RACH_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->prach_config.prach_multiple_carriers_in_a_band,
+           NFAPI_NR_CONFIG_PRACH_MULTIPLE_CARRIERS_IN_A_BAND_TAG,
+           rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->ssb_table.ssb_offset_point_a, NFAPI_NR_CONFIG_SSB_OFFSET_POINT_A_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->ssb_table.ssb_period, NFAPI_NR_CONFIG_SSB_PERIOD_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->ssb_table.ssb_subcarrier_offset, NFAPI_NR_CONFIG_SSB_SUBCARRIER_OFFSET_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->ssb_table.MIB, NFAPI_NR_CONFIG_MIB_TAG, rand32());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->ssb_table.ssb_mask_list[0].ssb_mask, NFAPI_NR_CONFIG_SSB_MASK_TAG, rand32());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->ssb_table.ssb_mask_list[1].ssb_mask, NFAPI_NR_CONFIG_SSB_MASK_TAG, rand32());
+  nfapi_resp->num_tlv++;
+
+  for (int i = 0; i < 64; i++) {
+    FILL_TLV(nfapi_resp->ssb_table.ssb_beam_id_list[i].beam_id, NFAPI_NR_CONFIG_BEAM_ID_TAG, rand8());
+    nfapi_resp->num_tlv++;
+  }
+
+  FILL_TLV(nfapi_resp->tdd_table.tdd_period, NFAPI_NR_CONFIG_TDD_PERIOD_TAG, rand8());
+  nfapi_resp->num_tlv++;
+  const uint8_t slotsperframe[5] = {10, 20, 40, 80, 160};
+  // Assuming always CP_Normal, because Cyclic prefix is not included in CONFIG.request 10.02, but is present in 10.04
+  uint8_t cyclicprefix = 1;
+  bool normal_CP = cyclicprefix ? false : true;
+  // 3GPP 38.211 Table 4.3.2.1 & Table 4.3.2.2
+  uint8_t number_of_symbols_per_slot = normal_CP ? 14 : 12;
+
+  nfapi_resp->tdd_table.max_tdd_periodicity_list = (nfapi_nr_max_tdd_periodicity_t *)malloc(
+      slotsperframe[nfapi_resp->ssb_config.scs_common.value] * sizeof(nfapi_nr_max_tdd_periodicity_t));
+
+  for (int i = 0; i < slotsperframe[nfapi_resp->ssb_config.scs_common.value]; i++) {
+    nfapi_resp->tdd_table.max_tdd_periodicity_list[i].max_num_of_symbol_per_slot_list =
+        (nfapi_nr_max_num_of_symbol_per_slot_t *)malloc(number_of_symbols_per_slot * sizeof(nfapi_nr_max_num_of_symbol_per_slot_t));
+  }
+
+  for (int i = 0; i < slotsperframe[nfapi_resp->ssb_config.scs_common.value]; i++) { // TODO check right number of slots
+    for (int k = 0; k < number_of_symbols_per_slot; k++) { // TODO can change?
+      FILL_TLV(nfapi_resp->tdd_table.max_tdd_periodicity_list[i].max_num_of_symbol_per_slot_list[k].slot_config,
+               NFAPI_NR_CONFIG_SLOT_CONFIG_TAG,
+               rand8());
+      nfapi_resp->num_tlv++;
+    }
+  }
+
+  FILL_TLV(nfapi_resp->measurement_config.rssi_measurement, NFAPI_NR_CONFIG_RSSI_MEASUREMENT_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  nfapi_resp->nfapi_config.p7_vnf_address_ipv4.tl.tag = NFAPI_NR_NFAPI_P7_VNF_ADDRESS_IPV4_TAG;
+  for (int i = 0; i < NFAPI_IPV4_ADDRESS_LENGTH; ++i) {
+    nfapi_resp->nfapi_config.p7_vnf_address_ipv4.address[i] = rand8();
+  }
+  nfapi_resp->num_tlv++;
+
+  nfapi_resp->nfapi_config.p7_vnf_address_ipv6.tl.tag = NFAPI_NR_NFAPI_P7_VNF_ADDRESS_IPV6_TAG;
+  for (int i = 0; i < NFAPI_IPV6_ADDRESS_LENGTH; ++i) {
+    nfapi_resp->nfapi_config.p7_vnf_address_ipv6.address[i] = rand8();
+  }
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->nfapi_config.p7_vnf_port, NFAPI_NR_NFAPI_P7_VNF_PORT_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->nfapi_config.timing_window, NFAPI_NR_NFAPI_TIMING_WINDOW_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->nfapi_config.timing_info_mode, NFAPI_NR_NFAPI_TIMING_INFO_MODE_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->nfapi_config.timing_info_period, NFAPI_NR_NFAPI_TIMING_INFO_PERIOD_TAG, rand8());
+  nfapi_resp->num_tlv++;
+}
+
+void test_pack_unpack(nfapi_nr_config_request_scf_t *req)
+{
+  uint8_t msg_buf[65535];
+  uint16_t msg_len = sizeof(*req);
+
+  // first test the packing procedure
+  int pack_result = fapi_nr_p5_message_pack(req, msg_len, msg_buf, sizeof(msg_buf), NULL);
+  // PARAM.request message body length is 0
+  DevAssert(pack_result >= 0 + NFAPI_HEADER_LENGTH);
+  // update req message_length value with value calculated in message_pack procedure
+  req->header.message_length = pack_result - NFAPI_HEADER_LENGTH;
+  // test the unpacking of the header
+  // copy first NFAPI_HEADER_LENGTH bytes into a new buffer, to simulate SCTP PEEK
+  fapi_message_header_t header;
+  uint32_t header_buffer_size = NFAPI_HEADER_LENGTH;
+  uint8_t header_buffer[header_buffer_size];
+  for (int idx = 0; idx < header_buffer_size; idx++) {
+    header_buffer[idx] = msg_buf[idx];
+  }
+  uint8_t *pReadPackedMessage = header_buffer;
+  int unpack_header_result = fapi_nr_p5_message_header_unpack(&pReadPackedMessage, NFAPI_HEADER_LENGTH, &header, sizeof(header), 0);
+  DevAssert(unpack_header_result >= 0);
+  DevAssert(header.message_id == req->header.message_id);
+  DevAssert(header.message_length == req->header.message_length);
+  // test the unpacking and compare with initial message
+  nfapi_nr_config_request_scf_t unpacked_req = {0};
+  int unpack_result =
+      fapi_nr_p5_message_unpack(msg_buf, header.message_length + NFAPI_HEADER_LENGTH, &unpacked_req, sizeof(unpacked_req), NULL);
+  DevAssert(unpack_result >= 0);
+  DevAssert(eq_config_request(&unpacked_req, req));
+  free_config_request(&unpacked_req);
+}
+
+void test_copy(const nfapi_nr_config_request_scf_t *msg)
+{
+  // Test copy function
+  nfapi_nr_config_request_scf_t copy = {0};
+  copy_config_request(msg, &copy);
+  DevAssert(eq_config_request(msg, &copy));
+  free_config_request(&copy);
+}
+
+int main(int n, char *v[])
+{
+  fapi_test_init();
+  nfapi_nr_config_request_scf_t req = {.header.message_id = NFAPI_NR_PHY_MSG_TYPE_CONFIG_REQUEST};
+  // Fill CONFIG.request TVLs
+  fill_config_request_tlv(&req);
+  // Perform tests
+  test_pack_unpack(&req);
+  test_copy(&req);
+  // All tests successful!
+  free_config_request(&req);
+  return 0;
+}

nfapi/tests/p5/nr_fapi_config_response_test.c

@@ -0,0 +1,144 @@
+/*
+ * 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 nfapi/tests/p5/nr_fapi_config_response_test.c
+ * \brief Defines a unitary test for the FAPI CONFIG.response message ( 0x03 )
+ *        The test consists of filling a message with randomized data, filling each lists as well with random TLVs
+ *        After the message is created, is is packed into a byte buffer
+ *        After packing, the header is unpacked to mimic SCTP PEEK and the values unpacked checked against the original message
+ *        After the header is checked, the whole message is unpacked.
+ *        The test ends by checking all of the unpacked message contents against the original message
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+#include "nfapi/tests/nr_fapi_test.h"
+#include "nr_fapi_p5_utils.h"
+
+void fill_config_response_tlv_list(nfapi_nr_generic_tlv_scf_t *list, uint8_t size)
+{
+  uint8_t const TLVtypes[] = {UINT_8, UINT_16, UINT_32, ARRAY_UINT_16};
+  for (int i = 0; i < size; ++i) {
+    nfapi_nr_generic_tlv_scf_t *element = &(list[i]);
+    element->tl.tag = rand16_range(NFAPI_NR_CONFIG_DL_BANDWIDTH_TAG, NFAPI_NR_CONFIG_RSSI_MEASUREMENT_TAG);
+    element->tl.length = TLVtypes[rand8_range(0, sizeof(TLVtypes) - 1)];
+    switch (element->tl.length) {
+      case UINT_8:
+        element->value.u8 = rand8();
+        break;
+      case UINT_16:
+        element->value.u16 = rand16();
+        break;
+      case UINT_32:
+        element->value.u32 = rand32();
+        break;
+      case ARRAY_UINT_16:
+        for (int j = 0; j < 5; ++j) {
+          element->value.array_u16[j] = rand16();
+        }
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+void fill_config_response_tlv(nfapi_nr_config_response_scf_t *nfapi_resp)
+{
+  nfapi_resp->error_code = rand8();
+  nfapi_resp->num_invalid_tlvs = rand8();
+  nfapi_resp->num_invalid_tlvs_configured_in_idle = rand8();
+  nfapi_resp->num_invalid_tlvs_configured_in_running = rand8();
+  nfapi_resp->num_missing_tlvs = rand8();
+  // Lists
+  nfapi_resp->invalid_tlvs_list =
+      (nfapi_nr_generic_tlv_scf_t *)malloc(nfapi_resp->num_invalid_tlvs * sizeof(nfapi_nr_generic_tlv_scf_t));
+  nfapi_resp->invalid_tlvs_configured_in_idle_list =
+      (nfapi_nr_generic_tlv_scf_t *)malloc(nfapi_resp->num_invalid_tlvs_configured_in_idle * sizeof(nfapi_nr_generic_tlv_scf_t));
+  nfapi_resp->invalid_tlvs_configured_in_running_list =
+      (nfapi_nr_generic_tlv_scf_t *)malloc(nfapi_resp->num_invalid_tlvs_configured_in_running * sizeof(nfapi_nr_generic_tlv_scf_t));
+  nfapi_resp->missing_tlvs_list =
+      (nfapi_nr_generic_tlv_scf_t *)malloc(nfapi_resp->num_missing_tlvs * sizeof(nfapi_nr_generic_tlv_scf_t));
+
+  fill_config_response_tlv_list(nfapi_resp->invalid_tlvs_list, nfapi_resp->num_invalid_tlvs);
+  fill_config_response_tlv_list(nfapi_resp->invalid_tlvs_configured_in_idle_list, nfapi_resp->num_invalid_tlvs_configured_in_idle);
+  fill_config_response_tlv_list(nfapi_resp->invalid_tlvs_configured_in_running_list,
+                                nfapi_resp->num_invalid_tlvs_configured_in_running);
+  fill_config_response_tlv_list(nfapi_resp->missing_tlvs_list, nfapi_resp->num_missing_tlvs);
+}
+
+void test_pack_unpack(nfapi_nr_config_response_scf_t *req)
+{
+  uint8_t msg_buf[65535];
+  uint16_t msg_len = sizeof(*req);
+  // first test the packing procedure
+  int pack_result = fapi_nr_p5_message_pack(req, msg_len, msg_buf, sizeof(msg_buf), NULL);
+  DevAssert(pack_result >= 0 + NFAPI_HEADER_LENGTH);
+  // update req message_length value with value calculated in message_pack procedure
+  req->header.message_length = pack_result - NFAPI_HEADER_LENGTH;
+  // test the unpacking of the header
+  // copy first NFAPI_HEADER_LENGTH bytes into a new buffer, to simulate SCTP PEEK
+  fapi_message_header_t header;
+  uint32_t header_buffer_size = NFAPI_HEADER_LENGTH;
+  uint8_t header_buffer[header_buffer_size];
+  for (int idx = 0; idx < header_buffer_size; idx++) {
+    header_buffer[idx] = msg_buf[idx];
+  }
+  uint8_t *pReadPackedMessage = header_buffer;
+  int unpack_header_result = fapi_nr_p5_message_header_unpack(&pReadPackedMessage, NFAPI_HEADER_LENGTH, &header, sizeof(header), 0);
+  DevAssert(unpack_header_result >= 0);
+  DevAssert(header.message_id == req->header.message_id);
+  DevAssert(header.message_length == req->header.message_length);
+  // test the unpacking and compare with initial message
+  nfapi_nr_config_response_scf_t unpacked_req = {0};
+  int unpack_result =
+      fapi_nr_p5_message_unpack(msg_buf, header.message_length + NFAPI_HEADER_LENGTH, &unpacked_req, sizeof(unpacked_req), 0);
+  DevAssert(unpack_result >= 0);
+  DevAssert(eq_config_response(&unpacked_req, req));
+  free_config_response(&unpacked_req);
+}
+
+void test_copy(const nfapi_nr_config_response_scf_t *msg)
+{
+  // Test copy function
+  nfapi_nr_config_response_scf_t copy = {0};
+  copy_config_response(msg, &copy);
+  DevAssert(eq_config_response(msg, &copy));
+  free_config_response(&copy);
+}
+
+int main(int n, char *v[])
+{
+  fapi_test_init();
+
+  nfapi_nr_config_response_scf_t req = {.header.message_id = NFAPI_NR_PHY_MSG_TYPE_CONFIG_RESPONSE};
+  // Fill Config response TVLs
+  fill_config_response_tlv(&req);
+  // Perform tests
+  test_pack_unpack(&req);
+  test_copy(&req);
+  // All tests successful!
+  free_config_response(&req);
+  return 0;
+}

nfapi/tests/p5/nr_fapi_error_indication_test.c

@@ -0,0 +1,90 @@
+/*
+ * 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 nfapi/tests/p5/nr_fapi_error_indication_test.c
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+#include "nfapi/tests/nr_fapi_test.h"
+#include "nr_fapi_p5_utils.h"
+
+void test_pack_unpack(nfapi_nr_error_indication_scf_t *req)
+{
+  uint8_t msg_buf[65535];
+  uint16_t msg_len = sizeof(*req);
+  // first test the packing procedure
+  int pack_result = fapi_nr_p5_message_pack(req, msg_len, msg_buf, sizeof(msg_buf), NULL);
+  DevAssert(pack_result >= 0 + NFAPI_HEADER_LENGTH);
+  // update req message_length value with value calculated in message_pack procedure
+  req->header.message_length = pack_result - NFAPI_HEADER_LENGTH;
+  // test the unpacking of the header
+  // copy first NFAPI_HEADER_LENGTH bytes into a new buffer, to simulate SCTP PEEK
+  fapi_message_header_t header;
+  uint32_t header_buffer_size = NFAPI_HEADER_LENGTH;
+  uint8_t header_buffer[header_buffer_size];
+  for (int idx = 0; idx < header_buffer_size; idx++) {
+    header_buffer[idx] = msg_buf[idx];
+  }
+  uint8_t *pReadPackedMessage = header_buffer;
+  int unpack_header_result = fapi_nr_p5_message_header_unpack(&pReadPackedMessage, NFAPI_HEADER_LENGTH, &header, sizeof(header), 0);
+  DevAssert(unpack_header_result >= 0);
+  DevAssert(header.message_id == req->header.message_id);
+  DevAssert(header.message_length == req->header.message_length);
+  // test the unpacking and compare with initial message
+  nfapi_nr_error_indication_scf_t unpacked_req = {0};
+  int unpack_result =
+      fapi_nr_p5_message_unpack(msg_buf, header.message_length + NFAPI_HEADER_LENGTH, &unpacked_req, sizeof(unpacked_req), NULL);
+  DevAssert(unpack_result >= 0);
+  DevAssert(eq_error_indication(&unpacked_req, req));
+  free_error_indication(&unpacked_req);
+}
+
+void test_copy(const nfapi_nr_error_indication_scf_t *msg)
+{
+  // Test copy function
+  nfapi_nr_error_indication_scf_t copy = {0};
+  copy_error_indication(msg, &copy);
+  DevAssert(eq_error_indication(msg, &copy));
+  free_error_indication(&copy);
+}
+
+int main(int n, char *v[])
+{
+  fapi_test_init();
+
+  nfapi_nr_error_indication_scf_t req = {.header.message_id = NFAPI_NR_PHY_MSG_TYPE_ERROR_INDICATION};
+  // Fill the message with randomized data
+  req.sfn = rand16_range(0, 1023);
+  req.slot = rand16_range(0, 159);
+  req.message_id = rand8_range(0x00, 0xFF);
+  req.error_code = rand8_range(0x00, 0x08);
+  // Perform tests
+  test_pack_unpack(&req);
+  test_copy(&req);
+  // All tests successful!
+  free_error_indication(&req);
+  return 0;
+}

nfapi/tests/p5/nr_fapi_param_request_test.c

@@ -0,0 +1,86 @@
+/*
+ * 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 nfapi/tests/p5/nr_fapi_param_request_test.c
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+#include "nfapi/tests/nr_fapi_test.h"
+#include "nr_fapi_p5_utils.h"
+
+void test_pack_unpack(nfapi_nr_param_request_scf_t *req)
+{
+  uint8_t msg_buf[65535];
+  uint16_t msg_len = sizeof(*req);
+  // first test the packing procedure
+  int pack_result = fapi_nr_p5_message_pack(req, msg_len, msg_buf, sizeof(msg_buf), NULL);
+  // PARAM.request message body length is 0
+  DevAssert(pack_result == 0 + NFAPI_HEADER_LENGTH);
+  // update req message_length value with value calculated in message_pack procedure
+  req->header.message_length = pack_result - NFAPI_HEADER_LENGTH;
+  // test the unpacking of the header
+  // copy first NFAPI_HEADER_LENGTH bytes into a new buffer, to simulate SCTP PEEK
+  fapi_message_header_t header;
+  uint32_t header_buffer_size = NFAPI_HEADER_LENGTH;
+  uint8_t header_buffer[header_buffer_size];
+  for (int idx = 0; idx < header_buffer_size; idx++) {
+    header_buffer[idx] = msg_buf[idx];
+  }
+  uint8_t *pReadPackedMessage = header_buffer;
+  int unpack_header_result = fapi_nr_p5_message_header_unpack(&pReadPackedMessage, NFAPI_HEADER_LENGTH, &header, sizeof(header), 0);
+  DevAssert(unpack_header_result >= 0);
+  DevAssert(header.message_id == req->header.message_id);
+  DevAssert(header.message_length == req->header.message_length);
+  // test the unpacking and compare with initial message
+  nfapi_nr_param_request_scf_t unpacked_req = {0};
+  int unpack_result =
+      fapi_nr_p5_message_unpack(msg_buf, header.message_length + NFAPI_HEADER_LENGTH, &unpacked_req, sizeof(unpacked_req), NULL);
+  DevAssert(unpack_result >= 0);
+  DevAssert(eq_param_request(&unpacked_req, req));
+  free_param_request(&unpacked_req);
+}
+
+void test_copy(const nfapi_nr_param_request_scf_t *msg)
+{
+  // Test copy function
+  nfapi_nr_param_request_scf_t copy = {0};
+  copy_param_request(msg, &copy);
+  DevAssert(eq_param_request(msg, &copy));
+  free_param_request(&copy);
+}
+
+int main(int n, char *v[])
+{
+  fapi_test_init();
+
+  nfapi_nr_param_request_scf_t req = {.header.message_id = NFAPI_NR_PHY_MSG_TYPE_PARAM_REQUEST};
+  // Perform tests
+  test_pack_unpack(&req);
+  test_copy(&req);
+  // All tests successful!
+  free_param_request(&req);
+  return 0;
+}

nfapi/tests/p5/nr_fapi_param_response_test.c

@@ -0,0 +1,279 @@
+/*
+ * 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 nfapi/tests/p5/nr_fapi_param_response_test.c
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+#include "nfapi/tests/nr_fapi_test.h"
+#include "nr_fapi_p5_utils.h"
+
+void fill_param_response_tlv(nfapi_nr_param_response_scf_t *nfapi_resp)
+{
+  nfapi_resp->error_code = rand8_range(NFAPI_MSG_OK, NFAPI_MSG_INVALID_STATE);
+
+  FILL_TLV(nfapi_resp->cell_param.release_capability, NFAPI_NR_PARAM_TLV_RELEASE_CAPABILITY_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->cell_param.phy_state, NFAPI_NR_PARAM_TLV_PHY_STATE_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->cell_param.skip_blank_dl_config, NFAPI_NR_PARAM_TLV_SKIP_BLANK_DL_CONFIG_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->cell_param.skip_blank_ul_config, NFAPI_NR_PARAM_TLV_SKIP_BLANK_UL_CONFIG_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->cell_param.num_config_tlvs_to_report,
+           NFAPI_NR_PARAM_TLV_NUM_CONFIG_TLVS_TO_REPORT_TAG,
+           rand16_range(0, NFAPI_NR_CONFIG_RSSI_MEASUREMENT_TAG - NFAPI_NR_CONFIG_DL_BANDWIDTH_TAG));
+  nfapi_resp->num_tlv++;
+
+  nfapi_resp->cell_param.config_tlvs_to_report_list =
+      calloc(nfapi_resp->cell_param.num_config_tlvs_to_report.value, sizeof(nfapi_uint8_tlv_t *));
+  for (int i = 0; i < nfapi_resp->cell_param.num_config_tlvs_to_report.value; ++i) {
+    FILL_TLV(nfapi_resp->cell_param.config_tlvs_to_report_list[i],
+             rand16_range(NFAPI_NR_CONFIG_DL_BANDWIDTH_TAG, NFAPI_NR_CONFIG_RSSI_MEASUREMENT_TAG),
+             rand8_range(0, 5));
+    nfapi_resp->cell_param.config_tlvs_to_report_list[i].tl.length = 1;
+  }
+
+  FILL_TLV(nfapi_resp->carrier_param.cyclic_prefix, NFAPI_NR_PARAM_TLV_CYCLIC_PREFIX_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->carrier_param.supported_subcarrier_spacings_dl,
+           NFAPI_NR_PARAM_TLV_SUPPORTED_SUBCARRIER_SPACINGS_DL_TAG,
+           rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->carrier_param.supported_bandwidth_dl, NFAPI_NR_PARAM_TLV_SUPPORTED_BANDWIDTH_DL_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->carrier_param.supported_subcarrier_spacings_ul,
+           NFAPI_NR_PARAM_TLV_SUPPORTED_SUBCARRIER_SPACINGS_UL_TAG,
+           rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->carrier_param.supported_bandwidth_ul, NFAPI_NR_PARAM_TLV_SUPPORTED_BANDWIDTH_UL_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdcch_param.cce_mapping_type, NFAPI_NR_PARAM_TLV_CCE_MAPPING_TYPE_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdcch_param.coreset_outside_first_3_of_ofdm_syms_of_slot,
+           NFAPI_NR_PARAM_TLV_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG,
+           rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdcch_param.coreset_precoder_granularity_coreset,
+           NFAPI_NR_PARAM_TLV_PRECODER_GRANULARITY_CORESET_TAG,
+           rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdcch_param.pdcch_mu_mimo, NFAPI_NR_PARAM_TLV_PDCCH_MU_MIMO_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdcch_param.pdcch_precoder_cycling, NFAPI_NR_PARAM_TLV_PDCCH_PRECODER_CYCLING_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdcch_param.max_pdcch_per_slot, NFAPI_NR_PARAM_TLV_MAX_PDCCHS_PER_SLOT_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pucch_param.pucch_formats, NFAPI_NR_PARAM_TLV_PUCCH_FORMATS_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pucch_param.max_pucchs_per_slot, NFAPI_NR_PARAM_TLV_MAX_PUCCHS_PER_SLOT_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.pdsch_mapping_type, NFAPI_NR_PARAM_TLV_PDSCH_MAPPING_TYPE_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.pdsch_allocation_types, NFAPI_NR_PARAM_TLV_PDSCH_ALLOCATION_TYPES_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.pdsch_vrb_to_prb_mapping, NFAPI_NR_PARAM_TLV_PDSCH_VRB_TO_PRB_MAPPING_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.pdsch_cbg, NFAPI_NR_PARAM_TLV_PDSCH_CBG_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.pdsch_dmrs_config_types, NFAPI_NR_PARAM_TLV_PDSCH_DMRS_CONFIG_TYPES_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.pdsch_dmrs_max_length, NFAPI_NR_PARAM_TLV_PDSCH_DMRS_MAX_LENGTH_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.pdsch_dmrs_additional_pos, NFAPI_NR_PARAM_TLV_PDSCH_DMRS_ADDITIONAL_POS_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.max_pdsch_tbs_per_slot, NFAPI_NR_PARAM_TLV_MAX_PDSCH_S_TBS_PER_SLOT_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.max_number_mimo_layers_pdsch, NFAPI_NR_PARAM_TLV_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.supported_max_modulation_order_dl,
+           NFAPI_NR_PARAM_TLV_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG,
+           rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.max_mu_mimo_users_dl, NFAPI_NR_PARAM_TLV_MAX_MU_MIMO_USERS_DL_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.pdsch_data_in_dmrs_symbols, NFAPI_NR_PARAM_TLV_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.premption_support, NFAPI_NR_PARAM_TLV_PREMPTION_SUPPORT_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pdsch_param.pdsch_non_slot_support, NFAPI_NR_PARAM_TLV_PDSCH_NON_SLOT_SUPPORT_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.uci_mux_ulsch_in_pusch, NFAPI_NR_PARAM_TLV_UCI_MUX_ULSCH_IN_PUSCH_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.uci_only_pusch, NFAPI_NR_PARAM_TLV_UCI_ONLY_PUSCH_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.pusch_frequency_hopping, NFAPI_NR_PARAM_TLV_PUSCH_FREQUENCY_HOPPING_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.pusch_dmrs_config_types, NFAPI_NR_PARAM_TLV_PUSCH_DMRS_CONFIG_TYPES_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.pusch_dmrs_max_len, NFAPI_NR_PARAM_TLV_PUSCH_DMRS_MAX_LEN_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.pusch_dmrs_additional_pos, NFAPI_NR_PARAM_TLV_PUSCH_DMRS_ADDITIONAL_POS_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.pusch_cbg, NFAPI_NR_PARAM_TLV_PUSCH_CBG_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.pusch_mapping_type, NFAPI_NR_PARAM_TLV_PUSCH_MAPPING_TYPE_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.pusch_allocation_types, NFAPI_NR_PARAM_TLV_PUSCH_ALLOCATION_TYPES_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.pusch_vrb_to_prb_mapping, NFAPI_NR_PARAM_TLV_PUSCH_VRB_TO_PRB_MAPPING_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.pusch_max_ptrs_ports, NFAPI_NR_PARAM_TLV_PUSCH_MAX_PTRS_PORTS_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.max_pduschs_tbs_per_slot, NFAPI_NR_PARAM_TLV_MAX_PDUSCHS_TBS_PER_SLOT_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.max_number_mimo_layers_non_cb_pusch,
+           NFAPI_NR_PARAM_TLV_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG,
+           rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.supported_modulation_order_ul, NFAPI_NR_PARAM_TLV_SUPPORTED_MODULATION_ORDER_UL_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.max_mu_mimo_users_ul, NFAPI_NR_PARAM_TLV_MAX_MU_MIMO_USERS_UL_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.dfts_ofdm_support, NFAPI_NR_PARAM_TLV_DFTS_OFDM_SUPPORT_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->pusch_param.pusch_aggregation_factor, NFAPI_NR_PARAM_TLV_PUSCH_AGGREGATION_FACTOR_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->prach_param.prach_long_formats, NFAPI_NR_PARAM_TLV_PRACH_LONG_FORMATS_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->prach_param.prach_short_formats, NFAPI_NR_PARAM_TLV_PRACH_SHORT_FORMATS_TAG, rand16());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->prach_param.prach_restricted_sets, NFAPI_NR_PARAM_TLV_PRACH_RESTRICTED_SETS_TAG, rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->prach_param.max_prach_fd_occasions_in_a_slot,
+           NFAPI_NR_PARAM_TLV_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG,
+           rand8());
+  nfapi_resp->num_tlv++;
+
+  FILL_TLV(nfapi_resp->measurement_param.rssi_measurement_support, NFAPI_NR_PARAM_TLV_RSSI_MEASUREMENT_SUPPORT_TAG, rand8());
+  nfapi_resp->num_tlv++;
+}
+
+void test_pack_unpack(nfapi_nr_param_response_scf_t *req)
+{
+  uint8_t msg_buf[65535];
+  uint16_t msg_len = sizeof(*req);
+  // first test the packing procedure
+  int pack_result = fapi_nr_p5_message_pack(req, msg_len, msg_buf, sizeof(msg_buf), NULL);
+  // PARAM.response message body length is AT LEAST 10 (NFAPI_HEADER_LENGTH + 1 byte error_code + 1 byte num_tlv)
+  DevAssert(pack_result >= NFAPI_HEADER_LENGTH + 1 + 1);
+  // update req message_length value with value calculated in message_pack procedure
+  req->header.message_length = pack_result - NFAPI_HEADER_LENGTH;
+  // test the unpacking of the header
+  // copy first NFAPI_HEADER_LENGTH bytes into a new buffer, to simulate SCTP PEEK
+  nfapi_p4_p5_message_header_t header;
+  uint32_t header_buffer_size = NFAPI_HEADER_LENGTH;
+  uint8_t header_buffer[header_buffer_size];
+  for (int idx = 0; idx < header_buffer_size; idx++) {
+    header_buffer[idx] = msg_buf[idx];
+  }
+  uint8_t *pReadPackedMessage = header_buffer;
+  int unpack_header_result = fapi_nr_p5_message_header_unpack(&pReadPackedMessage, NFAPI_HEADER_LENGTH, &header, sizeof(header), 0);
+  DevAssert(unpack_header_result >= 0);
+  DevAssert(header.message_id == req->header.message_id);
+  DevAssert(header.message_length == req->header.message_length);
+  // test the unpaking and compare with initial message
+  nfapi_nr_param_response_scf_t unpacked_req = {0};
+  int unpack_result =
+      fapi_nr_p5_message_unpack(msg_buf, header.message_length + NFAPI_HEADER_LENGTH, &unpacked_req, sizeof(unpacked_req), NULL);
+  DevAssert(unpack_result >= 0);
+  DevAssert(eq_param_response(&unpacked_req, req));
+  free_param_response(&unpacked_req);
+}
+
+void test_copy(const nfapi_nr_param_response_scf_t *msg)
+{
+  // Test copy function
+  nfapi_nr_param_response_scf_t copy = {0};
+  copy_param_response(msg, &copy);
+  DevAssert(eq_param_response(msg, &copy));
+  free_param_response(&copy);
+}
+
+int main(int n, char *v[])
+{
+  fapi_test_init();
+  nfapi_nr_param_response_scf_t req = {.header.message_id = NFAPI_NR_PHY_MSG_TYPE_PARAM_RESPONSE};
+  // Fill Param response TVLs
+  fill_param_response_tlv(&req);
+  // Perform tests
+  test_pack_unpack(&req);
+  test_copy(&req);
+  // All tests successful!
+  free_param_response(&req);
+  return 0;
+}

nfapi/tests/p5/nr_fapi_start_request_test.c

@@ -0,0 +1,86 @@
+/*
+ * 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 nfapi/tests/p5/nr_fapi_start_request_test.c
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+#include "nfapi/tests/nr_fapi_test.h"
+#include "nr_fapi_p5_utils.h"
+
+void test_pack_unpack(nfapi_nr_start_request_scf_t *req)
+{
+  uint8_t msg_buf[65535];
+  uint16_t msg_len = sizeof(*req);
+  // first test the packing procedure
+  int pack_result = fapi_nr_p5_message_pack(req, msg_len, msg_buf, sizeof(msg_buf), NULL);
+  // START.request message body length is 0
+  DevAssert(pack_result == 0 + NFAPI_HEADER_LENGTH);
+  // update req message_length value with value calculated in message_pack procedure
+  req->header.message_length = pack_result - NFAPI_HEADER_LENGTH;
+  // test the unpacking of the header
+  // copy first NFAPI_HEADER_LENGTH bytes into a new buffer, to simulate SCTP PEEK
+  fapi_message_header_t header;
+  uint32_t header_buffer_size = NFAPI_HEADER_LENGTH;
+  uint8_t header_buffer[header_buffer_size];
+  for (int idx = 0; idx < header_buffer_size; idx++) {
+    header_buffer[idx] = msg_buf[idx];
+  }
+  uint8_t *pReadPackedMessage = header_buffer;
+  int unpack_header_result = fapi_nr_p5_message_header_unpack(&pReadPackedMessage, NFAPI_HEADER_LENGTH, &header, sizeof(header), 0);
+  DevAssert(unpack_header_result >= 0);
+  DevAssert(header.message_id == req->header.message_id);
+  DevAssert(header.message_length == req->header.message_length);
+  // test the unpacking and compare with initial message
+  nfapi_nr_start_request_scf_t unpacked_req = {0};
+  int unpack_result =
+      fapi_nr_p5_message_unpack(msg_buf, header.message_length + NFAPI_HEADER_LENGTH, &unpacked_req, sizeof(unpacked_req), NULL);
+  DevAssert(unpack_result >= 0);
+  DevAssert(eq_start_request(&unpacked_req, req));
+  free_start_request(&unpacked_req);
+}
+
+void test_copy(const nfapi_nr_start_request_scf_t *msg)
+{
+  // Test copy function
+  nfapi_nr_start_request_scf_t copy = {0};
+  copy_start_request(msg, &copy);
+  DevAssert(eq_start_request(msg, &copy));
+  free_start_request(&copy);
+}
+
+int main(int n, char *v[])
+{
+  fapi_test_init();
+
+  nfapi_nr_start_request_scf_t req = {.header.message_id = NFAPI_NR_PHY_MSG_TYPE_START_REQUEST};
+  // Perform tests
+  test_pack_unpack(&req);
+  test_copy(&req);
+  // All tests successful!
+  free_start_request(&req);
+  return 0;
+}

nfapi/tests/p5/nr_fapi_start_response_test.c

@@ -0,0 +1,88 @@
+/*
+ * 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 nfapi/tests/p5/nr_fapi_start_response_test.c
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+#include "nfapi/tests/nr_fapi_test.h"
+#include "nr_fapi_p5_utils.h"
+
+void test_pack_unpack(nfapi_nr_start_response_scf_t *req)
+{
+  uint8_t msg_buf[65535];
+  uint16_t msg_len = sizeof(req);
+  // first test the packing procedure
+  int pack_result = fapi_nr_p5_message_pack(req, msg_len, msg_buf, sizeof(msg_buf), NULL);
+  // START.response message body length is 1
+  DevAssert(pack_result == 1 + NFAPI_HEADER_LENGTH);
+  // update req message_length value with value calculated in message_pack procedure
+  req->header.message_length = pack_result - NFAPI_HEADER_LENGTH;
+  // test the unpacking of the header
+  // copy first NFAPI_HEADER_LENGTH bytes into a new buffer, to simulate SCTP PEEK
+  fapi_message_header_t header;
+  uint32_t header_buffer_size = NFAPI_HEADER_LENGTH;
+  uint8_t header_buffer[header_buffer_size];
+  for (int idx = 0; idx < header_buffer_size; idx++) {
+    header_buffer[idx] = msg_buf[idx];
+  }
+  uint8_t *pReadPackedMessage = header_buffer;
+  int unpack_header_result = fapi_nr_p5_message_header_unpack(&pReadPackedMessage, NFAPI_HEADER_LENGTH, &header, sizeof(header), 0);
+  DevAssert(unpack_header_result >= 0);
+  DevAssert(header.message_id == req->header.message_id);
+  DevAssert(header.message_length == req->header.message_length);
+  // test the unpacking and compare with initial message
+  nfapi_nr_start_response_scf_t unpacked_req = {0};
+  int unpack_result =
+      fapi_nr_p5_message_unpack(msg_buf, header.message_length + NFAPI_HEADER_LENGTH, &unpacked_req, sizeof(unpacked_req), NULL);
+  DevAssert(unpack_result >= 0);
+  DevAssert(eq_start_response(&unpacked_req, req));
+  free_start_response(&unpacked_req);
+}
+
+void test_copy(const nfapi_nr_start_response_scf_t *msg)
+{
+  // Test copy function
+  nfapi_nr_start_response_scf_t copy = {0};
+  copy_start_response(msg, &copy);
+  DevAssert(eq_start_response(msg, &copy));
+  free_start_response(&copy);
+}
+
+int main(int n, char *v[])
+{
+  fapi_test_init();
+
+  nfapi_nr_start_response_scf_t req = {.header.message_id = NFAPI_NR_PHY_MSG_TYPE_START_RESPONSE};
+  // Fill the message with randomized data
+  req.error_code = rand8_range(0x00, 0x01);
+  // Perform tests
+  test_pack_unpack(&req);
+  test_copy(&req);
+  // All tests successful!
+  free_start_response(&req);
+  return 0;
+}

nfapi/tests/p5/nr_fapi_stop_indication_test.c

@@ -0,0 +1,86 @@
+/*
+ * 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 nfapi/tests/p5/nr_fapi_stop_indication_test.c
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+#include "nfapi/tests/nr_fapi_test.h"
+#include "nr_fapi_p5_utils.h"
+
+void test_pack_unpack(nfapi_nr_stop_indication_scf_t *req)
+{
+  uint8_t msg_buf[65535];
+  uint16_t msg_len = sizeof(*req);
+  // first test the packing procedure
+  int pack_result = fapi_nr_p5_message_pack(req, msg_len, msg_buf, sizeof(msg_buf), NULL);
+  // STOP.indication message body length is 0
+  DevAssert(pack_result == 0 + NFAPI_HEADER_LENGTH);
+  // update req message_length value with value calculated in message_pack procedure
+  req->header.message_length = pack_result - NFAPI_HEADER_LENGTH;
+  // test the unpacking of the header
+  // copy first NFAPI_HEADER_LENGTH bytes into a new buffer, to simulate SCTP PEEK
+  fapi_message_header_t header;
+  uint32_t header_buffer_size = NFAPI_HEADER_LENGTH;
+  uint8_t header_buffer[header_buffer_size];
+  for (int idx = 0; idx < header_buffer_size; idx++) {
+    header_buffer[idx] = msg_buf[idx];
+  }
+  uint8_t *pReadPackedMessage = header_buffer;
+  int unpack_header_result = fapi_nr_p5_message_header_unpack(&pReadPackedMessage, NFAPI_HEADER_LENGTH, &header, sizeof(header), 0);
+  DevAssert(unpack_header_result >= 0);
+  DevAssert(header.message_id == req->header.message_id);
+  DevAssert(header.message_length == req->header.message_length);
+  // test the unpacking and compare with initial message
+  nfapi_nr_stop_indication_scf_t unpacked_req = {0};
+  int unpack_result =
+      fapi_nr_p5_message_unpack(msg_buf, header.message_length + NFAPI_HEADER_LENGTH, &unpacked_req, sizeof(unpacked_req), NULL);
+  DevAssert(unpack_result >= 0);
+  DevAssert(eq_stop_indication(&unpacked_req, req));
+  free_stop_indication(&unpacked_req);
+}
+
+void test_copy(const nfapi_nr_stop_indication_scf_t *msg)
+{
+  // Test copy function
+  nfapi_nr_stop_indication_scf_t copy = {0};
+  copy_stop_indication(msg, &copy);
+  DevAssert(eq_stop_indication(msg, &copy));
+  free_stop_indication(&copy);
+}
+
+int main(int n, char *v[])
+{
+  fapi_test_init();
+
+  nfapi_nr_stop_indication_scf_t req = {.header.message_id = NFAPI_NR_PHY_MSG_TYPE_STOP_INDICATION};
+  // Perform tests
+  test_pack_unpack(&req);
+  test_copy(&req);
+  // All tests successful!
+  free_stop_indication(&req);
+  return 0;
+}

nfapi/tests/p5/nr_fapi_stop_request_test.c

@@ -0,0 +1,86 @@
+/*
+ * 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 nfapi/tests/p5/nr_fapi_stop_request_test.c
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+#include "nfapi/tests/nr_fapi_test.h"
+#include "nr_fapi_p5_utils.h"
+
+void test_pack_unpack(nfapi_nr_stop_request_scf_t *req)
+{
+  uint8_t msg_buf[65535];
+  uint16_t msg_len = sizeof(*req);
+  // first test the packing procedure
+  int pack_result = fapi_nr_p5_message_pack(req, msg_len, msg_buf, sizeof(msg_buf), NULL);
+  // STOP.request message body length is 0
+  DevAssert(pack_result == 0 + NFAPI_HEADER_LENGTH);
+  // update req message_length value with value calculated in message_pack procedure
+  req->header.message_length = pack_result - NFAPI_HEADER_LENGTH;
+  // test the unpacking of the header
+  // copy first NFAPI_HEADER_LENGTH bytes into a new buffer, to simulate SCTP PEEK
+  fapi_message_header_t header;
+  uint32_t header_buffer_size = NFAPI_HEADER_LENGTH;
+  uint8_t header_buffer[header_buffer_size];
+  for (int idx = 0; idx < header_buffer_size; idx++) {
+    header_buffer[idx] = msg_buf[idx];
+  }
+  uint8_t *pReadPackedMessage = header_buffer;
+  int unpack_header_result = fapi_nr_p5_message_header_unpack(&pReadPackedMessage, NFAPI_HEADER_LENGTH, &header, sizeof(header), 0);
+  DevAssert(unpack_header_result >= 0);
+  DevAssert(header.message_id == req->header.message_id);
+  DevAssert(header.message_length == req->header.message_length);
+  // test the unpacking and compare with initial message
+  nfapi_nr_stop_request_scf_t unpacked_req = {0};
+  int unpack_result =
+      fapi_nr_p5_message_unpack(msg_buf, header.message_length + NFAPI_HEADER_LENGTH, &unpacked_req, sizeof(unpacked_req), NULL);
+  DevAssert(unpack_result >= 0);
+  DevAssert(eq_stop_request(&unpacked_req, req));
+  free_stop_request(&unpacked_req);
+}
+
+void test_copy(const nfapi_nr_stop_request_scf_t *msg)
+{
+  // Test copy function
+  nfapi_nr_stop_request_scf_t copy = {0};
+  copy_stop_request(msg, &copy);
+  DevAssert(eq_stop_request(msg, &copy));
+  free_stop_request(&copy);
+}
+
+int main(int n, char *v[])
+{
+  fapi_test_init();
+
+  nfapi_nr_stop_request_scf_t req = {.header.message_id = NFAPI_NR_PHY_MSG_TYPE_STOP_REQUEST};
+  // Perform tests
+  test_pack_unpack(&req);
+  test_copy(&req);
+  // All tests successful!
+  free_stop_request(&req);
+  return 0;
+}

nfapi/tests/p7/CMakeLists.txt

@@ -0,0 +1,16 @@
+set(Test_Labels fapi p7)
+set(_fapi_p7_messages "dci_inversion")
+foreach (fapi_p7_message IN LISTS _fapi_p7_messages)
+    add_executable(nr_fapi_${fapi_p7_message}_test nr_fapi_${fapi_p7_message}_test.c)
+    target_link_libraries(nr_fapi_${fapi_p7_message}_test PUBLIC nr_fapi_p5)
+    target_link_libraries(nr_fapi_${fapi_p7_message}_test PRIVATE pthread UTIL ${T_LIB} minimal_lib)
+    add_dependencies(tests nr_fapi_${fapi_p7_message}_test)
+
+    add_test(nr_fapi_${fapi_p7_message}_test nr_fapi_${fapi_p7_message}_test)
+    set_tests_properties(nr_fapi_${fapi_p7_message}_test PROPERTIES LABELS "${Test_Labels}")
+endforeach ()
+# Add the dci label for the dci payload test
+set(dci_labels dci ${Test_Labels})
+set_tests_properties(nr_fapi_dci_inversion_test PROPERTIES LABELS "dci ${Test_Labels}")
+# Add the FAPI_BYTE_ORDERING_BIG_ENDIAN preprocessor define in order to test the invert/uninvert dci payload functions
+target_compile_definitions(nfapi_common PRIVATE FAPI_BYTE_ORDERING_BIG_ENDIAN)

nfapi/tests/p7/nr_fapi_dci_inversion_test.c

@@ -0,0 +1,145 @@
+/*
+ * 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 nfapi/tests/p5/nr_fapi_param_request_test.c
+ * \brief
+ * \author Ruben S. Silva
+ * \date 2024
+ * \version 0.1
+ * \company OpenAirInterface Software Alliance
+ * \email: contact@openairinterface.org, rsilva@allbesmart.pt
+ * \note
+ * \warning
+ */
+#include "nfapi/tests/nr_fapi_test.h"
+#include "nr_fapi_p5.h"
+#include "nr_fapi.h"
+void printbits(uint64_t n, uint8_t numBytesToPrint)
+{
+  uint64_t i;
+  uint8_t counter = 0;
+  if (numBytesToPrint == 0) {
+    i = 1UL << (sizeof(n) * 8 - 1);
+  } else {
+    i = 1UL << (numBytesToPrint * 8 - 1);
+  }
+  while (i > 0) {
+    if (n & i)
+      printf("1");
+    else
+      printf("0");
+    i >>= 1;
+    counter++;
+    if (counter % 8 == 0) {
+      printf(" ");
+    }
+  }
+}
+
+/*! \brief Drops unwanted bits from a byte array, leaving only a specified number of payload bits
+ *
+ *  \param payloadSizeBits How many bits the payload is to have, from 1 to 64 (8 * DCI_PAYLOAD_BYTE_LEN)
+ *  \param payload[] A uint8_t array containing the payload bytes with random data
+ *  \details This function creates a bitmask of payloadSizeBits width to truncate the data in payload[] to only have the specified
+ *  number of payload bits\n
+ *  For example, a payload of 39 bits needs 5 bytes, but on the last byte, the last bit is unused, this function makes sure that
+ *  last bit is set to 0, allowing the payload to be then packed and unpacked and successfully compared with the original payload
+ */
+void truncate_unwanted_bits(uint8_t payloadSizeBits, uint8_t payload[])
+{
+  uint8_t payloadSizeBytes = (payloadSizeBits + 7) / 8;
+  printf("Original Value:\t");
+  uint64_t t = 0;
+  memcpy(&t, payload, payloadSizeBytes);
+  printbits(t, payloadSizeBytes);
+  printf("\n");
+  uint64_t bitmask = 1;
+  for (int i = 0; i < payloadSizeBits - 1; i++) {
+    bitmask = bitmask << 1 | 1;
+  }
+  printf("Calculated Bitmask:\t");
+  printbits(bitmask, payloadSizeBytes);
+  printf("\n");
+  t = t & bitmask;
+  printf("Truncated Value:\t");
+  printbits(t, payloadSizeBytes);
+  printf("\n");
+  memcpy(payload, &t, payloadSizeBytes);
+}
+
+/*! \brief Generates a random payload payloadSizeBits long into payload[]
+ *
+ *  \param payloadSizeBits How many bits the payload is to have, from 1 to 64 (8 * DCI_PAYLOAD_BYTE_LEN)
+ *  \param payload[] A uint8_t array to contain the generated payload
+ *  \details This function fills a uint8_t array with payloadSizeBits of random data, by first filling however many bytes are needed
+ *  to contain payloadSizeBits with random data, and then truncating the excess bits
+ */
+void generate_payload(uint8_t payloadSizeBits, uint8_t payload[])
+{
+  for (int i = 0; i < (payloadSizeBits + 7) / 8; ++i) {
+    payload[i] = rand8();
+  }
+  truncate_unwanted_bits(payloadSizeBits, payload);
+}
+
+void test_pack_payload(uint8_t payloadSizeBits, uint8_t payload[])
+{
+  uint8_t msg_buf[8192] = {0};
+  uint8_t payloadSizeBytes = (payloadSizeBits + 7) / 8;
+  uint8_t *pWritePackedMessage = msg_buf;
+  uint8_t *pPackMessageEnd = msg_buf + sizeof(msg_buf);
+
+  pack_dci_payload(payload, payloadSizeBits, &pWritePackedMessage, pPackMessageEnd);
+
+  uint8_t unpack_buf[payloadSizeBytes];
+  pWritePackedMessage = msg_buf;
+  unpack_dci_payload(unpack_buf, payloadSizeBits, &pWritePackedMessage, pPackMessageEnd);
+
+  printf("\nOriginal:\t");
+  for (int j = payloadSizeBytes - 1; j >= 0; j--) {
+    printbits(payload[j], 1);
+    printf(" ");
+  }
+  printf("\n");
+
+  printf("Unpacked:\t");
+  for (int j = payloadSizeBytes - 1; j >= 0; j--) {
+    printbits(unpack_buf[j], 1);
+    printf(" ");
+  }
+  printf("\n");
+
+  DevAssert(memcmp(payload, unpack_buf, payloadSizeBytes) == 0);
+  // All tests successful!
+}
+
+int main(int n, char *v[])
+{
+  fapi_test_init();
+  uint8_t upper = 8 * DCI_PAYLOAD_BYTE_LEN;
+  uint8_t lower = 1;
+  uint8_t payloadSizeBits = (rand() % (upper - lower + 1)) + lower; // from 1 bit to DCI_PAYLOAD_BYTE_LEN, in bits
+  printf("payloadSizeBits:%d\n", payloadSizeBits);
+  uint8_t payload[(payloadSizeBits + 7) / 8];
+
+  generate_payload(payloadSizeBits, payload);
+  test_pack_payload(payloadSizeBits, payload);
+  return 0;
+}

openair1/PHY/nr_phy_common/CMakeLists.txt

@@ -1,2 +1,3 @@
 add_library(nr_phy_common src/nr_phy_common.c)
+target_link_libraries(nr_phy_common PRIVATE UTIL)
 target_include_directories(nr_phy_common PUBLIC inc/)

openair2/LAYER2/NR_MAC_COMMON/nr_mac.h

@@ -571,6 +571,7 @@ typedef struct NR_UE_UL_BWP {
   uint8_t mcs_table;
   nr_dci_format_t dci_format;
   int max_fb_time;
+  long *p0_NominalWithGrant;
 } NR_UE_UL_BWP_t;
 
 // non-BWP serving cell configuration
@@ -614,6 +615,7 @@ typedef struct NR_tda_info {
   int startSymbolIndex;
   int nrOfSymbols;
   long k2;
+  bool valid_tda;
 } NR_tda_info_t;
 
 #endif /*__LAYER2_MAC_H__ */

openair2/LAYER2/NR_MAC_COMMON/nr_mac_common.c

@@ -467,7 +467,11 @@ NR_tda_info_t get_ul_tda_info(const NR_UE_UL_BWP_t *ul_bwp,
   AssertFatal(scs >= 0 &&  scs < 5, "Subcarrier spacing indicatior %d invalid value\n", scs);
   int j = scs == 0 ? 1 : scs;
   if (tdalist) {
-    AssertFatal(tda_index < tdalist->list.count, "TDA index from DCI %d exceeds TDA list array size %d\n", tda_index, tdalist->list.count);
+    tda_info.valid_tda = tda_index < tdalist->list.count;
+    if (!tda_info.valid_tda) {
+      LOG_E(NR_MAC, "TDA index from DCI %d exceeds TDA list array size %d\n", tda_index, tdalist->list.count);
+      return tda_info;
+    }
     NR_PUSCH_TimeDomainResourceAllocation_t *tda = tdalist->list.array[tda_index];
     tda_info.mapping_type = tda->mappingType;
     // As described in 38.331, when the field is absent the UE applies the value 1 when PUSCH SCS is 15/30KHz
@@ -479,6 +483,11 @@ NR_tda_info_t get_ul_tda_info(const NR_UE_UL_BWP_t *ul_bwp,
     tda_info.nrOfSymbols = L;
   } else {
     bool normal_CP = ul_bwp->cyclicprefix ? false : true;
+    tda_info.valid_tda = tda_index < 16;
+    if (!tda_info.valid_tda) {
+      LOG_E(NR_MAC, "TDA index from DCI %d exceeds default TDA list array size %d\n", tda_index, 16);
+      return tda_info;
+    }
     if (normal_CP) {
       tda_info.mapping_type = table_6_1_2_1_1_2[tda_index][0];
       tda_info.k2 = table_6_1_2_1_1_2[tda_index][1] + j;
@@ -500,6 +509,11 @@ NR_tda_info_t get_info_from_tda_tables(default_table_type_t table_type,
                                        int normal_CP)
 {
   NR_tda_info_t tda_info = {0};
+  tda_info.valid_tda = tda < 16;
+  if (!tda_info.valid_tda) {
+    LOG_E(NR_MAC, "TDA index from DCI %d exceeds default TDA list array size %d\n", tda, 16);
+    return tda_info;
+  }
   bool is_mapping_typeA;
   int k0 = 0;
   switch(table_type){
@@ -586,7 +600,11 @@ default_table_type_t get_default_table_type(int mux_pattern)
 NR_tda_info_t set_tda_info_from_list(NR_PDSCH_TimeDomainResourceAllocationList_t *tdalist, int tda_index)
 {
   NR_tda_info_t tda_info = {0};
-  AssertFatal(tda_index < tdalist->list.count, "TDA index from DCI %d exceeds TDA list array size %d\n", tda_index, tdalist->list.count);
+  tda_info.valid_tda = tda_index < tdalist->list.count;
+  if (!tda_info.valid_tda) {
+    LOG_E(NR_MAC, "TDA index from DCI %d exceeds TDA list array size %d\n", tda_index, tdalist->list.count);
+    return tda_info;
+  }
   NR_PDSCH_TimeDomainResourceAllocation_t *tda = tdalist->list.array[tda_index];
   tda_info.mapping_type = tda->mappingType;
   int S, L;

openair2/LAYER2/NR_MAC_UE/config_ue.c

@@ -1409,11 +1409,14 @@ static void configure_common_BWP_ul(NR_UE_MAC_INST_t *mac, int bwp_id, NR_BWP_Up
                   ul_common->pusch_ConfigCommon->choice.setup->pusch_TimeDomainAllocationList,
                   NR_PUSCH_TimeDomainResourceAllocationList_t);
         UPDATE_IE(bwp->msg3_DeltaPreamble, ul_common->pusch_ConfigCommon->choice.setup->msg3_DeltaPreamble, long);
+        UPDATE_IE(bwp->p0_NominalWithGrant, ul_common->pusch_ConfigCommon->choice.setup->p0_NominalWithGrant, long);
       }
       if (ul_common->pusch_ConfigCommon->present == NR_SetupRelease_PUSCH_ConfigCommon_PR_release) {
         asn1cFreeStruc(asn_DEF_NR_PUSCH_TimeDomainResourceAllocationList, bwp->tdaList_Common);
         free(bwp->msg3_DeltaPreamble);
         bwp->msg3_DeltaPreamble = NULL;
+        free(bwp->p0_NominalWithGrant);
+        bwp->p0_NominalWithGrant = NULL;
       }
     }
   }
@@ -2130,6 +2133,8 @@ void release_ul_BWP(NR_UE_MAC_INST_t *mac, int index)
   asn1cFreeStruc(asn_DEF_NR_SRS_Config, bwp->srs_Config);
   free(bwp->msg3_DeltaPreamble);
   bwp->msg3_DeltaPreamble = NULL;
+  free(bwp->p0_NominalWithGrant);
+  bwp->p0_NominalWithGrant = NULL;
   free(bwp);
 }
 

openair2/LAYER2/NR_MAC_UE/mac_proto.h

@@ -219,6 +219,20 @@ int16_t get_pucch_tx_power_ue(NR_UE_MAC_INST_t *mac,
                               int subframe_number,
                               int O_uci,
                               uint16_t start_prb);
+int get_pusch_tx_power_ue(
+  NR_UE_MAC_INST_t *mac,
+  int num_rb,
+  int start_prb,
+  uint16_t nb_symb_sch,
+  uint16_t nb_dmrs_prb,
+  uint16_t nb_ptrs_prb,
+  uint16_t qm,
+  uint16_t R,
+  uint16_t beta_offset_csi1,
+  uint32_t sum_bits_in_codeblocks,
+  int delta_pusch,
+  bool is_rar_tx_retx,
+  bool transform_precoding);
 
 int nr_ue_configure_pucch(NR_UE_MAC_INST_t *mac,
                            int slot,
@@ -227,16 +241,18 @@ int nr_ue_configure_pucch(NR_UE_MAC_INST_t *mac,
                            PUCCH_sched_t *pucch,
                            fapi_nr_ul_config_pucch_pdu *pucch_pdu);
 
-int nr_get_Pcmax(int p_Max,
-                 uint16_t nr_band,
-                 frequency_range_t frequency_range,
-                 int Qm,
-                 bool powerBoostPi2BPSK,
-                 int scs,
-                 int N_RB_UL,
-                 bool is_transform_precoding,
-                 int n_prbs,
-                 int start_prb);
+float nr_get_Pcmax(int p_Max,
+                   uint16_t nr_band,
+                   frequency_range_t frequency_range,
+                   int Qm,
+                   bool powerBoostPi2BPSK,
+                   int scs,
+                   int N_RB_UL,
+                   bool is_transform_precoding,
+                   int n_prbs,
+                   int start_prb);
+
+float nr_get_Pcmin(int scs, int nr_band, int N_RB_UL);
 
 int get_sum_delta_pucch(NR_UE_MAC_INST_t *mac, int slot, frame_t frame);
 

openair2/LAYER2/NR_MAC_UE/nr_ue_power_procedures.c

@@ -65,62 +65,34 @@ static int get_deltatf(uint16_t nb_of_prbs,
                        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
-// -
-// The UE is allowed to set its configured maximum output power PCMAX,f,c for carrier f of serving cell c in each slot.
-// The configured maximum output power PCMAX,f,c is set within the following bounds: PCMAX_L,f,c <=  PCMAX,f,c <=  PCMAX_H,f,c
-// -
-// Measurement units:
-// - p_max:              dBm
-// - delta_TC_c:         dB
-// - P_powerclass:       dBm
-// - delta_P_powerclass: dB
-// - MPR_c:              dB
-// - delta_MPR_c:        dB
-// - delta_T_IB_c        dB
-// - delta_rx_SRS        dB
-// note:
-// - Assuming:
-// -- Powerclass 3 capable UE (which is default power class unless otherwise stated)
-// -- Maximum power reduction (MPR_c) for power class 3
-// -- no additional MPR (A_MPR_c)
-int nr_get_Pcmax(int p_Max,
-                 uint16_t nr_band,
-                 frequency_range_t frequency_range,
-                 int Qm,
-                 bool powerBoostPi2BPSK,
-                 int scs,
-                 int N_RB_UL,
-                 bool is_transform_precoding,
-                 int n_prbs,
-                 int start_prb)
+// ∆MPR according to Table 6.2.2-3 38.101-1
+static float get_delta_mpr(uint16_t nr_band, int scs, int N_RB_UL, int n_prbs, int start_prb, int power_class)
 {
-  if (frequency_range == FR1) {
-    // TODO configure P-MAX from the upper layers according to 38.331
-    int p_powerclass = 23; // dBm assuming poweclass 3 UE
-    int p_emax = p_Max != INT_MIN ? p_Max : p_powerclass;
-    int delta_P_powerclass = 0; // for powerclass 2 needs to be changed
-    if (p_Max && Qm == 1 && powerBoostPi2BPSK
-        && (nr_band == 40 || nr_band == 41 || nr_band == 77 || nr_band == 78 || nr_band == 79)) {
-      p_emax += 3;
-      delta_P_powerclass -= 3;
+  frame_type_t frame_type = get_frame_type(nr_band, scs);
+  if (compare_relative_ul_channel_bw(nr_band, scs, N_RB_UL, frame_type)) {
+    if (power_class == 3) {
+      if ((nr_band == 28 || nr_band == 83) && get_supported_bw_mhz(nr_band > 256 ? FR2 : FR1, scs, N_RB_UL) == 30) {
+        return 0.5f;
+      }
     }
+    if (power_class == 3 || power_class == 2) {
+      if ((nr_band == 40 || nr_band == 97) && get_supported_bw_mhz(nr_band > 256 ? FR2 : FR1, scs, N_RB_UL) == 100) {
+        return 1.0f;
+      }
+    }
+  }
+  return 0;
+}
 
-    // TODO to be set for CA and DC
-    int delta_T_IB = 0;
-
-    // TODO in case of band 41 and PRB allocation within 4MHz of the upper or lower limit of the band -> delta_TC = 1.5
-    if (nr_band == 41)
-      LOG_E(NR_MAC, "Need to implement delta_TC for band 41\n");
-    int delta_TC = 0;
-
-    float MPR = 0;
-    frame_type_t frame_type = get_frame_type(nr_band, scs);
-    if (compare_relative_ul_channel_bw(nr_band, scs, N_RB_UL, frame_type)) {
-      int rb_low = (n_prbs / 2) > 1 ? (n_prbs / 2) : 1;
-      int rb_high = N_RB_UL - rb_low - n_prbs;
-      bool is_inner_rb = start_prb >= rb_low && start_prb <= rb_high && n_prbs <= ((N_RB_UL / 2) + (N_RB_UL & 1));
+// MPR according to 38-101 6.2.2
+static float get_mpr(int Qm, int N_RB_UL, bool is_transform_precoding, int n_prbs, int start_prb, int power_class)
+{
+  float MPR = 0;
+  int rb_low = (n_prbs / 2) > 1 ? (n_prbs / 2) : 1;
+  int rb_high = N_RB_UL - rb_low - n_prbs;
+  bool is_inner_rb = start_prb >= rb_low && start_prb <= rb_high && n_prbs <= ((N_RB_UL / 2) + (N_RB_UL & 1));
+  switch (power_class) {
+    case 3:
       // Table 6.2.2-1 in 38.101
       switch (Qm) {
         case 1:
@@ -166,16 +138,73 @@ int nr_get_Pcmax(int p_Max,
         default:
           AssertFatal(false, "Invalid Qm %d\n", Qm);
       }
+      break;
+    default:
+      AssertFatal(false, "PowerClass != 3 not implemented\n");
+  }
+  return MPR;
+}
+
+// Implementation of 6.2.4 Configured ransmitted power
+// 3GPP TS 38.101-1 version 16.5.0 Release 16
+// -
+// The UE is allowed to set its configured maximum output power PCMAX,f,c for carrier f of serving cell c in each slot.
+// The configured maximum output power PCMAX,f,c is set within the following bounds: PCMAX_L,f,c <=  PCMAX,f,c <=  PCMAX_H,f,c
+// -
+// Measurement units:
+// - p_max:              dBm
+// - delta_TC_c:         dB
+// - P_powerclass:       dBm
+// - delta_P_powerclass: dB
+// - MPR_c:              dB
+// - delta_MPR_c:        dB
+// - delta_T_IB_c        dB
+// - delta_rx_SRS        dB
+// note:
+// - Assuming:
+// -- Powerclass 3 capable UE (which is default power class unless otherwise stated)
+// -- Maximum power reduction (MPR_c) for power class 3
+// -- no additional MPR (A_MPR_c)
+float nr_get_Pcmax(int p_Max,
+                   uint16_t nr_band,
+                   frequency_range_t frequency_range,
+                   int Qm,
+                   bool powerBoostPi2BPSK,
+                   int scs,
+                   int N_RB_UL,
+                   bool is_transform_precoding,
+                   int n_prbs,
+                   int start_prb)
+{
+  const int power_class = 3; // Assume power class 3
+  if (frequency_range == FR1) {
+    // TODO configure P-MAX from the upper layers according to 38.331
+    int p_powerclass = 23; // dBm assuming poweclass 3 UE
+    int p_emax = p_Max != INT_MIN ? p_Max : p_powerclass;
+    int delta_P_powerclass = 0; // for powerclass 2 needs to be changed
+    if (p_Max && Qm == 1 && powerBoostPi2BPSK
+        && (nr_band == 40 || nr_band == 41 || nr_band == 77 || nr_band == 78 || nr_band == 79)) {
+      p_emax += 3;
+      delta_P_powerclass -= 3;
     }
 
+    // TODO to be set for CA and DC
+    int delta_T_IB = 0;
+
+    // TODO in case of band 41 and PRB allocation within 4MHz of the upper or lower limit of the band -> delta_TC = 1.5
+    if (nr_band == 41)
+      LOG_E(NR_MAC, "Need to implement delta_TC for band 41\n");
+    int delta_TC = 0;
+
+    float MPR = get_mpr(Qm, N_RB_UL, is_transform_precoding, n_prbs, start_prb, power_class);
+    float delta_MPR = get_delta_mpr(nr_band, scs, N_RB_UL, n_prbs, start_prb, power_class);
     int A_MPR = 0; // TODO too complicated to implement for now (see 6.2.3 in 38.101-1)
     int delta_rx_SRS = 0; // TODO for SRS
     int P_MPR = 0; // to ensure compliance with applicable electromagnetic energy absorption requirements
 
-    float total_reduction = (MPR > A_MPR ? MPR : A_MPR) + delta_T_IB + delta_TC + delta_rx_SRS;
-    if (P_MPR > total_reduction)
-      total_reduction = P_MPR;
-    int pcmax_high, pcmax_low;
+    float total_reduction = max(max(MPR + delta_MPR, A_MPR) + delta_T_IB + delta_TC + delta_rx_SRS, P_MPR);
+
+    float pcmax_high, pcmax_low;
     if (p_Max) {
       pcmax_high = p_emax < (p_powerclass - delta_P_powerclass) ? p_emax : (p_powerclass - delta_P_powerclass);
       pcmax_low = (p_emax - delta_TC) < (p_powerclass - delta_P_powerclass - total_reduction)
@@ -186,8 +215,8 @@ int nr_get_Pcmax(int p_Max,
       pcmax_low = p_powerclass - delta_P_powerclass - total_reduction;
     }
     // TODO we need a strategy to select a value between minimum and maximum allowed PC_max
-    int pcmax = (pcmax_low + pcmax_high) / 2;
-    LOG_D(MAC, "Configured maximum output power:  %d dBm <= PCMAX %d dBm <= %d dBm \n", pcmax_low, pcmax, pcmax_high);
+    float pcmax = (pcmax_low + pcmax_high) / 2;
+    LOG_D(MAC, "Configured maximum output power:  %f dBm <= PCMAX %f dBm <= %f dBm \n", pcmax_low, pcmax, pcmax_high);
     return pcmax;
   } else {
     // FR2 TODO it is even more complex because it is radiated power
@@ -195,6 +224,14 @@ int nr_get_Pcmax(int p_Max,
   }
 }
 
+float nr_get_Pcmin(int scs, int nr_band, int N_RB_UL) {
+  int band_index = get_supported_band_index(nr_band > 256 ? FR2 : FR1, scs, N_RB_UL);
+  const float table_38101_6_3_1_1[] = {
+    -40, -40, -40, -40, -39, -38.2, -37.5, -37, -36.5, -35.2, -34.6, -34, -33.5, -33
+  };
+  return table_38101_6_3_1_1[band_index];
+}
+
 // 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
@@ -297,8 +334,9 @@ int16_t get_pucch_tx_power_ue(NR_UE_MAC_INST_t *mac,
     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
+  // 38.101-1: The allowed MPR for SRS, PUCCH formats 0, 1, 3 and 4, and PRACH shall be as specified for QPSK modulated DFT-
+  // s-OFDM of equivalent RB allocation. The allowed MPR for PUCCH format 2 shall be as specified for QPSK
+  // modulated CP-OFDM of equivalent RB allocation.
   int P_CMAX = nr_get_Pcmax(mac->p_Max,
                             mac->nr_band,
                             mac->frequency_range,
@@ -306,10 +344,10 @@ int16_t get_pucch_tx_power_ue(NR_UE_MAC_INST_t *mac,
                             false,
                             mac->current_UL_BWP->scs,
                             mac->current_UL_BWP->BWPSize,
-                            true,
+                            format_type == 2,
                             1,
                             start_prb);
-  int P_CMIN = -40; // TODO: minimum TX power, possibly 38.101-1 6.3.1
+  int P_CMIN = nr_get_Pcmin(mac->current_UL_BWP->scs, mac->nr_band,  mac->current_UL_BWP->BWPSize);
   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) {
@@ -396,3 +434,136 @@ int16_t compute_nr_SSB_PL(NR_UE_MAC_INST_t *mac, short ssb_rsrp_dBm)
 
   return pathloss;
 }
+
+// PUSCH transmission power according to 38.213 7.1
+int get_pusch_tx_power_ue(NR_UE_MAC_INST_t *mac,
+                          int num_rb,
+                          int start_prb,
+                          uint16_t nb_symb_sch,
+                          uint16_t nb_dmrs_prb,
+                          uint16_t nb_ptrs_prb,
+                          uint16_t qm,
+                          uint16_t R,
+                          uint16_t beta_offset_csi1,
+                          uint32_t sum_bits_in_codeblocks,
+                          int delta_pusch,
+                          bool is_rar_tx_retx,
+                          bool transform_precoding)
+{
+  LOG_D(NR_MAC,
+        "PUSCH tx power determination num_rb=%d start_prb=%d nb_symb_sch=%u nb_dmrs_prb=%u nb_ptrs_prb=%u Qm=%u R= %u "
+        "beta_offset_cs1=%u sum_bits_in_codeblocks=%u delta_pusch=%d is_rar_tx_retx=%d transform_precoding=%d\n",
+        num_rb,
+        start_prb,
+        nb_symb_sch,
+        nb_dmrs_prb,
+        nb_ptrs_prb,
+        qm,
+        R,
+        beta_offset_csi1,
+        sum_bits_in_codeblocks,
+        delta_pusch,
+        is_rar_tx_retx,
+        transform_precoding);
+  NR_UE_UL_BWP_t *current_UL_BWP = mac->current_UL_BWP;
+  AssertFatal(current_UL_BWP, "Missing configuration: need UL_BWP to calculate PUSCH tx power\n");
+  NR_PUSCH_Config_t *pusch_Config = current_UL_BWP->pusch_Config;
+  bool has_pusch_config = pusch_Config != NULL;
+  bool has_pusch_power_control_config = has_pusch_config && pusch_Config->pusch_PowerControl != NULL;
+  bool is_provided_alpha_sets = has_pusch_power_control_config && pusch_Config->pusch_PowerControl->p0_AlphaSets != NULL;
+  AssertFatal(!has_pusch_power_control_config || pusch_Config->pusch_PowerControl->sri_PUSCH_MappingToAddModList == NULL,
+              "SRI-PUSCH-PowerControl handling not implemented\n");
+
+  int P_O_NOMINAL_PUSCH;
+  float alpha;
+  const float alpha_factor_table[8] = {0.0f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f};
+  if (is_rar_tx_retx || !is_provided_alpha_sets || current_UL_BWP->p0_NominalWithGrant == NULL) {
+    int DELTA_PREAMBLE_MSG3 = 0;
+    if (current_UL_BWP->msg3_DeltaPreamble) {
+      DELTA_PREAMBLE_MSG3 = *current_UL_BWP->msg3_DeltaPreamble;
+    }
+    NR_RACH_ConfigCommon_t *nr_rach_ConfigCommon = current_UL_BWP->rach_ConfigCommon;
+    long preambleReceivedTargetPower = nr_rach_ConfigCommon->rach_ConfigGeneric.preambleReceivedTargetPower;
+    int P_O_PRE = preambleReceivedTargetPower;
+    P_O_NOMINAL_PUSCH = P_O_PRE + DELTA_PREAMBLE_MSG3;
+
+    if (has_pusch_power_control_config && pusch_Config->pusch_PowerControl->msg3_Alpha) {
+      alpha = alpha_factor_table[*pusch_Config->pusch_PowerControl->msg3_Alpha];
+    } else {
+      alpha = 1.0f;
+    }
+  } else {
+    P_O_NOMINAL_PUSCH = *current_UL_BWP->p0_NominalWithGrant;
+    if (pusch_Config->pusch_PowerControl->p0_AlphaSets->list.array[0]->alpha) {
+      alpha = alpha_factor_table[*pusch_Config->pusch_PowerControl->p0_AlphaSets->list.array[0]->alpha];
+    } else {
+      // Default according to 38.331 P0-PUSCH-AlphaSet field descriptions
+      alpha = 1.0f;
+    }
+  }
+
+  int P_O_UE_PUSCH;
+  if (is_rar_tx_retx || !is_provided_alpha_sets) {
+    P_O_UE_PUSCH = 0;
+  } else {
+    if (pusch_Config->pusch_PowerControl->p0_AlphaSets->list.array[0]->p0) {
+      P_O_UE_PUSCH = *pusch_Config->pusch_PowerControl->p0_AlphaSets->list.array[0]->p0;
+    } else {
+      // Default according to 38.331 P0-PUSCH-AlphaSet field descriptions
+      P_O_UE_PUSCH = 0;
+    }
+  }
+
+  int mu = current_UL_BWP->scs;
+
+  int M_pusch_component = 10 * log10((pow(2, mu)) * num_rb);
+  int P_CMAX = nr_get_Pcmax(mac->p_Max,
+                            mac->nr_band,
+                            mac->frequency_range,
+                            2,
+                            false,
+                            mac->current_UL_BWP->scs,
+                            mac->current_UL_BWP->BWPSize,
+                            transform_precoding,
+                            1,
+                            start_prb);
+
+  int P_O_PUSCH = P_O_NOMINAL_PUSCH + P_O_UE_PUSCH;
+
+  float DELTA_TF = 0;
+  if (has_pusch_power_control_config && pusch_Config->pusch_PowerControl->deltaMCS) {
+    float beta_offset = 1;
+    float BPRE;
+    if (sum_bits_in_codeblocks == 0) {
+      float table_38_213_9_3_2[] = {
+          1.125,   11.250,  21.375,  31.625,  41.750,  52.000,   62.250,   72.500,   82.875,   93.125,
+          103.500, 114.000, 125.000, 136.250, 148.000, 1510.000, 1612.625, 1715.875, 1820.000,
+      };
+      beta_offset = table_38_213_9_3_2[beta_offset_csi1];
+      BPRE = (qm * R / beta_offset) / 1024;
+    } else {
+      const int nb_subcarrier_per_rb = 12;
+      const uint32_t N_RE = nb_subcarrier_per_rb * nb_symb_sch - nb_dmrs_prb - nb_ptrs_prb;
+      BPRE = sum_bits_in_codeblocks / (float)(N_RE * num_rb);
+    }
+    DELTA_TF = 10 * log10(pow(2, BPRE * 1.25f) * beta_offset);
+  }
+
+  // TODO: compute pathoss using correct reference
+  int16_t pathloss = compute_nr_SSB_PL(mac, mac->ssb_measurements.ssb_rsrp_dBm);
+
+  int f_b_f_c = 0;
+  if (has_pusch_power_control_config && pusch_Config->pusch_PowerControl->tpc_Accumulation) {
+    f_b_f_c = delta_pusch;
+  } else {
+    // TODO: PUSCH power control state
+  }
+  LOG_D(NR_MAC,
+        "PUSCH tx power components P_O_PUSCH=%d, M_pusch_component=%d, alpha*pathloss=%f, delta_TF=%f, f_b_f_c=%d\n",
+        P_O_PUSCH,
+        M_pusch_component,
+        alpha * pathloss,
+        DELTA_TF,
+        f_b_f_c);
+  return min(P_CMAX, P_O_PUSCH + M_pusch_component + alpha * pathloss + DELTA_TF + f_b_f_c);
+}

openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c

@@ -435,11 +435,12 @@ static int nr_ue_process_dci_ul_00(NR_UE_MAC_INST_t *mac,
                                            dci_ind->ss_type,
                                            get_rnti_type(mac, dci_ind->rnti),
                                            dci->time_domain_assignment.val);
-  frame_t frame_tx;
-  int slot_tx;
-  if (tda_info.nrOfSymbols == 0)
+
+  if (!tda_info.valid_tda || tda_info.nrOfSymbols == 0)
     return -1;
 
+  frame_t frame_tx;
+  int slot_tx;
   if (-1 == nr_ue_pusch_scheduler(mac, 0, frame, slot, &frame_tx, &slot_tx, tda_info.k2)) {
     LOG_E(MAC, "Cannot schedule PUSCH\n");
     return -1;
@@ -525,15 +526,18 @@ static int nr_ue_process_dci_ul_01(NR_UE_MAC_INST_t *mac,
                                            get_rnti_type(mac, dci_ind->rnti),
                                            dci->time_domain_assignment.val);
 
+  if (!tda_info.valid_tda || tda_info.nrOfSymbols == 0)
+    return -1;
+
   if (dci->ulsch_indicator == 0) {
     // in case of CSI on PUSCH and no ULSCH we need to use reportSlotOffset in trigger state
-    AssertFatal(csi_K2 > 0, "Invalid CSI K2 value %ld\n", csi_K2);
+    if (csi_K2 <= 0) {
+      LOG_E(MAC, "Invalid CSI K2 value %ld\n", csi_K2);
+      return -1;
+    }
     tda_info.k2 = csi_K2;
   }
 
-  if (tda_info.nrOfSymbols == 0)
-    return -1;
-
   if (-1 == nr_ue_pusch_scheduler(mac, 0, frame, slot, &frame_tx, &slot_tx, tda_info.k2)) {
     LOG_E(MAC, "Cannot schedule PUSCH\n");
     return -1;
@@ -679,6 +683,8 @@ static int nr_ue_process_dci_dl_10(NR_UE_MAC_INST_t *mac,
                                            rnti_type,
                                            coreset_type,
                                            mac->get_sib1);
+  if (!tda_info.valid_tda)
+    return -1;
 
   dlsch_pdu->number_symbols = tda_info.nrOfSymbols;
   dlsch_pdu->start_symbol = tda_info.startSymbolIndex;
@@ -990,6 +996,8 @@ static int nr_ue_process_dci_dl_11(NR_UE_MAC_INST_t *mac,
                                            rnti_type,
                                            coreset_type,
                                            false);
+  if (!tda_info.valid_tda)
+    return -1;
 
   dlsch_pdu->number_symbols = tda_info.nrOfSymbols;
   dlsch_pdu->start_symbol = tda_info.startSymbolIndex;
@@ -3949,7 +3957,7 @@ static void nr_ue_process_rar(NR_UE_MAC_INST_t *mac, nr_downlink_indication_t *d
                                              pdcch_config->ra_SS->searchSpaceType->present,
                                              TYPE_RA_RNTI_,
                                              rar_grant.Msg3_t_alloc);
-    if (tda_info.nrOfSymbols == 0) {
+    if (!tda_info.valid_tda || tda_info.nrOfSymbols == 0) {
       LOG_E(MAC, "Cannot schedule Msg3. Something wrong in TDA information\n");
       return;
     }

openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c

@@ -913,6 +913,22 @@ int nr_config_pusch_pdu(NR_UE_MAC_INST_t *mac,
     pusch_config_pdu->pusch_data.tb_size = mac->ul_harq_info[pid].TBS;
   }
 
+  bool is_rar_tx_retx = rnti_type == TYPE_TC_RNTI_;
+
+  pusch_config_pdu->tx_power = get_pusch_tx_power_ue(mac,
+                                                     pusch_config_pdu->rb_size,
+                                                     pusch_config_pdu->rb_start,
+                                                     pusch_config_pdu->nr_of_symbols,
+                                                     nb_dmrs_re_per_rb * number_dmrs_symbols,
+                                                     0, //TODO: count PTRS per RB
+                                                     pusch_config_pdu->qam_mod_order,
+                                                     pusch_config_pdu->target_code_rate,
+                                                     pusch_config_pdu->pusch_uci.beta_offset_csi1,
+                                                     pusch_config_pdu->pusch_data.tb_size << 3,
+                                                     pusch_config_pdu->absolute_delta_PUSCH,
+                                                     is_rar_tx_retx,
+                                                     pusch_config_pdu->transform_precoding);
+
   pusch_config_pdu->ldpcBaseGraph = get_BG(pusch_config_pdu->pusch_data.tb_size << 3, pusch_config_pdu->target_code_rate);
 
   //The MAC entity shall restart retxBSR-Timer upon reception of a grant for transmission of new data on any UL-SCH

openair2/LAYER2/NR_MAC_UE/tests/test_nr_ue_power_procedures.cpp

@@ -19,43 +19,314 @@
  *      contact@openairinterface.org
  */
 
-
 #include "gtest/gtest.h"
 extern "C" {
 #include "openair2/LAYER2/NR_MAC_UE/mac_proto.h"
 #include "executables/softmodem-common.h"
-uint64_t get_softmodem_optmask(void) {return 0;}
+uint64_t get_softmodem_optmask(void)
+{
+  return 0;
+}
 static softmodem_params_t softmodem_params;
-softmodem_params_t *get_softmodem_params(void) {
+softmodem_params_t* get_softmodem_params(void)
+{
   return &softmodem_params;
-
 }
 }
 #include <cstdio>
 #include "common/utils/LOG/log.h"
 
-TEST(power_procedures_fr1, test_prach_max_tx_power_mpr)
+TEST(test_pcmax, test_mpr)
 {
-  // Inner PRB, MPR = 1.5
+  // Inner PRB, MPR = 1.5, no delta MPR
   int prb_start = 4;
   int N_RB_UL = 51; // 10Mhz
-  EXPECT_EQ(22, nr_get_Pcmax(23, 20, FR1, 2, false, 1, N_RB_UL, false, 6, prb_start));
+  int nr_band = 20;
+  float expected_power = 23 - (1.5 / 2);
+  EXPECT_EQ(expected_power, nr_get_Pcmax(23, nr_band, FR1, 2, false, 1, N_RB_UL, false, 6, prb_start));
 
-  // Outer PRB, MPR = 3
+  // Outer PRB, MPR = 3, no delta MPR
   prb_start = 0;
-  EXPECT_EQ(21, nr_get_Pcmax(23, 20, FR1, 2, false, 1, N_RB_UL, false, 6, prb_start));
+  expected_power = 23 - (3.0 / 2);
+  EXPECT_EQ(expected_power, nr_get_Pcmax(23, nr_band, FR1, 2, false, 1, N_RB_UL, false, 6, prb_start));
 
-  // Channel bandwidth conditon not met, no MPR
-  N_RB_UL = 106;
-  EXPECT_EQ(23, nr_get_Pcmax(23, 20, FR1, 2, false, 1, N_RB_UL, false, 6, prb_start));
+  // Outer PRB on band 28, MPR = 3, delta MPR = 0.5 dB
+  N_RB_UL = 78;
+  nr_band = 28;
+  expected_power = 23 - ((3.0 + 0.5) / 2);
+  EXPECT_EQ(expected_power, nr_get_Pcmax(23, nr_band, FR1, 2, false, 1, N_RB_UL, false, 100, prb_start));
 }
 
-TEST(power_procedures_fr1, test_not_implemented)
+TEST(test_pcmax, test_not_implemented)
 {
   int N_RB_UL = 51;
   EXPECT_DEATH(nr_get_Pcmax(23, 20, FR1, 1, false, 1, N_RB_UL, false, 6, 0), "MPR for Pi/2 BPSK not implemented yet");
 }
 
+TEST(test_pcmax, test_pucch_max_power)
+{
+  // Format 2, transform precoding, MPR = 1
+  int prb_start = 0;
+  int N_RB_UL = 51; // 10Mhz
+  float expected_power = 23 - (1.0 / 2);
+  EXPECT_EQ(expected_power, nr_get_Pcmax(23, 20, FR1, 2, false, 1, N_RB_UL, true, 1, prb_start));
+
+  // Other fromats, no transform precoding, MPR = 3
+  expected_power = 23 - (3.0 / 2);
+  EXPECT_EQ(expected_power, nr_get_Pcmax(23, 20, FR1, 2, false, 1, N_RB_UL, false, 1, prb_start));
+}
+
+TEST(test_pucch_power_state, test_accumulated_delta_pucch)
+{
+  NR_UE_MAC_INST_t mac = {0};
+  NR_UE_UL_BWP_t current_UL_BWP = {0};
+  current_UL_BWP.scs = 1;
+  current_UL_BWP.BWPSize = 106;
+  NR_PUCCH_ConfigCommon_t pucch_ConfigCommon = {0};
+  mac.current_UL_BWP = &current_UL_BWP;
+  mac.current_UL_BWP->pucch_ConfigCommon = &pucch_ConfigCommon;
+  mac.nr_band = 20;
+  NR_PUCCH_Config_t pucch_Config = {0};
+  struct NR_PUCCH_PowerControl power_config;
+  pucch_Config.pucch_PowerControl = &power_config;
+  mac.G_b_f_c = 0;
+  mac.pucch_power_control_initialized = true;
+
+  int scs = 1;
+  int sum_delta_pucch = 3;
+  uint8_t format_type = 1;
+  uint16_t nb_of_prbs = 1;
+  uint8_t freq_hop_flag = 0;
+  uint8_t add_dmrs_flag = 0;
+  uint8_t N_symb_PUCCH = 12;
+  int subframe_number = 0;
+  int O_uci = 2;
+  uint16_t start_prb = 0;
+  int P_CMAX =
+      nr_get_Pcmax(23, mac.nr_band, FR1, 2, false, current_UL_BWP.scs, current_UL_BWP.BWPSize, false, nb_of_prbs, start_prb);
+  int pucch_power_prev = get_pucch_tx_power_ue(&mac,
+                                               scs,
+                                               &pucch_Config,
+                                               sum_delta_pucch,
+                                               format_type,
+                                               nb_of_prbs,
+                                               freq_hop_flag,
+                                               add_dmrs_flag,
+                                               N_symb_PUCCH,
+                                               subframe_number,
+                                               O_uci,
+                                               start_prb);
+  EXPECT_LT(pucch_power_prev, P_CMAX);
+  for (int i = 0; i < 10; i++) {
+    int pucch_power_state = mac.G_b_f_c;
+    int pucch_power = get_pucch_tx_power_ue(&mac,
+                                            scs,
+                                            &pucch_Config,
+                                            sum_delta_pucch,
+                                            format_type,
+                                            nb_of_prbs,
+                                            freq_hop_flag,
+                                            add_dmrs_flag,
+                                            N_symb_PUCCH,
+                                            subframe_number,
+                                            O_uci,
+                                            start_prb);
+    if (pucch_power_prev == P_CMAX) {
+      EXPECT_EQ(pucch_power_state, mac.G_b_f_c) << "PUCCH power control state increased after reaching max TX power";
+    }
+    EXPECT_LE(pucch_power, P_CMAX) << "PUUCH TX power above P_CMAX";
+    EXPECT_EQ(std::min(P_CMAX, pucch_power_prev + sum_delta_pucch), pucch_power)
+        << "PUCCH power expected to change by delta pucch only, between P_CMAX and P_CMIN";
+    pucch_power_prev = pucch_power;
+
+    if (i > 5) {
+      EXPECT_EQ(pucch_power, P_CMAX) << "Expected to reach MAX PUCCH TX power";
+    }
+  }
+
+  sum_delta_pucch = -15;
+  for (int i = 0; i < 10; i++) {
+    int pucch_power_state = mac.G_b_f_c;
+    int pucch_power = get_pucch_tx_power_ue(&mac,
+                                            scs,
+                                            &pucch_Config,
+                                            sum_delta_pucch,
+                                            format_type,
+                                            nb_of_prbs,
+                                            freq_hop_flag,
+                                            add_dmrs_flag,
+                                            N_symb_PUCCH,
+                                            subframe_number,
+                                            O_uci,
+                                            start_prb);
+    EXPECT_LE(mac.G_b_f_c, pucch_power_state) << "PUCCH power control state increased with negative delta pucch";
+    pucch_power_prev = pucch_power;
+  }
+}
+
+TEST(pc_min, check_all_bw_indexes)
+{
+  const int NB_RB_UL[] = {11, 24, 38, 51, 65, 78, 106, 133, 162, 217, 245, 273};
+  for (auto i = 0U; i < sizeof(NB_RB_UL) / sizeof(NB_RB_UL[0]); i++) {
+    (void)nr_get_Pcmin(1, 20, NB_RB_UL[i]);
+  }
+}
+
+TEST(pusch_power_control, pusch_power_control_msg3)
+{
+  NR_UE_MAC_INST_t mac = {0};
+  NR_UE_UL_BWP_t current_UL_BWP = {0};
+  current_UL_BWP.scs = 1;
+  current_UL_BWP.BWPSize = 106;
+  mac.current_UL_BWP = &current_UL_BWP;
+  NR_RACH_ConfigCommon_t nr_rach_ConfigCommon = {0};
+  current_UL_BWP.rach_ConfigCommon = &nr_rach_ConfigCommon;
+  mac.nr_band = 78;
+  NR_PUSCH_Config_t pusch_Config = {0};
+  current_UL_BWP.pusch_Config = &pusch_Config;
+  NR_PUSCH_PowerControl pusch_PowerControl = {0};
+  pusch_Config.pusch_PowerControl = &pusch_PowerControl;
+  pusch_PowerControl.tpc_Accumulation = (long*)1;
+
+  // msg3 cofiguration as in 5g_rfsimulator testcase
+  int num_rb = 8;
+  int start_prb = 0;
+  uint16_t nb_symb_sch = 3;
+  uint16_t nb_dmrs_prb = 12;
+  uint16_t nb_ptrs_prb = 0;
+  uint16_t Qm = 2;
+  uint16_t R = 1570;
+  uint16_t beta_offset_csi1 = 0;
+  uint32_t sum_bits_in_codeblocks = 56;
+  int delta_pusch = 0;
+  bool is_rar_tx_retx = true;
+
+  int P_CMAX = nr_get_Pcmax(23, mac.nr_band, FR1, Qm, false, current_UL_BWP.scs, current_UL_BWP.BWPSize, false, num_rb, start_prb);
+
+  long preambleReceivedTargetPower = -96;
+  nr_rach_ConfigCommon.rach_ConfigGeneric.preambleReceivedTargetPower = preambleReceivedTargetPower;
+
+  int power = get_pusch_tx_power_ue(&mac,
+                                    num_rb,
+                                    start_prb,
+                                    nb_symb_sch,
+                                    nb_dmrs_prb,
+                                    nb_ptrs_prb,
+                                    Qm,
+                                    R,
+                                    beta_offset_csi1,
+                                    sum_bits_in_codeblocks,
+                                    delta_pusch,
+                                    is_rar_tx_retx,
+                                    false);
+  EXPECT_EQ(power, -84);
+  EXPECT_LT(power, P_CMAX);
+  nr_rach_ConfigCommon.rach_ConfigGeneric.preambleReceivedTargetPower -= 2;
+
+  int reduced_power = get_pusch_tx_power_ue(&mac,
+                                            num_rb,
+                                            start_prb,
+                                            nb_symb_sch,
+                                            nb_dmrs_prb,
+                                            nb_ptrs_prb,
+                                            Qm,
+                                            R,
+                                            beta_offset_csi1,
+                                            sum_bits_in_codeblocks,
+                                            delta_pusch,
+                                            is_rar_tx_retx,
+                                            false);
+  EXPECT_EQ(std::min(P_CMAX, power - 2), reduced_power)
+      << "Incorrect handling of preambleReceivedTargetPower";
+  EXPECT_LT(reduced_power, P_CMAX) << "Power above P_CMAX";
+
+  delta_pusch = 4;
+  int increased_power = get_pusch_tx_power_ue(&mac,
+                                            num_rb,
+                                            start_prb,
+                                            nb_symb_sch,
+                                            nb_dmrs_prb,
+                                            nb_ptrs_prb,
+                                            Qm,
+                                            R,
+                                            beta_offset_csi1,
+                                            sum_bits_in_codeblocks,
+                                            delta_pusch,
+                                            is_rar_tx_retx,
+                                            false);
+  EXPECT_EQ(std::min(P_CMAX, reduced_power + delta_pusch), increased_power)
+      << "delta_pusch should increase tx power";
+  EXPECT_LT(increased_power, P_CMAX) << "Power above P_CMAX";
+}
+
+TEST(pusch_power_control, pusch_power_data)
+{
+  NR_UE_MAC_INST_t mac = {0};
+  NR_UE_UL_BWP_t current_UL_BWP = {0};
+  current_UL_BWP.scs = 1;
+  current_UL_BWP.BWPSize = 106;
+  mac.current_UL_BWP = &current_UL_BWP;
+  NR_RACH_ConfigCommon_t nr_rach_ConfigCommon = {0};
+  current_UL_BWP.rach_ConfigCommon = &nr_rach_ConfigCommon;
+  mac.nr_band = 78;
+
+  bool is_rar_tx_retx = false;
+  int num_rb = 5;
+  int start_prb = 0;
+  uint16_t nb_symb_sch = 3;
+  uint16_t nb_dmrs_prb = 6;
+  uint16_t nb_ptrs_prb = 0;
+  uint16_t Qm = 2;
+  uint16_t R = 6790;
+  uint16_t beta_offset_csi1 = 0;
+  uint32_t sum_bits_in_codeblocks = 192;
+  int delta_pusch = 4;
+  bool transform_precoding = false;
+  NR_PUSCH_Config_t pusch_Config = {0};
+  current_UL_BWP.pusch_Config = &pusch_Config;
+  NR_PUSCH_PowerControl pusch_PowerControl = {0};
+  pusch_Config.pusch_PowerControl = &pusch_PowerControl;
+  pusch_PowerControl.tpc_Accumulation = (long*)1;
+  long p0_NominalWithGrant = 0;
+  current_UL_BWP.p0_NominalWithGrant = &p0_NominalWithGrant;
+  pusch_PowerControl.deltaMCS = (long*)1;
+
+  int P_CMAX = nr_get_Pcmax(23, mac.nr_band, FR1, Qm, false, current_UL_BWP.scs, current_UL_BWP.BWPSize, transform_precoding, num_rb, start_prb);
+
+  int power = get_pusch_tx_power_ue(&mac,
+                                    num_rb,
+                                    start_prb,
+                                    nb_symb_sch,
+                                    nb_dmrs_prb,
+                                    nb_ptrs_prb,
+                                    Qm,
+                                    R,
+                                    beta_offset_csi1,
+                                    sum_bits_in_codeblocks,
+                                    delta_pusch,
+                                    is_rar_tx_retx,
+                                    transform_precoding);
+  EXPECT_LE(power, P_CMAX);
+  EXPECT_EQ(power, 18);
+
+  const int BETA_OFFSET_CSI1_DEFAULT = 13;
+  sum_bits_in_codeblocks = 0; // CSI-only
+  power = get_pusch_tx_power_ue(&mac,
+                                num_rb,
+                                start_prb,
+                                nb_symb_sch,
+                                nb_dmrs_prb,
+                                nb_ptrs_prb,
+                                Qm,
+                                R,
+                                BETA_OFFSET_CSI1_DEFAULT,
+                                sum_bits_in_codeblocks,
+                                delta_pusch,
+                                is_rar_tx_retx,
+                                transform_precoding);
+  EXPECT_EQ(power, P_CMAX) << "Expecting max tx power because of deltaMCS with CSI-only";
+}
+
 int main(int argc, char** argv)
 {
   logInit();

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_RA.c

@@ -1271,6 +1271,8 @@ static void nr_generate_Msg2(module_id_t module_idP,
                                            TYPE_RA_RNTI_,
                                            coresetid,
                                            false);
+  if (!tda_info.valid_tda)
+    return;
 
   uint16_t *vrb_map = cc[CC_id].vrb_map;
   for (int i = 0; (i < rbSize) && (rbStart <= (BWPSize - rbSize)); i++) {
@@ -1804,6 +1806,8 @@ static void nr_generate_Msg4(module_id_t module_idP,
                                              TYPE_TC_RNTI_,
                                              coreset->controlResourceSetId,
                                              false);
+    if (!msg4_tda.valid_tda)
+      return;
 
     NR_pdsch_dmrs_t dmrs_info = get_dl_dmrs_params(scc,
                                                    dl_bwp,

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_dlsch.c

@@ -455,6 +455,8 @@ static bool allocate_dl_retransmission(module_id_t module_id,
                                            TYPE_C_RNTI_,
                                            coresetid,
                                            false);
+  if (!temp_tda.valid_tda)
+    return false;
 
   bool reuse_old_tda = (retInfo->tda_info.startSymbolIndex == temp_tda.startSymbolIndex) && (retInfo->tda_info.nrOfSymbols <= temp_tda.nrOfSymbols);
   LOG_D(NR_MAC, "[UE %x] %s old TDA, %s number of layers\n",
@@ -775,6 +777,7 @@ static void pf_dl(module_id_t module_id,
                                             TYPE_C_RNTI_,
                                             coresetid,
                                             false);
+    AssertFatal(sched_pdsch->tda_info.valid_tda, "Invalid TDA from get_dl_tda_info\n");
 
     NR_tda_info_t *tda_info = &sched_pdsch->tda_info;
 

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c

@@ -75,6 +75,8 @@ void nr_preprocessor_phytest(module_id_t module_id,
                                            TYPE_C_RNTI_,
                                            sched_ctrl->coreset->controlResourceSetId,
                                            false);
+  if(!tda_info.valid_tda)
+    return;
 
   sched_ctrl->sched_pdsch.tda_info = tda_info;
   sched_ctrl->sched_pdsch.time_domain_allocation = tda;
@@ -271,18 +273,15 @@ bool nr_ul_preprocessor_phytest(module_id_t module_id, frame_t frame, sub_frame_
                                            sched_ctrl->search_space->searchSpaceType->present,
                                            TYPE_C_RNTI_,
                                            tda);
+  if (!tda_info.valid_tda)
+    return false;
   sched_ctrl->sched_pusch.tda_info = tda_info;
 
   const int buffer_index = ul_buffer_index(sched_frame, sched_slot, mu, nr_mac->vrb_map_UL_size);
   uint16_t *vrb_map_UL = &nr_mac->common_channels[CC_id].vrb_map_UL[buffer_index * MAX_BWP_SIZE];
   for (int i = rbStart; i < rbStart + rbSize; ++i) {
     if ((vrb_map_UL[i+BWPStart] & SL_to_bitmap(tda_info.startSymbolIndex, tda_info.nrOfSymbols)) != 0) {
-      LOG_E(MAC,
-            "%s(): %4d.%2d RB %d is already reserved, cannot schedule UE\n",
-            __func__,
-            frame,
-            slot,
-            i);
+      LOG_E(MAC, "%4d.%2d RB %d is already reserved, cannot schedule UE\n", frame, slot, i);
       return false;
     }
   }

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c

@@ -1116,10 +1116,12 @@ void handle_nr_uci_pucch_2_3_4(module_id_t mod_id,
   }
   /* phy-test has hardcoded allocation, so no use to handle CSI reports */
   if ((uci_234->pduBitmap >> 2) & 0x01 && !get_softmodem_params()->phy_test) {
-    //API to parse the csi report and store it into sched_ctrl
-    extract_pucch_csi_report(csi_MeasConfig, uci_234, frame, slot, UE, nrmac->common_channels->ServingCellConfigCommon);
-    //TCI handling function
-    tci_handling(UE,frame, slot);
+    if (uci_234->csi_part1.csi_part1_crc != 1) {
+      // API to parse the csi report and store it into sched_ctrl
+      extract_pucch_csi_report(csi_MeasConfig, uci_234, frame, slot, UE, nrmac->common_channels->ServingCellConfigCommon);
+      // TCI handling function
+      tci_handling(UE, frame, slot);
+    }
     free(uci_234->csi_part1.csi_part1_payload);
   }
   if ((uci_234->pduBitmap >> 3) & 0x01) {

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c

@@ -1601,6 +1601,8 @@ static bool allocate_ul_retransmission(gNB_MAC_INST *nrmac,
                                            sched_ctrl->search_space->searchSpaceType->present,
                                            TYPE_C_RNTI_,
                                            tda);
+  if (!tda_info.valid_tda)
+    return false;
   bool reuse_old_tda = (retInfo->tda_info.startSymbolIndex == tda_info.startSymbolIndex) && (retInfo->tda_info.nrOfSymbols <= tda_info.nrOfSymbols);
   if (reuse_old_tda && nrOfLayers == retInfo->nrOfLayers) {
     /* Check the resource is enough for retransmission */
@@ -1844,6 +1846,7 @@ static void pf_ul(module_id_t module_id,
                                               sched_ctrl->search_space->searchSpaceType->present,
                                               TYPE_C_RNTI_,
                                               sched_pusch->time_domain_allocation);
+      AssertFatal(sched_pusch->tda_info.valid_tda, "Invalid TDA from get_ul_tda_info\n");
       sched_pusch->dmrs_info = get_ul_dmrs_params(scc,
                                                   current_BWP,
                                                   &sched_pusch->tda_info,
@@ -1967,6 +1970,7 @@ static void pf_ul(module_id_t module_id,
                                             sched_ctrl->search_space->searchSpaceType->present,
                                             TYPE_C_RNTI_,
                                             sched_pusch->time_domain_allocation);
+    AssertFatal(sched_pusch->tda_info.valid_tda, "Invalid TDA from get_ul_tda_info\n");
     sched_pusch->dmrs_info = get_ul_dmrs_params(scc,
                                                 current_BWP,
                                                 &sched_pusch->tda_info,

openair2/LAYER2/nr_rlc/nr_rlc_entity.c

@@ -110,11 +110,8 @@ nr_rlc_entity_t *new_nr_rlc_entity_am(
   ret->max_retx_threshold = max_retx_threshold;
   ret->sn_field_length    = sn_field_length;
 
-  if (!(sn_field_length == 12 || sn_field_length == 18)) {
-    LOG_E(RLC, "%s:%d:%s: wrong SN field_lenght (%d), must be 12 or 18\n",
-          __FILE__, __LINE__, __FUNCTION__, sn_field_length);
-    exit(1);
-  }
+  AssertFatal(sn_field_length == 12 || sn_field_length == 18, "Wrong SN field_length (%d), must be 12 or 18\n", sn_field_length);
+
   ret->sn_modulus = 1 << ret->sn_field_length;
   ret->window_size = ret->sn_modulus / 2;
 
@@ -172,11 +169,8 @@ nr_rlc_entity_t *new_nr_rlc_entity_um(
   ret->t_reassembly    = t_reassembly;
   ret->sn_field_length = sn_field_length;
 
-  if (!(sn_field_length == 6 || sn_field_length == 12)) {
-    LOG_E(RLC, "%s:%d:%s: wrong SN field_lenght (%d), must be 6 or 12\n",
-          __FILE__, __LINE__, __FUNCTION__, sn_field_length);
-    exit(1);
-  }
+  AssertFatal(sn_field_length == 6 || sn_field_length == 12, "Wrong SN field_length (%d), must be 6 or 12\n", sn_field_length);
+
   ret->sn_modulus = 1 << ret->sn_field_length;
   ret->window_size = ret->sn_modulus / 2;
 

openair2/RRC/NR/nr_rrc_config.c

@@ -655,6 +655,7 @@ static NR_SetupRelease_SRS_Config_t *get_config_srs(const NR_ServingCellConfigCo
                                                     const int uid,
                                                     const int res_id,
                                                     const long maxMIMO_Layers,
+                                                    const int minRXTXTIME,
                                                     int do_srs)
 {
   NR_SetupRelease_SRS_Config_t *setup_release_srs_Config = calloc(1,sizeof(*setup_release_srs_Config));
@@ -679,10 +680,10 @@ static NR_SetupRelease_SRS_Config_t *get_config_srs(const NR_ServingCellConfigCo
   } else {
     srs_resset0->resourceType.present =  NR_SRS_ResourceSet__resourceType_PR_aperiodic;
     srs_resset0->resourceType.choice.aperiodic = calloc(1,sizeof(*srs_resset0->resourceType.choice.aperiodic));
-    srs_resset0->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger=1;
-    srs_resset0->resourceType.choice.aperiodic->csi_RS=NULL;
+    srs_resset0->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger = 1;
+    srs_resset0->resourceType.choice.aperiodic->csi_RS = NULL;
     srs_resset0->resourceType.choice.aperiodic->slotOffset = calloc(1,sizeof(*srs_resset0->resourceType.choice.aperiodic->slotOffset));
-    *srs_resset0->resourceType.choice.aperiodic->slotOffset = 2;
+    *srs_resset0->resourceType.choice.aperiodic->slotOffset = minRXTXTIME;
     srs_resset0->resourceType.choice.aperiodic->ext1 = NULL;
   }
   srs_resset0->usage=NR_SRS_ResourceSet__usage_codebook;
@@ -1487,7 +1488,14 @@ static void config_uplinkBWP(NR_BWP_Uplink_t *ubwp,
                                 && servingcellconfigdedicated->uplinkConfig->pusch_ServingCellConfig->choice.setup->ext1->maxMIMO_Layers ?
                             *servingcellconfigdedicated->uplinkConfig->pusch_ServingCellConfig->choice.setup->ext1->maxMIMO_Layers : 1;
 
-  ubwp->bwp_Dedicated->srs_Config = get_config_srs(scc, NULL, curr_bwp, uid, bwp_loop + 1, maxMIMO_Layers, configuration->do_SRS);
+  ubwp->bwp_Dedicated->srs_Config = get_config_srs(scc,
+                                                   NULL,
+                                                   curr_bwp,
+                                                   uid,
+                                                   bwp_loop + 1,
+                                                   maxMIMO_Layers,
+                                                   configuration->minRXTXTIME,
+                                                   configuration->do_SRS);
 
   ubwp->bwp_Dedicated->configuredGrantConfig = NULL;
   ubwp->bwp_Dedicated->beamFailureRecoveryConfig = NULL;
@@ -2633,7 +2641,7 @@ static NR_SpCellConfig_t *get_initial_SpCellConfig(int uid,
                             : 1;
 
   // We are using do_srs = 0 here because the periodic SRS will only be enabled in update_cellGroupConfig() if do_srs == 1
-  initialUplinkBWP->srs_Config = get_config_srs(scc, NULL, curr_bwp, uid, 0, maxMIMO_Layers, 0);
+  initialUplinkBWP->srs_Config = get_config_srs(scc, NULL, curr_bwp, uid, 0, maxMIMO_Layers, configuration->minRXTXTIME, 0);
 
   scheduling_request_config(scc, pucch_Config, scc->uplinkConfigCommon->initialUplinkBWP->genericParameters.subcarrierSpacing);
 
@@ -2937,7 +2945,14 @@ void update_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig,
   // UL and SRS configuration
   if (configuration->do_SRS && uplinkConfig && uplinkConfig->initialUplinkBWP) {
     ASN_STRUCT_FREE(asn_DEF_NR_SetupRelease_SRS_Config, uplinkConfig->initialUplinkBWP->srs_Config);
-    uplinkConfig->initialUplinkBWP->srs_Config = get_config_srs(scc, uecap, curr_bwp, uid, 0, maxMIMO_Layers, configuration->do_SRS);
+    uplinkConfig->initialUplinkBWP->srs_Config = get_config_srs(scc,
+                                                                uecap,
+                                                                curr_bwp,
+                                                                uid,
+                                                                0,
+                                                                maxMIMO_Layers,
+                                                                configuration->minRXTXTIME,
+                                                                configuration->do_SRS);
   }
 
   // Set DL MCS table
@@ -2974,7 +2989,14 @@ void update_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig,
       }
 
       ASN_STRUCT_FREE(asn_DEF_NR_SetupRelease_SRS_Config, ul_bwp->bwp_Dedicated->srs_Config);
-      ul_bwp->bwp_Dedicated->srs_Config = get_config_srs(scc, uecap, bwp_size, uid, i + 1, maxMIMO_Layers, configuration->do_SRS);
+      ul_bwp->bwp_Dedicated->srs_Config = get_config_srs(scc,
+                                                         uecap,
+                                                         bwp_size,
+                                                         uid,
+                                                         i + 1,
+                                                         maxMIMO_Layers,
+                                                         configuration->minRXTXTIME,
+                                                         configuration->do_SRS);
     }
   }
   update_cqitables(bwp_Dedicated->pdsch_Config, csi_MeasConfig);
@@ -3172,7 +3194,14 @@ NR_CellGroupConfig_t *get_default_secondaryCellGroup(const NR_ServingCellConfigC
 
   int curr_bwp = NRRIV2BW(servingcellconfigcommon->downlinkConfigCommon->initialDownlinkBWP->genericParameters.locationAndBandwidth,
                           MAX_BWP_SIZE);
-  initialUplinkBWP->srs_Config = get_config_srs(servingcellconfigcommon, NULL, curr_bwp, uid, 0, maxMIMO_Layers, configuration->do_SRS);
+  initialUplinkBWP->srs_Config = get_config_srs(servingcellconfigcommon,
+                                                NULL,
+                                                curr_bwp,
+                                                uid,
+                                                0,
+                                                maxMIMO_Layers,
+                                                configuration->minRXTXTIME,
+                                                configuration->do_SRS);
 
   // Downlink BWPs
   int n_dl_bwp = 1;

openair2/RRC/NR/rrc_gNB_NGAP.c

@@ -200,59 +200,55 @@ rrc_gNB_send_NGAP_NAS_FIRST_REQ(
   //              ue_context_pP);
 
   /* Fill UE identities with available information */
-  req->ue_identity.presenceMask = NGAP_UE_IDENTITIES_NONE;
   if (UE->Initialue_identity_5g_s_TMSI.presence) {
     /* Fill s-TMSI */
     req->ue_identity.presenceMask = NGAP_UE_IDENTITIES_FiveG_s_tmsi;
     req->ue_identity.s_tmsi.amf_set_id = UE->Initialue_identity_5g_s_TMSI.amf_set_id;
     req->ue_identity.s_tmsi.amf_pointer = UE->Initialue_identity_5g_s_TMSI.amf_pointer;
     req->ue_identity.s_tmsi.m_tmsi = UE->Initialue_identity_5g_s_TMSI.fiveg_tmsi;
-  }
+  } else if (rrcSetupComplete->registeredAMF != NULL) {
+    NR_RegisteredAMF_t *r_amf = rrcSetupComplete->registeredAMF;
+    req->ue_identity.presenceMask = NGAP_UE_IDENTITIES_guami;
 
-  /* selected_plmn_identity: IE is 1-based, convert to 0-based (C array) */
-  int selected_plmn_identity = rrcSetupComplete->selectedPLMN_Identity - 1;
-  req->selected_plmn_identity = selected_plmn_identity;
+    /* The IE AMF-Identifier (AMFI) comprises of an AMF Region ID (8b), an AMF Set ID (10b) and an AMF Pointer (6b) as specified in TS 23.003 [21], clause 2.10.1. */
+    uint32_t amf_Id = BIT_STRING_to_uint32(&r_amf->amf_Identifier);
+    req->ue_identity.guami.amf_region_id = (amf_Id >> 16) & 0xff;
+    req->ue_identity.guami.amf_set_id = (amf_Id >> 6) & 0x3ff;
+    req->ue_identity.guami.amf_pointer = amf_Id & 0x3f;
 
-  if (rrcSetupComplete->registeredAMF != NULL) {
-      NR_RegisteredAMF_t *r_amf = rrcSetupComplete->registeredAMF;
-      req->ue_identity.presenceMask |= NGAP_UE_IDENTITIES_guami;
+    UE->ue_guami.amf_region_id = req->ue_identity.guami.amf_region_id;
+    UE->ue_guami.amf_set_id = req->ue_identity.guami.amf_set_id;
+    UE->ue_guami.amf_pointer = req->ue_identity.guami.amf_pointer;
 
-      if (r_amf->plmn_Identity != NULL) {
-          if ((r_amf->plmn_Identity->mcc != NULL) && (r_amf->plmn_Identity->mcc->list.count > 0)) {
-              /* Use first indicated PLMN MCC if it is defined */
-              req->ue_identity.guami.mcc = *r_amf->plmn_Identity->mcc->list.array[selected_plmn_identity];
-              LOG_I(NGAP, "[gNB %d] Build NGAP_NAS_FIRST_REQ adding in s_TMSI: GUMMEI MCC %u ue %x\n", ctxt_pP->module_id, req->ue_identity.guami.mcc, UE->rnti);
-          }
+    if (r_amf->plmn_Identity != NULL) {
+      AssertFatal(false, "At the moment, OAI RAN does not support multiple PLMN IDs. Therefore, this part has not been tested\n");
+      /* selected_plmn_identity: IE is 1-based, convert to 0-based (C array) */
+      int selected_plmn_identity = rrcSetupComplete->selectedPLMN_Identity - 1;
+      req->selected_plmn_identity = selected_plmn_identity;
 
-          if (r_amf->plmn_Identity->mnc.list.count > 0) {
-              /* Use first indicated PLMN MNC if it is defined */
-              req->ue_identity.guami.mnc = *r_amf->plmn_Identity->mnc.list.array[selected_plmn_identity];
-              LOG_I(NGAP, "[gNB %d] Build NGAP_NAS_FIRST_REQ adding in s_TMSI: GUMMEI MNC %u ue %x\n", ctxt_pP->module_id, req->ue_identity.guami.mnc, UE->rnti);
-          }
-      } else {
-          /* TODO */
+      if ((r_amf->plmn_Identity->mcc != NULL) && (r_amf->plmn_Identity->mcc->list.count > 0)) {
+        /* Use first indicated PLMN MCC if it is defined */
+        req->ue_identity.guami.mcc = *r_amf->plmn_Identity->mcc->list.array[selected_plmn_identity];
+        LOG_I(NGAP, "[gNB %d] Build NGAP_NAS_FIRST_REQ adding in s_TMSI: GUMMEI MCC %u ue %x\n", ctxt_pP->module_id, req->ue_identity.guami.mcc, UE->rnti);
       }
 
-      /* amf_Identifier */
-      uint32_t amf_Id = BIT_STRING_to_uint32(&r_amf->amf_Identifier);
-      req->ue_identity.guami.amf_region_id = amf_Id >> 16;
-      req->ue_identity.guami.amf_set_id = UE->Initialue_identity_5g_s_TMSI.amf_set_id;
-      req->ue_identity.guami.amf_pointer = UE->Initialue_identity_5g_s_TMSI.amf_pointer;
+      if (r_amf->plmn_Identity->mnc.list.count > 0) {
+        /* Use first indicated PLMN MNC if it is defined */
+        req->ue_identity.guami.mnc = *r_amf->plmn_Identity->mnc.list.array[selected_plmn_identity];
+        LOG_I(NGAP, "[gNB %d] Build NGAP_NAS_FIRST_REQ adding in s_TMSI: GUMMEI MNC %u ue %x\n", ctxt_pP->module_id, req->ue_identity.guami.mnc, UE->rnti);
+      }
+    } else {
+        /* TODO */
+    }
 
-      // fixme: illogical place to set UE values, should be in the function that call this one
-      UE->ue_guami.mcc = req->ue_identity.guami.mcc;
-      UE->ue_guami.mnc = req->ue_identity.guami.mnc;
-      UE->ue_guami.mnc_len = req->ue_identity.guami.mnc_len;
-      UE->ue_guami.amf_region_id = req->ue_identity.guami.amf_region_id;
-      UE->ue_guami.amf_set_id = req->ue_identity.guami.amf_set_id;
-      UE->ue_guami.amf_pointer = req->ue_identity.guami.amf_pointer;
-
-      LOG_I(NGAP,
-            "[gNB %d] Build NGAP_NAS_FIRST_REQ adding in s_TMSI: GUAMI amf_set_id %u amf_region_id %u ue %x\n",
-            ctxt_pP->module_id,
-            req->ue_identity.guami.amf_set_id,
-            req->ue_identity.guami.amf_region_id,
-            UE->rnti);
+    LOG_I(NGAP,
+          "[gNB %d] Build NGAP_NAS_FIRST_REQ adding in s_TMSI: GUAMI amf_set_id %u amf_region_id %u ue %x\n",
+          ctxt_pP->module_id,
+          req->ue_identity.guami.amf_set_id,
+          req->ue_identity.guami.amf_region_id,
+          UE->rnti);
+  } else {
+    req->ue_identity.presenceMask = NGAP_UE_IDENTITIES_NONE;
   }
 
   itti_send_msg_to_task (TASK_NGAP, ctxt_pP->instance, message_p);
@@ -482,6 +478,15 @@ int rrc_gNB_process_NGAP_INITIAL_CONTEXT_SETUP_REQ(MessageDef *msg_p, instance_t
   PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, GNB_FLAG_YES, UE->rrc_ue_id, 0, 0);
   UE->amf_ue_ngap_id = req->amf_ue_ngap_id;
 
+  /* store guami in gNB_RRC_UE_t context;
+   * we copy individual members because the guami types are different (nr_rrc_guami_t and ngap_guami_t) */
+  UE->ue_guami.mcc = req->guami.mcc;
+  UE->ue_guami.mnc = req->guami.mnc;
+  UE->ue_guami.mnc_len = req->guami.mnc_len;
+  UE->ue_guami.amf_region_id = req->guami.amf_region_id;
+  UE->ue_guami.amf_set_id = req->guami.amf_set_id;
+  UE->ue_guami.amf_pointer = req->guami.amf_pointer;
+
   /* NAS PDU */
   // this is malloced pointers, we pass it for later free()
   UE->nas_pdu = req->nas_pdu;

openair3/NGAP/ngap_gNB_handlers.c

@@ -740,37 +740,38 @@ static int ngap_gNB_handle_initial_context_request(sctp_assoc_t assoc_id, uint32
   NGAP_FIND_PROTOCOLIE_BY_ID(NGAP_InitialContextSetupRequestIEs_t, ie, container,
                              NGAP_ProtocolIE_ID_id_GUAMI, true);
 
-    TBCD_TO_MCC_MNC(&ie->value.choice.GUAMI.pLMNIdentity, msg->guami.mcc,
-                    msg->guami.mnc, msg->guami.mnc_len);
+  TBCD_TO_MCC_MNC(&ie->value.choice.GUAMI.pLMNIdentity, msg->guami.mcc,
+                  msg->guami.mnc, msg->guami.mnc_len);
     
-    OCTET_STRING_TO_INT8(&ie->value.choice.GUAMI.aMFRegionID, msg->guami.amf_region_id);
-    OCTET_STRING_TO_INT16(&ie->value.choice.GUAMI.aMFSetID, msg->guami.amf_set_id);
-    OCTET_STRING_TO_INT8(&ie->value.choice.GUAMI.aMFPointer, msg->guami.amf_pointer);
+  msg->guami.amf_region_id = BIT_STRING_to_uint8(&ie->value.choice.GUAMI.aMFRegionID);
+  msg->guami.amf_set_id = BIT_STRING_to_uint16(&ie->value.choice.GUAMI.aMFSetID);
+  msg->guami.amf_pointer = BIT_STRING_to_uint8(&ie->value.choice.GUAMI.aMFPointer);
 
-    NGAP_FIND_PROTOCOLIE_BY_ID(NGAP_InitialContextSetupRequestIEs_t, ie, container, NGAP_ProtocolIE_ID_id_PDUSessionResourceSetupListCxtReq, false);
-    if (ie != NULL) {
-      msg->nb_of_pdusessions = ie->value.choice.PDUSessionResourceSetupListCxtReq.list.count;
 
-      for (i = 0; i < ie->value.choice.PDUSessionResourceSetupListCxtReq.list.count; i++) {
-        NGAP_PDUSessionResourceSetupItemCxtReq_t *item_p = ie->value.choice.PDUSessionResourceSetupListCxtReq.list.array[i];
-        msg->pdusession_param[i].pdusession_id = item_p->pDUSessionID;
+  NGAP_FIND_PROTOCOLIE_BY_ID(NGAP_InitialContextSetupRequestIEs_t, ie, container, NGAP_ProtocolIE_ID_id_PDUSessionResourceSetupListCxtReq, false);
+  if (ie != NULL) {
+    msg->nb_of_pdusessions = ie->value.choice.PDUSessionResourceSetupListCxtReq.list.count;
 
-        OCTET_STRING_TO_INT8(&item_p->s_NSSAI.sST, msg->pdusession_param[i].nssai.sst);
-        if (item_p->s_NSSAI.sD != NULL) {
-          uint8_t *sd_p = (uint8_t *)&msg->pdusession_param[i].nssai.sd;
-          sd_p[0] = item_p->s_NSSAI.sD->buf[0];
-          sd_p[1] = item_p->s_NSSAI.sD->buf[1];
-          sd_p[2] = item_p->s_NSSAI.sD->buf[2];
-        } else {
-          msg->pdusession_param[i].nssai.sd = 0xffffff;
-        }
+    for (i = 0; i < ie->value.choice.PDUSessionResourceSetupListCxtReq.list.count; i++) {
+      NGAP_PDUSessionResourceSetupItemCxtReq_t *item_p = ie->value.choice.PDUSessionResourceSetupListCxtReq.list.array[i];
+      msg->pdusession_param[i].pdusession_id = item_p->pDUSessionID;
 
-        if (item_p->nAS_PDU) {
-          allocCopy(&msg->pdusession_param[i].nas_pdu, *item_p->nAS_PDU);
-        }
-        allocCopy(&msg->pdusession_param[i].pdusessionTransfer, item_p->pDUSessionResourceSetupRequestTransfer);
+      OCTET_STRING_TO_INT8(&item_p->s_NSSAI.sST, msg->pdusession_param[i].nssai.sst);
+      if (item_p->s_NSSAI.sD != NULL) {
+        uint8_t *sd_p = (uint8_t *)&msg->pdusession_param[i].nssai.sd;
+        sd_p[0] = item_p->s_NSSAI.sD->buf[0];
+        sd_p[1] = item_p->s_NSSAI.sD->buf[1];
+        sd_p[2] = item_p->s_NSSAI.sD->buf[2];
+      } else {
+        msg->pdusession_param[i].nssai.sd = 0xffffff;
       }
+
+      if (item_p->nAS_PDU) {
+        allocCopy(&msg->pdusession_param[i].nas_pdu, *item_p->nAS_PDU);
+      }
+      allocCopy(&msg->pdusession_param[i].pdusessionTransfer, item_p->pDUSessionResourceSetupRequestTransfer);
     }
+  }
 
   /* id-AllowedNSSAI */
   NGAP_FIND_PROTOCOLIE_BY_ID(NGAP_InitialContextSetupRequestIEs_t, ie, container,