Merge branch 'episys/sl-eurecom2' into eurecom/sl-eurecom2

Following modifications are included in this merge:
1) Implemented CSI reporting
2) Developed a measurement function of SNR and computed CQI based on
that
3) Simplified functions
4) Improved logging
5) Cleaned code
6) Fixed pointers issues

openair1/PHY/NR_REFSIG/refsig_defs_ue.h

@@ -41,6 +41,9 @@ typedef struct csi_rs_params {
   uint8_t ports;
   uint8_t koverline[16];
   uint8_t loverline[16];
+  double rho;
+  double alpha;
+  uint8_t gs;
 } csi_rs_params_t;
 
 /*!\brief This function generates the NR Gold sequence (38-211, Sec 5.2.1) for the PBCH DMRS.

openair1/PHY/NR_TRANSPORT/nr_csi_rs.c

@@ -87,7 +87,7 @@ void get_csi_rs_freq_ind_sl(const NR_DL_FRAME_PARMS *frame_parms,
       for (int s = 0 ; s < gs; s++)  { // loop over each CDM group size
         port_freq_indices[s].p = s; // port index
         for (kp = 0; kp <= table_params->kprime; kp++) { // loop over frequency resource elements within a group
-          port_freq_indices[s].k = (start_sc + (n * NR_NB_SC_PER_RB) + table_params->koverline[ji] + kp) % (frame_parms->ofdm_symbol_size);  // frequency index of current resource element
+          port_freq_indices[kp].k = (start_sc + (n * NR_NB_SC_PER_RB) + table_params->koverline[ji] + kp) % (frame_parms->ofdm_symbol_size);  // frequency index of current resource element
         }
       }
     }
@@ -101,6 +101,7 @@ void get_csi_rs_params_from_table(const nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *csi_
   uint8_t j[16], k_n[6], koverline[16], loverline[16];
   int found = 0;
   uint8_t fi = 0;
+  double rho, alpha;
   switch (csi_params->row) {
     // implementation of table 7.4.1.5.3-1 of 38.211
     // lprime and kprime are the max value of l' and k'
@@ -466,6 +467,58 @@ void get_csi_rs_params_from_table(const nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *csi_
     default:
       AssertFatal(0==1, "Row %d is not valid for CSI Table 7.4.1.5.3-1\n", csi_params->row);
   }
+
+    // setting the frequency density from its index
+  switch (csi_params->freq_density) {
+
+    case 0:
+      rho = 0.5;
+      break;
+
+    case 1:
+      rho = get_softmodem_params()->sl_mode ? 1 : 0.5;
+      break;
+
+    case 2:
+      rho = 1;
+      break;
+
+    case 3:
+      rho = 3;
+      break;
+
+    default:
+      AssertFatal(0==1, "Invalid frequency density index for CSI\n");
+  }
+
+  if (ports == 1)
+    alpha = rho;
+  else
+    alpha = 2*rho;
+
+  uint8_t gs = 0;
+  // CDM group size from CDM type index
+  switch (csi_params->cdm_type) {
+
+    case 0:
+      gs = 1;
+      break;
+
+    case 1:
+      gs = 2;
+      break;
+
+    case 2:
+      gs = 4;
+      break;
+
+    case 3:
+      gs = 8;
+      break;
+
+    default:
+      AssertFatal(0==1, "Invalid cdm type index for CSI\n");
+  }
   memcpy(table_params->j, j, sizeof(j));
   memcpy(table_params->k_n, k_n, sizeof(k_n));
   memcpy(table_params->koverline, koverline, sizeof(koverline));
@@ -474,6 +527,9 @@ void get_csi_rs_params_from_table(const nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *csi_
   table_params->kprime = kprime;
   table_params->lprime = lprime;
   table_params->size = size;
+  table_params->alpha = alpha;
+  table_params->rho = rho;
+  table_params->gs = gs;
 }
 
 void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
@@ -515,10 +571,9 @@ void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
   int16_t mod_csi[frame_parms->symbols_per_slot][csi_rs_length>>1] __attribute__((aligned(16)));
   uint16_t b = csi_params->freq_domain;
   uint16_t n, p, k, l, mprime, na, kpn;
-  uint8_t size, ports, kprime, lprime, gs;
+  uint8_t size, ports, kprime, lprime;
   uint8_t j[16], k_n[6], koverline[16], loverline[16];
   int wf, wt, lp, kp, symb;
-  double rho, alpha;
   uint32_t beta = amp;
   nr_csi_info->csi_rs_generated_signal_bits = log2_approx(amp);
 
@@ -555,71 +610,19 @@ void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
   printf("\n");
 #endif
 
-
-  // setting the frequency density from its index
-  switch (csi_params->freq_density) {
-  
-  case 0:
-    rho = 0.5;
-    break;
-  
-  case 1:
-    rho = get_softmodem_params()->sl_mode ? 1 : 0.5;
-    break;
-
-   case 2:
-    rho = 1;
-    break;
-
-   case 3:
-    rho = 3;
-    break;
-
-  default:
-    AssertFatal(0==1, "Invalid frequency density index for CSI\n");
-  }
-
-  if (ports == 1)
-    alpha = rho;
-  else
-    alpha = 2*rho; 
-
 #ifdef NR_CSIRS_DEBUG
     printf(" rho %f, alpha %f\n",rho,alpha);
 #endif
 
-  // CDM group size from CDM type index
-  switch (csi_params->cdm_type) {
-  
-  case 0:
-    gs = 1;
-    break;
-  
-  case 1:
-    gs = 2;
-    break;
-
-  case 2:
-    gs = 4;
-    break;
-
-  case 3:
-    gs = 8;
-    break;
-
-  default:
-    AssertFatal(0==1, "Invalid cdm type index for CSI\n");
-  }
-
   uint16_t csi_length;
-  if (rho < 1) {
+  if (table_params.rho < 1) {
     if (csi_params->freq_density == 0) {
       csi_length = (((csi_params->start_rb + csi_params->nr_of_rbs)>>1)<<kprime)<<1;
     } else {
       csi_length = ((((csi_params->start_rb + csi_params->nr_of_rbs)>>1)<<kprime)+1)<<1;
     }
   } else {
-    csi_length = (((uint16_t) rho*(csi_params->start_rb + csi_params->nr_of_rbs))<<kprime)<<1;
+    csi_length = (((uint16_t) table_params.rho*(csi_params->start_rb + csi_params->nr_of_rbs))<<kprime)<<1;
   }
 
 #ifdef NR_CSIRS_DEBUG
@@ -672,8 +675,8 @@ void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
   for (n=csi_params->start_rb; n<(csi_params->start_rb+csi_params->nr_of_rbs); n++) {
    if ( (csi_params->freq_density > 1) || get_softmodem_params()->sl_mode ? csi_params->freq_density : (csi_params->freq_density == (n%2))) {  // for freq density 0.5 checks if even or odd RB
     for (int ji=0; ji<size; ji++) { // loop over CDM groups
-      for (int s=0 ; s<gs; s++)  { // loop over each CDM group size
-        p = s+j[ji]*gs; // port index
+      for (int s=0 ; s<table_params.gs; s++)  { // loop over each CDM group size
+        p = s+j[ji]*table_params.gs; // port index
         for (kp=0; kp<=kprime; kp++) { // loop over frequency resource elements within a group
           k = (start_sc+(n*NR_NB_SC_PER_RB)+koverline[ji]+kp)%(frame_parms->ofdm_symbol_size);  // frequency index of current resource element
           // wf according to tables 7.4.5.3-2 to 7.4.5.3-5
@@ -681,8 +684,8 @@ void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
             wf = 1;
           else
             wf = -2*(s%2)+1;
-          na = n*alpha;
-          kpn = (rho*koverline[ji])/NR_NB_SC_PER_RB;
+          na = n*table_params.alpha;
+          kpn = (table_params.rho*koverline[ji])/NR_NB_SC_PER_RB;
           mprime = na + kp + kpn; // sequence index
           for (lp=0; lp<=lprime; lp++) { // loop over frequency resource elements within a group
             l = lp + loverline[ji];
@@ -721,7 +724,7 @@ void nr_generate_csi_rs(const NR_DL_FRAME_PARMS *frame_parms,
    }
   }
   if (N_cdm_groups) *N_cdm_groups = size;
-  if (CDM_group_size) *CDM_group_size = gs;
+  if (CDM_group_size) *CDM_group_size = table_params.gs;
   if (k_prime) *k_prime = kprime;
   if (l_prime) *l_prime = lprime;
   if (N_ports) *N_ports = ports;

openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c

@@ -388,6 +388,7 @@ void nr_ulsch_extract_rbs(int rxFSz,
                 csi_rs_rb++;
               }
               free(port_freq_indices);
+              port_freq_indices = NULL;
             }
 
             if (++k >= frame_parms->ofdm_symbol_size) {
@@ -2143,11 +2144,11 @@ void nr_rx_pusch(PHY_VARS_gNB *gNB,
             csi_params->start_rb,
             csi_params->nr_of_rbs);
       if (phy_data->sl_rx_action == SL_NR_CONFIG_TYPE_RX_PSSCH_SLSCH_CSI_RS) {
-        if (ue->csirs_vars[proc->gNB_id]->active == 1) {
+        if (ue->csirs_vars[0]->active == 1) {
           LOG_D(NR_PHY, "%d.%d CSI-RS Received\n", proc->frame_rx, proc->nr_slot_rx);
           nr_slot_fep(ue, frame_parms, proc, symbol, rxdataF, link_type_sl);
           nr_ue_csi_rs_procedures(ue, proc, rxdataF);
-          ue->csirs_vars[proc->gNB_id]->active = 0;
+          ue->csirs_vars[0]->active = 0;
         }
       }
     }

openair1/PHY/NR_UE_TRANSPORT/csi_rx.c

@@ -40,13 +40,14 @@
 #include "PHY/NR_TRANSPORT/nr_transport_proto.h"
 #include "PHY/NR_UE_ESTIMATION/filt16a_32.h"
 #include "executables/nr-uesoftmodem.h"
-
+#include "PHY/NR_REFSIG/refsig_defs_ue.h"
 // 10*log10(pow(2,30))
 #define pow_2_30_dB 90
 
 // Additional memory allocation, because of applying the filter and the memory offset to ensure memory alignment
 #define FILTER_MARGIN 32
-
+//#define DEBUG_CSI_PRINTS  // To enable CSI SNR debug logs
+extern short nr_qpsk_mod_table[8];
 //#define NR_CSIRS_DEBUG
 //#define NR_CSIIM_DEBUG
 
@@ -181,6 +182,87 @@ bool is_csi_rs_in_symbol(const fapi_nr_dl_config_csirs_pdu_rel15_t csirs_config_
   return ret;
 }
 
+int32_t sl_csi_rs_snr_estimation(PHY_VARS_NR_UE *ue,
+                                 UE_nr_rxtx_proc_t *proc,
+                                 const NR_DL_FRAME_PARMS *frame_parms,
+                                 c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP])
+{
+  //FIXME: This function needs to be updated for two ports
+  nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *csi_params = (nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *)&ue->csirs_vars[0]->csirs_config_pdu;
+  csi_rs_params_t table_params;
+  get_csi_rs_params_from_table(csi_params, &table_params);
+  const int16_t *fl;
+  switch (table_params.kprime) {
+    case 0:
+      fl  = filt8_l0;
+      break;
+    case 1:
+      fl  = filt8_l1;
+      break;
+    default:
+      LOG_I(PHY, "%s: ERROR!! Invalid k_prime=%d, symbol %d\n",__FUNCTION__, table_params.kprime, csi_params->symb_l0);
+      return(-1);
+      break;
+  }
+  // Pilots generation and modulation
+  uint32_t **nr_gold_csi_rs = ue->nr_csi_info->nr_gold_csi_rs[proc->nr_slot_rx];
+  int nrRECSI_RS = get_nRECSI_RS(csi_params->freq_density, csi_params->nr_of_rbs);
+  int16_t mod_csi[nrRECSI_RS << 1];
+  for (int m = 0; m < nrRECSI_RS; m++) {
+    uint8_t idx = (((nr_gold_csi_rs[csi_params->symb_l0][(m<<1)>>5])>>((m<<1)&0x1f))&3);
+    mod_csi[m<<1]     = nr_qpsk_mod_table[idx<<1];
+    mod_csi[(m<<1)+1] = nr_qpsk_mod_table[(idx<<1) + 1];
+  }
+
+  port_freq_indices_t *port_freq_indices = (port_freq_indices_t *)malloc(table_params.ports*sizeof(port_freq_indices));
+  int32_t snr = 0;
+  int16_t ch[2] = {0}, noiseFig[2] = {0};
+  for (uint8_t rxAnt = 0; rxAnt < frame_parms->nb_antennas_rx; rxAnt++) {
+    snr = 0;
+    int16_t *pil = (int16_t *)&mod_csi[0];
+    for (uint8_t rb = csi_params->start_rb; rb < csi_params->start_rb + csi_params->nr_of_rbs; rb++) {
+      // calculate RE offset
+      get_csi_rs_freq_ind_sl(frame_parms, rb, csi_params, &table_params, port_freq_indices);
+      // Channel estimation and interpolation
+      int16_t *rxF = (int16_t *)&rxdataF[rxAnt][csi_params->symb_l0 * frame_parms->ofdm_symbol_size + port_freq_indices[rxAnt].k];
+
+      //Start pilot
+      c16_t ch_tmp_buf[ue->frame_parms.ofdm_symbol_size] __attribute__((aligned(32)));
+      memset(ch_tmp_buf, 0, sizeof(ch_tmp_buf));
+      ch[0] = (int16_t)(((int32_t)rxF[0]*pil[0] + (int32_t)rxF[1]*pil[1])>>15);
+      ch[1] = (int16_t)(((int32_t)rxF[1]*pil[0] - (int32_t)rxF[0]*pil[1])>>15);
+      multadd_real_vector_complex_scalar(fl, ch, (int16_t *)ch_tmp_buf, 8);
+
+      //SNR estimation
+      noiseFig[0] = rxF[0] - (int16_t)(((int32_t)ch[0]*pil[0] - (int32_t)ch[1]*pil[1])>>15);
+      noiseFig[1] = rxF[1] - (int16_t)(((int32_t)ch[1]*pil[0] + (int32_t)ch[0]*pil[1])>>15);
+      snr += 10 * log10(squaredMod(*(c16_t*)rxF) - squaredMod(*(c16_t*)noiseFig)) - 10 * log10(squaredMod(*(c16_t*)noiseFig));
+#ifdef DEBUG_CSI_PRINTS
+      LOG_I(NR_PHY, "[Rx %d] symbol %d, carrier %d, SNR %+2d dB: rxF - > (%+3d, %+3d) addr %p  ch -> (%+3d, %+3d), pil -> (%+d, %+d) \n",
+            rxAnt,
+            csi_params->symb_l0,
+            port_freq_indices[rxAnt].k,
+            snr/((rb-csi_params->start_rb)+1),
+            rxF[0],
+            rxF[1],
+            &rxF[0],
+            ch[0],
+            ch[1],
+            pil[0],
+            pil[1]);
+#endif
+      pil += 2;
+    } // iterate over all rbs
+    snr = snr / nrRECSI_RS;
+#ifdef DEBUG_CSI_PRINTS
+    LOG_I(NR_PHY, "[Rx %d] symbol %d Avg SNR %+2d dB, Number of pilots %d\n", rxAnt, csi_params->symb_l0, snr, nrRECSI_RS);
+#endif
+  }
+  free(port_freq_indices);
+  port_freq_indices = NULL;
+  return snr;
+}
+
 int nr_get_csi_rs_signal(const PHY_VARS_NR_UE *ue,
                          const UE_nr_rxtx_proc_t *proc,
                          const fapi_nr_dl_config_csirs_pdu_rel15_t *csirs_config_pdu,
@@ -838,12 +920,12 @@ int nr_ue_csi_im_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, c16_t r
 void nr_ue_csi_rs_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP])
 {
 
-  int gNB_id = proc->gNB_id;
-  if(!ue->csirs_vars[gNB_id]->active) {
+  int id = get_softmodem_params()->sl_mode == 2 ? 0 : proc->gNB_id;
+  if (!ue->csirs_vars[id]->active) {
     return;
   }
 
-  fapi_nr_dl_config_csirs_pdu_rel15_t *csirs_config_pdu = (fapi_nr_dl_config_csirs_pdu_rel15_t*)&ue->csirs_vars[gNB_id]->csirs_config_pdu;
+  fapi_nr_dl_config_csirs_pdu_rel15_t *csirs_config_pdu = (fapi_nr_dl_config_csirs_pdu_rel15_t*)&ue->csirs_vars[id]->csirs_config_pdu;
 
 #ifdef NR_CSIRS_DEBUG
   LOG_I(NR_PHY, "csirs_config_pdu->subcarrier_spacing = %i\n", csirs_config_pdu->subcarrier_spacing);
@@ -971,22 +1053,31 @@ void nr_ue_csi_rs_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, c16_t
 
   // bit 3 in bitmap to indicate RI measurment
   if (csirs_config_pdu->measurement_bitmap & 8) {
-    nr_csi_rs_pmi_estimation(ue,
-                             csirs_config_pdu,
-                             ue->nr_csi_info,
-                             N_ports,
-                             mem_offset,
-                             csi_rs_estimated_channel_freq,
-                             ue->nr_csi_info->csi_im_meas_computed ? ue->nr_csi_info->interference_plus_noise_power : noise_power,
-                             rank_indicator,
-                             log2_re,
-                             i1,
-                             i2,
-                             &precoded_sinr_dB);
+    if (get_softmodem_params()->sl_mode != 2)
+      nr_csi_rs_pmi_estimation(ue,
+                              csirs_config_pdu,
+                              ue->nr_csi_info,
+                              N_ports,
+                              mem_offset,
+                              csi_rs_estimated_channel_freq,
+                              ue->nr_csi_info->csi_im_meas_computed ? ue->nr_csi_info->interference_plus_noise_power : noise_power,
+                              rank_indicator,
+                              log2_re,
+                              i1,
+                              i2,
+                              &precoded_sinr_dB);
 
     // bit 4 in bitmap to indicate RI measurment
-    if(csirs_config_pdu->measurement_bitmap & 16)
-      nr_csi_rs_cqi_estimation(precoded_sinr_dB, &cqi);
+    if (csirs_config_pdu->measurement_bitmap & 16) {
+      if (get_softmodem_params()->sl_mode == 2) {
+        uint32_t snr = sl_csi_rs_snr_estimation(ue,
+                                                proc,
+                                                frame_parms,
+                                                rxdataF);
+        nr_csi_rs_cqi_estimation(snr, &cqi);
+      } else
+        nr_csi_rs_cqi_estimation(precoded_sinr_dB, &cqi);
+    }
   }
 
   switch (csirs_config_pdu->measurement_bitmap) {

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_ue.c

@@ -596,6 +596,7 @@ void nr_ue_ulsch_procedures(PHY_VARS_NR_UE *UE,
               LOG_D(NR_PHY, "Tx port_freq_indices.p %i, port_freq_indices.k %d, is_csi_rs %d, k = %i, RE %i, csi_rs_rb %i\n", port_freq_indices[nl].p, port_freq_indices[nl].k, is_csi_rs, k, i, csi_rs_rb);
             }
             free(port_freq_indices);
+            port_freq_indices = NULL;
           }
         }
 

openair1/SCHED_NR_UE/defs.h

@@ -137,6 +137,11 @@ int is_pbch_in_slot(fapi_nr_config_request_t *config, int frame, int slot, NR_DL
 int is_ssb_in_slot(fapi_nr_config_request_t *config, int frame, int slot, NR_DL_FRAME_PARMS *fp);
 bool is_csi_rs_in_symbol(fapi_nr_dl_config_csirs_pdu_rel15_t csirs_config_pdu, int symbol);
 
+int32_t sl_csi_rs_snr_estimation(PHY_VARS_NR_UE *ue,
+                                 UE_nr_rxtx_proc_t *proc,
+                                 const NR_DL_FRAME_PARMS *frame_parms,
+                                 c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]);
+
 /*! \brief This function prepares the dl indication to pass to the MAC
     @param
     @param
@@ -192,6 +197,8 @@ int nr_ue_csi_im_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, c16_t r
 
 void nr_ue_csi_rs_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]);
 
+int get_nRECSI_RS(uint8_t  freq_density,
+                  uint16_t nr_of_rbs);
 
 void psbch_pscch_pssch_processing(PHY_VARS_NR_UE *ue,
                                   UE_nr_rxtx_proc_t *proc,

openair2/LAYER2/NR_MAC_UE/mac_defs.h

@@ -540,6 +540,7 @@ typedef struct {
   NR_SL_BWP_ConfigCommon_r16_t *sl_bwp;
   NR_SL_ResourcePool_r16_t *sl_rx_res_pool;
   NR_SL_ResourcePool_r16_t *sl_tx_res_pool;
+  nr_sl_csi_report_t *sl_csi_report;
 
   bool phy_config_request_sent;
   frame_type_t frame_type;

openair2/LAYER2/NR_MAC_UE/mac_proto.h

@@ -578,7 +578,5 @@ void fill_psfch_pdu(sl_nr_tx_config_psfch_pdu_t *mac_psfch_pdu,
                     sl_nr_tx_config_request_t *tx_config,
                     int num_psfch_symbols);
 
-int get_nRECSI_RS(uint8_t  freq_density,
-                 uint16_t nr_of_rbs);
 #endif
 /** @}*/

