.gitignore

+cscope.files
+cscope.files2
+cscope.in.out
+cscope.out
+cscope.po.out
+targets/bin/
+cmake_targets/log/
+cmake_targets/lte_build_oai/

cmake_targets/CMakeLists.txt

@@ -27,8 +27,8 @@ cmake_minimum_required (VERSION 2.8)
 # Base directories, compatible with legacy OAI building
 ################################################
 set (OPENAIR_DIR     $ENV{OPENAIR_DIR})
-#set (NFAPI_DIR       $ENV{NFAPI_DIR})
-set (NFAPI_DIR       ${OPENAIR_DIR}/nfapi)
+set (NFAPI_DIR       $ENV{NFAPI_DIR})
+set (NFAPI_USER_DIR  ${OPENAIR_DIR}/nfapi)
 set (OPENAIR1_DIR    ${OPENAIR_DIR}/openair1)
 set (OPENAIR2_DIR    ${OPENAIR_DIR}/openair2)
 set (OPENAIR3_DIR    ${OPENAIR_DIR}/openair3)
@@ -768,7 +768,12 @@ else()
   include_directories("${OPENAIR2_DIR}/UTIL")
   include_directories("${OPENAIR2_DIR}/UTIL/LOG")
 endif()
-include_directories("${NFAPI_DIR}")
+include_directories("${NFAPI_DIR}/nfapi/public_inc")
+include_directories("${NFAPI_DIR}/common/public_inc")
+include_directories("${NFAPI_DIR}/pnf/public_inc")
+include_directories("${NFAPI_DIR}/nfapi/inc")
+include_directories("${NFAPI_DIR}/sim_common/inc")
+include_directories("${NFAPI_DIR}/pnf_sim/inc")
 include_directories("${OPENAIR1_DIR}")
 include_directories("${OPENAIR2_DIR}/NAS")
 include_directories("${OPENAIR2_DIR}")
@@ -1010,6 +1015,58 @@ set(SCHED_SRC
 )
 add_library(SCHED_LIB ${SCHED_SRC})
 
+# 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})
+
+include_directories(${NFAPI_DIR}/nfapi/public_inc)
+include_directories(${NFAPI_DIR}/nfapi/inc)
+
+set(NFAPI_PNF_SRC
+  ${NFAPI_DIR}/pnf/src/pnf.c
+  ${NFAPI_DIR}/pnf/src/pnf_interface.c
+  ${NFAPI_DIR}/pnf/src/pnf_p7.c
+  ${NFAPI_DIR}/pnf/src/pnf_p7_interface.c
+)
+add_library(NFAPI_PNF_LIB ${NFAPI_PNF_SRC})
+
+include_directories(${NFAPI_DIR}/pnf/public_inc)
+include_directories(${NFAPI_DIR}/pnf/inc)
+
+set(NFAPI_VNF_SRC
+  ${NFAPI_DIR}/vnf/src/vnf.c
+  ${NFAPI_DIR}/vnf/src/vnf_interface.c
+  ${NFAPI_DIR}/vnf/src/vnf_p7.c
+  ${NFAPI_DIR}/vnf/src/vnf_p7_interface.c
+)
+add_library(NFAPI_VNF_LIB ${NFAPI_VNF_SRC})
+
+include_directories(${NFAPI_DIR}/vnf/public_inc)
+include_directories(${NFAPI_DIR}/vnf/inc)
+
+# nFAPI user defined code
+#############################
+set(NFAPI_USER_SRC
+${NFAPI_USER_DIR}/nfapi.c
+${NFAPI_USER_DIR}/nfapi_pnf.c
+${NFAPI_USER_DIR}/nfapi_vnf.c
+)
+add_library(NFAPI_USER_LIB ${NFAPI_USER_SRC})
+include_directories(${NFAPI_USER_DIR})
+
 # Layer 1
 #############################
 set(PHY_SRC
@@ -1167,6 +1224,7 @@ set(L2_SRC
   ${RRC_DIR}/L2_interface.c
   )
 set (MAC_SRC
+  ${PHY_INTERFACE_DIR}/phy_stub_UE.c
   ${PHY_INTERFACE_DIR}/IF_Module.c
   ${MAC_DIR}/main.c
   ${MAC_DIR}/ue_procedures.c
@@ -1205,6 +1263,8 @@ add_library(L2
   ${ENB_APP_SRC})
 #  ${OPENAIR2_DIR}/RRC/L2_INTERFACE/openair_rrc_L2_interface.c)
 
+include_directories(${NFAPI_USER_DIR})
+
 if (FLEXRAN_AGENT_SB_IF)
 
 #Test for adding a shared library
@@ -1618,6 +1678,13 @@ add_library(OPENAIR0_LIB
   ${OPENAIR_TARGETS}/ARCH/EXMIMO/USERSPACE/LIB/openair0_lib.c
 )
 
+include_directories("${NFAPI_DIR}/nfapi/public_inc")
+include_directories("${NFAPI_DIR}/common/public_inc")
+include_directories("${NFAPI_DIR}/pnf/public_inc")
+include_directories("${NFAPI_DIR}/nfapi/inc")
+include_directories("${NFAPI_DIR}/sim_common/inc")
+include_directories("${NFAPI_DIR}/pnf_sim/inc")
+
 # System packages that are required
 # We use either the cmake buildin, in ubuntu are in: /usr/share/cmake*/Modules/
 # or cmake provide a generic interface to pkg-config that widely used
@@ -1673,6 +1740,26 @@ endif()
 add_definitions("-DNETTLE_VERSION_MAJOR=${NETTLE_VERSION_MAJOR}")
 add_definitions("-DNETTLE_VERSION_MINOR=${NETTLE_VERSION_MINOR}")
 
+#pkg_search_module(NFAPI nfapi)
+#if(NOT ${NFAPI_FOUND})
+  #message( FATAL_ERROR "PACKAGE nfapi not found: some targets will fail. Run build_oai -I again!")
+#else()
+  #include_directories(${NFAPI_INCLUDE_DIRS})
+  #message( "PACKAGE nfapi!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+  #message( "${NFAPI_INCLUDE_DIR}")
+  #message( "${NFAPI_COMMON_INCLUDE_DIR}")
+  #message( "${NFAPI_VNF_INCLUDE_DIR}")
+  #message( "${NFAPI_PNF_INCLUDE_DIR}")
+  #message( "XXX")
+  #message( "${NFAPI_LIBRARY}")
+  #message( "${NFAPI_COMMON_LIBRARY}")
+  #message( "${NFAPI_PNF_LIBRARY}")
+  #message( "XXX")
+  #message( "${NFAPI_LIBRARIES}")
+  #message( "XXX")
+#endif()
+
+
 pkg_search_module(XPM xpm)
 if(NOT ${XPM_FOUND})
   message("PACKAGE xpm not found: some targets will fail")
@@ -1728,6 +1815,12 @@ if (${T_TRACER})
   set (T_LIB "rt")
 endif (${T_TRACER})
 
+#if (${NFAPI_DIR})
+#set (NFAPI_PNF_LIB "nfapi_pnf")
+#set (NFAPI_LIB "nfapi")
+#set (NFAPI_COMMON_LIB "nfapi_common")
+#endif (${NFAPI_DIR})
+#
 #Some files in the T directory are generated.
 #This rule and the following deal with it.
 add_custom_command (
@@ -1784,16 +1877,64 @@ add_executable(lte-softmodem
   ${SHLIB_LOADER_SOURCES}
   )
 
-target_link_libraries (lte-softmodem -ldl 
+target_link_libraries (lte-softmodem
   -Wl,--start-group
   RRC_LIB S1AP_LIB S1AP_ENB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB PHY LFDS L2 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ITTI_LIB} ${MIH_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} LFDS7
-  -Wl,--end-group )
+  NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB
+  NFAPI_USER_LIB
+  -Wl,--end-group z dl)
 
 target_link_libraries (lte-softmodem ${LIBXML2_LIBRARIES})
 target_link_libraries (lte-softmodem pthread m ${CONFIG_LIBRARIES} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES})
 target_link_libraries (lte-softmodem ${LIB_LMS_LIBRARIES})
 target_link_libraries (lte-softmodem ${T_LIB})
 
+
+
+
+# lte-softmodem-stub is both eNB and UE implementation
+###################################################
+
+add_executable(lte-softmodem-stub
+  ${rrc_h}
+  ${s1ap_h}
+  ${OPENAIR_BIN_DIR}/messages_xml.h
+  ${OPENAIR_TARGETS}/RT/USER/rt_wrapper.c
+  ${OPENAIR_TARGETS}/RT/USER/lte-ue.c
+  ${OPENAIR_TARGETS}/RT/USER/lte-enb.c
+  ${OPENAIR_TARGETS}/RT/USER/lte-softmodem-stub.c
+  ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c
+  ${OPENAIR_TARGETS}/SIMU/USER/init_lte.c
+  ${OPENAIR_TARGETS}/COMMON/create_tasks.c
+  ${OPENAIR_TARGETS}/ARCH/COMMON/common_lib.c
+  ${OPENAIR1_DIR}/SIMULATION/ETH_TRANSPORT/netlink_init.c
+  ${OPENAIR3_DIR}/NAS/UE/nas_ue_task.c
+  ${OPENAIR_DIR}/common/utils/utils.c
+  ${OPENAIR_DIR}/common/utils/system.c
+  ${GTPU_need_ITTI}
+  ${RTAI_SOURCE}
+  ${XFORMS_SOURCE}
+  ${XFORMS_SOURCE_SOFTMODEM}
+  ${T_SOURCE}
+  ${CONFIG_SOURCES}
+  ${SHLIB_LOADER_SOURCES}
+  )
+
+target_link_libraries (lte-softmodem-stub
+  -Wl,--start-group
+  RRC_LIB S1AP_LIB S1AP_ENB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB PHY LFDS L2 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ITTI_LIB} ${MIH_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} LFDS7
+  NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB
+  NFAPI_USER_LIB
+  -Wl,--end-group z dl)
+
+target_link_libraries (lte-softmodem-stub ${LIBXML2_LIBRARIES})
+target_link_libraries (lte-softmodem-stub pthread m ${CONFIG_LIBRARIES} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} sctp  ${XFORMS_LIBRARIES} ${PROTOBUF_LIB}  ${CMAKE_DL_LIBS} ${LIBYAML_LIBRARIES})
+target_link_libraries (lte-softmodem-stub ${LIB_LMS_LIBRARIES})
+target_link_libraries (lte-softmodem-stub ${T_LIB})
+
+
+
+
 # lte-softmodem-nos1 is both eNB and UE implementation
 ###################################################
 add_executable(lte-softmodem-nos1
@@ -1909,22 +2050,44 @@ add_executable(oaisim
   ${SHLIB_LOADER_SOURCES}
 )
 
+#add_library( imp_nfapi STATIC IMPORTED)
+#set_property(TARGET imp_nfapi PROPERTY IMPORTED_LOCATION ${NFAPI_DIR}/libnfapi.a)
+#set_property(TARGET imp_nfapi PROPERTY IMPORTED_IMPLIB ${NFAPI_DIR}/libnfapi.a)
+#target_link_libraries(oaisim imp_nfapi)
+
+#add_library( imp_nfapi_common STATIC IMPORTED)
+#set_property(TARGET imp_nfapi_common PROPERTY IMPORTED_LOCATION ${NFAPI_DIR}/common/libnfapi_common.a)
+#set_property(TARGET imp_nfapi_common PROPERTY IMPORTED_IMPLIB ${NFAPI_DIR}/common/libnfapi_common.a)
+#target_link_libraries(oaisim imp_nfapi_common)
+
+#add_library( imp_nfapi_pnf STATIC IMPORTED)
+#set_property(TARGET imp_nfapi_pnf PROPERTY IMPORTED_LOCATION ${NFAPI_DIR}/pnf/libnfapi_pnf.a)
+#set_property(TARGET imp_nfapi_pnf PROPERTY IMPORTED_IMPLIB ${NFAPI_DIR}/pnf/libnfapi_pnf.a)
+#target_link_libraries(oaisim imp_nfapi_pnf)
+
+#
+#add_library (imp_nfapi_common STATIC IMPORTED)
+#set_target_properties(imp_nfapi_common PROPERTIES IMPORTED_LOCATION ${NFAPI_DIR}/common/libnfapi_common.a
+#set_target_properties(oaisim PROPERTIES LINK_FLAGS ${NFAPI_DIR}/nfapi/libnfapi.a ${NFAPI_DIR}/pnf/libnfapi_pnf.a ${NFAPI_DIR}/common/libnfapi_common.a)
+
+
 
 target_include_directories(oaisim PUBLIC  ${OPENAIR_TARGETS}/SIMU/USER)
 target_link_libraries (oaisim
   -Wl,-ldl,--start-group
   RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB GTPV1U SECU_CN UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB PHY LFDS ${MSC_LIB} L2 ${RAL_LIB} LIB_NAS_UE SIMU SECU_OSA ${ITTI_LIB}  ${MIH_LIB}
+  NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB
+  NFAPI_USER_LIB
   -Wl,--end-group )
 
 target_link_libraries (oaisim ${LIBXML2_LIBRARIES} ${LAPACK_LIBRARIES})
-target_link_libraries (oaisim pthread m ${CONFIG_LIBRARIES} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES}  ${NETTLE_LIBRARIES} sctp 
-  ${ATLAS_LIBRARIES} ${XFORMS_LIBRARIES} ${OPENPGM_LIBRARIES})
+target_link_libraries (oaisim pthread m ${CONFIG_LIBRARIES} rt crypt ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES}  ${NETTLE_LIBRARIES} sctp z
+  ${ATLAS_LIBRARIES} ${XFORMS_LIBRARIES} ${OPENPGM_LIBRARIES} )
 #Force link with forms, regardless XFORMS option
 target_link_libraries (oaisim forms)
 target_link_libraries (oaisim ${T_LIB})
 
 
