PentHertz
/
srsLTE
mirror of https://github.com/PentHertz/srsLTE.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

BladeRF: Solved all clang tidy warnings

This commit is contained in:
Xavier Arteaga 2019-09-12 12:48:26 +02:00 committed by Xavier Arteaga
parent 0984debe1b
commit 9984e14170
1 changed files with 59 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
lib/src/phy/rf/rf_blade_imp.c
View File

@ -26,7 +26,7 @@
#include "srslte/srslte.h" #include "srslte/srslte.h"
#include "rf_blade_imp.h" #include "rf_blade_imp.h"
#define UNUSED __attribute__((unused))
#define CONVERT_BUFFER_SIZE (240*1024) #define CONVERT_BUFFER_SIZE (240*1024)
typedef struct { typedef struct {
@ -40,18 +40,19 @@ typedef struct {
srslte_rf_info_t info; srslte_rf_info_t info;
} rf_blade_handler_t; } rf_blade_handler_t;
srslte_rf_error_handler_t blade_error_handler = NULL; static srslte_rf_error_handler_t blade_error_handler = NULL;
void rf_blade_suppress_stdout(void *h) { void rf_blade_suppress_stdout(UNUSED void* h)
{
bladerf_log_set_verbosity(BLADERF_LOG_LEVEL_SILENT); bladerf_log_set_verbosity(BLADERF_LOG_LEVEL_SILENT);
} }
void rf_blade_register_error_handler(void *notused, srslte_rf_error_handler_t new_handler) void rf_blade_register_error_handler(UNUSED void* ptr, srslte_rf_error_handler_t new_handler)
{ {
new_handler = blade_error_handler; blade_error_handler = new_handler;
} }
bool rf_blade_rx_wait_lo_locked(void *h) bool rf_blade_rx_wait_lo_locked(UNUSED void* h)
{ {
usleep(1000); usleep(1000);
return true; return true;
@ -63,8 +64,7 @@ const unsigned int buffer_size_tx = 1024;
const unsigned int num_transfers = 32; const unsigned int num_transfers = 32;
const unsigned int timeout_ms = 4000; const unsigned int timeout_ms = 4000;
char* rf_blade_devname(UNUSED void* h)
char* rf_blade_devname(void* h)
{ {
return DEVNAME; return DEVNAME;
} }
@ -85,7 +85,7 @@ int rf_blade_start_tx_stream(void *h)
ERROR("Failed to configure TX sync interface: %s\n", bladerf_strerror(status)); ERROR("Failed to configure TX sync interface: %s\n", bladerf_strerror(status));
return status; return status;
} }
status = bladerf_enable_module(handler->dev, BLADERF_MODULE_TX, true); status = bladerf_enable_module(handler->dev, BLADERF_TX_X1, true);
if (status != 0) { if (status != 0) {
ERROR("Failed to enable TX module: %s\n", bladerf_strerror(status)); ERROR("Failed to enable TX module: %s\n", bladerf_strerror(status));
return status; return status;
@ -94,7 +94,7 @@ int rf_blade_start_tx_stream(void *h)
return 0; return 0;
} }
int rf_blade_start_rx_stream(void *h, bool now) int rf_blade_start_rx_stream(void* h, UNUSED bool now)
{ {
int status; int status;
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
@ -125,12 +125,12 @@ int rf_blade_start_rx_stream(void *h, bool now)
ERROR("Failed to configure TX sync interface: %s\n", bladerf_strerror(status)); ERROR("Failed to configure TX sync interface: %s\n", bladerf_strerror(status));
return status; return status;
} }
status = bladerf_enable_module(handler->dev, BLADERF_MODULE_RX, true); status = bladerf_enable_module(handler->dev, BLADERF_RX_X1, true);
if (status != 0) { if (status != 0) {
ERROR("Failed to enable RX module: %s\n", bladerf_strerror(status)); ERROR("Failed to enable RX module: %s\n", bladerf_strerror(status));
return status; return status;
} }
status = bladerf_enable_module(handler->dev, BLADERF_MODULE_TX, true); status = bladerf_enable_module(handler->dev, BLADERF_TX_X1, true);
if (status != 0) { if (status != 0) {
ERROR("Failed to enable TX module: %s\n", bladerf_strerror(status)); ERROR("Failed to enable TX module: %s\n", bladerf_strerror(status));
return status; return status;
@ -142,12 +142,12 @@ int rf_blade_start_rx_stream(void *h, bool now)
int rf_blade_stop_rx_stream(void *h) int rf_blade_stop_rx_stream(void *h)
{ {
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
int status = bladerf_enable_module(handler->dev, BLADERF_MODULE_RX, false); int status = bladerf_enable_module(handler->dev, BLADERF_RX_X1, false);
if (status != 0) { if (status != 0) {
ERROR("Failed to enable RX module: %s\n", bladerf_strerror(status)); ERROR("Failed to enable RX module: %s\n", bladerf_strerror(status));
return status; return status;
} }
status = bladerf_enable_module(handler->dev, BLADERF_MODULE_TX, false); status = bladerf_enable_module(handler->dev, BLADERF_TX_X1, false);
if (status != 0) { if (status != 0) {
ERROR("Failed to enable TX module: %s\n", bladerf_strerror(status)); ERROR("Failed to enable TX module: %s\n", bladerf_strerror(status));
return status; return status;
@ -157,21 +157,19 @@ int rf_blade_stop_rx_stream(void *h)
return 0; return 0;
} }
void rf_blade_flush_buffer(void *h) void rf_blade_flush_buffer(UNUSED void* h) {}
{
}
bool rf_blade_has_rssi(void *h) bool rf_blade_has_rssi(UNUSED void* h)
{ {
return false; return false;
} }
float rf_blade_get_rssi(void *h) float rf_blade_get_rssi(UNUSED void* h)
{ {
return 0; return 0;
} }
int rf_blade_open_multi(char *args, void **h, uint32_t nof_channels) int rf_blade_open_multi(char* args, void** h, UNUSED uint32_t nof_channels)
{ {
return rf_blade_open(args, h); return rf_blade_open(args, h);
} }
@ -196,7 +194,7 @@ int rf_blade_open(char *args, void **h)
return status; return status;
} }
status = bladerf_set_gain_mode(handler->dev, BLADERF_MODULE_RX, BLADERF_GAIN_MGC); status = bladerf_set_gain_mode(handler->dev, BLADERF_RX_X1, BLADERF_GAIN_MGC);
if (status) { if (status) {
ERROR("Unable to open device: %s\n", bladerf_strerror(status)); ERROR("Unable to open device: %s\n", bladerf_strerror(status));
return status; return status;
@ -205,19 +203,19 @@ int rf_blade_open(char *args, void **h)
//bladerf_log_set_verbosity(BLADERF_LOG_LEVEL_VERBOSE); //bladerf_log_set_verbosity(BLADERF_LOG_LEVEL_VERBOSE);
/* Get Gain ranges and set Rx to maximum */ /* Get Gain ranges and set Rx to maximum */
status = bladerf_get_gain_range(handler->dev, BLADERF_MODULE_RX, &range_rx); status = bladerf_get_gain_range(handler->dev, BLADERF_RX_X1, &range_rx);
if ((status != 0) | (range_rx == NULL)) { if ((status != 0) || (range_rx == NULL)) {
ERROR("Failed to get RX gain range: %s\n", bladerf_strerror(status)); ERROR("Failed to get RX gain range: %s\n", bladerf_strerror(status));
return status; return status;
} }
bladerf_get_gain_range(handler->dev, BLADERF_MODULE_RX, &range_tx); status = bladerf_get_gain_range(handler->dev, BLADERF_RX_X1, &range_tx);
if ((status != 0) | (range_tx == NULL)) { if ((status != 0) || (range_tx == NULL)) {
ERROR("Failed to get TX gain range: %s\n", bladerf_strerror(status)); ERROR("Failed to get TX gain range: %s\n", bladerf_strerror(status));
return status; return status;
} }
status = bladerf_set_gain(handler->dev, BLADERF_MODULE_RX, (bladerf_gain) range_rx->max); status = bladerf_set_gain(handler->dev, BLADERF_RX_X1, (bladerf_gain)range_rx->max);
if (status != 0) { if (status != 0) {
ERROR("Failed to set RX LNA gain: %s\n", bladerf_strerror(status)); ERROR("Failed to set RX LNA gain: %s\n", bladerf_strerror(status));
return status; return status;
@ -246,11 +244,9 @@ int rf_blade_close(void *h)
return 0; return 0;
} }
void rf_blade_set_master_clock_rate(void *h, double rate) void rf_blade_set_master_clock_rate(UNUSED void* h, UNUSED double rate) {}
{
}
bool rf_blade_is_master_clock_dynamic(void *h) bool rf_blade_is_master_clock_dynamic(UNUSED void* h)
{ {
return true; return true;
} }
@ -259,19 +255,19 @@ double rf_blade_set_rx_srate(void *h, double freq)
{ {
uint32_t bw; uint32_t bw;
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
int status = bladerf_set_sample_rate(handler->dev, BLADERF_MODULE_RX, (uint32_t) freq, &handler->rx_rate); int status = bladerf_set_sample_rate(handler->dev, BLADERF_RX_X1, (uint32_t)freq, &handler->rx_rate);
if (status != 0) { if (status != 0) {
ERROR("Failed to set samplerate = %u: %s\n", (uint32_t)freq, bladerf_strerror(status)); ERROR("Failed to set samplerate = %u: %s\n", (uint32_t)freq, bladerf_strerror(status));
return -1; return -1;
} }
if (handler->rx_rate < 2000000) { if (handler->rx_rate < 2000000) {
status = bladerf_set_bandwidth(handler->dev, BLADERF_MODULE_RX, handler->rx_rate, &bw); status = bladerf_set_bandwidth(handler->dev, BLADERF_RX_X1, handler->rx_rate, &bw);
if (status != 0) { if (status != 0) {
ERROR("Failed to set bandwidth = %u: %s\n", handler->rx_rate, bladerf_strerror(status)); ERROR("Failed to set bandwidth = %u: %s\n", handler->rx_rate, bladerf_strerror(status));
return -1; return -1;
} }
} else { } else {
status = bladerf_set_bandwidth(handler->dev, BLADERF_MODULE_RX, (bladerf_bandwidth) (handler->rx_rate * 0.8), &bw); status = bladerf_set_bandwidth(handler->dev, BLADERF_RX_X1, (bladerf_bandwidth)(handler->rx_rate * 0.8), &bw);
if (status != 0) { if (status != 0) {
ERROR("Failed to set bandwidth = %u: %s\n", handler->rx_rate, bladerf_strerror(status)); ERROR("Failed to set bandwidth = %u: %s\n", handler->rx_rate, bladerf_strerror(status));
return -1; return -1;
@ -285,12 +281,12 @@ double rf_blade_set_tx_srate(void *h, double freq)
{ {
uint32_t bw; uint32_t bw;
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
int status = bladerf_set_sample_rate(handler->dev, BLADERF_MODULE_TX, (uint32_t) freq, &handler->tx_rate); int status = bladerf_set_sample_rate(handler->dev, BLADERF_TX_X1, (uint32_t)freq, &handler->tx_rate);
if (status != 0) { if (status != 0) {
ERROR("Failed to set samplerate = %u: %s\n", (uint32_t)freq, bladerf_strerror(status)); ERROR("Failed to set samplerate = %u: %s\n", (uint32_t)freq, bladerf_strerror(status));
return -1; return -1;
} }
status = bladerf_set_bandwidth(handler->dev, BLADERF_MODULE_TX, handler->tx_rate, &bw); status = bladerf_set_bandwidth(handler->dev, BLADERF_TX_X1, handler->tx_rate, &bw);
if (status != 0) { if (status != 0) {
ERROR("Failed to set bandwidth = %u: %s\n", handler->tx_rate, bladerf_strerror(status)); ERROR("Failed to set bandwidth = %u: %s\n", handler->tx_rate, bladerf_strerror(status));
return -1; return -1;
@ -302,7 +298,7 @@ double rf_blade_set_rx_gain(void *h, double gain)
{ {
int status; int status;
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
status = bladerf_set_gain(handler->dev, BLADERF_MODULE_RX, (bladerf_gain) gain); status = bladerf_set_gain(handler->dev, BLADERF_RX_X1, (bladerf_gain)gain);
if (status != 0) { if (status != 0) {
ERROR("Failed to set RX gain: %s\n", bladerf_strerror(status)); ERROR("Failed to set RX gain: %s\n", bladerf_strerror(status));
return -1; return -1;
@ -314,7 +310,7 @@ double rf_blade_set_tx_gain(void *h, double gain)
{ {
int status; int status;
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
status = bladerf_set_gain(handler->dev, BLADERF_MODULE_TX, (bladerf_gain) gain); status = bladerf_set_gain(handler->dev, BLADERF_TX_X1, (bladerf_gain)gain);
if (status != 0) { if (status != 0) {
ERROR("Failed to set TX gain: %s\n", bladerf_strerror(status)); ERROR("Failed to set TX gain: %s\n", bladerf_strerror(status));
return -1; return -1;
@ -327,7 +323,7 @@ double rf_blade_get_rx_gain(void *h)
int status; int status;
bladerf_gain gain = 0; bladerf_gain gain = 0;
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
status = bladerf_get_gain(handler->dev, BLADERF_MODULE_RX, &gain); status = bladerf_get_gain(handler->dev, BLADERF_RX_X1, &gain);
if (status != 0) { if (status != 0) {
ERROR("Failed to get RX gain: %s\n", bladerf_strerror(status)); ERROR("Failed to get RX gain: %s\n", bladerf_strerror(status));
return -1; return -1;
@ -340,7 +336,7 @@ double rf_blade_get_tx_gain(void *h)
int status; int status;
bladerf_gain gain = 0; bladerf_gain gain = 0;
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
status = bladerf_get_gain(handler->dev, BLADERF_MODULE_TX, &gain); status = bladerf_get_gain(handler->dev, BLADERF_TX_X1, &gain);
if (status != 0) { if (status != 0) {
ERROR("Failed to get TX gain: %s\n", bladerf_strerror(status)); ERROR("Failed to get TX gain: %s\n", bladerf_strerror(status));
return -1; return -1;
@ -361,34 +357,34 @@ srslte_rf_info_t *rf_blade_get_info(void *h)
return info; return info;
} }
double rf_blade_set_rx_freq(void* h, uint32_t ch, double freq) double rf_blade_set_rx_freq(void* h, UNUSED uint32_t ch, double freq)
{ {
rf_blade_handler_t* handler = (rf_blade_handler_t*)h; rf_blade_handler_t* handler = (rf_blade_handler_t*)h;
bladerf_frequency f_int = (uint32_t) round(freq); bladerf_frequency f_int = (uint32_t) round(freq);
int status = bladerf_set_frequency(handler->dev, BLADERF_MODULE_RX, f_int); int status = bladerf_set_frequency(handler->dev, BLADERF_RX_X1, f_int);
if (status != 0) { if (status != 0) {
ERROR("Failed to set samplerate = %u: %s\n", (uint32_t)freq, bladerf_strerror(status)); ERROR("Failed to set samplerate = %u: %s\n", (uint32_t)freq, bladerf_strerror(status));
return -1; return -1;
} }
f_int=0; f_int=0;
bladerf_get_frequency(handler->dev, BLADERF_MODULE_RX, &f_int); bladerf_get_frequency(handler->dev, BLADERF_RX_X1, &f_int);
printf("set RX frequency to %lu\n", f_int); printf("set RX frequency to %lu\n", f_int);
return freq; return freq;
} }
double rf_blade_set_tx_freq(void* h, uint32_t ch, double freq) double rf_blade_set_tx_freq(void* h, UNUSED uint32_t ch, double freq)
{ {
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
bladerf_frequency f_int = (uint32_t)round(freq); bladerf_frequency f_int = (uint32_t)round(freq);
int status = bladerf_set_frequency(handler->dev, BLADERF_MODULE_TX, f_int); int status = bladerf_set_frequency(handler->dev, BLADERF_TX_X1, f_int);
if (status != 0) { if (status != 0) {
ERROR("Failed to set samplerate = %u: %s\n", (uint32_t)freq, bladerf_strerror(status)); ERROR("Failed to set samplerate = %u: %s\n", (uint32_t)freq, bladerf_strerror(status));
return -1; return -1;
} }
f_int=0; f_int=0;
bladerf_get_frequency(handler->dev, BLADERF_MODULE_TX, &f_int); bladerf_get_frequency(handler->dev, BLADERF_TX_X1, &f_int);
printf("set TX frequency to %lu\n", f_int); printf("set TX frequency to %lu\n", f_int);
return freq; return freq;
} }
@ -404,13 +400,6 @@ static void timestamp_to_secs(uint32_t rate, uint64_t timestamp, time_t *secs, d
} }
} }
static void secs_to_timestamps(uint32_t rate, time_t secs, double frac_secs, uint64_t *timestamp) {
double totalsecs = (double) secs + frac_secs;
if (timestamp) {
*timestamp = rate * totalsecs;
}
}
void rf_blade_get_time(void *h, time_t *secs, double *frac_secs) void rf_blade_get_time(void *h, time_t *secs, double *frac_secs)
{ {
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
@ -433,12 +422,8 @@ int rf_blade_recv_with_time_multi(void *h,
return rf_blade_recv_with_time(h, *data, nsamples, blocking, secs, frac_secs); return rf_blade_recv_with_time(h, *data, nsamples, blocking, secs, frac_secs);
} }
int rf_blade_recv_with_time(void *h, int rf_blade_recv_with_time(
void *data, void* h, void* data, uint32_t nsamples, UNUSED bool blocking, time_t* secs, double* frac_secs)
uint32_t nsamples,
bool blocking,
time_t *secs,
double *frac_secs)
{ {
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
struct bladerf_metadata meta; struct bladerf_metadata meta;
@ -453,7 +438,7 @@ int rf_blade_recv_with_time(void *h,
} }
status = bladerf_sync_rx(handler->dev, handler->rx_buffer, nsamples, &meta, 2000); status = bladerf_sync_rx(handler->dev, handler->rx_buffer, nsamples, &meta, 2000);
if (status) { if (status) {
ERROR("RX failed: %s\n\n", bladerf_strerror(status)); ERROR("RX failed: %s; nsamples=%d;\n", bladerf_strerror(status), nsamples);
return -1; return -1;
} else if (meta.status & BLADERF_META_STATUS_OVERRUN) { } else if (meta.status & BLADERF_META_STATUS_OVERRUN) {
if (blade_error_handler) { if (blade_error_handler) {
@ -487,15 +472,15 @@ int rf_blade_send_timed_multi(void *h,
is_end_of_burst); is_end_of_burst);
} }
int rf_blade_send_timed(void *h, int rf_blade_send_timed(void* h,
void *data, void* data,
int nsamples, int nsamples,
time_t secs, time_t secs,
double frac_secs, double frac_secs,
bool has_time_spec, bool has_time_spec,
bool blocking, UNUSED bool blocking,
bool is_start_of_burst, bool is_start_of_burst,
bool is_end_of_burst) bool is_end_of_burst)
{ {
rf_blade_handler_t *handler = (rf_blade_handler_t*) h; rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
struct bladerf_metadata meta; struct bladerf_metadata meta;
@ -515,7 +500,9 @@ int rf_blade_send_timed(void *h,
memset(&meta, 0, sizeof(meta)); memset(&meta, 0, sizeof(meta));
if (is_start_of_burst) { if (is_start_of_burst) {
if (has_time_spec) { if (has_time_spec) {
secs_to_timestamps(handler->tx_rate, secs, frac_secs, &meta.timestamp); // Convert time to ticks
srslte_timestamp_t ts = {.full_secs = secs, .frac_secs = frac_secs};
meta.timestamp = srslte_timestamp_uint64(&ts, handler->tx_rate);
} else { } else {
meta.flags |= BLADERF_META_FLAG_TX_NOW; meta.flags |= BLADERF_META_FLAG_TX_NOW;
} }