Merge remote-tracking branch 'origin/NR_PUCCH_RRC_Resources' into integration_2022_wk25

openair1/PHY/INIT/nr_init_ru.c

@@ -60,7 +60,7 @@ int nr_phy_init_RU(RU_t *ru) {
 
     for (i=0; i<ru->nb_tx; i++) {
       // Allocate 10 subframes of I/Q TX signal data (time) if not
-      ru->common.txdata[i]  = (int32_t*)malloc16_clear((ru->sf_extension +fp->samples_per_frame) *sizeof(int32_t));
+      ru->common.txdata[i]  = (int32_t*)malloc16_clear((ru->sf_extension + fp->samples_per_frame)*sizeof(int32_t));
       LOG_I(PHY,"[INIT] common.txdata[%d] = %p (%lu bytes,sf_extension %d)\n",i,ru->common.txdata[i],
 	     (ru->sf_extension + fp->samples_per_frame)*sizeof(int32_t),ru->sf_extension);
       ru->common.txdata[i] =  &ru->common.txdata[i][ru->sf_extension];

openair1/PHY/NR_TRANSPORT/pucch_rx.c

@@ -278,16 +278,30 @@ void nr_decode_pucch0(PHY_VARS_gNB *gNB,
   uint8_t maxpos=0;
   uint8_t index=0;
 
+  int nb_re_pucch = 12*pucch_pdu->prb_size;  // prb size is 1
+  int32_t rp[frame_parms->nb_antennas_rx][pucch_pdu->nr_of_symbols][nb_re_pucch],*tmp_rp;
+
   for (int l=0; l<pucch_pdu->nr_of_symbols; l++) {
     l2 = l+pucch_pdu->start_symbol_index;
+
     re_offset[l] = (12*prb_offset[l]) + frame_parms->first_carrier_offset;
     if (re_offset[l]>= frame_parms->ofdm_symbol_size)
       re_offset[l]-=frame_parms->ofdm_symbol_size;
-  
-    AssertFatal(re_offset[l]+12 < frame_parms->ofdm_symbol_size,"pucch straddles DC carrier, handle this!\n");
+
     for (int aa=0;aa<frame_parms->nb_antennas_rx;aa++) {
-      c16_t *r=(c16_t*)&rxdataF[aa][soffset+(l2*frame_parms->ofdm_symbol_size)+re_offset[l]];
-      for (n=0;n<12;n++) {
+      tmp_rp = &rxdataF[aa][soffset + l2*frame_parms->ofdm_symbol_size];
+      if(re_offset[l] + nb_re_pucch > frame_parms->ofdm_symbol_size) {
+        int neg_length = frame_parms->ofdm_symbol_size-re_offset[l];
+        int pos_length = nb_re_pucch-neg_length;
+        memcpy1((void*)rp[aa][l],(void*)&tmp_rp[re_offset[l]],neg_length*sizeof(int32_t));
+        memcpy1((void*)&rp[aa][l][neg_length],(void*)tmp_rp,pos_length*sizeof(int32_t));
+      }
+      else
+        memcpy1((void*)rp[aa][l],(void*)&tmp_rp[re_offset[l]],nb_re_pucch*sizeof(int32_t));
+
+      c16_t *r = (c16_t*)&rp[aa][l];
+
+      for (n=0;n<nb_re_pucch;n++) {
         xr[aa][l][n].r = (int32_t)x_re[l][n] * r[n].r + (int32_t)x_im[l][n] * r[n].i;
         xr[aa][l][n].i = (int32_t)x_re[l][n] * r[n].i - (int32_t)x_im[l][n] * r[n].r;
 #ifdef DEBUG_NR_PUCCH_RX
@@ -385,9 +399,7 @@ void nr_decode_pucch0(PHY_VARS_gNB *gNB,
 		   gNB->measurements.n0_subband_power_tot_dB[prb_offset[1]]);
   int SNRtimes10,sigenergy=0;
   for (int aa=0;aa<frame_parms->nb_antennas_rx;aa++)
-    sigenergy += signal_energy_nodc(&rxdataF[aa][soffset+
-                                                 (pucch_pdu->start_symbol_index*frame_parms->ofdm_symbol_size)+
-                                                 re_offset[0]],12);
+    sigenergy += signal_energy_nodc(rp[aa][0],12);
   SNRtimes10 = xrtmag_dBtimes10-(10*max_n0);
   int cqi;
   if (SNRtimes10 < -640) cqi=0;

openair1/SIMULATION/NR_PHY/pucchsim.c

@@ -640,6 +640,7 @@ int main(int argc, char **argv)
         pucch_pdu.initial_cyclic_shift  = 0;
         pucch_pdu.start_symbol_index    = startingSymbolIndex;
         pucch_pdu.prb_start             = startingPRB;
+        pucch_pdu.prb_size              = 1;
         pucch_pdu.bwp_start             = 0;
         pucch_pdu.bwp_size              = N_RB_DL;
         if (nrofSymbols>1) {

openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c

@@ -2433,11 +2433,9 @@ int8_t nr_ue_get_SR(module_id_t module_idP, frame_t frameP, slot_t slot){
     // start the sr-prohibittimer : rel 9 and above
     if (mac->scheduling_info.sr_ProhibitTimer > 0) { // timer configured
       mac->scheduling_info.sr_ProhibitTimer--;
-      mac->scheduling_info.
-      sr_ProhibitTimer_Running = 1;
+      mac->scheduling_info.sr_ProhibitTimer_Running = 1;
     } else {
-      mac->scheduling_info.
-      sr_ProhibitTimer_Running = 0;
+      mac->scheduling_info.sr_ProhibitTimer_Running = 0;
     }
     //mac->ul_active =1;
     return (1);   //instruct phy to signal SR

openair2/LAYER2/NR_MAC_gNB/config.c

@@ -458,8 +458,7 @@ int nr_mac_enable_ue_rrc_processing_timer(module_id_t Mod_idP, rnti_t rnti, NR_S
     return -1;
   }
   NR_UE_sched_ctrl_t *sched_ctrl = &UE_info->UE_sched_ctrl;
-  const uint16_t sf_ahead = 6/(0x01<<subcarrierSpacing) + ((6%(0x01<<subcarrierSpacing))>0);
-  const uint16_t sl_ahead = sf_ahead * (0x01<<subcarrierSpacing);
+  const uint16_t sl_ahead = RC.nrmac[Mod_idP]->if_inst->sl_ahead;
   sched_ctrl->rrc_processing_timer = (rrc_reconfiguration_delay<<subcarrierSpacing) + sl_ahead;
   LOG_I(NR_MAC, "Activating RRC processing timer for UE %04x with %d ms\n", UE_info->rnti, rrc_reconfiguration_delay);
 
@@ -481,19 +480,7 @@ int rrc_mac_config_req_gNB(module_id_t Mod_idP,
   if (scc != NULL ) {
     AssertFatal((scc->ssb_PositionsInBurst->present > 0) && (scc->ssb_PositionsInBurst->present < 4), "SSB Bitmap type %d is not valid\n",scc->ssb_PositionsInBurst->present);
 
-    /* dimension UL_tti_req_ahead for number of slots in frame */
     const int n = nr_slots_per_frame[*scc->ssbSubcarrierSpacing];
-    RC.nrmac[Mod_idP]->UL_tti_req_ahead[0] = calloc(n, sizeof(nfapi_nr_ul_tti_request_t));
-    AssertFatal(RC.nrmac[Mod_idP]->UL_tti_req_ahead[0],
-                "could not allocate memory for RC.nrmac[]->UL_tti_req_ahead[]\n");
-    /* fill in slot/frame numbers: slot is fixed, frame will be updated by scheduler
-     * consider that scheduler runs sl_ahead: the first sl_ahead slots are
-     * already "in the past" and thus we put frame 1 instead of 0! */
-    for (int i = 0; i < n; ++i) {
-      nfapi_nr_ul_tti_request_t *req = &RC.nrmac[Mod_idP]->UL_tti_req_ahead[0][i];
-      req->SFN = i < (RC.nrmac[Mod_idP]->if_inst->sl_ahead-1);
-      req->Slot = i;
-    }
     RC.nrmac[Mod_idP]->common_channels[0].vrb_map_UL =
         calloc(n * MAX_BWP_SIZE, sizeof(uint16_t));
     AssertFatal(RC.nrmac[Mod_idP]->common_channels[0].vrb_map_UL,

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler.c

@@ -68,6 +68,8 @@ void clear_nr_nfapi_information(gNB_MAC_INST * gNB,
   NR_ServingCellConfigCommon_t *scc = gNB->common_channels->ServingCellConfigCommon;
   const int num_slots = nr_slots_per_frame[*scc->ssbSubcarrierSpacing];
 
+  UL_tti_req_ahead_initialization(gNB, scc, num_slots, CC_idP);
+
   nfapi_nr_dl_tti_request_t    *DL_req = &gNB->DL_req[0];
   nfapi_nr_dl_tti_pdcch_pdu_rel15_t **pdcch = (nfapi_nr_dl_tti_pdcch_pdu_rel15_t **)gNB->pdcch_pdu_idx[CC_idP];
   nfapi_nr_ul_tti_request_t    *future_ul_tti_req =

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

@@ -3074,3 +3074,20 @@ void schedule_nr_bwp_switch(module_id_t module_id,
     }
   }
 }
+
+void UL_tti_req_ahead_initialization(gNB_MAC_INST * gNB, NR_ServingCellConfigCommon_t *scc, int n, int CCid) {
+
+  if(gNB->UL_tti_req_ahead[CCid]) return;
+
+  gNB->UL_tti_req_ahead[CCid] = calloc(n, sizeof(nfapi_nr_ul_tti_request_t));
+  AssertFatal(gNB->UL_tti_req_ahead[CCid],
+              "could not allocate memory for RC.nrmac[]->UL_tti_req_ahead[]\n");
+  /* fill in slot/frame numbers: slot is fixed, frame will be updated by scheduler
+   * consider that scheduler runs sl_ahead: the first sl_ahead slots are
+   * already "in the past" and thus we put frame 1 instead of 0! */
+  for (int i = 0; i < n; ++i) {
+    nfapi_nr_ul_tti_request_t *req = &gNB->UL_tti_req_ahead[CCid][i];
+    req->SFN = i < (gNB->if_inst->sl_ahead-1);
+    req->Slot = i;
+  }
+}

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c

@@ -1903,7 +1903,7 @@ void nr_sr_reporting(gNB_MAC_INST *nrmac, frame_t SFN, sub_frame_t slot)
   UE_iterator(nrmac->UE_info.list, UE) {
     NR_UE_sched_ctrl_t *sched_ctrl = &UE->UE_sched_ctrl;
 
-    if (sched_ctrl->ul_failure==1) continue;
+    if (sched_ctrl->ul_failure==1 || sched_ctrl->rrc_processing_timer>0) continue;
     NR_PUCCH_Config_t *pucch_Config = NULL;
     if (sched_ctrl->active_ubwp) {
       pucch_Config = sched_ctrl->active_ubwp->bwp_Dedicated->pucch_Config->choice.setup;

openair2/LAYER2/NR_MAC_gNB/mac_proto.h

@@ -514,6 +514,8 @@ int get_mcs_from_bler(const NR_bler_options_t *bler_options,
                       int max_mcs,
                       frame_t frame);
 
+void UL_tti_req_ahead_initialization(gNB_MAC_INST * gNB, NR_ServingCellConfigCommon_t *scc, int n, int CCid);
+
 void nr_sr_reporting(gNB_MAC_INST *nrmac, frame_t frameP, sub_frame_t slotP);
 
 size_t dump_mac_stats(gNB_MAC_INST *gNB, char *output, size_t strlen, bool reset_rsrp);

openair2/RRC/NR/L2_nr_interface.c

@@ -357,7 +357,8 @@ int8_t nr_mac_rrc_data_ind(const module_id_t     module_idP,
     memcpy(msg->rrc_container, sduP, sdu_lenP);
     msg->rrc_container_length=sdu_lenP;
     itti_send_msg_to_task(TASK_DU_F1, 0, tmp);
-    return(0);
+
+    return 0;
   }
 
   protocol_ctxt_t ctxt;
@@ -370,7 +371,6 @@ int8_t nr_mac_rrc_data_ind(const module_id_t     module_idP,
       nr_rrc_gNB_decode_ccch(&ctxt, sduP, sdu_lenP, NULL, CC_id);
     }
   }
-
   return 0;
 }
 

openair2/RRC/NR/MESSAGES/asn1_msg.h

@@ -102,7 +102,7 @@ uint8_t do_RRCReject(uint8_t Mod_id,
                      uint8_t *const buffer);
 
 void fill_initial_SpCellConfig(int uid,
-                               NR_SpCellConfig_t *SpCellConfig,
+                               NR_CellGroupConfig_t *cellGroupConfig,
                                NR_ServingCellConfigCommon_t *scc,
                                NR_ServingCellConfig_t *servingcellconfigdedicated,
                                const gNB_RrcConfigurationReq *configuration);

openair2/RRC/NR/nr_rrc_config.h

@@ -120,6 +120,12 @@ void nr_rrc_config_dl_tda(NR_ServingCellConfigCommon_t *scc,
                           NR_PDSCH_TimeDomainResourceAllocationList_t	*pdsch_TimeDomainAllocationList,
                           int curr_bwp);
 void nr_rrc_config_ul_tda(NR_ServingCellConfigCommon_t *scc, int min_fb_delay);
+void config_pucch_resset0(NR_PUCCH_Config_t *pucch_Config, int uid, int curr_bwp, NR_UE_NR_Capability_t *uecap);
+void config_pucch_resset1(NR_PUCCH_Config_t *pucch_Config, NR_UE_NR_Capability_t *uecap);
+void set_dl_DataToUL_ACK(NR_PUCCH_Config_t *pucch_Config, int min_feedback_time);
+void set_pucch_power_config(NR_PUCCH_Config_t *pucch_Config, int do_csirs);
+void scheduling_request_config(NR_ServingCellConfigCommon_t *scc,
+                               NR_PUCCH_Config_t *pucch_Config);
 void config_csirs(NR_ServingCellConfigCommon_t *servingcellconfigcommon,
                   NR_CSI_MeasConfig_t *csi_MeasConfig,
                   int uid,
@@ -138,5 +144,4 @@ void prepare_sim_uecap(NR_UE_NR_Capability_t *cap,
                        int rbsize,
                        int mcs_table);
 
-
 #endif