PDSCH refactoring

PBCH refactoring

PTRS refactoring

CSI refactoring

Main functional changes to bring in symbol based processing

Initial sync changes to use nr_symbol_fep() and rxdataF for symbol

Function arguments changes made in header files
and changes to global structures

PRS and other measurement changes

Physim updates

Code cleanup

Changed DURATION_RX_TO_TX to 2. Works fine with k1,k2=2.

Fix wrong SSB symbol detect

PBCH decoding error message

Decoded SSB of init sync till SIB1 rx

Fix DMRS scrambling ID bug (Fixes SIB1 reception)

common/utils/nr/nr_common.c

@@ -308,8 +308,8 @@ int cce_to_reg_interleaving(const int R, int k, int n_shift, const int C, int L,
   return f;
 }
 
-void get_coreset_rballoc(uint8_t *FreqDomainResource,int *n_rb,int *rb_offset) {
-
+void get_coreset_rballoc(const uint8_t *FreqDomainResource, int *n_rb, int *rb_offset)
+{
   uint8_t count=0, start=0, start_set=0;
 
   uint64_t bitmap = (((uint64_t)FreqDomainResource[0])<<37)|

common/utils/nr/nr_common.h

@@ -180,7 +180,7 @@ uint32_t to_nrarfcn(int nr_bandP, uint64_t dl_CarrierFreq, uint8_t scs_index, ui
 int get_first_ul_slot(int nrofDownlinkSlots, int nrofDownlinkSymbols, int nrofUplinkSymbols);
 int cce_to_reg_interleaving(const int R, int k, int n_shift, const int C, int L, const int N_regs);
 int get_SLIV(uint8_t S, uint8_t L);
-void get_coreset_rballoc(uint8_t *FreqDomainResource,int *n_rb,int *rb_offset);
+void get_coreset_rballoc(const uint8_t *FreqDomainResource, int *n_rb, int *rb_offset);
 int get_nr_table_idx(int nr_bandP, uint8_t scs_index);
 int32_t get_delta_duplex(int nr_bandP, uint8_t scs_index);
 frame_type_t get_frame_type(uint16_t nr_bandP, uint8_t scs_index);
@@ -218,6 +218,7 @@ void freq2time(uint16_t ofdm_symbol_size,
 
 void nr_est_delay(int ofdm_symbol_size, const c16_t *ls_est, c16_t *ch_estimates_time, delay_t *delay);
 
+#define SYMBOL_HAS_LONGER_CP(a, b) (!(a % (0x7 << b)))
 #define CEILIDIV(a,b) ((a+b-1)/b)
 #define ROUNDIDIV(a,b) (((a<<1)+b)/(b<<1))
 

executables/nr-gnb.c

@@ -259,7 +259,8 @@ void rx_func(void *param)
                              gNB->frame_parms.N_RB_UL,
                              soffset,
                              0,
-                             gNB->frame_parms.Ncp == EXTENDED ? 12 : 14);
+                             gNB->frame_parms.Ncp == EXTENDED ? 12 : 14,
+                             false);
       }
     }
     phy_procedures_gNB_uespec_RX(gNB, frame_rx, slot_rx);

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