-
 # A all in one network simulator
 ################
 add_executable(oaisim_nos1
@@ -2064,7 +2227,7 @@ endforeach(myExe)
 if (${T_TRACER})
   foreach(i
         #all "add_executable" definitions (except tests, rb_tool, updatefw)
-        lte-softmodem lte-softmodem-nos1 rrh_gw oaisim oaisim_nos1
+        lte-softmodem lte-softmodem-stub lte-softmodem-nos1 rrh_gw oaisim oaisim_nos1
         dlsim_tm4 dlsim dlsim_tm7 ulsim pbchsim scansim mbmssim
         pdcchsim pucchsim prachsim syncsim
         #all "add_library" definitions

cmake_targets/build_oai

@@ -196,7 +196,7 @@ function main() {
             GDB=1
             CMAKE_BUILD_TYPE="Debug"
             echo_info "Will Compile with gdb symbols and disable compiler optimization"
-            CMAKE_CMD="$CMAKE_CMD -DCMAKE_BUILD_TYPE=Debug"
+            CMAKE_CMD="$CMAKE_CMD -DCMAKE_BUILD_TYPE=Debug --trace-expand"
             shift;;
        --eNB)
             eNB=1
@@ -506,6 +506,7 @@ function main() {
   else
       lte_build_dir=lte_build_oai
       lte_exec=lte-softmodem
+      #lte_exec=lte-softmodem-stub
   fi
 
 # configuration module libraries, one currently available, using libconfig 

cmake_targets/tools/build_helper

@@ -230,6 +230,7 @@ install_protobuf_c_from_source(){
     rm -rf /tmp/protobuf-c
     git clone https://github.com/protobuf-c/protobuf-c.git
     cd protobuf-c
+	git checkout 2a46af42784abf86804d536f6e0122d47cfeea45
     ./autogen.sh
     ./configure
     echo "Compiling protobuf-c"

common/config/config_userapi.c

@@ -124,6 +124,7 @@ int config_get(paramdef_t *params,int numparams, char *prefix)
 {
 int ret= -1;
 
+printf("numparams:%d prefix:%s\n", numparams, prefix);
 if (CONFIG_ISFLAGSET(CONFIG_ABORT)) {
     fprintf(stderr,"[CONFIG] config_get skipped, config module not properly initialized\n");
     return ret;

nfapi/debug.h

+/*
+ * Copyright 2017 Cisco Systems, Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * 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.
+ */
+
+
+#ifndef _DEBUG_H_
+#define _DEBUG_H_
+
+/*! The trace levels used by the nfapi libraries */
+typedef enum nfapi_trace_level
+{
+	NFAPI_TRACE_ERROR = 1,
+	NFAPI_TRACE_WARN,
+	NFAPI_TRACE_NOTE,
+	NFAPI_TRACE_INFO,
+
+	NFAPI_TRACE_LEVEL_MAX
+} nfapi_trace_level_t;
+
+/*! The trace function pointer */
+typedef void (*nfapi_trace_fn_t)(nfapi_trace_level_t level, const char* format, ...);
+
+/*! Global trace function */
+extern nfapi_trace_fn_t nfapi_trace_g;
+
+/*! Global trace level */
+extern nfapi_trace_level_t nfapi_trace_level_g;
+
+/*! NFAPI trace macro */
+#define NFAPI_TRACE(level, format, ...) { if(nfapi_trace_g && ((nfapi_trace_level_t)level <= nfapi_trace_level_g)) (*nfapi_trace_g)(level, format, ##__VA_ARGS__); }
+
+/*! Function to change the trace level 
+ * \param new_level The modified trace level
+ */
+
+void nfapi_set_trace_level(nfapi_trace_level_t new_level);
+
+#endif /* _DEBUG_H_ */

nfapi/nfapi.c

+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <ifaddrs.h>
+#include <netdb.h>
+#include <pthread.h>
+#include <unistd.h>
+
+#if 0
+#if 0
+//DJP
+#include <mutex>
+#include <queue>
+#include <list>
+#endif
+
+//DJP struct phy_pdu
+typedef struct
+{
+#if 0
+	phy_pdu() : buffer_len(1500), buffer(0), len(0)
+	{
+		buffer = (char*) malloc(buffer_len);
+	}
+	
+	virtual ~phy_pdu()
+	{
+		free(buffer);
+	}
+#endif
+
+	unsigned buffer_len;
+	char* buffer;
+	unsigned len;
+} phy_pdu;
+
+// DJP class fapi_private 
+typedef struct
+{
+		//std::mutex mutex;
+		//std::queue<phy_pdu*> rx_buffer;
+
+		//std::queue<phy_pdu*> free_store;
+#if 0
+	public:
+
+		fapi_private()
+			: byte_count(0), tick(0), first_dl_config(false)
+		{
+		}
+
+		phy_pdu* allocate_phy_pdu()
+		{
+			phy_pdu* pdu = 0;
+			mutex.lock();
+			if(free_store.empty())
+			{
+				pdu = new phy_pdu();
+			}
+			else
+			{
+				pdu = free_store.front();
+				free_store.pop();
+			}
+			mutex.unlock();
+			return pdu;
+		}
+
+		void release_phy_pdu(phy_pdu* pdu)
+		{
+			mutex.lock();
+			free_store.push(pdu);
+			mutex.unlock();
+		}
+
+		bool rx_buffer_empty()
+		{
+			bool empty;
+			mutex.lock();
+			empty = rx_buffer.empty();
+			mutex.unlock();
+
+			return empty;
+		}
+		
+
+		void push_rx_buffer(phy_pdu* buff)
+		{
+			mutex.lock();
+			rx_buffer.push(buff);
+			mutex.unlock();
+		}
+
+		phy_pdu* pop_rx_buffer()
+		{
+			phy_pdu* buff = 0;
+			mutex.lock();
+			if(!rx_buffer.empty())
+			{
+				buff = rx_buffer.front();
+				rx_buffer.pop();
+			}
+			mutex.unlock();
+			return buff;
+		}
+#endif
+
+		uint32_t byte_count;
+		uint32_t tick;
+		uint8_t first_dl_config;
+
+} fapi_private ;
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+	typedef struct fapi_internal
+	{
+		fapi_t _public;
+
+		fapi_cb_t callbacks;
+
+		uint8_t state;
+		fapi_config_t config;
+
+		int rx_sock;
+		int tx_sock;
+		struct sockaddr_in tx_addr;
+
+		uint32_t tx_byte_count;
+		uint32_t tick;
+		
+		fapi_private* fapi;
+
+	} fapi_internal_t;
+#if defined(__cplusplus)
+}
+#endif
+#endif
+
+void set_thread_priority(int priority)
+{
+	//printf("%s(priority:%d)\n", __FUNCTION__, priority);
+	
+	pthread_attr_t ptAttr;
+	
+	struct sched_param schedParam;
+	schedParam.__sched_priority = priority; //79;
+	if(sched_setscheduler(0, SCHED_RR, &schedParam) != 0)
+	{
+		printf("Failed to set scheduler to SCHED_RR\n");
+	}
+
+	if(pthread_attr_setschedpolicy(&ptAttr, SCHED_RR) != 0)
+	{
+		printf("Failed to set pthread sched policy SCHED_RR\n");
+	}
+
+	pthread_attr_setinheritsched(&ptAttr, PTHREAD_EXPLICIT_SCHED);
+
+	struct sched_param thread_params;
+	thread_params.sched_priority = 20;
+	if(pthread_attr_setschedparam(&ptAttr, &thread_params) != 0)
+	{
+		printf("failed to set sched param\n");
+	}
+}

nfapi/nfapi_pnf.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "debug.h"
+#include "nfapi_pnf_interface.h"
+#include "nfapi.h"
+#include "nfapi_pnf.h"
+#include "common/ran_context.h"
+#include "openair2/PHY_INTERFACE/phy_stub_UE.h"
+//#include "openair1/PHY/vars.h"
+extern RAN_CONTEXT_t RC;
+
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <assert.h>
+#include <arpa/inet.h>
+#include <pthread.h>
+#include <errno.h>
+
+#include <vendor_ext.h>
+#include "fapi_stub.h"
+//#include "fapi_l1.h"
+#include "UTIL/LOG/log.h"
+
+#define NUM_P5_PHY 2
+
+#define _GNU_SOURCE
+
+extern void phy_init_RU(RU_t*);
+extern int config_sync_var;
+
+extern pthread_cond_t nfapi_sync_cond;
+extern pthread_mutex_t nfapi_sync_mutex;
+extern int nfapi_sync_var;
+
+extern int sync_var;
+char uecap_xer_in;
+
+extern void init_eNB_afterRU(void);
+extern void init_UE_stub(int nb_inst,int,int);
+extern void handle_nfapi_dci_dl_pdu(PHY_VARS_eNB *eNB, eNB_rxtx_proc_t *proc, nfapi_dl_config_request_pdu_t *dl_config_pdu);
+extern void handle_nfapi_ul_pdu(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, nfapi_ul_config_request_pdu_t *ul_config_pdu, uint16_t frame,uint8_t subframe,uint8_t srs_present);
+extern void handle_nfapi_dlsch_pdu(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,  nfapi_dl_config_request_pdu_t *dl_config_pdu, uint8_t codeword_index, uint8_t *sdu);
+extern void handle_nfapi_hi_dci0_dci_pdu(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, nfapi_hi_dci0_request_pdu_t *hi_dci0_config_pdu);
+extern void handle_nfapi_hi_dci0_hi_pdu(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, nfapi_hi_dci0_request_pdu_t *hi_dci0_config_pdu);
+extern void handle_nfapi_bch_pdu(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, nfapi_dl_config_request_pdu_t *dl_config_pdu, uint8_t *sdu);
+
+extern uint8_t  nfapi_mode;
+
+nfapi_tx_request_pdu_t* tx_request_pdu[1023][10][10]; // [frame][subframe][max_num_pdus]
+
+
+uint16_t phy_antenna_capability_values[] = { 1, 2, 4, 8, 16 };
+
+nfapi_pnf_param_response_t g_pnf_param_resp;
+
+
+nfapi_pnf_p7_config_t *p7_config_g = NULL;
+
+void* pnf_allocate(size_t size)
+{
+  //DJP
+  //return (void*)memory_pool::allocate(size);
+  return malloc(size);
+}
+
+void pnf_deallocate(void* ptr)
+{
+  //DJP
+  //memory_pool::deallocate((uint8_t*)ptr);
+  free(ptr);
+}
+
+
+//class udp_data
+//DJP
+typedef struct 
+{
+  //public:
+  uint8_t enabled;
+  uint32_t rx_port;
+  uint32_t tx_port;
+  //std::string tx_addr;
+  char tx_addr[80];
+}udp_data;
+
+//class phy_info
+//DJP
+typedef struct 
+{
+#if 0
+  public:
+
+    phy_info()
+      : first_subframe_ind(0), fapi(0),
+      dl_ues_per_subframe(0), ul_ues_per_subframe(0), 
+      timing_window(0), timing_info_mode(0), timing_info_period(0)
+  {
+    index = 0;
+    id = 0;
+
+    local_port = 0;
+    remote_addr = 0;
+    remote_port = 0;
+
+    duplex_mode = 0;
+    dl_channel_bw_support = 0;
+    ul_channel_bw_support = 0;
+    num_dl_layers_supported = 0;
+    num_ul_layers_supported = 0;
+    release_supported = 0;
+    nmm_modes_supported = 0;
+  }
+#endif
+
+    uint16_t index;
+    uint16_t id;
+    //std::vector<uint8_t> rfs;
+    //std::vector<uint8_t> excluded_rfs;
+    uint8_t rfs[2];
+    uint8_t excluded_rfs[2];
+
+    udp_data udp;
+
+    //std::string local_addr;
+    char local_addr[80];
+    int local_port;
+
+    char* remote_addr;
+    int remote_port;
+
+    uint8_t duplex_mode;
+    uint16_t dl_channel_bw_support;
+    uint16_t ul_channel_bw_support;
+    uint8_t num_dl_layers_supported;
+    uint8_t num_ul_layers_supported;
+    uint16_t release_supported;
+    uint8_t nmm_modes_supported;
+
+    uint8_t dl_ues_per_subframe;
+    uint8_t ul_ues_per_subframe;
+
+    uint8_t first_subframe_ind;
+
+    // timing information recevied from the vnf
+    uint8_t timing_window;
+    uint8_t timing_info_mode;
+    uint8_t timing_info_period;
+
+    //fapi_t* fapi;
+
+}phy_info;
+
+//class rf_info
+//DJP
+typedef struct 
+{
+  //public:
+  uint16_t index;
+  uint16_t band;
+  int16_t max_transmit_power;
+  int16_t min_transmit_power;
+  uint8_t num_antennas_supported;
+  uint32_t min_downlink_frequency;
+  uint32_t max_downlink_frequency;
+  uint32_t max_uplink_frequency;
+  uint32_t min_uplink_frequency;
+}rf_info;
+
+
+//class pnf_info
+//DJP
+typedef struct 
+{
+#if 0
+  public:
+
+    pnf_info() 
+      : release(13), wireshark_test_mode(0),
+      max_total_power(0), oui(0)
+
+  {
+    release = 0;
+
+    sync_mode = 0;
+    location_mode = 0;
+    dl_config_timing = 0;
+    ul_config_timing = 0;
+    tx_timing = 0;
+    hi_dci0_timing = 0;
+
+    max_phys = 0;
+    max_total_bw = 0;
+    max_total_dl_layers = 0;
+    max_total_ul_layers = 0;
+    shared_bands = 0;
+    shared_pa = 0;
+
+  }
+#endif
+
+    int release;
+    //DJPstd::vector<phy_info> phys;
+    //std::vector<rf_info> rfs;
+    phy_info phys[2];
+    rf_info rfs[2];
+
+    uint8_t sync_mode;
+    uint8_t location_mode;
+    uint8_t location_coordinates[6];
+    uint32_t dl_config_timing;
+    uint32_t ul_config_timing;
+    uint32_t tx_timing;
+    uint32_t hi_dci0_timing;
+
+    uint16_t max_phys;
+    uint16_t max_total_bw;
+    uint16_t max_total_dl_layers;
+    uint16_t max_total_ul_layers;
+    uint8_t shared_bands;
+    uint8_t shared_pa;
+    int16_t max_total_power;
+    uint8_t oui;
+
+    uint8_t wireshark_test_mode;
+
+}pnf_info;
+
+// DJP struct pnf_phy_user_data_t
+typedef struct 
+{
+  uint16_t phy_id;
+  nfapi_pnf_config_t* config;
+  phy_info* phy;
+  nfapi_pnf_p7_config_t* p7_config;
+}pnf_phy_user_data_t;
+
+static pnf_info pnf;
+static pthread_t pnf_start_pthread;
+
+
+extern void nfapi_log(char *file, char *func, int line, int comp, int level, const char* format, va_list args);
+
+void pnf_nfapi_trace(nfapi_trace_level_t nfapi_level, const char* message, ...)
+{
+#if 1
+
+  va_list    args;
+  int oai_level;
+
+  if (nfapi_level==NFAPI_TRACE_ERROR)
+  {
+    oai_level = LOG_ERR;
+  }
+  else if (nfapi_level==NFAPI_TRACE_WARN)
+  {
+    oai_level = LOG_WARNING;
+  }
+  else if (nfapi_level==NFAPI_TRACE_NOTE)
+  {
+    oai_level = LOG_INFO;
+  }
+  else if (nfapi_level==NFAPI_TRACE_INFO)
+  {
+    oai_level = LOG_INFO;
+  }
+  else
+  {
+    oai_level = LOG_INFO;
+  }
+
+  va_start(args, message);
+  nfapi_log("FILE>", "FUNC", 999, PHY, oai_level, message, args);
+  va_end(args);
+  #else
+  va_list    args;
+  va_start(args, message);
+  vprintf(message, args);
+  va_end(args);
+  #endif
+}
+
+void pnf_set_thread_priority(int priority)
+{
+  //printf("%s(priority:%d)\n", __FUNCTION__, priority);
+
+  pthread_attr_t ptAttr;
+
+  struct sched_param schedParam;
+  schedParam.__sched_priority = priority; //79;
+  if(sched_setscheduler(0, SCHED_RR, &schedParam) != 0)
+  {
+    printf("failed to set SCHED_RR\n");
+  }
+
+  if(pthread_attr_setschedpolicy(&ptAttr, SCHED_RR) != 0)
+  {
+    printf("failed to set pthread SCHED_RR %d\n", errno);
+  }
+
+  pthread_attr_setinheritsched(&ptAttr, PTHREAD_EXPLICIT_SCHED);
+
+  struct sched_param thread_params;
+  thread_params.sched_priority = 20;
+  if(pthread_attr_setschedparam(&ptAttr, &thread_params) != 0)
+  {
+    printf("failed to set sched param\n");
+  }
+}
+
+void* pnf_p7_thread_start(void* ptr)
+{
+  NFAPI_TRACE(NFAPI_TRACE_INFO, "[PNF] P7 THREAD %s\n", __FUNCTION__);
+
+  pnf_set_thread_priority(79);
+
+  nfapi_pnf_p7_config_t* config = (nfapi_pnf_p7_config_t*)ptr;
+  nfapi_pnf_p7_start(config);
+
+  return 0;
+}
+
+
+
+int pnf_param_request(nfapi_pnf_config_t* config, nfapi_pnf_param_request_t* req)
+{
+  printf("[PNF] pnf param request\n");
+
+  nfapi_pnf_param_response_t resp;
+  memset(&resp, 0, sizeof(resp));
+  resp.header.message_id = NFAPI_PNF_PARAM_RESPONSE;
+  resp.error_code = NFAPI_MSG_OK;
+
+  pnf_info* pnf = (pnf_info*)(config->user_data);
+
+  resp.pnf_param_general.tl.tag = NFAPI_PNF_PARAM_GENERAL_TAG;
+  resp.pnf_param_general.nfapi_sync_mode = pnf->sync_mode;
+  resp.pnf_param_general.location_mode = pnf->location_mode;
+  //uint8_t location_coordinates[NFAPI_PNF_PARAM_GENERAL_LOCATION_LENGTH];
+  resp.pnf_param_general.dl_config_timing = pnf->dl_config_timing;
+  resp.pnf_param_general.tx_timing = pnf->tx_timing;
+  resp.pnf_param_general.ul_config_timing = pnf->ul_config_timing;
+  resp.pnf_param_general.hi_dci0_timing = pnf->hi_dci0_timing;
+  resp.pnf_param_general.maximum_number_phys = pnf->max_phys;
+  resp.pnf_param_general.maximum_total_bandwidth = pnf->max_total_bw;
+  resp.pnf_param_general.maximum_total_number_dl_layers = pnf->max_total_dl_layers;
+  resp.pnf_param_general.maximum_total_number_ul_layers = pnf->max_total_ul_layers;
+  resp.pnf_param_general.shared_bands = pnf->shared_bands;
+  resp.pnf_param_general.shared_pa = pnf->shared_pa;
+  resp.pnf_param_general.maximum_total_power = pnf->max_total_power;
+  //uint8_t oui[NFAPI_PNF_PARAM_GENERAL_OUI_LENGTH];
+
+  resp.pnf_phy.tl.tag = NFAPI_PNF_PHY_TAG;
+  //DJP resp.pnf_phy.number_of_phys = pnf->phys.size();
+  resp.pnf_phy.number_of_phys = 1;
+
+  //for(int i = 0; i < pnf->phys.size(); ++i)
+  for(int i = 0; i < 1; ++i)
+  {
+    resp.pnf_phy.phy[i].phy_config_index = pnf->phys[i].index; 
+    resp.pnf_phy.phy[i].downlink_channel_bandwidth_supported = pnf->phys[i].dl_channel_bw_support;
+    resp.pnf_phy.phy[i].uplink_channel_bandwidth_supported = pnf->phys[i].ul_channel_bw_support;
+    resp.pnf_phy.phy[i].number_of_dl_layers_supported = pnf->phys[i].num_dl_layers_supported;
+    resp.pnf_phy.phy[i].number_of_ul_layers_supported = pnf->phys[i].num_ul_layers_supported;
+    resp.pnf_phy.phy[i].maximum_3gpp_release_supported = pnf->phys[i].release_supported;
+    resp.pnf_phy.phy[i].nmm_modes_supported = pnf->phys[i].nmm_modes_supported;
+
+    //DJP resp.pnf_phy.phy[i].number_of_rfs = pnf->phys[i].rfs.size();
+    resp.pnf_phy.phy[i].number_of_rfs = 2;
+    //for(int j = 0; j < pnf->phys[i].rfs.size(); ++j)
+    for(int j = 0; j < 1; ++j)
+    {
+      resp.pnf_phy.phy[i].rf_config[j].rf_config_index = pnf->phys[i].rfs[j];
+    }
+
+    //DJP resp.pnf_phy.phy[i].number_of_rf_exclusions = pnf->phys[i].excluded_rfs.size();
+    resp.pnf_phy.phy[i].number_of_rf_exclusions = 0;
+    //DJP for(int j = 0; j < pnf->phys[i].excluded_rfs.size(); ++j)
+    for(int j = 0; j < 0; ++j)
+    {
+      resp.pnf_phy.phy[i].excluded_rf_config[j].rf_config_index = pnf->phys[i].excluded_rfs[j];
+    }
+  }
+
+
+  resp.pnf_rf.tl.tag = NFAPI_PNF_RF_TAG;
+  //DJPresp.pnf_rf.number_of_rfs = pnf->rfs.size();
+  resp.pnf_rf.number_of_rfs = 2;
+
+  //for(int i = 0; i < pnf->rfs.size(); ++i)
+  for(int i = 0; i < 2; ++i)
+  {
+    resp.pnf_rf.rf[i].rf_config_index = pnf->rfs[i].index; 
+    resp.pnf_rf.rf[i].band = pnf->rfs[i].band;
+    resp.pnf_rf.rf[i].maximum_transmit_power = pnf->rfs[i].max_transmit_power; 
+    resp.pnf_rf.rf[i].minimum_transmit_power = pnf->rfs[i].min_transmit_power;
+    resp.pnf_rf.rf[i].number_of_antennas_suppported = pnf->rfs[i].num_antennas_supported;
+    resp.pnf_rf.rf[i].minimum_downlink_frequency = pnf->rfs[i].min_downlink_frequency;
+    resp.pnf_rf.rf[i].maximum_downlink_frequency = pnf->rfs[i].max_downlink_frequency;
+    resp.pnf_rf.rf[i].minimum_uplink_frequency = pnf->rfs[i].min_uplink_frequency;
+    resp.pnf_rf.rf[i].maximum_uplink_frequency = pnf->rfs[i].max_uplink_frequency;
+  }
+
+  if(pnf->release >= 10)
+  {
+    resp.pnf_phy_rel10.tl.tag = NFAPI_PNF_PHY_REL10_TAG;
+    //DJPresp.pnf_phy_rel10.number_of_phys = pnf->phys.size();
+    resp.pnf_phy_rel10.number_of_phys = 1;
+
+    //for(int i = 0; i < pnf->phys.size(); ++i)
+    for(int i = 0; i < 1; ++i)
+    {
+      resp.pnf_phy_rel10.phy[i].phy_config_index = pnf->phys[i].index; 
+      resp.pnf_phy_rel10.phy[i].transmission_mode_7_supported = 0;
+      resp.pnf_phy_rel10.phy[i].transmission_mode_8_supported = 1;
+      resp.pnf_phy_rel10.phy[i].two_antenna_ports_for_pucch = 0;
+      resp.pnf_phy_rel10.phy[i].transmission_mode_9_supported = 1;
+      resp.pnf_phy_rel10.phy[i].simultaneous_pucch_pusch = 0;
+      resp.pnf_phy_rel10.phy[i].four_layer_tx_with_tm3_and_tm4 = 1;
+
+    }
+  }
+
+  if(pnf->release >= 11)
+  {
+    resp.pnf_phy_rel11.tl.tag = NFAPI_PNF_PHY_REL11_TAG;
+    //DJP resp.pnf_phy_rel11.number_of_phys = pnf->phys.size();
+    resp.pnf_phy_rel11.number_of_phys = 1;
+
+    //DJP for(int i = 0; i < pnf->phys.size(); ++i)
+    for(int i = 0; i < 1; ++i)
+    {
+      resp.pnf_phy_rel11.phy[i].phy_config_index = pnf->phys[i].index; 
+      resp.pnf_phy_rel11.phy[i].edpcch_supported = 0;
+      resp.pnf_phy_rel11.phy[i].multi_ack_csi_reporting = 1;
+      resp.pnf_phy_rel11.phy[i].pucch_tx_diversity = 0;
+      resp.pnf_phy_rel11.phy[i].ul_comp_supported = 1;
+      resp.pnf_phy_rel11.phy[i].transmission_mode_5_supported = 0;
+    }
+  }
+
+  if(pnf->release >= 12)
+  {
+    resp.pnf_phy_rel12.tl.tag = NFAPI_PNF_PHY_REL12_TAG;
+    //DJP resp.pnf_phy_rel12.number_of_phys = pnf->phys.size();
+    resp.pnf_phy_rel12.number_of_phys = 1;
+
+    //DJP for(int i = 0; i < pnf->phys.size(); ++i)
+    for(int i = 0; i < 1; ++i)
+    {
+      resp.pnf_phy_rel12.phy[i].phy_config_index = pnf->phys[i].index; 
+      resp.pnf_phy_rel12.phy[i].csi_subframe_set = 0;
+      resp.pnf_phy_rel12.phy[i].enhanced_4tx_codebook = 2; // yes this is invalid
+      resp.pnf_phy_rel12.phy[i].drs_supported = 0;
+      resp.pnf_phy_rel12.phy[i].ul_64qam_supported = 1;
+      resp.pnf_phy_rel12.phy[i].transmission_mode_10_supported = 0;
+      resp.pnf_phy_rel12.phy[i].alternative_bts_indices = 1;
+    }
+  }
+
+  if(pnf->release >= 13)
+  {
+    resp.pnf_phy_rel13.tl.tag = NFAPI_PNF_PHY_REL13_TAG;
+    //DJP resp.pnf_phy_rel13.number_of_phys = pnf->phys.size();
+    resp.pnf_phy_rel13.number_of_phys = 1;
+
+    //for(int i = 0; i < pnf->phys.size(); ++i)
+    for(int i = 0; i < 1; ++i)
+    {
+      resp.pnf_phy_rel13.phy[i].phy_config_index = pnf->phys[i].index; 
+      resp.pnf_phy_rel13.phy[i].pucch_format4_supported = 0;
+      resp.pnf_phy_rel13.phy[i].pucch_format5_supported = 1;
+      resp.pnf_phy_rel13.phy[i].more_than_5_ca_support = 0;
+      resp.pnf_phy_rel13.phy[i].laa_supported = 1;
+      resp.pnf_phy_rel13.phy[i].laa_ending_in_dwpts_supported = 0;
+      resp.pnf_phy_rel13.phy[i].laa_starting_in_second_slot_supported = 1;
+      resp.pnf_phy_rel13.phy[i].beamforming_supported = 0;
+      resp.pnf_phy_rel13.phy[i].csi_rs_enhancement_supported = 1;
+      resp.pnf_phy_rel13.phy[i].drms_enhancement_supported = 0;
+      resp.pnf_phy_rel13.phy[i].srs_enhancement_supported = 1;
+    }
+
+    resp.pnf_phy_rel13_nb_iot.tl.tag = NFAPI_PNF_PHY_REL13_NB_IOT_TAG;
+    //DJP resp.pnf_phy_rel13_nb_iot.number_of_phys = pnf->phys.size();		
+    resp.pnf_phy_rel13_nb_iot.number_of_phys = 1;
+
+    //for(int i = 0; i < pnf->phys.size(); ++i)
+    for(int i = 0; i < 1; ++i)
+    {
+      resp.pnf_phy_rel13_nb_iot.phy[i].phy_config_index = pnf->phys[i].index; 
+
+      //DJP resp.pnf_phy_rel13_nb_iot.phy[i].number_of_rfs = pnf->phys[i].rfs.size();
+      resp.pnf_phy_rel13_nb_iot.phy[i].number_of_rfs = 1;
+      //DJP for(int j = 0; j < pnf->phys[i].rfs.size(); ++j)
+      for(int j = 0; j < 1; ++j)
+      {
+        resp.pnf_phy_rel13_nb_iot.phy[i].rf_config[j].rf_config_index = pnf->phys[i].rfs[j];
+      }
+
+      //DJP resp.pnf_phy_rel13_nb_iot.phy[i].number_of_rf_exclusions = pnf->phys[i].excluded_rfs.size();
+      resp.pnf_phy_rel13_nb_iot.phy[i].number_of_rf_exclusions = 1;
+      //DJP for(int j = 0; j < pnf->phys[i].excluded_rfs.size(); ++j)
+      for(int j = 0; j < 1; ++j)
+      {
+        resp.pnf_phy_rel13_nb_iot.phy[i].excluded_rf_config[j].rf_config_index = pnf->phys[i].excluded_rfs[j];
+      }
+
+      resp.pnf_phy_rel13_nb_iot.phy[i].number_of_dl_layers_supported = pnf->phys[i].num_dl_layers_supported;
+      resp.pnf_phy_rel13_nb_iot.phy[i].number_of_ul_layers_supported = pnf->phys[i].num_ul_layers_supported;
+      resp.pnf_phy_rel13_nb_iot.phy[i].maximum_3gpp_release_supported = pnf->phys[i].release_supported;
+      resp.pnf_phy_rel13_nb_iot.phy[i].nmm_modes_supported = pnf->phys[i].nmm_modes_supported;
+
+    }
+  }
+
+
+  nfapi_pnf_pnf_param_resp(config, &resp);
+
+  return 0;
+}
+
+int pnf_config_request(nfapi_pnf_config_t* config, nfapi_pnf_config_request_t* req)
+{
+  printf("[PNF] pnf config request\n");
+
+  pnf_info* pnf = (pnf_info*)(config->user_data);
+
+#if 0
+  for(int i = 0; i < req->pnf_phy_rf_config.number_phy_rf_config_info; ++i)
+  {
+    auto found = std::find_if(pnf->phys.begin(), pnf->phys.end(), [&](phy_info& item)
+        { return item.index == req->pnf_phy_rf_config.phy_rf_config[i].phy_config_index; });
+
+    if(found != pnf->phys.end())
+    {
+      phy_info& phy = (*found);
+      phy.id = req->pnf_phy_rf_config.phy_rf_config[i].phy_id;
+      printf("[PNF] pnf config request assigned phy_id %d to phy_config_index %d\n", phy.id, req->pnf_phy_rf_config.phy_rf_config[i].phy_config_index);
+    }
+    else
+    {
+      // did not find the phy
+      printf("[PNF] pnf config request did not find phy_config_index %d\n", req->pnf_phy_rf_config.phy_rf_config[i].phy_config_index);
+    }
+
+  }
+#endif
+  //DJP
+  phy_info *phy = pnf->phys;
+  phy->id = req->pnf_phy_rf_config.phy_rf_config[0].phy_id;
+  printf("[PNF] pnf config request assigned phy_id %d to phy_config_index %d\n", phy->id, req->pnf_phy_rf_config.phy_rf_config[0].phy_config_index);
+  //DJP
+
+  nfapi_pnf_config_response_t resp;
+  memset(&resp, 0, sizeof(resp));
+  resp.header.message_id = NFAPI_PNF_CONFIG_RESPONSE;
+  resp.error_code = NFAPI_MSG_OK;
+  nfapi_pnf_pnf_config_resp(config, &resp);
+  printf("[PNF] Sent pnf_config_resp\n");
+
+  return 0;
+}
+
+void nfapi_send_pnf_start_resp(nfapi_pnf_config_t* config, uint16_t phy_id)
+{
+  printf("Sending NFAPI_START_RESPONSE config:%p phy_id:%d\n", config, phy_id);
+
+  nfapi_start_response_t start_resp;
+  memset(&start_resp, 0, sizeof(start_resp));
+  start_resp.header.message_id = NFAPI_START_RESPONSE;
+  start_resp.header.phy_id = phy_id;
+  start_resp.error_code = NFAPI_MSG_OK;
+
+  nfapi_pnf_start_resp(config, &start_resp);
+}
+
+int pnf_start_request(nfapi_pnf_config_t* config, nfapi_pnf_start_request_t* req)
+{
+  printf("Received NFAPI_PNF_START_REQUEST\n");
+
+  pnf_info* pnf = (pnf_info*)(config->user_data);
+
+  // start all phys that have been configured
+  //for(phy_info& phy : pnf->phys)
+  phy_info* phy = pnf->phys;
+  if(phy->id != 0)
+  {
+    //auto found = std::find_if(pnf->phys.begin(), pnf->phys.end(), [&](phy_info& item)
+    //		{ return item.id == req->header.phy_id; });
+    //
+    //	if(found != pnf->phys.end())
+    //	{
+    //		phy_info& phy = (*found);
+    //}
+
+    nfapi_pnf_start_response_t resp;
+    memset(&resp, 0, sizeof(resp));
+    resp.header.message_id = NFAPI_PNF_START_RESPONSE;
+    resp.error_code = NFAPI_MSG_OK;
+    nfapi_pnf_pnf_start_resp(config, &resp);
+    printf("[PNF] Sent NFAPI_PNF_START_RESP\n");
+  }
+  return 0;
+}
+
+int pnf_stop_request(nfapi_pnf_config_t* config, nfapi_pnf_stop_request_t* req)
+{
+  printf("[PNF] Received NFAPI_PNF_STOP_REQ\n");
+
+  nfapi_pnf_stop_response_t resp;
+  memset(&resp, 0, sizeof(resp));
+  resp.header.message_id = NFAPI_PNF_STOP_RESPONSE;
+  resp.error_code = NFAPI_MSG_OK;
+  nfapi_pnf_pnf_stop_resp(config, &resp);
+  printf("[PNF] Sent NFAPI_PNF_STOP_REQ\n");
+
+  return 0;
+}
+
+int param_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_param_request_t* req)
+{
+  printf("[PNF] Received NFAPI_PARAM_REQUEST phy_id:%d\n", req->header.phy_id);
+
+  //pnf_info* pnf = (pnf_info*)(config->user_data);
+
+  nfapi_param_response_t nfapi_resp;
+
+  pnf_info* pnf = (pnf_info*)(config->user_data);
+
+  memset(&nfapi_resp, 0, sizeof(nfapi_resp));
+  nfapi_resp.header.message_id = NFAPI_PARAM_RESPONSE;
+  nfapi_resp.header.phy_id = req->header.phy_id;
+  nfapi_resp.error_code = 0; // DJP - what value???
+
+  struct sockaddr_in pnf_p7_sockaddr;
+
+  pnf_p7_sockaddr.sin_addr.s_addr = inet_addr(pnf->phys[0].local_addr);
+  nfapi_resp.nfapi_config.p7_pnf_address_ipv4.tl.tag = NFAPI_NFAPI_P7_PNF_ADDRESS_IPV4_TAG;
+  memcpy(nfapi_resp.nfapi_config.p7_pnf_address_ipv4.address, &pnf_p7_sockaddr.sin_addr.s_addr, 4);
+  nfapi_resp.num_tlv++;
+
+  // P7 PNF Port
+  nfapi_resp.nfapi_config.p7_pnf_port.tl.tag = NFAPI_NFAPI_P7_PNF_PORT_TAG;
+  nfapi_resp.nfapi_config.p7_pnf_port.value = 32123; // DJP - hard code alert!!!! FIXME TODO
+  nfapi_resp.num_tlv++;
+
+  nfapi_pnf_param_resp(config, &nfapi_resp);
+
+  printf("[PNF] Sent NFAPI_PARAM_RESPONSE phy_id:%d number_of_tlvs:%u\n", req->header.phy_id, nfapi_resp.num_tlv);
+#if 0
+  //DJP
+  auto found = std::find_if(pnf->phys.begin(), pnf->phys.end(), [&](phy_info& item)
+      { return item.id == req->header.phy_id; });
+
+  if(found != pnf->phys.end())
+#endif
+  {
+    //DJP phy_info& phy_info = (*found);
+    //phy_info *phy_info = pnf->phys;
+
+  }
+#if 0
+  else
+  {
+    // did not find the phy
+  }
+#endif
+
+  printf("[PNF] param request .. exit\n");
+
+  return 0;
+}
+
+// From MAC config.c
+extern uint32_t from_earfcn(int eutra_bandP,uint32_t dl_earfcn);
+extern int32_t get_uldl_offset(int eutra_bandP);
+
+int config_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_config_request_t* req)
+{
+  printf("[PNF] Received NFAPI_CONFIG_REQ phy_id:%d\n", req->header.phy_id);
+
+  pnf_info* pnf = (pnf_info*)(config->user_data);
+  uint8_t num_tlv = 0;
+  struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
+  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
+
+#if 0
+  //DJP
+  auto found = std::find_if(pnf->phys.begin(), pnf->phys.end(), [&](phy_info& item)
+      { return item.id == req->header.phy_id; });
+
+  if(found != pnf->phys.end())
+  {
+    phy_info& phy_info = (*found);
+  }
+#endif
+  //DJP 
+  phy_info* phy_info = pnf->phys;
+
+  if(req->nfapi_config.timing_window.tl.tag == NFAPI_NFAPI_TIMING_WINDOW_TAG)
+  {
+    phy_info->timing_window = req->nfapi_config.timing_window.value;
+    printf("Phy_info:Timing window:%u NFAPI_CONFIG:timing_window:%u\n", phy_info->timing_window, req->nfapi_config.timing_window.value);
+    num_tlv++;
+  }
+
+  if(req->nfapi_config.timing_info_mode.tl.tag == NFAPI_NFAPI_TIMING_INFO_MODE_TAG)
+  {
+    printf("timing info mode:%d\n", req->nfapi_config.timing_info_mode.value);
+    phy_info->timing_info_mode = req->nfapi_config.timing_info_mode.value;
+    num_tlv++;
+  }
+  else 
+  {
+    phy_info->timing_info_mode = 0;
+    printf("NO timing info mode provided\n");
+  }
+
+  if(req->nfapi_config.timing_info_period.tl.tag == NFAPI_NFAPI_TIMING_INFO_PERIOD_TAG)
+  {
+    printf("timing info period provided value:%d\n", req->nfapi_config.timing_info_period.value);
+    phy_info->timing_info_period = req->nfapi_config.timing_info_period.value;
+    num_tlv++;
+  }
+  else 
+  {
+    phy_info->timing_info_period = 0;
+  }
+
+  if(req->rf_config.dl_channel_bandwidth.tl.tag == NFAPI_RF_CONFIG_DL_CHANNEL_BANDWIDTH_TAG)
+  {
+    phy_info->dl_channel_bw_support = req->rf_config.dl_channel_bandwidth.value;
+    fp->N_RB_DL = req->rf_config.dl_channel_bandwidth.value;
+    num_tlv++;
+    NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s() NFAPI_RF_CONFIG_DL_CHANNEL_BANDWIDTH_TAG N_RB_DL:%u\n", __FUNCTION__, fp->N_RB_DL);
+  }
+  else
+  {
+    NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s() Missing NFAPI_RF_CONFIG_DL_CHANNEL_BANDWIDTH_TAG\n", __FUNCTION__);
+  }
+
+  if(req->rf_config.ul_channel_bandwidth.tl.tag == NFAPI_RF_CONFIG_UL_CHANNEL_BANDWIDTH_TAG)
+  {
+    phy_info->ul_channel_bw_support = req->rf_config.ul_channel_bandwidth.value;
+    fp->N_RB_UL = req->rf_config.ul_channel_bandwidth.value;
+    num_tlv++;
+  }
+
+  if(req->nfapi_config.rf_bands.tl.tag == NFAPI_NFAPI_RF_BANDS_TAG)
+  {
+    pnf->rfs[0].band = req->nfapi_config.rf_bands.rf_band[0];
+    fp->eutra_band = req->nfapi_config.rf_bands.rf_band[0];
+    num_tlv++;
+  }
+
+  if(req->nfapi_config.earfcn.tl.tag == NFAPI_NFAPI_EARFCN_TAG)
+  {
+    fp->dl_CarrierFreq = from_earfcn(fp->eutra_band, req->nfapi_config.earfcn.value); // DJP - TODO FIXME - hard coded to first rf
+    fp->ul_CarrierFreq = fp->dl_CarrierFreq - (get_uldl_offset(fp->eutra_band) * 1e5);
+    num_tlv++;
+
+    NFAPI_TRACE(NFAPI_TRACE_INFO, "%s() earfcn:%u dl_carrierFreq:%u ul_CarrierFreq:%u band:%u N_RB_DL:%u\n", 
+        __FUNCTION__, req->nfapi_config.earfcn.value, fp->dl_CarrierFreq, fp->ul_CarrierFreq, pnf->rfs[0].band, fp->N_RB_DL);
+  }
+
+  if (req->subframe_config.duplex_mode.tl.tag == NFAPI_SUBFRAME_CONFIG_DUPLEX_MODE_TAG)
+  {
+    fp->frame_type = req->subframe_config.duplex_mode.value==0 ? TDD : FDD;
+    num_tlv++;
+    NFAPI_TRACE(NFAPI_TRACE_INFO, "%s() frame_type:%d\n", __FUNCTION__, fp->frame_type);
+  }
+  if (req->subframe_config.dl_cyclic_prefix_type.tl.tag == NFAPI_SUBFRAME_CONFIG_DL_CYCLIC_PREFIX_TYPE_TAG)
+  {
+    fp->Ncp = req->subframe_config.dl_cyclic_prefix_type.value;
+    num_tlv++;
+  }
+
+  if (req->subframe_config.ul_cyclic_prefix_type.tl.tag == NFAPI_SUBFRAME_CONFIG_UL_CYCLIC_PREFIX_TYPE_TAG)
+  {
+    fp->Ncp_UL = req->subframe_config.ul_cyclic_prefix_type.value;
+    num_tlv++;
+  }
+
+  fp->num_MBSFN_config = 0; // DJP - hard code alert
+
+  if (req->sch_config.physical_cell_id.tl.tag == NFAPI_SCH_CONFIG_PHYSICAL_CELL_ID_TAG)
+  {
+    fp->Nid_cell = req->sch_config.physical_cell_id.value;
+    fp->nushift = fp->Nid_cell%6;
+    num_tlv++;
+  }
+
+  if (req->rf_config.tx_antenna_ports.tl.tag == NFAPI_RF_CONFIG_TX_ANTENNA_PORTS_TAG)
+  {
+    fp->nb_antennas_tx = req->rf_config.tx_antenna_ports.value;
+    fp->nb_antenna_ports_eNB = 1;
+    num_tlv++;
+  }
+
+  if (req->rf_config.rx_antenna_ports.tl.tag == NFAPI_RF_CONFIG_RX_ANTENNA_PORTS_TAG)
+  {
+    fp->nb_antennas_rx = req->rf_config.rx_antenna_ports.value;
+    num_tlv++;
+  }
+
+  if (req->phich_config.phich_resource.tl.tag == NFAPI_PHICH_CONFIG_PHICH_RESOURCE_TAG)
+  {
+    fp->phich_config_common.phich_resource = req->phich_config.phich_resource.value;
+    num_tlv++;
+  }
+
+  if (req->phich_config.phich_duration.tl.tag == NFAPI_PHICH_CONFIG_PHICH_DURATION_TAG)
+  {
+    fp->phich_config_common.phich_duration = req->phich_config.phich_duration.value;
+    num_tlv++;
+  }
+
+  if (req->phich_config.phich_power_offset.tl.tag == NFAPI_PHICH_CONFIG_PHICH_POWER_OFFSET_TAG)
+  {
+    LOG_E(PHY, "%s() NFAPI_PHICH_CONFIG_PHICH_POWER_OFFSET_TAG tag:%d not supported\n", __FUNCTION__, req->phich_config.phich_power_offset.tl.tag);
+    //fp->phich_config_common.phich_power_offset = req->phich_config.
+    num_tlv++;
+  }
+
+  // UL RS Config
+  if (req->uplink_reference_signal_config.cyclic_shift_1_for_drms.tl.tag == NFAPI_UPLINK_REFERENCE_SIGNAL_CONFIG_CYCLIC_SHIFT_1_FOR_DRMS_TAG)
+  {
+    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift = req->uplink_reference_signal_config.cyclic_shift_1_for_drms.value;
+    num_tlv++;
+  }
+
+  if (req->uplink_reference_signal_config.uplink_rs_hopping.tl.tag == NFAPI_UPLINK_REFERENCE_SIGNAL_CONFIG_UPLINK_RS_HOPPING_TAG)
+  {
+    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled = req->uplink_reference_signal_config.uplink_rs_hopping.value;
+    num_tlv++;
+  }
+
+  if (req->uplink_reference_signal_config.group_assignment.tl.tag == NFAPI_UPLINK_REFERENCE_SIGNAL_CONFIG_GROUP_ASSIGNMENT_TAG)
+  {
+    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH = req->uplink_reference_signal_config.group_assignment.value;
+    num_tlv++;
+  }
+
+  if (req->pusch_config.hopping_mode.tl.tag == NFAPI_PUSCH_CONFIG_HOPPING_MODE_TAG) { }  // DJP - not being handled?
+
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = 0; // DJP - not being handled
+
+  if (req->prach_config.configuration_index.tl.tag == NFAPI_PRACH_CONFIG_CONFIGURATION_INDEX_TAG)
+  {
+    fp->prach_config_common.prach_ConfigInfo.prach_ConfigIndex=req->prach_config.configuration_index.value;
+    num_tlv++;
+  }
+
+  if (req->prach_config.root_sequence_index.tl.tag == NFAPI_PRACH_CONFIG_ROOT_SEQUENCE_INDEX_TAG)
+  {
+    fp->prach_config_common.rootSequenceIndex=req->prach_config.root_sequence_index.value;
+    num_tlv++;
+  }
+
+  if (req->prach_config.zero_correlation_zone_configuration.tl.tag == NFAPI_PRACH_CONFIG_ZERO_CORRELATION_ZONE_CONFIGURATION_TAG)
+  {
+    fp->prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig=req->prach_config.zero_correlation_zone_configuration.value;
+    num_tlv++;
+  }
+
+  if (req->prach_config.high_speed_flag.tl.tag == NFAPI_PRACH_CONFIG_HIGH_SPEED_FLAG_TAG)
+  {
+    fp->prach_config_common.prach_ConfigInfo.highSpeedFlag=req->prach_config.high_speed_flag.value;
+    num_tlv++;
+  }
+
+  if (req->prach_config.frequency_offset.tl.tag == NFAPI_PRACH_CONFIG_FREQUENCY_OFFSET_TAG)
+  {
+    fp->prach_config_common.prach_ConfigInfo.prach_FreqOffset=req->prach_config.frequency_offset.value;
+    num_tlv++;
+  }
+
+  printf("[PNF] CONFIG_REQUEST[num_tlv:%d] TLVs processed:%d\n", req->num_tlv, num_tlv);
+
+  printf("[PNF] Simulating PHY CONFIG - DJP\n");
+  PHY_Config_t phy_config;
+  phy_config.Mod_id = 0;
+  phy_config.CC_id=0;
+  phy_config.cfg = req;
+
+  phy_config_request(&phy_config);
+
+  dump_frame_parms(fp);
+
+  phy_info->remote_port = req->nfapi_config.p7_vnf_port.value;
+
+  struct sockaddr_in vnf_p7_sockaddr;
+  memcpy(&vnf_p7_sockaddr.sin_addr.s_addr, &(req->nfapi_config.p7_vnf_address_ipv4.address[0]), 4);
+  phy_info->remote_addr = inet_ntoa(vnf_p7_sockaddr.sin_addr);
+
+  printf("[PNF] %d vnf p7 %s:%d timing %d %d %d\n", phy_info->id, phy_info->remote_addr, phy_info->remote_port, 
+      phy_info->timing_window, phy_info->timing_info_mode, phy_info->timing_info_period);
+
+  nfapi_config_response_t nfapi_resp;
+  memset(&nfapi_resp, 0, sizeof(nfapi_resp));
+  nfapi_resp.header.message_id = NFAPI_CONFIG_RESPONSE;
+  nfapi_resp.header.phy_id = phy_info->id;
+  nfapi_resp.error_code = 0; // DJP - some value resp->error_code;
+  nfapi_pnf_config_resp(config, &nfapi_resp);
+  printf("[PNF] Sent NFAPI_CONFIG_RESPONSE phy_id:%d\n", phy_info->id);
+
+  return 0;
+}
+
+nfapi_p7_message_header_t* pnf_phy_allocate_p7_vendor_ext(uint16_t message_id, uint16_t* msg_size)
+{
+  if(message_id == P7_VENDOR_EXT_REQ)
+  {
+    (*msg_size) = sizeof(vendor_ext_p7_req);
+    return (nfapi_p7_message_header_t*)malloc(sizeof(vendor_ext_p7_req));
+  }
+
+  return 0;
+}
+
+void pnf_phy_deallocate_p7_vendor_ext(nfapi_p7_message_header_t* header)
+{
+  free(header);
+}
+
+int pnf_phy_hi_dci0_req(nfapi_pnf_p7_config_t* pnf_p7, nfapi_hi_dci0_request_t* req)
+{
+  LOG_D(PHY,"[PNF] hi dci0 request sfn_sf:%d dci:%d hi:%d\n", NFAPI_SFNSF2DEC(req->sfn_sf), req->hi_dci0_request_body.number_of_dci, req->hi_dci0_request_body.number_of_hi);
+
+  //phy_info* phy = (phy_info*)(pnf_p7->user_data);
+
+  struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
+  eNB_rxtx_proc_t *proc = &eNB->proc.proc_rxtx[0];
+
+  for (int i=0; i<req->hi_dci0_request_body.number_of_dci + req->hi_dci0_request_body.number_of_hi; i++)
+  {
+    //LOG_D(PHY,"[PNF] HI_DCI0_REQ sfn_sf:%d PDU[%d]\n", NFAPI_SFNSF2DEC(req->sfn_sf), i);
+
+    if (req->hi_dci0_request_body.hi_dci0_pdu_list[i].pdu_type == NFAPI_HI_DCI0_DCI_PDU_TYPE)
+    {
+      LOG_D(PHY,"[PNF] HI_DCI0_REQ sfn_sf:%d PDU[%d] - NFAPI_HI_DCI0_DCI_PDU_TYPE\n", NFAPI_SFNSF2DEC(req->sfn_sf), i);
+
+      nfapi_hi_dci0_request_pdu_t *hi_dci0_req_pdu = &req->hi_dci0_request_body.hi_dci0_pdu_list[i];
+
+      handle_nfapi_hi_dci0_dci_pdu(eNB,proc,hi_dci0_req_pdu);
+
+      eNB->pdcch_vars[NFAPI_SFNSF2SF(req->sfn_sf)&1].num_dci++;
+    }
+    else if (req->hi_dci0_request_body.hi_dci0_pdu_list[i].pdu_type == NFAPI_HI_DCI0_HI_PDU_TYPE)
+    {
+      LOG_D(PHY,"[PNF] HI_DCI0_REQ sfn_sf:%d PDU[%d] - NFAPI_HI_DCI0_HI_PDU_TYPE\n", NFAPI_SFNSF2DEC(req->sfn_sf), i);
+
+      nfapi_hi_dci0_request_pdu_t *hi_dci0_req_pdu = &req->hi_dci0_request_body.hi_dci0_pdu_list[i];
+
+      handle_nfapi_hi_dci0_hi_pdu(eNB, proc, hi_dci0_req_pdu);
+    }
+    else
+    {
+      LOG_E(PHY,"[PNF] HI_DCI0_REQ sfn_sf:%d PDU[%d] - unknown pdu type:%d\n", NFAPI_SFNSF2DEC(req->sfn_sf), i, req->hi_dci0_request_body.hi_dci0_pdu_list[i].pdu_type);
+    }
+  }
+
+  return 0;
+}
+
+int pnf_phy_dl_config_req(nfapi_pnf_p7_config_t* pnf_p7, nfapi_dl_config_request_t* req)
+{
+  LOG_D(PHY,"[PNF] %s() sfn_sf:%d pdcch:%u dl_cfg[dci:%u pdus:%d pdsch_rnti:%d] pcfich:%u\n", __FUNCTION__,NFAPI_SFNSF2DEC(req->sfn_sf), req->dl_config_request_body.number_pdcch_ofdm_symbols, req->dl_config_request_body.number_dci, req->dl_config_request_body.number_pdu, req->dl_config_request_body.number_pdsch_rnti, req->dl_config_request_body.transmission_power_pcfich);
+
+  if (RC.ru == 0)
+  {
+    return -1;
+  }
+
+  if (RC.eNB == 0)
+  {
+    return -2;
+  }
+
+  if (RC.eNB[0][0] == 0)
+  {
+    return -3;
+  }
+
+  if (sync_var != 0)
+  { 
+    NFAPI_TRACE(NFAPI_TRACE_INFO, "%s() Main system not up - is this a dummy subframe?\n", __FUNCTION__);
+    return -4;
+  }
+
+  int sfn = NFAPI_SFNSF2SFN(req->sfn_sf);
+  int sf = NFAPI_SFNSF2SF(req->sfn_sf);
+
+  struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
+  eNB_rxtx_proc_t *proc = &eNB->proc.proc_rxtx[0];
+  nfapi_dl_config_request_pdu_t* dl_config_pdu_list = req->dl_config_request_body.dl_config_pdu_list;
+  LTE_eNB_PDCCH *pdcch_vars = &eNB->pdcch_vars[sf&1];
+
+  pdcch_vars->num_pdcch_symbols = req->dl_config_request_body.number_pdcch_ofdm_symbols;
+  pdcch_vars->num_dci = 0;
+
+  //NFAPI_TRACE(NFAPI_TRACE_INFO, "%s() TX:%d/%d RX:%d/%d sfn_sf:%d DCI:%d PDU:%d\n", __FUNCTION__, proc->frame_tx, proc->subframe_tx, proc->frame_rx, proc->subframe_rx, NFAPI_SFNSF2DEC(req->sfn_sf), req->dl_config_request_body.number_dci, req->dl_config_request_body.number_pdu);
+
+  for (int i=0;i<req->dl_config_request_body.number_pdu;i++)
+  {
+    //NFAPI_TRACE(NFAPI_TRACE_INFO, "%s() sfn/sf:%d PDU[%d] size:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(req->sfn_sf), i, dl_config_pdu_list[i].pdu_size);
+
+    if (dl_config_pdu_list[i].pdu_type == NFAPI_DL_CONFIG_DCI_DL_PDU_TYPE)
+    {
+      handle_nfapi_dci_dl_pdu(eNB,proc,&dl_config_pdu_list[i]);
+
+      pdcch_vars->num_dci++; // Is actually number of DCI PDUs
+
+      //NFAPI_TRACE(NFAPI_TRACE_INFO, "%s() pdcch_vars->num_dci:%d\n", __FUNCTION__, pdcch_vars->num_dci);
+    }
+    else if (dl_config_pdu_list[i].pdu_type == NFAPI_DL_CONFIG_BCH_PDU_TYPE)
+    {
+      nfapi_dl_config_bch_pdu *bch_pdu = &dl_config_pdu_list[i].bch_pdu;
+      uint16_t pdu_index = bch_pdu->bch_pdu_rel8.pdu_index;
+
+      if (tx_request_pdu[sfn][sf][pdu_index] != NULL)
+      {
+        uint8_t *sdu = malloc(tx_request_pdu[sfn][sf][pdu_index]->segments[0].segment_length);
+
+        memcpy(sdu, tx_request_pdu[sfn][sf][pdu_index]->segments[0].segment_data, tx_request_pdu[sfn][sf][pdu_index]->segments[0].segment_length);
+
+        //NFAPI_TRACE(NFAPI_TRACE_INFO, "%s() PDU:%d BCH: pdu_index:%u pdu_length:%d sdu_length:%d BCH_SDU:%x,%x,%x\n", __FUNCTION__, i, pdu_index, bch_pdu->bch_pdu_rel8.length, tx_request_pdu[sfn][sf][pdu_index]->segments[0].segment_length, sdu[0], sdu[1], sdu[2]);
+
+        handle_nfapi_bch_pdu(eNB, proc, &dl_config_pdu_list[i], sdu);
+
+        eNB->pbch_configured=1;
+      }
+      else
+      {
+        NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s() BCH NULL TX PDU SFN/SF:%d PDU_INDEX:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(req->sfn_sf), pdu_index); 
+      }
+    }
+    else if (dl_config_pdu_list[i].pdu_type == NFAPI_DL_CONFIG_DLSCH_PDU_TYPE)
+    {
+      nfapi_dl_config_dlsch_pdu *dlsch_pdu = &dl_config_pdu_list[i].dlsch_pdu;
+      nfapi_dl_config_dlsch_pdu_rel8_t *rel8_pdu = &dlsch_pdu->dlsch_pdu_rel8;
+      nfapi_tx_request_pdu_t *tx_pdu = tx_request_pdu[sfn][sf][rel8_pdu->pdu_index];
+
+      if (tx_pdu != NULL)
+      {
+        uint8_t *dlsch_sdu = malloc(tx_pdu->segments[0].segment_length);
+
+// **********************************************************************
+// THIS IS CREATING AN INTENTIONAL LEAK - I think...
+//
+// nFAPI won't be managing dlsch_sdu
+//
+// not sure about the stack, but it does seem to allow it to stay up!!!
+//
+// I THINK I NEED TO FIX THIS - unless it IS getting freed by the stack
+//
+// **********************************************************************
+      memcpy(dlsch_sdu, tx_pdu->segments[0].segment_data, tx_pdu->segments[0].segment_length);
+
+      //NFAPI_TRACE(NFAPI_TRACE_INFO, "%s() DLSCH:pdu_index:%d handle_nfapi_dlsch_pdu(eNB, proc_rxtx, dlsch_pdu, transport_blocks:%d sdu:%p) eNB->pdcch_vars[proc->subframe_tx & 1].num_pdcch_symbols:%d\n", __FUNCTION__, rel8_pdu->pdu_index, rel8_pdu->transport_blocks, dlsch_sdu, eNB->pdcch_vars[proc->subframe_tx & 1].num_pdcch_symbols);
+
+      handle_nfapi_dlsch_pdu(
+          eNB,
+          &eNB->proc.proc_rxtx[0],
+          &dl_config_pdu_list[i],
+          rel8_pdu->transport_blocks-1,
+          dlsch_sdu);
+      }
+      else
+      {
+        NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s() DLSCH NULL TX PDU SFN/SF:%d PDU_INDEX:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(req->sfn_sf), rel8_pdu->pdu_index);
+      }
+    }
+    else
+    {
+      NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s() UNKNOWN:%d\n", __FUNCTION__, dl_config_pdu_list[i].pdu_type);
+    }
+  }
+
+  if(req->vendor_extension)
+    free(req->vendor_extension);
+
+  return 0;
+}
+
+int  pnf_phy_tx_req(nfapi_pnf_p7_config_t* pnf_p7, nfapi_tx_request_t* req)
+{
+  uint16_t sfn = NFAPI_SFNSF2SFN(req->sfn_sf);
+  uint16_t sf = NFAPI_SFNSF2SF(req->sfn_sf);
+
+  if (req->tx_request_body.number_of_pdus==0)
+    LOG_D(PHY,"%s() SFN/SF:%d%d PDUs:%d\n", __FUNCTION__, sfn, sf, req->tx_request_body.number_of_pdus);
+
+  if (req->tx_request_body.tl.tag==NFAPI_TX_REQUEST_BODY_TAG)
+  {
+    for (int i=0; i<req->tx_request_body.number_of_pdus; i++)
+    {
+      LOG_D(PHY,"%s() SFN/SF:%d%d number_of_pdus:%d [PDU:%d] pdu_length:%d pdu_index:%d num_segments:%d\n",
+          __FUNCTION__,
+          sfn, sf,
+          req->tx_request_body.number_of_pdus,
+          i,
+          req->tx_request_body.tx_pdu_list[i].pdu_length,
+          req->tx_request_body.tx_pdu_list[i].pdu_index,
+          req->tx_request_body.tx_pdu_list[i].num_segments
+          );
+
+      tx_request_pdu[sfn][sf][i] = &req->tx_request_body.tx_pdu_list[i];
+    }
+  }
+
+  return 0;
+}
+
+int pnf_phy_ul_config_req(nfapi_pnf_p7_config_t* pnf_p7, nfapi_ul_config_request_t* req)
+{
+  if (0)LOG_D(PHY,"[PNF] UL_CONFIG_REQ %s() sfn_sf:%d pdu:%d rach_prach_frequency_resources:%d srs_present:%u\n", 
+      __FUNCTION__,
+      NFAPI_SFNSF2DEC(req->sfn_sf), 
+      req->ul_config_request_body.number_of_pdus,
+      req->ul_config_request_body.rach_prach_frequency_resources,
+      req->ul_config_request_body.srs_present
+      );
+
+  if (RC.ru == 0)
+  {
+    return -1;
+  }
+
+  if (RC.eNB == 0)
+  {
+    return -2;
+  }
+
+  if (RC.eNB[0][0] == 0)
+  {
+    return -3;
+  }
+
+  if (sync_var != 0)
+  { 
+    NFAPI_TRACE(NFAPI_TRACE_INFO, "%s() Main system not up - is this a dummy subframe?\n", __FUNCTION__);
+    return -4;
+  }
+
+  uint16_t curr_sfn = NFAPI_SFNSF2SFN(req->sfn_sf);
+  uint16_t curr_sf = NFAPI_SFNSF2SF(req->sfn_sf);
+
+  struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
+  eNB_rxtx_proc_t *proc = &eNB->proc.proc_rxtx[0];
+  nfapi_ul_config_request_pdu_t* ul_config_pdu_list = req->ul_config_request_body.ul_config_pdu_list;
+
+  for (int i=0;i<req->ul_config_request_body.number_of_pdus;i++)
+  {
+    //LOG_D(PHY, "%s() sfn/sf:%d PDU[%d] size:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(req->sfn_sf), i, ul_config_pdu_list[i].pdu_size);
+
+    if (
+        ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_ULSCH_PDU_TYPE ||
+        ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_ULSCH_HARQ_PDU_TYPE ||
+        ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_ULSCH_CQI_RI_PDU_TYPE ||
+        ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_ULSCH_CQI_HARQ_RI_PDU_TYPE ||
+        ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_UCI_HARQ_PDU_TYPE ||
+        ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_UCI_SR_PDU_TYPE ||
+        ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_UCI_SR_HARQ_PDU_TYPE
+       )
+    {
+      //LOG_D(PHY, "%s() handle_nfapi_ul_pdu() for PDU:%d\n", __FUNCTION__, i);
+
+      handle_nfapi_ul_pdu(eNB,proc,&ul_config_pdu_list[i],curr_sfn,curr_sf,req->ul_config_request_body.srs_present);
+    }
+    else
+    {
+      NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s() PDU:%i UNKNOWN type :%d\n", __FUNCTION__, i, ul_config_pdu_list[i].pdu_type);
+    }
+  }
+
+  return 0;
+}
+
+int pnf_phy_lbt_dl_config_req(nfapi_pnf_p7_config_t* config, nfapi_lbt_dl_config_request_t* req)
+{
+  //printf("[PNF] lbt dl config request\n");
+  return 0;
+}
+
+int pnf_phy_vendor_ext(nfapi_pnf_p7_config_t* config, nfapi_p7_message_header_t* msg)
+{
+  if(msg->message_id == P7_VENDOR_EXT_REQ)
+  {
+    //vendor_ext_p7_req* req = (vendor_ext_p7_req*)msg;
+    //printf("[PNF] vendor request (1:%d 2:%d)\n", req->dummy1, req->dummy2);
+  }
+  else
+  {
+    printf("[PNF] unknown vendor ext\n");
+  }
+  return 0;
+}
+
+int pnf_phy_pack_p7_vendor_extension(nfapi_p7_message_header_t* header, uint8_t** ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* codex)
+{
+  //NFAPI_TRACE(NFAPI_TRACE_INFO, "%s\n", __FUNCTION__);
+  if(header->message_id == P7_VENDOR_EXT_IND)
+  {
+    vendor_ext_p7_ind* ind = (vendor_ext_p7_ind*)(header);
+    if(!push16(ind->error_code, ppWritePackedMsg, end))
+      return 0;
+
+    return 1;
+  }
+  return -1;
+}
+
+int pnf_phy_unpack_p7_vendor_extension(nfapi_p7_message_header_t* header, uint8_t** ppReadPackedMessage, uint8_t *end, nfapi_p7_codec_config_t* codec)
+{
+  if(header->message_id == P7_VENDOR_EXT_REQ)
+  {
+    //NFAPI_TRACE(NFAPI_TRACE_INFO, "%s\n", __FUNCTION__);
+    vendor_ext_p7_req* req = (vendor_ext_p7_req*)(header);
+    if(!(pull16(ppReadPackedMessage, &req->dummy1, end) &&
+          pull16(ppReadPackedMessage, &req->dummy2, end)))
+      return 0;
+    return 1;
+  }
+  return -1;
+}
+
+int pnf_phy_unpack_vendor_extension_tlv(nfapi_tl_t* tl, uint8_t **ppReadPackedMessage, uint8_t* end, void** ve, nfapi_p7_codec_config_t* config)
+{
+  //NFAPI_TRACE(NFAPI_TRACE_INFO, "pnf_phy_unpack_vendor_extension_tlv\n");
+
+  switch(tl->tag)
+  {
+    case VENDOR_EXT_TLV_1_TAG:
+      *ve = malloc(sizeof(vendor_ext_tlv_1));
+      if(!pull32(ppReadPackedMessage, &((vendor_ext_tlv_1*)(*ve))->dummy, end))
+	return 0;
+
+      return 1;
+      break;
+  }
+
+  return -1;
+}
+
+int pnf_phy_pack_vendor_extention_tlv(void* ve, uint8_t **ppWritePackedMsg, uint8_t* end, nfapi_p7_codec_config_t* config)
+{
+  //printf("%s\n", __FUNCTION__);
+  (void)ve;
+  (void)ppWritePackedMsg;
+  return -1;
+}
+
+int pnf_sim_unpack_vendor_extension_tlv(nfapi_tl_t* tl, uint8_t **ppReadPackedMessage, uint8_t *end, void** ve, nfapi_p4_p5_codec_config_t* config)
+{
+  //NFAPI_TRACE(NFAPI_TRACE_INFO, "pnf_sim_unpack_vendor_extension_tlv\n");
+
+  switch(tl->tag)
+  {
+    case VENDOR_EXT_TLV_2_TAG:
+      *ve = malloc(sizeof(vendor_ext_tlv_2));
+      if(!pull32(ppReadPackedMessage, &((vendor_ext_tlv_2*)(*ve))->dummy, end))
+	return 0;
+
+      return 1;
+      break;
+  }
+
+  return -1;
+}
+
+int pnf_sim_pack_vendor_extention_tlv(void* ve, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t* config)
+{
+  //printf("%s\n", __FUNCTION__);
+  (void)ve;
+  (void)ppWritePackedMsg;
+  return -1;
+}
+
+nfapi_dl_config_request_t dummy_dl_config_req;
+nfapi_tx_request_t dummy_tx_req;
+
+nfapi_pnf_p7_subframe_buffer_t dummy_subframe;
+
+int start_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_start_request_t* req)
+{
+  printf("[PNF] Received NFAPI_START_REQ phy_id:%d\n", req->header.phy_id);
+
+  nfapi_set_trace_level(NFAPI_TRACE_INFO);
+
+  pnf_info* pnf = (pnf_info*)(config->user_data);
+
+#if 0
+  //DJP
+  auto found = std::find_if(pnf->phys.begin(), pnf->phys.end(), [&](phy_info& item)
+      { return item.id == req->header.phy_id; });
+
+  if(found != pnf->phys.end())
+#endif
+  {
+    //DJP phy_info& phy_info = (*found);
+    phy_info* phy_info = pnf->phys;
+
+    nfapi_pnf_p7_config_t* p7_config = nfapi_pnf_p7_config_create();
+
+    p7_config->phy_id = phy->phy_id;
+
+    p7_config->remote_p7_port = phy_info->remote_port;
+    p7_config->remote_p7_addr = phy_info->remote_addr;
+    p7_config->local_p7_port = 32123; // DJP - good grief cannot seem to get the right answer phy_info->local_port;
+    //DJP p7_config->local_p7_addr = (char*)phy_info->local_addr.c_str();
+    p7_config->local_p7_addr = phy_info->local_addr;
+
+    printf("[PNF] P7 remote:%s:%d local:%s:%d\n", p7_config->remote_p7_addr, p7_config->remote_p7_port, p7_config->local_p7_addr, p7_config->local_p7_port);
+
+    p7_config->user_data = phy_info;
+
+    p7_config->malloc = &pnf_allocate;
+    p7_config->free = &pnf_deallocate;
+    p7_config->codec_config.allocate = &pnf_allocate;
+    p7_config->codec_config.deallocate = &pnf_deallocate;
+
+    p7_config->trace = &pnf_nfapi_trace;
+
+    phy->user_data = p7_config;
+
+    p7_config->subframe_buffer_size = phy_info->timing_window;
+    printf("subframe_buffer_size configured using phy_info->timing_window:%d\n", phy_info->timing_window);
+    if(phy_info->timing_info_mode & 0x1)
+    {
+      p7_config->timing_info_mode_periodic = 1;
+      p7_config->timing_info_period = phy_info->timing_info_period;
+    }
+
+    if(phy_info->timing_info_mode & 0x2)
+    {
+      p7_config->timing_info_mode_aperiodic = 1;
+    }
+
+    if (nfapi_mode==3) {
+    	p7_config->dl_config_req = &memcpy_dl_config_req;
+    	p7_config->ul_config_req = &memcpy_ul_config_req;
+    	p7_config->hi_dci0_req = &memcpy_hi_dci0_req;
+    	p7_config->tx_req = &memcpy_tx_req;
+    }
+    else {
+    	p7_config->dl_config_req = &pnf_phy_dl_config_req;
+    	p7_config->ul_config_req = &pnf_phy_ul_config_req;
+    	p7_config->hi_dci0_req = &pnf_phy_hi_dci0_req;
+    	p7_config->tx_req = &pnf_phy_tx_req;
+    }
+    p7_config->lbt_dl_config_req = &pnf_phy_lbt_dl_config_req;
+
+    memset(&dummy_dl_config_req, 0, sizeof(dummy_dl_config_req));
+    dummy_dl_config_req.dl_config_request_body.tl.tag=NFAPI_DL_CONFIG_REQUEST_BODY_TAG;
+    dummy_dl_config_req.dl_config_request_body.number_pdcch_ofdm_symbols=1;
+    dummy_dl_config_req.dl_config_request_body.number_dci=0;
+    dummy_dl_config_req.dl_config_request_body.number_pdu=0;
+    dummy_dl_config_req.dl_config_request_body.number_pdsch_rnti=0;
+    dummy_dl_config_req.dl_config_request_body.transmission_power_pcfich=6000;
+    dummy_dl_config_req.dl_config_request_body.dl_config_pdu_list=0;
+
+    memset(&dummy_tx_req, 0, sizeof(dummy_tx_req));
+    dummy_tx_req.tx_request_body.number_of_pdus=0;
+    dummy_tx_req.tx_request_body.tl.tag=NFAPI_TX_REQUEST_BODY_TAG;
+
+    dummy_subframe.dl_config_req = &dummy_dl_config_req;
+    dummy_subframe.tx_req = 0;//&dummy_tx_req;
+
+    dummy_subframe.ul_config_req=0;
+    dummy_subframe.hi_dci0_req=0;
+    dummy_subframe.lbt_dl_config_req=0;
+
+    p7_config->dummy_subframe = dummy_subframe;
+
+    p7_config->vendor_ext = &pnf_phy_vendor_ext;
+
+    p7_config->allocate_p7_vendor_ext = &pnf_phy_allocate_p7_vendor_ext;
+    p7_config->deallocate_p7_vendor_ext = &pnf_phy_deallocate_p7_vendor_ext;
+
+    p7_config->codec_config.unpack_p7_vendor_extension = &pnf_phy_unpack_p7_vendor_extension;
+    p7_config->codec_config.pack_p7_vendor_extension = &pnf_phy_pack_p7_vendor_extension;
+    p7_config->codec_config.unpack_vendor_extension_tlv = &pnf_phy_unpack_vendor_extension_tlv;
+    p7_config->codec_config.pack_vendor_extension_tlv = &pnf_phy_pack_vendor_extention_tlv;
+
+    NFAPI_TRACE(NFAPI_TRACE_INFO, "[PNF] Creating P7 thread %s\n", __FUNCTION__);
+    pthread_t p7_thread;
+    pthread_create(&p7_thread, NULL, &pnf_p7_thread_start, p7_config);
+
+    //((pnf_phy_user_data_t*)(phy_info->fapi->user_data))->p7_config = p7_config;
+
+    NFAPI_TRACE(NFAPI_TRACE_INFO, "[PNF] Calling l1_north_init_eNB() %s\n", __FUNCTION__);
+    l1_north_init_eNB();
+
+    NFAPI_TRACE(NFAPI_TRACE_INFO, "[PNF] DJP - HACK - Set p7_config global ready for subframe ind%s\n", __FUNCTION__);
+    p7_config_g = p7_config;
+
+    // Need to wait for main thread to create RU structures
+    while(config_sync_var<0)
+    {
+      usleep(5000000);
+      printf("[PNF] waiting for OAI to be configured (eNB/RU)\n");
+    }
+    printf("[PNF] OAI eNB/RU configured\n");
+
+    //printf("[PNF] About to call phy_init_RU() for RC.ru[0]:%p\n", RC.ru[0]);
+    //phy_init_RU(RC.ru[0]);
+
+    printf("[PNF] About to call init_eNB_afterRU()\n");
+
+    // Panos: Instead
+    /*if (nfapi_mode == 3) {
+    	init_UE_stub(1,0,uecap_xer_in);
+    }*/
+    //else{
+    if (nfapi_mode != 3) {
+    	// Panos
+    	init_eNB_afterRU();
+    }
+
+    // Signal to main thread that it can carry on - otherwise RU will startup too quickly and it is not initialised
+    {
+      pthread_mutex_lock(&nfapi_sync_mutex);
+      nfapi_sync_var=0;
+      pthread_cond_broadcast(&nfapi_sync_cond);
+      pthread_mutex_unlock(&nfapi_sync_mutex);
+    }
+
+    while(sync_var<0)
+    {
+      usleep(5000000);
+      printf("[PNF] waiting for OAI to be started\n");
+    }
+
+    printf("[PNF] Sending PNF_START_RESP\n");
+    nfapi_send_pnf_start_resp(config, p7_config->phy_id);
+
+    printf("[PNF] Sending first P7 subframe ind\n");
+    nfapi_pnf_p7_subframe_ind(p7_config, p7_config->phy_id, 0); // DJP - SFN_SF set to zero - correct???
+    printf("[PNF] Sent first P7 subframe ind\n");
+  }
+
+  return 0;
+}
+
+int measurement_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_measurement_request_t* req)
+{
+  nfapi_measurement_response_t resp;
+  memset(&resp, 0, sizeof(resp));
+  resp.header.message_id = NFAPI_MEASUREMENT_RESPONSE;
+  resp.header.phy_id = req->header.phy_id;
+  resp.error_code = NFAPI_MSG_OK;
+  nfapi_pnf_measurement_resp(config, &resp);
+  return 0;
+}
+
+int rssi_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_rssi_request_t* req)
+{
+  nfapi_rssi_response_t resp;
+  memset(&resp, 0, sizeof(resp));
+  resp.header.message_id = NFAPI_RSSI_RESPONSE;
+  resp.header.phy_id = req->header.phy_id;
+  resp.error_code = NFAPI_P4_MSG_OK;
+  nfapi_pnf_rssi_resp(config, &resp);
+
+  nfapi_rssi_indication_t ind;
+  memset(&ind, 0, sizeof(ind));
+  ind.header.message_id = NFAPI_RSSI_INDICATION;
+  ind.header.phy_id = req->header.phy_id;
+  ind.error_code = NFAPI_P4_MSG_OK;
+  ind.rssi_indication_body.tl.tag = NFAPI_RSSI_INDICATION_TAG;
+  ind.rssi_indication_body.number_of_rssi = 1;
+  ind.rssi_indication_body.rssi[0] = -42;
+  nfapi_pnf_rssi_ind(config, &ind);
+  return 0;
+}
+
+int cell_search_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_cell_search_request_t* req)
+{
+  nfapi_cell_search_response_t resp;
+  memset(&resp, 0, sizeof(resp));
+  resp.header.message_id = NFAPI_CELL_SEARCH_RESPONSE;
+  resp.header.phy_id = req->header.phy_id;
+  resp.error_code = NFAPI_P4_MSG_OK;
+  nfapi_pnf_cell_search_resp(config, &resp);
+
+  nfapi_cell_search_indication_t ind;
+  memset(&ind, 0, sizeof(ind));
+  ind.header.message_id = NFAPI_CELL_SEARCH_INDICATION;
+  ind.header.phy_id = req->header.phy_id;
+  ind.error_code = NFAPI_P4_MSG_OK;
+
+  switch(req->rat_type)
+  {
+    case NFAPI_RAT_TYPE_LTE:
+      {
+        ind.lte_cell_search_indication.tl.tag = NFAPI_LTE_CELL_SEARCH_INDICATION_TAG;
+        ind.lte_cell_search_indication.number_of_lte_cells_found = 1;
+        ind.lte_cell_search_indication.lte_found_cells[0].pci = 123;
+        ind.lte_cell_search_indication.lte_found_cells[0].rsrp = 123;
+        ind.lte_cell_search_indication.lte_found_cells[0].rsrq = 123;
+        ind.lte_cell_search_indication.lte_found_cells[0].frequency_offset = 123;
+      }
+      break;
+    case NFAPI_RAT_TYPE_UTRAN:
+      {
+        ind.utran_cell_search_indication.tl.tag = NFAPI_UTRAN_CELL_SEARCH_INDICATION_TAG;
+        ind.utran_cell_search_indication.number_of_utran_cells_found = 1;
+        ind.utran_cell_search_indication.utran_found_cells[0].psc = 89;
+        ind.utran_cell_search_indication.utran_found_cells[0].rscp = 89;
+        ind.utran_cell_search_indication.utran_found_cells[0].ecno = 89;
+        ind.utran_cell_search_indication.utran_found_cells[0].frequency_offset = -89;
+
+      }
+      break;
+    case NFAPI_RAT_TYPE_GERAN:
+      {
+        ind.geran_cell_search_indication.tl.tag = NFAPI_GERAN_CELL_SEARCH_INDICATION_TAG;
+        ind.geran_cell_search_indication.number_of_gsm_cells_found = 1;
+        ind.geran_cell_search_indication.gsm_found_cells[0].bsic = 23;
+        ind.geran_cell_search_indication.gsm_found_cells[0].rxlev = 23;
+        ind.geran_cell_search_indication.gsm_found_cells[0].rxqual = 23;
+        ind.geran_cell_search_indication.gsm_found_cells[0].frequency_offset = -23;
+        ind.geran_cell_search_indication.gsm_found_cells[0].sfn_offset = 230;
+
+      }
+      break;
+  }
+
+  ind.pnf_cell_search_state.tl.tag = NFAPI_PNF_CELL_SEARCH_STATE_TAG;
+  ind.pnf_cell_search_state.length = 3;
+
+  nfapi_pnf_cell_search_ind(config, &ind);	
+
+  return 0;
+}
+
+int broadcast_detect_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_broadcast_detect_request_t* req)
+{
+  nfapi_broadcast_detect_response_t resp;
+  memset(&resp, 0, sizeof(resp));
+  resp.header.message_id = NFAPI_BROADCAST_DETECT_RESPONSE;
+  resp.header.phy_id = req->header.phy_id;
+  resp.error_code = NFAPI_P4_MSG_OK;
+  nfapi_pnf_broadcast_detect_resp(config, &resp);
+
+  nfapi_broadcast_detect_indication_t ind;
+  memset(&ind, 0, sizeof(ind));
+  ind.header.message_id = NFAPI_BROADCAST_DETECT_INDICATION;
+  ind.header.phy_id = req->header.phy_id;
+  ind.error_code = NFAPI_P4_MSG_OK;
+
+  switch(req->rat_type)
+  {
+    case NFAPI_RAT_TYPE_LTE:
+      {
+        ind.lte_broadcast_detect_indication.tl.tag = NFAPI_LTE_BROADCAST_DETECT_INDICATION_TAG;
+        ind.lte_broadcast_detect_indication.number_of_tx_antenna = 1;
+        ind.lte_broadcast_detect_indication.mib_length = 4;
+        //ind.lte_broadcast_detect_indication.mib...
+        ind.lte_broadcast_detect_indication.sfn_offset = 77;
+
+      }
+      break;
+    case NFAPI_RAT_TYPE_UTRAN:
+      {
+        ind.utran_broadcast_detect_indication.tl.tag = NFAPI_UTRAN_BROADCAST_DETECT_INDICATION_TAG;
+        ind.utran_broadcast_detect_indication.mib_length = 4;
+        //ind.utran_broadcast_detect_indication.mib...
+        // ind.utran_broadcast_detect_indication.sfn_offset; DJP - nonsense line
+
+      }
+      break;
+  }
+
+  ind.pnf_cell_broadcast_state.tl.tag = NFAPI_PNF_CELL_BROADCAST_STATE_TAG;
+  ind.pnf_cell_broadcast_state.length = 3;
+
+  nfapi_pnf_broadcast_detect_ind(config, &ind);	
+
+  return 0;
+}
+
+int system_information_schedule_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_system_information_schedule_request_t* req)
+{
+  nfapi_system_information_schedule_response_t resp;
+  memset(&resp, 0, sizeof(resp));
+  resp.header.message_id = NFAPI_SYSTEM_INFORMATION_SCHEDULE_RESPONSE;
+  resp.header.phy_id = req->header.phy_id;
+  resp.error_code = NFAPI_P4_MSG_OK;
+  nfapi_pnf_system_information_schedule_resp(config, &resp);
+
+  nfapi_system_information_schedule_indication_t ind;
+  memset(&ind, 0, sizeof(ind));
+  ind.header.message_id = NFAPI_SYSTEM_INFORMATION_SCHEDULE_INDICATION;
+  ind.header.phy_id = req->header.phy_id;
+  ind.error_code = NFAPI_P4_MSG_OK;
+
+  ind.lte_system_information_indication.tl.tag = NFAPI_LTE_SYSTEM_INFORMATION_INDICATION_TAG;
+  ind.lte_system_information_indication.sib_type = 3;
+  ind.lte_system_information_indication.sib_length = 5;
+  //ind.lte_system_information_indication.sib...
+
+  nfapi_pnf_system_information_schedule_ind(config, &ind);		
+
+  return 0;
+}
+
+int system_information_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_system_information_request_t* req)
+{
+  nfapi_system_information_response_t resp;
+  memset(&resp, 0, sizeof(resp));
+  resp.header.message_id = NFAPI_SYSTEM_INFORMATION_RESPONSE;
+  resp.header.phy_id = req->header.phy_id;
+  resp.error_code = NFAPI_P4_MSG_OK;
+  nfapi_pnf_system_information_resp(config, &resp);
+
+  nfapi_system_information_indication_t ind;
+  memset(&ind, 0, sizeof(ind));
+  ind.header.message_id = NFAPI_SYSTEM_INFORMATION_INDICATION;
+  ind.header.phy_id = req->header.phy_id;
+  ind.error_code = NFAPI_P4_MSG_OK;
+
+  switch(req->rat_type)
+  {
+    case NFAPI_RAT_TYPE_LTE:
+      {
+        ind.lte_system_information_indication.tl.tag = NFAPI_LTE_SYSTEM_INFORMATION_INDICATION_TAG;
+        ind.lte_system_information_indication.sib_type = 1;
+        ind.lte_system_information_indication.sib_length = 3;
+        //ind.lte_system_information_indication.sib...
+      }
+      break;
+    case NFAPI_RAT_TYPE_UTRAN:
+      {
+        ind.utran_system_information_indication.tl.tag = NFAPI_UTRAN_SYSTEM_INFORMATION_INDICATION_TAG;
+        ind.utran_system_information_indication.sib_length = 3;
+        //ind.utran_system_information_indication.sib...
+
+      }
+      break;
+    case NFAPI_RAT_TYPE_GERAN:
+      {
+        ind.geran_system_information_indication.tl.tag = NFAPI_GERAN_SYSTEM_INFORMATION_INDICATION_TAG;
+        ind.geran_system_information_indication.si_length = 3;
+        //ind.geran_system_information_indication.si...
+
+      }
+      break;
+  }
+
+  nfapi_pnf_system_information_ind(config, &ind);		
+
+  return 0;
+}
+
+int nmm_stop_request(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_nmm_stop_request_t* req)
+{
+  nfapi_nmm_stop_response_t resp;
+  memset(&resp, 0, sizeof(resp));
+  resp.header.message_id = NFAPI_NMM_STOP_RESPONSE;
+  resp.header.phy_id = req->header.phy_id;
+  resp.error_code = NFAPI_P4_MSG_OK;
+  nfapi_pnf_nmm_stop_resp(config, &resp);
+  return 0;
+}
+
+int vendor_ext(nfapi_pnf_config_t* config, nfapi_p4_p5_message_header_t* msg)
+{
+  NFAPI_TRACE(NFAPI_TRACE_INFO, "[PNF] P5 %s %p\n", __FUNCTION__, msg);
+
+  switch(msg->message_id)
+  {
+    case P5_VENDOR_EXT_REQ:
+      {
+        vendor_ext_p5_req* req = (vendor_ext_p5_req*)msg;
+        NFAPI_TRACE(NFAPI_TRACE_INFO, "[PNF] P5 Vendor Ext Req (%d %d)\n", req->dummy1, req->dummy2);
+        // send back the P5_VENDOR_EXT_RSP
+        vendor_ext_p5_rsp rsp;
+        memset(&rsp, 0, sizeof(rsp));
+        rsp.header.message_id = P5_VENDOR_EXT_RSP;
+        rsp.error_code = NFAPI_MSG_OK;
+        nfapi_pnf_vendor_extension(config, &rsp.header, sizeof(vendor_ext_p5_rsp));
+      }
+      break;
+  }
+
+  return 0;
+}
+
+nfapi_p4_p5_message_header_t* pnf_sim_allocate_p4_p5_vendor_ext(uint16_t message_id, uint16_t* msg_size)
+{
+  if(message_id == P5_VENDOR_EXT_REQ)
+  {
+    (*msg_size) = sizeof(vendor_ext_p5_req);
+    return (nfapi_p4_p5_message_header_t*)malloc(sizeof(vendor_ext_p5_req));
+  }
+
+  return 0;
+}
+
+void pnf_sim_deallocate_p4_p5_vendor_ext(nfapi_p4_p5_message_header_t* header)
+{
+  free(header);
+}
+
+int pnf_sim_pack_p4_p5_vendor_extension(nfapi_p4_p5_message_header_t* header, uint8_t** ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t* config)
+{
+  //NFAPI_TRACE(NFAPI_TRACE_INFO, "%s\n", __FUNCTION__);
+  if(header->message_id == P5_VENDOR_EXT_RSP)
+  {
+    vendor_ext_p5_rsp* rsp = (vendor_ext_p5_rsp*)(header);
+    return (!push16(rsp->error_code, ppWritePackedMsg, end));
+  }
+  return 0;
+}
+
+int pnf_sim_unpack_p4_p5_vendor_extension(nfapi_p4_p5_message_header_t* header, uint8_t** ppReadPackedMessage, uint8_t *end, nfapi_p4_p5_codec_config_t* codec)
+{
+  //NFAPI_TRACE(NFAPI_TRACE_INFO, "%s\n", __FUNCTION__);
+  if(header->message_id == P5_VENDOR_EXT_REQ)
+  {
+    vendor_ext_p5_req* req = (vendor_ext_p5_req*)(header);
+    return (!(pull16(ppReadPackedMessage, &req->dummy1, end) &&
+          pull16(ppReadPackedMessage, &req->dummy2, end)));
+
+    //NFAPI_TRACE(NFAPI_TRACE_INFO, "%s (%d %d)\n", __FUNCTION__, req->dummy1, req->dummy2);
+  }
+  return 0;
+}
+
+/*------------------------------------------------------------------------------*/
+
+void* pnf_start_thread(void* ptr)
+{
+  NFAPI_TRACE(NFAPI_TRACE_INFO, "[PNF] IN PNF NFAPI start thread %s\n", __FUNCTION__);
+
+  nfapi_pnf_config_t *config = (nfapi_pnf_config_t*)ptr;
+
+  struct sched_param sp;
+  sp.sched_priority = 20;
+  pthread_setschedparam(pthread_self(),SCHED_FIFO,&sp);
+
+  nfapi_pnf_start(config);
+
+  return (void*)0;
+}
+
+void configure_nfapi_pnf(char *vnf_ip_addr, int vnf_p5_port, char *pnf_ip_addr, int pnf_p7_port, int vnf_p7_port)
+{
+  printf("%s() PNF\n\n\n\n\n\n", __FUNCTION__);
+
+  nfapi_mode = 1;  // PNF!
+
+  nfapi_pnf_config_t* config = nfapi_pnf_config_create();
+
+  config->vnf_ip_addr = vnf_ip_addr;
+  config->vnf_p5_port = vnf_p5_port;
+
+  pnf.phys[0].udp.enabled = 1;
+  pnf.phys[0].udp.rx_port = pnf_p7_port;
+  pnf.phys[0].udp.tx_port = vnf_p7_port;
+  strcpy(pnf.phys[0].udp.tx_addr, vnf_ip_addr);
+
+  strcpy(pnf.phys[0].local_addr, pnf_ip_addr);
+
+  printf("%s() VNF:%s:%d PNF_PHY[addr:%s UDP:tx_addr:%s:%d rx:%d]\n", 
+      __FUNCTION__, 
+      config->vnf_ip_addr, config->vnf_p5_port, 
+      pnf.phys[0].local_addr,
+      pnf.phys[0].udp.tx_addr, pnf.phys[0].udp.tx_port,
+      pnf.phys[0].udp.rx_port);
+
+  config->pnf_param_req = &pnf_param_request;
+  config->pnf_config_req = &pnf_config_request;
+  config->pnf_start_req = &pnf_start_request;
+  config->pnf_stop_req = &pnf_stop_request;
+  config->param_req = &param_request;
+  config->config_req = &config_request;
+  config->start_req = &start_request;
+
+  config->measurement_req = &measurement_request;
+  config->rssi_req = &rssi_request;
+  config->cell_search_req = &cell_search_request;
+  config->broadcast_detect_req = &broadcast_detect_request;
+  config->system_information_schedule_req = &system_information_schedule_request;
+  config->system_information_req = &system_information_request;
+  config->nmm_stop_req = &nmm_stop_request;
+
+  config->vendor_ext = &vendor_ext;
+
+  config->trace = &pnf_nfapi_trace;
+
+  config->user_data = &pnf;
+
+  // To allow custom vendor extentions to be added to nfapi
+  config->codec_config.unpack_vendor_extension_tlv = &pnf_sim_unpack_vendor_extension_tlv;
+  config->codec_config.pack_vendor_extension_tlv = &pnf_sim_pack_vendor_extention_tlv;
+
+  config->allocate_p4_p5_vendor_ext = &pnf_sim_allocate_p4_p5_vendor_ext;
+  config->deallocate_p4_p5_vendor_ext = &pnf_sim_deallocate_p4_p5_vendor_ext;
+
+  config->codec_config.unpack_p4_p5_vendor_extension = &pnf_sim_unpack_p4_p5_vendor_extension;
+  config->codec_config.pack_p4_p5_vendor_extension = &pnf_sim_pack_p4_p5_vendor_extension;
+
+  NFAPI_TRACE(NFAPI_TRACE_INFO, "[PNF] Creating PNF NFAPI start thread %s\n", __FUNCTION__);
+  pthread_create(&pnf_start_pthread, NULL, &pnf_start_thread, config);
+
+  pthread_setname_np(pnf_start_pthread, "NFAPI_PNF");
+
+}
+
+void oai_subframe_ind(uint16_t sfn, uint16_t sf)
+{
+  //LOG_D(PHY,"%s(sfn:%d, sf:%d)\n", __FUNCTION__, sfn, sf);
+
+  //TODO FIXME - HACK - DJP - using a global to bodge it in 
+
+  if (p7_config_g != NULL && sync_var==0)
+  {
+    uint16_t sfn_sf_tx = sfn<<4 | sf;
+
+    if ((sfn % 100 == 0) && sf==0)
+    {
+      struct timespec ts;
+
+      clock_gettime(CLOCK_MONOTONIC, &ts);
+
+      NFAPI_TRACE(NFAPI_TRACE_INFO, "[PNF] %s %d.%d (sfn:%u sf:%u) SFN/SF(TX):%u\n", __FUNCTION__, ts.tv_sec, ts.tv_nsec, sfn, sf, NFAPI_SFNSF2DEC(sfn_sf_tx));
+    }
+
+    int subframe_ret = nfapi_pnf_p7_subframe_ind(p7_config_g, p7_config_g->phy_id, sfn_sf_tx);
+
+    if (subframe_ret)
+    {
+      NFAPI_TRACE(NFAPI_TRACE_INFO, "[PNF] %s(frame:%u subframe:%u) SFN/SF(TX):%u - PROBLEM with pnf_p7_subframe_ind()\n", __FUNCTION__, sfn, sf, sfn_sf_tx, NFAPI_SFNSF2DEC(sfn_sf_tx));
+    }
+    else
+    {
+      //NFAPI_TRACE(NFAPI_TRACE_INFO, "***NFAPI subframe handler finished *** \n");
+    }
+  }
+  else
+  {
+  }
+}
+
+int oai_nfapi_rach_ind(nfapi_rach_indication_t *rach_ind)
+{
+  rach_ind->header.phy_id = 1; // DJP HACK TODO FIXME - need to pass this around!!!!
+
+  LOG_E(PHY, "%s() sfn_sf:%d preambles:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(rach_ind->sfn_sf), rach_ind->rach_indication_body.number_of_preambles);
+
+  return nfapi_pnf_p7_rach_ind(p7_config_g, rach_ind);
+}
+
+int oai_nfapi_harq_indication(nfapi_harq_indication_t *harq_ind)
+{
+  harq_ind->header.phy_id = 1; // DJP HACK TODO FIXME - need to pass this around!!!!
+  harq_ind->header.message_id = NFAPI_HARQ_INDICATION;
+
+  LOG_E(PHY, "%s() sfn_sf:%d number_of_harqs:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(harq_ind->sfn_sf), harq_ind->harq_indication_body.number_of_harqs);
+
+  int retval = nfapi_pnf_p7_harq_ind(p7_config_g, harq_ind);
+
+  if (retval != 0) LOG_E(PHY, "%s() sfn_sf:%d number_of_harqs:%d nfapi_pnf_p7_harq_ind()=%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(harq_ind->sfn_sf), harq_ind->harq_indication_body.number_of_harqs, retval);
+  return retval;
+}
+
+int oai_nfapi_crc_indication(nfapi_crc_indication_t *crc_ind)
+{
+  crc_ind->header.phy_id = 1; // DJP HACK TODO FIXME - need to pass this around!!!!
+  crc_ind->header.message_id = NFAPI_CRC_INDICATION;
+
+  //LOG_E(PHY, "%s() sfn_sf:%d number_of_crcs:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(crc_ind->sfn_sf), crc_ind->crc_indication_body.number_of_crcs);
+
+  return nfapi_pnf_p7_crc_ind(p7_config_g, crc_ind);
+}
+
+int oai_nfapi_cqi_indication(nfapi_cqi_indication_t *ind)
+{
+  ind->header.phy_id = 1; // DJP HACK TODO FIXME - need to pass this around!!!!
+  ind->header.message_id = NFAPI_RX_CQI_INDICATION;
+
+  //LOG_E(PHY, "%s() sfn_sf:%d number_of_cqis:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->cqi_indication_body.number_of_cqis);
+
+  return nfapi_pnf_p7_cqi_ind(p7_config_g, ind);
+}
+
+int oai_nfapi_rx_ind(nfapi_rx_indication_t *ind)
+{
+  ind->header.phy_id = 1; // DJP HACK TODO FIXME - need to pass this around!!!!
+  ind->header.message_id = NFAPI_RX_ULSCH_INDICATION;
+
+  int retval = nfapi_pnf_p7_rx_ind(p7_config_g, ind);
+
+  //LOG_D(PHY,"%s() SFN/SF:%d pdus:%d retval:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->rx_indication_body.number_of_pdus, retval);
+
+  //free(ind.rx_indication_body.rx_pdu_list);
+
+  return retval;
+}
+
+int oai_nfapi_sr_indication(nfapi_sr_indication_t *ind)
+{
+  ind->header.phy_id = 1; // DJP HACK TODO FIXME - need to pass this around!!!!
+
+  int retval = nfapi_pnf_p7_sr_ind(p7_config_g, ind);
+
+  //LOG_E(PHY,"%s() SFN/SF:%d srs:%d retval:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->sr_indication_body.number_of_srs, retval);
+
+  //free(ind.rx_indication_body.rx_pdu_list);
+
+  return retval;
+}

nfapi/nfapi_pnf.h

+#if !defined(NFAPI_PNF_H__)
+#define NFAPI_PNF_H__
+
+void configure_nfapi_pnf(char *vnf_ip_addr, int vnf_p5_port, char *pnf_ip_addr, int pnf_p7_port, int vnf_p7_port);
+
+#endif

nfapi/nfapi_pnf_interface.h

+/*
+ * Copyright 2017 Cisco Systems, Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * 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.
+ */
+
+
+#ifndef _NFAPI_PNF_INTERFACE_H_
+#define _NFAPI_PNF_INTERFACE_H_
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include "nfapi_interface.h"
+#include "debug.h"
+
+#include <sys/types.h>
+
+/*! This enum is used to describe the states of the pnf 
+ */
+typedef enum
+{
+	NFAPI_PNF_IDLE = 0,
+	NFAPI_PNF_CONFIGURED,
+	NFAPI_PNF_RUNNING
+} nfapi_pnf_state_e;
+
+/*! This enum is used to describe the states of a phy instance of a pnf
+ */
+typedef enum
+{
+	NFAPI_PNF_PHY_IDLE = 0,
+	NFAPI_PNF_PHY_CONFIGURED = 1,
+	NFAPI_PNF_PHY_RUNNING = 2
+} nfapi_pnf_phy_state_e;
+
+typedef struct nfapi_pnf_phy_config nfapi_pnf_phy_config_t;
+
+/*! Configuration information for a pnf phy instance
+ */
+typedef struct nfapi_pnf_phy_config
+{
+	/*! The PHY id*/
+	uint16_t phy_id;
+
+	/*! The state of the PNF PHY instance*/
+	nfapi_pnf_phy_state_e state;
+
+	/*! Optional user defined data that will be passed back in the callbacks*/
+	void* user_data;
+
+	/*! Pointer for use in a linked list */
+	struct nfapi_pnf_phy_config* next;
+} nfapi_pnf_phy_config_t;
+
+typedef struct nfapi_pnf_config nfapi_pnf_config_t;
+
+/*! Configuration information for the pnf created by calling nfapi_pnf_create
+ */
+typedef struct nfapi_pnf_config
+{
+	/*! A user define callback to override the default memory allocation 
+	 * \param size The size of the data buffer to allocate
+	 * \return A pointer to a data buffer
+	 */
+	void* (*malloc)(size_t size);
+	
+	/*! A user define callback to override the default memory deallocation 
+	 * \param ptr Pointer to a data buffer to be deallocated
+	 */
+	void (*free)(void* ptr);
+
+	/*! A user define callback to handle trace from the pnf 
+	 * \param level The trace level 
+	 * \param message The trace string
+	 * 
+	 * This is a vardic function.
+	 */
+	void (*trace)(nfapi_trace_level_t  level, const char* message, ...);
+
+	/*! The ip address of the VNF 
+	 *
+	 */
+	char* vnf_ip_addr;
+
+	/*! The ip port of the VNF 
+	 */
+	int vnf_p5_port;
+
+	/*! The state of the PNF */
+	nfapi_pnf_state_e state;
+
+	/*! List of PHY instances configured for this PNF */
+	nfapi_pnf_phy_config_t* phys;
+	
+	/*! Configuation option of the p4 p5 encode decode functions */
+	nfapi_p4_p5_codec_config_t codec_config;
+	
+	/*! Optional user defined data that will be passed back in the callbacks*/
+	void* user_data;
+
+
+	/*! A callback for the PNF_PARAM.request 
+	 *  \param config A pointer to the pnf configuration
+	 *  \param req A data structure for the decoded PNF_PARAM.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the PNF_PARAM.response after receiving the
+	 *  PNF_PARAM.request. This can be done in the call back. 
+	 */
+	int (*pnf_param_req)(nfapi_pnf_config_t* config, nfapi_pnf_param_request_t* req);
+	
+	/*! A callback for the PNF_CONFIG.request
+	 *  \param config A pointer to the pnf configuration
+	 *  \param req A data structure for the decoded PNF_CONFIG.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the PNF_CONFIG.response after receiving the
+	 *  PNF_CONFIG.request. This can be done in the call back. 
+	 */
+	int (*pnf_config_req)(nfapi_pnf_config_t* config, nfapi_pnf_config_request_t* req);
+	
+	/*! A callback for the PNF_START.request
+	 *  \param config A pointer to the pnf configuration
+	 *  \param req A data structure for the decoded PNF_CONFIG.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the PNF_START.response after receiving the
+	 *  PNF_START.request. This can be done in the call back. 
+	 */
+	int (*pnf_start_req)(nfapi_pnf_config_t* config, nfapi_pnf_start_request_t* req);
+	
+	/*! A callback for the PNF_STOP.request
+	 *  \param config A pointer to the pnf configuration
+	 *  \param req A data structure for the decoded PNF_STOP.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the PNF_STOP.response after receiving the
+	 *  PNF_STOP.request. This can be done in the call back. 
+	 */
+	int (*pnf_stop_req)(nfapi_pnf_config_t* config, nfapi_pnf_stop_request_t* req);
+
+	/*! A callback for the PARAM.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 PARAM.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the PARAM.response after receiving the
+	 *  PARAM.request. This can be done in the call back. 
+	 */
+	int (*param_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_param_request_t* req);
+	
+	/*! A callback for the CONFIG.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 CONFIG.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the CONFIG.response after receiving the
+	 *  CONFIG.request. This can be done in the call back. 
+	 */
+	int (*config_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_config_request_t* req);
+	
+	/*! A callback for the START.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 START.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the START.response after the client has received the
+	 *  first subframe indication from FAPI.
+	 */
+	int (*start_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_start_request_t* req);
+	
+	/*! A callback for the STOP.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 STOP.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the STOP.response after receiving the
+	 *  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);
+	
+	/*! 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
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the RSSI.response after receiving the
+	 *  RSSI.request. This can be done in the call back. 
+	 */
+	int (*rssi_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_rssi_request_t* req);
+	
+	/*! A callback for the CELL_SEARCH.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 CELL_SEARCH.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the CELL_SEARCH.response after receiving the
+	 *  CELL_SEARCH.request. This can be done in the call back. 	
+	 */
+	int (*cell_search_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_cell_search_request_t* req);
+	
+	/*! A callback for the BROADCAST_DETECT.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 BROADCAST_DETECT.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the BROADCAST_DETECT.response after receiving the
+	 *  BROADCAST_DETECT.request. This can be done in the call back. 	
+	 */
+	int (*broadcast_detect_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_broadcast_detect_request_t* req);
+	
+	/*! A callback for the SYSTEM_INFORMATION_SCHEDULE.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 SYSTEM_INFORMATION_SCHEDULE.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the SYSTEM_INFORMATION_SCHEDULE.response after receiving the
+	 *  SYSTEM_INFORMATION_SCHEDULE.request. This can be done in the call back. 	
+	 */
+	int (*system_information_schedule_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_system_information_schedule_request_t* req);
+	
+	/*! A callback for the SYSTEM_INFORMATION.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 SYSTEM_INFORMATION.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the SYSTEM_INFORMATION.response after receiving the
+	 *  SYSTEM_INFORMATION.request. This can be done in the call back. 	
+	 */
+	int (*system_information_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_system_information_request_t* req);
+	
+	/*! A callback for the NMM_STOP.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 NMM_STOP.request. This will have
+	 *             been allocated on the stack
+	 *  \return not currently used
+	 * 
+	 * 	The client is expected to send the NMM_STOP.response after receiving the
+	 *  NMM_STOP.request. This can be done in the call back.
+	 */
+	int (*nmm_stop_req)(nfapi_pnf_config_t* config, nfapi_pnf_phy_config_t* phy, nfapi_nmm_stop_request_t* req);
+	
+	/*! A callback for any vendor extension messages recevied
+	 *  \param config A pointer to the pnf configuration
+	 *  \param msg A pointer to the decode P4/P5 message
+	 *  \return not current used
+	 */
+	int (*vendor_ext)(nfapi_pnf_config_t* config, nfapi_p4_p5_message_header_t* msg);
+	
+	/*! A callback to allocate vendor extension message
+	 * \param message_id The message id from the decode P4/P5 message header
+	 * \param msg_size A pointer a the size of the allocated message structure. The callee should set this
+	 * \return A pointer to a allocated P4/P5 message structure
+	 */
+	nfapi_p4_p5_message_header_t* (*allocate_p4_p5_vendor_ext)(uint16_t message_id, uint16_t* msg_size);
+	
+	/*! A callback to deallocate vendor extension message 
+	 * \param header A pointer to an P4/P5 message structure
+	 */
+	void (*deallocate_p4_p5_vendor_ext)(nfapi_p4_p5_message_header_t* header);
+
+
+
+} nfapi_pnf_config_t;
+
+/*! Create a pnf configuration 
+ *  \return A pointer to a pnf configuration struture
+ * 
+ *  This function will create and initialize a pnf instance. It is expected that 
+ *  the client will set the callback and parameters need before calling nfapi_pnf_start
+ *
+ *  0 will be returned if it fails.
+ * 
+ * \code
+ * nfapi_pnf_config_t* config = nfapi_pnf_config_create(void);
+ * \endcode
+ */
+nfapi_pnf_config_t* nfapi_pnf_config_create(void);
+
+/*! Delete a pnf configuration 
+ * \param config A pointer to a pnf configuraiton
+ * \return 0 is success, -1 for failure
+ */
+int nfapi_pnf_config_destroy(nfapi_pnf_config_t* config);
+
+/*! Start the PNF library. 
+ * \param config A pointer to the pnf configuration
+ * \return 0 is success, -1 for failure
+ * 
+ * This function will not return until nfapi_pnf_stop is called
+ *
+ * \code
+ * // Create the pnf config
+ * nfapi_pnf_config_t* config = nfapi_pnf_config_create(void);
+ *
+ * // Assumed that the vnf_address and vnf_port are provided over the P9 interface
+ * config->vnf_ip_addr = vnf_address;
+ * config->vnf_p5_port = vnf_port;
+ *
+ * // Set the required callbacks
+ * config->pnf_param_req = &pnf_param_request;
+ * ...
+ * 
+ * // Call start for the PNF to initiate a connection to the VNF
+ * nfai_pnf_start(config);
+ * 
+ * \endcode
+ */
+int nfapi_pnf_start(nfapi_pnf_config_t* config);
+
+/*! Stop the PNF library. 
+ * \param config A pointer to the pnf configuration
+ * \return 0 is success, -1 for failure
+ * 
+ * This function will cause the nfapi_pnf_start function to return
+ */
+int nfapi_pnf_stop(nfapi_pnf_config_t* config);
+
+/*! Send the PNF_PARAM.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_pnf_param_resp(nfapi_pnf_config_t* config, nfapi_pnf_param_response_t* resp);
+
+/*! Send the PNF_CONFIG.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_pnf_config_resp(nfapi_pnf_config_t* config, nfapi_pnf_config_response_t* resp);
+
+/*! Send the PNF_START.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_pnf_start_resp(nfapi_pnf_config_t* config, nfapi_pnf_start_response_t* resp);
+
+/*! Send the PNF_STOP.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_pnf_stop_resp(nfapi_pnf_config_t* config, nfapi_pnf_stop_response_t* resp);
+
+/*! Send the PARAM.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_param_resp(nfapi_pnf_config_t* config, nfapi_param_response_t* resp);
+
+/*! Send the CONFIG.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_config_resp(nfapi_pnf_config_t* config, nfapi_config_response_t* resp);
+
+/*! Send the START.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_start_resp(nfapi_pnf_config_t* config, nfapi_start_response_t* resp);
+
+/*! Send the STOP.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_stop_resp(nfapi_pnf_config_t* config, nfapi_stop_response_t* resp);
+
+/*! Send the MEASUREMENT.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_measurement_resp(nfapi_pnf_config_t* config, nfapi_measurement_response_t* resp);
+
+/*! Send the RSSI.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_rssi_resp(nfapi_pnf_config_t* config, nfapi_rssi_response_t* resp);
+
+/*! Send the RSSI.indication
+ * \param config A pointer to a pnf configuraiton
+ * \param ind A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_rssi_ind(nfapi_pnf_config_t* config, nfapi_rssi_indication_t* ind);
+
+/*! Send the CELL_SEARCH.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_cell_search_resp(nfapi_pnf_config_t* config, nfapi_cell_search_response_t* resp);
+
+/*! Send the CELL_SEARCH.indication
+ * \param config A pointer to a pnf configuraiton
+ * \param ind A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_cell_search_ind(nfapi_pnf_config_t* config, nfapi_cell_search_indication_t* ind);
+
+/*! Send the BROADCAST_DETECT.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_broadcast_detect_resp(nfapi_pnf_config_t* config, nfapi_broadcast_detect_response_t* resp);
+
+/*! Send the BROADCAST_DETECT.indication
+ * \param config A pointer to a pnf configuraiton
+ * \param ind A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_broadcast_detect_ind(nfapi_pnf_config_t* config, nfapi_broadcast_detect_indication_t* ind);
+
+/*! Send the SYSTEM_INFORMATION_SCHEDULE.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_system_information_schedule_resp(nfapi_pnf_config_t* config, nfapi_system_information_schedule_response_t* resp);
+
+/*! Send the SYSTEM_INFORMATION_SCHEDULE.indication
+ * \param config A pointer to a pnf configuraiton
+ * \param ind A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_system_information_schedule_ind(nfapi_pnf_config_t* config, nfapi_system_information_schedule_indication_t* ind);
+
+/*! Send the SYSTEM_INFORMATION.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_system_information_resp(nfapi_pnf_config_t* config, nfapi_system_information_response_t* resp);
+
+/*! Send the SYSTEM_INFORMATION.indication
+ * \param config A pointer to a pnf configuraiton
+ * \param ind A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_system_information_ind(nfapi_pnf_config_t* config, nfapi_system_information_indication_t* ind);
+
+/*! Send the NMM_STOP.response
+ * \param config A pointer to a pnf configuraiton
+ * \param resp A pointer to the message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_nmm_stop_resp(nfapi_pnf_config_t* config, nfapi_nmm_stop_response_t* resp);
+
+/*! Send a vendor extension message
+ * \param config A pointer to a pnf configuraiton
+ * \param msg A pointer to the vendor extention message structure
+ * \param msg_len The size of the vendor extention message structure
+ * \return 0 for success, -1 for failure
+ * 
+ */
+int nfapi_pnf_vendor_extension(nfapi_pnf_config_t* config, nfapi_p4_p5_message_header_t* msg, uint32_t msg_len);
+
+//--------------------------
+
+/*! A subframe buffer structure which can be used by the client to 
+ *  to configure the dummy information
+ */
+typedef struct 
+{
+	uint16_t sfn_sf;
+	
+	nfapi_dl_config_request_t* dl_config_req;
+	nfapi_ul_config_request_t* ul_config_req;
+	nfapi_hi_dci0_request_t* hi_dci0_req;
+	nfapi_tx_request_t* tx_req;
+	nfapi_lbt_dl_config_request_t* lbt_dl_config_req;
+
+} nfapi_pnf_p7_subframe_buffer_t;
+
+typedef struct nfapi_pnf_p7_config nfapi_pnf_p7_config_t;
+
+/*! The nfapi PNF PHY P7 configuration information created using the nfapi_pnf_p7_create function
+ */
+typedef struct nfapi_pnf_p7_config
+{
+	/*! A user define callback to override the default memory allocation 
+	 * \param size The size of the buffer to allocate
+	 * \return An allocated buffer. 0 in the case of failure
+	 * 
+	 * If not set malloc will be used
+	 */
+	void* (*malloc)(size_t size);
+	
+	/*! A user define callback to override the default memory deallocation 
+	 *  \param ptr Pointer to a buffer to dellocate
+	 *
+	 * If not set free will be used
+	 */
+	void (*free)(void* ptr);
+
+	/*! A user define callback to handle trace from the pnf
+	 * \param level The trace level
+	 * \param message The message string
+	 */
+	void (*trace)(nfapi_trace_level_t  level, const char* message, ...);
+
+	/*! The PHY id*/
+	uint16_t phy_id;
+
+	// remote
+	/*! The VNF P7 UDP port */
+	int remote_p7_port;
+	/*! The VNF P7 UDP address */
+	char* remote_p7_addr;
+
+	// local
+	/*! The PNF P7 UDP port */
+	int local_p7_port;
+	/*! The PNF P7 UDP address */
+	char* local_p7_addr;
+
+	/*! Flag to indicate of the pnf should use the P7 checksum */
+	uint8_t checksum_enabled;
+
+	/*! The maxium size of a P7 segement. If a message is large that this it
+	 * will be segemented */
+	uint16_t segment_size;
+
+	/*! The dummy subframe buffer structure that should be used in case there
+	 * are no 'valid' subframe messages */
+	nfapi_pnf_p7_subframe_buffer_t dummy_subframe;
+	
+	/*! Configuration options for the p7 pack unpack functions*/
+	nfapi_p7_codec_config_t codec_config;
+	
+	/*! Optional userdata that will be passed back in the callbacks*/
+	void* user_data;
+
+	// tdb : if these should be public
+	uint16_t subframe_buffer_size;
+	uint8_t timing_info_mode_periodic; // 0:false 1:true
+	uint8_t timing_info_mode_aperiodic; // 0:false 1:true
+	uint8_t timing_info_period; // 1..225 in subframes
+
+	/*! A callback for the DL_CONFIG.request
+	 * \param config A poiner to the PNF P7 config
+	 * \param req A pointer to the dl config request message structure
+	 * \return not currently used
+	 */
+	int (*dl_config_req)(nfapi_pnf_p7_config_t* config, nfapi_dl_config_request_t* req);
+	
+	/*! A callback for the UL_CONFIG.request
+	 * \param config A poiner to the PNF P7 config
+	 * \param req A pointer to the ul config request message structure
+	 * \return not currently used	
+	 */
+	int (*ul_config_req)(nfapi_pnf_p7_config_t* config, nfapi_ul_config_request_t* req);
+	
+	/*! A callback for the HI_DCI0.request
+	 * \param config A poiner to the PNF P7 config
+	 * \param req A pointer to the hi dci0 request message structure
+	 * \return not currently used
+	 */
+	int (*hi_dci0_req)(nfapi_pnf_p7_config_t* config, nfapi_hi_dci0_request_t* req);
+	
+	/*! A callback for the TX_REQ.request
+	 * \param config A poiner to the PNF P7 config
+	 * \param req A pointer to the tx request message structure
+	 * \return not currently used
+	 * 
+	 * The TX request contains pointers to the downlink PDUs to be sent. In the case that the FAPI interface
+	 * will 'keep' the pointers until they are transmitted the callee should set the pointers in the req to 0
+	 * and then use the p7 codec config free function to release the pdu's when appropriate. 
+	 */
+	int (*tx_req)(nfapi_pnf_p7_config_t* config, nfapi_tx_request_t* req);
+	
+	/*! A callback for the LBT_DL_CONFIG.request
+	 * \param config A poiner to the PNF P7 config
+	 * \param req A pointer to the lbt dl request message structure
+	 * \return not currently used
+	 */
+	int (*lbt_dl_config_req)(nfapi_pnf_p7_config_t* config, nfapi_lbt_dl_config_request_t* req);
+	
+	/*! A callback for vendor extension messages
+	 * \param config A poiner to the PNF P7 config
+	 * \param msg A pointer to a decode vendor extention message
+	 * \return not currently used
+	 */
+	int (*vendor_ext)(nfapi_pnf_p7_config_t* config, nfapi_p7_message_header_t* msg);
+
+	/*! A callback to allocate vendor extension message
+	 * \param message_id The vendor extention message id from the decode message header
+	 * \param msg_size A pointer to size of the allocate vendor extention message. Set by the callee
+	 * \return A pointer to an allocated vendor extention message structure. 0 if failed
+	 * 
+	 * 
+	 */
+	nfapi_p7_message_header_t* (*allocate_p7_vendor_ext)(uint16_t message_id, uint16_t* msg_size);
+	
+	/*! A callback to deallocate vendor extension message
+	 * \param header A pointer to a p7 vendor extention message
+	 */
+	void (*deallocate_p7_vendor_ext)(nfapi_p7_message_header_t* header);
+
+
+
+} nfapi_pnf_p7_config_t;
+
+/*! Create and initialise a nfapi_pnf_p7_config structure
+ * \return A pointer to a PNF P7 config structure
+ */
+nfapi_pnf_p7_config_t* nfapi_pnf_p7_config_create(void);
+
+/*! Delete an nfapi_pnf_p7_config structure
+ * \param config 
+ */
+int nfapi_pnf_p7_config_destroy(nfapi_pnf_p7_config_t* config);
+
+
+/*! Start the PNF P7 library. 
+ * \param config A pointer to a PNF P7 config
+ * \return 0 means success, -1 means failure
+ * 
+ * This function will not return until nfapi_pnf_p7_stop is called.
+ */
+int nfapi_pnf_p7_start(nfapi_pnf_p7_config_t* config);
+
+/*! Stop the PNF P7 library. 
+ * \param config A pointer to a PNF P7 config
+ * \return  0 means success, -1 means failure
+ * 
+ * This function will cause the nfapi_pnf_p7_start to return
+ */
+int nfapi_pnf_p7_stop(nfapi_pnf_p7_config_t* config);
+
+/*! Subframe indication
+ * \param config A pointer to a PNF P7 config
+ * \param phy_id The phy_id for the phy instance
+ * \param sfn_sf The SFN and SF in the format of FAPI
+ * \return 0 means success, -1 means failure
+ * 
+ * The client should call the subframe indication every 1ms. The PNF will
+ * respond by invoking the pnf p7 subframe callbacks with the messages from the subframe buffer
+ *
+ * If messages are not in the subframe buffer, they dummy subframe messages will be sent
+ */
+int nfapi_pnf_p7_subframe_ind(nfapi_pnf_p7_config_t* config, uint16_t phy_id, uint16_t sfn_sf);
+
+/*! Send the HARQ.indication
+ * \param config A pointer to a PNF P7 config
+ * \param ind A pointer to the harq indication message structure
+ * \return 0 means success, -1 means failure
+ */
+int nfapi_pnf_p7_harq_ind(nfapi_pnf_p7_config_t* config, nfapi_harq_indication_t* ind);
+
+/*! Send the CRC.indication
+ * \param config A pointer to a PNF P7 config
+ * \param ind A pointer to the crc indication message structure
+ * \return 0 means success, -1 means failure
+ */
+int nfapi_pnf_p7_crc_ind(nfapi_pnf_p7_config_t* config, nfapi_crc_indication_t* ind);
+
+/*! Send the RX.indication
+ * \param config A pointer to a PNF P7 config
+ * \param ind A pointer to the rx indication message structure
+ * \return 0 means success, -1 means failure
+ */
+int nfapi_pnf_p7_rx_ind(nfapi_pnf_p7_config_t* config, nfapi_rx_indication_t* ind);
+
+/*! Send the RACH.indication
+ * \param config A pointer to a PNF P7 config
+ * \param ind A pointer to the rach indication message structure
+ * \return 0 means success, -1 means failure
+ */
+int nfapi_pnf_p7_rach_ind(nfapi_pnf_p7_config_t* config, nfapi_rach_indication_t* ind);
+
+/*! Send the SRS.indication
+ * \param config A pointer to a PNF P7 config
+ * \param ind A pointer to the srs indication message structure
+ * \return 0 means success, -1 means failure
+ */
+int nfapi_pnf_p7_srs_ind(nfapi_pnf_p7_config_t* config, nfapi_srs_indication_t* ind);
+
+/*! Send the SR.indication
+ * \param config A pointer to a PNF P7 config
+ * \param ind A pointer to the sr indication message structure
+ * \return 0 means success, -1 means failure
+ */
+int nfapi_pnf_p7_sr_ind(nfapi_pnf_p7_config_t* config, nfapi_sr_indication_t* ind);
+
+/*! Send the CQI.indication
+ * \param config A pointer to a PNF P7 config
+ * \param ind A pointer to the cqi indication message structure
+ * \return 0 means success, -1 means failure
+ */
+int nfapi_pnf_p7_cqi_ind(nfapi_pnf_p7_config_t* config, nfapi_cqi_indication_t* ind);
+
+/*! Send the LBT_DL.indication
+ * \param config A pointer to a PNF P7 config
+ * \param ind A pointer to the lbt dl indication message structure
+ * \return 0 means success, -1 means failure
+ */
+int nfapi_pnf_p7_lbt_dl_ind(nfapi_pnf_p7_config_t* config, nfapi_lbt_dl_indication_t* ind);
+
+/*! Send the NB_HARQ.indication
+ * \param config A pointer to a PNF P7 config
+ * \param ind A pointer to the lbt dl indication message structure
+ * \return 0 means success, -1 means failure
+ */
+int nfapi_pnf_p7_nb_harq_ind(nfapi_pnf_p7_config_t* config, nfapi_nb_harq_indication_t* ind);
+
+/*! Send the NRACH.indication
+ * \param config A pointer to a PNF P7 config
+ * \param ind A pointer to the lbt dl indication message structure
+ * \return 0 means success, -1 means failure
+ */
+int nfapi_pnf_p7_nrach_ind(nfapi_pnf_p7_config_t* config, nfapi_nrach_indication_t* ind);
+
+
+/*! Send a vendor exntesion message
+ * \param config A pointer to a PNF P7 config
+ * \param msg A pointer to the lbt dl indication message structure
+ * \return 0 means success, -1 means failure
+ */
+int nfapi_pnf_p7_vendor_extension(nfapi_pnf_p7_config_t* config, nfapi_p7_message_header_t* msg);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // _NFAPI_PNF_INTERFACE_H_

nfapi/nfapi_vnf.c

+
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include "nfapi_interface.h"
+#include "nfapi_vnf_interface.h"
+#include "nfapi.h"
+#include "vendor_ext.h"
+
+#include "nfapi_vnf.h"
+
+
+#include "common/ran_context.h"
+//#include "openair1/PHY/vars.h"
+extern RAN_CONTEXT_t RC;
+
+typedef struct 
+{
+	//public:
+		uint8_t enabled;
+		uint32_t rx_port;
+		uint32_t tx_port;
+		//std::string tx_addr;
+		char tx_addr[80];
+} udp_data;
+
+//class phy_info
+//DJP
+typedef struct 
+{
+#if 0
+	public:
+
+		phy_info()
+			: first_subframe_ind(0), fapi(0),
+			  dl_ues_per_subframe(0), ul_ues_per_subframe(0), 
+			  timing_window(0), timing_info_mode(0), timing_info_period(0)
+		{
+			index = 0;
+			id = 0;
+
+			local_port = 0;
+			remote_addr = 0;
+			remote_port = 0;
+	
+			duplex_mode = 0;
+			dl_channel_bw_support = 0;
+			ul_channel_bw_support = 0;
+			num_dl_layers_supported = 0;
+			num_ul_layers_supported = 0;
+			release_supported = 0;
+			nmm_modes_supported = 0;
+		}
+#endif
+
+		uint16_t index;
+		uint16_t id;
+		//std::vector<uint8_t> rfs;
+		//std::vector<uint8_t> excluded_rfs;
+		uint8_t rfs[2];
+		uint8_t excluded_rfs[2];
+
+		udp_data udp;
+
+		//std::string local_addr;
+		char local_addr[80];
+		int local_port;
+
+		char* remote_addr;
+		int remote_port;
+
+		uint8_t duplex_mode;
+		uint16_t dl_channel_bw_support;
+		uint16_t ul_channel_bw_support;
+		uint8_t num_dl_layers_supported;
+		uint8_t num_ul_layers_supported;
+		uint16_t release_supported;
+		uint8_t nmm_modes_supported;
+
+		uint8_t dl_ues_per_subframe;
+		uint8_t ul_ues_per_subframe;
+
+		uint8_t first_subframe_ind;
+
+		// timing information recevied from the vnf
+		uint8_t timing_window;
+		uint8_t timing_info_mode;
+		uint8_t timing_info_period;
+
+    // DJP
+		//fapi_t* fapi;
+
+} phy_info;
+
+//class rf_info
+//DJP
+typedef struct 
+{
+	//public:
+		uint16_t index;
+		uint16_t band;
+		int16_t max_transmit_power;
+		int16_t min_transmit_power;
+		uint8_t num_antennas_supported;
+		uint32_t min_downlink_frequency;
+		uint32_t max_downlink_frequency;
+		uint32_t max_uplink_frequency;
+		uint32_t min_uplink_frequency;
+} rf_info;
+
+
+//class pnf_info
+//DJP
+typedef struct 
+{
+#if 0
+	public:
+
+		pnf_info() 
+		: release(13), wireshark_test_mode(0),
+		  max_total_power(0), oui(0)
+					
+		{
+			release = 0;
+	
+			sync_mode = 0;
+			location_mode = 0;
+			dl_config_timing = 0;
+			ul_config_timing = 0;
+			tx_timing = 0;
+			hi_dci0_timing = 0;
+	
+			max_phys = 0;
+			max_total_bw = 0;
+			max_total_dl_layers = 0;
+			max_total_ul_layers = 0;
+			shared_bands = 0;
+			shared_pa = 0;
+			
+		}
+#endif
+
+		int release;
+		//DJPstd::vector<phy_info> phys;
+		//std::vector<rf_info> rfs;
+		phy_info phys[2];
+		rf_info rfs[2];
+
+		uint8_t sync_mode;
+		uint8_t location_mode;
+		uint8_t location_coordinates[6];
+		uint32_t dl_config_timing;
+		uint32_t ul_config_timing;
+		uint32_t tx_timing;
+		uint32_t hi_dci0_timing;
+
+		uint16_t max_phys;
+		uint16_t max_total_bw;
+		uint16_t max_total_dl_layers;
+		uint16_t max_total_ul_layers;
+		uint8_t shared_bands;
+		uint8_t shared_pa;
+		int16_t max_total_power;
+		uint8_t oui;
+		
+		uint8_t wireshark_test_mode;
+
+} pnf_info;
+
+typedef struct mac mac_t;
+
+typedef struct mac
+{
+	void* user_data;
+
+	void (*dl_config_req)(mac_t* mac, nfapi_dl_config_request_t* req);
+	void (*ul_config_req)(mac_t* mac, nfapi_ul_config_request_t* req);
+	void (*hi_dci0_req)(mac_t* mac, nfapi_hi_dci0_request_t* req);
+	void (*tx_req)(mac_t* mac, nfapi_tx_request_t* req);
+} mac_t;
+
+//class vnf_p7_info
+typedef struct 
+{
+	//public:
+
+#if 0
+		vnf_p7_info()
+			: thread_started(false), 
+			  config(nfapi_vnf_p7_config_create(), 
+				     [] (nfapi_vnf_p7_config_t* f) { nfapi_vnf_p7_config_destory(f); }),
+			  mac(0)
+		{
+			local_port = 0;
+			
+			timing_window = 0;
+			periodic_timing_enabled = 0;
+			aperiodic_timing_enabled = 0;
+			periodic_timing_period = 0;
+			
+			//config = nfapi_vnf_p7_config_create();
+		}
+		
+		vnf_p7_info(const vnf_p7_info& other)  = default;
+		
+		vnf_p7_info(vnf_p7_info&& other) = default;
+		
+		vnf_p7_info& operator=(const vnf_p7_info&) = default;
+		
+		vnf_p7_info& operator=(vnf_p7_info&&) = default;
+		
+		
+		
+		virtual	~vnf_p7_info()
+		{
+			//NFAPI_TRACE(NFAPI_TRACE_INFO, "*** vnf_p7_info delete ***\n");
+			
+			//nfapi_vnf_p7_config_destory(config);
+			
+			// should we delete the mac?
+		}
+#endif
+		
+
+		int local_port;
+		//DJP std::string local_addr;
+		char local_addr[80];
+
+		unsigned timing_window;
+		unsigned periodic_timing_enabled;
+		unsigned aperiodic_timing_enabled;
+		unsigned periodic_timing_period;
+
+		// This is not really the right place if we have multiple PHY, 
+		// should be part of the phy struct
+		udp_data udp;
+
+		uint8_t thread_started;
+
+		nfapi_vnf_p7_config_t* config;
+		//std::shared_ptr<nfapi_vnf_p7_config_t> config;
+
+		mac_t* mac;
+
+} vnf_p7_info;
+
+//class vnf_info
+typedef struct
+{
+	//public:
+	
+		uint8_t wireshark_test_mode;
+
+		//std::map<uint16_t, pnf_info> pnfs;
+		pnf_info pnfs[2];
+
+		//std::vector<vnf_p7_info> p7_vnfs;
+		vnf_p7_info p7_vnfs[2];
+} vnf_info;
+
+int vnf_pack_vendor_extension_tlv(void* ve, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t* codec)
+{
+  //NFAPI_TRACE(NFAPI_TRACE_INFO, "vnf_pack_vendor_extension_tlv\n");
+  nfapi_tl_t* tlv = (nfapi_tl_t*)ve;
+  switch(tlv->tag)
+  {
+    case VENDOR_EXT_TLV_2_TAG:
+      {
+        //NFAPI_TRACE(NFAPI_TRACE_INFO, "Packing VENDOR_EXT_TLV_2\n");
+        vendor_ext_tlv_2* ve = (vendor_ext_tlv_2*)tlv;
+        if(!push32(ve->dummy, ppWritePackedMsg, end))
+          return 0;
+        return 1;
+      }
+      break;
+  }
+  return -1;
+}
+int vnf_unpack_vendor_extension_tlv(nfapi_tl_t* tl, uint8_t **ppReadPackedMessage, uint8_t *end, void** ve, nfapi_p4_p5_codec_config_t* codec)
+{
+  return -1;
+}
+
+void install_schedule_handlers(IF_Module_t *if_inst);
+extern int single_thread_flag;
+extern void init_eNB_afterRU(void);
+extern uint16_t sf_ahead;
+
+void oai_create_enb(void)
+{
+  int bodge_counter=0;
+  PHY_VARS_eNB *eNB = RC.eNB[0][0];
+
+  printf("[VNF] RC.eNB[0][0]. Mod_id:%d CC_id:%d nb_CC[0]:%d abstraction_flag:%d single_thread_flag:%d td:%p te:%p if_inst:%p\n", eNB->Mod_id, eNB->CC_id, RC.nb_CC[0], eNB->abstraction_flag, eNB->single_thread_flag, eNB->td, eNB->te, eNB->if_inst);
+
+  eNB->Mod_id  = bodge_counter;
+  eNB->CC_id   = bodge_counter;
+  eNB->abstraction_flag   = 0;
+  eNB->single_thread_flag = 0;//single_thread_flag;
+  eNB->td                   = ulsch_decoding_data;//(single_thread_flag==1) ? ulsch_decoding_data_2thread : ulsch_decoding_data;
+  eNB->te                   = dlsch_encoding;//(single_thread_flag==1) ? dlsch_encoding_2threads : dlsch_encoding;
+
+  RC.nb_CC[bodge_counter] = 1;
+
+  if (eNB->if_inst==0) {
+    eNB->if_inst = IF_Module_init(bodge_counter);
+  }
+
+  // This will cause phy_config_request to be installed. That will result in RRC configuring the PHY
+  // that will result in eNB->configured being set to TRUE.
+  // See we need to wait for that to happen otherwise the NFAPI message exchanges won't contain the right parameter values
+  if (RC.eNB[0][0]->if_inst==0 || RC.eNB[0][0]->if_inst->PHY_config_req==0 || RC.eNB[0][0]->if_inst->schedule_response==0)
+  {
+    printf("RC.eNB[0][0]->if_inst->PHY_config_req is not installed - install it\n");
+    install_schedule_handlers(RC.eNB[0][0]->if_inst);
+  }
+
+  do {
+    printf("%s() Waiting for eNB to become configured (by RRC/PHY) - need to wait otherwise NFAPI messages won't contain correct values\n", __FUNCTION__);
+    usleep(50000);
+  } while(eNB->configured != 1);
+  printf("%s() eNB is now configured\n", __FUNCTION__);
+}
+
+void oai_enb_init(void)
+{
+  printf("%s() About to call init_eNB_afterRU()\n", __FUNCTION__);
+  init_eNB_afterRU();
+}
+
+int pnf_connection_indication_cb(nfapi_vnf_config_t* config, int p5_idx)
+{
+  printf("[VNF] pnf connection indication idx:%d\n", p5_idx);
+
+  //pnf_info pnf;
+  //vnf_info* vnf = (vnf_info*)(config->user_data);
+  //vnf->pnfs.insert(std::pair<uint16_t, pnf_info>(p5_idx, pnf));
+
+  oai_create_enb();
+
+  nfapi_pnf_param_request_t req;
+  memset(&req, 0, sizeof(req));
+  req.header.message_id = NFAPI_PNF_PARAM_REQUEST;
+  nfapi_vnf_pnf_param_req(config, p5_idx, &req);
+  return 0;
+}
+
+int pnf_disconnection_indication_cb(nfapi_vnf_config_t* config, int p5_idx)
+{
+  printf("[VNF] pnf disconnection indication idx:%d\n", p5_idx);
+
+  vnf_info* vnf = (vnf_info*)(config->user_data);
+#if 0
+  auto find_result = vnf->pnfs.find(p5_idx);
+
+  if(find_result != vnf->pnfs.end())
+  {
+    pnf_info& pnf = find_result->second;
+
+    for(phy_info& phy : pnf.phys)
+    {
+      vnf_p7_info& p7_vnf = vnf->p7_vnfs[0];
+      nfapi_vnf_p7_del_pnf((p7_vnf.config.get()), phy.id);
+    }
+  }
+#else
+  pnf_info *pnf = vnf->pnfs;
+  phy_info *phy = pnf->phys;
+
+  vnf_p7_info* p7_vnf = vnf->p7_vnfs;
+  // DJP nfapi_vnf_p7_del_pnf((p7_vnf->config.get()), phy->id);
+  nfapi_vnf_p7_del_pnf((p7_vnf->config), phy->id);
+#endif
+
+  return 0;
+}
+
+int pnf_param_resp_cb(nfapi_vnf_config_t* config, int p5_idx, nfapi_pnf_param_response_t* resp)
+{
+  printf("[VNF] pnf param response idx:%d error:%d\n", p5_idx, resp->error_code);
+
+  vnf_info* vnf = (vnf_info*)(config->user_data);
+
+#if 0
+  auto find_result = vnf->pnfs.find(p5_idx);
+  if(find_result != vnf->pnfs.end())
+  {
+    pnf_info& pnf = find_result->second;
+#else
+    {
+      pnf_info *pnf = vnf->pnfs;
+#endif
+
+      for(int i = 0; i < resp->pnf_phy.number_of_phys; ++i)
+      {
+        phy_info phy;
+        phy.index = resp->pnf_phy.phy[i].phy_config_index;
+
+        printf("[VNF] (PHY:%d) phy_config_idx:%d\n", i, resp->pnf_phy.phy[i].phy_config_index);
+
+        nfapi_vnf_allocate_phy(config, p5_idx, &(phy.id));
+
+        for(int j = 0; j < resp->pnf_phy.phy[i].number_of_rfs; ++j)
+        {
+          printf("[VNF] (PHY:%d) (RF%d) %d\n", i, j, resp->pnf_phy.phy[i].rf_config[j].rf_config_index);
+          phy.rfs[0] = resp->pnf_phy.phy[i].rf_config[j].rf_config_index;
+        }
+
+        pnf->phys[0] = phy;
+      }
+
+      for(int i = 0; i < resp->pnf_rf.number_of_rfs; ++i)
+      {
+        rf_info rf;
+        rf.index = resp->pnf_rf.rf[i].rf_config_index;
+
+        printf("[VNF] (RF:%d) rf_config_idx:%d\n", i, resp->pnf_rf.rf[i].rf_config_index);
+
+        pnf->rfs[0] = rf;
+    }
+
+    nfapi_pnf_config_request_t req;
+    memset(&req, 0, sizeof(req));
+    req.header.message_id = NFAPI_PNF_CONFIG_REQUEST;
+
+    req.pnf_phy_rf_config.tl.tag = NFAPI_PNF_PHY_RF_TAG;
+    req.pnf_phy_rf_config.number_phy_rf_config_info = 2; // DJP pnf.phys.size();
+    printf("DJP:Hard coded num phy rf to 2\n");
+
+    // DJP for(unsigned i = 0; i < pnf.phys.size(); ++i)
+    for(unsigned i = 0; i < 2; ++i)
+    {
+      req.pnf_phy_rf_config.phy_rf_config[i].phy_id = pnf->phys[i].id;
+      req.pnf_phy_rf_config.phy_rf_config[i].phy_config_index = pnf->phys[i].index;
+      req.pnf_phy_rf_config.phy_rf_config[i].rf_config_index = pnf->phys[i].rfs[0];
+    }
+
+    nfapi_vnf_pnf_config_req(config, p5_idx, &req);
+  }
+  return 0;
+}
+
+int pnf_config_resp_cb(nfapi_vnf_config_t* config, int p5_idx, nfapi_pnf_config_response_t* resp)
+{
+  printf("[VNF] pnf config response idx:%d resp[header[phy_id:%u message_id:%02x message_length:%u]]\n", p5_idx, resp->header.phy_id, resp->header.message_id, resp->header.message_length);
+
+  if(1)
+  {
+    //vnf_info* vnf = (vnf_info*)(config->user_data);
+#if 0
+    auto find_result = vnf->pnfs.find(p5_idx);
+    if(find_result != vnf->pnfs.end())
+    {
+      //pnf_info& pnf = find_result->second;
+    }
+#else
+      nfapi_pnf_start_request_t req;
+      memset(&req, 0, sizeof(req));
+      req.header.phy_id = resp->header.phy_id;
+      req.header.message_id = NFAPI_PNF_START_REQUEST;
+      nfapi_vnf_pnf_start_req(config, p5_idx, &req);
+#endif
+  }
+  else
+  {
+    // Rather than send the pnf_start_request we will demonstrate
+    // sending a vendor extention message. The start request will be
+    // send when the vendor extension response is received 
+
+    //vnf_info* vnf = (vnf_info*)(config->user_data);
+    vendor_ext_p5_req req;
+    memset(&req, 0, sizeof(req));
+    req.header.message_id = P5_VENDOR_EXT_REQ;
+    req.dummy1 = 45;
+    req.dummy2 = 1977;
+    nfapi_vnf_vendor_extension(config, p5_idx, &req.header);
+  }
+  return 0;
+}
+
+int wake_eNB_rxtx(PHY_VARS_eNB *eNB, uint16_t sfn, uint16_t sf)
+{
+  eNB_proc_t *proc=&eNB->proc;
+
+  eNB_rxtx_proc_t *proc_rxtx=&proc->proc_rxtx[sf&1];
+
+  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
+
+  //printf("%s(eNB:%p, sfn:%d, sf:%d)\n", __FUNCTION__, eNB, sfn, sf);
+
+  //int i;
+  struct timespec wait;
+
+  wait.tv_sec=0;
+  wait.tv_nsec=5000000L;
+
+#if 0
+  /* accept some delay in processing - up to 5ms */
+  for (i = 0; i < 10 && proc_rxtx->instance_cnt_rxtx == 0; i++) {
+    LOG_W( PHY,"[eNB] sfn/sf:%d:%d proc_rxtx[%d]:TXsfn:%d/%d eNB RXn-TXnp4 thread busy!! (cnt_rxtx %i)\n", sfn, sf, sf&1, proc_rxtx->frame_tx, proc_rxtx->subframe_tx, proc_rxtx->instance_cnt_rxtx);
+    usleep(500);
+  }
+  if (proc_rxtx->instance_cnt_rxtx == 0) {
+    exit_fun( "TX thread busy" );
+    return(-1);
+  }
+#endif
+
+  // wake up TX for subframe n+sf_ahead
+  // lock the TX mutex and make sure the thread is ready
+  if (pthread_mutex_timedlock(&proc_rxtx->mutex_rxtx,&wait) != 0) {
+    LOG_E( PHY, "[eNB] ERROR pthread_mutex_lock for eNB RXTX thread %d (IC %d)\n", proc_rxtx->subframe_rx&1,proc_rxtx->instance_cnt_rxtx );
+    exit_fun( "error locking mutex_rxtx" );
+    return(-1);
+  }
+
+  {
+    static uint16_t old_sf = 0;
+    static uint16_t old_sfn = 0;
+
+    proc->subframe_rx = old_sf;
+    proc->frame_rx = old_sfn;
+
+    // Try to be 1 frame back
+    old_sf = sf;
+    old_sfn = sfn;
+
+    if (old_sf == 0 && old_sfn % 100==0) LOG_W( PHY,"[eNB] sfn/sf:%d%d old_sfn/sf:%d%d proc[rx:%d%d]\n", sfn, sf, old_sfn, old_sf, proc->frame_rx, proc->subframe_rx);
+  }
+
+  ++proc_rxtx->instance_cnt_rxtx;
+
+  //LOG_E( PHY,"[VNF-subframe_ind] sfn/sf:%d:%d proc[frame_rx:%d subframe_rx:%d] proc_rxtx->instance_cnt_rxtx:%d \n", sfn, sf, proc->frame_rx, proc->subframe_rx, proc_rxtx->instance_cnt_rxtx);
+
+  // We have just received and processed the common part of a subframe, say n.
+  // TS_rx is the last received timestamp (start of 1st slot), TS_tx is the desired
+  // transmitted timestamp of the next TX slot (first).
+  // The last (TS_rx mod samples_per_frame) was n*samples_per_tti,
+  // we want to generate subframe (n+N), so TS_tx = TX_rx+N*samples_per_tti,
+  // and proc->subframe_tx = proc->subframe_rx+sf_ahead
+  proc_rxtx->timestamp_tx = proc->timestamp_rx + (sf_ahead*fp->samples_per_tti);
+  proc_rxtx->frame_rx     = proc->frame_rx;
+  proc_rxtx->subframe_rx  = proc->subframe_rx;
+  proc_rxtx->frame_tx     = (proc_rxtx->subframe_rx > (9-sf_ahead)) ? (proc_rxtx->frame_rx+1)&1023 : proc_rxtx->frame_rx;
+  proc_rxtx->subframe_tx  = (proc_rxtx->subframe_rx + sf_ahead)%10;
+
+  LOG_D(PHY, "sfn/sf:%d%d proc[rx:%d%d] proc_rxtx[instance_cnt_rxtx:%d rx:%d%d] About to wake rxtx thread\n\n", sfn, sf, proc->frame_rx, proc->subframe_rx, proc_rxtx->instance_cnt_rxtx, proc_rxtx->frame_rx, proc_rxtx->subframe_rx);
+
+  // the thread can now be woken up
+  if (pthread_cond_signal(&proc_rxtx->cond_rxtx) != 0) {
+    LOG_E( PHY, "[eNB] ERROR pthread_cond_signal for eNB RXn-TXnp4 thread\n");
+    exit_fun( "ERROR pthread_cond_signal" );
+    return(-1);
+  }
+
+  //LOG_D(PHY,"%s() About to attempt pthread_mutex_unlock\n", __FUNCTION__);
+  pthread_mutex_unlock( &proc_rxtx->mutex_rxtx );
+  //LOG_D(PHY,"%s() UNLOCKED pthread_mutex_unlock\n", __FUNCTION__);
+
+  return(0);
+}
+
+extern pthread_cond_t nfapi_sync_cond;
+extern pthread_mutex_t nfapi_sync_mutex;
+extern int nfapi_sync_var;
+
+int phy_sync_indication(struct nfapi_vnf_p7_config* config, uint8_t sync)
+{
+  //vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+
+  printf("[VNF] SYNC %s\n", sync==1 ? "ACHIEVED" : "LOST");
+  
+  if (1)
+  {
+    if (sync==1 && nfapi_sync_var!=0)
+    {
+
+      printf("[VNF] Signal to OAI main code that it can go\n");
+      pthread_mutex_lock(&nfapi_sync_mutex);
+      nfapi_sync_var=0;
+      pthread_cond_broadcast(&nfapi_sync_cond);
+      pthread_mutex_unlock(&nfapi_sync_mutex);
+    }
+  }
+
+  return(0);
+}
+
+int phy_subframe_indication(struct nfapi_vnf_p7_config* config, uint16_t phy_id, uint16_t sfn_sf)
+{
+  static uint8_t first_time = 1;
+  if (first_time)
+  {
+    printf("[VNF] subframe indication %d\n", NFAPI_SFNSF2DEC(sfn_sf));
+    first_time = 0;
+  }
+
+  // vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+  //mac_subframe_ind(p7_vnf->mac, phy_id, sfn_sf);
+
+#if 1
+  //if (RC.eNB) printf("RC.eNB[0][0]->configured:%d\n", RC.eNB[0][0]->configured);
+
+  if (RC.eNB && RC.eNB[0][0]->configured)
+  {
+    uint16_t sfn = NFAPI_SFNSF2SFN(sfn_sf);
+    uint16_t sf = NFAPI_SFNSF2SF(sfn_sf);
+
+    //LOG_E(PHY,"[VNF] subframe indication sfn_sf:%d sfn:%d sf:%d\n", sfn_sf, sfn, sf);
+
+    wake_eNB_rxtx(RC.eNB[0][0], sfn, sf);
+  }
+  else
+  {
+    printf("[VNF] %s() RC.eNB:%p\n", __FUNCTION__, RC.eNB);
+    if (RC.eNB) printf("RC.eNB[0][0]->configured:%d\n", RC.eNB[0][0]->configured);
+  }
+#endif
+
+  return 0;
+}
+
+int phy_rach_indication(struct nfapi_vnf_p7_config* config, nfapi_rach_indication_t* ind)
+{
+  LOG_E(MAC, "%s() NFAPI SFN/SF:%d number_of_preambles:%u\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->rach_indication_body.number_of_preambles);
+
+  struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
+
+  printf("[VNF] RACH_IND eNB:%p sfn_sf:%d number_of_preambles:%d\n", eNB, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->rach_indication_body.number_of_preambles);
+
+  pthread_mutex_lock(&eNB->UL_INFO_mutex);
+
+  eNB->UL_INFO.rach_ind = *ind;
+  eNB->UL_INFO.rach_ind.rach_indication_body.preamble_list                       = eNB->preamble_list;
+
+  for (int i=0;i<ind->rach_indication_body.number_of_preambles;i++)
+  {
+    if (ind->rach_indication_body.preamble_list[i].preamble_rel8.tl.tag == NFAPI_PREAMBLE_REL8_TAG)
+    {
+      printf("preamble[%d]: rnti:%02x preamble:%d timing_advance:%d\n", 
+          i,
+          ind->rach_indication_body.preamble_list[i].preamble_rel8.rnti,
+          ind->rach_indication_body.preamble_list[i].preamble_rel8.preamble,
+          ind->rach_indication_body.preamble_list[i].preamble_rel8.timing_advance
+          );
+    }
+
+    if(ind->rach_indication_body.preamble_list[i].preamble_rel13.tl.tag == NFAPI_PREAMBLE_REL13_TAG)
+    {
+      printf("RACH PREAMBLE REL13 present\n");
+    }
+
+    eNB->preamble_list[i] = ind->rach_indication_body.preamble_list[i];
+  }
+  pthread_mutex_unlock(&eNB->UL_INFO_mutex);
+
+
+  // vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+  //mac_rach_ind(p7_vnf->mac, ind);
+  return 1;
+}
+
+int phy_harq_indication(struct nfapi_vnf_p7_config* config, nfapi_harq_indication_t* ind)
+{
+  struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
+
+  LOG_D(MAC, "%s() NFAPI SFN/SF:%d number_of_harqs:%u\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->harq_indication_body.number_of_harqs);
+
+  pthread_mutex_lock(&eNB->UL_INFO_mutex);
+
+  eNB->UL_INFO.harq_ind = *ind;
+  eNB->UL_INFO.harq_ind.harq_indication_body.harq_pdu_list = eNB->harq_pdu_list;
+
+  for (int i=0; i<ind->harq_indication_body.number_of_harqs; i++)
+  {
+    memcpy(&eNB->UL_INFO.harq_ind.harq_indication_body.harq_pdu_list[i], &ind->harq_indication_body.harq_pdu_list[i], sizeof(eNB->UL_INFO.harq_ind.harq_indication_body.harq_pdu_list[i]));
+  }
+
+  pthread_mutex_unlock(&eNB->UL_INFO_mutex);
+
+  // vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+  //mac_harq_ind(p7_vnf->mac, ind);
+  return 1;
+}
+
+int phy_crc_indication(struct nfapi_vnf_p7_config* config, nfapi_crc_indication_t* ind)
+{
+  struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
+
+  pthread_mutex_lock(&eNB->UL_INFO_mutex);
+
+  eNB->UL_INFO.crc_ind = *ind;
+
+  nfapi_crc_indication_t *dest_ind = &eNB->UL_INFO.crc_ind;
+  nfapi_crc_indication_pdu_t *dest_pdu_list = eNB->crc_pdu_list;
+
+  *dest_ind = *ind;
+  dest_ind->crc_indication_body.crc_pdu_list = dest_pdu_list;
+
+  if (ind->crc_indication_body.number_of_crcs==0)
+    LOG_E(MAC, "%s() NFAPI SFN/SF:%d IND:number_of_crcs:%u UL_INFO:crcs:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->crc_indication_body.number_of_crcs, eNB->UL_INFO.crc_ind.crc_indication_body.number_of_crcs);
+
+  for (int i=0; i<ind->crc_indication_body.number_of_crcs; i++)
+  {
+    memcpy(&dest_ind->crc_indication_body.crc_pdu_list[i], &ind->crc_indication_body.crc_pdu_list[i], sizeof(ind->crc_indication_body.crc_pdu_list[0]));
+
+    LOG_D(MAC, "%s() NFAPI SFN/SF:%d CRC_IND:number_of_crcs:%u UL_INFO:crcs:%d PDU[%d] rnti:%04x UL_INFO:rnti:%04x\n", 
+        __FUNCTION__,
+        NFAPI_SFNSF2DEC(ind->sfn_sf), ind->crc_indication_body.number_of_crcs, eNB->UL_INFO.crc_ind.crc_indication_body.number_of_crcs,
+        i, 
+        ind->crc_indication_body.crc_pdu_list[i].rx_ue_information.rnti, 
+        eNB->UL_INFO.crc_ind.crc_indication_body.crc_pdu_list[i].rx_ue_information.rnti);
+
+  }
+
+  pthread_mutex_unlock(&eNB->UL_INFO_mutex);
+
+  // vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+	//mac_crc_ind(p7_vnf->mac, ind);
+  return 1;
+}
+
+int phy_rx_indication(struct nfapi_vnf_p7_config* config, nfapi_rx_indication_t* ind)
+{
+  struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
+
+  if (ind->rx_indication_body.number_of_pdus==0)
+  {
+    LOG_E(MAC, "%s() NFAPI SFN/SF:%d number_of_pdus:%u\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->rx_indication_body.number_of_pdus);
+  }
+
+  pthread_mutex_lock(&eNB->UL_INFO_mutex);
+
+  nfapi_rx_indication_t *dest_ind = &eNB->UL_INFO.rx_ind;
+  nfapi_rx_indication_pdu_t *dest_pdu_list = eNB->rx_pdu_list;
+
+  *dest_ind = *ind;
+  dest_ind->rx_indication_body.rx_pdu_list = dest_pdu_list;
+
+  for(int i=0; i<ind->rx_indication_body.number_of_pdus; i++)
+  {
+    nfapi_rx_indication_pdu_t *dest_pdu = &dest_ind->rx_indication_body.rx_pdu_list[i];
+    nfapi_rx_indication_pdu_t *src_pdu = &ind->rx_indication_body.rx_pdu_list[i];
+
+    memcpy(dest_pdu, src_pdu, sizeof(*src_pdu));
+
+    // DJP - TODO FIXME - intentional memory leak
+    dest_pdu->data = malloc(dest_pdu->rx_indication_rel8.length);
+
+    memcpy(dest_pdu->data, src_pdu->data, dest_pdu->rx_indication_rel8.length);
+
+    LOG_E(PHY, "%s() NFAPI SFN/SF:%d PDUs:%d [PDU:%d] handle:%d rnti:%04x length:%d offset:%d ul_cqi:%d ta:%d data:%p\n",
+        __FUNCTION__,
+        NFAPI_SFNSF2DEC(ind->sfn_sf), ind->rx_indication_body.number_of_pdus, i,
+        dest_pdu->rx_ue_information.handle,
+        dest_pdu->rx_ue_information.rnti,
+        dest_pdu->rx_indication_rel8.length,
+        dest_pdu->rx_indication_rel8.offset,
+        dest_pdu->rx_indication_rel8.ul_cqi,
+        dest_pdu->rx_indication_rel8.timing_advance,
+        dest_pdu->data
+        );
+  }
+
+  pthread_mutex_unlock(&eNB->UL_INFO_mutex);
+
+  // vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+  //mac_rx_ind(p7_vnf->mac, ind);
+  return 1;
+}
+int phy_srs_indication(struct nfapi_vnf_p7_config* config, nfapi_srs_indication_t* ind)
+{
+	// vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+	//mac_srs_ind(p7_vnf->mac, ind);
+	return 1;
+}
+int phy_sr_indication(struct nfapi_vnf_p7_config* config, nfapi_sr_indication_t* ind)
+{
+
+  struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
+
+  LOG_D(MAC, "%s() NFAPI SFN/SF:%d srs:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->sr_indication_body.number_of_srs);
+
+  pthread_mutex_lock(&eNB->UL_INFO_mutex);
+
+  nfapi_sr_indication_t *dest_ind = &eNB->UL_INFO.sr_ind;
+  nfapi_sr_indication_pdu_t *dest_pdu_list = eNB->sr_pdu_list;
+
+  *dest_ind = *ind;
+  dest_ind->sr_indication_body.sr_pdu_list = dest_pdu_list;
+
+  LOG_D(MAC,"%s() eNB->UL_INFO.sr_ind.sr_indication_body.number_of_srs:%d\n", __FUNCTION__, eNB->UL_INFO.sr_ind.sr_indication_body.number_of_srs);
+
+  for (int i=0;i<eNB->UL_INFO.sr_ind.sr_indication_body.number_of_srs;i++)
+  {
+    nfapi_sr_indication_pdu_t *dest_pdu = &dest_ind->sr_indication_body.sr_pdu_list[i];
+    nfapi_sr_indication_pdu_t *src_pdu = &ind->sr_indication_body.sr_pdu_list[i];
+
+    LOG_D(MAC, "SR_IND[PDU:%d][rnti:%x cqi:%d channel:%d]\n", i, src_pdu->rx_ue_information.rnti, src_pdu->ul_cqi_information.ul_cqi, src_pdu->ul_cqi_information.channel);
+
+    memcpy(dest_pdu, src_pdu, sizeof(*src_pdu));
+  }
+
+  pthread_mutex_unlock(&eNB->UL_INFO_mutex);
+
+  // vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+  //mac_sr_ind(p7_vnf->mac, ind);
+  return 1;
+}
+
+int phy_cqi_indication(struct nfapi_vnf_p7_config* config, nfapi_cqi_indication_t* ind)
+{
+  // vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+  //mac_cqi_ind(p7_vnf->mac, ind);
+  struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
+
+  LOG_E(MAC, "%s() NFAPI SFN/SF:%d number_of_cqis:%u\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->cqi_indication_body.number_of_cqis);
+
+  pthread_mutex_lock(&eNB->UL_INFO_mutex);
+
+  eNB->UL_INFO.cqi_ind = ind->cqi_indication_body;
+
+  pthread_mutex_unlock(&eNB->UL_INFO_mutex);
+
+  return 1;
+}
+
+int phy_lbt_dl_indication(struct nfapi_vnf_p7_config* config, nfapi_lbt_dl_indication_t* ind)
+{
+	// vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+	//mac_lbt_dl_ind(p7_vnf->mac, ind);
+	return 1;
+}
+int phy_nb_harq_indication(struct nfapi_vnf_p7_config* config, nfapi_nb_harq_indication_t* ind)
+{
+	// vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+	//mac_nb_harq_ind(p7_vnf->mac, ind);
+	return 1;
+}
+int phy_nrach_indication(struct nfapi_vnf_p7_config* config, nfapi_nrach_indication_t* ind)
+{
+	// vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
+	//mac_nrach_ind(p7_vnf->mac, ind);
+	return 1;
+}
+
+void* vnf_allocate(size_t size)
+{
+	//return (void*)memory_pool::allocate(size);
+	return (void*)malloc(size);
+}
+
+void vnf_deallocate(void* ptr)
+{
+	//memory_pool::deallocate((uint8_t*)ptr);
+	free(ptr);
+}
+
+extern void nfapi_log(char *file, char *func, int line, int comp, int level, const char* format, va_list args);
+void vnf_trace(nfapi_trace_level_t nfapi_level, const char* message, ...)
+{
+#if 1
+
+  va_list    args;
+  int oai_level;
+
+  if (nfapi_level==NFAPI_TRACE_ERROR)
+  {
+    oai_level = LOG_ERR;
+  }
+  else if (nfapi_level==NFAPI_TRACE_WARN)
+  {
+    oai_level = LOG_WARNING;
+  }
+  else if (nfapi_level==NFAPI_TRACE_NOTE)
+  {
+    oai_level = LOG_INFO;
+  }
+  else if (nfapi_level==NFAPI_TRACE_INFO)
+  {
+    oai_level = LOG_INFO;
+  }
+  else
+  {
+    oai_level = LOG_INFO;
+  }
+
+  va_start(args, message);
+  nfapi_log("FILE>", "FUNC", 999, PHY, oai_level, message, args);
+  va_end(args);
+#else
+  va_list args;
+  va_start(args, message);
+  vprintf(message, args);
+  va_end(args);
+#endif
+}
+
+int phy_vendor_ext(struct nfapi_vnf_p7_config* config, nfapi_p7_message_header_t* msg)
+{
+	if(msg->message_id == P7_VENDOR_EXT_IND)
+	{
+		//vendor_ext_p7_ind* ind = (vendor_ext_p7_ind*)msg;
+		//printf("[VNF] vendor_ext (error_code:%d)\n", ind->error_code);
+	}
+	else
+	{
+		printf("[VNF] unknown %02x\n", msg->message_id);
+	}
+	return 0;
+}
+
+nfapi_p7_message_header_t* phy_allocate_p7_vendor_ext(uint16_t message_id, uint16_t* msg_size)
+{
+	if(message_id == P7_VENDOR_EXT_IND)
+	{
+		*msg_size = sizeof(vendor_ext_p7_ind);
+		return (nfapi_p7_message_header_t*)malloc(sizeof(vendor_ext_p7_ind));
+	}
+	return 0;
+}
+
+void phy_deallocate_p7_vendor_ext(nfapi_p7_message_header_t* header)
+{
+	free(header);
+}
+
+/// maybe these should be in the mac file...
+int phy_unpack_vendor_extension_tlv(nfapi_tl_t* tl, uint8_t **ppReadPackedMessage, uint8_t *end, void** ve, nfapi_p7_codec_config_t* codec)
+{
+	(void)tl;
+	(void)ppReadPackedMessage;
+	(void)ve;
+	return -1;
+}
+
+int phy_pack_vendor_extension_tlv(void* ve, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* codec)
+{
+	//NFAPI_TRACE(NFAPI_TRACE_INFO, "phy_pack_vendor_extension_tlv\n");
+
+	nfapi_tl_t* tlv = (nfapi_tl_t*)ve;
+	switch(tlv->tag)
+	{
+		case VENDOR_EXT_TLV_1_TAG:
+			{
+				//NFAPI_TRACE(NFAPI_TRACE_INFO, "Packing VENDOR_EXT_TLV_1\n");
+				vendor_ext_tlv_1* ve = (vendor_ext_tlv_1*)tlv;
+				if(!push32(ve->dummy, ppWritePackedMsg, end))
+					return 0;
+				return 1;
+			}
+			break;
+		default:
+			return -1;
+			break;
+	}
+}
+
+int phy_unpack_p7_vendor_extension(nfapi_p7_message_header_t* header, uint8_t** ppReadPackedMessage, uint8_t *end, nfapi_p7_codec_config_t* config)
+{
+	//NFAPI_TRACE(NFAPI_TRACE_INFO, "%s\n", __FUNCTION__);
+	if(header->message_id == P7_VENDOR_EXT_IND)
+	{
+		vendor_ext_p7_ind* req = (vendor_ext_p7_ind*)(header);
+		if(!pull16(ppReadPackedMessage, &req->error_code, end))
+			return 0;
+	}
+	return 1;
+}
+
+int phy_pack_p7_vendor_extension(nfapi_p7_message_header_t* header, uint8_t** ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* config)
+{
+	//NFAPI_TRACE(NFAPI_TRACE_INFO, "%s\n", __FUNCTION__);
+	if(header->message_id == P7_VENDOR_EXT_REQ)
+	{
+		//NFAPI_TRACE(NFAPI_TRACE_INFO, "%s\n", __FUNCTION__);
+		vendor_ext_p7_req* req = (vendor_ext_p7_req*)(header);
+		if(!(push16(req->dummy1, ppWritePackedMsg, end) &&
+			 push16(req->dummy2, ppWritePackedMsg, end)))
+			return 0;
+	}
+	return 1;
+}
+
+int vnf_pack_p4_p5_vendor_extension(nfapi_p4_p5_message_header_t* header, uint8_t** ppWritePackedMsg, uint8_t *end, nfapi_p4_p5_codec_config_t* codec)
+{
+	//NFAPI_TRACE(NFAPI_TRACE_INFO, "%s\n", __FUNCTION__);
+	if(header->message_id == P5_VENDOR_EXT_REQ)
+	{
+		vendor_ext_p5_req* req = (vendor_ext_p5_req*)(header);
+		//NFAPI_TRACE(NFAPI_TRACE_INFO, "%s %d %d\n", __FUNCTION__, req->dummy1, req->dummy2);
+		return (!(push16(req->dummy1, ppWritePackedMsg, end) &&
+				  push16(req->dummy2, ppWritePackedMsg, end)));
+	}
+	return 0;
+}
+
+static pthread_t vnf_start_pthread;
+static pthread_t vnf_p7_start_pthread;
+void* vnf_p7_start_thread(void *ptr)
+{
+  printf("%s()\n", __FUNCTION__);
+
+  nfapi_vnf_p7_config_t* config = (nfapi_vnf_p7_config_t*)ptr;
+
+  nfapi_vnf_p7_start(config);
+
+  return config;
+}
+
+void set_thread_priority(int priority);
+
+void* vnf_p7_thread_start(void* ptr)
+{
+	set_thread_priority(79);
+
+	vnf_p7_info* p7_vnf = (vnf_p7_info*)ptr;
+
+	p7_vnf->config->port = p7_vnf->local_port;
+	p7_vnf->config->sync_indication = &phy_sync_indication;
+	p7_vnf->config->subframe_indication = &phy_subframe_indication;
+	p7_vnf->config->harq_indication = &phy_harq_indication;
+	p7_vnf->config->crc_indication = &phy_crc_indication;
+	p7_vnf->config->rx_indication = &phy_rx_indication;
+	p7_vnf->config->rach_indication = &phy_rach_indication;
+	p7_vnf->config->srs_indication = &phy_srs_indication;
+	p7_vnf->config->sr_indication = &phy_sr_indication;
+	p7_vnf->config->cqi_indication = &phy_cqi_indication;
+	p7_vnf->config->lbt_dl_indication = &phy_lbt_dl_indication;
+	p7_vnf->config->nb_harq_indication = &phy_nb_harq_indication;
+	p7_vnf->config->nrach_indication = &phy_nrach_indication;
+	p7_vnf->config->malloc = &vnf_allocate;
+	p7_vnf->config->free = &vnf_deallocate;
+
+	p7_vnf->config->trace = &vnf_trace;
+
+	p7_vnf->config->vendor_ext = &phy_vendor_ext;
+	p7_vnf->config->user_data = p7_vnf;
+
+	p7_vnf->mac->user_data = p7_vnf;
+
+	p7_vnf->config->codec_config.unpack_p7_vendor_extension = &phy_unpack_p7_vendor_extension;
+	p7_vnf->config->codec_config.pack_p7_vendor_extension = &phy_pack_p7_vendor_extension;
+	p7_vnf->config->codec_config.unpack_vendor_extension_tlv = &phy_unpack_vendor_extension_tlv;
+	p7_vnf->config->codec_config.pack_vendor_extension_tlv = &phy_pack_vendor_extension_tlv;
+	p7_vnf->config->codec_config.allocate = &vnf_allocate;
+	p7_vnf->config->codec_config.deallocate = &vnf_deallocate;
+
+	p7_vnf->config->allocate_p7_vendor_ext = &phy_allocate_p7_vendor_ext;
+	p7_vnf->config->deallocate_p7_vendor_ext = &phy_deallocate_p7_vendor_ext;
+
+        {
+          NFAPI_TRACE(NFAPI_TRACE_INFO, "[VNF] Creating VNF NFAPI start thread %s\n", __FUNCTION__);
+          pthread_create(&vnf_p7_start_pthread, NULL, &vnf_p7_start_thread, p7_vnf->config);
+        }
+	return 0;
+}
+
+int pnf_start_resp_cb(nfapi_vnf_config_t* config, int p5_idx, nfapi_pnf_start_response_t* resp)
+{
+  vnf_info* vnf = (vnf_info*)(config->user_data);
+  vnf_p7_info *p7_vnf = vnf->p7_vnfs;
+
+  printf("[VNF] pnf start response idx:%d config:%p user_data:%p p7_vnf[config:%p thread_started:%d]\n", p5_idx, config, config->user_data, vnf->p7_vnfs[0].config, vnf->p7_vnfs[0].thread_started);
+
+  if(p7_vnf->thread_started == 0)
+  {
+    pthread_t vnf_p7_thread;
+    pthread_create(&vnf_p7_thread, NULL, &vnf_p7_thread_start, p7_vnf);
+    p7_vnf->thread_started = 1;
+  }
+  else
+  {
+    // P7 thread already running. 
+  }
+
+  // start all the phys in the pnf.
+
+#if 0
+  auto find_result = vnf->pnfs.find(p5_idx);
+  if(find_result != vnf->pnfs.end())
+  {
+    pnf_info& pnf = find_result->second;
+
+    for(unsigned i = 0; i < pnf.phys.size(); ++i)
+    {
+      pnf_info& pnf = find_result->second;
+    }
+  }
+#else
+  {
+    pnf_info *pnf = vnf->pnfs;
+    nfapi_param_request_t req;
+
+    printf("[VNF] Sending NFAPI_PARAM_REQUEST phy_id:%d\n", pnf->phys[0].id);
+
+    memset(&req, 0, sizeof(req));
+    req.header.message_id = NFAPI_PARAM_REQUEST;
+    req.header.phy_id = pnf->phys[0].id;
+
+    nfapi_vnf_param_req(config, p5_idx, &req);
+  }
+#endif
+
+  return 0;
+}
+
+extern uint32_t to_earfcn(int eutra_bandP,uint32_t dl_CarrierFreq,uint32_t bw);
+
+int param_resp_cb(nfapi_vnf_config_t* config, int p5_idx, nfapi_param_response_t* resp)
+{
+  printf("[VNF] Received NFAPI_PARAM_RESP idx:%d phy_id:%d\n", p5_idx, resp->header.phy_id);
+
+  vnf_info* vnf = (vnf_info*)(config->user_data);
+
+#if 0
+  auto find_result = vnf->pnfs.find(p5_idx);
+  if(find_result != vnf->pnfs.end())
+  {
+    pnf_info& pnf = find_result->second;
+
+    auto found = std::find_if(pnf.phys.begin(), pnf.phys.end(), [&](phy_info& item)
+        { return item.id == resp->header.phy_id; });
+
+    if(found != pnf.phys.end())
+    {
+      phy_info& phy = (*found);
+#else
+  pnf_info *pnf = vnf->pnfs;
+  phy_info *phy = pnf->phys;
+  {
+    {
+#endif
+
+      phy->remote_port = resp->nfapi_config.p7_pnf_port.value;
+
+      struct sockaddr_in pnf_p7_sockaddr;
+      memcpy(&pnf_p7_sockaddr.sin_addr.s_addr, &(resp->nfapi_config.p7_pnf_address_ipv4.address[0]), 4);
+
+      phy->remote_addr = inet_ntoa(pnf_p7_sockaddr.sin_addr);
+
+      // for now just 1
+      vnf_p7_info *p7_vnf = vnf->p7_vnfs;
+
+      printf("[VNF] %d.%d pnf p7 %s:%d timing %d %d %d %d\n", p5_idx, phy->id, phy->remote_addr, phy->remote_port, p7_vnf->timing_window, p7_vnf->periodic_timing_period, p7_vnf->aperiodic_timing_enabled, p7_vnf->periodic_timing_period);
+
+      nfapi_config_request_t *req = &RC.mac[0]->config[0];
+
+      //memset(&req, 0, sizeof(req));
+      req->header.message_id = NFAPI_CONFIG_REQUEST;
+      req->header.phy_id = phy->id;
+
+      printf("[VNF] Send NFAPI_CONFIG_REQUEST\n");
+
+      req->nfapi_config.p7_vnf_port.tl.tag = NFAPI_NFAPI_P7_VNF_PORT_TAG;
+      req->nfapi_config.p7_vnf_port.value = p7_vnf->local_port;
+      req->num_tlv++;
+
+printf("[VNF] DJP local_port:%d\n", p7_vnf->local_port);
+
+      req->nfapi_config.p7_vnf_address_ipv4.tl.tag = NFAPI_NFAPI_P7_VNF_ADDRESS_IPV4_TAG;
+      struct sockaddr_in vnf_p7_sockaddr;
+      vnf_p7_sockaddr.sin_addr.s_addr = inet_addr(p7_vnf->local_addr);
+      memcpy(&(req->nfapi_config.p7_vnf_address_ipv4.address[0]), &vnf_p7_sockaddr.sin_addr.s_addr, 4);
+      req->num_tlv++;
+printf("[VNF] DJP local_addr:%s\n", p7_vnf->local_addr);
+
+      req->nfapi_config.timing_window.tl.tag = NFAPI_NFAPI_TIMING_WINDOW_TAG;
+      req->nfapi_config.timing_window.value = p7_vnf->timing_window;
+printf("[VNF] Timing window:%d\n", p7_vnf->timing_window);
+      req->num_tlv++;
+
+      if(p7_vnf->periodic_timing_enabled || p7_vnf->aperiodic_timing_enabled)
+      {
+        req->nfapi_config.timing_info_mode.tl.tag = NFAPI_NFAPI_TIMING_INFO_MODE_TAG;
+        req->nfapi_config.timing_info_mode.value = (p7_vnf->aperiodic_timing_enabled << 1) | (p7_vnf->periodic_timing_enabled);
+        req->num_tlv++;
+
+        if(p7_vnf->periodic_timing_enabled)
+        {
+          req->nfapi_config.timing_info_period.tl.tag = NFAPI_NFAPI_TIMING_INFO_PERIOD_TAG;
+          req->nfapi_config.timing_info_period.value = p7_vnf->periodic_timing_period;
+          req->num_tlv++;
+        }
+      }
+
+      vendor_ext_tlv_2 ve2;
+      memset(&ve2, 0, sizeof(ve2));
+      ve2.tl.tag = VENDOR_EXT_TLV_2_TAG;
+      ve2.dummy = 2016;
+      req->vendor_extension = &ve2.tl;
+
+      nfapi_vnf_config_req(config, p5_idx, req);
+      printf("[VNF] Sent NFAPI_CONFIG_REQ num_tlv:%u\n",req->num_tlv);
+    }
+#if 0
+    else
+    {
+      printf("[VNF] param response failed to find pnf %d phy %d\n", p5_idx, resp->header.phy_id);
+    }
+#endif
+  }
+#if 0
+  else
+  {
+    printf("[VNF] param response failed to find pnf %d\n", p5_idx);
+  }
+#endif
+
+  return 0;
+}
+
+int config_resp_cb(nfapi_vnf_config_t* config, int p5_idx, nfapi_config_response_t* resp)
+{
+  nfapi_start_request_t req;
+
+  printf("[VNF] Received NFAPI_CONFIG_RESP idx:%d phy_id:%d\n", p5_idx, resp->header.phy_id);
+
+  printf("[VNF] Calling oai_enb_init()\n");
+  oai_enb_init();
+
+  memset(&req, 0, sizeof(req));
+  req.header.message_id = NFAPI_START_REQUEST;
+  req.header.phy_id = resp->header.phy_id;
+  nfapi_vnf_start_req(config, p5_idx, &req);
+
+  printf("[VNF] Send NFAPI_START_REQUEST idx:%d phy_id:%d\n", p5_idx, resp->header.phy_id);
+
+  return 0;
+}
+
+int start_resp_cb(nfapi_vnf_config_t* config, int p5_idx, nfapi_start_response_t* resp)
+{
+  printf("[VNF] Received NFAPI_START_RESP idx:%d phy_id:%d\n", p5_idx, resp->header.phy_id);
+
+  vnf_info* vnf = (vnf_info*)(config->user_data);
+
+#if 0
+  auto find_result = vnf->pnfs.find(p5_idx);
+  if(find_result != vnf->pnfs.end())
+  {
+    pnf_info& pnf = find_result->second;
+
+
+    auto found = std::find_if(pnf.phys.begin(), pnf.phys.end(), [&](phy_info& item)
+        { return item.id == resp->header.phy_id; });
+
+    if(found != pnf.phys.end())
+    {
+      phy_info& phy = (*found);
+
+      vnf_p7_info& p7_vnf = vnf->p7_vnfs[0];
+
+      nfapi_vnf_p7_add_pnf((p7_vnf.config.get()), phy.remote_addr.c_str(), phy.remote_port, phy.id);
+
+    }
+  }
+#else
+  pnf_info *pnf = vnf->pnfs;
+  phy_info *phy = pnf->phys;
+  vnf_p7_info *p7_vnf = vnf->p7_vnfs;
+  nfapi_vnf_p7_add_pnf((p7_vnf->config), phy->remote_addr, phy->remote_port, phy->id);
+
+
+#if 0
+  {
+    extern pthread_cond_t nfapi_sync_cond;
+    extern pthread_mutex_t nfapi_sync_mutex;
+    extern int nfapi_sync_var;
+
+    printf("[VNF] Signal to OAI main code that it can go\n");
+    pthread_mutex_lock(&nfapi_sync_mutex);
+    nfapi_sync_var=0;
+    pthread_cond_broadcast(&nfapi_sync_cond);
+    pthread_mutex_unlock(&nfapi_sync_mutex);
+  }
+#endif
+
+#endif
+
+  return 0;
+}
+
+int vendor_ext_cb(nfapi_vnf_config_t* config, int p5_idx, nfapi_p4_p5_message_header_t* msg)
+{
+  printf("[VNF] %s\n", __FUNCTION__);
+
+  switch(msg->message_id)
+  {
+    case P5_VENDOR_EXT_RSP:
+      {
+        vendor_ext_p5_rsp* rsp = (vendor_ext_p5_rsp*)msg;
+        printf("[VNF] P5_VENDOR_EXT_RSP error_code:%d\n", rsp->error_code);
+
+        // send the start request
+
+        nfapi_pnf_start_request_t req;
+        memset(&req, 0, sizeof(req));
+        req.header.message_id = NFAPI_PNF_START_REQUEST;
+        nfapi_vnf_pnf_start_req(config, p5_idx, &req);
+      }
+      break;
+  }
+
+  return 0;
+}
+
+int vnf_unpack_p4_p5_vendor_extension(nfapi_p4_p5_message_header_t* header, uint8_t** ppReadPackedMessage, uint8_t *end, nfapi_p4_p5_codec_config_t* codec)
+{
+  //NFAPI_TRACE(NFAPI_TRACE_INFO, "%s\n", __FUNCTION__);
+  if(header->message_id == P5_VENDOR_EXT_RSP)
+  {
+    vendor_ext_p5_rsp* req = (vendor_ext_p5_rsp*)(header);
+    return(!pull16(ppReadPackedMessage, &req->error_code, end));
+  }
+  return 0;
+}
+
+nfapi_p4_p5_message_header_t* vnf_allocate_p4_p5_vendor_ext(uint16_t message_id, uint16_t* msg_size)
+{
+  if(message_id == P5_VENDOR_EXT_RSP)
+  {
+    *msg_size = sizeof(vendor_ext_p5_rsp);
+    return (nfapi_p4_p5_message_header_t*)malloc(sizeof(vendor_ext_p5_rsp));
+  }
+  return 0;
+}
+
+void vnf_deallocate_p4_p5_vendor_ext(nfapi_p4_p5_message_header_t* header)
+{
+  free(header);
+}
+
+nfapi_vnf_config_t *config = 0;
+
+void vnf_start_thread(void* ptr)
+{
+  NFAPI_TRACE(NFAPI_TRACE_INFO, "[VNF] VNF NFAPI thread - nfapi_vnf_start()%s\n", __FUNCTION__);
+
+  config = (nfapi_vnf_config_t*)ptr;
+
+  nfapi_vnf_start(config);
+}
+
+static vnf_info vnf;
+extern uint8_t nfapi_mode;
+/*------------------------------------------------------------------------------*/
+void configure_nfapi_vnf(char *vnf_addr, int vnf_p5_port)
+{
+  nfapi_mode = 2;
+
+  memset(&vnf, 0, sizeof(vnf));
+
+  memset(vnf.p7_vnfs, 0, sizeof(vnf.p7_vnfs));
+
+  vnf.p7_vnfs[0].timing_window = 32;
+  vnf.p7_vnfs[0].periodic_timing_enabled = 1;
+  vnf.p7_vnfs[0].aperiodic_timing_enabled = 0;
+  vnf.p7_vnfs[0].periodic_timing_period = 10;
+
+  vnf.p7_vnfs[0].config = nfapi_vnf_p7_config_create();
+  NFAPI_TRACE(NFAPI_TRACE_INFO, "[VNF] %s() vnf.p7_vnfs[0].config:%p VNF ADDRESS:%s:%d\n", __FUNCTION__, vnf.p7_vnfs[0].config, vnf_addr, vnf_p5_port);
+
+  strcpy(vnf.p7_vnfs[0].local_addr, vnf_addr);
+  vnf.p7_vnfs[0].local_port = 50001;
+  vnf.p7_vnfs[0].mac = (mac_t*)malloc(sizeof(mac_t));
+
+  nfapi_vnf_config_t* config = nfapi_vnf_config_create();
+
+  config->malloc = malloc;
+  config->free = free;
+  config->trace = &vnf_trace;
+
+  config->vnf_p5_port = vnf_p5_port;
+  config->vnf_ipv4 = 1;
+  config->vnf_ipv6 = 0;
+
+  config->pnf_list = 0;
+  config->phy_list = 0;
+
+  config->pnf_connection_indication = &pnf_connection_indication_cb;
+  config->pnf_disconnect_indication = &pnf_disconnection_indication_cb;
+  config->pnf_param_resp = &pnf_param_resp_cb;
+  config->pnf_config_resp = &pnf_config_resp_cb;
+  config->pnf_start_resp = &pnf_start_resp_cb;
+  config->param_resp = &param_resp_cb;
+  config->config_resp = &config_resp_cb;
+  config->start_resp = &start_resp_cb;
+  config->vendor_ext = &vendor_ext_cb;
+
+  config->user_data = &vnf;
+
+  // To allow custom vendor extentions to be added to nfapi
+  config->codec_config.unpack_vendor_extension_tlv = &vnf_unpack_vendor_extension_tlv;
+  config->codec_config.pack_vendor_extension_tlv = &vnf_pack_vendor_extension_tlv;
+
+  config->codec_config.unpack_p4_p5_vendor_extension = &vnf_unpack_p4_p5_vendor_extension;
+  config->codec_config.pack_p4_p5_vendor_extension = &vnf_pack_p4_p5_vendor_extension;
+  config->allocate_p4_p5_vendor_ext = &vnf_allocate_p4_p5_vendor_ext;
+  config->deallocate_p4_p5_vendor_ext = &vnf_deallocate_p4_p5_vendor_ext;
+  config->codec_config.allocate = &vnf_allocate;
+  config->codec_config.deallocate = &vnf_deallocate;
+
+  {
+    NFAPI_TRACE(NFAPI_TRACE_INFO, "[VNF] Creating VNF NFAPI start thread %s\n", __FUNCTION__);
+    pthread_create(&vnf_start_pthread, NULL, (void*)&vnf_start_thread, config);
+    NFAPI_TRACE(NFAPI_TRACE_INFO, "[VNF] Created VNF NFAPI start thread %s\n", __FUNCTION__);
+  }
+}
+
+int oai_nfapi_dl_config_req(nfapi_dl_config_request_t *dl_config_req)
+{
+  nfapi_vnf_p7_config_t *p7_config = vnf.p7_vnfs[0].config;
+
+  dl_config_req->header.phy_id = 1; // DJP HACK TODO FIXME - need to pass this around!!!!
+  //dl_config_req->header.message_id = NFAPI_DL_CONFIG_BCH_PDU_TYPE;
+
+  //LOG_D(PHY, "[VNF] %s() header message_id:%02x\n", __FUNCTION__, dl_config_req->header.message_id);
+
+  //LOG_D(PHY, "[VNF] %s() DL_CONFIG sfn_sf:%d pdcch:%d dci:%d pdu:%d pdsch_rnti:%d pcfich:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(dl_config_req->sfn_sf), dl_config_req->dl_config_request_body.number_pdcch_ofdm_symbols, dl_config_req->dl_config_request_body.number_dci, dl_config_req->dl_config_request_body.number_pdu, dl_config_req->dl_config_request_body.number_pdsch_rnti, dl_config_req->dl_config_request_body.transmission_power_pcfich);
+
+  int retval = nfapi_vnf_p7_dl_config_req(p7_config, dl_config_req);
+
+  dl_config_req->dl_config_request_body.number_pdcch_ofdm_symbols           = 1;
+  dl_config_req->dl_config_request_body.number_dci                          = 0;
+  dl_config_req->dl_config_request_body.number_pdu                          = 0;
+  dl_config_req->dl_config_request_body.number_pdsch_rnti                   = 0;
+
+  if (retval!=0)
+  {
+    LOG_E(PHY, "%s() Problem sending retval:%d\n", __FUNCTION__, retval);
+  }
+  return retval;
+}
+
+int oai_nfapi_tx_req(nfapi_tx_request_t *tx_req)
+{
+  nfapi_vnf_p7_config_t *p7_config = vnf.p7_vnfs[0].config;
+
+  tx_req->header.phy_id = 1; // DJP HACK TODO FIXME - need to pass this around!!!!
+
+  //LOG_D(PHY, "[VNF] %s() TX_REQ sfn_sf:%d number_of_pdus:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(tx_req->sfn_sf), tx_req->tx_request_body.number_of_pdus);
+
+  int retval = nfapi_vnf_p7_tx_req(p7_config, tx_req);
+
+
+  if (retval!=0)
+  {
+    LOG_E(PHY, "%s() Problem sending retval:%d\n", __FUNCTION__, retval);
+  }
+  else
+  {
+    tx_req->tx_request_body.number_of_pdus = 0;
+  }
+  return retval;
+}
+
+int oai_nfapi_hi_dci0_req(nfapi_hi_dci0_request_t *hi_dci0_req)
+{
+  nfapi_vnf_p7_config_t *p7_config = vnf.p7_vnfs[0].config;
+
+  hi_dci0_req->header.phy_id = 1; // DJP HACK TODO FIXME - need to pass this around!!!!
+
+  //LOG_D(PHY, "[VNF] %s() HI_DCI0_REQ sfn_sf:%d dci:%d hi:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(hi_dci0_req->sfn_sf), hi_dci0_req->hi_dci0_request_body.number_of_dci, hi_dci0_req->hi_dci0_request_body.number_of_hi);
+
+  int retval = nfapi_vnf_p7_hi_dci0_req(p7_config, hi_dci0_req);
+
+
+  if (retval!=0)
+  {
+    LOG_E(PHY, "%s() Problem sending retval:%d\n", __FUNCTION__, retval);
+  }
+  else
+  {
+    hi_dci0_req->hi_dci0_request_body.number_of_hi = 0;
+    hi_dci0_req->hi_dci0_request_body.number_of_dci = 0;
+  }
+  return retval;
+}
+
+int oai_nfapi_ul_config_req(nfapi_ul_config_request_t *ul_config_req)
+{
+  nfapi_vnf_p7_config_t *p7_config = vnf.p7_vnfs[0].config;
+
+  ul_config_req->header.phy_id = 1; // DJP HACK TODO FIXME - need to pass this around!!!!
+
+  //LOG_D(PHY, "[VNF] %s() header message_id:%02x\n", __FUNCTION__, ul_config_req->header.message_id);
+
+  //LOG_D(PHY, "[VNF] %s() UL_CONFIG sfn_sf:%d PDUs:%d rach_prach_frequency_resources:%d srs_present:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(ul_config_req->sfn_sf), ul_config_req->ul_config_request_body.number_of_pdus, ul_config_req->ul_config_request_body.rach_prach_frequency_resources, ul_config_req->ul_config_request_body.srs_present);
+
+  int retval = nfapi_vnf_p7_ul_config_req(p7_config, ul_config_req);
+
+  if (retval!=0)
+  {
+    LOG_E(PHY, "%s() Problem sending retval:%d\n", __FUNCTION__, retval);
+  }
+  else
+  {
+    // Reset number of PDUs so that it is not resent
+    ul_config_req->ul_config_request_body.number_of_pdus = 0;
+    ul_config_req->ul_config_request_body.rach_prach_frequency_resources = 0;
+    ul_config_req->ul_config_request_body.srs_present = 0;
+  }
+  return retval;
+}

nfapi/nfapi_vnf.h

+#if !defined(NFAPI_VNF_H__)
+#define NFAPI_VNF_H__
+
+void configure_nfapi_vnf(char *vnf_addr, int vnf_p5_port);
+
+#endif

nfapi/vendor_ext.h

+/*
+ * Copyright 2017 Cisco Systems, Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * 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.
+ */
+
+#ifndef _VENDOR_EXT_H_
+#define _VENDOR_EXT_H_
+
+#include "nfapi_interface.h"
+
+typedef enum 
+{
+	P5_VENDOR_EXT_REQ = NFAPI_VENDOR_EXT_MSG_MIN,
+	P5_VENDOR_EXT_RSP,
+
+	P7_VENDOR_EXT_REQ,
+	P7_VENDOR_EXT_IND
+
+} vendor_ext_message_id_e;
+
+typedef struct {
+	nfapi_p4_p5_message_header_t header;
+	uint16_t dummy1;
+	uint16_t dummy2;
+} vendor_ext_p5_req;
+
+typedef struct {
+	nfapi_p4_p5_message_header_t header;
+	uint16_t error_code;
+} vendor_ext_p5_rsp;
+
+typedef struct {
+	nfapi_p7_message_header_t header;
+	uint16_t dummy1;
+	uint16_t dummy2;
+} vendor_ext_p7_req;
+
+typedef struct {
+	nfapi_p7_message_header_t header;
+	uint16_t error_code;
+} vendor_ext_p7_ind;
+
+typedef struct {
+	nfapi_tl_t tl;
+	uint32_t dummy;
+} vendor_ext_tlv_1;
+
+#define VENDOR_EXT_TLV_1_TAG 0xF001
+
+typedef struct {
+	nfapi_tl_t tl;
+	uint32_t dummy;
+} vendor_ext_tlv_2;
+
+#define VENDOR_EXT_TLV_2_TAG 0xF002
+
+
+
+
+#endif // _VENDOR_EXT_

oaienv

@@ -17,3 +17,11 @@ alias oait='cd $OPENAIR_TARGETS'
 alias oailte='cd $OPENAIR_TARGETS/RT/USER'
 alias oais='cd $OPENAIR_TARGETS/SIMU/USER'
 alias oaiex='cd $OPENAIR_TARGETS/SIMU/EXAMPLES'
+
+export NFAPI_DIR=${HOME}/open-nFAPI
+
+alias bld='cd $OPENAIR_HOME/cmake_targets ; ./build_oai --eNB -x -w USRP'
+alias b='cd $OPENAIR_HOME/cmake_targets ; ./build_oai --eNB -x -w USRP'
+alias run='cd $OPENAIR_HOME/cmake_targets/lte_build_oai/build'
+alias nf='cd $OPENAIR_HOME/nfapi'
+alias conf='cd $OPENAIR_HOME/targets/PROJECTS/GENERIC-LTE-EPC/CONF'

openair1/PHY/INIT/defs.h

@@ -356,6 +356,8 @@ void phy_cleanup(void);
 
 void phy_config_request(PHY_Config_t *phy_config);
 
+void phy_config_request_ue(UE_PHY_Config_t* UE_config_INFO);
+
 int init_frame_parms(LTE_DL_FRAME_PARMS *frame_parms,uint8_t osf);
 void dump_frame_parms(LTE_DL_FRAME_PARMS *frame_parms);
 

openair1/PHY/INIT/lte_init.c

@@ -32,6 +32,9 @@
 #include "assertions.h"
 #include <math.h>
 
+extern uint32_t from_earfcn(int eutra_bandP,uint32_t dl_earfcn);
+extern int32_t get_uldl_offset(int eutra_bandP);
+
 extern uint16_t prach_root_sequence_map0_3[838];
 extern uint16_t prach_root_sequence_map4[138];
 uint8_t dmrs1_tab[8] = {0,2,3,4,6,8,9,10};
@@ -42,24 +45,41 @@ int N_RB_DL_array[6] = {6,15,25,50,75,100};
 int l1_north_init_eNB() {
 
   int i,j;
-  AssertFatal(RC.nb_L1_inst>0,"nb_L1_inst=%d\n",RC.nb_L1_inst);
-  AssertFatal(RC.nb_L1_CC!=NULL,"nb_L1_CC is null\n");
-  AssertFatal(RC.eNB!=NULL,"RC.eNB is null\n");
-  for (i=0;i<RC.nb_L1_inst;i++) {
-    AssertFatal(RC.eNB[i]!=NULL,"RC.eNB[%d] is null\n",i);
-    AssertFatal(RC.nb_L1_CC[i]>0,"RC.nb_L1_CC[%d]=%d\n",i,RC.nb_L1_CC[i]);
-    for (j=0;j<RC.nb_L1_CC[i];j++) {
-      AssertFatal(RC.eNB[i][j]!=NULL,"RC.eNB[%d][%d] is null\n",i,j);
-      if ((RC.eNB[i][j]->if_inst =  IF_Module_init(i))<0) return(-1); 
-      RC.eNB[i][j]->if_inst->PHY_config_req = phy_config_request;
-      RC.eNB[i][j]->if_inst->schedule_response = schedule_response;
+
+  if (RC.nb_L1_inst > 0 && RC.nb_L1_CC != NULL && RC.eNB != NULL)
+  {
+    AssertFatal(RC.nb_L1_inst>0,"nb_L1_inst=%d\n",RC.nb_L1_inst);
+    AssertFatal(RC.nb_L1_CC!=NULL,"nb_L1_CC is null\n");
+    AssertFatal(RC.eNB!=NULL,"RC.eNB is null\n");
+
+    LOG_I(PHY,"%s() RC.nb_L1_inst:%d\n", __FUNCTION__, RC.nb_L1_inst);
+
+    for (i=0;i<RC.nb_L1_inst;i++) {
+      AssertFatal(RC.eNB[i]!=NULL,"RC.eNB[%d] is null\n",i);
+      AssertFatal(RC.nb_L1_CC[i]>0,"RC.nb_L1_CC[%d]=%d\n",i,RC.nb_L1_CC[i]);
+
+      LOG_I(PHY,"%s() RC.nb_L1_CC[%d]:%d\n", __FUNCTION__, i,  RC.nb_L1_CC[i]);
+
+      for (j=0;j<RC.nb_L1_CC[i];j++) {
+        AssertFatal(RC.eNB[i][j]!=NULL,"RC.eNB[%d][%d] is null\n",i,j);
+
+        if ((RC.eNB[i][j]->if_inst =  IF_Module_init(i))<0) return(-1); 
+
+        LOG_I(PHY,"%s() RC.eNB[%d][%d] installing callbacks\n", __FUNCTION__, i,  j);
+
+        RC.eNB[i][j]->if_inst->PHY_config_req = phy_config_request;
+        RC.eNB[i][j]->if_inst->schedule_response = schedule_response;
+      }
     }
   }
+  else
+  {
+    LOG_I(PHY,"%s() Not installing PHY callbacks - RC.nb_L1_inst:%d RC.nb_L1_CC:%p RC.eNB:%p\n", __FUNCTION__, RC.nb_L1_inst, RC.nb_L1_CC, RC.eNB);
+  }
   return(0);
 }
 
 
-
 void phy_config_request(PHY_Config_t *phy_config) {
 
   uint8_t Mod_id              = phy_config->Mod_id;
@@ -71,13 +91,14 @@ void phy_config_request(PHY_Config_t *phy_config) {
   PHICH_RESOURCE_t phich_resource_table[4]={oneSixth,half,one,two};
   int                 eutra_band     = cfg->nfapi_config.rf_bands.rf_band[0];  
   int                 dl_Bandwidth   = cfg->rf_config.dl_channel_bandwidth.value;
+  int                 ul_Bandwidth   = cfg->rf_config.ul_channel_bandwidth.value;
   int                 Nid_cell       = cfg->sch_config.physical_cell_id.value;
   int                 Ncp            = cfg->subframe_config.dl_cyclic_prefix_type.value;
   int                 p_eNB          = cfg->rf_config.tx_antenna_ports.value;
   uint32_t            dl_CarrierFreq = cfg->nfapi_config.earfcn.value;
 
-  LOG_I(PHY,"Configuring MIB for instance %d, CCid %d : (band %d,N_RB_DL %d,Nid_cell %d,p %d,Ncp %d,DL freq %u,phich_config.resource %d, phich_config.duration %d)\n",
-	Mod_id, CC_id, eutra_band, N_RB_DL_array[dl_Bandwidth], Nid_cell, p_eNB,Ncp,dl_CarrierFreq,
+  LOG_I(PHY,"Configuring MIB for instance %d, CCid %d : (band %d,N_RB_DL %d, N_RB_UL %d, Nid_cell %d,eNB_tx_antenna_ports %d,Ncp %d,DL freq %u,phich_config.resource %d, phich_config.duration %d)\n",
+	Mod_id, CC_id, eutra_band, dl_Bandwidth, ul_Bandwidth, Nid_cell, p_eNB,Ncp,dl_CarrierFreq,
 	cfg->phich_config.phich_resource.value,
 	cfg->phich_config.phich_duration.value);
 
@@ -86,13 +107,18 @@ void phy_config_request(PHY_Config_t *phy_config) {
   AssertFatal(RC.eNB[Mod_id][CC_id] != NULL, "PHY instance %d, CCid %d doesn't exist\n",Mod_id,CC_id);
 
 
+  if (RC.eNB[Mod_id][CC_id]->configured == 1)
+  {
+    LOG_E(PHY,"Already eNB already configured, do nothing\n");
+    return;
+  }
 
   RC.eNB[Mod_id][CC_id]->mac_enabled     = 1;
 
   fp = &RC.eNB[Mod_id][CC_id]->frame_parms;
 
-  fp->N_RB_DL                            = N_RB_DL_array[dl_Bandwidth];
-  fp->N_RB_UL                            = N_RB_DL_array[dl_Bandwidth];
+  fp->N_RB_DL                            = dl_Bandwidth;
+  fp->N_RB_UL                            = ul_Bandwidth;
   fp->Nid_cell                           = Nid_cell;
   fp->nushift                            = fp->Nid_cell%6;
   fp->eutra_band                         = eutra_band;
@@ -154,93 +180,95 @@ void phy_config_request(PHY_Config_t *phy_config) {
                     RC.eNB[Mod_id][CC_id]->X_u);
 
 #ifdef Rel14
-  if (cfg->emtc_config.prach_ce_level_0_enable.value == 1) {
-    fp->prach_emtc_config_common.prach_Config_enabled=1;
-
-    fp->prach_emtc_config_common.rootSequenceIndex                                         = cfg->emtc_config.prach_catm_root_sequence_index.value;
-
-    fp->prach_emtc_config_common.prach_ConfigInfo.highSpeedFlag                            = cfg->emtc_config.prach_catm_high_speed_flag.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig                = cfg->emtc_config.prach_catm_zero_correlation_zone_configuration.value;
-
-    // CE Level 3 parameters
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[3]                  = cfg->emtc_config.prach_ce_level_3_enable.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[3]   = cfg->emtc_config.prach_ce_level_3_starting_subframe_periodicity.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[3] = cfg->emtc_config.prach_ce_level_3_number_of_repetitions_per_attempt.value;
-    AssertFatal(fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[3]>=fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[3],
-		"prach_starting_subframe_periodicity[3] < prach_numPetitionPerPreambleAttempt[3]\n");
-
-
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[3]                     = cfg->emtc_config.prach_ce_level_3_configuration_index.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_FreqOffset[3]                      = cfg->emtc_config.prach_ce_level_3_frequency_offset.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_enable[3]                  = cfg->emtc_config.prach_ce_level_3_hopping_enable.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_offset[3]                  = cfg->emtc_config.prach_ce_level_3_hopping_offset.value;
-    if (fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[3] == 1)
-      compute_prach_seq(fp->prach_emtc_config_common.rootSequenceIndex,
-			fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[3],
-			fp->prach_emtc_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig,
-			fp->prach_emtc_config_common.prach_ConfigInfo.highSpeedFlag,
-			fp->frame_type,
-			RC.eNB[Mod_id][CC_id]->X_u_br[3]);
-
-    // CE Level 2 parameters
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[2]                  = cfg->emtc_config.prach_ce_level_2_enable.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[2]   = cfg->emtc_config.prach_ce_level_2_starting_subframe_periodicity.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[2] = cfg->emtc_config.prach_ce_level_2_number_of_repetitions_per_attempt.value;
-    AssertFatal(fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[2]>=fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[2],
-		"prach_starting_subframe_periodicity[2] < prach_numPetitionPerPreambleAttempt[2]\n");
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[2]                     = cfg->emtc_config.prach_ce_level_2_configuration_index.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_FreqOffset[2]                      = cfg->emtc_config.prach_ce_level_2_frequency_offset.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_enable[2]                  = cfg->emtc_config.prach_ce_level_2_hopping_enable.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_offset[2]                  = cfg->emtc_config.prach_ce_level_2_hopping_offset.value;
-    if (fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[2] == 1)
-      compute_prach_seq(fp->prach_emtc_config_common.rootSequenceIndex,
-			fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[3],
-			fp->prach_emtc_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig,
-			fp->prach_emtc_config_common.prach_ConfigInfo.highSpeedFlag,
-			fp->frame_type,
-			RC.eNB[Mod_id][CC_id]->X_u_br[2]);
-
-    // CE Level 1 parameters
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[1]                  = cfg->emtc_config.prach_ce_level_1_enable.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[1]   = cfg->emtc_config.prach_ce_level_1_starting_subframe_periodicity.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[1] = cfg->emtc_config.prach_ce_level_1_number_of_repetitions_per_attempt.value;
-    AssertFatal(fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[1]>=fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[1],
-		"prach_starting_subframe_periodicity[1] < prach_numPetitionPerPreambleAttempt[1]\n");
-
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[1]                     = cfg->emtc_config.prach_ce_level_1_configuration_index.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_FreqOffset[1]                      = cfg->emtc_config.prach_ce_level_1_frequency_offset.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_enable[1]                  = cfg->emtc_config.prach_ce_level_1_hopping_enable.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_offset[1]                  = cfg->emtc_config.prach_ce_level_1_hopping_offset.value;
-    if (fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[1] == 1)
-      compute_prach_seq(fp->prach_emtc_config_common.rootSequenceIndex,
-			fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[3],
-			fp->prach_emtc_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig,
-			fp->prach_emtc_config_common.prach_ConfigInfo.highSpeedFlag,
-			fp->frame_type,
-			RC.eNB[Mod_id][CC_id]->X_u_br[1]);
+  fp->prach_emtc_config_common.prach_Config_enabled=1;
+
+  fp->prach_emtc_config_common.rootSequenceIndex                                         = cfg->emtc_config.prach_catm_root_sequence_index.value;
+
+  fp->prach_emtc_config_common.prach_ConfigInfo.highSpeedFlag                            = cfg->emtc_config.prach_catm_high_speed_flag.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig                = cfg->emtc_config.prach_catm_zero_correlation_zone_configuration.value;
+
+  // CE Level 3 parameters
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[3]                  = cfg->emtc_config.prach_ce_level_3_enable.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[3]   = cfg->emtc_config.prach_ce_level_3_starting_subframe_periodicity.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[3] = cfg->emtc_config.prach_ce_level_3_number_of_repetitions_per_attempt.value;
+  AssertFatal(fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[3]>=fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[3],
+	      "prach_starting_subframe_periodicity[3] < prach_numPetitionPerPreambleAttempt[3]\n");
+
+
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[3]                     = cfg->emtc_config.prach_ce_level_3_configuration_index.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_FreqOffset[3]                      = cfg->emtc_config.prach_ce_level_3_frequency_offset.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_enable[3]                  = cfg->emtc_config.prach_ce_level_3_hopping_enable.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_offset[3]                  = cfg->emtc_config.prach_ce_level_3_hopping_offset.value;
+  if (fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[3] == 1)
+    compute_prach_seq(fp->prach_emtc_config_common.rootSequenceIndex,
+		      fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[3],
+		      fp->prach_emtc_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig,
+		      fp->prach_emtc_config_common.prach_ConfigInfo.highSpeedFlag,
+		      fp->frame_type,
+		      RC.eNB[Mod_id][CC_id]->X_u_br[3]);
+
+  // CE Level 2 parameters
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[2]                  = cfg->emtc_config.prach_ce_level_2_enable.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[2]   = cfg->emtc_config.prach_ce_level_2_starting_subframe_periodicity.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[2] = cfg->emtc_config.prach_ce_level_2_number_of_repetitions_per_attempt.value;
+  AssertFatal(fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[2]>=fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[2],
+	      "prach_starting_subframe_periodicity[2] < prach_numPetitionPerPreambleAttempt[2]\n");
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[2]                     = cfg->emtc_config.prach_ce_level_2_configuration_index.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_FreqOffset[2]                      = cfg->emtc_config.prach_ce_level_2_frequency_offset.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_enable[2]                  = cfg->emtc_config.prach_ce_level_2_hopping_enable.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_offset[2]                  = cfg->emtc_config.prach_ce_level_2_hopping_offset.value;
+  if (fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[2] == 1)
+    compute_prach_seq(fp->prach_emtc_config_common.rootSequenceIndex,
+		      fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[3],
+		      fp->prach_emtc_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig,
+		      fp->prach_emtc_config_common.prach_ConfigInfo.highSpeedFlag,
+		      fp->frame_type,
+		      RC.eNB[Mod_id][CC_id]->X_u_br[2]);
+
+  // CE Level 1 parameters
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[1]                  = cfg->emtc_config.prach_ce_level_1_enable.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[1]   = cfg->emtc_config.prach_ce_level_1_starting_subframe_periodicity.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[1] = cfg->emtc_config.prach_ce_level_1_number_of_repetitions_per_attempt.value;
+  AssertFatal(fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[1]>=fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[1],
+	      "prach_starting_subframe_periodicity[1] < prach_numPetitionPerPreambleAttempt[1]\n");
+
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[1]                     = cfg->emtc_config.prach_ce_level_1_configuration_index.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_FreqOffset[1]                      = cfg->emtc_config.prach_ce_level_1_frequency_offset.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_enable[1]                  = cfg->emtc_config.prach_ce_level_1_hopping_enable.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_offset[1]                  = cfg->emtc_config.prach_ce_level_1_hopping_offset.value;
+  if (fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[1] == 1)
+    compute_prach_seq(fp->prach_emtc_config_common.rootSequenceIndex,
+		      fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[3],
+		      fp->prach_emtc_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig,
+		      fp->prach_emtc_config_common.prach_ConfigInfo.highSpeedFlag,
+		      fp->frame_type,
+		      RC.eNB[Mod_id][CC_id]->X_u_br[1]);
   
-    // CE Level 0 parameters
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[0]                  = cfg->emtc_config.prach_ce_level_0_enable.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[0]   = cfg->emtc_config.prach_ce_level_0_starting_subframe_periodicity.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0] = cfg->emtc_config.prach_ce_level_0_number_of_repetitions_per_attempt.value;
-    AssertFatal(fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[0]>=fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0],
-		"prach_starting_subframe_periodicity[0] %d < prach_numPetitionPerPreambleAttempt[0] %d\n",
-		fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[0],
-		fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0]);
-    AssertFatal(fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0] > 0,
-		"prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0]==0\n");
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[0]                     = cfg->emtc_config.prach_ce_level_0_configuration_index.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_FreqOffset[0]                      = cfg->emtc_config.prach_ce_level_0_frequency_offset.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_enable[0]                = cfg->emtc_config.prach_ce_level_0_hopping_enable.value;
-    fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_offset[0]                = cfg->emtc_config.prach_ce_level_0_hopping_offset.value;
-    if (fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[0] == 1)
-      compute_prach_seq(fp->prach_emtc_config_common.rootSequenceIndex,
-			fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[3],
-			fp->prach_emtc_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig,
-			fp->prach_emtc_config_common.prach_ConfigInfo.highSpeedFlag,
-			fp->frame_type,
-			RC.eNB[Mod_id][CC_id]->X_u_br[0]);
-  }
+  // CE Level 0 parameters
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[0]                  = cfg->emtc_config.prach_ce_level_0_enable.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[0]   = cfg->emtc_config.prach_ce_level_0_starting_subframe_periodicity.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0] = cfg->emtc_config.prach_ce_level_0_number_of_repetitions_per_attempt.value;
+  AssertFatal(fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[0]>=fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0],
+	      "prach_starting_subframe_periodicity[0] %d < prach_numPetitionPerPreambleAttempt[0] %d\n",
+	      fp->prach_emtc_config_common.prach_ConfigInfo.prach_starting_subframe_periodicity[0],
+	      fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0]);
+#if 0
+  AssertFatal(fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0] > 0,
+	      "prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0]==0\n");
+#else
+  LOG_E(PHY,"***DJP*** removed assert on preamble fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0]:%d expecting >0 %s:%d\n\n\n", fp->prach_emtc_config_common.prach_ConfigInfo.prach_numRepetitionPerPreambleAttempt[0], __FILE__, __LINE__);
+#endif
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[0]                     = cfg->emtc_config.prach_ce_level_0_configuration_index.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_FreqOffset[0]                      = cfg->emtc_config.prach_ce_level_0_frequency_offset.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_enable[0]                = cfg->emtc_config.prach_ce_level_0_hopping_enable.value;
+  fp->prach_emtc_config_common.prach_ConfigInfo.prach_hopping_offset[0]                = cfg->emtc_config.prach_ce_level_0_hopping_offset.value;
+  if (fp->prach_emtc_config_common.prach_ConfigInfo.prach_CElevel_enable[0] == 1)
+    compute_prach_seq(fp->prach_emtc_config_common.rootSequenceIndex,
+		      fp->prach_emtc_config_common.prach_ConfigInfo.prach_ConfigIndex[3],
+		      fp->prach_emtc_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig,
+		      fp->prach_emtc_config_common.prach_ConfigInfo.highSpeedFlag,
+		      fp->frame_type,
+		      RC.eNB[Mod_id][CC_id]->X_u_br[0]);
 #endif
 
 
@@ -267,9 +295,9 @@ void phy_config_request(PHY_Config_t *phy_config) {
   fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled     = 0;
   fp->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled  = 0;
   if (cfg->uplink_reference_signal_config.uplink_rs_hopping.value == 1) 
-    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled = 1;
+      fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled = 1;
   if (cfg->uplink_reference_signal_config.uplink_rs_hopping.value == 2) 
-    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = 1;
+      fp->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = 1;
   LOG_I(PHY,"pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled = %d\n",fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled);
   fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH   =  cfg->uplink_reference_signal_config.group_assignment.value;
   LOG_I(PHY,"pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH = %d\n",fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH);
@@ -297,6 +325,18 @@ void phy_config_request(PHY_Config_t *phy_config) {
   LOG_I(PHY,"eNB %d/%d configured\n",Mod_id,CC_id);
 }
 
+
+/* Panos: New function of the UE MAC interface: This function
+should copy the values assigned to the interface parameters
+(within MAC/config.c) to the PHY frame configuration. It should be called at the end of
+config::rrc_mac_config_request_ue()*/
+
+void phy_config_request_ue (UE_PHY_Config_t* UE_config_INFO)
+{
+
+}
+
+
 void phy_config_sib1_ue(uint8_t Mod_id,int CC_id,
                         uint8_t eNB_id,
                         TDD_Config_t *tdd_Config,
@@ -316,14 +356,14 @@ void phy_config_sib1_ue(uint8_t Mod_id,int CC_id,
 }
 
 /*
-  void phy_config_sib2_eNB(uint8_t Mod_id,
-  int CC_id,
-  RadioResourceConfigCommonSIB_t *radioResourceConfigCommon,
-  ARFCN_ValueEUTRA_t *ul_CArrierFreq,
-  long *ul_Bandwidth,
-  AdditionalSpectrumEmission_t *additionalSpectrumEmission,
-  struct MBSFN_SubframeConfigList  *mbsfn_SubframeConfigList)
-  {
+void phy_config_sib2_eNB(uint8_t Mod_id,
+                         int CC_id,
+                         RadioResourceConfigCommonSIB_t *radioResourceConfigCommon,
+                         ARFCN_ValueEUTRA_t *ul_CArrierFreq,
+                         long *ul_Bandwidth,
+                         AdditionalSpectrumEmission_t *additionalSpectrumEmission,
+                         struct MBSFN_SubframeConfigList  *mbsfn_SubframeConfigList)
+{
 
   LTE_DL_FRAME_PARMS *fp = &RC.eNB[Mod_id][CC_id]->frame_parms;
   //LTE_eNB_UE_stats *eNB_UE_stats      = RC.eNB[Mod_id][CC_id].eNB_UE_stats;
@@ -350,7 +390,7 @@ void phy_config_sib1_ue(uint8_t Mod_id,int CC_id,
 
   init_prach_tables(839);
   compute_prach_seq(&fp->prach_config_common,fp->frame_type,
-  RC.eNB[Mod_id][CC_id]->X_u);
+                    RC.eNB[Mod_id][CC_id]->X_u);
 
   fp->pucch_config_common.deltaPUCCH_Shift = 1+radioResourceConfigCommon->pucch_ConfigCommon.deltaPUCCH_Shift;
   fp->pucch_config_common.nRB_CQI          = radioResourceConfigCommon->pucch_ConfigCommon.nRB_CQI;
@@ -392,15 +432,15 @@ void phy_config_sib1_ue(uint8_t Mod_id,int CC_id,
   fp->soundingrs_ul_config_common.enabled_flag                        = 0;
 
   if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon.present==SoundingRS_UL_ConfigCommon_PR_setup) {
-  fp->soundingrs_ul_config_common.enabled_flag                        = 1;
-  fp->soundingrs_ul_config_common.srs_BandwidthConfig                 = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_BandwidthConfig;
-  fp->soundingrs_ul_config_common.srs_SubframeConfig                  = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_SubframeConfig;
-  fp->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.ackNackSRS_SimultaneousTransmission;
+    fp->soundingrs_ul_config_common.enabled_flag                        = 1;
+    fp->soundingrs_ul_config_common.srs_BandwidthConfig                 = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_BandwidthConfig;
+    fp->soundingrs_ul_config_common.srs_SubframeConfig                  = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_SubframeConfig;
+    fp->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.ackNackSRS_SimultaneousTransmission;
 
-  if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_MaxUpPts)
-  fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 1;
-  else
-  fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 0;
+    if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_MaxUpPts)
+      fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 1;
+    else
+      fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 0;
   }
 
 
@@ -428,34 +468,34 @@ void phy_config_sib1_ue(uint8_t Mod_id,int CC_id,
 
   // MBSFN
   if (mbsfn_SubframeConfigList != NULL) {
-  fp->num_MBSFN_config = mbsfn_SubframeConfigList->list.count;
-
-  for (i=0; i<mbsfn_SubframeConfigList->list.count; i++) {
-  fp->MBSFN_config[i].radioframeAllocationPeriod = mbsfn_SubframeConfigList->list.array[i]->radioframeAllocationPeriod;
-  fp->MBSFN_config[i].radioframeAllocationOffset = mbsfn_SubframeConfigList->list.array[i]->radioframeAllocationOffset;
-
-  if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_oneFrame) {
-  fp->MBSFN_config[i].fourFrames_flag = 0;
-  fp->MBSFN_config[i].mbsfn_SubframeConfig = mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]; // 6-bit subframe configuration
-  LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is  %d\n", i,
-  fp->MBSFN_config[i].mbsfn_SubframeConfig);
-  } else if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_fourFrames) { // 24-bit subframe configuration
-  fp->MBSFN_config[i].fourFrames_flag = 1;
-  fp->MBSFN_config[i].mbsfn_SubframeConfig =
-  mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]|
-  (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[1]<<8)|
-  (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[2]<<16);
-
-  LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is  %d\n", i,
-  fp->MBSFN_config[i].mbsfn_SubframeConfig);
-  }
-  }
+    fp->num_MBSFN_config = mbsfn_SubframeConfigList->list.count;
+
+    for (i=0; i<mbsfn_SubframeConfigList->list.count; i++) {
+      fp->MBSFN_config[i].radioframeAllocationPeriod = mbsfn_SubframeConfigList->list.array[i]->radioframeAllocationPeriod;
+      fp->MBSFN_config[i].radioframeAllocationOffset = mbsfn_SubframeConfigList->list.array[i]->radioframeAllocationOffset;
+
+      if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_oneFrame) {
+        fp->MBSFN_config[i].fourFrames_flag = 0;
+        fp->MBSFN_config[i].mbsfn_SubframeConfig = mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]; // 6-bit subframe configuration
+        LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is  %d\n", i,
+              fp->MBSFN_config[i].mbsfn_SubframeConfig);
+      } else if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_fourFrames) { // 24-bit subframe configuration
+        fp->MBSFN_config[i].fourFrames_flag = 1;
+        fp->MBSFN_config[i].mbsfn_SubframeConfig =
+          mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]|
+          (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[1]<<8)|
+          (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[2]<<16);
+
+        LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is  %d\n", i,
+              fp->MBSFN_config[i].mbsfn_SubframeConfig);
+      }
+    }
 
   } else
-  fp->num_MBSFN_config = 0;
+    fp->num_MBSFN_config = 0;
 
   //
-  }
+}
 */
 
 void phy_config_sib2_ue(uint8_t Mod_id,int CC_id,
@@ -855,7 +895,7 @@ void phy_config_afterHO_ue(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_id, Mobility
     PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[1][eNB_id]->crnti = mobilityControlInfo->newUE_Identity.buf[0]|(mobilityControlInfo->newUE_Identity.buf[1]<<8);
 
     LOG_I(PHY,"SET C-RNTI %x %x\n",PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[0][eNB_id]->crnti,
-	  PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[1][eNB_id]->crnti);
+                                   PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[1][eNB_id]->crnti);
   }
 
   if(ho_failed) {
@@ -884,67 +924,67 @@ void phy_config_meas_ue(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index,uint8_t n
 }
 
 /*
-  void phy_config_dedicated_eNB(uint8_t Mod_id,
-  int CC_id,
-  uint16_t rnti,
-  struct PhysicalConfigDedicated *physicalConfigDedicated)
-  {
+void phy_config_dedicated_eNB(uint8_t Mod_id,
+                              int CC_id,
+                              uint16_t rnti,
+                              struct PhysicalConfigDedicated *physicalConfigDedicated)
+{
 
   PHY_VARS_eNB *eNB = RC.eNB[Mod_id][CC_id];
   int8_t UE_id = find_ue(rnti,eNB);
   int i;
 
   if (UE_id == -1) {
-  LOG_E( PHY, "[eNB %"PRIu8"] find_ue() returns -1\n", Mod_id);
-  return;
+    LOG_E( PHY, "[eNB %"PRIu8"] find_ue() returns -1\n", Mod_id);
+    return;
   }
 
 
   if (physicalConfigDedicated) {
-  eNB->physicalConfigDedicated[UE_id] = physicalConfigDedicated;
-  LOG_I(PHY,"phy_config_dedicated_eNB: physicalConfigDedicated=%p\n",physicalConfigDedicated);
-
-  if (physicalConfigDedicated->antennaInfo) {
-  switch(physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode) {
-  case AntennaInfoDedicated__transmissionMode_tm1:
-  eNB->transmission_mode[UE_id] = 1;
-  break;
-  case AntennaInfoDedicated__transmissionMode_tm2:
-  eNB->transmission_mode[UE_id] = 2;
-  break;
-  case AntennaInfoDedicated__transmissionMode_tm3:
-  eNB->transmission_mode[UE_id] = 3;
-  break;
-  case AntennaInfoDedicated__transmissionMode_tm4:
-  eNB->transmission_mode[UE_id] = 4;
-  break;
-  case AntennaInfoDedicated__transmissionMode_tm5:
-  eNB->transmission_mode[UE_id] = 5;
-  break;
-  case AntennaInfoDedicated__transmissionMode_tm6:
-  eNB->transmission_mode[UE_id] = 6;
-  break;
-  case AntennaInfoDedicated__transmissionMode_tm7:
-  lte_gold_ue_spec_port5(eNB->lte_gold_uespec_port5_table[0],eNB->frame_parms.Nid_cell,rnti);
-
-  for (i=0;i<eNB->num_RU;i++) eNB->RU_list[i]->do_precoding=1;
-  eNB->transmission_mode[UE_id] = 7;
-  break;
-  default:
-  LOG_E(PHY,"Unknown transmission mode!\n");
-  break;
-  }
-  LOG_I(PHY,"Transmission Mode (phy_config_dedicated_eNB) %d\n",eNB->transmission_mode[UE_id]);
+    eNB->physicalConfigDedicated[UE_id] = physicalConfigDedicated;
+    LOG_I(PHY,"phy_config_dedicated_eNB: physicalConfigDedicated=%p\n",physicalConfigDedicated);
 
+    if (physicalConfigDedicated->antennaInfo) {
+      switch(physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode) {
+      case AntennaInfoDedicated__transmissionMode_tm1:
+        eNB->transmission_mode[UE_id] = 1;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm2:
+        eNB->transmission_mode[UE_id] = 2;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm3:
+        eNB->transmission_mode[UE_id] = 3;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm4:
+        eNB->transmission_mode[UE_id] = 4;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm5:
+        eNB->transmission_mode[UE_id] = 5;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm6:
+        eNB->transmission_mode[UE_id] = 6;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm7:
+        lte_gold_ue_spec_port5(eNB->lte_gold_uespec_port5_table[0],eNB->frame_parms.Nid_cell,rnti);
+
+	for (i=0;i<eNB->num_RU;i++) eNB->RU_list[i]->do_precoding=1;
+	eNB->transmission_mode[UE_id] = 7;
+	break;
+      default:
+        LOG_E(PHY,"Unknown transmission mode!\n");
+        break;
+      }
+      LOG_I(PHY,"Transmission Mode (phy_config_dedicated_eNB) %d\n",eNB->transmission_mode[UE_id]);
+
+    } else {
+      LOG_D(PHY,"[eNB %d] : Received NULL radioResourceConfigDedicated->antennaInfo from eNB %d\n",Mod_id,UE_id);
+    }
   } else {
-  LOG_D(PHY,"[eNB %d] : Received NULL radioResourceConfigDedicated->antennaInfo from eNB %d\n",Mod_id,UE_id);
-  }
-  } else {
-  LOG_E(PHY,"[eNB %d] Received NULL radioResourceConfigDedicated from eNB %d\n",Mod_id, UE_id);
-  return;
+    LOG_E(PHY,"[eNB %d] Received NULL radioResourceConfigDedicated from eNB %d\n",Mod_id, UE_id);
+    return;
   }
 
-  }
+}
 */
 
 #if defined(Rel10) || defined(Rel14)
@@ -956,11 +996,11 @@ void phy_config_dedicated_scell_ue(uint8_t Mod_id,
 
 }
 /*
-  void phy_config_dedicated_scell_eNB(uint8_t Mod_id,
-  uint16_t rnti,
-  SCellToAddMod_r10_t *sCellToAddMod_r10,
-  int CC_id)
-  {
+void phy_config_dedicated_scell_eNB(uint8_t Mod_id,
+                                    uint16_t rnti,
+                                    SCellToAddMod_r10_t *sCellToAddMod_r10,
+                                    int CC_id)
+{
 
 
   uint8_t UE_id = find_ue(rnti,RC.eNB[Mod_id][0]);
@@ -971,37 +1011,37 @@ void phy_config_dedicated_scell_ue(uint8_t Mod_id,
   uint32_t carrier_freq_local;
 
   if ((dl_CarrierFreq_r10>=36000) && (dl_CarrierFreq_r10<=36199)) {
-  carrier_freq_local = 1900000000 + (dl_CarrierFreq_r10-36000)*100000; //band 33 from 3GPP 36.101 v 10.9 Table 5.7.3-1
-  LOG_I(PHY,"[eNB %d] Frame %d: Configured SCell %d to frequency %d (ARFCN %ld) for UE %d\n",Mod_id,
-  //eNB->frame
-  0,
-  CC_id,carrier_freq_local,dl_CarrierFreq_r10,UE_id);
+    carrier_freq_local = 1900000000 + (dl_CarrierFreq_r10-36000)*100000; //band 33 from 3GPP 36.101 v 10.9 Table 5.7.3-1
+    LOG_I(PHY,"[eNB %d] Frame %d: Configured SCell %d to frequency %d (ARFCN %ld) for UE %d\n",Mod_id,
+	  //eNB->frame
+	  0,
+	  CC_id,carrier_freq_local,dl_CarrierFreq_r10,UE_id);
   } else if ((dl_CarrierFreq_r10>=6150) && (dl_CarrierFreq_r10<=6449)) {
-  carrier_freq_local = 832000000 + (dl_CarrierFreq_r10-6150)*100000; //band 20 from 3GPP 36.101 v 10.9 Table 5.7.3-1
-  // this is actually for the UL only, but we use it for DL too, since there is no TDD mode for this band
-  LOG_I(PHY,"[eNB %d] Frame %d: Configured SCell %d to frequency %d (ARFCN %ld) for UE %d\n",Mod_id,
-  //eNB->frame
-  0,CC_id,carrier_freq_local,dl_CarrierFreq_r10,UE_id);
+    carrier_freq_local = 832000000 + (dl_CarrierFreq_r10-6150)*100000; //band 20 from 3GPP 36.101 v 10.9 Table 5.7.3-1
+    // this is actually for the UL only, but we use it for DL too, since there is no TDD mode for this band
+    LOG_I(PHY,"[eNB %d] Frame %d: Configured SCell %d to frequency %d (ARFCN %ld) for UE %d\n",Mod_id,
+          //eNB->frame
+          0,CC_id,carrier_freq_local,dl_CarrierFreq_r10,UE_id);
   } else {
-  LOG_E(PHY,"[eNB %d] Frame %d: ARFCN %ld of SCell %d for UE %d not supported\n",Mod_id,
-  //eNB->frame
-  0,dl_CarrierFreq_r10,CC_id,UE_id);
+    LOG_E(PHY,"[eNB %d] Frame %d: ARFCN %ld of SCell %d for UE %d not supported\n",Mod_id,
+	  //eNB->frame
+	  0,dl_CarrierFreq_r10,CC_id,UE_id);
   }
 
   if (physicalConfigDedicatedSCell_r10) {
-  //#warning " eNB->physicalConfigDedicatedSCell_r10 does not exist in eNB"
-  //  eNB->physicalConfigDedicatedSCell_r10[UE_id] = physicalConfigDedicatedSCell_r10;
-  LOG_I(PHY,"[eNB %d] Frame %d: Configured phyConfigDedicatedSCell with CC_id %d for UE %d\n",Mod_id,
-  //eNB->frame
-  0,CC_id,UE_id);
+//#warning " eNB->physicalConfigDedicatedSCell_r10 does not exist in eNB"
+    //  eNB->physicalConfigDedicatedSCell_r10[UE_id] = physicalConfigDedicatedSCell_r10;
+    LOG_I(PHY,"[eNB %d] Frame %d: Configured phyConfigDedicatedSCell with CC_id %d for UE %d\n",Mod_id,
+	  //eNB->frame
+          0,CC_id,UE_id);
   } else {
-  LOG_E(PHY,"[eNB %d] Frame %d: Received NULL radioResourceConfigDedicated (CC_id %d, UE %d)\n",Mod_id, 
-  //eNB->frame
-  0,CC_id,UE_id);
-  return;
+    LOG_E(PHY,"[eNB %d] Frame %d: Received NULL radioResourceConfigDedicated (CC_id %d, UE %d)\n",Mod_id, 
+	  //eNB->frame
+	  0,CC_id,UE_id);
+    return;
   }
 
-  }
+}
 */
 
 #endif
@@ -1178,7 +1218,7 @@ void phy_config_dedicated_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,
       }
       if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic) {
         if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->present == CQI_ReportPeriodic_PR_setup) {
-	  // configure PUCCH CQI reporting
+        // configure PUCCH CQI reporting
           phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.cqi_PUCCH_ResourceIndex = physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->choice.setup.cqi_PUCCH_ResourceIndex;
           phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.cqi_PMI_ConfigIndex     = physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->choice.setup.cqi_pmi_ConfigIndex;
           if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->choice.setup.ri_ConfigIndex)
@@ -1221,12 +1261,12 @@ void phy_config_dedicated_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,
   }
   //phy_vars_ue->pdcch_vars[1][eNB_id]->crnti = phy_vars_ue->pdcch_vars[0][eNB_id]->crnti;
   if(phy_vars_ue->pdcch_vars[0][eNB_id]->crnti == 0x1234)
-    phy_vars_ue->pdcch_vars[0][eNB_id]->crnti = phy_vars_ue->pdcch_vars[1][eNB_id]->crnti;
+      phy_vars_ue->pdcch_vars[0][eNB_id]->crnti = phy_vars_ue->pdcch_vars[1][eNB_id]->crnti;
   else
-    phy_vars_ue->pdcch_vars[1][eNB_id]->crnti = phy_vars_ue->pdcch_vars[0][eNB_id]->crnti;
+      phy_vars_ue->pdcch_vars[1][eNB_id]->crnti = phy_vars_ue->pdcch_vars[0][eNB_id]->crnti;
 
   LOG_I(PHY,"C-RNTI %x %x \n", phy_vars_ue->pdcch_vars[0][eNB_id]->crnti,
-	phy_vars_ue->pdcch_vars[1][eNB_id]->crnti);
+                               phy_vars_ue->pdcch_vars[1][eNB_id]->crnti);
 
 }
 
@@ -1690,7 +1730,7 @@ int phy_init_RU(RU_t *ru) {
       ru->common.txdata[i]  = (int32_t*)malloc16_clear( fp->samples_per_tti*10*sizeof(int32_t) );
 
       LOG_I(PHY,"[INIT] common.txdata[%d] = %p (%lu bytes)\n",i,ru->common.txdata[i],
-	    fp->samples_per_tti*10*sizeof(int32_t));
+	     fp->samples_per_tti*10*sizeof(int32_t));
 
     }
     for (i=0;i<ru->nb_rx;i++) {
@@ -1748,9 +1788,13 @@ int phy_init_RU(RU_t *ru) {
     AssertFatal(RC.nb_L1_inst <= NUMBER_OF_eNB_MAX,"eNB instances %d > %d\n",
 		RC.nb_L1_inst,NUMBER_OF_eNB_MAX);
 
+    LOG_E(PHY,"[INIT] %s() RC.nb_L1_inst:%d \n", __FUNCTION__, RC.nb_L1_inst);
+
     for (i=0; i<RC.nb_L1_inst; i++) {
       for (p=0;p<15;p++) {
+        LOG_D(PHY,"[INIT] %s() nb_antenna_ports_eNB:%d \n", __FUNCTION__, ru->eNB_list[i]->frame_parms.nb_antenna_ports_eNB);
 	if (p<ru->eNB_list[i]->frame_parms.nb_antenna_ports_eNB || p==5) {
+          LOG_D(PHY,"[INIT] %s() DO BEAM WEIGHTS nb_antenna_ports_eNB:%d nb_tx:%d\n", __FUNCTION__, ru->eNB_list[i]->frame_parms.nb_antenna_ports_eNB, ru->nb_tx);
 	  ru->beam_weights[i][p] = (int32_t **)malloc16_clear(ru->nb_tx*sizeof(int32_t*));
 	  for (j=0; j<ru->nb_tx; j++) {
 	    ru->beam_weights[i][p][j] = (int32_t *)malloc16_clear(fp->ofdm_symbol_size*sizeof(int32_t));
@@ -1759,15 +1803,20 @@ int phy_init_RU(RU_t *ru) {
 	    // antenna ports 5-14 are mapped on all antennas 
 	    if (((p<4) && (p==j)) || ((p==4) && (j==0))) {
 	      for (re=0; re<fp->ofdm_symbol_size; re++) 
+              {
 		ru->beam_weights[i][p][j][re] = 0x00007fff; 
+
+                //LOG_D(PHY,"[INIT] lte_common_vars->beam_weights[%d][%d][%d][%d] = %d\n", i,p,j,re,ru->beam_weights[i][p][j][re]);
+              }
 	    }
 	    else if (p>4) {
 	      for (re=0; re<fp->ofdm_symbol_size; re++) 
+              {
 		ru->beam_weights[i][p][j][re] = 0x00007fff/ru->nb_tx; 
+                //LOG_D(PHY,"[INIT] lte_common_vars->beam_weights[%d][%d][%d][%d] = %d\n", i,p,j,re,ru->beam_weights[i][p][j][re]);
+              }
 	    }  
-	    LOG_D(PHY,"[INIT] lte_common_vars->beam_weights[%d][%d] = %p (%lu bytes)\n",
-		  i,j,ru->beam_weights[i][p][j],
-		  fp->ofdm_symbol_size*sizeof(int32_t)); 
+	    //LOG_D(PHY,"[INIT] lte_common_vars->beam_weights[%d][%d] = %p (%lu bytes)\n", i,j,ru->beam_weights[i][p][j], fp->ofdm_symbol_size*sizeof(int32_t)); 
 	  }
 	}
       }
@@ -1794,6 +1843,7 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB,
 #endif
   int i, UE_id; 
 
+  LOG_I(PHY,"[eNB %d] %s() About to wait for eNB to be configured", eNB->Mod_id, __FUNCTION__);
 
   eNB->total_dlsch_bitrate = 0;
   eNB->total_transmitted_bits = 0;
@@ -1802,10 +1852,18 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB,
  
   while(eNB->configured == 0) usleep(10000);
 
-  LOG_I(PHY,"[eNB %"PRIu8"] Initializing DL_FRAME_PARMS : N_RB_DL %"PRIu8", PHICH Resource %d, PHICH Duration %d\n",
+  LOG_I(PHY,"[eNB %"PRIu8"] Initializing DL_FRAME_PARMS : N_RB_DL %"PRIu8", PHICH Resource %d, PHICH Duration %d nb_antennas_tx:%u nb_antennas_rx:%u nb_antenna_ports_eNB:%u PRACH[rootSequenceIndex:%u prach_Config_enabled:%u configIndex:%u highSpeed:%u zeroCorrelationZoneConfig:%u freqOffset:%u]\n",
         eNB->Mod_id,
         fp->N_RB_DL,fp->phich_config_common.phich_resource,
-        fp->phich_config_common.phich_duration);
+        fp->phich_config_common.phich_duration,
+        fp->nb_antennas_tx, fp->nb_antennas_rx, fp->nb_antenna_ports_eNB,
+        fp->prach_config_common.rootSequenceIndex,
+        fp->prach_config_common.prach_Config_enabled,
+        fp->prach_config_common.prach_ConfigInfo.prach_ConfigIndex,
+        fp->prach_config_common.prach_ConfigInfo.highSpeedFlag,
+        fp->prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig,
+        fp->prach_config_common.prach_ConfigInfo.prach_FreqOffset
+        );
   LOG_D(PHY,"[MSC_NEW][FRAME 00000][PHY_eNB][MOD %02"PRIu8"][]\n", eNB->Mod_id);
 
 
@@ -1832,6 +1890,8 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB,
   common_vars->txdataF = (int32_t **)malloc16(NB_ANTENNA_PORTS_ENB*sizeof(int32_t*));
   common_vars->rxdataF = (int32_t **)malloc16(64*sizeof(int32_t*));
   
+  LOG_D(PHY,"[INIT] NB_ANTENNA_PORTS_ENB:%d fp->nb_antenna_ports_eNB:%d\n", NB_ANTENNA_PORTS_ENB, fp->nb_antenna_ports_eNB);
+
   for (i=0; i<NB_ANTENNA_PORTS_ENB; i++) {
     if (i<fp->nb_antenna_ports_eNB || i==5) {
       common_vars->txdataF[i] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*fp->symbols_per_tti*10*sizeof(int32_t) );
@@ -1886,12 +1946,12 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB,
 #endif
   
   /* number of elements of an array X is computed as sizeof(X) / sizeof(X[0]) 
-     AssertFatal(fp->nb_antennas_rx <= sizeof(prach_vars->rxsigF) / sizeof(prach_vars->rxsigF[0]),
-     "nb_antennas_rx too large");
-     for (i=0; i<fp->nb_antennas_rx; i++) {
-     prach_vars->rxsigF[i] = (int16_t*)malloc16_clear( fp->ofdm_symbol_size*12*2*sizeof(int16_t) );
-     LOG_D(PHY,"[INIT] prach_vars->rxsigF[%d] = %p\n",i,prach_vars->rxsigF[i]);
-     }*/
+  AssertFatal(fp->nb_antennas_rx <= sizeof(prach_vars->rxsigF) / sizeof(prach_vars->rxsigF[0]),
+              "nb_antennas_rx too large");
+  for (i=0; i<fp->nb_antennas_rx; i++) {
+    prach_vars->rxsigF[i] = (int16_t*)malloc16_clear( fp->ofdm_symbol_size*12*2*sizeof(int16_t) );
+    LOG_D(PHY,"[INIT] prach_vars->rxsigF[%d] = %p\n",i,prach_vars->rxsigF[i]);
+    }*/
   
   for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
     
@@ -1919,7 +1979,7 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB,
       pusch_vars[UE_id]->rxdataF_comp[i]     = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->N_RB_UL*12*fp->symbols_per_tti );
       pusch_vars[UE_id]->ul_ch_mag[i]  = (int32_t*)malloc16_clear( fp->symbols_per_tti*sizeof(int32_t)*fp->N_RB_UL*12 );
       pusch_vars[UE_id]->ul_ch_magb[i] = (int32_t*)malloc16_clear( fp->symbols_per_tti*sizeof(int32_t)*fp->N_RB_UL*12 );
-    }
+      }
     
     pusch_vars[UE_id]->llr = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
   } //UE_id
@@ -1934,3 +1994,9 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB,
   return (0);
 
 }
+
+void install_schedule_handlers(IF_Module_t *if_inst)
+{
+  if_inst->PHY_config_req = phy_config_request;
+  if_inst->schedule_response = schedule_response;
+}

openair1/PHY/LTE_TRANSPORT/dci.c

@@ -43,6 +43,7 @@
 #include "assertions.h" 
 #include "T.h"
 #include "UTIL/LOG/log.h"
+#include "UTIL/LOG/vcd_signal_dumper.h"
 
 //#define DEBUG_DCI_ENCODING 1
 //#define DEBUG_DCI_DECODING 1
@@ -2065,6 +2066,8 @@ void pdcch_scrambling(LTE_DL_FRAME_PARMS *frame_parms,
   uint8_t reset;
   uint32_t x1, x2, s=0;
 
+  //LOG_D(PHY, "%s(fp, subframe:%d, e, length:%d)\n", __FUNCTION__, subframe, length);
+
   reset = 1;
   // x1 is set in lte_gold_generic
 
@@ -2216,6 +2219,11 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
   int Msymb2;
   int split_flag=0;
 
+  if (num_dci>0)
+  {
+    //LOG_D(PHY,"%s(num_pdcch_symbols:%d num_dci:%d dci_alloc:%p n_rnti:%04x amp:%d frame_parms:%p txdataF:%p subframe:%d)\n", __FUNCTION__, num_pdcch_symbols, num_dci, dci_alloc, n_rnti, amp, frame_parms, txdataF, subframe);
+  }
+
   switch (frame_parms->N_RB_DL) {
   case 100:
     Msymb2 = Msymb;
@@ -2247,11 +2255,13 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
   }
 
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_PCFICH,1);
   generate_pcfich(num_pdcch_symbols,
                   amp,
                   frame_parms,
                   txdataF,
                   subframe);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_PCFICH,0);
   wbar[0] = &wbar0[0];
   wbar[1] = &wbar1[0];
   y[0] = &yseq0[0];
@@ -2272,6 +2282,7 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
 
   e_ptr = e;
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_DCI0,1);
 
   // generate DCIs in order of decreasing aggregation level, then common/ue spec
   // MAC is assumed to have ordered the UE spec DCI according to the RNTI-based randomization
@@ -2298,18 +2309,26 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
       }
     }
   }
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_DCI0,0);
 
   // Scrambling
-  //  printf("pdcch scrambling\n");
+#ifdef DEBUG_DCI_ENCODING
+  printf("pdcch scrambling\n");
+#endif
+  //LOG_D(PHY, "num_pdcch_symbols:%d mi:%d nquad:%d\n", num_pdcch_symbols, mi, get_nquad(num_pdcch_symbols, frame_parms, mi));
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_SCRAMBLING,1);
   pdcch_scrambling(frame_parms,
                    subframe,
                    e,
                    8*get_nquad(num_pdcch_symbols, frame_parms, mi));
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_SCRAMBLING,0);
   //72*get_nCCE(num_pdcch_symbols,frame_parms,mi));
 
 
 
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_MODULATION,1);
   // Now do modulation
   if (frame_parms->nb_antenna_ports_eNB==1)
     gain_lin_QPSK = (int16_t)((amp*ONE_OVER_SQRT2_Q15)>>15);
