merge with latest develop
This commit is contained in:
@@ -100,7 +100,7 @@ int load_lib(openair0_device *device, openair0_config_t *openair0_cfg, eth_param
|
||||
libname=OAI_TP_LIBNAME;
|
||||
shlib_fdesc[0].fname="transport_init";
|
||||
}
|
||||
ret=load_module_shlib(libname,shlib_fdesc,1);
|
||||
ret=load_module_shlib(libname,shlib_fdesc,1,NULL);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr,"Library %s couldn't be loaded\n",libname);
|
||||
} else {
|
||||
|
||||
@@ -199,6 +199,8 @@ typedef struct {
|
||||
double tx_bw;
|
||||
//! clock source
|
||||
clock_source_t clock_source;
|
||||
//! Manual SDR IP address
|
||||
char *sdr_addrs;
|
||||
//! Auto calibration flag
|
||||
int autocal[4];
|
||||
//! rf devices work with x bits iqs when oai have its own iq format
|
||||
|
||||
@@ -43,6 +43,8 @@
|
||||
#include "common/utils/LOG/log.h"
|
||||
#include "common_lib.h"
|
||||
#include "assertions.h"
|
||||
#include <sys/sysinfo.h>
|
||||
#include <sys/resource.h>
|
||||
|
||||
#ifdef __SSE4_1__
|
||||
# include <smmintrin.h>
|
||||
@@ -274,6 +276,8 @@ static int sync_to_gps(openair0_device *device)
|
||||
#include "usrp_lib.h"
|
||||
static FILE *pFile = NULL;
|
||||
int mmapfd = 0;
|
||||
int iqfd = 0;
|
||||
int use_mmap = 1; // default is to use mmap
|
||||
struct stat sb;
|
||||
iqrec_t *ms_sample = NULL; // memory for all subframes
|
||||
unsigned int nb_samples = 0;
|
||||
@@ -406,13 +410,24 @@ static void trx_usrp_end(openair0_device *device) {
|
||||
}
|
||||
}
|
||||
if (u_sf_mode == 2) { // replay
|
||||
if (ms_sample != MAP_FAILED) {
|
||||
munmap(ms_sample, sb.st_size);
|
||||
ms_sample = NULL;
|
||||
}
|
||||
if (mmapfd != 0) {
|
||||
close(mmapfd);
|
||||
mmapfd = 0;
|
||||
if (use_mmap) {
|
||||
if (ms_sample != MAP_FAILED) {
|
||||
munmap(ms_sample, sb.st_size);
|
||||
ms_sample = NULL;
|
||||
}
|
||||
if (mmapfd != 0) {
|
||||
close(mmapfd);
|
||||
mmapfd = 0;
|
||||
}
|
||||
} else {
|
||||
if (ms_sample != NULL) {
|
||||
free(ms_sample);
|
||||
ms_sample = NULL;
|
||||
}
|
||||
if (iqfd != 0) {
|
||||
close(iqfd);
|
||||
iqfd = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -619,15 +634,50 @@ static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp
|
||||
return 0; // should make calling process exit
|
||||
}
|
||||
wrap_ts = wrap_count * (nb_samples * (((int)(device->openair0_cfg[0].sample_rate)) / 1000));
|
||||
if (!use_mmap) {
|
||||
if (lseek(iqfd, 0, SEEK_SET) == 0) {
|
||||
std::cerr << "Seeking at the beginning of IQ file" << std::endl;
|
||||
} else {
|
||||
std::cerr << "Problem seeking at the beginning of IQ file" << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (cur_samples < nb_samples) {
|
||||
*ptimestamp = (ms_sample[0].ts + (cur_samples * (((int)(device->openair0_cfg[0].sample_rate)) / 1000))) + wrap_ts;
|
||||
if (cur_samples == 0) {
|
||||
std::cerr << "starting subframes file with wrap_count=" << wrap_count << " wrap_ts=" << wrap_ts
|
||||
<< " ts=" << *ptimestamp << std::endl;
|
||||
if (use_mmap) {
|
||||
if (cur_samples < nb_samples) {
|
||||
*ptimestamp = (ms_sample[0].ts + (cur_samples * (((int)(device->openair0_cfg[0].sample_rate)) / 1000))) + wrap_ts;
|
||||
if (cur_samples == 0) {
|
||||
std::cerr << "starting subframes file with wrap_count=" << wrap_count << " wrap_ts=" << wrap_ts
|
||||
<< " ts=" << *ptimestamp << std::endl;
|
||||
}
|
||||
memcpy(buff[0], &ms_sample[cur_samples].samples[0], nsamps*4);
|
||||
cur_samples++;
|
||||
}
|
||||
} else {
|
||||
// read sample from file
|
||||
if (read(iqfd, ms_sample, sizeof(iqrec_t)) != sizeof(iqrec_t)) {
|
||||
std::cerr << "pb reading iqfile at index " << sizeof(iqrec_t)*cur_samples << std::endl;
|
||||
close(iqfd);
|
||||
free(ms_sample);
|
||||
ms_sample = NULL;
|
||||
iqfd = 0;
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
if (cur_samples < nb_samples) {
|
||||
static int64_t ts0 = 0;
|
||||
if ((cur_samples == 0) && (wrap_count == 0)) {
|
||||
ts0 = ms_sample->ts;
|
||||
}
|
||||
*ptimestamp = ts0 + (cur_samples * (((int)(device->openair0_cfg[0].sample_rate)) / 1000)) + wrap_ts;
|
||||
if (cur_samples == 0) {
|
||||
std::cerr << "starting subframes file with wrap_count=" << wrap_count << " wrap_ts=" << wrap_ts
|
||||
<< " ts=" << *ptimestamp << std::endl;
|
||||
}
|
||||
memcpy(buff[0], &ms_sample->samples[0], nsamps*4);
|
||||
cur_samples++;
|
||||
// Prepare for next read
|
||||
off_t where = lseek(iqfd, cur_samples * sizeof(iqrec_t), SEEK_SET);
|
||||
}
|
||||
memcpy(buff[0], &ms_sample[cur_samples].samples[0], nsamps*4);
|
||||
cur_samples++;
|
||||
}
|
||||
struct timespec req;
|
||||
req.tv_sec = 0;
|
||||
@@ -900,13 +950,18 @@ int trx_usrp_recplay_config_init(paramdef_t *usrp_recplay_params) {
|
||||
#endif
|
||||
|
||||
extern "C" {
|
||||
/*! \brief Initialize Openair USRP target. It returns 0 if OK
|
||||
* \param device the hardware to use
|
||||
* \param openair0_cfg RF frontend parameters set by application
|
||||
*/
|
||||
int device_init(openair0_device* device, openair0_config_t *openair0_cfg) {
|
||||
/*! \brief Initialize Openair USRP target. It returns 0 if OK
|
||||
* \param device the hardware to use
|
||||
* \param openair0_cfg RF frontend parameters set by application
|
||||
*/
|
||||
int device_init(openair0_device* device, openair0_config_t *openair0_cfg) {
|
||||
|
||||
LOG_D(PHY, "openair0_cfg[0].sdr_addrs == '%s'\n", openair0_cfg[0].sdr_addrs);
|
||||
LOG_D(PHY, "openair0_cfg[0].clock_source == '%d'\n", openair0_cfg[0].clock_source);
|
||||
|
||||
#if defined(USRP_REC_PLAY)
|
||||
paramdef_t usrp_recplay_params[7];
|
||||
struct sysinfo systeminfo;
|
||||
// to check
|
||||
static int done = 0;
|
||||
if (done == 1) {
|
||||
@@ -914,6 +969,11 @@ extern "C" {
|
||||
} // prevent from multiple init
|
||||
done = 1;
|
||||
// end to check
|
||||
// Use mmap for IQ files for systems with less than 6GB total RAM
|
||||
sysinfo(&systeminfo);
|
||||
if (systeminfo.totalram < 6144000000) {
|
||||
use_mmap = 0;
|
||||
}
|
||||
memset(usrp_recplay_params, 0, 7*sizeof(paramdef_t));
|
||||
memset(&u_sf_filename[0], 0, 1024);
|
||||
if (trx_usrp_recplay_config_init(usrp_recplay_params) != 0) {
|
||||
@@ -953,7 +1013,8 @@ extern "C" {
|
||||
device->trx_set_freq_func = trx_usrp_set_freq;
|
||||
device->trx_set_gains_func = trx_usrp_set_gains;
|
||||
device->openair0_cfg = openair0_cfg;
|
||||
std::cerr << "USRP device initialized in subframes replay mode for " << u_sf_loops << " loops." << std::endl;
|
||||
std::cerr << "USRP device initialized in subframes replay mode for " << u_sf_loops << " loops. Use mmap="
|
||||
<< use_mmap << std::endl;
|
||||
} else {
|
||||
#endif
|
||||
uhd::set_thread_priority_safe(1.0);
|
||||
@@ -965,8 +1026,30 @@ extern "C" {
|
||||
// Initialize USRP device
|
||||
device->openair0_cfg = openair0_cfg;
|
||||
|
||||
std::string args = "type=b200";
|
||||
uhd::device_addrs_t device_adds = uhd::device::find(args);
|
||||
std::string args = "type=b200";
|
||||
|
||||
char *addr_args = NULL;
|
||||
// Check whether sdr_addrs is set in the config or not
|
||||
if (openair0_cfg[0].sdr_addrs != NULL) {
|
||||
if (strcmp(openair0_cfg[0].sdr_addrs, "0.0.0.0") != 0) {
|
||||
// Check whether sdr_addrs contains multiple IP addresses
|
||||
// and split and add them to addr_args
|
||||
if (strstr(openair0_cfg[0].sdr_addrs, ",") != NULL) {
|
||||
char *addr0 = openair0_cfg[0].sdr_addrs;
|
||||
// Replace , with \0
|
||||
strsep(&openair0_cfg[0].sdr_addrs, ",");
|
||||
char *addr1 = openair0_cfg[0].sdr_addrs;
|
||||
// Allocate memory for ",addr0=,addr1=\0" and the addresses
|
||||
size_t addr_args_len = sizeof(char)*(15 + strlen(addr0) + strlen(addr1));
|
||||
addr_args = (char *)malloc(addr_args_len);
|
||||
snprintf(addr_args, addr_args_len, ",addr0=%s,addr1=%s", addr0, addr1);
|
||||
args += addr_args;
|
||||
LOG_D(PHY, "addr_args == '%s'\n", addr_args);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uhd::device_addrs_t device_adds = uhd::device::find(args);
|
||||
|
||||
int vers=0,subvers=0,subsubvers=0;
|
||||
int bw_gain_adjust=0;
|
||||
@@ -980,12 +1063,17 @@ extern "C" {
|
||||
LOG_I(PHY,"Checking for USRPs : UHD %s (%d.%d.%d)\n",
|
||||
uhd::get_version_string().c_str(),vers,subvers,subsubvers);
|
||||
|
||||
if(device_adds.size() == 0) {
|
||||
double usrp_master_clock = 184.32e6;
|
||||
std::string args = "type=x300";
|
||||
if(device_adds.size() == 0) {
|
||||
|
||||
// workaround for an api problem, master clock has to be set with the constructor not via set_master_clock_rate
|
||||
args += boost::str(boost::format(",master_clock_rate=%f") % usrp_master_clock);
|
||||
double usrp_master_clock = 184.32e6;
|
||||
std::string args = "type=x300";
|
||||
|
||||
if (addr_args) {
|
||||
args += addr_args;
|
||||
}
|
||||
|
||||
// workaround for an api problem, master clock has to be set with the constructor not via set_master_clock_rate
|
||||
args += boost::str(boost::format(",master_clock_rate=%f") % usrp_master_clock);
|
||||
|
||||
// args += ",num_send_frames=256,num_recv_frames=256, send_frame_size=4096, recv_frame_size=4096";
|
||||
uhd::device_addrs_t device_adds = uhd::device::find(args);
|
||||
@@ -1175,12 +1263,14 @@ extern "C" {
|
||||
}
|
||||
}
|
||||
|
||||
for(int i=0; i<s->usrp->get_tx_num_channels(); i++) {
|
||||
::uhd::gain_range_t gain_range_tx = s->usrp->get_tx_gain_range(i);
|
||||
if (i<openair0_cfg[0].tx_num_channels) {
|
||||
s->usrp->set_tx_rate(openair0_cfg[0].sample_rate,i);
|
||||
s->usrp->set_tx_freq(openair0_cfg[0].tx_freq[i],i);
|
||||
s->usrp->set_tx_gain(gain_range_tx.stop()-openair0_cfg[0].tx_gain[i],i);
|
||||
LOG_D(PHY, "usrp->get_tx_num_channels() == %zd\n", s->usrp->get_tx_num_channels());
|
||||
LOG_D(PHY, "openair0_cfg[0].tx_num_channels == %d\n", openair0_cfg[0].tx_num_channels);
|
||||
for(int i=0; i<s->usrp->get_tx_num_channels(); i++) {
|
||||
::uhd::gain_range_t gain_range_tx = s->usrp->get_tx_gain_range(i);
|
||||
if (i<openair0_cfg[0].tx_num_channels) {
|
||||
s->usrp->set_tx_rate(openair0_cfg[0].sample_rate,i);
|
||||
s->usrp->set_tx_freq(openair0_cfg[0].tx_freq[i],i);
|
||||
s->usrp->set_tx_gain(gain_range_tx.stop()-openair0_cfg[0].tx_gain[i],i);
|
||||
|
||||
LOG_I(PHY,"USRP TX_GAIN:%3.2lf gain_range:%3.2lf tx_gain:%3.2lf\n", gain_range_tx.stop()-openair0_cfg[0].tx_gain[i], gain_range_tx.stop(), openair0_cfg[0].tx_gain[i]);
|
||||
}
|
||||
@@ -1282,33 +1372,60 @@ extern "C" {
|
||||
memset(ms_sample, 0, u_sf_max * BELL_LABS_IQ_BYTES_PER_SF);
|
||||
}
|
||||
if (u_sf_mode == 2) {
|
||||
// use mmap
|
||||
mmapfd = open(u_sf_filename, O_RDONLY | O_LARGEFILE);
|
||||
if (mmapfd != 0) {
|
||||
fstat(mmapfd, &sb);
|
||||
std::cerr << "Loading subframes using mmap() from " << u_sf_filename << " size=" << (uint64_t)sb.st_size << " bytes ..." << std::endl;
|
||||
ms_sample = (iqrec_t*) mmap(NULL, sb.st_size, PROT_WRITE, MAP_PRIVATE, mmapfd, 0);
|
||||
if (ms_sample != MAP_FAILED) {
|
||||
nb_samples = (sb.st_size / sizeof(iqrec_t));
|
||||
int aligned = (((unsigned long)ms_sample & 31) == 0)? 1:0;
|
||||
std::cerr<< "Loaded "<< nb_samples << " subframes." << std::endl;
|
||||
if (aligned == 0) {
|
||||
std::cerr<< "mmap address is not 32 bytes aligned, exiting." << std::endl;
|
||||
if (use_mmap) {
|
||||
// use mmap
|
||||
mmapfd = open(u_sf_filename, O_RDONLY | O_LARGEFILE);
|
||||
if (mmapfd != 0) {
|
||||
fstat(mmapfd, &sb);
|
||||
std::cerr << "Loading subframes using mmap() from " << u_sf_filename << " size=" << (uint64_t)sb.st_size << " bytes ..." << std::endl;
|
||||
ms_sample = (iqrec_t*) mmap(NULL, sb.st_size, PROT_WRITE, MAP_PRIVATE, mmapfd, 0);
|
||||
if (ms_sample != MAP_FAILED) {
|
||||
nb_samples = (sb.st_size / sizeof(iqrec_t));
|
||||
int aligned = (((unsigned long)ms_sample & 31) == 0)? 1:0;
|
||||
std::cerr<< "Loaded "<< nb_samples << " subframes." << std::endl;
|
||||
if (aligned == 0) {
|
||||
std::cerr<< "mmap address is not 32 bytes aligned, exiting." << std::endl;
|
||||
close(mmapfd);
|
||||
exit(-1);
|
||||
}
|
||||
} else {
|
||||
std::cerr << "Cannot mmap file, exiting." << std::endl;
|
||||
close(mmapfd);
|
||||
exit(-1);
|
||||
}
|
||||
} else {
|
||||
std::cerr << "Cannot mmap file, exiting." << std::endl;
|
||||
close(mmapfd);
|
||||
std::cerr << "Cannot open " << u_sf_filename << " , exiting." << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
} else {
|
||||
iqfd = open(u_sf_filename, O_RDONLY | O_LARGEFILE);
|
||||
if (iqfd != 0) {
|
||||
fstat(iqfd, &sb);
|
||||
nb_samples = (sb.st_size / sizeof(iqrec_t));
|
||||
std::cerr << "Loading " << nb_samples << " subframes from " << u_sf_filename
|
||||
<< " size=" << (uint64_t)sb.st_size << " bytes ..." << std::endl;
|
||||
// allocate buffer for 1 sample at a time
|
||||
ms_sample = (iqrec_t*) malloc(sizeof(iqrec_t));
|
||||
if (ms_sample == NULL) {
|
||||
std::cerr<< "Memory allocation failed for individual subframe replay mode." << std::endl;
|
||||
close(iqfd);
|
||||
exit(-1);
|
||||
}
|
||||
memset(ms_sample, 0, sizeof(iqrec_t));
|
||||
// point at beginning of file
|
||||
if (lseek(iqfd, 0, SEEK_SET) == 0) {
|
||||
std::cerr << "Initial seek at beginning of the file" << std::endl;
|
||||
} else {
|
||||
std::cerr << "Problem initial seek at beginning of the file" << std::endl;
|
||||
}
|
||||
} else {
|
||||
std::cerr << "Cannot open " << u_sf_filename << " , exiting." << std::endl;
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
/*@}*/
|
||||
|
||||
@@ -253,7 +253,7 @@ int tcp_bridge_ue_first_read(openair0_device *device, openair0_timestamp *timest
|
||||
tcp_bridge_state_t *t = device->priv;
|
||||
|
||||
uint32_t b[t->samples_per_subframe * 12];
|
||||
memset(b, 0, nsamps * 4);
|
||||
memset(b, 0, t->samples_per_subframe * 12 * 4);
|
||||
int n = fullwrite(t->sock, b, t->samples_per_subframe * 12 * 4);
|
||||
if (n != t->samples_per_subframe * 12 * 4) {
|
||||
printf("tcp_bridge: write error ret %d error %s\n", n, strerror(errno));
|
||||
|
||||
@@ -22,7 +22,7 @@
|
||||
#if defined(ENABLE_ITTI)
|
||||
# include "intertask_interface.h"
|
||||
# include "create_tasks.h"
|
||||
# include "log.h"
|
||||
# include "common/utils/LOG/log.h"
|
||||
|
||||
# ifdef OPENAIR2
|
||||
# if defined(ENABLE_USE_MME)
|
||||
@@ -31,6 +31,8 @@
|
||||
# include "nas_ue_task.h"
|
||||
# include "udp_eNB_task.h"
|
||||
# include "gtpv1u_eNB_task.h"
|
||||
# else
|
||||
# define EPC_MODE_ENABLED 0
|
||||
# endif
|
||||
# if ENABLE_RAL
|
||||
# include "lteRALue.h"
|
||||
@@ -59,8 +61,8 @@ int create_tasks(uint32_t enb_nb)
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
# if defined(ENABLE_USE_MME)
|
||||
# if defined(ENABLE_USE_MME)
|
||||
if (EPC_MODE_ENABLED) {
|
||||
if (enb_nb > 0) {
|
||||
if (itti_create_task (TASK_SCTP, sctp_eNB_task, NULL) < 0) {
|
||||
LOG_E(SCTP, "Create task for SCTP failed\n");
|
||||
@@ -84,8 +86,8 @@ int create_tasks(uint32_t enb_nb)
|
||||
}
|
||||
}
|
||||
|
||||
# endif
|
||||
|
||||
} /* if (EPC_MODE_ENABLED) */
|
||||
#endif
|
||||
if (enb_nb > 0) {
|
||||
LOG_I(RRC,"Creating RRC eNB Task\n");
|
||||
|
||||
|
||||
@@ -22,7 +22,7 @@
|
||||
#if defined(ENABLE_ITTI)
|
||||
# include "intertask_interface.h"
|
||||
# include "create_tasks.h"
|
||||
# include "log.h"
|
||||
# include "common/utils/LOG/log.h"
|
||||
|
||||
# ifdef OPENAIR2
|
||||
# if defined(ENABLE_USE_MME)
|
||||
|
||||
@@ -47,6 +47,9 @@ eNBs =
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "eth0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "192.168.13.10/24";
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "192.168.13.10/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
@@ -59,6 +59,9 @@ eNBs =
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "eth0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "192.168.13.10/24";
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "192.168.13.10/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
# available options for level: error, warn, notice, info, debug, trace
|
||||
# available options for verbosity: none, low, medium, high, full
|
||||
|
||||
@@ -46,6 +46,9 @@ eNBs =
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "eth1";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "192.168.13.10/24";
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "192.168.13.10/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
@@ -151,6 +151,9 @@ eNBs =
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "eth0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "192.168.12.111/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "192.168.12.111/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
|
||||
log_config :
|
||||
|
||||
@@ -151,6 +151,9 @@ eNBs =
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "eth0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "192.168.12.111/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "192.168.12.111/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
|
||||
log_config :
|
||||
|
||||
@@ -33,7 +33,7 @@ eNBs =
|
||||
tdd_config_s = 0;
|
||||
prefix_type = "NORMAL";
|
||||
eutra_band = 7;
|
||||
downlink_frequency = 2685000000L;
|
||||
downlink_frequency = 2680000000L;
|
||||
uplink_frequency_offset = -120000000;
|
||||
Nid_cell = 0;
|
||||
N_RB_DL = 100;
|
||||
@@ -149,12 +149,14 @@ eNBs =
|
||||
|
||||
NETWORK_INTERFACES :
|
||||
{
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1_MME = "eth6";
|
||||
ENB_IPV4_ADDRESS_FOR_S1_MME = "192.168.12.111/24";
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "eth6";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "192.168.12.111/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "192.168.12.111/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
@@ -183,12 +183,14 @@ eNBs =
|
||||
|
||||
NETWORK_INTERFACES :
|
||||
{
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1_MME = "lo";
|
||||
ENB_IPV4_ADDRESS_FOR_S1_MME = "192.168.13.10/24";
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "lo";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "192.168.13.10/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "192.168.13.10/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
@@ -183,14 +183,14 @@ eNBs =
|
||||
|
||||
NETWORK_INTERFACES :
|
||||
{
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1_MME = "lo";
|
||||
ENB_IPV4_ADDRESS_FOR_S1_MME = "127.0.0.2/24";
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "eth0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "127.0.0.4/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "127.0.0.2/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
@@ -183,12 +183,14 @@ eNBs =
|
||||
|
||||
NETWORK_INTERFACES :
|
||||
{
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1_MME = "eth0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1_MME = "192.168.12.111/24";
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "eth0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "192.168.12.111/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "192.168.12.111/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
+3
-1
@@ -150,12 +150,14 @@ eNBs =
|
||||
|
||||
NETWORK_INTERFACES :
|
||||
{
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1_MME = "eth0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1_MME = "192.168.12.19/24";
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "eth0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "192.168.12.19/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "192.168.12.19/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
@@ -152,12 +152,14 @@ eNBs =
|
||||
|
||||
NETWORK_INTERFACES :
|
||||
{
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1_MME = "lo";
|
||||
ENB_IPV4_ADDRESS_FOR_S1_MME = "127.0.0.2/24";
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "lo";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "127.0.0.5/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "127.0.0.2/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
@@ -153,12 +153,14 @@ eNBs =
|
||||
|
||||
NETWORK_INTERFACES :
|
||||
{
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1_MME = "vboxnet0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1_MME = "192.168.56.1/24";
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "vboxnet0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "192.168.56.1/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "192.168.56.1/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
@@ -183,12 +183,14 @@ eNBs =
|
||||
|
||||
NETWORK_INTERFACES :
|
||||
{
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1_MME = "lo";
|
||||
ENB_IPV4_ADDRESS_FOR_S1_MME = "127.0.0.2/24";
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "lo";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "127.0.0.5/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "127.0.0.2/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
@@ -152,12 +152,14 @@ eNBs =
|
||||
|
||||
NETWORK_INTERFACES :
|
||||
{
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1_MME = "eth0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1_MME = "192.168.12.19/24";
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "eth0";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "127.0.0.5/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "192.168.12.19/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
@@ -151,12 +151,14 @@ eNBs =
|
||||
|
||||
NETWORK_INTERFACES :
|
||||
{
|
||||
|
||||
ENB_INTERFACE_NAME_FOR_S1_MME = "lo";
|
||||
ENB_IPV4_ADDRESS_FOR_S1_MME = "127.0.0.2/24";
|
||||
ENB_INTERFACE_NAME_FOR_S1U = "lo";
|
||||
ENB_IPV4_ADDRESS_FOR_S1U = "127.0.0.5/24";
|
||||
ENB_PORT_FOR_S1U = 2152; # Spec 2152
|
||||
|
||||
ENB_IPV4_ADDRESS_FOR_X2C = "127.0.0.2/24";
|
||||
ENB_PORT_FOR_X2C = 36422; # Spec 36422
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
+24
-33
@@ -223,7 +223,7 @@ static inline int rxtx(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, char *thread_nam
|
||||
}
|
||||
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ULSCH_SCHEDULER , 1 );
|
||||
|
||||
if(get_nprocs() >= 8){
|
||||
if(!eNB->single_thread_flag && get_nprocs() >= 8){
|
||||
if(wait_on_condition(&proc[1].mutex_rxtx,&proc[1].cond_rxtx,&proc[1].pipe_ready,"wakeup_tx")<0) {
|
||||
LOG_E(PHY,"Frame %d, subframe %d: TX1 not ready\n",proc[1].frame_rx,proc[1].subframe_rx);
|
||||
return(-1);
|
||||
@@ -245,7 +245,7 @@ static inline int rxtx(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, char *thread_nam
|
||||
/* CONFLICT RESOLUTION: BEGIN */
|
||||
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ULSCH_SCHEDULER , 0 );
|
||||
if(oai_exit) return(-1);
|
||||
if(get_nprocs() <= 4){
|
||||
if(eNB->single_thread_flag || get_nprocs() <= 4){
|
||||
#ifndef PHY_TX_THREAD
|
||||
phy_procedures_eNB_TX(eNB, proc, 1);
|
||||
#endif
|
||||
@@ -558,7 +558,7 @@ int wakeup_rxtx(PHY_VARS_eNB *eNB,RU_t *ru) {
|
||||
eNB_proc_t *proc=&eNB->proc;
|
||||
RU_proc_t *ru_proc=&ru->proc;
|
||||
|
||||
eNB_rxtx_proc_t *proc_rxtx0=&proc->proc_rxtx[0];//*proc_rxtx=&proc->proc_rxtx[proc->frame_rx&1];
|
||||
eNB_rxtx_proc_t *proc_rxtx0=&proc->proc_rxtx[0];
|
||||
//eNB_rxtx_proc_t *proc_rxtx1=&proc->proc_rxtx[1];
|
||||
|
||||
|
||||
@@ -847,7 +847,6 @@ extern void init_td_thread(PHY_VARS_eNB *);
|
||||
extern void init_te_thread(PHY_VARS_eNB *);
|
||||
extern void kill_td_thread(PHY_VARS_eNB *);
|
||||
extern void kill_te_thread(PHY_VARS_eNB *);
|
||||
//////////////////////////////////////need to modified////////////////*****
|
||||
|
||||
static void* process_stats_thread(void* param) {
|
||||
|
||||
@@ -856,20 +855,23 @@ static void* process_stats_thread(void* param) {
|
||||
wait_sync("process_stats_thread");
|
||||
|
||||
while (!oai_exit) {
|
||||
sleep(1);
|
||||
if (opp_enabled == 1) {
|
||||
if (eNB->td) print_meas(&eNB->ulsch_decoding_stats,"ulsch_decoding",NULL,NULL);
|
||||
if (eNB->te)
|
||||
{
|
||||
print_meas(&eNB->dlsch_turbo_encoding_preperation_stats,"dlsch_coding_crc",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_segmentation_stats,"dlsch_segmentation",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_encoding_stats,"dlsch_encoding",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_signal_stats,"coding_signal",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_main_stats,"coding_main",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_waiting_stats,"coding_wait",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_wakeup_stats0,"coding_worker_0",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_wakeup_stats1,"coding_worker_1",NULL,NULL);
|
||||
}
|
||||
sleep(1);
|
||||
if (opp_enabled == 1) {
|
||||
if (eNB->td) print_meas(&eNB->ulsch_decoding_stats,"ulsch_decoding",NULL,NULL);
|
||||
if (eNB->te)
|
||||
{
|
||||
print_meas(&eNB->dlsch_turbo_encoding_preperation_stats,"dlsch_coding_crc",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_segmentation_stats,"dlsch_segmentation",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_encoding_stats,"dlsch_encoding",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_signal_stats,"coding_signal",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_main_stats,"coding_main",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_stats,"turbo_encoding",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_interleaving_stats,"turbo_interleaving",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_rate_matching_stats,"turbo_rate_matching",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_waiting_stats,"coding_wait",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_wakeup_stats0,"coding_worker_0",NULL,NULL);
|
||||
print_meas(&eNB->dlsch_turbo_encoding_wakeup_stats1,"coding_worker_1",NULL,NULL);
|
||||
}
|
||||
print_meas(&eNB->dlsch_modulation_stats,"dlsch_modulation",NULL,NULL);
|
||||
}
|
||||
}
|
||||
@@ -950,30 +952,19 @@ void init_eNB_proc(int inst) {
|
||||
// attr_td = &proc->attr_td;
|
||||
// attr_te = &proc->attr_te;
|
||||
#endif
|
||||
//////////////////////////////////////need to modified////////////////*****
|
||||
|
||||
if(get_nprocs() > 2 && codingw)
|
||||
{
|
||||
init_te_thread(eNB);
|
||||
init_td_thread(eNB);
|
||||
}
|
||||
//////////////////////////////////////need to modified////////////////*****
|
||||
//pthread_create( &proc_rxtx[0].pthread_rxtx, attr0, eNB_thread_rxtx, proc );
|
||||
|
||||
//pthread_create( &proc_rxtx[0].pthread_rxtx, attr0, eNB_thread_rxtx, proc_rxtx );
|
||||
|
||||
|
||||
//Should we also include here the case where single_thread_flag = 1 ?
|
||||
if(nfapi_mode!=2){
|
||||
pthread_create( &proc_rxtx[0].pthread_rxtx, attr0, eNB_thread_rxtx, proc );
|
||||
pthread_create( &proc_rxtx[1].pthread_rxtx, attr1, tx_thread, proc);
|
||||
}
|
||||
|
||||
|
||||
LOG_I(PHY,"eNB->single_thread_flag:%d\n", eNB->single_thread_flag);
|
||||
|
||||
if (eNB->single_thread_flag==0) {
|
||||
pthread_create( &proc_rxtx[0].pthread_rxtx, attr0, eNB_thread_rxtx, &proc_rxtx[0] );
|
||||
pthread_create( &proc_rxtx[1].pthread_rxtx, attr1, eNB_thread_rxtx, &proc_rxtx[1] );
|
||||
if (eNB->single_thread_flag==0 && nfapi_mode!=2) {
|
||||
pthread_create( &proc_rxtx[0].pthread_rxtx, attr0, eNB_thread_rxtx, proc );
|
||||
pthread_create( &proc_rxtx[1].pthread_rxtx, attr1, tx_thread, proc);
|
||||
}
|
||||
pthread_create( &proc->pthread_prach, attr_prach, eNB_thread_prach, eNB );
|
||||
#if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
|
||||
|
||||
+63
-48
@@ -120,7 +120,8 @@ extern volatile int oai_exit;
|
||||
extern int emulate_rf;
|
||||
extern int numerology;
|
||||
extern int fepw;
|
||||
|
||||
extern int single_thread_flag;
|
||||
extern clock_source_t clock_source;
|
||||
|
||||
extern void phy_init_RU(RU_t*);
|
||||
extern void phy_free_RU(RU_t*);
|
||||
@@ -714,6 +715,11 @@ static void* emulatedRF_thread(void* param) {
|
||||
wait_sync("emulatedRF_thread");
|
||||
while(!oai_exit){
|
||||
nanosleep(&req, (struct timespec *)NULL);
|
||||
if(proc->emulate_rf_busy )
|
||||
{
|
||||
LOG_E(PHY,"rf being delayed in emulated RF\n");
|
||||
}
|
||||
proc->emulate_rf_busy = 1;
|
||||
pthread_mutex_lock(&proc->mutex_emulateRF);
|
||||
++proc->instance_cnt_emulateRF;
|
||||
pthread_mutex_unlock(&proc->mutex_emulateRF);
|
||||
@@ -1016,7 +1022,6 @@ void wakeup_slaves(RU_proc_t *proc) {
|
||||
wait.tv_nsec=5000000L;
|
||||
|
||||
for (i=0;i<proc->num_slaves;i++) {
|
||||
//printf("////////////////////calling for slave thrads\n");////////////////////////********
|
||||
RU_proc_t *slave_proc = proc->slave_proc[i];
|
||||
// wake up slave FH thread
|
||||
// lock the FH mutex and make sure the thread is ready
|
||||
@@ -1252,13 +1257,14 @@ void wakeup_eNBs(RU_t *ru) {
|
||||
LOG_D(PHY,"wakeup_eNBs (num %d) for RU %d ru->eNB_top:%p\n",ru->num_eNB,ru->idx, ru->eNB_top);
|
||||
|
||||
|
||||
if (ru->num_eNB==1 && ru->eNB_top!=0 && get_nprocs() <= 4) {
|
||||
if (ru->num_eNB==1 && ru->eNB_top!=0 && (get_nprocs() <= 4 || single_thread_flag)) {
|
||||
// call eNB function directly
|
||||
|
||||
char string[20];
|
||||
sprintf(string,"Incoming RU %d",ru->idx);
|
||||
LOG_D(PHY,"RU %d Call eNB_top\n",ru->idx);
|
||||
ru->eNB_top(eNB_list[0],ru->proc.frame_rx,ru->proc.subframe_rx,string,ru);
|
||||
ru->proc.emulate_rf_busy = 0;
|
||||
}
|
||||
else {
|
||||
|
||||
@@ -1270,8 +1276,9 @@ void wakeup_eNBs(RU_t *ru) {
|
||||
eNB_list[i]->proc.ru_proc = &ru->proc;
|
||||
if (ru->wakeup_rxtx!=0 && ru->wakeup_rxtx(eNB_list[i],ru) < 0)
|
||||
{
|
||||
LOG_E(PHY,"could not wakeup eNB rxtx process for subframe %d\n", ru->proc.subframe_rx);
|
||||
LOG_E(PHY,"could not wakeup eNB rxtx process for subframe %d\n", ru->proc.subframe_rx);
|
||||
}
|
||||
ru->proc.emulate_rf_busy = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1404,7 +1411,8 @@ void fill_rf_config(RU_t *ru, char *rf_config_file) {
|
||||
cfg->num_rb_dl=fp->N_RB_DL;
|
||||
cfg->tx_num_channels=ru->nb_tx;
|
||||
cfg->rx_num_channels=ru->nb_rx;
|
||||
|
||||
cfg->clock_source=clock_source;
|
||||
|
||||
for (i=0; i<ru->nb_tx; i++) {
|
||||
|
||||
cfg->tx_freq[i] = (double)fp->dl_CarrierFreq;
|
||||
@@ -1490,12 +1498,11 @@ int setup_RU_buffers(RU_t *ru) {
|
||||
static void* ru_stats_thread(void* param) {
|
||||
|
||||
RU_t *ru = (RU_t*)param;
|
||||
|
||||
wait_sync("ru_stats_thread");
|
||||
|
||||
while (!oai_exit) {
|
||||
sleep(1);
|
||||
if (opp_enabled == 1 && fepw) {
|
||||
if (opp_enabled) {
|
||||
if (ru->feprx) print_meas(&ru->ofdm_demod_stats,"feprx",NULL,NULL);
|
||||
if (ru->feptx_ofdm) print_meas(&ru->ofdm_mod_stats,"feptx_ofdm",NULL,NULL);
|
||||
if (ru->fh_north_asynch_in) print_meas(&ru->rx_fhaul,"rx_fhaul",NULL,NULL);
|
||||
@@ -1529,6 +1536,7 @@ static void* ru_thread_tx( void* param ) {
|
||||
//wait_sync("ru_thread_tx");
|
||||
|
||||
wait_on_condition(&proc->mutex_FH1,&proc->cond_FH1,&proc->instance_cnt_FH1,"ru_thread_tx");
|
||||
|
||||
|
||||
printf( "ru_thread_tx ready\n");
|
||||
while (!oai_exit) {
|
||||
@@ -1722,7 +1730,6 @@ static void* ru_thread( void* param ) {
|
||||
ru->do_prach,
|
||||
is_prach_subframe(fp, proc->frame_rx, proc->subframe_rx),
|
||||
proc->frame_rx,proc->subframe_rx);
|
||||
|
||||
if ((ru->do_prach>0) && (is_prach_subframe(fp, proc->frame_rx, proc->subframe_rx)==1)) {
|
||||
wakeup_prach_ru(ru);
|
||||
}
|
||||
@@ -1775,7 +1782,7 @@ static void* ru_thread( void* param ) {
|
||||
if (ru->num_eNB>0) wakeup_eNBs(ru);
|
||||
|
||||
#ifndef PHY_TX_THREAD
|
||||
if(get_nprocs() <= 4 || ru->num_eNB==0){
|
||||
if(get_nprocs() <= 4 || ru->num_eNB==0 || single_thread_flag){
|
||||
// do TX front-end processing if needed (precoding and/or IDFTs)
|
||||
if (ru->feptx_prec) ru->feptx_prec(ru);
|
||||
|
||||
@@ -1787,6 +1794,7 @@ static void* ru_thread( void* param ) {
|
||||
|
||||
if (ru->fh_north_out) ru->fh_north_out(ru);
|
||||
}
|
||||
proc->emulate_rf_busy = 0;
|
||||
}
|
||||
#else
|
||||
struct timespec time_req, time_rem;
|
||||
@@ -1803,10 +1811,12 @@ static void* ru_thread( void* param ) {
|
||||
|
||||
printf( "Exiting ru_thread \n");
|
||||
|
||||
if (ru->stop_rf != NULL) {
|
||||
if (ru->stop_rf(ru) != 0)
|
||||
LOG_E(HW,"Could not stop the RF device\n");
|
||||
else LOG_I(PHY,"RU %d rf device stopped\n",ru->idx);
|
||||
if (!emulate_rf){
|
||||
if (ru->stop_rf != NULL) {
|
||||
if (ru->stop_rf(ru) != 0)
|
||||
LOG_E(HW,"Could not stop the RF device\n");
|
||||
else LOG_I(PHY,"RU %d rf device stopped\n",ru->idx);
|
||||
}
|
||||
}
|
||||
|
||||
ru_thread_status = 0;
|
||||
@@ -1872,13 +1882,13 @@ void *ru_thread_synch(void *arg) {
|
||||
|
||||
LOG_I(PHY,"Estimated sync_pos %d, peak_val %d => timing offset %d\n",sync_pos,peak_val,ru->rx_offset);
|
||||
|
||||
LOG_M_BEGIN(RU)
|
||||
if ((peak_val > 300000) && (sync_pos > 0)) {
|
||||
LOG_M("ru_sync.m","sync",(void*)&sync_corr[0],fp->samples_per_tti*5,1,2);
|
||||
LOG_M("ru_rx.m","rxs",&(ru->eNB_list[0]->common_vars.rxdata[0][0]),fp->samples_per_tti*10,1,1);
|
||||
exit(-1);
|
||||
}
|
||||
LOG_M_END
|
||||
if (LOG_DEBUGFLAG(RU)) {
|
||||
if ((peak_val > 300000) && (sync_pos > 0)) {
|
||||
LOG_M("ru_sync.m","sync",(void*)&sync_corr[0],fp->samples_per_tti*5,1,2);
|
||||
LOG_M("ru_rx.m","rxs",&(ru->eNB_list[0]->common_vars.rxdata[0][0]),fp->samples_per_tti*10,1,1);
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
ru->in_synch=1;
|
||||
}
|
||||
}
|
||||
@@ -2076,6 +2086,8 @@ extern void feptx_ofdm_2thread(RU_t *ru);
|
||||
extern void feptx_prec(RU_t *ru);
|
||||
extern void init_fep_thread(RU_t *ru,pthread_attr_t *attr);
|
||||
extern void init_feptx_thread(RU_t *ru,pthread_attr_t *attr);
|
||||
extern void kill_fep_thread(RU_t *ru);
|
||||
extern void kill_feptx_thread(RU_t *ru);
|
||||
|
||||
void init_RU_proc(RU_t *ru) {
|
||||
|
||||
@@ -2183,7 +2195,7 @@ void init_RU_proc(RU_t *ru) {
|
||||
if(emulate_rf)
|
||||
pthread_create( &proc->pthread_emulateRF, attr_emulateRF, emulatedRF_thread, (void*)proc );
|
||||
|
||||
if (get_nprocs() > 4)
|
||||
if (!single_thread_flag && get_nprocs() > 4)
|
||||
pthread_create( &proc->pthread_FH1, attr_FH1, ru_thread_tx, (void*)ru );
|
||||
|
||||
if (ru->function == NGFI_RRU_IF4p5) {
|
||||
@@ -2211,8 +2223,8 @@ void init_RU_proc(RU_t *ru) {
|
||||
}
|
||||
|
||||
if (get_nprocs()> 2 && fepw) {
|
||||
if (ru->feprx) init_fep_thread(ru,NULL);
|
||||
if (ru->feptx_ofdm) init_feptx_thread(ru,NULL);
|
||||
init_fep_thread(ru,NULL);
|
||||
init_feptx_thread(ru,NULL);
|
||||
}
|
||||
if (opp_enabled == 1) pthread_create(&ru->ru_stats_thread,NULL,ru_stats_thread,(void*)ru);
|
||||
|
||||
@@ -2223,6 +2235,13 @@ void kill_RU_proc(int inst)
|
||||
RU_t *ru = RC.ru[inst];
|
||||
RU_proc_t *proc = &ru->proc;
|
||||
|
||||
if (get_nprocs() > 2 && fepw) {
|
||||
LOG_D(PHY, "killing FEP thread\n");
|
||||
kill_fep_thread(ru);
|
||||
LOG_D(PHY, "killing FEP TX thread\n");
|
||||
kill_feptx_thread(ru);
|
||||
}
|
||||
|
||||
pthread_mutex_lock(&proc->mutex_FH);
|
||||
proc->instance_cnt_FH = 0;
|
||||
pthread_cond_signal(&proc->cond_FH);
|
||||
@@ -2261,10 +2280,10 @@ void kill_RU_proc(int inst)
|
||||
pthread_cond_signal(&proc->cond_asynch_rxtx);
|
||||
pthread_mutex_unlock(&proc->mutex_asynch_rxtx);
|
||||
|
||||
LOG_D(PHY, "Joining pthread_FH\n");
|
||||
/*LOG_D(PHY, "Joining pthread_FH\n");
|
||||
pthread_join(proc->pthread_FH, NULL);
|
||||
LOG_D(PHY, "Joining pthread_FHTX\n");
|
||||
pthread_join(proc->pthread_FH1, NULL);
|
||||
pthread_join(proc->pthread_FH1, NULL);*/
|
||||
if (ru->function == NGFI_RRU_IF4p5) {
|
||||
LOG_D(PHY, "Joining pthread_prach\n");
|
||||
pthread_join(proc->pthread_prach, NULL);
|
||||
@@ -2284,28 +2303,6 @@ void kill_RU_proc(int inst)
|
||||
pthread_join(proc->pthread_asynch_rxtx, NULL);
|
||||
}
|
||||
}
|
||||
if (get_nprocs() > 2 && fepw) {
|
||||
if (ru->feprx) {
|
||||
pthread_mutex_lock(&proc->mutex_fep);
|
||||
proc->instance_cnt_fep = 0;
|
||||
pthread_mutex_unlock(&proc->mutex_fep);
|
||||
pthread_cond_signal(&proc->cond_fep);
|
||||
LOG_D(PHY, "Joining pthread_fep\n");
|
||||
pthread_join(proc->pthread_fep, NULL);
|
||||
pthread_mutex_destroy(&proc->mutex_fep);
|
||||
pthread_cond_destroy(&proc->cond_fep);
|
||||
}
|
||||
if (ru->feptx_ofdm) {
|
||||
pthread_mutex_lock(&proc->mutex_feptx);
|
||||
proc->instance_cnt_feptx = 0;
|
||||
pthread_mutex_unlock(&proc->mutex_feptx);
|
||||
pthread_cond_signal(&proc->cond_feptx);
|
||||
LOG_D(PHY, "Joining pthread_feptx\n");
|
||||
pthread_join(proc->pthread_feptx, NULL);
|
||||
pthread_mutex_destroy(&proc->mutex_feptx);
|
||||
pthread_cond_destroy(&proc->cond_feptx);
|
||||
}
|
||||
}
|
||||
if (opp_enabled) {
|
||||
LOG_D(PHY, "Joining ru_stats_thread\n");
|
||||
pthread_join(ru->ru_stats_thread, NULL);
|
||||
@@ -2670,7 +2667,7 @@ void set_function_spec_param(RU_t *ru)
|
||||
} // switch on interface type
|
||||
}
|
||||
|
||||
extern void RCconfig_RU(void);
|
||||
//extern void RCconfig_RU(void);
|
||||
|
||||
void init_RU(char *rf_config_file) {
|
||||
|
||||
@@ -2841,6 +2838,24 @@ void RCconfig_RU(void) {
|
||||
RC.ru[j]->num_eNB = 0;
|
||||
for (i=0;i<RC.ru[j]->num_eNB;i++) RC.ru[j]->eNB_list[i] = RC.eNB[RUParamList.paramarray[j][RU_ENB_LIST_IDX].iptr[i]][0];
|
||||
|
||||
if (config_isparamset(RUParamList.paramarray[j], RU_SDR_ADDRS)) {
|
||||
RC.ru[j]->openair0_cfg.sdr_addrs = strdup(*(RUParamList.paramarray[j][RU_SDR_ADDRS].strptr));
|
||||
}
|
||||
|
||||
if (config_isparamset(RUParamList.paramarray[j], RU_SDR_CLK_SRC)) {
|
||||
if (strcmp(*(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr), "internal") == 0) {
|
||||
RC.ru[j]->openair0_cfg.clock_source = internal;
|
||||
LOG_D(PHY, "RU clock source set as internal\n");
|
||||
} else if (strcmp(*(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr), "external") == 0) {
|
||||
RC.ru[j]->openair0_cfg.clock_source = external;
|
||||
LOG_D(PHY, "RU clock source set as external\n");
|
||||
} else if (strcmp(*(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr), "gpsdo") == 0) {
|
||||
RC.ru[j]->openair0_cfg.clock_source = gpsdo;
|
||||
LOG_D(PHY, "RU clock source set as gpsdo\n");
|
||||
} else {
|
||||
LOG_E(PHY, "Erroneous RU clock source in the provided configuration file: '%s'\n", *(RUParamList.paramarray[j][RU_SDR_CLK_SRC].strptr));
|
||||
}
|
||||
}
|
||||
|
||||
if (strcmp(*(RUParamList.paramarray[j][RU_LOCAL_RF_IDX].strptr), "yes") == 0) {
|
||||
if ( !(config_isparamset(RUParamList.paramarray[j],RU_LOCAL_IF_NAME_IDX)) ) {
|
||||
|
||||
@@ -107,6 +107,10 @@ unsigned char scope_enb_num_ue = 2;
|
||||
static pthread_t forms_thread; //xforms
|
||||
#endif //XFORMS
|
||||
|
||||
#ifndef ENABLE_USE_MME
|
||||
#define EPC_MODE_ENABLED 0
|
||||
#endif
|
||||
|
||||
pthread_cond_t nfapi_sync_cond;
|
||||
pthread_mutex_t nfapi_sync_mutex;
|
||||
int nfapi_sync_var=-1; //!< protected by mutex \ref nfapi_sync_mutex
|
||||
@@ -129,11 +133,11 @@ volatile int start_UE = 0;
|
||||
#endif
|
||||
volatile int oai_exit = 0;
|
||||
|
||||
static clock_source_t clock_source = internal;
|
||||
clock_source_t clock_source = internal;
|
||||
static int wait_for_sync = 0;
|
||||
|
||||
unsigned int mmapped_dma=0;
|
||||
int single_thread_flag=1;
|
||||
int single_thread_flag = 0;
|
||||
|
||||
static int8_t threequarter_fs=0;
|
||||
|
||||
@@ -513,7 +517,7 @@ void *l2l1_task(void *arg) {
|
||||
#endif
|
||||
|
||||
|
||||
static void get_options(void) {
|
||||
static void get_options(unsigned int *start_msc) {
|
||||
|
||||
int tddflag, nonbiotflag;
|
||||
|
||||
@@ -547,11 +551,9 @@ static void get_options(void) {
|
||||
set_glog(glog_level);
|
||||
}
|
||||
if (start_telnetsrv) {
|
||||
load_module_shlib("telnetsrv",NULL,0);
|
||||
load_module_shlib("telnetsrv",NULL,0,NULL);
|
||||
}
|
||||
|
||||
|
||||
|
||||
if ( !(CONFIG_ISFLAGSET(CONFIG_ABORT)) ) {
|
||||
memset((void*)&RC,0,sizeof(RC));
|
||||
/* Read RC configuration file */
|
||||
@@ -787,7 +789,7 @@ int stop_L1L2(module_id_t enb_id)
|
||||
oai_exit = 1;
|
||||
|
||||
if (!RC.ru) {
|
||||
LOG_F(ENB_APP, "no RU configured\n");
|
||||
LOG_UI(ENB_APP, "no RU configured\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
@@ -900,7 +902,16 @@ static void wait_nfapi_init(char *thread_name) {
|
||||
|
||||
pthread_mutex_unlock(&nfapi_sync_mutex);
|
||||
|
||||
/*
|
||||
* Raphael Defosseux: temporary workaround for CI
|
||||
* -- Repeating the message thrice to make sure
|
||||
* -- it is present during flush.
|
||||
*/
|
||||
printf( "NFAPI: got sync (%s)\n", thread_name);
|
||||
printf( "NFAPI: got sync (%s)\n", thread_name);
|
||||
printf( "NFAPI: got sync (%s)\n", thread_name);
|
||||
fflush(stdout);
|
||||
fflush(stderr);
|
||||
}
|
||||
|
||||
int main( int argc, char **argv )
|
||||
@@ -915,6 +926,7 @@ int main( int argc, char **argv )
|
||||
#if defined (XFORMS)
|
||||
int ret;
|
||||
#endif
|
||||
unsigned int start_msc=0;
|
||||
|
||||
if ( load_configmodule(argc,argv) == NULL) {
|
||||
exit_fun("[SOFTMODEM] Error, configuration module init failed\n");
|
||||
@@ -932,7 +944,7 @@ int main( int argc, char **argv )
|
||||
|
||||
printf("Reading in command-line options\n");
|
||||
|
||||
get_options ();
|
||||
get_options (&start_msc);
|
||||
if (CONFIG_ISFLAGSET(CONFIG_ABORT) ) {
|
||||
fprintf(stderr,"Getting configuration failed\n");
|
||||
exit(-1);
|
||||
@@ -957,22 +969,19 @@ int main( int argc, char **argv )
|
||||
|
||||
#if defined(ENABLE_ITTI)
|
||||
|
||||
printf("ITTI init\n");
|
||||
printf("ITTI init, useMME: %i\n" ,EPC_MODE_ENABLED);
|
||||
|
||||
itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info);
|
||||
|
||||
// initialize mscgen log after ITTI
|
||||
if (start_msc) {
|
||||
load_module_shlib("msc",NULL,0,&msc_interface);
|
||||
}
|
||||
MSC_INIT(MSC_E_UTRAN, THREAD_MAX+TASK_MAX);
|
||||
#endif
|
||||
|
||||
if (opt_type != OPT_NONE) {
|
||||
radio_type_t radio_type;
|
||||
|
||||
if (frame_parms[0]->frame_type == FDD)
|
||||
radio_type = RADIO_TYPE_FDD;
|
||||
else
|
||||
radio_type = RADIO_TYPE_TDD;
|
||||
|
||||
if (init_opt(in_path, in_ip, NULL, radio_type) == -1)
|
||||
if (init_opt(in_path, in_ip) == -1)
|
||||
LOG_E(OPT,"failed to run OPT \n");
|
||||
}
|
||||
|
||||
@@ -1121,13 +1130,6 @@ int main( int argc, char **argv )
|
||||
|
||||
rt_sleep_ns(10*100000000ULL);
|
||||
|
||||
if (nfapi_mode) {
|
||||
|
||||
printf("NFAPI*** - mutex and cond created - will block shortly for completion of PNF connection\n");
|
||||
pthread_cond_init(&sync_cond,NULL);
|
||||
pthread_mutex_init(&sync_mutex, NULL);
|
||||
}
|
||||
|
||||
if (nfapi_mode)
|
||||
{
|
||||
printf("NFAPI*** - mutex and cond created - will block shortly for completion of PNF connection\n");
|
||||
|
||||
@@ -65,7 +65,7 @@
|
||||
#define CONFIG_HLP_UELOOP "get softmodem (UE) to loop through memory instead of acquiring from HW\n"
|
||||
#define CONFIG_HLP_PHYTST "test UE phy layer, mac disabled\n"
|
||||
#define CONFIG_HLP_DMAMAP "sets flag for improved EXMIMO UE performance\n"
|
||||
#define CONFIG_HLP_EXCCLK "tells hardware to use an external clock reference\n"
|
||||
#define CONFIG_HLP_CLK "tells hardware to use a clock reference (0:internal, 1:external, 2:gpsdo)\n"
|
||||
#define CONFIG_HLP_USIM "use XOR autentication algo in case of test usim mode\n"
|
||||
#define CONFIG_HLP_NOSNGLT "Disables single-thread mode in lte-softmodem\n"
|
||||
#define CONFIG_HLP_TADV "Set timing_advance\n"
|
||||
@@ -161,9 +161,9 @@
|
||||
{"phy-test", CONFIG_HLP_PHYTST, PARAMFLAG_BOOL, iptr:&phy_test, defintval:0, TYPE_INT, 0}, \
|
||||
{"usim-test", CONFIG_HLP_USIM, PARAMFLAG_BOOL, u8ptr:&usim_test, defintval:0, TYPE_UINT8, 0}, \
|
||||
{"mmapped-dma", CONFIG_HLP_DMAMAP, PARAMFLAG_BOOL, uptr:&mmapped_dma, defintval:0, TYPE_INT, 0}, \
|
||||
{"external-clock", CONFIG_HLP_EXCCLK, PARAMFLAG_BOOL, uptr:&clock_source, defintval:0, TYPE_INT, 0}, \
|
||||
{"clock", CONFIG_HLP_CLK, 0, uptr:&clock_source, defintval:0, TYPE_UINT, 0}, \
|
||||
{"wait-for-sync", NULL, PARAMFLAG_BOOL, iptr:&wait_for_sync, defintval:0, TYPE_INT, 0}, \
|
||||
{"single-thread-disable", CONFIG_HLP_NOSNGLT, PARAMFLAG_BOOL, iptr:&single_thread_flag, defintval:1, TYPE_INT, 0}, \
|
||||
{"single-thread-enable", CONFIG_HLP_NOSNGLT, PARAMFLAG_BOOL, iptr:&single_thread_flag, defintval:0, TYPE_INT, 0}, \
|
||||
{"threadIQ", NULL, 0, iptr:&(threads.iq), defintval:1, TYPE_INT, 0}, \
|
||||
{"threadOneSubframe", NULL, 0, iptr:&(threads.one), defintval:1, TYPE_INT, 0}, \
|
||||
{"threadTwoSubframe", NULL, 0, iptr:&(threads.two), defintval:1, TYPE_INT, 0}, \
|
||||
@@ -192,8 +192,9 @@
|
||||
}
|
||||
|
||||
#define CONFIG_HLP_FLOG "Enable online log \n"
|
||||
#define CONFIG_HLP_LOGL "Set the global log level, valide options: (9:trace, 8/7:debug, 6:info, 4:warn, 3:error)\n"
|
||||
#define CONFIG_HLP_LOGL "Set the global log level, valide options: (4:trace, 3:debug, 2:info, 1:warn, (0:error))\n"
|
||||
#define CONFIG_HLP_TELN "Start embedded telnet server \n"
|
||||
#define CONFIG_HLP_MSC "Enable the MSC tracing utility \n"
|
||||
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
/* command line parameters for LOG utility */
|
||||
/* optname helpstr paramflags XXXptr defXXXval type numelt */
|
||||
@@ -202,6 +203,7 @@
|
||||
{"R" , CONFIG_HLP_FLOG, 0, uptr:&online_log_messages, defintval:1, TYPE_INT, 0}, \
|
||||
{"g" , CONFIG_HLP_LOGL, 0, uptr:&glog_level, defintval:0, TYPE_UINT, 0}, \
|
||||
{"telnetsrv", CONFIG_HLP_TELN, PARAMFLAG_BOOL, uptr:&start_telnetsrv, defintval:0, TYPE_UINT, 0}, \
|
||||
{"msc", CONFIG_HLP_MSC, PARAMFLAG_BOOL, uptr:start_msc, defintval:0, TYPE_UINT, 0}, \
|
||||
}
|
||||
#define CMDLINE_ONLINELOG_IDX 0
|
||||
#define CMDLINE_GLOGLEVEL_IDX 1
|
||||
|
||||
+15
-19
@@ -446,7 +446,6 @@ static void *UE_thread_synch(void *arg)
|
||||
int freq_offset=0;
|
||||
char threadname[128];
|
||||
|
||||
UE->is_synchronized = 0;
|
||||
printf("UE_thread_sync in with PHY_vars_UE %p\n",arg);
|
||||
|
||||
cpu_set_t cpuset;
|
||||
@@ -522,11 +521,6 @@ static void *UE_thread_synch(void *arg)
|
||||
|
||||
printf("Started device, unlocked sync_mutex (UE_sync_thread)\n");
|
||||
|
||||
if (UE->rfdevice.trx_start_func(&UE->rfdevice) != 0 ) {
|
||||
LOG_E(HW,"Could not start the device\n");
|
||||
oai_exit=1;
|
||||
}
|
||||
|
||||
while (oai_exit==0) {
|
||||
AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
|
||||
while (UE->proc.instance_cnt_synch < 0)
|
||||
@@ -755,7 +749,6 @@ static void *UE_thread_rxn_txnp4(void *arg) {
|
||||
UE_rxtx_proc_t *proc = rtd->proc;
|
||||
PHY_VARS_UE *UE = rtd->UE;
|
||||
|
||||
proc->instance_cnt_rxtx=-1;
|
||||
proc->subframe_rx=proc->sub_frame_start;
|
||||
|
||||
char threadname[256];
|
||||
@@ -1457,20 +1450,25 @@ void *UE_thread(void *arg) {
|
||||
int sub_frame=-1;
|
||||
//int cumulated_shift=0;
|
||||
|
||||
if (UE->rfdevice.trx_start_func(&UE->rfdevice) != 0 ) {
|
||||
LOG_E(HW,"Could not start the device\n");
|
||||
oai_exit=1;
|
||||
}
|
||||
|
||||
while (!oai_exit) {
|
||||
#if BASIC_SIMULATOR
|
||||
while (!(UE->proc.instance_cnt_synch < 0)) {
|
||||
printf("ue sync not ready\n");
|
||||
usleep(500*1000);
|
||||
}
|
||||
#endif
|
||||
|
||||
AssertFatal ( 0== pthread_mutex_lock(&UE->proc.mutex_synch), "");
|
||||
int instance_cnt_synch = UE->proc.instance_cnt_synch;
|
||||
int is_synchronized = UE->is_synchronized;
|
||||
AssertFatal ( 0== pthread_mutex_unlock(&UE->proc.mutex_synch), "");
|
||||
|
||||
if (is_synchronized == 0) {
|
||||
#if BASIC_SIMULATOR
|
||||
while (!((instance_cnt_synch = UE->proc.instance_cnt_synch) < 0)) {
|
||||
printf("ue sync not ready\n");
|
||||
usleep(500*1000);
|
||||
}
|
||||
#endif
|
||||
if (instance_cnt_synch < 0) { // we can invoke the synch
|
||||
// grab 10 ms of signal and wakeup synch thread
|
||||
for (int i=0; i<UE->frame_parms.nb_antennas_rx; i++)
|
||||
@@ -1661,12 +1659,7 @@ void *UE_thread(void *arg) {
|
||||
|
||||
proc->instance_cnt_rxtx++;
|
||||
LOG_D( PHY, "[SCHED][UE %d] UE RX instance_cnt_rxtx %d subframe %d !!\n", UE->Mod_id, proc->instance_cnt_rxtx,proc->subframe_rx);
|
||||
if (proc->instance_cnt_rxtx == 0) {
|
||||
if (pthread_cond_signal(&proc->cond_rxtx) != 0) {
|
||||
LOG_E( PHY, "[SCHED][UE %d] ERROR pthread_cond_signal for UE RX thread\n", UE->Mod_id);
|
||||
exit_fun("nothing to add");
|
||||
}
|
||||
} else {
|
||||
if (proc->instance_cnt_rxtx != 0) {
|
||||
LOG_E( PHY, "[SCHED][UE %d] UE RX thread busy (IC %d)!!\n", UE->Mod_id, proc->instance_cnt_rxtx);
|
||||
if (proc->instance_cnt_rxtx > 2)
|
||||
exit_fun("instance_cnt_rxtx > 2");
|
||||
@@ -1717,6 +1710,8 @@ void init_UE_threads(int inst) {
|
||||
|
||||
pthread_mutex_init(&UE->proc.mutex_synch,NULL);
|
||||
pthread_cond_init(&UE->proc.cond_synch,NULL);
|
||||
UE->proc.instance_cnt_synch = -1;
|
||||
UE->is_synchronized = 0;
|
||||
|
||||
// the threads are not yet active, therefore access is allowed without locking
|
||||
int nb_threads=RX_NB_TH;
|
||||
@@ -1728,6 +1723,7 @@ void init_UE_threads(int inst) {
|
||||
|
||||
pthread_mutex_init(&UE->proc.proc_rxtx[i].mutex_rxtx,NULL);
|
||||
pthread_cond_init(&UE->proc.proc_rxtx[i].cond_rxtx,NULL);
|
||||
UE->proc.proc_rxtx[i].instance_cnt_rxtx = -1;
|
||||
UE->proc.proc_rxtx[i].sub_frame_start=i;
|
||||
UE->proc.proc_rxtx[i].sub_frame_step=nb_threads;
|
||||
printf("Init_UE_threads rtd %d proc %d nb_threads %d i %d\n",rtd->proc->sub_frame_start, UE->proc.proc_rxtx[i].sub_frame_start,nb_threads, i);
|
||||
|
||||
@@ -135,7 +135,7 @@ volatile int start_UE = 0;
|
||||
#endif
|
||||
volatile int oai_exit = 0;
|
||||
|
||||
static clock_source_t clock_source = internal;
|
||||
clock_source_t clock_source = internal;
|
||||
static int wait_for_sync = 0;
|
||||
|
||||
unsigned int mmapped_dma=0;
|
||||
@@ -470,7 +470,7 @@ void *l2l1_task(void *arg) {
|
||||
|
||||
extern int16_t dlsch_demod_shift;
|
||||
|
||||
static void get_options(void) {
|
||||
static void get_options(unsigned int *start_msc) {
|
||||
int CC_id;
|
||||
int tddflag, nonbiotflag;
|
||||
char *loopfile=NULL;
|
||||
@@ -505,7 +505,7 @@ static void get_options(void) {
|
||||
set_glog(glog_level);
|
||||
}
|
||||
if (start_telnetsrv) {
|
||||
load_module_shlib("telnetsrv",NULL,0);
|
||||
load_module_shlib("telnetsrv",NULL,0,NULL);
|
||||
}
|
||||
|
||||
paramdef_t cmdline_uemodeparams[] =CMDLINE_UEMODEPARAMS_DESC;
|
||||
@@ -770,6 +770,7 @@ int main( int argc, char **argv )
|
||||
|
||||
int CC_id;
|
||||
uint8_t abstraction_flag=0;
|
||||
unsigned int start_msc=0;
|
||||
|
||||
// Default value for the number of UEs. It will hold,
|
||||
// if not changed from the command line option --num-ues
|
||||
@@ -797,7 +798,7 @@ int main( int argc, char **argv )
|
||||
printf("Reading in command-line options\n");
|
||||
|
||||
for (int i=0;i<MAX_NUM_CCs;i++) tx_max_power[i]=23;
|
||||
get_options ();
|
||||
get_options (&start_msc);
|
||||
|
||||
|
||||
printf("Running with %d UE instances\n",NB_UE_INST);
|
||||
@@ -830,21 +831,6 @@ int main( int argc, char **argv )
|
||||
//randominit (0);
|
||||
set_taus_seed (0);
|
||||
|
||||
|
||||
set_log(HW, OAILOG_DEBUG, 1);
|
||||
set_log(PHY, OAILOG_INFO, 1);
|
||||
set_log(MAC, OAILOG_INFO, 1);
|
||||
set_log(RLC, OAILOG_INFO, 1);
|
||||
set_log(PDCP, OAILOG_INFO, 1);
|
||||
set_log(OTG, OAILOG_INFO, 1);
|
||||
set_log(RRC, OAILOG_INFO, 1);
|
||||
#if defined(ENABLE_ITTI)
|
||||
set_log(SIM, OAILOG_INFO, 1);
|
||||
# if defined(ENABLE_USE_MME)
|
||||
set_log(NAS, OAILOG_INFO, 1);
|
||||
# endif
|
||||
#endif
|
||||
|
||||
cpuf=get_cpu_freq_GHz();
|
||||
|
||||
pthread_cond_init(&sync_cond,NULL);
|
||||
@@ -858,18 +844,14 @@ int main( int argc, char **argv )
|
||||
itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info);
|
||||
|
||||
// initialize mscgen log after ITTI
|
||||
if (start_msc) {
|
||||
load_module_shlib("msc",NULL,0,&msc_interface);
|
||||
}
|
||||
MSC_INIT(MSC_E_UTRAN, THREAD_MAX+TASK_MAX);
|
||||
#endif
|
||||
|
||||
if (opt_type != OPT_NONE) {
|
||||
radio_type_t radio_type;
|
||||
|
||||
if (frame_parms[0]->frame_type == FDD)
|
||||
radio_type = RADIO_TYPE_FDD;
|
||||
else
|
||||
radio_type = RADIO_TYPE_TDD;
|
||||
|
||||
if (init_opt(in_path, in_ip, NULL, radio_type) == -1)
|
||||
if (init_opt(in_path, in_ip) == -1)
|
||||
LOG_E(OPT,"failed to run OPT \n");
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user