diff --git a/executables/nr-gnb.c b/executables/nr-gnb.c
index 6efd26dfd7..3bd7b7a0f0 100644
--- a/executables/nr-gnb.c
+++ b/executables/nr-gnb.c
@@ -497,8 +497,7 @@ void init_gNB(int wait_for_sync) {
       RC.gNB[inst] = (PHY_VARS_gNB *) calloc(1, sizeof(PHY_VARS_gNB));
       LOG_I(PHY,"[nr-gnb.c] gNB structure RC.gNB[%d] allocated @ %p\n",inst,RC.gNB[inst]);
     }
-    gNB                     = RC.gNB[inst];
-    gNB->abstraction_flag   = 0;
+    gNB = RC.gNB[inst];
     /*nr_polar_init(&gNB->nrPolar_params,
       NR_POLAR_PBCH_MESSAGE_TYPE,
       NR_POLAR_PBCH_PAYLOAD_BITS,
diff --git a/executables/nr-softmodem.c b/executables/nr-softmodem.c
index 2378e31f3d..6f49537b3a 100644
--- a/executables/nr-softmodem.c
+++ b/executables/nr-softmodem.c
@@ -163,11 +163,6 @@ void pdcp_run(const protocol_ctxt_t *const ctxt_pP)
   abort();
 }
 
-/* see file openair2/LAYER2/MAC/main.c for why abstraction_flag is needed
- * this is very hackish - find a proper solution
- */
-uint8_t abstraction_flag=0;
-
 /* forward declarations */
 void set_default_frame_parms(nfapi_nr_config_request_scf_t *config[MAX_NUM_CCs], NR_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]);
 
