Merge branch 'sa-msg4-rrc-yihz' into sa-msg4-rrc

README.md

@@ -1,73 +1,3 @@
-# OpenAirInterface License #
+# OpenXG-RAN
 
-OpenAirInterface is under OpenAirInterface Software Alliance license.
-
- *  [OAI License Model](http://www.openairinterface.org/?page_id=101)
- *  [OAI License v1.1 on our website](http://www.openairinterface.org/?page_id=698)
-
-It is distributed under **OAI Public License V1.1**.
-
-The license information is distributed under [LICENSE](LICENSE) file in the same directory.
-
-Please see [NOTICE](NOTICE.md) file for third party software that is included in the sources.
-
-# Where to Start #
-
- *  [The implemented features](./doc/FEATURE_SET.md)
- *  [How to build](./doc/BUILD.md)
- *  [How to run the modems](./doc/RUNMODEM.md)
-
-# RAN repository structure #
-
-The OpenAirInterface (OAI) software is composed of the following parts: 
-
-<pre>
-openairinterface5g
-├── ci-scripts        : Meta-scripts used by the OSA CI process. Contains also configuration files used day-to-day by CI.
-├── cmake_targets     : Build utilities to compile (simulation, emulation and real-time platforms), and generated build files.
-├── common            : Some common OAI utilities, other tools can be found at openair2/UTILS.
-├── doc               : Contains an up-to-date feature set list and starting tutorials.
-├── executables       : Top-level executable source files.
-├── LICENSE           : License file.
-├── maketags          : Script to generate emacs tags.
-├── nfapi             : Contains the NFAPI code. A local Readme file provides more details.
-├── openair1          : 3GPP LTE Rel-10/12 PHY layer / 3GPP NR Rel-15 layer. A local Readme file provides more details.
-│   ├── PHY
-│   ├── SCHED
-│   ├── SCHED_NBIOT
-│   ├── SCHED_NR
-│   ├── SCHED_NR_UE
-│   ├── SCHED_UE
-│   └── SIMULATION    : PHY RF simulation.
-├── openair2          : 3GPP LTE Rel-10 RLC/MAC/PDCP/RRC/X2AP + LTE Rel-14 M2AP implementation. Also 3GPP NR Rel-15 RLC/MAC/PDCP/RRC/X2AP.
-│   ├── COMMON
-│   ├── DOCS
-│   ├── ENB_APP
-│   ├── F1AP
-│   ├── GNB_APP
-│   ├── LAYER2/RLC/   : with the following subdirectories: UM_v9.3.0, TM_v9.3.0, and AM_v9.3.0.
-│   ├── LAYER2/PDCP/PDCP_v10.1.0
-│   ├── M2AP
-│   ├── MCE_APP
-│   ├── NETWORK_DRIVER
-│   ├── NR_PHY_INTERFACE
-│   ├── NR_UE_PHY_INTERFACE
-│   ├── PHY_INTERFACE
-│   ├── RRC
-│   ├── UTIL
-│   └── X2AP
-├── openair3          : 3GPP LTE Rel10 for S1AP, NAS GTPV1-U for both ENB and UE.
-│   ├── COMMON
-│   ├── DOCS
-│   ├── GTPV1-U
-│   ├── M3AP
-│   ├── MME_APP
-│   ├── NAS
-│   ├── S1AP
-│   ├── SCTP
-│   ├── SECU
-│   ├── TEST
-│   ├── UDP
-│   └── UTILS
-└── targets           : Top-level wrappers for unitary simulation for PHY channels, system-level emulation (eNB-UE with and without S1), and realtime eNB and UE and RRH GW.
-</pre>
+OpenXG-RAN is originally forked from OpenAirInterface, and evolves at its own step.

cmake_targets/CMakeLists.txt

@@ -1969,6 +1969,7 @@ set(NR_PDCP_SRC
   ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_entity.c
   ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_entity_drb_am.c
   ${OPENAIR2_DIR}/LAYER2/nr_pdcp/asn1_utils.c
+  ${OPENAIR2_DIR}/LAYER2/nr_pdcp/nr_pdcp_entity_srb.c
   )
 
 set(L2_SRC

executables/nr-softmodem.c

@@ -419,7 +419,7 @@ int create_gNB_tasks(uint32_t gnb_nb) {
   }
 
 
-  if (AMF_MODE_ENABLED && (get_softmodem_params()->phy_test==0 && get_softmodem_params()->do_ra==0)) {
+  if (AMF_MODE_ENABLED && (get_softmodem_params()->phy_test==0 && get_softmodem_params()->do_ra==0 && get_softmodem_params()->sa_ra==0)) {
     if (gnb_nb > 0) {
       /*
       if (itti_create_task (TASK_SCTP, sctp_eNB_task, NULL) < 0) {

executables/nr-uesoftmodem.c

@@ -188,7 +188,22 @@ struct timespec clock_difftime(struct timespec start, struct timespec end) {
 void print_difftimes(void) {
   LOG_I(HW,"difftimes min = %lu ns ; max = %lu ns\n", min_diff_time.tv_nsec, max_diff_time.tv_nsec);
 }
+int create_tasks_nrue(uint32_t ue_nb) {
+  LOG_D(NR_RRC, "%s(ue_nb:%d)\n", __FUNCTION__, ue_nb);
+  itti_wait_ready(1);
 
+  if (ue_nb > 0) {
+    LOG_I(NR_RRC,"create TASK_RRC_NRUE \n");
+    if (itti_create_task (TASK_RRC_NRUE, rrc_nrue_task, NULL) < 0) {
+      LOG_E(NR_RRC, "Create task for RRC UE failed\n");
+      return -1;
+    }
+
+  }
+
+  itti_wait_ready(0);
+  return 0;
+}
 void exit_function(const char *file, const char *function, const int line, const char *s) {
   int CC_id;
 
@@ -585,6 +600,16 @@ int main( int argc, char **argv ) {
   // wait for end of program
   printf("TYPE <CTRL-C> TO TERMINATE\n");
 
+  if (create_tasks_nrue(1) < 0) {
+    printf("cannot create ITTI tasks\n");
+    exit(-1); // need a softer mode
+  }
+  protocol_ctxt_t ctxt_pP = {0};
+  ctxt_pP.enb_flag = ENB_FLAG_NO;
+  ctxt_pP.rnti = 0x1234;
+  rrc_ue_generate_RRCSetupRequest(&ctxt_pP, 0); 
+
+
   while(true)
     sleep(3600);
 

executables/softmodem-common.h

@@ -99,6 +99,7 @@ extern "C"
 #define SPLIT73             softmodem_params.split73
 #define TP_CONFIG           softmodem_params.threadPoolConfig
 #define PHY_TEST            softmodem_params.phy_test
+#define SA_RA                  softmodem_params.sa_ra
 #define DO_RA               softmodem_params.do_ra
 #define WAIT_FOR_SYNC       softmodem_params.wait_for_sync
 #define SINGLE_THREAD_FLAG  softmodem_params.single_thread_flag
@@ -118,6 +119,7 @@ extern "C"
     {"split73",              CONFIG_HLP_SPLIT73,      0,              strptr:(char **)&SPLIT73,           defstrval:NULL,        TYPE_STRING, sizeof(SPLIT73)},\
     {"thread-pool",          CONFIG_HLP_TPOOL,        0,              strptr:(char **)&TP_CONFIG,         defstrval:"n",         TYPE_STRING, sizeof(TP_CONFIG)}, \
     {"phy-test",             CONFIG_HLP_PHYTST,       PARAMFLAG_BOOL, iptr:&PHY_TEST,                     defintval:0,           TYPE_INT,    0},                     \
+    {"sa-ra",                  CONFIG_HLP_PHYTST,       PARAMFLAG_BOOL, iptr:&SA_RA,                            defintval:0,           TYPE_INT,    0},                     \
     {"do-ra",                CONFIG_HLP_DORA,         PARAMFLAG_BOOL, iptr:&DO_RA,                        defintval:0,           TYPE_INT,    0},                     \
     {"usim-test",            CONFIG_HLP_USIM,         PARAMFLAG_BOOL, u8ptr:&USIM_TEST,                   defintval:0,           TYPE_UINT8,  0},                     \
     {"clock-source",                CONFIG_HLP_CLK,          0,              uptr:&CLOCK_SOURCE,                 defintval:0,           TYPE_UINT,   0},                     \
@@ -212,6 +214,7 @@ typedef struct {
   char           split73[1024];
   char           threadPoolConfig[1024];
   int            phy_test;
+  int            sa_ra;
   int            do_ra;
   uint8_t        usim_test;
   int            emulate_rf;

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -391,6 +391,7 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
       LOG_D(PHY,"%02x\n",a[i]);
     LOG_D(PHY,"\n");
   */
+  log_dump(PHY, a, 16, LOG_DUMP_CHAR,"gNB pdsch tx frame %d %d: ", frame, slot);
 
     if (A > 3824) {
       // Add 24-bit crc (polynomial A) to payload

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -665,8 +665,8 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     return((1 + dlsch->max_ldpc_iterations));
   } else {
 //#if UE_DEBUG_TRACE
-    LOG_D(PHY,"[UE %d] DLSCH: Setting ACK for nr_slot_rx %d TBS %d mcs %d nb_rb %d harq_process->round %d\n",
-	  phy_vars_ue->Mod_id,nr_slot_rx,harq_process->TBS,harq_process->mcs,harq_process->nb_rb, harq_process->round);
+    LOG_D(PHY,"[UE %d] DLSCH: Setting ACK for SFN %d nr_slot_rx %d TBS %d mcs %d nb_rb %d harq_process->round %d\n",
+	  phy_vars_ue->Mod_id,frame,nr_slot_rx,harq_process->TBS,harq_process->mcs,harq_process->nb_rb, harq_process->round);
 //#endif
 
     harq_process->status = SCH_IDLE;
@@ -735,6 +735,7 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_COMBINE_SEG, VCD_FUNCTION_OUT);
 
   dlsch->last_iteration_cnt = ret;
+  log_dump(PHY, harq_process->b, 16, LOG_DUMP_CHAR,"nrue pdsch rx frame %d %d: ", frame, nr_slot_rx );
 
   return(ret);
 }

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_ue.c

@@ -157,7 +157,8 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
 
     ///////////
     ////////////////////////////////////////////////////////////////////
-
+    log_dump(PHY, harq_process_ul_ue->a, 16, LOG_DUMP_CHAR,"nrue pusch tx frame %d %d: ", frame, slot);
+  
     /////////////////////////ULSCH scrambling/////////////////////////
     ///////////
 

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -265,8 +265,9 @@ void nr_postDecode(PHY_VARS_gNB *gNB, notifiedFIFO_elt_t *req) {
 
       LOG_D(PHY, "ULSCH received ok \n");
       nr_fill_indication(gNB,ulsch_harq->frame, ulsch_harq->slot, rdata->ulsch_id, rdata->harq_pid, 0);
+      log_dump(PHY, ulsch_harq->b, 16, LOG_DUMP_CHAR,"gnb pusch rx frame %d %d: ", ulsch_harq->frame, ulsch_harq->slot);
     } else {
-      LOG_D(PHY,"[gNB %d] ULSCH: Setting NAK for SFN/SF %d/%d (pid %d, status %d, round %d, TBS %d) r %d\n",
+      LOG_I(PHY,"[gNB %d] ULSCH: Setting NAK for SFN/SF %d/%d (pid %d, status %d, round %d, TBS %d) r %d\n",
             gNB->Mod_id, ulsch_harq->frame, ulsch_harq->slot,
             rdata->harq_pid,ulsch_harq->status, ulsch_harq->round,ulsch_harq->TBS,r);
       if (ulsch_harq->round >= ulsch->Mlimit) {
@@ -569,7 +570,7 @@ void phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
           gNB->uci_pdu_list[num_ucis].pdu_type = NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE;
           gNB->uci_pdu_list[num_ucis].pdu_size = sizeof(nfapi_nr_uci_pucch_pdu_format_0_1_t);
           nfapi_nr_uci_pucch_pdu_format_0_1_t *uci_pdu_format0 = &gNB->uci_pdu_list[num_ucis].pucch_pdu_format_0_1;
-
+          uci_pdu_format0->rnti = pucch_pdu->rnti;
           nr_decode_pucch0(gNB,
 	                   slot_rx,
                            uci_pdu_format0,

openair1/SCHED_NR_UE/fapi_nr_ue_l1.c

@@ -94,8 +94,6 @@ int8_t nr_ue_scheduled_response(nr_scheduled_response_t *scheduled_response){
           dlsch0->rnti = dl_config->dl_config_list[i].dlsch_config_pdu.rnti;
           dlsch0_harq = dlsch0->harq_processes[current_harq_pid];
 
-          LOG_D(PHY,"current_harq_pid = %d\n", current_harq_pid);
-
           if (dlsch0_harq){
 
             dlsch0_harq->BWPStart = dlsch_config_pdu->BWPStart;

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -242,7 +242,7 @@ void phy_procedures_nrUE_TX(PHY_VARS_NR_UE *ue,
   //LOG_M("txdata.m","txs",ue->common_vars.txdata[0],1228800,1,1);
 
   /* RACH */
-  if (get_softmodem_params()->do_ra==1) {
+  if ((get_softmodem_params()->do_ra==1) || (get_softmodem_params()->sa_ra==1)) {
     if ((ue->UE_mode[gNB_id] > NOT_SYNCHED && ue->UE_mode[gNB_id] < PUSCH) && (ue->prach_vars[gNB_id]->prach_Config_enabled == 1)) {
       nr_ue_prach_procedures(ue, proc, gNB_id, mode);
     }
@@ -800,19 +800,25 @@ int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, int eNB_
       else { // This is to adjust the llr offset in the case of skipping over a dmrs symbol (i.e. in case of no PDSCH REs in DMRS)
 	if      (pdsch == RA_PDSCH) ue->pdsch_vars[proc->thread_id][eNB_id]->llr_offset[m]=ue->pdsch_vars[proc->thread_id][eNB_id]->llr_offset[m-1];
 	else if (pdsch == PDSCH) {
-          if (nr_rx_pdsch(ue,
-                    proc,
-                    pdsch,
-                    eNB_id,
-                    eNB_id_i,
-                    frame_rx,
-                    nr_slot_rx,
-                    m,
-                    first_symbol_flag,
-                    dual_stream_UE,
-                    i_mod,
-                    dlsch0->current_harq_pid) < 0)
-                      return -1;
+          if (dlsch0->harq_processes[harq_pid]->n_dmrs_cdm_groups == 2) 
+          {  
+            ue->pdsch_vars[proc->thread_id][eNB_id]->llr_offset[m]=ue->pdsch_vars[proc->thread_id][eNB_id]->llr_offset[m-1];
+          }
+          else  {
+            if (nr_rx_pdsch(ue,
+                      proc,
+                      pdsch,
+                      eNB_id,
+                      eNB_id_i,
+                      frame_rx,
+                      nr_slot_rx,
+                      m,
+                      first_symbol_flag,
+                      dual_stream_UE,
+                      i_mod,
+                      dlsch0->current_harq_pid) < 0)
+                        return -1;
+          }
         }
 	else AssertFatal(1==0,"not RA_PDSCH or PDSCH\n");
       }

openair1/SCHED_NR_UE/pucch_uci_ue_nr.c

@@ -1016,7 +1016,9 @@ boolean_t select_pucch_resource(PHY_VARS_NR_UE *ue, NR_UE_MAC_INST_t *mac, uint8
           return (FALSE);
         }
         /* check if resource indexing by pucch_resource_indicator of this set is compatible */
-        if ((ready_pucch_resource_id == TRUE) || (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->resourceSetToAddModList->list.array[pucch_resource_set_id]->resourceList.list.array[pucch_resource_indicator][0] != MAX_NB_OF_PUCCH_RESOURCES)) {
+        if ((ready_pucch_resource_id == TRUE) 
+        || ((mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->resourceSetToAddModList->list.array[pucch_resource_set_id]->resourceList.list.array[pucch_resource_indicator] != NULL)
+        && (mac->ULbwp[bwp_id-1]->bwp_Dedicated->pucch_Config->choice.setup->resourceSetToAddModList->list.array[pucch_resource_set_id]->resourceList.list.array[pucch_resource_indicator][0] != MAX_NB_OF_PUCCH_RESOURCES))) {
 
           if (ready_pucch_resource_id == TRUE) {
             current_resource_id = *resource_id;

openair2/COMMON/platform_constants.h

@@ -29,6 +29,7 @@
  ***************************************************************************/
 
 #include "LTE_asn_constant.h"
+#include "NR_asn_constant.h"
 
 #ifndef __PLATFORM_CONSTANTS_H__
 #    define __PLATFORM_CONSTANTS_H__
@@ -103,6 +104,7 @@
 #define DEFAULT_RAB_ID 1
 
 #define NB_RB_MAX      (LTE_maxDRB + 3) /* was 11, now 14, maxDRB comes from asn1_constants.h, + 3 because of 3 SRB, one invisible id 0, then id 1 and 2 */
+#define NR_NB_RB_MAX   (NR_maxDRB + 3)
 
 #define NB_RB_MBMS_MAX (LTE_maxSessionPerPMCH*LTE_maxServiceCount)
 

openair2/LAYER2/NR_MAC_UE/mac_proto.h

@@ -310,6 +310,21 @@ void get_num_re_dmrs(nfapi_nr_ue_pusch_pdu_t *pusch_pdu,
 
 void build_ssb_to_ro_map(NR_ServingCellConfigCommon_t *scc, uint8_t unpaired);
 
+/**\brief
+   \param module_id  module id
+   \param CC_id      component carrier id
+   \param frame_t    frameP
+   \param rb_id_t    SRB id
+   \param buffer_pP  pointer to buffer*/
+int8_t mac_rrc_nr_data_req_ue(  
+  const module_id_t Mod_idP,
+  const int         CC_id,
+  const frame_t     frameP,
+  const rb_id_t     Srb_id,
+  const uint8_t     Nb_tb,
+  uint8_t    *const buffer_pP,
+  const uint8_t     gNB_index,
+  const uint8_t     mbsfn_sync_area);
 
 #endif
 /** @}*/

openair2/LAYER2/NR_MAC_UE/nr_ra_procedures.c

@@ -553,12 +553,21 @@ uint8_t nr_ue_get_rach(NR_PRACH_RESOURCES_t *prach_resources,
 
       if (mac->RA_window_cnt >= 0 && mac->RA_RAPID_found == 1) {
 
-        // Reset RA_active flag: it disables Msg3 retransmission (8.3 of TS 38.213)
-        // TbD Msg3 Retransmissions to be scheduled by DCI 0_0
-        mac->RA_active = 0;
-        mac->RA_window_cnt = -1;
-        mac->ra_state = RA_SUCCEEDED;
-        mac->generate_nr_prach = 2;
+        if (get_softmodem_params()->sa_ra)
+        {
+           mac->ra_state = WAIT_CONTENTION_RESOLUTION;
+        }
+        else
+        {
+           // Reset RA_active flag: it disables Msg3 retransmission (8.3 of TS 38.213)
+           // TbD Msg3 Retransmissions to be scheduled by DCI 0_0
+           mac->RA_active = 0;
+           mac->ra_state = RA_SUCCEEDED;
+           mac->generate_nr_prach = 2;
+           mac->crnti = mac->t_crnti;
+           mac->t_crnti = 0;  
+        }
+        mac->RA_window_cnt = -1;       
         LOG_I(MAC, "[MAC][UE %d][RAPROC]: RAR successfully received \n", mod_id);
 
       } else if (mac->RA_window_cnt == 0 && !mac->RA_RAPID_found) {

openair2/LAYER2/NR_MAC_UE/nr_ue_dci_configuration.c

@@ -135,12 +135,22 @@ void config_dci_pdu(NR_UE_MAC_INST_t *mac, fapi_nr_dl_config_dci_dl_pdu_rel15_t
     rel15->BWPStart = NRRIV2PRBOFFSET(bwp_Common->genericParameters.locationAndBandwidth, 275); //NRRIV2PRBOFFSET(initialDownlinkBWP->genericParameters.locationAndBandwidth, 275);
     rel15->SubcarrierSpacing = initialDownlinkBWP->genericParameters.subcarrierSpacing;
     rel15->dci_length_options[0] = nr_dci_size(scc, mac->scg, def_dci_pdu_rel15, rel15->dci_format_options[0], NR_RNTI_RA, rel15->BWPSize, bwp_id);
+    LOG_D(PHY, "pdcch params: rnti %d, bwp %d %d, len %d\n",rel15->rnti, rel15->BWPSize, rel15->BWPStart, rel15->dci_length_options[0]);
     break;
     case NR_RNTI_P:
     break;
     case NR_RNTI_CS:
     break;
     case NR_RNTI_TC:
+    // we use the initial DL BWP
+    sps = initialDownlinkBWP->genericParameters.cyclicPrefix == NULL ? 14 : 12;
+    monitoringSymbolsWithinSlot = (ss->monitoringSymbolsWithinSlot->buf[0]<<(sps-8)) | (ss->monitoringSymbolsWithinSlot->buf[1]>>(16-sps));
+    rel15->rnti = mac->t_crnti;
+    rel15->BWPSize = NRRIV2BW(initialDownlinkBWP->genericParameters.locationAndBandwidth, 275);
+    rel15->BWPStart = NRRIV2PRBOFFSET(bwp_Common->genericParameters.locationAndBandwidth, 275); //NRRIV2PRBOFFSET(initialDownlinkBWP->genericParameters.locationAndBandwidth, 275);
+    rel15->SubcarrierSpacing = initialDownlinkBWP->genericParameters.subcarrierSpacing;
+    rel15->dci_length_options[0] = nr_dci_size(scc, mac->scg, def_dci_pdu_rel15, rel15->dci_format_options[0], NR_RNTI_TC, rel15->BWPSize, bwp_id);
+    LOG_D(PHY, "pdcch params: rnti %d, bwp %d %d (%d), len %d\n",rel15->rnti, rel15->BWPSize, rel15->BWPStart,initialDownlinkBWP->genericParameters.locationAndBandwidth,  rel15->dci_length_options[0]);
     break;
     case NR_RNTI_SP_CSI:
     break;
@@ -222,7 +232,12 @@ void ue_dci_configuration(NR_UE_MAC_INST_t *mac, fapi_nr_dl_config_request_t *dl
               fill_dci_search_candidates(ss, rel15);
               break;
               case WAIT_CONTENTION_RESOLUTION:
+              LOG_D(MAC, "[DCI_CONFIG] frame %d %d Configure monitoring of PDCCH candidates in Type1-PDCCH common random access search space\n",frame,slot);
               rel15->rnti = mac->t_crnti;
+              rel15->num_dci_options = 1; // just search the dci for msg4, should add the ul dci for retx for msg3 later.
+              rel15->dci_format_options[0] = NR_DL_DCI_FORMAT_1_0;
+              config_dci_pdu(mac, rel15, dl_config, NR_RNTI_TC, ss_id);
+              fill_dci_search_candidates(ss, rel15);              
               break;
               default:
               break;

openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c

@@ -962,7 +962,7 @@ int8_t nr_ue_decode_mib(module_id_t module_id,
 
   NR_UE_MAC_INST_t *mac = get_mac_inst(module_id);
 
-  nr_mac_rrc_data_ind_ue( module_id, cc_id, gNB_index, NR_BCCH_BCH, (uint8_t *) pduP, 3 );    //  fixed 3 bytes MIB PDU
+  nr_mac_rrc_data_ind_ue( module_id, cc_id, gNB_index, 0, 0, 0, NR_BCCH_BCH, (uint8_t *) pduP, 3 );    //  fixed 3 bytes MIB PDU
     
   AssertFatal(mac->mib != NULL, "nr_ue_decode_mib() mac->mib == NULL\n");
   //if(mac->mib != NULL){
@@ -1657,7 +1657,7 @@ NR_UE_L2_STATE_t nr_ue_scheduler(nr_downlink_indication_t *dl_info, nr_uplink_in
 
       }
 
-    } else if (get_softmodem_params()->do_ra){
+    } else if ((get_softmodem_params()->do_ra) || (get_softmodem_params()->sa_ra)){
 
       NR_UE_MAC_INST_t *mac = get_mac_inst(ul_info->module_id);
 
@@ -1671,32 +1671,79 @@ NR_UE_L2_STATE_t nr_ue_scheduler(nr_downlink_indication_t *dl_info, nr_uplink_in
         fapi_nr_ul_config_request_pdu_t *ul_config_list = &ul_config->ul_config_list[ul_config->number_pdus];
         uint16_t TBS_bytes = ul_config_list->pusch_config_pdu.pusch_data.tb_size;
 
-        //if (IS_SOFTMODEM_NOS1){
-        //  // Getting IP traffic to be transmitted
-        //  data_existing = nr_ue_get_sdu(mod_id,
-        //                                cc_id,
-        //                                frame_tx,
-        //                                slot_tx,
-        //                                0,
-        //                                ulsch_input_buffer,
-        //                                TBS_bytes,
-        //                                &access_mode);
-        //}
+        uint16_t size_sdu = 0;
+        int CC_id;
+        uint8_t mac_sdus[MAX_NR_ULSCH_PAYLOAD_BYTES];
+        uint8_t sdu_lcids[NB_RB_MAX] = {0};
+        uint16_t sdu_lengths[NB_RB_MAX] = {0};
+        uint8_t lcid = UL_SCH_LCID_CCCH;
+        // uint8_t *payload;
+        // payload = (uint8_t*) &mac->CCCH_pdu.payload;
+        // int TBS_bytes_new = 848;
+        int mac_ce_len = 0;
+        int header_length_total = 0;
+        int num_sdus = 1;
+        unsigned short post_padding = 1;
+        int offset;
 
-        //Random traffic to be transmitted if there is no IP traffic available for this Tx opportunity
-        //if (!IS_SOFTMODEM_NOS1 || !data_existing) {
-          //Use zeros for the header bytes in noS1 mode, in order to make sure that the LCID is not valid
-          //and block this traffic from being forwarded to the upper layers at the gNB
-          LOG_D(MAC, "Random data to be tranmsitted (TBS_bytes %d): \n", TBS_bytes);
-          //Give the first byte a dummy value (a value not corresponding to any valid LCID based on 38.321, Table 6.2.1-2)
-          //in order to distinguish the PHY random packets at the MAC layer of the gNB receiver from the normal packets that should
-          //have a valid LCID (nr_process_mac_pdu function)
-          ulsch_input_buffer[0] = 0x31;
-          for (int i = 1; i < TBS_bytes; i++) {
-            ulsch_input_buffer[i] = (unsigned char) rand();
-            //printf(" input encoder a[%d]=0x%02x\n",i,harq_process_ul_ue->a[i]);
-          }
-        //}
+        // //if (IS_SOFTMODEM_NOS1){
+        // //  // Getting IP traffic to be transmitted
+        // //  data_existing = nr_ue_get_sdu(mod_id,
+        // //                                cc_id,
+        // //                                frame_tx,
+        // //                                slot_tx,
+        // //                                0,
+        // //                                ulsch_input_buffer,
+        // //                                TBS_bytes,
+        // //                                &access_mode);
+        // //}
+
+        // //Random traffic to be transmitted if there is no IP traffic available for this Tx opportunity
+        // //if (!IS_SOFTMODEM_NOS1 || !data_existing) {
+        //   //Use zeros for the header bytes in noS1 mode, in order to make sure that the LCID is not valid
+        //   //and block this traffic from being forwarded to the upper layers at the gNB
+        //   LOG_D(MAC, "Random data to be tranmsitted (TBS_bytes %d): \n", TBS_bytes);
+        //   //Give the first byte a dummy value (a value not corresponding to any valid LCID based on 38.321, Table 6.2.1-2)
+        //   //in order to distinguish the PHY random packets at the MAC layer of the gNB receiver from the normal packets that should
+        //   //have a valid LCID (nr_process_mac_pdu function)
+        //   ulsch_input_buffer[0] = 0x31;
+        //   for (int i = 1; i < TBS_bytes; i++) {
+        //     ulsch_input_buffer[i] = (unsigned char) rand();
+        //     //printf(" input encoder a[%d]=0x%02x\n",i,harq_process_ul_ue->a[i]);
+        //   }
+        // //}
+
+        size_sdu = (uint16_t) mac_rrc_nr_data_req_ue(ul_info->module_id,
+                                                  ul_info->cc_id,
+                                                  ul_info->frame_rx,
+                                                  CCCH,
+                                                  1,
+                                                  mac_sdus,
+                                                  ul_info->gNB_index,
+                                                  0);
+        sdu_lcids[0] = lcid;
+        sdu_lengths[0] = TBS_bytes - 3 - post_padding - mac_ce_len;
+        header_length_total += 2 + (sdu_lengths[0] >= 128);
+        size_sdu += sdu_lengths[0];
+
+        offset = nr_generate_ulsch_pdu((uint8_t *) mac_sdus,              // sdus buffer
+                                       (uint8_t *) ulsch_input_buffer,               // UL MAC pdu pointer
+                                       num_sdus,                          // num sdus
+                                       sdu_lengths,                       // sdu length
+                                       sdu_lcids,                         // sdu lcid
+                                       0,                                 // power headroom
+                                       0,                                 // crnti
+                                       0,                                 // truncated bsr
+                                       0,                                 // short bsr
+                                       0,                                 // long_bsr
+                                       post_padding,
+                                       0);
+
+        // Padding: fill remainder with 0
+        if (post_padding > 0){
+          for (int j = 0; j < (TBS_bytes - offset); j++)
+            ulsch_input_buffer[offset + j] = 0; // mac_pdu[offset + j] = 0;
+        }
 
         LOG_D(MAC, "[UE %d] Frame %d, Subframe %d Adding Msg3 UL Config Request for rnti: %x\n",
           ul_info->module_id,
@@ -3154,7 +3201,7 @@ int8_t nr_ue_process_dci(module_id_t module_id, int cc_id, uint8_t gNB_index, fr
   AssertFatal(mac->DLbwp[0]!=NULL,"DLbwp[0] should not be zero here!\n");
   AssertFatal(mac->ULbwp[0]!=NULL,"DLbwp[0] should not be zero here!\n");
 
-  const uint16_t n_RB_DLBWP = (mac->ra_state == WAIT_RAR) ? NRRIV2BW(mac->scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters.locationAndBandwidth, 275) : NRRIV2BW(mac->DLbwp[0]->bwp_Common->genericParameters.locationAndBandwidth,275);
+  const uint16_t n_RB_DLBWP = ((mac->ra_state == WAIT_RAR)||(mac->ra_state == WAIT_CONTENTION_RESOLUTION) ) ? NRRIV2BW(mac->scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters.locationAndBandwidth, 275) : NRRIV2BW(mac->DLbwp[0]->bwp_Common->genericParameters.locationAndBandwidth,275);
   const uint16_t n_RB_ULBWP = NRRIV2BW(mac->ULbwp[0]->bwp_Common->genericParameters.locationAndBandwidth,275);
 
   LOG_D(MAC,"nr_ue_process_dci at MAC layer with dci_format=%d (DL BWP %d, UL BWP %d)\n",dci_format,n_RB_DLBWP,n_RB_ULBWP);
@@ -3756,7 +3803,7 @@ int8_t nr_ue_process_dci(module_id_t module_id, int cc_id, uint8_t gNB_index, fr
     }
 
     /* PDSCH_TO_HARQ_FEEDBACK_TIME_IND (only if CRC scrambled by C-RNTI or CS-RNTI or new-RNTI)*/
-    dlsch_config_pdu_1_0->pdsch_to_harq_feedback_time_ind = dci->pdsch_to_harq_feedback_timing_indicator.val;
+    dlsch_config_pdu_1_0->pdsch_to_harq_feedback_time_ind = dci->pdsch_to_harq_feedback_timing_indicator.val + 1;
 
     LOG_D(MAC,"(nr_ue_procedures.c) rnti = %x dl_config->number_pdus = %d\n",
 	  dl_config->dl_config_list[dl_config->number_pdus].dlsch_config_pdu.rnti,
@@ -4136,11 +4183,12 @@ int nr_extract_dci_info(NR_UE_MAC_INST_t *mac,
   int rnti_type=-1;
 
   if       (rnti == mac->ra_rnti) rnti_type = NR_RNTI_RA;
-  else if (rnti == mac->crnti)    rnti_type = NR_RNTI_C;
   else if (rnti == mac->t_crnti)  rnti_type = NR_RNTI_TC;
+  else if (rnti == mac->crnti)    rnti_type = NR_RNTI_C;
   else if (rnti == 0xFFFE)        rnti_type = NR_RNTI_P;
   else if (rnti == 0xFFFF)        rnti_type = NR_RNTI_SI;
 
+
   AssertFatal(rnti_type!=-1,"no identified/handled rnti\n");
   AssertFatal(mac->DLbwp[0] != NULL, "DLbwp[0] shouldn't be null here!\n");
   AssertFatal(mac->ULbwp[0] != NULL, "ULbwp[0] shouldn't be null here!\n");
@@ -4152,7 +4200,7 @@ int nr_extract_dci_info(NR_UE_MAC_INST_t *mac,
   int pos=0;
   int fsize=0;
 
-  if (rnti_type == NR_RNTI_C) {
+  if ((rnti_type == NR_RNTI_C)  || (rnti_type == NR_RNTI_TC)){
     // First find out the DCI format from the first bit (UE performed blind decoding)
     pos++;
     dci_pdu_rel15->format_indicator = (*dci_pdu>>(dci_size-pos))&1;
@@ -4175,7 +4223,7 @@ int nr_extract_dci_info(NR_UE_MAC_INST_t *mac,
     }
   }
 #ifdef DEBUG_EXTRACT_DCI
-  LOG_D(MAC, "DCI format is %d\n", dci_format);
+  LOG_D(MAC, "DCI format is %d, type %d, rnti %d, rnti_c %d, rnti_tc %d\n", dci_format, rnti_type, rnti, mac->crnti, mac->t_crnti);
 #endif
   
   switch(dci_format) {
@@ -4378,38 +4426,82 @@ int nr_extract_dci_info(NR_UE_MAC_INST_t *mac,
       break;
 	
     case NR_RNTI_TC:
-      // indicating a DL DCI format 1bit
-      pos++;
-      dci_pdu_rel15->format_indicator = (*dci_pdu>>(dci_size-pos))&1;
       // Freq domain assignment 0-16 bit
       fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
       pos+=fsize;
       dci_pdu_rel15->frequency_domain_assignment.val = (*dci_pdu>>(dci_size-pos))&((1<<fsize)-1);
+#ifdef DEBUG_EXTRACT_DCI
+      LOG_D(MAC,"Freq domain assignment %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->frequency_domain_assignment.val,fsize,dci_size-pos,*dci_pdu);
+#endif
+
       // Time domain assignment 4 bit
       pos+=4;
       dci_pdu_rel15->time_domain_assignment.val = (*dci_pdu>>(dci_size-pos))&0xf;
+#ifdef DEBUG_EXTRACT_DCI
+	LOG_D(MAC,"Time domain assignment %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->time_domain_assignment.val,4,dci_size-pos,*dci_pdu);
+#endif
+      pos+=1;
       // VRB to PRB mapping 1 bit
       dci_pdu_rel15->vrb_to_prb_mapping.val = (*dci_pdu>>(dci_size-pos))&1;
+#ifdef DEBUG_EXTRACT_DCI
+	LOG_D(MAC,"VRB to PRB %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->vrb_to_prb_mapping.val,1,dci_size-pos,*dci_pdu);
+#endif
+
       // MCS 5bit  //bit over 32, so dci_pdu ++
       pos+=5;
       dci_pdu_rel15->mcs = (*dci_pdu>>(dci_size-pos))&0x1f;
+#ifdef DEBUG_EXTRACT_DCI
+	LOG_D(MAC,"MCS %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->mcs,5,dci_size-pos,*dci_pdu);
+#endif
+
       // New data indicator 1bit
+      pos+=1;
       dci_pdu_rel15->ndi = (*dci_pdu>>(dci_size-pos))&1;
       // Redundancy version  2bit
+#ifdef DEBUG_EXTRACT_DCI
+	LOG_D(MAC,"NDI %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->ndi,1,dci_size-pos,*dci_pdu);
+#endif      
+
       pos+=2;
       dci_pdu_rel15->rv = (*dci_pdu>>(dci_size-pos))&3;
       // HARQ process number  4bit
+#ifdef DEBUG_EXTRACT_DCI
+	LOG_D(MAC,"RV %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->rv,2,dci_size-pos,*dci_pdu);
+#endif
+
       pos+=4;
       dci_pdu_rel15->harq_pid = (*dci_pdu>>(dci_size-pos))&0xf;
+#ifdef DEBUG_EXTRACT_DCI
+	LOG_D(MAC,"HARQ_PID %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->harq_pid,4,dci_size-pos,*dci_pdu);
+#endif
+
       // Downlink assignment index  E2 bits
       pos+=2;
       dci_pdu_rel15->dai[0].val = (*dci_pdu>>(dci_size-pos))&3;
+#ifdef DEBUG_EXTRACT_DCI
+	LOG_D(MAC,"DAI %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->dai[0].val,2,dci_size-pos,*dci_pdu);
+#endif
+
       // TPC command for scheduled PUCCH  E2 bits
       pos+=2;
       dci_pdu_rel15->tpc  = (*dci_pdu>>(dci_size-pos))&3;
+#ifdef DEBUG_EXTRACT_DCI
+	LOG_D(MAC,"TPC %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->tpc,2,dci_size-pos,*dci_pdu);
+#endif
+
+      // PDSCH-to-HARQ_feedback timing indicator  E3 bits
+      pos+=3;
+      dci_pdu_rel15->pucch_resource_indicator = (*dci_pdu>>(dci_size-pos))&7;
+#ifdef DEBUG_EXTRACT_DCI
+	LOG_D(MAC,"PUCCH RESOURCE INDICATOR %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->pucch_resource_indicator,3,dci_size-pos,*dci_pdu);
+#endif
+
       // PDSCH-to-HARQ_feedback timing indicator  E3 bits
       pos+=3;
       dci_pdu_rel15->pdsch_to_harq_feedback_timing_indicator.val = (*dci_pdu>>(dci_size-pos))&7;
+#ifdef DEBUG_EXTRACT_DCI
+	LOG_D(MAC,"PDSCH to HARQ TI %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->pdsch_to_harq_feedback_timing_indicator.val,3,dci_size-pos,*dci_pdu);
+#endif
        
       break;
     }
@@ -4497,80 +4589,159 @@ int nr_extract_dci_info(NR_UE_MAC_INST_t *mac,
         // Carrier indicator
         pos+=dci_pdu_rel15->carrier_indicator.nbits;
         dci_pdu_rel15->carrier_indicator.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->carrier_indicator.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"Carrier indicator %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->carrier_indicator.val,dci_pdu_rel15->carrier_indicator.nbits,dci_size-pos,*dci_pdu);
+#endif
         // BWP Indicator
         pos+=dci_pdu_rel15->bwp_indicator.nbits;
         dci_pdu_rel15->bwp_indicator.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->bwp_indicator.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"bwp indicator %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->bwp_indicator.val,dci_pdu_rel15->bwp_indicator.nbits,dci_size-pos,*dci_pdu);
+#endif        
         // Frequency domain resource assignment
         pos+=dci_pdu_rel15->frequency_domain_assignment.nbits;
         dci_pdu_rel15->frequency_domain_assignment.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->frequency_domain_assignment.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"frequency_domain_assignment %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->frequency_domain_assignment.val,dci_pdu_rel15->frequency_domain_assignment.nbits,dci_size-pos,*dci_pdu);
+#endif        
+
         // Time domain resource assignment
         pos+=dci_pdu_rel15->time_domain_assignment.nbits;
         dci_pdu_rel15->time_domain_assignment.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->time_domain_assignment.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"time_domain_assignment %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->time_domain_assignment.val,dci_pdu_rel15->time_domain_assignment.nbits,dci_size-pos,*dci_pdu);
+#endif        
+
         // VRB-to-PRB mapping
         pos+=dci_pdu_rel15->vrb_to_prb_mapping.nbits;
         dci_pdu_rel15->vrb_to_prb_mapping.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->vrb_to_prb_mapping.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"vrb_to_prb_mapping %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->vrb_to_prb_mapping.val,dci_pdu_rel15->vrb_to_prb_mapping.nbits,dci_size-pos,*dci_pdu);
+#endif        
+
         // PRB bundling size indicator
         pos+=dci_pdu_rel15->prb_bundling_size_indicator.nbits;
         dci_pdu_rel15->prb_bundling_size_indicator.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->prb_bundling_size_indicator.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"prb_bundling_size_indicator %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->prb_bundling_size_indicator.val,dci_pdu_rel15->prb_bundling_size_indicator.nbits,dci_size-pos,*dci_pdu);
+#endif          
         // Rate matching indicator
         pos+=dci_pdu_rel15->rate_matching_indicator.nbits;
         dci_pdu_rel15->rate_matching_indicator.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->rate_matching_indicator.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"rate_matching_indicator %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->rate_matching_indicator.val,dci_pdu_rel15->rate_matching_indicator.nbits,dci_size-pos,*dci_pdu);
+#endif          
+
         // ZP CSI-RS trigger
         pos+=dci_pdu_rel15->zp_csi_rs_trigger.nbits;
         dci_pdu_rel15->zp_csi_rs_trigger.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->zp_csi_rs_trigger.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"zp_csi_rs_trigger %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->zp_csi_rs_trigger.val,dci_pdu_rel15->zp_csi_rs_trigger.nbits,dci_size-pos,*dci_pdu);
+#endif
         //TB1
         // MCS 5bit
         pos+=5;
         dci_pdu_rel15->mcs = (*dci_pdu>>(dci_size-pos))&0x1f;
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"mcs %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->mcs,5,dci_size-pos,*dci_pdu);
+#endif
         // New data indicator 1bit
         pos+=1;
         dci_pdu_rel15->ndi = (*dci_pdu>>(dci_size-pos))&0x1;
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"ndi %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->ndi,1,dci_size-pos,*dci_pdu);
+#endif
         // Redundancy version  2bit
         pos+=2;
         dci_pdu_rel15->rv = (*dci_pdu>>(dci_size-pos))&0x3;
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"rv %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->rv,2,dci_size-pos,*dci_pdu);
+#endif
         //TB2
         // MCS 5bit
         pos+=dci_pdu_rel15->mcs2.nbits;
         dci_pdu_rel15->mcs2.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->mcs2.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"mcs2 %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->mcs2.val,dci_pdu_rel15->mcs2.nbits,dci_size-pos,*dci_pdu);
+#endif       
         // New data indicator 1bit
         pos+=dci_pdu_rel15->ndi2.nbits;
         dci_pdu_rel15->ndi2.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->ndi2.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"ndi2 %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->ndi2.val,dci_pdu_rel15->ndi2.nbits,dci_size-pos,*dci_pdu);
+#endif
         // Redundancy version  2bit
         pos+=dci_pdu_rel15->rv2.nbits;
         dci_pdu_rel15->rv2.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->rv2.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"rv2 %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->rv2.val,dci_pdu_rel15->rv2.nbits,dci_size-pos,*dci_pdu);
+#endif
         // HARQ process number  4bit
         pos+=4;
         dci_pdu_rel15->harq_pid = (*dci_pdu>>(dci_size-pos))&0xf;
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"harq_pid %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->harq_pid,4,dci_size-pos,*dci_pdu);
+#endif
         // Downlink assignment index
         pos+=dci_pdu_rel15->dai[0].nbits;
         dci_pdu_rel15->dai[0].val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->dai[0].nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"dai[0] %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->dai[0].val,dci_pdu_rel15->dai[0].nbits,dci_size-pos,*dci_pdu);
+#endif
         // TPC command for scheduled PUCCH  2bit
         pos+=2;
         dci_pdu_rel15->tpc = (*dci_pdu>>(dci_size-pos))&0x3;
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"tpc %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->tpc,2,dci_size-pos,*dci_pdu);
+#endif
         // PUCCH resource indicator  3bit
         pos+=3;
         dci_pdu_rel15->pucch_resource_indicator = (*dci_pdu>>(dci_size-pos))&0x3;
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"pucch_resource_indicator %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->pucch_resource_indicator,3,dci_size-pos,*dci_pdu);
+#endif        
         // PDSCH-to-HARQ_feedback timing indicator
         pos+=dci_pdu_rel15->pdsch_to_harq_feedback_timing_indicator.nbits;
         dci_pdu_rel15->pdsch_to_harq_feedback_timing_indicator.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->pdsch_to_harq_feedback_timing_indicator.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"pdsch_to_harq_feedback_timing_indicator %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->pdsch_to_harq_feedback_timing_indicator.val,dci_pdu_rel15->pdsch_to_harq_feedback_timing_indicator.nbits,dci_size-pos,*dci_pdu);
+#endif
         // Antenna ports
         pos+=dci_pdu_rel15->antenna_ports.nbits;
         dci_pdu_rel15->antenna_ports.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->antenna_ports.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"antenna_ports %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->antenna_ports.val,dci_pdu_rel15->antenna_ports.nbits,dci_size-pos,*dci_pdu);
+#endif
         // TCI
         pos+=dci_pdu_rel15->transmission_configuration_indication.nbits;
         dci_pdu_rel15->transmission_configuration_indication.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->transmission_configuration_indication.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"transmission_configuration_indication %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->transmission_configuration_indication.val,dci_pdu_rel15->transmission_configuration_indication.nbits,dci_size-pos,*dci_pdu);
+#endif
         // SRS request
         pos+=dci_pdu_rel15->srs_request.nbits;
         dci_pdu_rel15->srs_request.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->srs_request.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"srs_request %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->srs_request.val,dci_pdu_rel15->srs_request.nbits,dci_size-pos,*dci_pdu);
+#endif        
         // CBG transmission information
         pos+=dci_pdu_rel15->cbgti.nbits;
         dci_pdu_rel15->cbgti.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->cbgti.nbits)-1);
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"cbgti %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->cbgti.val,dci_pdu_rel15->cbgti.nbits,dci_size-pos,*dci_pdu);
+#endif 
         // CBG flushing out information
         pos+=dci_pdu_rel15->cbgfi.nbits;
         dci_pdu_rel15->cbgfi.val = (*dci_pdu>>(dci_size-pos))&((1<<dci_pdu_rel15->cbgfi.nbits)-1);
-        // DMRS sequence init
+
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"cbgfi %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->cbgfi.val,dci_pdu_rel15->cbgfi.nbits,dci_size-pos,*dci_pdu);
+#endif         // DMRS sequence init
         pos+=1;
         dci_pdu_rel15->dmrs_sequence_initialization.val = (*dci_pdu>>(dci_size-pos))&0x1;
+#ifdef DEBUG_EXTRACT_DCI
+	      LOG_D(MAC,"dmrs_sequence_initialization %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->dmrs_sequence_initialization,3,dci_size-pos,*dci_pdu);
+#endif 
         break;
       }
       break;
@@ -4740,23 +4911,28 @@ void nr_ue_process_mac_pdu(module_id_t module_idP,
         mac_subheader_len = 0x0001; //  default to fixed-length subheader = 1-oct
         mac_sdu_len = 0x0000;
         rx_lcid = ((NR_MAC_SUBHEADER_FIXED *)pdu_ptr)->LCID;
-	  //#ifdef DEBUG_HEADER_PARSING
-              LOG_D(MAC, "[UE] LCID %d, PDU length %d\n", ((NR_MAC_SUBHEADER_FIXED *)pdu_ptr)->LCID, pdu_len);
-	      //#endif
+	      #ifdef DEBUG_HEADER_PARSING
+            LOG_I(MAC, "[UE] LCID %d, PDU length %d\n", ((NR_MAC_SUBHEADER_FIXED *)pdu_ptr)->LCID, pdu_len);
+	      #endif
 
-        LOG_D(MAC, "[UE] LCID %d, PDU length %d\n", rx_lcid, pdu_len);
         switch(rx_lcid){
             //  MAC CE
 
             case DL_SCH_LCID_CCCH:
                 //  MSG4 RRC Connection Setup 38.331
                 //  varialbe length
-                mac_ce_len |= (uint16_t)((NR_MAC_SUBHEADER_SHORT *)pdu_ptr)->L;
-                mac_subheader_len = 2;
                 if(((NR_MAC_SUBHEADER_SHORT *)pdu_ptr)->F){
-                    mac_ce_len |= (uint16_t)(((NR_MAC_SUBHEADER_LONG *)pdu_ptr)->L2)<<8;
+                    mac_sdu_len = ((uint16_t)(((NR_MAC_SUBHEADER_LONG *) pdu_ptr)->L1 & 0x7f) << 8)
+                                 | ((uint16_t)((NR_MAC_SUBHEADER_LONG *) pdu_ptr)->L2 & 0xff);
                     mac_subheader_len = 3;
                 }
+                else
+                {
+                  mac_sdu_len = ((NR_MAC_SUBHEADER_LONG *) pdu_ptr)->L1;
+                  mac_subheader_len = 2;
+                }
+                
+                nr_mac_rrc_data_ind_ue(module_idP, CC_id, gNB_index, frameP, 0, mac->crnti, CCCH, pdu_ptr+mac_subheader_len, mac_sdu_len);
 
                 break;
 
@@ -4869,7 +5045,7 @@ void nr_ue_process_mac_pdu(module_id_t module_idP,
                 // WIP todo: handle CCCH_pdu
                 mac_ce_len = 6;
                 
-                LOG_I(MAC, "[UE %d][RAPROC] Frame %d : received contention resolution msg: %x.%x.%x.%x.%x.%x, Terminating RA procedure\n", module_idP, frameP, pdu_ptr[0], pdu_ptr[1], pdu_ptr[2], pdu_ptr[3], pdu_ptr[4], pdu_ptr[5]);
+                LOG_I(MAC, "[UE %d][RAPROC] Frame %d : received contention resolution msg: %x.%x.%x.%x.%x.%x, Terminating RA procedure\n", module_idP, frameP, pdu_ptr[1], pdu_ptr[2], pdu_ptr[3], pdu_ptr[4], pdu_ptr[5], pdu_ptr[6]);
 
                 if (mac->RA_active == 1) {
                   LOG_I(MAC, "[UE %d][RAPROC] Frame %d : Clearing RA_active flag\n", module_idP, frameP);
@@ -4933,7 +5109,7 @@ void nr_ue_process_mac_pdu(module_id_t module_idP,
                 #endif
 
                 if (IS_SOFTMODEM_NOS1){
-                  if (rx_lcid < NB_RB_MAX && rx_lcid >= DL_SCH_LCID_DTCH) {
+                  if (rx_lcid < NB_RB_MAX && rx_lcid >= DL_SCH_LCID_DCCH) {
 
                     mac_rlc_data_ind(module_idP,
                                      mac->crnti,
@@ -5013,7 +5189,10 @@ uint16_t nr_generate_ulsch_pdu(uint8_t *sdus_payload,
       }
     } else { // UL CCCH SDU
       mac_pdu_ptr->R = 0;
+      ((NR_MAC_SUBHEADER_SHORT *) mac_pdu_ptr)->F = 0;
       mac_pdu_ptr->LCID = sdu_lcids[i];
+      ((NR_MAC_SUBHEADER_SHORT *) mac_pdu_ptr)->L = (unsigned char) sdu_lengths[i];
+      last_size = 2;
     }
 
     mac_pdu_ptr += last_size;

openair2/LAYER2/NR_MAC_gNB/config.c

@@ -387,7 +387,7 @@ int rrc_mac_config_req_gNB(module_id_t Mod_idP,
 
     NR_UE_info_t *UE_info = &RC.nrmac[Mod_idP]->UE_info;
     if (add_ue == 1 && get_softmodem_params()->phy_test) {
-      const int UE_id = add_new_nr_ue(Mod_idP,rnti);
+      const int UE_id = add_new_nr_ue(Mod_idP,rnti,true);
       UE_info->secondaryCellGroup[UE_id] = secondaryCellGroup;
       compute_csi_bitlen (secondaryCellGroup, UE_info, UE_id);
       struct NR_ServingCellConfig__downlinkBWP_ToAddModList *bwpList =

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c

@@ -412,7 +412,7 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
   // This schedule RA procedure if not in phy_test mode
   // Otherwise already consider 5G already connected
   if (get_softmodem_params()->phy_test == 0) {
-    nr_schedule_RA(module_idP, frame, slot);
+    nr_schedule_RA(module_idP, frame, slot, num_slots_per_tdd);
   }
 
   // This schedules the DCI for Uplink and subsequently PUSCH
@@ -427,7 +427,8 @@ void gNB_dlsch_ulsch_scheduler(module_id_t module_idP,
   }
 
 
-  if (UE_info->active[UE_id])
+  //if (UE_info->active[UE_id])
+    if (UE_info->rnti[UE_id] > 0)
     nr_schedule_pucch(module_idP, UE_id, nr_ulmix_slots, frame, slot);
 
   stop_meas(&RC.nrmac[module_idP]->eNB_scheduler);

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_RA.c

@@ -541,7 +541,7 @@ void nr_initiate_ra_proc(module_id_t module_idP,
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_INITIATE_RA_PROC, 0);
 }
 
-void nr_schedule_RA(module_id_t module_idP, frame_t frameP, sub_frame_t slotP){
+void nr_schedule_RA(module_id_t module_idP, frame_t frameP, sub_frame_t slotP, int num_slots_per_tdd){
 
   //uint8_t i = 0;
   int CC_id = 0;
@@ -556,16 +556,19 @@ void nr_schedule_RA(module_id_t module_idP, frame_t frameP, sub_frame_t slotP){
 //	NR_RA_t *ra = &cc->ra[i];
 	NR_RA_t *ra = &cc->ra[0];
 
-  LOG_D(MAC,"RA[state:%d]\n",ra->state);
+  LOG_D(MAC,"RA[state:%d], frame %d %d\n",ra->state, frameP, slotP);
   switch (ra->state){
     case Msg2:
       nr_generate_Msg2(module_idP, CC_id, frameP, slotP);
       break;
     case Msg4:
-      //generate_Msg4(module_idP, CC_id, frameP, slotP);
+      LOG_D(MAC,"RA[state:%d], frame %d %d\n",ra->state, frameP, slotP);
+      if (ra->Msg4_frame == frameP && ra->Msg4_slot == slotP )
+        nr_generate_Msg4(module_idP, CC_id, frameP, slotP, num_slots_per_tdd, ra);
       break;
     case WAIT_Msg4_ACK:
       //check_Msg4_retransmission(module_idP, CC_id, frameP, slotP);
+      nr_check_Msg4_Ack(module_idP, CC_id, frameP, slotP, ra, num_slots_per_tdd);
       break;
     default:
     break;
@@ -830,7 +833,7 @@ void nr_generate_Msg2(module_id_t module_idP,
     LOG_I(MAC, "[RAPROC] Scheduling common search space DCI type 1 dlBWP BW %d\n", dci10_bw);
 
     // Qm>2 not allowed for RAR
-    if (get_softmodem_params()->do_ra)
+    if ((get_softmodem_params()->do_ra) || (get_softmodem_params()->sa_ra))
       mcsIndex = 9;
     else
       mcsIndex = 0;
@@ -926,7 +929,7 @@ void nr_generate_Msg2(module_id_t module_idP,
                        ss,
                        coreset,
                        scc,
-                       bwp,
+                       NULL,
                        aggregation_level,
                        CCEIndex);
 
@@ -935,13 +938,15 @@ void nr_generate_Msg2(module_id_t module_idP,
     dci_formats[0] = NR_DL_DCI_FORMAT_1_0;
     rnti_types[0] = NR_RNTI_RA;
 
-    LOG_I(MAC, "[RAPROC] DCI params: rnti %d, rnti_type %d, dci_format %d coreset params: FreqDomainResource %llx, start_symbol %d  n_symb %d\n",
+    LOG_I(MAC, "[RAPROC] DCI params: rnti %d, rnti_type %d, dci_format %d coreset params: FreqDomainResource %llx, start_symbol %d  n_symb %d, bwp %d %d\n",
       pdcch_pdu_rel15->dci_pdu.RNTI[0],
       rnti_types[0],
       dci_formats[0],
       (unsigned long long)pdcch_pdu_rel15->FreqDomainResource,
       pdcch_pdu_rel15->StartSymbolIndex,
-      pdcch_pdu_rel15->DurationSymbols);
+      pdcch_pdu_rel15->DurationSymbols,
+      pdcch_pdu_rel15->BWPSize,
+      pdcch_pdu_rel15->BWPStart);
 
     fill_dci_pdu_rel15(scc,ra->secondaryCellGroup,pdcch_pdu_rel15, &dci_pdu_rel15[0], dci_formats, rnti_types,dci10_bw,ra->bwp_id);
 
@@ -978,6 +983,313 @@ void nr_generate_Msg2(module_id_t module_idP,
   }
 }
 
+void
+nr_get_retransmission_timing(
+                          frame_t *frameP,
+                          sub_frame_t *subframeP)
+//------------------------------------------------------------------------------
+{
+  *frameP = (*frameP + 1) % 1024;
+  *subframeP = *subframeP;
+  return;
+}
+void
+nr_generate_Msg4(module_id_t module_id,
+                 int CC_id,
+                 frame_t frame,
+                 sub_frame_t slot,
+                 int num_slots_per_tdd,
+                 NR_RA_t *ra) {
+  /* PREPROCESSOR */
+ 
+  gNB_MAC_INST *gNB_mac = RC.nrmac[module_id];
+ 
+  /* PREPROCESSOR */
+   NR_UE_info_t *UE_info = &RC.nrmac[module_id]->UE_info;
+  //NR_ServingCellConfigCommon_t *scc = cc->ServingCellConfigCommon;
+  int16_t rrc_sdu_length = 0;
+  uint16_t msg4_padding = 0;
+  uint16_t msg4_post_padding = 0;
+  uint16_t msg4_header = 0;
+  
+  int UE_id = find_nr_UE_id_msg4(module_id, ra->rnti);
+
+  if (UE_id < 0) {
+    LOG_E(MAC, "Can't find UE for t-crnti %x, kill RA procedure for this UE\n",
+          ra->rnti);
+    nr_clear_ra_proc(module_id, CC_id, frame);
+    return;
+  }
+
+  if (ra->coreset0_configured == 1) {
+    AssertFatal(1==0,"This is a standalone condition\n");
+  }
+  else { // on configured BWP or initial LDBWP, bandwidth parameters in DCI correspond size of initialBWP
+  
+  }
+
+   gNB_mac->pre_processor_dl(module_id, frame, slot, num_slots_per_tdd, NR_RNTI_TC, UE_id);
+
+ 
+  NR_UE_sched_ctrl_t *sched_ctrl = &UE_info->UE_sched_ctrl[UE_id];
+    if (sched_ctrl->rbSize <= 0)
+    {   // do nothing
+         //continue;
+     }
+    /* POST processing */
+    struct NR_PDSCH_TimeDomainResourceAllocationList *tdaList =
+      sched_ctrl->active_bwp->bwp_Common->pdsch_ConfigCommon->choice.setup->pdsch_TimeDomainAllocationList;
+    AssertFatal(sched_ctrl->time_domain_allocation < tdaList->list.count,
+                "time_domain_allocation %d>=%d\n",
+                sched_ctrl->time_domain_allocation,
+                tdaList->list.count);
+
+    const int startSymbolAndLength =
+      tdaList->list.array[sched_ctrl->time_domain_allocation]->startSymbolAndLength;
+    int startSymbolIndex, nrOfSymbols;
+    SLIV2SL(startSymbolAndLength, &startSymbolIndex, &nrOfSymbols);
+
+    uint8_t N_PRB_DMRS =
+        getN_PRB_DMRS(sched_ctrl->active_bwp, sched_ctrl->numDmrsCdmGrpsNoData);
+    
+    uint8_t N_DMRS_SLOT = get_num_dmrs_symbols(NULL,
+                                               RC.nrmac[module_id]->common_channels->ServingCellConfigCommon->dmrs_TypeA_Position ,
+                                               nrOfSymbols);
+
+
+    const uint32_t TBS =
+        nr_compute_tbs(nr_get_Qm_dl(sched_ctrl->mcs, sched_ctrl->mcsTableIdx),
+                       nr_get_code_rate_dl(sched_ctrl->mcs, sched_ctrl->mcsTableIdx),
+                       sched_ctrl->rbSize,
+                       nrOfSymbols,
+                       N_PRB_DMRS * N_DMRS_SLOT,
+                       0 /* N_PRB_oh, 0 for initialBWP */,
+                       0 /* tb_scaling */,
+                       1 /* nrOfLayers */)
+        >> 3;
+
+    const int current_harq_pid = slot % num_slots_per_tdd;
+    NR_UE_harq_t *harq = &sched_ctrl->harq_processes[current_harq_pid];
+    NR_sched_pucch *pucch = &sched_ctrl->sched_pucch[sched_ctrl->pucch_sched_idx][sched_ctrl->pucch_occ_idx];
+    harq->feedback_slot = pucch->ul_slot;
+    harq->is_waiting = 1;
+    UE_info->mac_stats[UE_id].dlsch_rounds[harq->round]++;
+    ra->harq_pid = current_harq_pid;
+    LOG_I(MAC, "%4d.%2d RNTI %04x start %d RBS %d MCS %d TBS %d HARQ PID %d round %d NDI %d, feedback slot %d, iswaiting %d\n",
+          frame, slot, ra->rnti, sched_ctrl->rbStart, sched_ctrl->rbSize, sched_ctrl->mcs,
+          TBS, current_harq_pid, harq->round, harq->ndi, harq->feedback_slot, harq->is_waiting);
+
+    nfapi_nr_dl_tti_request_body_t *dl_req = &gNB_mac->DL_req[CC_id].dl_tti_request_body;
+    nr_fill_nfapi_dl_pdu(module_id,
+                         dl_req,
+                         ra->rnti,
+                         ra->secondaryCellGroup,
+                         sched_ctrl,
+                         pucch,
+                         getDmrsConfigType(sched_ctrl->active_bwp),
+                         nr_get_code_rate_dl(sched_ctrl->mcs, sched_ctrl->mcsTableIdx),
+                         nr_get_Qm_dl(sched_ctrl->mcs, sched_ctrl->mcsTableIdx),
+                         TBS,
+                         startSymbolIndex,
+                         nrOfSymbols,
+                         current_harq_pid,
+                         harq->ndi,
+                         harq->round,
+                         NR_RNTI_TC);
+
+    NR_UE_ret_info_t *retInfo = &sched_ctrl->retInfo[current_harq_pid];
+    if (harq->round != 0) { /* retransmission */
+      if (sched_ctrl->rbSize != retInfo->rbSize)
+        LOG_W(MAC,
+              "retransmission uses different rbSize (%d vs. orig %d)\n",
+              sched_ctrl->rbSize,
+              retInfo->rbSize);
+      if (sched_ctrl->time_domain_allocation != retInfo->time_domain_allocation)
+        LOG_W(MAC,
+              "retransmission uses different time_domain_allocation (%d vs. orig %d)\n",
+              sched_ctrl->time_domain_allocation,
+              retInfo->time_domain_allocation);
+      if (sched_ctrl->mcs != retInfo->mcs
+          || sched_ctrl->mcsTableIdx != retInfo->mcsTableIdx
+          || sched_ctrl->numDmrsCdmGrpsNoData != retInfo->numDmrsCdmGrpsNoData)
+        LOG_W(MAC,
+              "retransmission uses different table/MCS/numDmrsCdmGrpsNoData (%d/%d/%d vs. orig %d/%d/%d)\n",
+              sched_ctrl->mcsTableIdx,
+              sched_ctrl->mcs,
+              sched_ctrl->numDmrsCdmGrpsNoData,
+              retInfo->mcsTableIdx,
+              retInfo->mcs,
+              retInfo->numDmrsCdmGrpsNoData);
+      /* we do not have to do anything, since we do not require to get data
+       * from RLC, encode MAC CEs, or copy data to FAPI structures */
+      LOG_W(MAC, "%d.%2d retransmission UE %d/RNTI %04x\n", frame, slot, UE_id, ra->rnti);
+            LOG_W(MAC,
+            "%d.%2d DL retransmission UE %d/RNTI %04x HARQ PID %d round %d NDI %d\n",
+            frame,
+            slot,
+            UE_id,
+            ra->rnti,
+            current_harq_pid,
+            harq->round,
+            harq->ndi);
+    } else { /* initial transmission */
+      LOG_D(MAC, "[%s] Initial HARQ transmission in %d.%d\n", __FUNCTION__, frame, slot);
+      /* reserve space for timing advance of UE if necessary,
+       * nr_generate_dlsch_pdu() checks for ta_apply and add TA CE if necessary */
+      const int cont_res_len = 1 + 6;
+      const int ta_len = (sched_ctrl->ta_apply) ? 2 : 0;
+
+      /* Get RLC data TODO: remove random data retrieval */
+      int header_length_total = 0;
+      int header_length_last = 0;
+      int sdu_length_total = 0;
+      int num_sdus = 0;
+      uint16_t sdu_lengths[NB_RB_MAX] = {0};
+      uint8_t mac_sdus[MAX_NR_DLSCH_PAYLOAD_BYTES];
+      unsigned char sdu_lcids[NB_RB_MAX] = {0};
+      const int lcid = DL_SCH_LCID_CCCH;
+      if (sched_ctrl->num_total_bytes > 0) {
+        LOG_I(MAC,
+              "[gNB %d][MSG4] Frame %d : CCCH->DLSCH, Requesting "
+              "%d bytes from RLC (lcid %d total hdr len %d), TBS: %d \n \n",
+              module_id,
+              frame,
+              TBS - ta_len - header_length_total - sdu_length_total - 3,
+              lcid,
+              header_length_total,
+              TBS);
+#if 1
+        // sdu_lengths[num_sdus] = mac_rrc_data_req(module_id, CC_idP, frameP, CCCH,
+        //                                 UE_RNTI(module_idP,UE_id),1,  // 1 transport block
+        //                                 &cc[CC_idP].CCCH_pdu.payload[0], 1);  
+        sdu_lengths[num_sdus] = mac_rrc_nr_data_req(module_id, CC_id, frame, CCCH, ra->rnti, 1,  // 1 transport block
+                                        mac_sdus);  
+
+        LOG_D(MAC,
+              "[gNB %d][USER-PLANE DEFAULT DRB] Got %d bytes for DTCH %d \n",
+              module_id,
+              sdu_lengths[num_sdus],
+              lcid);
+
+        sdu_lcids[num_sdus] = lcid;
+        sdu_length_total += sdu_lengths[num_sdus];
+        header_length_last = 1 + 1 + (sdu_lengths[num_sdus] >= 128);
+        header_length_total += header_length_last;
+
+        num_sdus++;
+#else
+        LOG_I(MAC, "Configuring DL_TX in %d.%d: random data\n", frame, slot);
+        // fill dlsch_buffer with random data       
+        sdu_lcids[0] = lcid; // DRB
+        sdu_lengths[0] = 500; 
+        for (int i = 0; i < sdu_lengths[0]; i++)
+          mac_sdus[i] = (unsigned char) (lrand48()&0xff);
+        sdu_length_total += sdu_lengths[0];
+        header_length_total += 2 + (sdu_lengths[0] >= 128);
+         num_sdus +=1;
+#endif
+        //ue_sched_ctl->uplane_inactivity_timer = 0;
+      }
+
+      UE_info->mac_stats[UE_id].dlsch_total_bytes += TBS;
+      UE_info->mac_stats[UE_id].lc_bytes_tx[lcid] += sdu_length_total;
+
+      // Check if there is data from RLC or CE
+      const int post_padding = TBS > header_length_total + sdu_length_total + cont_res_len;
+
+      LOG_I(MAC, "Configuring DL_TX in %d.%d: TBS %d, header_length_total %d, sdu_length_total %d,cont_res_len %d, post_padding %d \n", frame, slot,
+              TBS , header_length_total , sdu_length_total  ,cont_res_len  , post_padding  );
+      // padding param currently not in use
+      //padding = TBS - header_length_total - sdu_length_total - ta_len - 1;
+
+      const int ntx_req = gNB_mac->TX_req[CC_id].Number_of_PDUs;
+      nfapi_nr_pdu_t *tx_req = &gNB_mac->TX_req[CC_id].pdu_list[ntx_req];
+      /* pointer to directly generate the PDU into the nFAPI structure */
+      uint32_t *buf = tx_req->TLVs[0].value.direct;
+
+      const int offset = nr_generate_dlsch_pdu(
+          module_id,
+          sched_ctrl,
+          (unsigned char *)mac_sdus,
+          (unsigned char *)buf,
+          num_sdus, // num_sdus
+          sdu_lengths,
+          sdu_lcids,
+          255, // no drx
+          ra->cont_res_id, // contention res id
+          post_padding);
+
+      // Padding: fill remainder of DLSCH with 0
+      if (post_padding > 0) {
+        for (int j = 0; j < TBS - offset; j++)
+          buf[offset + j] = 0;
+      }
+
+      /* the buffer has been filled by nr_generate_dlsch_pdu(), below we simply
+       * fill the remaining information */
+      tx_req->PDU_length = TBS;
+      tx_req->PDU_index  = gNB_mac->pdu_index[0]++;
+      tx_req->num_TLV = 1;
+      tx_req->TLVs[0].length = TBS + 2;
+      gNB_mac->TX_req[CC_id].Number_of_PDUs++;
+      gNB_mac->TX_req[CC_id].SFN = frame;
+      gNB_mac->TX_req[CC_id].Slot = slot;
+
+      retInfo->rbSize = sched_ctrl->rbSize;
+      retInfo->time_domain_allocation = sched_ctrl->time_domain_allocation;
+      retInfo->mcsTableIdx = sched_ctrl->mcsTableIdx;
+      retInfo->mcs = sched_ctrl->mcs;
+      retInfo->numDmrsCdmGrpsNoData = sched_ctrl->numDmrsCdmGrpsNoData;
+
+#if defined(ENABLE_MAC_PAYLOAD_DEBUG)
+      if (frame%100 == 0) {
+        LOG_I(MAC,
+              "%d.%d, first 10 payload bytes, TBS size: %d \n",
+              frame,
+              slot,
+              TBS);
+        for(int i = 0; i < 10; i++)
+          LOG_I(MAC, "byte %d: %x\n", i, ((uint8_t *) buf)[i]);
+      }
+#endif
+    }
+    nr_get_retransmission_timing(&ra->Msg4_frame, &ra->Msg4_slot);
+    ra->state = WAIT_Msg4_ACK;
+    LOG_I(MAC, "retrx time for msg4 is %d %d\n", ra->Msg4_frame, ra->Msg4_slot);
+}
+
+void
+nr_check_Msg4_Ack(module_id_t module_id,
+                  int CC_id,
+                 frame_t frame,
+                 sub_frame_t slot,
+                 NR_RA_t *ra,
+                 int num_slots_per_tdd) {
+
+  NR_UE_info_t *UE_info = &RC.nrmac[module_id]->UE_info;
+  int UE_id = find_nr_UE_id_msg4(module_id, ra->rnti);
+  NR_UE_sched_ctrl_t *sched_ctrl = &UE_info->UE_sched_ctrl[UE_id];
+  const int current_harq_pid = ra->harq_pid;
+  NR_UE_harq_t *harq = &sched_ctrl->harq_processes[current_harq_pid];
+
+  LOG_D(MAC, "ue %d, rnti %d, harq is waiting %d, round %d, frame %d %d, harq id %d\n", UE_id, ra->rnti, harq->is_waiting, harq->round, frame, slot, current_harq_pid);
+
+  if (harq->is_waiting == 0)
+  {
+      if ( harq->round == 0)
+      {
+          ra->state = IDLE;
+          UE_info->active[UE_id] = true;
+          free(ra->preambles.preamble_list);
+          LOG_I(MAC, "ue %d, rnti %d is active, frame %d %d\n", UE_id, ra->rnti, frame, slot);
+      }
+      else
+      {
+          ra->state = Msg4;
+      }
+  }  
+}
+
 void nr_clear_ra_proc(module_id_t module_idP, int CC_id, frame_t frameP){
   
   NR_RA_t *ra = &RC.nrmac[module_idP]->common_channels[CC_id].ra[0];

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_bch.c

@@ -114,7 +114,7 @@ void schedule_nr_mib(module_id_t module_idP, frame_t frameP, sub_frame_t slotP,
       dl_tti_request = &gNB->DL_req[CC_id];
       dl_req = &dl_tti_request->dl_tti_request_body;
 
-      mib_sdu_length = mac_rrc_nr_data_req(module_idP, CC_id, frameP, MIBCH, 1, &cc->MIB_pdu.payload[0]);
+      mib_sdu_length = mac_rrc_nr_data_req(module_idP, CC_id, frameP, MIBCH, 0, 1, &cc->MIB_pdu.payload[0]);
 
       LOG_D(MAC, "Frame %d, slot %d: BCH PDU length %d\n", frameP, slotP, mib_sdu_length);
 

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_dlsch.c

@@ -55,7 +55,7 @@
 #define HALFWORD 16
 #define WORD 32
 //#define SIZE_OF_POINTER sizeof (void *)
-
+static boolean_t loop_dcch_dtch = TRUE;
 int nr_generate_dlsch_pdu(module_id_t module_idP,
                           NR_UE_sched_ctrl_t *ue_sched_ctl,
                           unsigned char *sdus_payload,
@@ -375,60 +375,101 @@ uint8_t getN_PRB_DMRS(NR_BWP_Downlink_t *bwp, int numDmrsCdmGrpsNoData) {
 void nr_simple_dlsch_preprocessor(module_id_t module_id,
                                   frame_t frame,
                                   sub_frame_t slot,
-                                  int num_slots_per_tdd) {
+                                  int num_slots_per_tdd,
+                                  int rnti_type,
+                                  int UE_id) {
   NR_UE_info_t *UE_info = &RC.nrmac[module_id]->UE_info;
 
-  AssertFatal(UE_info->num_UEs <= 1,
-              "%s() cannot handle more than one UE, but found %d\n",
-              __func__,
-              UE_info->num_UEs);
-  if (UE_info->num_UEs == 0)
-    return;
-
-  const int UE_id = 0;
   const int CC_id = 0;
-
+  rnti_t rnti;
   NR_UE_sched_ctrl_t *sched_ctrl = &UE_info->UE_sched_ctrl[UE_id];
+  uint16_t Y = 0;
+  int m = 0;
+  int ss_type;
+  int cid;
+  rnti = UE_info->rnti[UE_id];
 
-  /* Retrieve amount of data to send for this UE */
-  sched_ctrl->num_total_bytes = 0;
-  const int lcid = DL_SCH_LCID_DTCH;
-  const rnti_t rnti = UE_info->rnti[UE_id];
-  sched_ctrl->rlc_status[lcid] = mac_rlc_status_ind(module_id,
-                                                    rnti,
-                                                    module_id,
-                                                    frame,
-                                                    slot,
-                                                    ENB_FLAG_YES,
-                                                    MBMS_FLAG_NO,
-                                                    lcid,
-                                                    0,
-                                                    0);
-  sched_ctrl->num_total_bytes += sched_ctrl->rlc_status[lcid].bytes_in_buffer;
-  if (sched_ctrl->num_total_bytes == 0
+  if (rnti_type == NR_RNTI_C)
+  {
+    /* Retrieve amount of data to send for this UE */
+    sched_ctrl->num_total_bytes = 0;
+    loop_dcch_dtch = BOOL_NOT(loop_dcch_dtch);
+    const int lcid = loop_dcch_dtch?DL_SCH_LCID_DTCH:DL_SCH_LCID_DCCH;
+    sched_ctrl->rlc_status[lcid] = mac_rlc_status_ind(module_id,
+                                                      rnti,
+                                                      module_id,
+                                                      frame,
+                                                      slot,
+                                                      ENB_FLAG_YES,
+                                                      MBMS_FLAG_NO,
+                                                      lcid,
+                                                      0,
+                                                      0);
+    sched_ctrl->num_total_bytes += sched_ctrl->rlc_status[lcid].bytes_in_buffer;
+  LOG_I(MAC,
+        "%d.%d, LCID%d:->DLSCH, RLC status %d bytes. \n",
+        frame,
+        slot,
+        lcid,
+        sched_ctrl->num_total_bytes);  
+
+    if (sched_ctrl->num_total_bytes == 0
       && !sched_ctrl->ta_apply) /* If TA should be applied, give at least one RB */
     return;
 
-  LOG_D(MAC, "[%s][%d.%d], DTCH%d->DLSCH, RLC status %d bytes TA %d\n",
+    LOG_D(MAC, "[%s][%d.%d], DTCH%d->DLSCH, RLC status %d bytes TA %d\n",
         __FUNCTION__,
         frame,
         slot,
         lcid,
         sched_ctrl->rlc_status[lcid].bytes_in_buffer,
         sched_ctrl->ta_apply);
+    ss_type = 1; // UE_Specific
+    const int target_ss = NR_SearchSpace__searchSpaceType_PR_ue_Specific;
+ 
+    sched_ctrl->search_space = get_searchspace(sched_ctrl->active_bwp, target_ss);
+    sched_ctrl->coreset = get_coreset(sched_ctrl->active_bwp, sched_ctrl->search_space, ss_type);
 
+    cid = sched_ctrl->coreset->controlResourceSetId;
+    Y = UE_info->Y[UE_id][cid][slot];
+    m = UE_info->num_pdcch_cand[UE_id][cid];
+  }
+  else if (rnti_type == NR_RNTI_TC)
+  { 
+    gNB_MAC_INST                      *nr_mac = RC.nrmac[module_id];
+    NR_COMMON_channels_t                  *cc = &nr_mac->common_channels[CC_id];
+    NR_RA_t *ra = &cc->ra[0];
+    /*
+    rrc_sdu_length = mac_rrc_data_req(module_idP, CC_idP, frameP, CCCH,
+                                          UE_RNTI(module_idP,UE_id),1,  // 1 transport block
+                                          &cc[CC_idP].CCCH_pdu.payload[0], 0);  // not used in this case
+    */
+    int rrc_sdu_length = 500;
+    sched_ctrl->num_total_bytes += rrc_sdu_length;
+    if (sched_ctrl->num_total_bytes == 0)
+    return;
+    LOG_D(MAC,
+              "[gNB %d][RAPROC] CC_id %d Frame %d, slot %d: UE_id %d, rrc_sdu_length %d\n",
+              module_id, CC_id, frame, slot, UE_id, rrc_sdu_length);
+    sched_ctrl->search_space = ra->ra_ss;
+    ss_type = 0; // Common
+    sched_ctrl->coreset = get_coreset(sched_ctrl->active_bwp, sched_ctrl->search_space, ss_type);
+    cid = sched_ctrl->coreset->controlResourceSetId;
+    rnti = ra->rnti;
+  }
+  else
+  {
+    return;
+  }
+  
+   
   /* Find a free CCE */
-  const int target_ss = NR_SearchSpace__searchSpaceType_PR_ue_Specific;
-  sched_ctrl->search_space = get_searchspace(sched_ctrl->active_bwp, target_ss);
+
   uint8_t nr_of_candidates;
   find_aggregation_candidates(&sched_ctrl->aggregation_level,
                               &nr_of_candidates,
                               sched_ctrl->search_space);
-  sched_ctrl->coreset = get_coreset(
-      sched_ctrl->active_bwp, sched_ctrl->search_space, 1 /* dedicated */);
-  int cid = sched_ctrl->coreset->controlResourceSetId;
-  const uint16_t Y = UE_info->Y[UE_id][cid][slot];
-  const int m = UE_info->num_pdcch_cand[UE_id][cid];
+
   sched_ctrl->cce_index = allocate_nr_CCEs(RC.nrmac[module_id],
                                            sched_ctrl->active_bwp,
                                            sched_ctrl->coreset,
@@ -436,6 +477,9 @@ void nr_simple_dlsch_preprocessor(module_id_t module_id,
                                            Y,
                                            m,
                                            nr_of_candidates);
+
+  LOG_D(PHY, "simple: frame %d %d, rnti %d, cce index %d, ss_type %d, ue is active %d\n",  frame,
+                        slot, rnti, sched_ctrl->cce_index, ss_type, UE_info->active[UE_id]);                                         
   if (sched_ctrl->cce_index < 0) {
     LOG_E(MAC, "%s(): could not find CCE for UE %d\n", __func__, UE_id);
     return;
@@ -449,7 +493,8 @@ void nr_simple_dlsch_preprocessor(module_id_t module_id,
                         slot,
                         num_slots_per_tdd,
                         &sched_ctrl->pucch_sched_idx,
-                        &sched_ctrl->pucch_occ_idx);
+                        &sched_ctrl->pucch_occ_idx,
+                        ss_type);
 
   AssertFatal(sched_ctrl->pucch_sched_idx >= 0, "no uplink slot for PUCCH found!\n");
 
@@ -496,7 +541,7 @@ void nr_simple_dlsch_preprocessor(module_id_t module_id,
     // modulation scheme
     sched_ctrl->mcsTableIdx = 0;
     sched_ctrl->mcs = 9;
-    sched_ctrl->numDmrsCdmGrpsNoData = 1;
+    sched_ctrl->numDmrsCdmGrpsNoData = (ss_type == 1)? 1 : 2;
 
     // Freq-demain allocation
     while (rbStart < bwpSize && vrb_map[rbStart]) rbStart++;
@@ -505,13 +550,22 @@ void nr_simple_dlsch_preprocessor(module_id_t module_id,
         getN_PRB_DMRS(sched_ctrl->active_bwp, sched_ctrl->numDmrsCdmGrpsNoData);
     int nrOfSymbols = getNrOfSymbols(sched_ctrl->active_bwp,
                                      sched_ctrl->time_domain_allocation);
-    uint8_t N_DMRS_SLOT = get_num_dmrs_symbols(sched_ctrl->active_bwp->bwp_Dedicated->pdsch_Config->choice.setup,
+    uint8_t N_DMRS_SLOT = get_num_dmrs_symbols((ss_type == 1)? sched_ctrl->active_bwp->bwp_Dedicated->pdsch_Config->choice.setup : NULL,
                                                RC.nrmac[module_id]->common_channels->ServingCellConfigCommon->dmrs_TypeA_Position ,
                                                nrOfSymbols);
 
     int rbSize = 0;
-    const int oh = 2 + (sched_ctrl->num_total_bytes >= 256)
-                 + 2 * (frame == (sched_ctrl->ta_frame + 10) % 1024);
+    int oh;
+    if (rnti_type == NR_RNTI_C)
+    {
+        oh = 2 + (sched_ctrl->num_total_bytes >= 256)
+                       + 2 * (frame == (sched_ctrl->ta_frame + 10) % 1024);
+    }
+    else 
+    {   // NR_RNTI_TC, msg4
+        oh = 2 + (sched_ctrl->num_total_bytes >= 256)
+                 + 1 + 6; // UE Contention Resolution Identity CE
+    }
     uint32_t TBS = 0;
     do {
       rbSize++;
@@ -540,16 +594,20 @@ void nr_schedule_ue_spec(module_id_t module_id,
                          int num_slots_per_tdd) {
   gNB_MAC_INST *gNB_mac = RC.nrmac[module_id];
 
-  /* PREPROCESSOR */
-  gNB_mac->pre_processor_dl(module_id, frame, slot, num_slots_per_tdd);
 
   NR_UE_info_t *UE_info = &gNB_mac->UE_info;
 
   const int CC_id = 0;
   NR_UE_list_t *UE_list = &UE_info->list;
   for (int UE_id = UE_list->head; UE_id >= 0; UE_id = UE_list->next[UE_id]) {
+    
+    if (!UE_info->active[UE_id])
+       continue;
     NR_UE_sched_ctrl_t *sched_ctrl = &UE_info->UE_sched_ctrl[UE_id];
 
+      /* PREPROCESSOR */
+    gNB_mac->pre_processor_dl(module_id, frame, slot, num_slots_per_tdd, NR_RNTI_C, UE_id);
+
     /* update TA and set ta_apply every 10 frames.
      * Possible improvement: take the periodicity from input file.
      * If such UE is not scheduled now, it will be by the preprocessor later.
@@ -620,7 +678,8 @@ void nr_schedule_ue_spec(module_id_t module_id,
                          nrOfSymbols,
                          current_harq_pid,
                          harq->ndi,
-                         harq->round);
+                         harq->round,
+                         NR_RNTI_C);
 
     NR_UE_ret_info_t *retInfo = &sched_ctrl->retInfo[current_harq_pid];
     if (harq->round != 0) { /* retransmission */
@@ -671,7 +730,7 @@ void nr_schedule_ue_spec(module_id_t module_id,
       uint16_t sdu_lengths[NB_RB_MAX] = {0};
       uint8_t mac_sdus[MAX_NR_DLSCH_PAYLOAD_BYTES];
       unsigned char sdu_lcids[NB_RB_MAX] = {0};
-      const int lcid = DL_SCH_LCID_DTCH;
+      const int lcid = loop_dcch_dtch?DL_SCH_LCID_DTCH:DL_SCH_LCID_DCCH;
       if (sched_ctrl->num_total_bytes > 0) {
         /* this is the data from the RLC we would like to request (e.g., only
          * some bytes for first LC and some more from a second one */
@@ -712,7 +771,7 @@ void nr_schedule_ue_spec(module_id_t module_id,
         header_length_total += header_length_last;
         num_sdus++;
       }
-      else if (get_softmodem_params()->phy_test || get_softmodem_params()->do_ra) {
+      else if (get_softmodem_params()->phy_test || get_softmodem_params()->do_ra || get_softmodem_params()->sa_ra) {
         LOG_D(MAC, "Configuring DL_TX in %d.%d: random data\n", frame, slot);
         // fill dlsch_buffer with random data
         for (int i = 0; i < TBS; i++)

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_phytest.c

@@ -334,7 +334,8 @@ void nr_preprocessor_phytest(module_id_t module_id,
                         slot,
                         num_slots_per_tdd,
                         &sched_ctrl->pucch_sched_idx,
-                        &sched_ctrl->pucch_occ_idx);
+                        &sched_ctrl->pucch_occ_idx,
+                        1);
   AssertFatal(sched_ctrl->pucch_sched_idx >= 0, "no uplink slot for PUCCH found!\n");
 
   sched_ctrl->rbStart = rbStart;

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

@@ -510,7 +510,8 @@ void nr_fill_nfapi_dl_pdu(int Mod_idP,
                           int NrOfSymbols,
                           int harq_pid,
                           int ndi,
-                          int round) {
+                          int round,
+                          int rnit_type) {
   gNB_MAC_INST                        *nr_mac  = RC.nrmac[Mod_idP];
   NR_COMMON_channels_t                *cc      = nr_mac->common_channels;
   NR_ServingCellConfigCommon_t        *scc     = cc->ServingCellConfigCommon;
@@ -604,22 +605,35 @@ void nr_fill_nfapi_dl_pdu(int Mod_idP,
   dci_pdu_rel15_t dci_pdu_rel15[MAX_DCI_CORESET];
   memset(dci_pdu_rel15, 0, sizeof(dci_pdu_rel15_t) * MAX_DCI_CORESET);
 
-  // bwp indicator
-  int n_dl_bwp = secondaryCellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.count;
-  if (n_dl_bwp < 4)
-    dci_pdu_rel15[0].bwp_indicator.val = bwp_id;
+  if (rnit_type == NR_RNTI_C)
+  {
+    // bwp indicator
+    int n_dl_bwp = secondaryCellGroup->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.count;
+    if (n_dl_bwp < 4)
+      dci_pdu_rel15[0].bwp_indicator.val = bwp_id;
+    else
+      dci_pdu_rel15[0].bwp_indicator.val = bwp_id - 1; // as per table 7.3.1.1.2-1 in 38.212
+    // frequency domain assignment
+    if (bwp->bwp_Dedicated->pdsch_Config->choice.setup->resourceAllocation==NR_PDSCH_Config__resourceAllocation_resourceAllocationType1)
+      dci_pdu_rel15[0].frequency_domain_assignment.val =
+          PRBalloc_to_locationandbandwidth0(
+              pdsch_pdu_rel15->rbSize,
+              pdsch_pdu_rel15->rbStart,
+              NRRIV2BW(bwp->bwp_Common->genericParameters.locationAndBandwidth,
+                      275));
+    else
+      AssertFatal(1==0,"Only frequency resource allocation type 1 is currently supported\n");
+  }
   else
-    dci_pdu_rel15[0].bwp_indicator.val = bwp_id - 1; // as per table 7.3.1.1.2-1 in 38.212
-  // frequency domain assignment
-  if (bwp->bwp_Dedicated->pdsch_Config->choice.setup->resourceAllocation==NR_PDSCH_Config__resourceAllocation_resourceAllocationType1)
+  {
     dci_pdu_rel15[0].frequency_domain_assignment.val =
         PRBalloc_to_locationandbandwidth0(
             pdsch_pdu_rel15->rbSize,
             pdsch_pdu_rel15->rbStart,
-            NRRIV2BW(bwp->bwp_Common->genericParameters.locationAndBandwidth,
+            NRRIV2BW(scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters.locationAndBandwidth, //bwp->bwp_Common->genericParameters.locationAndBandwidth,
                      275));
-  else
-    AssertFatal(1==0,"Only frequency resource allocation type 1 is currently supported\n");
+
+  }
   // time domain assignment: row index used instead of SLIV
   dci_pdu_rel15[0].time_domain_assignment.val = sched_ctrl->time_domain_allocation;
   // mcs and rv
@@ -661,21 +675,21 @@ void nr_fill_nfapi_dl_pdu(int Mod_idP,
                      sched_ctrl->search_space,
                      sched_ctrl->coreset,
                      scc,
-                     bwp,
+                     (rnit_type == NR_RNTI_TC) ? NULL:bwp,
                      sched_ctrl->aggregation_level,
                      sched_ctrl->cce_index);
 
   int dci_formats[2];
   int rnti_types[2];
 
-  if (sched_ctrl->search_space->searchSpaceType->choice.ue_Specific->dci_Formats)
+  if ((rnit_type == NR_RNTI_C) &&  (sched_ctrl->search_space->searchSpaceType->choice.ue_Specific->dci_Formats))
     dci_formats[0]  = NR_DL_DCI_FORMAT_1_1;
   else
     dci_formats[0]  = NR_DL_DCI_FORMAT_1_0;
 
-  rnti_types[0]   = NR_RNTI_C;
+  rnti_types[0]   = rnit_type;
 
-  fill_dci_pdu_rel15(scc,secondaryCellGroup,pdcch_pdu_rel15,dci_pdu_rel15,dci_formats,rnti_types,pdsch_pdu_rel15->BWPSize,bwp_id);
+  fill_dci_pdu_rel15(scc,secondaryCellGroup,pdcch_pdu_rel15,dci_pdu_rel15,dci_formats,rnti_types,pdcch_pdu_rel15->BWPSize,bwp_id);
 
   LOG_D(MAC,
         "DCI params: rnti %x, rnti_type %d, dci_format %d\n",
@@ -683,10 +697,12 @@ void nr_fill_nfapi_dl_pdu(int Mod_idP,
         rnti_types[0],
         dci_formats[0]);
   LOG_D(MAC,
-        "coreset params: FreqDomainResource %llx, start_symbol %d  n_symb %d\n",
+        "coreset params: FreqDomainResource %llx, start_symbol %d  n_symb %d, BWP %d %d\n",
         (unsigned long long)pdcch_pdu_rel15->FreqDomainResource,
         pdcch_pdu_rel15->StartSymbolIndex,
-        pdcch_pdu_rel15->DurationSymbols);
+        pdcch_pdu_rel15->DurationSymbols,
+        pdcch_pdu_rel15->BWPSize,
+        pdcch_pdu_rel15->BWPStart);
 
   LOG_D(MAC,
         "DLSCH PDU: start PRB %d n_PRB %d start symbol %d nb_symbols %d "
@@ -701,6 +717,7 @@ void nr_fill_nfapi_dl_pdu(int Mod_idP,
         TBS);
 
   dl_req->nPDUs += 2;
+
 }
 
 void config_uldci(NR_BWP_Uplink_t *ubwp,
@@ -787,6 +804,7 @@ void nr_configure_pdcch(gNB_MAC_INST *nr_mac,
                         NR_BWP_Downlink_t *bwp,
                         uint8_t aggregation_level,
                         int CCEIndex) {
+  int sps;
   if (bwp) { // This is not the InitialBWP
     pdcch_pdu->BWPSize  = NRRIV2BW(bwp->bwp_Common->genericParameters.locationAndBandwidth,275);
     pdcch_pdu->BWPStart = NRRIV2PRBOFFSET(bwp->bwp_Common->genericParameters.locationAndBandwidth,275);
@@ -795,8 +813,20 @@ void nr_configure_pdcch(gNB_MAC_INST *nr_mac,
 
     // first symbol
     //AssertFatal(pdcch_scs==kHz15, "PDCCH SCS above 15kHz not allowed if a symbol above 2 is monitored");
-    int sps = bwp->bwp_Common->genericParameters.cyclicPrefix == NULL ? 14 : 12;
+    sps = bwp->bwp_Common->genericParameters.cyclicPrefix == NULL ? 14 : 12;
+  }
+  else 
+  {  // This is not the InitialBWP
+    pdcch_pdu->BWPSize  = NRRIV2BW(scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters.locationAndBandwidth,275);
+    pdcch_pdu->BWPStart = NRRIV2PRBOFFSET(scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters.locationAndBandwidth,275);
+    pdcch_pdu->SubcarrierSpacing = scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters.subcarrierSpacing;
+    pdcch_pdu->CyclicPrefix = (scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters.cyclicPrefix==NULL) ? 0 : scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters.cyclicPrefix;
+    LOG_I(PHY, "initial dl bwp %d %d (%d)\n", pdcch_pdu->BWPSize, pdcch_pdu->BWPStart, scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters.locationAndBandwidth);
+    // first symbol
+    //AssertFatal(pdcch_scs==kHz15, "PDCCH SCS above 15kHz not allowed if a symbol above 2 is monitored");
+    sps = scc->downlinkConfigCommon->initialDownlinkBWP->genericParameters.cyclicPrefix == NULL ? 14 : 12;
 
+  }
     AssertFatal(ss->monitoringSymbolsWithinSlot!=NULL,"ss->monitoringSymbolsWithinSlot is null\n");
     AssertFatal(ss->monitoringSymbolsWithinSlot->buf!=NULL,"ss->monitoringSymbolsWithinSlot->buf is null\n");
     
@@ -858,10 +888,8 @@ void nr_configure_pdcch(gNB_MAC_INST *nr_mac,
 
     pdcch_pdu->dci_pdu.powerControlOffsetSS[pdcch_pdu->numDlDci]=1;
     pdcch_pdu->numDlDci++;
-  }
-  else { // this is for InitialBWP
-    AssertFatal(1==0,"Fill in InitialBWP PDCCH configuration\n");
-  }
+  
+
 }
 
 
@@ -1347,47 +1375,72 @@ void fill_dci_pdu_rel15(NR_ServingCellConfigCommon_t *scc,
 	
 	break;
 	
-      case NR_RNTI_TC:
+  case NR_RNTI_TC:
+  dci_pdu_rel15->format_indicator = 1;
 	// indicating a DL DCI format 1bit
-	*dci_pdu |= ((uint64_t)dci_pdu_rel15->format_indicator&1)<<(dci_size-pos++);
+
+  pos=1;
+  *dci_pdu |= ((uint64_t)dci_pdu_rel15->format_indicator&0x1)<<(dci_size-pos);
+  LOG_D(MAC,"format indicator %d (%d bits)=> %d (0x%lx), dci size %d\n",dci_pdu_rel15->format_indicator,1,dci_size-pos,*dci_pdu, dci_size);
+  
 	// Freq domain assignment 0-16 bit
-	fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
-	for (int i=0; i<fsize; i++)
-	  *dci_pdu |= (((uint64_t)dci_pdu_rel15->frequency_domain_assignment.val>>(fsize-i-1))&1)<<(dci_size-pos++);
+ 	fsize = (int)ceil( log2( (N_RB*(N_RB+1))>>1 ) );
+  pos += fsize;
+  *dci_pdu |= ((uint64_t)dci_pdu_rel15->frequency_domain_assignment.val&((1<<fsize)-1)) << (dci_size-pos);
+	LOG_D(MAC,"Freq domain assignment %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->frequency_domain_assignment.val,fsize,dci_size-pos,*dci_pdu);
+
 	// Time domain assignment 4 bit
-	for (int i=0; i<4; i++)
-	  *dci_pdu |= (((uint64_t)dci_pdu_rel15->time_domain_assignment.val>>(3-i))&1)<<(dci_size-pos++);
-	// VRB to PRB mapping 1 bit
-	*dci_pdu |= ((uint64_t)dci_pdu_rel15->vrb_to_prb_mapping.val&1)<<(dci_size-pos++);
-	// MCS 5bit  //bit over 32, so dci_pdu ++
-	for (int i=0; i<5; i++)
-	  *dci_pdu |= (((uint64_t)dci_pdu_rel15->mcs>>(4-i))&1)<<(dci_size-pos++);
+  pos += 4;
+  *dci_pdu |= ((uint64_t)dci_pdu_rel15->time_domain_assignment.val&0xf) << (dci_size-pos);
+  LOG_D(MAC,"Time domain assignment %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->time_domain_assignment.val,4,dci_size-pos,*dci_pdu);
+	
+  // VRB to PRB mapping 1 bit
+  pos += 1;
+	*dci_pdu |= ((uint64_t)dci_pdu_rel15->vrb_to_prb_mapping.val&1)<<(dci_size-pos);
+  LOG_D(MAC,"VRB to PRB %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->vrb_to_prb_mapping.val,1,dci_size-pos,*dci_pdu);
+	
+  // MCS 5bit  //bit over 32, so dci_pdu ++
+	pos+=5;
+	*dci_pdu |= ((uint64_t)dci_pdu_rel15->mcs&0x1f)<<(dci_size-pos);
+  LOG_D(MAC,"MCS %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->mcs,5,dci_size-pos,*dci_pdu);
+
 	// New data indicator 1bit
-	*dci_pdu |= ((uint64_t)dci_pdu_rel15->ndi&1)<<(dci_size-pos++);
+  pos += 1;
+	*dci_pdu |= ((uint64_t)dci_pdu_rel15->ndi&1)<<(dci_size-pos);
+  LOG_D(MAC,"NDI %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->ndi,1,dci_size-pos,*dci_pdu);
+
 	// Redundancy version  2bit
-	for (int i=0; i<2; i++)
-	  *dci_pdu |= (((uint64_t)dci_pdu_rel15->rv>>(1-i))&1)<<(dci_size-pos++);
+	pos += 2;
+	*dci_pdu |= ((uint64_t)dci_pdu_rel15->rv&0x3)<<(dci_size-pos);
+  LOG_D(MAC,"RV %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->rv,2,dci_size-pos,*dci_pdu);
+
 	// HARQ process number  4bit
-	for (int i=0; i<4; i++)
-	  *dci_pdu  |= (((uint64_t)dci_pdu_rel15->harq_pid>>(3-i))&1)<<(dci_size-pos++);
-	
-	// Downlink assignment index – 2 bits
-	for (int i=0; i<2; i++)
-	  *dci_pdu  |= (((uint64_t)dci_pdu_rel15->dai[0].val>>(1-i))&1)<<(dci_size-pos++);
+	pos += 4;
+	*dci_pdu  |= ((uint64_t)dci_pdu_rel15->harq_pid&0xf)<<(dci_size-pos);
+	LOG_D(MAC,"HARQ_PID %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->harq_pid,4,dci_size-pos,*dci_pdu);
 	
+  // Downlink assignment index – 2 bits
+	pos += 2;
+	*dci_pdu  |= ((uint64_t)dci_pdu_rel15->dai[0].val&0x3)<<(dci_size-pos);
+	LOG_D(MAC,"DAI %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->dai[0].val,2,dci_size-pos,*dci_pdu);
+
 	// TPC command for scheduled PUCCH – 2 bits
-	for (int i=0; i<2; i++)
-	  *dci_pdu  |= (((uint64_t)dci_pdu_rel15->tpc>>(1-i))&1)<<(dci_size-pos++);
-	
+	pos += 2;
+	*dci_pdu  |= ((uint64_t)dci_pdu_rel15->tpc&0x3)<<(dci_size-pos);
+	LOG_D(MAC,"TPC %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->tpc,2,dci_size-pos,*dci_pdu);
 	
 	//      LOG_D(MAC, "DCI PDU: [0]->0x%08llx \t [1]->0x%08llx \t [2]->0x%08llx \t [3]->0x%08llx\n",
 	//	    dci_pdu[0], dci_pdu[1], dci_pdu[2], dci_pdu[3]);
 	
-	
+	// pucch_resource_indicator – 3 bits
+	pos += 3;
+	*dci_pdu  |= ((uint64_t)dci_pdu_rel15->pucch_resource_indicator&0x7)<<(dci_size-pos);
+	LOG_D(MAC,"pucch_resource_indicator %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->pucch_resource_indicator,3,dci_size-pos,*dci_pdu);
+
 	// PDSCH-to-HARQ_feedback timing indicator – 3 bits
-	for (int i=0; i<3; i++)
-	  *dci_pdu  |= (((uint64_t)dci_pdu_rel15->pdsch_to_harq_feedback_timing_indicator.val>>(2-i))&1)<<(dci_size-pos++);
-	
+	pos += 3;
+	*dci_pdu  |= ((uint64_t)dci_pdu_rel15->pdsch_to_harq_feedback_timing_indicator.val&0x7)<<(dci_size-pos);
+	LOG_D(MAC,"PDSCH to HARQ TI %d (%d bits)=> %d (0x%lx)\n",dci_pdu_rel15->pdsch_to_harq_feedback_timing_indicator.val,3,dci_size-pos,*dci_pdu);
 	break;
       }
       break;
@@ -1787,7 +1840,8 @@ int find_nr_UE_id(module_id_t mod_idP, rnti_t rntiP)
   NR_UE_info_t *UE_info = &RC.nrmac[mod_idP]->UE_info;
 
   for (UE_id = 0; UE_id < MAX_MOBILES_PER_GNB; UE_id++) {
-    if (UE_info->active[UE_id]) {
+    //if (UE_info->active[UE_id]) 
+    {
       if (UE_info->rnti[UE_id] == rntiP) {
         return UE_id;
       }
@@ -1797,6 +1851,24 @@ int find_nr_UE_id(module_id_t mod_idP, rnti_t rntiP)
   return -1;
 }
 
+int find_nr_UE_id_msg4(module_id_t mod_idP, rnti_t rntiP)
+//------------------------------------------------------------------------------
+{
+  int UE_id;
+  NR_UE_info_t *UE_info = &RC.nrmac[mod_idP]->UE_info;
+
+  for (UE_id = 0; UE_id < MAX_MOBILES_PER_GNB; UE_id++) {
+    if (!UE_info->active[UE_id]) {
+      if (UE_info->rnti[UE_id] == rntiP) {
+        return UE_id;
+      }
+    }
+  }
+
+  return -1;
+}
+
+
 void set_Y(int Y[3][160], rnti_t rnti) {
   const int A[3] = {39827, 39829, 39839};
   const int D = 65537;
@@ -1831,7 +1903,7 @@ int find_nr_RA_id(module_id_t mod_idP, int CC_idP, rnti_t rntiP) {
 }
 
 //------------------------------------------------------------------------------
-int add_new_nr_ue(module_id_t mod_idP, rnti_t rntiP){
+int add_new_nr_ue(module_id_t mod_idP, rnti_t rntiP, bool isActive){
 
   NR_UE_info_t *UE_info = &RC.nrmac[mod_idP]->UE_info;
   NR_COMMON_channels_t *cc = RC.nrmac[mod_idP]->common_channels;
@@ -1839,10 +1911,11 @@ int add_new_nr_ue(module_id_t mod_idP, rnti_t rntiP){
   int num_slots_ul = scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofUplinkSlots;
   if (scc->tdd_UL_DL_ConfigurationCommon->pattern1.nrofUplinkSymbols>0)
     num_slots_ul++;
-  LOG_W(MAC, "[gNB %d] Adding UE with rnti %x (num_UEs %d)\n",
+  LOG_W(MAC, "[gNB %d] Adding UE with rnti %x (num_UEs %d), isActive %d\n",
         mod_idP,
         rntiP,
-        UE_info->num_UEs);
+        UE_info->num_UEs,
+        isActive);
   dump_nr_ue_list(&UE_info->list);
 
   for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
@@ -1851,7 +1924,7 @@ int add_new_nr_ue(module_id_t mod_idP, rnti_t rntiP){
 
     int UE_id = i;
     UE_info->num_UEs++;
-    UE_info->active[UE_id] = true;
+    UE_info->active[UE_id] = isActive;
     UE_info->rnti[UE_id] = rntiP;
     add_nr_ue_list(&UE_info->list, UE_id);
     set_Y(UE_info->Y[UE_id], rntiP);

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c

@@ -40,8 +40,10 @@ void nr_schedule_pucch(int Mod_idP,
                        frame_t frameP,
                        sub_frame_t slotP) {
   NR_UE_info_t *UE_info = &RC.nrmac[Mod_idP]->UE_info;
-  AssertFatal(UE_info->active[UE_id],"Cannot find UE_id %d is not active\n",UE_id);
-
+  //AssertFatal(UE_info->active[UE_id],"Cannot find UE_id %d is not active\n",UE_id);
+  if (UE_info->active[UE_id] <= 0)
+      LOG_D(MAC, "Cannot find UE_id %d is not active\n",UE_id);
+  
   for (int k=0; k<nr_ulmix_slots; k++) {
     for (int l=0; l<2; l++) {
       NR_sched_pucch *curr_pucch = &UE_info->UE_sched_ctrl[UE_id].sched_pucch[k][l];
@@ -280,6 +282,8 @@ void handle_nr_uci_pucch_0_1(module_id_t mod_id,
                              const nfapi_nr_uci_pucch_pdu_format_0_1_t *uci_01)
 {
   int UE_id = find_nr_UE_id(mod_id, uci_01->rnti);
+  
+  LOG_D(MAC, "handle_nr_uci_pucch_0_1, ue id %d, rnti %d\n", UE_id, uci_01->rnti);
   if (UE_id < 0) {
     LOG_E(MAC, "%s(): unknown RNTI %04x in PUCCH UCI\n", __func__, uci_01->rnti);
     return;
@@ -314,6 +318,10 @@ void handle_nr_uci_pucch_0_1(module_id_t mod_id,
           else
             sched_ctrl->harq_processes[harq_idx].round++;
           sched_ctrl->harq_processes[harq_idx].is_waiting = 0;
+          LOG_D(MAC, "%s():  RNTI %04x in PUCCH UCI, harq bit %d, idx %d, feedbanck slot %d, round %d, harq value %d, confidence %d\n", __func__, uci_01->rnti,
+          harq_bit, harq_idx, sched_ctrl->harq_processes[harq_idx].feedback_slot, sched_ctrl->harq_processes[harq_idx].round,
+          uci_01->harq->harq_list[harq_bit].harq_value,
+          uci_01->harq->harq_confidence_level);
           harq_idx_s = harq_idx + 1;
           // if the max harq rounds was reached
           if (sched_ctrl->harq_processes[harq_idx].round == max_harq_rounds) {
@@ -334,6 +342,10 @@ void handle_nr_uci_pucch_0_1(module_id_t mod_id,
             sched_ctrl->harq_processes[harq_idx].round = 0;
           }
           sched_ctrl->harq_processes[harq_idx].is_waiting = 0;
+          LOG_D(MAC, "%s():  RNTI %04x in PUCCH UCI, harq bit %d, idx %d, feedbanck slot %d, round %d, harq value %d, confidence %d\n", __func__, uci_01->rnti,
+          harq_bit, harq_idx, sched_ctrl->harq_processes[harq_idx].feedback_slot, sched_ctrl->harq_processes[harq_idx].round,
+          uci_01->harq->harq_list[harq_bit].harq_value,
+          uci_01->harq->harq_confidence_level);          
         }
       }
     }
@@ -380,6 +392,10 @@ void handle_nr_uci_pucch_2_3_4(module_id_t mod_id,
           else
             sched_ctrl->harq_processes[harq_idx].round++;
           sched_ctrl->harq_processes[harq_idx].is_waiting = 0;
+          LOG_D(MAC, "%s():  RNTI %04x in PUCCH UCI, harq bit %d, idx %d, feedbanck slot %d, round %d, harq crc %d, acknack %d\n", __func__, uci_234->rnti,
+          harq_bit, harq_idx, sched_ctrl->harq_processes[harq_idx].feedback_slot, sched_ctrl->harq_processes[harq_idx].round,
+          uci_234->harq.harq_crc,
+          acknack);          
           harq_idx_s = harq_idx + 1;
           // if the max harq rounds was reached
           if (sched_ctrl->harq_processes[harq_idx].round == max_harq_rounds) {
@@ -400,6 +416,10 @@ void handle_nr_uci_pucch_2_3_4(module_id_t mod_id,
             sched_ctrl->harq_processes[harq_idx].round = 0;
           }
           sched_ctrl->harq_processes[harq_idx].is_waiting = 0;
+          LOG_D(MAC, "%s():  RNTI %04x in PUCCH UCI, harq bit %d, idx %d, feedbanck slot %d, round %d, harq crc %d, acknack %d\n", __func__, uci_234->rnti,
+          harq_bit, harq_idx, sched_ctrl->harq_processes[harq_idx].feedback_slot, sched_ctrl->harq_processes[harq_idx].round,
+          uci_234->harq.harq_crc,
+          acknack);           
         }
       }
     }
@@ -414,7 +434,8 @@ void nr_acknack_scheduling(int Mod_idP,
                            sub_frame_t slotP,
                            int slots_per_tdd,
                            int *pucch_id,
-                           int *pucch_occ) {
+                           int *pucch_occ,
+                           int isUEspec) {
 
   NR_ServingCellConfigCommon_t *scc = RC.nrmac[Mod_idP]->common_channels->ServingCellConfigCommon;
   NR_UE_info_t *UE_info = &RC.nrmac[Mod_idP]->UE_info;
@@ -440,7 +461,15 @@ void nr_acknack_scheduling(int Mod_idP,
     max_acknacks=2;
 
   // this is hardcoded for now as ue specific
-  NR_SearchSpace__searchSpaceType_PR ss_type = NR_SearchSpace__searchSpaceType_PR_ue_Specific;
+  NR_SearchSpace__searchSpaceType_PR ss_type;
+  if( isUEspec == 1)
+  {
+      ss_type = NR_SearchSpace__searchSpaceType_PR_ue_Specific;
+  }
+  else
+  {
+      ss_type = NR_SearchSpace__searchSpaceType_PR_common;
+  }
   get_pdsch_to_harq_feedback(Mod_idP,UE_id,ss_type,pdsch_to_harq_feedback);
 
   // for each possible ul or mixed slot

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c

@@ -179,11 +179,7 @@ void nr_process_mac_pdu(
         	//  end of MAC PDU, can ignore the rest.
         	break;
 
-        // MAC SDUs
-        case UL_SCH_LCID_SRB1:
-              // todo
-              break;
-        case UL_SCH_LCID_SRB2:
+       case UL_SCH_LCID_SRB2:
               // todo
               break;
         case UL_SCH_LCID_SRB3:
@@ -195,8 +191,21 @@ void nr_process_mac_pdu(
         case UL_SCH_LCID_CCCH:
               // todo
               mac_subheader_len = 2;
+               nr_mac_rrc_data_ind(module_idP,
+                           CC_id,
+                           frameP, 0,
+                           0,
+                           rnti,
+                           CCCH,
+                           pdu_ptr+2,
+                           pdu_len-2,
+                           0,0
+                          );
+              
               break;
 
+        // MAC SDUs
+        case UL_SCH_LCID_SRB1:
         case UL_SCH_LCID_DTCH:
                 //  check if LCID is valid at current time.
                 if(((NR_MAC_SUBHEADER_SHORT *)pdu_ptr)->F){
@@ -210,7 +219,7 @@ void nr_process_mac_pdu(
                   mac_subheader_len = 2;
                 }
 
-                LOG_D(MAC, "[UE %d] Frame %d : ULSCH -> UL-DTCH %d (gNB %d, %d bytes)\n", module_idP, frameP, rx_lcid, module_idP, mac_sdu_len);
+                LOG_I(MAC, "[UE %d] Frame %d : ULSCH -> UL-DCCH %d (gNB %d, %d bytes)\n", module_idP, frameP, rx_lcid, module_idP, mac_sdu_len);
 		int UE_id = find_nr_UE_id(module_idP, rnti);
 		RC.nrmac[module_idP]->UE_info.mac_stats[UE_id].lc_bytes_rx[rx_lcid] += mac_sdu_len;
                 #if defined(ENABLE_MAC_PAYLOAD_DEBUG)
@@ -395,7 +404,8 @@ void nr_rx_sdu(const module_id_t gnb_mod_idP,
               current_rnti);
         continue;
       }
-      const int UE_id = add_new_nr_ue(gnb_mod_idP, ra->rnti);
+      bool isActive = (get_softmodem_params()->sa_ra ? false:true);
+      const int UE_id = add_new_nr_ue(gnb_mod_idP, ra->rnti, isActive);
       UE_info->secondaryCellGroup[UE_id] = ra->secondaryCellGroup;
       compute_csi_bitlen(ra->secondaryCellGroup, UE_info, UE_id);
       UE_info->UE_beam_index[UE_id] = ra->beam_id;
@@ -420,13 +430,19 @@ void nr_rx_sdu(const module_id_t gnb_mod_idP,
       // re-initialize ta update variables afrer RA procedure completion
       UE_info->UE_sched_ctrl[UE_id].ta_frame = frameP;
 
-      free(ra->preambles.preamble_list);
-      ra->state = RA_IDLE;
-      LOG_I(MAC,
-            "reset RA state information for RA-RNTI %04x/index %d\n",
-            ra->rnti,
-            i);
+      nr_process_mac_pdu(gnb_mod_idP, current_rnti, CC_idP, frameP, sduP, sdu_lenP);
 
+      free(ra->preambles.preamble_list);
+      //ra->state = RA_IDLE;
+      // LOG_I(MAC,
+      //       "reset RA state information for RA-RNTI %04x/index %d\n",
+      //      ra->rnti,
+      //      i);
+            //ra->state = RA_IDLE;
+      ra->state = Msg4;
+      ra->Msg4_frame = ( frameP +2 ) % 1024;
+      ra->Msg4_slot = 1;
+      LOG_I(MAC, "set RA state to Msg4 for RA-RNTI %04x, msg4 frame %d %d\n", ra->rnti, ra->Msg4_frame, ra->Msg4_slot);
       return;
     }
   }

openair2/LAYER2/NR_MAC_gNB/mac_proto.h

@@ -84,7 +84,9 @@ void nr_schedule_ue_spec(module_id_t module_id,
 void nr_simple_dlsch_preprocessor(module_id_t module_id,
                                   frame_t frame,
                                   sub_frame_t slot,
-                                  int num_slots_per_tdd);
+                                  int num_slots_per_tdd,
+                                  int rnti_type,
+                                  int UE_id);
 
 void schedule_nr_mib(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP, uint8_t slots_per_frame);
 
@@ -104,7 +106,7 @@ void nr_simple_ulsch_preprocessor(module_id_t module_id,
 
 /////// Random Access MAC-PHY interface functions and primitives ///////
 
-void nr_schedule_RA(module_id_t module_idP, frame_t frameP, sub_frame_t slotP);
+void nr_schedule_RA(module_id_t module_idP, frame_t frameP, sub_frame_t slotP, int num_slots_per_tdd);
 
 /* \brief Function to indicate a received preamble on PRACH.  It initiates the RA procedure.
 @param module_idP Instance ID of gNB
@@ -178,7 +180,8 @@ void nr_fill_nfapi_dl_pdu(int Mod_id,
                           int NrOfSymbols,
                           int harq_pid,
                           int ndi,
-                          int round);
+                          int round,
+                          int rnit_type);
 
 void handle_nr_uci_pucch_0_1(module_id_t mod_id,
                              frame_t frame,
@@ -221,7 +224,8 @@ void nr_acknack_scheduling(int Mod_idP,
                            sub_frame_t slotP,
                            int slots_per_tdd,
                            int *pucch_id,
-                           int *pucch_occ);
+                           int *pucch_occ,
+                           int isUEspec);
 
 int get_pucch_resource(NR_UE_info_t *UE_info,int UE_id,int k,int l);
 
@@ -338,7 +342,7 @@ int find_nr_UE_id(module_id_t mod_idP, rnti_t rntiP);
 
 int find_nr_RA_id(module_id_t mod_idP, int CC_idP, rnti_t rntiP);
 
-int add_new_nr_ue(module_id_t mod_idP, rnti_t rntiP);
+int add_new_nr_ue(module_id_t mod_idP, rnti_t rntiP, bool isActive);
 
 void mac_remove_nr_ue(module_id_t mod_id, rnti_t rnti);
 

openair2/LAYER2/NR_MAC_gNB/main.c

@@ -96,7 +96,7 @@ void mac_top_init_gNB(void)
     // These should be out of here later
     pdcp_layer_init();
 
-    if(IS_SOFTMODEM_NOS1 && !get_softmodem_params()->do_ra)
+//    if(IS_SOFTMODEM_NOS1 && !get_softmodem_params()->do_ra && !get_softmodem_params()->sa_ra)
       nr_DRB_preconfiguration(0x1234);
 
     rrc_init_nr_global_param();
@@ -117,6 +117,7 @@ void mac_top_init_gNB(void)
     for (list_el = 0; list_el < MAX_MOBILES_PER_GNB; list_el++) {
       UE_info->list.next[list_el] = -1;
       UE_info->active[list_el] = false;
+      UE_info->rnti[list_el] = 0;
       for (int list_harq = 0; list_harq < NR_MAX_NB_HARQ_PROCESSES; list_harq++) {
         UE_info->UE_sched_ctrl[list_el].harq_processes[list_harq].round = 0;
         UE_info->UE_sched_ctrl[list_el].harq_processes[list_harq].ndi = 0;

openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h

@@ -476,7 +476,9 @@ typedef struct {
 typedef void (*nr_pp_impl_dl)(module_id_t mod_id,
                               frame_t frame,
                               sub_frame_t slot,
-                              int num_slots_per_tdd);
+                              int num_slots_per_tdd,
+                              int rnti_type,
+                              int UE_id);
 typedef void (*nr_pp_impl_ul)(module_id_t mod_id,
                               frame_t frame,
                               sub_frame_t slot,

openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c

@@ -22,6 +22,7 @@
 #include "nr_pdcp_entity.h"
 
 #include "nr_pdcp_entity_drb_am.h"
+#include "nr_pdcp_entity_srb.h"
 
 #include "LOG/log.h"
 
@@ -34,7 +35,32 @@ nr_pdcp_entity_t *new_nr_pdcp_entity_srb(
                         char *buf, int size, int sdu_id),
     void *deliver_pdu_data)
 {
-  abort();
+
+  nr_pdcp_entity_srb_t *ret;
+
+  ret = calloc(1, sizeof(nr_pdcp_entity_srb_t));
+  if (ret == NULL) {
+    LOG_E(PDCP, "%s:%d:%s: out of memory\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  ret->common.recv_pdu          = nr_pdcp_entity_srb_recv_pdu;
+  ret->common.recv_sdu          = nr_pdcp_entity_srb_recv_sdu;
+  ret->common.set_integrity_key = nr_pdcp_entity_srb_set_integrity_key;
+
+  ret->common.delete = nr_pdcp_entity_srb_delete;
+
+  ret->common.deliver_sdu = deliver_sdu;
+  ret->common.deliver_sdu_data = deliver_sdu_data;
+
+  ret->common.deliver_pdu = deliver_pdu;
+  ret->common.deliver_pdu_data = deliver_pdu_data;
+
+  ret->srb_id = rb_id;
+
+  ret->common.maximum_nr_pdcp_sn = 4095;
+
+  return (nr_pdcp_entity_t *)ret;
 }
 
 nr_pdcp_entity_t *new_nr_pdcp_entity_drb_am(

openair2/LAYER2/nr_pdcp/nr_pdcp_entity.h

@@ -23,17 +23,18 @@
 
 #ifndef _NR_PDCP_ENTITY_H_
 #define _NR_PDCP_ENTITY_H_
+#include "platform_types.h"
 
 typedef struct nr_pdcp_entity_t {
   /* functions provided by the PDCP module */
-  void (*recv_pdu)(struct nr_pdcp_entity_t *entity, char *buffer, int size);
+  void (*recv_pdu)(protocol_ctxt_t *ctxt_pP,struct nr_pdcp_entity_t *entity, char *buffer, int size);
   void (*recv_sdu)(struct nr_pdcp_entity_t *entity, char *buffer, int size,
                    int sdu_id);
   void (*delete)(struct nr_pdcp_entity_t *entity);
   void (*set_integrity_key)(struct nr_pdcp_entity_t *entity, char *key);
 
   /* callbacks provided to the PDCP module */
-  void (*deliver_sdu)(void *deliver_sdu_data, struct nr_pdcp_entity_t *entity,
+  void (*deliver_sdu)(protocol_ctxt_t *ctxt_pP,void *deliver_sdu_data, struct nr_pdcp_entity_t *entity,
                       char *buf, int size);
   void *deliver_sdu_data;
   void (*deliver_pdu)(void *deliver_pdu_data, struct nr_pdcp_entity_t *entity,

openair2/LAYER2/nr_pdcp/nr_pdcp_entity_drb_am.c

@@ -26,7 +26,7 @@
 #include <string.h>
 #include "common/utils/LOG/log.h"
 
-void nr_pdcp_entity_drb_am_recv_pdu(nr_pdcp_entity_t *_entity, char *buffer, int size)
+void nr_pdcp_entity_drb_am_recv_pdu( protocol_ctxt_t *ctxt_pP , nr_pdcp_entity_t *_entity, char *buffer, int size)
 {
   nr_pdcp_entity_drb_am_t *entity = (nr_pdcp_entity_drb_am_t *)_entity;
 
@@ -35,7 +35,7 @@ void nr_pdcp_entity_drb_am_recv_pdu(nr_pdcp_entity_t *_entity, char *buffer, int
   if (!(buffer[0] & 0x80))
     LOG_E(PDCP, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
 
-  entity->common.deliver_sdu(entity->common.deliver_sdu_data,
+  entity->common.deliver_sdu(ctxt_pP, entity->common.deliver_sdu_data,
                              (nr_pdcp_entity_t *)entity, buffer+3, size-3);
 }
 

openair2/LAYER2/nr_pdcp/nr_pdcp_entity_drb_am.h

@@ -23,6 +23,7 @@
 #define _NR_PDCP_ENTITY_DRB_AM_H_
 
 #include "nr_pdcp_entity.h"
+#include "platform_types.h"
 
 typedef struct {
   nr_pdcp_entity_t common;
@@ -32,7 +33,7 @@ typedef struct {
   int discard_timer;         /* unit: ms, -1 means infinity */
 } nr_pdcp_entity_drb_am_t;
 
-void nr_pdcp_entity_drb_am_recv_pdu(nr_pdcp_entity_t *entity, char *buffer, int size);
+void nr_pdcp_entity_drb_am_recv_pdu(protocol_ctxt_t *ctxt_pP,nr_pdcp_entity_t *entity, char *buffer, int size);
 void nr_pdcp_entity_drb_am_recv_sdu(nr_pdcp_entity_t *entity, char *buffer, int size,
                                     int sdu_id);
 void nr_pdcp_entity_drb_am_set_integrity_key(nr_pdcp_entity_t *entity, char *key);

openair2/LAYER2/nr_pdcp/nr_pdcp_entity_srb.c

@@ -0,0 +1,75 @@
+/*
+ * 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
+ */
+
+#include "nr_pdcp_entity_srb.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void nr_pdcp_entity_srb_recv_pdu(protocol_ctxt_t *ctxt_pP, nr_pdcp_entity_t *_entity, char *buffer, int size)
+{
+  nr_pdcp_entity_srb_t *entity = (nr_pdcp_entity_srb_t *)_entity;
+
+  if (size < 2) abort();
+  entity->common.deliver_sdu(ctxt_pP, entity->common.deliver_sdu_data,
+                             (nr_pdcp_entity_t *)entity, buffer+2, size-6);
+}
+
+void nr_pdcp_entity_srb_recv_sdu(nr_pdcp_entity_t *_entity, char *buffer, int size,
+                              int sdu_id)
+{
+  nr_pdcp_entity_srb_t *entity = (nr_pdcp_entity_srb_t *)_entity;
+  int sn;
+  char buf[size+6];
+
+  sn = entity->common.next_nr_pdcp_tx_sn;
+
+  entity->common.next_nr_pdcp_tx_sn++;
+  if (entity->common.next_nr_pdcp_tx_sn > entity->common.maximum_nr_pdcp_sn) {
+    entity->common.next_nr_pdcp_tx_sn = 0;
+    entity->common.tx_hfn++;
+  }
+
+  buf[0] = (sn >> 8) & 0x0f;
+  buf[1] = sn & 0xff;
+  memcpy(buf+2, buffer, size);
+
+  /* For now use padding for the MAC-I bytes (normally carrying message authentication code)
+   * which come after the data payload bytes (38.323, section 6.2.2.1) */
+  for (int i=size+2; i<size+6; i++)
+    buf[i] = 0x11*(i-size-1);
+
+  entity->common.deliver_pdu(entity->common.deliver_pdu_data,
+                             (nr_pdcp_entity_t *)entity, buf, size+6, sdu_id);
+}
+
+void nr_pdcp_entity_srb_set_integrity_key(nr_pdcp_entity_t *_entity, char *key)
+{
+  /* nothing to do */
+}
+
+void nr_pdcp_entity_srb_delete(nr_pdcp_entity_t *_entity)
+{
+  nr_pdcp_entity_srb_t *entity = (nr_pdcp_entity_srb_t *)_entity;
+  free(entity);
+}
+

openair2/LAYER2/nr_pdcp/nr_pdcp_entity_srb.h

@@ -0,0 +1,38 @@
+ /*
+ * 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
+ */
+
+#ifndef _NR_PDCP_ENTITY_SRB_H_
+#define _NR_PDCP_ENTITY_SRB_H_
+
+#include "nr_pdcp_entity.h"
+
+typedef struct {
+  nr_pdcp_entity_t common;
+  int srb_id;
+} nr_pdcp_entity_srb_t;
+
+void nr_pdcp_entity_srb_recv_pdu(protocol_ctxt_t *ctxt_pP, nr_pdcp_entity_t *_entity, char *buffer, int size);
+void nr_pdcp_entity_srb_recv_sdu(nr_pdcp_entity_t *_entity, char *buffer, int size, int sdu_id);
+void nr_pdcp_entity_srb_set_integrity_key(nr_pdcp_entity_t *_entity, char *key);
+void nr_pdcp_entity_srb_delete(nr_pdcp_entity_t *_entity);
+
+
+#endif /* _NR_PDCP_ENTITY_SRB_H_ */

openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c

@@ -95,6 +95,65 @@ extern rlc_op_status_t nr_rrc_rlc_config_asn1_req (const protocol_ctxt_t   * con
     const LTE_PMCH_InfoList_r9_t * const pmch_InfoList_r9_pP,
     struct NR_CellGroupConfig__rlc_BearerToAddModList *rlc_bearer2add_list);
 
+//------------------------------------------------------------------------------
+void
+nr_rrc_data_ind(
+  const protocol_ctxt_t *const ctxt_pP,
+  const rb_id_t                Srb_id,
+  const sdu_size_t             sdu_sizeP,
+  const uint8_t   *const       buffer_pP
+)
+//------------------------------------------------------------------------------
+{
+  rb_id_t    DCCH_index = Srb_id;
+  LOG_I(RRC, "[UE %x] Frame %d: received a DCCH %ld message on SRB %ld with Size %d from eNB %d\n",
+        ctxt_pP->module_id, ctxt_pP->frame, DCCH_index,Srb_id,sdu_sizeP,  ctxt_pP->eNB_index);
+  {
+    MessageDef *message_p;
+    // Uses a new buffer to avoid issue with PDCP buffer content that could be changed by PDCP (asynchronous message handling).
+    uint8_t *message_buffer;
+    message_buffer = itti_malloc (ctxt_pP->enb_flag ? TASK_RRC_GNB : TASK_RRC_NRUE, ctxt_pP->enb_flag ? TASK_RRC_GNB : TASK_RRC_NRUE, sdu_sizeP);
+    memcpy (message_buffer, buffer_pP, sdu_sizeP);
+    message_p = itti_alloc_new_message (ctxt_pP->enb_flag ? TASK_RRC_GNB : TASK_RRC_NRUE, NR_RRC_DCCH_DATA_IND);
+    NR_RRC_DCCH_DATA_IND (message_p).frame      = ctxt_pP->frame;
+    NR_RRC_DCCH_DATA_IND (message_p).dcch_index = DCCH_index;
+    NR_RRC_DCCH_DATA_IND (message_p).sdu_size   = sdu_sizeP;
+    NR_RRC_DCCH_DATA_IND (message_p).sdu_p      = message_buffer;
+    NR_RRC_DCCH_DATA_IND (message_p).rnti       = ctxt_pP->rnti;
+    NR_RRC_DCCH_DATA_IND (message_p).module_id  = ctxt_pP->module_id;
+    NR_RRC_DCCH_DATA_IND (message_p).gNB_index  = ctxt_pP->eNB_index;
+    itti_send_msg_to_task (ctxt_pP->enb_flag ? TASK_RRC_GNB : TASK_RRC_NRUE, ctxt_pP->instance, message_p);
+  }
+}
+
+//------------------------------------------------------------------------------
+void
+nr_rrc_data_ind_ccch(
+  const protocol_ctxt_t *const ctxt_pP,
+  const rb_id_t                Srb_id,
+  const sdu_size_t             sdu_sizeP,
+  const uint8_t   *const       buffer_pP
+)
+//------------------------------------------------------------------------------
+{
+  rb_id_t    DCCH_index = Srb_id;
+  LOG_I(RRC, "[UE %x] Frame %d: received a CCCH %ld message on SRB %d with Size %d from gNB %d\n",
+        ctxt_pP->module_id, ctxt_pP->frame, DCCH_index,Srb_id,sdu_sizeP,  ctxt_pP->eNB_index);
+  {
+    MessageDef *message_p;
+    // Uses a new buffer to avoid issue with PDCP buffer content that could be changed by PDCP (asynchronous message handling).
+    message_p = itti_alloc_new_message (ctxt_pP->enb_flag ? TASK_RRC_GNB : TASK_RRC_NRUE, NR_RRC_MAC_CCCH_DATA_IND);
+    NR_RRC_MAC_CCCH_DATA_IND (message_p).frame      = ctxt_pP->frame;
+    NR_RRC_MAC_CCCH_DATA_IND (message_p).sub_frame  = 0;
+    NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu_size   = sdu_sizeP;
+    NR_RRC_MAC_CCCH_DATA_IND (message_p).gnb_index  = 0;
+    NR_RRC_MAC_CCCH_DATA_IND (message_p).CC_id      = 0;
+    NR_RRC_MAC_CCCH_DATA_IND (message_p).rnti       = ctxt_pP->rnti;
+    memcpy(NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu,buffer_pP,sdu_sizeP);
+    itti_send_msg_to_task (ctxt_pP->enb_flag ? TASK_RRC_GNB : TASK_RRC_NRUE, ctxt_pP->instance, message_p);
+  }
+}
+
 static void *rlc_data_req_thread(void *_)
 {
   int i;
@@ -210,7 +269,7 @@ static void *enb_tun_read_thread(void *_)
   int rnti;
   protocol_ctxt_t ctxt;
 
-  int rb_id = 1;
+  int lc_id = 4;
   pthread_setname_np( pthread_self(),"enb_tun_read");
 
   while (1) {
@@ -239,7 +298,7 @@ printf("\n\n\n########## nas_sock_fd read returns len %d\n", len);
 
     ctxt.rnti = rnti;
 
-    pdcp_data_req(&ctxt, SRB_FLAG_NO, rb_id, RLC_MUI_UNDEFINED,
+    pdcp_data_req(&ctxt, SRB_FLAG_NO, lc_id, RLC_MUI_UNDEFINED,
                   RLC_SDU_CONFIRM_NO, len, (unsigned char *)rx_buf,
                   PDCP_TRANSMISSION_MODE_DATA, NULL, NULL);
   }
@@ -255,7 +314,7 @@ static void *ue_tun_read_thread(void *_)
   int rnti;
   protocol_ctxt_t ctxt;
 
-  int rb_id = 1;
+  int lc_id = 4;
   pthread_setname_np( pthread_self(),"ue_tun_read"); 
   while (1) {
     len = read(nas_sock_fd[0], &rx_buf, NL_MAX_PAYLOAD);
@@ -283,7 +342,7 @@ printf("\n\n\n########## nas_sock_fd read returns len %d\n", len);
 
     ctxt.rnti = rnti;
 
-    pdcp_data_req(&ctxt, SRB_FLAG_NO, rb_id, RLC_MUI_UNDEFINED,
+    pdcp_data_req(&ctxt, SRB_FLAG_NO, lc_id, RLC_MUI_UNDEFINED,
                   RLC_SDU_CONFIRM_NO, len, (unsigned char *)rx_buf,
                   PDCP_TRANSMISSION_MODE_DATA, NULL, NULL);
   }
@@ -397,8 +456,8 @@ uint64_t pdcp_module_init(uint64_t _pdcp_optmask)
   }
   return pdcp_optmask ;
 }
-
-static void deliver_sdu_drb(void *_ue, nr_pdcp_entity_t *entity,
+static int liuyu=0;
+static void deliver_sdu_drb(protocol_ctxt_t *ctxt_pP,void *_ue, nr_pdcp_entity_t *entity,
                             char *buf, int size)
 {
   extern int nas_sock_fd[];
@@ -409,11 +468,63 @@ static void deliver_sdu_drb(void *_ue, nr_pdcp_entity_t *entity,
   int rb_id;
   int i;
 
-  if(IS_SOFTMODEM_NOS1){
+  if (IS_SOFTMODEM_NOS1 ||  ctxt_pP->enb_flag==ENB_FLAG_NO){
+    #if 0
+    log_dump(PDCP,buf,size,LOG_DUMP_CHAR,"   PDCP Received SDU:\n");
+    if (size > 4700)
+    {
+      LOG_I(PDCP,"maybe ip data \n");
+    }
+    else
+    {
+      LOG_I(PDCP,"send to gNB RRC \n");
+      
+      if(liuyu==2)
+          liuyu=1;
+      if(liuyu==0)
+          nr_rrc_data_ind_ccch( ctxt_pP, 1, size, buf);
+      if(liuyu==1)
+      {
+        for (i = 0; i < 5; i++) {
+           if (entity == ue->drb[i]) {
+              rb_id = i+1;
+              goto rb_found;
+           }
+        }
+
+      LOG_I(PDCP, "%s:%d:%s: fatal, no RB found for ue %d\n",
+            __FILE__, __LINE__, __FUNCTION__, ue->rnti);
+      exit(1);
+
+    rb_found:
+      gtpu_buffer_p = itti_malloc(TASK_PDCP_ENB, TASK_GTPV1_U,
+                                  size + GTPU_HEADER_OVERHEAD_MAX);
+      AssertFatal(gtpu_buffer_p != NULL, "OUT OF MEMORY");
+      memcpy(&gtpu_buffer_p[GTPU_HEADER_OVERHEAD_MAX], buf, size);
+      message_p = itti_alloc_new_message(TASK_PDCP_ENB, GTPV1U_ENB_TUNNEL_DATA_REQ);
+      AssertFatal(message_p != NULL, "OUT OF MEMORY");
+      GTPV1U_ENB_TUNNEL_DATA_REQ(message_p).buffer       = gtpu_buffer_p;
+      GTPV1U_ENB_TUNNEL_DATA_REQ(message_p).length       = size;
+      GTPV1U_ENB_TUNNEL_DATA_REQ(message_p).offset       = GTPU_HEADER_OVERHEAD_MAX;
+      GTPV1U_ENB_TUNNEL_DATA_REQ(message_p).rnti         = ue->rnti;
+      GTPV1U_ENB_TUNNEL_DATA_REQ(message_p).rnti         = 0x1234;
+      GTPV1U_ENB_TUNNEL_DATA_REQ(message_p).rab_id       = rb_id + 4;
+      LOG_I(PDCP, "%s() (drb %d) sending message to gtp size %d\n", __func__, rb_id, size);
+      //for (i = 0; i < size; i++) printf(" %2.2x", (unsigned char)buf[i]);
+      //printf("\n");
+      itti_send_msg_to_task(TASK_GTPV1_U, INSTANCE_DEFAULT, message_p); 
+      }
+          //nr_rrc_data_ind( ctxt_pP, 1, size, buf);
+      
+      liuyu++;
+      
+    }
+    #else
     len = write(nas_sock_fd[0], buf, size);
     if (len != size) {
       LOG_E(PDCP, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
     }
+    #endif
   }
   else{
     for (i = 0; i < 5; i++) {
@@ -488,6 +599,74 @@ rb_found:
   enqueue_rlc_data_req(&ctxt, 0, MBMS_FLAG_NO, rb_id, sdu_id, 0, size, memblock, NULL, NULL);
 }
 
+static void deliver_sdu_srb(protocol_ctxt_t *ctxt_pP, void *_ue, nr_pdcp_entity_t *entity,
+                            char *buf, int size)
+{
+  /* Implementation to be added */
+  
+  nr_pdcp_ue_t *ue = _ue;
+  MessageDef  *message_p;
+  uint8_t     *gtpu_buffer_p;
+  int srb_id;
+  int i;
+
+  for (i = 0; i < 2; i++) {
+    if (entity == ue->srb[i]) {
+      srb_id = i+1;
+      goto rb_found;
+    }
+  }
+
+  LOG_E(PDCP, "%s:%d:%s: fatal, no RB found for ue %d\n",
+        __FILE__, __LINE__, __FUNCTION__, ue->rnti);
+  exit(1);
+
+rb_found:
+  nr_rrc_data_ind( ctxt_pP, srb_id, size, buf);
+ 
+  return;
+}
+
+
+
+static void deliver_pdu_srb(void *_ue, nr_pdcp_entity_t *entity,
+                            char *buf, int size, int sdu_id)
+{
+  nr_pdcp_ue_t *ue = _ue;
+  int srb_id;
+  protocol_ctxt_t ctxt;
+  int i;
+  mem_block_t *memblock;
+
+  for (i = 0; i < 2; i++) {
+    if (entity == ue->srb[i]) {
+      srb_id = i+1;
+      goto rb_found;
+    }
+  }
+
+  LOG_E(PDCP, "%s:%d:%s: fatal, no RB found for ue %d\n",
+        __FILE__, __LINE__, __FUNCTION__, ue->rnti);
+  exit(1);
+
+rb_found:
+  ctxt.module_id = 0;
+  ctxt.enb_flag = 1;
+  ctxt.instance = 0;
+  ctxt.frame = 0;
+  ctxt.subframe = 0;
+  ctxt.eNB_index = 0;
+  ctxt.configured = 1;
+  ctxt.brOption = 0;
+
+  ctxt.rnti = ue->rnti;
+
+  memblock = get_free_mem_block(size, __FUNCTION__);
+  memcpy(memblock->data, buf, size);
+
+  enqueue_rlc_data_req(&ctxt, 1, MBMS_FLAG_NO, srb_id, sdu_id, 0, size, memblock, NULL, NULL);
+}
+
 boolean_t pdcp_data_ind(
   const protocol_ctxt_t *const  ctxt_pP,
   const srb_flag_t srb_flagP,
@@ -530,7 +709,7 @@ boolean_t pdcp_data_ind(
   }
 
   if (rb != NULL) {
-    rb->recv_pdu(rb, (char *)sdu_buffer->data, sdu_buffer_size);
+    rb->recv_pdu(ctxt_pP,rb, (char *)sdu_buffer->data, sdu_buffer_size);
   } else {
     LOG_E(PDCP, "%s:%d:%s: fatal: no RB found (rb_id %ld, srb_flag %d)\n",
           __FILE__, __LINE__, __FUNCTION__, rb_id, srb_flagP);
@@ -565,7 +744,7 @@ void pdcp_run(const protocol_ctxt_t *const  ctxt_pP)
           0,
           RRC_DCCH_DATA_REQ(msg_p).eNB_index);
       result = pdcp_data_req(&ctxt,
-                             SRB_FLAG_YES,
+                             SRB_FLAG_YES,//not used, use lcid to check
                              RRC_DCCH_DATA_REQ(msg_p).rb_id,
                              RRC_DCCH_DATA_REQ(msg_p).muip,
                              RRC_DCCH_DATA_REQ(msg_p).confirmp,
@@ -588,7 +767,32 @@ void pdcp_run(const protocol_ctxt_t *const  ctxt_pP)
 
 static void add_srb(int rnti, struct NR_SRB_ToAddMod *s)
 {
-  TODO;
+  nr_pdcp_entity_t *pdcp_srb;
+  nr_pdcp_ue_t *ue;
+
+  int srb_id = s->srb_Identity;
+
+  printf("\n\n################# rnti %d add srb %d\n\n\n", rnti, srb_id);
+
+  if (srb_id > 3) {
+    LOG_E(PDCP, "%s:%d:%s: fatal, bad drb id %d\n",
+          __FILE__, __LINE__, __FUNCTION__, srb_id);
+    exit(1);
+  }
+
+  nr_pdcp_manager_lock(nr_pdcp_ue_manager);
+  ue = nr_pdcp_manager_get_ue(nr_pdcp_ue_manager, rnti);
+  if (ue->srb[srb_id-1] != NULL) {
+    LOG_W(PDCP, "%s:%d:%s: warning DRB %d already exist for ue %d, do nothing\n",
+          __FILE__, __LINE__, __FUNCTION__, srb_id, rnti);
+  } else {
+    pdcp_srb = new_nr_pdcp_entity_srb(srb_id, deliver_sdu_srb, ue, deliver_pdu_srb, ue);
+    nr_pdcp_ue_add_srb_pdcp_entity(ue, srb_id, pdcp_srb);
+
+    LOG_I(PDCP, "%s:%d:%s: added drb %d to ue %d\n",
+          __FILE__, __LINE__, __FUNCTION__, srb_id, rnti);
+  }
+  nr_pdcp_manager_unlock(nr_pdcp_ue_manager);
 }
 
 static void add_drb_am(int rnti, struct NR_DRB_ToAddMod *s)
@@ -736,7 +940,17 @@ void nr_DRB_preconfiguration(uint16_t crnti)
   //fill_default_rbconfig(rb_config, 5, 1);
   rbconfig = calloc(1, sizeof(*rbconfig));
 
-  rbconfig->srb_ToAddModList = NULL;
+  rbconfig->srb_ToAddModList = calloc(1,sizeof(*rbconfig->srb_ToAddModList));
+  NR_SRB_ToAddMod_t *srb_ToAddMod = calloc(1,sizeof(*srb_ToAddMod));
+  srb_ToAddMod->srb_Identity = 1;
+  srb_ToAddMod->reestablishPDCP = NULL;
+  srb_ToAddMod->discardOnPDCP = NULL;
+  srb_ToAddMod->pdcp_Config = NULL;
+  ASN_SEQUENCE_ADD(&rbconfig->srb_ToAddModList->list,srb_ToAddMod);
+  // srb_ToAddMod = calloc(1,sizeof(*srb_ToAddMod));
+  // srb_ToAddMod->srb_Identity = 2;
+  // ASN_SEQUENCE_ADD(&rbconfig->srb_ToAddModList->list,srb_ToAddMod);
+
   rbconfig->srb3_ToRelease = NULL;
   rbconfig->drb_ToAddModList = calloc(1,sizeof(*rbconfig->drb_ToAddModList));
   NR_DRB_ToAddMod_t *drb_ToAddMod = calloc(1,sizeof(*drb_ToAddMod));
@@ -780,9 +994,58 @@ void nr_DRB_preconfiguration(uint16_t crnti)
   xer_fprint(stdout, &asn_DEF_NR_RadioBearerConfig, (const void*)rbconfig);
 
   NR_RLC_BearerConfig_t *RLC_BearerConfig = calloc(1,sizeof(*RLC_BearerConfig));
-  nr_rlc_bearer_init(RLC_BearerConfig);
-  nr_drb_config(RLC_BearerConfig->rlc_Config, NR_RLC_Config_PR_um_Bi_Directional);
-  nr_rlc_bearer_init_ul_spec(RLC_BearerConfig->mac_LogicalChannelConfig);
+
+
+  RLC_BearerConfig->logicalChannelIdentity = 4;
+  RLC_BearerConfig->servedRadioBearer = calloc(1,sizeof(*RLC_BearerConfig->servedRadioBearer));
+  RLC_BearerConfig->servedRadioBearer->present =    NR_RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
+
+  RLC_BearerConfig->servedRadioBearer->choice.drb_Identity=1;
+  RLC_BearerConfig->reestablishRLC=calloc(1,sizeof(*RLC_BearerConfig->reestablishRLC));
+  *RLC_BearerConfig->reestablishRLC=NR_RLC_BearerConfig__reestablishRLC_true;
+  RLC_BearerConfig->rlc_Config=calloc(1,sizeof(*RLC_BearerConfig->rlc_Config));
+
+#if 0
+  // RLC UM Bi-directional Bearer configuration
+  RLC_BearerConfig->rlc_Config->present = NR_RLC_Config_PR_um_Bi_Directional;
+  RLC_BearerConfig->rlc_Config->choice.um_Bi_Directional = calloc(1,sizeof(*RLC_BearerConfig->rlc_Config->choice.um_Bi_Directional));
+  RLC_BearerConfig->rlc_Config->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = calloc(1,sizeof(*RLC_BearerConfig->rlc_Config->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength));
+  *RLC_BearerConfig->rlc_Config->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength   =    NR_SN_FieldLengthUM_size12;
+
+  RLC_BearerConfig->rlc_Config->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = calloc(1,sizeof(*RLC_BearerConfig->rlc_Config->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength));
+  *RLC_BearerConfig->rlc_Config->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength   =    NR_SN_FieldLengthUM_size12;
+  RLC_BearerConfig->rlc_Config->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = NR_T_Reassembly_ms15;
+ #else
+  // RLC AM Bearer configuration
+  RLC_BearerConfig->rlc_Config->present = NR_RLC_Config_PR_am;
+  RLC_BearerConfig->rlc_Config->choice.am = calloc(1,sizeof(*RLC_BearerConfig->rlc_Config->choice.am));
+  RLC_BearerConfig->rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength = calloc(1,sizeof(*RLC_BearerConfig->rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength));
+  *RLC_BearerConfig->rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength   =  NR_SN_FieldLengthAM_size18;
+  RLC_BearerConfig->rlc_Config->choice.am->ul_AM_RLC.t_PollRetransmit = NR_T_PollRetransmit_ms45;
+  RLC_BearerConfig->rlc_Config->choice.am->ul_AM_RLC.pollPDU          = NR_PollPDU_p64;
+  RLC_BearerConfig->rlc_Config->choice.am->ul_AM_RLC.pollByte         = NR_PollByte_kB500;
+  RLC_BearerConfig->rlc_Config->choice.am->ul_AM_RLC.maxRetxThreshold = NR_UL_AM_RLC__maxRetxThreshold_t32;
+  RLC_BearerConfig->rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength = calloc(1,sizeof(*RLC_BearerConfig->rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength));
+  *RLC_BearerConfig->rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength = NR_SN_FieldLengthAM_size18;
+  RLC_BearerConfig->rlc_Config->choice.am->dl_AM_RLC.t_Reassembly   = NR_T_Reassembly_ms15;
+  RLC_BearerConfig->rlc_Config->choice.am->dl_AM_RLC.t_StatusProhibit = NR_T_StatusProhibit_ms15;
+#endif
+  RLC_BearerConfig->mac_LogicalChannelConfig = calloc(1,sizeof(*RLC_BearerConfig->mac_LogicalChannelConfig));
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters = calloc(1,sizeof(*RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters));
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->priority            = 1;
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->prioritisedBitRate  = NR_LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_infinity;
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->bucketSizeDuration  = NR_LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms50;
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->allowedServingCells = NULL;
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->allowedSCS_List     = NULL;
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->maxPUSCH_Duration   = NULL;
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULL;
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->logicalChannelGroup   = calloc(1,sizeof(*RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->logicalChannelGroup));
+  *RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->logicalChannelGroup  = 1;
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->schedulingRequestID   = NULL;
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
+  RLC_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->bitRateQueryProhibitTimer   = NULL;
+
 
   Rlc_Bearer_ToAdd_list = calloc(1,sizeof(*Rlc_Bearer_ToAdd_list));
   ASN_SEQUENCE_ADD(&Rlc_Bearer_ToAdd_list->list, RLC_BearerConfig);
@@ -796,7 +1059,7 @@ void nr_DRB_preconfiguration(uint16_t crnti)
 
   nr_rrc_pdcp_config_asn1_req(
     &ctxt,
-    (NR_SRB_ToAddModList_t *) NULL,
+    rbconfig->srb_ToAddModList,
     rbconfig->drb_ToAddModList ,
     rbconfig->drb_ToReleaseList,
     0xff,
@@ -808,7 +1071,7 @@ void nr_DRB_preconfiguration(uint16_t crnti)
     Rlc_Bearer_ToAdd_list);
 
   nr_rrc_rlc_config_asn1_req (&ctxt,
-      (NR_SRB_ToAddModList_t *) NULL,
+      rbconfig->srb_ToAddModList,
       rbconfig->drb_ToAddModList,
       rbconfig->drb_ToReleaseList,
       (LTE_PMCH_InfoList_r9_t *) NULL,
@@ -876,6 +1139,52 @@ void pdcp_config_set_security(
   }
 }
 
+
+static boolean_t pdcp_data_req_srb(
+  protocol_ctxt_t  *ctxt_pP,
+  const rb_id_t rb_id,
+  const mui_t muiP,
+  const confirm_t confirmP,
+  const sdu_size_t sdu_buffer_size,
+  unsigned char *const sdu_buffer)
+{
+  LOG_D(PDCP, "%s() called, size %d\n", __func__, sdu_buffer_size);
+  nr_pdcp_ue_t *ue;
+  nr_pdcp_entity_t *rb;
+  int rnti = ctxt_pP->rnti;
+
+  if (ctxt_pP->module_id != 0 ||
+      //ctxt_pP->enb_flag != 1 ||
+      ctxt_pP->instance != 0 ||
+      ctxt_pP->eNB_index != 0 /*||
+      ctxt_pP->configured != 1 ||
+      ctxt_pP->brOption != 0*/) {
+    LOG_E(PDCP, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  nr_pdcp_manager_lock(nr_pdcp_ue_manager);
+
+  ue = nr_pdcp_manager_get_ue(nr_pdcp_ue_manager, rnti);
+
+  if (rb_id < 1 || rb_id > 3)
+    rb = NULL;
+  else
+    rb = ue->srb[rb_id - 1];
+
+  if (rb == NULL) {
+    LOG_E(PDCP, "%s:%d:%s: no SRB found (rnti %d, rb_id %ld)\n",
+          __FILE__, __LINE__, __FUNCTION__, rnti, rb_id);
+    return 0;
+  }
+
+  rb->recv_sdu(rb, (char *)sdu_buffer, sdu_buffer_size, muiP);
+
+  nr_pdcp_manager_unlock(nr_pdcp_ue_manager);
+
+  return 1;
+}
+
 static boolean_t pdcp_data_req_drb(
   protocol_ctxt_t  *ctxt_pP,
   const rb_id_t rb_id,
@@ -936,8 +1245,12 @@ boolean_t pdcp_data_req(
 #endif
   )
 {
-  if (srb_flagP) { TODO; }
-  return pdcp_data_req_drb(ctxt_pP, rb_id, muiP, confirmP, sdu_buffer_size,
+  if (rb_id < 4) { 
+    return pdcp_data_req_srb(ctxt_pP, rb_id, muiP, confirmP, sdu_buffer_size,
+                           sdu_buffer); 
+  }
+  // use rbid to check drb or srb.
+  return pdcp_data_req_drb(ctxt_pP, rb_id - 3, muiP, confirmP, sdu_buffer_size,
                            sdu_buffer);
 }
 

openair2/LAYER2/nr_rlc/nr_rlc_oai_api.c

@@ -766,6 +766,78 @@ static void add_drb_am(int rnti, struct NR_DRB_ToAddMod *s, NR_RLC_BearerConfig_
   }
   nr_rlc_manager_unlock(nr_rlc_ue_manager);
 }
+static void srb_add_drb_am(int rnti, struct NR_DRB_ToAddMod *s, NR_RLC_BearerConfig_t *rlc_BearerConfig)
+{
+  nr_rlc_entity_t            *nr_rlc_am;
+  nr_rlc_ue_t                *ue;
+
+  struct NR_RLC_Config *r = rlc_BearerConfig->rlc_Config;
+  struct NR_LogicalChannelConfig *l = rlc_BearerConfig->mac_LogicalChannelConfig;
+  int srb_id = 1;
+  int channel_id = 1;//rlc_BearerConfig->logicalChannelIdentity;
+  int logical_channel_group;
+
+  int t_status_prohibit;
+  int t_poll_retransmit;
+  int poll_pdu;
+  int poll_byte;
+  int max_retx_threshold;
+  int t_reassembly;
+  int sn_field_length;
+
+
+  logical_channel_group = *l->ul_SpecificParameters->logicalChannelGroup;
+
+  /* TODO: accept other values? */
+  if (logical_channel_group != 1) {
+    LOG_E(RLC, "%s:%d:%s: fatal error\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  switch (r->present) {
+  case NR_RLC_Config_PR_am: {
+    struct NR_RLC_Config__am *am;
+    am = r->choice.am;
+    t_reassembly       = decode_t_reassembly(am->dl_AM_RLC.t_Reassembly);
+    t_status_prohibit  = decode_t_status_prohibit(am->dl_AM_RLC.t_StatusProhibit);
+    t_poll_retransmit  = decode_t_poll_retransmit(am->ul_AM_RLC.t_PollRetransmit);
+    poll_pdu           = decode_poll_pdu(am->ul_AM_RLC.pollPDU);
+    poll_byte          = decode_poll_byte(am->ul_AM_RLC.pollByte);
+    max_retx_threshold = decode_max_retx_threshold(am->ul_AM_RLC.maxRetxThreshold);
+    if (*am->dl_AM_RLC.sn_FieldLength != *am->ul_AM_RLC.sn_FieldLength) {
+      LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
+      exit(1);
+    }
+    sn_field_length    = decode_sn_field_length_am(*am->dl_AM_RLC.sn_FieldLength);
+    break;
+  }
+  default:
+    LOG_E(RLC, "%s:%d:%s: fatal error\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  nr_rlc_manager_lock(nr_rlc_ue_manager);
+  ue = nr_rlc_manager_get_ue(nr_rlc_ue_manager, rnti);
+  if (ue->srb[srb_id-1] != NULL) {
+    LOG_W(RLC, "%s:%d:%s: warning DRB %d already exist for ue %d, do nothing\n",
+          __FILE__, __LINE__, __FUNCTION__, srb_id, rnti);
+  } else {
+    nr_rlc_am = new_nr_rlc_entity_am(100000,
+                                     100000,
+                                     deliver_sdu, ue,
+                                     successful_delivery, ue,
+                                     max_retx_reached, ue,
+                                     t_poll_retransmit,
+                                     t_reassembly, t_status_prohibit,
+                                     poll_pdu, poll_byte, max_retx_threshold,
+                                     sn_field_length);
+    //nr_rlc_ue_add_drb_rlc_entity(ue, srb_id, nr_rlc_am);
+    ue->srb[srb_id-1] = nr_rlc_am;
+    LOG_I(RLC, "%s:%d:%s: added srb %d to ue %d\n",
+          __FILE__, __LINE__, __FUNCTION__, srb_id, rnti);
+  }
+  nr_rlc_manager_unlock(nr_rlc_ue_manager);
+}
 
 static void add_drb_um(int rnti, struct NR_DRB_ToAddMod *s, NR_RLC_BearerConfig_t *rlc_BearerConfig)
 {
@@ -834,6 +906,75 @@ static void add_drb_um(int rnti, struct NR_DRB_ToAddMod *s, NR_RLC_BearerConfig_
   }
   nr_rlc_manager_unlock(nr_rlc_ue_manager);
 }
+static void srb_add_drb_um(int rnti, struct NR_DRB_ToAddMod *s, NR_RLC_BearerConfig_t *rlc_BearerConfig)
+{
+  nr_rlc_entity_t            *nr_rlc_um;
+  nr_rlc_ue_t                *ue;
+
+  struct NR_RLC_Config *r = rlc_BearerConfig->rlc_Config;
+  struct NR_LogicalChannelConfig *l = rlc_BearerConfig->mac_LogicalChannelConfig;
+  int srb_id = 1;
+  int channel_id = rlc_BearerConfig->logicalChannelIdentity;
+  int logical_channel_group;
+
+  int sn_field_length;
+  int t_reassembly;
+
+  // if (!(drb_id >= 1 && drb_id <= 5)) {
+  //   LOG_E(RLC, "%s:%d:%s: fatal, bad srb id %d\n",
+  //         __FILE__, __LINE__, __FUNCTION__, drb_id);
+  //   exit(1);
+  // }
+
+  // if (channel_id != drb_id + 3) {
+  //   LOG_E(RLC, "%s:%d:%s: todo, remove this limitation\n",
+  //         __FILE__, __LINE__, __FUNCTION__);
+  //   exit(1);
+  // }
+
+  logical_channel_group = *l->ul_SpecificParameters->logicalChannelGroup;
+
+  /* TODO: accept other values? */
+  if (logical_channel_group != 1) {
+    LOG_E(RLC, "%s:%d:%s: fatal error\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  switch (r->present) {
+  case NR_RLC_Config_PR_um_Bi_Directional: {
+    struct NR_RLC_Config__um_Bi_Directional *um;
+    um = r->choice.um_Bi_Directional;
+    t_reassembly = decode_t_reassembly(um->dl_UM_RLC.t_Reassembly);
+    if (*um->dl_UM_RLC.sn_FieldLength != *um->ul_UM_RLC.sn_FieldLength) {
+      LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
+      exit(1);
+    }
+    sn_field_length = decode_sn_field_length_um(*um->dl_UM_RLC.sn_FieldLength);
+    break;
+  }
+  default:
+    LOG_E(RLC, "%s:%d:%s: fatal error\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  nr_rlc_manager_lock(nr_rlc_ue_manager);
+  ue = nr_rlc_manager_get_ue(nr_rlc_ue_manager, rnti);
+  if (ue->srb[srb_id-1] != NULL) {
+    LOG_W(RLC, "%s:%d:%s: warning DRB %d already exist for ue %d, do nothing\n",
+          __FILE__, __LINE__, __FUNCTION__, srb_id, rnti);
+  } else {
+    nr_rlc_um = new_nr_rlc_entity_um(1000000,
+                                     1000000,
+                                     deliver_sdu, ue,
+                                     t_reassembly,
+                                     sn_field_length);
+  //  nr_rlc_ue_add_drb_rlc_entity(ue, srb_id, nr_rlc_um);
+    ue->srb[srb_id-1] = nr_rlc_um;
+    LOG_I(RLC, "%s:%d:%s: added srb %d to ue %d\n",
+          __FILE__, __LINE__, __FUNCTION__, srb_id, rnti);
+  }
+  nr_rlc_manager_unlock(nr_rlc_ue_manager);
+}
 
 static void add_drb(int rnti, struct NR_DRB_ToAddMod *s, struct NR_RLC_BearerConfig *rlc_BearerConfig)
 {
@@ -895,7 +1036,8 @@ rlc_op_status_t nr_rrc_rlc_config_asn1_req (const protocol_ctxt_t   * const ctxt
 
   if (srb2add_listP != NULL) {
     for (i = 0; i < srb2add_listP->list.count; i++) {
-      add_srb(rnti, srb2add_listP->list.array[i]);
+//      add_srb(rnti, srb2add_listP->list.array[i]);
+      srb_add_drb_am(rnti, drb2add_listP->list.array[0], rlc_bearer2add_list->list.array[0]);
     }
   }
 

openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c

@@ -109,7 +109,7 @@ int nr_ue_ul_indication(nr_uplink_indication_t *ul_info){
 
   ret = nr_ue_scheduler(NULL, ul_info);
 
-  if (is_nr_UL_slot(mac->scc, ul_info->slot_tx) && get_softmodem_params()->do_ra)
+  if (is_nr_UL_slot(mac->scc, ul_info->slot_tx) && (get_softmodem_params()->do_ra || get_softmodem_params()->sa_ra))
     nr_ue_prach_scheduler(module_id, ul_info->frame_tx, ul_info->slot_tx, ul_info->thread_id);
 
   switch(ret){

openair2/RRC/NR/L2_nr_interface.c

@@ -108,8 +108,8 @@ nr_rrc_data_req(
   /* Hack: only trigger PDCP if in CU, otherwise it is triggered by RU threads
    * Ideally, PDCP would not neet to be triggered like this but react to ITTI
    * messages automatically */
-  if (ctxt_pP->enb_flag && NODE_IS_CU(RC.rrc[ctxt_pP->module_id]->node_type))
-    pdcp_run(ctxt_pP);
+  // if (ctxt_pP->enb_flag && NODE_IS_CU(RC.rrc[ctxt_pP->module_id]->node_type))
+  //   pdcp_run(ctxt_pP);
 
   return TRUE; // TODO should be changed to a CNF message later, currently RRC lite does not used the returned value anyway.
 }
@@ -118,6 +118,7 @@ int8_t mac_rrc_nr_data_req(const module_id_t Mod_idP,
                            const int         CC_id,
                            const frame_t     frameP,
                            const rb_id_t     Srb_id,
+                           const rnti_t      rnti,
                            const uint8_t     Nb_tb,
                            uint8_t *const    buffer_pP ){
 
@@ -167,24 +168,27 @@ int8_t mac_rrc_nr_data_req(const module_id_t Mod_idP,
   }
 
   /* CCCH */
+  struct rrc_gNB_ue_context_s *ue_context_p = NULL;
   if( (Srb_id & RAB_OFFSET ) == CCCH) {
     //struct rrc_eNB_ue_context_s *ue_context_p = rrc_eNB_get_ue_context(RC.rrc[Mod_idP],rnti);
     //if (ue_context_p == NULL) return(0);
     //eNB_RRC_UE_t *ue_p = &ue_context_p->ue_context;
-    LOG_D(RRC,"[gNB %d] Frame %d CCCH request (Srb_id %ld)\n", Mod_idP, frameP, Srb_id);
+    ue_context_p = rrc_gNB_get_ue_context(RC.nrrrc[Mod_idP], rnti);
+    // LOG_I(NR_RRC,"3333 Returning new UE context at %p\n",RC.nrrrc[Mod_idP]);
+    // LOG_I(NR_RRC,"4444 Returning new UE context at %p\n",ue_context_p);
+    LOG_I(RRC,"[gNB %d] Frame %d CCCH request (Srb_id %ld)， ue_context_p %p \n", Mod_idP, frameP, Srb_id, ue_context_p );
 
     // srb_info=&ue_p->Srb0;
 
-    payload_size = srb_info->Tx_buffer.payload_size;
-
+    payload_size = ue_context_p->ue_context.Srb0.Tx_buffer.payload_size;
     // check if data is there for MAC
     if (payload_size > 0) {
-      payload_pP = srb_info->Tx_buffer.Payload;
+      payload_pP = ue_context_p->ue_context.Srb0.Tx_buffer.Payload;
       LOG_D(RRC,"[gNB %d] CCCH (%p) has %d bytes (dest: %p, src %p)\n", Mod_idP, srb_info, payload_size, buffer_pP, payload_pP);
       // Fill buffer
       memcpy((void *)buffer_pP, (void*)payload_pP, payload_size);
       Sdu_size = payload_size;
-      srb_info->Tx_buffer.payload_size = 0;
+      ue_context_p->ue_context.Srb0.Tx_buffer.payload_size = 0;
     }
     return Sdu_size;
   }
@@ -192,3 +196,60 @@ int8_t mac_rrc_nr_data_req(const module_id_t Mod_idP,
   return(0);
 
 }
+
+//------------------------------------------------------------------------------
+int8_t
+nr_mac_rrc_data_ind(
+  const module_id_t     module_idP,
+  const int             CC_id,
+  const frame_t         frameP,
+  const sub_frame_t     sub_frameP,
+  const int             UE_id,
+  const rnti_t          rntiP,
+  const rb_id_t         srb_idP,
+  const uint8_t        *sduP,
+  const sdu_size_t      sdu_lenP,
+  const uint8_t         mbsfn_sync_areaP,
+  const boolean_t   brOption
+)
+//--------------------------------------------------------------------------
+{
+  // if (NODE_IS_DU(RC.nrrrc[module_idP]->node_type)) {
+  //   LOG_W(RRC,"[DU %d][RAPROC] Received SDU for CCCH on SRB %ld length %d for UE id %d RNTI %x \n",
+  //         module_idP, srb_idP, sdu_lenP, UE_id, rntiP);
+  //   /* do ITTI message */
+  //   DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(
+  //     module_idP,
+  //     CC_id,
+  //     UE_id,
+  //     rntiP,
+  //     sduP,
+  //     sdu_lenP
+  //   );
+  //   return(0);
+  // }
+
+  //SRB_INFO *Srb_info;
+  protocol_ctxt_t ctxt;
+  sdu_size_t      sdu_size = 0;
+  /* for no gcc warnings */
+  (void)sdu_size;
+  /*
+  int si_window;
+   */
+  PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, module_idP, GNB_FLAG_YES, rntiP, frameP, sub_frameP,0);
+  if((srb_idP & RAB_OFFSET) == CCCH) {
+    LOG_D(RRC, "[eNB %d] Received SDU for CCCH on SRB %ld\n", module_idP, srb_idP);
+    ctxt.brOption = brOption;
+
+    /*Srb_info = &RC.rrc[module_idP]->carrier[CC_id].Srb0;
+    if (sdu_lenP > 0) {
+      memcpy(Srb_info->Rx_buffer.Payload,sduP,sdu_lenP);
+      Srb_info->Rx_buffer.payload_size = sdu_lenP;
+      rrc_eNB_decode_ccch(&ctxt, Srb_info, CC_id);
+    }*/
+    if (sdu_lenP > 0)  nr_rrc_gNB_decode_ccch(&ctxt, sduP, sdu_lenP, CC_id);
+  }
+
+  return(0);
+}

openair2/RRC/NR/MESSAGES/asn1_msg.c

@@ -68,6 +68,7 @@
 #include "NR_SDAP-Config.h"
 #include "NR_RRCReconfigurationComplete.h"
 #include "NR_RRCReconfigurationComplete-IEs.h"
+#include "NR_DLInformationTransfer.h"
 #if defined(NR_Rel16)
   #include "NR_SCS-SpecificCarrier.h"
   #include "NR_TDD-UL-DL-ConfigCommon.h"
@@ -1260,3 +1261,64 @@ int do_DLInformationTransfer_NR (void * p) {
 	return 0;
 }
 
+//------------------------------------------------------------------------------
+uint8_t 
+do_NR_DLInformationTransfer(
+    uint8_t Mod_id,
+    uint8_t **buffer,
+    uint8_t transaction_id,
+    uint32_t pdu_length,
+    uint8_t *pdu_buffer
+)
+//------------------------------------------------------------------------------
+{
+    ssize_t encoded;
+    NR_DL_DCCH_Message_t   dl_dcch_msg;
+    memset(&dl_dcch_msg, 0, sizeof(NR_DL_DCCH_Message_t));
+    dl_dcch_msg.message.present            = NR_DL_DCCH_MessageType_PR_c1;
+    dl_dcch_msg.message.choice.c1          = CALLOC(1, sizeof(struct NR_DL_DCCH_MessageType__c1));
+    dl_dcch_msg.message.choice.c1->present = NR_DL_DCCH_MessageType__c1_PR_dlInformationTransfer;
+
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer = CALLOC(1, sizeof(NR_DLInformationTransfer_t));
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->rrc_TransactionIdentifier = transaction_id;
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->criticalExtensions.present =
+        NR_DLInformationTransfer__criticalExtensions_PR_dlInformationTransfer;
+
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->
+        criticalExtensions.choice.dlInformationTransfer = CALLOC(1, sizeof(NR_DLInformationTransfer_IEs_t));
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->
+        criticalExtensions.choice.dlInformationTransfer->dedicatedNAS_Message = CALLOC(1, sizeof(NR_DedicatedNAS_Message_t));
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->
+        criticalExtensions.choice.dlInformationTransfer->dedicatedNAS_Message->buf = pdu_buffer;
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->
+        criticalExtensions.choice.dlInformationTransfer->dedicatedNAS_Message->size = pdu_length;
+
+    encoded = uper_encode_to_new_buffer (&asn_DEF_NR_DL_DCCH_Message, NULL, (void *) &dl_dcch_msg, (void **)buffer);
+    AssertFatal(encoded > 0,"ASN1 message encoding failed (%s, %lu)!\n",
+                "DLInformationTransfer", encoded);
+    LOG_D(NR_RRC,"DLInformationTransfer Encoded %zd bytes\n", encoded);
+    return encoded;
+}
+
+uint8_t do_NR_ULInformationTransfer(uint8_t **buffer, uint32_t pdu_length, uint8_t *pdu_buffer) {
+    ssize_t encoded;
+    NR_UL_DCCH_Message_t ul_dcch_msg;
+    memset(&ul_dcch_msg, 0, sizeof(NR_UL_DCCH_Message_t));
+    ul_dcch_msg.message.present           = NR_UL_DCCH_MessageType_PR_c1;
+    ul_dcch_msg.message.choice.c1          = CALLOC(1,sizeof(struct NR_UL_DCCH_MessageType__c1));
+    ul_dcch_msg.message.choice.c1->present = NR_UL_DCCH_MessageType__c1_PR_ulInformationTransfer;
+    ul_dcch_msg.message.choice.c1->choice.ulInformationTransfer = CALLOC(1,sizeof(struct NR_ULInformationTransfer));
+    ul_dcch_msg.message.choice.c1->choice.ulInformationTransfer->criticalExtensions.present = NR_ULInformationTransfer__criticalExtensions_PR_ulInformationTransfer;
+    ul_dcch_msg.message.choice.c1->choice.ulInformationTransfer->criticalExtensions.choice.ulInformationTransfer = CALLOC(1,sizeof(struct NR_ULInformationTransfer_IEs));
+    struct NR_ULInformationTransfer_IEs *ulInformationTransfer = ul_dcch_msg.message.choice.c1->choice.ulInformationTransfer->criticalExtensions.choice.ulInformationTransfer;
+    ulInformationTransfer->dedicatedNAS_Message = CALLOC(1,sizeof(NR_DedicatedNAS_Message_t));
+    ulInformationTransfer->dedicatedNAS_Message->buf = pdu_buffer;
+    ulInformationTransfer->dedicatedNAS_Message->size = pdu_length;
+    ulInformationTransfer->lateNonCriticalExtension = NULL;
+    encoded = uper_encode_to_new_buffer (&asn_DEF_NR_UL_DCCH_Message, NULL, (void *) &ul_dcch_msg, (void **) buffer);
+    AssertFatal(encoded > 0,"ASN1 message encoding failed (%s, %lu)!\n",
+                "ULInformationTransfer",encoded);
+    LOG_D(NR_RRC,"ULInformationTransfer Encoded %zd bytes\n",encoded);
+
+    return encoded;
+}

openair2/RRC/NR/nr_rrc_proto.h

@@ -50,6 +50,7 @@ int8_t mac_rrc_nr_data_req(const module_id_t Mod_idP,
                            const int         CC_id,
                            const frame_t     frameP,
                            const rb_id_t     Srb_id,
+                           const rnti_t      rnti,
                            const uint8_t     Nb_tb,
                            uint8_t *const    buffer_pP );
 
@@ -64,7 +65,7 @@ void rrc_gNB_generate_SgNBAdditionRequestAcknowledge(
      );
 
 struct rrc_gNB_ue_context_s *rrc_gNB_allocate_new_UE_context(gNB_RRC_INST *rrc_instance_pP);
-
+struct rrc_gNB_ue_context_s *rrc_gNB_get_ue_context(gNB_RRC_INST *rrc_instance_pP,rnti_t rntiP);
 void rrc_parse_ue_capabilities(gNB_RRC_INST *rrc,LTE_UE_CapabilityRAT_ContainerList_t *UE_CapabilityRAT_ContainerList, x2ap_ENDC_sgnb_addition_req_t *m, NR_CG_ConfigInfo_IEs_t * cg_config_info);
 
 void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_p, x2ap_ENDC_sgnb_addition_req_t *m);
@@ -141,3 +142,22 @@ nr_rrc_data_req(
 int
 nr_rrc_mac_remove_ue(module_id_t mod_idP,
                   rnti_t rntiP);
+
+int8_t nr_mac_rrc_data_ind(
+  const module_id_t     module_idP,
+  const int             CC_id,
+  const frame_t         frameP,
+  const sub_frame_t     sub_frameP,
+  const int             UE_id,
+  const rnti_t          rntiP,
+  const rb_id_t         srb_idP,
+  const uint8_t        *sduP,
+  const sdu_size_t      sdu_lenP,
+  const uint8_t         mbsfn_sync_areaP,
+  const boolean_t   brOption
+);
+
+int nr_rrc_gNB_decode_ccch(protocol_ctxt_t    *const ctxt_pP,
+                           const uint8_t      *buffer,
+                           int                buffer_length,
+                           const int          CC_id);

openair2/RRC/NR/rrc_gNB.c

@@ -225,7 +225,7 @@ static void init_NR_SI(gNB_RRC_INST *rrc, gNB_RrcConfigurationReq *configuration
                          (NR_CellGroupConfig_t *)NULL
                         );
 
-  if (get_softmodem_params()->phy_test > 0 || get_softmodem_params()->do_ra > 0) {
+  if (get_softmodem_params()->phy_test > 0 || get_softmodem_params()->do_ra > 0 || get_softmodem_params()->sa_ra > 0) {
     // This is for phytest only, emulate first X2 message if uecap.raw file is present
     FILE *fd;
     fd = fopen("uecap.raw","r");
@@ -402,6 +402,17 @@ rrc_gNB_generate_RRCSetup(
   ue_context_pP->ue_context.ue_release_timer_thres = 1000;
   /* init timers */
   //   ue_context_pP->ue_context.ue_rrc_inactivity_timer = 0;
+
+  log_dump(NR_RRC, ue_p->Srb0.Tx_buffer.Payload, 16, LOG_DUMP_CHAR,"RRCSetup size: ");
+  // nr_rrc_data_req(ctxt_pP,
+  //           DCCH,
+  //           rrc_gNB_mui++,
+  //           SDU_CONFIRM_NO,
+  //           ue_p->Srb0.Tx_buffer.payload_size,
+  //           ue_p->Srb0.Tx_buffer.Payload,
+  //           PDCP_TRANSMISSION_MODE_CONTROL);
+  
+
 #ifdef ITTI_SIM
   MessageDef *message_p;
   uint8_t *message_buffer;
@@ -727,7 +738,7 @@ int nr_rrc_gNB_decode_ccch(protocol_ctxt_t    *const ctxt_pP,
                           100,
                           0,
                           0);
-
+                            
   if (dec_rval.consumed == 0) {
     /* TODO */
     LOG_E(NR_RRC, PROTOCOL_NR_RRC_CTXT_UE_FMT" FATAL Error in receiving CCCH\n",
@@ -946,7 +957,7 @@ rrc_gNB_decode_dcch(
                   sdu_sizeP,
                   0,
                   0);
-  // xer_fprint(stdout, &asn_DEF_NR_UL_DCCH_Message, (void *)&ul_dcch_msg);
+  xer_fprint(stdout, &asn_DEF_NR_UL_DCCH_Message, (void *)ul_dcch_msg);
 
   {
     for (i = 0; i < sdu_sizeP; i++) {
@@ -1298,13 +1309,14 @@ void *rrc_gnb_task(void *args_p) {
 
       /* Messages from MAC */
       case NR_RRC_MAC_CCCH_DATA_IND:
-      // PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt,
-      //                               NR_RRC_MAC_CCCH_DATA_IND(msg_p).gnb_index,
-      //                               GNB_FLAG_YES,
-      //                               NR_RRC_MAC_CCCH_DATA_IND(msg_p).rnti,
-      //                               msg_p->ittiMsgHeader.lte_time.frame,
-      //                               msg_p->ittiMsgHeader.lte_time.slot);
-        LOG_I(NR_RRC,"Decoding CCCH : inst %d, CC_id %d, ctxt %p, sib_info_p->Rx_buffer.payload_size %d\n",
+        PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt,
+                                    NR_RRC_MAC_CCCH_DATA_IND(msg_p).gnb_index,
+                                    GNB_FLAG_YES,
+                                    NR_RRC_MAC_CCCH_DATA_IND(msg_p).rnti,
+                                    msg_p->ittiMsgHeader.lte_time.frame,
+                                    msg_p->ittiMsgHeader.lte_time.slot);
+        LOG_I(NR_RRC,"Decoding CCCH : ue %d, inst %d, CC_id %d, ctxt %p, size %d\n",
+                ctxt.rnti,
                 instance,
                 NR_RRC_MAC_CCCH_DATA_IND(msg_p).CC_id,
                 &ctxt,
@@ -1324,12 +1336,17 @@ void *rrc_gnb_task(void *args_p) {
 
       /* Messages from PDCP */
       case NR_RRC_DCCH_DATA_IND:
-        // PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt,
-        //                               instance,
-        //                               ENB_FLAG_YES,
-        //                               RRC_DCCH_DATA_IND(msg_p).rnti,
-        //                               msg_p->ittiMsgHeader.lte_time.frame,
-        //                               msg_p->ittiMsgHeader.lte_time.slot);
+        PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt,
+                                      instance,
+                                      ENB_FLAG_YES,
+                                      RRC_DCCH_DATA_IND(msg_p).rnti,
+                                      msg_p->ittiMsgHeader.lte_time.frame,
+                                      msg_p->ittiMsgHeader.lte_time.slot);
+        LOG_I(NR_RRC,"Decoding DCCH : ue %d, inst %d, ctxt %p, size %d\n",
+                ctxt.rnti,
+                instance,
+                &ctxt,
+                NR_RRC_DCCH_DATA_IND(msg_p).sdu_size);
         LOG_D(NR_RRC, PROTOCOL_NR_RRC_CTXT_UE_FMT" Received on DCCH %d %s\n",
                 PROTOCOL_NR_RRC_CTXT_UE_ARGS(&ctxt),
                 NR_RRC_DCCH_DATA_IND(msg_p).dcch_index,

openair2/RRC/NR/rrc_gNB_internode.c

@@ -98,7 +98,7 @@ int generate_CG_Config(gNB_RRC_INST *rrc,
   total_size = (enc_rval.encoded+7)>>3;
 
   FILE *fd; // file to be generated for nr-ue
-  if (get_softmodem_params()->phy_test==1 || get_softmodem_params()->do_ra > 0) {
+  if (get_softmodem_params()->phy_test==1 || get_softmodem_params()->do_ra > 0 || get_softmodem_params()->sa_ra > 0) {
     // This is for phytest only, emulate first X2 message if uecap.raw file is present
     LOG_I(RRC,"Dumping NR_RRCReconfiguration message (%jd bytes)\n",(enc_rval.encoded+7)>>3);
     for (int i=0; i<(enc_rval.encoded+7)>>3; i++) {
@@ -123,7 +123,7 @@ int generate_CG_Config(gNB_RRC_INST *rrc,
 
 
   
-  if (get_softmodem_params()->phy_test==1 || get_softmodem_params()->do_ra > 0) {  
+  if (get_softmodem_params()->phy_test==1 || get_softmodem_params()->do_ra > 0 || get_softmodem_params()->sa_ra > 0) {  
 
     LOG_I(RRC,"Dumping scg_RB_Config message (%jd bytes)\n",(enc_rval.encoded+7)>>3);
     for (int i=0; i<(enc_rval.encoded+7)>>3; i++) {

openair2/RRC/NR/rrc_gNB_nsa.c

@@ -162,7 +162,7 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_
   NR_RRCReconfiguration_IEs_t *reconfig_ies=calloc(1,sizeof(NR_RRCReconfiguration_IEs_t));
   ue_context_p->ue_context.reconfig->criticalExtensions.choice.rrcReconfiguration = reconfig_ies;
   carrier->initial_csi_index[rrc->Nb_ue] = 0;
-  if (get_softmodem_params()->phy_test == 1 || get_softmodem_params()->do_ra == 1){
+  if (get_softmodem_params()->phy_test == 1 || get_softmodem_params()->do_ra == 1 || get_softmodem_params()->sa_ra == 1){
     ue_context_p->ue_context.rb_config = calloc(1,sizeof(NR_RRCReconfiguration_t));
     fill_default_rbconfig(ue_context_p->ue_context.rb_config);
   }
@@ -255,7 +255,7 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_
                               1024);
     X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg).rrc_buffer_size = (enc_rval.encoded+7)>>3;
     itti_send_msg_to_task(TASK_X2AP, ENB_MODULE_ID_TO_INSTANCE(0), msg); //Check right id instead of hardcoding
-  } else if (get_softmodem_params()->do_ra) {
+  } else if (get_softmodem_params()->do_ra || get_softmodem_params()->sa_ra) {
     PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, rrc->module_id, GNB_FLAG_YES, ue_context_p->ue_id_rnti, 0, 0,rrc->module_id);
   }
 

openair2/RRC/NR/rrc_gNB_reconfig.c

@@ -79,7 +79,7 @@ void fill_default_secondaryCellGroup(NR_ServingCellConfigCommon_t *servingcellco
   secondaryCellGroup->cellGroupId = scg_id;
   NR_RLC_BearerConfig_t *RLC_BearerConfig = calloc(1,sizeof(*RLC_BearerConfig));
   nr_rlc_bearer_init(RLC_BearerConfig);
-  if (get_softmodem_params()->do_ra)
+  if ((get_softmodem_params()->do_ra) || (get_softmodem_params()->sa_ra))
     nr_drb_config(RLC_BearerConfig->rlc_Config, NR_RLC_Config_PR_um_Bi_Directional);
   else
     nr_drb_config(RLC_BearerConfig->rlc_Config, NR_RLC_Config_PR_am);
@@ -129,7 +129,7 @@ void fill_default_secondaryCellGroup(NR_ServingCellConfigCommon_t *servingcellco
   *secondaryCellGroup->spCellConfig->servCellIndex = servCellIndex;
   secondaryCellGroup->spCellConfig->reconfigurationWithSync=calloc(1,sizeof(*secondaryCellGroup->spCellConfig->reconfigurationWithSync));
   secondaryCellGroup->spCellConfig->reconfigurationWithSync->spCellConfigCommon=servingcellconfigcommon;
-  secondaryCellGroup->spCellConfig->reconfigurationWithSync->newUE_Identity=(get_softmodem_params()->phy_test==1) ? 0x1234 : (taus()&0xffff);
+  secondaryCellGroup->spCellConfig->reconfigurationWithSync->newUE_Identity=0x1234;//(get_softmodem_params()->phy_test==1) ? 0x1234 : (taus()&0xffff);
   secondaryCellGroup->spCellConfig->reconfigurationWithSync->t304=NR_ReconfigurationWithSync__t304_ms2000;
   secondaryCellGroup->spCellConfig->reconfigurationWithSync->rach_ConfigDedicated = NULL;
   secondaryCellGroup->spCellConfig->reconfigurationWithSync->ext1                 = NULL;

openair2/RRC/NR_UE/L2_interface_ue.c

@@ -33,6 +33,7 @@
 #include "rrc_defs.h"
 #include "rrc_proto.h"
 #include "assertions.h"
+#include "rrc_vars.h"
 
 typedef uint32_t channel_t;
 
@@ -41,14 +42,44 @@ nr_mac_rrc_data_ind_ue(
     const module_id_t     module_id,
     const int             CC_id,
     const uint8_t         gNB_index,
+    const frame_t         frame,
+    const sub_frame_t     sub_frame,
+    const rnti_t          rnti,
     const channel_t       channel,
     const uint8_t*        pduP,
     const sdu_size_t      pdu_len){
+    sdu_size_t      sdu_size = 0;
+    protocol_ctxt_t ctxt;
 
     switch(channel){
         case NR_BCCH_BCH:
             AssertFatal( nr_rrc_ue_decode_NR_BCCH_BCH_Message( module_id, gNB_index, (uint8_t*)pduP, pdu_len) == 0, "UE decode BCCH-BCH error!\n");
             break;
+        case CCCH:
+             if (pdu_len>0) {
+                LOG_T(RRC,"[UE %d] Received SDU for CCCH on SRB %ld from gNB %d\n",module_id,channel & RAB_OFFSET,gNB_index);
+                {
+                  MessageDef *message_p;
+                  int msg_sdu_size = CCCH_SDU_SIZE;
+
+                  if (pdu_len > msg_sdu_size) {
+                    LOG_E(RRC, "SDU larger than CCCH SDU buffer size (%d, %d)", sdu_size, msg_sdu_size);
+                    sdu_size = msg_sdu_size;
+                  } else {
+                    sdu_size =  pdu_len;
+                  }
+
+                  message_p = itti_alloc_new_message (TASK_MAC_UE, NR_RRC_MAC_CCCH_DATA_IND); 
+                  memset (NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu, 0, CCCH_SDU_SIZE);
+                  memcpy (NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu, pduP, sdu_size);
+                  NR_RRC_MAC_CCCH_DATA_IND (message_p).frame     = frame; //frameP
+                  NR_RRC_MAC_CCCH_DATA_IND (message_p).sub_frame = sub_frame; //sub_frameP
+                  NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu_size  = sdu_size;
+                  NR_RRC_MAC_CCCH_DATA_IND (message_p).gnb_index = gNB_index;
+                  NR_RRC_MAC_CCCH_DATA_IND (message_p).rnti      = rnti;  //rntiP
+                  itti_send_msg_to_task (TASK_RRC_NRUE, GNB_MODULE_ID_TO_INSTANCE( module_id ), message_p);
+                }
+            }
         default:
             break;
     }
@@ -58,13 +89,49 @@ nr_mac_rrc_data_ind_ue(
 
 }
 
-int8_t mac_rrc_nr_data_req_ue(const module_id_t Mod_idP,
-                              const int         CC_id,
-                              const frame_t     frameP,
-                              const rb_id_t     Srb_id,
-                              uint8_t *const    buffer_pP ){
+int8_t mac_rrc_nr_data_req_ue(  
+  const module_id_t Mod_idP,
+  const int         CC_id,
+  const frame_t     frameP,
+  const rb_id_t     Srb_id,
+  const uint8_t     Nb_tb,
+  uint8_t    *const buffer_pP,
+  const uint8_t     gNB_index,
+  const uint8_t     mbsfn_sync_area
+){
 
   // todo
+  if( (NR_UE_rrc_inst[Mod_idP].Srb0[gNB_index].Tx_buffer.payload_size > 0) ) {
+    
+  //     MessageDef *message_p;
+  //     int ccch_size = NR_UE_rrc_inst[Mod_idP].Srb0[gNB_index].Tx_buffer.payload_size;
+  //     int sdu_size = sizeof(RRC_MAC_CCCH_DATA_REQ (message_p).sdu);
+
+  //     if (ccch_size > sdu_size) {
+  //       LOG_E(RRC, "SDU larger than CCCH SDU buffer size (%d, %d)", ccch_size, sdu_size);
+  //       ccch_size = sdu_size;
+  //     }
+
+  //     message_p = itti_alloc_new_message (TASK_RRC_UE, RRC_MAC_CCCH_DATA_REQ);
+  //     RRC_MAC_CCCH_DATA_REQ (message_p).frame = frameP;
+  //     RRC_MAC_CCCH_DATA_REQ (message_p).sdu_size = ccch_size;
+  //     memset (RRC_MAC_CCCH_DATA_REQ (message_p).sdu, 0, CCCH_SDU_SIZE);
+  //     memcpy (RRC_MAC_CCCH_DATA_REQ (message_p).sdu, NR_UE_rrc_inst[Mod_idP].Srb0[gNB_index].Tx_buffer.Payload, ccch_size);
+  //     RRC_MAC_CCCH_DATA_REQ (message_p).enb_index = gNB_index;
+
+  //     itti_send_msg_to_task (TASK_MAC_UE, UE_MODULE_ID_TO_INSTANCE(Mod_idP), message_p);
+  //   }
+    memset (buffer_pP, 0,sizeof(buffer_pP));
+    memcpy(&buffer_pP[0],&NR_UE_rrc_inst[Mod_idP].Srb0[gNB_index].Tx_buffer.Payload[0],NR_UE_rrc_inst[Mod_idP].Srb0[gNB_index].Tx_buffer.payload_size);
+    uint8_t Ret_size=NR_UE_rrc_inst[Mod_idP].Srb0[gNB_index].Tx_buffer.payload_size;
+    //   NR_UE_rrc_inst[Mod_id].Srb0[eNB_index].Tx_buffer.payload_size=0;
+    NR_UE_rrc_inst[Mod_idP].Info[gNB_index].T300_active = 1;
+    NR_UE_rrc_inst[Mod_idP].Info[gNB_index].T300_cnt = 0;
+    //      msg("[RRC][UE %d] Sending rach\n",Mod_id);
+    return(Ret_size);
+  } else {
+    return 0;
+  }
 
   return 0;
 }
@@ -84,11 +151,11 @@ rrc_data_req_ue(
     // Uses a new buffer to avoid issue with PDCP buffer content that could be changed by PDCP (asynchronous message handling).
     uint8_t *message_buffer;
     message_buffer = itti_malloc (
-                       ctxt_pP->enb_flag ? TASK_RRC_ENB : TASK_RRC_UE,
-                       ctxt_pP->enb_flag ? TASK_PDCP_ENB : TASK_PDCP_UE,
+                       TASK_RRC_UE,
+                       TASK_PDCP_UE,
                        sdu_sizeP);
     memcpy (message_buffer, buffer_pP, sdu_sizeP);
-    message_p = itti_alloc_new_message (ctxt_pP->enb_flag ? TASK_RRC_ENB : TASK_RRC_UE, RRC_DCCH_DATA_REQ);
+    message_p = itti_alloc_new_message ( TASK_RRC_UE, RRC_DCCH_DATA_REQ);
     RRC_DCCH_DATA_REQ (message_p).frame     = ctxt_pP->frame;
     RRC_DCCH_DATA_REQ (message_p).enb_flag  = ctxt_pP->enb_flag;
     RRC_DCCH_DATA_REQ (message_p).rb_id     = rb_idP;
@@ -107,3 +174,4 @@ rrc_data_req_ue(
     return TRUE; // TODO should be changed to a CNF message later, currently RRC lite does not used the returned value anyway.
 
 }
+

openair2/RRC/NR_UE/rrc_UE.c

@@ -458,7 +458,7 @@ NR_UE_RRC_INST_t* openair_rrc_top_init_ue_nr(char* rrc_config_path){
       RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].CSI_ReportConfig_list, NR_maxNrofCSI_ReportConfigurations);
     }
 
-    if (get_softmodem_params()->phy_test==1 || get_softmodem_params()->do_ra==1) {
+    if (get_softmodem_params()->phy_test==1 || get_softmodem_params()->do_ra || get_softmodem_params()->sa_ra ==1) {
       // read in files for RRCReconfiguration and RBconfig
       FILE *fd;
       char filename[1024];
@@ -995,7 +995,7 @@ int nr_decode_SI( const protocol_ctxt_t *const ctxt_pP, const uint8_t gNB_index
       if (NR_UE_rrc_inst[ctxt_pP->module_id].Info[gNB_index].SIcnt == sib1->si_SchedulingInfo->schedulingInfoList.list.count)
         nr_rrc_set_sub_state( ctxt_pP->module_id, RRC_SUB_STATE_IDLE_SIB_COMPLETE );
   
-      LOG_I(RRC,"SIStatus %x, SIcnt %d/%d\n",
+      LOG_I(NR_RRC,"SIStatus %x, SIcnt %d/%d\n",
             NR_UE_rrc_inst[ctxt_pP->module_id].Info[gNB_index].SIStatus,
             NR_UE_rrc_inst[ctxt_pP->module_id].Info[gNB_index].SIcnt,
             sib1->si_SchedulingInfo->schedulingInfoList.list.count);
@@ -1162,7 +1162,7 @@ int nr_decode_SIB1( const protocol_ctxt_t *const ctxt_pP, const uint8_t gNB_inde
         ) {
           /* PLMN match, send a confirmation to NAS */
           MessageDef  *msg_p;
-          msg_p = itti_alloc_new_message(TASK_RRC_UE, NAS_CELL_SELECTION_CNF);
+          msg_p = itti_alloc_new_message(TASK_RRC_NRUE, NAS_CELL_SELECTION_CNF);
           NAS_CELL_SELECTION_CNF (msg_p).errCode = AS_SUCCESS;
           NAS_CELL_SELECTION_CNF (msg_p).cellID = BIT_STRING_to_uint32(&sib1->cellAccessRelatedInfo.plmn_IdentityList.list.array[0]->cellIdentity);
           NAS_CELL_SELECTION_CNF (msg_p).tac = BIT_STRING_to_uint16(sib1->cellAccessRelatedInfo.plmn_IdentityList.list.array[0]->trackingAreaCode);
@@ -1180,7 +1180,7 @@ int nr_decode_SIB1( const protocol_ctxt_t *const ctxt_pP, const uint8_t gNB_inde
     if (cell_valid == 0) {
       /* Cell can not be used, ask PHY to try the next one */
       MessageDef  *msg_p;
-      msg_p = itti_alloc_new_message(TASK_RRC_UE, PHY_FIND_NEXT_CELL_REQ);
+      msg_p = itti_alloc_new_message(TASK_RRC_NRUE, PHY_FIND_NEXT_CELL_REQ);
       itti_send_msg_to_task(TASK_PHY_UE, ctxt_pP->instance, msg_p);
       LOG_E(RRC,
             "Synched with a cell, but PLMN doesn't match our SIM "
@@ -1416,6 +1416,7 @@ int8_t nr_rrc_ue_decode_ccch( const protocol_ctxt_t *const ctxt_pP, const NR_SRB
     return -1;
   }
   
+  NR_UE_rrc_inst[ctxt_pP->module_id].Info[gNB_index].State = NR_RRC_SI_RECEIVED;
   if (dl_ccch_msg->message.present == NR_DL_CCCH_MessageType_PR_c1) {
     if (NR_UE_rrc_inst[ctxt_pP->module_id].Info[gNB_index].State == NR_RRC_SI_RECEIVED) {
       switch (dl_ccch_msg->message.choice.c1->present) {
@@ -1723,7 +1724,7 @@ nr_rrc_ue_process_securityModeCommand(
     GNB_RRC_DCCH_DATA_IND (message_p).size    = (enc_rval.encoded + 7) / 8;
     itti_send_msg_to_task (TASK_RRC_GNB_SIM, ctxt_pP->instance, message_p);
 #else
-    rrc_data_req (
+    rrc_data_req_ue (
       ctxt_pP,
       DCCH,
       nr_rrc_mui++,
@@ -1755,11 +1756,11 @@ void rrc_ue_generate_RRCSetupRequest( const protocol_ctxt_t *const ctxt_pP, cons
     }
 
     LOG_T(NR_RRC,"\n");
-    // NR_UE_rrc_inst[ctxt_pP->module_id].Srb0[gNB_index].Tx_buffer.payload_size =
-    //   do_RRCSetupRequest(
-    //     ctxt_pP->module_id,
-    //     (uint8_t *)NR_UE_rrc_inst[ctxt_pP->module_id].Srb0[gNB_index].Tx_buffer.Payload,
-    //     rv);
+    NR_UE_rrc_inst[ctxt_pP->module_id].Srb0[gNB_index].Tx_buffer.payload_size =
+      do_RRCSetupRequest(
+        ctxt_pP->module_id,
+        (uint8_t *)NR_UE_rrc_inst[ctxt_pP->module_id].Srb0[gNB_index].Tx_buffer.Payload,
+        rv);
     LOG_I(NR_RRC,"[UE %d] : Frame %d, Logical Channel UL-CCCH (SRB0), Generating RRCSetupRequest (bytes %d, eNB %d)\n",
           ctxt_pP->module_id, ctxt_pP->frame, NR_UE_rrc_inst[ctxt_pP->module_id].Srb0[gNB_index].Tx_buffer.payload_size, gNB_index);
 
@@ -1771,6 +1772,17 @@ void rrc_ue_generate_RRCSetupRequest( const protocol_ctxt_t *const ctxt_pP, cons
     /*UE_rrc_inst[ue_mod_idP].Srb0[Idx].Tx_buffer.Payload[i] = taus()&0xff;
     UE_rrc_inst[ue_mod_idP].Srb0[Idx].Tx_buffer.payload_size =i; */
 
+    log_dump(RRC,NR_UE_rrc_inst[ctxt_pP->module_id].Srb0[gNB_index].Tx_buffer.Payload,NR_UE_rrc_inst[ctxt_pP->module_id].Srb0[gNB_index].Tx_buffer.payload_size,
+    LOG_DUMP_CHAR,"RRCSetupRequest :\n");
+    rrc_data_req_ue (
+      ctxt_pP,
+      DCCH,
+      nr_rrc_mui++,
+      SDU_CONFIRM_NO,
+      NR_UE_rrc_inst[ctxt_pP->module_id].Srb0[gNB_index].Tx_buffer.payload_size,
+      (uint8_t *)NR_UE_rrc_inst[ctxt_pP->module_id].Srb0[gNB_index].Tx_buffer.Payload,
+      PDCP_TRANSMISSION_MODE_CONTROL);
+
 #ifdef ITTI_SIM
     MessageDef *message_p;
     uint8_t *message_buffer;
@@ -1934,7 +1946,7 @@ nr_rrc_ue_process_measConfig(
                   (char *)measConfig->reportConfigToAddModList->list.array[i],
                   sizeof(NR_ReportConfigToAddMod_t));
       } else {
-        LOG_D(RRC,"Adding Report Configuration %ld %p \n", ind-1, measConfig->reportConfigToAddModList->list.array[i]);
+        LOG_D(NR_RRC,"Adding Report Configuration %ld %p \n", ind-1, measConfig->reportConfigToAddModList->list.array[i]);
         if (reportConfig->reportConfig.present == NR_ReportConfigToAddMod__reportConfig_PR_reportConfigNR) {
             NR_UE_rrc_inst[ctxt_pP->module_id].ReportConfig[gNB_index][ind-1] = measConfig->reportConfigToAddModList->list.array[i];
         }
@@ -1967,7 +1979,7 @@ nr_rrc_ue_process_measConfig(
 
   if (measConfig->quantityConfig != NULL) {
     if (NR_UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[gNB_index]) {
-      LOG_D(RRC,"Modifying Quantity Configuration \n");
+      LOG_D(NR_RRC,"Modifying Quantity Configuration \n");
       memcpy((char *)NR_UE_rrc_inst[ctxt_pP->module_id].QuantityConfig[gNB_index],
               (char *)measConfig->quantityConfig,
               sizeof(NR_QuantityConfig_t));
@@ -2191,7 +2203,30 @@ rrc_ue_process_rrcReconfiguration(
       for (list_count = 0; list_count < ie->nonCriticalExtension->dedicatedNAS_MessageList->list.count; list_count++) {
         pdu_length = ie->nonCriticalExtension->dedicatedNAS_MessageList->list.array[list_count]->size;
         pdu_buffer = ie->nonCriticalExtension->dedicatedNAS_MessageList->list.array[list_count]->buf;
-        msg_p = itti_alloc_new_message(TASK_RRC_UE, NAS_CONN_ESTABLI_CNF);
+
+        uint8_t msg_type = 0;
+        if((pdu_buffer + 1) != NULL){
+          if (*(pdu_buffer + 1) > 0 ) {
+            if(pdu_buffer + 9){
+                msg_type = *(pdu_buffer + 9);
+            } else {
+              LOG_W(NR_RRC, "[UE] Received invalid downlink message\n");
+              return;
+            }
+          } else {
+            if(pdu_buffer + 2){
+              msg_type = *(pdu_buffer + 2);
+            } else {
+                LOG_W(NR_RRC, "[UE] Received invalid downlink message\n");
+                return;
+            }
+          }
+        }
+        if(msg_type == 0x42 /*REGISTRATION_ACCEPT*/){
+          LOG_I(NR_RRC, "[UE] Received REGISTRATION ACCEPT message\n");
+        }
+
+        msg_p = itti_alloc_new_message(TASK_RRC_NRUE, NAS_CONN_ESTABLI_CNF);
         NAS_CONN_ESTABLI_CNF(msg_p).errCode = AS_SUCCESS;
         NAS_CONN_ESTABLI_CNF(msg_p).nasMsg.length = pdu_length;
         NAS_CONN_ESTABLI_CNF(msg_p).nasMsg.data = pdu_buffer;
@@ -2284,23 +2319,25 @@ nr_rrc_ue_decode_dcch(
   // }
 
   if (dl_dcch_msg->message.present == NR_DL_DCCH_MessageType_PR_c1) {
-    switch (dl_dcch_msg->message.choice.c1->present) {
-      case NR_DL_DCCH_MessageType__c1_PR_NOTHING:
+switch (dl_dcch_msg->message.choice.c1->present) {
+    case NR_DL_DCCH_MessageType__c1_PR_NOTHING:
         LOG_I(NR_RRC, "Received PR_NOTHING on DL-DCCH-Message\n");
         break;
 
-      case NR_DL_DCCH_MessageType__c1_PR_rrcReconfiguration:
+    case NR_DL_DCCH_MessageType__c1_PR_rrcReconfiguration:
+    {
         rrc_ue_process_rrcReconfiguration(ctxt_pP,
                                             dl_dcch_msg->message.choice.c1->choice.rrcReconfiguration,
                                             gNB_indexP);
         nr_rrc_ue_generate_RRCReconfigurationComplete(ctxt_pP,
                                     gNB_indexP,
                                     dl_dcch_msg->message.choice.c1->choice.rrcReconfiguration->rrc_TransactionIdentifier);
+    }
         break;
 
       case NR_DL_DCCH_MessageType__c1_PR_rrcResume:
       case NR_DL_DCCH_MessageType__c1_PR_rrcRelease:
-        msg_p = itti_alloc_new_message(TASK_RRC_UE, NAS_CONN_RELEASE_IND);
+        msg_p = itti_alloc_new_message(TASK_RRC_NRUE, NAS_CONN_RELEASE_IND);
 
         if((dl_dcch_msg->message.choice.c1->choice.rrcRelease->criticalExtensions.present == NR_RRCRelease__criticalExtensions_PR_rrcRelease) &&
            (dl_dcch_msg->message.choice.c1->present == NR_DL_DCCH_MessageType__c1_PR_rrcRelease)){
@@ -2313,7 +2350,7 @@ nr_rrc_ue_decode_dcch(
          itti_send_msg_to_task(TASK_NAS_UE, ctxt_pP->instance, msg_p);
          break;
       case NR_DL_DCCH_MessageType__c1_PR_ueCapabilityEnquiry:
-        LOG_I(RRC, "[UE %d] Received Capability Enquiry (gNB %d)\n",
+        LOG_I(NR_RRC, "[UE %d] Received Capability Enquiry (gNB %d)\n",
               ctxt_pP->module_id,gNB_indexP);
         nr_rrc_ue_process_ueCapabilityEnquiry(
           ctxt_pP,
@@ -2321,7 +2358,30 @@ nr_rrc_ue_decode_dcch(
           gNB_indexP);
          break;
       case NR_DL_DCCH_MessageType__c1_PR_rrcReestablishment:
+         break;
       case NR_DL_DCCH_MessageType__c1_PR_dlInformationTransfer:
+        {
+          NR_DLInformationTransfer_t *dlInformationTransfer = dl_dcch_msg->message.choice.c1->choice.dlInformationTransfer;
+
+          if (dlInformationTransfer->criticalExtensions.present
+                == NR_DLInformationTransfer__criticalExtensions_PR_dlInformationTransfer) {
+            /* This message hold a dedicated info NAS payload, forward it to NAS */
+            NR_DedicatedNAS_Message_t *dedicatedNAS_Message =
+                dlInformationTransfer->criticalExtensions.choice.dlInformationTransfer->dedicatedNAS_Message;
+            uint32_t pdu_length;
+            uint8_t *pdu_buffer;
+            pdu_length = dedicatedNAS_Message->size;
+            pdu_buffer = dedicatedNAS_Message->buf;
+
+            MessageDef *msg_p;
+            msg_p = itti_alloc_new_message(TASK_RRC_NRUE, NAS_DOWNLINK_DATA_IND);
+            NAS_DOWNLINK_DATA_IND(msg_p).UEid = ctxt_pP->module_id; // TODO set the UEid to something else ?
+            NAS_DOWNLINK_DATA_IND(msg_p).nasMsg.length = pdu_length;
+            NAS_DOWNLINK_DATA_IND(msg_p).nasMsg.data = pdu_buffer;
+            itti_send_msg_to_task(TASK_NAS_UE, ctxt_pP->instance, msg_p);
+          }
+        }
+        break;
       case NR_DL_DCCH_MessageType__c1_PR_mobilityFromNRCommand:
       case NR_DL_DCCH_MessageType__c1_PR_dlDedicatedMessageSegment_r16:
       case NR_DL_DCCH_MessageType__c1_PR_ueInformationRequest_r16:
@@ -2333,7 +2393,7 @@ nr_rrc_ue_decode_dcch(
       case NR_DL_DCCH_MessageType__c1_PR_counterCheck:
           break;
       case NR_DL_DCCH_MessageType__c1_PR_securityModeCommand:
-        LOG_I(RRC, "[UE %d] Received securityModeCommand (gNB %d)\n",
+        LOG_I(NR_RRC, "[UE %d] Received securityModeCommand (gNB %d)\n",
             ctxt_pP->module_id, gNB_indexP);
         nr_rrc_ue_process_securityModeCommand(
           ctxt_pP,
@@ -2385,7 +2445,7 @@ void *rrc_nrue_task( void *args_p ) {
                                    NR_RRC_MAC_BCCH_DATA_IND (msg_p).rsrp);
 
       case NR_RRC_MAC_CCCH_DATA_IND:
-        LOG_D(NR_RRC, "[UE %d] RNTI %x Received %s: frameP %d, gNB %d\n",
+        LOG_I(NR_RRC, "[UE %d] RNTI %x Received %s: frameP %d, gNB %d\n",
               ue_mod_id,
               NR_RRC_MAC_CCCH_DATA_IND (msg_p).rnti,
               ITTI_MSG_NAME (msg_p),
@@ -2405,7 +2465,7 @@ void *rrc_nrue_task( void *args_p ) {
       /* PDCP messages */
       case NR_RRC_DCCH_DATA_IND:
         PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, NR_RRC_DCCH_DATA_IND (msg_p).module_id, GNB_FLAG_NO, NR_RRC_DCCH_DATA_IND (msg_p).rnti, NR_RRC_DCCH_DATA_IND (msg_p).frame, 0,NR_RRC_DCCH_DATA_IND (msg_p).gNB_index);
-        LOG_D(NR_RRC, "[UE %d] Received %s: frameP %d, DCCH %d, gNB %d\n",
+        LOG_I(NR_RRC, "[UE %d] Received %s: frameP %d, DCCH %d, gNB %d\n",
               NR_RRC_DCCH_DATA_IND (msg_p).module_id,
               ITTI_MSG_NAME (msg_p),
               NR_RRC_DCCH_DATA_IND (msg_p).frame,
@@ -2469,7 +2529,7 @@ nr_rrc_ue_process_ueCapabilityEnquiry(
   NR_UE_CapabilityRAT_Container_t ue_CapabilityRAT_Container;
   uint8_t buffer[200];
   int i;
-  LOG_I(RRC,"[UE %d] Frame %d: Receiving from SRB1 (DL-DCCH), Processing UECapabilityEnquiry (gNB %d)\n",
+  LOG_I(NR_RRC,"[UE %d] Frame %d: Receiving from SRB1 (DL-DCCH), Processing UECapabilityEnquiry (gNB %d)\n",
         ctxt_pP->module_id,
         ctxt_pP->frame,
         gNB_index);

openair2/RRC/NR_UE/rrc_proto.h

@@ -100,7 +100,14 @@ int8_t nr_rrc_ue_decode_NR_DL_DCCH_Message(const module_id_t module_id, const ui
    \param channel    indicator for channel of the pdu
    \param pduP       pointer to pdu
    \param pdu_len    data length of pdu*/
-int8_t nr_mac_rrc_data_ind_ue(const module_id_t module_id, const int CC_id, const uint8_t gNB_index, const channel_t channel, const uint8_t* pduP, const sdu_size_t pdu_len);
+int8_t nr_mac_rrc_data_ind_ue(const module_id_t module_id, 
+                              const int CC_id, const uint8_t gNB_index, 
+                              const frame_t frame,
+                              const sub_frame_t sub_frame, 
+                              const rnti_t rnti, 
+                              const channel_t channel, 
+                              const uint8_t* pduP, 
+                              const sdu_size_t pdu_len);
 
 /**\brief
    \param module_id  module id
@@ -108,11 +115,15 @@ int8_t nr_mac_rrc_data_ind_ue(const module_id_t module_id, const int CC_id, cons
    \param frame_t    frameP
    \param rb_id_t    SRB id
    \param buffer_pP  pointer to buffer*/
-int8_t mac_rrc_nr_data_req_ue(const module_id_t Mod_idP,
-                              const int         CC_id,
-                              const frame_t     frameP,
-                              const rb_id_t     Srb_id,
-                              uint8_t *const    buffer_pP);
+int8_t mac_rrc_nr_data_req_ue(  
+  const module_id_t Mod_idP,
+  const int         CC_id,
+  const frame_t     frameP,
+  const rb_id_t     Srb_id,
+  const uint8_t     Nb_tb,
+  uint8_t    *const buffer_pP,
+  const uint8_t     gNB_index,
+  const uint8_t     mbsfn_sync_area);
 
 
 /**\brief RRC UE task.

targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpb210.gtp-itti.conf

@@ -0,0 +1,303 @@
+Active_gNBs = ( "gNB-Eurecom-5GNRBox");
+# Asn1_verbosity, choice in: none, info, annoying
+Asn1_verbosity = "none";
+
+gNBs =
+(
+ {
+    ////////// Identification parameters:
+    gNB_ID    =  0xe00;
+
+    cell_type =  "CELL_MACRO_GNB";
+
+    gNB_name  =  "gNB-Eurecom-5GNRBox";
+
+    // Tracking area code, 0x0000 and 0xfffe are reserved values
+    tracking_area_code  =  100;
+												
+    plmn_list = ({			
+			mcc = 208;		
+			mnc = 93;		
+			mnc_length = 2;		
+			snssaiList = (		
+				{	
+					sst = 1;
+					sd  = 0x010203; // 0 false, else true
+				},	
+				{	
+					sst = 1;
+					sd  = 0x112233; // 0 false, else true
+				}	
+			);		
+												
+			});		
+												
+    tr_s_preference     = "local_mac"
+
+    ////////// Physical parameters:
+
+    ssb_SubcarrierOffset                                      = 0;
+    pdsch_AntennaPorts                                        = 1;
+	
+    servingCellConfigCommon = (
+    {
+ #spCellConfigCommon
+
+      physCellId                                                    = 0;
+
+#  downlinkConfigCommon
+    #frequencyInfoDL
+      # this is 3600 MHz + 43 PRBs@30kHz SCS (same as initial BWP)
+      absoluteFrequencySSB                                          = 641032;
+      dl_frequencyBand                                                 = 78;
+      # this is 3600 MHz
+      dl_absoluteFrequencyPointA                                       = 640000;
+      #scs-SpecificCarrierList
+        dl_offstToCarrier                                              = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        dl_subcarrierSpacing                                           = 1;
+        dl_carrierBandwidth                                            = 106;
+     #initialDownlinkBWP
+      #genericParameters
+        # this is RBstart=41,L=24 (275*(L-1))+RBstart
+        initialDLBWPlocationAndBandwidth                                        = 6366;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        initialDLBWPsubcarrierSpacing                                           = 1;
+      #pdcch-ConfigCommon
+        initialDLBWPcontrolResourceSetZero                                      = 12;
+        initialDLBWPsearchSpaceZero                                             = 0;
+      #pdsch-ConfigCommon
+        #pdschTimeDomainAllocationList (up to 16 entries)
+             initialDLBWPk0_0                    = 0;
+             #initialULBWPmappingType
+	     #0=typeA,1=typeB
+             initialDLBWPmappingType_0           = 0;
+             #this is SS=1,L=13
+             initialDLBWPstartSymbolAndLength_0  = 40;
+
+             initialDLBWPk0_1                    = 0;
+             initialDLBWPmappingType_1           = 0;
+             #this is SS=2,L=12 
+             initialDLBWPstartSymbolAndLength_1  = 53;
+
+             initialDLBWPk0_2                    = 0;
+             initialDLBWPmappingType_2           = 0;
+             #this is SS=1,L=12 
+             initialDLBWPstartSymbolAndLength_2  = 54;
+
+             initialDLBWPk0_3                    = 0;
+             initialDLBWPmappingType_3           = 0;
+             #this is SS=1,L=5
+             initialDLBWPstartSymbolAndLength_3  = 57;
+
+  #uplinkConfigCommon 
+     #frequencyInfoUL
+      ul_frequencyBand                                                 = 78;
+      #scs-SpecificCarrierList
+      ul_offstToCarrier                                              = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      ul_subcarrierSpacing                                           = 1;
+      ul_carrierBandwidth                                            = 106;
+      pMax                                                          = 20;
+     #initialUplinkBWP
+      #genericParameters
+        initialULBWPlocationAndBandwidth                                        = 6366;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        initialULBWPsubcarrierSpacing                                           = 1;
+      #rach-ConfigCommon
+        #rach-ConfigGeneric
+          prach_ConfigurationIndex                                  = 98;
+#prach_msg1_FDM
+#0 = one, 1=two, 2=four, 3=eight
+          prach_msg1_FDM                                            = 0;
+          prach_msg1_FrequencyStart                                 = 0;
+          zeroCorrelationZoneConfig                                 = 13;
+          preambleReceivedTargetPower                               = -118;
+#preamblTransMax (0...10) = (3,4,5,6,7,8,10,20,50,100,200)
+          preambleTransMax                                          = 6;
+#powerRampingStep
+# 0=dB0,1=dB2,2=dB4,3=dB6
+        powerRampingStep                                            = 1;
+#ra_ReponseWindow
+#1,2,4,8,10,20,40,80
+        ra_ResponseWindow                                           = 4;
+#ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR
+#1=oneeighth,2=onefourth,3=half,4=one,5=two,6=four,7=eight,8=sixteen
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR                = 4;
+#oneHalf (0..15) 4,8,12,16,...60,64
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB                   = 15;
+#ra_ContentionResolutionTimer
+#(0..7) 8,16,24,32,40,48,56,64
+        ra_ContentionResolutionTimer                                = 7;
+        rsrp_ThresholdSSB                                           = 19;
+#prach-RootSequenceIndex_PR
+#1 = 839, 2 = 139
+        prach_RootSequenceIndex_PR                                  = 2;
+        prach_RootSequenceIndex                                     = 1;
+        # SCS for msg1, can only be 15 for 30 kHz < 6 GHz, takes precendence over the one derived from prach-ConfigIndex
+        #  
+        msg1_SubcarrierSpacing                                      = 1,
+
+# restrictedSetConfig
+# 0=unrestricted, 1=restricted type A, 2=restricted type B
+        restrictedSetConfig                                         = 0,
+      # pusch-ConfigCommon (up to 16 elements)
+        initialULBWPk2_0                      = 6;
+        initialULBWPmappingType_0             = 1
+        # this is SS=0 L=11
+        initialULBWPstartSymbolAndLength_0    = 55;
+
+        initialULBWPk2_1                      = 6;
+        initialULBWPmappingType_1             = 1;
+        # this is SS=0 L=12
+        initialULBWPstartSymbolAndLength_1    = 69;
+
+        initialULBWPk2_2                      = 7;
+        initialULBWPmappingType_2             = 1;
+        # this is SS=10 L=4
+        initialULBWPstartSymbolAndLength_2    = 52;
+
+        msg3_DeltaPreamble                                          = 1;
+        p0_NominalWithGrant                                         =-90;
+
+# pucch-ConfigCommon setup :
+# pucchGroupHopping
+# 0 = neither, 1= group hopping, 2=sequence hopping
+        pucchGroupHopping                                           = 0;
+        hoppingId                                                   = 40;
+        p0_nominal                                                  = -90;
+# ssb_PositionsInBurs_BitmapPR
+# 1=short, 2=medium, 3=long
+      ssb_PositionsInBurst_PR                                       = 2;
+      ssb_PositionsInBurst_Bitmap                                   = 1;
+
+# ssb_periodicityServingCell
+# 0 = ms5, 1=ms10, 2=ms20, 3=ms40, 4=ms80, 5=ms160, 6=spare2, 7=spare1 
+      ssb_periodicityServingCell                                    = 2;
+
+# dmrs_TypeA_position
+# 0 = pos2, 1 = pos3
+      dmrs_TypeA_Position                                           = 0;
+
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      subcarrierSpacing                                             = 1;
+
+
+  #tdd-UL-DL-ConfigurationCommon
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      referenceSubcarrierSpacing                                    = 1;
+      # pattern1 
+      # dl_UL_TransmissionPeriodicity
+      # 0=ms0p5, 1=ms0p625, 2=ms1, 3=ms1p25, 4=ms2, 5=ms2p5, 6=ms5, 7=ms10
+      dl_UL_TransmissionPeriodicity                                 = 6;
+      nrofDownlinkSlots                                             = 7;
+      nrofDownlinkSymbols                                           = 6;
+      nrofUplinkSlots                                               = 2;
+      nrofUplinkSymbols                                             = 4;
+
+  ssPBCH_BlockPower                                             = 10;
+  }
+
+  );
+
+
+    # ------- SCTP definitions
+    SCTP :
+    {
+        # Number of streams to use in input/output
+        SCTP_INSTREAMS  = 2;
+        SCTP_OUTSTREAMS = 2;
+    };
+
+												
+    ////////// AMF parameters:												
+    amf_ip_address      = ( { ipv4       = "192.168.199.223";												
+                              ipv6       = "192:168:199::223";												
+                              active     = "yes";												
+                              preference = "ipv4";												
+                            }												
+                          );												
+												
+						
+												
+    NETWORK_INTERFACES :												
+    {												
+												
+        GNB_INTERFACE_NAME_FOR_NG_AMF            = "eno1";												
+        GNB_IPV4_ADDRESS_FOR_NG_AMF              = "192.168.199.222/24";												
+        GNB_INTERFACE_NAME_FOR_NGU               = "enx000ec6c0a3ac";												
+        GNB_IPV4_ADDRESS_FOR_NGU                 = "192.168.10.100/24";												
+        GNB_PORT_FOR_NGU                         = 2152; # Spec 2152												
+        GNB_IPV4_ADDRESS_FOR_X2C                 = "192.168.20.20/24";												
+        GNB_PORT_FOR_X2C                         = 36422; # Spec 36422												
+    };												
+  }												
+);												
+
+MACRLCs = (
+	{
+	num_cc = 1;
+	tr_s_preference = "local_L1";
+	tr_n_preference = "local_RRC";
+        }  
+);
+
+L1s = (
+    	{
+	num_cc = 1;
+	tr_n_preference = "local_mac";
+        }  
+);
+
+
+RUs = (
+    {		  
+       local_rf       = "yes"
+         nb_tx          = 1
+         nb_rx          = 1
+         att_tx         = 0
+         att_rx         = 0;
+         bands          = [7];
+         max_pdschReferenceSignalPower = -27;
+         max_rxgain                    = 114;
+         eNB_instances  = [0];
+	 sdr_addrs = "type=b200";
+         #clock_src = "internal";
+    }
+);  
+
+THREAD_STRUCT = (
+  {
+    #three config for level of parallelism "PARALLEL_SINGLE_THREAD", "PARALLEL_RU_L1_SPLIT", or "PARALLEL_RU_L1_TRX_SPLIT"
+    parallel_config    = "PARALLEL_RU_L1_TRX_SPLIT";
+    #two option for worker "WORKER_DISABLE" or "WORKER_ENABLE"
+    worker_config      = "WORKER_ENABLE";
+  }
+);
+
+     log_config :
+     {
+       global_log_level                      ="info";
+       global_log_verbosity                  ="medium";
+       hw_log_level                          ="info";
+       hw_log_verbosity                      ="medium";
+       phy_log_level                         ="info";
+       phy_log_verbosity                     ="medium";
+       mac_log_level                         ="info";
+       mac_log_verbosity                     ="high";
+       rlc_log_level                         ="info";
+       rlc_log_verbosity                     ="medium";
+       pdcp_log_level                        ="info";
+       pdcp_log_verbosity                    ="medium";
+       rrc_log_level                         ="info";
+       rrc_log_verbosity                     ="medium";
+       ngap_log_level                         ="info";												
+       ngap_log_verbosity                    ="medium";												
+    };
+

targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpn300.gtp-itti.conf

@@ -0,0 +1,304 @@
+Active_gNBs = ( "gNB-Eurecom-5GNRBox");
+# Asn1_verbosity, choice in: none, info, annoying
+Asn1_verbosity = "none";
+
+gNBs =
+(
+ {
+    ////////// Identification parameters:
+    gNB_ID    =  0xe00;
+
+    cell_type =  "CELL_MACRO_GNB";
+
+    gNB_name  =  "gNB-Eurecom-5GNRBox";
+
+    // Tracking area code, 0x0000 and 0xfffe are reserved values
+    tracking_area_code  =  100;
+												
+    plmn_list = ({			
+			mcc = 208;		
+			mnc = 93;		
+			mnc_length = 2;		
+			snssaiList = (		
+				{	
+					sst = 1;
+					sd  = 0x010203; // 0 false, else true
+				},	
+				{	
+					sst = 1;
+					sd  = 0x112233; // 0 false, else true
+				}	
+			);		
+												
+			});		
+												
+    tr_s_preference     = "local_mac"
+
+    ////////// Physical parameters:
+
+    ssb_SubcarrierOffset                                      = 0;
+    pdsch_AntennaPorts                                        = 1;
+	
+    servingCellConfigCommon = (
+    {
+ #spCellConfigCommon
+
+      physCellId                                                    = 0;
+
+#  downlinkConfigCommon
+    #frequencyInfoDL
+      # this is 3600 MHz + 43 PRBs@30kHz SCS (same as initial BWP)
+      absoluteFrequencySSB                                          = 641032;
+      dl_frequencyBand                                                 = 78;
+      # this is 3600 MHz
+      dl_absoluteFrequencyPointA                                       = 640000;
+      #scs-SpecificCarrierList
+        dl_offstToCarrier                                              = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        dl_subcarrierSpacing                                           = 1;
+        dl_carrierBandwidth                                            = 106;
+     #initialDownlinkBWP
+      #genericParameters
+        # this is RBstart=41,L=24 (275*(L-1))+RBstart
+        initialDLBWPlocationAndBandwidth                                        = 6366;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        initialDLBWPsubcarrierSpacing                                           = 1;
+      #pdcch-ConfigCommon
+        initialDLBWPcontrolResourceSetZero                                      = 12;
+        initialDLBWPsearchSpaceZero                                             = 0;
+      #pdsch-ConfigCommon
+        #pdschTimeDomainAllocationList (up to 16 entries)
+             initialDLBWPk0_0                    = 0;
+             #initialULBWPmappingType
+	     #0=typeA,1=typeB
+             initialDLBWPmappingType_0           = 0;
+             #this is SS=1,L=13
+             initialDLBWPstartSymbolAndLength_0  = 40;
+
+             initialDLBWPk0_1                    = 0;
+             initialDLBWPmappingType_1           = 0;
+             #this is SS=2,L=12 
+             initialDLBWPstartSymbolAndLength_1  = 53;
+
+             initialDLBWPk0_2                    = 0;
+             initialDLBWPmappingType_2           = 0;
+             #this is SS=1,L=12 
+             initialDLBWPstartSymbolAndLength_2  = 54;
+
+             initialDLBWPk0_3                    = 0;
+             initialDLBWPmappingType_3           = 0;
+             #this is SS=1,L=5
+             initialDLBWPstartSymbolAndLength_3  = 57;
+
+  #uplinkConfigCommon 
+     #frequencyInfoUL
+      ul_frequencyBand                                                 = 78;
+      #scs-SpecificCarrierList
+      ul_offstToCarrier                                              = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      ul_subcarrierSpacing                                           = 1;
+      ul_carrierBandwidth                                            = 106;
+      pMax                                                          = 20;
+     #initialUplinkBWP
+      #genericParameters
+        initialULBWPlocationAndBandwidth                                        = 6366;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        initialULBWPsubcarrierSpacing                                           = 1;
+      #rach-ConfigCommon
+        #rach-ConfigGeneric
+          prach_ConfigurationIndex                                  = 98;
+#prach_msg1_FDM
+#0 = one, 1=two, 2=four, 3=eight
+          prach_msg1_FDM                                            = 0;
+          prach_msg1_FrequencyStart                                 = 0;
+          zeroCorrelationZoneConfig                                 = 13;
+          preambleReceivedTargetPower                               = -118;
+#preamblTransMax (0...10) = (3,4,5,6,7,8,10,20,50,100,200)
+          preambleTransMax                                          = 6;
+#powerRampingStep
+# 0=dB0,1=dB2,2=dB4,3=dB6
+        powerRampingStep                                            = 1;
+#ra_ReponseWindow
+#1,2,4,8,10,20,40,80
+        ra_ResponseWindow                                           = 4;
+#ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR
+#1=oneeighth,2=onefourth,3=half,4=one,5=two,6=four,7=eight,8=sixteen
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR                = 4;
+#oneHalf (0..15) 4,8,12,16,...60,64
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB                   = 15;
+#ra_ContentionResolutionTimer
+#(0..7) 8,16,24,32,40,48,56,64
+        ra_ContentionResolutionTimer                                = 7;
+        rsrp_ThresholdSSB                                           = 19;
+#prach-RootSequenceIndex_PR
+#1 = 839, 2 = 139
+        prach_RootSequenceIndex_PR                                  = 2;
+        prach_RootSequenceIndex                                     = 1;
+        # SCS for msg1, can only be 15 for 30 kHz < 6 GHz, takes precendence over the one derived from prach-ConfigIndex
+        #  
+        msg1_SubcarrierSpacing                                      = 1,
+
+# restrictedSetConfig
+# 0=unrestricted, 1=restricted type A, 2=restricted type B
+        restrictedSetConfig                                         = 0,
+      # pusch-ConfigCommon (up to 16 elements)
+        initialULBWPk2_0                      = 6;
+        initialULBWPmappingType_0             = 1
+        # this is SS=0 L=11
+        initialULBWPstartSymbolAndLength_0    = 55;
+
+        initialULBWPk2_1                      = 6;
+        initialULBWPmappingType_1             = 1;
+        # this is SS=0 L=12
+        initialULBWPstartSymbolAndLength_1    = 69;
+
+        initialULBWPk2_2                      = 7;
+        initialULBWPmappingType_2             = 1;
+        # this is SS=10 L=4
+        initialULBWPstartSymbolAndLength_2    = 52;
+
+        msg3_DeltaPreamble                                          = 1;
+        p0_NominalWithGrant                                         =-90;
+
+# pucch-ConfigCommon setup :
+# pucchGroupHopping
+# 0 = neither, 1= group hopping, 2=sequence hopping
+        pucchGroupHopping                                           = 0;
+        hoppingId                                                   = 40;
+        p0_nominal                                                  = -90;
+# ssb_PositionsInBurs_BitmapPR
+# 1=short, 2=medium, 3=long
+      ssb_PositionsInBurst_PR                                       = 2;
+      ssb_PositionsInBurst_Bitmap                                   = 1;
+
+# ssb_periodicityServingCell
+# 0 = ms5, 1=ms10, 2=ms20, 3=ms40, 4=ms80, 5=ms160, 6=spare2, 7=spare1 
+      ssb_periodicityServingCell                                    = 2;
+
+# dmrs_TypeA_position
+# 0 = pos2, 1 = pos3
+      dmrs_TypeA_Position                                           = 0;
+
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      subcarrierSpacing                                             = 1;
+
+
+  #tdd-UL-DL-ConfigurationCommon
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      referenceSubcarrierSpacing                                    = 1;
+      # pattern1 
+      # dl_UL_TransmissionPeriodicity
+      # 0=ms0p5, 1=ms0p625, 2=ms1, 3=ms1p25, 4=ms2, 5=ms2p5, 6=ms5, 7=ms10
+      dl_UL_TransmissionPeriodicity                                 = 6;
+      nrofDownlinkSlots                                             = 7;
+      nrofDownlinkSymbols                                           = 6;
+      nrofUplinkSlots                                               = 2;
+      nrofUplinkSymbols                                             = 4;
+
+  ssPBCH_BlockPower                                             = 10;
+  }
+
+  );
+
+
+    # ------- SCTP definitions
+    SCTP :
+    {
+        # Number of streams to use in input/output
+        SCTP_INSTREAMS  = 2;
+        SCTP_OUTSTREAMS = 2;
+    };
+
+												
+    ////////// AMF parameters:												
+    amf_ip_address      = ( { ipv4       = "192.168.199.223";												
+                              ipv6       = "192:168:199::223";												
+                              active     = "yes";												
+                              preference = "ipv4";												
+                            }												
+                          );												
+												
+						
+												
+    NETWORK_INTERFACES :												
+    {												
+												
+        GNB_INTERFACE_NAME_FOR_NG_AMF            = "eno1";												
+        GNB_IPV4_ADDRESS_FOR_NG_AMF              = "192.168.199.222/24";												
+        GNB_INTERFACE_NAME_FOR_NGU               = "enx000ec6c0a3ac";												
+        GNB_IPV4_ADDRESS_FOR_NGU                 = "192.168.10.100/24";												
+        GNB_PORT_FOR_NGU                         = 2152; # Spec 2152												
+        GNB_IPV4_ADDRESS_FOR_X2C                 = "192.168.20.20/24";												
+        GNB_PORT_FOR_X2C                         = 36422; # Spec 36422												
+    };												
+  }												
+);												
+
+MACRLCs = (
+	{
+	num_cc = 1;
+	tr_s_preference = "local_L1";
+	tr_n_preference = "local_RRC";
+        }  
+);
+
+L1s = (
+    	{
+	num_cc = 1;
+	tr_n_preference = "local_mac";
+        }  
+);
+
+RUs = (
+    {		  
+       local_rf       = "yes"
+         nb_tx          = 1
+         nb_rx          = 1
+         att_tx         = 0
+         att_rx         = 0;
+         bands          = [7];
+         max_pdschReferenceSignalPower = -27;
+         max_rxgain                    = 75;
+         eNB_instances  = [0];
+         #beamforming 1x4 matrix:
+         bf_weights = [0x00007fff, 0x0000, 0x0000, 0x0000];
+         sdr_addrs = "addr=192.168.10.2,mgmt_addr=192.168.10.2,second_addr=192.168.20.2";
+         clock_src = "external";
+    }
+);  
+
+THREAD_STRUCT = (
+  {
+    #three config for level of parallelism "PARALLEL_SINGLE_THREAD", "PARALLEL_RU_L1_SPLIT", or "PARALLEL_RU_L1_TRX_SPLIT"
+    parallel_config    = "PARALLEL_RU_L1_TRX_SPLIT";
+    #two option for worker "WORKER_DISABLE" or "WORKER_ENABLE"
+    worker_config      = "WORKER_ENABLE";
+  }
+);
+
+     log_config :
+     {
+       global_log_level                      ="info";
+       global_log_verbosity                  ="medium";
+       hw_log_level                          ="info";
+       hw_log_verbosity                      ="medium";
+       phy_log_level                         ="info";
+       phy_log_verbosity                     ="medium";
+       mac_log_level                         ="info";
+       mac_log_verbosity                     ="high";
+       rlc_log_level                         ="info";
+       rlc_log_verbosity                     ="medium";
+       pdcp_log_level                        ="info";
+       pdcp_log_verbosity                    ="medium";
+       rrc_log_level                         ="info";
+       rrc_log_verbosity                     ="medium";
+       ngap_log_level                         ="info";												
+       ngap_log_verbosity                    ="medium";												
+    };
+

targets/PROJECTS/GENERIC-LTE-EPC/CONF/gnb.band78.tm1.106PRB.usrpn300.gtp.conf

@@ -0,0 +1,285 @@
+Active_gNBs = ( "gNB-Eurecom-5GNRBox");
+# Asn1_verbosity, choice in: none, info, annoying
+Asn1_verbosity = "none";
+
+gNBs =
+(
+ {
+    ////////// Identification parameters:
+    gNB_ID    =  0xe00;
+
+    cell_type =  "CELL_MACRO_GNB";
+
+    gNB_name  =  "gNB-Eurecom-5GNRBox";
+
+    // Tracking area code, 0x0000 and 0xfffe are reserved values
+    tracking_area_code  =  1;
+
+    plmn_list = ({mcc = 208; mnc = 93; mnc_length = 2;});	 
+
+    tr_s_preference     = "local_mac"
+
+    ////////// Physical parameters:
+
+    ssb_SubcarrierOffset                                      = 0;
+    pdsch_AntennaPorts                                        = 1;
+	
+    servingCellConfigCommon = (
+    {
+ #spCellConfigCommon
+
+      physCellId                                                    = 0;
+
+#  downlinkConfigCommon
+    #frequencyInfoDL
+      # this is 3600 MHz + 43 PRBs@30kHz SCS (same as initial BWP)
+      absoluteFrequencySSB                                          = 641032;
+      dl_frequencyBand                                                 = 78;
+      # this is 3600 MHz
+      dl_absoluteFrequencyPointA                                       = 640000;
+      #scs-SpecificCarrierList
+        dl_offstToCarrier                                              = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        dl_subcarrierSpacing                                           = 1;
+        dl_carrierBandwidth                                            = 106;
+     #initialDownlinkBWP
+      #genericParameters
+        # this is RBstart=0,L=50 (275*(L-1))+RBstart
+        initialDLBWPlocationAndBandwidth                                        = 6366;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        initialDLBWPsubcarrierSpacing                                           = 1;
+      #pdcch-ConfigCommon
+        initialDLBWPcontrolResourceSetZero                                      = 12;
+        initialDLBWPsearchSpaceZero                                             = 0;
+      #pdsch-ConfigCommon
+        #pdschTimeDomainAllocationList (up to 16 entries)
+             initialDLBWPk0_0                    = 0;
+             #initialULBWPmappingType
+	     #0=typeA,1=typeB
+             initialDLBWPmappingType_0           = 0;
+             #this is SS=1,L=13
+             initialDLBWPstartSymbolAndLength_0  = 40;
+
+             initialDLBWPk0_1                    = 0;
+             initialDLBWPmappingType_1           = 0;
+             #this is SS=2,L=12 
+             initialDLBWPstartSymbolAndLength_1  = 53;
+
+             initialDLBWPk0_2                    = 0;
+             initialDLBWPmappingType_2           = 0;
+             #this is SS=1,L=12 
+             initialDLBWPstartSymbolAndLength_2  = 54;
+
+             initialDLBWPk0_3                    = 0;
+             initialDLBWPmappingType_3           = 0;
+             #this is SS=1,L=4
+             initialDLBWPstartSymbolAndLength_3  = 57;
+
+  #uplinkConfigCommon 
+     #frequencyInfoUL
+      ul_frequencyBand                                                 = 78;
+      #scs-SpecificCarrierList
+      ul_offstToCarrier                                              = 0;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      ul_subcarrierSpacing                                           = 1;
+      ul_carrierBandwidth                                            = 106;
+      pMax                                                          = 20;
+     #initialUplinkBWP
+      #genericParameters
+        initialULBWPlocationAndBandwidth                                        = 6366;
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+        initialULBWPsubcarrierSpacing                                           = 1;
+      #rach-ConfigCommon
+        #rach-ConfigGeneric
+          prach_ConfigurationIndex                                  = 98;
+#prach_msg1_FDM
+#0 = one, 1=two, 2=four, 3=eight
+          prach_msg1_FDM                                            = 0;
+          prach_msg1_FrequencyStart                                 = 0;
+          zeroCorrelationZoneConfig                                 = 13;
+          preambleReceivedTargetPower                               = -118;
+#preamblTransMax (0...10) = (3,4,5,6,7,8,10,20,50,100,200)
+          preambleTransMax                                          = 6;
+#powerRampingStep
+# 0=dB0,1=dB2,2=dB4,3=dB6
+        powerRampingStep                                            = 1;
+#ra_ReponseWindow
+#1,2,4,8,10,20,40,80
+        ra_ResponseWindow                                           = 4;
+#ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR
+#1=oneeighth,2=onefourth,3=half,4=one,5=two,6=four,7=eight,8=sixteen
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR                = 4;
+#oneHalf (0..15) 4,8,12,16,...60,64
+        ssb_perRACH_OccasionAndCB_PreamblesPerSSB                   = 15;
+#ra_ContentionResolutionTimer
+#(0..7) 8,16,24,32,40,48,56,64
+        ra_ContentionResolutionTimer                                = 7;
+        rsrp_ThresholdSSB                                           = 19;
+#prach-RootSequenceIndex_PR
+#1 = 839, 2 = 139
+        prach_RootSequenceIndex_PR                                  = 2;
+        prach_RootSequenceIndex                                     = 1;
+        # SCS for msg1, can only be 15 for 30 kHz < 6 GHz, takes precendence over the one derived from prach-ConfigIndex
+        #  
+        msg1_SubcarrierSpacing                                      = 1,
+# restrictedSetConfig
+# 0=unrestricted, 1=restricted type A, 2=restricted type B
+        restrictedSetConfig                                         = 0,
+
+      # pusch-ConfigCommon (up to 16 elements)
+        initialULBWPk2_0                      = 6;
+        initialULBWPmappingType_0             = 1
+        # this is SS=0 L=11
+        initialULBWPstartSymbolAndLength_0    = 55;
+ 	
+	initialULBWPk2_1                      = 6;
+        initialULBWPmappingType_1             = 1;
+        # this is SS=0 L=12
+        initialULBWPstartSymbolAndLength_1    = 69;
+
+	initialULBWPk2_2                      = 7;
+        initialULBWPmappingType_2             = 1;
+        # this is SS=10 L=4
+        initialULBWPstartSymbolAndLength_2    = 52;
+
+
+        msg3_DeltaPreamble                                          = 1;
+        p0_NominalWithGrant                                         =-90;
+
+# pucch-ConfigCommon setup :
+# pucchGroupHopping
+# 0 = neither, 1= group hopping, 2=sequence hopping
+        pucchGroupHopping                                           = 0;
+        hoppingId                                                   = 40;
+        p0_nominal                                                  = -90;
+# ssb_PositionsInBurs_BitmapPR
+# 1=short, 2=medium, 3=long
+      ssb_PositionsInBurst_PR                                       = 2;
+      ssb_PositionsInBurst_Bitmap                                   = 1;
+
+# ssb_periodicityServingCell
+# 0 = ms5, 1=ms10, 2=ms20, 3=ms40, 4=ms80, 5=ms160, 6=spare2, 7=spare1 
+      ssb_periodicityServingCell                                    = 2;
+
+# dmrs_TypeA_position
+# 0 = pos2, 1 = pos3
+      dmrs_TypeA_Position                                           = 0;
+
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      subcarrierSpacing                                             = 1;
+
+
+  #tdd-UL-DL-ConfigurationCommon
+# subcarrierSpacing
+# 0=kHz15, 1=kHz30, 2=kHz60, 3=kHz120  
+      referenceSubcarrierSpacing                                    = 1;
+      # pattern1 
+      # dl_UL_TransmissionPeriodicity
+      # 0=ms0p5, 1=ms0p625, 2=ms1, 3=ms1p25, 4=ms2, 5=ms2p5, 6=ms5, 7=ms10
+      dl_UL_TransmissionPeriodicity                                 = 6;
+      nrofDownlinkSlots                                             = 7;
+      nrofDownlinkSymbols                                           = 6;
+      nrofUplinkSlots                                               = 2;
+      nrofUplinkSymbols                                             = 4;
+
+  ssPBCH_BlockPower                                             = 10;
+  }
+
+  );
+
+
+    # ------- SCTP definitions
+    SCTP :
+    {
+        # Number of streams to use in input/output
+        SCTP_INSTREAMS  = 2;
+        SCTP_OUTSTREAMS = 2;
+    };
+
+
+    ////////// MME parameters:
+    mme_ip_address      = ( { ipv4       = "192.168.12.26";
+                              ipv6       = "192:168:30::17";
+                              active     = "yes";
+                              preference = "ipv4";
+                            }
+                          );
+
+    NETWORK_INTERFACES :
+    {
+	GNB_INTERFACE_NAME_FOR_NG_AMF            = "eno1";
+        GNB_IPV4_ADDRESS_FOR_NG_AMF              = "192.168.199.222/24";
+        GNB_INTERFACE_NAME_FOR_NGU               = "eno1";
+        GNB_IPV4_ADDRESS_FOR_NGU                 = "192.168.199.222/24";
+        GNB_PORT_FOR_NGU                         = 2152; # Spec 2152                                                                                            
+        GNB_IPV4_ADDRESS_FOR_X2C                 = "192.168.20.20/24";
+        GNB_PORT_FOR_X2C                         = 36422; # Spec 36422 
+    };
+  }
+);
+
+MACRLCs = (
+	{
+	num_cc = 1;
+	tr_s_preference = "local_L1";
+	tr_n_preference = "local_RRC";
+        }  
+);
+
+L1s = (
+    	{
+	num_cc = 1;
+	tr_n_preference = "local_mac";
+        }  
+);
+
+RUs = (
+    {		  
+       local_rf       = "yes"
+         nb_tx          = 1
+         nb_rx          = 1
+         att_tx         = 0
+         att_rx         = 0;
+         bands          = [7];
+         max_pdschReferenceSignalPower = -27;
+         max_rxgain                    = 75;
+         eNB_instances  = [0];
+         #beamforming 1x4 matrix:
+         bf_weights = [0x00007fff, 0x0000, 0x0000, 0x0000];
+         sdr_addrs = "addr=192.168.10.2,mgmt_addr=192.168.10.2,second_addr=192.168.20.2";
+         clock_src = "external";
+    }
+);  
+
+THREAD_STRUCT = (
+  {
+    #three config for level of parallelism "PARALLEL_SINGLE_THREAD", "PARALLEL_RU_L1_SPLIT", or "PARALLEL_RU_L1_TRX_SPLIT"
+    parallel_config    = "PARALLEL_RU_L1_TRX_SPLIT";
+    #two option for worker "WORKER_DISABLE" or "WORKER_ENABLE"
+    worker_config      = "WORKER_ENABLE";
+  }
+);
+
+     log_config :
+     {
+       global_log_level                      ="info";
+       global_log_verbosity                  ="medium";
+       hw_log_level                          ="info";
+       hw_log_verbosity                      ="medium";
+       phy_log_level                         ="info";
+       phy_log_verbosity                     ="medium";
+       mac_log_level                         ="info";
+       mac_log_verbosity                     ="high";
+       rlc_log_level                         ="info";
+       rlc_log_verbosity                     ="medium";
+       pdcp_log_level                        ="info";
+       pdcp_log_verbosity                    ="medium";
+       rrc_log_level                         ="info";
+       rrc_log_verbosity                     ="medium";
+    };
+