@@ -68,7 +68,7 @@ typedef struct {
 typedef struct {
   /// frequency_domain_resource;
   uint8_t frequency_domain_resource[6];
-  uint8_t StartSymbolIndex;
+  uint16_t StartSymbolBitmap;
   uint8_t duration;
   uint8_t CceRegMappingType; //  interleaved or noninterleaved
   uint8_t RegBundleSize;     //  valid if CCE to REG mapping type is interleaved type

openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c

@@ -618,10 +618,10 @@ void init_polar_deinterleaver_table(t_nrPolar_params *polarParams) {
 
 uint32_t polar_decoder_int16(int16_t *input,
                              uint64_t *out,
-                             uint8_t ones_flag,
-                             int8_t messageType,
-                             uint16_t messageLength,
-                             uint8_t aggregation_level )
+                             const uint8_t ones_flag,
+                             const int8_t messageType,
+                             const uint16_t messageLength,
+                             const uint8_t aggregation_level)
 {
   t_nrPolar_params *polarParams=nr_polar_params(messageType, messageLength, aggregation_level, true);
 

openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h

@@ -168,10 +168,10 @@ int8_t polar_decoder(double *input,
 
 uint32_t polar_decoder_int16(int16_t *input,
                              uint64_t *out,
-                             uint8_t ones_flag,
-                             int8_t messageType,
-                             uint16_t messageLength,
-                             uint8_t aggregation_level);
+                             const uint8_t ones_flag,
+                             const int8_t messageType,
+                             const uint16_t messageLength,
+                             const uint8_t aggregation_level);
 
 int8_t polar_decoder_dci(double *input,
                          uint32_t *out,
@@ -228,12 +228,7 @@ void nr_polar_rate_matching_pattern(uint16_t *rmp,
                                     uint16_t N,
                                     uint16_t E);
 
-void nr_polar_rate_matching(double *input,
-                            double *output,
-                            uint16_t *rmp,
-                            uint16_t K,
-                            uint16_t N,
-                            uint16_t E);
+void nr_polar_rate_matching(const double *input, double *output, uint16_t *rmp, uint16_t K, uint16_t N, uint16_t E);
 
 void nr_polar_rate_matching_int16(int16_t *input,
                                   int16_t *output,

openair1/PHY/CODING/nrPolar_tools/nr_polar_procedures.c

@@ -396,13 +396,7 @@ void nr_polar_rate_matching_pattern(uint16_t *rmp,
   }
 }
 
-
-void nr_polar_rate_matching(double *input,
-			    double *output,
-			    uint16_t *rmp,
-			    uint16_t K,
-			    uint16_t N,
-			    uint16_t E)
+void nr_polar_rate_matching(const double *input, double *output, uint16_t *rmp, uint16_t K, uint16_t N, uint16_t E)
 {
   if (E>=N) { //repetition
     for (int i=0; i<=N-1; i++) output[i]=0;

openair1/PHY/INIT/nr_init_ue.c

@@ -153,6 +153,12 @@ void init_nr_prs_ue_vars(PHY_VARS_NR_UE *ue)
       prs_vars[idx]->prs_resource[k].prs_meas = malloc16_clear(fp->nb_antennas_rx * sizeof(prs_meas_t *));
       AssertFatal((prs_vars[idx]->prs_resource[k].prs_meas!=NULL), "%s: PRS measurements malloc failed for gNB_id %d\n", __FUNCTION__, idx);
 
+      prs_vars[idx]->prs_resource[k].ch_est = malloc16_clear(sizeof(c16_t) * ue->frame_parms.ofdm_symbol_size);
+      AssertFatal((prs_vars[idx]->prs_resource[k].ch_est != NULL),
+                  "%s: PRS channel estimates malloc failed for gNB_id %d\n",
+                  __FUNCTION__,
+                  idx);
+
       for (int j=0; j<fp->nb_antennas_rx; j++) {
         prs_vars[idx]->prs_resource[k].prs_meas[j] = malloc16_clear(sizeof(prs_meas_t));
         AssertFatal((prs_vars[idx]->prs_resource[k].prs_meas[j]!=NULL), "%s: PRS measurements malloc failed for gNB_id %d, rx_ant %d\n", __FUNCTION__, idx, j);
@@ -195,12 +201,10 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB)
   // create shortcuts
   NR_DL_FRAME_PARMS *const fp            = &ue->frame_parms;
   NR_UE_COMMON *const common_vars        = &ue->common_vars;
-  NR_UE_PRACH **const prach_vars         = ue->prach_vars;
-  NR_UE_CSI_IM **const csiim_vars        = ue->csiim_vars;
-  NR_UE_CSI_RS **const csirs_vars        = ue->csirs_vars;
+  NR_UE_PRACH **const prach_vars = ue->prach_vars;
   NR_UE_SRS **const srs_vars             = ue->srs_vars;
 
-  int i, slot, symb, gNB_id;
+  int slot, symb, gNB_id;
 
   LOG_I(PHY, "Initializing UE vars for gNB TXant %u, UE RXant %u\n", fp->nb_antennas_tx, fp->nb_antennas_rx);
 
@@ -210,10 +214,10 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB)
   AssertFatal( nb_connected_gNB <= NUMBER_OF_CONNECTED_gNB_MAX, "n_connected_gNB is too large" );
   // init phy_vars_ue
 
-  for (i=0; i<fp->Lmax; i++)
+  for (int i = 0; i < fp->Lmax; i++)
     ue->measurements.ssb_rsrp_dBm[i] = INT_MIN;
 
-  for (i=0; i<4; i++) {
+  for (int i = 0; i < 4; i++) {
     ue->rx_gain_max[i] = 135;
     ue->rx_gain_med[i] = 128;
     ue->rx_gain_byp[i] = 120;
@@ -283,20 +287,20 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB)
   ///////////
   ////////////////////////////////////////////////////////////////////////////////////////////
 
-  for (i=0; i<10; i++)
+  for (int i = 0; i < 10; i++)
     ue->tx_power_dBm[i]=-127;
 
   // init TX buffers
   common_vars->txData = malloc16(fp->nb_antennas_tx * sizeof(c16_t *));
 
-  for (i=0; i<fp->nb_antennas_tx; i++) {
+  for (int i = 0; i < fp->nb_antennas_tx; i++) {
     common_vars->txData[i] = malloc16_clear((fp->samples_per_frame) * sizeof(c16_t));
   }
 
   // init RX buffers
   common_vars->rxdata = malloc16(fp->nb_antennas_rx * sizeof(c16_t *));
 
-  for (i=0; i<fp->nb_antennas_rx; i++) {
+  for (int i = 0; i < fp->nb_antennas_rx; i++) {
     common_vars->rxdata[i] = malloc16_clear((2 * (fp->samples_per_frame) + fp->ofdm_symbol_size) * sizeof(c16_t));
   }
 
@@ -342,12 +346,8 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB)
   // DLSCH
   for (gNB_id = 0; gNB_id < ue->n_connected_gNB; gNB_id++) {
     prach_vars[gNB_id] = malloc16_clear(sizeof(NR_UE_PRACH));
-    csiim_vars[gNB_id] = malloc16_clear(sizeof(NR_UE_CSI_IM));
-    csirs_vars[gNB_id] = malloc16_clear(sizeof(NR_UE_CSI_RS));
     srs_vars[gNB_id] = malloc16_clear(sizeof(NR_UE_SRS));
 
-    csiim_vars[gNB_id]->active = false;
-    csirs_vars[gNB_id]->active = false;
     srs_vars[gNB_id]->active = false;
 
     // ceil((NB_RB*8(max allocation per RB)*2(QPSK))/32)
@@ -363,9 +363,10 @@ int init_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB)
         AssertFatal(ue->nr_csi_info->nr_gold_csi_rs[slot][symb] != NULL, "NR init: csi reference signal for slot %d symbol %d - malloc failed\n", slot, symb);
       }
     }
-    ue->nr_csi_info->csi_rs_generated_signal = malloc16(NR_MAX_NB_PORTS * sizeof(int32_t *));
-    for (i=0; i<NR_MAX_NB_PORTS; i++) {
-      ue->nr_csi_info->csi_rs_generated_signal[i] = malloc16_clear(fp->samples_per_frame_wCP * sizeof(int32_t));
+    ue->nr_csi_info->csi_rs_generated_signal = malloc16(NR_MAX_NB_PORTS * sizeof(*ue->nr_csi_info->csi_rs_generated_signal));
+    for (int i = 0; i < NR_MAX_NB_PORTS; i++) {
+      ue->nr_csi_info->csi_rs_generated_signal[i] =
+          malloc16_clear(fp->samples_per_frame_wCP * sizeof(**ue->nr_csi_info->csi_rs_generated_signal));
     }
 
     ue->nr_srs_info = malloc16_clear(sizeof(nr_srs_info_t));
@@ -451,8 +452,6 @@ void term_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB)
 
     free_and_zero(ue->nr_srs_info);
 
-    free_and_zero(ue->csiim_vars[gNB_id]);
-    free_and_zero(ue->csirs_vars[gNB_id]);
     free_and_zero(ue->srs_vars[gNB_id]);
 
     free_and_zero(ue->prach_vars[gNB_id]);
@@ -485,6 +484,7 @@ void term_nr_ue_signal(PHY_VARS_NR_UE *ue, int nb_connected_gNB)
         free_and_zero(ue->prs_vars[idx]->prs_resource[k].prs_meas[j]);
       }
       free_and_zero(ue->prs_vars[idx]->prs_resource[k].prs_meas);
+      free_and_zero(ue->prs_vars[idx]->prs_resource[k].ch_est);
     }
 
     free_and_zero(ue->prs_vars[idx]);

openair1/PHY/INIT/nr_parms.c

@@ -65,9 +65,8 @@ void set_Lmax(NR_DL_FRAME_PARMS *fp) {
   }
 }
 
-
-int nr_get_ssb_start_symbol(NR_DL_FRAME_PARMS *fp,uint8_t i_ssb) {
-
+int nr_get_ssb_start_symbol(const NR_DL_FRAME_PARMS *fp, const uint8_t i_ssb)
+{
   int mu = fp->numerology_index;
   int symbol = 0;
   uint8_t n, n_temp;
@@ -187,15 +186,15 @@ uint32_t get_samples_per_slot(int slot, const NR_DL_FRAME_PARMS *fp)
 
 uint32_t get_slot_from_timestamp(openair0_timestamp timestamp_rx, const NR_DL_FRAME_PARMS *fp)
 {
-   uint32_t slot_idx = 0;
-   int samples_till_the_slot = fp->get_samples_per_slot(slot_idx,fp)-1;
-   timestamp_rx = timestamp_rx%fp->samples_per_frame;
-
-    while (timestamp_rx > samples_till_the_slot) {
-        slot_idx++;
-        samples_till_the_slot += fp->get_samples_per_slot(slot_idx,fp);
-     }
-   return slot_idx; 
+  uint32_t slot_idx = 0;
+  int samples_till_the_slot = fp->get_samples_per_slot(slot_idx, fp) - 1;
+  timestamp_rx = timestamp_rx % fp->samples_per_frame;
+
+  while (timestamp_rx > samples_till_the_slot) {
+    slot_idx++;
+    samples_till_the_slot += fp->get_samples_per_slot(slot_idx, fp);
+  }
+  return slot_idx;
 }
 
 uint32_t get_samples_slot_timestamp(int slot, const NR_DL_FRAME_PARMS *fp, uint8_t sl_ahead)

openair1/PHY/INIT/nr_phy_init.h

@@ -25,7 +25,7 @@
 #include "PHY/defs_gNB.h"
 #include "PHY/defs_nr_UE.h"
 
-int nr_get_ssb_start_symbol(NR_DL_FRAME_PARMS *fp,uint8_t i_ssb);
+int nr_get_ssb_start_symbol(const NR_DL_FRAME_PARMS *fp, const uint8_t i_ssb);
 void nr_init_frame_parms(nfapi_nr_config_request_scf_t *config, NR_DL_FRAME_PARMS *frame_parms);
 int nr_init_frame_parms_ue(NR_DL_FRAME_PARMS *frame_parms, fapi_nr_config_request_t *config, uint16_t nr_band);
 void nr_init_frame_parms_ue_sa(NR_DL_FRAME_PARMS *frame_parms, uint64_t downlink_frequency, int32_t uplink_frequency_offset, uint8_t mu, uint16_t nr_band);

openair1/PHY/MODULATION/modulation_UE.h

@@ -48,18 +48,13 @@ int slot_fep(PHY_VARS_UE *phy_vars_ue,
              int no_prefix,
 	     int reset_freq_est);
 
-int nr_slot_fep(PHY_VARS_NR_UE *ue,
-                const UE_nr_rxtx_proc_t *proc,
-                unsigned char symbol,
-                c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]);
-
-int nr_slot_fep_init_sync(PHY_VARS_NR_UE *ue,
-                          const UE_nr_rxtx_proc_t *proc,
-                          unsigned char symbol,
-                          int sample_offset,
-                          bool pbch_decoded,
-                          c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP],
-                          int link_type);
+void nr_symbol_fep(
+    const PHY_VARS_NR_UE *ue,
+    const int slot,
+    const unsigned char symbol,
+    const int link_type,
+    const c16_t rxdata[ue->frame_parms.nb_antennas_rx][ue->frame_parms.ofdm_symbol_size + ue->frame_parms.nb_prefix_samples0],
+    c16_t rxdataF[ue->frame_parms.nb_antennas_rx][ue->frame_parms.ofdm_symbol_size]);
 
 int slot_fep_mbsfn(PHY_VARS_UE *phy_vars_ue,
                    unsigned char l,

openair1/PHY/MODULATION/nr_modulation.h

@@ -117,14 +117,15 @@ void init_symbol_rotation(NR_DL_FRAME_PARMS *fp);
 
 void init_timeshift_rotation(NR_DL_FRAME_PARMS *fp);
 
-void apply_nr_rotation_RX(NR_DL_FRAME_PARMS *frame_parms,
-			  c16_t *rxdataF,
-                          c16_t *rot,
-			  int slot,
-                          int nb_rb,
-                          int soffset,
-			  int first_symbol,
-			  int nsymb);
+void apply_nr_rotation_RX(const NR_DL_FRAME_PARMS *frame_parms,
+                          c16_t *rxdataF,
+                          const c16_t *rot,
+                          const int slot,
+                          const int nb_rb,
+                          const int soffset,
+                          const int first_symbol,
+                          const int nsymb,
+                          const bool isUE);
 
 /*! \brief Perform NR precoding. TS 38.211 V15.4.0 subclause 6.3.1.5
   @param[in] datatx_F_precoding, Pointer to n_layers*re data array

openair1/PHY/NR_ESTIMATION/nr_ul_channel_estimation.c

@@ -534,12 +534,7 @@ void nr_pusch_ptrs_processing(PHY_VARS_gNB *gNB,
     }
 
     if(symbol == *startSymbIndex) {
-      *ptrsSymbPos = 0;
-      set_ptrs_symb_idx(ptrsSymbPos,
-                        *nbSymb,
-                        *startSymbIndex,
-                        1<< *L_ptrs,
-                        *dmrsSymbPos);
+      *ptrsSymbPos = get_ptrs_symb_idx(*nbSymb, *startSymbIndex, 1 << *L_ptrs, *dmrsSymbPos);
     }
 
     /* if not PTRS symbol set current ptrs symbol index to zero*/
@@ -558,8 +553,8 @@ void nr_pusch_ptrs_processing(PHY_VARS_gNB *gNB,
                              nr_tti_rx,
                              symbol,
                              frame_parms->ofdm_symbol_size,
-                             (int16_t *)&pusch_vars->rxdataF_comp[aarx][(symbol * nb_re_pusch)],
                              gNB->nr_gold_pusch_dmrs[rel15_ul->scid][nr_tti_rx][symbol],
+                             (int16_t *)&pusch_vars->rxdataF_comp[aarx][(symbol * nb_re_pusch)],
                              (int16_t *)&phase_per_symbol[symbol],
                              ptrs_re_symbol);
     }

openair1/PHY/NR_REFSIG/dmrs_nr.c

@@ -317,6 +317,15 @@ uint8_t get_dmrs_symbols_in_slot(uint16_t l_prime_mask,  uint16_t nb_symb)
   return tmp;
 }
 
+int get_last_dmrs_symbol_in_slot(const int dmrs_symbol_pos)
+{
+  for (int i = NR_SYMBOLS_PER_SLOT - 1; i > 0; i--) {
+    if ((dmrs_symbol_pos >> i) & 0x1)
+      return i;
+  }
+  return -1;
+}
+
 /* return the position of valid dmrs symbol in a slot for channel compensation */
 int8_t get_valid_dmrs_idx_for_channel_est(uint16_t  dmrs_symb_pos, uint8_t counter)
 {
@@ -339,79 +348,130 @@ int8_t get_valid_dmrs_idx_for_channel_est(uint16_t  dmrs_symb_pos, uint8_t count
   return symbIdx;
 }
 
+/* return number of data symbols before the last DMRS symbol */
+int get_num_data_symb_before_last_dmrs(const int dmrs_symb_pos)
+{
+  int sum = 0;
+  const int last_dmrs_symbol_idx = get_last_dmrs_symbol_in_slot(dmrs_symb_pos);
+  DevAssert(last_dmrs_symbol_idx != -1);
+  for (int i = 0; i < last_dmrs_symbol_idx; i++) {
+    sum += !((dmrs_symb_pos >> i) & 0x1);
+  }
+  return sum;
+}
+
+int get_first_symb_idx_with_data(const int dmrsBitMap,
+                                 const int dmrsType,
+                                 const int numDmrsCmdGrp,
+                                 const int startSymbol,
+                                 const int numSymbs)
+{
+  int dmrs_data_re;
+  int firstDataSymb = startSymbol;
+
+  if (dmrsType == NFAPI_NR_DMRS_TYPE1)
+    dmrs_data_re = NR_NB_SC_PER_RB - 6 * numDmrsCmdGrp;
+  else
+    dmrs_data_re = NR_NB_SC_PER_RB - 4 * numDmrsCmdGrp;
+
+  while ((dmrs_data_re == 0) && (dmrsBitMap & (1 << firstDataSymb))) {
+    firstDataSymb++;
+  }
+
+  return firstDataSymb;
+}
+
 /* perform averaging of channel estimates and store result in first symbol buffer */
-void nr_chest_time_domain_avg(NR_DL_FRAME_PARMS *frame_parms,
-                              int32_t **ch_estimates,
-                              uint8_t num_symbols,
-                              uint8_t start_symbol,
-                              uint16_t dmrs_bitmap,
-                              uint16_t num_rbs)
+void nr_chest_time_domain_avg(const NR_DL_FRAME_PARMS *frame_parms,
+                              const int num_symbols,
+                              const int start_symbol,
+                              const int dmrs_bitmap,
+                              const int num_rbs,
+                              const int antIdx,
+                              const int layerIdx,
+                              const int Nl,
+                              const bool isUE,
+                              c16_t *ch_estimates)
 {
   simde__m128i *ul_ch128_0;
   simde__m128i *ul_ch128_1;
   int16_t *ul_ch16_0;
-  int total_symbols = start_symbol + num_symbols;
-  int num_dmrs_symb = get_dmrs_symbols_in_slot(dmrs_bitmap, total_symbols);
-  int first_dmrs_symb = get_next_dmrs_symbol_in_slot(dmrs_bitmap, start_symbol, total_symbols);
+
+  const int total_symbols = start_symbol + num_symbols;
+  const int num_dmrs_symb = get_dmrs_symbols_in_slot(dmrs_bitmap, total_symbols);
+  const int first_dmrs_symb = get_next_dmrs_symbol_in_slot(dmrs_bitmap, start_symbol, total_symbols);
+
   AssertFatal(first_dmrs_symb > -1, "No DMRS symbol present in this slot\n");
-  for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) {
-    for (int symb = first_dmrs_symb+1; symb < total_symbols; symb++) {
-      ul_ch128_0 = (simde__m128i *)&ch_estimates[aarx][first_dmrs_symb*frame_parms->ofdm_symbol_size];
-      if ((dmrs_bitmap >> symb) & 0x01) {
-        ul_ch128_1 = (simde__m128i *)&ch_estimates[aarx][symb*frame_parms->ofdm_symbol_size];
-        for (int rbIdx = 0; rbIdx < num_rbs; rbIdx++) {
-          ul_ch128_0[0] = simde_mm_adds_epi16(ul_ch128_0[0], ul_ch128_1[0]);
-          ul_ch128_0[1] = simde_mm_adds_epi16(ul_ch128_0[1], ul_ch128_1[1]);
-          ul_ch128_0[2] = simde_mm_adds_epi16(ul_ch128_0[2], ul_ch128_1[2]);
-          ul_ch128_0 += 3;
-          ul_ch128_1 += 3;
-        }
-      }
-    }
-    ul_ch128_0 = (simde__m128i *)&ch_estimates[aarx][first_dmrs_symb*frame_parms->ofdm_symbol_size];
-    if (num_dmrs_symb == 2) {
-      for (int rbIdx = 0; rbIdx < num_rbs; rbIdx++) {
-        ul_ch128_0[0] = simde_mm_srai_epi16(ul_ch128_0[0], 1);
-        ul_ch128_0[1] = simde_mm_srai_epi16(ul_ch128_0[1], 1);
-        ul_ch128_0[2] = simde_mm_srai_epi16(ul_ch128_0[2], 1);
-        ul_ch128_0 += 3;
-      }
-    } else if (num_dmrs_symb == 4) {
+
+  const int symb_offset = Nl * frame_parms->nb_antennas_rx * frame_parms->ofdm_symbol_size;
+  const int layer_offset = frame_parms->nb_antennas_rx * frame_parms->ofdm_symbol_size;
+  for (int symb = first_dmrs_symb + 1; symb < total_symbols; symb++) {
+    ul_ch128_0 = isUE ? (simde__m128i *)&ch_estimates[first_dmrs_symb * symb_offset + layerIdx * layer_offset
+                                                      + antIdx * frame_parms->ofdm_symbol_size]
+                      : (simde__m128i *)&ch_estimates[first_dmrs_symb * frame_parms->ofdm_symbol_size];
+    if ((dmrs_bitmap >> symb) & 0x01) {
+      ul_ch128_1 =
+          isUE
+              ? (simde__m128i *)&ch_estimates[symb * symb_offset + layerIdx * layer_offset + antIdx * frame_parms->ofdm_symbol_size]
+              : (simde__m128i *)&ch_estimates[symb * frame_parms->ofdm_symbol_size];
       for (int rbIdx = 0; rbIdx < num_rbs; rbIdx++) {
-        ul_ch128_0[0] = simde_mm_srai_epi16(ul_ch128_0[0], 2);
-        ul_ch128_0[1] = simde_mm_srai_epi16(ul_ch128_0[1], 2);
-        ul_ch128_0[2] = simde_mm_srai_epi16(ul_ch128_0[2], 2);
+        ul_ch128_0[0] = simde_mm_adds_epi16(ul_ch128_0[0], ul_ch128_1[0]);
+        ul_ch128_0[1] = simde_mm_adds_epi16(ul_ch128_0[1], ul_ch128_1[1]);
+        ul_ch128_0[2] = simde_mm_adds_epi16(ul_ch128_0[2], ul_ch128_1[2]);
         ul_ch128_0 += 3;
+        ul_ch128_1 += 3;
       }
-    } else if (num_dmrs_symb == 3) {
-      ul_ch16_0 = (int16_t *)&ch_estimates[aarx][first_dmrs_symb*frame_parms->ofdm_symbol_size];
-      for (int rbIdx = 0; rbIdx < num_rbs; rbIdx++) {
-        ul_ch16_0[0] /= 3;
-        ul_ch16_0[1] /= 3;
-        ul_ch16_0[2] /= 3;
-        ul_ch16_0[3] /= 3;
-        ul_ch16_0[4] /= 3;
-        ul_ch16_0[5] /= 3;
-        ul_ch16_0[6] /= 3;
-        ul_ch16_0[7] /= 3;
-        ul_ch16_0[8] /= 3;
-        ul_ch16_0[9] /= 3;
-        ul_ch16_0[10] /= 3;
-        ul_ch16_0[11] /= 3;
-        ul_ch16_0[12] /= 3;
-        ul_ch16_0[13] /= 3;
-        ul_ch16_0[14] /= 3;
-        ul_ch16_0[15] /= 3;
-        ul_ch16_0[16] /= 3;
-        ul_ch16_0[17] /= 3;
-        ul_ch16_0[18] /= 3;
-        ul_ch16_0[19] /= 3;
-        ul_ch16_0[20] /= 3;
-        ul_ch16_0[21] /= 3;
-        ul_ch16_0[22] /= 3;
-        ul_ch16_0[23] /= 3;
-        ul_ch16_0 += 24;
-      }
-    } else AssertFatal((num_dmrs_symb < 5) && (num_dmrs_symb > 0), "Illegal number of DMRS symbols in the slot\n");
+    }
   }
+
+  ul_ch128_0 = isUE ? (simde__m128i *)&ch_estimates[first_dmrs_symb * symb_offset + layerIdx * layer_offset
+                                                    + antIdx * frame_parms->ofdm_symbol_size]
+                    : (simde__m128i *)&ch_estimates[first_dmrs_symb * frame_parms->ofdm_symbol_size];
+  if (num_dmrs_symb == 2) {
+    for (int rbIdx = 0; rbIdx < num_rbs; rbIdx++) {
+      ul_ch128_0[0] = simde_mm_srai_epi16(ul_ch128_0[0], 1);
+      ul_ch128_0[1] = simde_mm_srai_epi16(ul_ch128_0[1], 1);
+      ul_ch128_0[2] = simde_mm_srai_epi16(ul_ch128_0[2], 1);
+      ul_ch128_0 += 3;
+    }
+  } else if (num_dmrs_symb == 4) {
+    for (int rbIdx = 0; rbIdx < num_rbs; rbIdx++) {
+      ul_ch128_0[0] = simde_mm_srai_epi16(ul_ch128_0[0], 2);
+      ul_ch128_0[1] = simde_mm_srai_epi16(ul_ch128_0[1], 2);
+      ul_ch128_0[2] = simde_mm_srai_epi16(ul_ch128_0[2], 2);
+      ul_ch128_0 += 3;
+    }
+  } else if (num_dmrs_symb == 3) {
+    ul_ch16_0 = isUE ? (int16_t *)&ch_estimates[first_dmrs_symb * symb_offset + layerIdx * layer_offset
+                                                + antIdx * frame_parms->ofdm_symbol_size]
+                     : (int16_t *)&ch_estimates[first_dmrs_symb * frame_parms->ofdm_symbol_size];
+    for (int rbIdx = 0; rbIdx < num_rbs; rbIdx++) {
+      ul_ch16_0[0] /= 3;
+      ul_ch16_0[1] /= 3;
+      ul_ch16_0[2] /= 3;
+      ul_ch16_0[3] /= 3;
+      ul_ch16_0[4] /= 3;
+      ul_ch16_0[5] /= 3;
+      ul_ch16_0[6] /= 3;
+      ul_ch16_0[7] /= 3;
+      ul_ch16_0[8] /= 3;
+      ul_ch16_0[9] /= 3;
+      ul_ch16_0[10] /= 3;
+      ul_ch16_0[11] /= 3;
+      ul_ch16_0[12] /= 3;
+      ul_ch16_0[13] /= 3;
+      ul_ch16_0[14] /= 3;
+      ul_ch16_0[15] /= 3;
+      ul_ch16_0[16] /= 3;
+      ul_ch16_0[17] /= 3;
+      ul_ch16_0[18] /= 3;
+      ul_ch16_0[19] /= 3;
+      ul_ch16_0[20] /= 3;
+      ul_ch16_0[21] /= 3;
+      ul_ch16_0[22] /= 3;
+      ul_ch16_0[23] /= 3;
+      ul_ch16_0 += 24;
+    }
+  } else
+    AssertFatal((num_dmrs_symb < 5) && (num_dmrs_symb > 0), "Illegal number of DMRS symbols in the slot\n");
 }

openair1/PHY/NR_REFSIG/dmrs_nr.h

@@ -61,22 +61,32 @@ uint8_t allowed_xlsch_re_in_dmrs_symbol(uint16_t k,
                                         uint8_t numDmrsCdmGrpsNoData,
                                         uint8_t dmrs_type);
 
-void nr_gen_ref_conj_symbols(uint32_t *in, uint32_t length, int16_t *output, uint16_t offset, int mod_order);
+void nr_gen_ref_conj_symbols(const uint32_t *in, uint32_t length, int16_t *output, uint16_t offset, int mod_order);
 int8_t get_next_dmrs_symbol_in_slot(uint16_t  ul_dmrs_symb_pos, uint8_t counter, uint8_t end_symbol);
 uint8_t get_dmrs_symbols_in_slot(uint16_t l_prime_mask,  uint16_t nb_symb);
 int8_t get_valid_dmrs_idx_for_channel_est(uint16_t  dmrs_symb_pos, uint8_t counter);
-void nr_chest_time_domain_avg(NR_DL_FRAME_PARMS *frame_parms,
-                              int32_t **ch_estimates,
-                              uint8_t num_symbols,
-                              uint8_t start_symbol,
-                              uint16_t dmrs_bitmap,
-                              uint16_t num_rbs);
-
-static inline uint8_t is_dmrs_symbol(uint8_t l, uint16_t dmrsSymbMask)
+void nr_chest_time_domain_avg(const NR_DL_FRAME_PARMS *frame_parms,
+                              const int num_symbols,
+                              const int start_symbol,
+                              const int dmrs_bitmap,
+                              const int num_rbs,
+                              const int antIdx,
+                              const int layerIdx,
+                              const int Nl,
+                              const bool isUE,
+                              c16_t *ch_estimates);
+int get_first_symb_idx_with_data(const int dmrsBitMap,
+                                 const int dmrsType,
+                                 const int numDmrsCmdGrp,
+                                 const int startSymbol,
+                                 const int numSymbs);
+static inline uint8_t is_dmrs_symbol(const uint8_t l, const uint16_t dmrsSymbMask)
 {
   DevAssert(l < 32);
   return ((dmrsSymbMask >> l) & 0x1);
 }
+int get_last_dmrs_symbol_in_slot(const int dmrs_symbol_pos);
+int get_num_data_symb_before_last_dmrs(const int dmrs_symb_pos);
 #undef EXTERN
 
 #endif /* DMRS_NR_H */

openair1/PHY/NR_REFSIG/nr_dmrs_rx.c

@@ -120,14 +120,14 @@ int nr_pusch_dmrs_rx(PHY_VARS_gNB *gNB,
   return(0);
 }
 
-int nr_pdsch_dmrs_rx(PHY_VARS_NR_UE *ue,
-                     unsigned int Ns,
-                     unsigned int *nr_gold_pdsch,
-                     c16_t *output,
-                     unsigned short p,
-                     unsigned char lp,
-                     unsigned short nb_pdsch_rb,
-                     uint8_t config_type)
+int nr_pdsch_dmrs_rx(const PHY_VARS_NR_UE *ue,
+                     const unsigned int Ns,
+                     const unsigned int *nr_gold_pdsch,
+                     const unsigned short p,
+                     const unsigned char lp,
+                     const unsigned short nb_pdsch_rb,
+                     const uint8_t config_type,
+                     c16_t *output)
 {
   int8_t w;
   unsigned char idx=0;
@@ -170,12 +170,7 @@ int nr_pdsch_dmrs_rx(PHY_VARS_NR_UE *ue,
   return(0);
 }
 
-int nr_pdcch_dmrs_rx(PHY_VARS_NR_UE *ue,
-                     unsigned int Ns,
-                     unsigned int *nr_gold_pdcch,
-                     c16_t *output,
-                     unsigned short p,
-                     unsigned short nb_rb_coreset)
+int nr_pdcch_dmrs_rx(const unsigned int *nr_gold_pdcch, c16_t *output, const unsigned short p, const unsigned short nb_rb_coreset)
 {
   uint8_t idx=0;
   //uint8_t pdcch_rb_offset =0;
@@ -204,8 +199,7 @@ int nr_pdcch_dmrs_rx(PHY_VARS_NR_UE *ue,
 
 void nr_pbch_dmrs_rx(const int symbol, const unsigned int *nr_gold_pbch, c16_t *output)
 {
-  int m,m0,m1;
-  uint8_t idx=0;
+  int m, m0, m1;
   AssertFatal(symbol>=0 && symbol <3,"illegal symbol %d\n",symbol);
   if (symbol == 0) {
     m0=0;
@@ -222,9 +216,10 @@ void nr_pbch_dmrs_rx(const int symbol, const unsigned int *nr_gold_pbch, c16_t *
   //    printf("Generating pilots symbol %d, m0 %d, m1 %d\n",symbol,m0,m1);
   /// QPSK modulation
   for (m=m0; m<m1; m++) {
-    idx = ((((nr_gold_pbch[(m<<1)>>5])>>((m<<1)&0x1f))&1)<<1) ^ (((nr_gold_pbch[((m<<1)+1)>>5])>>(((m<<1)+1)&0x1f))&1);
+    const int idx = ((((nr_gold_pbch[(m << 1) >> 5]) >> ((m << 1) & 0x1f)) & 1) << 1)
+                    ^ (((nr_gold_pbch[((m << 1) + 1) >> 5]) >> (((m << 1) + 1) & 0x1f)) & 1);
     output[m - m0] = nr_rx_mod_table[NR_MOD_TABLE_QPSK_OFFSET + idx];
-
+    
 #ifdef DEBUG_PBCH
     if (m<16)
       {printf("nr_gold_pbch[(m<<1)>>5] %x\n",nr_gold_pbch[(m<<1)>>5]);
@@ -240,7 +235,7 @@ void nr_pbch_dmrs_rx(const int symbol, const unsigned int *nr_gold_pbch, c16_t *
   \param length is number of RE in a OFDM symbol
   \param *output pointer to all ptrs RE in a OFDM symbol
 */
-void nr_gen_ref_conj_symbols(uint32_t *in, uint32_t length, c16_t *output, uint16_t offset, int mod_order)
+void nr_gen_ref_conj_symbols(const uint32_t *in, uint32_t length, c16_t *output, uint16_t offset, int mod_order)
 {
   uint8_t idx, b_idx;
   for (int i=0; i<length/mod_order; i++)

openair1/PHY/NR_REFSIG/nr_gold_ue.c

@@ -72,11 +72,10 @@ void nr_gold_pdcch(PHY_VARS_NR_UE* ue,
   }
 }
 
-void nr_gold_pdsch(PHY_VARS_NR_UE* ue,
-                   int nscid,
-                   uint32_t nid)
+void nr_gold_pdsch(const int nscid, const unsigned int nid, PHY_VARS_NR_UE* ue)
 {
-  int pdsch_dmrs_init_length = ((ue->frame_parms.N_RB_DL * 12) >> 5) + 1;
+  const int pdsch_dmrs_init_length = ((ue->frame_parms.N_RB_DL * 12) >> 5) + 1;
+
   for (int ns=0; ns<ue->frame_parms.slots_per_frame; ns++) {
     for (int l=0; l<ue->frame_parms.symbols_per_slot; l++) {
       uint8_t reset = 1;

openair1/PHY/NR_REFSIG/ptrs_nr.c

@@ -37,34 +37,29 @@
 #include "PHY/NR_REFSIG/nr_refsig.h"
 
 /*******************************************************************
-*
-* NAME :         set_ptrs_symb_idx
-*
-* PARAMETERS :   ptrs_symbols           PTRS OFDM symbol indicies bit mask
-*                duration_in_symbols    number of scheduled ofdm symbols
-*                start_symbol           first ofdm symbol within slot
-*                L_ptrs                 the parameter L_ptrs
-*                dmrs_symb_pos          bitmap of the time domain positions of the DMRS symbols
-*
-* RETURN :       sets the bit map of PTRS ofdm symbol indicies
-*
-* DESCRIPTION :  3GPP TS 38.211 6.4.1.2.2.1
-*
-*********************************************************************/
+ *
+ * NAME :         get_ptrs_symb_idx
+ *
+ * PARAMETERS :   duration_in_symbols    number of scheduled PUSCH ofdm symbols
+ *                start_symbol           first ofdm symbol of PUSCH within slot
+ *                L_ptrs                 the parameter L_ptrs
+ *                ul_dmrs_symb_pos       bitmap of the time domain positions of the DMRS symbols in the scheduled PUSCH
+ *
+ * RETURN :       PTRS OFDM symbol indicies bit mask
+ *
+ * DESCRIPTION :  3GPP TS 38.211 6.4.1.2.2.1
+ *
+ *********************************************************************/
 
-void set_ptrs_symb_idx(uint16_t *ptrs_symbols,
-                       uint8_t duration_in_symbols,
-                       uint8_t start_symbol,
-                       uint8_t L_ptrs,
-                       uint16_t dmrs_symb_pos)
+int get_ptrs_symb_idx(const int duration_in_symbols, const int start_symbol, const int L_ptrs, const int dmrs_symb_pos)
 {
+  const int last_symbol = start_symbol + duration_in_symbols - 1;
   int i = 0;
   int l_ref = start_symbol;
-  const int last_symbol = start_symbol + duration_in_symbols - 1;
+  int ptrs_symbols = 0;
   if (L_ptrs == 0) {
     LOG_E(PHY,"bug: impossible L_ptrs\n");
-    *ptrs_symbols = 0;
-    return;
+    return 0;
   }
 
   while ((l_ref + i * L_ptrs) <= last_symbol) {
@@ -80,9 +75,11 @@ void set_ptrs_symb_idx(uint16_t *ptrs_symbols,
       i = 1;
       continue;
     }
-    *ptrs_symbols = *ptrs_symbols | (1 << (l_ref + i * L_ptrs));
+
+    ptrs_symbols = ptrs_symbols | (1 << (l_ref + i * L_ptrs));
     i++;
   }
+  return ptrs_symbols;
 }
 
 /*******************************************************************
@@ -183,15 +180,15 @@ int8_t get_next_estimate_in_slot(uint16_t  ptrsSymbPos,uint16_t  dmrsSymbPos, ui
  *  perform phase estimation from regenerated PTRS SC and channel compensated
  *  signal
  *********************************************************************/
-void nr_ptrs_cpe_estimation(uint8_t K_ptrs,
-                            uint8_t ptrsReOffset,
-                            uint16_t nb_rb,
-                            uint16_t rnti,
-                            unsigned char Ns,
-                            unsigned char symbol,
-                            uint16_t ofdm_symbol_size,
+void nr_ptrs_cpe_estimation(const uint8_t K_ptrs,
+                            const uint8_t ptrsReOffset,
+                            const uint16_t nb_rb,
+                            const uint16_t rnti,
+                            const unsigned char Ns,
+                            const unsigned char symbol,
+                            const uint16_t ofdm_symbol_size,
+                            const uint32_t *gold_seq,
                             int16_t *rxF_comp,
-                            uint32_t *gold_seq,
                             int16_t *error_est,
                             int32_t *ptrs_sc)
 {
@@ -245,7 +242,7 @@ void nr_ptrs_cpe_estimation(uint8_t K_ptrs,
     imag += ptrs_ch_p[i].i;
   }
 #ifdef DEBUG_PTRS
-  double alpha = atan(imag/real);
+  double alpha = atan(imag / real);
   printf("[PHY][PTRS]: Symbol  %d atan(Im,real):= %f \n",symbol, alpha );
 #endif
   /* mean */
@@ -262,7 +259,6 @@ void nr_ptrs_cpe_estimation(uint8_t K_ptrs,
 #endif
 }
 
-
 /*******************************************************************
  *
  * NAME :     nr_ptrs_process_slot

openair1/PHY/NR_REFSIG/ptrs_nr.h

@@ -47,11 +47,7 @@
 
 /************** FUNCTION ******************************************/
 
-void set_ptrs_symb_idx(uint16_t *ptrs_symbols,
-                       uint8_t duration_in_symbols,
-                       uint8_t start_symbol,
-                       uint8_t L_ptrs,
-                       uint16_t dmrs_symb_pos);
+int get_ptrs_symb_idx(const int duration_in_symbols, const int start_symbol, const int L_ptrs, const int dmrs_symb_pos);
 
 uint8_t is_ptrs_subcarrier(uint16_t k,
                            uint16_t n_rnti,
@@ -74,7 +70,10 @@ uint8_t is_ptrs_subcarrier(uint16_t k,
 *
 *********************************************************************/
 
-static inline uint8_t is_ptrs_symbol(uint8_t l, uint16_t ptrs_symbols) { return ((ptrs_symbols >> l) & 1); }
+static inline uint8_t is_ptrs_symbol(const uint8_t l, const uint16_t ptrs_symbols)
+{
+  return ((ptrs_symbols >> l) & 1);
+}
 
 uint8_t get_ptrs_symbols_in_slot(uint16_t l_prime_mask, uint16_t start_symb, uint16_t nb_symb);
 int8_t get_next_ptrs_symbol_in_slot(uint16_t  ptrsSymbPos, uint8_t counter, uint8_t nb_symb);
@@ -87,15 +86,15 @@ int8_t nr_ptrs_process_slot(uint16_t dmrsSymbPos,
                             uint16_t noSymb
                             );
 /*  general function to estimate common phase error based upon PTRS */
-void nr_ptrs_cpe_estimation(uint8_t K_ptrs,
-                            uint8_t ptrsReOffset,
-                            uint16_t nb_rb,
-                            uint16_t rnti,
-                            unsigned char Ns,
-                            unsigned char symbol,
-                            uint16_t ofdm_symbol_size,
+void nr_ptrs_cpe_estimation(const uint8_t K_ptrs,
+                            const uint8_t ptrsReOffset,
+                            const uint16_t nb_rb,
+                            const uint16_t rnti,
+                            const unsigned char Ns,
+                            const unsigned char symbol,
+                            const uint16_t ofdm_symbol_size,
+                            const uint32_t *gold_seq,
                             int16_t *rxF_comp,
-                            uint32_t *gold_seq,
                             int16_t *error_est,
                             int32_t *ptrs_sc);
 

openair1/PHY/NR_REFSIG/refsig_defs_ue.h

@@ -35,30 +35,26 @@ void nr_pbch_dmrs_rx(const int dmrss, const unsigned int *nr_gold_pbch, c16_t *o
 /*!\brief This function generates the NR Gold sequence (38-211, Sec 5.2.1) for the PDCCH DMRS.
 @param PHY_VARS_NR_UE* ue structure provides configuration, frame parameters and the pointers to the 32 bits sequence storage tables
  */
-int nr_pdcch_dmrs_rx(PHY_VARS_NR_UE *ue,
-                     unsigned int Ns,
-                     unsigned int *nr_gold_pdcch,
+int nr_pdcch_dmrs_rx(const unsigned int *nr_gold_pdcch,
                      c16_t *output,
-                     unsigned short p,
-                     unsigned short nb_rb_corset);
+                     const unsigned short p,
+                     const unsigned short nb_rb_coreset);
 
-int nr_pdsch_dmrs_rx(PHY_VARS_NR_UE *ue,
-                     unsigned int Ns,
-                     unsigned int *nr_gold_pdsch,
-                     c16_t *output,
-                     unsigned short p,
-                     unsigned char lp,
-                     unsigned short nb_pdsch_rb,
-                     uint8_t config_type);
+int nr_pdsch_dmrs_rx(const PHY_VARS_NR_UE *ue,
+                     const unsigned int Ns,
+                     const unsigned int *nr_gold_pdsch,
+                     const unsigned short p,
+                     const unsigned char lp,
+                     const unsigned short nb_pdsch_rb,
+                     const uint8_t config_type,
+                     c16_t *output);
 
 void nr_gold_pbch(PHY_VARS_NR_UE* ue);
 
 void nr_gold_pdcch(PHY_VARS_NR_UE* ue,
                    unsigned short n_idDMRS);
 
-void nr_gold_pdsch(PHY_VARS_NR_UE* ue,
-                   int nscid,
-                   uint32_t nid);
+void nr_gold_pdsch(const int nscid, const unsigned int nid, PHY_VARS_NR_UE *ue);
 
 void nr_init_pusch_dmrs(PHY_VARS_NR_UE* ue,
                         uint16_t N_n_scid,

openair1/PHY/NR_REFSIG/sss_nr.h

@@ -80,6 +80,6 @@ bool rx_sss_nr(PHY_VARS_NR_UE *ue,
                int32_t *tot_metric,
                uint8_t *phase_max,
                int *freq_offset_sss,
-               c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]);
+               c16_t rxdataF[NR_N_SYMBOLS_SSB][ue->frame_parms.nb_antennas_rx][ue->frame_parms.ofdm_symbol_size]);
 #endif /* SSS_NR_H */
 

openair1/PHY/NR_TRANSPORT/nr_csi_rs.c

@@ -44,20 +44,13 @@ void nr_init_csi_rs(const NR_DL_FRAME_PARMS *fp, uint32_t ***csi_rs, uint32_t Ni
 }
 
 void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
-                        int32_t **dataF,
                         const int16_t amp,
-                        nr_csi_info_t *nr_csi_info,
-                        const nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *csi_params,
                         const int slot,
-                        uint8_t *N_cdm_groups,
-                        uint8_t *CDM_group_size,
-                        uint8_t *k_prime,
-                        uint8_t *l_prime,
-                        uint8_t *N_ports,
-                        uint8_t *j_cdm,
-                        uint8_t *k_overline,
-                        uint8_t *l_overline) {
-
+                        const nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *csi_params,
+                        c16_t **dataF,
+                        nr_csi_info_t *nr_csi_info,
+                        nr_csi_phy_parms_t *csi_phy_parms)
+{
 #ifdef NR_CSIRS_DEBUG
   LOG_I(NR_PHY, "csi_params->subcarrier_spacing = %i\n", csi_params->subcarrier_spacing);
   LOG_I(NR_PHY, "csi_params->cyclic_prefix = %i\n", csi_params->cyclic_prefix);
@@ -628,12 +621,12 @@ void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
 
             // ZP CSI RS
             if (csi_params->csi_type == 2) {
-              ((int16_t*)dataF[p])[((l*frame_parms->ofdm_symbol_size + k)<<1)+(2*dataF_offset)] = 0;
-              ((int16_t*)dataF[p])[((l*frame_parms->ofdm_symbol_size + k)<<1)+1+(2*dataF_offset)] = 0;
+              dataF[p][l * frame_parms->ofdm_symbol_size + k + dataF_offset] = (c16_t){0};
             }
             else {
-              ((int16_t*)dataF[p])[((l*frame_parms->ofdm_symbol_size + k)<<1)+(2*dataF_offset)] = (beta*wt*wf*mod_csi[l][mprime<<1]) >> 15;
-              ((int16_t*)dataF[p])[((l*frame_parms->ofdm_symbol_size + k)<<1)+1+(2*dataF_offset)] = (beta*wt*wf*mod_csi[l][(mprime<<1) + 1]) >> 15;
+              dataF[p][l * frame_parms->ofdm_symbol_size + k + dataF_offset].r = (beta * wt * wf * mod_csi[l][mprime << 1]) >> 15;
+              dataF[p][l * frame_parms->ofdm_symbol_size + k + dataF_offset].i =
+                  (beta * wt * wf * mod_csi[l][(mprime << 1) + 1]) >> 15;
             }
 #ifdef NR_CSIRS_DEBUG
             printf("l,k (%d,%d)  seq. index %d \t port %d \t (%d,%d)\n",l,k,mprime,p+3000,
@@ -646,14 +639,17 @@ void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
     }
    }
   }
-  if (N_cdm_groups) *N_cdm_groups = size;
-  if (CDM_group_size) *CDM_group_size = gs;
-  if (k_prime) *k_prime = kprime;
-  if (l_prime) *l_prime = lprime;
-  if (N_ports) *N_ports = ports;
-  if (j_cdm) memcpy(j_cdm,j,16*sizeof(uint8_t));
-  if (k_overline) memcpy(k_overline,koverline,16*sizeof(uint8_t));
-  if (l_overline) memcpy(l_overline,loverline,16*sizeof(uint8_t));
+
+  if (csi_phy_parms) {
+    csi_phy_parms->N_cdm_groups = size;
+    csi_phy_parms->CDM_group_size = gs;
+    csi_phy_parms->k_prime = kprime;
+    csi_phy_parms->l_prime = lprime;
+    csi_phy_parms->N_ports = ports;
+    memcpy(csi_phy_parms->j_cdm, j, sizeof(csi_phy_parms->j_cdm));
+    memcpy(csi_phy_parms->k_overline, koverline, sizeof(csi_phy_parms->k_overline));
+    memcpy(csi_phy_parms->l_overline, loverline, sizeof(csi_phy_parms->l_overline));
+  }
 
 #ifdef NR_CSIRS_DEBUG
   if (N_ports) LOG_I(NR_PHY, "nr_csi_info->N_ports = %d\n", *N_ports);

openair1/PHY/NR_TRANSPORT/nr_dlsch.c

@@ -100,11 +100,10 @@ void nr_generate_pdsch(processingData_L1tx_t *msgTx, int frame, int slot)
     int n_ptrs = 0;
     uint32_t ptrsSymbPerSlot = 0;
     if(rel15->pduBitmap & 0x1) {
-      set_ptrs_symb_idx(&dlPtrsSymPos,
-                        rel15->NrOfSymbols,
-                        rel15->StartSymbolIndex,
-                        1 << rel15->PTRSTimeDensity,
-                        rel15->dlDmrsSymbPos);
+      dlPtrsSymPos = get_ptrs_symb_idx(rel15->NrOfSymbols,
+                                       rel15->StartSymbolIndex,
+                                       1 << rel15->PTRSTimeDensity,
+                                       rel15->dlDmrsSymbPos);
       n_ptrs = (rel15->rbSize + rel15->PTRSFreqDensity - 1) / rel15->PTRSFreqDensity;
       ptrsSymbPerSlot = get_ptrs_symbols_in_slot(dlPtrsSymPos, rel15->StartSymbolIndex, rel15->NrOfSymbols);
     }

openair1/PHY/NR_TRANSPORT/nr_transport_proto.h

@@ -311,19 +311,12 @@ void free_nr_ru_prach_entry(RU_t *ru, int prach_id);
 uint8_t get_nr_prach_duration(uint8_t prach_format);
 
 void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
-                        int32_t **dataF,
                         const int16_t amp,
-                        nr_csi_info_t *nr_csi_info,
-                        const nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *csi_params,
                         const int slot,
-                        uint8_t *N_cdm_groups,
-                        uint8_t *CDM_group_size,
-                        uint8_t *k_prime,
-                        uint8_t *l_prime,
-                        uint8_t *N_ports,
-                        uint8_t *j_cdm,
-                        uint8_t *k_overline,
-                        uint8_t *l_overline);
+                        const nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *csi_params,
+                        c16_t **dataF,
+                        nr_csi_info_t *nr_csi_info,
+                        nr_csi_phy_parms_t *csi_phy_parms);
 
 void free_nr_prach_entry(PHY_VARS_gNB *gNB, int prach_id);
 

openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c

@@ -1519,18 +1519,22 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB,
 
   nvar /= (rel15_ul->nr_of_symbols * rel15_ul->nrOfLayers * frame_parms->nb_antennas_rx);
 
-  // averaging time domain channel estimates
-  if (gNB->chest_time == 1) 
-  {
-    nr_chest_time_domain_avg(frame_parms,
-                             pusch_vars->ul_ch_estimates,
-                             rel15_ul->nr_of_symbols,
-                             rel15_ul->start_symbol_index,
-                             rel15_ul->ul_dmrs_symb_pos,
-                             rel15_ul->rb_size);
-    pusch_vars->dmrs_symbol = get_next_dmrs_symbol_in_slot(rel15_ul->ul_dmrs_symb_pos, 
-                                                           rel15_ul->start_symbol_index, 
-                                                           rel15_ul->nr_of_symbols);
+  if (gNB->chest_time == 1) { // averaging time domain channel estimates
+    for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) {
+      nr_chest_time_domain_avg(frame_parms,
+                               rel15_ul->nr_of_symbols,
+                               rel15_ul->start_symbol_index,
+                               rel15_ul->ul_dmrs_symb_pos,
+                               rel15_ul->rb_size,
+                               0,
+                               0,
+                               0,
+                               false,
+                               (c16_t *)pusch_vars->ul_ch_estimates[aarx]);
+    }
+
+    pusch_vars->dmrs_symbol =
+        get_next_dmrs_symbol_in_slot(rel15_ul->ul_dmrs_symb_pos, rel15_ul->start_symbol_index, rel15_ul->nr_of_symbols);
   }
 
   stop_meas(&gNB->ulsch_channel_estimation_stats);
@@ -1549,12 +1553,10 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB,
 
   uint32_t unav_res = 0;
   if (rel15_ul->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) {
-    uint16_t ptrsSymbPos = 0;
-    set_ptrs_symb_idx(&ptrsSymbPos,
-                      rel15_ul->nr_of_symbols,
-                      rel15_ul->start_symbol_index,
-                      1 << rel15_ul->pusch_ptrs.ptrs_time_density,
-                      rel15_ul->ul_dmrs_symb_pos);
+    uint16_t ptrsSymbPos = get_ptrs_symb_idx(rel15_ul->nr_of_symbols,
+                                             rel15_ul->start_symbol_index,
+                                             1 << rel15_ul->pusch_ptrs.ptrs_time_density,
+                                             rel15_ul->ul_dmrs_symb_pos);
     int ptrsSymbPerSlot = get_ptrs_symbols_in_slot(ptrsSymbPos, rel15_ul->start_symbol_index, rel15_ul->nr_of_symbols);
     int n_ptrs = (rel15_ul->rb_size + rel15_ul->pusch_ptrs.ptrs_freq_density - 1) / rel15_ul->pusch_ptrs.ptrs_freq_density;
     unav_res = n_ptrs * ptrsSymbPerSlot;

openair1/PHY/NR_UE_ESTIMATION/nr_adjust_synch_ue.c

@@ -33,17 +33,15 @@
 // The adjustment is performed once per frame based on the
 // last channel estimate of the receiver
 
-int nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
-                       PHY_VARS_NR_UE *ue,
-                       module_id_t gNB_id,
-                       const int estimateSz,
-                       struct complex16 dl_ch_estimates_time[][estimateSz],
-                       uint8_t frame,
-                       uint8_t slot,
-                       short coef)
+int nr_adjust_synch_ue(PHY_VARS_NR_UE *ue,
+                       const c16_t dl_ch_estimates_time[][ue->frame_parms.ofdm_symbol_size],
+                       const uint8_t frame,
+                       const uint8_t slot,
+                       const short coef)
 {
   int max_val = 0, max_pos = 0;
   uint8_t sync_offset = 0;
+  const NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_ADJUST_SYNCH, VCD_FUNCTION_IN);
 

openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h

@@ -33,13 +33,24 @@
 #define NR_SYNCH_HYST 1
 
 /* A function to perform the channel estimation of DL PRS signal */
-int nr_prs_channel_estimation(uint8_t gNB_id,
-                              uint8_t rsc_id,
-                              uint8_t rep_num,
-                              PHY_VARS_NR_UE *ue,
+int nr_prs_channel_estimation(const uint8_t gNB_id,
+                              const uint8_t rsc_id,
+                              const uint8_t rep_num,
+                              const int l,
+                              const PHY_VARS_NR_UE *ue,
                               const UE_nr_rxtx_proc_t *proc,
-                              NR_DL_FRAME_PARMS *frame_params,
-                              c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]);
+                              const prs_config_t *prs_cfg,
+                              const c16_t rxdataF[ue->frame_parms.nb_antennas_rx][ue->frame_parms.ofdm_symbol_size],
+                              prs_meas_t **prs_meas,
+                              c16_t ch_est_out[ue->frame_parms.ofdm_symbol_size]);
+
+void nr_prs_doa_estimation(const uint8_t gNB_id,
+                           const uint8_t rsc_id,
+                           const PHY_VARS_NR_UE *ue,
+                           const UE_nr_rxtx_proc_t *proc,
+                           const prs_config_t *prs_cfg,
+                           c16_t ch_est_in[ue->frame_parms.ofdm_symbol_size],
+                           prs_meas_t **prs_meas);
 
 /* Generic function to find the peak of channel estimation buffer */
 void peak_estimator(int32_t *buffer, int32_t buf_len, int32_t *peak_idx, int32_t *peak_val, int32_t mean_val);
@@ -62,44 +73,34 @@ c32_t nr_pbch_dmrs_correlation(const PHY_VARS_NR_UE *ue,
                                const int symbol,
                                const int dmrss,
                                const uint32_t nr_gold_pbch[NR_PBCH_DMRS_LENGTH_DWORD],
-                               const c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]);
+                               const c16_t rxdataF[ue->frame_parms.nb_antennas_rx][ue->frame_parms.ofdm_symbol_size]);
 
-int nr_pbch_channel_estimation(PHY_VARS_NR_UE *ue,
-                               int estimateSz,
-                               struct complex16 dl_ch_estimates[][estimateSz],
-                               struct complex16 dl_ch_estimates_time[][ue->frame_parms.ofdm_symbol_size],
-                               const UE_nr_rxtx_proc_t *proc,
-                               unsigned char symbol,
-                               int dmrss,
-                               uint8_t ssb_index,
-                               uint8_t n_hf,
-                               c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]);
+int nr_pbch_channel_estimation(const PHY_VARS_NR_UE *ue,
+                               const int dmrss,
+                               const int ssb_index,
+                               const int n_hf,
+                               const c16_t rxdataF[ue->frame_parms.ofdm_symbol_size],
+                               c16_t dl_ch_estimates[ue->frame_parms.ofdm_symbol_size]);
 
-int nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
+int nr_pdsch_channel_estimation(const PHY_VARS_NR_UE *ue,
                                 const UE_nr_rxtx_proc_t *proc,
-                                int nl,
-                                unsigned short p,
-                                unsigned char symbol,
-                                unsigned char nscid,
-                                unsigned short scrambling_id,
-                                unsigned short BWPStart,
-                                uint8_t config_type,
-                                uint16_t rb_offset,
-                                unsigned short bwp_start_subcarrier,
-                                unsigned short nb_rb_pdsch,
-                                uint32_t pdsch_est_size,
-                                int32_t dl_ch_estimates[][pdsch_est_size],
-                                int rxdataFsize,
-                                c16_t rxdataF[][rxdataFsize]);
-
-int nr_adjust_synch_ue(NR_DL_FRAME_PARMS *frame_parms,
-                       PHY_VARS_NR_UE *ue,
-                       module_id_t gNB_id,
-                       int estimateSz,
-                       struct complex16 dl_ch_estimates_time[][estimateSz],
-                       uint8_t frame,
-                       uint8_t subframe,
-                       short coef);
+                                const int rb_offset,
+                                const unsigned int p,
+                                const unsigned int aarx,
+                                const unsigned char symbol,
+                                const unsigned short BWPStart,
+                                const uint8_t config_type,
+                                const unsigned short bwp_start_subcarrier,
+                                const unsigned short nb_rb_pdsch,
+                                const int nscid,
+                                const c16_t rxdataF[ue->frame_parms.ofdm_symbol_size],
+                                c16_t dl_ch_estimates[ue->frame_parms.ofdm_symbol_size]);
+
+int nr_adjust_synch_ue(PHY_VARS_NR_UE *ue,
+                       const c16_t dl_ch_estimates_time[][ue->frame_parms.ofdm_symbol_size],
+                       const uint8_t frame,
+                       const uint8_t slot,
+                       const short coef);
 
 void nr_ue_measurements(PHY_VARS_NR_UE *ue,
                         const UE_nr_rxtx_proc_t *proc,
@@ -108,33 +109,35 @@ void nr_ue_measurements(PHY_VARS_NR_UE *ue,
                         int32_t dl_ch_estimates[][pdsch_est_size]);
 
 void nr_ue_ssb_rsrp_measurements(PHY_VARS_NR_UE *ue,
-                                 uint8_t gNB_index,
+                                 const int ssb_index,
                                  const UE_nr_rxtx_proc_t *proc,
-                                 c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]);
+                                 const c16_t rxdataF[ue->frame_parms.nb_antennas_rx][ue->frame_parms.ofdm_symbol_size]);
 
 void nr_ue_rrc_measurements(PHY_VARS_NR_UE *ue,
                             const UE_nr_rxtx_proc_t *proc,
-                            c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]);
+                            const c16_t rxdataF[ue->frame_parms.nb_antennas_rx][ue->frame_parms.ofdm_symbol_size]);
 
 void phy_adjust_gain_nr(PHY_VARS_NR_UE *ue,
                         uint32_t rx_power_fil_dB,
                         uint8_t gNB_id);
 
-void nr_pdsch_ptrs_processing(PHY_VARS_NR_UE *ue,
-                              int nbRx,
-                              c16_t ptrs_phase_per_slot[][14],
-                              int32_t ptrs_re_per_slot[][14],
-                              uint32_t rx_size_symbol,
-                              int32_t rxdataF_comp[][nbRx][rx_size_symbol * NR_SYMBOLS_PER_SLOT],
-                              NR_DL_FRAME_PARMS *frame_parms,
-                              NR_DL_UE_HARQ_t *dlsch0_harq,
-                              NR_DL_UE_HARQ_t *dlsch1_harq,
-                              uint8_t gNB_id,
-                              uint8_t nr_slot_rx,
-                              unsigned char symbol,
-                              uint32_t nb_re_pdsch,
-                              uint16_t rnti,
-                              NR_UE_DLSCH_t dlsch[2]);
+int nr_pdsch_ptrs_tdinterpol(const NR_UE_DLSCH_t *dlsch, c16_t phase_per_symbol[NR_SYMBOLS_PER_SLOT]);
+
+void nr_pdsch_ptrs_compensate(const c16_t phase_per_symbol,
+                              const int symbol,
+                              const NR_UE_DLSCH_t *dlsch,
+                              c16_t rxdataF_comp[dlsch->dlsch_config.number_rbs * NR_NB_SC_PER_RB]);
+
+void nr_pdsch_ptrs_processing_core(const PHY_VARS_NR_UE *ue,
+                                   const int gNB_id,
+                                   const int nr_slot_rx,
+                                   const int symbol,
+                                   const int nb_re_pdsch,
+                                   const int rnti,
+                                   const NR_UE_DLSCH_t *dlsch,
+                                   c16_t rxdataF_comp[dlsch->dlsch_config.number_rbs * NR_NB_SC_PER_RB],
+                                   c16_t *phase_per_symbol,
+                                   int32_t *ptrs_re_symbol);
 
 float_t get_nr_RSRP(module_id_t Mod_id,uint8_t CC_id,uint8_t gNB_index);
 /** @}*/

openair1/PHY/NR_UE_ESTIMATION/nr_ue_measurements.c

@@ -179,29 +179,22 @@ void nr_ue_measurements(PHY_VARS_NR_UE *ue,
 // - RSRP:    W (dBW)
 // - RX Gain  dB
 void nr_ue_ssb_rsrp_measurements(PHY_VARS_NR_UE *ue,
-                                 int ssb_index,
+                                 const int ssb_index,
                                  const UE_nr_rxtx_proc_t *proc,
-                                 c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP])
+                                 const c16_t rxdataF[ue->frame_parms.nb_antennas_rx][ue->frame_parms.ofdm_symbol_size])
 {
-  int k_start = 56;
-  int k_end   = 183;
-  int slot = proc->nr_slot_rx;
-  unsigned int ssb_offset = ue->frame_parms.first_carrier_offset + ue->frame_parms.ssb_start_subcarrier;
-  int symbol_offset = nr_get_ssb_start_symbol(&ue->frame_parms,ssb_index);
-
-  if (ue->frame_parms.half_frame_bit)
-    symbol_offset += (ue->frame_parms.slots_per_frame>>1)*ue->frame_parms.symbols_per_slot;
-
-  uint8_t l_sss = (symbol_offset + 2) % ue->frame_parms.symbols_per_slot;
+  const int k_start = 56;
+  const int k_end = 183;
+  const int slot = proc->nr_slot_rx;
+  const unsigned int ssb_offset = ue->frame_parms.first_carrier_offset + ue->frame_parms.ssb_start_subcarrier;
 
   uint32_t rsrp = 0;
 
-  LOG_D(PHY, "In %s: [UE %d] slot %d l_sss %d ssb_offset %d\n", __FUNCTION__, ue->Mod_id, slot, l_sss, ssb_offset);
+  LOG_D(PHY, "In %s: [UE %d] slot %d \n", __FUNCTION__, ue->Mod_id, slot);
   int nb_re = 0;
 
   for (int aarx = 0; aarx < ue->frame_parms.nb_antennas_rx; aarx++) {
-
-    int16_t *rxF_sss = (int16_t *)&rxdataF[aarx][l_sss*ue->frame_parms.ofdm_symbol_size];
+    int16_t *rxF_sss = (int16_t *)rxdataF[aarx];
 
     for(int k = k_start; k < k_end; k++){
 
@@ -236,59 +229,52 @@ void nr_ue_ssb_rsrp_measurements(PHY_VARS_NR_UE *ue,
 // - psd_awgn (AWGN power spectral density):     dBm/Hz
 void nr_ue_rrc_measurements(PHY_VARS_NR_UE *ue,
                             const UE_nr_rxtx_proc_t *proc,
-                            c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP])
+                            const c16_t rxdataF[ue->frame_parms.nb_antennas_rx][ue->frame_parms.ofdm_symbol_size])
 {
-  uint8_t k;
-  int slot = proc->nr_slot_rx;
-  int aarx;
-  int16_t *rxF_sss;
+  const int slot = proc->nr_slot_rx;
+  const int16_t *rxF_sss;
   const uint8_t k_left = 48;
   const uint8_t k_right = 183;
   const uint8_t k_length = 8;
-  uint8_t l_sss = (ue->symbol_offset + 2) % ue->frame_parms.symbols_per_slot;
-  unsigned int ssb_offset = ue->frame_parms.first_carrier_offset + ue->frame_parms.ssb_start_subcarrier;
-  double rx_gain = openair0_cfg[0].rx_gain[0];
-  double rx_gain_offset = openair0_cfg[0].rx_gain_offset[0];
+  const unsigned int ssb_offset = ue->frame_parms.first_carrier_offset + ue->frame_parms.ssb_start_subcarrier;
+  const double rx_gain = openair0_cfg[0].rx_gain[0];
+  const double rx_gain_offset = openair0_cfg[0].rx_gain_offset[0];
 
   ue->measurements.n0_power_tot = 0;
 
-  LOG_D(PHY, "In %s doing measurements for ssb_offset %d l_sss %d \n", __FUNCTION__, ssb_offset, l_sss);
-
-  for (aarx = 0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
+  LOG_D(PHY, "In %s doing measurements for ssb_offset %d \n", __FUNCTION__, ssb_offset);
 
+  for (int aarx = 0; aarx < ue->frame_parms.nb_antennas_rx; aarx++) {
     ue->measurements.n0_power[aarx] = 0;
-    rxF_sss = (int16_t *)&rxdataF[aarx][l_sss*ue->frame_parms.ofdm_symbol_size];
+    rxF_sss = (int16_t *)rxdataF[aarx];
 
     //-ve spectrum from SSS
-    for(k = k_left; k < k_left + k_length; k++){
-
+    for (int k = k_left; k < k_left + k_length; k++) {
       int re = (ssb_offset + k) % ue->frame_parms.ofdm_symbol_size;
 
       #ifdef DEBUG_MEAS_RRC
       LOG_I(PHY, "In %s -rxF_sss %d %d\n", __FUNCTION__, rxF_sss[re*2], rxF_sss[re*2 + 1]);
       #endif
 
-      ue->measurements.n0_power[aarx] += (((int32_t)rxF_sss[re*2]*rxF_sss[re*2]) + ((int32_t)rxF_sss[re*2 + 1]*rxF_sss[re*2 + 1]));
-
+      ue->measurements.n0_power[aarx] +=
+          (((int32_t)rxF_sss[re * 2] * rxF_sss[re * 2]) + ((int32_t)rxF_sss[re * 2 + 1] * rxF_sss[re * 2 + 1]));
     }
 
     //+ve spectrum from SSS
-    for(k = k_right; k < k_right + k_length; k++){
-
+    for (int k = k_right; k < k_right + k_length; k++) {
       int re = (ssb_offset + k) % ue->frame_parms.ofdm_symbol_size;
 
       #ifdef DEBUG_MEAS_RRC
       LOG_I(PHY, "In %s +rxF_sss %d %d\n", __FUNCTION__, rxF_sss[re*2], rxF_sss[re*2 + 1]);
       #endif
 
-      ue->measurements.n0_power[aarx] += (((int32_t)rxF_sss[re*2]*rxF_sss[re*2]) + ((int32_t)rxF_sss[re*2 + 1]*rxF_sss[re*2 + 1]));
-
+      ue->measurements.n0_power[aarx] +=
+          (((int32_t)rxF_sss[re * 2] * rxF_sss[re * 2]) + ((int32_t)rxF_sss[re * 2 + 1] * rxF_sss[re * 2 + 1]));
     }
 
     ue->measurements.n0_power[aarx] /= 2*k_length;
     ue->measurements.n0_power_dB[aarx] = (unsigned short) dB_fixed(ue->measurements.n0_power[aarx]);
     ue->measurements.n0_power_tot += ue->measurements.n0_power[aarx];
-
   }
 
   ue->measurements.n0_power_tot_dB = (unsigned short) dB_fixed(ue->measurements.n0_power_tot);

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c

@@ -56,7 +56,8 @@ extended_kpi_ue* getKPIUE(void) {
   return &kpiStructure;
 }
 
-void nr_ue_dlsch_init(NR_UE_DLSCH_t *dlsch_list, int num_dlsch, uint8_t max_ldpc_iterations) {
+void nr_ue_dlsch_init(NR_UE_DLSCH_t dlsch_list[2], int num_dlsch, uint8_t max_ldpc_iterations)
+{
   for (int i=0; i < num_dlsch; i++) {
     NR_UE_DLSCH_t *dlsch = dlsch_list + i;
     memset(dlsch, 0, sizeof(NR_UE_DLSCH_t));
@@ -159,33 +160,18 @@ static void nr_processDLSegment(void *arg)
   NR_UE_DLSCH_t *dlsch = rdata->dlsch;
   NR_DL_UE_HARQ_t *harq_process= rdata->harq_process;
   t_nrLDPC_dec_params *p_decoderParms = &rdata->decoderParms;
-  int Kr;
-  int K_bits_F;
-  int r = rdata->segment_r;
-  int A = rdata->A;
-  int E = rdata->E;
-  int Qm = rdata->Qm;
-  //int rv_index = rdata->rv_index;
-  int r_offset = rdata->r_offset;
-  uint8_t kc = rdata->Kc;
-  uint32_t Tbslbrm = rdata->Tbslbrm;
-  short* dlsch_llr = rdata->dlsch_llr;
-  int8_t LDPCoutput[OAI_UL_LDPC_MAX_NUM_LLR] __attribute__((aligned(32)));
-  int16_t z[68 * 384 + 16] __attribute__((aligned(16)));
-  int8_t   l [68*384 + 16] __attribute__ ((aligned(16)));
-
-  Kr = harq_process->K;
-  K_bits_F = Kr-harq_process->F;
-
-  t_nrLDPC_time_stats procTime = {0};
-
   //if we return before LDPC decoder run, the block is in error
   rdata->decodeIterations = dlsch->max_ldpc_iterations + 1;
 
+  const int Kr = harq_process->K;
   start_meas(&rdata->ts_deinterleave);
 
   //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_DEINTERLEAVING, VCD_FUNCTION_IN);
+  const int E = rdata->E;
+  const int Qm = rdata->Qm;
+  const int r_offset = rdata->r_offset;
   int16_t w[E];
+  short *dlsch_llr = rdata->dlsch_llr;
   nr_deinterleaving_ldpc(E,
                          Qm,
                          w, // [hna] w is e
@@ -205,6 +191,8 @@ static void nr_processDLSegment(void *arg)
         harq_process->round); */
   //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_RATE_MATCHING, VCD_FUNCTION_IN);
 
+  const int r = rdata->segment_r;
+  const uint32_t Tbslbrm = rdata->Tbslbrm;
   if (nr_rate_matching_ldpc_rx(Tbslbrm,
                                p_decoderParms->BG,
                                p_decoderParms->Z,
@@ -232,6 +220,11 @@ static void nr_processDLSegment(void *arg)
     LOG_D(PHY,"\n");
   }
   {
+    const int kc = rdata->Kc;
+    const int K_bits_F = Kr - harq_process->F;
+    __attribute__((aligned(16))) int16_t z[68 * 384 + 16] = {0};
+    __attribute__((aligned(16))) int8_t l[68 * 384 + 16] = {0};
+
     start_meas(&rdata->ts_ldpc_decode);
     //set first 2*Z_c bits to zeros
     memset(z,0,2*harq_process->Z*sizeof(int16_t));
@@ -250,8 +243,11 @@ static void nr_processDLSegment(void *arg)
     }
 
     //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_LDPC, VCD_FUNCTION_IN);
+    const int A = rdata->A;
     p_decoderParms->E = lenWithCrc(harq_process->C, A);
     p_decoderParms->crc_type = crcType(harq_process->C, A);
+    int8_t LDPCoutput[OAI_UL_LDPC_MAX_NUM_LLR] __attribute__((aligned(32)));
+    t_nrLDPC_time_stats procTime = {0};
     rdata->decodeIterations =
         ldpc_interface.LDPCdecoder(p_decoderParms, 0, 0, 0, l, LDPCoutput, &procTime, &harq_process->abort_decode);
     //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_LDPC, VCD_FUNCTION_OUT);
@@ -274,78 +270,33 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
                            uint8_t nr_slot_rx,
                            uint8_t harq_pid,
                            int b_size,
-                           uint8_t b[b_size])
-{
-  uint32_t ret,offset;
-  uint32_t r,r_offset=0,Kr=8424,Kr_bytes;
-  t_nrLDPC_dec_params decParams;
-  decParams.check_crc = check_crc;
-
-  if (!harq_process) {
-    LOG_E(PHY,"dlsch_decoding.c: NULL harq_process pointer\n");
-    return(dlsch->max_ldpc_iterations + 1);
-  }
+                           uint8_t b[b_size]) {
+  DevAssert(harq_process != NULL);
+  DevAssert(dlsch_llr != NULL);
 
   // HARQ stats
   phy_vars_ue->dl_stats[harq_process->DLround]++;
   LOG_D(PHY, "Round %d RV idx %d\n", harq_process->DLround, dlsch->dlsch_config.rv);
-  uint16_t nb_rb;// = 30;
-  uint8_t dmrs_Type = dlsch->dlsch_config.dmrsConfigType;
+  const int dmrs_Type = dlsch->dlsch_config.dmrsConfigType;
   AssertFatal(dmrs_Type == 0 || dmrs_Type == 1, "Illegal dmrs_type %d\n", dmrs_Type);
-  uint8_t nb_re_dmrs;
-
-  if (dmrs_Type==NFAPI_NR_DMRS_TYPE1) {
-    nb_re_dmrs = 6*dlsch->dlsch_config.n_dmrs_cdm_groups;
-  } else {
-    nb_re_dmrs = 4*dlsch->dlsch_config.n_dmrs_cdm_groups;
-  }
+  const int nb_re_dmrs =
+      (dmrs_Type == NFAPI_NR_DMRS_TYPE1) ? 6 * dlsch->dlsch_config.n_dmrs_cdm_groups : 4 * dlsch->dlsch_config.n_dmrs_cdm_groups;
 
-  uint16_t dmrs_length = get_num_dmrs(dlsch->dlsch_config.dlDmrsSymbPos);
+  const int dmrs_length = get_num_dmrs(dlsch->dlsch_config.dlDmrsSymbPos);
   vcd_signal_dumper_dump_function_by_name(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_SEGMENTATION, VCD_FUNCTION_IN);
 
-  //NR_DL_UE_HARQ_t *harq_process = dlsch->harq_processes[0];
-
-  if (!dlsch_llr) {
-    LOG_E(PHY,"dlsch_decoding.c: NULL dlsch_llr pointer\n");
-    return(dlsch->max_ldpc_iterations + 1);
-  }
-
-  if (!frame_parms) {
-    LOG_E(PHY,"dlsch_decoding.c: NULL frame_parms pointer\n");
-    return(dlsch->max_ldpc_iterations + 1);
-  }
-
-  /*if (nr_slot_rx> (frame_parms->slots_per_frame-1)) {
-    printf("dlsch_decoding.c: Illegal slot index %d\n",nr_slot_rx);
-    return(dlsch->max_ldpc_iterations + 1);
-  }*/
-  /*if (harq_process->harq_ack.ack != 2) {
-    LOG_D(PHY, "[UE %d] DLSCH @ SF%d : ACK bit is %d instead of DTX even before PDSCH is decoded!\n",
-        phy_vars_ue->Mod_id, nr_slot_rx, harq_process->harq_ack.ack);
-  }*/
-  //  nb_rb = dlsch->nb_rb;
-  /*
-  if (nb_rb > frame_parms->N_RB_DL) {
-    printf("dlsch_decoding.c: Illegal nb_rb %d\n",nb_rb);
-    return(max_ldpc_iterations + 1);
-    }*/
-  /*harq_pid = dlsch->current_harq_pid[proc->thread_id];
-  if (harq_pid >= 8) {
-    printf("dlsch_decoding.c: Illegal harq_pid %d\n",harq_pid);
-    return(max_ldpc_iterations + 1);
-  }
-  */
-  nb_rb = dlsch->dlsch_config.number_rbs;
   uint32_t A = dlsch->dlsch_config.TBS;
-  ret = dlsch->max_ldpc_iterations + 1;
-  dlsch->last_iteration_cnt = ret;
-  uint32_t G = harq_process->G;
+  const int nb_rb = dlsch->dlsch_config.number_rbs;
+  dlsch->last_iteration_cnt = dlsch->max_ldpc_iterations + 1;
+  const int G = harq_process->G;
 
   // target_code_rate is in 0.1 units
-  float Coderate = (float) dlsch->dlsch_config.targetCodeRate / 10240.0f;
+  const float Coderate = (float)dlsch->dlsch_config.targetCodeRate / 10240.0f;
 
   LOG_D(PHY,"%d.%d DLSCH Decoding, harq_pid %d TBS %d (%d) G %d nb_re_dmrs %d length dmrs %d mcs %d Nl %d nb_symb_sch %d nb_rb %d Qm %d Coderate %f\n",
         frame,nr_slot_rx,harq_pid,A,A/8,G, nb_re_dmrs, dmrs_length, dlsch->dlsch_config.mcs, dlsch->Nl, nb_symb_sch, nb_rb, dlsch->dlsch_config.qamModOrder, Coderate);
+  t_nrLDPC_dec_params decParams;
+  decParams.check_crc = check_crc;
   decParams.BG = dlsch->dlsch_config.ldpcBaseGraph;
   unsigned int kc = decParams.BG == 2 ? 52 : 68;
 
@@ -376,7 +327,6 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
   decParams.Z = harq_process->Z;
   decParams.numMaxIter = dlsch->max_ldpc_iterations;
   decParams.outMode = 0;
-  r_offset = 0;
   uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER*dlsch->Nl;  //number of segments to be allocated
 
   if (nb_rb != 273) {
@@ -384,23 +334,21 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     a_segments = a_segments/273 +1;
   }
 
-  if (harq_process->C > a_segments) {
-    LOG_E(PHY,"Illegal harq_process->C %d > %d\n",harq_process->C,a_segments);
-    return((1+dlsch->max_ldpc_iterations));
-  }
+  DevAssert(harq_process->C <= a_segments);
 
   if (LOG_DEBUGFLAG(DEBUG_DLSCH_DECOD))
     LOG_I(PHY,"Segmentation: C %d, K %d\n",harq_process->C,harq_process->K);
 
-  Kr = harq_process->K;
-  Kr_bytes = Kr>>3;
-  offset = 0;
+  const int Kr_bytes = harq_process->K >> 3;
+  int offset = 0;
+  int r_offset = 0;
   notifiedFIFO_t nf;
   initNotifiedFIFO(&nf);
+  start_meas(&phy_vars_ue->dlsch_ldpc_whole);
   set_abort(&harq_process->abort_decode, false);
-  for (r=0; r<harq_process->C; r++) {
+  for (int r = 0; r < harq_process->C; r++) {
     //printf("start rx segment %d\n",r);
-    uint32_t E = nr_get_E(G, harq_process->C, dlsch->dlsch_config.qamModOrder, dlsch->Nl, r);
+    const int E = nr_get_E(G, harq_process->C, dlsch->dlsch_config.qamModOrder, dlsch->Nl, r);
     decParams.R = nr_get_R_ldpc_decoder(dlsch->dlsch_config.rv, E, decParams.BG, decParams.Z, &harq_process->llrLen, harq_process->DLround);
     union ldpcReqUnion id = {.s={dlsch->rnti,frame,nr_slot_rx,0,0}};
     notifiedFIFO_elt_t *req = newNotifiedFIFO_elt(sizeof(ldpcDecode_ue_t), id.p, &nf, &nr_processDLSegment);
@@ -444,8 +392,9 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     delNotifiedFIFO_elt(req);
     nbDecode--;
   }
+  stop_meas(&phy_vars_ue->dlsch_ldpc_whole);
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_DLSCH_COMBINE_SEG, VCD_FUNCTION_OUT);
-  ret = dlsch->last_iteration_cnt;
-  return(ret);
+
+  return dlsch->last_iteration_cnt;
 }

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_llr_computation.c

@@ -48,21 +48,18 @@ int16_t nr_zeros[8] __attribute__((aligned(16))) = {0, 0, 0, 0, 0, 0, 0, 0};
 // QPSK
 //----------------------------------------------------------------------------------------------
 
-int nr_dlsch_qpsk_llr(NR_DL_FRAME_PARMS *frame_parms,
-                   int32_t *rxdataF_comp,
-                   int16_t *dlsch_llr,
-                   uint8_t symbol,
-                   uint32_t len,
-                   uint8_t first_symbol_flag,
-                   uint16_t nb_rb)
+int nr_dlsch_qpsk_llr(const NR_DL_FRAME_PARMS *frame_parms,
+                      const c16_t *rxdataF_comp,
+                      int16_t *dlsch_llr,
+                      const uint32_t len,
+                      const uint16_t nb_rb)
 {
-
-  c16_t *rxF   = (c16_t *)&rxdataF_comp[((int32_t)symbol*nb_rb*12)];
+  c16_t *rxF = (c16_t *)rxdataF_comp;
   c16_t *llr32 = (c16_t *)dlsch_llr;
   int i;
 
   if (!llr32) {
-    LOG_E(PHY,"nr_dlsch_qpsk_llr: llr is null, symbol %d, llr32=%p\n",symbol, llr32);
+    LOG_E(PHY, "nr_dlsch_qpsk_llr: llr is null, llr32=%p\n", llr32);
     return(-1);
   }
 
@@ -89,39 +86,30 @@ int nr_dlsch_qpsk_llr(NR_DL_FRAME_PARMS *frame_parms,
 // 16-QAM
 //----------------------------------------------------------------------------------------------
 
-void nr_dlsch_16qam_llr(NR_DL_FRAME_PARMS *frame_parms,
-                     int32_t *rxdataF_comp,
-                     int16_t *dlsch_llr,
-                     int32_t *dl_ch_mag,
-                     uint8_t symbol,
-                     uint32_t len,
-                     uint8_t first_symbol_flag,
-                     uint16_t nb_rb)
+void nr_dlsch_16qam_llr(const NR_DL_FRAME_PARMS *frame_parms,
+                        const c16_t *rxdataF_comp,
+                        int16_t *dlsch_llr,
+                        const c16_t *dl_ch_mag,
+                        const uint32_t len,
+                        const uint16_t nb_rb)
 {
-
-  simde__m128i *rxF = (simde__m128i*)&rxdataF_comp[(symbol*nb_rb*12)];
-  simde__m128i *ch_mag;
+  simde__m128i *rxF = (simde__m128i *)rxdataF_comp;
   simde__m128i llr128[2];
-  uint32_t *llr32;
-
 
   int i;
   unsigned char len_mod4=0;
 
+  uint32_t *llr32 = (uint32_t *)dlsch_llr;
+  simde__m128i *ch_mag = (simde__m128i *)dl_ch_mag;
 
-    llr32 = (uint32_t*)dlsch_llr;
-    ch_mag = (simde__m128i *)dl_ch_mag;
-
-
- // printf("len=%d\n", len);
+  // printf("len=%d\n", len);
   len_mod4 = len&3;
  // printf("len_mod4=%d\n", len_mod4);
-  len>>=2;  // length in quad words (4 REs)
- // printf("len>>=2=%d\n", len);
-  len+=(len_mod4==0 ? 0 : 1);
- // printf("len+=%d\n", len);
-  for (i=0; i<len; i++) {
-
+  int nlen = len >> 2; // length in quad words (4 REs)
+  // printf("len>>=2=%d\n", len);
+  nlen += (len_mod4 == 0 ? 0 : 1);
+  // printf("len+=%d\n", len);
+  for (i = 0; i < nlen; i++) {
     simde__m128i xmm0 =simde_mm_abs_epi16(rxF[i]);
     xmm0 =simde_mm_subs_epi16(ch_mag[i],xmm0);
 
@@ -136,8 +124,7 @@ void nr_dlsch_16qam_llr(NR_DL_FRAME_PARMS *frame_parms,
     llr32[5] =simde_mm_extract_epi32(llr128[1],1); //((uint32_t *)&llr128[1])[1];
     llr32[6] =simde_mm_extract_epi32(llr128[1],2); //((uint32_t *)&llr128[1])[2];
     llr32[7] =simde_mm_extract_epi32(llr128[1],3); //((uint32_t *)&llr128[1])[3];
-    llr32+=8;
-
+    llr32 += 8;
   }
 
  simde_mm_empty();
@@ -148,35 +135,31 @@ void nr_dlsch_16qam_llr(NR_DL_FRAME_PARMS *frame_parms,
 // 64-QAM
 //----------------------------------------------------------------------------------------------
 
-void nr_dlsch_64qam_llr(NR_DL_FRAME_PARMS *frame_parms,
-			int32_t *rxdataF_comp,
-			int16_t *dlsch_llr,
-			int32_t *dl_ch_mag,
-			int32_t *dl_ch_magb,
-			uint8_t symbol,
-			uint32_t len,
-			uint8_t first_symbol_flag,
-			uint16_t nb_rb)
+void nr_dlsch_64qam_llr(const NR_DL_FRAME_PARMS *frame_parms,
+                        const c16_t *rxdataF_comp,
+                        int16_t *dlsch_llr,
+                        const c16_t *dl_ch_mag,
+                        const c16_t *dl_ch_magb,
+                        const uint32_t len,
+                        const uint16_t nb_rb)
 {
-  simde__m128i *rxF = (simde__m128i*)&rxdataF_comp[(symbol*nb_rb*12)];
-  simde__m128i *ch_mag,*ch_magb;
+  const simde__m128i *rxF = (simde__m128i *)rxdataF_comp;
   int i,len2;
   unsigned char len_mod4;
   int16_t *llr2;
 
   llr2 = dlsch_llr;
 
-  ch_mag = (simde__m128i *)dl_ch_mag;
-  ch_magb = (simde__m128i *)dl_ch_magb;
+  const simde__m128i *ch_mag = (simde__m128i *)dl_ch_mag;
+  const simde__m128i *ch_magb = (simde__m128i *)dl_ch_magb;
 
-//  printf("nr_dlsch_64qam_llr: symbol %d,nb_rb %d, len %d,pbch_pss_sss_adjust %d\n",symbol,nb_rb,len,pbch_pss_sss_adjust);
+  //  printf("nr_dlsch_64qam_llr: symbol %d,nb_rb %d, len %d,pbch_pss_sss_adjust %d\n",symbol,nb_rb,len,pbch_pss_sss_adjust);
 
-/*  LOG_I(PHY,"nr_dlsch_64qam_llr [symb %d / FirstSym %d / Length %d]: @LLR Buff %x \n",
-             symbol,
-             first_symbol_flag,
-             len,
-             dlsch_llr,
-             pllr_symbol);*/
+  /*  LOG_I(PHY,"nr_dlsch_64qam_llr [symb %d / Length %d]: @LLR Buff %x \n",
+               symbol,
+               len,
+               dlsch_llr,
+               pllr_symbol);*/
 
   len_mod4 =len&3;
   len2=len>>2;  // length in quad words (4 REs)
@@ -243,19 +226,16 @@ void nr_dlsch_64qam_llr(NR_DL_FRAME_PARMS *frame_parms,
 // 256-QAM
 //----------------------------------------------------------------------------------------------
 
-void nr_dlsch_256qam_llr(NR_DL_FRAME_PARMS *frame_parms,
-                     int32_t *rxdataF_comp,
-                     int16_t *dlsch_llr,
-                     int32_t *dl_ch_mag,
-                     int32_t *dl_ch_magb,
-                     int32_t *dl_ch_magr,
-                     uint8_t symbol,
-                     uint32_t len,
-                     uint8_t first_symbol_flag,
-                     uint16_t nb_rb)
+void nr_dlsch_256qam_llr(const NR_DL_FRAME_PARMS *frame_parms,
+                         const c16_t *rxdataF_comp,
+                         int16_t *dlsch_llr,
+                         const c16_t *dl_ch_mag,
+                         const c16_t *dl_ch_magb,
+                         const c16_t *dl_ch_magr,
+                         const uint32_t len,
+                         const uint16_t nb_rb)
 {
-  simde__m128i *rxF = (simde__m128i*)&rxdataF_comp[(symbol*nb_rb*12)];
-  simde__m128i *ch_mag,*ch_magb,*ch_magr;
+  const simde__m128i *rxF = (simde__m128i *)rxdataF_comp;
 
   int i,len2;
   unsigned char len_mod4;
@@ -263,9 +243,9 @@ void nr_dlsch_256qam_llr(NR_DL_FRAME_PARMS *frame_parms,
 
   llr2 = dlsch_llr;
 
-  ch_mag = (simde__m128i *)dl_ch_mag;
-  ch_magb = (simde__m128i *)dl_ch_magb;
-  ch_magr = (simde__m128i *)dl_ch_magr;
+  const simde__m128i *ch_mag = (simde__m128i *)dl_ch_mag;
+  const simde__m128i *ch_magb = (simde__m128i *)dl_ch_magb;
+  const simde__m128i *ch_magr = (simde__m128i *)dl_ch_magr;
 
   len_mod4 =len&3;
   len2=len>>2;  // length in quad words (4 REs)

openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c

@@ -65,10 +65,10 @@ static int ssb_sort(const void *a, const void *b)
   return ((NR_UE_SSB *)b)->metric - ((NR_UE_SSB *)a)->metric;
 }
 
-static bool nr_pbch_detection(const UE_nr_rxtx_proc_t *proc,
+static bool nr_pbch_detection(UE_nr_rxtx_proc_t *proc,
                               PHY_VARS_NR_UE *ue,
-                              int pbch_initial_symbol,
-                              c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP])
+                              const int pbch_initial_symbol,
+                              const c16_t rxdataF[NR_N_SYMBOLS_SSB][ue->frame_parms.nb_antennas_rx][ue->frame_parms.ofdm_symbol_size])
 {
   NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
 
@@ -83,7 +83,7 @@ static bool nr_pbch_detection(const UE_nr_rxtx_proc_t *proc,
       // computing correlation between received DMRS symbols and transmitted sequence for current i_ssb and n_hf
       cd_t cumul = {0};
       for (int i = pbch_initial_symbol; i < pbch_initial_symbol + 3; i++) {
-        c32_t meas = nr_pbch_dmrs_correlation(ue, proc, i, i - pbch_initial_symbol, ue->nr_gold_pbch[hf][l], rxdataF);
+        c32_t meas = nr_pbch_dmrs_correlation(ue, proc, i, i - pbch_initial_symbol, ue->nr_gold_pbch[hf][l], rxdataF[i]);
         csum(cumul, cumul, meas);
       }
       *current_ssb = (NR_UE_SSB){.i_ssb = l, .n_hf = hf, .metric = squaredMod(cumul)};
@@ -93,37 +93,27 @@ static bool nr_pbch_detection(const UE_nr_rxtx_proc_t *proc,
   qsort(best_ssb, N_L * N_hf, sizeof(NR_UE_SSB), ssb_sort);
   stop_meas(&ue->dlsch_channel_estimation_stats);
 
-  const int nb_ant = frame_parms->nb_antennas_rx;
   for (NR_UE_SSB *ssb = best_ssb; ssb < best_ssb + N_L * N_hf; ssb++) {
-    start_meas(&ue->dlsch_channel_estimation_stats);
     // computing channel estimation for selected best ssb
     const int estimateSz = frame_parms->symbols_per_slot * frame_parms->ofdm_symbol_size;
-    __attribute__((aligned(32))) c16_t dl_ch_estimates[nb_ant][estimateSz];
-    __attribute__((aligned(32))) c16_t dl_ch_estimates_time[nb_ant][frame_parms->ofdm_symbol_size];
-
-    for(int i=pbch_initial_symbol; i<pbch_initial_symbol+3;i++)
-      nr_pbch_channel_estimation(ue,
-                                 estimateSz,
-                                 dl_ch_estimates,
-                                 dl_ch_estimates_time,
-                                 proc,
-                                 i,
-                                 i - pbch_initial_symbol,
-                                 ssb->i_ssb,
-                                 ssb->n_hf,
-                                 rxdataF);
-
-    stop_meas(&ue->dlsch_channel_estimation_stats);
-    fapiPbch_t result = {0};
-    if (0 == nr_rx_pbch(ue, proc, estimateSz, dl_ch_estimates, frame_parms, ssb->i_ssb, &result, rxdataF)) {
+    __attribute__ ((aligned(32))) struct complex16 dl_ch_estimates[frame_parms->nb_antennas_rx][estimateSz];
+    int16_t pbch_e_rx[NR_POLAR_PBCH_E];
+
+    for (int i = pbch_initial_symbol; i < pbch_initial_symbol + 3; i++) {
+      for (int aarx = 0; aarx < ue->frame_parms.nb_antennas_rx; aarx++) {
+        nr_pbch_channel_estimation(ue,
+                                   i - pbch_initial_symbol,
+                                   ssb->i_ssb,
+                                   ssb->n_hf,
+                                   rxdataF[i][aarx],
+                                   dl_ch_estimates[aarx]);
+      }
+      nr_generate_pbch_llr(ue, i - pbch_initial_symbol + 1, ssb->i_ssb, rxdataF[i], dl_ch_estimates, pbch_e_rx);
+    }
+    fapiPbch_t pbchResult = {0}; /* TODO: Not used anywhere. To be cleaned later */
+    if (0 == nr_pbch_decode(ue, proc, ssb->i_ssb, pbch_e_rx, &pbchResult)) {
       if (DUMP_PBCH_CH_ESTIMATES) {
-        write_output("pbch_ch_estimates.m", "pbch_ch_estimates", dl_ch_estimates, nb_ant * estimateSz, 1, 1);
-        write_output("pbch_ch_estimates_time.m",
-                     "pbch_ch_estimates_time",
-                     dl_ch_estimates_time,
-                     nb_ant * frame_parms->ofdm_symbol_size,
-                     1,
-                     1);
+        write_output("pbch_ch_estimates.m", "pbch_ch_estimates", dl_ch_estimates, frame_parms->nb_antennas_rx * estimateSz, 1, 1);
       }
       LOG_I(PHY, "[UE%d] Initial sync: pbch decoded sucessfully, ssb index %d\n", ue->Mod_id, frame_parms->ssb_index);
       return true;
@@ -161,8 +151,6 @@ nr_initial_sync_t nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *ue, i
    *          sync_pos            SS/PBCH block
    */
 
-  const uint32_t rxdataF_sz = ue->frame_parms.samples_per_slot_wCP;
-  __attribute__((aligned(32))) c16_t rxdataF[ue->frame_parms.nb_antennas_rx][rxdataF_sz];
   cnt++;
   if (1) { // (cnt>100)
     cnt = 0;
@@ -192,6 +180,9 @@ nr_initial_sync_t nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *ue, i
           // In SA we need to perform frequency offset correction until the end of buffer because we need to decode SIB1
           // and we do not know yet in which slot it goes.
 
+        // In SA we need to perform frequency offset correction until the end of buffer because we need to decode SIB1
+        // and we do not know yet in which slot it goes.
+
           for (int n = frame_id * fp->samples_per_frame; n < (frame_id + 1) * fp->samples_per_frame; n++) {
             for (int ar = 0; ar < fp->nb_antennas_rx; ar++) {
               const double re = ue->common_vars.rxdata[ar][n].r;
@@ -211,11 +202,26 @@ nr_initial_sync_t nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *ue, i
         /* time samples in buffer rxdata are used as input of FFT -> FFT results are stored in the frequency buffer rxdataF */
         /* rxdataF stores SS/PBCH from beginning of buffers in the same symbol order as in time domain */
 
-        for (int i = 0; i < NR_N_SYMBOLS_SSB; i++)
-          nr_slot_fep_init_sync(ue, proc, i, frame_id * fp->samples_per_frame + ue->ssb_offset, false, rxdataF, link_type_dl);
+        __attribute__((aligned(32)))
+        c16_t rxdata[NR_N_SYMBOLS_SSB][fp->nb_antennas_rx][fp->ofdm_symbol_size + fp->nb_prefix_samples0];
+        __attribute__((aligned(32))) c16_t rxdataF[NR_N_SYMBOLS_SSB][fp->nb_antennas_rx][fp->ofdm_symbol_size];
+
+        for (int aarx = 0; aarx < fp->nb_antennas_rx; aarx++) {
+          const int symbolSamples = (fp->ofdm_symbol_size + fp->nb_prefix_samples);
+          for (int symbol = 0; symbol < NR_N_SYMBOLS_SSB; symbol++) {
+            memcpy(rxdata[symbol][aarx],
+                  &ue->common_vars.rxdata[aarx][frame_id * fp->samples_per_frame + ue->ssb_offset + (symbol * symbolSamples)
+                                                + fp->nb_prefix_samples],
+                  sizeof(c16_t) * fp->ofdm_symbol_size);
+          }
+        }
+
+        for (int i = 0; i < NR_N_SYMBOLS_SSB; i++) {
+          nr_symbol_fep(ue, proc->nr_slot_rx, i, link_type_dl, rxdata[i], rxdataF[i]);
+        }
 
 #ifdef DEBUG_INITIAL_SYNCH
-        LOG_I(PHY, "Calling sss detection (normal CP)\n");
+        LOG_I(PHY,"Calling sss detection (normal CP)\n");
 #endif
 
         int freq_offset_sss = 0;
@@ -265,7 +271,7 @@ nr_initial_sync_t nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *ue, i
           // compute the scrambling IDs for PDSCH DMRS
           for (int i = 0; i < NR_NB_NSCID; i++) {
             ue->scramblingID_dlsch[i] = fp->Nid_cell;
-            nr_gold_pdsch(ue, i, ue->scramblingID_dlsch[i]);
+            nr_gold_pdsch(i, ue->scramblingID_dlsch[i], ue);
           }
 
           nr_init_csi_rs(fp, ue->nr_csi_info->nr_gold_csi_rs, fp->Nid_cell);

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_ue.c

@@ -162,13 +162,8 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
     K_ptrs = pusch_pdu->pusch_ptrs.ptrs_freq_density;
     L_ptrs = 1 << pusch_pdu->pusch_ptrs.ptrs_time_density;
 
-    ulsch_ue->ptrs_symbols = 0;
+    ulsch_ue->ptrs_symbols = get_ptrs_symb_idx(number_of_symbols, start_symbol, L_ptrs, ul_dmrs_symb_pos);
 
-    set_ptrs_symb_idx(&ulsch_ue->ptrs_symbols,
-                      number_of_symbols,
-                      start_symbol,
-                      L_ptrs,
-                      ul_dmrs_symb_pos);
     int n_ptrs = (nb_rb + K_ptrs - 1) / K_ptrs;
     int ptrsSymbPerSlot = get_ptrs_symbols_in_slot(ulsch_ue->ptrs_symbols,
                                                    start_symbol,

openair1/PHY/NR_UE_TRANSPORT/sss_nr.c

@@ -259,25 +259,24 @@ static int pss_ch_est_nr(PHY_VARS_NR_UE *ue,
 static int do_pss_sss_extract_nr(
     PHY_VARS_NR_UE *ue,
     const UE_nr_rxtx_proc_t *proc,
-    c16_t pss_ext[NB_ANTENNAS_RX][LENGTH_PSS_NR],
-    c16_t sss_ext[NB_ANTENNAS_RX][LENGTH_SSS_NR],
-    uint8_t doPss,
-    uint8_t doSss,
-    uint8_t subframe,
-    c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]) // add flag to indicate extracting only PSS, only SSS, or both
+    c16_t pss_ext[ue->frame_parms.nb_antennas_rx][LENGTH_PSS_NR],
+    c16_t sss_ext[ue->frame_parms.nb_antennas_rx][LENGTH_SSS_NR],
+    const uint8_t doPss,
+    const uint8_t doSss,
+    const uint8_t subframe,
+    const c16_t rxdataF[NR_N_SYMBOLS_SSB][ue->frame_parms.nb_antennas_rx]
+                       [ue->frame_parms.ofdm_symbol_size]) // add flag to indicate extracting only PSS, only SSS, or both
 {
   NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
   AssertFatal(frame_parms->nb_antennas_rx > 0, "UB as sss_ext is not set to any value\n");
 
   for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) {
-    int pss_symbol = 0;
-    int sss_symbol = get_softmodem_params()->sl_mode == 0 ?
-                     (SSS_SYMBOL_NB - PSS_SYMBOL_NB) :
-                     (SSS0_SL_SYMBOL_NB - PSS0_SL_SYMBOL_NB) ;
-    unsigned int ofdm_symbol_size = frame_parms->ofdm_symbol_size;
+    const int pss_symbol = 0;
+    const int sss_symbol =
+        get_softmodem_params()->sl_mode == 0 ? (SSS_SYMBOL_NB - PSS_SYMBOL_NB) : (SSS0_SL_SYMBOL_NB - PSS0_SL_SYMBOL_NB);
 
-    c16_t *pss_rxF = rxdataF[aarx] + pss_symbol * ofdm_symbol_size;
-    c16_t *sss_rxF = rxdataF[aarx] + sss_symbol * ofdm_symbol_size;
+    const c16_t *pss_rxF = rxdataF[pss_symbol][aarx];
+    const c16_t *sss_rxF = rxdataF[sss_symbol][aarx];
 
     c16_t *pss_rxF_ext = pss_ext[aarx];
     c16_t *sss_rxF_ext = sss_ext[aarx];
@@ -342,10 +341,10 @@ static int do_pss_sss_extract_nr(
 
 static int pss_sss_extract_nr(PHY_VARS_NR_UE *phy_vars_ue,
                               const UE_nr_rxtx_proc_t *proc,
-                              c16_t pss_ext[NB_ANTENNAS_RX][LENGTH_PSS_NR],
-                              c16_t sss_ext[NB_ANTENNAS_RX][LENGTH_SSS_NR],
-                              uint8_t subframe,
-                              c16_t rxdataF[][phy_vars_ue->frame_parms.samples_per_slot_wCP])
+                              c16_t pss_ext[phy_vars_ue->frame_parms.nb_antennas_rx][LENGTH_PSS_NR],
+                              c16_t sss_ext[phy_vars_ue->frame_parms.nb_antennas_rx][LENGTH_SSS_NR],
+                              const uint8_t subframe,
+                              const c16_t rxdataF[NR_N_SYMBOLS_SSB][phy_vars_ue->frame_parms.nb_antennas_rx][phy_vars_ue->frame_parms.ofdm_symbol_size])
 {
   return do_pss_sss_extract_nr(phy_vars_ue, proc, pss_ext, sss_ext, 1 /* doPss */, 1 /* doSss */, subframe, rxdataF);
 }
@@ -356,18 +355,19 @@ static int pss_sss_extract_nr(PHY_VARS_NR_UE *phy_vars_ue,
  *
  * PARAMETERS :   none
  *
- * RETURN :       Set Nid_cell in ue context, return true if cell detected
+ * RETURN :       Set Nid_cell in ue context
  *
  * DESCRIPTION :  Determine element Nid1 of cell identity
  *                so Nid_cell in ue context is set according to Nid1 & Nid2
  *
  *********************************************************************/
+
 bool rx_sss_nr(PHY_VARS_NR_UE *ue,
                const UE_nr_rxtx_proc_t *proc,
                int32_t *tot_metric,
                uint8_t *phase_max,
                int *freq_offset_sss,
-               c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP])
+               c16_t rxdataF[NR_N_SYMBOLS_SSB][ue->frame_parms.nb_antennas_rx][ue->frame_parms.ofdm_symbol_size])
 {
   uint8_t i;
   c16_t pss_ext[NB_ANTENNAS_RX][LENGTH_PSS_NR] = {0};

openair1/PHY/TOOLS/cmult_vv.c

@@ -155,12 +155,7 @@ int mult_cpx_vector(int16_t *x1, //Q15
   return(0);
 }
 
-int multadd_cpx_vector(int16_t *x1,
-                    int16_t *x2,
-                    int16_t *y,
-                    uint8_t zero_flag,
-                    uint32_t N,
-                    int output_shift)
+int multadd_cpx_vector(int16_t *x1, const int16_t *x2, int16_t *y, uint8_t zero_flag, uint32_t N, int output_shift)
 {
   // Multiply elementwise the complex conjugate of x1 with x2.
   // x1       - input 1    in the format  |Re0 Im0 Re1 Im1|,......,|Re(N-2)  Im(N-2) Re(N-1) Im(N-1)|