updated for CI sa test

executables/nr-ue.c

@@ -330,7 +330,7 @@ static void *NRUE_phy_stub_standalone_pnf_task(void *arg)
         AssertFatal(ul_config->number_pdus < sizeof(ul_config->ul_config_list) / sizeof(ul_config->ul_config_list[0]),
                     "Number of PDUS in ul_config = %d > ul_config_list num elements", ul_config->number_pdus);
         fapi_nr_ul_config_prach_pdu *prach_pdu = &ul_config->ul_config_list[ul_config->number_pdus].prach_config_pdu;
-        uint8_t nr_prach = nr_ue_get_rach(&prach_resources, prach_pdu, mod_id, CC_id, ul_info.frame_tx, gNB_id, ul_info.slot_tx);
+        uint8_t nr_prach = nr_ue_get_rach_nsa(&prach_resources, prach_pdu, mod_id, CC_id, ul_info.frame_tx, gNB_id, ul_info.slot_tx);
         if (nr_prach == 1)
         {
           L1_nsa_prach_procedures(ul_info.frame_tx, ul_info.slot_tx, prach_pdu);

executables/nr-uesoftmodem.c

@@ -194,18 +194,18 @@ int create_tasks_nrue(uint32_t ue_nb) {
       LOG_E(NR_RRC, "Create task for RRC UE failed\n");
       return -1;
     }
-  }
-  if (ue_nb > 0 && get_softmodem_params()->nsa == 1) {
-    init_connections_with_lte_ue();
-    if (itti_create_task (TASK_RRC_NSA_NRUE, recv_msgs_from_lte_ue, NULL) < 0) {
-      LOG_E(NR_RRC, "Create task for RRC NSA nr-UE failed\n");
+    if (get_softmodem_params()->nsa) {
+      init_connections_with_lte_ue();
+      if (itti_create_task (TASK_RRC_NSA_NRUE, recv_msgs_from_lte_ue, NULL) < 0) {
+        LOG_E(NR_RRC, "Create task for RRC NSA nr-UE failed\n");
+        return -1;
+      }
+    }
+    if (itti_create_task (TASK_NAS_NRUE, nas_nrue_task, NULL) < 0) {
+      LOG_E(NR_RRC, "Create task for NAS UE failed\n");
       return -1;
     }
   }
-  if (itti_create_task (TASK_NAS_NRUE, nas_nrue_task, NULL) < 0) {
-    LOG_E(NR_RRC, "Create task for NAS UE failed\n");
-    return -1;
-  }
 
   itti_wait_ready(0);
   return 0;
@@ -480,7 +480,9 @@ int main( int argc, char **argv ) {
   NB_INST=1;
   PHY_vars_UE_g = malloc(sizeof(PHY_VARS_NR_UE **));
   PHY_vars_UE_g[0] = malloc(sizeof(PHY_VARS_NR_UE *)*MAX_NUM_CCs);
-  RCconfig_nr_ue_L1();
+  if(get_softmodem_params()->nsa) {
+    RCconfig_nr_ue_L1();
+  }
 
   if (get_softmodem_params()->do_ra)
     AssertFatal(get_softmodem_params()->phy_test == 0,"RA and phy_test are mutually exclusive\n");
@@ -488,11 +490,6 @@ int main( int argc, char **argv ) {
   if (get_softmodem_params()->sa)
     AssertFatal(get_softmodem_params()->phy_test == 0,"Standalone mode and phy_test are mutually exclusive\n");
 
-  if (create_tasks_nrue(1) < 0) {
-    LOG_E(NR_RRC,"Cannot create ITTI tasks for RRC layer of nr-UE\n");
-    exit(-1);
-  }
-
   if (!get_softmodem_params()->nsa) {
     for (int CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
       PHY_vars_UE_g[0][CC_id] = (PHY_VARS_NR_UE *)malloc(sizeof(PHY_VARS_NR_UE));
@@ -500,34 +497,32 @@ int main( int argc, char **argv ) {
       memset(UE[CC_id],0,sizeof(PHY_VARS_NR_UE));
 
       set_options(CC_id, UE[CC_id]);
-
       NR_UE_MAC_INST_t *mac = get_mac_inst(0);
-      if(mac->if_module != NULL && mac->if_module->phy_config_request != NULL)
-        mac->if_module->phy_config_request(&mac->phy_config);
 
-      fapi_nr_config_request_t *nrUE_config = &UE[CC_id]->nrUE_config;
       if (get_softmodem_params()->sa) { // set frame config to initial values from command line and assume that the SSB is centered on the grid
-        nrUE_config->ssb_config.scs_common = get_softmodem_params()->numerology;
-        nrUE_config->carrier_config.dl_grid_size[nrUE_config->ssb_config.scs_common] = UE[CC_id]->frame_parms.N_RB_DL;
-        nrUE_config->carrier_config.ul_grid_size[nrUE_config->ssb_config.scs_common] = UE[CC_id]->frame_parms.N_RB_DL;
-        nrUE_config->carrier_config.dl_frequency =  (downlink_frequency[0][0] -(6*UE[CC_id]->frame_parms.N_RB_DL*(15000<<nrUE_config->ssb_config.scs_common)))/1000;
-        nrUE_config->carrier_config.uplink_frequency =  (downlink_frequency[0][0] -(6*UE[CC_id]->frame_parms.N_RB_DL*(15000<<nrUE_config->ssb_config.scs_common)))/1000;
-        nrUE_config->ssb_table.ssb_offset_point_a = (UE[CC_id]->frame_parms.N_RB_DL - 20)>>1;
-
-        // Initialize values, will be updated upon SIB1 reception
-        nrUE_config->cell_config.frame_duplex_type = TDD;
-        nrUE_config->ssb_table.ssb_mask_list[0].ssb_mask = 0xFFFFFFFF;
-        nrUE_config->ssb_table.ssb_period = 1;
+        uint16_t nr_band = get_band(downlink_frequency[CC_id][0],uplink_frequency_offset[CC_id][0]);
+        mac->nr_band = nr_band;
+        nr_init_frame_parms_ue_sa(&UE[CC_id]->frame_parms,
+                                  downlink_frequency[CC_id][0],
+                                  uplink_frequency_offset[CC_id][0],
+                                  get_softmodem_params()->numerology,
+                                  nr_band);
+      }
+      else{
+        if(mac->if_module != NULL && mac->if_module->phy_config_request != NULL)
+          mac->if_module->phy_config_request(&mac->phy_config);
+
+        fapi_nr_config_request_t *nrUE_config = &UE[CC_id]->nrUE_config;
+
+        nr_init_frame_parms_ue(&UE[CC_id]->frame_parms, nrUE_config,
+            *mac->scc->downlinkConfigCommon->frequencyInfoDL->frequencyBandList.list.array[0]);
       }
-      nr_init_frame_parms_ue(&UE[CC_id]->frame_parms, nrUE_config,
-          mac->scc == NULL ? 78 : *mac->scc->downlinkConfigCommon->frequencyInfoDL->frequencyBandList.list.array[0]);
 
       init_symbol_rotation(&UE[CC_id]->frame_parms);
+      init_timeshift_rotation(&UE[CC_id]->frame_parms);
       init_nr_ue_vars(UE[CC_id], 0, abstraction_flag);
     }
 
-    init_NR_UE_threads(1);
-    printf("UE threads created by %ld\n", gettid());
     init_openair0();
     // init UE_PF_PO and mutex lock
     pthread_mutex_init(&ue_pf_po_mutex, NULL);
@@ -538,12 +533,19 @@ int main( int argc, char **argv ) {
     if(IS_SOFTMODEM_DOSCOPE) {
       load_softscope("nr",PHY_vars_UE_g[0][0]);
     }
+
+    init_NR_UE_threads(1);
+    printf("UE threads created by %ld\n", gettid());
   }
 
-  config_sync_var=0;
   // 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
+  }
+
   // Sleep a while before checking all parameters have been used
   // Some are used directly in external threads, asynchronously
   sleep(20);

openair2/LAYER2/NR_MAC_UE/mac_proto.h

@@ -345,6 +345,16 @@ uint8_t nr_ue_get_rach(NR_PRACH_RESOURCES_t *prach_resources,
                        uint8_t gNB_id,
                        int nr_slot_tx);
 
+uint8_t nr_ue_get_rach_nsa(NR_PRACH_RESOURCES_t *prach_resources,
+                       fapi_nr_ul_config_prach_pdu *prach_pdu,
+                       module_id_t mod_id,
+                       int CC_id,
+                       frame_t frame,
+                       uint8_t gNB_id,
+                       int nr_slot_tx);
+
+
+
 /* \brief Function implementing the routine for the selection of Random Access resources (5.1.2 TS 38.321).
 @param module_idP Index of UE instance
 @param CC_id Component Carrier Index

openair2/LAYER2/NR_MAC_UE/nr_ra_procedures.c

@@ -655,7 +655,7 @@ void nr_Msg3_transmitted(module_id_t mod_id, uint8_t CC_id, frame_t frameP, slot
  * @gNB_id              gNB ID
  * @nr_slot_tx          current UL TX slot
  */
-uint8_t nr_ue_get_rach(NR_PRACH_RESOURCES_t *prach_resources,
+uint8_t nr_ue_get_rach_nsa(NR_PRACH_RESOURCES_t *prach_resources,
                        fapi_nr_ul_config_prach_pdu *prach_pdu,
                        module_id_t mod_id,
                        int CC_id,
@@ -817,6 +817,209 @@ uint8_t nr_ue_get_rach(NR_PRACH_RESOURCES_t *prach_resources,
 
 }
 
+
+/**
+ * Function:            handles Random Access Preamble Initialization (5.1.1 TS 38.321)
+ *                      handles Random Access Response reception (5.1.4 TS 38.321)
+ * Note:                In SA mode the Msg3 contains a CCCH SDU, therefore no C-RNTI MAC CE is transmitted.
+ *
+ * @prach_resources     pointer to PRACH resources
+ * @prach_pdu           pointer to FAPI UL PRACH PDU
+ * @mod_id              module ID
+ * @CC_id               CC ID
+ * @frame               current UL TX frame
+ * @gNB_id              gNB ID
+ * @nr_slot_tx          current UL TX slot
+ */
+uint8_t nr_ue_get_rach(NR_PRACH_RESOURCES_t *prach_resources,
+                       fapi_nr_ul_config_prach_pdu *prach_pdu,
+                       module_id_t mod_id,
+                       int CC_id,
+                       frame_t frame,
+                       uint8_t gNB_id,
+                       int nr_slot_tx){
+
+  NR_UE_MAC_INST_t *mac = get_mac_inst(mod_id);
+  RA_config_t *ra = &mac->ra;
+  NR_RACH_ConfigCommon_t *setup;
+  if (mac->scc) setup = mac->scc->uplinkConfigCommon->initialUplinkBWP->rach_ConfigCommon->choice.setup;
+  else          setup = mac->scc_SIB->uplinkConfigCommon->initialUplinkBWP.rach_ConfigCommon->choice.setup;
+  AssertFatal(&setup->rach_ConfigGeneric != NULL, "In %s: FATAL! rach_ConfigGeneric is NULL...\n", __FUNCTION__);
+  NR_RACH_ConfigGeneric_t *rach_ConfigGeneric = &setup->rach_ConfigGeneric;
+  NR_RACH_ConfigDedicated_t *rach_ConfigDedicated = ra->rach_ConfigDedicated;
+
+  // Delay init RA procedure to allow the convergence of the IIR filter on PRACH noise measurements at gNB side
+  if (!prach_resources->init_msg1) {
+    if ( (mac->common_configuration_complete>0 || get_softmodem_params()->do_ra==1) && ((MAX_FRAME_NUMBER+frame-prach_resources->sync_frame)%MAX_FRAME_NUMBER)>150 ){
+      prach_resources->init_msg1 = 1;
+    } else {
+      LOG_D(NR_MAC,"PRACH Condition not met: frame %d, prach_resources->sync_frame %d\n",frame,prach_resources->sync_frame);
+      return 0;
+    }
+  }
+
+  LOG_D(NR_MAC, "In %s: [UE %d][%d.%d]: init_msg1 %d, ra_state %d, RA_active %d\n",
+    __FUNCTION__,
+    mod_id,
+    frame,
+    nr_slot_tx,
+    prach_resources->init_msg1,
+    ra->ra_state,
+    ra->RA_active);
+
+  if (prach_resources->init_msg1 && ra->ra_state != RA_SUCCEEDED) {
+
+    if (ra->RA_active == 0) {
+      /* RA not active - checking if RRC is ready to initiate the RA procedure */
+
+      LOG_D(NR_MAC, "In %s: RA not active. Checking for data to transmit from upper layers...\n", __FUNCTION__);
+
+      const uint8_t lcid = UL_SCH_LCID_CCCH;
+      const uint8_t sh_size = sizeof(NR_MAC_SUBHEADER_FIXED);
+      const uint8_t TBS_max = 8 + sizeof(NR_MAC_SUBHEADER_SHORT) + sizeof(NR_MAC_SUBHEADER_SHORT); // Note: unclear the reason behind the selection of such TBS_max
+      int8_t size_sdu = 0;
+      uint8_t mac_ce[16] = {0};
+      uint8_t *pdu = get_softmodem_params()->sa ? mac->CCCH_pdu.payload : mac_ce;
+      uint8_t *payload = pdu;
+
+      // Concerning the C-RNTI MAC CE, it has to be included if the UL transmission (Msg3) is not being made for the CCCH logical channel.
+      // Therefore it has been assumed that this event only occurs only when RA is done and it is not SA mode.
+      if (get_softmodem_params()->sa) {
+
+        NR_MAC_SUBHEADER_FIXED *header = (NR_MAC_SUBHEADER_FIXED *) pdu;
+        pdu += sh_size;
+
+        // initialisation by RRC
+        nr_rrc_ue_generate_RRCSetupRequest(mod_id,gNB_id);
+
+        // CCCH PDU
+        size_sdu = nr_mac_rrc_data_req_ue(mod_id, CC_id, gNB_id, frame, CCCH, pdu);
+        LOG_D(NR_MAC, "In %s: [UE %d][%d.%d]: Requested RRCConnectionRequest, got %d bytes for LCID 0x%02x \n", __FUNCTION__, mod_id, frame, nr_slot_tx, size_sdu, lcid);
+
+        if (size_sdu > 0) {
+
+          // UE Contention Resolution Identity
+          // Store the first 48 bits belonging to the uplink CCCH SDU within Msg3 to determine whether or not the
+          // Random Access Procedure has been successful after reception of Msg4
+          memcpy(ra->cont_res_id, pdu, sizeof(uint8_t) * 6);
+
+          pdu += size_sdu;
+          ra->Msg3_size = size_sdu + sh_size;
+
+          // Build header
+          header->R = 0;
+          header->LCID = lcid;
+
+        } else {
+          pdu -= sh_size;
+        }
+
+      } else {
+
+        size_sdu = nr_write_ce_ulsch_pdu(pdu, mac);
+        pdu += size_sdu;
+        ra->Msg3_size = size_sdu;
+
+      }
+
+      if (size_sdu > 0 && ra->generate_nr_prach == GENERATE_PREAMBLE) {
+
+        LOG_D(NR_MAC, "In %s: [UE %d][%d.%d]: starting initialisation Random Access Procedure...\n", __FUNCTION__, mod_id, frame, nr_slot_tx);
+        AssertFatal(TBS_max > ra->Msg3_size, "In %s: allocated resources are not enough for Msg3!\n", __FUNCTION__);
+
+        // Init RA procedure
+        init_RA(mod_id, prach_resources, setup, rach_ConfigGeneric, rach_ConfigDedicated);
+        nr_get_RA_window(mac);
+        // Fill in preamble and PRACH resources
+        nr_get_prach_resources(mod_id, CC_id, gNB_id, prach_resources, prach_pdu, rach_ConfigDedicated);
+
+        // Padding: fill remainder with 0
+        if (TBS_max - ra->Msg3_size > 0) {
+          LOG_D(NR_MAC, "In %s: remaining %d bytes, filling with padding\n", __FUNCTION__, TBS_max - ra->Msg3_size);
+          ((NR_MAC_SUBHEADER_FIXED *) pdu)->R = 0;
+          ((NR_MAC_SUBHEADER_FIXED *) pdu)->LCID = UL_SCH_LCID_PADDING;
+          pdu += sizeof(NR_MAC_SUBHEADER_FIXED);
+          for (int j = 0; j < TBS_max - ra->Msg3_size - sizeof(NR_MAC_SUBHEADER_FIXED); j++) {
+            pdu[j] = 0;
+          }
+        }
+
+        // Dumping ULSCH payload
+        LOG_D(NR_MAC, "In %s: dumping UL Msg3 MAC PDU with length %d: \n", __FUNCTION__, TBS_max);
+        for(int k = 0; k < TBS_max; k++) {
+          LOG_D(NR_MAC,"(%i): %i\n", k, payload[k]);
+        }
+
+        // Msg3 was initialized with TBS_max bytes because the RA_Msg3_size will only be known after
+        // receiving Msg2 (which contains the Msg3 resource reserve).
+        // Msg3 will be transmitted with RA_Msg3_size bytes, removing unnecessary 0s.
+        mac->ulsch_pdu.Pdu_size = TBS_max;
+        memcpy(mac->ulsch_pdu.payload, payload, TBS_max);
+
+      } else {
+        return 0;
+      }
+    } else if (ra->RA_window_cnt != -1) { // RACH is active
+
+      LOG_D(MAC, "In %s [%d.%d] RA is active: RA window count %d, RA backoff count %d\n", __FUNCTION__, frame, nr_slot_tx, ra->RA_window_cnt, ra->RA_backoff_cnt);
+
+      if (ra->RA_BI_found){
+        prach_resources->RA_PREAMBLE_BACKOFF = prach_resources->RA_SCALING_FACTOR_BI * ra->RA_backoff_indicator;
+      } else {
+        prach_resources->RA_PREAMBLE_BACKOFF = 0;
+      }
+
+      if (ra->RA_window_cnt >= 0 && ra->RA_RAPID_found == 1) {
+
+        if(ra->cfra) {
+          // Reset RA_active flag: it disables Msg3 retransmission (8.3 of TS 38.213)
+          nr_ra_succeeded(mod_id, frame, nr_slot_tx);
+        } else {
+          ra->generate_nr_prach = GENERATE_IDLE;
+        }
+
+      } else if (ra->RA_window_cnt == 0 && !ra->RA_RAPID_found) {
+
+        LOG_I(MAC, "[UE %d][%d:%d] RAR reception failed \n", mod_id, frame, nr_slot_tx);
+
+        nr_ra_failed(mod_id, CC_id, prach_resources, frame, nr_slot_tx);
+
+      } else if (ra->RA_window_cnt > 0) {
+
+        LOG_D(MAC, "[UE %d][%d.%d]: RAR not received yet (RA window count %d) \n", mod_id, frame, nr_slot_tx, ra->RA_window_cnt);
+
+        // Fill in preamble and PRACH resources
+        ra->RA_window_cnt--;
+        if (ra->generate_nr_prach == GENERATE_PREAMBLE) {
+          nr_get_prach_resources(mod_id, CC_id, gNB_id, prach_resources, prach_pdu, rach_ConfigDedicated);
+        }
+      } else if (ra->RA_backoff_cnt > 0) {
+
+        LOG_D(MAC, "[UE %d][%d.%d]: RAR not received yet (RA backoff count %d) \n", mod_id, frame, nr_slot_tx, ra->RA_backoff_cnt);
+
+        ra->RA_backoff_cnt--;
+
+        if ((ra->RA_backoff_cnt > 0 && ra->generate_nr_prach == GENERATE_PREAMBLE) || ra->RA_backoff_cnt == 0) {
+          nr_get_prach_resources(mod_id, CC_id, gNB_id, prach_resources, prach_pdu, rach_ConfigDedicated);
+        }
+
+      }
+    }
+  }
+
+  if (ra->RA_contention_resolution_timer_active){
+    nr_ue_contention_resolution(mod_id, CC_id, frame, nr_slot_tx, prach_resources);
+  }
+
+  LOG_D(MAC,"ra->generate_nr_prach %d ra->ra_state %d (GENERATE_IDLE %d)\n",ra->generate_nr_prach,ra->ra_state,GENERATE_IDLE);
+  if(ra->generate_nr_prach != GENERATE_IDLE) {
+    return ra->generate_nr_prach;
+  } else {
+    return ra->ra_state;
+  }
+
+}
+
 void nr_get_RA_window(NR_UE_MAC_INST_t *mac){
 
   uint8_t mu, ra_ResponseWindow;

openair2/RRC/NR_UE/rrc_UE.c

@@ -520,8 +520,8 @@ NR_UE_RRC_INST_t* openair_rrc_top_init_ue_nr(char* rrc_config_path){
                   errno,
                   strerror(errno));
       int msg_len=fread(buffer,1,1024,fd);
-      process_nsa_message(NR_UE_rrc_inst, nr_SecondaryCellGroupConfig_r15, buffer,msg_len);
       fclose(fd);
+      process_nsa_message(NR_UE_rrc_inst, nr_SecondaryCellGroupConfig_r15, buffer,msg_len);
       if (rrc_config_path)
         sprintf(filename,"%s/rbconfig.raw",rrc_config_path);
       else
@@ -533,9 +533,8 @@ NR_UE_RRC_INST_t* openair_rrc_top_init_ue_nr(char* rrc_config_path){
                   errno,
                   strerror(errno));
       msg_len=fread(buffer,1,1024,fd);
-      process_nsa_message(NR_UE_rrc_inst, nr_SecondaryCellGroupConfig_r15, buffer,msg_len);
       fclose(fd);
-
+      process_nsa_message(NR_UE_rrc_inst, nr_RadioBearerConfigX_r15, buffer,msg_len); 
     }
     else if (get_softmodem_params()->nsa)
     {
@@ -2663,8 +2662,11 @@ nr_rrc_ue_process_ueCapabilityEnquiry(
   OCTET_STRING_fromBuf(&ue_CapabilityRAT_Container.ue_CapabilityRAT_Container,
                        (const char *)NR_UE_rrc_inst[ctxt_pP->module_id].UECapability,
                        NR_UE_rrc_inst[ctxt_pP->module_id].UECapability_size);
-  OCTET_STRING_t * requestedFreqBandsNR = UECapabilityEnquiry->criticalExtensions.choice.ueCapabilityEnquiry->ue_CapabilityEnquiryExt;
-  nsa_sendmsg_to_lte_ue(requestedFreqBandsNR->buf, requestedFreqBandsNR->size, UE_CAPABILITY_INFO);
+
+  if (get_softmodem_params()->nsa == 1) {
+    OCTET_STRING_t * requestedFreqBandsNR = UECapabilityEnquiry->criticalExtensions.choice.ueCapabilityEnquiry->ue_CapabilityEnquiryExt;
+    nsa_sendmsg_to_lte_ue(requestedFreqBandsNR->buf, requestedFreqBandsNR->size, UE_CAPABILITY_INFO);
+  }
   //  ue_CapabilityRAT_Container.ueCapabilityRAT_Container.buf  = UE_rrc_inst[ue_mod_idP].UECapability;
   // ue_CapabilityRAT_Container.ueCapabilityRAT_Container.size = UE_rrc_inst[ue_mod_idP].UECapability_size;
   AssertFatal(UECapabilityEnquiry->criticalExtensions.present == NR_UECapabilityEnquiry__criticalExtensions_PR_ueCapabilityEnquiry,