Merge branch 'develop-nr' into nr_pdcch

cmake_targets/CMakeLists.txt

@@ -1023,6 +1023,7 @@ set(SCHED_SRC
 add_library(SCHED_LIB ${SCHED_SRC})
 
 set(SCHED_NR_SRC
+  ${OPENAIR1_DIR}/SCHED_NR/fapi_nr_l1.c
   ${OPENAIR1_DIR}/SCHED_NR/phy_procedures_nr_common.c
   ${OPENAIR1_DIR}/SCHED_NR/phy_procedures_nr_gNB.c
 )
@@ -1471,6 +1472,7 @@ set (MAC_SRC
   ${NR_MAC_DIR}/config.c
   ${NR_MAC_DIR}/gNB_scheduler.c
   ${NR_MAC_DIR}/gNB_scheduler_bch.c
+  ${NR_MAC_DIR}/gNB_scheduler_primitives.c
  )
 
 

nfapi/oai_integration/nfapi_vnf.c

@@ -31,7 +31,7 @@
 #include <netinet/in.h>
 #include <arpa/inet.h>
 
-#include "nfapi_interface.h"
+#include "nfapi_nr_interface.h"
 #include "nfapi_vnf_interface.h"
 #include "nfapi.h"
 #include "vendor_ext.h"
@@ -1161,6 +1161,25 @@ int oai_nfapi_dl_config_req(nfapi_dl_config_request_t *dl_config_req)
   return retval;
 }
 
