change datamodel in nr-ue-ru.c to implement the current status: a ru has 0 or 1 cell, a cell has 0 or 1 UE

Signed-off-by: Laurent THOMAS <laurent.thomas@open-cells.com>

common/utils/websrv/websrv_scope.c

@@ -19,6 +19,7 @@
 #include "openair1/PHY/TOOLS/phy_scope.h"
 #include "openair1/PHY/TOOLS/phy_scope_interface.h"
 #include "common/utils/load_module_shlib.h"
+#include "openair1/PHY/phy_extern_nr_ue.h"
 
 static websrv_scope_params_t scope_params = {0, 1000, NULL, NULL, 65535};
 static websrv_params_t *websrvparams_ptr;
@@ -122,8 +123,8 @@ char *websrv_scope_initdata(void)
     scope_params.statusmask |= SCOPE_STATUSMASK_AVAILABLE;
     return "gNB";
   } else if (IS_SOFTMODEM_5GUE) {
-    scope_params.scopedata = PHY_vars_UE_g[0][0];
-    nrUEinitScope(PHY_vars_UE_g[0][0]);
+    scope_params.scopedata = nrPHY_vars_UE_g[0][0];
+    nrUEinitScope(nrPHY_vars_UE_g[0][0]);
     scope_params.scopeform = create_phy_scope_nrue(scope_params.selectedTarget);
     scope_params.statusmask |= SCOPE_STATUSMASK_AVAILABLE;
     return "5GUE";

executables/lte-ru.c

@@ -1533,7 +1533,8 @@ static void *ru_thread( void *param ) {
     init_frame_parms(ru->frame_parms,1);
     ru->frame_parms->nb_antennas_rx = ru->nb_rx;
 
-    if (ru->if_south == LOCAL_RF)       openair0_device_load(&ru->rfdevice,&ru->openair0_cfg);
+    if (ru->if_south == LOCAL_RF)
+      openair0_device_load(&ru->rfdevice, &ru->openair0_cfg);
 
     phy_init_RU(ru);
       

executables/lte-ue.c

@@ -287,7 +287,7 @@ void init_UE(int nb_inst,
 
     LOG_I(PHY,"Intializing UE Threads for instance %d (%p,%p)...\n",inst,PHY_vars_UE_g[inst],PHY_vars_UE_g[inst][0]);
     init_UE_threads(inst);
-    ret = openair0_device_load(&(UE->rfdevice), &openair0_cfg[0]);
+    ret = openair0_device_load(&(UE->rfdevice), openair0_cfg_g);
 
     if (ret !=0) {
       exit_fun("Error loading device library");
@@ -404,6 +404,7 @@ static void *UE_thread_synch(void *arg) {
   printf("starting UE synch thread (IC %d)\n",UE->proc.instance_cnt_synch);
   ind = 0;
   found = 0;
+  openair0_config_t *cfg = openair0_cfg_g + UE->rf_map.card;
 
   if (UE->UE_scan == 0) {
     do  {
@@ -429,32 +430,35 @@ static void *UE_thread_synch(void *arg) {
       return &UE_thread_synch_retval;
     }
 
-    LOG_I( PHY, "[SCHED][UE] Check absolute frequency DL %"PRIu32", UL %"PRIu32" (oai_exit %d, rx_num_channels %d)\n", UE->frame_parms.dl_CarrierFreq, UE->frame_parms.ul_CarrierFreq,oai_exit,
-           openair0_cfg[0].rx_num_channels);
+    LOG_I(PHY,
+          "[SCHED][UE] Check absolute frequency DL %" PRIu32 ", UL %" PRIu32 " (oai_exit %d, rx_num_channels %d)\n",
+          UE->frame_parms.dl_CarrierFreq,
+          UE->frame_parms.ul_CarrierFreq,
+          oai_exit,
+          openair0_cfg_g[0].rx_num_channels);
 
-    for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
-      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = UE->frame_parms.dl_CarrierFreq;
-      openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = UE->frame_parms.ul_CarrierFreq;
-      openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
+    for (i = 0; i < cfg->rx_num_channels; i++) {
+      cfg->rx_freq[UE->rf_map.chain + i] = UE->frame_parms.dl_CarrierFreq;
+      cfg->tx_freq[UE->rf_map.chain + i] = UE->frame_parms.ul_CarrierFreq;
+      cfg->autocal[UE->rf_map.chain + i] = 1;
 
       if (uplink_frequency_offset[CC_id][i] != 0) //
-        openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_FDD;
+        cfg->duplex_mode = duplex_mode_FDD;
       else //FDD
-        openair0_cfg[UE->rf_map.card].duplex_mode = duplex_mode_TDD;
+        cfg->duplex_mode = duplex_mode_TDD;
     }
 
     sync_mode = pbch;
   } else if  (UE->UE_scan == 1) {
     current_band=0;
 
-    for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+    for (i = 0; i < cfg->rx_num_channels; i++) {
       downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[CC_id].dl_min;
       int32_t delta = bands_to_scan.band_info[CC_id].ul_min - bands_to_scan.band_info[CC_id].dl_min;
       uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] = delta;
-      openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
-      openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =
-        downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
-      openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
+      cfg->rx_freq[UE->rf_map.chain + i] = downlink_frequency[CC_id][i];
+      cfg->tx_freq[UE->rf_map.chain + i] = downlink_frequency[CC_id][i] + uplink_frequency_offset[CC_id][i];
+      cfg->rx_gain[UE->rf_map.chain + i] = UE->rx_total_gain_dB;
     }
   }
 
@@ -491,16 +495,16 @@ static void *UE_thread_synch(void *arg) {
           oai_exit=1;
         }
 
-        for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
+        for (i = 0; i < cfg->rx_num_channels; i++) {
           downlink_frequency[UE->rf_map.card][UE->rf_map.chain+i] = bands_to_scan.band_info[current_band].dl_min+current_offset;
           int32_t delta = bands_to_scan.band_info[current_band].ul_min - bands_to_scan.band_info[0].dl_min + current_offset;
           uplink_frequency_offset[UE->rf_map.card][UE->rf_map.chain+i] = delta;
-          openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i];
-          openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i];
-          openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;
+          cfg->rx_freq[UE->rf_map.chain + i] = downlink_frequency[CC_id][i];
+          cfg->tx_freq[UE->rf_map.chain + i] = downlink_frequency[CC_id][i] + uplink_frequency_offset[CC_id][i];
+          cfg->rx_gain[UE->rf_map.chain + i] = UE->rx_total_gain_dB;
 
           if (UE->UE_scan_carrier) {
-            openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
+            cfg->autocal[UE->rf_map.chain + i] = 1;
           }
         }
 
@@ -519,18 +523,17 @@ static void *UE_thread_synch(void *arg) {
                  UE->UE_scan_carrier );
 
           // rerun with new cell parameters and frequency-offset
-          for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
-            openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
+          for (i = 0; i < cfg->rx_num_channels; i++) {
+            cfg->rx_gain[UE->rf_map.chain + i] = UE->rx_total_gain_dB; //-USRP_GAIN_OFFSET;
 
             if (UE->UE_scan_carrier == 1) {
               if (freq_offset >= 0)
-                openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] += abs(UE->common_vars.freq_offset);
+                cfg->rx_freq[UE->rf_map.chain + i] += abs(UE->common_vars.freq_offset);
               else
-                openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] -= abs(UE->common_vars.freq_offset);
+                cfg->rx_freq[UE->rf_map.chain + i] -= abs(UE->common_vars.freq_offset);
 
-              openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] =
-                openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i]+uplink_frequency_offset[CC_id][i];
-              downlink_frequency[CC_id][i] = openair0_cfg[CC_id].rx_freq[i];
+              cfg->tx_freq[UE->rf_map.chain + i] = cfg->rx_freq[UE->rf_map.chain + i] + uplink_frequency_offset[CC_id][i];
+              downlink_frequency[CC_id][i] = openair0_cfg_g[CC_id].rx_freq[i];
               freq_offset=0;
             }
           }
@@ -538,35 +541,35 @@ static void *UE_thread_synch(void *arg) {
           // reconfigure for potentially different bandwidth
           switch(UE->frame_parms.N_RB_DL) {
             case 6:
-              openair0_cfg[UE->rf_map.card].sample_rate =1.92e6;
-              openair0_cfg[UE->rf_map.card].rx_bw          =.96e6;
-              openair0_cfg[UE->rf_map.card].tx_bw          =.96e6;
+              cfg->sample_rate = 1.92e6;
+              cfg->rx_bw = .96e6;
+              cfg->tx_bw = .96e6;
               //            openair0_cfg[0].rx_gain[0] -= 12;
               break;
 
             case 25:
-              openair0_cfg[UE->rf_map.card].sample_rate =7.68e6;
-              openair0_cfg[UE->rf_map.card].rx_bw          =2.5e6;
-              openair0_cfg[UE->rf_map.card].tx_bw          =2.5e6;
+              cfg->sample_rate = 7.68e6;
+              cfg->rx_bw = 2.5e6;
+              cfg->tx_bw = 2.5e6;
               //            openair0_cfg[0].rx_gain[0] -= 6;
               break;
 
             case 50:
-              openair0_cfg[UE->rf_map.card].sample_rate =15.36e6;
-              openair0_cfg[UE->rf_map.card].rx_bw          =5.0e6;
-              openair0_cfg[UE->rf_map.card].tx_bw          =5.0e6;
+              cfg->sample_rate = 15.36e6;
+              cfg->rx_bw = 5.0e6;
+              cfg->tx_bw = 5.0e6;
               //            openair0_cfg[0].rx_gain[0] -= 3;
               break;
 
             case 100:
-              openair0_cfg[UE->rf_map.card].sample_rate=30.72e6;
-              openair0_cfg[UE->rf_map.card].rx_bw=10.0e6;
-              openair0_cfg[UE->rf_map.card].tx_bw=10.0e6;
+              cfg->sample_rate = 30.72e6;
+              cfg->rx_bw = 10.0e6;
+              cfg->tx_bw = 10.0e6;
               //            openair0_cfg[0].rx_gain[0] -= 0;
               break;
           }
 
-          UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0]);
+          UE->rfdevice.trx_set_freq_func(&UE->rfdevice, &openair0_cfg_g[0]);
           //UE->rfdevice.trx_set_gains_func(&openair0,&openair0_cfg[0]);
           //UE->rfdevice.trx_stop_func(&UE->rfdevice);
           sleep(1);
@@ -641,16 +644,16 @@ static void *UE_thread_synch(void *arg) {
                 downlink_frequency[0][0]+freq_offset,
                 downlink_frequency[0][0]+uplink_frequency_offset[0][0]+freq_offset );
 
-          for (i=0; i<openair0_cfg[UE->rf_map.card].rx_num_channels; i++) {
-            openair0_cfg[UE->rf_map.card].rx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+freq_offset;
-            openair0_cfg[UE->rf_map.card].tx_freq[UE->rf_map.chain+i] = downlink_frequency[CC_id][i]+uplink_frequency_offset[CC_id][i]+freq_offset;
-            openair0_cfg[UE->rf_map.card].rx_gain[UE->rf_map.chain+i] = UE->rx_total_gain_dB;//-USRP_GAIN_OFFSET;
+          for (i = 0; i < cfg->rx_num_channels; i++) {
+            cfg->rx_freq[UE->rf_map.chain + i] = downlink_frequency[CC_id][i] + freq_offset;
+            cfg->tx_freq[UE->rf_map.chain + i] = downlink_frequency[CC_id][i] + uplink_frequency_offset[CC_id][i] + freq_offset;
+            cfg->rx_gain[UE->rf_map.chain + i] = UE->rx_total_gain_dB; //-USRP_GAIN_OFFSET;
 
             if (UE->UE_scan_carrier==1)
-              openair0_cfg[UE->rf_map.card].autocal[UE->rf_map.chain+i] = 1;
+              cfg->autocal[UE->rf_map.chain + i] = 1;
           }
 
-          UE->rfdevice.trx_set_freq_func(&UE->rfdevice,&openair0_cfg[0]);
+          UE->rfdevice.trx_set_freq_func(&UE->rfdevice, &openair0_cfg_g[0]);
         }// initial_sync=0
 
         break;

