Merge with branch NR_RRC_PRACH_procedures

executables/nr-gnb.c

@@ -93,18 +93,16 @@
 // extern openair0_device openair0;
 
 
-#if defined(ENABLE_ITTI)
-  extern volatile int start_gNB;
-  extern volatile int start_UE;
-#endif
+extern volatile int start_gNB;
+extern volatile int start_UE;
 extern volatile int oai_exit;
 
 extern openair0_config_t openair0_cfg[MAX_CARDS];
 
 extern int transmission_mode;
 
-uint16_t sf_ahead=3;
-uint16_t sl_ahead;
+extern uint16_t sf_ahead;
+extern uint16_t sl_ahead;
 //pthread_t                       main_gNB_thread;
 
 time_stats_t softmodem_stats_mt; // main thread
@@ -377,7 +375,7 @@ static void *gNB_L1_thread( void *param ) {
 }
 
 
-#if 0 //defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
+#if 0 
 // Wait for gNB application initialization to be complete (gNB registration to MME)
 static void wait_system_ready (char *message, volatile int *start_flag) {
   static char *indicator[] = {".    ", "..   ", "...  ", ".... ", ".....",

executables/nr-ru.c

@@ -132,8 +132,8 @@ void configure_rru(int idx, void *arg);
 int attach_rru(RU_t *ru);
 int connect_rau(RU_t *ru);
 
-extern uint16_t sf_ahead;
-extern uint16_t sl_ahead;
+uint16_t sf_ahead;
+uint16_t sl_ahead;
 
 extern int emulate_rf;
 extern int numerology;
@@ -1499,6 +1499,7 @@ void *ru_thread( void *param ) {
     }
   }
 
+  sf_ahead = (uint16_t) ceil((float)6/(0x01<<fp->numerology_index));
   LOG_I(PHY, "Signaling main thread that RU %d is ready\n",ru->idx);
   pthread_mutex_lock(&RC.ru_mutex);
   RC.ru_mask &= ~(1<<ru->idx);

executables/nr-softmodem-common.h

@@ -143,9 +143,7 @@ extern int sync_var;
 extern int transmission_mode;
 extern double cpuf;
 
-#if defined(ENABLE_ITTI)
-  extern volatile int start_eNB;
-  extern volatile int start_UE;
-#endif
+extern volatile int start_eNB;
+extern volatile int start_UE;
 
 #endif

executables/nr-softmodem.c

@@ -71,9 +71,7 @@ unsigned short config_frames[4] = {2,9,11,13};
   #include "UTIL/OTG/otg_vars.h"
 #endif
 
-#if defined(ENABLE_ITTI)
-  #include "intertask_interface.h"
-#endif
+#include "intertask_interface.h"
 
 #include "PHY/INIT/phy_init.h"
 
@@ -102,9 +100,7 @@ pthread_mutex_t sync_mutex;
 int sync_var=-1; //!< protected by mutex \ref sync_mutex.
 int config_sync_var=-1;
 
-#if defined(ENABLE_ITTI)
-  volatile int             start_gNB = 0;
-#endif
+volatile int             start_gNB = 0;
 volatile int             oai_exit = 0;
 
 static int wait_for_sync = 0;
@@ -120,9 +116,7 @@ int32_t uplink_frequency_offset[MAX_NUM_CCs][4];
 //Temp fix for inexistent NR upper layer
 unsigned char NB_gNB_INST = 1;
 
-#if defined(ENABLE_ITTI)
-  static char                    *itti_dump_file = NULL;
-#endif
+static char                    *itti_dump_file = NULL;
 
 int UE_scan = 1;
 int UE_scan_carrier = 0;
@@ -304,7 +298,7 @@ void exit_function(const char *file, const char *function, const int line, const
   exit(1);
 }
 
-#if defined(ENABLE_ITTI)
+
 void *l2l1_task(void *arg) {
   MessageDef *message_p = NULL;
   int         result;
@@ -377,7 +371,6 @@ void *l2l1_task(void *arg) {
   */
   return NULL;
 }
-#endif
 
 int create_gNB_tasks(uint32_t gnb_nb) {
   LOG_D(GNB_APP, "%s(gnb_nb:%d)\n", __FUNCTION__, gnb_nb);
@@ -654,7 +647,6 @@ void wait_gNBs(void) {
   printf("gNB L1 are configured\n");
 }
 
-#if defined(ENABLE_ITTI)
 /*
  * helper function to terminate a certain ITTI task
  */
@@ -769,7 +761,6 @@ int restart_L1L2(module_id_t gnb_id) {
   pthread_mutex_unlock(&sync_mutex);
   return 0;
 }
-#endif
 
 static  void wait_nfapi_init(char *thread_name) {
   printf( "waiting for NFAPI PNF connection and population of global structure (%s)\n",thread_name);
@@ -828,7 +819,7 @@ int main( int argc, char **argv )
   configure_linux();
   printf("Reading in command-line options\n");
   get_options ();
-  get_common_options();
+  get_common_options(SOFTMODEM_GNB_BIT );
 
   if (CONFIG_ISFLAGSET(CONFIG_ABORT) ) {
     fprintf(stderr,"Getting configuration failed\n");
@@ -850,16 +841,16 @@ int main( int argc, char **argv )
   }
 
   cpuf=get_cpu_freq_GHz();
-#if defined(ENABLE_ITTI)
   itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info);
   // initialize mscgen log after ITTI
   MSC_INIT(MSC_E_UTRAN, THREAD_MAX+TASK_MAX);
-#endif
+
 
 init_opt();
 
 
 #ifdef PDCP_USE_NETLINK
+if(!IS_SOFTMODEM_NOS1)
   netlink_init();
 #if defined(PDCP_USE_NETLINK_QUEUES)
   pdcp_netlink_init();
@@ -874,7 +865,6 @@ init_opt();
   if(IS_SOFTMODEM_NOS1)
 	  init_pdcp();
 
-
   if (RC.nb_nr_inst > 0)  {
     // don't create if node doesn't connect to RRC/S1/GTP
     AssertFatal(create_gNB_tasks(1) == 0,"cannot create ITTI tasks\n");
@@ -883,8 +873,6 @@ init_opt();
     RCconfig_L1();
   }
 
-
-  
   /* Start the agent. If it is turned off in the configuration, it won't start */
   /*
   RCconfig_nr_flexran();
@@ -998,20 +986,34 @@ init_opt();
   // wait for end of program
   printf("TYPE <CTRL-C> TO TERMINATE\n");
   //getchar();
-#if defined(ENABLE_ITTI)
   printf("Entering ITTI signals handler\n");
   itti_wait_tasks_end();
   printf("Returned from ITTI signal handler\n");
   oai_exit=1;
   printf("oai_exit=%d\n",oai_exit);
-#else
 
-  while (oai_exit==0)
-    sleep(1);
+  // stop threads
+/*#ifdef XFORMS
 
-  printf("Terminating application - oai_exit=%d\n",oai_exit);
-#endif
-  // stop threads  
+    printf("waiting for XFORMS thread\n");
+
+    if (do_forms==1) {
+      pthread_join(forms_thread,&status);
+      fl_hide_form(form_stats->stats_form);
+      fl_free_form(form_stats->stats_form);
+
+        fl_hide_form(form_stats_l2->stats_form);
+        fl_free_form(form_stats_l2->stats_form);
+
+        for(UE_id=0; UE_id<scope_enb_num_ue; UE_id++) {
+    for(CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+      fl_hide_form(form_enb[CC_id][UE_id]->phy_scope_gNB);
+      fl_free_form(form_enb[CC_id][UE_id]->phy_scope_gNB);
+    }
+        }
+    }
+
+#endif*/
   printf("stopping MODEM threads\n");
   // cleanup
   stop_gNB(NB_gNB_INST);

executables/nr-ue.c

@@ -142,15 +142,23 @@ void init_nr_ue_vars(PHY_VARS_NR_UE *ue,
                      uint8_t abstraction_flag)
 {
 
+  int nb_connected_gNB = 1, gNB_id;
+
   memcpy(&(ue->frame_parms), frame_parms, sizeof(NR_DL_FRAME_PARMS));
 
   ue->Mod_id      = UE_id;
   ue->mac_enabled = 1;
 
+  // Setting UE mode to NOT_SYNCHED by default
+  for (gNB_id = 0; gNB_id < nb_connected_gNB; gNB_id++){
+    ue->UE_mode[gNB_id] = NOT_SYNCHED;
+    ue->prach_resources[gNB_id] = (NR_PRACH_RESOURCES_t *)malloc16_clear(sizeof(NR_PRACH_RESOURCES_t));
+  }
+
   // initialize all signal buffers
-  init_nr_ue_signal(ue,1,abstraction_flag);
+  init_nr_ue_signal(ue, nb_connected_gNB, abstraction_flag);
   // intialize transport
-  init_nr_ue_transport(ue,abstraction_flag);
+  init_nr_ue_transport(ue, abstraction_flag);
 }
 
 /*!
@@ -366,7 +374,7 @@ void processSlotTX( PHY_VARS_NR_UE *UE, UE_nr_rxtx_proc_t *proc) {
   nr_scheduled_response_t scheduled_response;
 
   // program PUSCH. this should actually be done by the MAC upon reception of an UL DCI
-  if (proc->nr_tti_tx == 8 || UE->frame_parms.frame_type == FDD){
+  if (proc->nr_tti_tx == 8 || proc->nr_tti_tx == 19 || UE->frame_parms.frame_type == FDD){
 
     mod_id = UE->Mod_id;
 
@@ -412,7 +420,7 @@ void processSlotTX( PHY_VARS_NR_UE *UE, UE_nr_rxtx_proc_t *proc) {
     nr_ue_scheduled_response(&scheduled_response);
 
     if (UE->mode != loop_through_memory) {
-      uint8_t thread_id = PHY_vars_UE_g[UE->Mod_id][0]->current_thread_id[proc->nr_tti_tx];
+      uint8_t thread_id = PHY_vars_UE_g[mod_id][0]->current_thread_id[proc->nr_tti_tx];
       phy_procedures_nrUE_TX(UE,proc,0,thread_id);
     }
   }
@@ -463,6 +471,7 @@ void processSlotRX( PHY_VARS_NR_UE *UE, UE_nr_rxtx_proc_t *proc) {
     LOG_D(PHY,"phy_procedures_nrUE_RX: slot:%d, time %lu\n", proc->nr_tti_rx, (rdtsc()-a)/3500);
     //printf(">>> nr_ue_pdcch_procedures ended\n");
 #endif
+
     if(IS_SOFTMODEM_NOS1){ //&& proc->nr_tti_rx==1
       //Hardcoded rnti value
       protocol_ctxt_t ctxt;
@@ -470,7 +479,6 @@ void processSlotRX( PHY_VARS_NR_UE *UE, UE_nr_rxtx_proc_t *proc) {
 				     0x1234, proc->frame_rx,
 				     proc->nr_tti_rx, 0);
       pdcp_run(&ctxt);
-      pdcp_fifo_flush_sdus(&ctxt);
     }
   }
 }
@@ -531,8 +539,10 @@ void UE_processing(void *arg) {
       ul_indication.module_id = mod_id;
       ul_indication.gNB_index = gNB_id;
       ul_indication.cc_id     = CC_id;
-      ul_indication.frame     = proc->frame_rx;
-      ul_indication.slot      = proc->nr_tti_rx;
+      ul_indication.frame_rx  = proc->frame_rx;
+      ul_indication.slot_rx   = proc->nr_tti_rx;
+      ul_indication.frame_tx  = proc->frame_tx;
+      ul_indication.slot_tx   = proc->nr_tti_tx;
       UE->if_inst->ul_indication(&ul_indication);
     }
   }
@@ -596,30 +606,24 @@ void syncInFrame(PHY_VARS_NR_UE *UE, openair0_timestamp *timestamp) {
     LOG_I(PHY,"Resynchronizing RX by %d samples (mode = %d)\n",UE->rx_offset,UE->mode);
     void *dummy_tx[UE->frame_parms.nb_antennas_tx];
 
-    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-      dummy_tx[i]=malloc16_clear(UE->frame_parms.samples_per_subframe*4);
-
+    *timestamp += UE->frame_parms.get_samples_per_slot(1,&UE->frame_parms);
     for ( int size=UE->rx_offset ; size > 0 ; size -= UE->frame_parms.samples_per_subframe ) {
       int unitTransfer=size>UE->frame_parms.samples_per_subframe ? UE->frame_parms.samples_per_subframe : size ;
+      // we write before read becasue gNB waits for UE to write and both executions halt
+      // this happens here as the read size is samples_per_subframe which is very much larger than samp_per_slot
+      if (IS_SOFTMODEM_RFSIM) dummyWrite(UE,*timestamp, unitTransfer);
       AssertFatal(unitTransfer ==
                   UE->rfdevice.trx_read_func(&UE->rfdevice,
                                              timestamp,
                                              (void **)UE->common_vars.rxdata,
                                              unitTransfer,
                                              UE->frame_parms.nb_antennas_rx),"");
+      *timestamp += unitTransfer; // this does not affect the read but needed for RFSIM write
     }
 
-    for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
-      free(dummy_tx[i]);
-
 }
 
 int computeSamplesShift(PHY_VARS_NR_UE *UE) {
-  if (IS_SOFTMODEM_RFSIM) {
-    LOG_E(PHY,"SET rx_offset %d \n",UE->rx_offset);
-    //UE->rx_offset_diff=0;
-    return 0;
-  }
 
   // compute TO compensation that should be applied for this frame
   if ( UE->rx_offset < UE->frame_parms.samples_per_frame/2  &&
@@ -637,6 +641,22 @@ int computeSamplesShift(PHY_VARS_NR_UE *UE) {
   return 0;
 }
 
+static inline int get_firstSymSamp(uint16_t slot, NR_DL_FRAME_PARMS *fp) {
+  if (fp->numerology_index == 0)
+    return fp->nb_prefix_samples0 + fp->ofdm_symbol_size;
+  int num_samples = (slot%(fp->slots_per_subframe/2)) ? fp->nb_prefix_samples : fp->nb_prefix_samples0;
+  num_samples += fp->ofdm_symbol_size;
+  return num_samples;
+}
+
+static inline int get_readBlockSize(uint16_t slot, NR_DL_FRAME_PARMS *fp) {
+  int rem_samples = fp->get_samples_per_slot(slot, fp) - get_firstSymSamp(slot, fp);
+  int next_slot_first_symbol = 0;
+  if (slot < (fp->slots_per_frame-1))
+    next_slot_first_symbol = get_firstSymSamp(slot+1, fp);
+  return rem_samples + next_slot_first_symbol;
+}
+
 void *UE_thread(void *arg) {
   //this thread should be over the processing thread to keep in real time
   PHY_VARS_NR_UE *UE = (PHY_VARS_NR_UE *) arg;
@@ -653,6 +673,7 @@ void *UE_thread(void *arg) {
   int thread_idx=0;
   notifiedFIFO_t freeBlocks;
   initNotifiedFIFO_nothreadSafe(&freeBlocks);
+  NR_UE_MAC_INST_t *mac = get_mac_inst(0);
 
   for (int i=0; i<RX_NB_TH+1; i++)  // RX_NB_TH working + 1 we are making to be pushed
     pushNotifiedFIFO_nothreadSafe(&freeBlocks,
@@ -670,11 +691,11 @@ void *UE_thread(void *arg) {
         syncRunning=false;
         syncData_t *tmp=(syncData_t *)NotifiedFifoData(res);
         // shift the frame index with all the frames we trashed meanwhile we perform the synch search
-        decoded_frame_rx=(tmp->proc.decoded_frame_rx+trashed_frames) % MAX_FRAME_NUMBER;
+        decoded_frame_rx=(tmp->proc.decoded_frame_rx + (!UE->init_sync_frame) + trashed_frames) % MAX_FRAME_NUMBER;
         delNotifiedFIFO_elt(res);
       } else {
         readFrame(UE, &timestamp, true);
-        trashed_frames++;
+        trashed_frames+=2;
         continue;
       }
     }
@@ -709,7 +730,7 @@ void *UE_thread(void *arg) {
       // and we shifted above to the first slot of next frame
       decoded_frame_rx++;
       // we do ++ first in the regular processing, so it will be begin of frame;
-      absolute_slot=decoded_frame_rx*nb_slot_frame + nb_slot_frame -1;
+      absolute_slot=decoded_frame_rx*nb_slot_frame -1;
       continue;
     }
 
@@ -746,10 +767,10 @@ void *UE_thread(void *arg) {
     }*/
 #endif
 
+    int firstSymSamp = get_firstSymSamp(slot_nr, &UE->frame_parms);
     for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
-      rxp[i] = (void *)&UE->common_vars.rxdata[i][UE->frame_parms.ofdm_symbol_size+
-               UE->frame_parms.nb_prefix_samples0+UE->frame_parms.
-               get_samples_slot_timestamp(slot_nr,&UE->frame_parms,0)];
+      rxp[i] = (void *)&UE->common_vars.rxdata[i][firstSymSamp+
+               UE->frame_parms.get_samples_slot_timestamp(slot_nr,&UE->frame_parms,0)];
 
     for (int i=0; i<UE->frame_parms.nb_antennas_tx; i++)
       txp[i] = (void *)&UE->common_vars.txdata[i][UE->frame_parms.get_samples_slot_timestamp(
@@ -758,15 +779,13 @@ void *UE_thread(void *arg) {
     int readBlockSize, writeBlockSize;
 
     if (slot_nr<(nb_slot_frame - 1)) {
-      readBlockSize=UE->frame_parms.get_samples_per_slot(slot_nr,&UE->frame_parms);
-      writeBlockSize=UE->frame_parms.get_samples_per_slot(slot_nr,&UE->frame_parms);
+      readBlockSize=get_readBlockSize(slot_nr, &UE->frame_parms);
+      writeBlockSize=UE->frame_parms.get_samples_per_slot(curMsg->proc.nr_tti_tx,&UE->frame_parms);
     } else {
       UE->rx_offset_diff = computeSamplesShift(UE);
-      readBlockSize=UE->frame_parms.get_samples_per_slot(slot_nr,&UE->frame_parms) -
-                    UE->frame_parms.ofdm_symbol_size -
-                    UE->frame_parms.nb_prefix_samples0 -
+      readBlockSize=get_readBlockSize(slot_nr, &UE->frame_parms) -
                     UE->rx_offset_diff;
-      writeBlockSize=UE->frame_parms.get_samples_per_slot(slot_nr,&UE->frame_parms) -
+      writeBlockSize=UE->frame_parms.get_samples_per_slot(curMsg->proc.nr_tti_tx,&UE->frame_parms) -
                      UE->rx_offset_diff;
     }
 
@@ -781,8 +800,7 @@ void *UE_thread(void *arg) {
                  UE->rfdevice.trx_write_func(&UE->rfdevice,
                      timestamp+
                      UE->frame_parms.get_samples_slot_timestamp(slot_nr,
-                     &UE->frame_parms,DURATION_RX_TO_TX) -
-                     UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0 -
+                     &UE->frame_parms,DURATION_RX_TO_TX) - firstSymSamp -
                      openair0_cfg[0].tx_sample_advance,
                      txp,
                      writeBlockSize,
@@ -791,7 +809,7 @@ void *UE_thread(void *arg) {
 
     if( slot_nr==(nb_slot_frame-1)) {
       // read in first symbol of next frame and adjust for timing drift
-      int first_symbols=writeBlockSize-readBlockSize;
+      int first_symbols=UE->frame_parms.ofdm_symbol_size+UE->frame_parms.nb_prefix_samples0; // first symbol of every frames
 
       if ( first_symbols > 0 )
         AssertFatal(first_symbols ==
@@ -806,8 +824,8 @@ void *UE_thread(void *arg) {
 
     curMsg->proc.timestamp_tx = timestamp+
                                 UE->frame_parms.get_samples_slot_timestamp(slot_nr,
-                                &UE->frame_parms,DURATION_RX_TO_TX) -
-                                UE->frame_parms.ofdm_symbol_size-UE->frame_parms.nb_prefix_samples0;
+                                &UE->frame_parms,DURATION_RX_TO_TX) - firstSymSamp;
+
     notifiedFIFO_elt_t *res;
 
     while (nbSlotProcessing >= RX_NB_TH) {
@@ -816,7 +834,8 @@ void *UE_thread(void *arg) {
         processingData_t *tmp=(processingData_t *)res->msgData;
 
         if (tmp->proc.decoded_frame_rx != -1)
-          decoded_frame_rx=tmp->proc.decoded_frame_rx;
+          decoded_frame_rx=(((mac->mib->systemFrameNumber.buf[0] >> mac->mib->systemFrameNumber.bits_unused)<<4) | tmp->proc.decoded_frame_rx);
+          //decoded_frame_rx=tmp->proc.decoded_frame_rx;
 
         pushNotifiedFIFO_nothreadSafe(&freeBlocks,res);
       }
@@ -842,7 +861,8 @@ void *UE_thread(void *arg) {
       processingData_t *tmp=(processingData_t *)res->msgData;
 
       if (tmp->proc.decoded_frame_rx != -1)
-        decoded_frame_rx=tmp->proc.decoded_frame_rx;
+        decoded_frame_rx=(((mac->mib->systemFrameNumber.buf[0] >> mac->mib->systemFrameNumber.bits_unused)<<4) | tmp->proc.decoded_frame_rx);
+        //decoded_frame_rx=tmp->proc.decoded_frame_rx;
 
       pushNotifiedFIFO_nothreadSafe(&freeBlocks,res);
     }

executables/nr-uesoftmodem.c

@@ -135,6 +135,7 @@ int                      threequarter_fs=0;
 
 uint64_t                 downlink_frequency[MAX_NUM_CCs][4];
 int32_t                  uplink_frequency_offset[MAX_NUM_CCs][4];
+//int32_t					 uplink_counter = 0;
 
 
 extern int16_t nr_dlsch_demod_shift;
@@ -334,8 +335,6 @@ void init_scope(void) {
 
 }
 
-
-#if defined(ENABLE_ITTI)
 void *l2l1_task(void *arg) {
   MessageDef *message_p = NULL;
   int         result;
@@ -375,7 +374,7 @@ void *l2l1_task(void *arg) {
 
   return NULL;
 }
-#endif
+
 
 int16_t dlsch_demod_shift;
 
@@ -669,7 +668,7 @@ int main( int argc, char **argv ) {
   logInit();
   // get options and fill parameters from configuration file
   get_options (); //Command-line options, enb_properties
-  get_common_options();
+  get_common_options(SOFTMODEM_5GUE_BIT );
 #if T_TRACER
   T_Config_Init();
 #endif
@@ -689,6 +688,7 @@ int main( int argc, char **argv ) {
   itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info);
 
   init_opt() ;
+  load_nrLDPClib();
 
   if (ouput_vcd) {
     vcd_signal_dumper_init("/tmp/openair_dump_nrUE.vcd");
@@ -759,15 +759,49 @@ int main( int argc, char **argv ) {
     UE[CC_id]->rx_total_gain_dB =  (int)rx_gain[CC_id][0] + rx_gain_off;
     UE[CC_id]->tx_power_max_dBm = tx_max_power[CC_id];
 
-    if (frame_parms[CC_id]->frame_type==FDD) {
+    if (UE[CC_id]->frame_parms.frame_type == FDD) {
       UE[CC_id]->N_TA_offset = 0;
     } else {
-      if (frame_parms[CC_id]->N_RB_DL == 100)
-        UE[CC_id]->N_TA_offset = 624;
-      else if (frame_parms[CC_id]->N_RB_DL == 50)
-        UE[CC_id]->N_TA_offset = 624/2;
-      else if (frame_parms[CC_id]->N_RB_DL == 25)
-        UE[CC_id]->N_TA_offset = 624/4;
+      int N_RB = UE[CC_id]->frame_parms.N_RB_DL;
+      int N_TA_offset = UE[CC_id]->frame_parms.ul_CarrierFreq < 6e9 ? 400 : 431; // reference samples  for 25600Tc @ 30.72 Ms/s for FR1, same @ 61.44 Ms/s for FR2
+      double factor=1;
+      switch (UE[CC_id]->frame_parms.numerology_index) {
+        case 0: //15 kHz scs
+          AssertFatal(N_TA_offset == 400, "scs_common 15kHz only for FR1\n");
+          if (N_RB <= 25) factor = .25;      // 7.68 Ms/s
+          else if (N_RB <=50) factor = .5;   // 15.36 Ms/s
+          else if (N_RB <=75) factor = 1.0;  // 30.72 Ms/s
+          else if (N_RB <=100) factor = 1.0; // 30.72 Ms/s
+          else AssertFatal(1==0,"Too many PRBS for mu=0\n");
+          break;
+        case 1: //30 kHz sc
+          AssertFatal(N_TA_offset == 400, "scs_common 30kHz only for FR1\n");
+          if (N_RB <= 106) factor = 2.0; // 61.44 Ms/s
+          else if (N_RB <= 275) factor = 4.0; // 122.88 Ms/s
+          break;
+        case 2: //60 kHz scs
+          AssertFatal(1==0,"scs_common should not be 60 kHz\n");
+          break;
+        case 3: //120 kHz scs
+          AssertFatal(N_TA_offset == 431, "scs_common 120kHz only for FR2\n");
+          break;
+        case 4: //240 kHz scs
+          AssertFatal(1==0,"scs_common should not be 60 kHz\n");
+          if (N_RB <= 32) factor = 1.0; // 61.44 Ms/s
+          else if (N_RB <= 66) factor = 2.0; // 122.88 Ms/s
+          else AssertFatal(1==0,"N_RB %d is too big for curretn FR2 implementation\n",N_RB);
+          break;
+
+        if (N_RB == 100)
+          UE[CC_id]->N_TA_offset = 624;
+        else if (N_RB == 50)
+          UE[CC_id]->N_TA_offset = 624/2;
+        else if (N_RB == 25)
+          UE[CC_id]->N_TA_offset = 624/4;
+      }
+      if (UE[CC_id]->frame_parms.threequarter_fs == 1) factor = factor*.75;
+      UE[CC_id]->N_TA_offset = (int)(N_TA_offset * factor);
+      LOG_I(PHY,"UE %d Setting N_TA_offset to %d samples (factor %f, UL Freq %d, N_RB %d)\n", UE[CC_id]->Mod_id, UE[CC_id]->N_TA_offset, factor, UE[CC_id]->frame_parms.ul_CarrierFreq, N_RB);
     }
   }
 

executables/softmodem-common.c

@@ -37,6 +37,7 @@
 #include "common/utils/load_module_shlib.h"
 #include "common/utils/telnetsrv/telnetsrv.h"
 #include "executables/thread-common.h"
+#include "common/utils/LOG/log.h"
 #include "softmodem-common.h"
 
 static softmodem_params_t softmodem_params;
@@ -44,7 +45,7 @@ char *parallel_config=NULL;
 char *worker_config=NULL;
 
 
-
+static mapping softmodem_funcs[] = MAPPING_SOFTMODEM_FUNCTIONS;
 static struct timespec start;
 
 uint64_t get_softmodem_optmask(void) {
@@ -60,6 +61,89 @@ softmodem_params_t *get_softmodem_params(void) {
   return &softmodem_params;
 }
 
+int32_t check_execmask(uint64_t execmask) {
+  char *softmodemfunc=map_int_to_str(softmodem_funcs, execmask);
+  if (softmodemfunc != NULL) {
+  	  set_softmodem_optmask(execmask);
+  	  return 0;
+  } 
+  return -1;
+}
+char *get_softmodem_function(uint64_t *sofmodemfunc_mask_ptr) {
+  uint64_t fmask=(get_softmodem_optmask()&SOFTMODEM_FUNC_BITS);
+  char *softmodemfunc=map_int_to_str(softmodem_funcs, fmask);
+  if (sofmodemfunc_mask_ptr != NULL)
+  	  *sofmodemfunc_mask_ptr=fmask;
+  if (softmodemfunc != NULL) {
+  	  return softmodemfunc;
+  }
+  return "???";
+}
+
+void get_common_options(uint32_t execmask) {
+  uint32_t online_log_messages;
+  uint32_t glog_level ;
+  uint32_t start_telnetsrv = 0;
+  uint32_t noS1 = 0, nokrnmod = 0, nonbiot = 0;
+  uint32_t rfsim = 0, basicsim = 0, do_forms = 0;
+  char *logmem_filename = NULL;
+  paramdef_t cmdline_params[] =CMDLINE_PARAMS_DESC ;
+  paramdef_t cmdline_logparams[] =CMDLINE_LOGPARAMS_DESC ;
+  checkedparam_t cmdline_log_CheckParams[] = CMDLINE_LOGPARAMS_CHECK_DESC;
+  check_execmask(execmask);
+  config_get( cmdline_params,sizeof(cmdline_params)/sizeof(paramdef_t),NULL);
+  config_set_checkfunctions(cmdline_logparams, cmdline_log_CheckParams,
+                            sizeof(cmdline_logparams)/sizeof(paramdef_t));
+  config_get( cmdline_logparams,sizeof(cmdline_logparams)/sizeof(paramdef_t),NULL);
+
+  if(config_isparamset(cmdline_logparams,CMDLINE_ONLINELOG_IDX)) {
+    set_glog_onlinelog(online_log_messages);
+  }
+
+  if(config_isparamset(cmdline_logparams,CMDLINE_GLOGLEVEL_IDX)) {
+    set_glog(glog_level);
+  }
+
+  if (start_telnetsrv) {
+    load_module_shlib("telnetsrv",NULL,0,NULL);
+  }
+
+  if (logmem_filename != NULL && strlen(logmem_filename) > 0) {
+    log_mem_filename = &logmem_filename[0];
+    log_mem_flag = 1;
+    printf("Enabling OPT for log save at memory %s\n",log_mem_filename);
+    logInit_log_mem();
+  }
+
+  if (noS1) {
+    set_softmodem_optmask(SOFTMODEM_NOS1_BIT);
+  }
+
+  if (nokrnmod) {
+    printf("nokrnmod bit enabled \n");
+    set_softmodem_optmask(SOFTMODEM_NOKRNMOD_BIT);
+  }
+
+  if (nonbiot) {
+    set_softmodem_optmask(SOFTMODEM_NONBIOT_BIT);
+  }
+
+  if (rfsim) {
+    set_softmodem_optmask(SOFTMODEM_RFSIM_BIT);
+  }
+
+  if (basicsim) {
+    set_softmodem_optmask(SOFTMODEM_BASICSIM_BIT);
+  }
+
+  if (do_forms) {
+    set_softmodem_optmask(SOFTMODEM_DOFORMS_BIT);
+  }
+
+  if(parallel_config != NULL) set_parallel_conf(parallel_config);
+
+  if(worker_config != NULL)   set_worker_conf(worker_config);
+}
 void softmodem_printresources(int sig, telnet_printfunc_t pf) {
    struct rusage usage;
    struct timespec stop;
@@ -119,68 +203,4 @@ void set_softmodem_sighandler(void) {
   signal(SIGTERM, signal_handler);
   signal(SIGABRT, signal_handler);	
 }
-#ifndef PHYSICAL_SIMULATOR
-void get_common_options(void) {
-  uint32_t online_log_messages;
-  uint32_t glog_level ;
-  uint32_t start_telnetsrv = 0;
-  uint32_t noS1 = 0, nokrnmod = 0, nonbiot = 0;
-  uint32_t rfsim = 0, basicsim = 0, do_forms = 0;
-  char *logmem_filename = NULL;
-  paramdef_t cmdline_params[] =CMDLINE_PARAMS_DESC ;
-  paramdef_t cmdline_logparams[] =CMDLINE_LOGPARAMS_DESC ;
-  checkedparam_t cmdline_log_CheckParams[] = CMDLINE_LOGPARAMS_CHECK_DESC;
-  config_get( cmdline_params,sizeof(cmdline_params)/sizeof(paramdef_t),NULL);
-  config_set_checkfunctions(cmdline_logparams, cmdline_log_CheckParams,
-                            sizeof(cmdline_logparams)/sizeof(paramdef_t));
-  config_get( cmdline_logparams,sizeof(cmdline_logparams)/sizeof(paramdef_t),NULL);
 
-  if(config_isparamset(cmdline_logparams,CMDLINE_ONLINELOG_IDX)) {
-    set_glog_onlinelog(online_log_messages);
-  }
-
-  if(config_isparamset(cmdline_logparams,CMDLINE_GLOGLEVEL_IDX)) {
-    set_glog(glog_level);
-  }
-
-  if (start_telnetsrv) {
-    load_module_shlib("telnetsrv",NULL,0,NULL);
-  }
-
-  if (logmem_filename != NULL && strlen(logmem_filename) > 0) {
-    log_mem_filename = &logmem_filename[0];
-    log_mem_flag = 1;
-    printf("Enabling OPT for log save at memory %s\n",log_mem_filename);
-    logInit_log_mem();
-  }
-
-  if (noS1) {
-    set_softmodem_optmask(SOFTMODEM_NOS1_BIT);
-  }
-
-  if (nokrnmod) {
-    printf("nokrnmod bit enabled \n");
-    set_softmodem_optmask(SOFTMODEM_NOKRNMOD_BIT);
-  }
-
-  if (nonbiot) {
-    set_softmodem_optmask(SOFTMODEM_NONBIOT_BIT);
-  }
-
-  if (rfsim) {
-    set_softmodem_optmask(SOFTMODEM_RFSIM_BIT);
-  }
-
-  if (basicsim) {
-    set_softmodem_optmask(SOFTMODEM_BASICSIM_BIT);
-  }
-
-  if (do_forms) {
-    set_softmodem_optmask(SOFTMODEM_DOFORMS_BIT);
-  }
-
-  if(parallel_config != NULL) set_parallel_conf(parallel_config);
-
-  if(worker_config != NULL)   set_worker_conf(worker_config);
-}
-#endif

executables/softmodem-common.h

@@ -31,6 +31,7 @@
  */
 #ifndef SOFTMODEM_COMMON_H
 #define SOFTMODEM_COMMON_H
+#include "openair1/PHY/defs_common.h"
 #ifdef __cplusplus
 extern "C"
 {
@@ -164,6 +165,14 @@ extern "C"
 #define SOFTMODEM_BASICSIM_BIT        (1<<11)
 #define SOFTMODEM_SIML1_BIT           (1<<12)
 #define SOFTMODEM_DOFORMS_BIT         (1<<15)
+#define SOFTMODEM_RECPLAY_BIT         (1<<16)
+#define SOFTMODEM_ENB_BIT             (1<<20)
+#define SOFTMODEM_GNB_BIT             (1<<21)
+#define SOFTMODEM_4GUE_BIT            (1<<22)
+#define SOFTMODEM_5GUE_BIT            (1<<23)
+#define SOFTMODEM_FUNC_BITS (SOFTMODEM_ENB_BIT | SOFTMODEM_GNB_BIT | SOFTMODEM_5GUE_BIT | SOFTMODEM_4GUE_BIT)
+#define MAPPING_SOFTMODEM_FUNCTIONS {{"enb",SOFTMODEM_ENB_BIT},{"gnb",SOFTMODEM_GNB_BIT},{"4Gue",SOFTMODEM_4GUE_BIT},{"5Gue",SOFTMODEM_5GUE_BIT}}
+
 
 #define IS_SOFTMODEM_NOS1            ( get_softmodem_optmask() & SOFTMODEM_NOS1_BIT)
 #define IS_SOFTMODEM_NOKRNMOD        ( get_softmodem_optmask() & SOFTMODEM_NOKRNMOD_BIT)
@@ -172,7 +181,11 @@ extern "C"
 #define IS_SOFTMODEM_BASICSIM        ( get_softmodem_optmask() & SOFTMODEM_BASICSIM_BIT)
 #define IS_SOFTMODEM_SIML1           ( get_softmodem_optmask() & SOFTMODEM_SIML1_BIT)
 #define IS_SOFTMODEM_DOFORMS         ( get_softmodem_optmask() & SOFTMODEM_DOFORMS_BIT)
-
+#define IS_SOFTMODEM_IQPLAYER        ( get_softmodem_optmask() & SOFTMODEM_RECPLAY_BIT)
+#define IS_SOFTMODEM_ENB_BIT         ( get_softmodem_optmask() & SOFTMODEM_ENB_BIT)
+#define IS_SOFTMODEM_GNB_BIT         ( get_softmodem_optmask() & SOFTMODEM_GNB_BIT)
+#define IS_SOFTMODEM_4GUE_BIT        ( get_softmodem_optmask() & SOFTMODEM_4GUE_BIT)
+#define IS_SOFTMODEM_5GUE_BIT        ( get_softmodem_optmask() & SOFTMODEM_5GUE_BIT)
 
 typedef struct {
   uint64_t       optmask;
@@ -195,7 +208,8 @@ typedef struct {
 extern uint64_t get_softmodem_optmask(void);
 extern uint64_t set_softmodem_optmask(uint64_t bitmask);
 extern softmodem_params_t *get_softmodem_params(void);
-extern void get_common_options(void);
+extern void get_common_options(uint32_t execmask);
+extern char *get_softmodem_function(uint64_t *sofmodemfunc_mask_ptr);
 #define SOFTMODEM_RTSIGNAL  (SIGRTMIN+1)
 extern void set_softmodem_sighandler(void);
 extern uint64_t downlink_frequency[MAX_NUM_CCs][4];