Add frame_parms_NB_IoT (remain error)

openair1/PHY/defs_L1_NB_IoT.h

@@ -111,7 +111,7 @@
 typedef enum {normal_txrx_NB_IoT=0,rx_calib_ue_NB_IoT=1,rx_calib_ue_med_NB_IoT=2,rx_calib_ue_byp_NB_IoT=3,debug_prach_NB_IoT=4,no_L2_connect_NB_IoT=5,calib_prach_tx_NB_IoT=6,rx_dump_frame_NB_IoT=7,loop_through_memory_NB_IoT=8} runmode_NB_IoT_t;
 #endif
 /*
-enum transmission_access_mode {
+enum transmission_access_mode_NB_IoT {
   NO_ACCESS=0,
   POSTPONED_ACCESS,
   CANCELED_ACCESS,

openair1/PHY/defs_common.h

@@ -631,6 +631,8 @@ typedef struct {
   uint8_t srsX;
   /// indicates if node is a UE (NODE=2) or eNB (PRIMARY_CH=0).
   uint8_t node_id;
+  /// flag to indicate SISO transmission
+  uint8_t mode1_flag;  
   /// Indicator that 20 MHz channel uses 3/4 sampling frequency
   uint8_t threequarter_fs;
   /// Size of FFT

openair1/PHY/defs_eNB.h

@@ -604,6 +604,12 @@ typedef struct {
   /// - first index: tx antenna [0..14[ where 14 is the total supported antenna ports.
   /// - second index: sample [0..]
   int32_t **txdataF;
+  /// \brief Holds the beamforming weights
+  /// - first index: eNB id [0..2] (hard coded)
+  /// - second index: eNB antenna port index (hard coded)
+  /// - third index: tx antenna [0..nb_antennas_tx[
+  /// - fourth index: sample [0..]
+  int32_t **beam_weights[3][15];
 } LTE_eNB_COMMON;
 
 typedef struct {
@@ -1109,7 +1115,7 @@ typedef struct PHY_VARS_eNB_s {
 
   uint32_t max_peak_val;
   int max_eNB_id, max_sync_pos;
-
+  int              N_TA_offset; ///timing offset used in TDD
   /// \brief sinr for all subcarriers of the current link (used only for abstraction).
   /// first index: ? [0..N_RB_DL*12[
   double *sinr_dB;
@@ -1120,7 +1126,8 @@ typedef struct PHY_VARS_eNB_s {
   unsigned char first_run_timing_advance[NUMBER_OF_UE_MAX];
   unsigned char first_run_I0_measurements;
 
-  
+  unsigned char cooperation_flag; // for cooperative communication
+    
   unsigned char    is_secondary_eNB; // primary by default
   unsigned char    is_init_sync;     /// Flag to tell if initial synchronization is performed. This affects how often the secondary eNB will listen to the PSS from the primary system.
   unsigned char    has_valid_precoder; /// Flag to tell if secondary eNB has channel estimates to create NULL-beams from, and this B/F vector is created.

openair1/PHY/phy_vars.h

@@ -47,8 +47,8 @@ PHY_VARS_UE ***PHY_vars_UE_g;
 RAN_CONTEXT_t RC;
 UL_RCC_IND_t  UL_RCC_INFO;
 
-//PHY_VARS_eNB ***PHY_vars_eNB_g;
-//PHY_VARS_RN **PHY_vars_RN_g;
+PHY_VARS_eNB ***PHY_vars_eNB_g;
+PHY_VARS_RN **PHY_vars_RN_g;
 LTE_DL_FRAME_PARMS *lte_frame_parms_g;
 #else
 PHY_VARS_UE * PHY_vars_UE_g[MAX_UE][MAX_NUM_CCs]={NULL};

openair1/PHY/vars.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file vars.h
+* \brief mac vars
+* \author  Navid Nikaein and Raymond Knopp
+* \date 2010 - 2014
+* \version 1.0
+* \email navid.nikaein@eurecom.fr
+* @ingroup _mac
+
+*/
+
+
+#ifndef __MAC_VARS_H__
+#define __MAC_VARS_H__
+#ifdef USER_MODE
+//#include "stdio.h"
+#endif //USER_MODE
+#include "PHY/defs_L1_NB_IoT.h"
+#include "defs.h"
+#include "defs_NB_IoT.h"
+#include "PHY_INTERFACE/defs.h"
+#include "COMMON/mac_rrc_primitives.h"
+
+
+const uint32_t BSR_TABLE[BSR_TABLE_SIZE]= {0,10,12,14,17,19,22,26,31,36,42,49,57,67,78,91,
+                                           105,125,146,171,200,234,274,321,376,440,515,603,706,826,967,1132,
+                                           1326,1552,1817,2127,2490,2915,3413,3995,4677,5467,6411,7505,8787,10287,12043,14099,
+                                           16507,19325,22624,26487,31009,36304,42502,49759,58255,68201,79846,93479,109439, 128125,150000, 300000
+                                          };
+// extended bsr table--currently not used										  
+const uint32_t Extended_BSR_TABLE[BSR_TABLE_SIZE] = {0,10,13,16,19,23,29,35,43,53,65,80,98,120,147,
+                                                     181,223,274,337,414,509,625,769,945,1162,1429,
+                                                     1757,2161,2657,3267,4017,4940,6074,7469,9185,
+                                                     11294,13888,17077,20999,25822,31752,39045,48012,
+                                                     59039,72598,89272,109774,134986,165989,204111,
+                                                     250990,308634,379519,466683,573866,705666,867737,
+                                                     1067031,1312097,1613447,1984009,2439678,3000000,
+                                                     6000000};
+
+//#define MAX_SIZE_OF_AGG3   576 
+//#define MAX_SIZE_OF_AGG2   288
+//#define MAX_SIZE_OF_AGG1   144
+//#define MAX_SIZE_OF_AGG0   72
+
+/*
+ * If the CQI is low, then scheduler will use a higher aggregation level and lower aggregation level otherwise
+ * this is also dependent to transmission mode, where an offset could be defined
+ */
+// the follwoing three tables are calibrated for TXMODE 1 and 2
+const uint8_t cqi2fmt0_agg[MAX_SUPPORTED_BW][CQI_VALUE_RANGE]= { 
+  {3, 3, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0}, // 1.4_DCI0_CRC_Size= 37 bits
+  //{3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0}, // 5_DCI0_CRC_SIZE = 41
+  {3, 3, 3, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0}, // 5_DCI0_CRC_SIZE = 41
+  {3, 3, 3, 3, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0}, // 10_DCI0_CRC_SIZE = 43
+  {3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0}   // 20_DCI0_CRC_SIZE = 44
+};
+const uint8_t cqi2fmt1x_agg[MAX_SUPPORTED_BW][CQI_VALUE_RANGE]= { 
+  {3, 3, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0}, // 1.4_DCI0_CRC_Size < 38 bits
+  {3, 3, 3, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0}, // 5_DCI0_CRC_SIZE  < 43
+  {3, 3, 3, 3, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0}, // 10_DCI0_CRC_SIZE  < 47
+  {3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0}   // 20_DCI0_CRC_SIZE  < 55
+};
+const uint8_t cqi2fmt2x_agg[MAX_SUPPORTED_BW][CQI_VALUE_RANGE]= { 
+  {3, 3, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0}, // 1.4_DCI0_CRC_Size= 47 bits
+  {3, 3, 3, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0}, // 5_DCI0_CRC_SIZE = 55
+  {3, 3, 3, 3, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0}, // 10_DCI0_CRC_SIZE = 59
+  {3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0}   // 20_DCI0_CRC_SIZE = 64
+};
+
+//uint32_t EBSR_Level[63]={0,10,13,16,19,23,29,35,43,53,65,80,98,120,147,181};
+
+MAC_xface *mac_xface;
+
+uint32_t RRC_CONNECTION_FLAG;
+
+UE_MAC_INST *UE_mac_inst; //[NB_MODULE_MAX];
+eNB_MAC_INST *eNB_mac_inst; //[NB_MODULE_MAX];
+MAC_RLC_XFACE *Mac_rlc_xface;
+
+/// Primary component carrier index of eNB
+int pCC_id[NUMBER_OF_eNB_MAX];
+
+
+eNB_ULSCH_INFO eNB_ulsch_info[NUMBER_OF_eNB_MAX][MAX_NUM_CCs][NUMBER_OF_UE_MAX]; // eNBxUE = 8x8
+eNB_DLSCH_INFO eNB_dlsch_info[NUMBER_OF_eNB_MAX][MAX_NUM_CCs][NUMBER_OF_UE_MAX]; // eNBxUE = 8x8
+
+/*
+#ifndef USER_MODE
+RRC_XFACE *Rrc_xface;
+MAC_xface *mac_xface;
+#else
+#include "PHY_INTERFACE/extern.h"
+#include "RRC/LITE/extern.h"
+#endif
+*/
+
+uint8_t Is_rrc_registered;
+
+#ifdef OPENAIR2
+unsigned char NB_eNB_INST=0;
+unsigned char NB_UE_INST=0;
+unsigned char NB_RN_INST=0;
+unsigned char NB_INST=0;
+#endif
+
+
+DCI0_5MHz_TDD_1_6_t       UL_alloc_pdu;
+
+DCI1A_5MHz_TDD_1_6_t      DLSCH_alloc_pdu1A;
+DCI1A_5MHz_TDD_1_6_t      RA_alloc_pdu;
+DCI1A_5MHz_TDD_1_6_t      BCCH_alloc_pdu;
+
+DCI1A_5MHz_TDD_1_6_t      CCCH_alloc_pdu;
+DCI1_5MHz_TDD_t           DLSCH_alloc_pdu;
+
+#if defined(Rel10) || defined(Rel14)
+DCI1C_5MHz_t                 MCCH_alloc_pdu;
+#endif
+
+DCI0_5MHz_FDD_t       UL_alloc_pdu_fdd;
+
+DCI1A_5MHz_FDD_t      DLSCH_alloc_pdu1A_fdd;
+DCI1A_5MHz_FDD_t      RA_alloc_pdu_fdd;
+DCI1A_5MHz_FDD_t      BCCH_alloc_pdu_fdd;
+
+DCI1A_5MHz_FDD_t      CCCH_alloc_pdu_fdd;
+DCI1_5MHz_FDD_t       DLSCH_alloc_pdu_fdd;
+
+DCI2_5MHz_2A_TDD_t DLSCH_alloc_pdu1;
+DCI2_5MHz_2A_TDD_t DLSCH_alloc_pdu2;
+
+DCI1E_5MHz_2A_M10PRB_TDD_t DLSCH_alloc_pdu1E;
+
+
+
+#endif
+
+