@@ -2322,6 +2341,7 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
   printf(" PDCCH Modulation, Msymb %d, Msymb2 %d,gain_lin_QPSK %d\n",Msymb,Msymb2,gain_lin_QPSK);
 #endif
 
+  //LOG_D(PHY,"%s() Msymb2:%d\n", __FUNCTION__, Msymb2);
 
   if (frame_parms->nb_antenna_ports_eNB==1) { //SISO
 
@@ -2368,22 +2388,38 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
 
     }
   }
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_MODULATION,0);
 
 
 #ifdef DEBUG_DCI_ENCODING
   printf(" PDCCH Interleaving\n");
 #endif
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_INTERLEAVING,1);
   //  printf("y %p (%p,%p), wbar %p (%p,%p)\n",y,y[0],y[1],wbar,wbar[0],wbar[1]);
   // This is the interleaving procedure defined in 36-211, first part of Section 6.8.5
   pdcch_interleaving(frame_parms,&y[0],&wbar[0],num_pdcch_symbols,mi);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_INTERLEAVING,0);
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_TX,1);
   mprime=0;
   nsymb = (frame_parms->Ncp==0) ? 14:12;
   re_offset = frame_parms->first_carrier_offset;
 
   // This is the REG allocation algorithm from 36-211, second part of Section 6.8.5
   //  printf("DCI (SF %d) : txdataF %p (0 %p)\n",subframe,&txdataF[0][512*14*subframe],&txdataF[0][0]);