+int oai_nfapi_nr_dl_config_req(nfapi_nr_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!!!!
+
+  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;

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

@@ -79,8 +79,13 @@ typedef struct {
 	uint8_t redundancy_version;
     uint8_t harq_process;
     uint8_t tpc_command;
-
+    uint8_t padding_bits;
     uint8_t ul_sul_ind;
+    uint8_t ul_sch_indicator;
+
+    uint8_t random_access_preamble_index;
+    uint8_t ss_pbch_index;
+    uint8_t prach_mask_index;
 
     uint8_t carrier_indicator;
     uint8_t bwp_indndicator;
@@ -100,6 +105,9 @@ typedef struct {
     uint8_t pdsch_to_harq_feedback_timing_indicator;
 
     uint8_t short_messages_indicator;
+    uint8_t short_messages;
+    uint8_t tb_scaling;
+
 
     uint8_t prb_bundling_size_indicator;    //  38.214 chapter 5.1.2.3
     uint8_t rate_matching_indicator;
@@ -113,11 +121,12 @@ typedef struct {
     uint8_t preemption_indication_count;
     uint8_t *preemption_indications;    //  38.213 chapter 11.2
 
+    uint8_t block_number_count;         //  for F22 and F23
+    uint8_t *block_numbers;             //  for F22 and F23
+    uint8_t closed_loop_indicator;
+
     uint8_t tpc_command_count;
     uint8_t *tpc_command_numbers;
-
-    uint8_t block_number_count;
-    uint8_t *block_numbers;
     uint8_t dci2_3_srs_request;    //  38.212 table 7.3.1.1.2-5   
     uint8_t dci2_3_tpc_command;
 

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

@@ -3,6 +3,17 @@
 
 #include "nfapi_interface.h"
 
+// nFAPI enums
+typedef enum {
+  NFAPI_NR_DL_CONFIG_DCI_DL_PDU_TYPE = 0,
+  NFAPI_NR_DL_CONFIG_BCH_PDU_TYPE,
+  NFAPI_NR_DL_CONFIG_DLSCH_PDU_TYPE,
+  NFAPI_NR_DL_CONFIG_PCH_PDU_TYPE,
+  NFAPI_NR_DL_CONFIG_NBCH_PDU_TYPE,
+  NFAPI_NR_DL_CONFIG_NPDCCH_PDU_TYPE,
+  NFAPI_NR_DL_CONFIG_NDLSCH_PDU_TYPE
+} nfapi_nr_dl_config_pdu_type_e;
+
 //These TLVs are used exclusively by nFAPI
 typedef struct
 {
@@ -405,18 +416,18 @@ typedef struct {
   union {
     nfapi_nr_dl_config_dci_dl_pdu_rel15_t     dci_dl_pdu_rel15;
     nfapi_nr_ul_config_dci_ul_pdu_rel15_t     dci_ul_pdu_rel15;
-    nfapi_nr_dl_config_bch_pdu_rel15_t        bch_pdu;
-    nfapi_nr_dl_config_dlsch_pdu_rel15_t      dlsch_pdu;
-    nfapi_nr_dl_config_pch_pdu_rel15_t        pch_pdu;
-    nfapi_nr_dl_config_nbch_pdu_rel15_t       nbch_pdu;
-    nfapi_nr_dl_config_npdcch_pdu_rel15_t     npdcch_pdu;
-    nfapi_nr_dl_config_ndlsch_pdu_rel15_t     ndlsch_pdu;
+    nfapi_nr_dl_config_bch_pdu_rel15_t        bch_pdu_rel15;
+    nfapi_nr_dl_config_dlsch_pdu_rel15_t      dlsch_pdu_rel15;
+    nfapi_nr_dl_config_pch_pdu_rel15_t        pch_pdu_rel15;
+    nfapi_nr_dl_config_nbch_pdu_rel15_t       nbch_pdu_rel15;
+    nfapi_nr_dl_config_npdcch_pdu_rel15_t     npdcch_pdu_rel15;
+    nfapi_nr_dl_config_ndlsch_pdu_rel15_t     ndlsch_pdu_rel15;
   };
 } nfapi_nr_dl_config_request_pdu_t;
  
 typedef struct {
   nfapi_tl_t tl;
-  //uint8_t number_pdcch_ofdm_symbols;
+  uint8_t number_pdcch_ofdm_symbols;
   uint8_t   number_dci;
   uint16_t  number_pdu;
   uint8_t   number_pdsch_rnti;

openair1/PHY/INIT/nr_init.c

@@ -36,6 +36,7 @@
 
 #include "PHY/NR_REFSIG/nr_refsig.h" 
 #include "PHY/LTE_REFSIG/lte_refsig.h"
+#include "SCHED_NR/fapi_nr_l1.h"
 
 extern uint32_t from_earfcn(int eutra_bandP,uint32_t dl_earfcn);
 extern int32_t get_uldl_offset(int eutra_bandP);
@@ -65,8 +66,8 @@ int l1_north_init_gNB() {
 
         LOG_I(PHY,"%s() RC.gNB[%d][%d] installing callbacks\n", __FUNCTION__, i,  j);
 
-        RC.gNB[i][j]->if_inst->PHY_config_req = nr_phy_config_request;
-        RC.gNB[i][j]->if_inst->schedule_response = schedule_response;
+        RC.gNB[i][j]->if_inst->NR_PHY_config_req = nr_phy_config_request;
+        RC.gNB[i][j]->if_inst->NR_Schedule_response = nr_schedule_response;
       }
     }
   }

openair1/PHY/NR_TRANSPORT/nr_pbch.c

@@ -143,7 +143,7 @@ void nr_pbch_scrambling(NR_gNB_PBCH *pbch,
   uint8_t *pbch_e = pbch->pbch_e;
   uint32_t *pbch_a_prime = (uint32_t*)pbch->pbch_a_prime;
   uint32_t *pbch_a_interleaved = (uint32_t*)pbch->pbch_a_interleaved;
-  uint32_t unscrambling_mask = 0x87002D;
+  uint32_t unscrambling_mask = 0x100006D;
 
   reset = 1;
   // x1 is set in lte_gold_generic
@@ -177,21 +177,26 @@ void nr_pbch_scrambling(NR_gNB_PBCH *pbch,
   }
 }
 
-uint8_t nr_pbch_payload_interleaving_pattern[32] = {16, 23, 18, 17, 8, 30, 10, 6, 24, 7, 0, 5, 3, 2, 1, 4,
+/* This portion of code is temporarily kept until the optimized version is validated
+ * uint8_t nr_pbch_payload_interleaving_pattern[32] = {16, 23, 18, 17, 8, 30, 10, 6, 24, 7, 0, 5, 3, 2, 1, 4,
                                                 9, 11, 12, 13, 14, 15, 19, 20, 21, 22, 25, 26, 27, 28, 29, 31};
 
 uint8_t nr_pbch_payload_interleaver(uint8_t i) {
   uint8_t j_sfn=0, j_hrf=10, j_ssb=11, j_other=14;
 
-  if (24<=i && i<=27) //Sfn bits
-    return nr_pbch_payload_interleaving_pattern[j_sfn + i -24];
+  if (18<=i && i<=27) //Sfn bits
+    return nr_pbch_payload_interleaving_pattern[j_sfn + i -18];
   else if (i==28) // Hrf bit
     return nr_pbch_payload_interleaving_pattern[j_hrf];
   else if (29<=i) // Ssb bits
     return nr_pbch_payload_interleaving_pattern[j_ssb + (i-29)];
   else
     return nr_pbch_payload_interleaving_pattern[j_other + i];
-}
+}*/
+
+/*This pattern takes into account the adjustments for the field specific counters j_sfn, j_hrf, j_ssb and j_other*/
+uint8_t nr_pbch_payload_interleaving_pattern[32] = {1,4,9,11,12,13,14,15,19,20,21,22,25,26,27,28,
+                                                    29,31,16,23,18,17,8,30,10,6,24,7,0,5,3,2};
 
 int nr_generate_pbch(NR_gNB_PBCH *pbch,
                      uint8_t *pbch_pdu,
@@ -212,6 +217,8 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
   uint8_t idx=0;
   uint16_t M;
   uint8_t nushift;
+  uint8_t *xbyte = pbch->pbch_a;
+  memset((void*) xbyte, 0, 1);
 
   LOG_I(PHY, "PBCH generation started\n");
 
@@ -223,13 +230,10 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
 #ifdef DEBUG_PBCH_ENCODING
   printf("Byte endian fix:\n");
   for (int i=0; i<4; i++)
-  printf("pbch_a[%d]: 0x%04x\n", i, pbch->pbch_a[i]);
-  
+    printf("pbch_a[%d]: 0x%02x\n", i, pbch->pbch_a[i]);
 #endif
 
     // Extra byte generation
-  uint8_t *xbyte = pbch->pbch_a;
-  //memset((void*) xbyte, 0, 1);
   for (int i=0; i<4; i++)
     (*xbyte) ^= ((sfn>>i)&1)<<i; // 4 lsb of sfn
 
@@ -243,18 +247,28 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
 #ifdef DEBUG_PBCH_ENCODING
   printf("Extra byte:\n");
   for (int i=0; i<4; i++)
-  printf("pbch_a[%d]: 0x%04x\n", i, pbch->pbch_a[i]);
+    printf("pbch_a[%d]: 0x%02x\n", i, pbch->pbch_a[i]);
 #endif
 
     // Payload interleaving
-  uint32_t* input = (uint32_t*)pbch->pbch_a;
-  uint32_t* output = (uint32_t*)pbch->pbch_a_interleaved;
-  for (int i=0; i<32; i++)
-    (*output) |= (((*input)>>i)&1)<<(nr_pbch_payload_interleaver(i));
+  uint32_t in=0, out=0;
+  for (int i=0; i<NR_POLAR_PBCH_PAYLOAD_BITS>>3; i++)
+    in |= (uint32_t)(pbch->pbch_a[i]<<((3-i)<<3));
+
+  for (int i=0; i<32; i++) {
+    out |= ((in>>i)&1)<<(nr_pbch_payload_interleaving_pattern[i]);
+#ifdef DEBUG_PBCH_ENCODING
+  printf("i %d in 0x%08x out 0x%08x ilv %d (in>>i)&1) 0x%08x\n", i, in, out, nr_pbch_payload_interleaving_pattern[i], (in>>i)&1);
+#endif
+  }
+
+  for (int i=0; i<NR_POLAR_PBCH_PAYLOAD_BITS>>3; i++)
+    pbch->pbch_a_interleaved[i] = (uint8_t)((out>>(i<<3))&0xff);
+
 #ifdef DEBUG_PBCH_ENCODING
   printf("Interleaving:\n");
   for (int i=0; i<4; i++)
-  printf("pbch_a_interleaved[%d]: 0x%04x\n", i, pbch->pbch_a_interleaved[i]);
+    printf("pbch_a_interleaved[%d]: 0x%02x\n", i, pbch->pbch_a_interleaved[i]);
 #endif
 
     // Scrambling
@@ -264,7 +278,7 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
 #ifdef DEBUG_PBCH_ENCODING
   printf("Payload scrambling:\n");
   for (int i=0; i<4; i++)
-  printf("pbch_a_prime[%d]: 0x%04x\n", i, pbch->pbch_a_prime[i]);
+    printf("pbch_a_prime[%d]: 0x%02x\n", i, pbch->pbch_a_prime[i]);
 #endif
 
 
@@ -273,18 +287,18 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
 #ifdef DEBUG_PBCH_ENCODING
   printf("Channel coding:\n");
   for (int i=0; i<NR_POLAR_PBCH_E>>3; i++)
-  printf("pbch_e[%d]: 0x%04x\t", i, pbch->pbch_e[i]);
+    printf("pbch_e[%d]: 0x%02x\t", i, pbch->pbch_e[i]);
   printf("\n");
 #endif
 
   /// Scrambling
   M =  NR_POLAR_PBCH_E;
-  nushift = config->sch_config.physical_cell_id.value &3;;
+  nushift = (Lmax==4)? ssb_index&3 : ssb_index&7;
   nr_pbch_scrambling(pbch, (uint32_t)config->sch_config.physical_cell_id.value, nushift, M, NR_POLAR_PBCH_E, 0);
 #ifdef DEBUG_PBCH_ENCODING
   printf("Scrambling:\n");
   for (int i=0; i<NR_POLAR_PBCH_E>>3; i++)
-  printf("pbch_e[%d]: 0x%04x\t", i, pbch->pbch_e[i]);
+    printf("pbch_e[%d]: 0x%02x\t", i, pbch->pbch_e[i]);
   printf("\n");
 #endif
 
@@ -300,6 +314,7 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
   }
 
   /// Resource mapping
+  nushift = config->sch_config.physical_cell_id.value &3;
   a = (config->rf_config.tx_antenna_ports.value == 1) ? amp : (amp*ONE_OVER_SQRT2_Q15)>>15;
 
   for (int aa = 0; aa < config->rf_config.tx_antenna_ports.value; aa++)

openair1/PHY/phy_extern_nr_ue.h

@@ -23,7 +23,7 @@
 #define __PHY_EXTERN_UE__H__
 
 #include "PHY/defs_nr_UE.h"
-#include "common/ran_context.h"
+//#include "common/ran_context.h"
 
 extern  char* namepointer_chMag ;
 extern char* namepointer_log2;

openair1/SCHED_NR/fapi_nr_l1.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file fapi_l1.c
+ * \brief functions for FAPI L1 interface
+ * \author R. Knopp
+ * \date 2017
+ * \version 0.1
+ * \company Eurecom
+ * \email: knopp@eurecom.fr
+ * \note
+ * \warning
+ */
+#include "fapi_nr_l1.h"
+
+int oai_nfapi_nr_dl_config_req(nfapi_nr_dl_config_request_t *dl_config_req);
+int oai_nfapi_tx_req(nfapi_tx_request_t *tx_req);
+
+extern uint8_t nfapi_mode;
+
+void handle_nr_nfapi_bch_pdu(PHY_VARS_gNB *gNB,
+                             gNB_rxtx_proc_t *proc,
+                             nfapi_nr_dl_config_request_pdu_t *dl_config_pdu,
+                             uint8_t *sdu)
+{
+
+  AssertFatal(dl_config_pdu->bch_pdu_rel15.length == 3, "BCH PDU has length %d != 3\n",
+              dl_config_pdu->bch_pdu_rel15.length);
+
+  LOG_I(PHY,"pbch_pdu[0]: %x,pbch_pdu[1]: %x,gNB->pbch_pdu[2]: %x\n",sdu[0],sdu[1],sdu[2]);
+  gNB->pbch_pdu[0] = sdu[2];
+  gNB->pbch_pdu[1] = sdu[1];
+  gNB->pbch_pdu[2] = sdu[0];
+
+  // adjust transmit amplitude here based on NFAPI info
+}
+
+void nr_schedule_response(NR_Sched_Rsp_t *Sched_INFO){
+  PHY_VARS_gNB *gNB;
+  gNB_rxtx_proc_t *proc;
+  // copy data from L2 interface into L1 structures
+  module_id_t                   Mod_id       = Sched_INFO->module_id;
+  uint8_t                       CC_id        = Sched_INFO->CC_id;
+  nfapi_nr_dl_config_request_t  *DL_req      = Sched_INFO->DL_req;
+  nfapi_tx_request_t            *TX_req      = Sched_INFO->TX_req;
+  frame_t                       frame        = Sched_INFO->frame;
+  sub_frame_t                   subframe     = Sched_INFO->subframe;
+
+  AssertFatal(RC.gNB!=NULL,"RC.gNB is null\n");
+  AssertFatal(RC.gNB[Mod_id]!=NULL,"RC.gNB[%d] is null\n",Mod_id);
+  AssertFatal(RC.gNB[Mod_id][CC_id]!=NULL,"RC.gNB[%d][%d] is null\n",Mod_id,CC_id);
+
+  gNB         = RC.gNB[Mod_id][CC_id];
+  proc        = &gNB->proc.proc_rxtx[0];
+
+  uint8_t number_dl_pdu             = DL_req->dl_config_request_body.number_pdu;
+
+  nfapi_nr_dl_config_request_pdu_t *dl_config_pdu;
+ 
+  int i;
+
+  LOG_D(PHY,"NFAPI: Sched_INFO:SFN/SF:%04d%d DL_req:SFN/SF:%04d%d:dl_pdu:%d tx_req:SFN/SF:%04d%d:pdus:%d \n",
+        frame,subframe,
+        NFAPI_SFNSF2SFN(DL_req->sfn_sf),NFAPI_SFNSF2SF(DL_req->sfn_sf),number_dl_pdu,
+        NFAPI_SFNSF2SFN(TX_req->sfn_sf),NFAPI_SFNSF2SF(TX_req->sfn_sf),TX_req->tx_request_body.number_of_pdus);
+
+  int do_oai =0;
+  int dont_send =0;
+
+  for (i=0;i<number_dl_pdu;i++) {
+    dl_config_pdu = &DL_req->dl_config_request_body.dl_config_pdu_list[i];
+    //LOG_D(PHY,"NFAPI: dl_pdu %d : type %d\n",i,dl_config_pdu->pdu_type);
+    switch (dl_config_pdu->pdu_type) {
+      case NFAPI_NR_DL_CONFIG_BCH_PDU_TYPE:
+        AssertFatal(dl_config_pdu->bch_pdu_rel15.pdu_index < TX_req->tx_request_body.number_of_pdus,
+                    "bch_pdu_rel8.pdu_index>=TX_req->number_of_pdus (%d>%d)\n",
+                    dl_config_pdu->bch_pdu_rel15.pdu_index,
+                    TX_req->tx_request_body.number_of_pdus);
+        gNB->pbch_configured=1;
+        do_oai=1;
+
+        handle_nr_nfapi_bch_pdu(gNB,
+                                proc,
+                                dl_config_pdu,
+                                TX_req->tx_request_body.tx_pdu_list[dl_config_pdu->bch_pdu_rel15.pdu_index].segments[0].segment_data);
+      break;
+    }
+  }
+  
+  if (nfapi_mode && do_oai && !dont_send) {
+    oai_nfapi_tx_req(Sched_INFO->TX_req);
+
+    oai_nfapi_nr_dl_config_req(Sched_INFO->DL_req); // DJP - .dl_config_request_body.dl_config_pdu_list[0]); // DJP - FIXME TODO - yuk - only copes with 1 pdu
+  }
+
+}

openair2/LAYER2/NR_MAC_UE/mac_proto.h → openair1/SCHED_NR/fapi_nr_l1.h

@@ -19,39 +19,23 @@
  *      contact@openairinterface.org
  */
 
-/*! \file LAYER2/MAC/proto.h
- * \brief MAC functions prototypes for eNB and UE
- * \author Navid Nikaein and Raymond Knopp
- * \date 2010 - 2014
- * \email navid.nikaein@eurecom.fr
- * \version 1.0
+/*! \file fapi_l1.h
+ * \brief function prototypes for FAPI L1 interface
+ * \author R. Knopp
+ * \date 2017
+ * \version 0.1
+ * \company Eurecom
+ * \email: knopp@eurecom.fr
+ * \note
+ * \warning
  */
-#ifndef __LAYER2_MAC_PROTO_H__
-#define __LAYER2_MAC_PROTO_H__
 
-#include "mac_defs.h"
+#include "PHY/defs_gNB.h"
+#include "PHY/phy_extern.h"
+#include "PHY/LTE_TRANSPORT/transport_proto.h"
+#include "SCHED/sched_eNB.h"
+#include "SCHED/sched_common.h"
+#include "SCHED_NR/sched_nr.h"
+#include "nfapi_nr_interface.h"
 
-/**\brief decode mib pdu in NR_UE, from if_module ul_ind with P7 tx_ind message
-   \param module_id     module id
-   \param CC_id         component carrier id
-   \param gNB_index     gNB index
-   \param extra_bits    extra bits for frame calculation
-   \param ssb_index     SSB index for frame calculation
-   \param frameP        pointer to frame for revising after frame calculation
-   \param pduP          pointer to pdu
-   \param pdu_length    length of pdu*/
-void nr_ue_decode_mib(module_id_t module_id, int CC_id, uint8_t gNB_index, uint8_t extra_bits, uint32_t ssb_index, uint32_t *frameP, void *pduP, uint16_t pdu_len);
-
-
-/**\brief primitive from RRC layer to MAC layer for configuration L1/L2, now supported 4 rrc messages: MIB, cell_group_config for MAC/PHY, spcell_config(serving cell config)
-   \param module_id                 module id
-   \param CC_id                     component carrier id
-   \param gNB_index                 gNB index
-   \param mibP                      pointer to RRC message MIB
-   \param mac_cell_group_configP    pointer to RRC message MAC-related in cell group config 
-   \param phy_cell_group_configP    pointer to RRC message PHY-related in cell group config
-   \param spcell_configP            pointer to RRC message serving cell config*/
-int nr_rrc_mac_config_req_ue( module_id_t module_id, int CC_id, uint8_t gNB_index, NR_MIB_t *mibP, NR_MAC_CellGroupConfig_t *mac_cell_group_configP, NR_PhysicalCellGroupConfig_t *phy_cell_group_configP, NR_SpCellConfig_t *spcell_configP ){
-
-#endif
-/** @}*/
+void nr_schedule_response(NR_Sched_Rsp_t *Sched_INFO);
\ No newline at end of file

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -60,7 +60,7 @@
 #endif
 
 #include "LAYER2/NR_MAC_UE/extern.h"
-#include "LAYER2/NR_MAC_UE/defs.h"
+#include "LAYER2/NR_MAC_UE/mac_defs.h"
 #include "UTIL/LOG/log.h"
 
 #ifdef EMOS

openair2/GNB_APP/gnb_app.c

@@ -81,6 +81,8 @@ static void configure_nr_rrc(uint32_t gnb_id)
 }
 
 /*------------------------------------------------------------------------------*/
+
+/*
 # if defined(ENABLE_USE_MME)
 static uint32_t gNB_app_register(uint32_t gnb_id_start, uint32_t gnb_id_end)//, const Enb_properties_array_t *enb_properties)
 {
@@ -92,7 +94,7 @@ static uint32_t gNB_app_register(uint32_t gnb_id_start, uint32_t gnb_id_end)//,
     {
       s1ap_register_enb_req_t *s1ap_register_gNB; //Type Temporarily reuse
 
-      /* note:  there is an implicit relationship between the data structure and the message name */
+      // note:  there is an implicit relationship between the data structure and the message name 
       msg_p = itti_alloc_new_message (TASK_GNB_APP, S1AP_REGISTER_ENB_REQ); //Message Temporarily reuse
 
       RCconfig_NR_S1(msg_p, gnb_id);
@@ -113,8 +115,10 @@ static uint32_t gNB_app_register(uint32_t gnb_id_start, uint32_t gnb_id_end)//,
   return register_gnb_pending;
 }
 # endif
+*/
 #endif
 
+
 /*------------------------------------------------------------------------------*/
 void *gNB_app_task(void *args_p)
 {

openair2/GNB_APP/gnb_config.c

@@ -599,7 +599,7 @@ int RCconfig_NRRRC(MessageDef *msg_p, uint32_t i, gNB_RRC_INST *rrc) {
   int32_t                srb1_poll_byte                = 0;
   int32_t                srb1_max_retx_threshold       = 0;
 
-  int32_t             my_int;
+  //int32_t             my_int;
 
   paramdef_t GNBSParams[] = GNBSPARAMS_DESC;
   ////////// Identification parameters

openair2/LAYER2/NR_MAC_UE/mac.h

@@ -34,8 +34,8 @@
 
 /*@}*/
 
-#ifndef __LAYER2_MAC_DEFS_H__
-#define __LAYER2_MAC_DEFS_H__
+#ifndef __LAYER2_NR_UE_MAC_DEFS_H__
+#define __LAYER2_NR_UE_MAC_DEFS_H__
 
 
 
@@ -43,40 +43,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "COMMON/platform_constants.h"
-#include "BCCH-BCH-Message.h"
-#include "RadioResourceConfigCommon.h"
-#include "RadioResourceConfigCommonSIB.h"
-#include "RadioResourceConfigDedicated.h"
-#include "MeasGapConfig.h"
-#include "SchedulingInfoList.h"
-#include "TDD-Config.h"
-#include "RACH-ConfigCommon.h"
-#include "MeasObjectToAddModList.h"
-#include "MobilityControlInfo.h"
-#if defined(Rel10) || defined(Rel14)
-#include "MBSFN-AreaInfoList-r9.h"
-#include "MBSFN-SubframeConfigList.h"
-#include "PMCH-InfoList-r9.h"
-#include "SCellToAddMod-r10.h"
-#endif
-#ifdef Rel14
-#include "SystemInformationBlockType1-v1310-IEs.h"
-#endif
-
-#include "nfapi_interface.h"
-#include "PHY_INTERFACE/IF_Module.h"
-
-#include "PHY/TOOLS/time_meas.h"
-
-#include "PHY/defs_common.h" // for PRACH_RESOURCES_t
-
-#include "targets/ARCH/COMMON/common_lib.h"
-
-//solve implicit declaration
-#include "PHY/LTE_ESTIMATION/lte_estimation.h"
-#include "PHY/LTE_TRANSPORT/transport_proto.h"
-#include "PHY/LTE_TRANSPORT/transport_common_proto.h"
 
 /** @defgroup _mac  MAC
  * @ingroup _oai2
@@ -89,4 +55,24 @@
 /*!\brief Values of PCCH logical channel (fake) */
 #define NR_BCCH_BCH 5			// MIB
 /*@}*/
+
+
+
+
+
+/*!\brief UE layer 2 status */
+typedef enum {
+    CONNECTION_OK = 0,
+    CONNECTION_LOST,
+    PHY_RESYNCH,
+    PHY_HO_PRACH
+} UE_L2_STATE_t;
+
+
+
+
+
+
+
+
 #endif /*__LAYER2_MAC_DEFS_H__ */

openair2/LAYER2/NR_MAC_UE/mac_vars.c

@@ -29,7 +29,7 @@
 
 */
 
-#include "defs.h"
+#include "mac_defs.h"
 
 NR_UE_MAC_INST_t UE_mac_inst;	//[NB_MODULE_MAX];
 

openair2/LAYER2/NR_MAC_UE/proto.h

@@ -29,7 +29,7 @@
 #ifndef __LAYER2_MAC_PROTO_H__
 #define __LAYER2_MAC_PROTO_H__
 
-#include "defs.h"
+#include "mac_defs.h"
 
 /**\brief decode mib pdu in NR_UE, from if_module ul_ind with P7 tx_ind message
    \param module_id      module id

openair2/LAYER2/NR_MAC_gNB/config.c

@@ -215,11 +215,11 @@ int rrc_mac_config_req_gNB(module_id_t Mod_idP,
 
 
 
-  LOG_E(MAC, "%s() %s:%d RC.nrmac[Mod_idP]->if_inst->PHY_config_req:%p\n", __FUNCTION__, __FILE__, __LINE__, RC.nrmac[Mod_idP]->if_inst->PHY_config_req);
+  LOG_E(MAC, "%s() %s:%d RC.nrmac[Mod_idP]->if_inst->NR_PHY_config_req:%p\n", __FUNCTION__, __FILE__, __LINE__, RC.nrmac[Mod_idP]->if_inst->NR_PHY_config_req);
 
   // if in nFAPI mode 
-  if ( (nfapi_mode == 1 || nfapi_mode == 2) && (RC.nrmac[Mod_idP]->if_inst->PHY_config_req == NULL) ){
-    while(RC.nrmac[Mod_idP]->if_inst->PHY_config_req == NULL) {
+  if ( (nfapi_mode == 1 || nfapi_mode == 2) && (RC.nrmac[Mod_idP]->if_inst->NR_PHY_config_req == NULL) ){
+    while(RC.nrmac[Mod_idP]->if_inst->NR_PHY_config_req == NULL) {
       // DJP AssertFatal(RC.nrmac[Mod_idP]->if_inst->PHY_config_req != NULL,"if_inst->phy_config_request is null\n");
       usleep(100 * 1000);
       printf("Waiting for PHY_config_req\n");
@@ -232,7 +232,7 @@ int rrc_mac_config_req_gNB(module_id_t Mod_idP,
     phycfg.CC_id  = CC_idP;
     phycfg.cfg    = &RC.nrmac[Mod_idP]->config[CC_idP];
       
-    if (RC.nrmac[Mod_idP]->if_inst->PHY_config_req) RC.nrmac[Mod_idP]->if_inst->PHY_config_req(&phycfg); 
+    if (RC.nrmac[Mod_idP]->if_inst->NR_PHY_config_req) RC.nrmac[Mod_idP]->if_inst->NR_PHY_config_req(&phycfg); 
       
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_MAC_CONFIG, VCD_FUNCTION_OUT);
   }

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c

@@ -72,10 +72,10 @@ void clear_nr_nfapi_information(gNB_MAC_INST * gNB,
                                 frame_t frameP, 
                                 sub_frame_t subframeP){
 
-  nfapi_dl_config_request_t      *DL_req = &gNB->DL_req[0];
-  nfapi_ul_config_request_t      *UL_req = &gNB->UL_req[0];
-  nfapi_hi_dci0_request_t   *HI_DCI0_req = &gNB->HI_DCI0_req[0];
-  nfapi_tx_request_t             *TX_req = &gNB->TX_req[0];
+  nfapi_nr_dl_config_request_t    *DL_req = &gNB->DL_req[0];
+  nfapi_ul_config_request_t       *UL_req = &gNB->UL_req[0];
+  nfapi_hi_dci0_request_t   *     HI_DCI0_req = &gNB->HI_DCI0_req[0];
+  nfapi_tx_request_t              *TX_req = &gNB->TX_req[0];
 
   gNB->pdu_index[CC_idP] = 0;
 
@@ -85,7 +85,7 @@ void clear_nr_nfapi_information(gNB_MAC_INST * gNB,
     DL_req[CC_idP].dl_config_request_body.number_dci                          = 0;
     DL_req[CC_idP].dl_config_request_body.number_pdu                          = 0;
     DL_req[CC_idP].dl_config_request_body.number_pdsch_rnti                   = 0;
-    DL_req[CC_idP].dl_config_request_body.transmission_power_pcfich           = 6000;
+    //DL_req[CC_idP].dl_config_request_body.transmission_power_pcfich           = 6000;
 
     HI_DCI0_req[CC_idP].hi_dci0_request_body.sfnsf                            = subframeP + (frameP<<4);
     HI_DCI0_req[CC_idP].hi_dci0_request_body.number_of_dci                    = 0;
@@ -99,17 +99,17 @@ void clear_nr_nfapi_information(gNB_MAC_INST * gNB,
 
   }
 }
-
+/*
 void check_nr_ul_failure(module_id_t module_idP, 
                          int CC_id, 
                          int UE_id,
                          frame_t frameP, 
                          sub_frame_t subframeP) {
 
-  UE_list_t                 *UE_list = &RC.nrmac[module_idP]->UE_list;
-  nfapi_dl_config_request_t  *DL_req = &RC.nrmac[module_idP]->DL_req[0];
-  uint16_t                      rnti = UE_RNTI(module_idP, UE_id);
-  COMMON_channels_t              *cc = RC.nrmac[module_idP]->common_channels;
+  UE_list_t                     *UE_list  = &RC.nrmac[module_idP]->UE_list;
+  nfapi_nr_dl_config_request_t  *DL_req   = &RC.nrmac[module_idP]->DL_req[0];
+  uint16_t                      rnti      = UE_RNTI(module_idP, UE_id);
+  NR_COMMON_channels_t          *cc       = RC.nrmac[module_idP]->common_channels;
 
   // check uplink failure
   if ((UE_list->UE_sched_ctrl[UE_id].ul_failure_timer > 0) &&
@@ -120,7 +120,7 @@ void check_nr_ul_failure(module_id_t module_idP,
       UE_list->UE_sched_ctrl[UE_id].ra_pdcch_order_sent = 1;
 
       // add a format 1A dci for this UE to request an RA procedure (only one UE per subframe)
-      nfapi_dl_config_request_pdu_t *dl_config_pdu                    = &DL_req[CC_id].dl_config_request_body.dl_config_pdu_list[DL_req[CC_id].dl_config_request_body.number_pdu];
+      nfapi_nr_dl_config_request_pdu_t *dl_config_pdu                    = &DL_req[CC_id].dl_config_request_body.dl_config_pdu_list[DL_req[CC_id].dl_config_request_body.number_pdu];
       memset((void *) dl_config_pdu, 0,sizeof(nfapi_dl_config_request_pdu_t));
       dl_config_pdu->pdu_type                                         = NFAPI_DL_CONFIG_DCI_DL_PDU_TYPE;
       dl_config_pdu->pdu_size                                         = (uint8_t) (2 + sizeof(nfapi_dl_config_dci_dl_pdu));
@@ -175,14 +175,15 @@ void check_nr_ul_failure(module_id_t module_idP,
   }       // ul_failure_timer>0
 
 }
-
+*/
+/*
 void schedule_nr_SRS(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP)
 {
   gNB_MAC_INST *gNB = RC.nrmac[module_idP];
   UE_list_t *UE_list = &gNB->UE_list;
   nfapi_ul_config_request_body_t *ul_req;
   int CC_id, UE_id;
-  COMMON_channels_t *cc = RC.nrmac[module_idP]->common_channels;
+  NR_COMMON_channels_t *cc = RC.nrmac[module_idP]->common_channels;
   SoundingRS_UL_ConfigCommon_t *soundingRS_UL_ConfigCommon;
   struct SoundingRS_UL_ConfigDedicated *soundingRS_UL_ConfigDedicated;
   uint8_t TSFC;
@@ -257,201 +258,7 @@ void schedule_nr_SRS(module_id_t module_idP, frame_t frameP, sub_frame_t subfram
     }     // SRS config
   }
 }
-
-void
-schedule_nr_CSI(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP)
-{
-  gNB_MAC_INST                   *gNB = RC.nrmac[module_idP];
-  UE_list_t                      *UE_list = &gNB->UE_list;
-  COMMON_channels_t              *cc;
-  nfapi_ul_config_request_body_t *ul_req;
-  int                            CC_id, UE_id;
-  struct CQI_ReportPeriodic      *cqi_ReportPeriodic;
-  uint16_t                       Npd, N_OFFSET_CQI;
-  int                            H;
-
-  for (CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++) {
-
-    cc = &gNB->common_channels[CC_id];
-    for (UE_id = 0; UE_id < MAX_MOBILES_PER_GNB; UE_id++) {
-      if (!UE_list->active[UE_id]) continue;
-
-      ul_req = &RC.nrmac[module_idP]->UL_req[CC_id].ul_config_request_body;
-
-      // drop the allocation if the UE hasn't send RRCConnectionSetupComplete yet
-      if (mac_eNB_get_rrc_status(module_idP, UE_RNTI(module_idP, UE_id)) < RRC_CONNECTED) continue;
-
-      AssertFatal(UE_list->
-      UE_template[CC_id][UE_id].physicalConfigDedicated
-      != NULL,
-      "physicalConfigDedicated is null for UE %d\n",
-      UE_id);
-
-      if (UE_list->UE_template[CC_id][UE_id].physicalConfigDedicated->cqi_ReportConfig) {
-  if ((cqi_ReportPeriodic = UE_list->UE_template[CC_id][UE_id].physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic) != NULL
-      && (cqi_ReportPeriodic->present != CQI_ReportPeriodic_PR_release)) {
-    //Rel8 Periodic CQI/PMI/RI reporting
-
-    get_csi_params(cc, cqi_ReportPeriodic, &Npd,
-       &N_OFFSET_CQI, &H);
-
-    if ((((frameP * 10) + subframeP) % Npd) == N_OFFSET_CQI) {  // CQI opportunity
-      UE_list->UE_sched_ctrl[UE_id].feedback_cnt[CC_id] = (((frameP * 10) + subframeP) / Npd) % H;
-      // Program CQI
-      nfapi_ul_config_request_pdu_t *ul_config_pdu = &ul_req->ul_config_pdu_list[ul_req->number_of_pdus];
-      memset((void *) ul_config_pdu, 0,
-       sizeof(nfapi_ul_config_request_pdu_t));
-      ul_config_pdu->pdu_type                                                          = NFAPI_UL_CONFIG_UCI_CQI_PDU_TYPE;
-      ul_config_pdu->pdu_size                                                          = 2 + (uint8_t) (2 + sizeof(nfapi_ul_config_uci_cqi_pdu));
-      ul_config_pdu->uci_cqi_pdu.ue_information.ue_information_rel8.tl.tag             = NFAPI_UL_CONFIG_REQUEST_UE_INFORMATION_REL8_TAG;
-      ul_config_pdu->uci_cqi_pdu.ue_information.ue_information_rel8.rnti               = UE_list->UE_template[CC_id][UE_id].rnti;
-      ul_config_pdu->uci_cqi_pdu.cqi_information.cqi_information_rel8.tl.tag           = NFAPI_UL_CONFIG_REQUEST_CQI_INFORMATION_REL8_TAG;
-      ul_config_pdu->uci_cqi_pdu.cqi_information.cqi_information_rel8.pucch_index      = cqi_ReportPeriodic->choice.setup.cqi_PUCCH_ResourceIndex;
-      ul_config_pdu->uci_cqi_pdu.cqi_information.cqi_information_rel8.dl_cqi_pmi_size  = get_rel8_dl_cqi_pmi_size(&UE_list->UE_sched_ctrl[UE_id], CC_id, cc,
-                              get_tmode(module_idP, CC_id, UE_id),
-                              cqi_ReportPeriodic);
-      ul_req->number_of_pdus++;
-      ul_req->tl.tag                                                                   = NFAPI_UL_CONFIG_REQUEST_BODY_TAG;
-
-#if defined(Rel10) || defined(Rel14)
-      // PUT rel10-13 UCI options here
-#endif
-    } else
-      if ((cqi_ReportPeriodic->choice.setup.ri_ConfigIndex)
-    && ((((frameP * 10) + subframeP) % ((H * Npd) << (*cqi_ReportPeriodic->choice.setup.ri_ConfigIndex / 161))) == N_OFFSET_CQI + (*cqi_ReportPeriodic->choice.setup.ri_ConfigIndex % 161))) {  // RI opportunity
-        // Program RI
-        nfapi_ul_config_request_pdu_t *ul_config_pdu = &ul_req->ul_config_pdu_list[ul_req->number_of_pdus];
-        memset((void *) ul_config_pdu, 0,
-         sizeof(nfapi_ul_config_request_pdu_t));
-        ul_config_pdu->pdu_type                                                          = NFAPI_UL_CONFIG_UCI_CQI_PDU_TYPE;
-        ul_config_pdu->pdu_size                                                          = 2 + (uint8_t) (2 + sizeof(nfapi_ul_config_uci_cqi_pdu));
-        ul_config_pdu->uci_cqi_pdu.ue_information.ue_information_rel8.tl.tag             = NFAPI_UL_CONFIG_REQUEST_UE_INFORMATION_REL8_TAG;
-        ul_config_pdu->uci_cqi_pdu.ue_information.ue_information_rel8.rnti               = UE_list->UE_template[CC_id][UE_id].rnti;
-        ul_config_pdu->uci_cqi_pdu.cqi_information.cqi_information_rel8.tl.tag           = NFAPI_UL_CONFIG_REQUEST_CQI_INFORMATION_REL8_TAG;
-        ul_config_pdu->uci_cqi_pdu.cqi_information.cqi_information_rel8.pucch_index      = cqi_ReportPeriodic->choice.setup.cqi_PUCCH_ResourceIndex;
-        ul_config_pdu->uci_cqi_pdu.cqi_information.cqi_information_rel8.dl_cqi_pmi_size  = (cc->p_eNB == 2) ? 1 : 2;
-        RC.nrmac[module_idP]->UL_req[CC_id].sfn_sf                                         = (frameP << 4) + subframeP;
-        ul_req->number_of_pdus++;
-        ul_req->tl.tag                                                                   = NFAPI_UL_CONFIG_REQUEST_BODY_TAG;
-      }
-  }   // if ((cqi_ReportPeriodic = cqi_ReportConfig->cqi_ReportPeriodic)!=NULL) {
-      }     // if (UE_list->UE_template[CC_id][UE_id].physicalConfigDedicated->cqi_ReportConfig)
-    }     // for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id]) {
-  }       // for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
-}
-
-void
-schedule_nr_SR(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP)
-{
-  gNB_MAC_INST                   *gNB = RC.nrmac[module_idP];
-  UE_list_t                      *UE_list = &gNB->UE_list;
-  nfapi_ul_config_request_t      *ul_req;
-  nfapi_ul_config_request_body_t *ul_req_body;
-  int                            CC_id;
-  int                            UE_id;
-  SchedulingRequestConfig_t      *SRconfig;
-  int                            skip_ue;
-  int                            is_harq;
-  nfapi_ul_config_sr_information sr;
-  int                            i;
-
-  for (CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++) {
-    RC.nrmac[module_idP]->UL_req[CC_id].sfn_sf = (frameP << 4) + subframeP;
-
-    for (UE_id = 0; UE_id < MAX_MOBILES_PER_GNB; UE_id++) {
-      if (!RC.nrmac[module_idP]->UE_list.active[UE_id]) continue;
-
-      ul_req        = &RC.nrmac[module_idP]->UL_req[CC_id];
-      ul_req_body   = &ul_req->ul_config_request_body;
-
-      // drop the allocation if the UE hasn't send RRCConnectionSetupComplete yet
-      if (mac_eNB_get_rrc_status(module_idP, UE_RNTI(module_idP, UE_id)) < RRC_CONNECTED) continue;
-
-      AssertFatal(UE_list->
-      UE_template[CC_id][UE_id].physicalConfigDedicated!= NULL,
-      "physicalConfigDedicated is null for UE %d\n",
-      UE_id);
-
-      if ((SRconfig = UE_list->UE_template[CC_id][UE_id].physicalConfigDedicated->schedulingRequestConfig) != NULL) {
-  if (SRconfig->present == SchedulingRequestConfig_PR_setup) {
-    if (SRconfig->choice.setup.sr_ConfigIndex <= 4) { // 5 ms SR period
-      if ((subframeP % 5) != SRconfig->choice.setup.sr_ConfigIndex) continue;
-    } else if (SRconfig->choice.setup.sr_ConfigIndex <= 14) { // 10 ms SR period
-      if (subframeP != (SRconfig->choice.setup.sr_ConfigIndex - 5)) continue;
-    } else if (SRconfig->choice.setup.sr_ConfigIndex <= 34) { // 20 ms SR period
-      if ((10 * (frameP & 1) + subframeP) != (SRconfig->choice.setup.sr_ConfigIndex - 15)) continue;
-    } else if (SRconfig->choice.setup.sr_ConfigIndex <= 74) { // 40 ms SR period
-      if ((10 * (frameP & 3) + subframeP) != (SRconfig->choice.setup.sr_ConfigIndex - 35)) continue;
-    } else if (SRconfig->choice.setup.sr_ConfigIndex <= 154) {  // 80 ms SR period
-      if ((10 * (frameP & 7) + subframeP) != (SRconfig->choice.setup.sr_ConfigIndex - 75)) continue;
-    }
-  }   // SRconfig->present == SchedulingRequestConfig_PR_setup)
-      }     // SRconfig = UE_list->UE_template[CC_id][UE_id].physicalConfigDedicated->schedulingRequestConfig)!=NULL)
-
-      // if we get here there is some PUCCH1 reception to schedule for SR
-
-      skip_ue = 0;
-      is_harq = 0;
-      // check that there is no existing UL grant for ULSCH which overrides the SR
-      for (i = 0; i < ul_req_body->number_of_pdus; i++) {
-  if (((ul_req_body->ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_ULSCH_PDU_TYPE) || 
-       (ul_req_body->ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_ULSCH_HARQ_PDU_TYPE) || 
-       (ul_req_body->ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_ULSCH_CQI_RI_PDU_TYPE) || 
-       (ul_req_body->ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_ULSCH_CQI_HARQ_RI_PDU_TYPE)) && 
-      (ul_req_body->ul_config_pdu_list[i].ulsch_pdu.ulsch_pdu_rel8.rnti == UE_list->UE_template[CC_id][UE_id].rnti)) {
-    skip_ue = 1;
-    break;
-  }
-  /* if there is already an HARQ pdu, convert to SR_HARQ */
-  else if ((ul_req_body->ul_config_pdu_list[i].pdu_type == NFAPI_UL_CONFIG_UCI_HARQ_PDU_TYPE) && 
-     (ul_req_body->ul_config_pdu_list[i].uci_harq_pdu.ue_information.ue_information_rel8.rnti == UE_list->UE_template[CC_id][UE_id].rnti)) {
-    is_harq = 1;
-    break;
-  }
-      }
-
-      // drop the allocation because ULSCH with handle it with BSR
-      if (skip_ue == 1) continue;
-
-      LOG_D(MAC,"Frame %d, Subframe %d : Scheduling SR for UE %d/%x is_harq:%d\n",frameP,subframeP,UE_id,UE_list->UE_template[CC_id][UE_id].rnti, is_harq);
-
-      // check Rel10 or Rel8 SR
-#if defined(Rel10) || defined(Rel14)
-      if ((UE_list-> UE_template[CC_id][UE_id].physicalConfigDedicated->ext2)
-    && (UE_list->UE_template[CC_id][UE_id].physicalConfigDedicated->ext2->schedulingRequestConfig_v1020)
-    && (UE_list->UE_template[CC_id][UE_id].physicalConfigDedicated->ext2->schedulingRequestConfig_v1020)) {
-  sr.sr_information_rel10.tl.tag                    = NFAPI_UL_CONFIG_REQUEST_SR_INFORMATION_REL10_TAG;
-  sr.sr_information_rel10.number_of_pucch_resources = 1;
-  sr.sr_information_rel10.pucch_index_p1            = *UE_list->UE_template[CC_id][UE_id].physicalConfigDedicated->ext2->schedulingRequestConfig_v1020->sr_PUCCH_ResourceIndexP1_r10;
-  LOG_D(MAC,"REL10 PUCCH INDEX P1:%d\n", sr.sr_information_rel10.pucch_index_p1);
-      } else
-#endif
-  {
-    sr.sr_information_rel8.tl.tag                   = NFAPI_UL_CONFIG_REQUEST_SR_INFORMATION_REL8_TAG;
-    sr.sr_information_rel8.pucch_index              = UE_list->UE_template[CC_id][UE_id].physicalConfigDedicated->schedulingRequestConfig->choice.setup.sr_PUCCH_ResourceIndex;
-    LOG_D(MAC,"REL8 PUCCH INDEX:%d\n", sr.sr_information_rel8.pucch_index);
-  }
-
-      /* if there is already an HARQ pdu, convert to SR_HARQ */
-      if (is_harq) {
-  nfapi_ul_config_harq_information h                                                                                 = ul_req_body->ul_config_pdu_list[i].uci_harq_pdu.harq_information;
-  ul_req_body->ul_config_pdu_list[i].pdu_type                                                                        = NFAPI_UL_CONFIG_UCI_SR_HARQ_PDU_TYPE;
-  ul_req_body->ul_config_pdu_list[i].uci_sr_harq_pdu.sr_information                                                  = sr;
-  ul_req_body->ul_config_pdu_list[i].uci_sr_harq_pdu.harq_information                                                = h;
-      } else {
-  ul_req_body->ul_config_pdu_list[ul_req_body->number_of_pdus].pdu_type                                              = NFAPI_UL_CONFIG_UCI_SR_PDU_TYPE;
-  ul_req_body->ul_config_pdu_list[ul_req_body->number_of_pdus].uci_sr_pdu.ue_information.ue_information_rel8.tl.tag  = NFAPI_UL_CONFIG_REQUEST_UE_INFORMATION_REL8_TAG;
-  ul_req_body->ul_config_pdu_list[ul_req_body->number_of_pdus].uci_sr_pdu.ue_information.ue_information_rel8.rnti    = UE_list->UE_template[CC_id][UE_id].rnti;
-  ul_req_body->ul_config_pdu_list[ul_req_body->number_of_pdus].uci_sr_pdu.ue_information.ue_information_rel11.tl.tag = 0;
-  ul_req_body->ul_config_pdu_list[ul_req_body->number_of_pdus].uci_sr_pdu.ue_information.ue_information_rel13.tl.tag = 0;
-  ul_req_body->ul_config_pdu_list[ul_req_body->number_of_pdus].uci_sr_pdu.sr_information                             = sr;
-  ul_req_body->number_of_pdus++;
-      }     /* if (is_harq) */
-      ul_req_body->tl.tag                                                                                                  = NFAPI_UL_CONFIG_REQUEST_BODY_TAG;
-    }     // for (UE_id=UE_list->head; UE_id>=0; UE_id=UE_list->next[UE_id])
-  }       // for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++)
-}
-
+*/
 void copy_nr_ulreq(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP)
 {
   int CC_id;
@@ -484,8 +291,6 @@ void copy_nr_ulreq(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP
 void gNB_dlsch_ulsch_scheduler(module_id_t module_idP, 
                                frame_t frameP,
                                sub_frame_t subframeP){
-
-  int               mbsfn_status[MAX_NUM_CCs];
   protocol_ctxt_t   ctxt;
 
   int               CC_id, i = -1;
@@ -501,7 +306,7 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
   RC.nrmac[module_idP]->subframe = subframeP;
 
   for (CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++) {
-    mbsfn_status[CC_id] = 0;
+    //mbsfn_status[CC_id] = 0;
 
     // clear vrb_maps
     memset(cc[CC_id].vrb_map, 0, 100);
@@ -545,7 +350,7 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
             RC.nrmac[module_idP]->UE_list.UE_sched_ctrl[i].ul_inactivity_timer,
             RC.nrmac[module_idP]->UE_list.UE_sched_ctrl[i].cqi_req_timer);
       
-      check_nr_ul_failure(module_idP, CC_id, i, frameP, subframeP);
+      //check_nr_ul_failure(module_idP, CC_id, i, frameP, subframeP);
       
       if (RC.nrmac[module_idP]->UE_list.UE_sched_ctrl[i].ue_reestablishment_reject_timer > 0) {
         RC.nrmac[module_idP]->UE_list.UE_sched_ctrl[i].ue_reestablishment_reject_timer++;
@@ -606,13 +411,13 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
   
   pdcp_run(&ctxt);
 
-  rrc_rx_tx(&ctxt, CC_id);
+  //rrc_rx_tx(&ctxt, CC_id);
 
   // This schedules MIB
   if((subframeP == 0) && (frameP & 7) == 0){
     schedule_nr_mib(module_idP, frameP, subframeP);
   }
-  
+  /*
   if (phy_test == 0){
     // This schedules SI for legacy LTE and eMTC starting in subframeP
     schedule_SI(module_idP, frameP, subframeP);
@@ -637,16 +442,18 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
     schedule_ulsch_phy_test(module_idP,frameP,subframeP);
     schedule_ue_spec_phy_test(module_idP,frameP,subframeP,mbsfn_status);
   }
-  
+  */
 
   if (RC.flexran[module_idP]->enabled)
     flexran_agent_send_update_stats(module_idP);
   
+  /*
   // Allocate CCEs for good after scheduling is done
   for (CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++)
     allocate_CCEs(module_idP, CC_id, subframeP, 0);
 
   stop_meas(&RC.nrmac[module_idP]->eNB_scheduler);
-
+  */
+  
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ULSCH_SCHEDULER,VCD_FUNCTION_OUT);
 }
\ No newline at end of file

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_bch.c

@@ -94,12 +94,12 @@ void schedule_nr_mib(module_id_t module_idP, frame_t frameP, sub_frame_t subfram
 
       dl_config_pdu = &dl_req->dl_config_pdu_list[dl_req->number_pdu];
       memset((void *) dl_config_pdu, 0,sizeof(nfapi_nr_dl_config_request_pdu_t));
-      dl_config_pdu->pdu_type      = NFAPI_DL_CONFIG_BCH_PDU_TYPE;
+      dl_config_pdu->pdu_type      = NFAPI_NR_DL_CONFIG_BCH_PDU_TYPE;
       dl_config_pdu->pdu_size      =2 + sizeof(nfapi_nr_dl_config_bch_pdu_rel15_t);
-      dl_config_pdu->bch_pdu.tl.tag             = NFAPI_NR_DL_CONFIG_REQUEST_BCH_PDU_REL15_TAG;
-      dl_config_pdu->bch_pdu.length             = mib_sdu_length;
-      dl_config_pdu->bch_pdu.pdu_index          = gNB->pdu_index[CC_id];
-      dl_config_pdu->bch_pdu.transmission_power = 6000;
+      dl_config_pdu->bch_pdu_rel15.tl.tag             = NFAPI_NR_DL_CONFIG_REQUEST_BCH_PDU_REL15_TAG;
+      dl_config_pdu->bch_pdu_rel15.length             = mib_sdu_length;
+      dl_config_pdu->bch_pdu_rel15.pdu_index          = gNB->pdu_index[CC_id];
+      dl_config_pdu->bch_pdu_rel15.transmission_power = 6000;
       dl_req->tl.tag                            = NFAPI_DL_CONFIG_REQUEST_BODY_TAG;
       dl_req->number_pdu++;
       dl_config_request->header.message_id = NFAPI_DL_CONFIG_REQUEST;

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file eNB_scheduler_primitives.c
+ * \brief primitives used by eNB for BCH, RACH, ULSCH, DLSCH scheduling
+ * \author  Navid Nikaein and Raymond Knopp
+ * \date 2010 - 2014
+ * \email: navid.nikaein@eurecom.fr
+ * \version 1.0
+ * @ingroup _mac
+
+ */
+
+#include "assertions.h"
+
+#include "LAYER2/MAC/mac.h"
+#include "LAYER2/NR_MAC_gNB/mac.h"
+#include "LAYER2/MAC/mac_extern.h"
+
+#include "LAYER2/NR_MAC_gNB/mac_proto.h"
+#include "UTIL/LOG/log.h"
+#include "UTIL/LOG/vcd_signal_dumper.h"
+#include "UTIL/OPT/opt.h"
+#include "OCG.h"
+#include "OCG_extern.h"
+
+#include "RRC/LTE/rrc_extern.h"
+#include "RRC/NR/nr_rrc_extern.h"
+#include "RRC/L2_INTERFACE/openair_rrc_L2_interface.h"
+
+//#include "LAYER2/MAC/pre_processor.c"
+#include "pdcp.h"
+
+#if defined(ENABLE_ITTI)
+#include "intertask_interface.h"
+#endif
+
+#include "T.h"
+
+#define ENABLE_MAC_PAYLOAD_DEBUG
+#define DEBUG_gNB_SCHEDULER 1
+
+#include "common/ran_context.h"
+
+extern RAN_CONTEXT_t RC;
+
+extern int n_active_slices;
+
+int is_nr_UL_sf(NR_COMMON_channels_t * ccP, sub_frame_t subframeP){
+  // if FDD return dummy value
+  if (ccP->tdd_Config == NULL)
+    return (0);
+
+  switch (ccP->tdd_Config->subframeAssignment) {
+  case 1:
+    switch (subframeP) {
+    case 0:
+    case 4:
+    case 5:
+    case 9:
+      return (0);
+      break;
+    case 2:
+    case 3:
+    case 7:
+    case 8:
+      return (1);
+      break;
+    default:
+      return (0);
+      break;
+    }
+    break;
+  case 3:
+    if ((subframeP <= 1) || (subframeP >= 5))
+      return (0);
+    else if ((subframeP > 1) && (subframeP < 5))
+      return (1);
+    else
+      AssertFatal(1 == 0, "Unknown subframe number\n");
+    break;
+  case 4:
+    if ((subframeP <= 1) || (subframeP >= 4))
+      return (0);
+    else if ((subframeP > 1) && (subframeP < 4))
+      return (1);
+    else
+      AssertFatal(1 == 0, "Unknown subframe number\n");
+    break;
+  case 5:
+    if ((subframeP <= 1) || (subframeP >= 3))
+      return (0);
+    else if ((subframeP > 1) && (subframeP < 3))
+      return (1);
+    else
+      AssertFatal(1 == 0, "Unknown subframe number\n");
+    break;
+  default:
+    AssertFatal(1 == 0,
+    "subframe %d Unsupported TDD configuration %d\n",
+    subframeP, (int) ccP->tdd_Config->subframeAssignment);
+    break;
+  }
+}
\ No newline at end of file

openair2/LAYER2/NR_MAC_gNB/mac.h

@@ -113,27 +113,27 @@ typedef struct gNB_MAC_INST_s {
   uint16_t pdu_index[NFAPI_CC_MAX];
 
   /// NFAPI Config Request Structure
-  nfapi_nr_config_request_t       config[NFAPI_CC_MAX];
+  nfapi_nr_config_request_t         config[NFAPI_CC_MAX];
   /// NFAPI DL Config Request Structure
-  nfapi_nr_dl_config_request_t    DL_req[NFAPI_CC_MAX];
+  nfapi_nr_dl_config_request_t      DL_req[NFAPI_CC_MAX];
   /// NFAPI UL Config Request Structure, send to L1 4 subframes before processing takes place
-  nfapi_ul_config_request_t       UL_req[NFAPI_CC_MAX];
+  nfapi_ul_config_request_t         UL_req[NFAPI_CC_MAX];
   /// Preallocated DL pdu list
-  nfapi_dl_config_request_pdu_t   dl_config_pdu_list[NFAPI_CC_MAX][MAX_NUM_DL_PDU];
+  nfapi_nr_dl_config_request_pdu_t  dl_config_pdu_list[NFAPI_CC_MAX][MAX_NUM_DL_PDU];
   /// Preallocated UL pdu list
-  nfapi_ul_config_request_pdu_t   ul_config_pdu_list[NFAPI_CC_MAX][MAX_NUM_UL_PDU];
+  nfapi_ul_config_request_pdu_t     ul_config_pdu_list[NFAPI_CC_MAX][MAX_NUM_UL_PDU];
   /// Preallocated UL pdu list for ULSCH (n+k delay)
-  nfapi_ul_config_request_pdu_t   ul_config_pdu_list_tmp[NFAPI_CC_MAX][10][MAX_NUM_UL_PDU];
+  nfapi_ul_config_request_pdu_t     ul_config_pdu_list_tmp[NFAPI_CC_MAX][10][MAX_NUM_UL_PDU];
   /// NFAPI "Temporary" UL Config Request Structure, holds future UL_config requests
-  nfapi_ul_config_request_t       UL_req_tmp[NFAPI_CC_MAX][10];
+  nfapi_ul_config_request_t         UL_req_tmp[NFAPI_CC_MAX][10];
   /// Preallocated HI_DCI0 pdu list
-  nfapi_hi_dci0_request_pdu_t     hi_dci0_pdu_list[NFAPI_CC_MAX][MAX_NUM_HI_DCI0_PDU];
+  nfapi_hi_dci0_request_pdu_t       hi_dci0_pdu_list[NFAPI_CC_MAX][MAX_NUM_HI_DCI0_PDU];
   /// NFAPI HI/DCI0 Config Request Structure
-  nfapi_hi_dci0_request_t         HI_DCI0_req[NFAPI_CC_MAX];
+  nfapi_hi_dci0_request_t           HI_DCI0_req[NFAPI_CC_MAX];
   /// Prealocated TX pdu list
-  nfapi_tx_request_pdu_t          tx_request_pdu[NFAPI_CC_MAX][MAX_NUM_TX_REQUEST_PDU];
+  nfapi_tx_request_pdu_t            tx_request_pdu[NFAPI_CC_MAX][MAX_NUM_TX_REQUEST_PDU];
   /// NFAPI DL PDU structure
-  nfapi_tx_request_t              TX_req[NFAPI_CC_MAX];
+  nfapi_tx_request_t                TX_req[NFAPI_CC_MAX];
 
   UE_list_t UE_list;
 

openair2/LAYER2/NR_MAC_gNB/mac_proto.h

@@ -5,8 +5,6 @@
 #include "mac.h"
 #include "PHY/defs_nr_common.h"
 
-void schedule_nr_mib(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP);
-
 void mac_top_init_gNB(void);
 
 int rrc_mac_config_req_gNB(module_id_t Mod_idP, 
@@ -19,8 +17,17 @@ int rrc_mac_config_req_gNB(module_id_t Mod_idP,
                            NR_ServingCellConfigCommon_t *servingcellconfigcommon
                            );
 
+int  is_nr_UL_sf(NR_COMMON_channels_t * ccP, sub_frame_t subframeP);
+
+void clear_nr_nfapi_information(gNB_MAC_INST * gNB, 
+                                int CC_idP,
+                                frame_t frameP, 
+                                sub_frame_t subframeP);
+
 void gNB_dlsch_ulsch_scheduler(module_id_t module_idP, 
                                frame_t frameP,
                                sub_frame_t subframeP);
 
+void schedule_nr_mib(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP);
+
 #endif /*__LAYER2_NR_MAC_PROTO_H__*/
\ No newline at end of file

openair2/LAYER2/NR_MAC_gNB/main.c

@@ -45,7 +45,7 @@ extern RAN_CONTEXT_t RC;
 
 void mac_top_init_gNB(void)
 {
-  module_id_t     i;
+  module_id_t     i,j;
   int             list_el;
   UE_list_t       *UE_list;
   gNB_MAC_INST    *nrmac;
@@ -73,7 +73,7 @@ void mac_top_init_gNB(void)
         
         RC.nrmac[i]->Mod_id = i;
         
-        /*
+        
         for (j = 0; j < MAX_NUM_CCs; j++) {
           RC.nrmac[i]->DL_req[j].dl_config_request_body.dl_config_pdu_list = RC.nrmac[i]->dl_config_pdu_list[j];
           RC.nrmac[i]->UL_req[j].ul_config_request_body.ul_config_pdu_list = RC.nrmac[i]->ul_config_pdu_list[j];
@@ -85,7 +85,7 @@ void mac_top_init_gNB(void)
         RC.nrmac[i]->TX_req[j].tx_request_body.tx_pdu_list =                RC.nrmac[i]->tx_request_pdu[j];
         RC.nrmac[i]->ul_handle = 0;     
         }
-        */
+        
 
     }//END for (i = 0; i < RC.nb_nr_macrlc_inst; i++)
 

openair2/NR_PHY_INTERFACE/NR_IF_Module.c

 #include "openair1/PHY/defs_eNB.h"
-#include "openair2/NR_PHY_INTERFACE/NR_IF_Module.h"
 #include "openair1/PHY/phy_extern.h"
+#include "openair1/SCHED_NR/fapi_nr_l1.h"
+#include "openair2/NR_PHY_INTERFACE/NR_IF_Module.h"
 #include "LAYER2/MAC/mac_extern.h"
 #include "LAYER2/MAC/mac_proto.h"
 #include "LAYER2/NR_MAC_gNB/mac_proto.h"
@@ -262,8 +263,7 @@ void NR_UL_indication(NR_UL_IND_t *UL_info)
 
 
   // clear DL/UL info for new scheduling round
-  clear_nfapi_information(RC.mac[module_id],CC_id,
-        UL_info->frame,UL_info->subframe);
+  clear_nr_nfapi_information(RC.nrmac[module_id],CC_id,UL_info->frame,UL_info->subframe);
 
   handle_nr_rach(UL_info);
 
@@ -300,7 +300,7 @@ void NR_UL_indication(NR_UL_IND_t *UL_info)
       sched_info->DL_req      = &mac->DL_req[CC_id];
       sched_info->HI_DCI0_req = &mac->HI_DCI0_req[CC_id];
       if ((mac->common_channels[CC_id].tdd_Config==NULL) ||
-          (is_UL_sf(&mac->common_channels[CC_id],(sched_info->subframe+sf_ahead)%10)>0))
+          (is_nr_UL_sf(&mac->common_channels[CC_id],(sched_info->subframe+sf_ahead)%10)>0))
         sched_info->UL_req      = &mac->UL_req[CC_id];
       else
         sched_info->UL_req      = NULL;
@@ -311,16 +311,16 @@ void NR_UL_indication(NR_UL_IND_t *UL_info)
       dump_dl(sched_info);
 #endif
 
-      if (ifi->schedule_response)
+      if (ifi->NR_Schedule_response)
       {
-        AssertFatal(ifi->schedule_response!=NULL,
-            "schedule_response is null (mod %d, cc %d)\n",
-            module_id,
-            CC_id);
-        ifi->schedule_response(sched_info);
+        AssertFatal(ifi->NR_Schedule_response!=NULL,
+                    "nr_schedule_response is null (mod %d, cc %d)\n",
+                    module_id,
+                    CC_id);
+        ifi->NR_Schedule_response(sched_info);
       }
 
-      LOG_D(PHY,"Schedule_response: SFN_SF:%d%d dl_pdus:%d\n",sched_info->frame,sched_info->subframe,sched_info->DL_req->dl_config_request_body.number_pdu);
+      LOG_D(PHY,"NR_Schedule_response: SFN_SF:%d%d dl_pdus:%d\n",sched_info->frame,sched_info->subframe,sched_info->DL_req->dl_config_request_body.number_pdu);
     }
   }
 }
@@ -336,7 +336,7 @@ NR_IF_Module_t *NR_IF_Module_init(int Mod_id){
     memset((void*)if_inst[Mod_id],0,sizeof(NR_IF_Module_t));
 
     if_inst[Mod_id]->CC_mask=0;
-    if_inst[Mod_id]->UL_indication = NR_UL_indication;
+    if_inst[Mod_id]->NR_UL_indication = NR_UL_indication;
 
     AssertFatal(pthread_mutex_init(&if_inst[Mod_id]->if_mutex,NULL)==0,
         "allocation of if_inst[%d]->if_mutex fails\n",Mod_id);

openair2/NR_PHY_INTERFACE/NR_IF_Module.h

@@ -100,7 +100,7 @@ typedef struct{
   /// subframe
   sub_frame_t subframe;
   /// nFAPI DL Config Request
-  nfapi_dl_config_request_t *DL_req;
+  nfapi_nr_dl_config_request_t *DL_req;
   /// nFAPI UL Config Request
   nfapi_ul_config_request_t *UL_req;
   /// nFAPI HI_DCI Request
@@ -117,9 +117,9 @@ typedef struct {
 
 typedef struct NR_IF_Module_s{
 //define the function pointer
-  void (*UL_indication)(NR_UL_IND_t *UL_INFO);
-  void (*schedule_response)(NR_Sched_Rsp_t *Sched_INFO);
-  void (*PHY_config_req)(NR_PHY_Config_t* config_INFO);
+  void (*NR_UL_indication)(NR_UL_IND_t *UL_INFO);
+  void (*NR_Schedule_response)(NR_Sched_Rsp_t *Sched_INFO);
+  void (*NR_PHY_config_req)(NR_PHY_Config_t* config_INFO);
   uint32_t CC_mask;
   uint16_t current_frame;
   uint8_t current_subframe;

openair2/RRC/NR/L2_nr_interface.c

@@ -20,10 +20,10 @@ int8_t mac_rrc_nr_data_req(const module_id_t Mod_idP,
                            uint8_t *const    buffer_pP ){
 
   asn_enc_rval_t enc_rval;
-  SRB_INFO *Srb_info;
-  uint8_t Sdu_size                = 0;
-  uint8_t sfn                     = (uint8_t)((frameP>>2)&0xff);
-
+  //SRB_INFO *Srb_info;
+  //uint8_t Sdu_size                = 0;
+  uint8_t sfn_msb                     = (uint8_t)((frameP>>4)&0x3f);
+  
 #ifdef DEBUG_RRC
   int i;
   LOG_I(RRC,"[eNB %d] mac_rrc_data_req to SRB ID=%d\n",Mod_idP,Srb_id);
@@ -38,16 +38,17 @@ int8_t mac_rrc_nr_data_req(const module_id_t Mod_idP,
   mib     = &carrier->mib;
 
   if( (Srb_id & RAB_OFFSET ) == MIBCH) {
-    mib->message.choice.mib->systemFrameNumber.buf = &sfn;
+    mib->message.choice.mib->systemFrameNumber.buf[0] = sfn_msb << 2;
     enc_rval = uper_encode_to_buffer(&asn_DEF_NR_BCCH_BCH_Message,
                                      NULL,
                                      (void *)mib,
                                      carrier->MIB,
                                      24);
-    LOG_D(RRC,"Encoded MIB for frame %d (%p), bits %lu\n",sfn,carrier->MIB,enc_rval.encoded);
+    LOG_I(NR_RRC,"Encoded MIB for frame %d sfn_msb %d (%p), bits %lu\n",frameP,sfn_msb,carrier->MIB,enc_rval.encoded);
     buffer_pP[0]=carrier->MIB[0];
     buffer_pP[1]=carrier->MIB[1];
     buffer_pP[2]=carrier->MIB[2];
+    LOG_I(NR_RRC,"MIB PDU buffer_pP[0]=%x , buffer_pP[1]=%x, buffer_pP[2]=%x\n",buffer_pP[0],buffer_pP[1],buffer_pP[2]);
     AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %lu)!\n",
                  enc_rval.failed_type->name, enc_rval.encoded);
     return(3);
@@ -59,4 +60,4 @@ int8_t mac_rrc_nr_data_req(const module_id_t Mod_idP,
 
   return(0);
 
-}
\ No newline at end of file
+}

openair2/RRC/NR/MESSAGES/asn1_msg.c

@@ -205,10 +205,11 @@ uint8_t do_MIB_NR(rrc_gNB_carrier_data_t *carrier,
   mib->message.choice.mib = CALLOC(1,sizeof(struct NR_MIB));
   memset(mib->message.choice.mib,0,sizeof(struct NR_MIB));
   //36.331 SFN BIT STRING (SIZE (8)  , 38.331 SFN BIT STRING (SIZE (6))
-  uint8_t sfn = (uint8_t)((frame>>2)&0x3f);
-  mib->message.choice.mib->systemFrameNumber.buf = &sfn;
+  uint8_t sfn_msb = (uint8_t)((frame>>4)&0x3f);
+  mib->message.choice.mib->systemFrameNumber.buf = CALLOC(1,sizeof(uint8_t));
+  mib->message.choice.mib->systemFrameNumber.buf[0] = sfn_msb << 2;
   mib->message.choice.mib->systemFrameNumber.size = 1;
-  mib->message.choice.mib->systemFrameNumber.bits_unused=0;
+  mib->message.choice.mib->systemFrameNumber.bits_unused=2;
 
   //38.331 spare BIT STRING (SIZE (1))
   uint16_t *spare= calloc(1, sizeof(uint16_t));

openair2/RRC/NR_UE/main_ue.c

@@ -4,7 +4,7 @@
 #include "rrc_proto.h"
 
 int nr_l3_init_ue(void){
-    LOG_I(RRC, "[MAIN] NR UE MAC initialization...\n");
+    //LOG_I(RRC, "[MAIN] NR UE MAC initialization...\n");
 
     openair_rrc_top_init_ue_nr(); 
 

openair2/RRC/NR_UE/rrc_UE.c

@@ -71,21 +71,21 @@ int8_t nr_rrc_ue_process_rrcReconfiguration(NR_RRCReconfiguration_t *rrcReconfig
 
     switch(rrcReconfiguration->criticalExtensions.present){
         case NR_RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration:
-            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration.radioBearerConfig != NULL){
+            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig != NULL){
                 if(NR_UE_rrc_inst->radio_bearer_config == NULL){
-                    NR_UE_rrc_inst->radio_bearer_config = rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration.radioBearerConfig;                
+                    NR_UE_rrc_inst->radio_bearer_config = rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig;                
                 }else{
-                    nr_rrc_ue_process_radio_bearer_config(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration.radioBearerConfig);
+                    nr_rrc_ue_process_radio_bearer_config(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
                 }
             }
 
-            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration.secondaryCellGroup != NULL){
+            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->secondaryCellGroup != NULL){
                 NR_CellGroupConfig_t *cellGroupConfig = NULL;
                 uper_decode(NULL,
                             &asn_DEF_NR_CellGroupConfig,   //might be added prefix later
                             (void **)&cellGroupConfig,
-                            (uint8_t *)rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration.secondaryCellGroup->buf,
-                            rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration.secondaryCellGroup->size, 0, 0); 
+                            (uint8_t *)rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->secondaryCellGroup->buf,
+                            rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->secondaryCellGroup->size, 0, 0); 
 
                 if(NR_UE_rrc_inst->cell_group_config == NULL){
                     //  first time receive the configuration, just use the memory allocated from uper_decoder. TODO this is not good implementation, need to maintain RRC_INST own structure every time.
@@ -100,21 +100,21 @@ int8_t nr_rrc_ue_process_rrcReconfiguration(NR_RRCReconfiguration_t *rrcReconfig
                 
             }
 
-            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration.measConfig != NULL){
+            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->measConfig != NULL){
                 if(NR_UE_rrc_inst->meas_config == NULL){
-                    NR_UE_rrc_inst->meas_config = rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration.measConfig;
+                    NR_UE_rrc_inst->meas_config = rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->measConfig;
                 }else{
                     //  if some element need to be updated
-                    nr_rrc_ue_process_meas_config(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration.measConfig);
+                    nr_rrc_ue_process_meas_config(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->measConfig);
                 }
                
             }
 
-            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration.lateNonCriticalExtension != NULL){
+            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->lateNonCriticalExtension != NULL){
                 //  unuse now
             }
 
-            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration.nonCriticalExtension != NULL){
+            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension != NULL){
                 // unuse now
             }
             break;
@@ -298,10 +298,7 @@ int8_t nr_rrc_ue_decode_NR_BCCH_BCH_Message(
                             buffer_len );
 
     if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
-        LOG_E( RRC, "[UE %"PRIu8"] Failed to decode BCCH_DLSCH_MESSAGE (%zu bits)\n",
-               module_id,
-               dec_rval.consumed );
-
+        
         for (i=0; i<buffer_len; i++)
             printf("%02x ",bufferP[i]);
 
@@ -312,7 +309,7 @@ int8_t nr_rrc_ue_decode_NR_BCCH_BCH_Message(
     }
 
     //  link to rrc instance
-    mib = &bcch_message->message.choice.mib;
+    mib = bcch_message->message.choice.mib;
     //memcpy( (void *)mib,
     //    (void *)&bcch_message->message.choice.mib,
     //    sizeof(NR_MIB_t) );
@@ -340,9 +337,6 @@ int8_t nr_rrc_ue_decode_NR_DL_DCCH_Message(
                                             buffer_len, 0, 0); 
 
     if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
-        LOG_E( RRC, "[UE %"PRIu8"] Failed to decode NR_DL_DCCH_Message (%zu bits)\n",
-               module_id,
-               dec_rval.consumed );
 
         for (i=0; i<buffer_len; i++)
             printf("%02x ",bufferP[i]);
@@ -357,9 +351,9 @@ int8_t nr_rrc_ue_decode_NR_DL_DCCH_Message(
         switch(nr_dl_dcch_msg->message.present){            
             case NR_DL_DCCH_MessageType_PR_c1:
 
-                switch(nr_dl_dcch_msg->message.choice.c1.present){
+                switch(nr_dl_dcch_msg->message.choice.c1->present){
                     case NR_DL_DCCH_MessageType__c1_PR_rrcReconfiguration:
-                        nr_rrc_ue_process_rrcReconfiguration(&nr_dl_dcch_msg->message.choice.c1.choice.rrcReconfiguration);
+                        nr_rrc_ue_process_rrcReconfiguration(nr_dl_dcch_msg->message.choice.c1->choice.rrcReconfiguration);
                         break;
 
                     case NR_DL_DCCH_MessageType__c1_PR_NOTHING:

openair2/RRC/NR_UE/rrc_list.h

+#ifndef _RRC_LIST_H_
+#define _RRC_LIST_H_
+
+
+#define RRC_LIST_TYPE(T, N)     \
+    struct {                    \
+        T *entries[N];          \
+        int next[N];            \
+        int prev[N];            \
+        int start;              \
+        int count;              \
+    }
+
+//  initial function for the certain list, storage number of entry, initial pointer and corresponding links
+#define RRC_LIST_INIT(list, c)                      \
+    do {                                            \
+        int iterator;                               \
+        (list).count = (c);                         \
+        for(iterator=0; iterator<c; ++iterator){    \
+            (list).entries[iterator] = NULL;        \
+            (list).next[iterator] = -1;             \
+            (list).prev[iterator] = -1;             \
+            (list).start = -1;                      \
+        }                                           \
+    }while(0)
+
+
+//  check the entry by id first then update or create new entry.
+#define RRC_LIST_MOD_ADD(list, new, id_name)                                        \
+    do {                                                                            \
+        int iterator;                                                               \
+        for(iterator=(list).start; iterator!=-1; iterator=(list).next[iterator]){   \
+            if((new)->id_name == (list).entries[iterator]->id_name){                \
+                (list).entries[iterator] = (new);                                   \
+                break;                                                              \
+            }                                                                       \
+        }                                                                           \
+        if(iterator==-1){                                                           \
+            for(iterator=0; iterator<(list).count; ++iterator){                     \
+                if((list).entries[iterator] == NULL){                               \
+                    (list).next[iterator] = (list).start;                           \
+                    (list).prev[iterator] = -1;                                     \
+                    if((list).start != -1){                                         \
+                        (list).prev[list.start] = iterator;                         \
+                    }                                                               \
+                    (list).start = iterator;                                        \
+                    (list).entries[iterator] = (new);                               \
+                    break;                                                          \
+                }                                                                   \
+            }                                                                       \
+        }                                                                           \
+    }while(0)
+
+//  search entries by id, unlink from the list and output free pointer for upper function to release memory
+#define RRC_LIST_MOD_REL(list, id_name, id, free)                                   \
+    do{                                                                             \
+        int iterator;                                                               \
+        for(iterator=(list).start; iterator!=-1; iterator=(list).next[iterator]){   \
+            if(id == (list).entries[iterator]->id_name){                            \
+                if((list).prev[iterator] == -1){                                    \
+                    (list).start = (list).next[iterator];                           \
+                }else{                                                              \
+                    (list).next[(list).prev[iterator]] = (list).next[iterator];     \
+                }                                                                   \
+                if((list).next[iterator] != -1){                                    \
+                    (list).prev[(list).next[iterator]] = (list).prev[iterator];     \
+                }                                                                   \
+                (free) = (list).entries[iterator];                                  \
+                (list).entries[iterator] = NULL;                                    \
+                break;                                                              \
+            }                                                                       \
+        }                                                                           \
+    }while(0)
+
+
+#define RRC_LIST_FOREACH(list, i)       \
+        for((i)=(list).start; (i) != -1; (i)=(list).next[i])
+
+#define RRC_LIST_ENTRY(list, i)         \
+        list.entries[i]
+
+#endif
\ No newline at end of file

targets/RT/USER/nr-gnb.c

@@ -49,6 +49,7 @@
 #include "PHY/defs_gNB.h"
 #include "SCHED/sched_eNB.h"
 #include "SCHED_NR/sched_nr.h"
+#include "SCHED_NR/fapi_nr_l1.h"
 #include "PHY/LTE_TRANSPORT/transport_proto.h"
 
 #undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
@@ -196,12 +197,12 @@ static inline int rxtx(PHY_VARS_gNB *gNB,gNB_rxtx_proc_t *proc, char *thread_nam
     return 0;
   }
   /// NR disabling
-/*
+
   // ****************************************
   // Common RX procedures subframe n
 
   T(T_gNB_PHY_DL_TICK, T_INT(gNB->Mod_id), T_INT(proc->frame_tx), T_INT(proc->subframe_tx));
-
+/*
   // if this is IF5 or 3GPP_gNB
   if (gNB && gNB->RU_list && gNB->RU_list[0] && gNB->RU_list[0]->function < NGFI_RAU_IF4p5) {
     wakeup_prach_gNB(gNB,NULL,proc->frame_rx,proc->subframe_rx);
@@ -211,7 +212,7 @@ static inline int rxtx(PHY_VARS_gNB *gNB,gNB_rxtx_proc_t *proc, char *thread_nam
   if (nfapi_mode == 0 || nfapi_mode == 1) {
     phy_procedures_gNB_uespec_RX(gNB, proc, no_relay );
   }
-
+*/
   pthread_mutex_lock(&gNB->UL_INFO_mutex);
 
   gNB->UL_INFO.frame     = proc->frame_rx;
@@ -219,10 +220,10 @@ static inline int rxtx(PHY_VARS_gNB *gNB,gNB_rxtx_proc_t *proc, char *thread_nam
   gNB->UL_INFO.module_id = gNB->Mod_id;
   gNB->UL_INFO.CC_id     = gNB->CC_id;
 
-  gNB->if_inst->UL_indication(&gNB->UL_INFO);
+  gNB->if_inst->NR_UL_indication(&gNB->UL_INFO);
 
   pthread_mutex_unlock(&gNB->UL_INFO_mutex);
-*/
+
 /// end
   // *****************************************
   // TX processing for subframe n+sf_ahead
@@ -928,8 +929,8 @@ void init_gNB(int single_thread_flag,int wait_for_sync) {
 
       LOG_I(PHY,"Registering with MAC interface module\n");
       AssertFatal((gNB->if_inst         = NR_IF_Module_init(inst))!=NULL,"Cannot register interface");
-      gNB->if_inst->schedule_response   = schedule_response;
-      gNB->if_inst->PHY_config_req      = nr_phy_config_request;
+      gNB->if_inst->NR_Schedule_response   = nr_schedule_response;
+      gNB->if_inst->NR_PHY_config_req      = nr_phy_config_request;
       memset((void*)&gNB->UL_INFO,0,sizeof(gNB->UL_INFO));
       memset((void*)&gNB->Sched_INFO,0,sizeof(gNB->Sched_INFO));
       LOG_I(PHY,"Setting indication lists\n");

targets/RT/USER/nr-ue.c

@@ -33,16 +33,16 @@
 
 #include "rt_wrapper.h"
 
-#include "LAYER2/MAC/mac.h"
-#include "RRC/LTE/rrc_extern.h"
+#include "LAYER2/NR_MAC_UE/mac.h"
+//#include "RRC/LTE/rrc_extern.h"
 #include "PHY_INTERFACE/phy_interface_extern.h"
 
 #undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
 //#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
 
 #include "PHY/phy_extern_nr_ue.h"
-#include "LAYER2/MAC/mac_extern.h"
-#include "LAYER2/MAC/mac_proto.h"
+//#include "LAYER2/NR_MAC_UE/extern.h"
+#include "LAYER2/NR_MAC_UE/proto.h"
 
 #include "SCHED_NR/extern.h"
 //#ifndef NO_RAT_NR
@@ -734,7 +734,7 @@ void *UE_thread(void *arg) {
     init_UE_threads(UE);
 
 #ifdef NAS_UE
-    MessageDef *message_p;
+    //MessageDef *message_p;
     //message_p = itti_alloc_new_message(TASK_NAS_UE, INITIALIZE_MESSAGE);
     //itti_send_msg_to_task (TASK_NAS_UE, UE->Mod_id + NB_eNB_INST, message_p);
 #endif
@@ -1037,6 +1037,7 @@ void init_UE_threads(PHY_VARS_NR_UE *UE) {
 
 
 #ifdef OPENAIR2
+/*
 void fill_ue_band_info(void) {
 
     UE_EUTRA_Capability_t *UE_EUTRA_Capability = UE_rrc_inst[0].UECap->UE_EUTRA_Capability;
@@ -1063,7 +1064,7 @@ void fill_ue_band_info(void) {
                 break;
             }
     }
-}
+}*/
 #endif
 
 int setup_ue_buffers(PHY_VARS_NR_UE **phy_vars_ue, openair0_config_t *openair0_cfg) {