openair2/LAYER2/NR_MAC_UE/nr_slsch_scheduler.c

@@ -52,15 +52,15 @@ bool nr_schedule_slsch(NR_UE_MAC_INST_t *mac, int frameP,int slotP, nr_sci_pdu_t
   uint8_t psfch_period = 0;
   if (mac->sl_tx_res_pool->sl_PSFCH_Config_r16 && mac->sl_tx_res_pool->sl_PSFCH_Config_r16->choice.setup->sl_PSFCH_Period_r16)
     psfch_period = *mac->sl_tx_res_pool->sl_PSFCH_Config_r16->choice.setup->sl_PSFCH_Period_r16;
-//   rlc_status.bytes_in_buffer = 0;
-   *slsch_pdu_length_max = 0;
-
-  if (rlc_status.bytes_in_buffer > 0 || mac->sci_pdu_rx.harq_feedback) {
-// Fill SCI1A
+  *slsch_pdu_length_max = 0;
+  bool csi_acq = !mac->SL_MAC_PARAMS->sl_CSI_Acquisition;
+  bool csi_req_slot = !((slots_per_frame * frameP + slotP - sl_mac->slot_offset) % sl_mac->slot_periodicity);
+  if (rlc_status.bytes_in_buffer > 0 || mac->sci_pdu_rx.harq_feedback || (csi_acq && csi_req_slot)) {
+     // Fill SCI1A
      sci_pdu->priority = 0;
-     sci_pdu->frequency_resource_assignment.val=0;
-     sci_pdu->time_resource_assignment.val=0;
-     sci_pdu->resource_reservation_period.val=0;   
+     sci_pdu->frequency_resource_assignment.val = 0;
+     sci_pdu->time_resource_assignment.val = 0;
+     sci_pdu->resource_reservation_period.val = 0;
      sci_pdu->dmrs_pattern.val = 0;
      sci_pdu->second_stage_sci_format = 0;
      sci_pdu->number_of_dmrs_port = 0;
@@ -71,21 +71,21 @@ bool nr_schedule_slsch(NR_UE_MAC_INST_t *mac, int frameP,int slotP, nr_sci_pdu_t
      sci_pdu->conflict_information_receiver.val = 0;
      sci_pdu->beta_offset_indicator = 0;
 
-// Fill SCI2A
+     // Fill SCI2A
      sci2_pdu->harq_pid = 0;
-     sci2_pdu->ndi = (1-sci2_pdu->ndi)&1;
+     sci2_pdu->ndi = (1 - sci2_pdu->ndi) & 1;
      sci2_pdu->rv_index = 0;
      sci2_pdu->source_id = get_softmodem_params()->node_number;
-     sci2_pdu->dest_id=0xabcd;
+     sci2_pdu->dest_id = 0xabcd;
      sci2_pdu->harq_feedback = psfch_period ? 1 : 0;
      sci2_pdu->cast_type = 1;
      if (format2 == NR_SL_SCI_FORMAT_2C || format2 == NR_SL_SCI_FORMAT_2A) {
-       sci2_pdu->csi_req = mac->SL_MAC_PARAMS->sl_CSI_Acquisition ? 0 :
-                           ((slots_per_frame * frameP + slotP - sl_mac->slot_offset) % sl_mac->slot_periodicity) && (!mac->SL_MAC_PARAMS->sl_CSI_Acquisition) ? 0 : 1;
+       sci2_pdu->csi_req = (csi_acq && csi_req_slot) ? 1 : 0;
+       LOG_D(NR_MAC, "Setting sci2_pdu->csi_req %d (%d.%d)\n", sci2_pdu->csi_req, frameP, slotP);
      }
      if (format2 == NR_SL_SCI_FORMAT_2B)
        sci2_pdu->zone_id = 0;
-   // Fill in for R17: communication_range
+     // Fill in for R17: communication_range
      sci2_pdu->communication_range.val = 0;
      if (format2 == NR_SL_SCI_FORMAT_2C) {
        sci2_pdu->providing_req_ind = 0;
@@ -98,11 +98,9 @@ bool nr_schedule_slsch(NR_UE_MAC_INST_t *mac, int frameP,int slotP, nr_sci_pdu_t
        // Fill in for R17 : lowest_subchannel_indices
        sci2_pdu->lowest_subchannel_indices.val = 0;
      }
-
-// Set SLSCH
-
+     // Set SLSCH
      *slsch_pdu_length_max = rlc_status.bytes_in_buffer;
-     return true; 
+     return true;
    }
    return false;
 }

openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c

@@ -3306,14 +3306,14 @@ bool nr_ue_sl_pssch_scheduler(NR_UE_MAC_INST_t *mac,
   int buflen = tx_config->tx_config_list[0].tx_pscch_pssch_config_pdu.tb_size;
 
   LOG_D(NR_MAC, "[UE%d] TTI-%d:%d TX PSCCH_PSSCH REQ  TBS %d\n", sl_ind->module_id, frame, slot, buflen);
-  
+
   NR_SLSCH_MAC_SUBHEADER_FIXED *sl_sch_subheader = (NR_SLSCH_MAC_SUBHEADER_FIXED *) pdu;
   sl_sch_subheader->V = 0;
   sl_sch_subheader->R = 0;
   sl_sch_subheader->SRC = get_softmodem_params()->node_number;
   sl_sch_subheader->DST = 0xab;
   pdu += sizeof(NR_SLSCH_MAC_SUBHEADER_FIXED);
-  LOG_D(NR_PHY, "V %d, R %d, SRC %d, DST %d\n", sl_sch_subheader->V, sl_sch_subheader->R, sl_sch_subheader->SRC, sl_sch_subheader->DST);
+  LOG_D(NR_PHY, "Tx V %d, R %d, SRC %d, DST %d\n", sl_sch_subheader->V, sl_sch_subheader->R, sl_sch_subheader->SRC, sl_sch_subheader->DST);
   int buflen_remain = buflen - sizeof(NR_SLSCH_MAC_SUBHEADER_FIXED);
   LOG_D(NR_PHY, "buflen_remain after adding SL_SCH_MAC_SUBHEADER_FIXED %d\n", buflen_remain);
 
@@ -3381,13 +3381,29 @@ bool nr_ue_sl_pssch_scheduler(NR_UE_MAC_INST_t *mac,
     mac_ce_p->phr_len = 0;
     mac_ce_p->sdu_length_total = sdu_length_total;
     mac_ce_p->total_mac_pdu_header_len = total_mac_pdu_header_len;
-    LOG_D(NR_MAC, "[UE%d] TTI-%d:%d TX PSCCH_PSSCH REQ  TBS %d\n", sl_ind->module_id, frame, slot, buflen);
 
     //nr_ue_get_sdu_mac_ce_pre updates all mac_ce related header field related to length
     mac_ce_p->tot_mac_ce_len = nr_ue_get_sdu_mac_ce_pre(0, 0, frame, slot, 0, pdu, buflen, mac_ce_p);
     buflen_remain -= mac_ce_p->tot_mac_ce_len;
     pdu += mac_ce_p->tot_mac_ce_len;
-    LOG_D(NR_PHY, "buflen_remain %d, total_mac_pdu_header_len %d, adding tot_mac_ce_len %d, \n", buflen_remain, mac_ce_p->total_mac_pdu_header_len, mac_ce_p->tot_mac_ce_len);
+    LOG_D(NR_PHY, "buflen_remain %d, sdu_length_total %d, total_mac_pdu_header_len %d, adding tot_mac_ce_len %d, \n", buflen_remain, mac_ce_p->sdu_length_total, mac_ce_p->total_mac_pdu_header_len, mac_ce_p->tot_mac_ce_len);
+  }
+
+  if (buflen_remain > 0) {
+    if (mac->sl_csi_report != NULL) {
+      ((NR_MAC_SUBHEADER_FIXED *) pdu)->R = 0;
+      ((NR_MAC_SUBHEADER_FIXED *) pdu)->LCID = SL_SCH_LCID_SL_CSI_REPORT;
+      pdu++;
+      buflen_remain--;
+      ((nr_sl_csi_report_t *) pdu)->RI = mac->sl_csi_report->RI;
+      ((nr_sl_csi_report_t *) pdu)->CQI = mac->sl_csi_report->CQI;
+      ((nr_sl_csi_report_t *) pdu)->R = mac->sl_csi_report->R;
+      LOG_D(NR_MAC, "%4d.%2d Sending sl_csi_report with CQI %i, RI %i\n", frame, slot, ((nr_sl_csi_report_t *) pdu)->CQI, ((nr_sl_csi_report_t *) pdu)->RI);
+      pdu++;
+      buflen_remain--;
+      free(mac->sl_csi_report);
+      mac->sl_csi_report = NULL;
+    }
   }
 
   if (buflen_remain > 0) {
@@ -3599,7 +3615,7 @@ void nr_ue_sidelink_scheduler(nr_sidelink_indication_t *sl_ind) {
       nr_ue_sl_pscch_rx_scheduler(sl_ind, mac->sl_bwp, mac->sl_rx_res_pool,&rx_config, &tti_action);
   }
 
-  if (!is_psbch_slot && tx_allowed && sl_ind->slot_type == SIDELINK_SLOT_TYPE_TX) {
+  if (!is_psbch_slot && tx_allowed) {
     //Check if reserved slot or a sidelink resource configured in Rx/Tx resource pool timeresource bitmap
     bool schedule_slsch = nr_ue_sl_pssch_scheduler(mac, sl_ind, mac->sl_bwp, mac->sl_tx_res_pool, &tx_config, &tti_action);
     bool is_csi_rs_sent = false;
@@ -3607,10 +3623,9 @@ void nr_ue_sidelink_scheduler(nr_sidelink_indication_t *sl_ind) {
           schedule_slsch && mac->sci2_pdu.csi_req) {
       nr_ue_sl_csi_rs_scheduler(mac, mu, mac->sl_bwp, &tx_config, NULL, &tti_action);
       is_csi_rs_sent = true;
-      mac->sci2_pdu.csi_req = 0;
-      LOG_D(NR_MAC, "%d.%d Scheduling CSI-RS\n", frame, slot);
+      LOG_D(NR_MAC, "%4d.%2d Scheduling CSI-RS\n", frame, slot);
     }
-    if (mac->sci_pdu_rx.harq_feedback &&  mac->sl_tx_res_pool->sl_PSFCH_Config_r16 &&  mac->sl_tx_res_pool->sl_PSFCH_Config_r16->choice.setup) {
+    if (mac->sci_pdu_rx.harq_feedback) {
       NR_SL_PSFCH_Config_r16_t *sl_psfch_config = mac->sl_tx_res_pool->sl_PSFCH_Config_r16->choice.setup;
       const uint8_t psfch_periods[] = {0,1,2,4};
       long psfch_period = (sl_psfch_config->sl_PSFCH_Period_r16)

openair2/LAYER2/NR_MAC_UE/nr_ue_sci_slsch.c

@@ -247,7 +247,7 @@ void fill_pssch_pscch_pdu(sl_nr_ue_mac_params_t *sl_mac_params,
   //(Total Sidelink symbols available - number of psfch symbols configured - 2)
   //Guard symbol + AGC symbol are also excluded
   //Indicates the number of symbols for PSCCH+PSSCH txn
-  int num_psfch_symbols=0;
+  int num_psfch_symbols = 0;
   LOG_D(NR_MAC,"startrb %d, pscch_numsym %d, pscch_numrbs %d,pscch_dmrs_scrambling_id %d,num_subch%d,subchannel_size%d\n",
   nr_sl_pssch_pscch_pdu->startrb,
   nr_sl_pssch_pscch_pdu->pscch_numsym,
@@ -259,7 +259,7 @@ void fill_pssch_pscch_pdu(sl_nr_ue_mac_params_t *sl_mac_params,
      // As per 38214 8.1.3.2, num_psfch_symbols can be 3 if psfch_overhead_indication.nbits is 1; FYI psfch_overhead_indication.nbits is set to 1 in case of PSFCH period 2 or 4 in sl_determine_sci_1a_len()
      num_psfch_symbols = 3;
   }
-  nr_sl_pssch_pscch_pdu->pssch_numsym=7+*sl_bwp->sl_BWP_Generic_r16->sl_LengthSymbols_r16-num_psfch_symbols-2;
+  nr_sl_pssch_pscch_pdu->pssch_numsym = 7 + *sl_bwp->sl_BWP_Generic_r16->sl_LengthSymbols_r16 - num_psfch_symbols - 2;
   nr_sl_pssch_pscch_pdu->pssch_startsym = *sl_bwp->sl_BWP_Generic_r16->sl_StartSymbol_r16;
 
   nr_sl_pssch_pscch_pdu->sci2_beta_offset = *sl_res_pool->sl_PSSCH_Config_r16->choice.setup->sl_BetaOffsets2ndSCI_r16->list.array[sci_pdu->beta_offset_indicator];
@@ -500,7 +500,7 @@ void config_pscch_pdu_rx(sl_nr_rx_config_pscch_pdu_t *nr_sl_pscch_pdu,
   //(Total Sidelink symbols available - number of psfch symbols configured - 2)
   //Guard symbol + AGC symbol are also excluded
   //Indicates the number of symbols for PSCCH+PSSCH txn
-  int num_psfch_symbols=0;
+  int num_psfch_symbols = 0;
   if (sl_res_pool->sl_PSFCH_Config_r16 && sl_res_pool->sl_PSFCH_Config_r16->choice.setup->sl_PSFCH_Period_r16 && *sl_res_pool->sl_PSFCH_Config_r16->choice.setup->sl_PSFCH_Period_r16>0) {
      // As per 38214 8.1.3.2, num_psfch_symbols can be 3 if psfch_overhead_indication.nbits is 1; FYI psfch_overhead_indication.nbits is set to 1 in case of PSFCH period 2 or 4 in sl_determine_sci_1a_len()
      num_psfch_symbols = 3;
@@ -661,12 +661,12 @@ void config_pssch_slsch_pdu_rx(sl_nr_rx_config_pssch_pdu_t *nr_sl_pssch_pdu,
   nr_sl_pssch_pdu->tbslbrm = nr_compute_tbslbrm(sci_pdu->additional_mcs.val,
 		                                NRRIV2BW(sl_bwp->sl_BWP_Generic_r16->sl_BWP_r16->locationAndBandwidth,273),
 						nr_sl_pssch_pdu->num_layers);
-  int num_psfch_symbols=0;
+  int num_psfch_symbols = 0;
   if (sl_res_pool->sl_PSFCH_Config_r16 && sl_res_pool->sl_PSFCH_Config_r16->choice.setup->sl_PSFCH_Period_r16 && *sl_res_pool->sl_PSFCH_Config_r16->choice.setup->sl_PSFCH_Period_r16>0) {
      // As per 38214 8.1.3.2, num_psfch_symbols can be 3 if psfch_overhead_indication.nbits is 1; FYI psfch_overhead_indication.nbits is set to 1 in case of PSFCH period 2 or 4 in sl_determine_sci_1a_len()
      num_psfch_symbols = 3;
   }
-  int pssch_numsym=7+*sl_bwp->sl_BWP_Generic_r16->sl_LengthSymbols_r16-num_psfch_symbols-2;
+  int pssch_numsym = 7 + *sl_bwp->sl_BWP_Generic_r16->sl_LengthSymbols_r16 - num_psfch_symbols - 2;
   uint16_t l_subch;
   convNRFRIV(sci_pdu->frequency_resource_assignment.val,
 	     *sl_res_pool->sl_NumSubchannel_r16,
@@ -757,7 +757,7 @@ int config_pssch_sci_pdu_rx(sl_nr_rx_config_pssch_sci_pdu_t *nr_sl_pssch_sci_pdu
   //(Total Sidelink symbols available - number of psfch symbols configured - 2)
   //Guard symbol + AGC symbol are also excluded
   //Indicates the number of symbols for PSCCH+PSSCH txn
-  int num_psfch_symbols=0;
+  int num_psfch_symbols = 0;
   if (sl_res_pool->sl_PSFCH_Config_r16 && sl_res_pool->sl_PSFCH_Config_r16->choice.setup->sl_PSFCH_Period_r16 && *sl_res_pool->sl_PSFCH_Config_r16->choice.setup->sl_PSFCH_Period_r16>0) {
      // As per 38214 8.1.3.2, num_psfch_symbols can be 3 if psfch_overhead_indication.nbits is 1; FYI psfch_overhead_indication.nbits is set to 1 in case of PSFCH period 2 or 4 in sl_determine_sci_1a_len()
      num_psfch_symbols = 3;
@@ -826,8 +826,6 @@ int nr_ue_process_sci2_indication_pdu(NR_UE_MAC_INST_t *mac, module_id_t mod_id,
   rx_config.sl_rx_config_list[0].pdu_type =  SL_NR_CONFIG_TYPE_RX_PSSCH_SLSCH;
   sl_nr_phy_config_request_t *sl_cfg = &mac->SL_MAC_PARAMS->sl_phy_config.sl_config_req;
   uint8_t mu = sl_cfg->sl_bwp_config.sl_scs;
-  uint8_t slots_per_frame = nr_slots_per_frame[mu];
-
   if ((!mac->SL_MAC_PARAMS->sl_CSI_Acquisition) &&
      sci_pdu->csi_req) {
     sl_nr_phy_config_request_t *sl_cfg = &sl_mac_params->sl_phy_config.sl_config_req;