calling dlsch detection in initial sync for sib1

executables/nr-ue.c

@@ -215,7 +215,7 @@ static void UE_synch(void *arg) {
       double rx_gain_off = 0;
       nr_get_carrier_frequencies(&UE->frame_parms, &dl_carrier, &ul_carrier);
 
-      if (nr_initial_sync(&syncD->proc, UE, 2, get_softmodem_params()->sa) == 0) {
+      if (nr_initial_sync(&syncD->proc, UE, 2, get_softmodem_params()->sa, get_nrUE_params()->nr_dlsch_parallel) == 0) {
         freq_offset = UE->common_vars.freq_offset; // frequency offset computed with pss in initial sync
         hw_slot_offset = ((UE->rx_offset<<1) / UE->frame_parms.samples_per_subframe * UE->frame_parms.slots_per_subframe) +
                          round((float)((UE->rx_offset<<1) % UE->frame_parms.samples_per_subframe)/UE->frame_parms.samples_per_slot0);

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c

@@ -720,11 +720,11 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
 }
 
 void nr_dlsch_deinterleaving(uint8_t symbol,
-							uint8_t start_symbol,
-							uint16_t L,
-							uint16_t *llr,
-							uint16_t *llr_deint,
-							uint16_t nb_rb_pdsch)
+                             uint8_t start_symbol,
+                             uint16_t L,
+                             uint16_t *llr,
+                             uint16_t *llr_deint,
+                             uint16_t nb_rb_pdsch)
 {
 
   uint32_t bundle_idx, N_bundle, R, C, r,c;

openair1/PHY/NR_UE_TRANSPORT/nr_initial_sync.c

@@ -202,7 +202,10 @@ int nr_pbch_detection(UE_nr_rxtx_proc_t * proc, PHY_VARS_NR_UE *ue, int pbch_ini
 char duplex_string[2][4] = {"FDD","TDD"};
 char prefix_string[2][9] = {"NORMAL","EXTENDED"};
 
-int nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *ue, int n_frames, int sa)
+int nr_initial_sync(UE_nr_rxtx_proc_t *proc,
+                    PHY_VARS_NR_UE *ue,
+                    int n_frames, int sa,
+                    int dlsch_parallel)
 {
 
   int32_t sync_pos, sync_pos_frame; // k_ssb, N_ssb_crb, sync_pos2,
@@ -482,11 +485,12 @@ int nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *ue, int n_frames, i
   // if stand alone and sync on ssb do sib1 detection as part of initial sync
   if (sa==1 && ret==0) {
     NR_UE_PDCCH *pdcch_vars  = ue->pdcch_vars[proc->thread_id][0];
-    uint8_t nb_symb_pdcch = pdcch_vars->nb_search_space > 0 ? pdcch_vars->pdcch_config[0].coreset.duration : 0;
+    int gnb_id = 0; //FIXME
     int coreset_nb_rb=0;
     int coreset_start_rb=0;
 
     for(int n_ss = 0; n_ss<pdcch_vars->nb_search_space; n_ss++) {
+      uint8_t nb_symb_pdcch = pdcch_vars->pdcch_config[n_ss].coreset.duration : 0;
       get_coreset_rballoc(pdcch_vars->pdcch_config[n_ss].coreset.frequency_domain_resource,&coreset_nb_rb,&coreset_start_rb);
 
       for (uint16_t l=0; l<nb_symb_pdcch; l++) {
@@ -506,8 +510,42 @@ int nr_initial_sync(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *ue, int n_frames, i
                                       coreset_nb_rb);
 
       }
-      int  dci_cnt = nr_ue_pdcch_procedures(0, ue, proc, n_ss); //gNB_id set to 0
+      int  dci_cnt = nr_ue_pdcch_procedures(gnb_id, ue, proc, n_ss);
       if (dci_cnt>0){
+        NR_UE_DLSCH_t *dlsch = ue->dlsch_SI[gnb_id];
+        if (dlsch && (dlsch->active == 1)) {
+          uint8_t harq_pid = dlsch->current_harq_pid;
+          NR_DL_UE_HARQ_t *dlsch0_harq = dlsch->harq_processes[harq_pid];
+          uint16_t nb_symb_sch = dlsch0_harq->nb_symbols;
+          uint16_t start_symb_sch = dlsch0_harq->start_symbol;
+
+          for (uint16_t m=start_symb_sch;m<(nb_symb_sch+start_symb_sch) ; m++){
+            nr_slot_fep_init_sync(ue,
+                                  proc,
+                                  m,
+                                  pdcch_vars->slot,  // same slot and offset as pdcch
+                                  pdcch_vars->sfn*fp->samples_per_frame+ue->rx_offset);
+          }
+
+          int ret = nr_ue_pdsch_procedures(ue,
+                                           proc,
+                                           gnb_id,
+                                           SI_PDSCH,
+                                           ue->dlsch_SI[gnb_id],
+                                           NULL);
+          if (ret >= 0)
+            nr_ue_dlsch_procedures(ue,
+                                   proc,
+                                   gnb_id,
+                                   SI_PDSCH,
+                                   ue->dlsch_SI[gnb_id],
+                                   NULL,
+                                   &ue->dlsch_SI_errors[gnb_id],
+                                   dlsch_parallel);
+
+          // deactivate dlsch once dlsch proc is done
+          ue->dlsch_SI[gnb_id]->active = 0;
+        }
         break;
       }
     }

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -1458,7 +1458,8 @@ void generate_RIV_tables(void);
 int nr_initial_sync(UE_nr_rxtx_proc_t *proc,
                     PHY_VARS_NR_UE *phy_vars_ue, 
                     int n_frames,
-                    int sa);
+                    int sa,
+                    int dlsch_parallel);
 
 /*!
   \brief This function gets the carrier frequencies either from FP or command-line-set global variables, depending on the availability of the latter

openair1/SCHED_NR_UE/defs.h

@@ -416,6 +416,20 @@ void nr_fill_rx_indication(fapi_nr_rx_indication_t *rx_ind,
                            NR_UE_DLSCH_t *dlsch0,
                            uint16_t n_pdus);
 
+void nr_ue_dlsch_procedures(PHY_VARS_NR_UE *ue,
+       UE_nr_rxtx_proc_t *proc,
+       int gNB_id,
+       PDSCH_t pdsch,
+       NR_UE_DLSCH_t *dlsch0,
+       NR_UE_DLSCH_t *dlsch1,
+       int *dlsch_errors,
+       uint8_t dlsch_parallel);
+
+int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
+                           UE_nr_rxtx_proc_t *proc,
+                           int eNB_id, PDSCH_t pdsch,
+                           NR_UE_DLSCH_t *dlsch0, NR_UE_DLSCH_t *dlsch1);
+
 int nr_ue_pdcch_procedures(uint8_t gNB_id,
 			   PHY_VARS_NR_UE *ue,
 			   UE_nr_rxtx_proc_t *proc,

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -682,7 +682,7 @@ int main(int argc, char **argv)
       }
       if (UE->is_synchronized == 0) {
 	UE_nr_rxtx_proc_t proc={0};
-	ret = nr_initial_sync(&proc, UE, 1, 0);
+	ret = nr_initial_sync(&proc, UE, 1, 0, 0);
 	printf("nr_initial_sync1 returns %d\n",ret);
 	if (ret<0) n_errors++;
       }