[NR_PHY] Extract common nr_layer_demapping for UE and gNB Rx

Move layer de-mapping logic into a shared nr_layer_demapping() in
nr_phy_common, callable by both UE PDSCH and gNB PUSCH receivers.
Signed-off-by: Rupanjali <rupanjali.srivastava@openairinterface.org>

openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c

@@ -392,11 +392,7 @@ static void nr_pusch_symbol_processing(void *arg)
     int16_t *llr_ptr = llrs[0];
     if (rel15_ul->nrOfLayers != 1) {
       llr_ptr = &rdata->llr[pusch_vars->llr_offset[symbol] * rel15_ul->nrOfLayers];
-      for (int i = 0; i < (nb_re_pusch); i++)
-        for (int l = 0; l < rel15_ul->nrOfLayers; l++)
-          for (int m = 0; m < rel15_ul->qam_mod_order; m++)
-            llr_ptr[i * rel15_ul->nrOfLayers * rel15_ul->qam_mod_order + l * rel15_ul->qam_mod_order + m] =
-                llrss[l][i * rel15_ul->qam_mod_order + m];
+      nr_layer_demapping(rel15_ul->nrOfLayers, rel15_ul->qam_mod_order, nb_re_pusch, llrss, llr_ptr);
     }
     stop_meas(&rdata->ul_demap);
     // unscrambling

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c

@@ -675,18 +675,6 @@ static void nr_dlsch_mmse(uint32_t rx_size_symbol,
   }
 }
 
-/* Constant MO lets the compiler inline memcpy as fixed-size vector stores */
-static inline void layer_demapping(uint8_t Nl, int nb_re, int16_t **layer_ptrs, int16_t *llr_out, int MO)
-{
-  int k = 0;
-  for (int j = 0; j < nb_re; j++) {
-    for (int l = 0; l < Nl; l++) {
-      memcpy(llr_out + k, layer_ptrs[l] + j * MO, MO * sizeof(int16_t));
-      k += MO;
-    }
-  }
-}
-
 static void nr_dlsch_layer_demapping(const uint8_t Nl,
                                      const uint8_t mod_order,
                                      const int llrLayerSize,
@@ -697,42 +685,13 @@ static void nr_dlsch_layer_demapping(const uint8_t Nl,
 {
   const int s0 = dlsch_config->start_symbol;
   const int s1 = dlsch_config->number_symbols;
-
   int k = 0;
 
-  if (Nl == 1) {
-    /* Single layer: one contiguous memcpy per symbol, no interleaving needed. */
-    for (int i = s0; i < (s0 + s1); i++) {
-      memcpy(llr + k, llr_layers[i][0], re_len[i] * mod_order * sizeof(int16_t));
-      k += re_len[i] * mod_order;
-    }
-    return;
-  }
-
-  AssertFatal(Nl <= 4, "Not supported number of layers %d\n", Nl);
-
-  /* Switch on mod_order so MO is a compile-time literal, enabling the compiler
-   * to inline memcpy as fixed-size vector stores. */
   for (int i = s0; i < (s0 + s1); i++) {
     int16_t *p_layer[Nl];
     for (int l = 0; l < Nl; l++)
       p_layer[l] = (int16_t *)llr_layers[i][l];
-    switch (mod_order) {
-      case 2:
-        layer_demapping(Nl, re_len[i], p_layer, llr + k, 2);
-        break;
-      case 4:
-        layer_demapping(Nl, re_len[i], p_layer, llr + k, 4);
-        break;
-      case 6:
-        layer_demapping(Nl, re_len[i], p_layer, llr + k, 6);
-        break;
-      case 8:
-        layer_demapping(Nl, re_len[i], p_layer, llr + k, 8);
-        break;
-      default:
-        AssertFatal(0, "Unknown mod_order %d\n", mod_order);
-    }
+    nr_layer_demapping(Nl, mod_order, re_len[i], p_layer, llr + k);
     k += re_len[i] * mod_order * Nl;
   }
 }

openair1/PHY/nr_phy_common/inc/nr_phy_common.h

@@ -377,6 +377,22 @@ int nr_get_ssb_start_sc(int scs,
                         int ssb_sco,
                         frequency_range_t freq_range);
 
+/**
+ * @brief Interleave per-layer LLRs into a flat output buffer (layer de-mapping).
+ *
+ * For Nl=1 the per-layer LLR array is copied contiguously into llr_out.
+ * For Nl>1 LLRs are interleaved as: RE0_L0, RE0_L1, ..., RE0_L(Nl-1),
+ * RE1_L0, ... so that the decoder sees all layers interleaved per RE.
+ *
+ * @param Nl          Number of layers (1-4)
+ * @param mod_order   Modulation order (2/4/6/8)
+ * @param nb_re       Number of REs in this symbol
+ * @param llr_layers  Per-layer LLR pointers: llr_layers[l] points to
+ *                    nb_re * mod_order int16_t values for layer l
+ * @param llr_out     Output flat buffer (nb_re * mod_order * Nl int16_t values)
+ */
+void nr_layer_demapping(uint8_t Nl, uint8_t mod_order, int nb_re, int16_t **llr_layers, int16_t *llr_out);
+
 #include "nr_channel_compensation.h"
 #include "nr_compute_llr.h"
 #endif

openair1/PHY/nr_phy_common/src/nr_phy_common.c

@@ -489,3 +489,45 @@ int nr_get_ssb_start_sc(int scs, int ssb_offset_point_a, int ssb_sco, frequency_
 
   return ssb_start_subcarrier;
 }
+
+/* Constant MO lets the compiler inline memcpy as fixed-size vector stores */
+static inline void layer_demapping(uint8_t Nl, int nb_re, int16_t **llr_layers, int16_t *llr_out, int MO)
+{
+  int k = 0;
+  for (int j = 0; j < nb_re; j++) {
+    for (int l = 0; l < Nl; l++) {
+      memcpy(llr_out + k, llr_layers[l] + j * MO, MO * sizeof(int16_t));
+      k += MO;
+    }
+  }
+}
+
+void nr_layer_demapping(uint8_t Nl, uint8_t mod_order, int nb_re, int16_t **llr_layers, int16_t *llr_out)
+{
+  AssertFatal(Nl >= 1 && Nl <= 4, "Unsupported number of layers %d\n", Nl);
+
+  if (Nl == 1) {
+    /* Single layer: one contiguous memcpy, no interleaving needed. */
+    memcpy(llr_out, llr_layers[0], nb_re * mod_order * sizeof(int16_t));
+    return;
+  }
+
+  /* Switch on mod_order so MO is a compile-time literal, enabling the compiler
+   * to inline memcpy as fixed-size vector stores. */
+  switch (mod_order) {
+    case 2:
+      layer_demapping(Nl, nb_re, llr_layers, llr_out, 2);
+      break;
+    case 4:
+      layer_demapping(Nl, nb_re, llr_layers, llr_out, 4);
+      break;
+    case 6:
+      layer_demapping(Nl, nb_re, llr_layers, llr_out, 6);
+      break;
+    case 8:
+      layer_demapping(Nl, nb_re, llr_layers, llr_out, 8);
+      break;
+    default:
+      AssertFatal(0, "Unknown mod_order %d\n", mod_order);
+  }
+}