mirror of
https://gitlab.eurecom.fr/oai/openairinterface5g.git
synced 2026-07-13 04:30:28 +00:00
245 lines
6.4 KiB
C
245 lines
6.4 KiB
C
/*
|
|
* SPDX-License-Identifier: LicenseRef-CSSL-1.0
|
|
*/
|
|
|
|
#include <sched.h>
|
|
#include "assertions.h"
|
|
#include "PHY/types.h"
|
|
#include "PHY/defs_RU.h"
|
|
#include "common/oai_version.h"
|
|
#include "common/config/config_userapi.h"
|
|
#include "common/utils/load_module_shlib.h"
|
|
#include "common/ran_context.h"
|
|
#include "radio/COMMON/common_lib.h"
|
|
#include "radio/ETHERNET/if_defs.h"
|
|
#include "PHY/phy_vars.h"
|
|
#include "PHY/phy_extern.h"
|
|
#include "PHY/TOOLS/phy_scope_interface.h"
|
|
#include "common/utils/LOG/log.h"
|
|
#include "openair2/ENB_APP/enb_paramdef.h"
|
|
#include "system.h"
|
|
#include "nfapi/oai_integration/vendor_ext.h"
|
|
#include <executables/softmodem-common.h>
|
|
#include <executables/thread-common.h>
|
|
#include "executables/nr-softmodem.h"
|
|
#include "nr-oru.h"
|
|
#include "openair1/PHY/INIT/nr_phy_init.h"
|
|
#include "openair1/SCHED_NR/sched_nr.h"
|
|
|
|
pthread_cond_t sync_cond;
|
|
pthread_mutex_t sync_mutex;
|
|
int sync_var = -1; //!< protected by mutex \ref sync_mutex.
|
|
int config_sync_var = -1;
|
|
|
|
int oai_exit = 0;
|
|
int sf_ahead = 4;
|
|
int emulate_rf = 0;
|
|
|
|
RAN_CONTEXT_t RC;
|
|
|
|
extern void kill_NR_RU_proc(int inst);
|
|
extern void set_function_spec_param(RU_t *ru);
|
|
extern void start_NR_RU();
|
|
extern void init_NR_RU(configmodule_interface_t *cfg, char *);
|
|
void fill_rf_config(RU_t *ru, char *rf_config_file);
|
|
void fill_split7_2_config(split7_config_t *split7, const nfapi_nr_config_request_scf_t *config, const NR_DL_FRAME_PARMS *fp);
|
|
|
|
int64_t uplink_frequency_offset[MAX_NUM_CCs][4];
|
|
|
|
void nfapi_setmode(nfapi_mode_t nfapi_mode)
|
|
{
|
|
return;
|
|
}
|
|
void exit_function(const char *file, const char *function, const int line, const char *s, const int assert)
|
|
{
|
|
if (s != NULL) {
|
|
printf("%s:%d %s() Exiting OAI softmodem: %s\n", file, line, function, s);
|
|
}
|
|
close_log_mem();
|
|
oai_exit = 1;
|
|
RU_t *ru = RC.ru[0];
|
|
|
|
if (ru->rfdevice.trx_end_func) {
|
|
ru->rfdevice.trx_end_func(&ru->rfdevice);
|
|
ru->rfdevice.trx_end_func = NULL;
|
|
}
|
|
|
|
if (ru->ifdevice.trx_end_func) {
|
|
ru->ifdevice.trx_end_func(&ru->ifdevice);
|
|
ru->ifdevice.trx_end_func = NULL;
|
|
}
|
|
|
|
pthread_mutex_destroy(ru->ru_mutex);
|
|
pthread_cond_destroy(ru->ru_cond);
|
|
if (assert) {
|
|
abort();
|
|
} else {
|
|
sleep(1); // allow lte-softmodem threads to exit first
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
}
|
|
|
|
static void get_options(configmodule_interface_t *cfg)
|
|
{
|
|
CONFIG_SETRTFLAG(CONFIG_NOEXITONHELP);
|
|
get_common_options(cfg);
|
|
CONFIG_CLEARRTFLAG(CONFIG_NOEXITONHELP);
|
|
|
|
// NRCConfig();
|
|
}
|
|
|
|
nfapi_mode_t nfapi_getmode(void)
|
|
{
|
|
return (NFAPI_MODE_PNF);
|
|
}
|
|
|
|
void oai_nfapi_rach_ind(nfapi_rach_indication_t *rach_ind)
|
|
{
|
|
AssertFatal(1 == 0, "This is bad ... please check why we get here\n");
|
|
}
|
|
|
|
void wait_eNBs(void)
|
|
{
|
|
return;
|
|
}
|
|
void wait_gNBs(void)
|
|
{
|
|
return;
|
|
}
|
|
|
|
struct timespec timespec_add(struct timespec, struct timespec)
|
|
{
|
|
struct timespec t = {0};
|
|
return t;
|
|
};
|
|
struct timespec timespec_sub(struct timespec, struct timespec)
|
|
{
|
|
struct timespec t = {0};
|
|
return t;
|
|
};
|
|
void beam_index_allocation(uint16_t fapi_beam_index,
|
|
int ant,
|
|
int num_ports,
|
|
int symbols_per_slot,
|
|
int slot,
|
|
uint16_t bitmap_symbols,
|
|
int num_ant_max,
|
|
uint16_t **ant_beam_id_list)
|
|
{
|
|
}
|
|
uint16_t get_first_ant_idx(bool das, uint16_t num_ports_beams, uint16_t beam_id, uint16_t fapi_start_port)
|
|
{
|
|
return 0;
|
|
};
|
|
void nr_fill_du(uint16_t N_ZC, const uint16_t *prach_root_sequence_map, uint16_t nr_du[NR_PRACH_SEQ_LEN_L - 1])
|
|
{
|
|
return;
|
|
};
|
|
|
|
static void sig_handler(int sig_num)
|
|
{
|
|
oai_exit = 1;
|
|
}
|
|
|
|
uint16_t nr_du[838];
|
|
|
|
uint64_t downlink_frequency[MAX_NUM_CCs][4];
|
|
|
|
configmodule_interface_t *uniqCfg = NULL;
|
|
THREAD_STRUCT thread_struct;
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
memset(&RC, 0, sizeof(RC));
|
|
if ((uniqCfg = load_configmodule(argc, argv, 0)) == NULL) {
|
|
exit_fun("[SOFTMODEM] Error, configuration module init failed\n");
|
|
}
|
|
|
|
logInit();
|
|
LOG_W(PHY, "%s is experimental software and at this point is not an implementation of a 7.2 O-RAN RU\n", argv[0]);
|
|
printf("Reading in command-line options\n");
|
|
get_options(uniqCfg);
|
|
|
|
if (CONFIG_ISFLAGSET(CONFIG_ABORT)) {
|
|
fprintf(stderr, "Getting configuration failed\n");
|
|
exit(-1);
|
|
}
|
|
|
|
#if T_TRACER
|
|
T_Config_Init();
|
|
#endif
|
|
printf("configuring for RRU\n");
|
|
// strdup to put the sring in the core file for post mortem identification
|
|
LOG_I(HW, "Version: %s\n", strdup(OAI_PACKAGE_VERSION));
|
|
|
|
/* Read configuration */
|
|
|
|
printf("About to Init RU threads\n");
|
|
|
|
lock_memory_to_ram();
|
|
load_dftslib();
|
|
|
|
RC.nb_RU = 1;
|
|
RC.ru = malloc(sizeof(RC.ru));
|
|
|
|
init_NR_RU(config_get_if(), NULL);
|
|
|
|
RU_t *ru = RC.ru[0];
|
|
ORU_t oru = {0};
|
|
oru.ru = ru;
|
|
int ret = get_oru_options(&oru);
|
|
AssertFatal(ret == 0, "Cannot configure oru, check your config file/cmdline");
|
|
ru->numerology = oru.numerology;
|
|
oru_init_frame_parms(&oru);
|
|
NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
|
|
nr_dump_frame_parms(fp);
|
|
init_symbol_rotation(fp);
|
|
ru->if_south = LOCAL_RF;
|
|
nr_phy_init_RU(oru.ru);
|
|
fill_rf_config(ru, ru->rf_config_file);
|
|
ru->N_TA_offset = set_default_nta_offset(fp->freq_range, fp->samples_per_subframe);
|
|
|
|
oru.fronthaul = oru_fh_init(&oru.fh_config);
|
|
AssertFatal(oru.fronthaul != NULL, "Cannot configure oru fronthaul, check your config file/cmdline");
|
|
|
|
LOG_I(PHY, "starting vrtsim\n");
|
|
ret = openair0_load(&ru->rfdevice, "vrtsim", &ru->openair0_cfg, NULL);
|
|
AssertFatal(ret == 0, "RU %u: openair0_load() ret %d: cannot initialize vrtsim\n", ru->idx, ret);
|
|
ret = ru->rfdevice.trx_start_func(&ru->rfdevice);
|
|
AssertFatal(ret == 0, "RU %u: trx_start_func() ret %d: cannot start vrtsim\n", ru->idx, ret);
|
|
|
|
threadCreate(&oru.north_read_thread, oru_north_read_thread, (void *)&oru, "north_read_thread", -1, OAI_PRIORITY_RT_MAX);
|
|
threadCreate(&oru.south_read_thread, oru_south_read_thread, (void *)&oru, "south_read_thread", -1, OAI_PRIORITY_RT_MAX);
|
|
usleep(1000);
|
|
oru_fh_start(oru.fronthaul);
|
|
|
|
// Signal handler
|
|
signal(SIGINT, sig_handler);
|
|
|
|
while (oai_exit == 0) {
|
|
oru_fh_print_stats(oru.fronthaul);
|
|
sleep(1);
|
|
}
|
|
|
|
pthread_join(oru.north_read_thread, NULL);
|
|
pthread_join(oru.south_read_thread, NULL);
|
|
|
|
oru_fh_stop(oru.fronthaul);
|
|
|
|
if (ru->rfdevice.trx_stop_func) {
|
|
ru->rfdevice.trx_stop_func(&ru->rfdevice);
|
|
ru->rfdevice.trx_stop_func = NULL;
|
|
}
|
|
|
|
if (ru->rfdevice.trx_end_func) {
|
|
ru->rfdevice.trx_end_func(&ru->rfdevice);
|
|
ru->rfdevice.trx_end_func = NULL;
|
|
}
|
|
|
|
end_configmodule(uniqCfg);
|
|
|
|
logClean();
|
|
printf("Bye.\n");
|
|
return 0;
|
|
}
|