yigid/openairinterface5g
1
0
Fork 0
mirror of https://gitlab.eurecom.fr/oai/openairinterface5g.git synced 2026-07-13 04:30:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

factorize code in nr-ue-ru.c

Browse Source 
Signed-off-by: Laurent THOMAS <laurent.thomas@open-cells.com>
This commit is contained in:
Laurent THOMAS
2026-06-01 15:53:12 +02:00
parent c54342881e
commit a0526fc1d0
1 changed files with 155 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

302
executables/nr-ue-ru.c
View File

@@ -81,43 +81,47 @@
}
// 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;
static struct {
int count;
nrUE_cell_params_t *cfg;
NR_DL_FRAME_PARMS *fp;
} nrue_cells = {};
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] = {};
static openair0_device_t openair0_dev[MAX_CARDS] = {};
int nrue_get_cell_count(void)
{
return nrue_cell_count;
return nrue_cells.count;
}
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;
int cell_id = nrue_rus.cfg[UE->rf_map.card].used_by_cell;
return nrue_cells.cfg[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];
AssertFatal(cell_id >= 0 && cell_id < nrue_cells.count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cells.count);
return &nrue_cells.cfg[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];
AssertFatal(cell_id >= 0 && cell_id < nrue_cells.count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cells.count);
return &nrue_cells.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;
AssertFatal(cell_id >= 0 && cell_id < nrue_cells.count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cells.count);
nrue_cells.cfg[cell_id] = *cell;
}
void nrue_set_cell_params(configmodule_interface_t *cfg)
@@ -127,65 +131,68 @@ 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_cells.count = 1;
nrue_cells.fp = calloc_or_fail(nrue_cells.count, sizeof(*nrue_cells.fp));
nrue_cells.cfg = calloc_or_fail(nrue_cells.count, sizeof(*nrue_cells.cfg));
nrue_cells.cfg[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};
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));
nrue_cells.count = cellParamList.numelt;
nrue_cells.fp = calloc_or_fail(nrue_cells.count, sizeof(*nrue_cells.fp));
nrue_cells.cfg = calloc_or_fail(nrue_cells.count, sizeof(*nrue_cells.cfg));
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 < nrue_cells.count; cell_id++) {
paramdef_t *param = cellParamList.paramarray[cell_id];
const int sz = sizeofArray(cellParams);
nrUE_cell_params_t *cell = nrue_cells.cfg + cell_id;
*cell = (nrUE_cell_params_t){.ru_id = *gpd(param, sz, NRUE_CELL_RU_ID)->iptr,
.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,
.used_by_ue = -1};
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_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->ru_id,
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)
{
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];
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_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);
AssertFatal(cell_id >= 0 && cell_id < nrue_cells.count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cells.count);
nrue_rus.cfg[ru_id].used_by_cell = cell_id;
}
void nrue_set_ru_params(configmodule_interface_t *cfg)
@@ -195,91 +202,92 @@ 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,
.used_by_cell = -1};
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;
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;
for (int ru_id = 0; ru_id < nrue_rus.count; ru_id++) {
nrUE_RU_params_t *ru = nrue_rus.cfg + ru_id;
int cell_id = ru->used_by_cell;
if (cell_id < 0) {
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 = nrue_cells.fp + cell_id;
if (is_sidelink) {
int UE_id = nrue_cells[cell_id].used_by_ue;
int UE_id = nrue_cells.cfg[cell_id].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;
@@ -310,12 +318,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);
@@ -323,20 +331,20 @@ 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++) {
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 = &openair0_dev[ru_id];
openair0_device_t *dev = &nrue_rus.openair0_dev[ru_id];
dev->host_type = RAU_HOST;
int tmp = openair0_device_load(dev, cfg);
@@ -350,7 +358,7 @@ void nrue_ru_start(void)
void nrue_ru_stop(void)
{
for (openair0_device_t *ru = openair0_dev; ru < openair0_dev + nrue_ru_count; ru++) {
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);
}
@@ -358,7 +366,7 @@ void nrue_ru_stop(void)
void nrue_ru_end(void)
{
for (openair0_device_t *ru = openair0_dev; ru < openair0_dev + nrue_ru_count; ru++) {
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)
@@ -368,22 +376,22 @@ void nrue_ru_end(void)
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];
int current_cell_id = nrue_rus.cfg[UE->rf_map.card].used_by_cell;
NR_DL_FRAME_PARMS *fp0 = nrue_cells.fp + current_cell_id;
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;
for (int ru_id = 0; carrier_distance != 0 && ru_id < nrue_rus.count; ru_id++) {
int cell_id = nrue_rus.cfg[ru_id].used_by_cell;
if (cell_id < 0) // 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 (nrue_cells.cfg[cell_id].used_by_ue >= 0) // skip cells that are already used by an UE
continue;
fp0 = &nrue_cell_fp[cell_id];
fp0 = nrue_cells.fp + cell_id;
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 =
@@ -395,12 +403,12 @@ void nrue_ru_set_freq(PHY_VARS_NR_UE *UE, uint64_t ul_carrier, uint64_t dl_carri
}
}
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;
nrue_cells.cfg[current_cell_id].used_by_ue = -1;
current_cell_id = nrue_rus.cfg[UE->rf_map.card].used_by_cell;
nrue_cells.cfg[current_cell_id].used_by_ue = UE->Mod_id;
openair0_config_t *cfg = &openair0_cfg_g[UE->rf_map.card];
openair0_device_t *dev = &openair0_dev[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);
}
@@ -408,7 +416,7 @@ void nrue_ru_set_freq(PHY_VARS_NR_UE *UE, uint64_t ul_carrier, uint64_t dl_carri
int nrue_ru_adjust_rx_gain(PHY_VARS_NR_UE *UE, int gain_change)
{
openair0_config_t *cfg = &openair0_cfg_g[UE->rf_map.card];
openair0_device_t *dev = &openair0_dev[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
cfg->rx_gain[0] += gain_change;
@@ -430,7 +438,7 @@ 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 *dev = &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 = dev->trx_read_func(dev, &tmp_timestamp, buff, nsamps, num_antennas);
if (!dev->firstTS_initialized) {
@@ -449,15 +457,15 @@ 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;
for (int ru_id = 0; ru_id < nrue_rus.count; ru_id++) {
int cell_id = nrue_rus.cfg[ru_id].used_by_cell;
if (cell_id < 0) // skip RUs that have no cell definition
continue;
int ue_id = nrue_cells[cell_id].used_by_ue;
int ue_id = nrue_cells.cfg[cell_id].used_by_ue;
if (ue_id >= 0) // skip cells that are already used by an UE
continue;
dev = &openair0_dev[ru_id];
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;
@@ -470,7 +478,7 @@ 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 *dev = &openair0_dev[UE->rf_map.card];
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)
@@ -484,15 +492,15 @@ 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;
for (int ru_id = 0; ru_id < nrue_rus.count; ru_id++) {
int cell_id = nrue_rus.cfg[ru_id].used_by_cell;
if (cell_id < 0) // skip RUs that have no cell definition
continue;
int ue_id = nrue_cells[cell_id].used_by_ue;
int ue_id = nrue_cells.cfg[cell_id].used_by_ue;
if (ue_id >= 0) // skip cells that are already used by an UE
continue;
dev = &openair0_dev[ru_id];
dev = &nrue_rus.openair0_dev[ru_id];
dev->trx_write_func(dev, timestamp + dev->firstTS, tmp_buf, nsamps, num_antennas, flags);
}
return ret;
@@ -500,12 +508,12 @@ int nrue_ru_write(PHY_VARS_NR_UE *UE, openair0_timestamp_t timestamp, void **buf
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);
}