diff options
Diffstat (limited to 'Radio/HW/AirSpy/src')
| -rw-r--r-- | Radio/HW/AirSpy/src/airspy.c | 2011 | ||||
| -rw-r--r-- | Radio/HW/AirSpy/src/airspy.h | 224 | ||||
| -rw-r--r-- | Radio/HW/AirSpy/src/airspy_commands.h | 145 | ||||
| -rw-r--r-- | Radio/HW/AirSpy/src/filters.h | 134 | ||||
| -rw-r--r-- | Radio/HW/AirSpy/src/iqconverter_float.c | 502 | ||||
| -rw-r--r-- | Radio/HW/AirSpy/src/iqconverter_float.h | 47 | ||||
| -rw-r--r-- | Radio/HW/AirSpy/src/iqconverter_int16.c | 205 | ||||
| -rw-r--r-- | Radio/HW/AirSpy/src/iqconverter_int16.h | 45 |
8 files changed, 3313 insertions, 0 deletions
diff --git a/Radio/HW/AirSpy/src/airspy.c b/Radio/HW/AirSpy/src/airspy.c new file mode 100644 index 0000000..02c1542 --- /dev/null +++ b/Radio/HW/AirSpy/src/airspy.c @@ -0,0 +1,2011 @@ +/* +Copyright (c) 2013, Michael Ossmann <mike@ossmann.com> +Copyright (c) 2012, Jared Boone <jared@sharebrained.com> +Copyright (c) 2014, Youssef Touil <youssef@airspy.com> +Copyright (c) 2014, Benjamin Vernoux <bvernoux@airspy.com> +Copyright (c) 2015, Ian Gilmour <ian@sdrsharp.com> + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + Neither the name of AirSpy nor the names of its contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "libusb.h" + +#if _MSC_VER > 1700 // To avoid error with Visual Studio 2017/2019 or more define which define timespec as it is already defined in pthread.h +#define HAVE_STRUCT_TIMESPEC +#endif + +#include <pthread.h> + +#include "airspy.h" +#include "iqconverter_float.h" +#include "iqconverter_int16.h" +#include "filters.h" + +#ifndef bool +typedef int bool; +#define true 1 +#define false 0 +#endif + +#define PACKET_SIZE (12) +#define UNPACKED_SIZE (16) +#define RAW_BUFFER_COUNT (8) + +#ifdef AIRSPY_BIG_ENDIAN +#define TO_LE(x) __builtin_bswap32(x) +#else +#define TO_LE(x) x +#endif + +#define SAMPLE_RESOLUTION 12 +#define SAMPLE_ENCAPSULATION 16 + +#define SAMPLE_SHIFT (SAMPLE_ENCAPSULATION - SAMPLE_RESOLUTION) +#define SAMPLE_SCALE (1.0f / (1 << (15 - SAMPLE_SHIFT))) + +#define SERIAL_NUMBER_UNUSED (0ULL) +#define FILE_DESCRIPTOR_UNUSED (-1) + +#define USB_PRODUCT_ID (2) +#define STR_DESCRIPTOR_SIZE (250) + +#define MIN_SAMPLERATE_BY_VALUE (1000000) +#define SAMPLE_TYPE_IS_IQ(x) ((x) == AIRSPY_SAMPLE_FLOAT32_IQ || (x) == AIRSPY_SAMPLE_INT16_IQ) + +#define LIBUSB_CTRL_TIMEOUT_MS (500) + +typedef struct { + uint32_t freq_hz; +} set_freq_params_t; + +typedef struct airspy_device +{ + libusb_context* usb_context; + libusb_device_handle* usb_device; + struct libusb_transfer** transfers; + airspy_sample_block_cb_fn callback; + volatile bool streaming; + volatile bool stop_requested; + pthread_t transfer_thread; + pthread_t consumer_thread; + bool transfer_thread_running; + bool consumer_thread_running; + pthread_cond_t consumer_cv; + pthread_mutex_t consumer_mp; + uint32_t supported_samplerate_count; + uint32_t *supported_samplerates; + uint32_t transfer_count; + uint32_t buffer_size; + uint32_t dropped_buffers; + uint32_t dropped_buffers_queue[RAW_BUFFER_COUNT]; + uint16_t *received_samples_queue[RAW_BUFFER_COUNT]; + volatile int received_samples_queue_head; + volatile int received_samples_queue_tail; + volatile int received_buffer_count; + void *output_buffer; + uint16_t *unpacked_samples; + bool packing_enabled; + iqconverter_float_t *cnv_f; + iqconverter_int16_t *cnv_i; + void* ctx; + enum airspy_sample_type sample_type; +} airspy_device_t; + +static const uint16_t airspy_usb_vid = 0x1d50; +static const uint16_t airspy_usb_pid = 0x60a1; + +#define STR_PREFIX_SERIAL_AIRSPY_SIZE (10) + +#define SERIAL_AIRSPY_EXPECTED_SIZE (26) + +#define GAIN_COUNT (22) + +uint8_t airspy_linearity_vga_gains[GAIN_COUNT] = { 13, 12, 11, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 9, 8, 7, 6, 5, 4 }; +uint8_t airspy_linearity_mixer_gains[GAIN_COUNT] = { 12, 12, 11, 9, 8, 7, 6, 6, 5, 0, 0, 1, 0, 0, 2, 2, 1, 1, 1, 1, 0, 0 }; +uint8_t airspy_linearity_lna_gains[GAIN_COUNT] = { 14, 14, 14, 13, 12, 10, 9, 9, 8, 9, 8, 6, 5, 3, 1, 0, 0, 0, 0, 0, 0, 0 }; +uint8_t airspy_sensitivity_vga_gains[GAIN_COUNT] = { 13, 12, 11, 10, 9, 8, 7, 6, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4 }; +uint8_t airspy_sensitivity_mixer_gains[GAIN_COUNT] = { 12, 12, 12, 12, 11, 10, 10, 9, 9, 8, 7, 4, 4, 4, 3, 2, 2, 1, 0, 0, 0, 0 }; +uint8_t airspy_sensitivity_lna_gains[GAIN_COUNT] = { 14, 14, 14, 14, 14, 14, 14, 14, 14, 13, 12, 12, 9, 9, 8, 7, 6, 5, 3, 2, 1, 0 }; + +static int cancel_transfers(airspy_device_t* device) +{ + uint32_t transfer_index; + + if (device->transfers != NULL) + { + for (transfer_index = 0; transfer_index<device->transfer_count; transfer_index++) + { + if (device->transfers[transfer_index] != NULL) + { + libusb_cancel_transfer(device->transfers[transfer_index]); + } + } + return AIRSPY_SUCCESS; + } + else { + return AIRSPY_ERROR_OTHER; + } +} + +static int free_transfers(airspy_device_t* device) +{ + int i; + uint32_t transfer_index; + + if (device->transfers != NULL) + { + // libusb_close() should free all transfers referenced from this array. + for (transfer_index = 0; transfer_index < device->transfer_count; transfer_index++) + { + if (device->transfers[transfer_index] != NULL) + { + free(device->transfers[transfer_index]->buffer); + libusb_free_transfer(device->transfers[transfer_index]); + device->transfers[transfer_index] = NULL; + } + } + free(device->transfers); + device->transfers = NULL; + + if (device->output_buffer != NULL) + { + free(device->output_buffer); + device->output_buffer = NULL; + } + + if (device->unpacked_samples != NULL) + { + free(device->unpacked_samples); + device->unpacked_samples = NULL; + } + + for (i = 0; i < RAW_BUFFER_COUNT; i++) + { + if (device->received_samples_queue[i] != NULL) + { + free(device->received_samples_queue[i]); + device->received_samples_queue[i] = NULL; + } + } + } + + return AIRSPY_SUCCESS; +} + +static int allocate_transfers(airspy_device_t* const device) +{ + int i; + size_t sample_count; + uint32_t transfer_index; + + if (device->transfers == NULL) + { + for (i = 0; i < RAW_BUFFER_COUNT; i++) + { + device->received_samples_queue[i] = (uint16_t *)malloc(device->buffer_size); + if (device->received_samples_queue[i] == NULL) + { + return AIRSPY_ERROR_NO_MEM; + } + + memset(device->received_samples_queue[i], 0, device->buffer_size); + } + + if (device->packing_enabled) + { + sample_count = ((device->buffer_size / 2) * 4) / 3; + } + else + { + sample_count = device->buffer_size / 2; + } + + device->output_buffer = (float *)malloc(sample_count * sizeof(float)); + if (device->output_buffer == NULL) + { + return AIRSPY_ERROR_NO_MEM; + } + + if (device->packing_enabled) + { + device->unpacked_samples = (uint16_t*)malloc(sample_count * sizeof(uint16_t)); + if (device->unpacked_samples == NULL) + { + return AIRSPY_ERROR_NO_MEM; + } + } + + device->transfers = (struct libusb_transfer**) calloc(device->transfer_count, sizeof(struct libusb_transfer)); + if (device->transfers == NULL) + { + return AIRSPY_ERROR_NO_MEM; + } + + for (transfer_index = 0; transfer_index<device->transfer_count; transfer_index++) + { + device->transfers[transfer_index] = libusb_alloc_transfer(0); + if (device->transfers[transfer_index] == NULL) + { + return AIRSPY_ERROR_LIBUSB; + } + + libusb_fill_bulk_transfer( + device->transfers[transfer_index], + device->usb_device, + 0, + (unsigned char*)malloc(device->buffer_size), + device->buffer_size, + NULL, + device, + 0 + ); + + if (device->transfers[transfer_index]->buffer == NULL) + { + return AIRSPY_ERROR_NO_MEM; + } + } + return AIRSPY_SUCCESS; + } + else + { + return AIRSPY_ERROR_BUSY; + } +} + +static int prepare_transfers(airspy_device_t* device, const uint_fast8_t endpoint_address, libusb_transfer_cb_fn callback) +{ + int error; + uint32_t transfer_index; + if (device->transfers != NULL) + { + for (transfer_index = 0; transfer_index<device->transfer_count; transfer_index++) + { + device->transfers[transfer_index]->endpoint = endpoint_address; + device->transfers[transfer_index]->callback = callback; + + error = libusb_submit_transfer(device->transfers[transfer_index]); + if (error != 0) + { + return AIRSPY_ERROR_LIBUSB; + } + } + return AIRSPY_SUCCESS; + } + else { + // This shouldn't happen. + return AIRSPY_ERROR_OTHER; + } +} + +static void convert_samples_int16(uint16_t *src, int16_t *dest, int count) +{ + int i; + for (i = 0; i < count; i += 4) + { + dest[i + 0] = (src[i + 0] - 2048) << SAMPLE_SHIFT; + dest[i + 1] = (src[i + 1] - 2048) << SAMPLE_SHIFT; + dest[i + 2] = (src[i + 2] - 2048) << SAMPLE_SHIFT; + dest[i + 3] = (src[i + 3] - 2048) << SAMPLE_SHIFT; + } +} + +static void convert_samples_float(uint16_t *src, float *dest, int count) +{ + int i; + for (i = 0; i < count; i += 4) + { + dest[i + 0] = (src[i + 0] - 2048) * SAMPLE_SCALE; + dest[i + 1] = (src[i + 1] - 2048) * SAMPLE_SCALE; + dest[i + 2] = (src[i + 2] - 2048) * SAMPLE_SCALE; + dest[i + 3] = (src[i + 3] - 2048) * SAMPLE_SCALE; + } +} + +static inline void unpack_samples(uint32_t *input, uint16_t *output, int length) +{ + int i, j; + + for (i = 0, j = 0; j < length; i += 3, j += 8) + { + output[j + 0] = (input[i] >> 20) & 0xfff; + output[j + 1] = (input[i] >> 8) & 0xfff; + output[j + 2] = ((input[i] & 0xff) << 4) | ((input[i + 1] >> 28) & 0xf); + output[j + 3] = ((input[i + 1] & 0xfff0000) >> 16); + output[j + 4] = ((input[i + 1] & 0xfff0) >> 4); + output[j + 5] = ((input[i + 1] & 0xf) << 8) | ((input[i + 2] & 0xff000000) >> 24); + output[j + 6] = ((input[i + 2] >> 12) & 0xfff); + output[j + 7] = ((input[i + 2] & 0xfff)); + } +} + +static void* consumer_threadproc(void *arg) +{ + int sample_count; + uint16_t* input_samples; + uint32_t dropped_buffers; + airspy_device_t* device = (airspy_device_t*)arg; + airspy_transfer_t transfer; + +#ifdef _WIN32 + + SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST); + +#endif + + pthread_mutex_lock(&device->consumer_mp); + + while (device->streaming && !device->stop_requested) + { + while (device->received_buffer_count == 0 && device->streaming && !device->stop_requested) + { + pthread_cond_wait(&device->consumer_cv, &device->consumer_mp); + } + if (!device->streaming || device->stop_requested) + { + break; + } + + input_samples = device->received_samples_queue[device->received_samples_queue_tail]; + dropped_buffers = device->dropped_buffers_queue[device->received_samples_queue_tail]; + device->received_samples_queue_tail = (device->received_samples_queue_tail + 1) & (RAW_BUFFER_COUNT - 1); + + pthread_mutex_unlock(&device->consumer_mp); + + if (device->packing_enabled) + { + sample_count = ((device->buffer_size / 2) * 4) / 3; + + if (device->sample_type != AIRSPY_SAMPLE_RAW) + { + unpack_samples((uint32_t*)input_samples, device->unpacked_samples, sample_count); + + input_samples = device->unpacked_samples; + } + } + else + { + sample_count = device->buffer_size / 2; + } + + switch (device->sample_type) + { + case AIRSPY_SAMPLE_FLOAT32_IQ: + convert_samples_float(input_samples, (float *)device->output_buffer, sample_count); + iqconverter_float_process(device->cnv_f, (float *) device->output_buffer, sample_count); + sample_count /= 2; + transfer.samples = device->output_buffer; + break; + + case AIRSPY_SAMPLE_FLOAT32_REAL: + convert_samples_float(input_samples, (float *)device->output_buffer, sample_count); + transfer.samples = device->output_buffer; + break; + + case AIRSPY_SAMPLE_INT16_IQ: + convert_samples_int16(input_samples, (int16_t *)device->output_buffer, sample_count); + iqconverter_int16_process(device->cnv_i, (int16_t *) device->output_buffer, sample_count); + sample_count /= 2; + transfer.samples = device->output_buffer; + break; + + case AIRSPY_SAMPLE_INT16_REAL: + convert_samples_int16(input_samples, (int16_t *)device->output_buffer, sample_count); + transfer.samples = device->output_buffer; + break; + + case AIRSPY_SAMPLE_UINT16_REAL: + case AIRSPY_SAMPLE_RAW: + transfer.samples = input_samples; + break; + + case AIRSPY_SAMPLE_END: + // Just to shut GCC's moaning + break; + } + + transfer.device = device; + transfer.ctx = device->ctx; + transfer.sample_count = sample_count; + transfer.sample_type = device->sample_type; + transfer.dropped_samples = (uint64_t) dropped_buffers * (uint64_t) sample_count; + + if (device->callback(&transfer) != 0) + { + device->streaming = false; + } + + pthread_mutex_lock(&device->consumer_mp); + device->received_buffer_count--; + } + + device->streaming = false; + + pthread_mutex_unlock(&device->consumer_mp); + + return NULL; +} + +static void airspy_libusb_transfer_callback(struct libusb_transfer* usb_transfer) +{ + uint16_t *temp; + airspy_device_t* device = (airspy_device_t*)usb_transfer->user_data; + + if (!device->streaming || device->stop_requested) + { + return; + } + + if (usb_transfer->status == LIBUSB_TRANSFER_COMPLETED && usb_transfer->actual_length == usb_transfer->length) + { + pthread_mutex_lock(&device->consumer_mp); + + if (device->received_buffer_count < RAW_BUFFER_COUNT) + { + temp = device->received_samples_queue[device->received_samples_queue_head]; + device->received_samples_queue[device->received_samples_queue_head] = (uint16_t *)usb_transfer->buffer; + usb_transfer->buffer = (uint8_t *)temp; + + device->dropped_buffers_queue[device->received_samples_queue_head] = device->dropped_buffers; + device->dropped_buffers = 0; + + device->received_samples_queue_head = (device->received_samples_queue_head + 1) & (RAW_BUFFER_COUNT - 1); + device->received_buffer_count++; + + pthread_cond_signal(&device->consumer_cv); + } + else + { + device->dropped_buffers++; + } + + pthread_mutex_unlock(&device->consumer_mp); + + if (libusb_submit_transfer(usb_transfer) != 0) + { + device->streaming = false; + } + } + else + { + device->streaming = false; + } +} + +static void* transfer_threadproc(void* arg) +{ + airspy_device_t* device = (airspy_device_t*)arg; + int error; + struct timeval timeout = { 0, 500000 }; + +#ifdef _WIN32 + + SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST); + +#endif + + while (device->streaming && !device->stop_requested) + { + error = libusb_handle_events_timeout_completed(device->usb_context, &timeout, NULL); + if (error < 0) + { + if (error != LIBUSB_ERROR_INTERRUPTED) + device->streaming = false; + } + } + + device->streaming = false; + + return NULL; +} + +static int kill_io_threads(airspy_device_t* device) +{ + struct timeval timeout = { 0, 0 }; + + if (device->stop_requested) + { + device->stop_requested = false; + device->streaming = false; + cancel_transfers(device); + + pthread_mutex_lock(&device->consumer_mp); + pthread_cond_signal(&device->consumer_cv); + pthread_mutex_unlock(&device->consumer_mp); + + if (device->transfer_thread_running) { + pthread_join(device->transfer_thread, NULL); + device->transfer_thread_running = false; + } + if (device->consumer_thread_running) { + pthread_join(device->consumer_thread, NULL); + device->consumer_thread_running = false; + } + + libusb_handle_events_timeout_completed(device->usb_context, &timeout, NULL); + } + + return AIRSPY_SUCCESS; +} + +static int create_io_threads(airspy_device_t* device, airspy_sample_block_cb_fn callback) +{ + int result; + pthread_attr_t attr; + + if (!device->streaming && !device->stop_requested) + { + device->callback = callback; + device->streaming = true; + + result = prepare_transfers(device, LIBUSB_ENDPOINT_IN | 1, (libusb_transfer_cb_fn)airspy_libusb_transfer_callback); + if (result != AIRSPY_SUCCESS) + { + return result; + } + + device->received_samples_queue_head = 0; + device->received_samples_queue_tail = 0; + device->received_buffer_count = 0; + + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); + + result = pthread_create(&device->consumer_thread, &attr, consumer_threadproc, device); + if (result != 0) + { + return AIRSPY_ERROR_THREAD; + } + device->consumer_thread_running = true; + + result = pthread_create(&device->transfer_thread, &attr, transfer_threadproc, device); + if (result != 0) + { + return AIRSPY_ERROR_THREAD; + } + device->transfer_thread_running = true; + + pthread_attr_destroy(&attr); + } + else { + return AIRSPY_ERROR_BUSY; + } + + return AIRSPY_SUCCESS; +} + +static void airspy_open_exit(airspy_device_t* device) +{ + if (device->usb_device != NULL) + { + libusb_release_interface(device->usb_device, 0); + libusb_close(device->usb_device); + device->usb_device = NULL; + } + libusb_exit(device->usb_context); + device->usb_context = NULL; +} + +static void airspy_open_device(airspy_device_t* device, + int* ret, + uint16_t vid, + uint16_t pid, + uint64_t serial_number_val) +{ + int i; + int result; + libusb_device_handle** libusb_dev_handle; + int serial_number_len; + libusb_device_handle* dev_handle; + libusb_device *dev; + libusb_device** devices = NULL; + + ssize_t cnt; + int serial_descriptor_index; + struct libusb_device_descriptor device_descriptor; + unsigned char serial_number[SERIAL_AIRSPY_EXPECTED_SIZE + 1]; + + libusb_dev_handle = &device->usb_device; + *libusb_dev_handle = NULL; + + cnt = libusb_get_device_list(device->usb_context, &devices); + if (cnt < 0) + { + *ret = AIRSPY_ERROR_NOT_FOUND; + return; + } + + i = 0; + while ((dev = devices[i++]) != NULL) + { + libusb_get_device_descriptor(dev, &device_descriptor); + + if ((device_descriptor.idVendor == vid) && + (device_descriptor.idProduct == pid)) + { + if (serial_number_val != SERIAL_NUMBER_UNUSED) + { + serial_descriptor_index = device_descriptor.iSerialNumber; + if (serial_descriptor_index > 0) + { + if (libusb_open(dev, libusb_dev_handle) != 0) + { + *libusb_dev_handle = NULL; + continue; + } + dev_handle = *libusb_dev_handle; + serial_number_len = libusb_get_string_descriptor_ascii(dev_handle, + serial_descriptor_index, + serial_number, + sizeof(serial_number)); + if (serial_number_len == SERIAL_AIRSPY_EXPECTED_SIZE) + { + uint64_t serial = 0; + // use same code to determine device's serial number as in airspy_list_devices() + { + char *start, *end; + + serial_number[SERIAL_AIRSPY_EXPECTED_SIZE] = 0; + start = (char*)(serial_number + STR_PREFIX_SERIAL_AIRSPY_SIZE); + end = NULL; + serial = strtoull(start, &end, 16); + } + + if (serial == serial_number_val) + { +#ifdef __linux__ + /* Check whether a kernel driver is attached to interface #0. If so, we'll + * need to detach it. + */ + if (libusb_kernel_driver_active(dev_handle, 0)) + { + libusb_detach_kernel_driver(dev_handle, 0); + } +#endif + result = libusb_set_configuration(dev_handle, 1); + if (result != 0) + { + libusb_close(dev_handle); + *libusb_dev_handle = NULL; + continue; + } + result = libusb_claim_interface(dev_handle, 0); + if (result != 0) + { + libusb_close(dev_handle); + *libusb_dev_handle = NULL; + continue; + } + break; + } + else + { + libusb_close(dev_handle); + *libusb_dev_handle = NULL; + continue; + } + } + else + { + libusb_close(dev_handle); + *libusb_dev_handle = NULL; + continue; + } + } + } + else + { + if (libusb_open(dev, libusb_dev_handle) == 0) + { + dev_handle = *libusb_dev_handle; +#ifdef __linux__ + /* Check whether a kernel driver is attached to interface #0. If so, we'll + * need to detach it. + */ + if (libusb_kernel_driver_active(dev_handle, 0)) + { + libusb_detach_kernel_driver(dev_handle, 0); + } +#endif + result = libusb_set_configuration(dev_handle, 1); + if (result != 0) + { + libusb_close(dev_handle); + *libusb_dev_handle = NULL; + continue; + } + result = libusb_claim_interface(dev_handle, 0); + if (result != 0) + { + libusb_close(dev_handle); + *libusb_dev_handle = NULL; + continue; + } + break; + } + } + } + } + libusb_free_device_list(devices, 1); + + dev_handle = device->usb_device; + if (dev_handle == NULL) + { + *ret = AIRSPY_ERROR_NOT_FOUND; + return; + } + + *ret = AIRSPY_SUCCESS; + return; +} + +static void airspy_open_device_fd(airspy_device_t* device, + int* ret, + int fd) +{ + int result = -1; + +#ifdef __ANDROID__ + result = libusb_wrap_sys_device(device->usb_context, (intptr_t)fd, &device->usb_device); +#else + device->usb_device = NULL; + *ret = AIRSPY_ERROR_UNSUPPORTED; + return; +#endif + + if (result != 0 || device->usb_device == NULL) + { + *ret = AIRSPY_ERROR_LIBUSB; + return; + } + +#ifdef __linux__ + /* Check whether a kernel driver is attached to interface #0. If so, we'll + * need to detach it. + */ + if (libusb_kernel_driver_active(device->usb_device, 0)) + { + libusb_detach_kernel_driver(device->usb_device, 0); + } +#endif + + result = libusb_set_configuration(device->usb_device, 1); + if (result != 0) + { + libusb_close(device->usb_device); + device->usb_device = NULL; + *ret = AIRSPY_ERROR_LIBUSB; + return; + } + + result = libusb_claim_interface(device->usb_device, 0); + if (result != 0) + { + libusb_close(device->usb_device); + device->usb_device = NULL; + *ret = AIRSPY_ERROR_LIBUSB; + return; + } + + *ret = AIRSPY_SUCCESS; + return; +} + +static int airspy_read_samplerates_from_fw(struct airspy_device* device, uint32_t* buffer, const uint32_t len) +{ + int result; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_GET_SAMPLERATES, + 0, + len, + (unsigned char*)buffer, + (len > 0 ? len : 1) * sizeof(uint32_t), + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < 1) + { + return AIRSPY_ERROR_OTHER; + } + + return AIRSPY_SUCCESS; +} + +static int airspy_open_init(airspy_device_t** device, uint64_t serial_number, int fd) +{ + airspy_device_t* lib_device; + int libusb_error; + int result; + + *device = NULL; + + lib_device = (airspy_device_t*)calloc(1, sizeof(airspy_device_t)); + if (lib_device == NULL) + { + return AIRSPY_ERROR_NO_MEM; + } + +#ifdef __ANDROID__ + // LibUSB does not support device discovery on android + libusb_set_option(NULL, LIBUSB_OPTION_NO_DEVICE_DISCOVERY, NULL); +#endif + + libusb_error = libusb_init(&lib_device->usb_context); + if (libusb_error != 0) + { + free(lib_device); + return AIRSPY_ERROR_LIBUSB; + } + + if (fd == FILE_DESCRIPTOR_UNUSED) { + airspy_open_device(lib_device, + &result, + airspy_usb_vid, + airspy_usb_pid, + serial_number); + } + else { + airspy_open_device_fd(lib_device, + &result, + fd); + } + + if (lib_device->usb_device == NULL) + { + libusb_exit(lib_device->usb_context); + free(lib_device); + return result; + } + + lib_device->transfers = NULL; + lib_device->callback = NULL; + lib_device->transfer_count = 16; + lib_device->buffer_size = 262144; + lib_device->packing_enabled = false; + lib_device->streaming = false; + lib_device->stop_requested = false; + lib_device->sample_type = AIRSPY_SAMPLE_FLOAT32_IQ; + + result = airspy_read_samplerates_from_fw(lib_device, &lib_device->supported_samplerate_count, 0); + if (result == AIRSPY_SUCCESS) + { + lib_device->supported_samplerates = (uint32_t *) malloc(lib_device->supported_samplerate_count * sizeof(uint32_t)); + result = airspy_read_samplerates_from_fw(lib_device, lib_device->supported_samplerates, lib_device->supported_samplerate_count); + if (result != AIRSPY_SUCCESS) + { + free(lib_device->supported_samplerates); + } + } + + if (result != AIRSPY_SUCCESS) + { + lib_device->supported_samplerate_count = 2; + lib_device->supported_samplerates = (uint32_t *) malloc(lib_device->supported_samplerate_count * sizeof(uint32_t)); + lib_device->supported_samplerates[0] = 10000000; + lib_device->supported_samplerates[1] = 2500000; + } + + airspy_set_packing(lib_device, 0); + + result = allocate_transfers(lib_device); + if (result != 0) + { + airspy_open_exit(lib_device); + free(lib_device->supported_samplerates); + free(lib_device); + return AIRSPY_ERROR_NO_MEM; + } + + lib_device->cnv_f = iqconverter_float_create(HB_KERNEL_FLOAT, HB_KERNEL_FLOAT_LEN); + lib_device->cnv_i = iqconverter_int16_create(HB_KERNEL_INT16, HB_KERNEL_INT16_LEN); + + pthread_cond_init(&lib_device->consumer_cv, NULL); + pthread_mutex_init(&lib_device->consumer_mp, NULL); + + *device = lib_device; + + return AIRSPY_SUCCESS; +} + +#ifdef __cplusplus +extern "C" +{ +#endif + + void ADDCALL airspy_lib_version(airspy_lib_version_t* lib_version) + { + lib_version->major_version = AIRSPY_VER_MAJOR; + lib_version->minor_version = AIRSPY_VER_MINOR; + lib_version->revision = AIRSPY_VER_REVISION; + } + + /* airspy_init() deprecated */ + int ADDCALL airspy_init(void) + { + return AIRSPY_SUCCESS; + } + + /* airspy_exit() deprecated */ + int ADDCALL airspy_exit(void) + { + return AIRSPY_SUCCESS; + } + +int airspy_list_devices(uint64_t *serials, int count) +{ + libusb_device_handle* libusb_dev_handle; + struct libusb_context *context; + libusb_device** devices = NULL; + libusb_device *dev; + struct libusb_device_descriptor device_descriptor; + + int serial_descriptor_index; + int serial_number_len; + int output_count; + int i; + unsigned char serial_number[SERIAL_AIRSPY_EXPECTED_SIZE + 1]; + + if (serials) + { + memset(serials, 0, sizeof(uint64_t) * count); + } + +#ifdef __ANDROID__ + // LibUSB does not support device discovery on android + libusb_set_option(NULL, LIBUSB_OPTION_NO_DEVICE_DISCOVERY, NULL); +#endif + + if (libusb_init(&context) != 0) + { + return AIRSPY_ERROR_LIBUSB; + } + + if (libusb_get_device_list(context, &devices) < 0) + { + return AIRSPY_ERROR_NOT_FOUND; + } + + i = 0; + output_count = 0; + while ((dev = devices[i++]) != NULL && (!serials || output_count < count)) + { + libusb_get_device_descriptor(dev, &device_descriptor); + + if ((device_descriptor.idVendor == airspy_usb_vid) && + (device_descriptor.idProduct == airspy_usb_pid)) + { + serial_descriptor_index = device_descriptor.iSerialNumber; + if (serial_descriptor_index > 0) + { + if (libusb_open(dev, &libusb_dev_handle) != 0) + { + continue; + } + + serial_number_len = libusb_get_string_descriptor_ascii(libusb_dev_handle, + serial_descriptor_index, + serial_number, + sizeof(serial_number)); + + if (serial_number_len == SERIAL_AIRSPY_EXPECTED_SIZE) + { + char *start, *end; + uint64_t serial; + + serial_number[SERIAL_AIRSPY_EXPECTED_SIZE] = 0; + start = (char*)(serial_number + STR_PREFIX_SERIAL_AIRSPY_SIZE); + end = NULL; + serial = strtoull(start, &end, 16); + if (serial == 0 && start == end) + { + libusb_close(libusb_dev_handle); + continue; + } + + if (serials) + { + serials[output_count] = serial; + } + output_count++; + } + + libusb_close(libusb_dev_handle); + } + } + } + + libusb_free_device_list(devices, 1); + libusb_exit(context); + return output_count; +} + + int ADDCALL airspy_open_sn(airspy_device_t** device, uint64_t serial_number) + { + int result; + + result = airspy_open_init(device, serial_number, FILE_DESCRIPTOR_UNUSED); + return result; + } + + int ADDCALL airspy_open_fd(airspy_device_t** device, int fd) + { + int result; + + result = airspy_open_init(device, SERIAL_NUMBER_UNUSED, fd); + return result; + } + + int ADDCALL airspy_open(airspy_device_t** device) + { + int result; + + result = airspy_open_init(device, SERIAL_NUMBER_UNUSED, FILE_DESCRIPTOR_UNUSED); + return result; + } + + int ADDCALL airspy_close(airspy_device_t* device) + { + int result; + + result = AIRSPY_SUCCESS; + + if (device != NULL) + { + result = airspy_stop_rx(device); + + iqconverter_float_free(device->cnv_f); + iqconverter_int16_free(device->cnv_i); + + pthread_cond_destroy(&device->consumer_cv); + pthread_mutex_destroy(&device->consumer_mp); + + free_transfers(device); + airspy_open_exit(device); + free(device->supported_samplerates); + free(device); + } + + return result; + } + + int ADDCALL airspy_get_samplerates(struct airspy_device* device, uint32_t* buffer, const uint32_t len) + { + uint32_t i; + + if (len == 0) + { + *buffer = device->supported_samplerate_count; + } + else if (len <= device->supported_samplerate_count) + { + memcpy(buffer, device->supported_samplerates, len * sizeof(uint32_t)); + + if (!SAMPLE_TYPE_IS_IQ(device->sample_type)) + { + for (i = 0; i < len; i++) + { + buffer[i] *= 2; + } + } + } + else + { + return AIRSPY_ERROR_INVALID_PARAM; + } + + return AIRSPY_SUCCESS; + } + + int ADDCALL airspy_set_samplerate(airspy_device_t* device, uint32_t samplerate) + { + int result; + uint8_t retval; + uint8_t length; + uint32_t i; + + if (samplerate >= MIN_SAMPLERATE_BY_VALUE) + { + for (i = 0; i < device->supported_samplerate_count; i++) + { + if (samplerate == device->supported_samplerates[i]) + { + samplerate = i; + break; + } + } + + if (samplerate >= MIN_SAMPLERATE_BY_VALUE) + { + if (SAMPLE_TYPE_IS_IQ(device->sample_type)) + { + samplerate *= 2; + } + samplerate /= 1000; + } + } + + libusb_clear_halt(device->usb_device, LIBUSB_ENDPOINT_IN | 1); + + length = 1; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SET_SAMPLERATE, + 0, + samplerate, + &retval, + length, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < length) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_set_receiver_mode(airspy_device_t* device, receiver_mode_t value) + { + int result; + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_RECEIVER_MODE, + value, + 0, + NULL, + 0, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result != 0) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_start_rx(airspy_device_t* device, airspy_sample_block_cb_fn callback, void* ctx) + { + int result; + + iqconverter_float_reset(device->cnv_f); + iqconverter_int16_reset(device->cnv_i); + + memset(device->dropped_buffers_queue, 0, RAW_BUFFER_COUNT * sizeof(uint32_t)); + device->dropped_buffers = 0; + + result = airspy_set_receiver_mode(device, RECEIVER_MODE_OFF); + if (result != AIRSPY_SUCCESS) + { + return result; + } + + libusb_clear_halt(device->usb_device, LIBUSB_ENDPOINT_IN | 1); + + result = airspy_set_receiver_mode(device, RECEIVER_MODE_RX); + if (result == AIRSPY_SUCCESS) + { + device->ctx = ctx; + result = create_io_threads(device, callback); + } + + return result; + } + + int ADDCALL airspy_stop_rx(airspy_device_t* device) + { + int result1, result2; + + device->stop_requested = true; + result1 = airspy_set_receiver_mode(device, RECEIVER_MODE_OFF); + result2 = kill_io_threads(device); + + if (result1 != AIRSPY_SUCCESS) + { + return result1; + } + return result2; + } + + int ADDCALL airspy_si5351c_read(airspy_device_t* device, uint8_t register_number, uint8_t* value) + { + uint8_t temp_value; + int result; + + temp_value = 0; + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SI5351C_READ, + 0, + register_number, + (unsigned char*)&temp_value, + 1, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < 1) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + *value = temp_value; + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_si5351c_write(airspy_device_t* device, uint8_t register_number, uint8_t value) + { + int result; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SI5351C_WRITE, + value, + register_number, + NULL, + 0, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result != 0) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_r820t_read(airspy_device_t* device, uint8_t register_number, uint8_t* value) + { + int result; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_R820T_READ, + 0, + register_number, + (unsigned char*)value, + 1, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < 1) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_r820t_write(airspy_device_t* device, uint8_t register_number, uint8_t value) + { + int result; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_R820T_WRITE, + value, + register_number, + NULL, + 0, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result != 0) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_gpio_read(airspy_device_t* device, airspy_gpio_port_t port, airspy_gpio_pin_t pin, uint8_t* value) + { + int result; + uint8_t port_pin; + + port_pin = ((uint8_t)port) << 5; + port_pin = port_pin | pin; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_GPIO_READ, + 0, + port_pin, + (unsigned char*)value, + 1, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < 1) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_gpio_write(airspy_device_t* device, airspy_gpio_port_t port, airspy_gpio_pin_t pin, uint8_t value) + { + int result; + uint8_t port_pin; + + port_pin = ((uint8_t)port) << 5; + port_pin = port_pin | pin; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_GPIO_WRITE, + value, + port_pin, + NULL, + 0, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result != 0) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + + int ADDCALL airspy_gpiodir_read(airspy_device_t* device, airspy_gpio_port_t port, airspy_gpio_pin_t pin, uint8_t* value) + { + int result; + uint8_t port_pin; + + port_pin = ((uint8_t)port) << 5; + port_pin = port_pin | pin; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_GPIODIR_READ, + 0, + port_pin, + (unsigned char*)value, + 1, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < 1) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_gpiodir_write(airspy_device_t* device, airspy_gpio_port_t port, airspy_gpio_pin_t pin, uint8_t value) + { + int result; + uint8_t port_pin; + + port_pin = ((uint8_t)port) << 5; + port_pin = port_pin | pin; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_GPIODIR_WRITE, + value, + port_pin, + NULL, + 0, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result != 0) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_spiflash_erase(airspy_device_t* device) + { + int result; + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SPIFLASH_ERASE, + 0, + 0, + NULL, + 0, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result != 0) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_spiflash_erase_sector(airspy_device_t* device, const uint16_t sector_num) + { + int result; + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SPIFLASH_ERASE_SECTOR, + sector_num, + 0, + NULL, + 0, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result != 0) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_spiflash_write(airspy_device_t* device, const uint32_t address, const uint16_t length, unsigned char* const data) + { + int result; + + if (address > 0x0FFFFF) + { + return AIRSPY_ERROR_INVALID_PARAM; + } + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SPIFLASH_WRITE, + address >> 16, + address & 0xFFFF, + data, + length, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < length) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_spiflash_read(airspy_device_t* device, const uint32_t address, const uint16_t length, unsigned char* data) + { + int result; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SPIFLASH_READ, + address >> 16, + address & 0xFFFF, + data, + length, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < length) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_board_id_read(airspy_device_t* device, uint8_t* value) + { + int result; + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_BOARD_ID_READ, + 0, + 0, + value, + 1, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < 1) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_version_string_read(airspy_device_t* device, char* version, uint8_t length) + { +#define VERSION_LOCAL_SIZE (128) + int result; + char version_local[VERSION_LOCAL_SIZE] = ""; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_VERSION_STRING_READ, + 0, + 0, + (unsigned char*)version_local, + (VERSION_LOCAL_SIZE - 1), + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < 0) + { + return AIRSPY_ERROR_LIBUSB; + } + else + { + if (length > 0) + { + const int num_bytes_to_copy = (length > VERSION_LOCAL_SIZE ? VERSION_LOCAL_SIZE : length) - 1; + memcpy(version, version_local, num_bytes_to_copy); + version[num_bytes_to_copy] = 0; + return AIRSPY_SUCCESS; + } + else + { + return AIRSPY_ERROR_INVALID_PARAM; + } + } + } + + int ADDCALL airspy_board_partid_serialno_read(airspy_device_t* device, airspy_read_partid_serialno_t* read_partid_serialno) + { + uint8_t length; + int result; + + length = sizeof(airspy_read_partid_serialno_t); + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_BOARD_PARTID_SERIALNO_READ, + 0, + 0, + (unsigned char*)read_partid_serialno, + length, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < length) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + + read_partid_serialno->part_id[0] = TO_LE(read_partid_serialno->part_id[0]); + read_partid_serialno->part_id[1] = TO_LE(read_partid_serialno->part_id[1]); + read_partid_serialno->serial_no[0] = TO_LE(read_partid_serialno->serial_no[0]); + read_partid_serialno->serial_no[1] = TO_LE(read_partid_serialno->serial_no[1]); + read_partid_serialno->serial_no[2] = TO_LE(read_partid_serialno->serial_no[2]); + read_partid_serialno->serial_no[3] = TO_LE(read_partid_serialno->serial_no[3]); + + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_set_sample_type(struct airspy_device* device, enum airspy_sample_type sample_type) + { + device->sample_type = sample_type; + return AIRSPY_SUCCESS; + } + + int ADDCALL airspy_set_freq(airspy_device_t* device, const uint32_t freq_hz) + { + set_freq_params_t set_freq_params; + uint8_t length; + int result; + + set_freq_params.freq_hz = TO_LE(freq_hz); + length = sizeof(set_freq_params_t); + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SET_FREQ, + 0, + 0, + (unsigned char*)&set_freq_params, + length, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < length) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_set_conversion_filter_float32(struct airspy_device* device, const float *kernel, const uint32_t len) + { + if (device->streaming) + { + return AIRSPY_ERROR_BUSY; + } + + iqconverter_float_free(device->cnv_f); + device->cnv_f = iqconverter_float_create(kernel, len); + + return AIRSPY_SUCCESS; + } + + int ADDCALL airspy_set_conversion_filter_int16(struct airspy_device* device, const int16_t *kernel, const uint32_t len) + { + if (device->streaming) + { + return AIRSPY_ERROR_BUSY; + } + + iqconverter_int16_free(device->cnv_i); + device->cnv_i = iqconverter_int16_create(kernel, len); + + return AIRSPY_SUCCESS; + } + + int ADDCALL airspy_set_lna_gain(airspy_device_t* device, uint8_t value) + { + int result; + uint8_t retval; + uint8_t length; + + if (value > 14) + value = 14; + + length = 1; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SET_LNA_GAIN, + 0, + value, + &retval, + length, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < length) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_set_mixer_gain(airspy_device_t* device, uint8_t value) + { + int result; + uint8_t retval; + uint8_t length; + + if (value > 15) + value = 15; + + length = 1; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SET_MIXER_GAIN, + 0, + value, + &retval, + length, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < length) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_set_vga_gain(airspy_device_t* device, uint8_t value) + { + int result; + uint8_t retval; + uint8_t length; + + if (value > 15) + value = 15; + + length = 1; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SET_VGA_GAIN, + 0, + value, + &retval, + length, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < length) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_set_lna_agc(airspy_device_t* device, uint8_t value) + { + int result; + uint8_t retval; + uint8_t length; + + length = 1; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SET_LNA_AGC, + 0, + value, + &retval, + length, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < length) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_set_mixer_agc(airspy_device_t* device, uint8_t value) + { + int result; + uint8_t retval; + uint8_t length; + + length = 1; + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SET_MIXER_AGC, + 0, + value, + &retval, + length, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < length) + { + return AIRSPY_ERROR_LIBUSB; + } + else { + return AIRSPY_SUCCESS; + } + } + + int ADDCALL airspy_set_linearity_gain(struct airspy_device* device, uint8_t value) + { + int rc; + + if (value >= GAIN_COUNT) + { + value = GAIN_COUNT - 1; + } + + value = GAIN_COUNT - 1 - value; + + rc = airspy_set_mixer_agc(device, 0); + if (rc < 0) + return rc; + + rc = airspy_set_lna_agc(device, 0); + if (rc < 0) + return rc; + + rc = airspy_set_vga_gain(device, airspy_linearity_vga_gains[value]); + if (rc < 0) + return rc; + + rc = airspy_set_mixer_gain(device, airspy_linearity_mixer_gains[value]); + if (rc < 0) + return rc; + + rc = airspy_set_lna_gain(device, airspy_linearity_lna_gains[value]); + if (rc < 0) + return rc; + + return AIRSPY_SUCCESS; + } + + int ADDCALL airspy_set_sensitivity_gain(struct airspy_device* device, uint8_t value) + { + int rc; + + if (value >= GAIN_COUNT) + { + value = GAIN_COUNT - 1; + } + + value = GAIN_COUNT - 1 - value; + + rc = airspy_set_mixer_agc(device, 0); + if (rc < 0) + return rc; + + rc = airspy_set_lna_agc(device, 0); + if (rc < 0) + return rc; + + rc = airspy_set_vga_gain(device, airspy_sensitivity_vga_gains[value]); + if (rc < 0) + return rc; + + rc = airspy_set_mixer_gain(device, airspy_sensitivity_mixer_gains[value]); + if (rc < 0) + return rc; + + rc = airspy_set_lna_gain(device, airspy_sensitivity_lna_gains[value]); + if (rc < 0) + return rc; + + return AIRSPY_SUCCESS; + } + + int ADDCALL airspy_set_rf_bias(airspy_device_t* device, uint8_t value) + { + return airspy_gpio_write(device, GPIO_PORT1, GPIO_PIN13, value); + } + + int ADDCALL airspy_set_packing(airspy_device_t* device, uint8_t value) + { + int result; + uint8_t retval; + bool packing_enabled; + + if (device->streaming) + { + return AIRSPY_ERROR_BUSY; + } + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + AIRSPY_SET_PACKING, + 0, + value, + &retval, + 1, + LIBUSB_CTRL_TIMEOUT_MS); + + if (result < 1) + { + return AIRSPY_ERROR_LIBUSB; + } + + packing_enabled = value ? true : false; + if (packing_enabled != device->packing_enabled) + { + cancel_transfers(device); + free_transfers(device); + + device->packing_enabled = packing_enabled; + device->buffer_size = packing_enabled ? (6144 * 24) : 262144; + + result = allocate_transfers(device); + if (result != 0) + { + return AIRSPY_ERROR_NO_MEM; + } + } + + return AIRSPY_SUCCESS; + } + + int ADDCALL airspy_is_streaming(airspy_device_t* device) + { + return (device->streaming == true && device->stop_requested == false); + } + + const char* ADDCALL airspy_error_name(enum airspy_error errcode) + { + switch (errcode) + { + case AIRSPY_SUCCESS: + return "AIRSPY_SUCCESS"; + + case AIRSPY_TRUE: + return "AIRSPY_TRUE"; + + case AIRSPY_ERROR_INVALID_PARAM: + return "AIRSPY_ERROR_INVALID_PARAM"; + + case AIRSPY_ERROR_NOT_FOUND: + return "AIRSPY_ERROR_NOT_FOUND"; + + case AIRSPY_ERROR_BUSY: + return "AIRSPY_ERROR_BUSY"; + + case AIRSPY_ERROR_NO_MEM: + return "AIRSPY_ERROR_NO_MEM"; + + case AIRSPY_ERROR_LIBUSB: + return "AIRSPY_ERROR_LIBUSB"; + + case AIRSPY_ERROR_THREAD: + return "AIRSPY_ERROR_THREAD"; + + case AIRSPY_ERROR_STREAMING_THREAD_ERR: + return "AIRSPY_ERROR_STREAMING_THREAD_ERR"; + + case AIRSPY_ERROR_STREAMING_STOPPED: + return "AIRSPY_ERROR_STREAMING_STOPPED"; + + case AIRSPY_ERROR_OTHER: + return "AIRSPY_ERROR_OTHER"; + + default: + return "airspy unknown error"; + } + } + + const char* ADDCALL airspy_board_id_name(enum airspy_board_id board_id) + { + switch (board_id) + { + case AIRSPY_BOARD_ID_PROTO_AIRSPY: + return "AIRSPY"; + + case AIRSPY_BOARD_ID_INVALID: + return "Invalid Board ID"; + + default: + return "Unknown Board ID"; + } + } + +#ifdef __cplusplus +} // __cplusplus defined. +#endif diff --git a/Radio/HW/AirSpy/src/airspy.h b/Radio/HW/AirSpy/src/airspy.h new file mode 100644 index 0000000..573298b --- /dev/null +++ b/Radio/HW/AirSpy/src/airspy.h @@ -0,0 +1,224 @@ +/* +Copyright (c) 2012, Jared Boone <jared@sharebrained.com> +Copyright (c) 2013, Michael Ossmann <mike@ossmann.com> +Copyright (c) 2013-2016, Benjamin Vernoux <bvernoux@airspy.com> +Copyright (C) 2013-2016, Youssef Touil <youssef@airspy.com> + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + Neither the name of AirSpy nor the names of its contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef __AIRSPY_H__ +#define __AIRSPY_H__ + +#include <stdint.h> +#include "airspy_commands.h" + +#define AIRSPY_VERSION "1.0.12" +#define AIRSPY_VER_MAJOR 1 +#define AIRSPY_VER_MINOR 0 +#define AIRSPY_VER_REVISION 12 + +#ifdef _WIN32 + #define ADD_EXPORTS + + /* You should define ADD_EXPORTS *only* when building the DLL. */ + #ifdef ADD_EXPORTS + #define ADDAPI __declspec(dllexport) + #else + #define ADDAPI __declspec(dllimport) + #endif + + /* Define calling convention in one place, for convenience. */ + #define ADDCALL __cdecl + +#else /* _WIN32 not defined. */ + + /* Define with no value on non-Windows OSes. */ + #define ADDAPI + #define ADDCALL + +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + +enum airspy_error +{ + AIRSPY_SUCCESS = 0, + AIRSPY_TRUE = 1, + AIRSPY_ERROR_INVALID_PARAM = -2, + AIRSPY_ERROR_NOT_FOUND = -5, + AIRSPY_ERROR_BUSY = -6, + AIRSPY_ERROR_NO_MEM = -11, + AIRSPY_ERROR_UNSUPPORTED = -12, + AIRSPY_ERROR_LIBUSB = -1000, + AIRSPY_ERROR_THREAD = -1001, + AIRSPY_ERROR_STREAMING_THREAD_ERR = -1002, + AIRSPY_ERROR_STREAMING_STOPPED = -1003, + AIRSPY_ERROR_OTHER = -9999, +}; + +enum airspy_board_id +{ + AIRSPY_BOARD_ID_PROTO_AIRSPY = 0, + AIRSPY_BOARD_ID_INVALID = 0xFF, +}; + +enum airspy_sample_type +{ + AIRSPY_SAMPLE_FLOAT32_IQ = 0, /* 2 * 32bit float per sample */ + AIRSPY_SAMPLE_FLOAT32_REAL = 1, /* 1 * 32bit float per sample */ + AIRSPY_SAMPLE_INT16_IQ = 2, /* 2 * 16bit int per sample */ + AIRSPY_SAMPLE_INT16_REAL = 3, /* 1 * 16bit int per sample */ + AIRSPY_SAMPLE_UINT16_REAL = 4, /* 1 * 16bit unsigned int per sample */ + AIRSPY_SAMPLE_RAW = 5, /* Raw packed samples from the device */ + AIRSPY_SAMPLE_END = 6 /* Number of supported sample types */ +}; + +#define MAX_CONFIG_PAGE_SIZE (0x10000) + +struct airspy_device; + +typedef struct { + struct airspy_device* device; + void* ctx; + void* samples; + int sample_count; + uint64_t dropped_samples; + enum airspy_sample_type sample_type; +} airspy_transfer_t, airspy_transfer; + +typedef struct { + uint32_t part_id[2]; + uint32_t serial_no[4]; +} airspy_read_partid_serialno_t; + +typedef struct { + uint32_t major_version; + uint32_t minor_version; + uint32_t revision; +} airspy_lib_version_t; + +typedef int (*airspy_sample_block_cb_fn)(airspy_transfer* transfer); + +extern ADDAPI void ADDCALL airspy_lib_version(airspy_lib_version_t* lib_version); +/* airspy_init() deprecated */ +extern ADDAPI int ADDCALL airspy_init(void); +/* airspy_exit() deprecated */ +extern ADDAPI int ADDCALL airspy_exit(void); + +extern ADDAPI int ADDCALL airspy_list_devices(uint64_t *serials, int count); + +extern ADDAPI int ADDCALL airspy_open_sn(struct airspy_device** device, uint64_t serial_number); +extern ADDAPI int ADDCALL airspy_open_fd(struct airspy_device** device, int fd); +extern ADDAPI int ADDCALL airspy_open(struct airspy_device** device); +extern ADDAPI int ADDCALL airspy_close(struct airspy_device* device); + +/* Use airspy_get_samplerates(device, buffer, 0) to get the number of available sample rates. It will be returned in the first element of buffer */ +extern ADDAPI int ADDCALL airspy_get_samplerates(struct airspy_device* device, uint32_t* buffer, const uint32_t len); + +/* Parameter samplerate can be either the index of a samplerate or directly its value in Hz within the list returned by airspy_get_samplerates() */ +extern ADDAPI int ADDCALL airspy_set_samplerate(struct airspy_device* device, uint32_t samplerate); + +extern ADDAPI int ADDCALL airspy_set_conversion_filter_float32(struct airspy_device* device, const float *kernel, const uint32_t len); +extern ADDAPI int ADDCALL airspy_set_conversion_filter_int16(struct airspy_device* device, const int16_t *kernel, const uint32_t len); + +extern ADDAPI int ADDCALL airspy_start_rx(struct airspy_device* device, airspy_sample_block_cb_fn callback, void* rx_ctx); +extern ADDAPI int ADDCALL airspy_stop_rx(struct airspy_device* device); + +/* return AIRSPY_TRUE if success */ +extern ADDAPI int ADDCALL airspy_is_streaming(struct airspy_device* device); + +extern ADDAPI int ADDCALL airspy_si5351c_write(struct airspy_device* device, uint8_t register_number, uint8_t value); +extern ADDAPI int ADDCALL airspy_si5351c_read(struct airspy_device* device, uint8_t register_number, uint8_t* value); + +extern ADDAPI int ADDCALL airspy_config_write(struct airspy_device* device, const uint8_t page_index, const uint16_t length, unsigned char *data); +extern ADDAPI int ADDCALL airspy_config_read(struct airspy_device* device, const uint8_t page_index, const uint16_t length, unsigned char *data); + +extern ADDAPI int ADDCALL airspy_r820t_write(struct airspy_device* device, uint8_t register_number, uint8_t value); +extern ADDAPI int ADDCALL airspy_r820t_read(struct airspy_device* device, uint8_t register_number, uint8_t* value); + +/* Parameter value shall be 0=clear GPIO or 1=set GPIO */ +extern ADDAPI int ADDCALL airspy_gpio_write(struct airspy_device* device, airspy_gpio_port_t port, airspy_gpio_pin_t pin, uint8_t value); +/* Parameter value corresponds to GPIO state 0 or 1 */ +extern ADDAPI int ADDCALL airspy_gpio_read(struct airspy_device* device, airspy_gpio_port_t port, airspy_gpio_pin_t pin, uint8_t* value); + +/* Parameter value shall be 0=GPIO Input direction or 1=GPIO Output direction */ +extern ADDAPI int ADDCALL airspy_gpiodir_write(struct airspy_device* device, airspy_gpio_port_t port, airspy_gpio_pin_t pin, uint8_t value); +extern ADDAPI int ADDCALL airspy_gpiodir_read(struct airspy_device* device, airspy_gpio_port_t port, airspy_gpio_pin_t pin, uint8_t* value); + +extern ADDAPI int ADDCALL airspy_spiflash_erase(struct airspy_device* device); +extern ADDAPI int ADDCALL airspy_spiflash_write(struct airspy_device* device, const uint32_t address, const uint16_t length, unsigned char* const data); +extern ADDAPI int ADDCALL airspy_spiflash_read(struct airspy_device* device, const uint32_t address, const uint16_t length, unsigned char* data); + +extern ADDAPI int ADDCALL airspy_board_id_read(struct airspy_device* device, uint8_t* value); +/* Parameter length shall be at least 128bytes to avoid possible string clipping */ +extern ADDAPI int ADDCALL airspy_version_string_read(struct airspy_device* device, char* version, uint8_t length); + +extern ADDAPI int ADDCALL airspy_board_partid_serialno_read(struct airspy_device* device, airspy_read_partid_serialno_t* read_partid_serialno); + +extern ADDAPI int ADDCALL airspy_set_sample_type(struct airspy_device* device, enum airspy_sample_type sample_type); + +/* Parameter freq_hz shall be between 24000000(24MHz) and 1750000000(1.75GHz) */ +extern ADDAPI int ADDCALL airspy_set_freq(struct airspy_device* device, const uint32_t freq_hz); + +/* Parameter value shall be between 0 and 15 */ +extern ADDAPI int ADDCALL airspy_set_lna_gain(struct airspy_device* device, uint8_t value); + +/* Parameter value shall be between 0 and 15 */ +extern ADDAPI int ADDCALL airspy_set_mixer_gain(struct airspy_device* device, uint8_t value); + +/* Parameter value shall be between 0 and 15 */ +extern ADDAPI int ADDCALL airspy_set_vga_gain(struct airspy_device* device, uint8_t value); + +/* Parameter value: + 0=Disable LNA Automatic Gain Control + 1=Enable LNA Automatic Gain Control +*/ +extern ADDAPI int ADDCALL airspy_set_lna_agc(struct airspy_device* device, uint8_t value); +/* Parameter value: + 0=Disable MIXER Automatic Gain Control + 1=Enable MIXER Automatic Gain Control +*/ +extern ADDAPI int ADDCALL airspy_set_mixer_agc(struct airspy_device* device, uint8_t value); + +/* Parameter value: 0..21 */ +extern ADDAPI int ADDCALL airspy_set_linearity_gain(struct airspy_device* device, uint8_t value); + +/* Parameter value: 0..21 */ +extern ADDAPI int ADDCALL airspy_set_sensitivity_gain(struct airspy_device* device, uint8_t value); + +/* Parameter value shall be 0=Disable BiasT or 1=Enable BiasT */ +extern ADDAPI int ADDCALL airspy_set_rf_bias(struct airspy_device* dev, uint8_t value); + +/* Parameter value shall be 0=Disable Packing or 1=Enable Packing */ +extern ADDAPI int ADDCALL airspy_set_packing(struct airspy_device* device, uint8_t value); + +extern ADDAPI const char* ADDCALL airspy_error_name(enum airspy_error errcode); +extern ADDAPI const char* ADDCALL airspy_board_id_name(enum airspy_board_id board_id); + +/* Parameter sector_num shall be between 2 & 13 (sector 0 & 1 are reserved) */ +extern ADDAPI int ADDCALL airspy_spiflash_erase_sector(struct airspy_device* device, const uint16_t sector_num); + +#ifdef __cplusplus +} // __cplusplus defined. +#endif + +#endif//__AIRSPY_H__ diff --git a/Radio/HW/AirSpy/src/airspy_commands.h b/Radio/HW/AirSpy/src/airspy_commands.h new file mode 100644 index 0000000..21194f8 --- /dev/null +++ b/Radio/HW/AirSpy/src/airspy_commands.h @@ -0,0 +1,145 @@ +/* +Copyright (c) 2013-2016, Benjamin Vernoux <bvernoux@airspy.com> + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + Neither the name of AirSpy nor the names of its contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef __AIRSPY_COMMANDS_H__ +#define __AIRSPY_COMMANDS_H__ + +#include <stdint.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef enum +{ + RECEIVER_MODE_OFF = 0, + RECEIVER_MODE_RX = 1 +} receiver_mode_t; + +/* + Note: airspy_samplerate_t is now obsolete and left for backward compatibility. + The list of supported sample rates should be retrieved at run time by calling airspy_get_samplerates(). + Refer to the Airspy Tools for illustrations. +*/ +typedef enum +{ + AIRSPY_SAMPLERATE_10MSPS = 0, /* 12bits 10MHz IQ */ + AIRSPY_SAMPLERATE_2_5MSPS = 1, /* 12bits 2.5MHz IQ */ + AIRSPY_SAMPLERATE_END = 2 /* End index for sample rate (corresponds to number of samplerate) */ +} airspy_samplerate_t; + + +#define AIRSPY_CONF_CMD_SHIFT_BIT (3) // Up to 3bits=8 samplerates (airspy_samplerate_t enum shall not exceed 7) + +// Commands (usb vendor request) shared between Firmware and Host. +#define AIRSPY_CMD_MAX (27) +typedef enum +{ + AIRSPY_INVALID = 0 , + AIRSPY_RECEIVER_MODE = 1 , + AIRSPY_SI5351C_WRITE = 2 , + AIRSPY_SI5351C_READ = 3 , + AIRSPY_R820T_WRITE = 4 , + AIRSPY_R820T_READ = 5 , + AIRSPY_SPIFLASH_ERASE = 6 , + AIRSPY_SPIFLASH_WRITE = 7 , + AIRSPY_SPIFLASH_READ = 8 , + AIRSPY_BOARD_ID_READ = 9 , + AIRSPY_VERSION_STRING_READ = 10, + AIRSPY_BOARD_PARTID_SERIALNO_READ = 11, + AIRSPY_SET_SAMPLERATE = 12, + AIRSPY_SET_FREQ = 13, + AIRSPY_SET_LNA_GAIN = 14, + AIRSPY_SET_MIXER_GAIN = 15, + AIRSPY_SET_VGA_GAIN = 16, + AIRSPY_SET_LNA_AGC = 17, + AIRSPY_SET_MIXER_AGC = 18, + AIRSPY_MS_VENDOR_CMD = 19, + AIRSPY_SET_RF_BIAS_CMD = 20, + AIRSPY_GPIO_WRITE = 21, + AIRSPY_GPIO_READ = 22, + AIRSPY_GPIODIR_WRITE = 23, + AIRSPY_GPIODIR_READ = 24, + AIRSPY_GET_SAMPLERATES = 25, + AIRSPY_SET_PACKING = 26, + AIRSPY_SPIFLASH_ERASE_SECTOR = AIRSPY_CMD_MAX +} airspy_vendor_request; + +typedef enum +{ + CONFIG_CALIBRATION = 0, + //CONFIG_META = 1, +} airspy_common_config_pages_t; + +typedef enum +{ + GPIO_PORT0 = 0, + GPIO_PORT1 = 1, + GPIO_PORT2 = 2, + GPIO_PORT3 = 3, + GPIO_PORT4 = 4, + GPIO_PORT5 = 5, + GPIO_PORT6 = 6, + GPIO_PORT7 = 7 +} airspy_gpio_port_t; + +typedef enum +{ + GPIO_PIN0 = 0, + GPIO_PIN1 = 1, + GPIO_PIN2 = 2, + GPIO_PIN3 = 3, + GPIO_PIN4 = 4, + GPIO_PIN5 = 5, + GPIO_PIN6 = 6, + GPIO_PIN7 = 7, + GPIO_PIN8 = 8, + GPIO_PIN9 = 9, + GPIO_PIN10 = 10, + GPIO_PIN11 = 11, + GPIO_PIN12 = 12, + GPIO_PIN13 = 13, + GPIO_PIN14 = 14, + GPIO_PIN15 = 15, + GPIO_PIN16 = 16, + GPIO_PIN17 = 17, + GPIO_PIN18 = 18, + GPIO_PIN19 = 19, + GPIO_PIN20 = 20, + GPIO_PIN21 = 21, + GPIO_PIN22 = 22, + GPIO_PIN23 = 23, + GPIO_PIN24 = 24, + GPIO_PIN25 = 25, + GPIO_PIN26 = 26, + GPIO_PIN27 = 27, + GPIO_PIN28 = 28, + GPIO_PIN29 = 29, + GPIO_PIN30 = 30, + GPIO_PIN31 = 31 +} airspy_gpio_pin_t; + +#ifdef __cplusplus +} // __cplusplus defined. +#endif + +#endif//__AIRSPY_COMMANDS_H__ diff --git a/Radio/HW/AirSpy/src/filters.h b/Radio/HW/AirSpy/src/filters.h new file mode 100644 index 0000000..30da6e4 --- /dev/null +++ b/Radio/HW/AirSpy/src/filters.h @@ -0,0 +1,134 @@ +/* +Copyright (C) 2014, Youssef Touil <youssef@airspy.com> + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +#ifndef FILTERS_H +#define FILTERS_H + +#include <stdint.h> + +#define HB_KERNEL_FLOAT_LEN 47 + +const float HB_KERNEL_FLOAT[HB_KERNEL_FLOAT_LEN] = +{ + -0.000998606272947510, + 0.000000000000000000, + 0.001695637278417295, + 0.000000000000000000, + -0.003054430179754289, + 0.000000000000000000, + 0.005055504379767936, + 0.000000000000000000, + -0.007901319195893647, + 0.000000000000000000, + 0.011873357051047719, + 0.000000000000000000, + -0.017411159379930066, + 0.000000000000000000, + 0.025304817427568772, + 0.000000000000000000, + -0.037225225204559217, + 0.000000000000000000, + 0.057533286997004301, + 0.000000000000000000, + -0.102327462004259350, + 0.000000000000000000, + 0.317034472508947400, + 0.500000000000000000, + 0.317034472508947400, + 0.000000000000000000, + -0.102327462004259350, + 0.000000000000000000, + 0.057533286997004301, + 0.000000000000000000, + -0.037225225204559217, + 0.000000000000000000, + 0.025304817427568772, + 0.000000000000000000, + -0.017411159379930066, + 0.000000000000000000, + 0.011873357051047719, + 0.000000000000000000, + -0.007901319195893647, + 0.000000000000000000, + 0.005055504379767936, + 0.000000000000000000, + -0.003054430179754289, + 0.000000000000000000, + 0.001695637278417295, + 0.000000000000000000, + -0.000998606272947510 +}; + +#define HB_KERNEL_INT16_LEN 47 + +const int16_t HB_KERNEL_INT16[HB_KERNEL_INT16_LEN] = +{ + -33, + 0, + 56, + 0, + -100, + 0, + 166, + 0, + -259, + 0, + 389, + 0, + -571, + 0, + 829, + 0, + -1220, + 0, + 1885, + 0, + -3353, + 0, + 10389, + 16384, + 10389, + 0, + -3353, + 0, + 1885, + 0, + -1220, + 0, + 829, + 0, + -571, + 0, + 389, + 0, + -259, + 0, + 166, + 0, + -100, + 0, + 56, + 0, + -33 +}; + +#endif // FILTERS_H diff --git a/Radio/HW/AirSpy/src/iqconverter_float.c b/Radio/HW/AirSpy/src/iqconverter_float.c new file mode 100644 index 0000000..c656cdb --- /dev/null +++ b/Radio/HW/AirSpy/src/iqconverter_float.c @@ -0,0 +1,502 @@ +/* +Copyright (C) 2014, Youssef Touil <youssef@airspy.com> + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +#include "iqconverter_float.h" +#include <stdlib.h> +#include <string.h> + +#include <stdio.h> + +#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) + #include <malloc.h> + #define _aligned_malloc __mingw_aligned_malloc + #define _aligned_free __mingw_aligned_free + #define _inline inline + #define FIR_STANDARD +#elif defined(__APPLE__) + #include <malloc/malloc.h> + #define _aligned_malloc(size, alignment) malloc(size) + #define _aligned_free(mem) free(mem) + #define _inline inline + #define FIR_STANDARD +#elif defined(__FreeBSD__) + #define USE_SSE2 +#include <immintrin.h> + #define _inline inline + #define _aligned_free(mem) free(mem) +void *_aligned_malloc(size_t size, size_t alignment) +{ + void *result; + if (posix_memalign(&result, alignment, size) == 0) + return result; + return 0; +} +#elif defined(__GNUC__) && !defined(__MINGW64_VERSION_MAJOR) + #include <malloc.h> + #define _aligned_malloc(size, alignment) memalign(alignment, size) + #define _aligned_free(mem) free(mem) + #define _inline inline +#else + #if (_MSC_VER >= 1800) + //#define USE_SSE2 + //#include <immintrin.h> + #endif +#endif + +#define SIZE_FACTOR 32 +#define DEFAULT_ALIGNMENT 16 +#define HPF_COEFF 0.01f + +#if defined(_MSC_VER) + #define ALIGNED __declspec(align(DEFAULT_ALIGNMENT)) +#else + #define ALIGNED +#endif + +iqconverter_float_t *iqconverter_float_create(const float *hb_kernel, int len) +{ + int i, j; + size_t buffer_size; + iqconverter_float_t *cnv = (iqconverter_float_t *) _aligned_malloc(sizeof(iqconverter_float_t), DEFAULT_ALIGNMENT); + + cnv->len = len / 2 + 1; + cnv->hbc = hb_kernel[len / 2]; + + buffer_size = cnv->len * sizeof(float); + + cnv->fir_kernel = (float *) _aligned_malloc(buffer_size, DEFAULT_ALIGNMENT); + cnv->fir_queue = (float *) _aligned_malloc(buffer_size * SIZE_FACTOR, DEFAULT_ALIGNMENT); + cnv->delay_line = (float *) _aligned_malloc(buffer_size / 2, DEFAULT_ALIGNMENT); + + iqconverter_float_reset(cnv); + + for (i = 0, j = 0; i < cnv->len; i++, j += 2) + { + cnv->fir_kernel[i] = hb_kernel[j]; + } + + return cnv; +} + +void iqconverter_float_free(iqconverter_float_t *cnv) +{ + _aligned_free(cnv->fir_kernel); + _aligned_free(cnv->fir_queue); + _aligned_free(cnv->delay_line); + _aligned_free(cnv); +} + +void iqconverter_float_reset(iqconverter_float_t *cnv) +{ + cnv->avg = 0.0f; + cnv->fir_index = 0; + cnv->delay_index = 0; + memset(cnv->delay_line, 0, cnv->len * sizeof(float) / 2); + memset(cnv->fir_queue, 0, cnv->len * sizeof(float) * SIZE_FACTOR); +} + +static _inline float process_fir_taps(const float *kernel, const float *queue, int len) +{ + int i; + +#ifdef USE_SSE2 + + __m128 acc = _mm_set_ps(0, 0, 0, 0); + +#else + + float sum = 0.0f; + +#endif + + if (len >= 8) + { + int it = len >> 3; + +#ifdef USE_SSE2 + + for (i = 0; i < it; i++)
+ {
+ __m128 head1 = _mm_loadu_ps(queue);
+ __m128 kern1 = _mm_load_ps(kernel);
+ __m128 head2 = _mm_loadu_ps(queue + 4);
+ __m128 kern2 = _mm_load_ps(kernel + 4);
+
+ __m128 mul1 = _mm_mul_ps(kern1, head1);
+ __m128 mul2 = _mm_mul_ps(kern2, head2);
+
+ mul1 = _mm_add_ps(mul1, mul2);
+
+ acc = _mm_add_ps(acc, mul1);
+
+ queue += 8;
+ kernel += 8;
+ } + +#else + + for (i = 0; i < it; i++) + { + sum += kernel[0] * queue[0] + + kernel[1] * queue[1] + + kernel[2] * queue[2] + + kernel[3] * queue[3] + + kernel[4] * queue[4] + + kernel[5] * queue[5] + + kernel[6] * queue[6] + + kernel[7] * queue[7];
+
+ queue += 8;
+ kernel += 8; + } + +#endif + len &= 7; + } + + if (len >= 4) + { + +#ifdef USE_SSE2 + + __m128 head = _mm_loadu_ps(queue);
+ __m128 kern = _mm_load_ps(kernel);
+ __m128 mul = _mm_mul_ps(kern, head); + acc = _mm_add_ps(acc, mul); + +#else + + sum += kernel[0] * queue[0] + + kernel[1] * queue[1] + + kernel[2] * queue[2] + + kernel[3] * queue[3]; + +#endif + + kernel += 4; + queue += 4; + len &= 3; + }
+
+#ifdef USE_SSE2 +
+ __m128 t = _mm_add_ps(acc, _mm_movehl_ps(acc, acc));
+ acc = _mm_add_ss(t, _mm_shuffle_ps(t, t, 1)); + +#ifdef __FreeBSD__ + float sum = acc[0]; +#else + float sum = acc.m128_f32[0]; +#endif + +#endif + + if (len >= 2) + { + sum += kernel[0] * queue[0] + + kernel[1] * queue[1]; + + //kernel += 2; + //queue += 2; + //len &= 1; + } + + //if (len >= 1) + //{ + // sum += kernel[0] * queue[0]; + //} + + return sum; +} + +static void fir_interleaved_4(iqconverter_float_t *cnv, float *samples, int len) +{ + int i; + int fir_index = cnv->fir_index; + int fir_len = cnv->len; + float *fir_kernel = cnv->fir_kernel; + float *fir_queue = cnv->fir_queue; + float *queue; + float acc; + + for (i = 0; i < len; i += 2) + { + queue = fir_queue + fir_index; + + queue[0] = samples[i]; + + acc = fir_kernel[0] * (queue[0] + queue[4 - 1]) + + fir_kernel[1] * (queue[1] + queue[4 - 2]); + + samples[i] = acc; + + if (--fir_index < 0) + { + fir_index = fir_len * (SIZE_FACTOR - 1); + memcpy(fir_queue + fir_index + 1, fir_queue, (fir_len - 1) * sizeof(float)); + } + } + + cnv->fir_index = fir_index; +} + +static void fir_interleaved_8(iqconverter_float_t *cnv, float *samples, int len) +{ + int i; + int fir_index = cnv->fir_index; + int fir_len = cnv->len; + float *fir_kernel = cnv->fir_kernel; + float *fir_queue = cnv->fir_queue; + float *queue; + float acc; + + for (i = 0; i < len; i += 2) + { + queue = fir_queue + fir_index; + + queue[0] = samples[i]; + + acc = fir_kernel[0] * (queue[0] + queue[8 - 1]) + + fir_kernel[1] * (queue[1] + queue[8 - 2]) + + fir_kernel[2] * (queue[2] + queue[8 - 3]) + + fir_kernel[3] * (queue[3] + queue[8 - 4]); + + samples[i] = acc; + + if (--fir_index < 0) + { + fir_index = fir_len * (SIZE_FACTOR - 1); + memcpy(fir_queue + fir_index + 1, fir_queue, (fir_len - 1) * sizeof(float)); + } + } + + cnv->fir_index = fir_index; +} + +static void fir_interleaved_12(iqconverter_float_t *cnv, float *samples, int len) +{ + int i; + int fir_index = cnv->fir_index; + int fir_len = cnv->len; + float *fir_kernel = cnv->fir_kernel; + float *fir_queue = cnv->fir_queue; + float *queue; + float acc = 0; + + for (i = 0; i < len; i += 2) + { + queue = fir_queue + fir_index; + + queue[0] = samples[i]; + + acc = fir_kernel[0] * (queue[0] + queue[12 - 1]) + + fir_kernel[1] * (queue[1] + queue[12 - 2]) + + fir_kernel[2] * (queue[2] + queue[12 - 3]) + + fir_kernel[3] * (queue[3] + queue[12 - 4]) + + fir_kernel[4] * (queue[4] + queue[12 - 5]) + + fir_kernel[5] * (queue[5] + queue[12 - 6]); + + samples[i] = acc; + + if (--fir_index < 0) + { + fir_index = fir_len * (SIZE_FACTOR - 1); + memcpy(fir_queue + fir_index + 1, fir_queue, (fir_len - 1) * sizeof(float)); + } + } + + cnv->fir_index = fir_index; +} + +static void fir_interleaved_24(iqconverter_float_t *cnv, float *samples, int len) +{ + int i; + int fir_index = cnv->fir_index; + int fir_len = cnv->len; + float *fir_kernel = cnv->fir_kernel; + float *fir_queue = cnv->fir_queue; + float *queue; + float acc = 0; + + for (i = 0; i < len; i += 2) + { + queue = fir_queue + fir_index; + + queue[0] = samples[i]; + + acc = fir_kernel[0] * (queue[0] + queue[24 - 1]) + + fir_kernel[1] * (queue[1] + queue[24 - 2]) + + fir_kernel[2] * (queue[2] + queue[24 - 3]) + + fir_kernel[3] * (queue[3] + queue[24 - 4]) + + fir_kernel[4] * (queue[4] + queue[24 - 5]) + + fir_kernel[5] * (queue[5] + queue[24 - 6]) + + fir_kernel[6] * (queue[6] + queue[24 - 7]) + + fir_kernel[7] * (queue[7] + queue[24 - 8]) + + fir_kernel[8] * (queue[8] + queue[24 - 9]) + + fir_kernel[9] * (queue[9] + queue[24 - 10]) + + fir_kernel[10] * (queue[10] + queue[24 - 11]) + + fir_kernel[11] * (queue[11] + queue[24 - 12]); + + samples[i] = acc; + + if (--fir_index < 0) + { + fir_index = fir_len * (SIZE_FACTOR - 1); + memcpy(fir_queue + fir_index + 1, fir_queue, (fir_len - 1) * sizeof(float)); + } + } + + cnv->fir_index = fir_index; +} + +static void fir_interleaved_generic(iqconverter_float_t *cnv, float *samples, int len) +{ + int i; + int fir_index = cnv->fir_index; + int fir_len = cnv->len; + float *fir_kernel = cnv->fir_kernel; + float *fir_queue = cnv->fir_queue; + float *queue; + + for (i = 0; i < len; i += 2) + { + queue = fir_queue + fir_index; + + queue[0] = samples[i]; + + samples[i] = process_fir_taps(fir_kernel, queue, fir_len); + + if (--fir_index < 0) + { + fir_index = fir_len * (SIZE_FACTOR - 1); + memcpy(fir_queue + fir_index + 1, fir_queue, (fir_len - 1) * sizeof(float)); + } + } + + cnv->fir_index = fir_index; +} + +static void fir_interleaved(iqconverter_float_t *cnv, float *samples, int len) +{ + switch (cnv->len) + { + case 4: + fir_interleaved_4(cnv, samples, len); + break; + case 8: + fir_interleaved_8(cnv, samples, len); + break; + case 12: + fir_interleaved_12(cnv, samples, len); + break; + case 24: + fir_interleaved_24(cnv, samples, len); + break; + default: + fir_interleaved_generic(cnv, samples, len); + break; + } +} + +static void delay_interleaved(iqconverter_float_t *cnv, float *samples, int len) +{ + int i; + ALIGNED int index; + ALIGNED int half_len; + ALIGNED float res; + + half_len = cnv->len >> 1; + index = cnv->delay_index; + + for (i = 0; i < len; i += 2) + { + res = cnv->delay_line[index]; + cnv->delay_line[index] = samples[i]; + samples[i] = res; + + if (++index >= half_len) + { + index = 0; + } + } + + cnv->delay_index = index; +} + +#define SCALE (0.01f) + +static void remove_dc(iqconverter_float_t *cnv, float *samples, int len) +{ + int i; + ALIGNED float avg = cnv->avg; + + for (i = 0; i < len; i++) + { + samples[i] -= avg; + avg += SCALE * samples[i]; + } + + cnv->avg = avg; +} + +static void translate_fs_4(iqconverter_float_t *cnv, float *samples, int len) +{ + int i; + ALIGNED float hbc = cnv->hbc; + +#ifdef USE_SSE2 + + float *buf = samples; + ALIGNED __m128 vec; + ALIGNED __m128 rot = _mm_set_ps(hbc, 1.0f, -hbc, -1.0f); + + for (i = 0; i < len / 4; i++, buf +=4) + { + vec = _mm_loadu_ps(buf); + vec = _mm_mul_ps(vec, rot); + _mm_storeu_ps(buf, vec); + } + +#else + + int j; + + for (i = 0; i < len / 4; i++) + { + j = i << 2; + samples[j + 0] = -samples[j + 0]; + samples[j + 1] = -samples[j + 1] * hbc; + //samples[j + 2] = samples[j + 2]; + samples[j + 3] = samples[j + 3] * hbc; + } + +#endif + + fir_interleaved(cnv, samples, len); + delay_interleaved(cnv, samples + 1, len); +} + +void iqconverter_float_process(iqconverter_float_t *cnv, float *samples, int len) +{ + remove_dc(cnv, samples, len); + translate_fs_4(cnv, samples, len); +} diff --git a/Radio/HW/AirSpy/src/iqconverter_float.h b/Radio/HW/AirSpy/src/iqconverter_float.h new file mode 100644 index 0000000..f82b8b3 --- /dev/null +++ b/Radio/HW/AirSpy/src/iqconverter_float.h @@ -0,0 +1,47 @@ +/* +Copyright (C) 2014, Youssef Touil <youssef@airspy.com> + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +#ifndef IQCONVERTER_FLOAT_H +#define IQCONVERTER_FLOAT_H + +#include <stdint.h> + +#define IQCONVERTER_NZEROS 2 +#define IQCONVERTER_NPOLES 2 + +typedef struct { + float avg; + float hbc; + int len; + int fir_index; + int delay_index; + float *fir_kernel; + float *fir_queue; + float *delay_line; +} iqconverter_float_t; + +iqconverter_float_t *iqconverter_float_create(const float *hb_kernel, int len); +void iqconverter_float_free(iqconverter_float_t *cnv); +void iqconverter_float_reset(iqconverter_float_t *cnv); +void iqconverter_float_process(iqconverter_float_t *cnv, float *samples, int len); + +#endif // IQCONVERTER_FLOAT_H diff --git a/Radio/HW/AirSpy/src/iqconverter_int16.c b/Radio/HW/AirSpy/src/iqconverter_int16.c new file mode 100644 index 0000000..abb3109 --- /dev/null +++ b/Radio/HW/AirSpy/src/iqconverter_int16.c @@ -0,0 +1,205 @@ +/* +Copyright (C) 2014, Youssef Touil <youssef@airspy.com> + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +#include "iqconverter_int16.h" +#include <stdlib.h> +#include <string.h> + +#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) + #include <malloc.h> + #define _aligned_malloc __mingw_aligned_malloc + #define _aligned_free __mingw_aligned_free + #define _inline inline +#elif defined(__APPLE__) + #include <malloc/malloc.h> + #define _aligned_malloc(size, alignment) malloc(size) + #define _aligned_free(mem) free(mem) + #define _inline inline +#elif defined(__FreeBSD__) + #define _inline inline + #define _aligned_free(mem) free(mem) +void * _aligned_malloc(size_t size, size_t alignment); +#elif defined(__GNUC__) && !defined(__MINGW64_VERSION_MAJOR) + #include <malloc.h> + #define _aligned_malloc(size, alignment) memalign(alignment, size) + #define _aligned_free(mem) free(mem) + #define _inline inline +#endif + +#define SIZE_FACTOR 16 +#define DEFAULT_ALIGNMENT 16 + +iqconverter_int16_t *iqconverter_int16_create(const int16_t *hb_kernel, int len) +{ + int i; + size_t buffer_size; + iqconverter_int16_t *cnv = (iqconverter_int16_t *) _aligned_malloc(sizeof(iqconverter_int16_t), DEFAULT_ALIGNMENT); + + cnv->len = len / 2 + 1; + + buffer_size = cnv->len * sizeof(int32_t); + + cnv->fir_kernel = (int32_t *) _aligned_malloc(buffer_size, DEFAULT_ALIGNMENT); + cnv->fir_queue = (int32_t *) _aligned_malloc(buffer_size * SIZE_FACTOR, DEFAULT_ALIGNMENT); + cnv->delay_line = (int16_t *) _aligned_malloc(buffer_size / 4, DEFAULT_ALIGNMENT); + + iqconverter_int16_reset(cnv); + + for (i = 0; i < cnv->len; i++) + { + cnv->fir_kernel[i] = hb_kernel[i * 2]; + } + + return cnv; +} + +void iqconverter_int16_free(iqconverter_int16_t *cnv) +{ + _aligned_free(cnv->fir_kernel); + _aligned_free(cnv->fir_queue); + _aligned_free(cnv->delay_line); + _aligned_free(cnv); +} + +void iqconverter_int16_reset(iqconverter_int16_t *cnv) +{ + cnv->fir_index = 0; + cnv->delay_index = 0; + cnv->old_x = 0; + cnv->old_y = 0; + cnv->old_e = 0; + memset(cnv->delay_line, 0, cnv->len * sizeof(int16_t) / 4); + memset(cnv->fir_queue, 0, cnv->len * sizeof(int16_t) * SIZE_FACTOR); +} + +static void fir_interleaved(iqconverter_int16_t *cnv, int16_t *samples, int len) +{ + int i; + int j; + int fir_index; + int fir_len; + int32_t *queue; + int32_t acc; + + fir_len = cnv->len; + fir_index = cnv->fir_index; + + for (i = 0; i < len; i += 2) + { + queue = cnv->fir_queue + fir_index; + + queue[0] = samples[i]; + + acc = 0; + + // Auto vectorization works on VS2012, VS2013 and GCC + for (j = 0; j < fir_len; j++) + { + acc += cnv->fir_kernel[j] * queue[j]; + } + + if (--fir_index < 0) + { + fir_index = cnv->len * (SIZE_FACTOR - 1); + memcpy(cnv->fir_queue + fir_index + 1, cnv->fir_queue, (cnv->len - 1) * sizeof(int32_t)); + } + + samples[i] = acc >> 15; + } + + cnv->fir_index = fir_index; +} + +static void delay_interleaved(iqconverter_int16_t *cnv, int16_t *samples, int len) +{ + int i; + int index; + int half_len; + int16_t res; + + half_len = cnv->len >> 1; + index = cnv->delay_index; + + for (i = 0; i < len; i += 2) + { + res = cnv->delay_line[index]; + cnv->delay_line[index] = samples[i]; + samples[i] = res; + + if (++index >= half_len) + { + index = 0; + } + } + + cnv->delay_index = index; +} + +static void remove_dc(iqconverter_int16_t *cnv, int16_t *samples, int len) +{ + int i; + int32_t u, old_e; + int16_t x, y, w, s, old_x, old_y; + + old_x = cnv->old_x; + old_y = cnv->old_y; + old_e = cnv->old_e; + + for (i = 0; i < len; i++) + { + x = samples[i]; + w = x - old_x; + u = old_e + (int32_t) old_y * 32100; + s = u >> 15; + y = w + s; + old_e = u - (s << 15); + old_x = x; + old_y = y; + samples[i] = y; + } + + cnv->old_x = old_x; + cnv->old_y = old_y; + cnv->old_e = old_e; +} + +static void translate_fs_4(iqconverter_int16_t *cnv, int16_t *samples, int len) +{ + int i; + + for (i = 0; i < len; i += 4) + { + samples[i + 0] = -samples[i + 0]; + samples[i + 1] = -samples[i + 1] >> 1; + //samples[i + 2] = samples[i + 2]; + samples[i + 3] = samples[i + 3] >> 1; + } + + fir_interleaved(cnv, samples, len); + delay_interleaved(cnv, samples + 1, len); +} + +void iqconverter_int16_process(iqconverter_int16_t *cnv, int16_t *samples, int len) +{ + remove_dc(cnv, samples, len); + translate_fs_4(cnv, samples, len); +} diff --git a/Radio/HW/AirSpy/src/iqconverter_int16.h b/Radio/HW/AirSpy/src/iqconverter_int16.h new file mode 100644 index 0000000..10c867d --- /dev/null +++ b/Radio/HW/AirSpy/src/iqconverter_int16.h @@ -0,0 +1,45 @@ +/* +Copyright (C) 2014, Youssef Touil <youssef@airspy.com> + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +#ifndef IQCONVERTER_INT16_H +#define IQCONVERTER_INT16_H + +#include <stdint.h> + +typedef struct { + int len; + int fir_index; + int delay_index; + int16_t old_x; + int16_t old_y; + int32_t old_e; + int32_t *fir_kernel; + int32_t *fir_queue; + int16_t *delay_line; +} iqconverter_int16_t; + +iqconverter_int16_t *iqconverter_int16_create(const int16_t *hb_kernel, int len); +void iqconverter_int16_free(iqconverter_int16_t *cnv); +void iqconverter_int16_reset(iqconverter_int16_t *cnv); +void iqconverter_int16_process(iqconverter_int16_t *cnv, int16_t *samples, int len); + +#endif // IQCONVERTER_INT16_H |