maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

consistenty use suffix _t for openair0_* types

Browse Source
This commit is contained in:
Thomas Schlichter
2026-01-23 18:30:39 +01:00
parent ed4cca814a
commit 75df29a333
38 changed files with 499 additions and 513 deletions
Download Patch File Download Diff File Expand all files Collapse all files
radio/AW2SORI/oaiori.c
+10 -13
View File
@@ -212,8 +212,8 @@ void cb(void * userData, ORI_IndicationType_e type, ORI_IndicationValue_u value)
printf("<============\n");
}
int aw2s_oricleanup(openair0_device *device) {
int aw2s_oricleanup(openair0_device_t *device)
{
ORI_s * ori = (ORI_s*)device->thirdparty_priv;
ORI_Disconnect(ori);
@@ -222,8 +222,8 @@ int aw2s_oricleanup(openair0_device *device) {
return(0);
}
int aw2s_startstreaming(openair0_device *device) {
int aw2s_startstreaming(openair0_device_t *device)
{
ORI_s * ori = (ORI_s*)device->thirdparty_priv;
ORI_Result_e result;
ORI_Result_e RE_result;
@@ -413,9 +413,8 @@ int aw2s_startstreaming(openair0_device *device) {
printf("ORI_ObjectStateModify: %s\n", ORI_Result_Print(RE_result));
}
device->fhstate.active=1;
return(0);
device->fhstate.active = 1;
return (0);
}
uint32_t to_nrarfcn(int nr_bandP,
@@ -423,9 +422,8 @@ uint32_t to_nrarfcn(int nr_bandP,
uint8_t scs_index,
uint32_t bw);
int aw2s_oriinit(openair0_device *device) {
int aw2s_oriinit(openair0_device_t *device)
{
ORI_s * ori;
ORI_Result_e result;
ORI_Result_e RE_result;
@@ -892,9 +890,8 @@ int aw2s_oriinit(openair0_device *device) {
return 0;
}
int transport_init(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t * eth_params ) {
int transport_init(openair0_device_t *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params)
{
printf("Initializing AW2S (%p,%p,%p)\n",aw2s_oriinit,aw2s_oricleanup,aw2s_startstreaming);
device->thirdparty_init = aw2s_oriinit;
device->thirdparty_cleanup = aw2s_oricleanup;
radio/BLADERF/bladerf_lib.c
+16 -28
View File
@@ -46,7 +46,7 @@ int num_devices=0;
* \param device RF frontend parameters set by application
* \returns 0 on success
*/
int trx_brf_init(openair0_device *device)
int trx_brf_init(openair0_device_t *device)
{
return 0;
}
@@ -57,8 +57,7 @@ int trx_brf_init(openair0_device *device)
*\param module the bladeRf module
*\returns timestamp of BladeRF
*/
openair0_timestamp trx_get_timestamp(openair0_device *device,
bladerf_module module)
openair0_timestamp_t trx_get_timestamp(openair0_device_t *device, bladerf_module module)
{
int status;
struct bladerf_metadata meta;
@@ -78,7 +77,7 @@ openair0_timestamp trx_get_timestamp(openair0_device *device,
* \param device the hardware to use
* \returns 0 on success
*/
int trx_brf_start(openair0_device *device)
int trx_brf_start(openair0_device_t *device)
{
brf_state_t *brf = (brf_state_t*)device->priv;
int status;
@@ -127,12 +126,7 @@ int trx_brf_start(openair0_device *device)
\param flags Ignored for the moment
\returns 0 on success
*/
static int trx_brf_write(openair0_device *device,
openair0_timestamp ptimestamp,
void **buff,
int nsamps,
int cc,
int flags)
static int trx_brf_write(openair0_device_t *device, openair0_timestamp_t ptimestamp, void **buff, int nsamps, int cc, int flags)
{
int status;
brf_state_t *brf = (brf_state_t*)device->priv;
@@ -185,11 +179,7 @@ static int trx_brf_write(openair0_device *device,
* \param cc Index of component carrier
* \returns number of samples read
*/
static int trx_brf_read(openair0_device *device,
openair0_timestamp *ptimestamp,
void **buff,
int nsamps,
int cc)
static int trx_brf_read(openair0_device_t *device, openair0_timestamp_t *ptimestamp, void **buff, int nsamps, int cc)
{
int status=0;
brf_state_t *brf = (brf_state_t*)device->priv;
@@ -235,7 +225,7 @@ static int trx_brf_read(openair0_device *device,
/*! \brief Terminate operation of the BladeRF transceiver -- free all associated resources
* \param device the hardware to use
*/
void trx_brf_end(openair0_device *device)
void trx_brf_end(openair0_device_t *device)
{
int status;
brf_state_t *brf = (brf_state_t*)device->priv;
@@ -255,7 +245,7 @@ void trx_brf_end(openair0_device *device)
* \param device the hardware to use
* \returns 0 on success
*/
int trx_brf_get_stats(openair0_device* device)
int trx_brf_get_stats(openair0_device_t *device)
{
return(0);
}
@@ -265,7 +255,7 @@ int trx_brf_get_stats(openair0_device* device)
* \param device the hardware to use
* \returns 0 on success
*/
int trx_brf_reset_stats(openair0_device* device)
int trx_brf_reset_stats(openair0_device_t *device)
{
return(0);
}
@@ -275,7 +265,7 @@ int trx_brf_reset_stats(openair0_device* device)
* \param card the hardware to use
* \returns 0 in success
*/
int trx_brf_stop(openair0_device* device)
int trx_brf_stop(openair0_device_t *device)
{
return(0);
}
@@ -286,7 +276,7 @@ int trx_brf_stop(openair0_device* device)
* \param openair0_cfg1 openair0 Config structure (ignored. It is there to comply with RF common API)
* \returns 0 in success
*/
int trx_brf_set_freq(openair0_device* device, openair0_config_t *openair0_cfg1)
int trx_brf_set_freq(openair0_device_t *device, openair0_config_t *openair0_cfg1)
{
int status;
brf_state_t *brf = (brf_state_t *)device->priv;
@@ -315,12 +305,11 @@ int trx_brf_set_freq(openair0_device* device, openair0_config_t *openair0_cfg1)
* \param openair0_cfg openair0 Config structure
* \returns 0 in success
*/
int trx_brf_set_gains(openair0_device* device,
openair0_config_t *openair0_cfg)
int trx_brf_set_gains(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
return(0);
}
int trx_brf_write_init(openair0_device *device)
int trx_brf_write_init(openair0_device_t *device)
{
return 0;
}
@@ -368,13 +357,13 @@ void set_rx_gain_offset(openair0_config_t *openair0_cfg,
/*! \brief Calibrate LMSSDR RF
* \param device the hardware to use
*/
void calibrate_rf(openair0_device *device)
void calibrate_rf(openair0_device_t *device)
{
/* TODO: this function does not seem to work. Disabled until fixed. */
return;
brf_state_t *brf = (brf_state_t *)device->priv;
openair0_timestamp ptimestamp;
openair0_timestamp_t ptimestamp;
int16_t *calib_buffp,*calib_tx_buffp;
int16_t calib_buff[2*RXDCLENGTH];
int16_t calib_tx_buff[2*RXDCLENGTH];
@@ -948,8 +937,7 @@ void calibrate_rf(openair0_device *device)
* \param openair0_cfg RF frontend parameters set by application
* \returns 0 on success
*/
int device_init(openair0_device *device,
openair0_config_t *openair0_cfg)
int device_init(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
int status;
brf_state_t *brf = (brf_state_t*)malloc(sizeof(brf_state_t));
@@ -1138,7 +1126,7 @@ int device_init(openair0_device *device,
*/
bladerf_log_set_verbosity(BLADERF_LOG_LEVEL_INFO);
printf("BLADERF: Initializing openair0_device\n");
printf("BLADERF: Initializing openair0_device_t\n");
device->Mod_id = num_devices++;
device->type = BLADERF_DEV;
device->trx_start_func = trx_brf_start;
radio/BLADERF/bladerf_lib.h
+3 -3
View File
@@ -94,7 +94,7 @@ typedef struct {
//! number of RX count
uint64_t rx_count;
//! timestamp of RX packet
openair0_timestamp rx_timestamp;
openair0_timestamp_t rx_timestamp;
} brf_state_t;
/*
@@ -103,13 +103,13 @@ typedef struct {
/*! \brief BladeRF Init function (not used at the moment)
* \param device RF frontend parameters set by application
*/
int trx_brf_init(openair0_device *device);
int trx_brf_init(openair0_device_t *device);
/*! \brief get current timestamp
*\param device the hardware to use
*\param module the bladeRf module
*/
openair0_timestamp trx_get_timestamp(openair0_device *device, bladerf_module module);
openair0_timestamp_t trx_get_timestamp(openair0_device_t *device, bladerf_module module);
/*! \brief bladeRF error report
* \param status
radio/COMMON/common_lib.c
+11 -20
View File
@@ -53,7 +53,7 @@ const char *get_devname(int devtype) {
return "none";
}
int set_device(openair0_device *device)
int set_device(openair0_device_t *device)
{
const char *devname = get_devname(device->type);
if (strcmp(devname,"none") != 0) {
@@ -65,7 +65,7 @@ int set_device(openair0_device *device)
return 0;
}
int set_transport(openair0_device *device)
int set_transport(openair0_device_t *device)
{
switch (device->transp_type) {
case ETHERNET_TP:
@@ -85,14 +85,10 @@ int set_transport(openair0_device *device)
}
}
typedef int(*devfunc_t)(openair0_device *, openair0_config_t *, eth_params_t *);
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 *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 *cfg, uint8_t flag)
{
loader_shlibfunc_t shlib_fdesc[1];
int ret=0;
@@ -139,9 +135,7 @@ int load_lib(openair0_device *device,
return ((devfunc_t)shlib_fdesc[0].fptr)(device,openair0_cfg,cfg);
}
int openair0_device_load(openair0_device *device,
openair0_config_t *openair0_cfg)
int openair0_device_load(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
int rc=0;
rc=load_lib(device, openair0_cfg, NULL,RAU_LOCAL_RADIO_HEAD );
@@ -157,10 +151,7 @@ int openair0_device_load(openair0_device *device,
return rc;
}
int openair0_transport_load(openair0_device *device,
openair0_config_t *openair0_cfg,
eth_params_t *eth_params)
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);
@@ -175,7 +166,7 @@ int openair0_transport_load(openair0_device *device,
return rc;
}
static void writerEnqueue(re_order_t *ctx, openair0_timestamp timestamp, void **txp, int nsamps, int nbAnt, int flags)
static void writerEnqueue(re_order_t *ctx, openair0_timestamp_t timestamp, void **txp, int nsamps, int nbAnt, int flags)
{
pthread_mutex_lock(&ctx->mutex_store);
LOG_D(HW, "Enqueue write for TS: %lu\n", timestamp);
@@ -196,7 +187,7 @@ static void writerEnqueue(re_order_t *ctx, openair0_timestamp timestamp, void **
pthread_mutex_unlock(&ctx->mutex_store);
}
static void writerProcessWaitingQueue(openair0_device *device)
static void writerProcessWaitingQueue(openair0_device_t *device)
{
bool found = false;
re_order_t *ctx = &device->reOrder;
@@ -205,7 +196,7 @@ static void writerProcessWaitingQueue(openair0_device *device)
pthread_mutex_lock(&ctx->mutex_store);
for (int i = 0; i < WRITE_QUEUE_SZ; i++) {
if (ctx->queue[i].active && llabs(ctx->queue[i].timestamp - ctx->nextTS) < MAX_GAP) {
openair0_timestamp timestamp = ctx->queue[i].timestamp;
openair0_timestamp_t timestamp = ctx->queue[i].timestamp;
LOG_D(HW, "Dequeue write for TS: %lu\n", timestamp);
int nsamps = ctx->queue[i].nsamps;
int nbAnt = ctx->queue[i].nbAnt;
@@ -235,7 +226,7 @@ static void writerProcessWaitingQueue(openair0_device *device)
// but to make zerocopy and agnostic design, we need to make a proper ring buffer with mutex protection
// mutex (or atomic flags) will be mandatory because this out order system root cause is there are several writer threads
int openair0_write_reorder(openair0_device *device, openair0_timestamp timestamp, void **txp, int nsamps, int nbAnt, int flags)
int openair0_write_reorder(openair0_device_t *device, openair0_timestamp_t timestamp, void **txp, int nsamps, int nbAnt, int flags)
{
int wroteSamples = 0;
re_order_t *ctx = &device->reOrder;
@@ -270,7 +261,7 @@ int openair0_write_reorder(openair0_device *device, openair0_timestamp timestamp
return nsamps;
}
void openair0_write_reorder_clear_context(openair0_device *device)
void openair0_write_reorder_clear_context(openair0_device_t *device)
{
LOG_I(HW, "received write reorder clear context\n");
re_order_t *ctx = &device->reOrder;
radio/COMMON/common_lib.h
+62 -55
View File
@@ -58,12 +58,11 @@
#define MAX_WRITE_THREAD_BUFFER_SIZE 8
#define MAX_CARDS 8
typedef int64_t openair0_timestamp;
typedef volatile int64_t openair0_vtimestamp;
typedef int64_t openair0_timestamp_t;
typedef volatile int64_t openair0_vtimestamp_t;
/*!\brief structure holds the parameters to configure USRP devices*/
typedef struct openair0_device_t openair0_device;
typedef struct openair0_device openair0_device_t;
//#define USRP_GAIN_OFFSET (56.0) // 86 calibrated for USRP B210 @ 2.6 GHz to get equivalent RS EPRE in OAI to SMBV100 output
@@ -167,7 +166,7 @@ typedef enum {
/*! \brief Structure used for initializing UDP read threads */
typedef struct {
openair0_device *device;
openair0_device_t *device;
int thread_id;
pthread_t pthread;
notifiedFIFO_t *resp;
@@ -317,8 +316,7 @@ typedef struct {
int card;
//! rf chain id
int chain;
} openair0_rf_map;
} openair0_rf_map_t;
typedef struct {
char *remote_addr;
@@ -350,7 +348,7 @@ typedef struct {
} if_buffer_t;
typedef struct {
openair0_timestamp timestamp;
openair0_timestamp_t timestamp;
void *buff[MAX_WRITE_THREAD_BUFFER_SIZE];// buffer to be write;
int nsamps;
int cc;
@@ -378,11 +376,11 @@ typedef struct {
} openair0_thread_t;
typedef struct fhstate_s {
openair0_timestamp TS[8];
openair0_timestamp TS0;
openair0_timestamp olddeltaTS[8];
openair0_timestamp oldTS[8];
openair0_timestamp TS_read;
openair0_timestamp_t TS[8];
openair0_timestamp_t TS0;
openair0_timestamp_t olddeltaTS[8];
openair0_timestamp_t oldTS[8];
openair0_timestamp_t TS_read;
int first_read;
uint32_t *buff[8];
uint32_t buff_size;
@@ -395,10 +393,10 @@ typedef struct {
bool initDone;
pthread_mutex_t mutex_write;
pthread_mutex_t mutex_store;
openair0_timestamp nextTS;
openair0_timestamp_t nextTS;
struct {
bool active;
openair0_timestamp timestamp;
openair0_timestamp_t timestamp;
void *txp[NB_ANTENNAS_TX];
int nsamps;
int nbAnt;
@@ -407,7 +405,7 @@ typedef struct {
} re_order_t;
/*!\brief structure holds the parameters to configure USRP devices */
struct openair0_device_t {
struct openair0_device {
/*!tx write thread*/
openair0_thread_t write_thread;
@@ -463,28 +461,27 @@ struct openair0_device_t {
/*! \brief Called to start the transceiver. Return 0 if OK, < 0 if error
@param device pointer to the device structure specific to the RF hardware target
*/
int (*trx_start_func)(openair0_device *device);
int (*trx_start_func)(openair0_device_t *device);
/*! \brief Called to configure the device
@param device pointer to the device structure specific to the RF hardware target
*/
/*! \brief Called to configure the device
@param device pointer to the device structure specific to the RF hardware target
*/
int (*trx_config_func)(openair0_device* device, openair0_config_t *openair0_cfg);
int (*trx_config_func)(openair0_device_t *device, openair0_config_t *openair0_cfg);
/*! \brief Called to send a request message between RAU-RRU on control port
@param device pointer to the device structure specific to the RF hardware target
@param msg pointer to the message structure passed between RAU-RRU
@param msg_len length of the message
*/
int (*trx_ctlsend_func)(openair0_device *device, void *msg, ssize_t msg_len);
int (*trx_ctlsend_func)(openair0_device_t *device, void *msg, ssize_t msg_len);
/*! \brief Called to receive a reply message between RAU-RRU on control port
@param device pointer to the device structure specific to the RF hardware target
@param msg pointer to the message structure passed between RAU-RRU
@param msg_len length of the message
*/
int (*trx_ctlrecv_func)(openair0_device *device, void *msg, ssize_t msg_len);
int (*trx_ctlrecv_func)(openair0_device_t *device, void *msg, ssize_t msg_len);
/*! \brief Called to send samples to the RF target
@param device pointer to the device structure specific to the RF hardware target
@@ -495,8 +492,8 @@ struct openair0_device_t {
@param num_beams number of beams
@param flags flags must be set to true if timestamp parameter needs to be applied
*/
int (*trx_write_beams_func)(openair0_device *device,
openair0_timestamp timestamp,
int (*trx_write_beams_func)(openair0_device_t *device,
openair0_timestamp_t timestamp,
void ***buff,
int nsamps,
int nb_antennas_tx,
@@ -511,7 +508,12 @@ struct openair0_device_t {
@param nb_antennas_tx number of antennas
@param flags flags must be set to true if timestamp parameter needs to be applied
*/
int (*trx_write_func)(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int nb_antennas_tx, int flags);
int (*trx_write_func)(openair0_device_t *device,
openair0_timestamp_t timestamp,
void **buff,
int nsamps,
int nb_antennas_tx,
int flags);
/*! \brief Called to send samples to the RF target
@param device pointer to the device structure specific to the RF hardware target
@@ -520,7 +522,13 @@ struct openair0_device_t {
@param nsamps number of samples to be sent
@param flags flags must be set to true if timestamp parameter needs to be applied
*/
int (*trx_write_func2)(openair0_device *device, openair0_timestamp timestamp, void **buff, int fd_ind,int nsamps, int flags,int nant);
int (*trx_write_func2)(openair0_device_t *device,
openair0_timestamp_t timestamp,
void **buff,
int fd_ind,
int nsamps,
int flags,
int nant);
/*! \brief Receive samples from hardware.
* Read nsamps samples from each channel to buffers. buff[0] is the array for
@@ -533,7 +541,7 @@ struct openair0_device_t {
* antennas from which to receive samples \returns the number of sample read
*/
int (*trx_read_func)(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int num_antennas);
int (*trx_read_func)(openair0_device_t *device, openair0_timestamp_t *ptimestamp, void **buff, int nsamps, int num_antennas);
/*! \brief Receive samples from hardware.
* Read nsamps samples from each channel to buffers. buff[0] is the array for
@@ -548,8 +556,8 @@ struct openair0_device_t {
* \param num_beams number of beams from which to receive samples
* \returns the number of sample read
*/
int (*trx_read_beams_func)(openair0_device *device,
openair0_timestamp *ptimestamp,
int (*trx_read_beams_func)(openair0_device_t *device,
openair0_timestamp_t *ptimestamp,
void ***buff,
int nsamps,
int num_antennas,
@@ -567,28 +575,28 @@ struct openair0_device_t {
* \param antenna_id Index of antenna from which samples were received
* \returns the number of sample read
*/
int (*trx_read_func2)(openair0_device *device, openair0_timestamp *ptimestamp, uint32_t **buff, int nsamps);
int (*trx_read_func2)(openair0_device_t *device, openair0_timestamp_t *ptimestamp, uint32_t **buff, int nsamps);
/*! \brief print the device statistics
* \param device the hardware to use
* \returns 0 on success
*/
int (*trx_get_stats_func)(openair0_device *device);
int (*trx_get_stats_func)(openair0_device_t *device);
/*! \brief Reset device statistics
* \param device the hardware to use
* \returns 0 in success
*/
int (*trx_reset_stats_func)(openair0_device *device);
int (*trx_reset_stats_func)(openair0_device_t *device);
/*! \brief Terminate operation of the transceiver -- free all associated resources
* \param device the hardware to use
*/
void (*trx_end_func)(openair0_device *device);
void (*trx_end_func)(openair0_device_t *device);
/*! \brief Stop operation of the transceiver
*/
int (*trx_stop_func)(openair0_device *device);
int (*trx_stop_func)(openair0_device_t *device);
/* Functions API related to UE*/
@@ -597,14 +605,14 @@ struct openair0_device_t {
* \param openair0_cfg RF frontend parameters set by application
* \returns 0 in success
*/
int (*trx_set_freq_func)(openair0_device *device, openair0_config_t *openair0_cfg);
int (*trx_set_freq_func)(openair0_device_t *device, openair0_config_t *openair0_cfg);
/*! \brief Set gains
* \param device the hardware to use
* \param openair0_cfg RF frontend parameters set by application
* \returns 0 in success
*/
int (*trx_set_gains_func)(openair0_device *device, openair0_config_t *openair0_cfg);
int (*trx_set_gains_func)(openair0_device_t *device, openair0_config_t *openair0_cfg);
/*! \brief Set tx/rx beams
*
@@ -619,9 +627,9 @@ struct openair0_device_t {
* \param beam_map the beams to receive
* \return 0 on success
*/
int (*trx_set_beams)(openair0_device *device, uint64_t beam_map, openair0_timestamp timestamp);
int (*trx_set_beams)(openair0_device_t *device, uint64_t beam_map, openair0_timestamp_t timestamp);
/*! \brief Set tx/rx beams
/*! \brief Set tx/rx beams
*
* Set the tx/rx beams. This has to be done in advance of the reception in order to
* allow the underlying device to change receiver configuration. The exact time depends
@@ -635,7 +643,7 @@ struct openair0_device_t {
* \param num_beams number of beams
* \return 0 on success
*/
int (*trx_set_beams2)(openair0_device *device, int* beams, int num_beams, openair0_timestamp timestamp);
int (*trx_set_beams2)(openair0_device_t *device, int *beams, int num_beams, openair0_timestamp_t timestamp);
/*! \brief RRU Configuration callback
* \param idx RU index
@@ -651,22 +659,22 @@ struct openair0_device_t {
/*! \brief Callback for Third-party RRU Initialization routine
\param device the hardware configuration to use
*/
int (*thirdparty_init)(openair0_device *device);
int (*thirdparty_init)(openair0_device_t *device);
/*! \brief Callback for Third-party RRU Cleanup routine
\param device the hardware configuration to use
*/
int (*thirdparty_cleanup)(openair0_device *device);
int (*thirdparty_cleanup)(openair0_device_t *device);
/*! \brief Callback for Third-party start streaming routine
\param device the hardware configuration to use
*/
int (*thirdparty_startstreaming)(openair0_device *device);
int (*thirdparty_startstreaming)(openair0_device_t *device);
/*! \brief RRU Configuration callback
* \param idx RU index
* \param arg pointer to capabilities or configuration
*/
int (*trx_write_init)(openair0_device *device);
int (*trx_write_init)(openair0_device_t *device);
/* \brief Get internal parameter
* \param id parameter to get
* \return a pointer to the parameter
@@ -679,9 +687,9 @@ struct openair0_device_t {
};
/* type of device init function, implemented in shared lib */
typedef int(*oai_device_initfunc_t)(openair0_device *device, openair0_config_t *openair0_cfg);
typedef int (*oai_device_initfunc_t)(openair0_device_t *device, openair0_config_t *openair0_cfg);
/* type of transport init function, implemented in shared lib */
typedef int(*oai_transport_initfunc_t)(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params);
typedef int (*oai_transport_initfunc_t)(openair0_device_t *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params);
#define OPTION_LZ4 0x00000001 // LZ4 compression (option_value is set to compressed size)
@@ -723,30 +731,29 @@ extern "C"
/*! \brief get device name from device type */
const char *get_devname(int devtype);
/*! \brief Initialize openair RF target. It returns 0 if OK */
int openair0_device_load(openair0_device *device, openair0_config_t *openair0_cfg);
int openair0_device_load(openair0_device_t *device, openair0_config_t *openair0_cfg);
/*! \brief Initialize transport protocol . It returns 0 if OK */
int openair0_transport_load(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params);
int openair0_transport_load(openair0_device_t *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params);
/*! \brief Get current timestamp of USRP
* \param device the hardware to use
*/
openair0_timestamp get_usrp_time(openair0_device *device);
openair0_timestamp_t get_usrp_time(openair0_device_t *device);
/*! \brief Set RX frequencies
* \param device the hardware to use
* \param openair0_cfg RF frontend parameters set by application
* \returns 0 in success
*/
int openair0_set_rx_frequencies(openair0_device *device, openair0_config_t *openair0_cfg);
int openair0_set_rx_frequencies(openair0_device_t *device, openair0_config_t *openair0_cfg);
/*! \brief read the iq record-player configuration */
extern int read_recplayconfig(recplay_conf_t **recplay_conf, recplay_state_t **recplay_state);
/*! \brief store recorded iqs from memory to file. */
extern void iqrecorder_end(openair0_device *device);
extern void iqrecorder_end(openair0_device_t *device);
int openair0_write_reorder(openair0_device *device, openair0_timestamp timestamp, void **txp, int nsamps, int nbAnt, int flags);
void openair0_write_reorder_clear_context(openair0_device *device);
int openair0_write_reorder(openair0_device_t *device, openair0_timestamp_t timestamp, void **txp, int nsamps, int nbAnt, int flags);
void openair0_write_reorder_clear_context(openair0_device_t *device);
#include <unistd.h>
#ifndef gettid
#define gettid() syscall(__NR_gettid)
radio/COMMON/record_player.c
+2 -1
View File
@@ -78,7 +78,8 @@ int read_recplayconfig(recplay_conf_t **recplay_conf, recplay_state_t **recplay_
* used in record mode
* \param device the hardware used
*/
void iqrecorder_end(openair0_device *device) {
void iqrecorder_end(openair0_device_t *device)
{
if (device->recplay_state != NULL) { // subframes store
iqfile_header_t fh = {device->type,device->openair0_cfg->tx_sample_advance, device->openair0_cfg->rx_bw,0,OAIIQFILE_ID};
recplay_state_t *rs = device->recplay_state;
radio/ETHERNET/eth_raw.c
+31 -40
View File
@@ -52,8 +52,8 @@
//int addr_len[MAX_INST];
//struct ifreq if_index[MAX_INST];
int eth_socket_init_raw(openair0_device *device) {
int eth_socket_init_raw(openair0_device_t *device)
{
eth_state_t *eth = (eth_state_t*)device->priv;
const char *local_mac, *remote_mac;
int sock_dom=0;
@@ -125,8 +125,8 @@ int eth_socket_init_raw(openair0_device *device) {
}
/* 09/03/2019: fix obvious inconsistencies, but this code hasn't be tested for sure */
int trx_eth_write_raw(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps,int cc, int flags) {
int trx_eth_write_raw(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int cc, int flags)
{
int bytes_sent=0;
eth_state_t *eth = (eth_state_t*)device->priv;
int sendto_flag =0;
@@ -148,12 +148,12 @@ int trx_eth_write_raw(openair0_device *device, openair0_timestamp timestamp, voi
/* we don't want to ovewrite with the header info the previous tx buffer data so we store it*/
struct ether_header temp = *(struct ether_header *)buff2;
int32_t temp0 = *(int32_t *)(buff2 + MAC_HEADER_SIZE_BYTES);
openair0_timestamp temp1 = *(openair0_timestamp *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t));
openair0_timestamp_t temp1 = *(openair0_timestamp_t *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t));
bytes_sent = 0;
memcpy(buff2,(void*)&eth->ehd,MAC_HEADER_SIZE_BYTES);
*(int16_t *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int16_t))=1+(i<<1);
*(openair0_timestamp *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t)) = timestamp;
*(openair0_timestamp_t *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t)) = timestamp;
/*printf("[RRU]write mod_%d %d , len %d, buff %p \n",
Mod_id,eth->sockfd[Mod_id],RAW_PACKET_SIZE_BYTES(nsamps), buff2);*/
@@ -180,15 +180,13 @@ int trx_eth_write_raw(openair0_device *device, openair0_timestamp timestamp, voi
/* tx buffer values restored */
*(struct ether_header *)buff2 = temp;
*(int32_t *)(buff2 + MAC_HEADER_SIZE_BYTES) = temp0;
*(openair0_timestamp *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t)) = temp1;
*(openair0_timestamp_t *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t)) = temp1;
}
return (bytes_sent-APP_HEADER_SIZE_BYTES-MAC_HEADER_SIZE_BYTES)>>2;
}
int trx_eth_write_raw_IF4p5(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags) {
int trx_eth_write_raw_IF4p5(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int cc, int flags)
{
int nblocks = nsamps;
int bytes_sent = 0;
@@ -225,13 +223,11 @@ int trx_eth_write_raw_IF4p5(openair0_device *device, openair0_timestamp timestam
eth->tx_count++;
}
return (bytes_sent-MAC_HEADER_SIZE_BYTES);
return (bytes_sent-MAC_HEADER_SIZE_BYTES);
}
int trx_eth_read_raw(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc) {
int trx_eth_read_raw(openair0_device_t *device, openair0_timestamp_t *timestamp, void **buff, int nsamps, int cc)
{
int ret;
int bytes_received=0;
int i=0;
@@ -251,7 +247,7 @@ int trx_eth_read_raw(openair0_device *device, openair0_timestamp *timestamp, voi
/* we don't want to ovewrite with the header info the previous rx buffer data so we store it*/
struct ether_header temp = *(struct ether_header *)buff2;
int32_t temp0 = *(int32_t *)(buff2 + MAC_HEADER_SIZE_BYTES);
openair0_timestamp temp1 = *(openair0_timestamp *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t));
openair0_timestamp_t temp1 = *(openair0_timestamp_t *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t));
bytes_received=0;
int receive_bytes;
@@ -299,18 +295,18 @@ int trx_eth_read_raw(openair0_device *device, openair0_timestamp *timestamp, voi
} else {
bytes_received+=ret;
/* store the timestamp value from packet's header */
*timestamp = *(openair0_timestamp *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t));
*timestamp = *(openair0_timestamp_t *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t));
eth->rx_actual_nsamps=bytes_received>>2;
eth->rx_count++;
}
}
#if DEBUG
#if DEBUG
printf("------- RX------: nu=%x an_id=%d ts%d bytes_recv=%d \n",
*(uint8_t *)(buff2+ETH_ALEN),
*(int16_t *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int16_t)),
*(openair0_timestamp *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t)),
bytes_received);
*(uint8_t *)(buff2 + ETH_ALEN),
*(int16_t *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int16_t)),
*(openair0_timestamp_t *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t)),
bytes_received);
dump_packet((device->host_type == RAU_HOST)? "RAU":"RRU", buff2, RAW_PACKET_SIZE_BYTES(nsamps),RX_FLAG);
@@ -319,15 +315,13 @@ int trx_eth_read_raw(openair0_device *device, openair0_timestamp *timestamp, voi
/* tx buffer values restored */
*(struct ether_header *)buff2 = temp;
*(int32_t *)(buff2 + MAC_HEADER_SIZE_BYTES) = temp0;
*(openair0_timestamp *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t)) = temp1;
*(openair0_timestamp_t *)(buff2 + MAC_HEADER_SIZE_BYTES + sizeof(int32_t)) = temp1;
}
return (bytes_received-APP_HEADER_SIZE_BYTES-MAC_HEADER_SIZE_BYTES)>>2;
}
int trx_eth_read_raw_IF4p5(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc) {
int trx_eth_read_raw_IF4p5(openair0_device_t *device, openair0_timestamp_t *timestamp, void **buff, int nsamps, int cc)
{
int ret;
// Read nblocks info from packet itself
int nblocks = nsamps;
@@ -413,9 +407,8 @@ int trx_eth_read_raw_IF4p5(openair0_device *device, openair0_timestamp *timestam
return(bytes_received);
}
int eth_set_dev_conf_raw(openair0_device *device) {
int eth_set_dev_conf_raw(openair0_device_t *device)
{
eth_state_t *eth = (eth_state_t*)device->priv;
void *msg;
ssize_t msg_len;
@@ -443,9 +436,8 @@ int eth_set_dev_conf_raw(openair0_device *device) {
return 0;
}
int eth_set_dev_conf_raw_IF4p5(openair0_device *device) {
int eth_set_dev_conf_raw_IF4p5(openair0_device_t *device)
{
// use for cc_id info
eth_state_t *eth = (eth_state_t*)device->priv;
@@ -475,9 +467,8 @@ int eth_set_dev_conf_raw_IF4p5(openair0_device *device) {
return 0;
}
int eth_get_dev_conf_raw(openair0_device *device) {
int eth_get_dev_conf_raw(openair0_device_t *device)
{
eth_state_t *eth = (eth_state_t*)device->priv;
void *msg;
ssize_t msg_len;
@@ -503,8 +494,8 @@ int eth_get_dev_conf_raw(openair0_device *device) {
return 0;
}
int eth_get_dev_conf_raw_IF4p5(openair0_device *device) {
int eth_get_dev_conf_raw_IF4p5(openair0_device_t *device)
{
// use for cc_id info
eth_state_t *eth = (eth_state_t*)device->priv;
radio/ETHERNET/eth_udp.c
+29 -28
View File
@@ -58,8 +58,8 @@ uint16_t pck_seq_num = 1;
uint16_t pck_seq_num_cur=0;
uint16_t pck_seq_num_prev=0;
int eth_socket_init_udp(openair0_device *device) {
int eth_socket_init_udp(openair0_device_t *device)
{
eth_state_t *eth = (eth_state_t*)device->priv;
eth_params_t *eth_params = device->eth_params;
@@ -192,8 +192,8 @@ int eth_socket_init_udp(openair0_device *device) {
return 0;
}
int trx_eth_read_udp_IF4p5(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc) {
int trx_eth_read_udp_IF4p5(openair0_device_t *device, openair0_timestamp_t *timestamp, void **buff, int nsamps, int cc)
{
// Read nblocks info from packet itself
int nblocks = nsamps;
int bytes_received=-1;
@@ -244,8 +244,8 @@ int trx_eth_read_udp_IF4p5(openair0_device *device, openair0_timestamp *timestam
return(bytes_received);
}
int trx_eth_write_udp_IF4p5(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags) {
int trx_eth_write_udp_IF4p5(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int cc, int flags)
{
int nblocks = nsamps;
int bytes_sent = 0;
@@ -294,10 +294,10 @@ int trx_eth_write_udp_IF4p5(openair0_device *device, openair0_timestamp timestam
void *trx_eth_write_udp_cmd(udpTXelem_t *udpTXelem) {
openair0_device *device=udpTXelem->device;
openair0_timestamp timestamp = udpTXelem->timestamp;
void *trx_eth_write_udp_cmd(udpTXelem_t *udpTXelem)
{
openair0_device_t *device=udpTXelem->device;
openair0_timestamp_t timestamp = udpTXelem->timestamp;
void **buff = udpTXelem->buff;
int nsamps = udpTXelem->nsamps;
int nant = udpTXelem->nant;
@@ -331,7 +331,7 @@ void *trx_eth_write_udp_cmd(udpTXelem_t *udpTXelem) {
// ECPRI Message type (1 byte)
*(uint8_t *)(buff2 + 1) = 64;
openair0_timestamp TS = timestamp + fhstate->TS0;
openair0_timestamp_t TS = timestamp + fhstate->TS0;
TS = (6*device->sampling_rate_ratio_d*TS)/device->sampling_rate_ratio_n;
TS -= device->txrx_offset;
int TSinc = (6*256*device->sampling_rate_ratio_d)/device->sampling_rate_ratio_n;
@@ -386,8 +386,8 @@ void *trx_eth_write_udp_cmd(udpTXelem_t *udpTXelem) {
return(NULL);
}
int trx_eth_write_udp(openair0_device *device, openair0_timestamp timestamp, void **buff, int fd_ind, int nsamps, int flags, int nant) {
int trx_eth_write_udp(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int fd_ind, int nsamps, int flags, int nant)
{
union udpTXReqUnion id = {.s={(uint64_t)timestamp,nsamps,0}};
notifiedFIFO_elt_t *req=newNotifiedFIFO_elt(sizeof(udpTXelem_t), id.p, device->utx[fd_ind]->resp,NULL);
udpTXelem_t * udptxelem=(udpTXelem_t *) NotifiedFifoData(req);
@@ -425,12 +425,13 @@ void *udp_write_thread(void *arg) {
return(NULL);
}
void *udp_read_thread(void *arg) {
openair0_timestamp TS;
void *udp_read_thread(void *arg)
{
openair0_timestamp_t TS;
int aid;
udp_ctx_t *u = (udp_ctx_t *)arg;
openair0_device *device=u->device;
openair0_device_t *device=u->device;
fhstate_t *fhstate = &device->fhstate;
char buffer[UDP_PACKET_SIZE_BYTES(256)];
int first_read=0;
@@ -457,7 +458,7 @@ void *udp_read_thread(void *arg) {
if (oai_exit)
break;
aid = *(uint16_t*)(&buffer[ECPRICOMMON_BYTES]);
TS = *(openair0_timestamp *)(&buffer[ECPRICOMMON_BYTES+ECPRIPCID_BYTES]);
TS = *(openair0_timestamp_t *)(&buffer[ECPRICOMMON_BYTES+ECPRIPCID_BYTES]);
// convert TS to samples, /6 for AW2S @ 30.72 Ms/s, this is converted for other sample rates in OAI application
TS = (device->sampling_rate_ratio_n*TS)/(device->sampling_rate_ratio_d*6);
AssertFatal(aid < 8,"Cannot handle more than 8 antennas, got aid %d\n",aid);
@@ -487,24 +488,24 @@ void *udp_read_thread(void *arg) {
return(0);
}
int trx_eth_read_udp(openair0_device *device, openair0_timestamp *timestamp, uint32_t **buff, int nsamps) {
int trx_eth_read_udp(openair0_device_t *device, openair0_timestamp_t *timestamp, uint32_t **buff, int nsamps)
{
fhstate_t *fhstate = &device->fhstate;
openair0_timestamp prev_read_TS= fhstate->TS_read;
volatile openair0_timestamp min_TS;
openair0_timestamp_t prev_read_TS= fhstate->TS_read;
volatile openair0_timestamp_t min_TS;
// block until FH is ready
while (fhstate->r[0] == 0 || fhstate->r[1] == 0 || fhstate->r[2] == 0 || fhstate->r[3] == 0 ||
fhstate->r[4] == 0 || fhstate->r[5] == 0 || fhstate->r[6] == 0 || fhstate->r[7] == 0) usleep(100);
// get minimum TS over all antennas
min_TS = (volatile openair0_timestamp)fhstate->TS[0];
min_TS = (volatile openair0_timestamp_t)fhstate->TS[0];
for (int i=1;i<device->openair0_cfg->rx_num_channels;i++) min_TS = min(min_TS,fhstate->TS[i]);
// poll/sleep until we accumulated enough samples on each antenna port
int count=0;
while (fhstate->first_read == 1 && min_TS < (fhstate->TS0+prev_read_TS + nsamps)) {
usleep(10);
min_TS = (volatile openair0_timestamp)fhstate->TS[0];
for (int i=1;i<device->openair0_cfg->rx_num_channels;i++) min_TS = min(min_TS,(volatile openair0_timestamp)fhstate->TS[i]);
min_TS = (volatile openair0_timestamp_t)fhstate->TS[0];
for (int i=1;i<device->openair0_cfg->rx_num_channels;i++) min_TS = min(min_TS,(volatile openair0_timestamp_t)fhstate->TS[i]);
count++;
}
if (fhstate->first_read == 0) {
@@ -524,8 +525,8 @@ int trx_eth_read_udp(openair0_device *device, openair0_timestamp *timestamp, uin
int trx_eth_ctlsend_udp(openair0_device *device, void *msg, ssize_t msg_len) {
int trx_eth_ctlsend_udp(openair0_device_t *device, void *msg, ssize_t msg_len)
{
return(sendto(((eth_state_t*)device->priv)->sockfdc,
msg,
msg_len,
@@ -535,8 +536,8 @@ int trx_eth_ctlsend_udp(openair0_device *device, void *msg, ssize_t msg_len) {
}
int trx_eth_ctlrecv_udp(openair0_device *device, void *msg, ssize_t msg_len) {
int trx_eth_ctlrecv_udp(openair0_device_t *device, void *msg, ssize_t msg_len)
{
return (recvfrom(((eth_state_t*)device->priv)->sockfdc,
msg,
msg_len,
radio/ETHERNET/ethernet_lib.c
+17 -38
View File
@@ -51,12 +51,9 @@ int num_devices_eth = 0;
struct sockaddr_in dest_addr[MAX_INST];
int dest_addr_len[MAX_INST];
int load_lib(openair0_device *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 *cfg, uint8_t flag);
int trx_eth_start(openair0_device *device)
int trx_eth_start(openair0_device_t *device)
{
eth_state_t *eth = (eth_state_t*)device->priv;
@@ -225,8 +222,7 @@ int trx_eth_start(openair0_device *device)
return 0;
}
void trx_eth_end(openair0_device *device)
void trx_eth_end(openair0_device_t *device)
{
eth_state_t *eth = (eth_state_t*)device->priv;
/* destroys socket only for the processes that call the eth_end fuction-- shutdown() for beaking the pipe */
@@ -239,9 +235,8 @@ void trx_eth_end(openair0_device *device)
}
}
int trx_eth_stop(openair0_device *device) {
int trx_eth_stop(openair0_device_t *device)
{
eth_state_t *eth = (eth_state_t*)device->priv;
if (eth->flags == ETH_UDP_IF5_ECPRI_MODE) {
@@ -251,38 +246,32 @@ int trx_eth_stop(openair0_device *device) {
return(0);
}
int trx_eth_set_freq(openair0_device* device, openair0_config_t *openair0_cfg)
int trx_eth_set_freq(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
return(0);
}
int trx_eth_set_gains(openair0_device* device, openair0_config_t *openair0_cfg)
int trx_eth_set_gains(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
return(0);
}
int trx_eth_get_stats(openair0_device* device)
int trx_eth_get_stats(openair0_device_t *device)
{
return(0);
}
int trx_eth_reset_stats(openair0_device* device)
int trx_eth_reset_stats(openair0_device_t *device)
{
return(0);
}
int trx_eth_write_init(openair0_device *device)
int trx_eth_write_init(openair0_device_t *device)
{
return 0;
}
int ethernet_tune(openair0_device *device,
unsigned int option,
int value)
int ethernet_tune(openair0_device_t *device, unsigned int option, int value)
{
eth_state_t *eth = (eth_state_t*)device->priv;
struct timeval timeout;
@@ -471,10 +460,7 @@ int ethernet_tune(openair0_device *device,
return 0;
}
int transport_init(openair0_device *device,
openair0_config_t *openair0_cfg,
eth_params_t * eth_params )
int transport_init(openair0_device_t *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params)
{
eth_state_t *eth = (eth_state_t*)malloc(sizeof(eth_state_t));
memset(eth, 0, sizeof(eth_state_t));
@@ -496,7 +482,7 @@ int transport_init(openair0_device *device,
eth->num_fd = 1;
printf("[ETHERNET]: Initializing openair0_device for %s ...\n", ((device->host_type == RAU_HOST) ? "RAU": "RRU"));
printf("[ETHERNET]: Initializing openair0_device_t for %s ...\n", ((device->host_type == RAU_HOST) ? "RAU" : "RRU"));
printf("[ETHERNET]: num_fd %d\n",eth->num_fd);
device->Mod_id = 0;//num_devices_eth++;
device->transp_type = ETHERNET_TP;
@@ -577,8 +563,7 @@ unsigned short calc_csum (unsigned short *buf,
return ~sum;
}
void dump_dev(openair0_device *device)
void dump_dev(openair0_device_t *device)
{
eth_state_t *eth = (eth_state_t*)device->priv;
@@ -594,27 +579,21 @@ void dump_dev(openair0_device *device)
}
void inline dump_txcounters(openair0_device *device)
void inline dump_txcounters(openair0_device_t *device)
{
eth_state_t *eth = (eth_state_t*)device->priv;
printf(" Ethernet device interface %i, tx counters:\n" ,device->openair0_cfg->Mod_id);
printf(" Sent packets: %llu send errors: %i\n", (long long unsigned int)eth->tx_count, eth->num_tx_errors);
}
void inline dump_rxcounters(openair0_device *device)
void inline dump_rxcounters(openair0_device_t *device)
{
eth_state_t *eth = (eth_state_t*)device->priv;
printf(" Ethernet device interface %i rx counters:\n" ,device->openair0_cfg->Mod_id);
printf(" Received packets: %llu missed packets errors: %i\n", (long long unsigned int)eth->rx_count, eth->num_underflows);
}
void inline dump_buff(openair0_device *device,
char *buff,
unsigned int tx_rx_flag,
int nsamps)
void inline dump_buff(openair0_device_t *device, char *buff, unsigned int tx_rx_flag, int nsamps)
{
char *strptr;
eth_state_t *eth = (eth_state_t*)device->priv;
radio/ETHERNET/ethernet_lib.h
+40 -35
View File
@@ -51,7 +51,7 @@
#include "if_defs.h"
#define ECPRICOMMON_BYTES 4
#define ECPRIPCID_BYTES 2
#define APP_HEADER_SIZE_BYTES (ECPRICOMMON_BYTES + ECPRIPCID_BYTES + sizeof(openair0_timestamp))
#define APP_HEADER_SIZE_BYTES (ECPRICOMMON_BYTES + ECPRIPCID_BYTES + sizeof(openair0_timestamp_t))
#define ECPRIREV 1 // ECPRI Version 1, C=0 - single ECPRI message per OAI TX packet
/*!\brief opaque ethernet data structure */
@@ -111,11 +111,11 @@ typedef struct {
int num_rx_errors;
/*!\brief number of errors in interface's transmitter */
int num_tx_errors;
/*!\brief current TX timestamp */
openair0_timestamp tx_current_ts;
/*!\brief socket file desc */
openair0_timestamp rx_current_ts;
/*!\brief current TX timestamp */
openair0_timestamp_t tx_current_ts;
/*!\brief socket file desc */
openair0_timestamp_t rx_current_ts;
/*!\brief actual number of samples transmitted */
uint64_t tx_actual_nsamps;
/*!\brief actual number of samples received */
@@ -150,8 +150,8 @@ typedef struct {
uint16_t seq_num ;
/*!\brief antenna port used to resynchronize */
uint16_t antenna_id;
/*!\brief packet's timestamp */
openair0_timestamp timestamp;
/*!\brief packet's timestamp */
openair0_timestamp_t timestamp;
} header_t;
/*!\brief different options for ethernet tuning in socket and driver level */
@@ -204,8 +204,8 @@ typedef struct {
} iqoai_t ;
typedef struct udpTXelem_s {
openair0_device *device;
openair0_timestamp timestamp;
openair0_device_t *device;
openair0_timestamp_t timestamp;
void **buff;
int fd_ind;
int nant;
@@ -227,17 +227,17 @@ union udpTXReqUnion {
void dump_packet(char *title, unsigned char* pkt, int bytes, unsigned int tx_rx_flag);
unsigned short calc_csum (unsigned short *buf, int nwords);
void dump_dev(openair0_device *device);
/*void inline dump_buff(openair0_device *device, char *buff,unsigned int tx_rx_flag,int nsamps);
void inline dump_rxcounters(openair0_device *device);
void inline dump_txcounters(openair0_device *device);
void dump_dev(openair0_device_t *device);
/*void inline dump_buff(openair0_device_t *device, char *buff,unsigned int tx_rx_flag,int nsamps);
void inline dump_rxcounters(openair0_device_t *device);
void inline dump_txcounters(openair0_device_t *device);
*/
void dump_iqs(char * buff, int iq_cnt);
void *udp_read_thread(void *arg);
void *udp_write_thread(void *arg);
/*! \fn int ethernet_tune (openair0_device *device, unsigned int option, int value);
/*! \fn int ethernet_tune (openair0_device_t *device, unsigned int option, int value);
* \brief this function allows you to configure certain ethernet parameters in socket or device level
* \param[in] device device which bears the socket
* \param[in] option of parameter to configure
@@ -246,34 +246,39 @@ void *udp_write_thread(void *arg);
* \note
* @ingroup _oai
*/
int ethernet_tune(openair0_device *device, unsigned int option, int value);
int ethernet_tune(openair0_device_t *device, unsigned int option, int value);
/*! \fn int eth_socket_init_udp(openair0_device *device)
/*! \fn int eth_socket_init_udp(openair0_device_t *device)
* \brief initialization of UDP Socket to communicate with one destination
* \param[in] device openair device for which the socket will be created
* \return 0 on success, otherwise -1
* \note
* @ingroup _oai
*/
int eth_socket_init_udp(openair0_device *device);
int trx_eth_write_udp(openair0_device *device, openair0_timestamp timestamp, void **buf, int fd_ind, int nsamps, int flags,int nant);
int trx_eth_read_udp(openair0_device *device, openair0_timestamp *timestamp, uint32_t **buff, int nsamps);
int eth_socket_init_udp(openair0_device_t *device);
int trx_eth_write_udp(openair0_device_t *device,
openair0_timestamp_t timestamp,
void **buf,
int fd_ind,
int nsamps,
int flags,
int nant);
int trx_eth_read_udp(openair0_device_t *device, openair0_timestamp_t *timestamp, uint32_t **buff, int nsamps);
int eth_socket_init_raw(openair0_device_t *device);
int trx_eth_write_raw(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int cc, int flags);
int trx_eth_read_raw(openair0_device_t *device, openair0_timestamp_t *timestamp, void **buff, int nsamps, int cc);
int trx_eth_write_raw_IF4p5(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int cc, int flags);
int trx_eth_read_raw_IF4p5(openair0_device_t *device, openair0_timestamp_t *timestamp, void **buff, int nsamps, int cc);
int trx_eth_read_raw_IF5_mobipass(openair0_device_t *device, openair0_timestamp_t *timestamp, void **buff, int nsamps, int cc);
int trx_eth_write_udp_IF4p5(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int cc, int flags);
int trx_eth_read_udp_IF4p5(openair0_device_t *device, openair0_timestamp_t *timestamp, void **buff, int nsamps, int cc);
int trx_eth_ctlsend_udp(openair0_device_t *device, void *msg, ssize_t msg_len);
int trx_eth_ctlrecv_udp(openair0_device_t *device, void *msg, ssize_t msg_len);
int eth_socket_init_raw(openair0_device *device);
int trx_eth_write_raw(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps,int cc, int flags);
int trx_eth_read_raw(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc);
int trx_eth_write_raw_IF4p5(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps,int cc, int flags);
int trx_eth_read_raw_IF4p5(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc);
int trx_eth_read_raw_IF5_mobipass(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc);
int trx_eth_write_udp_IF4p5(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps,int cc, int flags);
int trx_eth_read_udp_IF4p5(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc);
int trx_eth_ctlsend_udp(openair0_device *device, void *msg, ssize_t msg_len);
int trx_eth_ctlrecv_udp(openair0_device *device, void *msg, ssize_t msg_len);
int eth_get_dev_conf_raw(openair0_device *device);
int eth_set_dev_conf_raw(openair0_device *device);
int eth_get_dev_conf_raw_IF4p5(openair0_device *device);
int eth_set_dev_conf_raw_IF4p5(openair0_device *device);
int eth_get_dev_conf_raw(openair0_device_t *device);
int eth_set_dev_conf_raw(openair0_device_t *device);
int eth_get_dev_conf_raw_IF4p5(openair0_device_t *device);
int eth_set_dev_conf_raw_IF4p5(openair0_device_t *device);
#endif
radio/IRIS/iris_lib.cpp
+24 -21
View File
@@ -71,14 +71,15 @@ extern "C" {
//! rx count
int64_t rx_count;
//! timestamp of RX packet
openair0_timestamp rx_timestamp;
openair0_timestamp_t rx_timestamp;
} iris_state_t;
}
/*! \brief Called to start the Iris lime transceiver. Return 0 if OK, < 0 if error
@param device pointer to the device structure specific to the RF hardware target
*/
static int trx_iris_start(openair0_device *device) {
static int trx_iris_start(openair0_device_t *device)
{
iris_state_t *s = (iris_state_t *) device->priv;
long long timeNs = s->iris[0]->getHardwareTime("") + 500000;
@@ -97,7 +98,8 @@ static int trx_iris_start(openair0_device *device) {
/*! \brief Stop Iris
* \param card refers to the hardware index to use
*/
int trx_iris_stop(openair0_device *device) {
int trx_iris_stop(openair0_device_t *device)
{
iris_state_t *s = (iris_state_t *) device->priv;
int r;
for (r = 0; r < s->device_num; r++) {
@@ -110,7 +112,8 @@ int trx_iris_stop(openair0_device *device) {
/*! \brief Terminate operation of the Iris lime transceiver -- free all associated resources
* \param device the hardware to use
*/
static void trx_iris_end(openair0_device *device) {
static void trx_iris_end(openair0_device_t *device)
{
LOG_I(HW, "Closing Iris device.\n");
trx_iris_stop(device);
iris_state_t *s = (iris_state_t *) device->priv;
@@ -133,7 +136,7 @@ static void trx_iris_end(openair0_device *device) {
static int
trx_iris_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags)
trx_iris_write(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int cc, int flags)
{
using namespace std::chrono;
@@ -209,7 +212,8 @@ trx_iris_write(openair0_device *device, openair0_timestamp timestamp, void **buf
* \param antenna_id Index of antenna for which to receive samples
* \returns the number of sample read
*/
static int trx_iris_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
static int trx_iris_read(openair0_device_t *device, openair0_timestamp_t *ptimestamp, void **buff, int nsamps, int cc)
{
int ret = 0;
static long long nextTime;
static bool nextTimeValid = false;
@@ -304,7 +308,8 @@ static int trx_iris_read(openair0_device *device, openair0_timestamp *ptimestamp
/*! \brief Get current timestamp of Iris
* \param device the hardware to use
*/
openair0_timestamp get_iris_time(openair0_device *device) {
openair0_timestamp_t get_iris_time(openair0_device_t *device)
{
iris_state_t *s = (iris_state_t *) device->priv;
return SoapySDR::timeNsToTicks(s->iris[0]->getHardwareTime(""), s->sample_rate);
}
@@ -317,9 +322,9 @@ static bool is_equal(double a, double b) {
return std::fabs(a - b) < std::numeric_limits<double>::epsilon();
}
void *set_freq_thread(void *arg) {
openair0_device *device = (openair0_device *) arg;
void *set_freq_thread(void *arg)
{
openair0_device_t *device = (openair0_device_t *) arg;
iris_state_t *s = (iris_state_t *) device->priv;
int r, i;
printf("Setting Iris TX Freq %f, RX Freq %f\n", device->openair0_cfg[0].tx_freq[0],
@@ -344,7 +349,7 @@ void *set_freq_thread(void *arg) {
* \param dummy dummy variable not used
* \returns 0 in success
*/
int trx_iris_set_freq(openair0_device *device, openair0_config_t *openair0_cfg)
int trx_iris_set_freq(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
iris_state_t *s = (iris_state_t *)device->priv;
int r, i;
@@ -369,7 +374,7 @@ int trx_iris_set_freq(openair0_device *device, openair0_config_t *openair0_cfg)
* \param openair0_cfg RF frontend parameters set by application
* \returns 0 in success
*/
int trx_iris_set_gains(openair0_device *device,
int trx_iris_set_gains(openair0_device_t *device,
openair0_config_t *openair0_cfg) {
iris_state_t *s = (iris_state_t *) device->priv;
int r;
@@ -448,23 +453,21 @@ void set_rx_gain_offset(openair0_config_t *openair0_cfg, int chain_index, int bw
* \param device the hardware to use
* \returns 0 on success
*/
int trx_iris_get_stats(openair0_device *device) {
int trx_iris_get_stats(openair0_device_t *device)
{
return (0);
}
/*! \brief Reset the Iris statistics
* \param device the hardware to use
* \returns 0 on success
*/
int trx_iris_reset_stats(openair0_device *device) {
int trx_iris_reset_stats(openair0_device_t *device)
{
return (0);
}
int trx_iris_write_init(openair0_device *device)
int trx_iris_write_init(openair0_device_t *device)
{
return 0;
}
@@ -475,8 +478,8 @@ extern "C" {
* \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) {
int device_init(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
int bw_gain_adjust = 0;
openair0_cfg[0].rx_gain_calib_table = calib_table_iris;
iris_state_t *s = (iris_state_t *) calloc(1, sizeof(*s));
radio/LMSSDR/lms_lib.cpp
+23 -21
View File
@@ -72,7 +72,8 @@ int write_output(const char *fname,const char *vname,void *data,int length,int d
\param flags Ignored for the moment
\returns 0 on success
*/
int trx_lms_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int antenna_id, int flags) {
int trx_lms_write(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int antenna_id, int flags)
{
timestamp -= device->openair0_cfg->command_line_sample_advance - device->openair0_cfg->tx_sample_advance;
lms_stream_meta_t meta;
meta.waitForTimestamp = true;
@@ -93,8 +94,8 @@ int trx_lms_write(openair0_device *device, openair0_timestamp timestamp, void **
* \param antenna_id Index of antenna port
* \returns number of samples read
*/
int trx_lms_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int antenna_id) {
int trx_lms_read(openair0_device_t *device, openair0_timestamp_t *ptimestamp, void **buff, int nsamps, int antenna_id)
{
lms_stream_meta_t meta;
meta.waitForTimestamp = false;
meta.flushPartialPacket = false;
@@ -140,7 +141,8 @@ void set_rx_gain_offset(openair0_config_t *openair0_cfg, int chain_index) {
* \param openair0_cfg openair0 Config structure
* \returns 0 in success, -1 on error
*/
int trx_lms_set_gains(openair0_device* device, openair0_config_t *openair0_cfg) {
int trx_lms_set_gains(openair0_device_t* device, openair0_config_t *openair0_cfg)
{
int ret = 0;
if (openair0_cfg->rx_gain[0] > 70+openair0_cfg->rx_gain_offset[0]) {
@@ -158,8 +160,8 @@ int trx_lms_set_gains(openair0_device* device, openair0_config_t *openair0_cfg)
* \param device the hardware to use
* \returns 0 on success
*/
int trx_lms_start(openair0_device *device){
int trx_lms_start(openair0_device_t *device)
{
lms_info_str_t list[16]={0};
int n= LMS_GetDeviceList(list);
@@ -269,7 +271,8 @@ int trx_lms_start(openair0_device *device){
* \param card Index of the RF card to use
* \returns 0 on success
*/
int trx_lms_stop(openair0_device *device) {
int trx_lms_stop(openair0_device_t *device)
{
LMS_StopStream(&rx_stream);
LMS_StopStream(&tx_stream);
LMS_DestroyStream(lms_device,&rx_stream);
@@ -283,7 +286,8 @@ int trx_lms_stop(openair0_device *device) {
* \param openair0_cfg openair0 Config structure (ignored. It is there to comply with RF common API)
* \returns 0 in success
*/
int trx_lms_set_freq(openair0_device* device, openair0_config_t *openair0_cfg) {
int trx_lms_set_freq(openair0_device_t* device, openair0_config_t *openair0_cfg)
{
//Control port must be connected
LMS_SetLOFrequency(lms_device,LMS_CH_TX,0,openair0_cfg->tx_freq[0]);
LMS_SetLOFrequency(lms_device,LMS_CH_RX,0,openair0_cfg->rx_freq[0]);
@@ -322,45 +326,43 @@ rx_gain_calib_table_t calib_table_lmssdr[] = {
* \returns 0 in success
*/
int trx_lms_get_stats(openair0_device* device) {
int trx_lms_get_stats(openair0_device_t* device)
{
return(0);
}
/*! \brief Reset LMSSDR Statistics
* \param device the hardware to use
* \returns 0 in success
*/
int trx_lms_reset_stats(openair0_device* device) {
int trx_lms_reset_stats(openair0_device_t* device)
{
return(0);
}
/*! \brief Terminate operation of the LMSSDR transceiver -- free all associated resources
* \param device the hardware to use
*/
void trx_lms_end(openair0_device *device) {
void trx_lms_end(openair0_device_t *device)
{
}
int trx_lms_write_init(openair0_device *device)
int trx_lms_write_init(openair0_device_t *device)
{
return 0;
}
extern "C" {
/*! \brief Initialize Openair LMSSDR 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){
int device_init(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
device->type=LMSSDR_DEV;
printf("LMSSDR: Initializing openair0_device for %s ...\n", ((device->host_type == RAU_HOST) ? "RAU": "RRU"));
printf("LMSSDR: Initializing openair0_device_t for %s ...\n", ((device->host_type == RAU_HOST) ? "RAU": "RRU"));
switch ((int)openair0_cfg[0].sample_rate) {
case 30720000:
radio/LMSSDR/sodera_lib.cpp
+21 -27
View File
@@ -87,7 +87,7 @@ typedef struct
int64_t tx_count;
int64_t rx_count;
openair0_timestamp rx_timestamp;
openair0_timestamp_t rx_timestamp;
} sodera_t;
@@ -131,7 +131,7 @@ uint16_t SPI_read(LMScomms* dataPort, uint16_t address)
return 0;
}
static int trx_sodera_start(openair0_device *device)
static int trx_sodera_start(openair0_device_t *device)
{
sodera_t *s = (sodera_t*)device->priv;
@@ -182,7 +182,7 @@ static int trx_sodera_start(openair0_device *device)
return 0;
}
static void trx_sodera_end(openair0_device *device)
static void trx_sodera_end(openair0_device_t *device)
{
sodera_t *s = (sodera_t*)device->priv;
@@ -193,7 +193,7 @@ static void trx_sodera_end(openair0_device *device)
}
static int trx_sodera_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags)
static int trx_sodera_write(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int cc, int flags)
{
sodera_t *s = (sodera_t*)device->priv;
@@ -203,7 +203,7 @@ static int trx_sodera_write(openair0_device *device, openair0_timestamp timestam
#define DEBUG_READ 1
static int trx_sodera_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc)
static int trx_sodera_read(openair0_device_t *device, openair0_timestamp_t *ptimestamp, void **buff, int nsamps, int cc)
{
sodera_t *s = (sodera_t*)device->priv;
int samples_received=0,i,j;
@@ -350,19 +350,18 @@ static bool is_equal(double a, double b)
return fabs(a-b) < 1e-6;
}
int trx_sodera_set_freq(openair0_device* device, openair0_config_t *openair0_cfg, int dummy) {
int trx_sodera_set_freq(openair0_device_t *device, openair0_config_t *openair0_cfg, int dummy)
{
sodera_t *s = (sodera_t*)device->priv;
// s->usrp->set_tx_freq(openair0_cfg[0].tx_freq[0]);
// s->usrp->set_rx_freq(openair0_cfg[0].rx_freq[0]);
return(0);
return (0);
}
int openair0_set_rx_frequencies(openair0_device* device, openair0_config_t *openair0_cfg) {
int openair0_set_rx_frequencies(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
sodera_t *s = (sodera_t*)device->priv;
static int first_call=1;
static double rf_freq,diff;
@@ -374,13 +373,11 @@ int openair0_set_rx_frequencies(openair0_device* device, openair0_config_t *open
// rf_freq=openair0_cfg[0].rx_freq[0];
// s->usrp->set_rx_freq(rx_tune_req);
return(0);
return (0);
}
int trx_sodera_set_gains(openair0_device* device,
openair0_config_t *openair0_cfg) {
int trx_sodera_set_gains(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
sodera_t *s = (sodera_t*)device->priv;
// s->usrp->set_tx_gain(openair0_cfg[0].tx_gain[0]);
@@ -456,20 +453,17 @@ void set_rx_gain_offset(openair0_config_t *openair0_cfg, int chain_index,int bw_
}
int trx_sodera_get_stats(openair0_device* device) {
return(0);
}
int trx_sodera_reset_stats(openair0_device* device) {
return(0);
int trx_sodera_get_stats(openair0_device_t *device)
{
return (0);
}
int trx_sodera_reset_stats(openair0_device_t *device)
{
return (0);
}
int openair0_dev_init_sodera(openair0_device* device, openair0_config_t *openair0_cfg)
int openair0_dev_init_sodera(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
sodera_t *s=&sodera_state;
radio/USRP/usrp_lib.cpp
+42 -30
View File
@@ -104,7 +104,7 @@ typedef struct {
//int first_tx;
//int first_rx;
//! timestamp of RX packet
openair0_timestamp rx_timestamp;
openair0_timestamp_t rx_timestamp;
} usrp_state_t;
//void print_notes(void)
@@ -145,7 +145,8 @@ int check_ref_locked(usrp_state_t *s,size_t mboard) {
return ref_locked;
}
static int sync_to_gps(openair0_device *device) {
static int sync_to_gps(openair0_device_t *device)
{
//uhd::set_thread_priority_safe();
//std::string args;
//Set up program options
@@ -266,7 +267,7 @@ static int sync_to_gps(openair0_device *device) {
#define ATR_XX 0x20 //data[5]
#define MAN_MASK ATR_MASK ^ 0xFFF // manually controlled pins
static void trx_usrp_start_interdigital_gpio(openair0_device *device, usrp_state_t *s)
static void trx_usrp_start_interdigital_gpio(openair0_device_t *device, usrp_state_t *s)
{
AssertFatal(device->type == USRP_X400_DEV,
"interdigital frontend device for beam management can only be used together with an X400\n");
@@ -280,7 +281,7 @@ static void trx_usrp_start_interdigital_gpio(openair0_device *device, usrp_state
s->usrp->set_gpio_attr(s->gpio_bank, "OUT", (1 << 4), 0x1c);
}
static void trx_usrp_start_generic_gpio(openair0_device *device, usrp_state_t *s)
static void trx_usrp_start_generic_gpio(openair0_device_t *device, usrp_state_t *s)
{
// setup GPIO for TDD, GPIO(4) = ATR_RX
// set data direction register (DDR) to output
@@ -299,7 +300,8 @@ static void trx_usrp_start_generic_gpio(openair0_device *device, usrp_state_t *s
/*! \brief Called to start the USRP transceiver. Return 0 if OK, < 0 if error
@param device pointer to the device structure specific to the RF hardware target
*/
static int trx_usrp_start(openair0_device *device) {
static int trx_usrp_start(openair0_device_t *device)
{
usrp_state_t *s = (usrp_state_t *)device->priv;
s->gpio_bank = (char *) "FP0"; //good for B210, X310 and N310
@@ -383,7 +385,8 @@ static void trx_usrp_write_reset(openair0_thread_t *wt);
/*! \brief Terminate operation of the USRP transceiver -- free all associated resources
* \param device the hardware to use
*/
static void trx_usrp_end(openair0_device *device) {
static void trx_usrp_end(openair0_device_t *device)
{
if (device == NULL)
return;
@@ -423,12 +426,13 @@ static void trx_usrp_end(openair0_device *device) {
@param antenna_id index of the antenna if the device has multiple antennas
@param flags flags must be set to true if timestamp parameter needs to be applied
*/
static int trx_usrp_write(openair0_device *device,
openair0_timestamp timestamp,
static int trx_usrp_write(openair0_device_t *device,
openair0_timestamp_t timestamp,
void **buff,
int nsamps,
int cc,
int flags) {
int flags)
{
int ret=0;
usrp_state_t *s = (usrp_state_t *)device->priv;
timestamp -= device->openair0_cfg->command_line_sample_advance + device->openair0_cfg->tx_sample_advance;
@@ -562,22 +566,23 @@ static int trx_usrp_write(openair0_device *device,
@param antenna_id index of the antenna if the device has multiple antennas
@param flags flags must be set to true if timestamp parameter needs to be applied
*/
void *trx_usrp_write_thread(void * arg){
void *trx_usrp_write_thread(void * arg)
{
int ret=0;
openair0_device *device=(openair0_device *)arg;
openair0_device_t *device=(openair0_device_t *)arg;
openair0_thread_t *write_thread = &device->write_thread;
openair0_write_package_t *write_package = write_thread->write_package;
usrp_state_t *s;
int nsamps2; // aligned to upper 32 or 16 byte boundary
int start;
openair0_timestamp timestamp;
void **buff;
int nsamps;
int cc;
signed char first_packet;
signed char last_packet;
int flags_gpio;
openair0_timestamp_t timestamp;
void **buff;
int nsamps;
int cc;
signed char first_packet;
signed char last_packet;
int flags_gpio;
printf("trx_usrp_write_thread started on cpu %d\n",sched_getcpu());
while(1){
@@ -659,8 +664,8 @@ void *trx_usrp_write_thread(void * arg){
return NULL;
}
int trx_usrp_write_init(openair0_device *device){
int trx_usrp_write_init(openair0_device_t *device)
{
//uhd::set_thread_priority_safe(1.0);
openair0_thread_t *write_thread = &device->write_thread;
printf("initializing tx write thread\n");
@@ -705,7 +710,8 @@ static void trx_usrp_write_reset(openair0_thread_t *wt) {
* \param antenna_id Index of antenna for which to receive samples
* \returns the number of sample read
*/
static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
static int trx_usrp_read(openair0_device_t *device, openair0_timestamp_t *ptimestamp, void **buff, int nsamps, int cc)
{
usrp_state_t *s = (usrp_state_t *)device->priv;
int samples_received=0;
int nsamps2; // aligned to upper 32 or 16 byte boundary
@@ -817,7 +823,7 @@ static bool is_equal(double a, double b) {
}
void *freq_thread(void *arg) {
openair0_device *device=(openair0_device *)arg;
openair0_device_t *device=(openair0_device_t *)arg;
usrp_state_t *s = (usrp_state_t *)device->priv;
uhd::tune_request_t tx_tune_req(device->openair0_cfg[0].tx_freq[0],
device->openair0_cfg[0].tune_offset);
@@ -833,7 +839,7 @@ void *freq_thread(void *arg) {
* \param dummy dummy variable not used
* \returns 0 in success
*/
int trx_usrp_set_freq(openair0_device *device, openair0_config_t *openair0_cfg)
int trx_usrp_set_freq(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
usrp_state_t *s = (usrp_state_t *)device->priv;
printf("Setting USRP TX Freq %f, RX Freq %f, tune_offset: %f\n", openair0_cfg[0].tx_freq[0], openair0_cfg[0].rx_freq[0], openair0_cfg[0].tune_offset);
@@ -851,7 +857,8 @@ int trx_usrp_set_freq(openair0_device *device, openair0_config_t *openair0_cfg)
* \param openair0_cfg RF frontend parameters set by application
* \returns 0 in success
*/
int openair0_set_rx_frequencies(openair0_device *device, openair0_config_t *openair0_cfg) {
int openair0_set_rx_frequencies(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
usrp_state_t *s = (usrp_state_t *)device->priv;
uhd::tune_request_t rx_tune_req(openair0_cfg[0].rx_freq[0], openair0_cfg[0].tune_offset);
printf("In openair0_set_rx_frequencies, freq: %f, tune offset: %f\n",
@@ -867,8 +874,9 @@ int openair0_set_rx_frequencies(openair0_device *device, openair0_config_t *open
* \param openair0_cfg RF frontend parameters set by application
* \returns 0 in success
*/
int trx_usrp_set_gains(openair0_device *device,
openair0_config_t *openair0_cfg) {
int trx_usrp_set_gains(openair0_device_t *device,
openair0_config_t *openair0_cfg)
{
usrp_state_t *s = (usrp_state_t *)device->priv;
::uhd::gain_range_t gain_range_tx = s->usrp->get_tx_gain_range(0);
s->usrp->set_tx_gain(gain_range_tx.stop()-openair0_cfg[0].tx_gain[0]);
@@ -892,7 +900,8 @@ int trx_usrp_set_gains(openair0_device *device,
/*! \brief Stop USRP
* \param card refers to the hardware index to use
*/
int trx_usrp_stop(openair0_device *device) {
int trx_usrp_stop(openair0_device_t *device)
{
return(0);
}
@@ -1012,7 +1021,8 @@ void set_rx_gain_offset(openair0_config_t *openair0_cfg, int chain_index,int bw_
* \param device the hardware to use
* \returns 0 on success
*/
int trx_usrp_get_stats(openair0_device *device) {
int trx_usrp_get_stats(openair0_device_t *device)
{
return(0);
}
@@ -1020,7 +1030,8 @@ int trx_usrp_get_stats(openair0_device *device) {
* \param device the hardware to use
* \returns 0 on success
*/
int trx_usrp_reset_stats(openair0_device *device) {
int trx_usrp_reset_stats(openair0_device_t *device)
{
return(0);
}
@@ -1047,7 +1058,8 @@ static void usrp_sync_pps(usrp_state_t *s)
}
extern "C" {
int device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
int device_init(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
LOG_I(HW, "openair0_cfg[0].sdr_addrs == '%s'\n", openair0_cfg[0].sdr_addrs);
LOG_I(HW, "openair0_cfg[0].clock_source == '%d' (internal = %d, external = %d)\n", openair0_cfg[0].clock_source,internal,external);
usrp_state_t *s ;
radio/emulator/rf_emulator.c
+11 -11
View File
@@ -115,7 +115,7 @@ static void *emulator_timing_job(void *arg)
/*! \brief Called to start the RF transceiver. Return 0 if OK, < 0 if error
* \param device pointer to the device structure specific to the RF hardware target
*/
static int emulator_start(openair0_device *device)
static int emulator_start(openair0_device_t *device)
{
// Start the timing thread and the noise device
emulator_state_t *emulator_state = (emulator_state_t *)device->priv;
@@ -163,7 +163,7 @@ static int emulator_start(openair0_device *device)
* \param device pointer to the device structure specific to the RF hardware target
* \returns 0 on success
*/
int emulator_get_stats(openair0_device *device)
int emulator_get_stats(openair0_device_t *device)
{
return (0);
}
@@ -172,7 +172,7 @@ int emulator_get_stats(openair0_device *device)
* \param device pointer to the device structure specific to the RF hardware target
* \returns 0 on success
*/
int emulator_reset_stats(openair0_device *device)
int emulator_reset_stats(openair0_device_t *device)
{
return (0);
}
@@ -180,7 +180,7 @@ int emulator_reset_stats(openair0_device *device)
/*! \brief Terminate operation of the RF transceiver -- free all associated resources (if any)
* \param pointer to the device structure specific to the RF hardware target
*/
static void emulator_end(openair0_device *device)
static void emulator_end(openair0_device_t *device)
{
// Stop the timing thread and the noise device
emulator_state_t *emulator_state = (emulator_state_t *)device->priv;
@@ -197,7 +197,7 @@ static void emulator_end(openair0_device *device)
/*! \brief Stop RF
* \param device pointer to the device structure specific to the RF hardware target
*/
int emulator_stop(openair0_device *device)
int emulator_stop(openair0_device_t *device)
{
return (0);
}
@@ -207,7 +207,7 @@ int emulator_stop(openair0_device *device)
* \param openair0_cfg RF frontend parameters set by application
* \returns 0 in success
*/
int emulator_set_gains(openair0_device *device, openair0_config_t *openair0_cfg)
int emulator_set_gains(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
return (0);
}
@@ -217,12 +217,12 @@ int emulator_set_gains(openair0_device *device, openair0_config_t *openair0_cfg)
* \param openair0_cfg RF frontend parameters set by application
* \returns 0 in success
*/
int emulator_set_freq(openair0_device *device, openair0_config_t *openair0_cfg)
int emulator_set_freq(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
return (0);
}
int emulator_write_init(openair0_device *device)
int emulator_write_init(openair0_device_t *device)
{
return (0);
}
@@ -235,7 +235,7 @@ int emulator_write_init(openair0_device *device)
* \param nbAnt number of antennas
* \param flags flags must be set to true if timestamp parameter needs to be applied
*/
static int emulator_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int nbAnt, int flags)
static int emulator_write(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int nbAnt, int flags)
{
emulator_state_t *emulator_state = (emulator_state_t *)device->priv;
@@ -297,7 +297,7 @@ static void read_noise(void *buff, int nsamps)
* \param nbAnt number of antennas
* \returns the number of samples read
*/
static int emulator_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int nbAnt)
static int emulator_read(openair0_device_t *device, openair0_timestamp_t *ptimestamp, void **buff, int nsamps, int nbAnt)
{
emulator_state_t *emulator_state = (emulator_state_t *)device->priv;
@@ -339,7 +339,7 @@ static void emulator_readconfig(emulator_state_t *emulator_state)
AssertFatal(ret >= 0, "configuration couldn't be performed\n");
}
int device_init(openair0_device *device, openair0_config_t *openair0_cfg)
int device_init(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
LOG_I(HW, "This is emulator RF that does nothing\n");
radio/fhi_72/oran.h
+1 -1
View File
@@ -28,7 +28,7 @@ void oran_fh_if4p5_south_out(RU_t *ru, int frame, int slot, uint64_t timestamp);
void oran_fh_if4p5_south_in(RU_t *ru, int *frame, int *slot);
int transport_init(openair0_device *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params);
int transport_init(openair0_device_t *device, openair0_config_t *openair0_cfg, eth_params_t *eth_params);
typedef struct {
eth_state_t e;
radio/fhi_72/oran_isolate.c
+13 -13
View File
@@ -55,7 +55,7 @@ typedef struct {
notifiedFIFO_t oran_sync_fifo;
int trx_oran_start(openair0_device *device)
int trx_oran_start(openair0_device_t *device)
{
printf("ORAN: %s\n", __FUNCTION__);
@@ -71,14 +71,14 @@ int trx_oran_start(openair0_device *device)
return 0;
}
void trx_oran_end(openair0_device *device)
void trx_oran_end(openair0_device_t *device)
{
printf("ORAN: %s\n", __FUNCTION__);
oran_eth_state_t *s = device->priv;
xran_close(s->oran_priv);
}
int trx_oran_stop(openair0_device *device)
int trx_oran_stop(openair0_device_t *device)
{
printf("ORAN: %s\n", __FUNCTION__);
oran_eth_state_t *s = device->priv;
@@ -91,19 +91,19 @@ int trx_oran_stop(openair0_device *device)
return (0);
}
int trx_oran_set_freq(openair0_device *device, openair0_config_t *openair0_cfg)
int trx_oran_set_freq(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
printf("ORAN: %s\n", __FUNCTION__);
return (0);
}
int trx_oran_set_gains(openair0_device *device, openair0_config_t *openair0_cfg)
int trx_oran_set_gains(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
printf("ORAN: %s\n", __FUNCTION__);
return (0);
}
int trx_oran_get_stats(openair0_device *device)
int trx_oran_get_stats(openair0_device_t *device)
{
uint64_t total_time, used_time;
uint32_t num_core_used, core_used[64];
@@ -114,25 +114,25 @@ int trx_oran_get_stats(openair0_device *device)
return (0);
}
int trx_oran_reset_stats(openair0_device *device)
int trx_oran_reset_stats(openair0_device_t *device)
{
printf("ORAN: %s\n", __FUNCTION__);
return (0);
}
int ethernet_tune(openair0_device *device, unsigned int option, int value)
int ethernet_tune(openair0_device_t *device, unsigned int option, int value)
{
printf("ORAN: %s\n", __FUNCTION__);
return 0;
}
int trx_oran_write_raw(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags)
int trx_oran_write_raw(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int cc, int flags)
{
printf("ORAN: %s\n", __FUNCTION__);
return 0;
}
int trx_oran_read_raw(openair0_device *device, openair0_timestamp *timestamp, void **buff, int nsamps, int cc)
int trx_oran_read_raw(openair0_device_t *device, openair0_timestamp_t *timestamp, void **buff, int nsamps, int cc)
{
printf("ORAN: %s\n", __FUNCTION__);
return 0;
@@ -160,7 +160,7 @@ char *msg_type(int t)
return s[t];
}
int trx_oran_ctlsend(openair0_device *device, void *msg, ssize_t msg_len)
int trx_oran_ctlsend(openair0_device_t *device, void *msg, ssize_t msg_len)
{
RRU_CONFIG_msg_t *rru_config_msg = msg;
oran_eth_state_t *s = device->priv;
@@ -174,7 +174,7 @@ int trx_oran_ctlsend(openair0_device *device, void *msg, ssize_t msg_len)
return msg_len;
}
int trx_oran_ctlrecv(openair0_device *device, void *msg, ssize_t msg_len)
int trx_oran_ctlrecv(openair0_device_t *device, void *msg, ssize_t msg_len)
{
RRU_CONFIG_msg_t *rru_config_msg = msg;
oran_eth_state_t *s = device->priv;
@@ -312,7 +312,7 @@ void *get_internal_parameter(char *name)
return NULL;
}
__attribute__((__visibility__("default"))) int transport_init(openair0_device *device,
__attribute__((__visibility__("default"))) int transport_init(openair0_device_t *device,
openair0_config_t *openair0_cfg,
eth_params_t *eth_params)
{
radio/iqplayer/iqplayer_lib.c
+19 -14
View File
@@ -57,7 +57,8 @@ static void busy_wait(uint32_t usecs) {
//LOG_I(HW, "Expected: %d Elapsed: %d us\n", usecs, elapsed_usecs);
}
static void parse_iqfile_header(openair0_device *device, iqfile_header_t *iq_fh) {
static void parse_iqfile_header(openair0_device_t *device, iqfile_header_t *iq_fh)
{
char tmp[4]=OAIIQFILE_ID;
AssertFatal((memcmp(iq_fh->oaiid,tmp,sizeof(iq_fh->oaiid)) == 0),
"iqfile doesn't seem to be compatible with oai (invalid id %.4s in header)\n",
@@ -69,11 +70,11 @@ static void parse_iqfile_header(openair0_device *device, iqfile_header_t *iq_fh)
LOG_UI(HW,"Replay iqs from %s device, bandwidth %e\n",get_devname(iq_fh->devtype),iq_fh->bw);
}
/*! \brief Called to start the iqplayer device. Return 0 if OK, < 0 if error
@param device pointer to the device structure specific to the RF hardware target
*/
static int iqplayer_loadfile(openair0_device *device, openair0_config_t *openair0_cfg) {
static int iqplayer_loadfile(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
recplay_state_t *s = device->recplay_state;
recplay_conf_t *c = openair0_cfg->recplay_conf;
@@ -142,7 +143,7 @@ static int iqplayer_loadfile(openair0_device *device, openair0_config_t *openair
* \param device the hardware to use
* \returns 0 on success
*/
static int trx_iqplayer_get_stats(openair0_device *device)
static int trx_iqplayer_get_stats(openair0_device_t *device)
{
LOG_I(HW, "trx_iqplayer_get_stats() called, not implemented\n");
return 0;
@@ -152,7 +153,7 @@ static int trx_iqplayer_get_stats(openair0_device *device)
* \param device the hardware to use
* \returns 0 in success
*/
static int trx_iqplayer_reset_stats(openair0_device *device)
static int trx_iqplayer_reset_stats(openair0_device_t *device)
{
LOG_I(HW, "trx_iqplayer_reset_stats() called, not implemented\n");
return 0;
@@ -160,7 +161,7 @@ static int trx_iqplayer_reset_stats(openair0_device *device)
/*! \brief Stop operation of the transceiver
*/
static int trx_iqplayer_stop(openair0_device *device)
static int trx_iqplayer_stop(openair0_device_t *device)
{
LOG_I(HW, "trx_iqplayer_stop() called, not implemented\n");
return 0;
@@ -171,7 +172,7 @@ static int trx_iqplayer_stop(openair0_device *device)
* \param openair0_cfg RF frontend parameters set by application
* \returns 0 in success
*/
static int trx_iqplayer_set_freq(openair0_device *device, openair0_config_t *openair0_cfg)
static int trx_iqplayer_set_freq(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
LOG_I(HW, "trx_iqplayer_set_freq() called, not implemented\n");
return 0;
@@ -182,7 +183,7 @@ static int trx_iqplayer_set_freq(openair0_device *device, openair0_config_t *ope
* \param openair0_cfg RF frontend parameters set by application
* \returns 0 in success
*/
static int trx_iqplayer_set_gains(openair0_device *device, openair0_config_t *openair0_cfg)
static int trx_iqplayer_set_gains(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
LOG_I(HW, "trx_iqplayer_set_gains() called, not implemented\n");
return 0;
@@ -191,14 +192,16 @@ static int trx_iqplayer_set_gains(openair0_device *device, openair0_config_t *op
/*! \brief start the oai iq player
* \param device, the hardware used
*/
static int trx_iqplayer_start(openair0_device *device) {
static int trx_iqplayer_start(openair0_device_t *device)
{
return 0;
}
/*! \brief Terminate operation of the oai iq player
* \param device, the hardware used
*/
static void trx_iqplayer_end(openair0_device *device) {
static void trx_iqplayer_end(openair0_device_t *device)
{
if (device == NULL)
return;
if (device->recplay_state == NULL)
@@ -218,7 +221,6 @@ static void trx_iqplayer_end(openair0_device *device) {
close(device->recplay_state->fd);
device->recplay_state->fd = -1;
}
}
/*! \brief Write iqs function when in replay mode, just introduce a delay, as configured at init time,
@param device pointer to the device structure specific to the RF hardware target
@@ -228,7 +230,8 @@ static void trx_iqplayer_end(openair0_device *device) {
@param antenna_id index of the antenna if the device has multiple antennas
@param flags flags must be set to true if timestamp parameter needs to be applied
*/
static int trx_iqplayer_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags) {
static int trx_iqplayer_write(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int cc, int flags)
{
struct timespec req;
req.tv_sec = 0;
req.tv_nsec = device->openair0_cfg->recplay_conf->u_sf_write_delay * 1000;
@@ -247,7 +250,8 @@ static int trx_iqplayer_write(openair0_device *device, openair0_timestamp timest
* \param antenna_id Index of antenna for which to receive samples
* \returns the number of sample read
*/
static int trx_iqplayer_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc) {
static int trx_iqplayer_read(openair0_device_t *device, openair0_timestamp_t *ptimestamp, void **buff, int nsamps, int cc)
{
recplay_state_t *s = device->recplay_state;
static struct timeval tprev;
static int read_count = 0;
@@ -324,7 +328,8 @@ static int trx_iqplayer_read(openair0_device *device, openair0_timestamp *ptimes
return nsamps;
}
int device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
int device_init(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
device->openair0_cfg = openair0_cfg;
device->trx_start_func = trx_iqplayer_start;
device->trx_get_stats_func = trx_iqplayer_get_stats;
radio/rfsimulator/simulator.cpp
+31 -30
View File
@@ -141,7 +141,7 @@ typedef c16_t sample_t; // 2*16 bits complex number
typedef struct beam_switch_command_t {
std::vector<int> beams;
openair0_timestamp timestamp;
openair0_timestamp_t timestamp;
} beam_switch_command_t;
typedef struct {
@@ -157,7 +157,7 @@ typedef struct {
typedef struct buffer_s {
int conn_sock;
openair0_timestamp lastReceivedTS;
openair0_timestamp_t lastReceivedTS;
bool headerMode;
bool trashingPacket;
samplesBlockHeader_t th;
@@ -183,8 +183,8 @@ typedef struct {
int listen_sock, epollfd;
pthread_mutex_t Sockmutex;
unsigned int nb_cnx;
openair0_timestamp nextRxTstamp;
openair0_timestamp lastWroteTS;
openair0_timestamp_t nextRxTstamp;
openair0_timestamp_t lastWroteTS;
simuRole role;
char *ip;
uint16_t port;
@@ -218,7 +218,7 @@ typedef struct {
* @param nsamps_out output pointer to receive the number of samples until the next beam switch.
* @return The beam map (uint64_t) valid for the given timestamp.
*/
static std::vector<int> get_beams(beam_state_t *beam_state, openair0_timestamp timestamp, uint32_t nsamps, uint32_t *nsamps_out)
static std::vector<int> get_beams(beam_state_t *beam_state, openair0_timestamp_t timestamp, uint32_t nsamps, uint32_t *nsamps_out)
{
std::lock_guard<std::mutex> lock(beam_state->mutex);
std::vector<int> current_beams = beam_state->beams;
@@ -284,7 +284,7 @@ static uint64_t beams_to_beam_map(const std::vector<int> &beam_ids)
* @param beam_state Pointer to the beam_state_t structure containing the command queue and current beam map.
* @param timestamp The timestamp up to which commands should be processed and removed.
*/
static void clear_beam_queue(beam_state_t *beam_state, openair0_timestamp timestamp)
static void clear_beam_queue(beam_state_t *beam_state, openair0_timestamp_t timestamp)
{
std::lock_guard<std::mutex> lock(beam_state->mutex);
while (!beam_state->cmd_queue.empty()) {
@@ -472,7 +472,7 @@ static float get_rx_gain_db(rfsimulator_state_t *rfsimulator, uint rx_beam, uint
return rfsimulator->beam_ctrl->beam_gains[rx_beam][tx_beam];
}
static int rfsimulator_set_beams(openair0_device *device, uint64_t beam_map, openair0_timestamp timestamp)
static int rfsimulator_set_beams(openair0_device_t *device, uint64_t beam_map, openair0_timestamp_t timestamp)
{
rfsimulator_state_t *s = static_cast<rfsimulator_state_t *>(device->priv);
rfsim_beam_ctrl_t *beam_ctrl = s->beam_ctrl;
@@ -484,7 +484,7 @@ static int rfsimulator_set_beams(openair0_device *device, uint64_t beam_map, ope
return 0;
}
static int rfsimulator_set_beams_vector(openair0_device *device, int* beams, int num_beams, openair0_timestamp timestamp)
static int rfsimulator_set_beams_vector(openair0_device_t *device, int *beams, int num_beams, openair0_timestamp_t timestamp)
{
rfsimulator_state_t *s = static_cast<rfsimulator_state_t *>(device->priv);
rfsim_beam_ctrl_t *beam_ctrl = s->beam_ctrl;
@@ -769,13 +769,13 @@ static int rfsimu_getdistance_cmd(char *buff, int debug, telnet_printfunc_t prnt
static int rfsimu_vtime_cmd(char *buff, int debug, telnet_printfunc_t prnt, void *arg)
{
rfsimulator_state_t *t = (rfsimulator_state_t *)arg;
const openair0_timestamp ts = t->nextRxTstamp;
const openair0_timestamp_t ts = t->nextRxTstamp;
const double sample_rate = t->sample_rate;
prnt("%s: vtime measurement: TS %llu sample_rate %.3f\n", __func__, ts, sample_rate);
return CMDSTATUS_FOUND;
}
static int startServer(openair0_device *device)
static int startServer(openair0_device_t *device)
{
int sock = -1;
struct addrinfo *results = NULL;
@@ -885,7 +885,7 @@ static int client_try_connect(const char *host, uint16_t port)
return sock;
}
static int startClient(openair0_device *device)
static int startClient(openair0_device_t *device)
{
rfsimulator_state_t *t = static_cast<rfsimulator_state_t *>(device->priv);
t->role = SIMU_ROLE_CLIENT;
@@ -928,7 +928,7 @@ static int startClient(openair0_device *device)
}
static int rfsimulator_write_internal(rfsimulator_state_t *t,
openair0_timestamp timestamp,
openair0_timestamp_t timestamp,
void ***samplesVoid,
int nsamps,
int nbAnt,
@@ -986,8 +986,8 @@ static int rfsimulator_write_internal(rfsimulator_state_t *t,
return nsamps;
}
static int rfsimulator_write_beams(openair0_device *device,
openair0_timestamp timestamp,
static int rfsimulator_write_beams(openair0_device_t *device,
openair0_timestamp_t timestamp,
void ***samplesVoid,
int nsamps,
int nbAnt,
@@ -1022,7 +1022,7 @@ static int rfsimulator_write_beams(openair0_device *device,
return nsamps_initial;
}
static int rfsimulator_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags)
static int rfsimulator_write(openair0_device_t *device, openair0_timestamp_t timestamp, void **buff, int nsamps, int cc, int flags)
{
void **tmp = buff;
return rfsimulator_write_beams(device, timestamp, &tmp, nsamps, cc, 1, flags);
@@ -1253,7 +1253,7 @@ static bool flushInput(rfsimulator_state_t *t, int timeout, bool first_time)
static void rfsimulator_read_internal(rfsimulator_state_t *t,
c16_t **samples,
openair0_timestamp timestamp,
openair0_timestamp_t timestamp,
int nsamps,
int nbAnt,
int rx_beam_id,
@@ -1355,8 +1355,8 @@ static void rfsimulator_read_internal(rfsimulator_state_t *t,
}
}
static int rfsimulator_read_beams(openair0_device *device,
openair0_timestamp *ptimestamp,
static int rfsimulator_read_beams(openair0_device_t *device,
openair0_timestamp_t *ptimestamp,
void ***samplesVoid,
int nsamps,
int nbAnt,
@@ -1438,7 +1438,7 @@ static int rfsimulator_read_beams(openair0_device *device,
for (int a = 0; a < nbAnt; a++)
memset(samplesVoid[beam][a], 0, sampleToByte(nsamps, 1));
openair0_timestamp timestamp = t->nextRxTstamp;
openair0_timestamp_t timestamp = t->nextRxTstamp;
int nsamps_to_process = nsamps;
while (nsamps_to_process > 0) {
uint32_t nsamps_beam_map;
@@ -1488,7 +1488,7 @@ static int rfsimulator_read_beams(openair0_device *device,
buffer_t *ptr = &t->buf[sock];
if (ptr->conn_sock != -1 && !ptr->received_packets.empty()) {
openair0_timestamp timestamp_to_free = t->nextRxTstamp - 1;
openair0_timestamp_t timestamp_to_free = t->nextRxTstamp - 1;
if (ptr->channel_model) {
timestamp_to_free -=
(ptr->channel_model->channel_length - 1) + std::max(ptr->channel_model->channel_offset, t->chan_offset);
@@ -1502,20 +1502,20 @@ static int rfsimulator_read_beams(openair0_device *device,
return nsamps;
}
static int rfsimulator_read(openair0_device *device, openair0_timestamp *ptimestamp, void **samplesVoid, int nsamps, int nbAnt)
static int rfsimulator_read(openair0_device_t *device, openair0_timestamp_t *ptimestamp, void **samplesVoid, int nsamps, int nbAnt)
{
return rfsimulator_read_beams(device, ptimestamp, &samplesVoid, nsamps, nbAnt, 1);
}
static int rfsimulator_get_stats(openair0_device *device)
static int rfsimulator_get_stats(openair0_device_t *device)
{
return 0;
}
static int rfsimulator_reset_stats(openair0_device *device)
static int rfsimulator_reset_stats(openair0_device_t *device)
{
return 0;
}
static void rfsimulator_end(openair0_device *device)
static void rfsimulator_end(openair0_device_t *device)
{
rfsimulator_state_t *s = static_cast<rfsimulator_state_t *>(device->priv);
for (int i = 0; i < MAX_FD_RFSIMU; i++) {
@@ -1529,7 +1529,8 @@ static void rfsimulator_end(openair0_device *device)
close(s->epollfd);
free(s);
}
static void stopServer(openair0_device *device)
static void stopServer(openair0_device_t *device)
{
rfsimulator_state_t *t = (rfsimulator_state_t *)device->priv;
DevAssert(t != NULL);
@@ -1537,26 +1538,26 @@ static void stopServer(openair0_device *device)
rfsimulator_end(device);
}
static int rfsimulator_stop(openair0_device *device)
static int rfsimulator_stop(openair0_device_t *device)
{
return 0;
}
static int rfsimulator_set_freq(openair0_device *device, openair0_config_t *openair0_cfg)
static int rfsimulator_set_freq(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
rfsimulator_state_t *s = static_cast<rfsimulator_state_t *>(device->priv);
s->rx_freq = openair0_cfg->rx_freq[0];
return 0;
}
static int rfsimulator_set_gains(openair0_device *device, openair0_config_t *openair0_cfg)
static int rfsimulator_set_gains(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
return 0;
}
static int rfsimulator_write_init(openair0_device *device)
static int rfsimulator_write_init(openair0_device_t *device)
{
return 0;
}
extern "C" __attribute__((__visibility__("default"))) int device_init(openair0_device *device, openair0_config_t *openair0_cfg)
extern "C" __attribute__((__visibility__("default"))) int device_init(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
// to change the log level, use this on command line
// --log_config.hw_log_level debug
radio/vrtsim/vrtsim.c
+25 -19
View File
@@ -275,7 +275,7 @@ static client_info_t client_read_info(char *descriptor_file)
return client_info;
}
static int vrtsim_connect(openair0_device *device)
static int vrtsim_connect(openair0_device_t *device)
{
vrtsim_state_t *vrtsim_state = (vrtsim_state_t *)device->priv;
@@ -337,7 +337,7 @@ static int vrtsim_connect(openair0_device *device)
}
static int vrtsim_write_internal(vrtsim_state_t *vrtsim_state,
openair0_timestamp timestamp,
openair0_timestamp_t timestamp,
c16_t *samples,
int nsamps,
int aarx,
@@ -366,7 +366,7 @@ static int vrtsim_write_internal(vrtsim_state_t *vrtsim_state,
typedef struct {
vrtsim_state_t *vrtsim_state;
openair0_timestamp timestamp;
openair0_timestamp_t timestamp;
c16_t *samples[MAX_NUM_ANTENNAS_TX];
int nsamps;
int nbAnt;
@@ -469,7 +469,7 @@ static void perform_channel_modelling(void *arg)
}
static int vrtsim_write_with_chanmod(vrtsim_state_t *vrtsim_state,
openair0_timestamp timestamp,
openair0_timestamp_t timestamp,
void **samplesVoid,
int nsamps,
int nbAnt,
@@ -478,7 +478,7 @@ static int vrtsim_write_with_chanmod(vrtsim_state_t *vrtsim_state,
// Sample history for channel impulse response
static c16_t saved_samples[MAX_NUM_ANTENNAS_TX][SAVED_SAMPLES_LEN] __attribute__((aligned(32))) = {0};
// Indicates what samples are saves in saved_samples
static openair0_timestamp last_timestamp = 0;
static openair0_timestamp_t last_timestamp = 0;
const int batch_size = 4096;
AssertFatal(nbAnt <= MAX_NUM_ANTENNAS_TX, "Number of antennas %d exceeds maximum %d\n", nbAnt, MAX_NUM_ANTENNAS_TX);
@@ -533,7 +533,12 @@ static int vrtsim_write_with_chanmod(vrtsim_state_t *vrtsim_state,
return nsamps;
}
static int vrtsim_write(openair0_device *device, openair0_timestamp timestamp, void **samplesVoid, int nsamps, int nbAnt, int flags)
static int vrtsim_write(openair0_device_t *device,
openair0_timestamp_t timestamp,
void **samplesVoid,
int nsamps,
int nbAnt,
int flags)
{
AssertFatal(nsamps > 0, "Number of samples must be greater than 0\n");
AssertFatal(nbAnt > 0 && nbAnt <= MAX_NUM_ANTENNAS_TX,
@@ -548,8 +553,8 @@ static int vrtsim_write(openair0_device *device, openair0_timestamp timestamp, v
: vrtsim_write_internal(vrtsim_state, timestamp, (c16_t *)samplesVoid[0], nsamps, 0, flags, 0);
}
static int vrtsim_write_beams(openair0_device *device,
openair0_timestamp timestamp,
static int vrtsim_write_beams(openair0_device_t *device,
openair0_timestamp_t timestamp,
void ***buff,
int nsamps,
int nb_antennas_tx,
@@ -560,7 +565,7 @@ static int vrtsim_write_beams(openair0_device *device,
return nsamps;
}
static int vrtsim_read(openair0_device *device, openair0_timestamp *ptimestamp, void **samplesVoid, int nsamps, int nbAnt)
static int vrtsim_read(openair0_device_t *device, openair0_timestamp_t *ptimestamp, void **samplesVoid, int nsamps, int nbAnt)
{
vrtsim_state_t *vrtsim_state = (vrtsim_state_t *)device->priv;
if (shm_td_iq_channel_is_aborted(vrtsim_state->channel)) {
@@ -599,7 +604,7 @@ static int vrtsim_read(openair0_device *device, openair0_timestamp *ptimestamp,
return nsamps;
}
static void vrtsim_end(openair0_device *device)
static void vrtsim_end(openair0_device_t *device)
{
vrtsim_state_t *vrtsim_state = (vrtsim_state_t *)device->priv;
if (vrtsim_state->role == ROLE_SERVER && vrtsim_state->run_timing_thread) {
@@ -653,33 +658,34 @@ static void vrtsim_end(openair0_device *device)
}
}
static int vrtsim_stub(openair0_device *device)
{
return 0;
}
static int vrtsim_stub2(openair0_device *device, openair0_config_t *openair0_cfg)
static int vrtsim_stub(openair0_device_t *device)
{
return 0;
}
static int vrtsim_set_freq(openair0_device *device, openair0_config_t *openair0_cfg)
static int vrtsim_stub2(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
return 0;
}
static int vrtsim_set_freq(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
vrtsim_state_t *s = device->priv;
s->rx_freq = openair0_cfg->rx_freq[0];
return 0;
}
static int vrtsim_set_beams(openair0_device *device, uint64_t beam_map, openair0_timestamp timestamp)
static int vrtsim_set_beams(openair0_device_t *device, uint64_t beam_map, openair0_timestamp_t timestamp)
{
return 0;
}
static int vrtsim_set_beams2(openair0_device *device, int *beam_ids, int num_beams, openair0_timestamp timestamp)
static int vrtsim_set_beams2(openair0_device_t *device, int *beam_ids, int num_beams, openair0_timestamp_t timestamp)
{
return 0;
}
__attribute__((__visibility__("default"))) int device_init(openair0_device *device, openair0_config_t *openair0_cfg)
__attribute__((__visibility__("default"))) int device_init(openair0_device_t *device, openair0_config_t *openair0_cfg)
{
randominit();
vrtsim_state_t *vrtsim_state = calloc_or_fail(1, sizeof(vrtsim_state_t));