improve nr_slot_fep() and variants

openair1/PHY/MODULATION/modulation_UE.h

@@ -51,16 +51,13 @@ int slot_fep(PHY_VARS_UE *phy_vars_ue,
 int nr_slot_fep(PHY_VARS_NR_UE *phy_vars_ue,
                 UE_nr_rxtx_proc_t *proc,
                 unsigned char l,
-                unsigned char Ns,
-                int sample_offset,
-                int no_prefix);
+                unsigned char Ns);
 
 int nr_slot_fep_init_sync(PHY_VARS_NR_UE *ue,
                           UE_nr_rxtx_proc_t *proc,
                           unsigned char symbol,
                           unsigned char Ns,
-                          int sample_offset,
-                          int no_prefix);
+                          int sample_offset);
 
 int slot_fep_mbsfn(PHY_VARS_UE *phy_vars_ue,
                    unsigned char l,

openair1/PHY/MODULATION/nr_modulation.h

@@ -74,7 +74,6 @@ void nr_ue_layer_mapping(NR_UE_ULSCH_t **ulsch_ue,
 \param symbol symbol within slot (0..12/14)
 \param Ns Slot number (0..19)
 \param sample_offset offset within rxdata (points to beginning of subframe)
-\param no_prefix if 1 prefix is removed by HW
 */
 
 int nr_slot_fep_ul(NR_DL_FRAME_PARMS *frame_parms,
@@ -82,8 +81,7 @@ int nr_slot_fep_ul(NR_DL_FRAME_PARMS *frame_parms,
                    int32_t *rxdataF,
                    unsigned char symbol,
                    unsigned char Ns,
-                   int sample_offset,
-                   int no_prefix);
+                   int sample_offset);
 
 /*!
 \brief This function implements the dft transform precoding in PUSCH

openair1/PHY/MODULATION/slot_fep_nr.c

@@ -29,362 +29,224 @@
 
 //#define DEBUG_FEP
 
-#define SOFFSET 0
-
 /*#ifdef LOG_I
 #undef LOG_I
 #define LOG_I(A,B...) printf(A)
 #endif*/
 
-int nr_slot_fep(PHY_VARS_NR_UE *ue,
-                UE_nr_rxtx_proc_t *proc,
-                unsigned char symbol,
-                unsigned char Ns,
-                int sample_offset,
-                int no_prefix)
+dft_size_idx_t get_dft_size_idx(uint16_t ofdm_symbol_size)
 {
-  NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
-  NR_UE_COMMON *common_vars   = &ue->common_vars;
-  unsigned char aa;
-  unsigned int nb_prefix_samples;
-  unsigned int nb_prefix_samples0;
-  unsigned int abs_symbol;
-  if (ue->is_synchronized) {
-    nb_prefix_samples = (no_prefix ? 0 : frame_parms->nb_prefix_samples);
-    nb_prefix_samples0 = (no_prefix ? 0 : frame_parms->nb_prefix_samples0);
-  }
-  else {
-    nb_prefix_samples = (no_prefix ? 0 : frame_parms->nb_prefix_samples);
-    nb_prefix_samples0 = (no_prefix ? 0 : frame_parms->nb_prefix_samples);
-  }
-  //unsigned int subframe_offset;//,subframe_offset_F;
-  unsigned int slot_offset;
-  //int i;
-  unsigned int frame_length_samples = frame_parms->samples_per_subframe * 10;
-  unsigned int rx_offset;
-
-
-  dft_size_idx_t dftsize;
-  int tmp_dft_in[8192] __attribute__ ((aligned (32)));  // This is for misalignment issues for 6 and 15 PRBs
-
-  switch (frame_parms->ofdm_symbol_size) {
+  switch (ofdm_symbol_size) {
   case 128:
-    dftsize = DFT_128;
-    break;
+    return DFT_128;
 
   case 256:
-    dftsize = DFT_256;
-    break;
+    return DFT_256;
 
   case 512:
-    dftsize = DFT_512;
-    break;
+    return DFT_512;
 
   case 1024:
-    dftsize = DFT_1024;
-    break;
+    return DFT_1024;
 
   case 1536:
-    dftsize = DFT_1536;
-    break;
+    return DFT_1536;
 
   case 2048:
-    dftsize = DFT_2048;
-    break;
+    return DFT_2048;
 
   case 3072:
-    dftsize = DFT_3072;
-    break;
+    return DFT_3072;
 
   case 4096:
-    dftsize = DFT_4096;
-    break;
+    return DFT_4096;
+
+  case 6144:
+    return DFT_6144;
 
   case 8192:
-    dftsize = DFT_8192;
-    break;
+    return DFT_8192;
 
   default:
     printf("unsupported ofdm symbol size \n");
     assert(0);
   }
 
-  if (no_prefix) {
-    slot_offset = frame_parms->ofdm_symbol_size * (frame_parms->symbols_per_slot) * (Ns);
-  } else {
-    slot_offset = frame_parms->get_samples_slot_timestamp(Ns,frame_parms,0);
-  }
+  return DFT_SIZE_IDXTABLESIZE;
+}
 
-  /*if (l<0 || l>=7-frame_parms->Ncp) {
-    printf("slot_fep: l must be between 0 and %d\n",7-frame_parms->Ncp);
-    return(-1);
-    }*/
+int nr_slot_fep(PHY_VARS_NR_UE *ue,
+                UE_nr_rxtx_proc_t *proc,
+                unsigned char symbol,
+                unsigned char Ns)
+{
+  NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
+  NR_UE_COMMON *common_vars      = &ue->common_vars;
+
+  AssertFatal(symbol < frame_parms->symbols_per_slot, "slot_fep: symbol must be between 0 and %d\n", frame_parms->symbols_per_slot-1);
+  AssertFatal(Ns < frame_parms->slots_per_frame, "slot_fep: Ns must be between 0 and %d\n", frame_parms->slots_per_frame-1);
 
-  if (Ns<0 || Ns>(frame_parms->slots_per_frame-1)) {
-    printf("slot_fep: Ns must be between 0 and %d\n",frame_parms->slots_per_frame-1);
-    return(-1);
+  unsigned int nb_prefix_samples;
+  unsigned int nb_prefix_samples0;
+  if (ue->is_synchronized) {
+    nb_prefix_samples  = frame_parms->nb_prefix_samples;
+    nb_prefix_samples0 = frame_parms->nb_prefix_samples0;
+  } else {
+    nb_prefix_samples  = frame_parms->nb_prefix_samples;
+    nb_prefix_samples0 = frame_parms->nb_prefix_samples;
   }
 
-  for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
-    memset(&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],0,frame_parms->ofdm_symbol_size*sizeof(int));
+  dft_size_idx_t dftsize = get_dft_size_idx(frame_parms->ofdm_symbol_size);
+  // This is for misalignment issues
+  int32_t tmp_dft_in[8192] __attribute__ ((aligned (32)));
 
-    rx_offset = sample_offset + slot_offset - SOFFSET;
-    // Align with 256 bit
-    //    rx_offset = rx_offset&0xfffffff8;
+  unsigned int rx_offset = frame_parms->get_samples_slot_timestamp(Ns,frame_parms,0);
+  unsigned int abs_symbol = Ns * frame_parms->symbols_per_slot + symbol;
+  for (int idx_symb = Ns*frame_parms->symbols_per_slot; idx_symb <= abs_symbol; idx_symb++)
+    rx_offset += (idx_symb%(0x7<<frame_parms->numerology_index)) ? nb_prefix_samples : nb_prefix_samples0;
+  rx_offset += frame_parms->ofdm_symbol_size * symbol;
 
 #ifdef DEBUG_FEP
-      //  if (ue->frame <100)
-    /*LOG_I(PHY,*/printf("slot_fep: slot %d, symbol %d, nb_prefix_samples %u, nb_prefix_samples0 %u, slot_offset %u, sample_offset %d,rx_offset %u, frame_length_samples %u\n",
-			 Ns, symbol, nb_prefix_samples, nb_prefix_samples0, slot_offset, sample_offset, rx_offset, frame_length_samples);
+  //  if (ue->frame <100)
+  printf("slot_fep: slot %d, symbol %d, nb_prefix_samples %u, nb_prefix_samples0 %u, rx_offset %u\n",
+         Ns, symbol, nb_prefix_samples, nb_prefix_samples0, rx_offset);
 #endif
 
-    abs_symbol = Ns * frame_parms->symbols_per_slot + symbol;
-    
-    for (int idx_symb = Ns*frame_parms->symbols_per_slot; idx_symb < abs_symbol; idx_symb++)
-      rx_offset += (idx_symb%(0x7<<frame_parms->numerology_index)) ? nb_prefix_samples : nb_prefix_samples0;
-
-    rx_offset += frame_parms->ofdm_symbol_size * symbol;
-
-    if (abs_symbol%(0x7<<frame_parms->numerology_index)) {
-
-      rx_offset += nb_prefix_samples;
-      if (rx_offset > (frame_length_samples - frame_parms->ofdm_symbol_size))
-        memcpy((short*) &common_vars->rxdata[aa][frame_length_samples],
-               (short*) &common_vars->rxdata[aa][0],
-               frame_parms->ofdm_symbol_size*sizeof(int));
-
-      if ((rx_offset&7)!=0) {  // if input to dft is not 256-bit aligned, issue for size 6,15 and 25 PRBs
-        memcpy((void *)tmp_dft_in,
-               (void *) &common_vars->rxdata[aa][rx_offset % frame_length_samples],
-               frame_parms->ofdm_symbol_size*sizeof(int));
-        dft(dftsize,(int16_t *)tmp_dft_in,
-            (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1);
-      } else { // use dft input from RX buffer directly
-#if UE_TIMING_TRACE
-          start_meas(&ue->rx_dft_stats);
-#endif
+  for (unsigned char aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
+    memset(&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],0,frame_parms->ofdm_symbol_size*sizeof(int32_t));
 
-        dft(dftsize,(int16_t *) &common_vars->rxdata[aa][(rx_offset) % frame_length_samples],
-            (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1);
-#if UE_TIMING_TRACE
-        stop_meas(&ue->rx_dft_stats);
-#endif
-      }
-    } else {
+    int16_t *rxdata_ptr = (int16_t *)&common_vars->rxdata[aa][rx_offset];
+
+    // if input to dft is not 256-bit aligned
+    if ((rx_offset & 7) != 0) {
+      memcpy((void *)&tmp_dft_in[0],
+             (void *)&common_vars->rxdata[aa][rx_offset],
+             frame_parms->ofdm_symbol_size * sizeof(int32_t));
+
+      rxdata_ptr = (int16_t *)tmp_dft_in;
+    }
 
-      rx_offset += nb_prefix_samples0;
-      if (rx_offset > (frame_length_samples - frame_parms->ofdm_symbol_size))
-        memcpy((void *) &common_vars->rxdata[aa][frame_length_samples],
-               (void *) &common_vars->rxdata[aa][0],
-               frame_parms->ofdm_symbol_size*sizeof(int));
 #if UE_TIMING_TRACE
-      start_meas(&ue->rx_dft_stats);
+    start_meas(&ue->rx_dft_stats);
 #endif
 
-      if ((rx_offset&7)!=0) {  // if input to dft is not 128-bit aligned, issue for size 6 and 15 PRBs
-        memcpy((void *)tmp_dft_in,
-               (void *) &common_vars->rxdata[aa][(rx_offset) % frame_length_samples],
-               frame_parms->ofdm_symbol_size*sizeof(int));
-        dft(dftsize,(int16_t *)tmp_dft_in,
-            (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1);
-      } else { // use dft input from RX buffer directly
-
-        dft(dftsize,(int16_t *) &common_vars->rxdata[aa][(rx_offset) % frame_length_samples],
-            (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1);
-      }
+    dft(dftsize,
+        rxdata_ptr,
+        (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
+        1);
+
 #if UE_TIMING_TRACE
-      stop_meas(&ue->rx_dft_stats);
+    stop_meas(&ue->rx_dft_stats);
 #endif
 
-
-    }
+    int symb_offset = (Ns%frame_parms->slots_per_subframe)*frame_parms->symbols_per_slot;
+    int32_t rot2 = ((uint32_t*)frame_parms->symbol_rotation)[symbol+symb_offset];
+    ((int16_t*)&rot2)[1]=-((int16_t*)&rot2)[1];
 
 #ifdef DEBUG_FEP
     //  if (ue->frame <100)
-    printf("slot_fep: symbol %d rx_offset %u\n", symbol, rx_offset);
+    printf("slot_fep: slot %d, symbol %d rx_offset %u, rotation symbol %d %d.%d\n", Ns,symbol, rx_offset,
+	   symbol+symb_offset,((int16_t*)&rot2)[0],((int16_t*)&rot2)[1]);
 #endif
-    
-    int symb_offset = (Ns%frame_parms->slots_per_subframe)*frame_parms->symbols_per_slot;
-    int32_t rot2 = ((uint32_t*)frame_parms->symbol_rotation)[symbol+symb_offset];
-    ((int16_t*)&rot2)[1]=-((int16_t*)&rot2)[1];
+
     rotate_cpx_vector((int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
 		      (int16_t*)&rot2,
 		      (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
 		      frame_parms->ofdm_symbol_size,
 		      15);
-    
   }
-  
 
 #ifdef DEBUG_FEP
   printf("slot_fep: done\n");
 #endif
-  return(0);
+
+  return 0;
 }
 
 int nr_slot_fep_init_sync(PHY_VARS_NR_UE *ue,
                           UE_nr_rxtx_proc_t *proc,
                           unsigned char symbol,
                           unsigned char Ns,
-                          int sample_offset,
-                          int no_prefix)
+                          int sample_offset)
 {
   NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
   NR_UE_COMMON *common_vars   = &ue->common_vars;
-  unsigned char aa;
+
+  AssertFatal(symbol < frame_parms->symbols_per_slot, "slot_fep: symbol must be between 0 and %d\n", frame_parms->symbols_per_slot-1);
+  AssertFatal(Ns < frame_parms->slots_per_frame, "slot_fep: Ns must be between 0 and %d\n", frame_parms->slots_per_frame-1);
+
   unsigned int nb_prefix_samples;
   unsigned int nb_prefix_samples0;
-  unsigned int abs_symbol;
   if (ue->is_synchronized) {
-    nb_prefix_samples = (no_prefix ? 0 : frame_parms->nb_prefix_samples);
-    nb_prefix_samples0 = (no_prefix ? 0 : frame_parms->nb_prefix_samples0);
+    nb_prefix_samples  = frame_parms->nb_prefix_samples;
+    nb_prefix_samples0 = frame_parms->nb_prefix_samples0;
   }
   else {
-    nb_prefix_samples = (no_prefix ? 0 : frame_parms->nb_prefix_samples);
-    nb_prefix_samples0 = (no_prefix ? 0 : frame_parms->nb_prefix_samples);
+    nb_prefix_samples  = frame_parms->nb_prefix_samples;
+    nb_prefix_samples0 = frame_parms->nb_prefix_samples;
   }
-  //unsigned int subframe_offset;//,subframe_offset_F;
-  unsigned int slot_offset;
-  //int i;
-  unsigned int frame_length_samples = frame_parms->samples_per_subframe * 10;
-  unsigned int rx_offset;
+  unsigned int frame_length_samples = frame_parms->samples_per_frame;
 
+  dft_size_idx_t dftsize = get_dft_size_idx(frame_parms->ofdm_symbol_size);
+  // This is for misalignment issues
+  int32_t tmp_dft_in[8192] __attribute__ ((aligned (32)));
 
-  dft_size_idx_t dftsize;
-  int tmp_dft_in[8192] __attribute__ ((aligned (32)));  // This is for misalignment issues for 6 and 15 PRBs
+  unsigned int slot_offset = frame_parms->get_samples_slot_timestamp(Ns,frame_parms,0);
+  unsigned int rx_offset   = sample_offset + slot_offset;
+  unsigned int abs_symbol  = Ns * frame_parms->symbols_per_slot + symbol;
+  for (int idx_symb = Ns*frame_parms->symbols_per_slot; idx_symb <= abs_symbol; idx_symb++)
+    rx_offset += (abs_symbol%(0x7<<frame_parms->numerology_index)) ? nb_prefix_samples : nb_prefix_samples0;
+  rx_offset += frame_parms->ofdm_symbol_size * symbol;
 
-  switch (frame_parms->ofdm_symbol_size) {
-  case 128:
-    dftsize = DFT_128;
-    break;
-
-  case 256:
-    dftsize = DFT_256;
-    break;
-
-  case 512:
-    dftsize = DFT_512;
-    break;
-
-  case 1024:
-    dftsize = DFT_1024;
-    break;
-
-  case 1536:
-    dftsize = DFT_1536;
-    break;
-
-  case 2048:
-    dftsize = DFT_2048;
-    break;
-
-  case 3072:
-    dftsize = DFT_3072;
-    break;
-
-  case 4096:
-    dftsize = DFT_4096;
-    break;
-
-  case 8192:
-    dftsize = DFT_8192;
-    break;
+#ifdef DEBUG_FEP
+  //  if (ue->frame <100)
+  printf("slot_fep: slot %d, symbol %d, nb_prefix_samples %u, nb_prefix_samples0 %u, slot_offset %u, sample_offset %d,rx_offset %u, frame_length_samples %u\n",
+         Ns, symbol, nb_prefix_samples, nb_prefix_samples0, slot_offset, sample_offset, rx_offset, frame_length_samples);
+#endif
 
-  default:
-    printf("unsupported ofdm symbol size \n");
-    assert(0);
-  }
+  for (unsigned char aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
+    memset(&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],0,frame_parms->ofdm_symbol_size*sizeof(int32_t));
 
-  if (no_prefix) {
-    slot_offset = frame_parms->ofdm_symbol_size * (frame_parms->symbols_per_slot) * (Ns);
-  } else {
-    slot_offset = frame_parms->get_samples_slot_timestamp(Ns,frame_parms,0);
-  }
+    int16_t *rxdata_ptr;
 
-  /*if (l<0 || l>=7-frame_parms->Ncp) {
-    printf("slot_fep: l must be between 0 and %d\n",7-frame_parms->Ncp);
-    return(-1);
-    }*/
+    if (frame_length_samples - rx_offset < frame_parms->ofdm_symbol_size) {
 
-  if (Ns<0 || Ns>(frame_parms->slots_per_frame-1)) {
-    printf("slot_fep: Ns must be between 0 and %d\n",frame_parms->slots_per_frame-1);
-    return(-1);
-  }
+      memcpy((void *)&tmp_dft_in[0],
+             (void *)&common_vars->rxdata[aa][rx_offset],
+             (frame_length_samples - rx_offset) * sizeof(int32_t));
+      memcpy((void *)&tmp_dft_in[frame_length_samples - rx_offset],
+             (void *)&common_vars->rxdata[aa][0],
+             (frame_parms->ofdm_symbol_size - (frame_length_samples - rx_offset)) * sizeof(int32_t));
+      rxdata_ptr = (int16_t *)&tmp_dft_in[0];
 
-  for (aa=0; aa<frame_parms->nb_antennas_rx; aa++) {
-    memset(&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],0,frame_parms->ofdm_symbol_size*sizeof(int));
+    } else if ((rx_offset & 7) != 0) {
 
-    rx_offset = sample_offset + slot_offset - SOFFSET;
-    // Align with 256 bit
-    //    rx_offset = rx_offset&0xfffffff8;
+      // if input to dft is not 256-bit aligned
+      memcpy((void *)&tmp_dft_in[0],
+             (void *)&common_vars->rxdata[aa][rx_offset],
+             frame_parms->ofdm_symbol_size * sizeof(int32_t));
+      rxdata_ptr = (int16_t *)&tmp_dft_in[0];
 
-#ifdef DEBUG_FEP
-      //  if (ue->frame <100)
-    /*LOG_I(PHY,*/printf("slot_fep: slot %d, symbol %d, nb_prefix_samples %u, nb_prefix_samples0 %u, slot_offset %u, sample_offset %d,rx_offset %u, frame_length_samples %u\n",
-    		Ns, symbol, nb_prefix_samples, nb_prefix_samples0, slot_offset, sample_offset, rx_offset, frame_length_samples);
-#endif
+    } else {
 
-    abs_symbol = Ns * frame_parms->symbols_per_slot + symbol;
-    
-    for (int idx_symb = Ns*frame_parms->symbols_per_slot; idx_symb < abs_symbol; idx_symb++)
-      rx_offset += (abs_symbol%(0x7<<frame_parms->numerology_index)) ? nb_prefix_samples : nb_prefix_samples0;
-
-    rx_offset += frame_parms->ofdm_symbol_size * symbol;
-
-    if (abs_symbol%(0x7<<frame_parms->numerology_index)) {
-
-      rx_offset += nb_prefix_samples;
-      if (rx_offset > (frame_length_samples - frame_parms->ofdm_symbol_size))
-        memcpy((short*) &common_vars->rxdata[aa][frame_length_samples],
-               (short*) &common_vars->rxdata[aa][0],
-               frame_parms->ofdm_symbol_size*sizeof(int));
-
-      if ((rx_offset&7)!=0) {  // if input to dft is not 256-bit aligned, issue for size 6,15 and 25 PRBs
-        memcpy((void *)tmp_dft_in,
-               (void *) &common_vars->rxdata[aa][rx_offset],
-               frame_parms->ofdm_symbol_size*sizeof(int));
-        dft(dftsize,(int16_t *)tmp_dft_in,
-            (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1);
-      } else { // use dft input from RX buffer directly
-#if UE_TIMING_TRACE
-          start_meas(&ue->rx_dft_stats);
-#endif
+      // use dft input from RX buffer directly
+      rxdata_ptr = (int16_t *)&common_vars->rxdata[aa][rx_offset];
 
+    }
 
-        dft(dftsize,(int16_t *) &common_vars->rxdata[aa][rx_offset],
-            (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1);
 #if UE_TIMING_TRACE
-        stop_meas(&ue->rx_dft_stats);
+    start_meas(&ue->rx_dft_stats);
 #endif
-      }
-    } else {
 
-      rx_offset += nb_prefix_samples0;
-      if (rx_offset > (frame_length_samples - frame_parms->ofdm_symbol_size))
-        memcpy((void *) &common_vars->rxdata[aa][frame_length_samples],
-               (void *) &common_vars->rxdata[aa][0],
-               frame_parms->ofdm_symbol_size*sizeof(int));
-#if UE_TIMING_TRACE
-      start_meas(&ue->rx_dft_stats);
-#endif
+    dft(dftsize,
+        rxdata_ptr,
+        (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
+        1);
 
-      if ((rx_offset&7)!=0) {  // if input to dft is not 128-bit aligned, issue for size 6 and 15 PRBs
-        memcpy((void *)tmp_dft_in,
-               (void *) &common_vars->rxdata[aa][rx_offset],
-               frame_parms->ofdm_symbol_size*sizeof(int));
-        dft(dftsize,(int16_t *)tmp_dft_in,
-            (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1);
-      } else { // use dft input from RX buffer directly
-        dft(dftsize,(int16_t *) &common_vars->rxdata[aa][rx_offset],
-            (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],1);
-      }
 #if UE_TIMING_TRACE
-      stop_meas(&ue->rx_dft_stats);
+    stop_meas(&ue->rx_dft_stats);
 #endif
 
-
-    }
-
     int symb_offset = (Ns%frame_parms->slots_per_subframe)*frame_parms->symbols_per_slot;
     int32_t rot2 = ((uint32_t*)frame_parms->symbol_rotation)[symbol+symb_offset];
     ((int16_t*)&rot2)[1]=-((int16_t*)&rot2)[1];
@@ -400,14 +262,13 @@ int nr_slot_fep_init_sync(PHY_VARS_NR_UE *ue,
 		      (int16_t *)&common_vars->common_vars_rx_data_per_thread[proc->thread_id].rxdataF[aa][frame_parms->ofdm_symbol_size*symbol],
 		      frame_parms->ofdm_symbol_size,
 		      15);
-    
   }
 
-
 #ifdef DEBUG_FEP
   printf("slot_fep: done\n");
 #endif
-  return(0);
+
+  return 0;
 }
 
 
@@ -416,91 +277,60 @@ int nr_slot_fep_ul(NR_DL_FRAME_PARMS *frame_parms,
                    int32_t *rxdataF,
                    unsigned char symbol,
                    unsigned char Ns,
-                   int sample_offset,
-                   int no_prefix)
+                   int sample_offset)
 {
-  int32_t slot_offset, rxdata_offset;
-
-  unsigned int nb_prefix_samples  = (no_prefix ? 0 : frame_parms->nb_prefix_samples);
-  unsigned int nb_prefix_samples0 = (no_prefix ? 0 : frame_parms->nb_prefix_samples0);
+  unsigned int nb_prefix_samples  = frame_parms->nb_prefix_samples;
+  unsigned int nb_prefix_samples0 = frame_parms->nb_prefix_samples0;
   
-  int tmp_dft_in[8192] __attribute__ ((aligned (32)));
+  dft_size_idx_t dftsize = get_dft_size_idx(frame_parms->ofdm_symbol_size);
+  // This is for misalignment issues
+  int32_t tmp_dft_in[8192] __attribute__ ((aligned (32)));
 
-  dft_size_idx_t dftsize;
+  unsigned int slot_offset = frame_parms->get_samples_slot_timestamp(Ns,frame_parms,0);
 
-  switch (frame_parms->ofdm_symbol_size) {
-    case 128:
-      dftsize = DFT_128;
-      break;
+  // offset of first OFDM symbol
+  int32_t rxdata_offset = slot_offset + nb_prefix_samples0;
+  // offset of n-th OFDM symbol
+  rxdata_offset += symbol * (frame_parms->ofdm_symbol_size + nb_prefix_samples);
+  // use OFDM symbol from within 1/8th of the CP to avoid ISI
+  rxdata_offset -= nb_prefix_samples / 8;
 
-    case 256:
-      dftsize = DFT_256;
-      break;
+  int16_t *rxdata_ptr;
 
-    case 512:
-      dftsize = DFT_512;
-      break;
+  if(sample_offset > rxdata_offset) {
 
-    case 1024:
-      dftsize = DFT_1024;
-      break;
+    memcpy((void *)&tmp_dft_in[0],
+           (void *)&rxdata[frame_parms->samples_per_frame - sample_offset + rxdata_offset],
+           (sample_offset - rxdata_offset) * sizeof(int32_t));
+    memcpy((void *)&tmp_dft_in[sample_offset - rxdata_offset],
+           (void *)&rxdata[0],
+           (frame_parms->ofdm_symbol_size - sample_offset + rxdata_offset) * sizeof(int32_t));
+    rxdata_ptr = (int16_t *)&tmp_dft_in[0];
 
-    case 1536:
-      dftsize = DFT_1536;
-      break;
+  } else if (((rxdata_offset - sample_offset) & 7) != 0) {
 
-    case 2048:
-      dftsize = DFT_2048;
-      break;
+    // if input to dft is not 256-bit aligned
+    memcpy((void *)&tmp_dft_in[0],
+           (void *)&rxdata[rxdata_offset - sample_offset],
+           (frame_parms->ofdm_symbol_size) * sizeof(int32_t));
+    rxdata_ptr = (int16_t *)&tmp_dft_in[0];
 
-    case 4096:
-      dftsize = DFT_4096;
-      break;
+  } else {
 
-    case 8192:
-      dftsize = DFT_8192;
-      break;
+    // use dft input from RX buffer directly
+    rxdata_ptr = (int16_t *)&rxdata[rxdata_offset - sample_offset];
 
-    default:
-      dftsize = DFT_512;
-      break;
   }
-  
-  slot_offset   = frame_parms->get_samples_slot_timestamp(Ns,frame_parms,0);
-
-  // offset of first OFDM symbol
-  rxdata_offset  = slot_offset + nb_prefix_samples0 - SOFFSET;
-  // offset of n-th OFDM symbol
-  rxdata_offset += symbol * (frame_parms->ofdm_symbol_size + nb_prefix_samples);
-  // use OFDM symbol from within 1/8th of the CP to avoid ISI
-  rxdata_offset -= nb_prefix_samples / 8;
-
-  if(sample_offset>rxdata_offset) {
-    memcpy1((void *)tmp_dft_in,
-           (void *) &rxdata[frame_parms->samples_per_frame-sample_offset+rxdata_offset],
-           (sample_offset-rxdata_offset)*sizeof(int));
-
-    memcpy1((void *)&tmp_dft_in[sample_offset-rxdata_offset],
-           (void *) &rxdata[0],
-           (frame_parms->ofdm_symbol_size-sample_offset+rxdata_offset)*sizeof(int));
 
-    dft(dftsize,(int16_t *)&tmp_dft_in,
-        (int16_t *)&rxdataF[symbol * frame_parms->ofdm_symbol_size], 1);
-  }
-  else {
-    //dft(dftsize,(int16_t *)&rxdata[rxdata_offset-sample_offset],
-      //  (int16_t *)&rxdataF[symbol * frame_parms->ofdm_symbol_size], 1);
-    memcpy((void *)tmp_dft_in,
-           (void *) &rxdata[rxdata_offset-sample_offset],
-           (frame_parms->ofdm_symbol_size)*sizeof(int));
-    dft(dftsize,(int16_t *)&tmp_dft_in,
-        (int16_t *)&rxdataF[symbol * frame_parms->ofdm_symbol_size], 1);
-  }
+  dft(dftsize,
+      rxdata_ptr,
+      (int16_t *)&rxdataF[symbol * frame_parms->ofdm_symbol_size],
+      1);
 
   // clear DC carrier from OFDM symbols
   rxdataF[symbol * frame_parms->ofdm_symbol_size] = 0;
 
-  return(0);
+  return 0;
 }
 
 void apply_nr_rotation_ul(NR_DL_FRAME_PARMS *frame_parms,

openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c

@@ -289,8 +289,7 @@ int nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *ue, int n_frames)
                               proc,
                               i,
                               0,
-                              is*fp->samples_per_frame+ue->ssb_offset,
-                              0);
+                              is*fp->samples_per_frame+ue->ssb_offset);
 
 #ifdef DEBUG_INITIAL_SYNCH
       LOG_I(PHY,"Calling sss detection (normal CP)\n");

openair1/SCHED_NR/nr_ru_procedures.c

@@ -520,8 +520,7 @@ void nr_fep0(RU_t *ru, int first_half) {
                      ru->common.rxdataF[aa],
                      l,
                      proc->tti_rx,
-                     ru->N_TA_offset,
-                     0);
+                     ru->N_TA_offset);
     }
   }
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_RU_FEPRX+proc->tti_rx, 0);
@@ -657,8 +656,7 @@ void nr_fep_full(RU_t *ru, int slot) {
                      ru->common.rxdataF[aa],
                      l,
                      proc->tti_rx,
-                     ru->N_TA_offset,
-                     0);
+                     ru->N_TA_offset);
     }
   }
 

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -508,15 +508,12 @@ void phy_procedures_gNB_common_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx)
   unsigned char aa;
 
   for(symbol = 0; symbol < (gNB->frame_parms.Ncp==EXTENDED?12:14); symbol++) {
-    // nr_slot_fep_ul(gNB, symbol, proc->slot_rx, 0, 0);
-
     for (aa = 0; aa < gNB->frame_parms.nb_antennas_rx; aa++) {
       nr_slot_fep_ul(&gNB->frame_parms,
                      gNB->common_vars.rxdata[aa],
                      gNB->common_vars.rxdataF[aa],
                      symbol,
                      slot_rx,
-                     0,
                      0);
     }
   }

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -1689,9 +1689,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
       nr_slot_fep(ue,
                   proc,
                   (ue->symbol_offset+i)%(fp->symbols_per_slot),
-                  nr_slot_rx,
-                  0,
-                  0);
+                  nr_slot_rx);
 
 #if UE_TIMING_TRACE
       start_meas(&ue->dlsch_channel_estimation_stats);
@@ -1744,9 +1742,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
     nr_slot_fep(ue,
                 proc,
                 l,
-                nr_slot_rx,
-                0,
-                0);
+                nr_slot_rx);
 
     dci_cnt = 0;
     for(int n_ss = 0; n_ss<pdcch_vars->nb_search_space; n_ss++) {
@@ -1805,9 +1801,7 @@ int phy_procedures_nrUE_RX(PHY_VARS_NR_UE *ue,
         nr_slot_fep(ue,
                     proc,
                     m,  //to be updated from higher layer
-                    nr_slot_rx,
-                    0,
-                    0);
+                    nr_slot_rx);
       }
     }
   } else {

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -692,9 +692,7 @@ int main(int argc, char **argv)
           nr_slot_fep(UE,
                       &proc,
                       i%frame_parms->symbols_per_slot,
-                      ssb_slot,
-                      0,
-                      0);
+                      ssb_slot);
 
           nr_pbch_channel_estimation(UE,&proc,0,ssb_slot,i%frame_parms->symbols_per_slot,i-(UE->symbol_offset+1),ssb_index%8,n_hf);