libbladeRF.h

Go to the documentation of this file.

#ifndef LIBBLADERF_H_
#define LIBBLADERF_H_

#include <inttypes.h>
#include <stdint.h>
#include <stdlib.h>

#define LIBBLADERF_API_VERSION (0x02020100)

#ifdef __cplusplus
extern "C" {
#else

#include <stdbool.h>
#endif

// clang-format off
#if defined _WIN32 || defined __CYGWIN__
# include <windows.h>
# define CALL_CONV __cdecl
# ifdef __GNUC__
# define API_EXPORT __attribute__ ((dllexport))
# else
# define API_EXPORT __declspec(dllexport)
# endif
#elif defined _DOXYGEN_ONLY_ || defined MATLAB_LINUX_THUNK_BUILD_

# define API_EXPORT

# define CALL_CONV
#else
# define API_EXPORT __attribute__ ((visibility ("default")))
# define CALL_CONV
#endif
// clang-format on

struct bladerf;

typedef enum {
 BLADERF_BACKEND_ANY, 
 BLADERF_BACKEND_LINUX, 
 BLADERF_BACKEND_LIBUSB, 
 BLADERF_BACKEND_CYPRESS, 
 BLADERF_BACKEND_DUMMY = 100, 
} bladerf_backend;

#define BLADERF_DESCRIPTION_LENGTH 33

#define BLADERF_SERIAL_LENGTH 33

struct bladerf_devinfo {
 bladerf_backend backend; 
 char serial[BLADERF_SERIAL_LENGTH]; 
 uint8_t usb_bus; 
 uint8_t usb_addr; 
 unsigned int instance; 
 char manufacturer[BLADERF_DESCRIPTION_LENGTH];
 char product[BLADERF_DESCRIPTION_LENGTH]; 
};

API_EXPORT
int CALL_CONV bladerf_open(struct bladerf **device,
 const char *device_identifier);

API_EXPORT
void CALL_CONV bladerf_close(struct bladerf *device);

API_EXPORT
int CALL_CONV bladerf_open_with_devinfo(struct bladerf **device,
 struct bladerf_devinfo *devinfo);

API_EXPORT
int CALL_CONV bladerf_get_device_list(struct bladerf_devinfo **devices);

API_EXPORT
void CALL_CONV bladerf_free_device_list(struct bladerf_devinfo *devices);

API_EXPORT
void CALL_CONV bladerf_init_devinfo(struct bladerf_devinfo *info);

API_EXPORT
int CALL_CONV bladerf_get_devinfo(struct bladerf *dev,
 struct bladerf_devinfo *info);

API_EXPORT
int CALL_CONV bladerf_get_devinfo_from_str(const char *devstr,
 struct bladerf_devinfo *info);

API_EXPORT
bool CALL_CONV bladerf_devinfo_matches(const struct bladerf_devinfo *a,
 const struct bladerf_devinfo *b);

API_EXPORT
bool CALL_CONV bladerf_devstr_matches(const char *dev_str,
 struct bladerf_devinfo *info);

API_EXPORT
const char *CALL_CONV bladerf_backend_str(bladerf_backend backend);

API_EXPORT
void CALL_CONV bladerf_set_usb_reset_on_open(bool enabled);

struct bladerf_range {
 int64_t min; 
 int64_t max; 
 int64_t step; 
 float scale; 
};

struct bladerf_serial {
 char serial[BLADERF_SERIAL_LENGTH]; 
};

struct bladerf_version {
 uint16_t major; 
 uint16_t minor; 
 uint16_t patch; 
 const char *describe; 
};

typedef enum {
 BLADERF_FPGA_UNKNOWN = 0, 
 BLADERF_FPGA_40KLE = 40, 
 BLADERF_FPGA_115KLE = 115, 
 BLADERF_FPGA_A4 = 49, 
 BLADERF_FPGA_A9 = 301 
} bladerf_fpga_size;

typedef enum {
 BLADERF_DEVICE_SPEED_UNKNOWN,
 BLADERF_DEVICE_SPEED_HIGH,
 BLADERF_DEVICE_SPEED_SUPER
} bladerf_dev_speed;

typedef enum {
 BLADERF_FPGA_SOURCE_UNKNOWN = 0, 
 BLADERF_FPGA_SOURCE_FLASH = 1, 
 BLADERF_FPGA_SOURCE_HOST = 2 
} bladerf_fpga_source;

API_EXPORT
int CALL_CONV bladerf_get_serial(struct bladerf *dev, char *serial);

API_EXPORT
int CALL_CONV bladerf_get_serial_struct(struct bladerf *dev,
 struct bladerf_serial *serial);

API_EXPORT
int CALL_CONV bladerf_get_fpga_size(struct bladerf *dev,
 bladerf_fpga_size *size);

API_EXPORT
int CALL_CONV bladerf_get_fpga_bytes(struct bladerf *dev, size_t *size);

API_EXPORT
int CALL_CONV bladerf_get_flash_size(struct bladerf *dev,
 uint32_t *size,
 bool *is_guess);

API_EXPORT
int CALL_CONV bladerf_fw_version(struct bladerf *dev,
 struct bladerf_version *version);

API_EXPORT
int CALL_CONV bladerf_is_fpga_configured(struct bladerf *dev);

API_EXPORT
int CALL_CONV bladerf_fpga_version(struct bladerf *dev,
 struct bladerf_version *version);

API_EXPORT
int CALL_CONV bladerf_get_fpga_source(struct bladerf *dev,
 bladerf_fpga_source *source);

API_EXPORT
bladerf_dev_speed CALL_CONV bladerf_device_speed(struct bladerf *dev);

API_EXPORT
const char *CALL_CONV bladerf_get_board_name(struct bladerf *dev);

typedef int bladerf_channel;

#define BLADERF_CHANNEL_RX(ch) (bladerf_channel)(((ch) << 1) | 0x0)

#define BLADERF_CHANNEL_TX(ch) (bladerf_channel)(((ch) << 1) | 0x1)

#define BLADERF_CHANNEL_INVALID (bladerf_channel)(-1)

#define BLADERF_DIRECTION_MASK (0x1)

/* Backwards compatible mapping to `bladerf_module`. */
typedef bladerf_channel bladerf_module;
#define BLADERF_MODULE_INVALID BLADERF_CHANNEL_INVALID
#define BLADERF_MODULE_RX BLADERF_CHANNEL_RX(0)
#define BLADERF_MODULE_TX BLADERF_CHANNEL_TX(0)

#define BLADERF_CHANNEL_IS_TX(ch) (ch & BLADERF_TX)

typedef enum {
 BLADERF_RX = 0, 
 BLADERF_TX = 1, 
} bladerf_direction;

typedef enum {
 BLADERF_RX_X1 = 0, 
 BLADERF_TX_X1 = 1, 
 BLADERF_RX_X2 = 2, 
 BLADERF_TX_X2 = 3, 
} bladerf_channel_layout;

API_EXPORT
size_t CALL_CONV bladerf_get_channel_count(struct bladerf *dev,
 bladerf_direction dir);

typedef int bladerf_gain;

typedef enum {
 BLADERF_GAIN_DEFAULT,

 BLADERF_GAIN_MGC,

 BLADERF_GAIN_FASTATTACK_AGC,

 BLADERF_GAIN_SLOWATTACK_AGC,

 BLADERF_GAIN_HYBRID_AGC,
} bladerf_gain_mode;

#define BLADERF_GAIN_AUTOMATIC BLADERF_GAIN_DEFAULT

#define BLADERF_GAIN_MANUAL BLADERF_GAIN_MGC

struct bladerf_gain_modes {
 const char *name; 
 bladerf_gain_mode mode; 
};

API_EXPORT
int CALL_CONV bladerf_set_gain(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_gain gain);

API_EXPORT
int CALL_CONV bladerf_get_gain(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_gain *gain);

API_EXPORT
int CALL_CONV bladerf_set_gain_mode(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_gain_mode mode);

API_EXPORT
int CALL_CONV bladerf_get_gain_mode(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_gain_mode *mode);

API_EXPORT
int CALL_CONV bladerf_get_gain_modes(struct bladerf *dev,
 bladerf_channel ch,
 const struct bladerf_gain_modes **modes);

API_EXPORT
int CALL_CONV bladerf_get_gain_range(struct bladerf *dev,
 bladerf_channel ch,
 const struct bladerf_range **range);

API_EXPORT
int CALL_CONV bladerf_set_gain_stage(struct bladerf *dev,
 bladerf_channel ch,
 const char *stage,
 bladerf_gain gain);

API_EXPORT
int CALL_CONV bladerf_get_gain_stage(struct bladerf *dev,
 bladerf_channel ch,
 const char *stage,
 bladerf_gain *gain);

API_EXPORT
int CALL_CONV bladerf_get_gain_stage_range(struct bladerf *dev,
 bladerf_channel ch,
 const char *stage,
 const struct bladerf_range **range);

API_EXPORT
int CALL_CONV bladerf_get_gain_stages(struct bladerf *dev,
 bladerf_channel ch,
 const char **stages,
 size_t count);

typedef unsigned int bladerf_sample_rate;

struct bladerf_rational_rate {
 uint64_t integer; 
 uint64_t num; 
 uint64_t den; 
};

API_EXPORT
int CALL_CONV bladerf_set_sample_rate(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_sample_rate rate,
 bladerf_sample_rate *actual);

API_EXPORT
int CALL_CONV
 bladerf_set_rational_sample_rate(struct bladerf *dev,
 bladerf_channel ch,
 struct bladerf_rational_rate *rate,
 struct bladerf_rational_rate *actual);
API_EXPORT
int CALL_CONV bladerf_get_sample_rate(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_sample_rate *rate);

API_EXPORT
int CALL_CONV bladerf_get_sample_rate_range(struct bladerf *dev,
 bladerf_channel ch,
 const struct bladerf_range **range);

API_EXPORT
int CALL_CONV
 bladerf_get_rational_sample_rate(struct bladerf *dev,
 bladerf_channel ch,
 struct bladerf_rational_rate *rate);

typedef unsigned int bladerf_bandwidth;

API_EXPORT
int CALL_CONV bladerf_set_bandwidth(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_bandwidth bandwidth,
 bladerf_bandwidth *actual);

API_EXPORT
int CALL_CONV bladerf_get_bandwidth(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_bandwidth *bandwidth);

API_EXPORT
int CALL_CONV bladerf_get_bandwidth_range(struct bladerf *dev,
 bladerf_channel ch,
 const struct bladerf_range **range);

typedef uint64_t bladerf_frequency;

#define BLADERF_PRIuFREQ PRIu64

#define BLADERF_PRIxFREQ PRIx64

#define BLADERF_SCNuFREQ SCNu64

#define BLADERF_SCNxFREQ SCNx64

API_EXPORT
int CALL_CONV bladerf_select_band(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_frequency frequency);

API_EXPORT
int CALL_CONV bladerf_set_frequency(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_frequency frequency);
API_EXPORT
int CALL_CONV bladerf_get_frequency(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_frequency *frequency);

API_EXPORT
int CALL_CONV bladerf_get_frequency_range(struct bladerf *dev,
 bladerf_channel ch,
 const struct bladerf_range **range);

typedef enum {
 BLADERF_LB_NONE = 0,

 BLADERF_LB_FIRMWARE,

 BLADERF_LB_BB_TXLPF_RXVGA2,

 BLADERF_LB_BB_TXVGA1_RXVGA2,

 BLADERF_LB_BB_TXLPF_RXLPF,

 BLADERF_LB_BB_TXVGA1_RXLPF,

 BLADERF_LB_RF_LNA1,

 BLADERF_LB_RF_LNA2,

 BLADERF_LB_RF_LNA3,

 BLADERF_LB_RFIC_BIST,
} bladerf_loopback;

struct bladerf_loopback_modes {
 const char *name; 
 bladerf_loopback mode; 
};

API_EXPORT
int CALL_CONV bladerf_get_loopback_modes(
 struct bladerf *dev, const struct bladerf_loopback_modes **modes);

API_EXPORT bool CALL_CONV bladerf_is_loopback_mode_supported(
 struct bladerf *dev, bladerf_loopback mode);

API_EXPORT
int CALL_CONV bladerf_set_loopback(struct bladerf *dev, bladerf_loopback lb);

API_EXPORT
int CALL_CONV bladerf_get_loopback(struct bladerf *dev, bladerf_loopback *lb);

typedef enum {
 BLADERF_TRIGGER_ROLE_INVALID = -1,

 BLADERF_TRIGGER_ROLE_DISABLED,

 BLADERF_TRIGGER_ROLE_MASTER,

 BLADERF_TRIGGER_ROLE_SLAVE,
} bladerf_trigger_role;

typedef enum {
 BLADERF_TRIGGER_INVALID = -1, 
 BLADERF_TRIGGER_J71_4, 
 BLADERF_TRIGGER_J51_1, 
 BLADERF_TRIGGER_MINI_EXP_1, 
 BLADERF_TRIGGER_USER_0 = 128, 
 BLADERF_TRIGGER_USER_1, 
 BLADERF_TRIGGER_USER_2, 
 BLADERF_TRIGGER_USER_3, 
 BLADERF_TRIGGER_USER_4, 
 BLADERF_TRIGGER_USER_5, 
 BLADERF_TRIGGER_USER_6, 
 BLADERF_TRIGGER_USER_7, 
} bladerf_trigger_signal;

struct bladerf_trigger {
 bladerf_channel channel; 
 bladerf_trigger_role role; 
 bladerf_trigger_signal signal; 
 uint64_t options; 
};

API_EXPORT
int CALL_CONV bladerf_trigger_init(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_trigger_signal signal,
 struct bladerf_trigger *trigger);

API_EXPORT
int CALL_CONV bladerf_trigger_arm(struct bladerf *dev,
 const struct bladerf_trigger *trigger,
 bool arm,
 uint64_t resv1,
 uint64_t resv2);

API_EXPORT
int CALL_CONV bladerf_trigger_fire(struct bladerf *dev,
 const struct bladerf_trigger *trigger);

API_EXPORT
int CALL_CONV bladerf_trigger_state(struct bladerf *dev,
 const struct bladerf_trigger *trigger,
 bool *is_armed,
 bool *has_fired,
 bool *fire_requested,
 uint64_t *resv1,
 uint64_t *resv2);

typedef enum {
 BLADERF_RX_MUX_INVALID = -1,

 BLADERF_RX_MUX_BASEBAND = 0x0,

 BLADERF_RX_MUX_12BIT_COUNTER = 0x1,

 BLADERF_RX_MUX_32BIT_COUNTER = 0x2,

 /* RX_MUX setting 0x3 is reserved for future use */

 BLADERF_RX_MUX_DIGITAL_LOOPBACK = 0x4,
} bladerf_rx_mux;

/* Backwards compatible mapping for `bladerf_rx_mux`. */
#define BLADERF_RX_MUX_BASEBAND_LMS BLADERF_RX_MUX_BASEBAND

API_EXPORT
int CALL_CONV bladerf_set_rx_mux(struct bladerf *dev, bladerf_rx_mux mux);

API_EXPORT
int CALL_CONV bladerf_get_rx_mux(struct bladerf *dev, bladerf_rx_mux *mode);

typedef uint64_t bladerf_timestamp;

#define BLADERF_RETUNE_NOW (bladerf_timestamp)0

struct bladerf_quick_tune {
 union {
 /* bladeRF1 quick tune parameters */
 struct {
 uint8_t freqsel; 
 uint8_t vcocap; 
 uint16_t nint; 
 uint32_t nfrac; 
 uint8_t flags; 
 uint8_t xb_gpio; 
 };
 /* bladeRF2 quick tune parameters */
 struct {
 uint16_t nios_profile; 
 uint8_t rffe_profile; 
 uint8_t port; 
 uint8_t spdt; 
 };
 };
};

API_EXPORT
int CALL_CONV bladerf_schedule_retune(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_timestamp timestamp,
 bladerf_frequency frequency,
 struct bladerf_quick_tune *quick_tune);

API_EXPORT
int CALL_CONV bladerf_cancel_scheduled_retunes(struct bladerf *dev,
 bladerf_channel ch);

API_EXPORT
int CALL_CONV bladerf_get_quick_tune(struct bladerf *dev,
 bladerf_channel ch,
 struct bladerf_quick_tune *quick_tune);

typedef int16_t bladerf_correction_value;

typedef enum {
 BLADERF_CORR_DCOFF_I,

 BLADERF_CORR_DCOFF_Q,

 BLADERF_CORR_PHASE,

 BLADERF_CORR_GAIN
} bladerf_correction;

/* Backwards compatible mapping to `bladerf_correction`. */
#define BLADERF_CORR_LMS_DCOFF_I BLADERF_CORR_DCOFF_I
#define BLADERF_CORR_LMS_DCOFF_Q BLADERF_CORR_DCOFF_Q
#define BLADERF_CORR_FPGA_PHASE BLADERF_CORR_PHASE
#define BLADERF_CORR_FPGA_GAIN BLADERF_CORR_GAIN

API_EXPORT
int CALL_CONV bladerf_set_correction(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_correction corr,
 bladerf_correction_value value);

API_EXPORT
int CALL_CONV bladerf_get_correction(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_correction corr,
 bladerf_correction_value *value);

#define BLADERF_PRIuTS PRIu64

#define BLADERF_PRIxTS PRIx64

#define BLADERF_SCNuTS SCNu64

#define BLADERF_SCNxTS SCNx64

typedef enum {
 BLADERF_FORMAT_SC16_Q11,

 BLADERF_FORMAT_SC16_Q11_META,
} bladerf_format;

/*
 * Metadata status bits
 *
 * These are used in conjunction with the bladerf_metadata structure's `status`
 * field.
 */

#define BLADERF_META_STATUS_OVERRUN (1 << 0)

#define BLADERF_META_STATUS_UNDERRUN (1 << 1)

/*
 * Metadata flags
 *
 * These are used in conjunction with the bladerf_metadata structure's `flags`
 * field.
 */

#define BLADERF_META_FLAG_TX_BURST_START (1 << 0)

#define BLADERF_META_FLAG_TX_BURST_END (1 << 1)

#define BLADERF_META_FLAG_TX_NOW (1 << 2)

#define BLADERF_META_FLAG_TX_UPDATE_TIMESTAMP (1 << 3)

#define BLADERF_META_FLAG_RX_NOW (1 << 31)

#define BLADERF_META_FLAG_RX_HW_UNDERFLOW (1 << 0)

#define BLADERF_META_FLAG_RX_HW_MINIEXP1 (1 << 16)

#define BLADERF_META_FLAG_RX_HW_MINIEXP2 (1 << 17)

struct bladerf_metadata {
 bladerf_timestamp timestamp;

 uint32_t flags;

 uint32_t status;

 unsigned int actual_count;

 uint8_t reserved[32];
};

API_EXPORT
int CALL_CONV bladerf_interleave_stream_buffer(bladerf_channel_layout layout,
 bladerf_format format,
 unsigned int buffer_size,
 void *samples);

API_EXPORT
int CALL_CONV bladerf_deinterleave_stream_buffer(bladerf_channel_layout layout,
 bladerf_format format,
  unsigned int buffer_size,
 void *samples);

API_EXPORT
int CALL_CONV bladerf_enable_module(struct bladerf *dev,
 bladerf_channel ch,
 bool enable);

API_EXPORT
int CALL_CONV bladerf_get_timestamp(struct bladerf *dev,
 bladerf_direction dir,
 bladerf_timestamp *timestamp);

API_EXPORT
int CALL_CONV bladerf_sync_config(struct bladerf *dev,
 bladerf_channel_layout layout,
 bladerf_format format,
 unsigned int num_buffers,
 unsigned int buffer_size,
 unsigned int num_transfers,
 unsigned int stream_timeout);

API_EXPORT
int CALL_CONV bladerf_sync_tx(struct bladerf *dev,
 const void *samples,
 unsigned int num_samples,
 struct bladerf_metadata *metadata,
 unsigned int timeout_ms);

API_EXPORT
int CALL_CONV bladerf_sync_rx(struct bladerf *dev,
 void *samples,
 unsigned int num_samples,
 struct bladerf_metadata *metadata,
 unsigned int timeout_ms);


#define BLADERF_STREAM_SHUTDOWN (NULL)

#define BLADERF_STREAM_NO_DATA ((void *)(-1))

struct bladerf_stream;

typedef void *(*bladerf_stream_cb)(struct bladerf *dev,
 struct bladerf_stream *stream,
 struct bladerf_metadata *meta,
 void *samples,
 size_t num_samples,
 void *user_data);

API_EXPORT
int CALL_CONV bladerf_init_stream(struct bladerf_stream **stream,
 struct bladerf *dev,
 bladerf_stream_cb callback,
 void ***buffers,
 size_t num_buffers,
 bladerf_format format,
 size_t samples_per_buffer,
 size_t num_transfers,
 void *user_data);

API_EXPORT
int CALL_CONV bladerf_stream(struct bladerf_stream *stream,
 bladerf_channel_layout layout);

API_EXPORT
int CALL_CONV bladerf_submit_stream_buffer(struct bladerf_stream *stream,
 void *buffer,
 unsigned int timeout_ms);

API_EXPORT
int CALL_CONV bladerf_submit_stream_buffer_nb(struct bladerf_stream *stream,
 void *buffer);


API_EXPORT
void CALL_CONV bladerf_deinit_stream(struct bladerf_stream *stream);

API_EXPORT
int CALL_CONV bladerf_set_stream_timeout(struct bladerf *dev,
 bladerf_direction dir,
 unsigned int timeout);

API_EXPORT
int CALL_CONV bladerf_get_stream_timeout(struct bladerf *dev,
 bladerf_direction dir,
 unsigned int *timeout);

API_EXPORT
int CALL_CONV bladerf_flash_firmware(struct bladerf *dev, const char *firmware);

API_EXPORT
int CALL_CONV bladerf_load_fpga(struct bladerf *dev, const char *fpga);

API_EXPORT
int CALL_CONV bladerf_flash_fpga(struct bladerf *dev, const char *fpga_image);

API_EXPORT
int CALL_CONV bladerf_erase_stored_fpga(struct bladerf *dev);

API_EXPORT
int CALL_CONV bladerf_device_reset(struct bladerf *dev);

API_EXPORT
int CALL_CONV bladerf_get_fw_log(struct bladerf *dev, const char *filename);

API_EXPORT
int CALL_CONV bladerf_jump_to_bootloader(struct bladerf *dev);

API_EXPORT
int CALL_CONV bladerf_get_bootloader_list(struct bladerf_devinfo **list);

API_EXPORT
int CALL_CONV bladerf_load_fw_from_bootloader(const char *device_identifier,
 bladerf_backend backend,
 uint8_t bus,
 uint8_t addr,
 const char *file);

typedef enum {
 BLADERF_IMAGE_TYPE_INVALID = -1, 
 BLADERF_IMAGE_TYPE_RAW, 
 BLADERF_IMAGE_TYPE_FIRMWARE, 
 BLADERF_IMAGE_TYPE_FPGA_40KLE, 
 BLADERF_IMAGE_TYPE_FPGA_115KLE, 
 BLADERF_IMAGE_TYPE_FPGA_A4, 
 BLADERF_IMAGE_TYPE_FPGA_A9, 
 BLADERF_IMAGE_TYPE_CALIBRATION, 
 BLADERF_IMAGE_TYPE_RX_DC_CAL, 
 BLADERF_IMAGE_TYPE_TX_DC_CAL, 
 BLADERF_IMAGE_TYPE_RX_IQ_CAL, 
 BLADERF_IMAGE_TYPE_TX_IQ_CAL, 
} bladerf_image_type;

#define BLADERF_IMAGE_MAGIC_LEN 7

#define BLADERF_IMAGE_CHECKSUM_LEN 32

#define BLADERF_IMAGE_RESERVED_LEN 128

struct bladerf_image {
 char magic[BLADERF_IMAGE_MAGIC_LEN + 1];

 uint8_t checksum[BLADERF_IMAGE_CHECKSUM_LEN];

 struct bladerf_version version;

 uint64_t timestamp;

 char serial[BLADERF_SERIAL_LENGTH + 1];

 char reserved[BLADERF_IMAGE_RESERVED_LEN];

 bladerf_image_type type;

 uint32_t address;

 uint32_t length;

 uint8_t *data;
};

API_EXPORT
struct bladerf_image *CALL_CONV bladerf_alloc_image(struct bladerf *dev,
 bladerf_image_type type,
 uint32_t address,
 uint32_t length);

API_EXPORT
struct bladerf_image *CALL_CONV bladerf_alloc_cal_image(
 struct bladerf *dev, bladerf_fpga_size fpga_size, uint16_t vctcxo_trim);

API_EXPORT
void CALL_CONV bladerf_free_image(struct bladerf_image *image);

API_EXPORT
int CALL_CONV bladerf_image_write(struct bladerf *dev,
 struct bladerf_image *image,
 const char *file);

API_EXPORT
int CALL_CONV bladerf_image_read(struct bladerf_image *image, const char *file);

typedef enum {
 BLADERF_VCTCXO_TAMER_INVALID = -1,

 BLADERF_VCTCXO_TAMER_DISABLED = 0,

 BLADERF_VCTCXO_TAMER_1_PPS = 1,

 BLADERF_VCTCXO_TAMER_10_MHZ = 2
} bladerf_vctcxo_tamer_mode;

API_EXPORT
int CALL_CONV bladerf_set_vctcxo_tamer_mode(struct bladerf *dev,
 bladerf_vctcxo_tamer_mode mode);

API_EXPORT
int CALL_CONV bladerf_get_vctcxo_tamer_mode(struct bladerf *dev,
 bladerf_vctcxo_tamer_mode *mode);

API_EXPORT
int CALL_CONV bladerf_get_vctcxo_trim(struct bladerf *dev, uint16_t *trim);

API_EXPORT
int CALL_CONV bladerf_trim_dac_write(struct bladerf *dev, uint16_t val);

API_EXPORT
int CALL_CONV bladerf_trim_dac_read(struct bladerf *dev, uint16_t *val);

typedef enum {
 BLADERF_TUNING_MODE_INVALID = -1,

 BLADERF_TUNING_MODE_HOST,

 BLADERF_TUNING_MODE_FPGA,
} bladerf_tuning_mode;

API_EXPORT
int CALL_CONV bladerf_set_tuning_mode(struct bladerf *dev,
 bladerf_tuning_mode mode);

API_EXPORT
int CALL_CONV bladerf_get_tuning_mode(struct bladerf *dev,
 bladerf_tuning_mode *mode);

#define BLADERF_TRIGGER_REG_ARM ((uint8_t)(1 << 0))

#define BLADERF_TRIGGER_REG_FIRE ((uint8_t)(1 << 1))

#define BLADERF_TRIGGER_REG_MASTER ((uint8_t)(1 << 2))

#define BLADERF_TRIGGER_REG_LINE ((uint8_t)(1 << 3))

API_EXPORT
int CALL_CONV bladerf_read_trigger(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_trigger_signal signal,
 uint8_t *val);

API_EXPORT
int CALL_CONV bladerf_write_trigger(struct bladerf *dev,
 bladerf_channel ch,
 bladerf_trigger_signal signal,
 uint8_t val);

API_EXPORT
int CALL_CONV bladerf_config_gpio_read(struct bladerf *dev, uint32_t *val);

API_EXPORT
int CALL_CONV bladerf_config_gpio_write(struct bladerf *dev, uint32_t val);

API_EXPORT
int CALL_CONV bladerf_erase_flash(struct bladerf *dev,
 uint32_t erase_block,
 uint32_t count);

API_EXPORT
int CALL_CONV bladerf_erase_flash_bytes(struct bladerf *dev,
 uint32_t address,
 uint32_t length);

API_EXPORT
int CALL_CONV bladerf_read_flash(struct bladerf *dev,
 uint8_t *buf,
 uint32_t page,
 uint32_t count);

API_EXPORT
int CALL_CONV bladerf_read_flash_bytes(struct bladerf *dev,
 uint8_t *buf,
 uint32_t address,
 uint32_t bytes);

API_EXPORT
int CALL_CONV bladerf_write_flash(struct bladerf *dev,
 const uint8_t *buf,
 uint32_t page,
 uint32_t count);

API_EXPORT
int CALL_CONV bladerf_write_flash_bytes(struct bladerf *dev,
 const uint8_t *buf,
 uint32_t address,
 uint32_t length);

API_EXPORT
int CALL_CONV bladerf_lock_otp(struct bladerf *dev);

API_EXPORT
int CALL_CONV bladerf_read_otp(struct bladerf *dev,
 uint8_t *buf);

API_EXPORT
int CALL_CONV bladerf_write_otp(struct bladerf *dev,
 uint8_t *buf);

API_EXPORT
int CALL_CONV bladerf_set_rf_port(struct bladerf *dev,
 bladerf_channel ch,
 const char *port);

API_EXPORT
int CALL_CONV bladerf_get_rf_port(struct bladerf *dev,
 bladerf_channel ch,
 const char **port);

API_EXPORT
int CALL_CONV bladerf_get_rf_ports(struct bladerf *dev,
 bladerf_channel ch,
 const char **ports,
 unsigned int count);

typedef enum {
 BLADERF_XB_NONE = 0, 
 BLADERF_XB_100, 
 BLADERF_XB_200, 
 BLADERF_XB_300 
} bladerf_xb;

API_EXPORT
int CALL_CONV bladerf_expansion_attach(struct bladerf *dev, bladerf_xb xb);

API_EXPORT
int CALL_CONV bladerf_expansion_get_attached(struct bladerf *dev,
 bladerf_xb *xb);

typedef enum {
 BLADERF_LOG_LEVEL_VERBOSE, 
 BLADERF_LOG_LEVEL_DEBUG, 
 BLADERF_LOG_LEVEL_INFO, 
 BLADERF_LOG_LEVEL_WARNING, 
 BLADERF_LOG_LEVEL_ERROR, 
 BLADERF_LOG_LEVEL_CRITICAL, 
 BLADERF_LOG_LEVEL_SILENT 
} bladerf_log_level;

API_EXPORT
void CALL_CONV bladerf_log_set_verbosity(bladerf_log_level level);

API_EXPORT
void CALL_CONV bladerf_version(struct bladerf_version *version);

// clang-format off
#define BLADERF_ERR_UNEXPECTED (-1) 
#define BLADERF_ERR_RANGE (-2) 
#define BLADERF_ERR_INVAL (-3) 
#define BLADERF_ERR_MEM (-4) 
#define BLADERF_ERR_IO (-5) 
#define BLADERF_ERR_TIMEOUT (-6) 
#define BLADERF_ERR_NODEV (-7) 
#define BLADERF_ERR_UNSUPPORTED (-8) 
#define BLADERF_ERR_MISALIGNED (-9) 
#define BLADERF_ERR_CHECKSUM (-10) 
#define BLADERF_ERR_NO_FILE (-11) 
#define BLADERF_ERR_UPDATE_FPGA (-12) 
#define BLADERF_ERR_UPDATE_FW (-13) 
#define BLADERF_ERR_TIME_PAST (-14) 
#define BLADERF_ERR_QUEUE_FULL (-15) 
#define BLADERF_ERR_FPGA_OP (-16) 
#define BLADERF_ERR_PERMISSION (-17) 
#define BLADERF_ERR_WOULD_BLOCK (-18) 
#define BLADERF_ERR_NOT_INIT (-19) 
// clang-format on

API_EXPORT
const char *CALL_CONV bladerf_strerror(int error);

#include <bladeRF1.h>
#include <bladeRF2.h>

#ifdef __cplusplus
}
#endif

#endif /* LIBBLADERF_H_ */