diff --git a/nfapi/oai_integration/nfapi_vnf.c b/nfapi/oai_integration/nfapi_vnf.c
index c553053cd8..c742a7088a 100644
--- a/nfapi/oai_integration/nfapi_vnf.c
+++ b/nfapi/oai_integration/nfapi_vnf.c
@@ -260,9 +260,8 @@ void oai_create_gnb(void) {
   PHY_VARS_gNB *gNB = RC.gNB[0];
   RC.nb_nr_CC = (int *)malloc(sizeof(int)); // TODO: find a better function to place this in
 
-  gNB->Mod_id  = bodge_counter;
-  gNB->CC_id   = bodge_counter;
-  gNB->abstraction_flag   = 0;
+  gNB->Mod_id = bodge_counter;
+  gNB->CC_id = bodge_counter;
   RC.nb_nr_CC[bodge_counter] = 1;
 
   if (gNB->if_inst==0) {
diff --git a/openair1/PHY/INIT/nr_init.c b/openair1/PHY/INIT/nr_init.c
index 4647525a7f..d47eec2278 100644
--- a/openair1/PHY/INIT/nr_init.c
+++ b/openair1/PHY/INIT/nr_init.c
@@ -190,7 +190,6 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB)
   common_vars->debugBuff_sample_offset = 0; 
 
   // PRACH
-  prach_vars->prachF = (int16_t *)malloc16_clear( 1024*2*sizeof(int16_t) );
   prach_vars->rxsigF = (int16_t **)malloc16_clear(Prx*sizeof(int16_t*));
   prach_vars->prach_ifft       = (int32_t *)malloc16_clear(1024*2*sizeof(int32_t));
 
@@ -205,19 +204,13 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB)
   gNB->pusch_vars = (NR_gNB_PUSCH *)malloc16_clear(gNB->max_nb_pusch * sizeof(NR_gNB_PUSCH));
   for (int ULSCH_id = 0; ULSCH_id < gNB->max_nb_pusch; ULSCH_id++) {
     NR_gNB_PUSCH *pusch = &gNB->pusch_vars[ULSCH_id];
-    pusch->rxdataF_ext = (int32_t **)malloc16(Prx * sizeof(int32_t *));
     pusch->ul_ch_estimates = (int32_t **)malloc16(n_buf * sizeof(int32_t *));
-    pusch->ul_ch_estimates_ext = (int32_t **)malloc16(n_buf * sizeof(int32_t *));
     pusch->ptrs_phase_per_slot = (int32_t **)malloc16(n_buf * sizeof(int32_t *));
     pusch->ul_ch_estimates_time = (int32_t **)malloc16(n_buf * sizeof(int32_t *));
     pusch->rxdataF_comp = (int32_t **)malloc16(n_buf * sizeof(int32_t *));
     pusch->llr_layers = (int16_t **)malloc16(max_ul_mimo_layers * sizeof(int32_t *));
-    for (i = 0; i < Prx; i++) {
-      pusch->rxdataF_ext[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot);
-    }
     for (i = 0; i < n_buf; i++) {
       pusch->ul_ch_estimates[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * fp->ofdm_symbol_size * fp->symbols_per_slot);
-      pusch->ul_ch_estimates_ext[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot);
       pusch->ul_ch_estimates_time[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * fp->ofdm_symbol_size);
       pusch->ptrs_phase_per_slot[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * fp->symbols_per_slot); // symbols per slot
       pusch->rxdataF_comp[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot);
@@ -279,7 +272,6 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
   free_and_zero(common_vars->debugBuff);
 
   NR_gNB_PRACH* prach_vars = &gNB->prach_vars;
-  free_and_zero(prach_vars->prachF);
   free_and_zero(prach_vars->rxsigF);
   free_and_zero(prach_vars->prach_ifft);
 
@@ -287,20 +279,14 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
     NR_gNB_PUSCH *pusch_vars = &gNB->pusch_vars[ULSCH_id];
     for (int i=0; i< max_ul_mimo_layers; i++)
       free_and_zero(pusch_vars->llr_layers[i]);
-    for (int i = 0; i < Prx; i++) {
-      free_and_zero(pusch_vars->rxdataF_ext[i]);
-    }
     for (int i = 0; i < n_buf; i++) {
       free_and_zero(pusch_vars->ul_ch_estimates[i]);
-      free_and_zero(pusch_vars->ul_ch_estimates_ext[i]);
       free_and_zero(pusch_vars->ul_ch_estimates_time[i]);
       free_and_zero(pusch_vars->ptrs_phase_per_slot[i]);
       free_and_zero(pusch_vars->rxdataF_comp[i]);
     }
     free_and_zero(pusch_vars->llr_layers);
-    free_and_zero(pusch_vars->rxdataF_ext);
     free_and_zero(pusch_vars->ul_ch_estimates);
-    free_and_zero(pusch_vars->ul_ch_estimates_ext);
     free_and_zero(pusch_vars->ptrs_phase_per_slot);
     free_and_zero(pusch_vars->ul_ch_estimates_time);
     free_and_zero(pusch_vars->ul_valid_re_per_slot);
diff --git a/openair1/PHY/NR_TRANSPORT/nr_pbch.c b/openair1/PHY/NR_TRANSPORT/nr_pbch.c
index cfbdc2ac95..a7507c2679 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_pbch.c
+++ b/openair1/PHY/NR_TRANSPORT/nr_pbch.c
@@ -47,12 +47,13 @@ const uint8_t nr_pbch_payload_interleaving_pattern[32] = {16, 23, 18, 17, 8, 30,
                                                     9, 11, 12, 13, 14, 15, 19, 20, 21, 22, 25, 26, 27, 28, 29, 31
                                                    };
 
-int nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
-                          c16_t *txdataF,
-                          int16_t amp,
-                          uint8_t ssb_start_symbol,
-                          nfapi_nr_config_request_scf_t *config,
-                          NR_DL_FRAME_PARMS *frame_parms) {
+void nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
+                           c16_t *txdataF,
+                           int16_t amp,
+                           uint8_t ssb_start_symbol,
+                           nfapi_nr_config_request_scf_t *config,
+                           NR_DL_FRAME_PARMS *frame_parms)
+{
   int k,l;
   //int16_t a;
   int16_t mod_dmrs[NR_PBCH_DMRS_LENGTH<<1];
@@ -139,186 +140,220 @@ int nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
 #ifdef DEBUG_PBCH_DMRS
   write_output("txdataF_pbch_dmrs.m", "txdataF_pbch_dmrs", txdataF[0], frame_parms->samples_per_frame_wCP>>1, 1, 1);
 #endif
-  return 0;
 }
 
-static void nr_pbch_scrambling(NR_gNB_PBCH *pbch,
-                               uint32_t Nid,
-                               uint8_t nushift,
-                               uint16_t M,
-                               uint16_t length,
-                               uint8_t encoded,
-                               uint32_t unscrambling_mask)
-{
-  uint32_t *pbch_e = pbch->pbch_e;
-  // x1 is set in lte_gold_generic
+typedef struct {
+  int len;
+  int goldIdx;
+  int offset;
+} NR_PBCH_scramb_info_t;
 
-  const int len = (nushift * M + 31) / 32 + (length + 31) / 32;
-  uint32_t *s = gold_cache(Nid, len);
+static NR_PBCH_scramb_info_t get_scrambling_info(uint8_t nushift,
+                                                 uint16_t M,
+                                                 uint16_t length)
+{
+  NR_PBCH_scramb_info_t info;
+  info.len = (nushift * M + 31) / 32 + (length + 31) / 32;
   // The Gold sequence is shifted by nushift* M, so we skip (nushift*M /32) double words
-  int goldIdx = (nushift * M + 31) / 32 - 1;
+  info.goldIdx = (nushift * M + 31) / 32 - 1;
   // Scrambling is now done with offset (nushift*M)%32
-  uint8_t offset = (nushift * M) & 0x1f;
+  info.offset = (nushift * M) & 0x1f;
+  return info;
+}
+
+static void nr_pbch_encoded_scrambling(uint32_t *pbch_e,
+                                       uint32_t Nid,
+                                       uint8_t nushift,
+                                       uint16_t M,
+                                       uint16_t length)
+{
+  NR_PBCH_scramb_info_t info = get_scrambling_info(nushift, M, length);
+  uint32_t *s = gold_cache(Nid, info.len);
+  int goldIdx = info.goldIdx;
 #ifdef DEBUG_PBCH_ENCODING
-  printf("Scrambling params: nushift %d M %d length %d encoded %d offset %d\n", nushift, M, length, encoded, offset);
+  printf("Scrambling params: nushift %d M %d length %d offset %d\n", nushift, M, length, info.offset);
 #endif
 #ifdef DEBUG_PBCH_ENCODING
   printf("s: %04x\t", s);
 #endif
-  int k = 0;
 
-  if (!encoded) {
-    /// 1st Scrambling
-    for (int i = 0; i < length; ++i) {
-      if ((unscrambling_mask>>i)&1)
-        pbch->pbch_a_prime ^= ((pbch->pbch_a_interleaved>>i)&1)<<i;
-      else {
-        if (((k + offset) & 0x1f) == 0)
-          goldIdx++;
-        pbch->pbch_a_prime ^= (((pbch->pbch_a_interleaved >> i) & 1) ^ ((s[goldIdx] >> ((k + offset) & 0x1f)) & 1)) << i;
-        k++;                  /// k increase only when payload bit is not special bit
-      }
-    }
-  } else {
-    /// 2nd Scrambling
-    for (int i = 0; i < length; ++i) {
-      if (((i + offset) & 0x1f) == 0)
-        goldIdx++;
-      pbch_e[i >> 5] ^= (((s[goldIdx] >> ((i + offset) & 0x1f)) & 1) << (i & 0x1f));
-    }
+  for (int i = 0; i < length; ++i) {
+    if (((i + info.offset) & 0x1f) == 0)
+      goldIdx++;
+    pbch_e[i >> 5] ^= (((s[goldIdx] >> ((i + info.offset) & 0x1f)) & 1) << (i & 0x1f));
   }
 }
 
-void nr_init_pbch_interleaver(uint8_t *interleaver) {
-  uint8_t j_sfn=0, j_hrf=10, j_ssb=11, j_other=14;
-  memset((void *)interleaver,0, NR_POLAR_PBCH_PAYLOAD_BITS);
-
-  for (uint8_t i=0; i<NR_POLAR_PBCH_PAYLOAD_BITS; i++)
-    if (!i) // choice bit:1
-      *(interleaver+i) = *(nr_pbch_payload_interleaving_pattern+j_other++);
-    else if (i<7) //Sfn bits:6
-      *(interleaver+i) = *(nr_pbch_payload_interleaving_pattern+j_sfn++);
-    else if (i<24) // other:17
-      *(interleaver+i) = *(nr_pbch_payload_interleaving_pattern+j_other++);
-    else if (i<28) // Sfn:4
-      *(interleaver+i) = *(nr_pbch_payload_interleaving_pattern+j_sfn++);
-    else if (i==28) // Hrf bit:1
-      *(interleaver+i) = *(nr_pbch_payload_interleaving_pattern+j_hrf);
-    else // Ssb bits:3
-      *(interleaver+i) = *(nr_pbch_payload_interleaving_pattern+j_ssb++);
+static uint32_t nr_pbch_scrambling(uint32_t pbch_a_interleaved,
+                                   uint32_t Nid,
+                                   uint8_t nushift,
+                                   uint16_t M,
+                                   uint16_t length,
+                                   uint32_t unscrambling_mask)
+{
+  uint32_t pbch_a_prime = 0;
+  int k = 0;
+  NR_PBCH_scramb_info_t info = get_scrambling_info(nushift, M, length);
+  uint32_t *s = gold_cache(Nid, info.len);
+#ifdef DEBUG_PBCH_ENCODING
+  printf("Scrambling params: nushift %d M %d length %d offset %d\n", nushift, M, length, info.offset);
+#endif
+#ifdef DEBUG_PBCH_ENCODING
+  printf("s: %04x\t", s);
+#endif
+  int goldIdx = info.goldIdx;
+  for (int i = 0; i < length; ++i) {
+    if ((unscrambling_mask >> i) & 1)
+      pbch_a_prime ^= ((pbch_a_interleaved >> i) & 1) << i;
+    else {
+      if (((k + info.offset) & 0x1f) == 0)
+        goldIdx++;
+      pbch_a_prime ^= (((pbch_a_interleaved >> i) & 1) ^ ((s[goldIdx] >> ((k + info.offset) & 0x1f)) & 1)) << i;
+      k++; /// k increase only when payload bit is not special bit
+    }
+  }
+  return pbch_a_prime;
 }
 
-int nr_generate_pbch(nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,
-                     uint8_t *interleaver,
-                     c16_t *txdataF,
-                     int16_t amp,
-                     uint8_t ssb_start_symbol,
-                     uint8_t n_hf,
-                     int sfn,
-                     nfapi_nr_config_request_scf_t *config,
-                     NR_DL_FRAME_PARMS *frame_parms) {
-  int k,l,m;
-  //int16_t a;
-  int16_t mod_pbch_e[NR_POLAR_PBCH_E];
-  uint8_t idx=0;
-  uint16_t M;
-  uint8_t nushift;
-  uint32_t unscrambling_mask;
+void nr_init_pbch_interleaver(uint8_t *interleaver)
+{
+  uint8_t j_sfn = 0, j_hrf = 10, j_ssb = 11, j_other = 14;
+  memset((void *)interleaver,0, NR_POLAR_PBCH_PAYLOAD_BITS);
+
+  for (int i = 0; i < NR_POLAR_PBCH_PAYLOAD_BITS; i++)
+    if (!i) // choice bit:1
+      *(interleaver + i) = *(nr_pbch_payload_interleaving_pattern + j_other++);
+    else if (i < 7) //Sfn bits:6
+      *(interleaver + i) = *(nr_pbch_payload_interleaving_pattern + j_sfn++);
+    else if (i < 24) // other:17
+      *(interleaver + i) = *(nr_pbch_payload_interleaving_pattern + j_other++);
+    else if (i < 28) // Sfn:4
+      *(interleaver + i) = *(nr_pbch_payload_interleaving_pattern + j_sfn++);
+    else if (i == 28) // Hrf bit:1
+      *(interleaver + i) = *(nr_pbch_payload_interleaving_pattern + j_hrf);
+    else // Ssb bits:3
+      *(interleaver + i) = *(nr_pbch_payload_interleaving_pattern + j_ssb++);
+}
+
+uint32_t nr_pbch_extra_byte_generation(int sfn, int n_hf, int ssb_index, int ssb_sc_offset, int Lmax)
+{
+  uint32_t extra_byte = 0;
+  // Extra byte generation
+  for (int i = 0; i < 4; i++)
+    extra_byte |= ((sfn >> (3 - i)) & 1) << i; // resp. 4th, 3rd, 2nd ans 1st lsb of sfn
+
+  extra_byte |= n_hf << 4; // half frame index bit
+
+  if (Lmax == 64)
+    for (int i = 0; i < 3; i++)
+      extra_byte |= (uint32_t)((ssb_index >> (5 - i)) & 1) << (5 + i); // resp. 6th, 5th and 4th bits of ssb_index
+  else
+    extra_byte |= ((ssb_sc_offset >> 4) & 1) << 5; //MSB of k_SSB (bit index 4)
+  return extra_byte;
+}
+
+void nr_generate_pbch(PHY_VARS_gNB *gNB,
+                      const nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,
+                      c16_t *txdataF,
+                      uint8_t ssb_start_symbol,
+                      uint8_t n_hf,
+                      int sfn,
+                      nfapi_nr_config_request_scf_t *config,
+                      NR_DL_FRAME_PARMS *frame_parms)
+{
   LOG_D(PHY, "PBCH generation started\n");
   ///Payload generation
-  NR_gNB_PBCH m_pbch;
-  NR_gNB_PBCH *pbch = &m_pbch;
-  memset((void *)pbch, 0, sizeof(NR_gNB_PBCH));
-  pbch->pbch_a=0;
   uint8_t ssb_index = ssb_pdu->ssb_pdu_rel15.SsbBlockIndex;
-  uint8_t *pbch_pdu = (uint8_t*)&ssb_pdu->ssb_pdu_rel15.bchPayload;
+  const uint8_t *pbch_pdu = (const uint8_t*)&ssb_pdu->ssb_pdu_rel15.bchPayload;
   uint8_t Lmax = frame_parms->Lmax;
-  for (int i=0; i<NR_PBCH_PDU_BITS; i++)
-    pbch->pbch_a |= ((pbch_pdu[i>>3]>>(7-(i&7)))&1)<<i;
+  uint32_t pbch_a = 0;
+  for (int i = 0; i < NR_PBCH_PDU_BITS; i++)
+    pbch_a |= ((pbch_pdu[i >> 3] >> (7 - (i & 7))) & 1) << i;
 
   // NSA to signal no coreset0
   const int ssb_sc_offset = get_softmodem_params()->sa ? config->ssb_table.ssb_subcarrier_offset.value : 31;
 
   #ifdef DEBUG_PBCH_ENCODING
-  for (int i=0; i<3; i++)
+  for (int i = 0; i < 3; i++)
     printf("pbch_pdu[%d]: 0x%02x\n", i, pbch_pdu[i]);
-
-  printf("PBCH payload = 0x%08x\n",pbch->pbch_a);
+  printf("PBCH payload = 0x%08x\n", pbch_a);
   #endif
 
-  // Extra byte generation
-  for (int i=0; i<4; i++)
-    pbch->pbch_a |= ((sfn>>(3-i))&1)<<(24+i); // resp. 4th, 3rd, 2nd ans 1st lsb of sfn
-
-  pbch->pbch_a |= n_hf<<28; // half frame index bit
-
-  if (Lmax == 64)
-    for (int i = 0; i < 3; i++)
-      pbch->pbch_a |= (uint32_t)((ssb_index >> (5 - i)) & 1) << (29 + i); // resp. 6th, 5th and 4th bits of ssb_index
-  else
-    pbch->pbch_a |= ((ssb_sc_offset >> 4) & 1) << 29; //MSB of k_SSB (bit index 4)
-
-  LOG_D(PHY,"After extra byte: pbch_a = 0x%08x\n",pbch->pbch_a);
+  uint32_t extra_byte = nr_pbch_extra_byte_generation(sfn, n_hf, ssb_index, ssb_sc_offset, Lmax);
+  pbch_a |= extra_byte << 24;
+  LOG_D(PHY,"After extra byte: pbch_a = 0x%08x\n", pbch_a);
 
   // Payload interleaving
-
-  for (int i=0; i<NR_POLAR_PBCH_PAYLOAD_BITS; i++) {
-    pbch->pbch_a_interleaved |= ((pbch->pbch_a>>i)&1)<<(*(interleaver+i));
+  uint32_t pbch_a_interleaved = 0;
+  uint8_t *interleaver = gNB->nr_pbch_interleaver;
+  for (int i = 0; i < NR_POLAR_PBCH_PAYLOAD_BITS; i++) {
+    pbch_a_interleaved |= ((pbch_a >> i) & 1) << (*(interleaver + i));
 #ifdef DEBUG_PBCH_ENCODING
-    printf("i %d out 0x%08x ilv %d (in>>i)&1) %d\n", i, pbch->pbch_a_interleaved, *(interleaver+i), (pbch->pbch_a>>i)&1);
+    printf("i %d out 0x%08x ilv %d (in>>i)&1) %d\n", i, pbch_a_interleaved, *(interleaver+i), (pbch_a >> i) & 1);
 #endif
   }
 
 #ifdef DEBUG_PBCH_ENCODING
   printf("Interleaving:\n");
-  printf("pbch_a_interleaved: 0x%08x\n", pbch->pbch_a_interleaved);
+  printf("pbch_a_interleaved: 0x%08x\n", pbch_a_interleaved);
 #endif
   // Scrambling
-  unscrambling_mask = (Lmax ==64)? 0x100006D:0x1000041;
-  M = (Lmax == 64)? (NR_POLAR_PBCH_PAYLOAD_BITS - 6) : (NR_POLAR_PBCH_PAYLOAD_BITS - 3);
-  nushift = (((sfn>>2)&1)<<1) ^ ((sfn>>1)&1);
-  pbch->pbch_a_prime = 0;
-  nr_pbch_scrambling(pbch, (uint32_t)config->cell_config.phy_cell_id.value, nushift, M, NR_POLAR_PBCH_PAYLOAD_BITS, 0, unscrambling_mask);
+  uint32_t unscrambling_mask = (Lmax == 64) ? 0x100006D : 0x1000041;
+  uint16_t M = (Lmax == 64)? (NR_POLAR_PBCH_PAYLOAD_BITS - 6) : (NR_POLAR_PBCH_PAYLOAD_BITS - 3);
+  uint8_t nushift = (((sfn >> 2) & 1) << 1) ^ ((sfn >> 1) & 1);
+  uint32_t pbch_a_prime = nr_pbch_scrambling(pbch_a_interleaved,
+                                             (uint32_t)config->cell_config.phy_cell_id.value,
+                                             nushift,
+                                             M,
+                                             NR_POLAR_PBCH_PAYLOAD_BITS,
+                                             unscrambling_mask);
 #ifdef DEBUG_PBCH_ENCODING
-  printf("Payload scrambling: nushift %d M %d sfn3 %d sfn2 %d\n", nushift, M, (sfn>>2)&1, (sfn>>1)&1);
-  printf("pbch_a_prime: 0x%08x\n", pbch->pbch_a_prime);
+  printf("Payload scrambling: nushift %d M %d sfn3 %d sfn2 %d\n", nushift, M, (sfn >> 2) & 1, (sfn >> 1) & 1);
+  printf("pbch_a_prime: 0x%08x\n", pbch_a_prime);
 #endif
 
   // Encoder reversal
-  uint64_t a_reversed = reverse_bits((uint64_t)pbch->pbch_a_prime, NR_POLAR_PBCH_PAYLOAD_BITS);
-
+  uint64_t a_reversed = reverse_bits((uint64_t)pbch_a_prime, NR_POLAR_PBCH_PAYLOAD_BITS);
+  uint32_t pbch_e[NR_POLAR_PBCH_E_DWORD];
   /// CRC, coding and rate matching
-  polar_encoder_fast (&a_reversed, (void*)pbch->pbch_e, 0, 0,
-                      NR_POLAR_PBCH_MESSAGE_TYPE, NR_POLAR_PBCH_PAYLOAD_BITS, NR_POLAR_PBCH_AGGREGATION_LEVEL);
+  polar_encoder_fast(&a_reversed,
+                     pbch_e,
+                     0,
+                     0,
+                     NR_POLAR_PBCH_MESSAGE_TYPE,
+                     NR_POLAR_PBCH_PAYLOAD_BITS,
+                     NR_POLAR_PBCH_AGGREGATION_LEVEL);
 
 #ifdef DEBUG_PBCH_ENCODING
   printf("Channel coding:\n");
-
-  for (int i=0; i<NR_POLAR_PBCH_E_DWORD; i++)
-    printf("pbch_e[%d]: 0x%08x\t", i, pbch->pbch_e[i]);
-
+  for (int i = 0; i < NR_POLAR_PBCH_E_DWORD; i++)
+    printf("pbch_e[%d]: 0x%08x\t", i, pbch_e[i]);
   printf("\n");
 #endif
   /// Scrambling
-  M =  NR_POLAR_PBCH_E;
-  nushift = (Lmax==4)? ssb_index&3 : ssb_index&7;
-  nr_pbch_scrambling(pbch, (uint32_t)config->cell_config.phy_cell_id.value, nushift, M, NR_POLAR_PBCH_E, 1, 0);
+  M = NR_POLAR_PBCH_E;
+  nushift = (Lmax == 4) ? ssb_index & 3 : ssb_index & 7;
+  nr_pbch_encoded_scrambling(pbch_e,
+                             (uint32_t)config->cell_config.phy_cell_id.value,
+                             nushift,
+                             M,
+                             NR_POLAR_PBCH_E);
 #ifdef DEBUG_PBCH_ENCODING
   printf("Scrambling:\n");
-
-  for (int i=0; i<NR_POLAR_PBCH_E_DWORD; i++)
-    printf("pbch_e[%d]: 0x%08x\t", i, pbch->pbch_e[i]);
+  for (int i = 0; i < NR_POLAR_PBCH_E_DWORD; i++)
+    printf("pbch_e[%d]: 0x%08x\t", i, pbch_e[i]);
 
   printf("\n");
 #endif
 
+  int16_t mod_pbch_e[NR_POLAR_PBCH_E];
   /// QPSK modulation
   for (int i=0; i<NR_POLAR_PBCH_E>>1; i++) {
-    idx = ((pbch->pbch_e[(i<<1)>>5]>>((i<<1)&0x1f))&3);
-    mod_pbch_e[i<<1] = nr_qpsk_mod_table[idx<<1];
-    mod_pbch_e[(i<<1)+1] = nr_qpsk_mod_table[(idx<<1)+1];
+    int idx = ((pbch_e[(i << 1) >> 5] >> ((i << 1) & 0x1f)) & 3);
+    mod_pbch_e[i<<1] = nr_qpsk_mod_table[idx << 1];
+    mod_pbch_e[(i<<1)+1] = nr_qpsk_mod_table[(idx << 1) + 1];
 #ifdef DEBUG_PBCH
-    printf("i %d idx %d  mod_pbch %d %d\n", i, idx, mod_pbch_e[2*i], mod_pbch_e[2*i+1]);
+    printf("i %d idx %d  mod_pbch %d %d\n", i, idx, mod_pbch_e[2 * i], mod_pbch_e[2 * i + 1]);
 #endif
   }
 
@@ -326,9 +361,10 @@ int nr_generate_pbch(nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,
   nushift = config->cell_config.phy_cell_id.value &3;
   // PBCH modulated symbols are mapped  within the SSB block on symbols 1, 2, 3 excluding the subcarriers used for the PBCH DMRS
   ///symbol 1  [0:239] -- 180 mod symbols
-  k = frame_parms->first_carrier_offset + frame_parms->ssb_start_subcarrier;
-  l = ssb_start_symbol + 1;
-  m = 0;
+  int k = frame_parms->first_carrier_offset + frame_parms->ssb_start_subcarrier;
+  int l = ssb_start_symbol + 1;
+  int m = 0;
+  int16_t amp = gNB->TX_AMP;
 
   for (int ssb_sc_idx = 0; ssb_sc_idx < 240; ssb_sc_idx++) {
     if ((ssb_sc_idx&3) == nushift) {  //skip DMRS
@@ -419,7 +455,4 @@ int nr_generate_pbch(nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,
     if (k >= frame_parms->ofdm_symbol_size)
       k-=frame_parms->ofdm_symbol_size;
   }
-
-
-  return 0;
 }
diff --git a/openair1/PHY/NR_TRANSPORT/nr_prach.c b/openair1/PHY/NR_TRANSPORT/nr_prach.c
index c9f645333b..40c358477f 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_prach.c
+++ b/openair1/PHY/NR_TRANSPORT/nr_prach.c
@@ -432,21 +432,17 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
                  uint16_t *max_preamble_energy,
                  uint16_t *max_preamble_delay)
 {
-  AssertFatal(gNB!=NULL,"Can only be called from gNB\n");
-
-  int i;
-
-  nfapi_nr_prach_config_t *cfg=&gNB->gNB_config.prach_config;
+  AssertFatal(gNB != NULL, "Can only be called from gNB\n");
+  nfapi_nr_prach_config_t *cfg = &gNB->gNB_config.prach_config;
   NR_DL_FRAME_PARMS *fp;
 
-  uint16_t           rootSequenceIndex;  
-  int                numrootSequenceIndex;
-  uint8_t            restricted_set;      
-  uint8_t            n_ra_prb=0xFF;
-  int16_t            *prachF=NULL;
-  int                nb_rx;
+  uint16_t rootSequenceIndex;
+  int numrootSequenceIndex;
+  uint8_t restricted_set;
+  uint8_t n_ra_prb=0xFF;
+  int nb_rx;
 
-  int16_t **rxsigF            = gNB->prach_vars.rxsigF;
+  int16_t **rxsigF = gNB->prach_vars.rxsigF;
 
   uint8_t preamble_index;
   uint16_t NCS=99,NCS2;
@@ -460,10 +456,8 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
   uint8_t not_found;
   uint16_t u;
   int16_t *Xu=0;
-  uint16_t offset;
   uint16_t first_nonzero_root_idx=0;
   uint8_t new_dft=0;
-  uint8_t aa;
   int32_t lev;
   int16_t levdB;
   int log2_ifft_size=10;
@@ -473,23 +467,22 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
   fp = &gNB->frame_parms;
 
   nb_rx = gNB->gNB_config.carrier_config.num_rx_ant.value;
-  rootSequenceIndex   = cfg->num_prach_fd_occasions_list[prach_pdu->num_ra].prach_root_sequence_index.value;
-  numrootSequenceIndex   = cfg->num_prach_fd_occasions_list[prach_pdu->num_ra].num_root_sequences.value;
-  NCS          = prach_pdu->num_cs;//cfg->num_prach_fd_occasions_list[0].prach_zero_corr_conf.value;
+  rootSequenceIndex = cfg->num_prach_fd_occasions_list[prach_pdu->num_ra].prach_root_sequence_index.value;
+  numrootSequenceIndex = cfg->num_prach_fd_occasions_list[prach_pdu->num_ra].num_root_sequences.value;
+  NCS = prach_pdu->num_cs;//cfg->num_prach_fd_occasions_list[0].prach_zero_corr_conf.value;
   int prach_sequence_length = cfg->prach_sequence_length.value;
-  int msg1_frequencystart   = cfg->num_prach_fd_occasions_list[prach_pdu->num_ra].k1.value;
+  int msg1_frequencystart = cfg->num_prach_fd_occasions_list[prach_pdu->num_ra].k1.value;
   //  int num_unused_root_sequences = cfg->num_prach_fd_occasions_list[0].num_unused_root_sequences.value;
   // cfg->num_prach_fd_occasions_list[0].unused_root_sequences_list
 
-  restricted_set      = cfg->restricted_set_config.value;
+  restricted_set = cfg->restricted_set_config.value;
 
   uint8_t prach_fmt = prach_pdu->prach_format;
   uint16_t N_ZC = (prach_sequence_length==0)?839:139;
 
   LOG_D(PHY,"L1 PRACH RX: rooSequenceIndex %d, numRootSeqeuences %d, NCS %d, N_ZC %d, format %d \n",rootSequenceIndex,numrootSequenceIndex,NCS,N_ZC,prach_fmt);
 
-  prach_ifft        = gNB->prach_vars.prach_ifft;
-  prachF            = gNB->prach_vars.prachF;
+  prach_ifft = gNB->prach_vars.prach_ifft;
   if (LOG_DEBUGFLAG(PRACH)){
     if ((frame&1023) < 20) LOG_D(PHY,"PRACH (gNB) : running rx_prach for slot %d, msg1_frequencystart %d, rootSequenceIndex %d\n", slot, msg1_frequencystart, rootSequenceIndex);
   }
@@ -508,10 +501,10 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
   preamble_offset_old = 99;
 
   
-  *max_preamble_energy=0;
-  *max_preamble_delay=0;
-  *max_preamble=0;
-
+  *max_preamble_energy = 0;
+  *max_preamble_delay = 0;
+  *max_preamble = 0;
+  int16_t prachF[2 * 1024];
   for (preamble_index=0 ; preamble_index<64 ; preamble_index++) {
 
     if (LOG_DEBUGFLAG(PRACH)){
@@ -521,14 +514,14 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
     if (restricted_set == 0) {
       // This is the relative offset in the root sequence table (5.7.2-4 from 36.211) for the given preamble index
       preamble_offset = ((NCS==0)? preamble_index : (preamble_index/(N_ZC/NCS)));
-   
+
       if (preamble_offset != preamble_offset_old) {
         preamble_offset_old = preamble_offset;
         new_dft = 1;
         // This is the \nu corresponding to the preamble index
         preamble_shift  = 0;
       }
-      
+
       else {
         preamble_shift  -= NCS;
 
@@ -551,33 +544,32 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
           // current root depending on rootSequenceIndex
           int index = (rootSequenceIndex + preamble_offset) % N_ZC;
 
-	  u = prach_root_sequence_map[index];
+          u = prach_root_sequence_map[index];
 	  
-	  uint16_t n_group_ra = 0;
+          uint16_t n_group_ra = 0;
 	  
-	  if ( (nr_du[u]<(N_ZC/3)) && (nr_du[u]>=NCS) ) {
-	    n_shift_ra     = nr_du[u]/NCS;
-	    d_start        = (nr_du[u]<<1) + (n_shift_ra * NCS);
-	    n_group_ra     = N_ZC/d_start;
-	    n_shift_ra_bar = max(0,(N_ZC-(nr_du[u]<<1)-(n_group_ra*d_start))/N_ZC);
-	  } else if  ( (nr_du[u]>=(N_ZC/3)) && (nr_du[u]<=((N_ZC - NCS)>>1)) ) {
-	    n_shift_ra     = (N_ZC - (nr_du[u]<<1))/NCS;
-	    d_start        = N_ZC - (nr_du[u]<<1) + (n_shift_ra * NCS);
-	    n_group_ra     = nr_du[u]/d_start;
-	    n_shift_ra_bar = min(n_shift_ra,max(0,(nr_du[u]- (n_group_ra*d_start))/NCS));
-	  } else {
-	    n_shift_ra     = 0;
-	    n_shift_ra_bar = 0;
-	  }
-	  
-	  // This is the number of cyclic shifts for the current root u
-	  numshift = (n_shift_ra*n_group_ra) + n_shift_ra_bar;
-	  // skip to next root and recompute parameters if numshift==0
-	  (numshift>0) ? (not_found = 0) : (preamble_offset++);
-	}
-      }        
-      
-      
+          if ((nr_du[u] < (N_ZC / 3)) && (nr_du[u] >= NCS) ) {
+            n_shift_ra = nr_du[u] / NCS;
+            d_start = (nr_du[u] << 1) + (n_shift_ra * NCS);
+            n_group_ra = N_ZC / d_start;
+            n_shift_ra_bar = max(0, (N_ZC-(nr_du[u] << 1) - (n_group_ra * d_start)) / N_ZC);
+          } else if  ((nr_du[u] >= (N_ZC / 3)) && (nr_du[u] <= ((N_ZC - NCS) >> 1))) {
+            n_shift_ra = (N_ZC - (nr_du[u] << 1)) / NCS;
+            d_start = N_ZC - (nr_du[u] << 1) + (n_shift_ra * NCS);
+            n_group_ra = nr_du[u] / d_start;
+            n_shift_ra_bar = min(n_shift_ra, max(0, (nr_du[u]- (n_group_ra * d_start)) / NCS));
+          } else {
+            n_shift_ra = 0;
+            n_shift_ra_bar = 0;
+          }
+
+          // This is the number of cyclic shifts for the current root u
+          numshift = (n_shift_ra * n_group_ra) + n_shift_ra_bar;
+          // skip to next root and recompute parameters if numshift==0
+          (numshift>0) ? (not_found = 0) : (preamble_offset++);
+        }
+      }
+
       if (n_shift_ra>0)
         preamble_shift = -((d_start * (preamble_index0/n_shift_ra)) + ((preamble_index0%n_shift_ra)*NCS)); // minus because the channel is h(t -\tau + Cv)
       else
@@ -595,8 +587,17 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
     // Compute DFT of RX signal (conjugate input, results in conjugate output) for each new rootSequenceIndex
     if (LOG_DEBUGFLAG(PRACH)) {
       int en = dB_fixed(signal_energy((int32_t*)&rxsigF[0][0],840));
-      if (en>60) LOG_D(PHY,"frame %d, slot %d : preamble index %d, NCS %d, N_ZC/NCS %d: offset %d, preamble shift %d , en %d)\n",
-		       frame,slot,preamble_index,NCS,N_ZC/NCS,preamble_offset,preamble_shift,en);
+      if (en>60)
+        LOG_D(PHY,
+              "frame %d, slot %d : preamble index %d, NCS %d, N_ZC/NCS %d: offset %d, preamble shift %d , en %d)\n",
+              frame,
+              slot,
+              preamble_index,
+              NCS,
+              N_ZC / NCS,
+              preamble_offset,
+              preamble_shift,
+              en);
     }
 
     LOG_D(PHY,"PRACH RX preamble_index %d, preamble_offset %d\n",preamble_index,preamble_offset);
@@ -605,57 +606,56 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
     if (new_dft == 1) {
       new_dft = 0;
 
-      Xu=(int16_t*)gNB->X_u[preamble_offset-first_nonzero_root_idx];
+      Xu = (int16_t*)gNB->X_u[preamble_offset-first_nonzero_root_idx];
 
       LOG_D(PHY,"PRACH RX new dft preamble_offset-first_nonzero_root_idx %d\n",preamble_offset-first_nonzero_root_idx);
 
-
       memset(prach_ifft,0,((N_ZC==839) ? 2048 : 256)*sizeof(int32_t));
-    
-
-      memset(prachF, 0, sizeof(int16_t)*2*1024 );
-      if (LOG_DUMPFLAG(PRACH)) {      
+      memset(prachF, 0, sizeof(int16_t) * 2 * 1024);
+      if (LOG_DUMPFLAG(PRACH)) {
         LOG_M("prach_rxF0.m","prach_rxF0",rxsigF[0],N_ZC,1,1);
         LOG_M("prach_rxF1.m","prach_rxF1",rxsigF[1],6144,1,1);
       }
    
-      for (aa=0;aa<nb_rx; aa++) {
+      for (int aa = 0; aa < nb_rx; aa++) {
 	// Do componentwise product with Xu* on each antenna 
 
-	       for (offset=0; offset<(N_ZC<<1); offset+=2) {
-	          prachF[offset]   = (int16_t)(((int32_t)Xu[offset]*rxsigF[aa][offset]   + (int32_t)Xu[offset+1]*rxsigF[aa][offset+1])>>15);
-	          prachF[offset+1] = (int16_t)(((int32_t)Xu[offset]*rxsigF[aa][offset+1] - (int32_t)Xu[offset+1]*rxsigF[aa][offset])>>15);
-	       }
+        for (int offset = 0; offset < (N_ZC << 1); offset += 2) {
+          prachF[offset] = (int16_t)(((int32_t)Xu[offset]*rxsigF[aa][offset] + (int32_t)Xu[offset+1]*rxsigF[aa][offset+1])>>15);
+          prachF[offset+1] = (int16_t)(((int32_t)Xu[offset]*rxsigF[aa][offset+1] - (int32_t)Xu[offset+1]*rxsigF[aa][offset])>>15);
+        }
 	
-	       // Now do IFFT of size 1024 (N_ZC=839) or 256 (N_ZC=139)
-	       if (N_ZC == 839) {
-	         idft(IDFT_1024,prachF,prach_ifft_tmp,1);
-	         // compute energy and accumulate over receive antennas
-	         for (i=0;i<1024;i++)
-	           prach_ifft[i] += (int32_t)prach_ifft_tmp[i<<1]*(int32_t)prach_ifft_tmp[i<<1] + (int32_t)prach_ifft_tmp[1+(i<<1)]*(int32_t)prach_ifft_tmp[1+(i<<1)];
-	       } else {
-	         idft(IDFT_256,prachF,prach_ifft_tmp,1);
-	         log2_ifft_size = 8;
-           // compute energy and accumulate over receive antennas and repetitions for BR
-           for (i=0;i<256;i++)
-             prach_ifft[i] += (int32_t)prach_ifft_tmp[i<<1]*(int32_t)prach_ifft_tmp[(i<<1)] + (int32_t)prach_ifft_tmp[1+(i<<1)]*(int32_t)prach_ifft_tmp[1+(i<<1)];
-         }
-
-        if (LOG_DUMPFLAG(PRACH)) {
-          if (aa==0) LOG_M("prach_rxF_comp0.m","prach_rxF_comp0",prachF,1024,1,1);
-          if (aa==1) LOG_M("prach_rxF_comp1.m","prach_rxF_comp1",prachF,1024,1,1);
+        // Now do IFFT of size 1024 (N_ZC=839) or 256 (N_ZC=139)
+        if (N_ZC == 839) {
+          idft(IDFT_1024, prachF, prach_ifft_tmp, 1);
+          // compute energy and accumulate over receive antennas
+          for (int i = 0; i < 1024; i++)
+            prach_ifft[i] += (int32_t)prach_ifft_tmp[i<<1]*(int32_t)prach_ifft_tmp[i<<1] + (int32_t)prach_ifft_tmp[1+(i<<1)]*(int32_t)prach_ifft_tmp[1+(i<<1)];
+        } else {
+          idft(IDFT_256, prachF, prach_ifft_tmp, 1);
+          log2_ifft_size = 8;
+          // compute energy and accumulate over receive antennas and repetitions for BR
+          for (int i = 0; i < 256; i++)
+            prach_ifft[i] += (int32_t)prach_ifft_tmp[i<<1]*(int32_t)prach_ifft_tmp[(i<<1)] + (int32_t)prach_ifft_tmp[1+(i<<1)]*(int32_t)prach_ifft_tmp[1+(i<<1)];
         }
 
-      }// antennas_rx
+        if (LOG_DUMPFLAG(PRACH)) {
+          if (aa == 0)
+            LOG_M("prach_rxF_comp0.m","prach_rxF_comp0", prachF, 1024, 1, 1);
+          if (aa == 1)
+            LOG_M("prach_rxF_comp1.m","prach_rxF_comp1", prachF, 1024, 1, 1);
+        }
+
+      } // antennas_rx
 
       // Normalization of energy over ifft and receive antennas
       if (N_ZC == 839) {
         log2_ifft_size = 10;
-        for (i=0;i<1024;i++)
+        for (int i = 0; i < 1024; i++)
           prach_ifft[i] = (prach_ifft[i]>>log2_ifft_size)/nb_rx;
       } else {
         log2_ifft_size = 8;
-        for (i=0;i<256;i++)
+        for (int i = 0; i < 256; i++)
           prach_ifft[i] = (prach_ifft[i]>>log2_ifft_size)/nb_rx;
       }
 
@@ -665,14 +665,14 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
 
     preamble_shift2 = ((preamble_shift==0) ? 0 : ((preamble_shift<<log2_ifft_size)/N_ZC));
 
-    for (i=0; i<NCS2; i++) {
+    for (int i = 0; i < NCS2; i++) {
       lev = (int32_t)prach_ifft[(preamble_shift2+i)];
       levdB = dB_fixed_times10(lev);
       if (levdB>*max_preamble_energy) {
         LOG_D(PHY,"preamble_index %d, delay %d en %d dB > %d dB\n",preamble_index,i,levdB,*max_preamble_energy);
-        *max_preamble_energy  = levdB;
-        *max_preamble_delay   = i; // Note: This has to be normalized to the 30.72 Ms/s sampling rate
-        *max_preamble         = preamble_index;
+        *max_preamble_energy = levdB;
+        *max_preamble_delay = i; // Note: This has to be normalized to the 30.72 Ms/s sampling rate
+        *max_preamble = preamble_index;
       }
     }
   }// preamble_index
@@ -695,9 +695,11 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
   // max_preamble_delay * ( (2048/2^mu*(fs/30.72M)) / 256 ) / fs = TA * 16 * 64 / 2^mu * Tc
   uint16_t *TA = max_preamble_delay;
   int mu = fp->numerology_index;
-  if (cfg->prach_sequence_length.value==0) {
-    if (prach_fmt == 0 || prach_fmt == 1 || prach_fmt == 2) *TA = *TA*3*(1<<mu)/2;
-    else if (prach_fmt == 3)                                *TA = *TA*3*(1<<mu)/8;
+  if (cfg->prach_sequence_length.value == 0) {
+    if (prach_fmt == 0 || prach_fmt == 1 || prach_fmt == 2)
+      *TA = *TA * 3 * (1 << mu) / 2;
+    else if (prach_fmt == 3)
+      *TA = *TA * 3 * (1 << mu) / 8;
   }
   else *TA = *TA/2;
 
@@ -705,19 +707,18 @@ void rx_nr_prach(PHY_VARS_gNB *gNB,
   if (LOG_DUMPFLAG(PRACH)) {
     //int en = dB_fixed(signal_energy((int32_t*)&rxsigF[0][0],840));
     //    if (en>60) {
-      int k = (12*n_ra_prb) - 6*fp->N_RB_UL;
-      
-      if (k<0) k+=fp->ofdm_symbol_size;
-      
+      int k = (12 * n_ra_prb) - 6 * fp->N_RB_UL;
+      if (k < 0)
+        k += fp->ofdm_symbol_size;
+
       k*=12;
       k+=13;
       k*=2;
-      
 
-      LOG_M("rxsigF.m","prach_rxF",&rxsigF[0][0],12288,1,1);
-      LOG_M("prach_rxF_comp0.m","prach_rxF_comp0",prachF,1024,1,1);
-      LOG_M("Xu.m","xu",Xu,N_ZC,1,1);
-      LOG_M("prach_ifft0.m","prach_t0",prach_ifft,1024,1,1);
+      LOG_M("rxsigF.m","prach_rxF", &rxsigF[0][0], 12288, 1, 1);
+      LOG_M("prach_rxF_comp0.m","prach_rxF_comp0", prachF, 1024, 1, 1);
+      LOG_M("Xu.m","xu", Xu, N_ZC, 1, 1);
+      LOG_M("prach_ifft0.m","prach_t0", prach_ifft, 1024, 1, 1);
       //    }
   } /* LOG_DUMPFLAG(PRACH) */
   stop_meas(&gNB->rx_prach);
diff --git a/openair1/PHY/NR_TRANSPORT/nr_transport_proto.h b/openair1/PHY/NR_TRANSPORT/nr_transport_proto.h
index a8b9e8ebf6..a086c347ef 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_transport_proto.h
+++ b/openair1/PHY/NR_TRANSPORT/nr_transport_proto.h
@@ -72,33 +72,30 @@ int nr_generate_sss(c16_t *txdataF,
                     NR_DL_FRAME_PARMS *frame_parms);
 
 /*!
-\fn int nr_generate_pbch_dmrs
+\fn void nr_generate_pbch_dmrs
 \brief Generation of the DMRS for the PBCH
 @param
-@returns 0 on success
  */
-int nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
-                          c16_t *txdataF,
-                          int16_t amp,
-                          uint8_t ssb_start_symbol,
-                          nfapi_nr_config_request_scf_t *config,
-                          NR_DL_FRAME_PARMS *frame_parms);
+void nr_generate_pbch_dmrs(uint32_t *gold_pbch_dmrs,
+                           c16_t *txdataF,
+                           int16_t amp,
+                           uint8_t ssb_start_symbol,
+                           nfapi_nr_config_request_scf_t *config,
+                           NR_DL_FRAME_PARMS *frame_parms);
 
 /*!
-\fn int nr_generate_pbch
+\fn void nr_generate_pbch
 \brief Generation of the PBCH
 @param
-@returns 0 on success
  */
-int nr_generate_pbch(nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,
-                     uint8_t *interleaver,
-                     c16_t *txdataF,
-                     int16_t amp,
-                     uint8_t ssb_start_symbol,
-                     uint8_t n_hf,
-                     int sfn,
-                     nfapi_nr_config_request_scf_t *config,
-                     NR_DL_FRAME_PARMS *frame_parms);
+void nr_generate_pbch(PHY_VARS_gNB *gNB,
+                      const nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,
+                      c16_t *txdataF,
+                      uint8_t ssb_start_symbol,
+                      uint8_t n_hf,
+                      int sfn,
+                      nfapi_nr_config_request_scf_t *config,
+                      NR_DL_FRAME_PARMS *frame_parms);
 
 /*!
 \fn int nr_generate_pbch
@@ -107,6 +104,7 @@ int nr_generate_pbch(nfapi_nr_dl_tti_ssb_pdu *ssb_pdu,
 @returns the bit index of the output
  */
 void nr_init_pbch_interleaver(uint8_t *interleaver);
+uint32_t nr_pbch_extra_byte_generation(int sfn, int n_hf, int ssb_index, int ssb_sc_offset, int Lmax);
 
 NR_gNB_DLSCH_t new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms, uint16_t N_RB);
 
diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c
index b21f48647e..75ee35385f 100644
--- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c
+++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c
@@ -288,14 +288,11 @@ static void nr_ulsch_extract_rbs(c16_t* const rxdataF,
                                  NR_DL_FRAME_PARMS *frame_parms)
 {
   uint8_t delta = 0;
-
   int start_re = (frame_parms->first_carrier_offset + (pusch_pdu->rb_start + pusch_pdu->bwp_start) * NR_NB_SC_PER_RB)%frame_parms->ofdm_symbol_size;
   int nb_re_pusch = NR_NB_SC_PER_RB * pusch_pdu->rb_size;
-
-
-  c16_t *rxF        = &rxdataF[rxoffset];
-  c16_t *rxF_ext    = &rxFext[0];
-  c16_t *ul_ch0     = &chF[choffset]; 
+  c16_t *rxF = &rxdataF[rxoffset];
+  c16_t *rxF_ext = &rxFext[0];
+  c16_t *ul_ch0 = &chF[choffset];
   c16_t *ul_ch0_ext = &chFext[0];
 
   if (is_dmrs_symbol == 0) {
@@ -307,11 +304,11 @@ static void nr_ulsch_extract_rbs(c16_t* const rxdataF,
       memcpy(rxF_ext, &rxF[start_re], neg_length * sizeof(c16_t));
       memcpy(&rxF_ext[neg_length], rxF, pos_length * sizeof(c16_t));
     }
-   memcpy(ul_ch0_ext, ul_ch0, nb_re_pusch * sizeof(c16_t));
+    memcpy(ul_ch0_ext, ul_ch0, nb_re_pusch * sizeof(c16_t));
   }
   else if (pusch_pdu->dmrs_config_type == pusch_dmrs_type1) { // 6 REs / PRB
     AssertFatal(delta == 0 || delta == 1, "Illegal delta %d\n",delta);
-    c16_t *rxF32        = &rxF[start_re];
+    c16_t *rxF32 = &rxF[start_re];
     if (start_re + nb_re_pusch < frame_parms->ofdm_symbol_size) {
       for (int idx = 1 - delta; idx < nb_re_pusch; idx += 2) {
         *rxF_ext++ = rxF32[idx];
@@ -367,7 +364,8 @@ static void nr_ulsch_extract_rbs(c16_t* const rxdataF,
   }
 }
 
-static void nr_ulsch_scale_channel(int **ul_ch_estimates_ext,
+static void nr_ulsch_scale_channel(int size_est,
+                                   int ul_ch_estimates_ext[][size_est],
                                    NR_DL_FRAME_PARMS *frame_parms,
                                    uint8_t symbol,
                                    uint8_t is_dmrs_symbol,
@@ -419,7 +417,8 @@ static int get_nb_re_pusch (NR_DL_FRAME_PARMS *frame_parms, nfapi_nr_pusch_pdu_t
 }
 
 // compute average channel_level on each (TX,RX) antenna pair
-static void nr_ulsch_channel_level(int **ul_ch_estimates_ext,
+static void nr_ulsch_channel_level(int size_est,
+                                   int ul_ch_estimates_ext[][size_est],
                                    NR_DL_FRAME_PARMS *frame_parms,
                                    int32_t *avg,
                                    uint8_t symbol,
@@ -436,7 +435,7 @@ static void nr_ulsch_channel_level(int **ul_ch_estimates_ext,
       //clear average level
       avg128U = simde_mm_setzero_si128();
 
-      ul_ch128 = (simde__m128i *)&ul_ch_estimates_ext[aatx*frame_parms->nb_antennas_rx+aarx][symbol * len];
+      ul_ch128 = (simde__m128i *)&ul_ch_estimates_ext[aatx * frame_parms->nb_antennas_rx + aarx][symbol * len];
 
       for (int i = 0; i < len >> 2; i++) {
         avg128U = simde_mm_add_epi32(avg128U, simde_mm_srai_epi32(simde_mm_madd_epi16(ul_ch128[i], ul_ch128[i]), x));
@@ -1638,17 +1637,21 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB,
     dmrs_symbol = get_valid_dmrs_idx_for_channel_est(rel15_ul->ul_dmrs_symb_pos, meas_symbol);
   else // average of channel estimates stored in first symbol
     dmrs_symbol = get_next_dmrs_symbol_in_slot(rel15_ul->ul_dmrs_symb_pos, rel15_ul->start_symbol_index, end_symbol);
-
+  int size_est = nb_re_pusch * frame_parms->symbols_per_slot;
+  __attribute__((aligned(32))) int ul_ch_estimates_ext[rel15_ul->nrOfLayers * frame_parms->nb_antennas_rx][size_est];
+  memset(ul_ch_estimates_ext, 0, sizeof(ul_ch_estimates_ext));
+  int buffer_length = rel15_ul->rb_size * NR_NB_SC_PER_RB;
+  c16_t temp_rxFext[frame_parms->nb_antennas_rx][buffer_length] __attribute__((aligned(32)));
   for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) 
-    for (int aatx = 0; aatx < rel15_ul->nrOfLayers; aatx++) 
+    for (int nl = 0; nl < rel15_ul->nrOfLayers; nl++)
       nr_ulsch_extract_rbs(gNB->common_vars.rxdataF[aarx],
-                           (c16_t*)pusch_vars->ul_ch_estimates[aatx * frame_parms->nb_antennas_rx + aarx],
-                           (c16_t*)&pusch_vars->rxdataF_ext[aarx][meas_symbol * nb_re_pusch],
-                           (c16_t*)&pusch_vars->ul_ch_estimates_ext[aatx * frame_parms->nb_antennas_rx+aarx][meas_symbol * nb_re_pusch],
+                           (c16_t *)pusch_vars->ul_ch_estimates[nl * frame_parms->nb_antennas_rx + aarx],
+                           temp_rxFext[aarx],
+                           (c16_t*)&ul_ch_estimates_ext[nl * frame_parms->nb_antennas_rx + aarx][meas_symbol * nb_re_pusch],
                            soffset + meas_symbol * frame_parms->ofdm_symbol_size,
                            dmrs_symbol * frame_parms->ofdm_symbol_size,
                            aarx,
-                           (rel15_ul->ul_dmrs_symb_pos >> meas_symbol) & 0x01,
+                           (rel15_ul->ul_dmrs_symb_pos >> meas_symbol) & 0x01, 
                            rel15_ul,
                            frame_parms);
 
@@ -1659,7 +1662,8 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB,
   //----------------------------------------------------------
   //--------------------- Channel Scaling --------------------
   //----------------------------------------------------------
-  nr_ulsch_scale_channel(pusch_vars->ul_ch_estimates_ext,
+  nr_ulsch_scale_channel(size_est,
+                         ul_ch_estimates_ext,
                          frame_parms,
                          meas_symbol,
                          (rel15_ul->ul_dmrs_symb_pos >> meas_symbol) & 0x01,
@@ -1668,16 +1672,17 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB,
                          rel15_ul->rb_size,
                          shift_ch_ext);
   
-  nr_ulsch_channel_level(pusch_vars->ul_ch_estimates_ext,
+  nr_ulsch_channel_level(size_est,
+                         ul_ch_estimates_ext,
                          frame_parms,
                          avg,
                          meas_symbol, // index of the start symbol
                          nb_re_pusch, // number of the re in pusch
                          rel15_ul->nrOfLayers);
 
-  for (int aatx = 0; aatx < rel15_ul->nrOfLayers; aatx++)
+  for (int nl = 0; nl < rel15_ul->nrOfLayers; nl++)
     for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++)
-       avgs = cmax(avgs, avg[aatx*frame_parms->nb_antennas_rx+aarx]);
+       avgs = cmax(avgs, avg[nl * frame_parms->nb_antennas_rx + aarx]);
   
   pusch_vars->log2_maxh = (log2_approx(avgs) >> 1);
 
diff --git a/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h b/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h
index d08cc87f1d..835876d4bf 100644
--- a/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h
+++ b/openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h
@@ -24,7 +24,7 @@
 
 
 #include "PHY/defs_nr_UE.h"
-//#include "PHY/defs_gNB.h"
+
 /** @addtogroup _PHY_PARAMETER_ESTIMATION_BLOCKS_
  * @{
  */
diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c b/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c
index e295681ae0..cc566d6e1c 100644
--- a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c
+++ b/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c
@@ -417,7 +417,7 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue,
     //printf("start rx segment %d\n",r);
     uint32_t 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}};
+    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);
     ldpcDecode_ue_t * rdata=(ldpcDecode_ue_t *) NotifiedFifoData(req);
 
diff --git a/openair1/PHY/defs_gNB.h b/openair1/PHY/defs_gNB.h
index 7589021493..6609ddce88 100644
--- a/openair1/PHY/defs_gNB.h
+++ b/openair1/PHY/defs_gNB.h
@@ -53,23 +53,6 @@ typedef struct {
   int lut[MAX_PUCCH0_NID][160][14];
 } NR_gNB_PUCCH0_LUT_t;
 
-
-typedef struct {
-  uint32_t pbch_a;
-  uint32_t pbch_a_interleaved;
-  uint32_t pbch_a_prime;
-  uint32_t pbch_e[NR_POLAR_PBCH_E_DWORD];
-} NR_gNB_PBCH;
-
-
-typedef enum {
-  NR_SCH_IDLE,
-  NR_ACTIVE,
-  NR_CBA_ACTIVE,
-  NR_DISABLED
-} NR_SCH_status_t;
-
-
 typedef struct {
   /// Nfapi DLSCH PDU
   nfapi_nr_dl_tti_pdsch_pdu pdsch_pdu;
@@ -81,8 +64,6 @@ typedef struct {
   uint8_t **c;
   /// Frame where current HARQ round was sent
   uint32_t frame;
-  /// Subframe where current HARQ round was sent
-  uint32_t subframe;
   /// Interleaver outputs
   uint8_t *f;
   /// LDPC lifting size
@@ -164,9 +145,6 @@ typedef struct {
 #define NUMBER_OF_NR_PRACH_MAX 8
 
 typedef struct {
-  /// \brief ?.
-  /// first index: ? [0..1023] (hard coded)
-  int16_t *prachF;
   /// \brief ?.
   /// second index: rx antenna [0..63] (hard coded) \note Hard coded array size indexed by \c nb_antennas_rx.
   /// third index: frequency-domain sample [0..ofdm_symbol_size*12[
@@ -221,6 +199,7 @@ typedef struct {
   int llrLen;
   //////////////////////////////////////////////////////////////
 } NR_UL_gNB_HARQ_t;
+
 static inline int lenWithCrc(int nbSeg, int len)
 {
   if (nbSeg > 1)
@@ -237,24 +216,8 @@ static inline int crcType(int nbSeg, int len)
 typedef struct {
   //! estimated rssi (dBm)
   int rx_rssi_dBm;
-  //! estimated correlation (wideband linear) between spatial channels (computed in dlsch_demodulation)
-  int rx_correlation[2];
-  //! estimated correlation (wideband dB) between spatial channels (computed in dlsch_demodulation)
-  int rx_correlation_dB[2];
-  /// Wideband CQI (= SINR)
-  int wideband_cqi[MAX_NUM_RU_PER_gNB];
-  /// Wideband CQI in dB (= SINR dB)
-  int wideband_cqi_dB[MAX_NUM_RU_PER_gNB];
   /// Wideband CQI (sum of all RX antennas, in dB)
   char wideband_cqi_tot;
-  /// Subband CQI per RX antenna and RB (= SINR)
-  int subband_cqi[MAX_NUM_RU_PER_gNB][275];
-  /// Total Subband CQI and RB (= SINR)
-  int subband_cqi_tot[275];
-  /// Subband CQI in dB and RB (= SINR dB)
-  int subband_cqi_dB[MAX_NUM_RU_PER_gNB][275];
-  /// Total Subband CQI and RB
-  int subband_cqi_tot_dB[275];
 } ulsch_measurements_gNB;
 
 typedef struct {
@@ -320,10 +283,6 @@ typedef struct {
 
 
 typedef struct {
-  /// \brief Holds the received data in the frequency domain for the allocated RBs in repeated format.
-  /// - first index: rx antenna id [0..nb_antennas_rx[
-  /// - second index: ? [0..2*ofdm_symbol_size[
-  int32_t **rxdataF_ext;
   /// \brief Hold the channel estimates in time domain based on DRS.
   /// - first index: rx antenna id [0..nb_antennas_rx[
   /// - second index: ? [0..4*ofdm_symbol_size[
@@ -332,10 +291,6 @@ typedef struct {
   /// - first index: rx antenna id [0..nb_antennas_rx[
   /// - second index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
   int32_t **ul_ch_estimates;
-  /// \brief Uplink channel estimates extracted in PRBS.
-  /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
-  /// - second index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
-  int32_t **ul_ch_estimates_ext;
   /// \brief Holds the compensated signal.
   /// - first index: rx antenna id [0..nb_antennas_rx[
   /// - second index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
@@ -379,7 +334,7 @@ typedef struct {
 /// Context data structure for RX/TX portion of slot processing
 typedef struct {
   /// Component Carrier index
-  uint8_t              CC_id;
+  uint8_t CC_id;
   /// timestamp transmitted to HW
   openair0_timestamp timestamp_tx;
   /// slot to act upon for transmission
@@ -393,111 +348,32 @@ typedef struct {
   /// \brief Instance count for RXn-TXnp4 processing thread.
   /// \internal This variable is protected by \ref mutex_rxtx.
   int instance_cnt;
-  /// pthread structure for RXn-TXnp4 processing thread
-  pthread_t pthread;
-  /// pthread attributes for RXn-TXnp4 processing thread
-  pthread_attr_t attr;
   /// condition variable for tx processing thread
   pthread_cond_t cond;
   /// mutex for RXn-TXnp4 processing thread
   pthread_mutex_t mutex;
-  /// scheduling parameters for RXn-TXnp4 thread
-  struct sched_param sched_param_rxtx;
-
-  /// \internal This variable is protected by \ref mutex_RUs_tx.
-  int instance_cnt_RUs;
-  /// condition variable for tx processing thread
-  pthread_cond_t cond_RUs;
-  /// mutex for L1 RXTX processing thread
-  pthread_mutex_t mutex_RUs;
-  /// mutex for L1 TX FH synchronization
-  pthread_mutex_t mutex_RUs_tx;
 } gNB_L1_rxtx_proc_t;
 
 
 /// Context data structure for eNB slot processing
 typedef struct gNB_L1_proc_t_s {
   /// Component Carrier index
-  uint8_t              CC_id;
-  /// thread index
-  int thread_index;
+  uint8_t CC_id;
   /// timestamp received from HW
   openair0_timestamp timestamp_rx;
   /// timestamp to send to "slave rru"
   openair0_timestamp timestamp_tx;
   /// slot to act upon for reception
   int slot_rx;
-  /// slot to act upon for PRACH
-  int slot_prach;
   /// frame to act upon for reception
   int frame_rx;
   /// frame to act upon for transmission
   int frame_tx;
-  /// frame to act upon for PRACH
-  int frame_prach;
-  /// \internal This variable is protected by \ref mutex_td.
-  int instance_cnt_td;
-  /// \internal This variable is protected by \ref mutex_te.
-  int instance_cnt_te;
-  /// \internal This variable is protected by \ref mutex_prach.
-  int instance_cnt_prach;
-  /// \internal This variable is protected by \ref mutex_asynch_rxtx.
-  int instance_cnt_asynch_rxtx;
-  /// pthread structure for eNB single processing thread
-  pthread_t pthread_single;
-  /// pthread structure for asychronous RX/TX processing thread
-  pthread_t pthread_asynch_rxtx;
   /// pthread structure for dumping L1 stats
   pthread_t L1_stats_thread;
-  /// pthread structure for printing time meas
-  pthread_t process_stats_thread;
-  /// pthread structure for reordering L1 tx thread messages
-  pthread_t pthread_tx_reorder;
-  /// flag to indicate first RX acquisition
-  int first_rx;
-  /// flag to indicate first TX transmission
-  int first_tx;
-  /// pthread attributes for single gNB processing thread
-  pthread_attr_t attr_single;
-  /// pthread attributes for prach processing thread
-  pthread_attr_t attr_prach;
-  /// pthread attributes for asynchronous RX thread
-  pthread_attr_t attr_asynch_rxtx;
-  /// scheduling parameters for parallel turbo-decoder thread
-  struct sched_param sched_param_td;
-  /// scheduling parameters for parallel turbo-encoder thread
-  struct sched_param sched_param_te;
-  /// scheduling parameters for single eNB thread
-  struct sched_param sched_param_single;
-  /// scheduling parameters for prach thread
-  struct sched_param sched_param_prach;
-  /// scheduling parameters for asynch_rxtx thread
-  struct sched_param sched_param_asynch_rxtx;
-  pthread_cond_t cond_prach;
-  /// condition variable for asynch RX/TX thread
-  pthread_cond_t cond_asynch_rxtx;
-  /// mutex for parallel turbo-decoder thread
-  pthread_mutex_t mutex_td;
-  /// mutex for parallel turbo-encoder thread
-  pthread_mutex_t mutex_te;
-  /// mutex for PRACH thread
-  pthread_mutex_t mutex_prach;
-  /// mutex for asynch RX/TX thread
-  pthread_mutex_t mutex_asynch_rxtx;
-  /// mutex for RU access to eNB processing (PDSCH/PUSCH)
-  pthread_mutex_t mutex_RU;
-  /// mutex for RU_tx access to eNB_tx processing (PDSCH/PUSCH)
-  pthread_mutex_t mutex_RU_tx;
-  /// mutex for RU access to eNB processing (PRACH)
-  pthread_mutex_t mutex_RU_PRACH;
-  /// mutex for RU access to eNB processing (PRACH BR)
-  pthread_mutex_t mutex_RU_PRACH_br;
-  /// mask for RUs serving eNB (PDSCH/PUSCH)
-  int RU_mask, RU_mask_tx;
-  /// mask for RUs serving eNB (PRACH)
-  int RU_mask_prach;
   /// set of scheduling variables RXn-TXnp4 threads
-  gNB_L1_rxtx_proc_t L1_proc, L1_proc_tx;
+  gNB_L1_rxtx_proc_t L1_proc;
+  gNB_L1_rxtx_proc_t L1_proc_tx;
 } gNB_L1_proc_t;
 
 typedef struct {
@@ -523,8 +399,7 @@ typedef struct {
   //! estimated avg noise power per RB (dBm)
   int n0_subband_power_tot_dBm[275];
   /// PRACH background noise level
-  int            prach_I0;
-
+  int prach_I0;
 } PHY_MEASUREMENTS_gNB;
 
 
@@ -539,25 +414,23 @@ typedef struct {
 /// Top-level PHY Data Structure for gNB
 typedef struct PHY_VARS_gNB_s {
   /// Module ID indicator for this instance
-  module_id_t          Mod_id;
-  uint8_t              CC_id;
-  uint8_t              configured;
-  gNB_L1_proc_t        proc;
-  int                  abstraction_flag;
-  int                  num_RU;
-  RU_t                 *RU_list[MAX_NUM_RU_PER_gNB];
+  module_id_t Mod_id;
+  uint8_t CC_id;
+  uint8_t configured;
+  gNB_L1_proc_t proc;
+  int num_RU;
+  RU_t *RU_list[MAX_NUM_RU_PER_gNB];
   /// Ethernet parameters for northbound midhaul interface
-  eth_params_t         eth_params_n;
+  eth_params_t eth_params_n;
   /// Ethernet parameters for fronthaul interface
-  eth_params_t         eth_params;
-  int                  rx_total_gain_dB;
-  int                  (*nr_start_if)(struct RU_t_s *ru, struct PHY_VARS_gNB_s *gNB);
-  uint8_t              local_flag;
-  nfapi_nr_config_request_scf_t  gNB_config;
-  NR_DL_FRAME_PARMS    frame_parms;
+  eth_params_t eth_params;
+  int rx_total_gain_dB;
+  int (*nr_start_if)(struct RU_t_s *ru, struct PHY_VARS_gNB_s *gNB);
+  nfapi_nr_config_request_scf_t gNB_config;
+  NR_DL_FRAME_PARMS frame_parms;
   PHY_MEASUREMENTS_gNB measurements;
-  NR_IF_Module_t       *if_inst;
-  NR_UL_IND_t          UL_INFO;
+  NR_IF_Module_t *if_inst;
+  NR_UL_IND_t UL_INFO;
 
   /// NFAPI RX ULSCH information
   nfapi_nr_rx_data_pdu_t  rx_pdu_list[MAX_UL_PDUS_PER_SLOT];
@@ -570,7 +443,7 @@ typedef struct PHY_VARS_gNB_s {
   /// NFAPI PRACH information
   nfapi_nr_prach_indication_pdu_t prach_pdu_indication_list[MAX_NUM_NR_RX_RACH_PDUS];
 
-  nfapi_nr_ul_tti_request_t     UL_tti_req;
+  nfapi_nr_ul_tti_request_t UL_tti_req;
   nfapi_nr_uci_indication_t uci_indication;
   
   int max_nb_pucch;
@@ -578,16 +451,15 @@ typedef struct PHY_VARS_gNB_s {
   int max_nb_pdsch;
   int max_nb_pusch;
 
-  NR_gNB_PBCH        pbch;
-  NR_gNB_COMMON      common_vars;
-  NR_gNB_PRACH       prach_vars;
-  NR_gNB_PRS         prs_vars;
+  NR_gNB_COMMON common_vars;
+  NR_gNB_PRACH prach_vars;
+  NR_gNB_PRS prs_vars;
   NR_gNB_PUSCH *pusch_vars;
   NR_gNB_PUCCH_t *pucch;
   NR_gNB_SRS_t *srs;
   NR_gNB_ULSCH_t *ulsch;
   NR_gNB_PHY_STATS_t phy_stats[MAX_MOBILES_PER_GNB];
-  t_nrPolar_params    **polarParams;
+  t_nrPolar_params **polarParams;
 
   /// SRS variables
   nr_srs_info_t **nr_srs_info;
@@ -635,15 +507,11 @@ typedef struct PHY_VARS_gNB_s {
   uint64_t bad_pucch;
   int num_ulprbbl;
   int ulprbbl[275];
-  /*
-  time_stats_t phy_proc;
-  */
+
   time_stats_t phy_proc_tx;
   time_stats_t phy_proc_rx;
   time_stats_t rx_prach;
-  /*
-  time_stats_t ofdm_mod_stats;
-  */
+
   time_stats_t dlsch_encoding_stats;
   time_stats_t dlsch_modulation_stats;
   time_stats_t dlsch_scrambling_stats;
@@ -678,10 +546,6 @@ typedef struct PHY_VARS_gNB_s {
   time_stats_t srs_beam_report_stats;
   time_stats_t srs_iq_matrix_stats;
 
-  /*
-  time_stats_t rx_dft_stats;
-  time_stats_t ulsch_freq_offset_estimation_stats;
-  */
   notifiedFIFO_t respPuschSymb;
   notifiedFIFO_t respDecode;
   notifiedFIFO_t resp_L1;
@@ -739,7 +603,7 @@ typedef struct LDPCDecode_s {
 struct ldpcReqId {
   uint16_t rnti;
   uint16_t frame;
-  uint8_t  subframe;
+  uint8_t  slot;
   uint8_t  codeblock;
   uint16_t spare;
 } __attribute__((packed));
@@ -756,12 +620,6 @@ typedef struct processingData_L1 {
   PHY_VARS_gNB *gNB;
 } processingData_L1_t;
 
-typedef enum {
-  FILLED,
-  FILLING,
-  NOT_FILLED
-} msgStatus_t;
-
 typedef struct processingData_L1tx {
   int frame;
   int slot;
diff --git a/openair1/SCHED_NR/phy_procedures_nr_gNB.c b/openair1/SCHED_NR/phy_procedures_nr_gNB.c
index b5423bab23..06b9b7c46f 100644
--- a/openair1/SCHED_NR/phy_procedures_nr_gNB.c
+++ b/openair1/SCHED_NR/phy_procedures_nr_gNB.c
@@ -45,7 +45,7 @@
 
 extern uint8_t nfapi_mode;
 
-void nr_common_signal_procedures(PHY_VARS_gNB *gNB,int frame,int slot, nfapi_nr_dl_tti_ssb_pdu ssb_pdu)
+void nr_common_signal_procedures(PHY_VARS_gNB *gNB, int frame,int slot, nfapi_nr_dl_tti_ssb_pdu ssb_pdu)
 {
   NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   nfapi_nr_config_request_scf_t *cfg = &gNB->gNB_config;
@@ -135,10 +135,9 @@ void nr_common_signal_procedures(PHY_VARS_gNB *gNB,int frame,int slot, nfapi_nr_
       gNB->common_vars.beam_id[0][slot*fp->symbols_per_slot+j] = cfg->ssb_table.ssb_beam_id_list[ssb_index].beam_id.value;
   }
 
-  nr_generate_pbch(&ssb_pdu,
-                   gNB->nr_pbch_interleaver,
+  nr_generate_pbch(gNB,
+                   &ssb_pdu,
                    &txdataF[0][txdataF_offset],
-                   gNB->TX_AMP,
                    ssb_start_symbol,
                    n_hf,
                    frame,
@@ -346,10 +345,7 @@ static void nr_postDecode(PHY_VARS_gNB *gNB, notifiedFIFO_elt_t *req)
        ulsch_harq->ulsch_pdu.rb_size],ulsch_harq->ulsch_pdu.nr_of_symbols*(off+(NR_NB_SC_PER_RB *
        ulsch_harq->ulsch_pdu.rb_size)),1,1); LOG_M("chestF0.m","chF0",
                 &gNB->pusch_vars[0].ul_ch_estimates[0][ulsch_harq->ulsch_pdu.start_symbol_index*gNB->frame_parms.ofdm_symbol_size],gNB->frame_parms.ofdm_symbol_size,1,1);
-          LOG_M("chestF0_ext.m","chF0_ext",
-                &gNB->pusch_vars[0]->ul_ch_estimates_ext[0][(ulsch_harq->ulsch_pdu.start_symbol_index+1)*(off+(NR_NB_SC_PER_RB *
-       ulsch_harq->ulsch_pdu.rb_size))], (ulsch_harq->ulsch_pdu.nr_of_symbols-1)*(off+(NR_NB_SC_PER_RB *
-       ulsch_harq->ulsch_pdu.rb_size)),1,1); LOG_M("rxsigF0_comp.m","rxsF0_comp",
+          LOG_M("rxsigF0_comp.m","rxsF0_comp",
                 &gNB->pusch_vars[0].rxdataF_comp[0][ulsch_harq->ulsch_pdu.start_symbol_index*(off+(NR_NB_SC_PER_RB *
        ulsch_harq->ulsch_pdu.rb_size))],ulsch_harq->ulsch_pdu.nr_of_symbols*(off+(NR_NB_SC_PER_RB *
        ulsch_harq->ulsch_pdu.rb_size)),1,1); LOG_M("rxsigF0_llr.m","rxsF0_llr",
@@ -361,10 +357,7 @@ static void nr_postDecode(PHY_VARS_gNB *gNB, notifiedFIFO_elt_t *req)
        ulsch_harq->ulsch_pdu.rb_size],ulsch_harq->ulsch_pdu.nr_of_symbols*(off+(NR_NB_SC_PER_RB *
        ulsch_harq->ulsch_pdu.rb_size)),1,1); LOG_M("chestF1.m","chF1",
                   &gNB->pusch_vars[0].ul_ch_estimates[1][ulsch_harq->ulsch_pdu.start_symbol_index*gNB->frame_parms.ofdm_symbol_size],gNB->frame_parms.ofdm_symbol_size,1,1);
-            LOG_M("chestF1_ext.m","chF1_ext",
-                  &gNB->pusch_vars[0].ul_ch_estimates_ext[1][(ulsch_harq->ulsch_pdu.start_symbol_index+1)*(off+(NR_NB_SC_PER_RB *
-       ulsch_harq->ulsch_pdu.rb_size))], (ulsch_harq->ulsch_pdu.nr_of_symbols-1)*(off+(NR_NB_SC_PER_RB *
-       ulsch_harq->ulsch_pdu.rb_size)),1,1); LOG_M("rxsigF1_comp.m","rxsF1_comp",
+             LOG_M("rxsigF1_comp.m","rxsF1_comp",
                   &gNB->pusch_vars[0].rxdataF_comp[1][ulsch_harq->ulsch_pdu.start_symbol_index*(off+(NR_NB_SC_PER_RB *
        ulsch_harq->ulsch_pdu.rb_size))],ulsch_harq->ulsch_pdu.nr_of_symbols*(off+(NR_NB_SC_PER_RB *
        ulsch_harq->ulsch_pdu.rb_size)),1,1);
diff --git a/openair1/SIMULATION/NR_PHY/pbchsim.c b/openair1/SIMULATION/NR_PHY/pbchsim.c
index 987c0e4b62..9d5a787051 100644
--- a/openair1/SIMULATION/NR_PHY/pbchsim.c
+++ b/openair1/SIMULATION/NR_PHY/pbchsim.c
@@ -204,6 +204,7 @@ int main(int argc, char **argv)
 
   channel_desc_t *gNB2UE;
   get_softmodem_params()->sa = 1;
+  get_softmodem_params()->usim_test = 1;
 
   //uint8_t extended_prefix_flag=0;
   //int8_t interf1=-21,interf2=-21;
@@ -230,7 +231,7 @@ int main(int argc, char **argv)
   int frame_length_complex_samples_no_prefix;
   NR_DL_FRAME_PARMS *frame_parms;
 
-  int ret, payload_ret=0;
+  int ret;
   int run_initial_sync=0;
 
   int loglvl=OAILOG_WARNING;
@@ -835,17 +836,15 @@ int main(int argc, char **argv)
                          rxdataF);
 
         if (ret == 0) {
-          // UE->rx_ind.rx_indication_body->mib_pdu.ssb_index;  //not yet detected automatically
-          // UE->rx_ind.rx_indication_body->mib_pdu.ssb_length; //Lmax, not yet detected automatically
-          uint8_t gNB_xtra_byte = 0;
-          for (int i = 0; i < 8; i++)
-            gNB_xtra_byte |= ((gNB->pbch.pbch_a >> (31 - i)) & 1) << (7 - i);
-
-          payload_ret = (result.xtra_byte == gNB_xtra_byte);
-          for (i = 0; i < 3; i++) {
-            payload_ret +=
-                (result.decoded_output[i] == ((msgDataTx.ssb[ssb_index].ssb_pdu.ssb_pdu_rel15.bchPayload >> (8 * i)) & 0xff));
-          }
+          uint32_t xtra_byte = nr_pbch_extra_byte_generation(frame,
+                                                             n_hf,
+                                                             ssb_index,
+                                                             gNB->gNB_config.ssb_table.ssb_subcarrier_offset.value,
+                                                             frame_parms->Lmax);
+          int payload_ret = (result.xtra_byte == xtra_byte);
+          nfapi_nr_dl_tti_ssb_pdu_rel15_t *pdu = &msgDataTx.ssb[ssb_index].ssb_pdu.ssb_pdu_rel15;
+          for (int i = 0; i < 3; i++)
+            payload_ret += (result.decoded_output[i] == ((pdu->bchPayload >> (8 * i)) & 0xff));
           // printf("ret %d\n", payload_ret);
           if (payload_ret != 4)
             n_errors_payload++;
diff --git a/openair1/SIMULATION/NR_PHY/prachsim.c b/openair1/SIMULATION/NR_PHY/prachsim.c
index cf1603a810..d4b109a529 100644
--- a/openair1/SIMULATION/NR_PHY/prachsim.c
+++ b/openair1/SIMULATION/NR_PHY/prachsim.c
@@ -135,11 +135,6 @@ int main(int argc, char **argv){
   int prachOccasion = 0;
   double DS_TDL = .03;
 
-  //  int8_t interf1=-19,interf2=-19;
-  //  uint8_t abstraction_flag=0,calibration_flag=0;
-  //  double prach_sinr;
-  //  uint32_t nsymb;
-  //  uint16_t preamble_max, preamble_energy_max;
   FILE *input_fd=NULL;
   char* input_file=NULL;
   int n_bytes=0;
@@ -784,22 +779,21 @@ int main(int argc, char **argv){
 
         if (n_frames==1) {
           printf("preamble %d (tx %d) : energy %d, delay %d\n",preamble_rx,preamble_tx,preamble_energy,preamble_delay);
-          #ifdef NR_PRACH_DEBUG
-	  LOG_M("prach0.m","prach0", &txdata[0][prach_start], frame_parms->samples_per_subframe, 1, 1);
-            LOG_M("prachF0.m","prachF0", &gNB->prach_vars.prachF[0], N_ZC, 1, 1);
-            LOG_M("rxsig0.m","rxs0", &ru->common.rxdata[0][subframe*frame_parms->samples_per_subframe], frame_parms->samples_per_subframe, 1, 1);
-            LOG_M("ru_rxsig0.m","rxs0", &ru->common.rxdata[0][subframe*frame_parms->samples_per_subframe], frame_parms->samples_per_subframe, 1, 1);
-            LOG_M("ru_rxsigF0.m","rxsF0", ru->common.rxdataF[0], frame_parms->ofdm_symbol_size*frame_parms->symbols_per_slot, 1, 1);
-            LOG_M("ru_prach_rxsigF0.m","rxsF0", ru->prach_rxsigF[0][0], N_ZC, 1, 1);
-            LOG_M("prach_preamble.m","prachp", &gNB->X_u[0], N_ZC, 1, 1);
-            LOG_M("ue_prach_preamble.m","prachp", &UE->X_u[0], N_ZC, 1, 1);
-          #endif
+#ifdef NR_PRACH_DEBUG
+          LOG_M("prach0.m","prach0", &txdata[0][prach_start], frame_parms->samples_per_subframe, 1, 1);
+          LOG_M("rxsig0.m","rxs0", &ru->common.rxdata[0][subframe*frame_parms->samples_per_subframe], frame_parms->samples_per_subframe, 1, 1);
+          LOG_M("ru_rxsig0.m","rxs0", &ru->common.rxdata[0][subframe*frame_parms->samples_per_subframe], frame_parms->samples_per_subframe, 1, 1);
+          LOG_M("ru_rxsigF0.m","rxsF0", ru->common.rxdataF[0], frame_parms->ofdm_symbol_size*frame_parms->symbols_per_slot, 1, 1);
+          LOG_M("ru_prach_rxsigF0.m","rxsF0", ru->prach_rxsigF[0][0], N_ZC, 1, 1);
+          LOG_M("prach_preamble.m","prachp", &gNB->X_u[0], N_ZC, 1, 1);
+          LOG_M("ue_prach_preamble.m","prachp", &UE->X_u[0], N_ZC, 1, 1);
+#endif
         }
       }
 
       printf("SNR %f dB, UE Speed %f km/h: errors %u/%d (delay %f)\n", SNR, ue_speed, prach_errors, n_frames, delay_avg/(double)(n_frames-prach_errors));
       if (input_fd)
-	break;
+        break;
       if (prach_errors)
         break;
 
diff --git a/openair1/SIMULATION/NR_PHY/ulsim.c b/openair1/SIMULATION/NR_PHY/ulsim.c
index bbcc5f0759..5403bedbf7 100644
--- a/openair1/SIMULATION/NR_PHY/ulsim.c
+++ b/openair1/SIMULATION/NR_PHY/ulsim.c
@@ -1266,30 +1266,20 @@ int main(int argc, char *argv[])
         if (n_trials == 1 && round == 0) {
           __attribute__((unused)) int off = ((nb_rb & 1) == 1) ? 4 : 0;
 
-          LOG_M("rxsigF0_ext.m",
-                "rxsF0_ext",
-                &pusch_vars->rxdataF_ext[0][start_symbol * NR_NB_SC_PER_RB * pusch_pdu->rb_size],
-                nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
-                1,
-                1);
           LOG_M("chestF0.m",
                 "chF0",
                 &pusch_vars->ul_ch_estimates[0][start_symbol * frame_parms->ofdm_symbol_size],
                 frame_parms->ofdm_symbol_size,
                 1,
                 1);
-          LOG_M("chestF0_ext.m",
-                "chF0_ext",
-                &pusch_vars->ul_ch_estimates_ext[0][(start_symbol + 1) * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
-                (nb_symb_sch - 1) * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
-                1,
-                1);
+
           LOG_M("rxsigF0_comp.m",
                 "rxsF0_comp",
                 &pusch_vars->rxdataF_comp[0][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
                 nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
                 1,
                 1);
+
           LOG_M("rxsigF0_llrlayers0.m",
                 "rxsF0_llrlayers0",
                 &pusch_vars->llr_layers[0][0],
@@ -1298,12 +1288,6 @@ int main(int argc, char *argv[])
                 0);
 
           if (precod_nbr_layers == 2) {
-            LOG_M("rxsigF1_ext.m",
-                  "rxsF1_ext",
-                  &pusch_vars->rxdataF_ext[1][start_symbol * NR_NB_SC_PER_RB * pusch_pdu->rb_size],
-                  nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
-                  1,
-                  1);
 
             LOG_M("chestF3.m",
                   "chF3",
@@ -1312,13 +1296,6 @@ int main(int argc, char *argv[])
                   1,
                   1);
 
-            LOG_M("chestF3_ext.m",
-                  "chF3_ext",
-                  &pusch_vars->ul_ch_estimates_ext[3][(start_symbol + 1) * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
-                  (nb_symb_sch - 1) * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
-                  1,
-                  1);
-
             LOG_M("rxsigF2_comp.m",
                   "rxsF2_comp",
                   &pusch_vars->rxdataF_comp[2][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
@@ -1335,24 +1312,6 @@ int main(int argc, char *argv[])
           }
 
           if (precod_nbr_layers == 4) {
-            LOG_M("rxsigF1_ext.m",
-                  "rxsF1_ext",
-                  &pusch_vars->rxdataF_ext[1][start_symbol * NR_NB_SC_PER_RB * pusch_pdu->rb_size],
-                  nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
-                  1,
-                  1);
-            LOG_M("rxsigF2_ext.m",
-                  "rxsF2_ext",
-                  &pusch_vars->rxdataF_ext[2][start_symbol * NR_NB_SC_PER_RB * pusch_pdu->rb_size],
-                  nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
-                  1,
-                  1);
-            LOG_M("rxsigF3_ext.m",
-                  "rxsF3_ext",
-                  &pusch_vars->rxdataF_ext[3][start_symbol * NR_NB_SC_PER_RB * pusch_pdu->rb_size],
-                  nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
-                  1,
-                  1);
 
             LOG_M("chestF5.m",
                   "chF5",
@@ -1373,25 +1332,6 @@ int main(int argc, char *argv[])
                   1,
                   1);
 
-            LOG_M("chestF5_ext.m",
-                  "chF5_ext",
-                  &pusch_vars->ul_ch_estimates_ext[5][(start_symbol + 1) * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
-                  (nb_symb_sch - 1) * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
-                  1,
-                  1);
-            LOG_M("chestF10_ext.m",
-                  "chF10_ext",
-                  &pusch_vars->ul_ch_estimates_ext[10][(start_symbol + 1) * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
-                  (nb_symb_sch - 1) * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
-                  1,
-                  1);
-            LOG_M("chestF15_ext.m",
-                  "chF15_ext",
-                  &pusch_vars->ul_ch_estimates_ext[15][(start_symbol + 1) * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
-                  (nb_symb_sch - 1) * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
-                  1,
-                  1);
-
             LOG_M("rxsigF4_comp.m",
                   "rxsF4_comp",
                   &pusch_vars->rxdataF_comp[4][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],