executables/lte-uesoftmodem.c

@@ -124,7 +124,7 @@ THREAD_STRUCT thread_struct;
 /* struct for ethernet specific parameters given in eNB conf file */
 eth_params_t *eth_params;
 
-openair0_config_t openair0_cfg[MAX_CARDS];
+openair0_config_t openair0_cfg_g[MAX_CARDS] = {};
 
 double cpuf;
 
@@ -308,78 +308,75 @@ void set_default_frame_parms(LTE_DL_FRAME_PARMS *frame_parms[MAX_NUM_CCs]) {
 
 static void init_openair0(LTE_DL_FRAME_PARMS *frame_parms, int rxgain)
 {
-  int card;
-  int i;
-
-  for (card=0; card<MAX_CARDS; card++) {
-    openair0_cfg[card].mmapped_dma=mmapped_dma;
-    openair0_cfg[card].configFilename = NULL;
+  for (openair0_config_t *cfg = openair0_cfg_g; cfg < openair0_cfg_g + MAX_CARDS; cfg++) {
+    cfg->mmapped_dma = mmapped_dma;
+    cfg->configFilename = NULL;
 
     if(frame_parms->N_RB_DL == 100) {
       if (frame_parms->threequarter_fs) {
-        openair0_cfg[card].sample_rate=23.04e6;
-        openair0_cfg[card].tx_bw = 10e6;
-        openair0_cfg[card].rx_bw = 10e6;
+        cfg->sample_rate = 23.04e6;
+        cfg->tx_bw = 10e6;
+        cfg->rx_bw = 10e6;
       } else {
-        openair0_cfg[card].sample_rate=30.72e6;
-        openair0_cfg[card].tx_bw = 10e6;
-        openair0_cfg[card].rx_bw = 10e6;
+        cfg->sample_rate = 30.72e6;
+        cfg->tx_bw = 10e6;
+        cfg->rx_bw = 10e6;
       }
     } else if(frame_parms->N_RB_DL == 50) {
-      openair0_cfg[card].sample_rate=15.36e6;
-      openair0_cfg[card].tx_bw = 5e6;
-      openair0_cfg[card].rx_bw = 5e6;
+      cfg->sample_rate = 15.36e6;
+      cfg->tx_bw = 5e6;
+      cfg->rx_bw = 5e6;
     } else if (frame_parms->N_RB_DL == 25) {
-      openair0_cfg[card].sample_rate=7.68e6;
-      openair0_cfg[card].tx_bw = 2.5e6;
-      openair0_cfg[card].rx_bw = 2.5e6;
+      cfg->sample_rate = 7.68e6;
+      cfg->tx_bw = 2.5e6;
+      cfg->rx_bw = 2.5e6;
     } else if (frame_parms->N_RB_DL == 6) {
-      openair0_cfg[card].sample_rate=1.92e6;
-      openair0_cfg[card].tx_bw = 1.5e6;
-      openair0_cfg[card].rx_bw = 1.5e6;
+      cfg->sample_rate = 1.92e6;
+      cfg->tx_bw = 1.5e6;
+      cfg->rx_bw = 1.5e6;
     }
 
     if (frame_parms->frame_type==TDD)
-      openair0_cfg[card].duplex_mode = duplex_mode_TDD;
+      cfg->duplex_mode = duplex_mode_TDD;
     else //FDD
-      openair0_cfg[card].duplex_mode = duplex_mode_FDD;
+      cfg->duplex_mode = duplex_mode_FDD;
 
-    openair0_cfg[card].num_rb_dl=frame_parms->N_RB_DL;
-    openair0_cfg[card].clock_source = get_softmodem_params()->clock_source;
-    openair0_cfg[card].time_source = get_softmodem_params()->timing_source;
-    openair0_cfg[card].tune_offset = get_softmodem_params()->tune_offset;
-    openair0_cfg[card].tx_num_channels=min(2,frame_parms->nb_antennas_tx);
-    openair0_cfg[card].rx_num_channels=min(2,frame_parms->nb_antennas_rx);
+    cfg->num_rb_dl = frame_parms->N_RB_DL;
+    cfg->clock_source = get_softmodem_params()->clock_source;
+    cfg->time_source = get_softmodem_params()->timing_source;
+    cfg->tune_offset = get_softmodem_params()->tune_offset;
+    cfg->tx_num_channels = min(2, frame_parms->nb_antennas_tx);
+    cfg->rx_num_channels = min(2, frame_parms->nb_antennas_rx);
 
-    for (i=0; i<4; i++) {
-      if (i<openair0_cfg[card].tx_num_channels)
-        openair0_cfg[card].tx_freq[i] = downlink_frequency[0][i]+uplink_frequency_offset[0][i];
+    for (int i = 0; i < 4; i++) {
+      if (i < cfg->tx_num_channels)
+        cfg->tx_freq[i] = downlink_frequency[0][i] + uplink_frequency_offset[0][i];
       else
-        openair0_cfg[card].tx_freq[i]=0.0;
+        cfg->tx_freq[i] = 0.0;
 
-      if (i<openair0_cfg[card].rx_num_channels)
-        openair0_cfg[card].rx_freq[i] = downlink_frequency[0][i];
+      if (i < cfg->rx_num_channels)
+        cfg->rx_freq[i] = downlink_frequency[0][i];
       else
-        openair0_cfg[card].rx_freq[i]=0.0;
+        cfg->rx_freq[i] = 0.0;
 
-      openair0_cfg[card].autocal[i] = 1;
-      openair0_cfg[card].tx_gain[i] = tx_gain[0][i];
-      openair0_cfg[card].rx_gain[i] = rxgain - rx_gain_off;
-      openair0_cfg[card].configFilename = get_softmodem_params()->rf_config_file;
-      printf("Card %d, channel %d, Setting tx_gain %.0f, rx_gain %.0f, tx_freq %.0f, rx_freq %.0f, tune_offset %.0f\n",
-             card,i, openair0_cfg[card].tx_gain[i],
-             openair0_cfg[card].rx_gain[i],
-             openair0_cfg[card].tx_freq[i],
-             openair0_cfg[card].rx_freq[i],
-             openair0_cfg[card].tune_offset);
+      cfg->autocal[i] = 1;
+      cfg->tx_gain[i] = tx_gain[0][i];
+      cfg->rx_gain[i] = rxgain - rx_gain_off;
+      cfg->configFilename = get_softmodem_params()->rf_config_file;
+      printf("channel %d, Setting tx_gain %.0f, rx_gain %.0f, tx_freq %.0f, rx_freq %.0f, tune_offset %.0f\n",
+             i,
+             cfg->tx_gain[i],
+             cfg->rx_gain[i],
+             cfg->tx_freq[i],
+             cfg->rx_freq[i],
+             cfg->tune_offset);
     }
 
-    if (usrp_args) openair0_cfg[card].sdr_addrs = usrp_args;
+    if (usrp_args)
+      cfg->sdr_addrs = usrp_args;
   }
 }
 
-
-
 /* helper function to terminate a certain ITTI task
  */
 void terminate_task(task_id_t task_id, module_id_t mod_id) {
@@ -442,7 +439,7 @@ int main( int argc, char **argv ) {
   }
 
   mode = normal_txrx;
-  memset(&openair0_cfg[0],0,sizeof(openair0_config_t)*MAX_CARDS);
+  memset(openair0_cfg_g, 0, sizeof(openair0_cfg_g));
   logInit();
   lock_memory_to_ram();
   printf("Reading in command-line options\n");

executables/nr-ue-ru.c

@@ -81,43 +81,17 @@
 }
 // clang-format on
 
-static int nrue_cell_count;
-static nrUE_cell_params_t *nrue_cells;
-static NR_DL_FRAME_PARMS *nrue_cell_fp;
-
-static int nrue_ru_count;
-static nrUE_RU_params_t *nrue_rus;
-
-openair0_config_t openair0_cfg[MAX_CARDS];
-openair0_device_t openair0_dev[MAX_CARDS];
-
-int nrue_get_cell_count(void)
-{
-  return nrue_cell_count;
-}
+static struct {
+  int count;
+  nrUE_RU_params_t *cfg;
+  openair0_device_t *openair0_dev;
+} nrue_rus = {};
+// We keep openair0_cfg_g outside for legacy code
+openair0_config_t openair0_cfg_g[MAX_CARDS] = {};
 
 int nrue_get_band(const PHY_VARS_NR_UE *UE)
 {
-  int cell_id = nrue_rus[UE->rf_map.card].used_by_cell;
-  return nrue_cells[cell_id].band;
-}
-
-const nrUE_cell_params_t *nrue_get_cell(int cell_id)
-{
-  AssertFatal(cell_id >= 0 && cell_id < nrue_cell_count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cell_count);
-  return &nrue_cells[cell_id];
-}
-
-NR_DL_FRAME_PARMS *nrue_get_cell_fp(int cell_id)
-{
-  AssertFatal(cell_id >= 0 && cell_id < nrue_cell_count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cell_count);
-  return &nrue_cell_fp[cell_id];
-}
-
-void nrue_set_cell(int cell_id, const nrUE_cell_params_t *cell)
-{
-  AssertFatal(cell_id >= 0 && cell_id < nrue_cell_count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cell_count);
-  nrue_cells[cell_id] = *cell;
+  return nrue_rus.cfg[UE->rf_map.card].cell.band;
 }
 
 void nrue_set_cell_params(configmodule_interface_t *cfg)
@@ -127,65 +101,53 @@ void nrue_set_cell_params(configmodule_interface_t *cfg)
   config_getlist(cfg, &cellParamList, cellParams, sizeofArray(cellParams), NULL);
 
   if (cellParamList.numelt <= 0) {
-    nrue_cell_count = 1;
-    nrue_cell_fp = calloc_or_fail(nrue_cell_count, sizeof(NR_DL_FRAME_PARMS));
-    nrue_cells = calloc_or_fail(nrue_cell_count, sizeof(nrUE_cell_params_t));
-    nrue_cells[0] = (nrUE_cell_params_t){.ru_id = 0,
-                                         .band = get_softmodem_params()->band,
-                                         .rf_frequency = downlink_frequency[0][0],
-                                         .rf_freq_offset = uplink_frequency_offset[0][0],
-                                         .numerology = get_softmodem_params()->numerology,
-                                         .N_RB_DL = get_nrUE_params()->N_RB_DL,
-                                         .ssb_start = get_nrUE_params()->ssb_start_subcarrier,
-                                         .used_by_ue = -1};
+    nrue_rus.cfg[0].cell = (nrUE_cell_params_t){.active = true,
+                                                .band = get_softmodem_params()->band,
+                                                .rf_frequency = downlink_frequency[0][0],
+                                                .rf_freq_offset = uplink_frequency_offset[0][0],
+                                                .numerology = get_softmodem_params()->numerology,
+                                                .N_RB_DL = get_nrUE_params()->N_RB_DL,
+                                                .ssb_start = get_nrUE_params()->ssb_start_subcarrier,
+                                                .fp = calloc_or_fail(1, sizeof(*nrue_rus.cfg[0].cell.fp))};
     return;
   }
 
-  nrue_cell_count = cellParamList.numelt;
-  nrue_cell_fp = calloc_or_fail(nrue_cell_count, sizeof(NR_DL_FRAME_PARMS));
-  nrue_cells = calloc_or_fail(nrue_cell_count, sizeof(nrUE_cell_params_t));
-
   LOG_W(NR_PHY, "Ignoring command line cell parameters, using the following instead:\n");
 
-  for (int cell_id = 0; cell_id < nrue_cell_count; cell_id++) {
-    nrue_cells[cell_id].ru_id          = *(gpd(cellParamList.paramarray[cell_id], sizeofArray(cellParams), NRUE_CELL_RU_ID)->iptr);
-    nrue_cells[cell_id].band           = *(gpd(cellParamList.paramarray[cell_id], sizeofArray(cellParams), NRUE_CELL_BAND)->iptr);
-    nrue_cells[cell_id].rf_frequency   = *(gpd(cellParamList.paramarray[cell_id], sizeofArray(cellParams), NRUE_CELL_RF_FREQUENCY)->u64ptr);
-    nrue_cells[cell_id].rf_freq_offset = *(gpd(cellParamList.paramarray[cell_id], sizeofArray(cellParams), NRUE_CELL_RF_FREQ_OFFSET)->i64ptr);
-    nrue_cells[cell_id].numerology     = *(gpd(cellParamList.paramarray[cell_id], sizeofArray(cellParams), NRUE_CELL_NUMEROLOGY)->iptr);
-    nrue_cells[cell_id].N_RB_DL        = *(gpd(cellParamList.paramarray[cell_id], sizeofArray(cellParams), NRUE_CELL_N_RB_DL)->iptr);
-    nrue_cells[cell_id].ssb_start      = *(gpd(cellParamList.paramarray[cell_id], sizeofArray(cellParams), NRUE_CELL_SSB_START)->iptr);
-    nrue_cells[cell_id].used_by_ue     = -1;
+  for (int cell_id = 0; cell_id < cellParamList.numelt; cell_id++) {
+    paramdef_t *param = cellParamList.paramarray[cell_id];
+    const int sz = sizeofArray(cellParams);
+    nrUE_cell_params_t *cell = &nrue_rus.cfg[*gpd(param, sz, NRUE_CELL_RU_ID)->iptr].cell;
+    *cell = (nrUE_cell_params_t){.active = true,
+                                 .band = *gpd(param, sz, NRUE_CELL_BAND)->iptr,
+                                 .rf_frequency = *gpd(param, sz, NRUE_CELL_RF_FREQUENCY)->u64ptr,
+                                 .rf_freq_offset = *gpd(param, sz, NRUE_CELL_RF_FREQ_OFFSET)->i64ptr,
+                                 .numerology = *gpd(param, sz, NRUE_CELL_NUMEROLOGY)->iptr,
+                                 .N_RB_DL = *gpd(param, sz, NRUE_CELL_N_RB_DL)->iptr,
+                                 .ssb_start = *gpd(param, sz, NRUE_CELL_SSB_START)->iptr,
+                                 .fp = calloc_or_fail(1, sizeof(*nrue_rus.cfg[0].cell.fp))};
 
     LOG_I(NR_PHY,
-          "cell %d: ru_id %d, band %d, DL freq %lu, UL freq_offset %ld, numerology %d, N_RB_DL %d, ssb_start %d\n",
+          "cell %d: band %d, DL freq %lu, UL freq_offset %ld, numerology %d, N_RB_DL %d, ssb_start %d\n",
           cell_id,
-          nrue_cells[cell_id].ru_id,
-          nrue_cells[cell_id].band,
-          nrue_cells[cell_id].rf_frequency,
-          nrue_cells[cell_id].rf_freq_offset,
-          nrue_cells[cell_id].numerology,
-          nrue_cells[cell_id].N_RB_DL,
-          nrue_cells[cell_id].ssb_start);
+          cell->band,
+          cell->rf_frequency,
+          cell->rf_freq_offset,
+          cell->numerology,
+          cell->N_RB_DL,
+          cell->ssb_start);
   }
 }
 
 int nrue_get_ru_count(void)
 {
-  return nrue_ru_count;
+  return nrue_rus.count;
 }
 
-const nrUE_RU_params_t *nrue_get_ru(int ru_id)
+nrUE_RU_params_t *nrue_get_ru(int ru_id)
 {
-  AssertFatal(ru_id >= 0 && ru_id < nrue_ru_count, "Invalid RU ID %d! RU count = %d\n", ru_id, nrue_ru_count);
-  return &nrue_rus[ru_id];
-}
-
-void nrue_set_ru_cell_id(int ru_id, int cell_id)
-{
-  AssertFatal(ru_id >= 0 && ru_id < nrue_ru_count, "Invalid RU ID %d! RU count = %d\n", ru_id, nrue_ru_count);
-  AssertFatal(cell_id >= 0 && cell_id < nrue_cell_count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cell_count);
-  nrue_rus[ru_id].used_by_cell = cell_id;
+  AssertFatal(ru_id >= 0 && ru_id < nrue_rus.count, "Invalid RU ID %d! RU count = %d\n", ru_id, nrue_rus.count);
+  return &nrue_rus.cfg[ru_id];
 }
 
 void nrue_set_ru_params(configmodule_interface_t *cfg)
@@ -195,95 +157,90 @@ void nrue_set_ru_params(configmodule_interface_t *cfg)
   config_getlist(cfg, &RUParamList, RUParams, sizeofArray(RUParams), NULL);
 
   if (RUParamList.numelt <= 0) {
-    nrue_ru_count = 1;
-    nrue_rus = calloc_or_fail(nrue_ru_count, sizeof(nrUE_RU_params_t));
-    nrue_rus[0] = (nrUE_RU_params_t){.nb_tx = get_nrUE_params()->nb_antennas_tx,
-                                     .nb_rx = get_nrUE_params()->nb_antennas_rx,
-                                     .att_tx = get_nrUE_params()->tx_gain,
-                                     .att_rx = 0,
-                                     .max_rxgain = get_nrUE_params()->rx_gain,
-                                     .sdr_addrs = get_nrUE_params()->usrp_args,
-                                     .tx_subdev = get_nrUE_params()->tx_subdev,
-                                     .rx_subdev = get_nrUE_params()->rx_subdev,
-                                     .clock_source = get_softmodem_params()->clock_source,
-                                     .time_source = get_softmodem_params()->timing_source,
-                                     .tune_offset = get_softmodem_params()->tune_offset,
-                                     .if_frequency = get_nrUE_params()->if_freq,
-                                     .if_freq_offset = get_nrUE_params()->if_freq_off,
-                                     .used_by_cell = -1};
+    nrue_rus.count = 1;
+    nrue_rus.cfg = calloc_or_fail(nrue_rus.count, sizeof(*nrue_rus.cfg));
+    nrue_rus.openair0_dev = calloc_or_fail(nrue_rus.count, sizeof(*nrue_rus.openair0_dev));
+    nrue_rus.cfg[0] = (nrUE_RU_params_t){.nb_tx = get_nrUE_params()->nb_antennas_tx,
+                                         .nb_rx = get_nrUE_params()->nb_antennas_rx,
+                                         .att_tx = get_nrUE_params()->tx_gain,
+                                         .att_rx = 0,
+                                         .max_rxgain = get_nrUE_params()->rx_gain,
+                                         .sdr_addrs = get_nrUE_params()->usrp_args,
+                                         .tx_subdev = get_nrUE_params()->tx_subdev,
+                                         .rx_subdev = get_nrUE_params()->rx_subdev,
+                                         .clock_source = get_softmodem_params()->clock_source,
+                                         .time_source = get_softmodem_params()->timing_source,
+                                         .tune_offset = get_softmodem_params()->tune_offset,
+                                         .if_frequency = get_nrUE_params()->if_freq,
+                                         .if_freq_offset = get_nrUE_params()->if_freq_off};
     return;
   }
 
-  nrue_ru_count = RUParamList.numelt;
-  nrue_rus = calloc_or_fail(nrue_ru_count, sizeof(nrUE_RU_params_t));
+  nrue_rus.count = RUParamList.numelt;
+  nrue_rus.openair0_dev = calloc_or_fail(nrue_rus.count, sizeof(*nrue_rus.openair0_dev));
+  nrue_rus.cfg = calloc_or_fail(nrue_rus.count, sizeof(nrUE_RU_params_t));
 
   LOG_W(NR_PHY, "Ignoring command line RU parameters, using the following instead:\n");
 
-  for (int ru_id = 0; ru_id < nrue_ru_count; ru_id++) {
-    nrue_rus[ru_id].nb_tx            = *(gpd(RUParamList.paramarray[ru_id], sizeofArray(RUParams), NRUE_RU_NB_TX)->uptr);
-    nrue_rus[ru_id].nb_rx            = *(gpd(RUParamList.paramarray[ru_id], sizeofArray(RUParams), NRUE_RU_NB_RX)->uptr);
-    nrue_rus[ru_id].att_tx           = *(gpd(RUParamList.paramarray[ru_id], sizeofArray(RUParams), NRUE_RU_ATT_TX)->uptr);
-    nrue_rus[ru_id].att_rx           = *(gpd(RUParamList.paramarray[ru_id], sizeofArray(RUParams), NRUE_RU_ATT_RX)->uptr);
-    nrue_rus[ru_id].max_rxgain       = *(gpd(RUParamList.paramarray[ru_id], sizeofArray(RUParams), NRUE_RU_MAX_RXGAIN)->iptr);
-    nrue_rus[ru_id].tune_offset      = *(gpd(RUParamList.paramarray[ru_id], sizeofArray(RUParams), NRUE_RU_TUNE_OFFSET)->dblptr);
-    nrue_rus[ru_id].if_frequency     = *(gpd(RUParamList.paramarray[ru_id], sizeofArray(RUParams), NRUE_RU_IF_FREQUENCY)->u64ptr);
-    nrue_rus[ru_id].if_freq_offset   = *(gpd(RUParamList.paramarray[ru_id], sizeofArray(RUParams), NRUE_RU_IF_FREQ_OFFSET)->iptr);
-    nrue_rus[ru_id].used_by_cell     = -1;
-
-    nrue_rus[ru_id].sdr_addrs = strdup(*(gpd(RUParamList.paramarray[ru_id], sizeofArray(RUParams), NRUE_RU_SDR_ADDRS)->strptr));
-    nrue_rus[ru_id].tx_subdev = strdup(*(gpd(RUParamList.paramarray[ru_id], sizeofArray(RUParams), NRUE_RU_TX_SUBDEV)->strptr));
-    nrue_rus[ru_id].rx_subdev = strdup(*(gpd(RUParamList.paramarray[ru_id], sizeofArray(RUParams), NRUE_RU_RX_SUBDEV)->strptr));
-
-    int clock_src_idx = config_paramidx_fromname(RUParams, sizeofArray(RUParams), NRUE_RU_CLOCK_SRC);
+  for (int ru_id = 0; ru_id < nrue_rus.count; ru_id++) {
+    paramdef_t *param = RUParamList.paramarray[ru_id];
+    const int sz = sizeofArray(RUParams);
+    nrUE_RU_params_t *ru = nrue_rus.cfg + ru_id;
+    int clock_src_idx = config_paramidx_fromname(RUParams, sz, NRUE_RU_CLOCK_SRC);
     AssertFatal(clock_src_idx >= 0, "Index for clock_src config option not found!\n");
-    nrue_rus[ru_id].clock_source = config_get_processedint(cfg, &RUParamList.paramarray[ru_id][clock_src_idx]);
-
-    int time_src_idx = config_paramidx_fromname(RUParams, sizeofArray(RUParams), NRUE_RU_TIME_SRC);
+    int time_src_idx = config_paramidx_fromname(RUParams, sz, NRUE_RU_TIME_SRC);
     AssertFatal(time_src_idx >= 0, "Index for time_src config option not found!\n");
-    nrue_rus[ru_id].time_source = config_get_processedint(cfg, &RUParamList.paramarray[ru_id][time_src_idx]);
-
+    *ru = (nrUE_RU_params_t){.nb_tx = *gpd(param, sz, NRUE_RU_NB_TX)->uptr,
+                             .nb_rx = *gpd(param, sz, NRUE_RU_NB_RX)->uptr,
+                             .att_tx = *gpd(param, sz, NRUE_RU_ATT_TX)->uptr,
+                             .att_rx = *gpd(param, sz, NRUE_RU_ATT_RX)->uptr,
+                             .max_rxgain = *gpd(param, sz, NRUE_RU_MAX_RXGAIN)->iptr,
+                             .sdr_addrs = strdup(*gpd(param, sz, NRUE_RU_SDR_ADDRS)->strptr),
+                             .tx_subdev = strdup(*gpd(param, sz, NRUE_RU_TX_SUBDEV)->strptr),
+                             .rx_subdev = strdup(*gpd(param, sz, NRUE_RU_RX_SUBDEV)->strptr),
+                             .clock_source = config_get_processedint(cfg, param + clock_src_idx),
+                             .time_source = config_get_processedint(cfg, param + time_src_idx),
+                             .tune_offset = *gpd(param, sz, NRUE_RU_TUNE_OFFSET)->dblptr,
+                             .if_frequency = *gpd(param, sz, NRUE_RU_IF_FREQUENCY)->u64ptr,
+                             .if_freq_offset = *gpd(param, sz, NRUE_RU_IF_FREQ_OFFSET)->iptr};
     LOG_I(NR_PHY,
           "RU %d: nb_tx %d, nb_rx %d, att_tx %d, att_rx %d, max_rxgain %d, tune_offset %f, if_frequency %lu, if_freq_offset %d, "
           "sdr_addrs \"%s\", tx_subdev \"%s\", rx_subdev \"%s\", clock_source %d, time_source %d\n",
           ru_id,
-          nrue_rus[ru_id].nb_tx,
-          nrue_rus[ru_id].nb_rx,
-          nrue_rus[ru_id].att_tx,
-          nrue_rus[ru_id].att_rx,
-          nrue_rus[ru_id].max_rxgain,
-          nrue_rus[ru_id].tune_offset,
-          nrue_rus[ru_id].if_frequency,
-          nrue_rus[ru_id].if_freq_offset,
-          nrue_rus[ru_id].sdr_addrs,
-          nrue_rus[ru_id].tx_subdev,
-          nrue_rus[ru_id].rx_subdev,
-          nrue_rus[ru_id].clock_source,
-          nrue_rus[ru_id].time_source);
+          ru->nb_tx,
+          ru->nb_rx,
+          ru->att_tx,
+          ru->att_rx,
+          ru->max_rxgain,
+          ru->tune_offset,
+          ru->if_frequency,
+          ru->if_freq_offset,
+          ru->sdr_addrs,
+          ru->tx_subdev,
+          ru->rx_subdev,
+          ru->clock_source,
+          ru->time_source);
   }
 }
 
 void nrue_init_openair0(void)
 {
   int freq_off = 0;
-  bool is_sidelink = (get_softmodem_params()->sl_mode) ? true : false;
-
-  memset(openair0_cfg, 0, sizeof(openair0_config_t) * MAX_CARDS);
-  memset(openair0_dev, 0, sizeof(openair0_device_t) * MAX_CARDS);
-
-  AssertFatal(MAX_CARDS >= nrue_ru_count,
+  bool is_sidelink = get_softmodem_params()->sl_mode ? true : false;
+  AssertFatal(MAX_CARDS >= nrue_rus.count,
               "Too many RUs allocated (%d)! Maybe increase MAX_CARDS (%d).\n",
-              nrue_ru_count,
+              nrue_rus.count,
               MAX_CARDS);
 
-  for (int ru_id = 0; ru_id < nrue_ru_count; ru_id++) {
-    int cell_id = nrue_rus[ru_id].used_by_cell;
-    if (cell_id < 0) {
+  for (int ru_id = 0; ru_id < nrue_rus.count; ru_id++) {
+    nrUE_RU_params_t *ru = nrue_rus.cfg + ru_id;
+    if (!ru->cell.active) {
       LOG_W(PHY, "Skipping initialization of RU %d because it is not used by any cell!\n", ru_id);
       continue;
     }
-    NR_DL_FRAME_PARMS *frame_parms = &nrue_cell_fp[cell_id];
+    NR_DL_FRAME_PARMS *frame_parms = ru->cell.fp;
     if (is_sidelink) {
-      int UE_id = nrue_cells[cell_id].used_by_ue;
+      int UE_id = ru->cell.used_by_ue;
       if (UE_id < 0) {
         LOG_W(PHY, "Skipping initialization of RU %d because it is not used by any UE!\n", ru_id);
         continue;
@@ -291,7 +248,7 @@ void nrue_init_openair0(void)
       frame_parms = &nrPHY_vars_UE_g[UE_id][0]->SL_UE_PHY_PARAMS.sl_frame_params;
     }
 
-    openair0_config_t *cfg = &openair0_cfg[ru_id];
+    openair0_config_t *cfg = &openair0_cfg_g[ru_id];
     cfg->configFilename    = NULL;
     cfg->sample_rate       = frame_parms->samples_per_subframe * 1e3;
 
@@ -314,12 +271,12 @@ void nrue_init_openair0(void)
           duplex_mode_txt[cfg->duplex_mode]);
 
     uint64_t dl_carrier, ul_carrier;
-    if (is_sidelink || nrue_rus[ru_id].if_frequency == 0) {
+    if (is_sidelink || ru->if_frequency == 0) {
       dl_carrier = frame_parms->dl_CarrierFreq;
       ul_carrier = frame_parms->ul_CarrierFreq;
     } else {
-      dl_carrier = nrue_rus[ru_id].if_frequency;
-      ul_carrier = nrue_rus[ru_id].if_frequency + nrue_rus[ru_id].if_freq_offset;
+      dl_carrier = ru->if_frequency;
+      ul_carrier = ru->if_frequency + ru->if_freq_offset;
     }
 
     nr_rf_card_config_freq(cfg, ul_carrier, dl_carrier, freq_off);
@@ -327,106 +284,103 @@ void nrue_init_openair0(void)
 
     cfg->configFilename = get_softmodem_params()->rf_config_file;
 
-    cfg->sdr_addrs = nrue_rus[ru_id].sdr_addrs;
-    cfg->tx_subdev = nrue_rus[ru_id].tx_subdev;
-    cfg->rx_subdev = nrue_rus[ru_id].rx_subdev;
-    cfg->clock_source = nrue_rus[ru_id].clock_source;
-    cfg->time_source = nrue_rus[ru_id].time_source;
-    cfg->tune_offset = nrue_rus[ru_id].tune_offset;
+    cfg->sdr_addrs = ru->sdr_addrs;
+    cfg->tx_subdev = ru->tx_subdev;
+    cfg->rx_subdev = ru->rx_subdev;
+    cfg->clock_source = ru->clock_source;
+    cfg->time_source = ru->time_source;
+    cfg->tune_offset = ru->tune_offset;
   }
 }
 
 void nrue_ru_start(void)
 {
-  for (int ru_id = 0; ru_id < nrue_ru_count; ru_id++) {
-    openair0_config_t *cfg0 = &openair0_cfg[ru_id];
-    openair0_device_t *dev0 = &openair0_dev[ru_id];
+  for (int ru_id = 0; ru_id < nrue_rus.count; ru_id++) {
+    openair0_config_t *cfg = &openair0_cfg_g[ru_id];
+    openair0_device_t *dev = &nrue_rus.openair0_dev[ru_id];
 
-    dev0->host_type = RAU_HOST;
-    int tmp = openair0_device_load(dev0, cfg0);
+    dev->host_type = RAU_HOST;
+    int tmp = openair0_device_load(dev, cfg);
     AssertFatal(tmp == 0, "Could not load the device %d\n", ru_id);
-    int tmp2 = dev0->trx_start_func(dev0);
+    int tmp2 = dev->trx_start_func(dev);
     AssertFatal(tmp2 == 0, "Could not start the device %d\n", ru_id);
     if (usrp_tx_thread == 1)
-      dev0->trx_write_init(dev0);
+      dev->trx_write_init(dev);
   }
 }
 
 void nrue_ru_stop(void)
 {
-  for (int ru_id = 0; ru_id < nrue_ru_count; ru_id++) {
-    if (openair0_dev[ru_id].trx_stop_func)
-      openair0_dev[ru_id].trx_stop_func(&openair0_dev[ru_id]);
+  for (openair0_device_t *ru = nrue_rus.openair0_dev; ru < nrue_rus.openair0_dev + nrue_rus.count; ru++) {
+    if (ru->trx_stop_func)
+      ru->trx_stop_func(ru);
   }
 }
 
 void nrue_ru_end(void)
 {
-  for (int ru_id = 0; ru_id < nrue_ru_count; ru_id++) {
-    if (openair0_dev[ru_id].trx_get_stats_func)
-      openair0_dev[ru_id].trx_get_stats_func(&openair0_dev[ru_id]);
-    if (openair0_dev[ru_id].trx_end_func)
-      openair0_dev[ru_id].trx_end_func(&openair0_dev[ru_id]);
+  for (openair0_device_t *ru = nrue_rus.openair0_dev; ru < nrue_rus.openair0_dev + nrue_rus.count; ru++) {
+    if (ru->trx_get_stats_func)
+      ru->trx_get_stats_func(ru);
+    if (ru->trx_end_func)
+      ru->trx_end_func(ru);
   }
 }
 
 void nrue_ru_set_freq(PHY_VARS_NR_UE *UE, uint64_t ul_carrier, uint64_t dl_carrier, int freq_offset)
 {
-  int current_cell_id = nrue_rus[UE->rf_map.card].used_by_cell;
-  NR_DL_FRAME_PARMS *fp0 = &nrue_cell_fp[current_cell_id];
+  nrUE_RU_params_t *ru = nrue_rus.cfg + UE->rf_map.card;
+  NR_DL_FRAME_PARMS *fp0 = ru->cell.fp;
   uint64_t dl_carrier_distance =
       fp0->dl_CarrierFreq > dl_carrier ? fp0->dl_CarrierFreq - dl_carrier : dl_carrier - fp0->dl_CarrierFreq;
   uint64_t ul_carrier_distance =
       fp0->ul_CarrierFreq > ul_carrier ? fp0->ul_CarrierFreq - ul_carrier : ul_carrier - fp0->ul_CarrierFreq;
   uint64_t carrier_distance = dl_carrier_distance + ul_carrier_distance;
 
-  for (int ru_id = 0; carrier_distance != 0 && ru_id < nrue_ru_count; ru_id++) {
-    int cell_id = nrue_rus[ru_id].used_by_cell;
-    if (cell_id < 0) // skip RUs that have no cell definition
+  for (int ru_id = 0; carrier_distance != 0 && ru_id < nrue_rus.count; ru_id++) {
+    nrUE_RU_params_t *ru_loop = nrue_rus.cfg + ru_id;
+    if (!ru_loop->cell.active) // skip RUs that have no cell definition
       continue;
-    if (nrue_cells[cell_id].used_by_ue >= 0) // skip cells that are already used by an UE
+    if (ru_loop->cell.used_by_ue >= 0) // skip cells that are already used by an UE
       continue;
 
-    fp0 = &nrue_cell_fp[cell_id];
+    fp0 = ru_loop->cell.fp;
     uint64_t this_dl_carrier_distance =
         fp0->dl_CarrierFreq > dl_carrier ? fp0->dl_CarrierFreq - dl_carrier : dl_carrier - fp0->dl_CarrierFreq;
     uint64_t this_ul_carrier_distance =
         fp0->ul_CarrierFreq > ul_carrier ? fp0->ul_CarrierFreq - ul_carrier : ul_carrier - fp0->ul_CarrierFreq;
     uint64_t this_carrier_distance = this_dl_carrier_distance + this_ul_carrier_distance;
     if (this_carrier_distance < carrier_distance) {
-      UE->rf_map.card = ru_id;
+      UE->rf_map.card = ru_id; // ???? fixme
       carrier_distance = this_carrier_distance;
     }
   }
 
-  nrue_cells[current_cell_id].used_by_ue = -1;
-  current_cell_id = nrue_rus[UE->rf_map.card].used_by_cell;
-  nrue_cells[current_cell_id].used_by_ue = UE->Mod_id;
-
-  openair0_config_t *cfg0 = &openair0_cfg[UE->rf_map.card];
-  openair0_device_t *dev0 = &openair0_dev[UE->rf_map.card];
-  nr_rf_card_config_freq(cfg0, ul_carrier, dl_carrier, freq_offset);
-  dev0->trx_set_freq_func(dev0, cfg0);
+  ru->cell.used_by_ue = UE->Mod_id;
+  openair0_config_t *cfg = &openair0_cfg_g[UE->rf_map.card];
+  openair0_device_t *dev = &nrue_rus.openair0_dev[UE->rf_map.card];
+  nr_rf_card_config_freq(cfg, ul_carrier, dl_carrier, freq_offset);
+  dev->trx_set_freq_func(dev, cfg);
 }
 
 int nrue_ru_adjust_rx_gain(PHY_VARS_NR_UE *UE, int gain_change)
 {
-  openair0_config_t *cfg0 = &openair0_cfg[UE->rf_map.card];
-  openair0_device_t *dev0 = &openair0_dev[UE->rf_map.card];
+  openair0_config_t *cfg = &openair0_cfg_g[UE->rf_map.card];
+  openair0_device_t *dev = &nrue_rus.openair0_dev[UE->rf_map.card];
 
   // Increase the RX gain by the value determined by adjust_rxgain
-  cfg0->rx_gain[0] += gain_change;
+  cfg->rx_gain[0] += gain_change;
 
   // Set new RX gain.
-  int ret_gain = dev0->trx_set_gains_func(dev0, cfg0);
+  int ret_gain = dev->trx_set_gains_func(dev, cfg);
   // APPLY RX gain again if crossed the MAX RX gain threshold
   if (ret_gain < 0) {
     gain_change += ret_gain;
-    cfg0->rx_gain[0] += ret_gain;
-    ret_gain = dev0->trx_set_gains_func(dev0, cfg0);
+    cfg->rx_gain[0] += ret_gain;
+    ret_gain = dev->trx_set_gains_func(dev, cfg);
   }
 
-  int applied_rxgain = cfg0->rx_gain[0] - cfg0->rx_gain_offset[0];
+  int applied_rxgain = cfg->rx_gain[0] - cfg->rx_gain_offset[0];
   LOG_I(HW, "Rxgain adjusted by %d dB, RX gain: %d dB \n", gain_change, applied_rxgain);
 
   return gain_change;
@@ -434,14 +388,14 @@ int nrue_ru_adjust_rx_gain(PHY_VARS_NR_UE *UE, int gain_change)
 
 int nrue_ru_read(PHY_VARS_NR_UE *UE, openair0_timestamp_t *ptimestamp, void **buff, int nsamps, int num_antennas)
 {
-  openair0_device_t *dev0 = &openair0_dev[UE->rf_map.card];
+  openair0_device_t *dev = &nrue_rus.openair0_dev[UE->rf_map.card];
   openair0_timestamp_t tmp_timestamp;
-  int ret = dev0->trx_read_func(dev0, &tmp_timestamp, buff, nsamps, num_antennas);
-  if (!dev0->firstTS_initialized) {
-    dev0->firstTS = tmp_timestamp;
-    dev0->firstTS_initialized = true;
+  int ret = dev->trx_read_func(dev, &tmp_timestamp, buff, nsamps, num_antennas);
+  if (!dev->firstTS_initialized) {
+    dev->firstTS = tmp_timestamp;
+    dev->firstTS_initialized = true;
   }
-  *ptimestamp = tmp_timestamp - dev0->firstTS;
+  *ptimestamp = tmp_timestamp - dev->firstTS;
 
   if (UE->Mod_id != 0)
     return ret;
@@ -453,19 +407,16 @@ int nrue_ru_read(PHY_VARS_NR_UE *UE, openair0_timestamp_t *ptimestamp, void **bu
   for (int ant = 0; ant < num_antennas; ant++)
     tmp_buf[ant] = tmp_samples;
 
-  for (int ru_id = 0; ru_id < nrue_ru_count; ru_id++) {
-    int cell_id = nrue_rus[ru_id].used_by_cell;
-    if (cell_id < 0) // skip RUs that have no cell definition
+  for (int ru_id = 0; ru_id < nrue_rus.count; ru_id++) {
+    if (!nrue_rus.cfg[ru_id].cell.active) // skip RUs that have no cell definition
       continue;
-    int ue_id = nrue_cells[cell_id].used_by_ue;
-    if (ue_id >= 0) // skip cells that are already used by an UE
+    if (nrue_rus.cfg[ru_id].cell.used_by_ue >= 0) // skip cells that are already used by an UE
       continue;
-
-    dev0 = &openair0_dev[ru_id];
-    dev0->trx_read_func(dev0, &tmp_timestamp, tmp_buf, nsamps, num_antennas);
-    if (!dev0->firstTS_initialized) {
-      dev0->firstTS = tmp_timestamp;
-      dev0->firstTS_initialized = true;
+    dev = &nrue_rus.openair0_dev[ru_id];
+    dev->trx_read_func(dev, &tmp_timestamp, tmp_buf, nsamps, num_antennas);
+    if (!dev->firstTS_initialized) {
+      dev->firstTS = tmp_timestamp;
+      dev->firstTS_initialized = true;
     }
   }
 
@@ -474,8 +425,8 @@ int nrue_ru_read(PHY_VARS_NR_UE *UE, openair0_timestamp_t *ptimestamp, void **bu
 
 int nrue_ru_write(PHY_VARS_NR_UE *UE, openair0_timestamp_t timestamp, void **buff, int nsamps, int num_antennas, int flags)
 {
-  openair0_device_t *dev0 = &openair0_dev[UE->rf_map.card];
-  int ret = dev0->trx_write_func(dev0, timestamp + dev0->firstTS, buff, nsamps, num_antennas, flags);
+  openair0_device_t *dev = &nrue_rus.openair0_dev[UE->rf_map.card];
+  int ret = dev->trx_write_func(dev, timestamp + dev->firstTS, buff, nsamps, num_antennas, flags);
 
   if (UE->Mod_id != 0)
     return ret;
@@ -488,38 +439,25 @@ int nrue_ru_write(PHY_VARS_NR_UE *UE, openair0_timestamp_t timestamp, void **buf
   for (int ant = 0; ant < num_antennas; ant++)
     tmp_buf[ant] = tmp_samples;
 
-  for (int ru_id = 0; ru_id < nrue_ru_count; ru_id++) {
-    int cell_id = nrue_rus[ru_id].used_by_cell;
-    if (cell_id < 0) // skip RUs that have no cell definition
+  for (int ru_id = 0; ru_id < nrue_rus.count; ru_id++) {
+    if (!nrue_rus.cfg[ru_id].cell.active) // skip RUs that have no cell definition
       continue;
-    int ue_id = nrue_cells[cell_id].used_by_ue;
-    if (ue_id >= 0) // skip cells that are already used by an UE
+    if (nrue_rus.cfg[ru_id].cell.used_by_ue >= 0) // skip cells that are already used by an UE
       continue;
-
-    dev0 = &openair0_dev[ru_id];
-    dev0->trx_write_func(dev0, timestamp + dev0->firstTS, tmp_buf, nsamps, num_antennas, flags);
+    dev = &nrue_rus.openair0_dev[ru_id];
+    dev->trx_write_func(dev, timestamp + dev->firstTS, tmp_buf, nsamps, num_antennas, flags);
   }
   return ret;
 }
 
-typedef int (*nrue_ru_write_t)(PHY_VARS_NR_UE *UE, openair0_timestamp_t timestamp, void **txp, int nsamps, int nbAnt, int flags);
-int openair0_write_reorder_common(nrue_ru_write_t nrue_ru_write,
-                                  PHY_VARS_NR_UE *UE,
-                                  openair0_device_t *device,
-                                  openair0_timestamp_t timestamp,
-                                  void **txp,
-                                  int nsamps,
-                                  int nbAnt,
-                                  int flags);
-
 int nrue_ru_write_reorder(PHY_VARS_NR_UE *UE, openair0_timestamp_t timestamp, void **txp, int nsamps, int nbAnt, int flags)
 {
-  openair0_device_t *device = &openair0_dev[UE->rf_map.card];
+  openair0_device_t *device = &nrue_rus.openair0_dev[UE->rf_map.card];
   return openair0_write_reorder_common(nrue_ru_write, UE, device, timestamp, txp, nsamps, nbAnt, flags);
 }
 
 void nrue_ru_write_reorder_clear_context(PHY_VARS_NR_UE *UE)
 {
-  openair0_device_t *device = &openair0_dev[UE->rf_map.card];
+  openair0_device_t *device = &nrue_rus.openair0_dev[UE->rf_map.card];
   openair0_write_reorder_clear_context(device);
 }

executables/nr-ue-ru.h

@@ -8,15 +8,10 @@
 #include "PHY/defs_nr_UE.h"
 #include "radio/COMMON/common_lib.h"
 
-int nrue_get_cell_count(void);
-const nrUE_cell_params_t *nrue_get_cell(int cell_id);
-NR_DL_FRAME_PARMS *nrue_get_cell_fp(int cell_id);
-void nrue_set_cell(int cell_id, const nrUE_cell_params_t *cell);
 void nrue_set_cell_params(configmodule_interface_t *cfg);
 int nrue_get_band(const PHY_VARS_NR_UE *UE);
 int nrue_get_ru_count(void);
-const nrUE_RU_params_t *nrue_get_ru(int ru_id);
-void nrue_set_ru_cell_id(int ru_id, int cell_id);
+nrUE_RU_params_t *nrue_get_ru(int ru_id);
 void nrue_set_ru_params(configmodule_interface_t *cfg);
 
 void nrue_init_openair0(void);

executables/nr-ue.c

@@ -770,7 +770,6 @@ void *UE_thread(void *arg)
       readFrame(UE, &tmp, duration_rx_to_tx, true);
   }
 
-  c16_t *rxp[fp->nb_antennas_rx];
   while (!oai_exit) {
     if (syncRunning) {
       notifiedFIFO_elt_t *res = pollNotifiedFIFO(&nf);
@@ -806,7 +805,7 @@ void *UE_thread(void *arg)
           /* For IQ recorder-player we force synchronization to happen in a fixed duration so that
              the replay runs in sync with recorded samples.
           */
-          openair0_config_t *cfg0 = &openair0_cfg[UE->rf_map.card];
+          openair0_config_t *cfg0 = &openair0_cfg_g[UE->rf_map.card];
           const unsigned int sync_in_frames = cfg0->recplay_conf->u_f_sync;
           while (trashed_frames != sync_in_frames) {
             readFrame(UE, &sync_timestamp, duration_rx_to_tx, true);
@@ -936,6 +935,7 @@ void *UE_thread(void *arg)
     }
 
     int firstSymSamp = get_firstSymSamp(slot_nr, fp);
+    c16_t *rxp[fp->nb_antennas_rx];
     for (int i = 0; i < fp->nb_antennas_rx; i++)
       rxp[i] = &UE->common_vars.rxdata[i][firstSymSamp + get_samples_slot_timestamp(fp, slot_nr)];
 

executables/nr-uesoftmodem.c

@@ -168,11 +168,10 @@ static void set_UE_options(int CC_id, PHY_VARS_NR_UE *UE, int ru_id)
         UE->UE_fo_compensation, UE->UE_scan_carrier, UE->no_timing_correction, UE->chest_freq, UE->chest_time);
 }
 
-static void set_fp_options(int cell_id, int ru_id)
+static void set_fp_options(int ru_id)
 {
-  NR_DL_FRAME_PARMS *fp = nrue_get_cell_fp(cell_id);
   const nrUE_RU_params_t *RU = nrue_get_ru(ru_id);
-
+  NR_DL_FRAME_PARMS *fp = RU->cell.fp;
   // Set FP variables
   fp->nb_antennas_rx = RU->nb_rx;
   fp->nb_antennas_tx = RU->nb_tx;
@@ -285,7 +284,7 @@ int main(int argc, char **argv)
              get_nrUE_params()->uecap_file,
              get_nrUE_params()->reconfig_file,
              get_nrUE_params()->rbconfig_file,
-             nrue_get_cell(0)->numerology);
+             nrue_get_ru(0)->cell.numerology);
 
   // start time manager with some reasonable default for the running mode
   // (may be overwritten in configuration file or command line)
@@ -303,50 +302,26 @@ int main(int argc, char **argv)
                                         : TIME_SOURCE_REALTIME);
 
   // initialize per-cell frame parameters
-  for (int cell_id = 0; cell_id < nrue_get_cell_count(); cell_id++) {
-    int ru_id = nrue_get_cell(cell_id)->ru_id;
-    AssertFatal(ru_id >= 0 && ru_id < nrue_get_ru_count(),
-                "Invalid ru_id (%d) for cell %d. Should be >= 0 and < %d\n",
-                ru_id,
-                cell_id,
-                nrue_get_ru_count());
-    AssertFatal(nrue_get_ru(ru_id)->used_by_cell == -1,
-                "RU %d is already used by cell %d and therefore cannot also be used by cell %d\n",
-                ru_id,
-                nrue_get_ru(ru_id)->used_by_cell,
-                cell_id);
-    nrue_set_ru_cell_id(ru_id, cell_id);
-
-    set_fp_options(cell_id, ru_id);
+  for (int ru_id = 0; ru_id < nrue_get_ru_count(); ru_id++) {
+    nrUE_RU_params_t *ru = nrue_get_ru(ru_id);
+    if (!ru->cell.active) // skip RUs that have no cell definition
+      continue;
+    set_fp_options(ru_id);
     if (IS_SA_MODE(get_softmodem_params()) || get_softmodem_params()->sl_mode)
-      nr_init_frame_parms_ue_sa(nrue_get_cell_fp(cell_id), nrue_get_cell(cell_id));
+      nr_init_frame_parms_ue_sa(ru->cell.fp, &ru->cell);
   }
 
-  int cell_id = 0;
+  int ru_id = 0;
   for (int inst = 0; inst < NB_UE_INST; inst++) {
     NR_UE_MAC_INST_t *mac = get_mac_inst(inst);
-
     for (int CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++) {
       PHY_VARS_NR_UE *UE_CC = nrPHY_vars_UE_g[inst][CC_id];
-
-      AssertFatal(cell_id >= 0 && cell_id < nrue_get_cell_count(),
-                  "There are not enough cell definitions for all UEs! NB_UE_INST = %d, MAX_NUM_CCs = %d, nrue_cell_count = %d\n",
-                  NB_UE_INST,
-                  MAX_NUM_CCs,
-                  nrue_get_cell_count());
-      nrUE_cell_params_t cell = *nrue_get_cell(cell_id);
-
-      AssertFatal(cell.used_by_ue == -1,
-                  "Cell %d is already used by UE %d and cannot also be used by UE %d as cells map 1:1 to RUs and RU sharing is not implemented\n",
-                  cell_id,
-                  cell.used_by_ue,
-                  inst);
-      cell.used_by_ue = inst;
-
-      set_UE_options(CC_id, UE_CC, cell.ru_id);
+      // fixme: it seems implicit mapping
+      AssertFatal(ru_id < nrue_get_ru_count(), " more UEs than ru+cell definitions in the config file\n");
+      set_UE_options(CC_id, UE_CC, ru_id);
       init_nr_ue_phy_cpu_stats(&UE_CC->phy_cpu_stats);
-
-      NR_DL_FRAME_PARMS *fp = nrue_get_cell_fp(cell_id);
+      nrUE_RU_params_t *ru = nrue_get_ru(ru_id);
+      NR_DL_FRAME_PARMS *fp = ru->cell.fp;
       if (!IS_SA_MODE(get_softmodem_params()) && !get_softmodem_params()->sl_mode) {
         do {
           notifiedFIFO_elt_t *elt = pollNotifiedFIFO(&mac->input_nf);
@@ -359,19 +334,18 @@ int main(int argc, char **argv)
         fapi_nr_config_request_t *nrUE_config = &UE_CC->nrUE_config;
         nr_init_frame_parms_ue(fp, nrUE_config, mac->nr_band);
 
-        cell.band = mac->nr_band;
-        cell.rf_frequency = fp->dl_CarrierFreq;
-        cell.rf_freq_offset = fp->ul_CarrierFreq - fp->dl_CarrierFreq;
-        cell.numerology = fp->numerology_index;
-        cell.N_RB_DL = fp->N_RB_DL;
-        cell.ssb_start = fp->ssb_start_subcarrier;
+        ru->cell.band = mac->nr_band;
+        ru->cell.rf_frequency = fp->dl_CarrierFreq;
+        ru->cell.rf_freq_offset = fp->ul_CarrierFreq - fp->dl_CarrierFreq;
+        ru->cell.numerology = fp->numerology_index;
+        ru->cell.N_RB_DL = fp->N_RB_DL;
+        ru->cell.ssb_start = fp->ssb_start_subcarrier;
       }
-      nrue_set_cell(cell_id, &cell);
 
       UE_CC->frame_parms = *fp;
-      mac->nr_band = cell.band;
-      mac->ssb_start_subcarrier = cell.ssb_start;
-      mac->dl_frequency = cell.rf_frequency;
+      mac->nr_band = ru->cell.band;
+      mac->ssb_start_subcarrier = ru->cell.ssb_start;
+      mac->dl_frequency = ru->cell.rf_frequency;
 
       UE_CC->sl_mode = get_softmodem_params()->sl_mode;
       init_actor(&UE_CC->sync_actor, "SYNC_", -1);
@@ -404,7 +378,7 @@ int main(int argc, char **argv)
         sl_ue_phy_init(UE_CC);
       }
 
-      cell_id++; // initially connect each UE and carrier to its own cell
+      ru_id++; // initially connect each UE and carrier to its own cell
     }
   }
 

executables/ru_control.c

@@ -562,12 +562,15 @@ void* ru_thread_control( void* param )
 					 
 		//if (ru->is_slave == 1) lte_sync_time_init(&ru->frame_parms);
 
-		if (ru->rfdevice.is_init != 1) openair0_device_load(&ru->rfdevice,&ru->openair0_cfg);
-		
-		if (ru->rfdevice.trx_config_func) AssertFatal((ru->rfdevice.trx_config_func(&ru->rfdevice,&ru->openair0_cfg)==0), 
-							      "Failed to configure RF device for RU %d\n",ru->idx);
+    if (ru->rfdevice.is_init != 1)
+      openair0_device_load(&ru->rfdevice, &ru->openair0_cfg);
 
-		if (setup_RU_buffers(ru)!=0) {
+    if (ru->rfdevice.trx_config_func)
+      AssertFatal((ru->rfdevice.trx_config_func(&ru->rfdevice, &ru->openair0_cfg) == 0),
+                  "Failed to configure RF device for RU %d\n",
+                  ru->idx);
+
+    if (setup_RU_buffers(ru)!=0) {
 		  printf("Exiting, cannot initialize RU Buffers\n");
 		  exit(-1);
 		}

openair1/PHY/LTE_UE_TRANSPORT/initial_sync.c

@@ -482,10 +482,11 @@ int initial_sync(PHY_VARS_UE *ue, runmode_t mode) {
           ue->frame_parms.phich_config_common.phich_duration,
           phich_string[ue->frame_parms.phich_config_common.phich_resource],
           ue->frame_parms.nb_antenna_ports_eNB);
-    LOG_I(PHY, "[UE %d] Frame %d Measured Carrier Frequency %.0f Hz (offset %d Hz)\n",
+    LOG_I(PHY,
+          "[UE %d] Frame %d Measured Carrier Frequency %.0f Hz (offset %d Hz)\n",
           ue->Mod_id,
           ue->proc.proc_rxtx[0].frame_rx,
-          openair0_cfg[0].rx_freq[0]-ue->common_vars.freq_offset,
+          openair0_cfg_g[0].rx_freq[0] - ue->common_vars.freq_offset,
           ue->common_vars.freq_offset);
   } else {
     LOG_D(PHY,"[UE%d] Initial sync : PBCH not ok\n",ue->Mod_id);

openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c

@@ -440,16 +440,13 @@ int nr_prs_channel_estimation(uint8_t gNB_id,
     // peak estimator
     mean_val = squaredMod(((c16_t *)ch_tmp)[(prs_cfg->NumRB * 12) >> 1]);
     peak_estimator(&chT_interpol[rxAnt][0], NR_PRS_IDFT_OVERSAMP_FACTOR * frame_params->ofdm_symbol_size, &prs_toa, &ch_pwr, mean_val);
-
+    openair0_config_t *cfg = &openair0_cfg_g[ue->rf_map.card];
     // adjusting the rx_gains for channel peak power
-    ch_pwr_dbm = 10 * log10(ch_pwr) + 30 - SQ15_SQUARED_NORM_FACTOR_DB
-                 - ((int)openair0_cfg[ue->rf_map.card].rx_gain[0] - (int)openair0_cfg[ue->rf_map.card].rx_gain_offset[0])
+    ch_pwr_dbm = 10 * log10(ch_pwr) + 30 - SQ15_SQUARED_NORM_FACTOR_DB - ((int)cfg->rx_gain[0] - (int)cfg->rx_gain_offset[0])
                  - dB_fixed(frame_params->ofdm_symbol_size);
 
-    prs_meas[rxAnt]->rsrp_dBm =
-        10 * log10(prs_meas[rxAnt]->rsrp) + 30 - SQ15_SQUARED_NORM_FACTOR_DB
-        - ((int)openair0_cfg[ue->rf_map.card].rx_gain[0] - (int)openair0_cfg[ue->rf_map.card].rx_gain_offset[0])
-        - dB_fixed(ue->frame_parms.ofdm_symbol_size);
+    prs_meas[rxAnt]->rsrp_dBm = 10 * log10(prs_meas[rxAnt]->rsrp) + 30 - SQ15_SQUARED_NORM_FACTOR_DB
+                                - ((int)cfg->rx_gain[0] - (int)cfg->rx_gain_offset[0]) - dB_fixed(ue->frame_parms.ofdm_symbol_size);
 
     // prs measurements
     prs_meas[rxAnt]->gNB_id     = gNB_id;

openair1/PHY/NR_UE_ESTIMATION/nr_ue_measurements.c

@@ -100,7 +100,7 @@ void nr_ue_measurements(PHY_VARS_NR_UE *ue,
     ue->measurements.wideband_cqi_avg[gNB_id] = ue->measurements.rx_power_avg_dB[gNB_id] - ue->measurements.n0_power_avg_dB;
     ue->measurements.rx_rssi_dBm[gNB_id] =
         ue->measurements.rx_power_avg_dB[gNB_id] + 30 - SQ15_SQUARED_NORM_FACTOR_DB
-        - ((int)openair0_cfg[ue->rf_map.card].rx_gain[0] - (int)openair0_cfg[ue->rf_map.card].rx_gain_offset[0])
+        - ((int)openair0_cfg_g[ue->rf_map.card].rx_gain[0] - (int)openair0_cfg_g[ue->rf_map.card].rx_gain_offset[0])
         - dB_fixed(ue->frame_parms.ofdm_symbol_size);
 
     LOG_D(PHY, "[gNB %d] Slot %d, RSSI %d dB (%d dBm/RE), WBandCQI %d dB, rxPwrAvg %d, n0PwrAvg %d\n",
@@ -187,13 +187,13 @@ void nr_ue_ssb_rsrp_measurements(PHY_VARS_NR_UE *ue,
   uint32_t rsrp_avg = nr_ue_calculate_ssb_rsrp(fp, rxdataF, fp->ssb_start_subcarrier);
   float rsrp_db_per_re = 10 * log10(rsrp_avg);
 
-  openair0_config_t *cfg0 = &openair0_cfg[ue->rf_map.card];
+  openair0_config_t *cfg = &openair0_cfg_g[ue->rf_map.card];
 
   if (rsrp_avg == 0)
     ue->measurements.ssb_rsrp_dBm[ssb_index] = -200; // lower than any value to be reported per Table 10.1.6.1-1 of 38.133
   else
     ue->measurements.ssb_rsrp_dBm[ssb_index] = rsrp_db_per_re + 30 - SQ15_SQUARED_NORM_FACTOR_DB
-                                               - ((int)cfg0->rx_gain[0] - (int)cfg0->rx_gain_offset[0])
+                                               - ((int)cfg->rx_gain[0] - (int)cfg->rx_gain_offset[0])
                                                - dB_fixed(fp->ofdm_symbol_size);
 
   // to obtain non-integer dB value with a resoluion of 0.5dB
@@ -436,7 +436,7 @@ void do_neighboring_cell_measurements(UE_nr_rxtx_proc_t *proc, PHY_VARS_NR_UE *u
 
     neighboring_cell_info->ssb_rsrp_dBm =
         10 * log10(neighboring_cell_info->ssb_rsrp) + 30 - SQ15_SQUARED_NORM_FACTOR_DB
-        - ((int)openair0_cfg[ue->rf_map.card].rx_gain[0] - (int)openair0_cfg[ue->rf_map.card].rx_gain_offset[0])
+        - ((int)openair0_cfg_g[ue->rf_map.card].rx_gain[0] - (int)openair0_cfg_g[ue->rf_map.card].rx_gain_offset[0])
         - dB_fixed(ue->frame_parms.ofdm_symbol_size);
 
     // Send SS measurements to MAC
@@ -467,8 +467,8 @@ void nr_ue_rrc_measurements(PHY_VARS_NR_UE *ue,
   const uint8_t k_right = 183;
   const uint8_t k_length = 8;
   unsigned int ssb_offset = ue->frame_parms.first_carrier_offset + ue->frame_parms.ssb_start_subcarrier;
-  double rx_gain = openair0_cfg[ue->rf_map.card].rx_gain[0];
-  double rx_gain_offset = openair0_cfg[ue->rf_map.card].rx_gain_offset[0];
+  double rx_gain = openair0_cfg_g[ue->rf_map.card].rx_gain[0];
+  double rx_gain_offset = openair0_cfg_g[ue->rf_map.card].rx_gain_offset[0];
 
   ue->measurements.n0_power_tot = 0;
 
@@ -582,7 +582,7 @@ int nr_sl_psbch_rsrp_measurements(PHY_VARS_NR_UE *ue,
     psbch_rx->rsrp_dB_per_RE = 10 * log10(psbch_rx->rsrp_sum / psbch_rx->rsrp_re_sum);
     psbch_rx->rsrp_dBm_per_RE =
         psbch_rx->rsrp_dB_per_RE + 30 - SQ15_SQUARED_NORM_FACTOR_DB
-        - ((int)openair0_cfg[ue->rf_map.card].rx_gain[0] - (int)openair0_cfg[ue->rf_map.card].rx_gain_offset[0])
+        - ((int)openair0_cfg_g[ue->rf_map.card].rx_gain[0] - (int)openair0_cfg_g[ue->rf_map.card].rx_gain_offset[0])
         - dB_fixed(fp->ofdm_symbol_size);
     adjust_rxgain = TARGET_RX_POWER - psbch_rx->rsrp_dB_per_RE;
     LOG_D(PHY,

openair1/PHY/NR_UE_TRANSPORT/csi_rx.c

@@ -25,8 +25,6 @@
 //#define NR_CSIRS_DEBUG
 //#define NR_CSIIM_DEBUG
 
-extern openair0_config_t openair0_cfg[MAX_CARDS];
-
 void nr_det_A_MF_2x2(int32_t *a_mf_00,
                      int32_t *a_mf_01,
                      int32_t *a_mf_10,
@@ -222,7 +220,7 @@ static int nr_get_csi_rs_signal(const PHY_VARS_NR_UE *ue,
 
   *rsrp = rsrp_sum/meas_count;
   *rsrp_dBm = dB_fixed(*rsrp) + 30 - SQ15_SQUARED_NORM_FACTOR_DB
-              - ((int)openair0_cfg[ue->rf_map.card].rx_gain[0] - (int)openair0_cfg[ue->rf_map.card].rx_gain_offset[0])
+              - ((int)openair0_cfg_g[ue->rf_map.card].rx_gain[0] - (int)openair0_cfg_g[ue->rf_map.card].rx_gain_offset[0])
               - dB_fixed(ue->frame_parms.ofdm_symbol_size);
 
 #ifdef NR_CSIRS_DEBUG

openair1/PHY/defs_nr_UE.h

@@ -239,6 +239,18 @@ typedef struct UE_NR_SCAN_INFO_s {
   int32_t freq_offset_Hz[3][10];
 } UE_NR_SCAN_INFO_t;
 
+typedef struct {
+  bool active;
+  int band;
+  uint64_t rf_frequency;
+  int64_t rf_freq_offset;
+  int numerology;
+  int N_RB_DL;
+  int ssb_start;
+  int used_by_ue;
+  NR_DL_FRAME_PARMS *fp;
+} nrUE_cell_params_t;
+
 typedef struct {
   unsigned int nb_tx;
   unsigned int nb_rx;
@@ -253,20 +265,9 @@ typedef struct {
   double tune_offset;
   uint64_t if_frequency;
   int if_freq_offset;
-  int used_by_cell;
+  nrUE_cell_params_t cell;
 } nrUE_RU_params_t;
 
-typedef struct {
-  int ru_id;
-  int band;
-  uint64_t rf_frequency;
-  int64_t rf_freq_offset;
-  int numerology;
-  int N_RB_DL;
-  int ssb_start;
-  int used_by_ue;
-} nrUE_cell_params_t;
-
 /// Top-level PHY Data Structure for UE
 typedef struct PHY_VARS_NR_UE_s {
   /// \brief Module ID indicator for this instance

openair1/SIMULATION/NR_PHY/dlsim.c

@@ -168,7 +168,7 @@ void nr_derive_key(int alg_type, uint8_t alg_id, const uint8_t key[32], uint8_t
 void processSlotTX(void *arg) {}
 
 // needed for some functions
-openair0_config_t openair0_cfg[MAX_CARDS];
+openair0_config_t openair0_cfg_g[MAX_CARDS] = {};
 void update_ptrs_config(NR_CellGroupConfig_t *secondaryCellGroup, uint16_t *rbSize, uint8_t *mcsIndex,int8_t *ptrs_arg);
 void update_dmrs_config(NR_CellGroupConfig_t *scg, int8_t *dmrs_arg);
 

openair1/SIMULATION/NR_PHY/pbchsim.c

@@ -43,7 +43,7 @@ int64_t uplink_frequency_offset[MAX_NUM_CCs][4];
 double cpuf;
 
 // needed for some functions
-openair0_config_t openair0_cfg[MAX_CARDS];
+openair0_config_t openair0_cfg_g[MAX_CARDS] = {};
 
 uint8_t const nr_rv_round_map[4] = {0, 2, 3, 1};
 

openair1/SIMULATION/NR_PHY/psbchsim.c

@@ -56,7 +56,7 @@ void get_num_re_dmrs(nfapi_nr_ue_pusch_pdu_t *pusch_pdu, uint8_t *nb_dmrs_re_per
 uint64_t downlink_frequency[MAX_NUM_CCs][4];
 int64_t uplink_frequency_offset[MAX_NUM_CCs][4];
 THREAD_STRUCT thread_struct;
-openair0_config_t openair0_cfg[MAX_CARDS];
+openair0_config_t openair0_cfg_g[MAX_CARDS] = {};
 
 RAN_CONTEXT_t RC;
 char *uecap_file;

openair1/SIMULATION/NR_PHY/srssim.c

@@ -40,7 +40,7 @@ THREAD_STRUCT thread_struct;
 
 // needed for some functions
 uint16_t n_rnti = 0x1234;
-openair0_config_t openair0_cfg[MAX_CARDS];
+openair0_config_t openair0_cfg_g[MAX_CARDS] = {};
 nrUE_params_t nrUE_params;
 
 nrUE_params_t *get_nrUE_params(void)
@@ -316,7 +316,7 @@ int main(int argc, char *argv[])
   gNB = calloc_or_fail(1, sizeof(PHY_VARS_gNB));
   gNB->ofdm_offset_divisor = UINT_MAX;
   gNB->RU_list[0] = calloc_or_fail(1, sizeof(**gNB->RU_list));
-  gNB->RU_list[0]->rfdevice.openair0_cfg = openair0_cfg;
+  gNB->RU_list[0]->rfdevice.openair0_cfg = openair0_cfg_g;
 
   NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
   fp->N_RB_DL = N_RB_DL;

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -147,7 +147,7 @@ nrUE_params_t *get_nrUE_params(void) {
 }
 // needed for some functions
 uint16_t n_rnti = 0x1234;
-openair0_config_t openair0_cfg[MAX_CARDS];
+openair0_config_t openair0_cfg_g[MAX_CARDS] = {};
 
 channel_desc_t *UE2gNB[MAX_MOBILES_PER_GNB][NUMBER_OF_gNB_MAX];
 
@@ -742,7 +742,7 @@ int main(int argc, char *argv[])
   gNB->num_pusch_symbols_per_thread = 1;
   gNB->dmrs_num_antennas_per_thread = num_antennas_per_thread;
   gNB->RU_list[0] = calloc(1, sizeof(**gNB->RU_list));
-  gNB->RU_list[0]->rfdevice.openair0_cfg = openair0_cfg;
+  gNB->RU_list[0]->rfdevice.openair0_cfg = openair0_cfg_g;
 
   if (setAffinity == false)
     initFloatingCoresTpool(threadCnt, &gNB->threadPool, false, "gNB-tpool");

radio/COMMON/common_lib.c

@@ -32,86 +32,80 @@ const char *get_devname(int devtype) {
   return "none";
 }
 
-int set_device(openair0_device_t *device)
+static int set_device(openair0_device_t *device)
 {
+  char *dev_type = device->host_type == RAU_HOST ? "RAU" : "RRU";
   const char *devname = get_devname(device->type);
-    if (strcmp(devname,"none") != 0) {
-      LOG_I(HW,"[%s] has loaded %s device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"),devname);
-    } else {
-      LOG_E(HW,"[%s] invalid HW device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
-      return -1;
-    }
-  return 0;
+  if (strcmp(devname, "none") != 0) {
+    LOG_I(HW, "[%s] has loaded %s device.\n", dev_type, devname);
+    return 0;
+  }
+  LOG_E(HW, "[%s] invalid HW device.\n", dev_type);
+  return -1;
 }
 
-int set_transport(openair0_device_t *device)
+static int set_transport(openair0_device_t *device)
 {
+  char *dev_type = device->host_type == RAU_HOST ? "RAU" : "RRU";
   switch (device->transp_type) {
     case ETHERNET_TP:
-      LOG_I(HW,"[%s] has loaded ETHERNET trasport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+      LOG_I(HW, "[%s] has loaded ETHERNET trasport protocol.\n", dev_type);
       return 0;
       break;
 
     case NONE_TP:
-      LOG_I(HW,"[%s] has not loaded a transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+      LOG_I(HW, "[%s] has not loaded a transport protocol.\n", dev_type);
       return 0;
       break;
 
     default:
-      LOG_E(HW,"[%s] invalid transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+      LOG_E(HW, "[%s] invalid transport protocol.\n", dev_type);
       return -1;
       break;
   }
 }
 
-typedef int (*devfunc_t)(openair0_device_t *, openair0_config_t *, eth_params_t *);
-
 /* look for the interface library and load it */
-int load_lib(openair0_device_t *device, openair0_config_t *openair0_cfg, eth_params_t *cfg, uint8_t flag)
+int load_lib(openair0_device_t *device, openair0_config_t *openair0_cfg, eth_params_t *eth_cfg, rau_type_t rau_type)
 {
-  loader_shlibfunc_t shlib_fdesc[1];
-  int ret=0;
-  char *deflibname=OAI_RF_LIBNAME;
   openair0_cfg->command_line_sample_advance = get_softmodem_params()->command_line_sample_advance;
-  openair0_cfg->recplay_mode = read_recplayconfig(&(openair0_cfg->recplay_conf),&(device->recplay_state));
 
-  if (openair0_cfg->recplay_mode == RECPLAY_RECORDMODE) {
-    IS_SOFTMODEM_IQRECORDER = true; // softmodem has to know we use the iqrecorder to workaround randomized algorithms
-  }
+  openair0_cfg->recplay_mode = read_recplayconfig(&openair0_cfg->recplay_conf, &device->recplay_state);
+  // softmodem has to know we use the iqrecorder to workaround randomized algorithms
+  IS_SOFTMODEM_IQRECORDER = openair0_cfg->recplay_mode == RECPLAY_RECORDMODE;
+
+  char *deflibname = OAI_RF_LIBNAME;
+  loader_shlibfunc_t shlib_fdesc = {.fname = "device_init"};
   if (openair0_cfg->recplay_mode == RECPLAY_REPLAYMODE) {
-  	  deflibname=OAI_IQPLAYER_LIBNAME;
-  	  shlib_fdesc[0].fname="device_init";
-      IS_SOFTMODEM_IQPLAYER = true; // softmodem has to know we use the iqplayer to workaround randomized algorithms
-  } else if (IS_SOFTMODEM_RFSIM && flag == RAU_LOCAL_RADIO_HEAD) {
-	  deflibname=OAI_RFSIM_LIBNAME;
-	  shlib_fdesc[0].fname="device_init";
-  } else if (flag == RAU_LOCAL_RADIO_HEAD) {
-	  if (IS_SOFTMODEM_RFSIM)
-		  deflibname="rfsimulator";
-	  else
-          deflibname=OAI_RF_LIBNAME;
-      shlib_fdesc[0].fname="device_init";
-  } else if (flag == RAU_REMOTE_THIRDPARTY_RADIO_HEAD) {
-    deflibname=OAI_THIRDPARTY_TP_LIBNAME;
-    shlib_fdesc[0].fname="transport_init";
+    deflibname=OAI_IQPLAYER_LIBNAME;
+    IS_SOFTMODEM_IQPLAYER = true; // softmodem has to know we use the iqplayer to workaround randomized algorithms
   } else {
-	  deflibname=OAI_TP_LIBNAME;
-	  shlib_fdesc[0].fname="transport_init";
+    switch (rau_type) {
+      case RAU_LOCAL_RADIO_HEAD:
+        if (IS_SOFTMODEM_RFSIM)
+          deflibname = OAI_RFSIM_LIBNAME;
+        break;
+      case RAU_REMOTE_THIRDPARTY_RADIO_HEAD:
+        deflibname = OAI_THIRDPARTY_TP_LIBNAME;
+        shlib_fdesc.fname = "transport_init";
+        break;
+      case RAU_REMOTE_RADIO_HEAD:
+        deflibname = OAI_TP_LIBNAME;
+        shlib_fdesc.fname = "transport_init";
+        break;
+      default:
+        AssertFatal(false, "impossible radio head\n");
+    }
   }
-  
+
   char *devname=NULL;
-  paramdef_t device_params[]=DEVICE_PARAMS_DESC ;
-  int numparams = sizeofArray(device_params);
-  int devname_pidx = config_paramidx_fromname(device_params,numparams, CONFIG_DEVICEOPT_NAME);
-  device_params[devname_pidx].defstrval=deflibname;
+  paramdef_t device_params = {"name", CONFIG_HLP_DEVICE, 0, .strptr = &devname, .defstrval = deflibname, TYPE_STRING, 0};
+  config_get(config_get_if(), &device_params, 1, DEVICE_SECTION);
 
-  config_get(config_get_if(), device_params, numparams, DEVICE_SECTION);
-
-  ret=load_module_shlib(devname,shlib_fdesc,1,NULL);
-  AssertFatal( (ret >= 0),
-  	           "Library %s couldn't be loaded\n",devname);
-
-  return ((devfunc_t)shlib_fdesc[0].fptr)(device,openair0_cfg,cfg);
+  int ret = load_module_shlib(devname, &shlib_fdesc, 1, NULL);
+  AssertFatal(ret >= 0, "Library %s couldn't be loaded\n", devname);
+  typedef int (*devfunc_t)(openair0_device_t *, openair0_config_t *, eth_params_t *);
+  return ((devfunc_t)shlib_fdesc.fptr)(device, openair0_cfg, eth_cfg);
 }
 
 int openair0_device_load(openair0_device_t *device, openair0_config_t *openair0_cfg)
@@ -123,10 +117,10 @@ int openair0_device_load(openair0_device_t *device, openair0_config_t *openair0_
     if ( set_device(device) < 0) {
       LOG_E(HW, "%s %d:Unsupported radio head\n", __FILE__, __LINE__);
       return -1;
-	}
-  } else
+    }
+  } else {
     AssertFatal(false, "can't open the radio device: %s\n", get_devname(device->type));
-
+  }
   pthread_mutex_init(&device->reOrder.mutex_store, NULL);
   pthread_mutex_init(&device->reOrder.mutex_write, NULL);
   return rc;
@@ -134,8 +128,7 @@ int openair0_device_load(openair0_device_t *device, openair0_config_t *openair0_
 
 int openair0_transport_load(openair0_device_t *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params)
 {
-  int rc;
-  rc=load_lib(device, openair0_cfg, eth_params, RAU_REMOTE_RADIO_HEAD);
+  int rc = load_lib(device, openair0_cfg, eth_params, RAU_REMOTE_RADIO_HEAD);
 
   if ( rc >= 0) {
     if ( set_transport(device) < 0) {
@@ -168,9 +161,6 @@ static void writerEnqueue(re_order_t *ctx, openair0_timestamp_t timestamp, void
   pthread_mutex_unlock(&ctx->mutex_store);
 }
 
-typedef struct PHY_VARS_NR_UE_s PHY_VARS_NR_UE;
-typedef int (*nrue_ru_write_t)(PHY_VARS_NR_UE *UE, openair0_timestamp_t timestamp, void **txp, int nsamps, int nbAnt, int flags);
-
 static void writerProcessWaitingQueue(nrue_ru_write_t nrue_ru_write, PHY_VARS_NR_UE *UE, openair0_device_t *device)
 {
   bool found = false;

radio/COMMON/common_lib.h

@@ -26,9 +26,8 @@
 #define OAI_IQPLAYER_LIBNAME  "oai_iqplayer"
 
 /* flags for BBU to determine whether the attached radio head is local or remote */
-#define RAU_LOCAL_RADIO_HEAD  0
-#define RAU_REMOTE_RADIO_HEAD 1
-#define RAU_REMOTE_THIRDPARTY_RADIO_HEAD 2
+typedef enum { RAU_LOCAL_RADIO_HEAD, RAU_REMOTE_RADIO_HEAD, RAU_REMOTE_THIRDPARTY_RADIO_HEAD } rau_type_t;
+
 #define MAX_WRITE_THREAD_PACKAGE     10
 #define MAX_WRITE_THREAD_BUFFER_SIZE 8
 #define MAX_CARDS 10
@@ -253,7 +252,7 @@ typedef struct openair0_config {
   //! this interface is reused for split 7, so split 7 options provided below
   split7_config_t split7;
 } openair0_config_t;
-extern openair0_config_t openair0_cfg[MAX_CARDS];
+extern openair0_config_t openair0_cfg_g[MAX_CARDS];
 
 /*! \brief RF mapping */
 typedef struct {
@@ -639,22 +638,20 @@ extern "C"
 {
 #endif
 
+int load_lib(openair0_device_t *device, openair0_config_t *openair0_cfg, eth_params_t *eth_cfg, rau_type_t rau_type);
+typedef struct PHY_VARS_NR_UE_s PHY_VARS_NR_UE;
+typedef int (*nrue_ru_write_t)(PHY_VARS_NR_UE *UE, openair0_timestamp_t timestamp, void **txp, int nsamps, int nbAnt, int flags);
 
+int openair0_write_reorder_common(nrue_ru_write_t nrue_ru_write,
+                                  PHY_VARS_NR_UE *UE,
+                                  openair0_device_t *device,
+                                  openair0_timestamp_t timestamp,
+                                  void **txp,
+                                  int nsamps,
+                                  int nbAnt,
+                                  int flags);
 #define  DEVICE_SECTION   "device"
-#define  CONFIG_HLP_DEVICE  "Identifies the oai device (the interface to RF) to use, the shared lib \"lib_<name>.so\" will be loaded"
-#define  CONFIG_DEVICEOPT_NAME "name"
-
-/* inclusion for device configuration */
-/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
-/*                                            config parameters for oai device                                                                                               */
-/*   optname                     helpstr                paramflags                      XXXptr                  defXXXval                            type           numelt   */
-/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
-#define DEVICE_PARAMS_DESC {\
-    { CONFIG_DEVICEOPT_NAME,      CONFIG_HLP_DEVICE,          0,               .strptr=&devname,                .defstrval=NULL,         TYPE_STRING,     0}\
-}
-
-
-
+#define CONFIG_HLP_DEVICE "Identifies the oai device (the interface to RF) to use, the shared lib \"lib_<name>.so\" will be loaded"
 /*! \brief get device name from device type */
 const char *get_devname(int devtype);
 /*! \brief Initialize openair RF target. It returns 0 if OK */

radio/ETHERNET/ethernet_lib.c

@@ -28,8 +28,6 @@ int num_devices_eth = 0;
 struct sockaddr_in dest_addr[MAX_INST];
 int dest_addr_len[MAX_INST];
 
-int load_lib(openair0_device_t *device, openair0_config_t *openair0_cfg, eth_params_t *cfg, uint8_t flag);
-
 int trx_eth_start(openair0_device_t *device)
 {
     eth_state_t *eth = (eth_state_t*)device->priv;
@@ -452,8 +450,8 @@ int transport_init(openair0_device_t *device, openair0_config_t *openair0_cfg, e
     eth->flags = eth_params->transp_preference;
 
     // load third-party driver
-    if (eth->flags == ETH_UDP_IF5_ECPRI_MODE) load_lib(device,openair0_cfg,eth_params,RAU_REMOTE_THIRDPARTY_RADIO_HEAD);
-
+    if (eth->flags == ETH_UDP_IF5_ECPRI_MODE)
+      load_lib(device, openair0_cfg, eth_params, RAU_REMOTE_THIRDPARTY_RADIO_HEAD);
 
     if (eth_params->if_compress == 0) {
         eth->compression = NO_COMPRESS;