+#ifdef DEBUG_DCI_ENCODING
+  printf("kprime loop - N_RB_DL:%d lprime:num_pdcch_symbols:%d Ncp:%d pcfich:%02x,%02x,%02x,%02x ofdm_symbol_size:%d first_carrier_offset:%d nb_antenna_ports_eNB:%d\n",
+  frame_parms->N_RB_DL, num_pdcch_symbols,frame_parms->Ncp,
+  frame_parms->pcfich_reg[0],
+  frame_parms->pcfich_reg[1],
+  frame_parms->pcfich_reg[2],
+  frame_parms->pcfich_reg[3],
+  frame_parms->ofdm_symbol_size,
+  frame_parms->first_carrier_offset,
+  frame_parms->nb_antenna_ports_eNB
+  );
+#endif
   for (kprime=0; kprime<frame_parms->N_RB_DL*12; kprime++) {
     for (lprime=0; lprime<num_pdcch_symbols; lprime++) {
 
@@ -2500,6 +2536,7 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
     if (re_offset == (frame_parms->ofdm_symbol_size))
       re_offset = 1;
   } // kprime loop
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_TX,0);
 
   return(num_pdcch_symbols);
 }

openair1/PHY/LTE_TRANSPORT/dci_tools.c

@@ -801,6 +801,28 @@ void generate_RIV_tables()
 //       n_tilde_PRB(0,1) = (0,2)
 
 
