Merge remote-tracking branch...

Merge remote-tracking branch 'origin/improve-readability-phy_procedures_gNB_uespec_RX' into integration_2025_w46 (!3707)

Cleanup phy_procedures_gNB_uespec_RX

phy_procedures_gNB_uespec_RX is too long function with too long lines of code,
this commit only shorten lines and improve a bit the readability

openair1/PHY/NR_TRANSPORT/nr_prs.c

@@ -13,7 +13,7 @@ int nr_generate_prs(int slot,
                     int16_t amp,
                     prs_config_t *prs_cfg,
                     nfapi_nr_config_request_scf_t *config,
-                    NR_DL_FRAME_PARMS *frame_parms)
+                    const NR_DL_FRAME_PARMS *frame_parms)
 {
   
   int k_prime = 0, k = 0, idx;

openair1/PHY/NR_TRANSPORT/nr_transport_proto.h

@@ -45,7 +45,7 @@ int nr_generate_prs(int slot,
                     int16_t amp,
                     prs_config_t *prs_cfg,
                     nfapi_nr_config_request_scf_t *config,
-                    NR_DL_FRAME_PARMS *frame_parms);
+                    const NR_DL_FRAME_PARMS *frame_parms);
 
 /*!
 \fn int nr_generate_pss

openair1/PHY/nr_phy_common/inc/nr_phy_common.h

@@ -365,7 +365,7 @@ void nr_channel_level(const int symbol,
                       int32_t avg[nb_rx * Nl],
                       const uint32_t len);
 void nr_scale_channel(int size, int ch_estimates_ext[][size], int symb, uint32_t len, int nrOfLayers, int nb_rx, int shift_ch_ext);
-bool generate_srs_nr(NR_DL_FRAME_PARMS *frame_parms,
+bool generate_srs_nr(const NR_DL_FRAME_PARMS *frame_parms,
                      c16_t **txdataF,
                      uint16_t symbol_offset,
                      int bwp_start,

openair1/PHY/nr_phy_common/src/nr_phy_common_srs.c

@@ -139,7 +139,7 @@ static int compute_n_b(frame_t frame_number,
 *                See TS 38.211 - Section 6.4.1.4 Sounding reference signal
 *
 ***************************************************************************/
