361c4ac54f
This is a defensive change to make the transceiver code easier to reason about, and to avoid the possibility of races such as that seen in #1042. Previously, set_transceiver_mode() was called in the vendor request handler for the SET_TRANSCEIVER_MODE request, as well in the callback for a USB configuration change. Both these calls are made from the USB0 ISR, so could interrupt the rx_mode(), tx_mode() and sweep_mode() functions at any point. It was hard to tell if this was safe. Instead, set_transceiver_mode() has been removed, and its work is split into three parts: - request_transceiver_mode(), which is safe to call from ISR context. All this function does is update the requested mode and increment a sequence number. This builds on work already done in PR #1029, but the interface has been simplified to use a shared volatile structure. - transceiver_startup(), which transitions the transceiver from an idle state to the configuration required for a specific mode, including setting up the RF path, configuring the M0, adjusting LEDs and UI etc. - transceiver_shutdown(), which transitions the transceiver back to an idle state. The *_mode() functions that implement the transceiver modes now call transceiver_startup() before starting work, and transceiver_shutdown() before returning, and all this happens in the main thread of execution. As such, it is now guaranteed that all the steps involved happen in a consistent order, with the transceiver starting from an idle state, and being returned to an idle state before control returns to the main loop. For consistency of interface, an off_mode() function has been added to implement the behaviour of the OFF transceiver mode. Since the transceiver is already guaranteed to be in an idle state when this is called, the only work required is to set the UI mode and wait for a new mode request.
415 lines
11 KiB
C
415 lines
11 KiB
C
/*
|
|
* Copyright 2012 Jared Boone
|
|
* Copyright 2013 Benjamin Vernoux
|
|
*
|
|
* This file is part of HackRF.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 51 Franklin Street,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "usb_api_transceiver.h"
|
|
|
|
#include "hackrf_ui.h"
|
|
#include "operacake_sctimer.h"
|
|
|
|
#include <libopencm3/cm3/vector.h>
|
|
#include "usb_bulk_buffer.h"
|
|
#include "m0_state.h"
|
|
|
|
#include "usb_api_cpld.h" // Remove when CPLD update is handled elsewhere
|
|
|
|
#include <max2837.h>
|
|
#include <rf_path.h>
|
|
#include <tuning.h>
|
|
#include <streaming.h>
|
|
#include <usb.h>
|
|
#include <usb_queue.h>
|
|
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
|
|
#include "usb_endpoint.h"
|
|
#include "usb_api_sweep.h"
|
|
|
|
typedef struct {
|
|
uint32_t freq_mhz;
|
|
uint32_t freq_hz;
|
|
} set_freq_params_t;
|
|
|
|
set_freq_params_t set_freq_params;
|
|
|
|
struct set_freq_explicit_params {
|
|
uint64_t if_freq_hz; /* intermediate frequency */
|
|
uint64_t lo_freq_hz; /* front-end local oscillator frequency */
|
|
uint8_t path; /* image rejection filter path */
|
|
};
|
|
|
|
struct set_freq_explicit_params explicit_params;
|
|
|
|
typedef struct {
|
|
uint32_t freq_hz;
|
|
uint32_t divider;
|
|
} set_sample_r_params_t;
|
|
|
|
set_sample_r_params_t set_sample_r_params;
|
|
|
|
usb_request_status_t usb_vendor_request_set_baseband_filter_bandwidth(
|
|
usb_endpoint_t* const endpoint,
|
|
const usb_transfer_stage_t stage
|
|
) {
|
|
if( stage == USB_TRANSFER_STAGE_SETUP ) {
|
|
const uint32_t bandwidth = (endpoint->setup.index << 16) | endpoint->setup.value;
|
|
if( baseband_filter_bandwidth_set(bandwidth) ) {
|
|
usb_transfer_schedule_ack(endpoint->in);
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
return USB_REQUEST_STATUS_STALL;
|
|
} else {
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
}
|
|
|
|
usb_request_status_t usb_vendor_request_set_freq(
|
|
usb_endpoint_t* const endpoint,
|
|
const usb_transfer_stage_t stage)
|
|
{
|
|
if (stage == USB_TRANSFER_STAGE_SETUP)
|
|
{
|
|
usb_transfer_schedule_block(endpoint->out, &set_freq_params, sizeof(set_freq_params_t),
|
|
NULL, NULL);
|
|
return USB_REQUEST_STATUS_OK;
|
|
} else if (stage == USB_TRANSFER_STAGE_DATA)
|
|
{
|
|
const uint64_t freq = set_freq_params.freq_mhz * 1000000ULL + set_freq_params.freq_hz;
|
|
if( set_freq(freq) )
|
|
{
|
|
usb_transfer_schedule_ack(endpoint->in);
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
return USB_REQUEST_STATUS_STALL;
|
|
} else
|
|
{
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
}
|
|
|
|
usb_request_status_t usb_vendor_request_set_sample_rate_frac(
|
|
usb_endpoint_t* const endpoint,
|
|
const usb_transfer_stage_t stage)
|
|
{
|
|
if (stage == USB_TRANSFER_STAGE_SETUP)
|
|
{
|
|
usb_transfer_schedule_block(endpoint->out, &set_sample_r_params, sizeof(set_sample_r_params_t),
|
|
NULL, NULL);
|
|
return USB_REQUEST_STATUS_OK;
|
|
} else if (stage == USB_TRANSFER_STAGE_DATA)
|
|
{
|
|
if( sample_rate_frac_set(set_sample_r_params.freq_hz * 2, set_sample_r_params.divider ) )
|
|
{
|
|
usb_transfer_schedule_ack(endpoint->in);
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
return USB_REQUEST_STATUS_STALL;
|
|
} else
|
|
{
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
}
|
|
|
|
usb_request_status_t usb_vendor_request_set_amp_enable(
|
|
usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage)
|
|
{
|
|
if (stage == USB_TRANSFER_STAGE_SETUP) {
|
|
switch (endpoint->setup.value) {
|
|
case 0:
|
|
rf_path_set_lna(&rf_path, 0);
|
|
usb_transfer_schedule_ack(endpoint->in);
|
|
return USB_REQUEST_STATUS_OK;
|
|
case 1:
|
|
rf_path_set_lna(&rf_path, 1);
|
|
usb_transfer_schedule_ack(endpoint->in);
|
|
return USB_REQUEST_STATUS_OK;
|
|
default:
|
|
return USB_REQUEST_STATUS_STALL;
|
|
}
|
|
} else {
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
}
|
|
|
|
usb_request_status_t usb_vendor_request_set_lna_gain(
|
|
usb_endpoint_t* const endpoint,
|
|
const usb_transfer_stage_t stage)
|
|
{
|
|
if( stage == USB_TRANSFER_STAGE_SETUP ) {
|
|
const uint8_t value = max2837_set_lna_gain(&max2837, endpoint->setup.index);
|
|
endpoint->buffer[0] = value;
|
|
if(value) hackrf_ui()->set_bb_lna_gain(endpoint->setup.index);
|
|
usb_transfer_schedule_block(endpoint->in, &endpoint->buffer, 1,
|
|
NULL, NULL);
|
|
usb_transfer_schedule_ack(endpoint->out);
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
|
|
usb_request_status_t usb_vendor_request_set_vga_gain(
|
|
usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage)
|
|
{
|
|
if( stage == USB_TRANSFER_STAGE_SETUP ) {
|
|
const uint8_t value = max2837_set_vga_gain(&max2837, endpoint->setup.index);
|
|
endpoint->buffer[0] = value;
|
|
if(value) hackrf_ui()->set_bb_vga_gain(endpoint->setup.index);
|
|
usb_transfer_schedule_block(endpoint->in, &endpoint->buffer, 1,
|
|
NULL, NULL);
|
|
usb_transfer_schedule_ack(endpoint->out);
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
|
|
usb_request_status_t usb_vendor_request_set_txvga_gain(
|
|
usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage)
|
|
{
|
|
if( stage == USB_TRANSFER_STAGE_SETUP ) {
|
|
const uint8_t value = max2837_set_txvga_gain(&max2837, endpoint->setup.index);
|
|
endpoint->buffer[0] = value;
|
|
if(value) hackrf_ui()->set_bb_tx_vga_gain(endpoint->setup.index);
|
|
usb_transfer_schedule_block(endpoint->in, &endpoint->buffer, 1,
|
|
NULL, NULL);
|
|
usb_transfer_schedule_ack(endpoint->out);
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
|
|
usb_request_status_t usb_vendor_request_set_antenna_enable(
|
|
usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage)
|
|
{
|
|
if (stage == USB_TRANSFER_STAGE_SETUP) {
|
|
switch (endpoint->setup.value) {
|
|
case 0:
|
|
rf_path_set_antenna(&rf_path, 0);
|
|
usb_transfer_schedule_ack(endpoint->in);
|
|
return USB_REQUEST_STATUS_OK;
|
|
case 1:
|
|
rf_path_set_antenna(&rf_path, 1);
|
|
usb_transfer_schedule_ack(endpoint->in);
|
|
return USB_REQUEST_STATUS_OK;
|
|
default:
|
|
return USB_REQUEST_STATUS_STALL;
|
|
}
|
|
} else {
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
}
|
|
|
|
usb_request_status_t usb_vendor_request_set_freq_explicit(
|
|
usb_endpoint_t* const endpoint,
|
|
const usb_transfer_stage_t stage)
|
|
{
|
|
if (stage == USB_TRANSFER_STAGE_SETUP) {
|
|
usb_transfer_schedule_block(endpoint->out, &explicit_params,
|
|
sizeof(struct set_freq_explicit_params), NULL, NULL);
|
|
return USB_REQUEST_STATUS_OK;
|
|
} else if (stage == USB_TRANSFER_STAGE_DATA) {
|
|
if (set_freq_explicit(explicit_params.if_freq_hz,
|
|
explicit_params.lo_freq_hz, explicit_params.path)) {
|
|
usb_transfer_schedule_ack(endpoint->in);
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
return USB_REQUEST_STATUS_STALL;
|
|
} else {
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
}
|
|
|
|
static volatile hw_sync_mode_t _hw_sync_mode = HW_SYNC_MODE_OFF;
|
|
|
|
void set_hw_sync_mode(const hw_sync_mode_t new_hw_sync_mode) {
|
|
_hw_sync_mode = new_hw_sync_mode;
|
|
}
|
|
|
|
volatile transceiver_request_t transceiver_request = {
|
|
.mode = TRANSCEIVER_MODE_OFF,
|
|
.seq = 0,
|
|
};
|
|
|
|
// Must be called from an atomic context (normally USB ISR)
|
|
void request_transceiver_mode(transceiver_mode_t mode)
|
|
{
|
|
transceiver_request.mode = mode;
|
|
transceiver_request.seq++;
|
|
}
|
|
|
|
void transceiver_shutdown(void)
|
|
{
|
|
baseband_streaming_disable(&sgpio_config);
|
|
operacake_sctimer_reset_state();
|
|
|
|
usb_endpoint_flush(&usb_endpoint_bulk_in);
|
|
usb_endpoint_flush(&usb_endpoint_bulk_out);
|
|
|
|
led_off(LED2);
|
|
led_off(LED3);
|
|
rf_path_set_direction(&rf_path, RF_PATH_DIRECTION_OFF);
|
|
m0_state.tx = false;
|
|
}
|
|
|
|
void transceiver_startup(const transceiver_mode_t mode) {
|
|
|
|
hackrf_ui()->set_transceiver_mode(mode);
|
|
|
|
switch (mode) {
|
|
case TRANSCEIVER_MODE_RX_SWEEP:
|
|
case TRANSCEIVER_MODE_RX:
|
|
led_off(LED3);
|
|
led_on(LED2);
|
|
rf_path_set_direction(&rf_path, RF_PATH_DIRECTION_RX);
|
|
m0_state.tx = false;
|
|
break;
|
|
case TRANSCEIVER_MODE_TX:
|
|
led_off(LED2);
|
|
led_on(LED3);
|
|
rf_path_set_direction(&rf_path, RF_PATH_DIRECTION_TX);
|
|
m0_state.tx = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
activate_best_clock_source();
|
|
hw_sync_enable(_hw_sync_mode);
|
|
m0_state.offset = 0;
|
|
}
|
|
|
|
usb_request_status_t usb_vendor_request_set_transceiver_mode(
|
|
usb_endpoint_t* const endpoint,
|
|
const usb_transfer_stage_t stage)
|
|
{
|
|
if( stage == USB_TRANSFER_STAGE_SETUP ) {
|
|
switch( endpoint->setup.value ) {
|
|
case TRANSCEIVER_MODE_OFF:
|
|
case TRANSCEIVER_MODE_RX:
|
|
case TRANSCEIVER_MODE_TX:
|
|
case TRANSCEIVER_MODE_RX_SWEEP:
|
|
case TRANSCEIVER_MODE_CPLD_UPDATE:
|
|
request_transceiver_mode(endpoint->setup.value);
|
|
usb_transfer_schedule_ack(endpoint->in);
|
|
return USB_REQUEST_STATUS_OK;
|
|
default:
|
|
return USB_REQUEST_STATUS_STALL;
|
|
}
|
|
} else {
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
}
|
|
|
|
usb_request_status_t usb_vendor_request_set_hw_sync_mode(
|
|
usb_endpoint_t* const endpoint,
|
|
const usb_transfer_stage_t stage)
|
|
{
|
|
if( stage == USB_TRANSFER_STAGE_SETUP ) {
|
|
set_hw_sync_mode(endpoint->setup.value);
|
|
usb_transfer_schedule_ack(endpoint->in);
|
|
return USB_REQUEST_STATUS_OK;
|
|
} else {
|
|
return USB_REQUEST_STATUS_OK;
|
|
}
|
|
}
|
|
|
|
void rx_mode(uint32_t seq) {
|
|
unsigned int phase = 1;
|
|
|
|
transceiver_startup(TRANSCEIVER_MODE_RX);
|
|
|
|
baseband_streaming_enable(&sgpio_config);
|
|
|
|
while (transceiver_request.seq == seq) {
|
|
// Set up IN transfer of buffer 0.
|
|
if (16384 <= m0_state.offset && 1 == phase) {
|
|
usb_transfer_schedule_block(
|
|
&usb_endpoint_bulk_in,
|
|
&usb_bulk_buffer[0x0000],
|
|
0x4000,
|
|
NULL, NULL
|
|
);
|
|
phase = 0;
|
|
}
|
|
// Set up IN transfer of buffer 1.
|
|
if (16384 > m0_state.offset && 0 == phase) {
|
|
usb_transfer_schedule_block(
|
|
&usb_endpoint_bulk_in,
|
|
&usb_bulk_buffer[0x4000],
|
|
0x4000,
|
|
NULL, NULL
|
|
);
|
|
phase = 1;
|
|
}
|
|
}
|
|
|
|
transceiver_shutdown();
|
|
}
|
|
|
|
void tx_mode(uint32_t seq) {
|
|
unsigned int phase = 1;
|
|
|
|
transceiver_startup(TRANSCEIVER_MODE_TX);
|
|
|
|
memset(&usb_bulk_buffer[0x0000], 0, 0x8000);
|
|
// Set up OUT transfer of buffer 1.
|
|
usb_transfer_schedule_block(
|
|
&usb_endpoint_bulk_out,
|
|
&usb_bulk_buffer[0x4000],
|
|
0x4000,
|
|
NULL, NULL
|
|
);
|
|
// Start transmitting zeros while the host fills buffer 1.
|
|
baseband_streaming_enable(&sgpio_config);
|
|
|
|
while (transceiver_request.seq == seq) {
|
|
// Set up OUT transfer of buffer 0.
|
|
if (16384 <= m0_state.offset && 1 == phase) {
|
|
usb_transfer_schedule_block(
|
|
&usb_endpoint_bulk_out,
|
|
&usb_bulk_buffer[0x0000],
|
|
0x4000,
|
|
NULL, NULL
|
|
);
|
|
phase = 0;
|
|
}
|
|
// Set up OUT transfer of buffer 1.
|
|
if (16384 > m0_state.offset && 0 == phase) {
|
|
usb_transfer_schedule_block(
|
|
&usb_endpoint_bulk_out,
|
|
&usb_bulk_buffer[0x4000],
|
|
0x4000,
|
|
NULL, NULL
|
|
);
|
|
phase = 1;
|
|
}
|
|
}
|
|
|
|
transceiver_shutdown();
|
|
}
|
|
|
|
void off_mode(uint32_t seq)
|
|
{
|
|
hackrf_ui()->set_transceiver_mode(TRANSCEIVER_MODE_OFF);
|
|
|
|
while (transceiver_request.seq == seq);
|
|
}
|