+void check_dlsch(char *file, int line)
+{
+  PHY_VARS_eNB *eNB = RC.eNB[0][0];
+  static char oldbuf[13*NUMBER_OF_UE_MAX+100]="";
+  char buf[13*NUMBER_OF_UE_MAX+100];
+  char *pbuf=buf;
+
+  for (int i=0; i<NUMBER_OF_UE_MAX; i++) {
+    pbuf+=sprintf(pbuf, "[%02d]:%02x:%04x ", i, eNB->dlsch[i][0]->harq_mask, eNB->dlsch[i][0]->rnti);
+  }
+
+  int diff_size = memcmp(oldbuf, buf, strlen(buf));
+  
+  if (diff_size!=0)
+  {
+    LOG_I(PHY,"check_dlsch:%s:%d:%s\n", file, line, buf);
+    LOG_I(PHY,"check_dlsch:%s:%d:%s\n", file, line, oldbuf);
+  }
+
+  memcpy(oldbuf, buf, sizeof(buf));
+}
+
 int8_t find_dlsch(uint16_t rnti, PHY_VARS_eNB *eNB,find_type_t type)
 {
   uint8_t i;
@@ -810,8 +832,7 @@ int8_t find_dlsch(uint16_t rnti, PHY_VARS_eNB *eNB,find_type_t type)
   for (i=0; i<NUMBER_OF_UE_MAX; i++) {
     AssertFatal(eNB->dlsch[i]!=NULL,"eNB->dlsch[%d] is null\n",i);
     AssertFatal(eNB->dlsch[i]!=NULL,"eNB->dlsch[%d][0] is null\n",i);
-    LOG_D(PHY,"searching for rnti %x : UE index %d=> harq_mask %x, rnti %x, first_free_index %d\n",
-          rnti,i,eNB->dlsch[i][0]->harq_mask,eNB->dlsch[i][0]->rnti,first_free_index);
+    LOG_D(PHY,"searching for rnti %x : UE index %d=> harq_mask %x, rnti %x, first_free_index %d\n", rnti,i,eNB->dlsch[i][0]->harq_mask,eNB->dlsch[i][0]->rnti,first_free_index);
     if ((eNB->dlsch[i][0]->harq_mask >0) &&
         (eNB->dlsch[i][0]->rnti==rnti))       return i;
     else if ((eNB->dlsch[i][0]->harq_mask == 0) && (first_free_index==-1)) first_free_index=i;
@@ -1041,6 +1062,12 @@ void fill_dci_and_dlsch(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,DCI_ALLOC_t *dci
   dlsch1_harq                               = dlsch1->harq_processes[rel8->harq_process];
   dlsch1_harq->codeword                     = 1;
   dlsch0->subframe_tx[subframe]             = 1;
+
+  LOG_D(PHY,"NFAPI: dlsch0[rnti:%x] dci_pdu[rnti:%x rnti_type:%d harq_process:%d ndi1:%d] dlsch0_harq[round:%d harq_mask:%x ndi:%d]\n", 
+      dlsch0->rnti, 
+      rel8->rnti, rel8->rnti_type, rel8->harq_process, rel8->new_data_indicator_1,
+      dlsch0_harq->round, dlsch0->harq_mask, dlsch0_harq->ndi);
+
   if (dlsch0->rnti != rel8->rnti) { // if rnti of dlsch is not the same as in the config, this is a new entry
     dlsch0_harq->round=0;
     dlsch0->harq_mask=0;
@@ -1057,8 +1084,9 @@ void fill_dci_and_dlsch(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,DCI_ALLOC_t *dci
   dlsch0->active        = 1;
   if (rel8->rnti_type == 2)
       dlsch0_harq->round    = 0;
-LOG_D(PHY,"NFAPI: harq_pid %d harq_mask %x, round %d ndi (%d,%d) rnti type %d\n",rel8->harq_process,dlsch0->harq_mask,dlsch0_harq->round,
-	dlsch0_harq->ndi,rel8->new_data_indicator_1, rel8->rnti_type);
+
+  LOG_D(PHY,"NFAPI: harq_pid %d harq_mask %x, round %d ndi (%d,%d) rnti type %d\n",rel8->harq_process,dlsch0->harq_mask,dlsch0_harq->round,
+      dlsch0_harq->ndi,rel8->new_data_indicator_1, rel8->rnti_type);
 
   switch (rel8->dci_format) {
 
@@ -2412,9 +2440,10 @@ void fill_dci0(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,DCI_ALLOC_t *dci_alloc,
 
   void *dci_pdu = (void*)dci_alloc->dci_pdu;
 
-  LOG_D(PHY,"Filling DCI0 with cqi %d, mcs %d, hopping %d, rballoc %x (%d,%d) ndi %d TPC %d cshift %d\n",cqi_req,
-	mcs,hopping,rballoc,pdu->dci_pdu_rel8.resource_block_start,pdu->dci_pdu_rel8.number_of_resource_block,
-	ndi,TPC,cshift);
+  LOG_D(PHY,"Filling DCI0 with rnti %x cqi %d, mcs %d, hopping %d, rballoc %x (%d,%d) ndi %d TPC %d cshift %d\n",
+      pdu->dci_pdu_rel8.rnti,cqi_req, mcs,hopping,rballoc,
+      pdu->dci_pdu_rel8.resource_block_start,
+      pdu->dci_pdu_rel8.number_of_resource_block, ndi,TPC,cshift);
 
   dci_alloc->format   = format0;
   dci_alloc->firstCCE = pdu->dci_pdu_rel8.cce_index;
@@ -2574,10 +2603,10 @@ void fill_ulsch(PHY_VARS_eNB *eNB,nfapi_ul_config_ulsch_pdu *ulsch_pdu,int frame
   ulsch->harq_processes[harq_pid]->dci_alloc                             = 1;
   ulsch->harq_processes[harq_pid]->rar_alloc                             = 0;
   ulsch->harq_processes[harq_pid]->n_DMRS                                = ulsch_pdu->ulsch_pdu_rel8.cyclic_shift_2_for_drms;
-
+  
   ulsch->harq_processes[harq_pid]->Nsymb_pusch                           = 12-(frame_parms->Ncp<<1)-(use_srs==0?0:1);
   ulsch->harq_processes[harq_pid]->srs_active                            = use_srs;
-
+  
   //Mapping of cyclic shift field in DCI format0 to n_DMRS2 (3GPP 36.211, Table 5.5.2.1.1-1)
   if(ulsch->harq_processes[harq_pid]->n_DMRS == 0)
     ulsch->harq_processes[harq_pid]->n_DMRS2 = 0;
@@ -2595,23 +2624,25 @@ void fill_ulsch(PHY_VARS_eNB *eNB,nfapi_ul_config_ulsch_pdu *ulsch_pdu,int frame
     ulsch->harq_processes[harq_pid]->n_DMRS2 = 10;
   else if(ulsch->harq_processes[harq_pid]->n_DMRS == 7)
     ulsch->harq_processes[harq_pid]->n_DMRS2 = 9;
-
-  LOG_D(PHY,"[eNB %d][PUSCH %d] Programming PUSCH with n_DMRS2 %d (cshift %d) for Frame %d, Subframe %d\n",
-	eNB->Mod_id,harq_pid,ulsch->harq_processes[harq_pid]->n_DMRS2,ulsch->harq_processes[harq_pid]->n_DMRS,
-	frame,subframe);
-
+  
+  LOG_D(PHY,"[eNB %d][PUSCH %d] Frame %d, Subframe %d Programming PUSCH with n_DMRS2 %d (cshift %d) ulsch:ndi:%d ulsch_pdu:ndi:%d new_ulsch:%d status:%d\n",
+	eNB->Mod_id,harq_pid,frame,subframe,
+        ulsch->harq_processes[harq_pid]->n_DMRS2,
+        ulsch->harq_processes[harq_pid]->n_DMRS,
+	ulsch->harq_processes[harq_pid]->ndi, ulsch_pdu->ulsch_pdu_rel8.new_data_indication, new_ulsch, ulsch->harq_processes[harq_pid]->status);
+  
   ulsch->harq_processes[harq_pid]->rvidx = ulsch_pdu->ulsch_pdu_rel8.redundancy_version;
   ulsch->harq_processes[harq_pid]->Qm    = ulsch_pdu->ulsch_pdu_rel8.modulation_type;
-  // Set O_ACK to 0 by default, will be set of DLSCH is scheduled and needs to be
+  // Set O_ACK to 0 by default, will be set of DLSCH is scheduled and needs to be 
   ulsch->harq_processes[harq_pid]->O_ACK         = 0;
 
   if ((ulsch->harq_processes[harq_pid]->status == SCH_IDLE) ||
       (ulsch->harq_processes[harq_pid]->ndi    != ulsch_pdu->ulsch_pdu_rel8.new_data_indication) ||
 	  (new_ulsch == TRUE)){
     ulsch->harq_processes[harq_pid]->status        = ACTIVE;
-
+    
     ulsch->harq_processes[harq_pid]->TBS           = ulsch_pdu->ulsch_pdu_rel8.size<<3;
-
+    
     ulsch->harq_processes[harq_pid]->Msc_initial   = 12*ulsch_pdu->ulsch_pdu_rel8.number_of_resource_blocks;
     ulsch->harq_processes[harq_pid]->Nsymb_initial = ulsch->harq_processes[harq_pid]->Nsymb_pusch;
     ulsch->harq_processes[harq_pid]->round         = 0;
@@ -2621,23 +2652,25 @@ void fill_ulsch(PHY_VARS_eNB *eNB,nfapi_ul_config_ulsch_pdu *ulsch_pdu,int frame
     // will be set if MAC has activated ULSCH_CQI_RI_PDU or ULSCH_CQI_HARQ_RI_PDU
     ulsch->harq_processes[harq_pid]->Or1           = 0;
     ulsch->harq_processes[harq_pid]->Or2           = 0;
-  }
+  } 
   else  ulsch->harq_processes[harq_pid]->round++;
 
   ulsch->rnti = ulsch_pdu->ulsch_pdu_rel8.rnti;
-  LOG_D(PHY,"Filling ULSCH %x (UE_id %d) (new_ulsch %d) for Frame %d, Subframe %d : harq_pid %d, first_rb %d, nb_rb %d, rvidx %d, Qm %d, TBS %d, round %d \n",
+  LOG_D(PHY,"Filling ULSCH %x (UE_id %d) (new_ulsch %d) for Frame %d, Subframe %d : harq_pid %d, status %d, handled %d, first_rb %d, nb_rb %d, rvidx %d, Qm %d, TBS %d, round %d \n",
 	ulsch->rnti,
         UE_id,
         new_ulsch,
 	frame,
 	subframe,
 	harq_pid,
+	ulsch->harq_processes[harq_pid]->status,
+	ulsch->harq_processes[harq_pid]->handled,
 	ulsch->harq_processes[harq_pid]->first_rb,
 	ulsch->harq_processes[harq_pid]->nb_rb,
 	ulsch->harq_processes[harq_pid]->rvidx,
 	ulsch->harq_processes[harq_pid]->Qm,
 	ulsch->harq_processes[harq_pid]->TBS,
-	ulsch->harq_processes[harq_pid]->round);
+	ulsch->harq_processes[harq_pid]->round);  
 }
 
 int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci)
@@ -2725,7 +2758,7 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci)
         break;
 
       case 25:
-        LOG_D(PHY,"DCI format0 (FDD, 5MHz), rnti %x (%x): hopping %d, rb_alloc %x, mcs %d, ndi %d, TPC %d, cshift %d, cqi_req %d\n",
+        LOG_I(PHY,"DCI format0 (FDD, 5MHz), rnti %x (%x): hopping %d, rb_alloc %x, mcs %d, ndi %d, TPC %d, cshift %d, cqi_req %d\n",
               dci->rnti,
               ((uint32_t*)&dci->dci_pdu[0])[0],
               ((DCI0_5MHz_FDD_t *)&dci->dci_pdu[0])->hopping,
@@ -6401,7 +6434,7 @@ uint8_t subframe2harq_pid(LTE_DL_FRAME_PARMS *frame_parms,uint32_t frame,uint8_t
   uint8_t ret = 255;
 
   if (frame_parms->frame_type == FDD) {
-    ret = (((frame<<1)+subframe)&7);
+    ret = (((frame*10)+subframe)&7);
   } else {
 
     switch (frame_parms->tdd_config) {
@@ -6535,7 +6568,7 @@ uint32_t pdcch_alloc2ul_frame(LTE_DL_FRAME_PARMS *frame_parms,uint32_t frame, ui
   else
     ul_frame = (frame+(n>=6 ? 1 : 0));
 
-  LOG_D(PHY, "frame %d subframe %d: PUSCH frame = %d\n", frame, n, ul_frame);
+  //LOG_D(PHY, "frame %d subframe %d: PUSCH frame = %d\n", frame, n, ul_frame);
   return ul_frame % 1024;
 }