-bool generate_srs_nr(NR_DL_FRAME_PARMS *frame_parms,
+bool generate_srs_nr(const NR_DL_FRAME_PARMS *frame_parms,
                      c16_t **txdataF,
                      uint16_t symbol_offset,
                      int bwp_start,

openair1/SCHED_NR/fapi_nr_l1.h

@@ -53,15 +53,6 @@ void handle_nr_nfapi_pdsch_pdu(processingData_L1tx_t *msgTx,
 			       nfapi_nr_dl_tti_pdsch_pdu *pdsch_pdu,
                             uint8_t *sdu);
 
-void nr_fill_indication(PHY_VARS_gNB *gNB,
-                        int frame,
-                        int slot_rx,
-                        int UE_id,
-                        uint8_t harq_pid,
-                        uint8_t crc_flag,
-                        int dtx_flag,
-                        nfapi_nr_crc_t *crc,
-                        nfapi_nr_rx_data_pdu_t *pdu);
 //added
 
 void handle_nfapi_nr_ul_dci_pdu(PHY_VARS_gNB *gNB,

openair1/SCHED_NR/phy_frame_config_nr.c

@@ -152,7 +152,7 @@ void set_tdd_config_nr(nfapi_nr_config_request_scf_t *cfg, frame_structure_t *fs
   }
 }
 
-int nr_slot_select(nfapi_nr_config_request_scf_t *cfg, int nr_frame, int nr_slot)
+int nr_slot_select(const nfapi_nr_config_request_scf_t *cfg, int nr_frame, int nr_slot)
 {
   (void) nr_frame;
 

openair1/SCHED_NR/phy_frame_config_nr.h

@@ -53,7 +53,7 @@ void set_tdd_config_nr(nfapi_nr_config_request_scf_t *cfg, frame_structure_t *fs
  *  @param nr_slot  : slot number
     @returns int : downlink, uplink or mixed slot type*/
 
-int nr_slot_select(nfapi_nr_config_request_scf_t *cfg, int nr_frame, int nr_slot);
+int nr_slot_select(const nfapi_nr_config_request_scf_t *cfg, int nr_frame, int nr_slot);
 
 void do_tdd_config_sim(PHY_VARS_gNB *gNB, int mu);
 

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -45,6 +45,15 @@
 
 //#define DEBUG_RXDATA
 //#define SRS_IND_DEBUG
+static void nr_fill_indication(PHY_VARS_gNB *gNB,
+                               int frame,
+                               int slot_rx,
+                               int UE_id,
+                               uint8_t harq_pid,
+                               uint8_t crc_flag,
+                               int dtx_flag,
+                               nfapi_nr_crc_t *crc,
+                               nfapi_nr_rx_data_pdu_t *pdu);
 
 int beam_index_allocation(bool das,
                           int fapi_beam_index,
@@ -186,10 +195,10 @@ void nr_common_signal_procedures(PHY_VARS_gNB *gNB, int frame, int slot, nfapi_n
 void clear_slot_beamid(PHY_VARS_gNB *gNB, int slot)
 {
   LOG_D(PHY, "Clearing beam_id structure for slot %d\n", slot);
-  NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+  int slot_sz = gNB->frame_parms.symbols_per_slot;
   for (int i = 0; i < gNB->common_vars.num_beams_period; i++) {
     if (gNB->common_vars.beam_id)
-      memset(&gNB->common_vars.beam_id[i][slot * fp->symbols_per_slot], -1, fp->symbols_per_slot * sizeof(int));
+      memset(&gNB->common_vars.beam_id[i][slot * slot_sz], -1, slot_sz * sizeof(**gNB->common_vars.beam_id));
   }
 }
 
@@ -199,11 +208,9 @@ void phy_procedures_gNB_TX(processingData_L1tx_t *msgTx,
                            int do_meas)
 {
   PHY_VARS_gNB *gNB = msgTx->gNB;
-  NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
+  const NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   nfapi_nr_config_request_scf_t *cfg = &gNB->gNB_config;
-  int slot_prs = 0;
-  int txdataF_offset = slot * fp->samples_per_slot_wCP;
-  prs_config_t *prs_config = NULL;
+  const int txdataF_offset = slot * fp->samples_per_slot_wCP;
 
   if ((cfg->cell_config.frame_duplex_type.value == TDD) && (nr_slot_select(cfg,frame,slot) == NR_UPLINK_SLOT))
     return;
@@ -213,19 +220,19 @@ void phy_procedures_gNB_TX(processingData_L1tx_t *msgTx,
   // clear the transmit data array and beam index for the current slot
   for (int i = 0; i < gNB->common_vars.num_beams_period; i++) {
     for (int aa = 0; aa < cfg->carrier_config.num_tx_ant.value; aa++) {
-      memset(&gNB->common_vars.txdataF[i][aa][txdataF_offset], 0, fp->samples_per_slot_wCP * sizeof(int32_t));
+      memset(&gNB->common_vars.txdataF[i][aa][txdataF_offset], 0, fp->samples_per_slot_wCP * sizeof(***gNB->common_vars.txdataF));
     }
   }
 
   // Check for PRS slot - section 7.4.1.7.4 in 3GPP rel16 38.211
   for(int rsc_id = 0; rsc_id < gNB->prs_vars.NumPRSResources; rsc_id++)
   {
-    prs_config = &gNB->prs_vars.prs_cfg[rsc_id];
+    prs_config_t *prs_config = &gNB->prs_vars.prs_cfg[rsc_id];
     for (int i = 0; i < prs_config->PRSResourceRepetition; i++)
     {
       if( (((frame*fp->slots_per_frame + slot) - (prs_config->PRSResourceSetPeriod[1] + prs_config->PRSResourceOffset)+prs_config->PRSResourceSetPeriod[0])%prs_config->PRSResourceSetPeriod[0]) == i*prs_config->PRSResourceTimeGap )
       {
-        slot_prs = (slot - i*prs_config->PRSResourceTimeGap + fp->slots_per_frame)%fp->slots_per_frame;
+        int slot_prs = (slot - i * prs_config->PRSResourceTimeGap + fp->slots_per_frame) % fp->slots_per_frame;
         LOG_D(PHY,"gNB_TX: frame %d, slot %d, slot_prs %d, PRS Resource ID %d\n",frame, slot, slot_prs, rsc_id);
         nr_generate_prs(slot_prs, &gNB->common_vars.txdataF[0][0][txdataF_offset], AMP, prs_config, cfg, fp);
       }
@@ -537,7 +544,7 @@ static int nr_ulsch_procedures(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, boo
   return ret_nr_ulsch_decoding;
 }
 
-void nr_fill_indication(PHY_VARS_gNB *gNB,
+static void nr_fill_indication(PHY_VARS_gNB *gNB,
                                int frame,
                                int slot_rx,
                                int ULSCH_id,
@@ -547,14 +554,14 @@ void nr_fill_indication(PHY_VARS_gNB *gNB,
                                nfapi_nr_crc_t *crc,
                                nfapi_nr_rx_data_pdu_t *pdu)
 {
-  NR_gNB_ULSCH_t *ulsch = &gNB->ulsch[ULSCH_id];
-  NR_UL_gNB_HARQ_t *harq_process = ulsch->harq_process;
-  NR_gNB_PHY_STATS_t *stats = get_phy_stats(gNB, ulsch->rnti);
+  NR_UL_gNB_HARQ_t *harq_process = gNB->ulsch[ULSCH_id].harq_process;
+  NR_gNB_PHY_STATS_t *stats = get_phy_stats(gNB, gNB->ulsch[ULSCH_id].rnti);
+  NR_gNB_PUSCH *pusch = &gNB->pusch_vars[ULSCH_id];
 
   nfapi_nr_pusch_pdu_t *pusch_pdu = &harq_process->ulsch_pdu;
 
   // Get estimated timing advance for MAC
-  int sync_pos = ulsch->delay.est_delay;
+  const int sync_pos = gNB->ulsch[ULSCH_id].delay.est_delay;
 
   // scale the 16 factor in N_TA calculation in 38.213 section 4.2 according to the used FFT size
   uint16_t bw_scaling = 16 * gNB->frame_parms.ofdm_symbol_size / 2048;
@@ -584,16 +591,15 @@ void nr_fill_indication(PHY_VARS_gNB *gNB,
           timing_advance_update);
 
   // estimate UL_CQI for MAC
-  int SNRtimes10 =
-      dB_fixed_x10(gNB->pusch_vars[ULSCH_id].ulsch_power_tot) - dB_fixed_x10(gNB->pusch_vars[ULSCH_id].ulsch_noise_power_tot);
+  int SNRtimes10 = dB_fixed_x10(pusch->ulsch_power_tot) - dB_fixed_x10(pusch->ulsch_noise_power_tot);
 
   LOG_D(PHY,
         "%d.%d: Estimated SNR for PUSCH is = %f dB (ulsch_power %f, noise %f) delay %d\n",
         frame,
         slot_rx,
         SNRtimes10 / 10.0,
-        dB_fixed_x10(gNB->pusch_vars[ULSCH_id].ulsch_power_tot) / 10.0,
-        dB_fixed_x10(gNB->pusch_vars[ULSCH_id].ulsch_noise_power_tot) / 10.0,
+        dB_fixed_x10(pusch->ulsch_power_tot) / 10.0,
+        dB_fixed_x10(pusch->ulsch_noise_power_tot) / 10.0,
         sync_pos);
 
   int cqi;
@@ -609,8 +615,7 @@ void nr_fill_indication(PHY_VARS_gNB *gNB,
   crc->ul_cqi = cqi;
   crc->timing_advance = timing_advance_update;
   // in terms of dBFS range -128 to 0 with 0.1 step
-  crc->rssi =
-      (dtx_flag == 0) ? 1280 - (10 * dB_fixed(32767 * 32767) - dB_fixed_times10(gNB->pusch_vars[ULSCH_id].ulsch_power[0])) : 0;
+  crc->rssi = (dtx_flag == 0) ? 1280 - (10 * dB_fixed(32767 * 32767) - dB_fixed_times10(pusch->ulsch_power[0])) : 0;
 
   pdu->handle = pusch_pdu->handle;
   pdu->rnti = pusch_pdu->rnti;
@@ -627,18 +632,18 @@ void nr_fill_indication(PHY_VARS_gNB *gNB,
 }
 
 // Function to fill UL RB mask to be used for N0 measurements
-static void fill_ul_rb_mask(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, uint32_t rb_mask_ul[14][9])
+static void fill_ul_rb_mask(PHY_VARS_gNB *gNB,
+                            int frame_rx,
+                            int slot_rx,
+                            uint32_t rb_mask_ul[14][9],
+                            nfapi_nr_max_num_of_symbol_per_slot_t *slot_conf)
 {
-  int rb = 0;
-  int rb2 = 0;
-  int prbpos = 0;
-
   for (int symbol = 0; symbol < 14; symbol++) {
     for (int m = 0; m < 9; m++) {
       rb_mask_ul[symbol][m] = 0;
       for (int i = 0; i < 32; i++) {
-        prbpos = (m * 32) + i;
-        if (prbpos>gNB->frame_parms.N_RB_UL)
+        int prbpos = (m * 32) + i;
+        if (prbpos > gNB->frame_parms.N_RB_UL)
           break;
         rb_mask_ul[symbol][m] |= (gNB->ulprbbl[prbpos] > 0 ? 1U : 0) << i;
       }
@@ -646,23 +651,27 @@ static void fill_ul_rb_mask(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, uint32
   }
 
   for (int i = 0; i < gNB->max_nb_pucch; i++){
-    NR_gNB_PUCCH_t *pucch = &gNB->pucch[i];
-    if (pucch) {
-      if ((pucch->active == 1) &&
-          (pucch->frame == frame_rx) &&
-          (pucch->slot == slot_rx) ) {
-        nfapi_nr_pucch_pdu_t  *pucch_pdu = &pucch->pucch_pdu;
-        LOG_D(PHY,"%d.%d pucch %d : start_symbol %d, nb_symbols %d, prb_size %d\n",frame_rx,slot_rx,i,pucch_pdu->start_symbol_index,pucch_pdu->nr_of_symbols,pucch_pdu->prb_size);
-        for (int symbol=pucch_pdu->start_symbol_index ; symbol<(pucch_pdu->start_symbol_index+pucch_pdu->nr_of_symbols);symbol++) {
-          if(gNB->frame_parms.frame_type == FDD ||
-              (gNB->frame_parms.frame_type == TDD && gNB->gNB_config.tdd_table.max_tdd_periodicity_list[slot_rx].max_num_of_symbol_per_slot_list[symbol].slot_config.value==1)) {
-            for (rb=0; rb<pucch_pdu->prb_size; rb++) {
-              rb2 = rb + pucch_pdu->bwp_start +
-                    ((symbol < pucch_pdu->start_symbol_index+(pucch_pdu->nr_of_symbols>>1)) || (pucch_pdu->freq_hop_flag == 0) ?
-                     pucch_pdu->prb_start : pucch_pdu->second_hop_prb);
-              rb_mask_ul[symbol][rb2>>5] |= (((uint32_t)1)<<(rb2&31));
-            }
-          }
+    const NR_gNB_PUCCH_t *pucch = gNB->pucch + i;
+    if (!(pucch && pucch->active && pucch->frame == frame_rx && pucch->slot == slot_rx))
+      continue;
+    const nfapi_nr_pucch_pdu_t *pucch_pdu = &pucch->pucch_pdu;
+    const int start = pucch_pdu->start_symbol_index;
+    LOG_D(PHY,
+          "%d.%d pucch %d : start_symbol %d, nb_symbols %d, prb_size %d\n",
+          frame_rx,
+          slot_rx,
+          i,
+          start,
+          pucch_pdu->nr_of_symbols,
+          pucch_pdu->prb_size);
+    for (int symbol = start; symbol < (start + pucch_pdu->nr_of_symbols); symbol++) {
+      if (gNB->frame_parms.frame_type == FDD || (gNB->frame_parms.frame_type == TDD && slot_conf[symbol].slot_config.value == 1)) {
+        for (int rb = 0; rb < pucch_pdu->prb_size; rb++) {
+          int rb2 =
+              rb + pucch_pdu->bwp_start
+              + ((symbol < start + (pucch_pdu->nr_of_symbols >> 1)) || (pucch_pdu->freq_hop_flag == 0) ? pucch_pdu->prb_start
+                                                                                                       : pucch_pdu->second_hop_prb);
+          rb_mask_ul[symbol][rb2 >> 5] |= 1U << (rb2 & 31);
         }
       }
     }
@@ -672,63 +681,59 @@ static void fill_ul_rb_mask(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, uint32
     NR_gNB_ULSCH_t *ulsch = &gNB->ulsch[ULSCH_id];
     NR_UL_gNB_HARQ_t *ulsch_harq = ulsch->harq_process;
     AssertFatal(ulsch_harq != NULL, "harq_pid %d is not allocated\n", ulsch->harq_pid);
-    if ((ulsch->active == true) && (ulsch->frame == frame_rx) && (ulsch->slot == slot_rx) && (ulsch->handled == 0)) {
+    if (!(ulsch->active && ulsch->frame == frame_rx && ulsch->slot == slot_rx && !ulsch->handled))
+      continue;
     uint8_t symbol_start = ulsch_harq->ulsch_pdu.start_symbol_index;
     uint8_t symbol_end = symbol_start + ulsch_harq->ulsch_pdu.nr_of_symbols;
     for (int symbol = symbol_start; symbol < symbol_end; symbol++) {
-        if (gNB->frame_parms.frame_type == FDD
-            || (gNB->frame_parms.frame_type == TDD
-                && gNB->gNB_config.tdd_table.max_tdd_periodicity_list[slot_rx]
-                           .max_num_of_symbol_per_slot_list[symbol]
-                           .slot_config.value
-                       == 1)) {
+      if (gNB->frame_parms.frame_type == FDD || (gNB->frame_parms.frame_type == TDD && slot_conf[symbol].slot_config.value == 1)) {
         LOG_D(PHY, "symbol %d Filling rb_mask_ul rb_size %d\n", symbol, ulsch_harq->ulsch_pdu.rb_size);
-          for (rb = 0; rb < ulsch_harq->ulsch_pdu.rb_size; rb++) {
-            rb2 = rb + ulsch_harq->ulsch_pdu.rb_start + ulsch_harq->ulsch_pdu.bwp_start;
+        for (int rb = 0; rb < ulsch_harq->ulsch_pdu.rb_size; rb++) {
+          int rb2 = rb + ulsch_harq->ulsch_pdu.rb_start + ulsch_harq->ulsch_pdu.bwp_start;
           rb_mask_ul[symbol][rb2 >> 5] |= 1U << (rb2 & 31);
         }
       }
     }
   }
-  }
 
   for (int i = 0; i < gNB->max_nb_srs; i++) {
     NR_gNB_SRS_t *srs = &gNB->srs[i];
-    if (srs) {
-      if ((srs->active == 1) && (srs->frame == frame_rx) && (srs->slot == slot_rx)) {
+    if (!(srs && srs->active && srs->frame == frame_rx && srs->slot == slot_rx))
+      continue;
     nfapi_nr_srs_pdu_t *srs_pdu = &srs->srs_pdu;
-        for(int symbol = 0; symbol < (1 << srs_pdu->num_symbols); symbol++) {
-          for(rb = srs_pdu->bwp_start; rb < (srs_pdu->bwp_start+srs_pdu->bwp_size); rb++) {
+    for (int symbol = 0; symbol < (1 << srs_pdu->num_symbols); symbol++) {
+      for (int rb = srs_pdu->bwp_start; rb < (srs_pdu->bwp_start + srs_pdu->bwp_size); rb++) {
         rb_mask_ul[srs_pdu->time_start_position + symbol][rb >> 5] |= 1U << (rb & 31);
       }
     }
   }
-    }
-  }
 }
 
-int fill_srs_reported_symbol(nfapi_nr_srs_reported_symbol_t *reported_symbol,
+static int fill_srs_reported_symbol(nfapi_nr_srs_reported_symbol_t *reported_symbol,
                                     const nfapi_nr_srs_pdu_t *srs_pdu,
                                     const int N_RB_UL,
                                     const int16_t *snr_per_rb,
-                                  const int srs_est) {
+                                    const int srs_est)
+{
   reported_symbol->num_prgs = srs_pdu->beamforming.num_prgs;
   for (int prg_idx = 0; prg_idx < reported_symbol->num_prgs; prg_idx++) {
-    if (srs_est<0) {
-      reported_symbol->prg_list[prg_idx].rb_snr = 0xFF;
+    uint8_t *snr = &reported_symbol->prg_list[prg_idx].rb_snr;
+    if (srs_est < 0) {
+      *snr = 0xFF;
     } else if (snr_per_rb[prg_idx] < -64) {
-      reported_symbol->prg_list[prg_idx].rb_snr = 0;
+      *snr = 0;
     } else if (snr_per_rb[prg_idx] > 63) {
-      reported_symbol->prg_list[prg_idx].rb_snr = 0xFE;
+      *snr = 0xFE;
     } else {
-      reported_symbol->prg_list[prg_idx].rb_snr = (snr_per_rb[prg_idx] + 64) << 1;
+      *snr = (snr_per_rb[prg_idx] + 64) << 1;
     }
   }
 
   return 0;
 }
 
-int fill_srs_channel_matrix(uint8_t *channel_matrix,
+static int fill_srs_channel_matrix(
+    nfapi_nr_srs_normalized_channel_iq_matrix_t *nr_srs_channel_iq_matrix,
     const nfapi_nr_srs_pdu_t *srs_pdu,
     const nr_srs_info_t *nr_srs_info,
     const uint8_t normalized_iq_representation,
@@ -740,6 +745,12 @@ int fill_srs_channel_matrix(uint8_t *channel_matrix,
     const c16_t srs_estimated_channel_freq[][1 << srs_pdu->num_ant_ports]
                                           [frame_parms->ofdm_symbol_size * (1 << srs_pdu->num_symbols)])
 {
+  nr_srs_channel_iq_matrix->normalized_iq_representation = normalized_iq_representation;
+  nr_srs_channel_iq_matrix->num_gnb_antenna_elements = num_gnb_antenna_elements;
+  nr_srs_channel_iq_matrix->num_ue_srs_ports = num_ue_srs_ports;
+  nr_srs_channel_iq_matrix->prg_size = prg_size;
+  nr_srs_channel_iq_matrix->num_prgs = num_prgs;
+  uint8_t *channel_matrix = nr_srs_channel_iq_matrix->channel_matrix;
   const uint64_t subcarrier_offset = frame_parms->first_carrier_offset + srs_pdu->bwp_start*NR_NB_SC_PER_RB;
   const uint16_t step = prg_size*NR_NB_SC_PER_RB;
 
@@ -837,75 +848,73 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
   int pusch_decode_done = 0;
   int pusch_DTX = 0;
 
+  const NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
+  const int symb_sz = frame_parms->ofdm_symbol_size;
+  const int nb_symb = frame_parms->symbols_per_slot;
+  const int ant = gNB->frame_parms.nb_antennas_rx;
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_UESPEC_RX,1);
   LOG_D(PHY,"phy_procedures_gNB_uespec_RX frame %d, slot %d\n",frame_rx,slot_rx);
+  {
     // Mask of occupied RBs, per symbol and PRB
     uint32_t rb_mask_ul[14][9];
-  fill_ul_rb_mask(gNB, frame_rx, slot_rx, rb_mask_ul);
-
-  int first_symb=0,num_symb=0;
-  if (gNB->frame_parms.frame_type == TDD)
-    for(int symbol_count=0; symbol_count<NR_NUMBER_OF_SYMBOLS_PER_SLOT; symbol_count++) {
-      if (gNB->gNB_config.tdd_table.max_tdd_periodicity_list[slot_rx].max_num_of_symbol_per_slot_list[symbol_count].slot_config.value==1) {
-	      if (num_symb==0) first_symb=symbol_count;
+    nfapi_nr_max_num_of_symbol_per_slot_t *slot_conf = NULL;
+    if (frame_parms->frame_type == TDD)
+      slot_conf = gNB->gNB_config.tdd_table.max_tdd_periodicity_list[slot_rx].max_num_of_symbol_per_slot_list;
+    fill_ul_rb_mask(gNB, frame_rx, slot_rx, rb_mask_ul, slot_conf);
+
+    int first_symb = 0, num_symb = 0;
+    if (frame_parms->frame_type == TDD)
+      for (int symbol_count = 0; symbol_count < NR_NUMBER_OF_SYMBOLS_PER_SLOT; symbol_count++) {
+        if (slot_conf[symbol_count].slot_config.value == 1) {
+          if (num_symb == 0)
+            first_symb = symbol_count;
           num_symb++;
         }
       }
     else
       num_symb = NR_NUMBER_OF_SYMBOLS_PER_SLOT;
     gNB_I0_measurements(gNB, slot_rx, first_symb, num_symb, rb_mask_ul);
+  }
 
-  const int soffset = (slot_rx & 3) * gNB->frame_parms.symbols_per_slot * gNB->frame_parms.ofdm_symbol_size;
+  const int soffset = (slot_rx & 3) * nb_symb * symb_sz;
   start_meas(&gNB->phy_proc_rx);
 
   for (int i = 0; i < gNB->max_nb_pucch; i++) {
     NR_gNB_PUCCH_t *pucch = &gNB->pucch[i];
-    if (pucch) {
-      if (pucch->active && (pucch->frame == frame_rx) && (pucch->slot == slot_rx)) {
+    if (!(pucch && pucch->active && pucch->frame == frame_rx && pucch->slot == slot_rx))
+      continue;
     c16_t **rxdataF = gNB->common_vars.rxdataF[pucch->beam_nb];
     pucch_decode_done = 1;
     nfapi_nr_pucch_pdu_t *pucch_pdu = &pucch->pucch_pdu;
     UL_INFO->uci_ind.uci_list = UL_INFO->uci_pdu_list;
     nfapi_nr_uci_t *uci = UL_INFO->uci_ind.uci_list + UL_INFO->uci_ind.num_ucis;
-        switch (pucch_pdu->format_type) {
-          case 0:
     UL_INFO->uci_ind.sfn = frame_rx;
     UL_INFO->uci_ind.slot = slot_rx;
+    switch (pucch_pdu->format_type) {
+      case 0:
         uci->pdu_type = NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE;
         uci->pdu_size = sizeof(nfapi_nr_uci_pucch_pdu_format_0_1_t);
         nfapi_nr_uci_pucch_pdu_format_0_1_t *uci_pdu_format0 = &uci->pucch_pdu_format_0_1;
-
-            int offset = pucch_pdu->start_symbol_index * gNB->frame_parms.ofdm_symbol_size
-                         + (gNB->frame_parms.first_carrier_offset + pucch_pdu->prb_start * 12);
+        int offset = pucch_pdu->start_symbol_index * symb_sz + (frame_parms->first_carrier_offset + pucch_pdu->prb_start * 12);
         LOG_D(NR_PHY,
               "frame %d, slot %d: PUCCH signal energy %d\n",
               frame_rx,
               slot_rx,
               signal_energy_nodc(&rxdataF[0][soffset + offset], 12));
-
         nr_decode_pucch0(gNB, rxdataF, frame_rx, slot_rx, uci_pdu_format0, pucch_pdu);
-
-            UL_INFO->uci_ind.num_ucis += 1;
-            pucch->active = false;
         break;
       case 2:
-            UL_INFO->uci_ind.sfn = frame_rx;
-            UL_INFO->uci_ind.slot = slot_rx;
         uci->pdu_type = NFAPI_NR_UCI_FORMAT_2_3_4_PDU_TYPE;
         uci->pdu_size = sizeof(nfapi_nr_uci_pucch_pdu_format_2_3_4_t);
         nfapi_nr_uci_pucch_pdu_format_2_3_4_t *uci_pdu_format2 = &uci->pucch_pdu_format_2_3_4;
-
         LOG_D(PHY, "%d.%d Calling nr_decode_pucch2\n", frame_rx, slot_rx);
         nr_decode_pucch2(gNB, rxdataF, frame_rx, slot_rx, uci_pdu_format2, pucch_pdu);
-
-            UL_INFO->uci_ind.num_ucis += 1;
-            pucch->active = false;
         break;
       default:
         AssertFatal(1 == 0, "Only PUCCH formats 0 and 2 are currently supported\n");
     }
-      }
-    }
+    UL_INFO->uci_ind.num_ucis += 1;
+    pucch->active = false;
   }
 
   UL_INFO->crc_ind.sfn = frame_rx;
@@ -915,23 +924,23 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
   UL_INFO->rx_ind.slot = slot_rx;
   UL_INFO->rx_ind.pdu_list = UL_INFO->rx_pdu_list;
   bool ulsch_to_decode[gNB->max_nb_pusch];
-  bzero((void *)ulsch_to_decode, sizeof(ulsch_to_decode));
+  bzero(ulsch_to_decode, sizeof(ulsch_to_decode));
   for (int ULSCH_id = 0; ULSCH_id < gNB->max_nb_pusch; ULSCH_id++) {
     NR_gNB_ULSCH_t *ulsch = &gNB->ulsch[ULSCH_id];
     NR_UL_gNB_HARQ_t *ulsch_harq = ulsch->harq_process;
     AssertFatal(ulsch_harq != NULL, "harq_pid %d is not allocated\n", ulsch->harq_pid);
-    if ((ulsch->active == true) && (ulsch->frame == frame_rx) && (ulsch->slot == slot_rx) && (ulsch->handled == 0)) {
+    if (!(ulsch->active && ulsch->frame == frame_rx && ulsch->slot == slot_rx && !ulsch->handled))
+      continue;
     LOG_D(PHY, "PUSCH ID %d with RNTI %x detection started in frame %d slot %d\n", ULSCH_id, ulsch->rnti, frame_rx, slot_rx);
     nfapi_nr_pusch_pdu_t *pdu = &ulsch_harq->ulsch_pdu;
     int num_dmrs = count_bits64_with_mask(pdu->ul_dmrs_symb_pos, 0, NR_NUMBER_OF_SYMBOLS_PER_SLOT);
 
 #ifdef DEBUG_RXDATA
-      NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
     RU_t *ru = gNB->RU_list[0];
     int slot_offset = frame_parms->get_samples_slot_timestamp(slot_rx, frame_parms, 0);
     slot_offset -= ru->N_TA_offset;
     int32_t sample_offset = gNB->common_vars.debugBuff_sample_offset;
-      int16_t *buf = (int16_t *)&gNB->common_vars.debugBuff[offset];
+    int16_t buf = (int16_t *)&gNB->common_vars.debugBuff[offset];
     buf[0] = (int16_t)ulsch->rnti;
     buf[1] = (int16_t)pdu->rb_size;
     buf[2] = (int16_t)pdu->rb_start;
@@ -966,7 +975,7 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
     NR_gNB_PUSCH *pusch_vars = &gNB->pusch_vars[ULSCH_id];
     pusch_vars->ulsch_power_tot = 0;
     pusch_vars->ulsch_noise_power_tot = 0;
-      for (int aarx = 0; aarx < gNB->frame_parms.nb_antennas_rx; aarx++) {
+    for (int aarx = 0; aarx < ant; aarx++) {
       pusch_vars->ulsch_power[aarx] /= num_dmrs;
       pusch_vars->ulsch_power_tot += pusch_vars->ulsch_power[aarx];
       pusch_vars->ulsch_noise_power[aarx] /= num_dmrs;
@@ -1013,7 +1022,6 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
     // LOG_M("rxdataF_comp.m","rxF_comp",gNB->pusch_vars[0]->rxdataF_comp[0],6900,1,1);
     // LOG_M("rxdataF_ext.m","rxF_ext",gNB->pusch_vars[0]->rxdataF_ext[0],6900,1,1);
   }
-  }
 
   /* Do ULSCH decoding time measurement only when number of PUSCH is limited to 1
    * (valid for unitary physical simulators). ULSCH processing lopp is then executed
@@ -1033,25 +1041,22 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
    * measurement per processed TB.*/
   if (gNB->max_nb_pusch == 1)
     stop_meas(&gNB->ulsch_decoding_stats);
+
   for (int i = 0; i < gNB->max_nb_srs; i++) {
     NR_gNB_SRS_t *srs = &gNB->srs[i];
-    if (srs) {
-      if ((srs->active == true) && (srs->frame == frame_rx) && (srs->slot == slot_rx)) {
+    if (!(srs && srs->active && srs->frame == frame_rx && srs->slot == slot_rx))
+      continue;
     LOG_D(NR_PHY, "(%d.%d) gNB is waiting for SRS, id = %i\n", frame_rx, slot_rx, i);
 
     start_meas(&gNB->rx_srs_stats);
 
-        NR_DL_FRAME_PARMS *frame_parms = &gNB->frame_parms;
     nfapi_nr_srs_pdu_t *srs_pdu = &srs->srs_pdu;
     uint8_t N_symb_SRS = 1 << srs_pdu->num_symbols;
-        c16_t srs_received_signal[frame_parms->nb_antennas_rx][frame_parms->ofdm_symbol_size * N_symb_SRS];
-        c16_t srs_received_noise[frame_parms->nb_antennas_rx][frame_parms->ofdm_symbol_size * N_symb_SRS];
-        c16_t srs_estimated_channel_freq[frame_parms->nb_antennas_rx][1 << srs_pdu->num_ant_ports]
-                                        [frame_parms->ofdm_symbol_size * N_symb_SRS] __attribute__((aligned(32)));
-        c16_t srs_estimated_channel_time[frame_parms->nb_antennas_rx][1 << srs_pdu->num_ant_ports][frame_parms->ofdm_symbol_size]
-            __attribute__((aligned(32)));
-        c16_t srs_estimated_channel_time_shifted[frame_parms->nb_antennas_rx][1 << srs_pdu->num_ant_ports]
-                                                [frame_parms->ofdm_symbol_size];
+    c16_t srs_received_signal[ant][symb_sz * N_symb_SRS];
+    c16_t srs_received_noise[ant][symb_sz * N_symb_SRS];
+    c16_t srs_estimated_channel_freq[ant][1 << srs_pdu->num_ant_ports][symb_sz * N_symb_SRS] __attribute__((aligned(32)));
+    c16_t srs_estimated_channel_time[ant][1 << srs_pdu->num_ant_ports][symb_sz] __attribute__((aligned(32)));
+    c16_t srs_estimated_channel_time_shifted[ant][1 << srs_pdu->num_ant_ports][symb_sz];
     int16_t snr_per_rb[srs_pdu->bwp_size];
 
     start_meas(&gNB->generate_srs_stats);
@@ -1069,7 +1074,8 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
     stop_meas(&gNB->generate_srs_stats);
     c16_t **rxdataF = gNB->common_vars.rxdataF[srs->beam_nb];
     start_meas(&gNB->get_srs_signal_stats);
-        int srs_est = nr_get_srs_signal(gNB, rxdataF, frame_rx, slot_rx, srs_pdu, gNB->nr_srs_info[i], srs_received_signal, srs_received_noise);
+    int srs_est =
+        nr_get_srs_signal(gNB, rxdataF, frame_rx, slot_rx, srs_pdu, gNB->nr_srs_info[i], srs_received_signal, srs_received_noise);
     stop_meas(&gNB->get_srs_signal_stats);
 
     if (srs_est >= 0) {
@@ -1079,7 +1085,7 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
                                 slot_rx,
                                 srs_pdu,
                                 gNB->nr_srs_info[i],
-                                    (const c16_t**)gNB->nr_srs_info[i]->srs_generated_signal,
+                                (const c16_t **)gNB->nr_srs_info[i]->srs_generated_signal,
                                 srs_received_signal,
                                 srs_received_noise,
                                 srs_estimated_channel_freq,
@@ -1100,7 +1106,7 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
       T_INT(frame_rx),
       T_INT(0),
       T_INT(0),
-          T_BUFFER(srs_estimated_channel_freq[0][0], frame_parms->ofdm_symbol_size * sizeof(int32_t)));
+      T_BUFFER(srs_estimated_channel_freq[0][0], symb_sz * sizeof(int32_t)));
 
     T(T_GNB_PHY_UL_TIME_CHANNEL_ESTIMATE,
       T_INT(0),
@@ -1108,7 +1114,7 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
       T_INT(frame_rx),
       T_INT(0),
       T_INT(0),
-          T_BUFFER(srs_estimated_channel_time_shifted[0][0], frame_parms->ofdm_symbol_size * sizeof(int32_t)));
+      T_BUFFER(srs_estimated_channel_time_shifted[0][0], symb_sz * sizeof(int32_t)));
 
     T(T_GNB_PHY_UL_SNR_ESTIMATE,
       T_INT(0),
@@ -1127,9 +1133,12 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
     srs_indication->handle = srs_pdu->handle;
     srs_indication->rnti = srs_pdu->rnti;
     start_meas(&gNB->srs_timing_advance_stats);
-        srs_indication->timing_advance_offset = srs_est >= 0 ? nr_est_timing_advance_srs(frame_parms, srs_estimated_channel_time[0]) : 0xFFFF;
+    srs_indication->timing_advance_offset =
+        srs_est >= 0 ? nr_est_timing_advance_srs(frame_parms, srs_estimated_channel_time[0]) : 0xFFFF;
     stop_meas(&gNB->srs_timing_advance_stats);
-        srs_indication->timing_advance_offset_nsec = srs_est >= 0 ? (int16_t)((((int32_t)srs_indication->timing_advance_offset - 31) * ((int32_t)TC_NSEC_x32768)) >> 15) : 0xFFFF;
+    srs_indication->timing_advance_offset_nsec =
+        srs_est >= 0 ? (int16_t)((((int32_t)srs_indication->timing_advance_offset - 31) * ((int32_t)TC_NSEC_x32768)) >> 15)
+                     : 0xFFFF;
     switch (srs_pdu->srs_parameters_v4.usage) {
       case 0:
         LOG_W(NR_PHY, "SRS report was not requested by MAC\n");
@@ -1172,7 +1181,8 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
         nfapi_nr_srs_beamforming_report_t nr_srs_bf_report;
         nr_srs_bf_report.prg_size = srs_pdu->beamforming.prg_size;
         nr_srs_bf_report.num_symbols = 1 << srs_pdu->num_symbols;
-            nr_srs_bf_report.wide_band_snr = srs_est >= 0 ? (gNB->srs->snr + 64) << 1 : 0xFF; // 0xFF will be set if this field is invalid
+        nr_srs_bf_report.wide_band_snr =
+            srs_est >= 0 ? (gNB->srs->snr + 64) << 1 : 0xFF; // 0xFF will be set if this field is invalid
         nr_srs_bf_report.num_reported_symbols = 1 << srs_pdu->num_symbols;
         AssertFatal(nr_srs_bf_report.num_reported_symbols == 1,
                     "nr_srs_bf_report.num_reported_symbols %i not handled yet!\n",
@@ -1182,9 +1192,14 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
 #ifdef SRS_IND_DEBUG
         LOG_I(NR_PHY, "nr_srs_bf_report.prg_size = %i\n", nr_srs_bf_report.prg_size);
         LOG_I(NR_PHY, "nr_srs_bf_report.num_symbols = %i\n", nr_srs_bf_report.num_symbols);
-            LOG_I(NR_PHY, "nr_srs_bf_report.wide_band_snr = %i (%i dB)\n", nr_srs_bf_report.wide_band_snr, (nr_srs_bf_report.wide_band_snr >> 1) - 64);
+        LOG_I(NR_PHY,
+              "nr_srs_bf_report.wide_band_snr = %i (%i dB)\n",
+              nr_srs_bf_report.wide_band_snr,
+              (nr_srs_bf_report.wide_band_snr >> 1) - 64);
         LOG_I(NR_PHY, "nr_srs_bf_report.num_reported_symbols = %i\n", nr_srs_bf_report.num_reported_symbols);
-            LOG_I(NR_PHY, "nr_srs_bf_report.reported_symbol_list[0].num_prgs = %i\n", nr_srs_bf_report.reported_symbol_list[0].num_prgs);
+        LOG_I(NR_PHY,
+              "nr_srs_bf_report.reported_symbol_list[0].num_prgs = %i\n",
+              nr_srs_bf_report.reported_symbol_list[0].num_prgs);
         for (int prg_idx = 0; prg_idx < nr_srs_bf_report.reported_symbol_list[0].num_prgs; prg_idx++) {
           LOG_I(NR_PHY,
                 "nr_srs_beamforming_report.reported_symbol_list[0].prg_list[%3i].rb_snr = %i (%i dB)\n",
@@ -1202,25 +1217,24 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
       case NFAPI_NR_SRS_CODEBOOK: {
         start_meas(&gNB->srs_iq_matrix_stats);
         nfapi_nr_srs_normalized_channel_iq_matrix_t nr_srs_channel_iq_matrix;
-            nr_srs_channel_iq_matrix.normalized_iq_representation = srs_pdu->srs_parameters_v4.iq_representation;
-            nr_srs_channel_iq_matrix.num_gnb_antenna_elements = gNB->frame_parms.nb_antennas_rx;
-            nr_srs_channel_iq_matrix.num_ue_srs_ports = srs_pdu->srs_parameters_v4.num_total_ue_antennas;
-            nr_srs_channel_iq_matrix.prg_size = srs_pdu->srs_parameters_v4.prg_size;
-            nr_srs_channel_iq_matrix.num_prgs = srs_pdu->srs_parameters_v4.srs_bandwidth_size / srs_pdu->srs_parameters_v4.prg_size;
-            fill_srs_channel_matrix(nr_srs_channel_iq_matrix.channel_matrix,
+        fill_srs_channel_matrix(&nr_srs_channel_iq_matrix,
                                 srs_pdu,
                                 gNB->nr_srs_info[i],
-                                    nr_srs_channel_iq_matrix.normalized_iq_representation,
-                                    nr_srs_channel_iq_matrix.num_gnb_antenna_elements,
-                                    nr_srs_channel_iq_matrix.num_ue_srs_ports,
-                                    nr_srs_channel_iq_matrix.prg_size,
-                                    nr_srs_channel_iq_matrix.num_prgs,
-                                    &gNB->frame_parms,
+                                srs_pdu->srs_parameters_v4.iq_representation,
+                                ant,
+                                srs_pdu->srs_parameters_v4.num_total_ue_antennas,
+                                srs_pdu->srs_parameters_v4.prg_size,
+                                srs_pdu->srs_parameters_v4.srs_bandwidth_size / srs_pdu->srs_parameters_v4.prg_size,
+                                frame_parms,
                                 srs_estimated_channel_freq);
 
 #ifdef SRS_IND_DEBUG
-            LOG_I(NR_PHY, "nr_srs_channel_iq_matrix.normalized_iq_representation = %i\n", nr_srs_channel_iq_matrix.normalized_iq_representation);
-            LOG_I(NR_PHY, "nr_srs_channel_iq_matrix.num_gnb_antenna_elements = %i\n", nr_srs_channel_iq_matrix.num_gnb_antenna_elements);
+        LOG_I(NR_PHY,
+              "nr_srs_channel_iq_matrix.normalized_iq_representation = %i\n",
+              nr_srs_channel_iq_matrix.normalized_iq_representation);
+        LOG_I(NR_PHY,
+              "nr_srs_channel_iq_matrix.num_gnb_antenna_elements = %i\n",
+              nr_srs_channel_iq_matrix.num_gnb_antenna_elements);
         LOG_I(NR_PHY, "nr_srs_channel_iq_matrix.num_ue_srs_ports = %i\n", nr_srs_channel_iq_matrix.num_ue_srs_ports);
         LOG_I(NR_PHY, "nr_srs_channel_iq_matrix.prg_size = %i\n", nr_srs_channel_iq_matrix.prg_size);
         LOG_I(NR_PHY, "nr_srs_channel_iq_matrix.num_prgs = %i\n", nr_srs_channel_iq_matrix.num_prgs);
@@ -1229,21 +1243,24 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
         for (int uI = 0; uI < nr_srs_channel_iq_matrix.num_ue_srs_ports; uI++) {
           for (int gI = 0; gI < nr_srs_channel_iq_matrix.num_gnb_antenna_elements; gI++) {
             for (int pI = 0; pI < nr_srs_channel_iq_matrix.num_prgs; pI++) {
-                  uint16_t index =
-                      uI * nr_srs_channel_iq_matrix.num_gnb_antenna_elements * nr_srs_channel_iq_matrix.num_prgs + gI * nr_srs_channel_iq_matrix.num_prgs + pI;
-                  LOG_I(NR_PHY,
+              uint16_t index = uI * nr_srs_channel_iq_matrix.num_gnb_antenna_elements * nr_srs_channel_iq_matrix.num_prgs
+                               + gI * nr_srs_channel_iq_matrix.num_prgs + pI;
+              LOG_I(
+                  NR_PHY,
                   "(uI %i, gI %i, pI %i) channel_matrix --> real %i, imag %i\n",
                   uI,
                   gI,
                   pI,
                   nr_srs_channel_iq_matrix.normalized_iq_representation == 0 ? channel_matrix8[index].r : channel_matrix16[index].r,
-                        nr_srs_channel_iq_matrix.normalized_iq_representation == 0 ? channel_matrix8[index].i : channel_matrix16[index].i);
+                  nr_srs_channel_iq_matrix.normalized_iq_representation == 0 ? channel_matrix8[index].i
+                                                                             : channel_matrix16[index].i);
             }
           }
         }
 #endif
 
-            report_tlv->length = pack_nr_srs_normalized_channel_iq_matrix(&nr_srs_channel_iq_matrix, report_tlv->value, sizeof(report_tlv->value));
+        report_tlv->length =
+            pack_nr_srs_normalized_channel_iq_matrix(&nr_srs_channel_iq_matrix, report_tlv->value, sizeof(report_tlv->value));
         stop_meas(&gNB->srs_iq_matrix_stats);
         break;
       }
@@ -1269,13 +1286,14 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
     srs->active = false;
     stop_meas(&gNB->rx_srs_stats);
   }
-    }
-  }
 
   stop_meas(&gNB->phy_proc_rx);
 
   if (pucch_decode_done || pusch_decode_done) {
-    T(T_GNB_PHY_PUCCH_PUSCH_IQ, T_INT(frame_rx), T_INT(slot_rx), T_BUFFER(&gNB->common_vars.rxdataF[0][0][0], gNB->frame_parms.symbols_per_slot * gNB->frame_parms.ofdm_symbol_size * 4));
+    T(T_GNB_PHY_PUCCH_PUSCH_IQ,
+      T_INT(frame_rx),
+      T_INT(slot_rx),
+      T_BUFFER(&gNB->common_vars.rxdataF[0][0][0], nb_symb * symb_sz * 4));
   }
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_gNB_UESPEC_RX,0);