openair2/ENB_APP/enb_config.c

@@ -112,7 +112,6 @@ void RCconfig_L1(void) {
 
   if (RC.eNB == NULL) {
     RC.eNB                       = (PHY_VARS_eNB ** *)malloc((1+NUMBER_OF_eNB_MAX)*sizeof(PHY_VARS_eNB **));
-    RC.L1_NB_IoT                 = (PHY_VARS_eNB_NB_IoT **)malloc((1+NUMBER_OF_eNB_MAX)*sizeof(PHY_VARS_eNB_NB_IoT *));//Ann
     LOG_I(PHY,"RC.eNB = %p\n",RC.eNB);
     memset(RC.eNB,0,(1+NUMBER_OF_eNB_MAX)*sizeof(PHY_VARS_eNB **));
     RC.nb_L1_CC = malloc((1+RC.nb_L1_inst)*sizeof(int));
@@ -121,13 +120,6 @@ void RCconfig_L1(void) {
   config_getlist( &L1_ParamList,L1_Params,sizeof(L1_Params)/sizeof(paramdef_t), NULL);
 
   if (L1_ParamList.numelt > 0) {
-    for (j = 0; j < RC.nb_nb_iot_L1_inst; j++) {//Ann
-      if (RC.L1_NB_IoT[j] == NULL) { 
-        RC.L1_NB_IoT[j]                       = (PHY_VARS_eNB_NB_IoT *)malloc((1+MAX_NUM_CCs)*sizeof(PHY_VARS_eNB_NB_IoT ));
-        LOG_I(PHY,"RC.L1_NB_IoT[%d] = %p\n",j,RC.L1_NB_IoT[j]);
-        memset(RC.L1_NB_IoT[j],0,(1+MAX_NUM_CCs)*sizeof(PHY_VARS_eNB_NB_IoT));
-      }
-    }
 
     for (j = 0; j < RC.nb_L1_inst; j++) {
       RC.nb_L1_CC[j] = *(L1_ParamList.paramarray[j][L1_CC_IDX].uptr);
@@ -2949,6 +2941,7 @@ void read_config_and_init(void) {
                 RC.nb_macrlc_inst, RC.nb_inst);
 
   RCconfig_L1();
+  RCconfig_NbIoTL1();
   LOG_I(PHY, "%s() RC.nb_L1_inst: %d\n", __FUNCTION__, RC.nb_L1_inst);
   RCconfig_macrlc(macrlc_has_f1);
   LOG_I(MAC, "%s() RC.nb_macrlc_inst: %d\n", __FUNCTION__, RC.nb_macrlc_inst);

openair2/LAYER2/MAC/defs.h

@@ -261,7 +261,14 @@ typedef struct {
   uint8_t PH:6;
   uint8_t R:2;
 } __attribute__((__packed__))POWER_HEADROOM_CMD;
-
+/*!\brief  DCI PDU filled by MAC for the PHY  */
+typedef struct {
+  uint8_t Num_ue_spec_dci ;
+  uint8_t Num_common_dci  ;
+  //  uint32_t nCCE;
+  uint32_t num_pdcch_symbols;
+  DCI_ALLOC_t dci_alloc[NUM_DCI_MAX] ;
+} DCI_PDU;
 /*! \brief MIB payload */
 typedef struct {
   uint8_t payload[3] ;
@@ -305,7 +312,6 @@ typedef struct {
   uint8_t lcid:5;        // octet 2 MSB
   uint8_t stop_sf_LSB:8;
 } __attribute__((__packed__))MSI_ELEMENT;
-#endif
 /*! \brief Values of CCCH LCID for DLSCH */
 #define CCCH_LCHANID 0
 /*!\brief Values of BCCH logical channel (fake)*/
@@ -1343,3 +1349,4 @@ typedef struct {
 #include "proto.h"
 /*@}*/
 #endif /*__LAYER2_MAC_DEFS_H__ */
+#endif 
\ No newline at end of file

openair2/UTIL/OMG/defs.h

@@ -36,7 +36,7 @@
 
 //typedef char bool;
 #include <stdbool.h>
-
+#include "omg_constants.h"
 #ifdef STANDALONE
 typedef struct {
   char *name; /*!< \brief string name of item */

targets/RT/USER/init_lte.c

@@ -37,6 +37,8 @@
 //#include "PHY_INTERFACE/extern.h"
 #include "../../../openair1/PHY/defs_eNB.h"
 #include "../../../openair1/PHY/defs_common.h"
+#include "../../../openair1/PHY/vars.h"
+#include "../../../openair1/PHY/phy_vars.h"
 
 PHY_VARS_eNB* init_lte_eNB(LTE_DL_FRAME_PARMS *frame_parms,
                            uint8_t eNB_id,
@@ -92,9 +94,7 @@ PHY_VARS_eNB* init_lte_eNB(LTE_DL_FRAME_PARMS *frame_parms,
     
     LOG_I(PHY,"Allocating Transport Channel Buffer for ULSCH, UE %d\n", i);
     PHY_vars_eNB->ulsch[1+i] = new_eNB_ulsch(MAX_TURBO_ITERATIONS,frame_parms->N_RB_UL, abstraction_flag);
-    //////////////// NB-IoT testing ////////////////////////////
-    PHY_vars_eNB->ulsch_NB_IoT[1+i] = new_eNB_ulsch_NB_IoT(MAX_TURBO_ITERATIONS,frame_parms->N_RB_UL, abstraction_flag);
-    //////////////////////////////////////////////////////////////
+
     if (!PHY_vars_eNB->ulsch[1+i]) {
       LOG_E(PHY,"Can't get eNB ulsch structures\n");
       exit(-1);
@@ -128,18 +128,13 @@ PHY_VARS_eNB* init_lte_eNB(LTE_DL_FRAME_PARMS *frame_parms,
   
   // ULSCH for RA
   PHY_vars_eNB->ulsch[0] = new_eNB_ulsch(MAX_TURBO_ITERATIONS, frame_parms->N_RB_UL, abstraction_flag);
-  //////////////// NB-IoT testing ////////////////////////////
-  PHY_vars_eNB->ulsch_NB_IoT[0] = new_eNB_ulsch_NB_IoT(MAX_TURBO_ITERATIONS, frame_parms->N_RB_UL, abstraction_flag);
-  ////////////////////////////////////////////////////////////
+
   
   if (!PHY_vars_eNB->ulsch[0]) {
     LOG_E(PHY,"Can't get eNB ulsch structures\n");
     exit(-1);
   }
-  if (!PHY_vars_eNB->ulsch_NB_IoT[0]) {
-    LOG_E(PHY,"Can't get eNB ulsch structures\n");
-    exit(-1);
-  }
+
   PHY_vars_eNB->dlsch_SI  = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL, abstraction_flag, frame_parms);
   LOG_D(PHY,"eNB %d : SI %p\n",eNB_id,PHY_vars_eNB->dlsch_SI);
   PHY_vars_eNB->dlsch_ra  = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL, abstraction_flag, frame_parms);
@@ -147,25 +142,7 @@ PHY_VARS_eNB* init_lte_eNB(LTE_DL_FRAME_PARMS *frame_parms,
   PHY_vars_eNB->dlsch_MCH = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL, 0, frame_parms);
   LOG_D(PHY,"eNB %d : MCH %p\n",eNB_id,PHY_vars_eNB->dlsch_MCH);
 
-  ///// NB-IoT ////////////
-  PHY_vars_eNB->ndlsch_SIB1  = new_eNB_dlsch_NB_IoT(1,frame_parms);   // frame_parms is not used , to be removed is not used in futur
-  PHY_vars_eNB->ndlsch_SIB23  = new_eNB_dlsch_NB_IoT(1,frame_parms);
-  PHY_vars_eNB->ndlsch_RAR  = new_eNB_dlsch_NB_IoT(1,frame_parms);
-
-  PHY_vars_eNB->npdcch_DCI  = new_eNB_dlcch_NB_IoT(frame_parms);
-
-  PHY_vars_eNB->UL_INFO.nrach_ind.nrach_pdu_list  = (nfapi_nrach_indication_pdu_t *)malloc16(sizeof(nfapi_nrach_indication_pdu_t));
-  PHY_vars_eNB->UL_INFO.crc_ind.crc_pdu_list  = (nfapi_crc_indication_pdu_t *)malloc16(sizeof(nfapi_crc_indication_pdu_t));
-  PHY_vars_eNB->UL_INFO.RX_NPUSCH.rx_pdu_list  = (nfapi_rx_indication_pdu_t *)malloc16(sizeof(nfapi_rx_indication_pdu_t));
-  PHY_vars_eNB->UL_INFO.RX_NPUSCH.rx_pdu_list[0].data  = (unsigned char*)malloc(300);
-  
-  PHY_vars_eNB->UL_INFO.nb_harq_ind.nb_harq_indication_body.nb_harq_pdu_list = (nfapi_nb_harq_indication_pdu_t*)malloc16(sizeof(nfapi_nb_harq_indication_pdu_t));
 
-  
-  //nfapi_nb_harq_indication_t nb_harq_ind
- 
-  PHY_vars_eNB->ndlsch_SIB1->rnti = 0xffff;
-  PHY_vars_eNB->ndlsch_SIB23->rnti = 0xffff;
  
   PHY_vars_eNB->rx_total_gain_dB=130;
   
@@ -242,6 +219,13 @@ PHY_VARS_eNB_NB_IoT* init_lte_eNB_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms,
     LOG_I(PHY,"Allocating Transport Channel Buffer for ULSCH, UE %d\n", i);
     PHY_vars_eNB->ulsch[1+i] = new_eNB_ulsch(MAX_TURBO_ITERATIONS,frame_parms->N_RB_UL, abstraction_flag);
     
+    //////////////// NB-IoT testing ////////////////////////////
+    PHY_vars_eNB->ulsch_NB_IoT[1+i] = new_eNB_ulsch_NB_IoT(MAX_TURBO_ITERATIONS,frame_parms->N_RB_UL, abstraction_flag);
+    //////////////////////////////////////////////////////////////
+    //////////////// NB-IoT testing ////////////////////////////
+    PHY_vars_eNB->ulsch_NB_IoT[0] = new_eNB_ulsch_NB_IoT(MAX_TURBO_ITERATIONS, frame_parms->N_RB_UL, abstraction_flag);
+    ////////////////////////////////////////////////////////////
+
     if (!PHY_vars_eNB->ulsch[1+i]) {
       LOG_E(PHY,"Can't get eNB ulsch structures\n");
       exit(-1);
@@ -290,7 +274,25 @@ PHY_VARS_eNB_NB_IoT* init_lte_eNB_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms,
   PHY_vars_eNB->dlsch_MCH = new_eNB_dlsch(1,8,NSOFT,frame_parms->N_RB_DL, 0, frame_parms);
   LOG_D(PHY,"eNB %d : MCH %p\n",eNB_id,PHY_vars_eNB->dlsch_MCH);
   */
+    ///// NB-IoT ////////////
+  PHY_vars_eNB->ndlsch_SIB1  = new_eNB_dlsch_NB_IoT(1,frame_parms);   // frame_parms is not used , to be removed is not used in futur
+  PHY_vars_eNB->ndlsch_SIB23  = new_eNB_dlsch_NB_IoT(1,frame_parms);
+  PHY_vars_eNB->ndlsch_RAR  = new_eNB_dlsch_NB_IoT(1,frame_parms);
+
+  PHY_vars_eNB->npdcch_DCI  = new_eNB_dlcch_NB_IoT(frame_parms);
+
+  PHY_vars_eNB->UL_INFO.nrach_ind.nrach_pdu_list  = (nfapi_nrach_indication_pdu_t *)malloc16(sizeof(nfapi_nrach_indication_pdu_t));
+  PHY_vars_eNB->UL_INFO.crc_ind.crc_pdu_list  = (nfapi_crc_indication_pdu_t *)malloc16(sizeof(nfapi_crc_indication_pdu_t));
+  PHY_vars_eNB->UL_INFO.RX_NPUSCH.rx_pdu_list  = (nfapi_rx_indication_pdu_t *)malloc16(sizeof(nfapi_rx_indication_pdu_t));
+  PHY_vars_eNB->UL_INFO.RX_NPUSCH.rx_pdu_list[0].data  = (unsigned char*)malloc(300);
+  
+  PHY_vars_eNB->UL_INFO.nb_harq_ind.nb_harq_indication_body.nb_harq_pdu_list = (nfapi_nb_harq_indication_pdu_t*)malloc16(sizeof(nfapi_nb_harq_indication_pdu_t));
+
   
+  //nfapi_nb_harq_indication_t nb_harq_ind
+ 
+  PHY_vars_eNB->ndlsch_SIB1->rnti = 0xffff;
+  PHY_vars_eNB->ndlsch_SIB23->rnti = 0xffff;
   PHY_vars_eNB->rx_total_gain_dB=130;
   
  /* for(i=0; i<NUMBER_OF_UE_MAX; i++)

targets/RT/USER/lte-enb.c

@@ -857,7 +857,7 @@ static void *process_stats_thread(void *param) {
 void init_eNB_proc(int inst) {
   /*int i=0;*/
   int CC_id;
-  PHY_VARS_eNB *eNB;
+  //PHY_VARS_eNB *eNB;
   // PHY_VARS_eNB_NB_IoT *eNB_NB_IoT;//Ann
   eNBs_t *eNBs;//Ann
   L1_proc_t *proc;
@@ -867,14 +867,14 @@ void init_eNB_proc(int inst) {
   pthread_attr_t *attr_prach_br=NULL;
 #endif
   LOG_I(PHY,"%s(inst:%d) RC.nb_CC[inst]:%d \n",__FUNCTION__,inst,RC.nb_CC[inst]);
-    eNBs->eNB_NB_IoT = RC.L1_NB_IoT[inst];//[CC_id];//Ann
+    eNBs->eNB_NB_IoT = RC.L1_NB_IoT[inst];//Ann
   for (CC_id=0; CC_id<RC.nb_CC[inst]; CC_id++) {
     eNBs->eNB = RC.eNB[inst][CC_id];
     
 #ifndef OCP_FRAMEWORK
     LOG_I(PHY,"Initializing eNB processes instance:%d CC_id %d \n",inst,CC_id);
 #endif
-    proc = &eNB->proc;
+    proc = &eNBs->eNB->proc;
     L1_proc                        = &proc->L1_proc;
     L1_proc_tx                     = &proc->L1_proc_tx;
     L1_proc->instance_cnt          = -1;
@@ -887,10 +887,10 @@ void init_eNB_proc(int inst) {
     proc->CC_id                    = CC_id;
     proc->first_rx                 =1;
     proc->first_tx                 =1;
-    proc->RU_mask_tx               = (1<<eNB->num_RU)-1;
+    proc->RU_mask_tx               = (1<<eNBs->eNB->num_RU)-1;
     memset((void*)proc->RU_mask,0,10*sizeof(proc->RU_mask[0]));
     proc->RU_mask_prach            =0;
-    pthread_mutex_init( &eNB->UL_INFO_mutex, NULL);
+    pthread_mutex_init( &eNBs->eNB->UL_INFO_mutex, NULL);
     pthread_mutex_init( &L1_proc->mutex, NULL);
     pthread_mutex_init( &L1_proc_tx->mutex, NULL);
     pthread_cond_init( &L1_proc->cond, NULL);
@@ -930,11 +930,11 @@ void init_eNB_proc(int inst) {
 #endif
 
     if(get_thread_worker_conf() == WORKER_ENABLE) {
-      init_te_thread(eNB);
-      init_td_thread(eNB);
+      init_te_thread(eNBs->eNB);
+      init_td_thread(eNBs->eNB);
     }
 
-    LOG_I(PHY,"eNB->single_thread_flag:%d\n", eNB->single_thread_flag);
+    LOG_I(PHY,"eNBs->eNB->single_thread_flag:%d\n", eNBs->eNB->single_thread_flag);
 
     if ((get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT) && NFAPI_MODE!=NFAPI_MODE_VNF) {
       pthread_create( &L1_proc->pthread, attr0, L1_thread, proc );
@@ -952,26 +952,26 @@ void init_eNB_proc(int inst) {
     if (NFAPI_MODE!=NFAPI_MODE_VNF) {
       pthread_create( &proc->pthread_prach, attr_prach, eNB_thread_prach, eNBs );
 #if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
-      pthread_create( &proc->pthread_prach_br, attr_prach_br, eNB_thread_prach_br, eNB );
+      pthread_create( &proc->pthread_prach_br, attr_prach_br, eNB_thread_prach_br, eNBs->eNB );
 #endif
     }
     AssertFatal(proc->instance_cnt_prach == -1,"instance_cnt_prach = %d\n",proc->instance_cnt_prach);
 
-    if (opp_enabled == 1) pthread_create(&proc->process_stats_thread,NULL,process_stats_thread,(void *)eNB);
+    if (opp_enabled == 1) pthread_create(&proc->process_stats_thread,NULL,process_stats_thread,(void *)eNBs->eNB);
   }
 
   //for multiple CCs: setup master and slaves
   /*
      for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-     eNB = PHY_vars_eNB_g[inst][CC_id];
+     eNBs->eNB = PHY_vars_eNB_g[inst][CC_id];
 
-     if (eNB->node_timing == synch_to_ext_device) { //master
-     eNB->proc.num_slaves = MAX_NUM_CCs-1;
-     eNB->proc.slave_proc = (L1_proc_t**)malloc(eNB->proc.num_slaves*sizeof(L1_proc_t*));
+     if (eNBs->eNB->node_timing == synch_to_ext_device) { //master
+     eNBs->eNB->proc.num_slaves = MAX_NUM_CCs-1;
+     eNBs->eNB->proc.slave_proc = (L1_proc_t**)malloc(eNBs->eNB->proc.num_slaves*sizeof(L1_proc_t*));
 
-     for (i=0; i< eNB->proc.num_slaves; i++) {
-     if (i < CC_id)  eNB->proc.slave_proc[i] = &(PHY_vars_eNB_g[inst][i]->proc);
-     if (i >= CC_id)  eNB->proc.slave_proc[i] = &(PHY_vars_eNB_g[inst][i+1]->proc);
+     for (i=0; i< eNBs->eNB->proc.num_slaves; i++) {
+     if (i < CC_id)  eNBs->eNB->proc.slave_proc[i] = &(PHY_vars_eNB_g[inst][i]->proc);
+     if (i >= CC_id)  eNBs->eNB->proc.slave_proc[i] = &(PHY_vars_eNB_g[inst][i+1]->proc);
      }
      }
      }