libbladeRF: Cleaned up API enumerations and macro definitions.
The _t suffix on enums has been removed, as "_t" is reserved for POSIX types. To avoid naming collisions, macro definitions and enumeration values are now prefixed with at least "BLADERF_". Also in the mix is a stubbed out "unsupported" implementation of the stream routines for the Linux driver backend.
This commit is contained in:
parent
27de30d0cf
commit
8cc9f2a4b5
16 changed files with 282 additions and 240 deletions
|
|
@ -50,20 +50,20 @@ struct bladerf_stream;
|
|||
* Backend by which the host communicates with the device
|
||||
*/
|
||||
typedef enum {
|
||||
BACKEND_ANY, /**< "Don't Care" -- use any available backend */
|
||||
BACKEND_LINUX, /**< Linux kernel driver */
|
||||
BACKEND_LIBUSB, /**< libusb */
|
||||
} bladerf_backend_t;
|
||||
BLADERF_BACKEND_ANY, /**< "Don't Care" -- use any available backend */
|
||||
BLADERF_BACKEND_LINUX, /**< Linux kernel driver */
|
||||
BLADERF_BACKEND_LIBUSB /**< libusb */
|
||||
} bladerf_backend;
|
||||
|
||||
|
||||
/**
|
||||
* Information about a bladeRF attached to the system
|
||||
*/
|
||||
struct bladerf_devinfo {
|
||||
bladerf_backend_t backend; /**< Backend to use when connecting to device */
|
||||
bladerf_backend backend; /**< Backend to use when connecting to device */
|
||||
char serial[33]; /**< Device's serial number */
|
||||
uint8_t usb_bus; /**< Bus # device is attached to */
|
||||
uint8_t usb_addr; /**< Device address on bus */
|
||||
uint8_t usb_bus; /**< Bus # device is attached to */
|
||||
uint8_t usb_addr; /**< Device address on bus */
|
||||
unsigned int instance; /**< Device instance or ID */
|
||||
};
|
||||
|
||||
|
|
@ -89,9 +89,9 @@ struct bladerf_stats {
|
|||
* Sample format
|
||||
*/
|
||||
typedef enum {
|
||||
FORMAT_SC16, /**< Signed, Complex 16-bit Q12. TODO more info */
|
||||
FORMAT_FC64, /**< Floating point, Complex 64-bit TODO more info */
|
||||
} bladerf_format_t;
|
||||
BLADERF_FORMAT_SC16_Q12, /**< Signed, Complex 16-bit Q12.
|
||||
* This is the native format of the DAC data. */
|
||||
} bladerf_format;
|
||||
|
||||
/**
|
||||
* Sample metadata
|
||||
|
|
@ -105,34 +105,34 @@ struct bladerf_metadata {
|
|||
* LNA gain options
|
||||
*/
|
||||
typedef enum {
|
||||
LNA_UNKNOWN, /**< Invalid LNA gain */
|
||||
LNA_BYPASS, /**< LNA bypassed - 0dB gain */
|
||||
LNA_MID, /**< LNA Mid Gain (MAX-6dB) */
|
||||
LNA_MAX /**< LNA Max Gain */
|
||||
} bladerf_lna_gain_t ;
|
||||
BLADERF_LNA_GAIN_UNKNOWN, /**< Invalid LNA gain */
|
||||
BLADERF_LNA_GAIN_BYPASS, /**< LNA bypassed - 0dB gain */
|
||||
BLADERF_LNA_GAIN_MID, /**< LNA Mid Gain (MAX-6dB) */
|
||||
BLADERF_LNA_GAIN_MAX /**< LNA Max Gain */
|
||||
} bladerf_lna_gain;
|
||||
|
||||
/**
|
||||
* Module selection for those which have both RX and TX constituents
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
RX, /**< Receive Module */
|
||||
TX /**< Transmit Module */
|
||||
} bladerf_module_t ;
|
||||
BLADERF_MODULE_RX, /**< Receive Module */
|
||||
BLADERF_MODULE_TX /**< Transmit Module */
|
||||
} bladerf_module;
|
||||
|
||||
/**
|
||||
* Transmit Loopback options
|
||||
*/
|
||||
typedef enum {
|
||||
LB_BB_LPF = 0, /**< Baseband loopback enters before RX low-pass filter input */
|
||||
LB_BB_VGA2, /**< Baseband loopback enters before RX VGA2 input */
|
||||
LB_BB_OP, /**< Baseband loopback enters before RX ADC input */
|
||||
LB_RF_LNA_START, /**< Placeholder - DO NOT USE */
|
||||
LB_RF_LNA1, /**< RF loopback enters at LNA1 (300MHz - 2.8GHz)*/
|
||||
LB_RF_LNA2, /**< RF loopback enters at LNA2 (1.5GHz - 3.8GHz)*/
|
||||
LB_RF_LNA3, /**< RF loopback enters at LNA3 (300MHz - 3.0GHz)*/
|
||||
LB_NONE /**< Null loopback mode*/
|
||||
} bladerf_loopback_t;
|
||||
BLADERF_LB_BB_LPF = 0, /**< Baseband loopback enters before RX low-pass filter input */
|
||||
BLADERF_LB_BB_VGA2, /**< Baseband loopback enters before RX VGA2 input */
|
||||
BLADERF_LB_BB_OP, /**< Baseband loopback enters before RX ADC input */
|
||||
BLADERF_LB_RF_LNA_START, /**< Placeholder - DO NOT USE */
|
||||
BLADERF_LB_RF_LNA1, /**< RF loopback enters at LNA1 (300MHz - 2.8GHz)*/
|
||||
BLADERF_LB_RF_LNA2, /**< RF loopback enters at LNA2 (1.5GHz - 3.8GHz)*/
|
||||
BLADERF_LB_RF_LNA3, /**< RF loopback enters at LNA3 (300MHz - 3.0GHz)*/
|
||||
BLADERF_LB_NONE /**< Null loopback mode*/
|
||||
} bladerf_loopback;
|
||||
|
||||
/**
|
||||
* For both RX and TX, the stream callback receives:
|
||||
|
|
@ -283,7 +283,7 @@ void bladerf_close(struct bladerf *device);
|
|||
* @return 0 on success, value from \ref RETCODES list on failure
|
||||
*/
|
||||
int bladerf_enable_module(struct bladerf *dev,
|
||||
bladerf_module_t m, bool enable);
|
||||
bladerf_module m, bool enable);
|
||||
|
||||
/**
|
||||
* Apply specified loopback mode
|
||||
|
|
@ -294,7 +294,7 @@ int bladerf_enable_module(struct bladerf *dev,
|
|||
*
|
||||
* @return 0 on success, value from \ref RETCODES list on failure
|
||||
*/
|
||||
int bladerf_set_loopback( struct bladerf *dev, bladerf_loopback_t l);
|
||||
int bladerf_set_loopback( struct bladerf *dev, bladerf_loopback l);
|
||||
|
||||
|
||||
/**
|
||||
|
|
@ -309,7 +309,7 @@ int bladerf_set_loopback( struct bladerf *dev, bladerf_loopback_t l);
|
|||
*
|
||||
* @return 0 on success, value from \ref RETCODES list on failure
|
||||
*/
|
||||
int bladerf_set_sample_rate(struct bladerf *dev, bladerf_module_t module,
|
||||
int bladerf_set_sample_rate(struct bladerf *dev, bladerf_module module,
|
||||
unsigned int rate, unsigned int *actual);
|
||||
|
||||
/**
|
||||
|
|
@ -327,7 +327,7 @@ int bladerf_set_sample_rate(struct bladerf *dev, bladerf_module_t module,
|
|||
* @return 0 on success, value from \ref RETCODES list on failure
|
||||
*/
|
||||
int bladerf_set_rational_sample_rate(struct bladerf *dev,
|
||||
bladerf_module_t module,
|
||||
bladerf_module module,
|
||||
unsigned int integer, unsigned int num,
|
||||
unsigned int denom);
|
||||
|
||||
|
|
@ -341,7 +341,7 @@ int bladerf_set_rational_sample_rate(struct bladerf *dev,
|
|||
*
|
||||
* @return 0 on success, value from \ref RETCODES list upon failure
|
||||
*/
|
||||
int bladerf_get_sample_rate(struct bladerf *dev, bladerf_module_t module,
|
||||
int bladerf_get_sample_rate(struct bladerf *dev, bladerf_module module,
|
||||
unsigned int *rate);
|
||||
|
||||
/**
|
||||
|
|
@ -392,7 +392,7 @@ int bladerf_get_txvga1(struct bladerf *dev, int *gain);
|
|||
*
|
||||
* @return 0 on success, value from \ref RETCODES list on failure
|
||||
*/
|
||||
int bladerf_set_lna_gain(struct bladerf *dev, bladerf_lna_gain_t gain);
|
||||
int bladerf_set_lna_gain(struct bladerf *dev, bladerf_lna_gain gain);
|
||||
|
||||
/**
|
||||
* Get the LNA gain
|
||||
|
|
@ -400,7 +400,7 @@ int bladerf_set_lna_gain(struct bladerf *dev, bladerf_lna_gain_t gain);
|
|||
* @param dev Device handle
|
||||
* @param gain Pointer to the set gain level
|
||||
*/
|
||||
int bladerf_get_lna_gain(struct bladerf *dev, bladerf_lna_gain_t *gain);
|
||||
int bladerf_get_lna_gain(struct bladerf *dev, bladerf_lna_gain *gain);
|
||||
|
||||
/**
|
||||
* Set the pre-LPF VGA gain
|
||||
|
|
@ -450,7 +450,7 @@ int bladerf_get_rxvga2(struct bladerf *dev, int *gain);
|
|||
*
|
||||
* @return 0 on success, value from \ref RETCODES list on failure
|
||||
*/
|
||||
int bladerf_set_bandwidth(struct bladerf *dev, bladerf_module_t module,
|
||||
int bladerf_set_bandwidth(struct bladerf *dev, bladerf_module module,
|
||||
unsigned int bandwidth,
|
||||
unsigned int *actual);
|
||||
|
||||
|
|
@ -463,7 +463,7 @@ int bladerf_set_bandwidth(struct bladerf *dev, bladerf_module_t module,
|
|||
*
|
||||
* @return 0 on success, value from \ref RETCODES list on failure
|
||||
*/
|
||||
int bladerf_get_bandwidth(struct bladerf *dev, bladerf_module_t module,
|
||||
int bladerf_get_bandwidth(struct bladerf *dev, bladerf_module module,
|
||||
unsigned int *bandwidth);
|
||||
|
||||
/**
|
||||
|
|
@ -473,7 +473,7 @@ int bladerf_get_bandwidth(struct bladerf *dev, bladerf_module_t module,
|
|||
* @param module Module to configure
|
||||
* @param frequency Tuned frequency
|
||||
*/
|
||||
int bladerf_select_band(struct bladerf *dev, bladerf_module_t module,
|
||||
int bladerf_select_band(struct bladerf *dev, bladerf_module module,
|
||||
unsigned int frequency);
|
||||
|
||||
/**
|
||||
|
|
@ -486,7 +486,7 @@ int bladerf_select_band(struct bladerf *dev, bladerf_module_t module,
|
|||
* @return 0 on success, value from \ref RETCODES list on failure
|
||||
*/
|
||||
int bladerf_set_frequency(struct bladerf *dev,
|
||||
bladerf_module_t module, unsigned int frequency);
|
||||
bladerf_module module, unsigned int frequency);
|
||||
|
||||
/**
|
||||
* Set module's frequency in Hz
|
||||
|
|
@ -496,7 +496,7 @@ int bladerf_set_frequency(struct bladerf *dev,
|
|||
* @param frequency Pointer to the returned frequency
|
||||
*/
|
||||
int bladerf_get_frequency(struct bladerf *dev,
|
||||
bladerf_module_t module, unsigned int *frequency);
|
||||
bladerf_module module, unsigned int *frequency);
|
||||
|
||||
/** @} (End of FN_CTRL) */
|
||||
|
||||
|
|
@ -545,7 +545,7 @@ int bladerf_init_stream(struct bladerf_stream **stream,
|
|||
bladerf_stream_cb callback,
|
||||
void ***buffers,
|
||||
size_t num_buffers,
|
||||
bladerf_format_t format,
|
||||
bladerf_format format,
|
||||
size_t samples_per_buffer,
|
||||
size_t num_transfers,
|
||||
void *user_data);
|
||||
|
|
@ -579,7 +579,7 @@ void bladerf_deinit_stream(struct bladerf_stream *stream);
|
|||
int16_t *samples, size_t num_samples);
|
||||
*/
|
||||
|
||||
ssize_t bladerf_tx(struct bladerf *dev, bladerf_format_t format,
|
||||
ssize_t bladerf_tx(struct bladerf *dev, bladerf_format format,
|
||||
void *samples, size_t num_samples,
|
||||
struct bladerf_metadata *metadata);
|
||||
|
||||
|
|
@ -609,7 +609,7 @@ ssize_t bladerf_tx(struct bladerf *dev, bladerf_format_t format,
|
|||
int16_t *samples, size_t num_samples);
|
||||
*/
|
||||
|
||||
ssize_t bladerf_rx(struct bladerf *dev, bladerf_format_t format,
|
||||
ssize_t bladerf_rx(struct bladerf *dev, bladerf_format format,
|
||||
void *samples, size_t num_samples,
|
||||
struct bladerf_metadata *metadata);
|
||||
|
||||
|
|
@ -619,8 +619,8 @@ ssize_t bladerf_rx(struct bladerf *dev, bladerf_format_t format,
|
|||
* samples_per_buffer, buffers_per_stream, and (optional) data fields
|
||||
* initialized prior to this call
|
||||
*/
|
||||
int bladerf_stream(struct bladerf *dev, bladerf_module_t module,
|
||||
bladerf_format_t format, struct bladerf_stream *stream);
|
||||
int bladerf_stream(struct bladerf *dev, bladerf_module module,
|
||||
bladerf_format format, struct bladerf_stream *stream);
|
||||
|
||||
/**
|
||||
*
|
||||
|
|
@ -628,7 +628,7 @@ int bladerf_stream(struct bladerf *dev, bladerf_module_t module,
|
|||
* samples_per_buffer, buffers_per_stream, and (optional) data fields
|
||||
* initialized prior to this call
|
||||
*/
|
||||
/*int bladerf_tx_stream(struct bladerf *dev, bladerf_format_t format,
|
||||
/*int bladerf_tx_stream(struct bladerf *dev, bladerf_format format,
|
||||
struct bladerf_stream *stream);
|
||||
*/
|
||||
/** @} (End of FN_DATA) */
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
|
||||
|
||||
struct backend_table_entry {
|
||||
const bladerf_backend_t type;
|
||||
const bladerf_backend type;
|
||||
const struct bladerf_fn *fns;
|
||||
};
|
||||
|
||||
|
|
@ -33,7 +33,7 @@ int backend_open(struct bladerf **device, struct bladerf_devinfo *info) {
|
|||
int status = BLADERF_ERR_NODEV;
|
||||
const size_t n_backends = ARRAY_SIZE(backend_list);
|
||||
|
||||
if (info->backend == BACKEND_ANY) {
|
||||
if (info->backend == BLADERF_BACKEND_ANY) {
|
||||
status = open_with_any_backend(device, info);
|
||||
} else {
|
||||
for (i = 0; i < n_backends; i++) {
|
||||
|
|
|
|||
|
|
@ -199,7 +199,7 @@ static int lusb_get_devinfo(libusb_device *dev, struct bladerf_devinfo *info)
|
|||
status = error_libusb2bladerf(status);
|
||||
} else {
|
||||
/* Populate */
|
||||
info->backend = BACKEND_LIBUSB;
|
||||
info->backend = BLADERF_BACKEND_LIBUSB;
|
||||
info->usb_bus = libusb_get_bus_number(dev);
|
||||
info->usb_addr = libusb_get_device_address(dev);
|
||||
|
||||
|
|
@ -262,7 +262,7 @@ static int lusb_open(struct bladerf **device, struct bladerf_devinfo *info)
|
|||
/* Assign libusb function table, backend type and backend */
|
||||
dev->fn = &bladerf_lusb_fn;
|
||||
dev->backend = (void *)lusb;
|
||||
dev->backend_type = BACKEND_LIBUSB;
|
||||
dev->backend_type = BLADERF_BACKEND_LIBUSB;
|
||||
|
||||
/* Populate the backend information */
|
||||
lusb->context = context;
|
||||
|
|
@ -987,7 +987,7 @@ static int lusb_dac_write(struct bladerf *dev, uint16_t value)
|
|||
return status;
|
||||
}
|
||||
|
||||
static ssize_t lusb_tx(struct bladerf *dev, bladerf_format_t format, void *samples,
|
||||
static ssize_t lusb_tx(struct bladerf *dev, bladerf_format format, void *samples,
|
||||
size_t n, struct bladerf_metadata *metadata)
|
||||
{
|
||||
size_t bytes_total, bytes_remaining;
|
||||
|
|
@ -995,7 +995,8 @@ static ssize_t lusb_tx(struct bladerf *dev, bladerf_format_t format, void *sampl
|
|||
uint8_t *samples8 = (uint8_t *)samples;
|
||||
int transferred, status;
|
||||
|
||||
assert(format==FORMAT_SC16);
|
||||
/* This is the only format we currently support */
|
||||
assert(format == BLADERF_FORMAT_SC16_Q12);
|
||||
|
||||
bytes_total = bytes_remaining = c16_samples_to_bytes(n);
|
||||
|
||||
|
|
@ -1022,7 +1023,7 @@ static ssize_t lusb_tx(struct bladerf *dev, bladerf_format_t format, void *sampl
|
|||
return bytes_to_c16_samples(bytes_total - bytes_remaining);
|
||||
}
|
||||
|
||||
static ssize_t lusb_rx(struct bladerf *dev, bladerf_format_t format, void *samples,
|
||||
static ssize_t lusb_rx(struct bladerf *dev, bladerf_format format, void *samples,
|
||||
size_t n, struct bladerf_metadata *metadata)
|
||||
{
|
||||
ssize_t bytes_total, bytes_remaining = c16_samples_to_bytes(n);
|
||||
|
|
@ -1031,7 +1032,7 @@ static ssize_t lusb_rx(struct bladerf *dev, bladerf_format_t format, void *sampl
|
|||
int transferred, status;
|
||||
|
||||
/* The only format currently is assumed here */
|
||||
assert(format == FORMAT_SC16);
|
||||
assert(format == BLADERF_FORMAT_SC16_Q12);
|
||||
bytes_total = bytes_remaining = c16_samples_to_bytes(n);
|
||||
|
||||
while( bytes_remaining ) {
|
||||
|
|
@ -1150,7 +1151,7 @@ static void LIBUSB_CALL lusb_stream_cb(struct libusb_transfer *transfer)
|
|||
libusb_fill_bulk_transfer(
|
||||
transfer,
|
||||
lusb->handle,
|
||||
stream->module == TX ? EP_OUT(0x01) : EP_IN(0x01),
|
||||
stream->module == BLADERF_MODULE_TX ? EP_OUT(0x01) : EP_IN(0x01),
|
||||
next_buffer,
|
||||
c16_samples_to_bytes(stream->samples_per_buffer),
|
||||
lusb_stream_cb,
|
||||
|
|
@ -1171,8 +1172,8 @@ static void LIBUSB_CALL lusb_stream_cb(struct libusb_transfer *transfer)
|
|||
}
|
||||
}
|
||||
|
||||
static int lusb_stream(struct bladerf *dev, bladerf_module_t module, bladerf_format_t format,
|
||||
struct bladerf_stream *stream)
|
||||
static int lusb_stream(struct bladerf *dev, bladerf_module module,
|
||||
bladerf_format format, struct bladerf_stream *stream)
|
||||
{
|
||||
size_t i;
|
||||
void *buffer;
|
||||
|
|
@ -1234,7 +1235,7 @@ static int lusb_stream(struct bladerf *dev, bladerf_module_t module, bladerf_for
|
|||
|
||||
/* Set up initial set of buffers */
|
||||
for( i = 0; i < stream->num_transfers; i++ ) {
|
||||
if( module == TX ) {
|
||||
if( module == BLADERF_MODULE_TX ) {
|
||||
buffer = stream->cb(
|
||||
dev,
|
||||
stream,
|
||||
|
|
@ -1267,7 +1268,7 @@ static int lusb_stream(struct bladerf *dev, bladerf_module_t module, bladerf_for
|
|||
libusb_fill_bulk_transfer(
|
||||
stream_data->transfers[i],
|
||||
lusb->handle,
|
||||
module == TX ? EP_OUT(0x01) : EP_IN(0x01),
|
||||
module == BLADERF_MODULE_TX ? EP_OUT(0x01) : EP_IN(0x01),
|
||||
buffer,
|
||||
buffer_size,
|
||||
lusb_stream_cb,
|
||||
|
|
|
|||
|
|
@ -694,6 +694,17 @@ static int linux_probe(struct bladerf_devinfo_list *info_list)
|
|||
return (!status && num_matches > 0) ? status : BLADERF_ERR_NODEV;
|
||||
}
|
||||
|
||||
static int linux_stream(struct bladerf *dev, bladerf_module_t module,
|
||||
bladerf_format_t format, struct bladerf_stream *stream)
|
||||
{
|
||||
return BLADERF_ERR_UNSUPPORTED;
|
||||
}
|
||||
|
||||
void lusb_deinit_stream(struct bladerf_stream *stream)
|
||||
{
|
||||
return BLADERF_ERR_UNSUPPORTED;
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------------
|
||||
* Function table
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
|
@ -728,5 +739,8 @@ const struct bladerf_fn bladerf_linux_fn = {
|
|||
|
||||
.rx = linux_rx,
|
||||
.tx = linux_tx
|
||||
|
||||
.stream = linux_stream,
|
||||
.deinit_stream = linux_deinit_stream
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
#ifdef ENABLE_BACKEND_LIBUSB
|
||||
# include "backend/libusb.h"
|
||||
# define BACKEND_LIBUSB_FN_TBL_ENTRY \
|
||||
{BACKEND_LIBUSB, &bladerf_lusb_fn},
|
||||
{BLADERF_BACKEND_LIBUSB, &bladerf_lusb_fn},
|
||||
#else
|
||||
# define BACKEND_LIBUSB_FN_TBL_ENTRY
|
||||
#endif
|
||||
|
|
@ -15,7 +15,7 @@
|
|||
#ifdef ENABLE_BACKEND_LINUX_DRIVER
|
||||
# include "backend/linux.h"
|
||||
# define BACKEND_LINUX_DRIVER_FN_TBL_ENTRY \
|
||||
{ BACKEND_LINUX_DRIVER, &bladerf_linux_fn},
|
||||
{ BLADERF_BACKEND_LINUX_DRIVER, &bladerf_linux_fn},
|
||||
#else
|
||||
# define BACKEND_LINUX_DRIVER_FN_TBL_ENTRY
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ void bladerf_close(struct bladerf *dev)
|
|||
}
|
||||
|
||||
int bladerf_enable_module(struct bladerf *dev,
|
||||
bladerf_module_t m, bool enable)
|
||||
bladerf_module m, bool enable)
|
||||
{
|
||||
int status = BLADERF_ERR_UNEXPECTED;
|
||||
uint32_t gpio_reg;
|
||||
|
|
@ -121,14 +121,14 @@ int bladerf_enable_module(struct bladerf *dev,
|
|||
|
||||
if (status == 0) {
|
||||
switch (m) {
|
||||
case TX:
|
||||
case BLADERF_MODULE_TX:
|
||||
if (enable) {
|
||||
gpio_reg |= BLADERF_GPIO_LMS_TX_ENABLE;
|
||||
} else {
|
||||
gpio_reg &= ~BLADERF_GPIO_LMS_TX_ENABLE;
|
||||
}
|
||||
break;
|
||||
case RX:
|
||||
case BLADERF_MODULE_RX:
|
||||
if (enable) {
|
||||
gpio_reg |= BLADERF_GPIO_LMS_RX_ENABLE;
|
||||
} else {
|
||||
|
|
@ -143,17 +143,17 @@ int bladerf_enable_module(struct bladerf *dev,
|
|||
return status;
|
||||
}
|
||||
|
||||
int bladerf_set_loopback(struct bladerf *dev, bladerf_loopback_t l)
|
||||
int bladerf_set_loopback(struct bladerf *dev, bladerf_loopback l)
|
||||
{
|
||||
lms_loopback_enable( dev, l );
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bladerf_set_sample_rate(struct bladerf *dev, bladerf_module_t module, unsigned int rate, unsigned int *actual)
|
||||
int bladerf_set_sample_rate(struct bladerf *dev, bladerf_module module, unsigned int rate, unsigned int *actual)
|
||||
{
|
||||
int ret = -1;
|
||||
/* TODO: Use module to pick the correct clock output to change */
|
||||
if( module == TX ) {
|
||||
if( module == BLADERF_MODULE_TX ) {
|
||||
ret = si5338_set_tx_freq(dev, rate<<1);
|
||||
dev->last_tx_sample_rate = rate;
|
||||
} else {
|
||||
|
|
@ -164,18 +164,18 @@ int bladerf_set_sample_rate(struct bladerf *dev, bladerf_module_t module, unsign
|
|||
return ret;
|
||||
}
|
||||
|
||||
int bladerf_set_rational_sample_rate(struct bladerf *dev, bladerf_module_t module, unsigned int integer, unsigned int num, unsigned int denom)
|
||||
int bladerf_set_rational_sample_rate(struct bladerf *dev, bladerf_module module, unsigned int integer, unsigned int num, unsigned int denom)
|
||||
{
|
||||
/* TODO: Program the Si5338 to be 2x the desired sample rate */
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bladerf_get_sample_rate( struct bladerf *dev, bladerf_module_t module, unsigned int *rate)
|
||||
int bladerf_get_sample_rate( struct bladerf *dev, bladerf_module module, unsigned int *rate)
|
||||
{
|
||||
/* TODO Reconstruct samplerare from Si5338 readback */
|
||||
if (module == RX) {
|
||||
if (module == BLADERF_MODULE_RX) {
|
||||
*rate = dev->last_rx_sample_rate;
|
||||
} else if (module == TX) {
|
||||
} else if (module == BLADERF_MODULE_TX) {
|
||||
*rate = dev->last_tx_sample_rate;
|
||||
} else {
|
||||
return BLADERF_ERR_INVAL;
|
||||
|
|
@ -184,7 +184,7 @@ int bladerf_get_sample_rate( struct bladerf *dev, bladerf_module_t module, unsig
|
|||
return 0;
|
||||
}
|
||||
|
||||
int bladerf_get_rational_sample_rate(struct bladerf *dev, bladerf_module_t module, unsigned int integer, unsigned int num, unsigned int denom)
|
||||
int bladerf_get_rational_sample_rate(struct bladerf *dev, bladerf_module module, unsigned int integer, unsigned int num, unsigned int denom)
|
||||
{
|
||||
/* TODO: Read the Si5338 and figure out the sample rate */
|
||||
return 0;
|
||||
|
|
@ -238,14 +238,14 @@ int bladerf_get_txvga1(struct bladerf *dev, int *gain)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int bladerf_set_lna_gain(struct bladerf *dev, bladerf_lna_gain_t gain)
|
||||
int bladerf_set_lna_gain(struct bladerf *dev, bladerf_lna_gain gain)
|
||||
{
|
||||
/* TODO: Make return values for lms call and return it for failure */
|
||||
lms_lna_set_gain( dev, gain );
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bladerf_get_lna_gain(struct bladerf *dev, bladerf_lna_gain_t *gain)
|
||||
int bladerf_get_lna_gain(struct bladerf *dev, bladerf_lna_gain *gain)
|
||||
{
|
||||
/* TODO: Make return values for lms call and return it for failure */
|
||||
lms_lna_get_gain( dev, gain );
|
||||
|
|
@ -288,7 +288,7 @@ int bladerf_get_rxvga2(struct bladerf *dev, int *gain)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int bladerf_set_bandwidth(struct bladerf *dev, bladerf_module_t module,
|
||||
int bladerf_set_bandwidth(struct bladerf *dev, bladerf_module module,
|
||||
unsigned int bandwidth,
|
||||
unsigned int *actual)
|
||||
{
|
||||
|
|
@ -299,7 +299,7 @@ int bladerf_set_bandwidth(struct bladerf *dev, bladerf_module_t module,
|
|||
return 0;
|
||||
}
|
||||
|
||||
int bladerf_get_bandwidth(struct bladerf *dev, bladerf_module_t module,
|
||||
int bladerf_get_bandwidth(struct bladerf *dev, bladerf_module module,
|
||||
unsigned int *bandwidth )
|
||||
{
|
||||
/* TODO: Make return values for lms call and return it for failure */
|
||||
|
|
@ -308,7 +308,7 @@ int bladerf_get_bandwidth(struct bladerf *dev, bladerf_module_t module,
|
|||
return 0;
|
||||
}
|
||||
|
||||
int bladerf_select_band(struct bladerf *dev, bladerf_module_t module,
|
||||
int bladerf_select_band(struct bladerf *dev, bladerf_module module,
|
||||
unsigned int frequency)
|
||||
{
|
||||
uint32_t gpio ;
|
||||
|
|
@ -321,14 +321,14 @@ int bladerf_select_band(struct bladerf *dev, bladerf_module_t module,
|
|||
lms_lna_select(dev, LNA_1);
|
||||
}
|
||||
bladerf_gpio_read(dev, &gpio);
|
||||
gpio &= ~(module == TX ? (3<<3) : (3<<5));
|
||||
gpio |= (module == TX ? (band<<3) : (band<<5));
|
||||
gpio &= ~(module == BLADERF_MODULE_TX ? (3<<3) : (3<<5));
|
||||
gpio |= (module == BLADERF_MODULE_TX ? (band<<3) : (band<<5));
|
||||
bladerf_gpio_write(dev, gpio);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bladerf_set_frequency(struct bladerf *dev,
|
||||
bladerf_module_t module, unsigned int frequency)
|
||||
bladerf_module module, unsigned int frequency)
|
||||
{
|
||||
/* TODO: Make return values for lms call and return it for failure */
|
||||
lms_set_frequency( dev, module, frequency );
|
||||
|
|
@ -337,7 +337,7 @@ int bladerf_set_frequency(struct bladerf *dev,
|
|||
}
|
||||
|
||||
int bladerf_get_frequency(struct bladerf *dev,
|
||||
bladerf_module_t module, unsigned int *frequency)
|
||||
bladerf_module module, unsigned int *frequency)
|
||||
{
|
||||
/* TODO: Make return values for lms call and return it for failure */
|
||||
struct lms_freq f;
|
||||
|
|
@ -352,13 +352,13 @@ int bladerf_get_frequency(struct bladerf *dev,
|
|||
return rv;
|
||||
}
|
||||
|
||||
ssize_t bladerf_tx(struct bladerf *dev, bladerf_format_t format, void *samples,
|
||||
ssize_t bladerf_tx(struct bladerf *dev, bladerf_format format, void *samples,
|
||||
size_t num_samples, struct bladerf_metadata *metadata)
|
||||
{
|
||||
return dev->fn->tx(dev, format, samples, num_samples, metadata);
|
||||
}
|
||||
|
||||
ssize_t bladerf_rx(struct bladerf *dev, bladerf_format_t format, void *samples,
|
||||
ssize_t bladerf_rx(struct bladerf *dev, bladerf_format format, void *samples,
|
||||
size_t num_samples, struct bladerf_metadata *metadata)
|
||||
{
|
||||
return dev->fn->rx(dev, format, samples, num_samples, metadata);
|
||||
|
|
@ -369,7 +369,7 @@ int bladerf_init_stream(struct bladerf_stream **stream,
|
|||
bladerf_stream_cb callback,
|
||||
void ***buffers,
|
||||
size_t num_buffers,
|
||||
bladerf_format_t format,
|
||||
bladerf_format format,
|
||||
size_t samples_per_buffer,
|
||||
size_t num_transfers,
|
||||
void *user_data)
|
||||
|
|
@ -399,7 +399,7 @@ int bladerf_init_stream(struct bladerf_stream **stream,
|
|||
lstream->buffers = NULL;
|
||||
|
||||
switch(format) {
|
||||
case FORMAT_SC16:
|
||||
case BLADERF_FORMAT_SC16_Q12:
|
||||
buffer_size_bytes = c16_samples_to_bytes(samples_per_buffer);
|
||||
break;
|
||||
|
||||
|
|
@ -471,8 +471,8 @@ void bladerf_deinit_stream(struct bladerf_stream *stream)
|
|||
return ;
|
||||
}
|
||||
|
||||
int bladerf_stream(struct bladerf *dev, bladerf_module_t module,
|
||||
bladerf_format_t format, struct bladerf_stream *stream)
|
||||
int bladerf_stream(struct bladerf *dev, bladerf_module module,
|
||||
bladerf_format format, struct bladerf_stream *stream)
|
||||
{
|
||||
int status;
|
||||
|
||||
|
|
|
|||
|
|
@ -63,16 +63,16 @@ int bladerf_init_device(struct bladerf *dev)
|
|||
bladerf_lms_write( dev, 0x5a, 0xa0 );
|
||||
|
||||
/* Set a default saplerate */
|
||||
bladerf_set_sample_rate( dev, TX, 1000000, &actual );
|
||||
bladerf_set_sample_rate( dev, RX, 1000000, &actual );
|
||||
bladerf_set_sample_rate( dev, BLADERF_MODULE_TX, 1000000, &actual );
|
||||
bladerf_set_sample_rate( dev, BLADERF_MODULE_RX, 1000000, &actual );
|
||||
|
||||
/* Enable TX and RX */
|
||||
bladerf_enable_module( dev, TX, true );
|
||||
bladerf_enable_module( dev, RX, true );
|
||||
bladerf_enable_module( dev, BLADERF_MODULE_TX, true );
|
||||
bladerf_enable_module( dev, BLADERF_MODULE_RX, true );
|
||||
|
||||
/* Set a default frequency of 1GHz */
|
||||
bladerf_set_frequency( dev, TX, 1000000000 );
|
||||
bladerf_set_frequency( dev, RX, 1000000000 );
|
||||
bladerf_set_frequency( dev, BLADERF_MODULE_TX, 1000000000 );
|
||||
bladerf_set_frequency( dev, BLADERF_MODULE_RX, 1000000000 );
|
||||
|
||||
/* TODO: Read this return from the SPI calls */
|
||||
return 0;
|
||||
|
|
@ -80,7 +80,7 @@ int bladerf_init_device(struct bladerf *dev)
|
|||
|
||||
void bladerf_init_devinfo(struct bladerf_devinfo *d)
|
||||
{
|
||||
d->backend = BACKEND_ANY;
|
||||
d->backend = BLADERF_BACKEND_ANY;
|
||||
strcpy(d->serial, DEVINFO_SERIAL_ANY);
|
||||
d->usb_bus = DEVINFO_BUS_ANY;
|
||||
d->usb_addr = DEVINFO_ADDR_ANY;
|
||||
|
|
|
|||
|
|
@ -56,14 +56,14 @@ typedef enum {
|
|||
|
||||
struct bladerf_stream {
|
||||
struct bladerf *dev;
|
||||
bladerf_module_t module;
|
||||
bladerf_module module;
|
||||
int error_code;
|
||||
bladerf_stream_state state;
|
||||
|
||||
size_t samples_per_buffer;
|
||||
size_t num_buffers;
|
||||
size_t num_transfers;
|
||||
bladerf_format_t format;
|
||||
bladerf_format format;
|
||||
|
||||
void **buffers;
|
||||
void *backend_data;
|
||||
|
|
@ -119,10 +119,10 @@ struct bladerf_fn {
|
|||
int (*dac_write)(struct bladerf *dev, uint16_t value);
|
||||
|
||||
/* Sample stream */
|
||||
ssize_t (*rx)(struct bladerf *dev, bladerf_format_t format, void *samples, size_t n, struct bladerf_metadata *metadata);
|
||||
ssize_t (*tx)(struct bladerf *dev, bladerf_format_t format, void *samples, size_t n, struct bladerf_metadata *metadata);
|
||||
ssize_t (*rx)(struct bladerf *dev, bladerf_format format, void *samples, size_t n, struct bladerf_metadata *metadata);
|
||||
ssize_t (*tx)(struct bladerf *dev, bladerf_format format, void *samples, size_t n, struct bladerf_metadata *metadata);
|
||||
|
||||
int (*stream)(struct bladerf *dev, bladerf_module_t module, bladerf_format_t format, struct bladerf_stream *stream);
|
||||
int (*stream)(struct bladerf *dev, bladerf_module module, bladerf_format format, struct bladerf_stream *stream);
|
||||
|
||||
void (*deinit_stream)(struct bladerf_stream *stream);
|
||||
|
||||
|
|
@ -142,7 +142,7 @@ struct bladerf {
|
|||
struct bladerf_error error;
|
||||
|
||||
/* Type of the underlying driver and its private data */
|
||||
bladerf_backend_t backend_type;
|
||||
bladerf_backend backend_type;
|
||||
void *backend;
|
||||
|
||||
/* Driver-sppecific implementations */
|
||||
|
|
|
|||
|
|
@ -38,9 +38,9 @@ static int handle_backend(char *str, struct bladerf_devinfo *d)
|
|||
str_end[1] = '\0';
|
||||
|
||||
if (!strcasecmp("libusb", str)) {
|
||||
d->backend = BACKEND_LIBUSB;
|
||||
d->backend = BLADERF_BACKEND_LIBUSB;
|
||||
} else if (!strcasecmp("linux", str)) {
|
||||
d->backend = BACKEND_LINUX;
|
||||
d->backend = BLADERF_BACKEND_LINUX;
|
||||
} else {
|
||||
dbg_printf("Invalid backend: %s\n", str);
|
||||
status = BLADERF_ERR_INVAL;
|
||||
|
|
|
|||
|
|
@ -68,9 +68,9 @@ const uint8_t lms_reg_dumpset[] = {
|
|||
};
|
||||
|
||||
// When enabling an LPF, we must select both the module and the filter bandwidth
|
||||
void lms_lpf_enable(struct bladerf *dev, bladerf_module_t mod, lms_bw_t bw)
|
||||
void lms_lpf_enable(struct bladerf *dev, bladerf_module mod, lms_bw_t bw)
|
||||
{
|
||||
uint8_t reg = (mod == RX) ? 0x54 : 0x34;
|
||||
uint8_t reg = (mod == BLADERF_MODULE_RX) ? 0x54 : 0x34;
|
||||
uint8_t data;
|
||||
// Check to see which bandwidth we have selected
|
||||
bladerf_lms_read(dev, reg, &data);
|
||||
|
|
@ -91,9 +91,9 @@ void lms_lpf_enable(struct bladerf *dev, bladerf_module_t mod, lms_bw_t bw)
|
|||
return;
|
||||
}
|
||||
|
||||
void lms_lpf_bypass(struct bladerf *dev, bladerf_module_t mod)
|
||||
void lms_lpf_bypass(struct bladerf *dev, bladerf_module mod)
|
||||
{
|
||||
uint8_t reg = (mod == RX) ? 0x55 : 0x35;
|
||||
uint8_t reg = (mod == BLADERF_MODULE_RX) ? 0x55 : 0x35;
|
||||
uint8_t data;
|
||||
bladerf_lms_read(dev, reg, &data);
|
||||
data |= (1<<6);
|
||||
|
|
@ -102,9 +102,9 @@ void lms_lpf_bypass(struct bladerf *dev, bladerf_module_t mod)
|
|||
}
|
||||
|
||||
// Disable the LPF for a specific module
|
||||
void lms_lpf_disable(struct bladerf *dev, bladerf_module_t mod)
|
||||
void lms_lpf_disable(struct bladerf *dev, bladerf_module mod)
|
||||
{
|
||||
uint8_t reg = (mod == RX) ? 0x54 : 0x34;
|
||||
uint8_t reg = (mod == BLADERF_MODULE_RX) ? 0x54 : 0x34;
|
||||
uint8_t data;
|
||||
bladerf_lms_read(dev, reg, &data);
|
||||
data &= ~(1<<6);
|
||||
|
|
@ -113,10 +113,10 @@ void lms_lpf_disable(struct bladerf *dev, bladerf_module_t mod)
|
|||
}
|
||||
|
||||
// Get the bandwidth for the selected module
|
||||
lms_bw_t lms_get_bandwidth(struct bladerf *dev, bladerf_module_t mod)
|
||||
lms_bw_t lms_get_bandwidth(struct bladerf *dev, bladerf_module mod)
|
||||
{
|
||||
uint8_t data;
|
||||
uint8_t reg = (mod == RX) ? 0x54 : 0x34;
|
||||
uint8_t reg = (mod == BLADERF_MODULE_RX) ? 0x54 : 0x34;
|
||||
bladerf_lms_read(dev, reg, &data);
|
||||
data &= 0x3c;
|
||||
data >>= 2;
|
||||
|
|
@ -152,10 +152,10 @@ unsigned int lms_bw2uint(lms_bw_t bw)
|
|||
}
|
||||
|
||||
// Enable dithering on the module PLL
|
||||
void lms_dither_enable(struct bladerf *dev, bladerf_module_t mod, uint8_t nbits)
|
||||
void lms_dither_enable(struct bladerf *dev, bladerf_module mod, uint8_t nbits)
|
||||
{
|
||||
// Select the base address based on which PLL we are configuring
|
||||
uint8_t reg = (mod == RX) ? 0x24 : 0x14;
|
||||
uint8_t reg = (mod == BLADERF_MODULE_RX) ? 0x24 : 0x14;
|
||||
uint8_t data;
|
||||
|
||||
// Read what we currently have in there
|
||||
|
|
@ -176,9 +176,9 @@ void lms_dither_enable(struct bladerf *dev, bladerf_module_t mod, uint8_t nbits)
|
|||
}
|
||||
|
||||
// Disable dithering on the module PLL
|
||||
void lms_dither_disable(struct bladerf *dev, bladerf_module_t mod)
|
||||
void lms_dither_disable(struct bladerf *dev, bladerf_module mod)
|
||||
{
|
||||
uint8_t reg = (mod == RX) ? 0x24 : 0x14;
|
||||
uint8_t reg = (mod == BLADERF_MODULE_RX) ? 0x24 : 0x14;
|
||||
uint8_t data;
|
||||
bladerf_lms_read(dev, reg, &data);
|
||||
data &= ~(1<<7);
|
||||
|
|
@ -195,7 +195,7 @@ void lms_soft_reset(struct bladerf *dev)
|
|||
}
|
||||
|
||||
// Set the gain on the LNA
|
||||
void lms_lna_set_gain(struct bladerf *dev, bladerf_lna_gain_t gain)
|
||||
void lms_lna_set_gain(struct bladerf *dev, bladerf_lna_gain gain)
|
||||
{
|
||||
uint8_t data;
|
||||
bladerf_lms_read(dev, 0x75, &data);
|
||||
|
|
@ -205,13 +205,13 @@ void lms_lna_set_gain(struct bladerf *dev, bladerf_lna_gain_t gain)
|
|||
return;
|
||||
}
|
||||
|
||||
void lms_lna_get_gain(struct bladerf *dev, bladerf_lna_gain_t *gain)
|
||||
void lms_lna_get_gain(struct bladerf *dev, bladerf_lna_gain *gain)
|
||||
{
|
||||
uint8_t data;
|
||||
bladerf_lms_read(dev, 0x75, &data);
|
||||
data >>= 6;
|
||||
data &= 3;
|
||||
*gain = (bladerf_lna_gain_t)data;
|
||||
*gain = (bladerf_lna_gain)data;
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -469,12 +469,12 @@ void lms_tx_loopback_disable(struct bladerf *dev, lms_txlb_t mode)
|
|||
}
|
||||
|
||||
// Loopback enable
|
||||
void lms_loopback_enable(struct bladerf *dev, bladerf_loopback_t mode)
|
||||
void lms_loopback_enable(struct bladerf *dev, bladerf_loopback mode)
|
||||
{
|
||||
uint8_t data;
|
||||
switch(mode)
|
||||
{
|
||||
case LB_BB_LPF:
|
||||
case BLADERF_LB_BB_LPF:
|
||||
// Disable RXVGA1 first
|
||||
lms_rxvga1_disable(dev);
|
||||
|
||||
|
|
@ -483,29 +483,29 @@ void lms_loopback_enable(struct bladerf *dev, bladerf_loopback_t mode)
|
|||
bladerf_lms_write(dev, 0x08, 1<<6);
|
||||
break;
|
||||
|
||||
case LB_BB_VGA2:
|
||||
case BLADERF_LB_BB_VGA2:
|
||||
// Disable RXLPF first
|
||||
lms_lpf_disable(dev, RX);
|
||||
lms_lpf_disable(dev, BLADERF_MODULE_RX);
|
||||
|
||||
// Enable TX and RX loopback
|
||||
lms_tx_loopback_enable(dev, TXLB_BB);
|
||||
bladerf_lms_write(dev, 0x08, 1<<5);
|
||||
break;
|
||||
|
||||
case LB_BB_OP:
|
||||
case BLADERF_LB_BB_OP:
|
||||
// Disable RXLPF, RXVGA2, and RXVGA1
|
||||
lms_rxvga1_disable(dev);
|
||||
lms_rxvga2_disable(dev);
|
||||
lms_lpf_disable(dev, RX);
|
||||
lms_lpf_disable(dev, BLADERF_MODULE_RX);
|
||||
|
||||
// Enable TX and RX loopback
|
||||
lms_tx_loopback_enable(dev, TXLB_BB);
|
||||
bladerf_lms_write(dev, 0x08, 1<<4);
|
||||
break;
|
||||
|
||||
case LB_RF_LNA1:
|
||||
case LB_RF_LNA2:
|
||||
case LB_RF_LNA3:
|
||||
case BLADERF_LB_RF_LNA1:
|
||||
case BLADERF_LB_RF_LNA2:
|
||||
case BLADERF_LB_RF_LNA3:
|
||||
// Disable all LNAs
|
||||
lms_lna_select(dev, LNA_NONE);
|
||||
|
||||
|
|
@ -516,14 +516,14 @@ void lms_loopback_enable(struct bladerf *dev, bladerf_loopback_t mode)
|
|||
bladerf_lms_write(dev, 0x7d, data);
|
||||
|
||||
// Choose the LNA (1 = LNA1, 2 = LNA2, 3 = LNA3)
|
||||
bladerf_lms_write(dev, 0x08, (mode - LB_RF_LNA_START));
|
||||
bladerf_lms_write(dev, 0x08, (mode - BLADERF_LB_RF_LNA_START));
|
||||
|
||||
// Set magical decode test registers bit
|
||||
bladerf_lms_write(dev, 0x70, (1<<1));
|
||||
break;
|
||||
|
||||
case LB_RF_LNA_START:
|
||||
case LB_NONE:
|
||||
case BLADERF_LB_RF_LNA_START:
|
||||
case BLADERF_LB_NONE:
|
||||
// Weird
|
||||
break;
|
||||
}
|
||||
|
|
@ -531,32 +531,32 @@ void lms_loopback_enable(struct bladerf *dev, bladerf_loopback_t mode)
|
|||
}
|
||||
|
||||
// Figure out what loopback mode we're in (if any at all!)
|
||||
bladerf_loopback_t lms_get_loopback_mode(struct bladerf *dev)
|
||||
bladerf_loopback lms_get_loopback_mode(struct bladerf *dev)
|
||||
{
|
||||
uint8_t data;
|
||||
bladerf_loopback_t mode = LB_NONE;
|
||||
bladerf_loopback mode = BLADERF_LB_NONE;
|
||||
bladerf_lms_read(dev, 0x08, &data);
|
||||
if (data == 0)
|
||||
{
|
||||
mode = LB_NONE;
|
||||
mode = BLADERF_LB_NONE;
|
||||
} else if (data&(1<<6))
|
||||
{
|
||||
mode = LB_BB_LPF;
|
||||
mode = BLADERF_LB_BB_LPF;
|
||||
} else if (data&(1<<5))
|
||||
{
|
||||
mode = LB_BB_VGA2;
|
||||
mode = BLADERF_LB_BB_VGA2;
|
||||
} else if (data&(1<<4))
|
||||
{
|
||||
mode = LB_BB_OP;
|
||||
mode = BLADERF_LB_BB_OP;
|
||||
} else if ((data&0xf) == 1)
|
||||
{
|
||||
mode = LB_RF_LNA1;
|
||||
mode = BLADERF_LB_RF_LNA1;
|
||||
} else if ((data&0xf) == 2)
|
||||
{
|
||||
mode = LB_RF_LNA2;
|
||||
mode = BLADERF_LB_RF_LNA2;
|
||||
} else if ((data&0xf) == 3)
|
||||
{
|
||||
mode = LB_RF_LNA3;
|
||||
mode = BLADERF_LB_RF_LNA3;
|
||||
}
|
||||
return mode;
|
||||
}
|
||||
|
|
@ -565,43 +565,43 @@ bladerf_loopback_t lms_get_loopback_mode(struct bladerf *dev)
|
|||
void lms_loopback_disable(struct bladerf *dev, lms_lna_t lna, lms_bw_t bw)
|
||||
{
|
||||
// Read which type of loopback mode we were in
|
||||
bladerf_loopback_t mode = lms_get_loopback_mode(dev);
|
||||
bladerf_loopback mode = lms_get_loopback_mode(dev);
|
||||
|
||||
// Disable all RX loopback modes
|
||||
bladerf_lms_write(dev, 0x08, 0);
|
||||
|
||||
switch(mode)
|
||||
{
|
||||
case LB_BB_LPF:
|
||||
case BLADERF_LB_BB_LPF:
|
||||
// Disable TX baseband loopback
|
||||
lms_tx_loopback_disable(dev, TXLB_BB);
|
||||
// Enable RXVGA1
|
||||
lms_rxvga1_enable(dev);
|
||||
break;
|
||||
case LB_BB_VGA2:
|
||||
case BLADERF_LB_BB_VGA2:
|
||||
// Disable TX baseband loopback
|
||||
lms_tx_loopback_disable(dev, TXLB_BB);
|
||||
// Enable RXLPF
|
||||
lms_lpf_enable(dev, RX, bw);
|
||||
lms_lpf_enable(dev, BLADERF_MODULE_RX, bw);
|
||||
break;
|
||||
case LB_BB_OP:
|
||||
case BLADERF_LB_BB_OP:
|
||||
// Disable TX baseband loopback
|
||||
lms_tx_loopback_disable(dev, TXLB_BB);
|
||||
// Enable RXLPF, RXVGA1 and RXVGA2
|
||||
lms_lpf_enable(dev, RX, bw);
|
||||
lms_lpf_enable(dev, BLADERF_MODULE_RX, bw);
|
||||
lms_rxvga2_enable(dev, 30/3);
|
||||
lms_rxvga1_enable(dev);
|
||||
break;
|
||||
case LB_RF_LNA1:
|
||||
case LB_RF_LNA2:
|
||||
case LB_RF_LNA3:
|
||||
case BLADERF_LB_RF_LNA1:
|
||||
case BLADERF_LB_RF_LNA2:
|
||||
case BLADERF_LB_RF_LNA3:
|
||||
// Disable TX RF loopback
|
||||
lms_tx_loopback_disable(dev, TXLB_RF);
|
||||
// Enable selected LNA
|
||||
lms_lna_select(dev, lna);
|
||||
break;
|
||||
case LB_RF_LNA_START:
|
||||
case LB_NONE:
|
||||
case BLADERF_LB_RF_LNA_START:
|
||||
case BLADERF_LB_NONE:
|
||||
// Weird
|
||||
break;
|
||||
}
|
||||
|
|
@ -619,9 +619,9 @@ void lms_power_down(struct bladerf *dev)
|
|||
}
|
||||
|
||||
// Enable the PLL of a module
|
||||
void lms_pll_enable(struct bladerf *dev, bladerf_module_t mod)
|
||||
void lms_pll_enable(struct bladerf *dev, bladerf_module mod)
|
||||
{
|
||||
uint8_t reg = (mod == RX) ? 0x24 : 0x14;
|
||||
uint8_t reg = (mod == BLADERF_MODULE_RX) ? 0x24 : 0x14;
|
||||
uint8_t data;
|
||||
bladerf_lms_read(dev, reg, &data);
|
||||
data |= (1<<3);
|
||||
|
|
@ -630,9 +630,9 @@ void lms_pll_enable(struct bladerf *dev, bladerf_module_t mod)
|
|||
}
|
||||
|
||||
// Disable the PLL of a module
|
||||
void lms_pll_disable(struct bladerf *dev, bladerf_module_t mod)
|
||||
void lms_pll_disable(struct bladerf *dev, bladerf_module mod)
|
||||
{
|
||||
uint8_t reg = (mod == RX) ? 0x24 : 0x14;
|
||||
uint8_t reg = (mod == BLADERF_MODULE_RX) ? 0x24 : 0x14;
|
||||
uint8_t data;
|
||||
bladerf_lms_read(dev, reg, &data);
|
||||
data &= ~(1<<3);
|
||||
|
|
@ -704,8 +704,8 @@ void lms_print_frequency(struct lms_freq *f)
|
|||
}
|
||||
|
||||
// Get the frequency structure
|
||||
void lms_get_frequency(struct bladerf *dev, bladerf_module_t mod, struct lms_freq *f) {
|
||||
uint8_t base = (mod == RX) ? 0x20 : 0x10;
|
||||
void lms_get_frequency(struct bladerf *dev, bladerf_module mod, struct lms_freq *f) {
|
||||
uint8_t base = (mod == BLADERF_MODULE_RX) ? 0x20 : 0x10;
|
||||
uint8_t data;
|
||||
bladerf_lms_read(dev, base+0, &data);
|
||||
f->nint = ((uint16_t)data) << 1;
|
||||
|
|
@ -724,10 +724,10 @@ void lms_get_frequency(struct bladerf *dev, bladerf_module_t mod, struct lms_fre
|
|||
}
|
||||
|
||||
// Set the frequency of a module
|
||||
void lms_set_frequency(struct bladerf *dev, bladerf_module_t mod, uint32_t freq)
|
||||
void lms_set_frequency(struct bladerf *dev, bladerf_module mod, uint32_t freq)
|
||||
{
|
||||
// Select the base address based on which PLL we are configuring
|
||||
uint8_t base = (mod == RX) ? 0x20 : 0x10;
|
||||
uint8_t base = (mod == BLADERF_MODULE_RX) ? 0x20 : 0x10;
|
||||
uint32_t lfreq = freq;
|
||||
uint8_t freqsel = bands[0].value;
|
||||
uint16_t nint;
|
||||
|
|
@ -775,7 +775,7 @@ void lms_set_frequency(struct bladerf *dev, bladerf_module_t mod, uint32_t freq)
|
|||
lms_print_frequency(&f);
|
||||
|
||||
// Program freqsel, selout (rx only), nint and nfrac
|
||||
if (mod == RX) {
|
||||
if (mod == BLADERF_MODULE_RX) {
|
||||
bladerf_lms_write(dev, base+5, freqsel<<2 | (freq < 1500000000 ? 1 : 2));
|
||||
} else {
|
||||
bladerf_lms_write(dev, base+5, freqsel<<2);
|
||||
|
|
@ -961,13 +961,13 @@ int lms_config_init(struct bladerf *dev, struct lms_xcvr_config *config)
|
|||
bladerf_lms_write(dev, 0x48, 20);
|
||||
bladerf_lms_write(dev, 0x49, 20);
|
||||
|
||||
lms_set_frequency(dev, RX, config->rx_freq_hz);
|
||||
lms_set_frequency(dev, TX, config->tx_freq_hz);
|
||||
lms_set_frequency(dev, BLADERF_MODULE_RX, config->rx_freq_hz);
|
||||
lms_set_frequency(dev, BLADERF_MODULE_TX, config->tx_freq_hz);
|
||||
|
||||
lms_lna_select(dev, config->lna);
|
||||
lms_pa_enable(dev, config->pa);
|
||||
|
||||
if (config->loopback_mode == LB_NONE) {
|
||||
if (config->loopback_mode == BLADERF_LB_NONE) {
|
||||
lms_loopback_disable(dev, config->lna, config->tx_bw);
|
||||
} else {
|
||||
lms_loopback_enable(dev, config->loopback_mode);
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ typedef enum {
|
|||
struct lms_xcvr_config {
|
||||
uint32_t tx_freq_hz; /**< Transmit frequency in Hz */
|
||||
uint32_t rx_freq_hz; /**< Receive frequency in Hz */
|
||||
bladerf_loopback_t loopback_mode; /**< Loopback Mode */
|
||||
bladerf_loopback loopback_mode; /**< Loopback Mode */
|
||||
lms_lna_t lna; /**< LNA Selection */
|
||||
lms_pa_t pa; /**< PA Selection */
|
||||
lms_bw_t tx_bw; /**< Transmit Bandwidth */
|
||||
|
|
@ -120,7 +120,7 @@ unsigned int lms_bw2uint(lms_bw_t bw);
|
|||
* @param[in] mod Module to change
|
||||
* @param[in] bw Low-pass bandwidth selection
|
||||
*/
|
||||
void lms_lpf_enable(struct bladerf *dev, bladerf_module_t mod, lms_bw_t bw);
|
||||
void lms_lpf_enable(struct bladerf *dev, bladerf_module mod, lms_bw_t bw);
|
||||
|
||||
/**
|
||||
* Explicitly bypass the low-pass filter
|
||||
|
|
@ -128,7 +128,7 @@ void lms_lpf_enable(struct bladerf *dev, bladerf_module_t mod, lms_bw_t bw);
|
|||
* @param[in] dev Device handle
|
||||
* @param[in] mod Module to change
|
||||
*/
|
||||
void lms_lpf_bypass(struct bladerf *dev, bladerf_module_t mod);
|
||||
void lms_lpf_bypass(struct bladerf *dev, bladerf_module mod);
|
||||
|
||||
/**
|
||||
* Disable the LPF for a specific module
|
||||
|
|
@ -136,7 +136,7 @@ void lms_lpf_bypass(struct bladerf *dev, bladerf_module_t mod);
|
|||
* @param[in] dev Device handle
|
||||
* @param[in] mod Module to change
|
||||
*/
|
||||
void lms_lpf_disable(struct bladerf *dev, bladerf_module_t mod);
|
||||
void lms_lpf_disable(struct bladerf *dev, bladerf_module mod);
|
||||
|
||||
/**
|
||||
* Get the bandwidth for the selected module
|
||||
|
|
@ -147,7 +147,7 @@ void lms_lpf_disable(struct bladerf *dev, bladerf_module_t mod);
|
|||
*
|
||||
* @return the current bandwidth of the module
|
||||
*/
|
||||
lms_bw_t lms_get_bandwidth(struct bladerf *dev, bladerf_module_t mod);
|
||||
lms_bw_t lms_get_bandwidth(struct bladerf *dev, bladerf_module mod);
|
||||
|
||||
/**
|
||||
* Enable dithering on PLL in the module to help reduce any fractional spurs
|
||||
|
|
@ -157,7 +157,7 @@ lms_bw_t lms_get_bandwidth(struct bladerf *dev, bladerf_module_t mod);
|
|||
* @param[in] mod Module to change
|
||||
* @param[in] nbits Number of bits to dither (1 to 8)
|
||||
*/
|
||||
void lms_dither_enable(struct bladerf *dev, bladerf_module_t mod, uint8_t nbits);
|
||||
void lms_dither_enable(struct bladerf *dev, bladerf_module mod, uint8_t nbits);
|
||||
|
||||
/**
|
||||
* Disable dithering on PLL in the module.
|
||||
|
|
@ -165,7 +165,7 @@ void lms_dither_enable(struct bladerf *dev, bladerf_module_t mod, uint8_t nbits)
|
|||
* @param[in] dev Device handle
|
||||
* @param[in] mod Module to change
|
||||
*/
|
||||
void lms_dither_disable(struct bladerf *dev, bladerf_module_t mod);
|
||||
void lms_dither_disable(struct bladerf *dev, bladerf_module mod);
|
||||
|
||||
/**
|
||||
* Perform a soft reset of the LMS6002D device
|
||||
|
|
@ -183,7 +183,7 @@ void lms_soft_reset(struct bladerf *dev);
|
|||
* @param[in] dev Device handle
|
||||
* @param[in] gain Bypass, mid or max gain
|
||||
*/
|
||||
void lms_lna_set_gain(struct bladerf *dev, bladerf_lna_gain_t gain);
|
||||
void lms_lna_set_gain(struct bladerf *dev, bladerf_lna_gain gain);
|
||||
|
||||
/**
|
||||
* Get the gain of the LNA
|
||||
|
|
@ -191,7 +191,7 @@ void lms_lna_set_gain(struct bladerf *dev, bladerf_lna_gain_t gain);
|
|||
* @param[in] dev Device handle
|
||||
* @param[out] gain Bypass, mid or max gain
|
||||
*/
|
||||
void lms_lna_get_gain(struct bladerf *dev, bladerf_lna_gain_t *gain);
|
||||
void lms_lna_get_gain(struct bladerf *dev, bladerf_lna_gain *gain);
|
||||
|
||||
/**
|
||||
* Select which LNA to enable
|
||||
|
|
@ -382,7 +382,7 @@ void lms_tx_loopback_disable(struct bladerf *dev, lms_txlb_t mode);
|
|||
* @param[in] dev Device handle
|
||||
* @param[in] mode Loopback mode
|
||||
*/
|
||||
void lms_loopback_enable(struct bladerf *dev, bladerf_loopback_t mode);
|
||||
void lms_loopback_enable(struct bladerf *dev, bladerf_loopback mode);
|
||||
|
||||
/**
|
||||
* Figure out what loopback mode we're in (if any at all!)
|
||||
|
|
@ -391,7 +391,7 @@ void lms_loopback_enable(struct bladerf *dev, bladerf_loopback_t mode);
|
|||
*
|
||||
* @return the loopback mode the LMS6002D is currently in, if any.
|
||||
*/
|
||||
bladerf_loopback_t lms_get_loopback_mode(struct bladerf *dev);
|
||||
bladerf_loopback lms_get_loopback_mode(struct bladerf *dev);
|
||||
|
||||
/**
|
||||
* Disable loopback mode.
|
||||
|
|
@ -416,7 +416,7 @@ void lms_power_down(struct bladerf *dev);
|
|||
* @param[in] dev Device handle
|
||||
* @param[in] mod Module PLL to enable
|
||||
*/
|
||||
void lms_pll_enable(struct bladerf *dev, bladerf_module_t mod);
|
||||
void lms_pll_enable(struct bladerf *dev, bladerf_module mod);
|
||||
|
||||
/**
|
||||
* Disable the PLL of a module.
|
||||
|
|
@ -424,7 +424,7 @@ void lms_pll_enable(struct bladerf *dev, bladerf_module_t mod);
|
|||
* @param[in] dev Device handle
|
||||
* @param[in] mod Module PLL to disable
|
||||
*/
|
||||
void lms_pll_disable(struct bladerf *dev, bladerf_module_t mod);
|
||||
void lms_pll_disable(struct bladerf *dev, bladerf_module mod);
|
||||
|
||||
/**
|
||||
* Enable the RX subsystem
|
||||
|
|
@ -476,7 +476,7 @@ void lms_print_frequency(struct lms_freq *freq);
|
|||
* @param[in] mod Module to change
|
||||
* @param[out] freq LMS frequency structure detailing VCO settings
|
||||
*/
|
||||
void lms_get_frequency(struct bladerf *dev, bladerf_module_t mod,
|
||||
void lms_get_frequency(struct bladerf *dev, bladerf_module mod,
|
||||
struct lms_freq *freq);
|
||||
|
||||
/**
|
||||
|
|
@ -487,7 +487,7 @@ void lms_get_frequency(struct bladerf *dev, bladerf_module_t mod,
|
|||
* @param[in] freq Frequency in Hz to tune
|
||||
*/
|
||||
void lms_set_frequency(struct bladerf *dev,
|
||||
bladerf_module_t mod, uint32_t freq);
|
||||
bladerf_module mod, uint32_t freq);
|
||||
|
||||
/**
|
||||
* Read back every register from the LMS6002D device.
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ struct test_data
|
|||
size_t num_buffers; /* Number of buffers */
|
||||
size_t samples_per_buffer; /* Number of samples per buffer */
|
||||
unsigned int idx; /* The next one that needs to go out */
|
||||
bladerf_module_t module; /* Direction */
|
||||
bladerf_module module; /* Direction */
|
||||
FILE *fout; /* Output file (RX only) */
|
||||
ssize_t samples_left; /* Number of samples left */
|
||||
};
|
||||
|
|
@ -63,7 +63,7 @@ void *stream_callback(struct bladerf *dev, struct bladerf_stream *stream,
|
|||
}
|
||||
|
||||
/* Save off the samples to disk if we are in RX */
|
||||
if( my_data->module == RX ) {
|
||||
if( my_data->module == BLADERF_MODULE_RX ) {
|
||||
size_t i;
|
||||
int16_t *sample = samples ;
|
||||
for(i = 0; i < num_samples ; i++ ) {
|
||||
|
|
@ -142,9 +142,9 @@ int main(int argc, char *argv[])
|
|||
}
|
||||
|
||||
if (strcasecmp(argv[1], "rx") == 0 ) {
|
||||
test_data.module = RX ;
|
||||
test_data.module = BLADERF_MODULE_RX ;
|
||||
} else if (strcasecmp(argv[1], "tx") == 0 ) {
|
||||
test_data.module = TX;
|
||||
test_data.module = BLADERF_MODULE_TX;
|
||||
} else {
|
||||
fprintf(stderr, "Invalid module: %s\n", argv[1]);
|
||||
return EXIT_FAILURE;
|
||||
|
|
@ -165,7 +165,7 @@ int main(int argc, char *argv[])
|
|||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
if(test_data.module == RX && argc == 5) {
|
||||
if(test_data.module == BLADERF_MODULE_RX && argc == 5) {
|
||||
test_data.samples_left = str2int(argv[4], 1, INT_MAX, &conv_ok);
|
||||
if(!conv_ok) {
|
||||
fprintf(stderr, "Invalid number of samples: %s\n", argv[4]);
|
||||
|
|
@ -223,14 +223,14 @@ int main(int argc, char *argv[])
|
|||
stream_callback,
|
||||
&test_data.buffers,
|
||||
test_data.num_buffers,
|
||||
FORMAT_SC16,
|
||||
BLADERF_FORMAT_SC16_Q12,
|
||||
test_data.samples_per_buffer,
|
||||
test_data.num_buffers,
|
||||
&test_data
|
||||
) ;
|
||||
|
||||
/* Populate buffers with test data */
|
||||
if( test_data.module == TX ) {
|
||||
if( test_data.module == BLADERF_MODULE_TX ) {
|
||||
if (populate_test_data(&test_data) ) {
|
||||
fprintf(stderr, "Failed to populated test data\n");
|
||||
bladerf_deinit_stream(stream);
|
||||
|
|
@ -256,7 +256,9 @@ int main(int argc, char *argv[])
|
|||
|
||||
if (!status) {
|
||||
/* Start stream and stay there until we kill the stream */
|
||||
status = bladerf_stream(dev, test_data.module, FORMAT_SC16, stream);
|
||||
status = bladerf_stream(dev, test_data.module,
|
||||
BLADERF_FORMAT_SC16_Q12, stream);
|
||||
|
||||
if (status < 0) {
|
||||
fprintf(stderr, "Stream error: %s\n", bladerf_strerror(status));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,14 +58,14 @@ struct printset_entry printset_table[] = {
|
|||
{ .print = NULL, .set = NULL, .name = "" }
|
||||
};
|
||||
|
||||
bladerf_module_t get_module( char *mod, bool *ok )
|
||||
bladerf_module get_module( char *mod, bool *ok )
|
||||
{
|
||||
bladerf_module_t rv = RX;
|
||||
bladerf_module rv = BLADERF_MODULE_RX;
|
||||
*ok = true;
|
||||
if( strcasecmp( mod, "rx" ) == 0 ) {
|
||||
rv = RX;
|
||||
rv = BLADERF_MODULE_RX;
|
||||
} else if( strcasecmp( mod, "tx" ) == 0 ) {
|
||||
rv = TX;
|
||||
rv = BLADERF_MODULE_TX;
|
||||
} else {
|
||||
*ok = false;
|
||||
}
|
||||
|
|
@ -104,7 +104,7 @@ int print_bandwidth(struct cli_state *state, int argc, char **argv)
|
|||
{
|
||||
/* Usage: print bandwidth [rx|tx]*/
|
||||
int rv = CMD_RET_OK, status;
|
||||
bladerf_module_t module = RX ;
|
||||
bladerf_module module = BLADERF_MODULE_RX ;
|
||||
unsigned int bw ;
|
||||
|
||||
if( argc == 3 ) {
|
||||
|
|
@ -121,8 +121,8 @@ int print_bandwidth(struct cli_state *state, int argc, char **argv)
|
|||
|
||||
printf( "\n" ) ;
|
||||
|
||||
if( argc == 2 || module == RX ) {
|
||||
status = bladerf_get_bandwidth( state->dev, RX, &bw );
|
||||
if( argc == 2 || module == BLADERF_MODULE_RX ) {
|
||||
status = bladerf_get_bandwidth( state->dev, BLADERF_MODULE_RX, &bw );
|
||||
if (status < 0) {
|
||||
state->last_lib_error = status;
|
||||
rv = CMD_RET_LIBBLADERF;
|
||||
|
|
@ -131,8 +131,8 @@ int print_bandwidth(struct cli_state *state, int argc, char **argv)
|
|||
}
|
||||
}
|
||||
|
||||
if( argc == 2 || module == TX ) {
|
||||
status = bladerf_get_bandwidth( state->dev, TX, &bw );
|
||||
if( argc == 2 || module == BLADERF_MODULE_TX ) {
|
||||
status = bladerf_get_bandwidth( state->dev, BLADERF_MODULE_TX, &bw );
|
||||
if (status < 0) {
|
||||
state->last_lib_error = status;
|
||||
rv = CMD_RET_LIBBLADERF;
|
||||
|
|
@ -151,7 +151,7 @@ int set_bandwidth(struct cli_state *state, int argc, char **argv)
|
|||
/* Usage: set bandwidth [rx|tx] <bandwidth in Hz> */
|
||||
int rv = CMD_RET_OK;
|
||||
int status;
|
||||
bladerf_module_t module = RX;
|
||||
bladerf_module module = BLADERF_MODULE_RX;
|
||||
unsigned int bw = 28000000, actual;
|
||||
|
||||
/* Check for extended help */
|
||||
|
|
@ -203,24 +203,30 @@ int set_bandwidth(struct cli_state *state, int argc, char **argv)
|
|||
printf( "\n" );
|
||||
|
||||
/* Lack of option, so set both or RX only */
|
||||
if( argc == 3 || module == RX ) {
|
||||
status = bladerf_set_bandwidth( state->dev, RX, bw, &actual );
|
||||
if( argc == 3 || module == BLADERF_MODULE_RX ) {
|
||||
status = bladerf_set_bandwidth( state->dev, BLADERF_MODULE_RX,
|
||||
bw, &actual );
|
||||
|
||||
if (status < 0) {
|
||||
state->last_lib_error = status;
|
||||
rv = CMD_RET_LIBBLADERF;
|
||||
} else {
|
||||
printf( " Set RX bandwidth - req:%9uHz actual:%9uHz\n", bw, actual );
|
||||
printf( " Set RX bandwidth - req:%9uHz actual:%9uHz\n",
|
||||
bw, actual );
|
||||
}
|
||||
}
|
||||
|
||||
/* Lack of option, so set both or TX only */
|
||||
if( argc == 3 || module == TX ) {
|
||||
status = bladerf_set_bandwidth( state->dev, TX, bw, &actual );
|
||||
if( argc == 3 || module == BLADERF_MODULE_TX ) {
|
||||
status = bladerf_set_bandwidth( state->dev, BLADERF_MODULE_TX,
|
||||
bw, &actual );
|
||||
|
||||
if (status < 0) {
|
||||
state->last_lib_error = status;
|
||||
rv = CMD_RET_LIBBLADERF;
|
||||
} else {
|
||||
printf( " Set TX bandwidth - req:%9uHz actual:%9uHz\n", bw, actual );
|
||||
printf( " Set TX bandwidth - req:%9uHz actual:%9uHz\n",
|
||||
bw, actual );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -247,7 +253,7 @@ int print_frequency(struct cli_state *state, int argc, char **argv)
|
|||
int rv = CMD_RET_OK;
|
||||
int status;
|
||||
unsigned int freq;
|
||||
bladerf_module_t module = RX;
|
||||
bladerf_module module = BLADERF_MODULE_RX;
|
||||
if( argc == 3 ) {
|
||||
/* Parse module */
|
||||
bool ok;
|
||||
|
|
@ -262,8 +268,8 @@ int print_frequency(struct cli_state *state, int argc, char **argv)
|
|||
}
|
||||
|
||||
if( rv == CMD_RET_OK ) {
|
||||
if( argc == 2 || module == RX ) {
|
||||
status = bladerf_get_frequency( state->dev, RX, &freq );
|
||||
if( argc == 2 || module == BLADERF_MODULE_RX ) {
|
||||
status = bladerf_get_frequency( state->dev, BLADERF_MODULE_RX, &freq );
|
||||
if (status < 0) {
|
||||
state->last_lib_error = status;
|
||||
rv = CMD_RET_LIBBLADERF;
|
||||
|
|
@ -276,8 +282,8 @@ int print_frequency(struct cli_state *state, int argc, char **argv)
|
|||
}
|
||||
}
|
||||
|
||||
if( argc == 2 || module == TX ) {
|
||||
status = bladerf_get_frequency( state->dev, TX, &freq );
|
||||
if( argc == 2 || module == BLADERF_MODULE_TX ) {
|
||||
status = bladerf_get_frequency( state->dev, BLADERF_MODULE_TX, &freq );
|
||||
if (status < 0) {
|
||||
state->last_lib_error = status;
|
||||
rv = CMD_RET_LIBBLADERF;
|
||||
|
|
@ -300,7 +306,7 @@ int set_frequency(struct cli_state *state, int argc, char **argv)
|
|||
int rv = CMD_RET_OK;
|
||||
int status;
|
||||
unsigned int freq;
|
||||
bladerf_module_t module = RX;
|
||||
bladerf_module module = BLADERF_MODULE_RX;
|
||||
|
||||
if( argc == 4 ) {
|
||||
/* Parse module */
|
||||
|
|
@ -328,8 +334,10 @@ int set_frequency(struct cli_state *state, int argc, char **argv)
|
|||
printf( "\n" );
|
||||
|
||||
/* Change RX frequency */
|
||||
if( argc == 3 || module == RX ) {
|
||||
int status = bladerf_set_frequency( state->dev, RX, freq );
|
||||
if( argc == 3 || module == BLADERF_MODULE_RX ) {
|
||||
int status = bladerf_set_frequency( state->dev,
|
||||
BLADERF_MODULE_RX, freq );
|
||||
|
||||
if (status < 0) {
|
||||
state->last_lib_error = status;
|
||||
rv = CMD_RET_LIBBLADERF;
|
||||
|
|
@ -339,8 +347,10 @@ int set_frequency(struct cli_state *state, int argc, char **argv)
|
|||
}
|
||||
|
||||
/* Change TX frequency */
|
||||
if( argc == 3 || module == TX ) {
|
||||
status = bladerf_set_frequency( state->dev, TX, freq );
|
||||
if( argc == 3 || module == BLADERF_MODULE_TX ) {
|
||||
status = bladerf_set_frequency( state->dev,
|
||||
BLADERF_MODULE_TX, freq );
|
||||
|
||||
if (status < 0) {
|
||||
state->last_lib_error = status;
|
||||
rv = CMD_RET_LIBBLADERF;
|
||||
|
|
@ -441,7 +451,7 @@ int set_lna(struct cli_state *state, int argc, char **argv)
|
|||
int print_lnagain(struct cli_state *state, int argc, char **argv)
|
||||
{
|
||||
int rv = CMD_RET_OK, status;
|
||||
bladerf_lna_gain_t gain;
|
||||
bladerf_lna_gain gain;
|
||||
|
||||
status = bladerf_get_lna_gain( state->dev, &gain );
|
||||
if (status < 0) {
|
||||
|
|
@ -451,10 +461,21 @@ int print_lnagain(struct cli_state *state, int argc, char **argv)
|
|||
printf( "\n" );
|
||||
printf( " LNA Gain: ");
|
||||
switch(gain) {
|
||||
case LNA_UNKNOWN: printf( "LNA_UNKNOWN\n" ); break;
|
||||
case LNA_MID : printf( "LNA_MID\n" ); break;
|
||||
case LNA_MAX : printf( "LNA_MAX\n" ); break;
|
||||
case LNA_BYPASS : printf( "LNA_BYPASS\n"); break;
|
||||
case BLADERF_LNA_GAIN_UNKNOWN:
|
||||
printf( "BLADERF_LNA_GAIN_UNKNOWN\n" );
|
||||
break;
|
||||
|
||||
case BLADERF_LNA_GAIN_MID:
|
||||
printf( "BLADERF_LNA_GAIN_MID\n" );
|
||||
break;
|
||||
|
||||
case BLADERF_LNA_GAIN_MAX:
|
||||
printf( "BLADERF_LNA_GAIN_MAX\n" );
|
||||
break;
|
||||
|
||||
case BLADERF_LNA_GAIN_BYPASS:
|
||||
printf( "BLADERF_LNA_GAIN_BYPASS\n");
|
||||
break;
|
||||
}
|
||||
printf( "\n" ) ;
|
||||
}
|
||||
|
|
@ -470,18 +491,18 @@ int set_lnagain(struct cli_state *state, int argc, char **argv)
|
|||
if( argc != 3 ) {
|
||||
rv = CMD_RET_NARGS;
|
||||
} else {
|
||||
bladerf_lna_gain_t gain = LNA_UNKNOWN;
|
||||
bladerf_lna_gain gain = BLADERF_LNA_GAIN_UNKNOWN;
|
||||
if( strcasecmp( argv[2], "max" ) == 0 ) {
|
||||
gain = LNA_MAX;
|
||||
gain = BLADERF_LNA_GAIN_MAX;
|
||||
} else if( strcasecmp( argv[2], "mid" ) == 0 ) {
|
||||
gain = LNA_MID;
|
||||
gain = BLADERF_LNA_GAIN_MID;
|
||||
} else if( strcasecmp( argv[2], "bypass" ) == 0 ) {
|
||||
gain = LNA_BYPASS;
|
||||
gain = BLADERF_LNA_GAIN_BYPASS;
|
||||
} else {
|
||||
invalid_gain(state, argv[0], argv[1], argv[2]);
|
||||
}
|
||||
|
||||
if (gain != LNA_UNKNOWN) {
|
||||
if (gain != BLADERF_LNA_GAIN_UNKNOWN) {
|
||||
status = bladerf_set_lna_gain( state->dev, gain );
|
||||
if (status < 0) {
|
||||
state->last_lib_error = status;
|
||||
|
|
@ -628,7 +649,7 @@ int print_samplerate(struct cli_state *state, int argc, char **argv)
|
|||
{
|
||||
int status;
|
||||
unsigned int rate;
|
||||
bladerf_module_t module;
|
||||
bladerf_module module;
|
||||
bool ok;
|
||||
|
||||
if (argc == 3) {
|
||||
|
|
@ -638,14 +659,16 @@ int print_samplerate(struct cli_state *state, int argc, char **argv)
|
|||
status = CMD_RET_INVPARAM;
|
||||
} else {
|
||||
status = bladerf_get_sample_rate(state->dev, module, &rate);
|
||||
printf(" %s sample rate: %u\n", module == RX ? "RX" : "TX", rate);
|
||||
printf(" %s sample rate: %u\n",
|
||||
module == BLADERF_MODULE_RX ? "RX" : "TX", rate);
|
||||
}
|
||||
} else if (argc == 2) {
|
||||
unsigned int tx_rate;
|
||||
status = bladerf_get_sample_rate(state->dev, RX, &rate);
|
||||
status = bladerf_get_sample_rate(state->dev, BLADERF_MODULE_RX, &rate);
|
||||
|
||||
if (!status) {
|
||||
status = bladerf_get_sample_rate(state->dev, TX, &tx_rate);
|
||||
status = bladerf_get_sample_rate(state->dev,
|
||||
BLADERF_MODULE_TX, &tx_rate);
|
||||
|
||||
if (!status) {
|
||||
printf(" RX sample rate: %u\n", rate);
|
||||
|
|
@ -670,7 +693,7 @@ int set_samplerate(struct cli_state *state, int argc, char **argv)
|
|||
{
|
||||
/* Usage: set samplerate [rx|tx] <samplerate in Hz> */
|
||||
int rv = CMD_RET_OK;
|
||||
bladerf_module_t module = RX;
|
||||
bladerf_module module = BLADERF_MODULE_RX;
|
||||
|
||||
if( argc == 4 ) {
|
||||
/* Parse module */
|
||||
|
|
@ -694,9 +717,10 @@ int set_samplerate(struct cli_state *state, int argc, char **argv)
|
|||
rv = CMD_RET_INVPARAM;
|
||||
} else {
|
||||
printf( "\n" );
|
||||
if( argc == 3 || module == RX ) {
|
||||
if( argc == 3 || module == BLADERF_MODULE_RX ) {
|
||||
int status = bladerf_set_sample_rate( state->dev,
|
||||
RX, rate, &actual );
|
||||
BLADERF_MODULE_RX,
|
||||
rate, &actual );
|
||||
|
||||
if (status < 0) {
|
||||
state->last_lib_error = status;
|
||||
|
|
@ -707,8 +731,9 @@ int set_samplerate(struct cli_state *state, int argc, char **argv)
|
|||
}
|
||||
}
|
||||
|
||||
if( argc == 3 || module == TX ) {
|
||||
int status = bladerf_set_sample_rate( state->dev, TX,
|
||||
if( argc == 3 || module == BLADERF_MODULE_TX ) {
|
||||
int status = bladerf_set_sample_rate( state->dev,
|
||||
BLADERF_MODULE_TX,
|
||||
rate, &actual );
|
||||
if (status < 0) {
|
||||
state->last_lib_error = status;
|
||||
|
|
|
|||
|
|
@ -1,12 +1,12 @@
|
|||
#include <assert.h>
|
||||
#include "cmd.h"
|
||||
|
||||
static inline const char *backend2str(bladerf_backend_t b)
|
||||
static inline const char *backend2str(bladerf_backend b)
|
||||
{
|
||||
switch (b) {
|
||||
case BACKEND_LIBUSB:
|
||||
case BLADERF_BACKEND_LIBUSB:
|
||||
return "libusb";
|
||||
case BACKEND_LINUX:
|
||||
case BLADERF_BACKEND_LINUX:
|
||||
return "Linux kernel driver";
|
||||
default:
|
||||
return "Unknown";
|
||||
|
|
|
|||
|
|
@ -634,7 +634,7 @@ static void *rx_task(void *arg) {
|
|||
rx->common.buff_size / 2);*/
|
||||
lib_ret = bladerf_rx(
|
||||
s->dev,
|
||||
FORMAT_SC16,
|
||||
BLADERF_FORMAT_SC16_Q12,
|
||||
rx->common.buff,
|
||||
rx->common.buff_size/2,
|
||||
NULL
|
||||
|
|
@ -649,7 +649,7 @@ static void *rx_task(void *arg) {
|
|||
|
||||
lib_ret = bladerf_rx(
|
||||
s->dev,
|
||||
FORMAT_SC16,
|
||||
BLADERF_FORMAT_SC16_Q12,
|
||||
rx->common.buff,
|
||||
rx->common.buff_size/2,
|
||||
NULL
|
||||
|
|
@ -686,7 +686,7 @@ static void *rx_task(void *arg) {
|
|||
|
||||
if (state != RXTX_STATE_RUNNING && prev_state == RXTX_STATE_RUNNING) {
|
||||
/* Clean up as we transition from RUNNING -> <any other state> */
|
||||
lib_ret = bladerf_enable_module(s->dev, RX, false);
|
||||
lib_ret = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, false);
|
||||
close_samples_file(&rx->common, false);
|
||||
pthread_mutex_unlock(&rx->common.file_lock);
|
||||
|
||||
|
|
@ -772,7 +772,7 @@ static void *tx_task(void *arg) {
|
|||
*/
|
||||
lib_ret = bladerf_tx(
|
||||
s->dev,
|
||||
FORMAT_SC16,
|
||||
BLADERF_FORMAT_SC16_Q12,
|
||||
tx->common.buff,
|
||||
tx->common.buff_size/2,
|
||||
NULL
|
||||
|
|
@ -835,7 +835,7 @@ static void *tx_task(void *arg) {
|
|||
|
||||
/* Clean up as we transition from RUNNING -> <any other state> */
|
||||
if (state != RXTX_STATE_RUNNING && prev_state == RXTX_STATE_RUNNING) {
|
||||
lib_ret = bladerf_enable_module(s->dev, TX, false);
|
||||
lib_ret = bladerf_enable_module(s->dev, BLADERF_MODULE_TX, false);
|
||||
close_samples_file(&tx->common, false);
|
||||
pthread_mutex_unlock(&tx->common.file_lock);
|
||||
|
||||
|
|
@ -1141,7 +1141,7 @@ static int rx_start_init(struct cli_state *s)
|
|||
return CMD_RET_UNKNOWN;
|
||||
}
|
||||
|
||||
status = bladerf_enable_module(s->dev, RX, true);
|
||||
status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, true);
|
||||
if (status >= 0) {
|
||||
set_state(&rx->common, RXTX_STATE_RUNNING, true);
|
||||
|
||||
|
|
@ -1191,7 +1191,7 @@ static int tx_start_init(struct cli_state *s)
|
|||
return CMD_RET_UNKNOWN;
|
||||
}
|
||||
|
||||
status = bladerf_enable_module(s->dev, TX, true);
|
||||
status = bladerf_enable_module(s->dev, BLADERF_MODULE_TX, true);
|
||||
if (status >= 0) {
|
||||
set_state(&s->rxtx_data->tx.common, RXTX_STATE_RUNNING, true);
|
||||
|
||||
|
|
|
|||
|
|
@ -328,8 +328,8 @@ int main(int argc, char *argv[])
|
|||
/* Ensure we exit with RX & TX disabled.
|
||||
* Can't do much about an error at this point anyway... */
|
||||
if (state->dev) {
|
||||
bladerf_enable_module(state->dev, TX, false);
|
||||
bladerf_enable_module(state->dev, RX, false);
|
||||
bladerf_enable_module(state->dev, BLADERF_MODULE_TX, false);
|
||||
bladerf_enable_module(state->dev, BLADERF_MODULE_RX, false);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue