diff --git a/firmware/common/hackrf_core.c b/firmware/common/hackrf_core.c index b5acb892..e81b18b4 100644 --- a/firmware/common/hackrf_core.c +++ b/firmware/common/hackrf_core.c @@ -26,10 +26,7 @@ #include "sgpio.h" #include "si5351c.h" #include "spi_ssp.h" -#include "max2837.h" -#include "max2837_target.h" -#include "max2839.h" -#include "max2839_target.h" +#include "max283x.h" #include "max5864.h" #include "max5864_target.h" #include "w25q80bv.h" @@ -65,9 +62,6 @@ static struct gpio_t gpio_1v8_enable = GPIO(3, 6); /* MAX2837 GPIO (XCVR_CTL) PinMux */ static struct gpio_t gpio_max2837_select = GPIO(0, 15); -static struct gpio_t gpio_max2837_enable = GPIO(2, 6); -static struct gpio_t gpio_max2837_rx_enable = GPIO(2, 5); -static struct gpio_t gpio_max2837_tx_enable = GPIO(2, 4); /* MAX5864 SPI chip select (AD_CS) GPIO PinMux */ static struct gpio_t gpio_max5864_select = GPIO(2, 7); @@ -229,22 +223,7 @@ spi_bus_t spi_bus_ssp1 = { .transfer_gather = spi_ssp_transfer_gather, }; -max2837_driver_t max2837 = { - .bus = &spi_bus_ssp1, - .gpio_enable = &gpio_max2837_enable, - .gpio_rx_enable = &gpio_max2837_rx_enable, - .gpio_tx_enable = &gpio_max2837_tx_enable, - .target_init = max2837_target_init, - .set_mode = max2837_target_set_mode, -}; - -max2839_driver_t max2839 = { - .bus = &spi_bus_ssp1, - .gpio_enable = &gpio_max2837_enable, - .gpio_rxtx = &gpio_max2837_rx_enable, - .target_init = max2839_target_init, - .set_mode = max2839_target_set_mode, -}; +max283x_driver_t max283x = {}; max5864_driver_t max5864 = { .bus = &spi_bus_ssp1, @@ -560,11 +539,7 @@ bool sample_rate_set(const uint32_t sample_rate_hz) bool baseband_filter_bandwidth_set(const uint32_t bandwidth_hz) { uint32_t bandwidth_hz_real; - if (detected_platform() == BOARD_ID_HACKRF1_R9) { - bandwidth_hz_real = max2839_set_lpf_bandwidth(&max2839, bandwidth_hz); - } else { - bandwidth_hz_real = max2837_set_lpf_bandwidth(&max2837, bandwidth_hz); - } + bandwidth_hz_real = max283x_set_lpf_bandwidth(&max283x, bandwidth_hz); if (bandwidth_hz_real) { hackrf_ui()->set_filter_bw(bandwidth_hz_real); diff --git a/firmware/common/hackrf_core.h b/firmware/common/hackrf_core.h index 0bd22da0..5aa08b24 100644 --- a/firmware/common/hackrf_core.h +++ b/firmware/common/hackrf_core.h @@ -34,6 +34,7 @@ extern "C" { #include "si5351c.h" #include "spi_ssp.h" +#include "max283x.h" #include "max2837.h" #include "max2839.h" #include "max5864.h" @@ -273,6 +274,7 @@ extern const ssp_config_t ssp_config_max2837; extern const ssp_config_t ssp_config_max2839; extern const ssp_config_t ssp_config_max5864; +extern max283x_driver_t max283x; extern max2837_driver_t max2837; extern max2839_driver_t max2839; //FIXME xcvr hal extern max5864_driver_t max5864; diff --git a/firmware/common/max2837.h b/firmware/common/max2837.h index 25a78a15..5f0b0024 100644 --- a/firmware/common/max2837.h +++ b/firmware/common/max2837.h @@ -45,7 +45,7 @@ struct max2837_driver_t; typedef struct max2837_driver_t max2837_driver_t; struct max2837_driver_t { - spi_bus_t* const bus; + spi_bus_t* bus; gpio_t gpio_enable; gpio_t gpio_rx_enable; gpio_t gpio_tx_enable; diff --git a/firmware/common/max2839.h b/firmware/common/max2839.h index dd7e7f3a..9be7d090 100644 --- a/firmware/common/max2839.h +++ b/firmware/common/max2839.h @@ -35,19 +35,19 @@ typedef enum { MAX2839_MODE_SHUTDOWN, - MAX2839_MODE_CLKOUT, MAX2839_MODE_STANDBY, - MAX2839_MODE_RX, MAX2839_MODE_TX, + MAX2839_MODE_RX, MAX2839_MODE_RX_CAL, MAX2839_MODE_TX_CAL, + MAX2839_MODE_CLKOUT, } max2839_mode_t; struct max2839_driver_t; typedef struct max2839_driver_t max2839_driver_t; struct max2839_driver_t { - spi_bus_t* const bus; + spi_bus_t* bus; gpio_t gpio_enable; gpio_t gpio_rxtx; void (*target_init)(max2839_driver_t* const drv); diff --git a/firmware/common/max283x.c b/firmware/common/max283x.c new file mode 100644 index 00000000..62f9829d --- /dev/null +++ b/firmware/common/max283x.c @@ -0,0 +1,280 @@ +/* + * Copyright 2012-2022 Great Scott Gadgets + * Copyright 2012 Will Code + * Copyright 2014 Jared Boone + * + * 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 "max283x.h" + +#include "gpio.h" +#include "gpio_lpc.h" +#include "max2837.h" +#include "max2837_target.h" +#include "max2839.h" +#include "max2839_target.h" +#include "spi_bus.h" + +extern spi_bus_t spi_bus_ssp1; +static struct gpio_t gpio_max2837_enable = GPIO(2, 6); +static struct gpio_t gpio_max2837_rx_enable = GPIO(2, 5); +static struct gpio_t gpio_max2837_tx_enable = GPIO(2, 4); + +max2837_driver_t max2837 = { + .bus = &spi_bus_ssp1, + .gpio_enable = &gpio_max2837_enable, + .gpio_rx_enable = &gpio_max2837_rx_enable, + .gpio_tx_enable = &gpio_max2837_tx_enable, + .target_init = max2837_target_init, + .set_mode = max2837_target_set_mode, +}; + +max2839_driver_t max2839 = { + .bus = &spi_bus_ssp1, + .gpio_enable = &gpio_max2837_enable, + .gpio_rxtx = &gpio_max2837_rx_enable, + .target_init = max2839_target_init, + .set_mode = max2839_target_set_mode, +}; + +/* Initialize chip. */ +void max283x_setup(max283x_driver_t* const drv, max283x_variant_t type) +{ + drv->type = type; + switch (type) { + case MAX2837_VARIANT: + memcpy(&drv->drv.max2837, &max2837, sizeof(max2837)); + max2837_setup(&drv->drv.max2837); + break; + + case MAX2839_VARIANT: + memcpy(&drv->drv.max2839, &max2839, sizeof(max2839)); + max2839_setup(&drv->drv.max2839); + break; + } +} + +/* Read a register via SPI. Save a copy to memory and return + * value. Mark clean. */ +uint16_t max283x_reg_read(max283x_driver_t* const drv, uint8_t r) +{ + switch (drv->type) { + case MAX2837_VARIANT: + return max2837_reg_read(&drv->drv.max2837, r); + break; + + case MAX2839_VARIANT: + return max2839_reg_read(&drv->drv.max2839, r); + break; + } + + return 0; +} + +/* Write value to register via SPI and save a copy to memory. Mark + * clean. */ +void max283x_reg_write(max283x_driver_t* const drv, uint8_t r, uint16_t v) +{ + switch (drv->type) { + case MAX2837_VARIANT: + max2837_reg_write(&drv->drv.max2837, r, v); + break; + + case MAX2839_VARIANT: + max2839_reg_write(&drv->drv.max2839, r, v); + break; + } +} + +/* Write all dirty registers via SPI from memory. Mark all clean. Some + * operations require registers to be written in a certain order. Use + * provided routines for those operations. */ +void max283x_regs_commit(max283x_driver_t* const drv) +{ + switch (drv->type) { + case MAX2837_VARIANT: + max2837_regs_commit(&drv->drv.max2837); + break; + + case MAX2839_VARIANT: + max2839_regs_commit(&drv->drv.max2839); + break; + } +} + +void max283x_set_mode(max283x_driver_t* const drv, const max283x_mode_t new_mode) +{ + switch (drv->type) { + case MAX2837_VARIANT: + max2837_set_mode(&drv->drv.max2837, (max2837_mode_t) new_mode); + break; + + case MAX2839_VARIANT: + max2839_set_mode(&drv->drv.max2839, (max2839_mode_t) new_mode); + break; + } +} + +max283x_mode_t max283x_mode(max283x_driver_t* const drv) +{ + switch (drv->type) { + case MAX2837_VARIANT: + return (max283x_mode_t) max2837_mode(&drv->drv.max2837); + break; + + case MAX2839_VARIANT: + return (max283x_mode_t) max2839_mode(&drv->drv.max2839); + break; + } + + return 0; +} + +//max283x_mode_t max283x_mode(max283x_driver_t* const drv); +//void max283x_set_mode(max283x_driver_t* const drv, const max283x_mode_t new_mode); + +/* Turn on/off all chip functions. Does not control oscillator and CLKOUT */ +void max283x_start(max283x_driver_t* const drv) +{ + switch (drv->type) { + case MAX2837_VARIANT: + max2837_start(&drv->drv.max2837); + break; + + case MAX2839_VARIANT: + max2839_start(&drv->drv.max2839); + break; + } +} + +void max283x_stop(max283x_driver_t* const drv) +{ + switch (drv->type) { + case MAX2837_VARIANT: + max2837_stop(&drv->drv.max2837); + break; + + case MAX2839_VARIANT: + max2839_stop(&drv->drv.max2839); + break; + } +} + +/* Set frequency in Hz. Frequency setting is a multi-step function + * where order of register writes matters. */ +void max283x_set_frequency(max283x_driver_t* const drv, uint32_t freq) +{ + switch (drv->type) { + case MAX2837_VARIANT: + max2837_set_frequency(&drv->drv.max2837, freq); + break; + + case MAX2839_VARIANT: + max2839_set_frequency(&drv->drv.max2839, freq); + break; + } +} + +uint32_t max283x_set_lpf_bandwidth( + max283x_driver_t* const drv, + const uint32_t bandwidth_hz) +{ + switch (drv->type) { + case MAX2837_VARIANT: + return max2837_set_lpf_bandwidth(&drv->drv.max2837, bandwidth_hz); + break; + + case MAX2839_VARIANT: + return max2839_set_lpf_bandwidth(&drv->drv.max2839, bandwidth_hz); + break; + } + + return 0; +} + +bool max283x_set_lna_gain(max283x_driver_t* const drv, const uint32_t gain_db) +{ + switch (drv->type) { + case MAX2837_VARIANT: + return max2837_set_lna_gain(&drv->drv.max2837, gain_db); + break; + + case MAX2839_VARIANT: + return max2839_set_lna_gain(&drv->drv.max2839, gain_db); + break; + } + + return false; +} + +bool max283x_set_vga_gain(max283x_driver_t* const drv, const uint32_t gain_db) +{ + switch (drv->type) { + case MAX2837_VARIANT: + return max2837_set_vga_gain(&drv->drv.max2837, gain_db); + break; + + case MAX2839_VARIANT: + return max2839_set_vga_gain(&drv->drv.max2839, gain_db); + break; + } + + return false; +} + +bool max283x_set_txvga_gain(max283x_driver_t* const drv, const uint32_t gain_db) +{ + switch (drv->type) { + case MAX2837_VARIANT: + return max2837_set_txvga_gain(&drv->drv.max2837, gain_db); + break; + + case MAX2839_VARIANT: + return max2839_set_txvga_gain(&drv->drv.max2839, gain_db); + break; + } + + return false; +} + +void max283x_tx(max283x_driver_t* const drv) +{ + switch (drv->type) { + case MAX2837_VARIANT: + max2837_tx(&drv->drv.max2837); + break; + + case MAX2839_VARIANT: + max2839_tx(&drv->drv.max2839); + break; + } +} + +void max283x_rx(max283x_driver_t* const drv) +{ + switch (drv->type) { + case MAX2837_VARIANT: + max2837_rx(&drv->drv.max2837); + break; + + case MAX2839_VARIANT: + max2839_rx(&drv->drv.max2839); + break; + } +} diff --git a/firmware/common/max283x.h b/firmware/common/max283x.h new file mode 100644 index 00000000..eaf15a70 --- /dev/null +++ b/firmware/common/max283x.h @@ -0,0 +1,104 @@ +/* + * Copyright 2012-2022 Great Scott Gadgets + * Copyright 2012 Will Code + * Copyright 2014 Jared Boone + * + * 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. + */ + +#ifndef __MAX283x_H +#define __MAX283x_H + +#include +#include +#include + +#include "gpio.h" +#include "gpio_lpc.h" +#include "max2837.h" +#include "max2837_target.h" +#include "max2839.h" +#include "max2839_target.h" +#include "spi_bus.h" + +typedef enum { + MAX283x_MODE_SHUTDOWN, + MAX283x_MODE_STANDBY, + MAX283x_MODE_TX, + MAX283x_MODE_RX, + MAX283x_MODE_RX_CAL, + MAX283x_MODE_TX_CAL, + MAX283x_MODE_CLKOUT, +} max283x_mode_t; + +typedef enum { + MAX2837_VARIANT, + MAX2839_VARIANT, +} max283x_variant_t; + +typedef struct { + max283x_variant_t type; + + union { + max2837_driver_t max2837; + max2839_driver_t max2839; + } drv; +} max283x_driver_t; + +/* Initialize chip. */ +void max283x_setup(max283x_driver_t* const drv, max283x_variant_t type); + +/* Read a register via SPI. Save a copy to memory and return + * value. Mark clean. */ +uint16_t max283x_reg_read(max283x_driver_t* const drv, uint8_t r); + +/* Write value to register via SPI and save a copy to memory. Mark + * clean. */ +void max283x_reg_write(max283x_driver_t* const drv, uint8_t r, uint16_t v); + +/* Write all dirty registers via SPI from memory. Mark all clean. Some + * operations require registers to be written in a certain order. Use + * provided routines for those operations. */ +void max283x_regs_commit(max283x_driver_t* const drv); + +//max283x_mode_t max283x_mode(max283x_driver_t* const drv); +//void max283x_set_mode(max283x_driver_t* const drv, const max283x_mode_t new_mode); + +max283x_mode_t max283x_mode(max283x_driver_t* const drv); +void max283x_set_mode(max283x_driver_t* const drv, const max283x_mode_t new_mode); + +/* Turn on/off all chip functions. Does not control oscillator and CLKOUT */ +void max283x_start(max283x_driver_t* const drv); +void max283x_stop(max283x_driver_t* const drv); + +/* Set frequency in Hz. Frequency setting is a multi-step function + * where order of register writes matters. */ +void max283x_set_frequency(max283x_driver_t* const drv, uint32_t freq); +uint32_t max283x_set_lpf_bandwidth( + max283x_driver_t* const drv, + const uint32_t bandwidth_hz); + +bool max283x_set_lna_gain(max283x_driver_t* const drv, const uint32_t gain_db); + +bool max283x_set_vga_gain(max283x_driver_t* const drv, const uint32_t gain_db); +bool max283x_set_txvga_gain(max283x_driver_t* const drv, const uint32_t gain_db); + +void max283x_tx(max283x_driver_t* const drv); +void max283x_rx(max283x_driver_t* const drv); + +#endif // __MAX283x_H diff --git a/firmware/common/rf_path.c b/firmware/common/rf_path.c index bdc5341e..229cfac8 100644 --- a/firmware/common/rf_path.c +++ b/firmware/common/rf_path.c @@ -31,6 +31,7 @@ #include "gpio_lpc.h" #include "platform_detect.h" #include "mixer.h" +#include "max283x.h" #include "max2837.h" #include "max2839.h" #include "max5864.h" @@ -370,13 +371,12 @@ void rf_path_init(rf_path_t* const rf_path) if (detected_platform() == BOARD_ID_HACKRF1_R9) { ssp1_set_mode_max2839(); - max2839_setup(&max2839); - max2839_start(&max2839); + max283x_setup(&max283x, MAX2839_VARIANT); } else { ssp1_set_mode_max2837(); - max2837_setup(&max2837); - max2837_start(&max2837); + max283x_setup(&max283x, MAX2837_VARIANT); } + max283x_start(&max283x); // On HackRF One, the mixer is now set up earlier in boot. #ifndef HACKRF_ONE @@ -406,11 +406,10 @@ void rf_path_set_direction(rf_path_t* const rf_path, const rf_path_direction_t d max5864_tx(&max5864); if (detected_platform() == BOARD_ID_HACKRF1_R9) { ssp1_set_mode_max2839(); - max2839_tx(&max2839); } else { ssp1_set_mode_max2837(); - max2837_tx(&max2837); } + max283x_tx(&max283x); sgpio_configure(&sgpio_config, SGPIO_DIRECTION_TX); break; @@ -430,11 +429,10 @@ void rf_path_set_direction(rf_path_t* const rf_path, const rf_path_direction_t d max5864_rx(&max5864); if (detected_platform() == BOARD_ID_HACKRF1_R9) { ssp1_set_mode_max2839(); - max2839_rx(&max2839); } else { ssp1_set_mode_max2837(); - max2837_rx(&max2837); } + max283x_rx(&max283x); sgpio_configure(&sgpio_config, SGPIO_DIRECTION_RX); break; @@ -451,11 +449,10 @@ void rf_path_set_direction(rf_path_t* const rf_path, const rf_path_direction_t d max5864_standby(&max5864); if (detected_platform() == BOARD_ID_HACKRF1_R9) { ssp1_set_mode_max2839(); - max2839_set_mode(&max2839, MAX2839_MODE_STANDBY); } else { ssp1_set_mode_max2837(); - max2837_set_mode(&max2837, MAX2837_MODE_STANDBY); } + max283x_set_mode(&max283x, MAX283x_MODE_STANDBY); sgpio_configure(&sgpio_config, SGPIO_DIRECTION_RX); break; } diff --git a/firmware/common/tuning.c b/firmware/common/tuning.c index 597fa396..ae12c238 100644 --- a/firmware/common/tuning.c +++ b/firmware/common/tuning.c @@ -70,15 +70,8 @@ bool set_freq(const uint64_t freq) success = true; - max2839_mode_t prior_max2839_mode = MAX2839_MODE_STANDBY; - max2837_mode_t prior_max2837_mode = MAX2837_MODE_STANDBY; - if (detected_platform() == BOARD_ID_HACKRF1_R9) { - prior_max2839_mode = max2839_mode(&max2839); - max2839_set_mode(&max2839, MAX2839_MODE_STANDBY); - } else { - prior_max2837_mode = max2837_mode(&max2837); - max2837_set_mode(&max2837, MAX2837_MODE_STANDBY); - } + max283x_mode_t prior_max283x_mode = max283x_mode(&max283x); + max283x_set_mode(&max283x, MAX283x_MODE_STANDBY); if (freq_mhz < MAX_LP_FREQ_MHZ) { rf_path_set_filter(&rf_path, RF_PATH_FILTER_LOW_PASS); #ifdef RAD1O @@ -90,21 +83,13 @@ bool set_freq(const uint64_t freq) mixer_freq_mhz = (max2837_freq_nominal_hz / FREQ_ONE_MHZ) + freq_mhz; /* Set Freq and read real freq */ real_mixer_freq_hz = mixer_set_frequency(&mixer, mixer_freq_mhz); - if (detected_platform() == BOARD_ID_HACKRF1_R9) { - max2839_set_frequency(&max2839, real_mixer_freq_hz - freq); - } else { - max2837_set_frequency(&max2837, real_mixer_freq_hz - freq); - } + max283x_set_frequency(&max283x, real_mixer_freq_hz - freq); sgpio_cpld_stream_rx_set_q_invert(&sgpio_config, 1); } else if ((freq_mhz >= MIN_BYPASS_FREQ_MHZ) && (freq_mhz < MAX_BYPASS_FREQ_MHZ)) { rf_path_set_filter(&rf_path, RF_PATH_FILTER_BYPASS); MAX2837_freq_hz = (freq_mhz * FREQ_ONE_MHZ) + freq_hz; /* mixer_freq_mhz <= not used in Bypass mode */ - if (detected_platform() == BOARD_ID_HACKRF1_R9) { - max2839_set_frequency(&max2839, MAX2837_freq_hz); - } else { - max2837_set_frequency(&max2837, MAX2837_freq_hz); - } + max283x_set_frequency(&max283x, MAX2837_freq_hz); sgpio_cpld_stream_rx_set_q_invert(&sgpio_config, 0); } else if ((freq_mhz >= MIN_HP_FREQ_MHZ) && (freq_mhz <= MAX_HP_FREQ_MHZ)) { if (freq_mhz < MID1_HP_FREQ_MHZ) { @@ -125,21 +110,13 @@ bool set_freq(const uint64_t freq) mixer_freq_mhz = freq_mhz - (max2837_freq_nominal_hz / FREQ_ONE_MHZ); /* Set Freq and read real freq */ real_mixer_freq_hz = mixer_set_frequency(&mixer, mixer_freq_mhz); - if (detected_platform() == BOARD_ID_HACKRF1_R9) { - max2839_set_frequency(&max2839, freq - real_mixer_freq_hz); - } else { - max2837_set_frequency(&max2837, freq - real_mixer_freq_hz); - } + max283x_set_frequency(&max283x, freq - real_mixer_freq_hz); sgpio_cpld_stream_rx_set_q_invert(&sgpio_config, 0); } else { /* Error freq_mhz too high */ success = false; } - if (detected_platform() == BOARD_ID_HACKRF1_R9) { - max2839_set_mode(&max2839, prior_max2839_mode); - } else { - max2837_set_mode(&max2837, prior_max2837_mode); - } + max283x_set_mode(&max283x, prior_max283x_mode); if (success) { freq_cache = freq; hackrf_ui()->set_frequency(freq); @@ -170,11 +147,7 @@ bool set_freq_explicit( } rf_path_set_filter(&rf_path, path); - if (detected_platform() == BOARD_ID_HACKRF1_R9) { - max2839_set_frequency(&max2839, if_freq_hz); - } else { - max2837_set_frequency(&max2837, if_freq_hz); - } + max283x_set_frequency(&max283x, if_freq_hz); if (lo_freq_hz > if_freq_hz) { sgpio_cpld_stream_rx_set_q_invert(&sgpio_config, 1); } else { diff --git a/firmware/hackrf-common.cmake b/firmware/hackrf-common.cmake index b39c8641..8418e47e 100644 --- a/firmware/hackrf-common.cmake +++ b/firmware/hackrf-common.cmake @@ -170,6 +170,7 @@ macro(DeclareTargets) ${PATH_HACKRF_FIRMWARE_COMMON}/sgpio.c ${PATH_HACKRF_FIRMWARE_COMMON}/rf_path.c ${PATH_HACKRF_FIRMWARE_COMMON}/si5351c.c + ${PATH_HACKRF_FIRMWARE_COMMON}/max283x.c ${PATH_HACKRF_FIRMWARE_COMMON}/max2837.c ${PATH_HACKRF_FIRMWARE_COMMON}/max2837_target.c ${PATH_HACKRF_FIRMWARE_COMMON}/max2839.c diff --git a/firmware/hackrf_usb/usb_api_transceiver.c b/firmware/hackrf_usb/usb_api_transceiver.c index 48bbbb94..a6cf86cc 100644 --- a/firmware/hackrf_usb/usb_api_transceiver.c +++ b/firmware/hackrf_usb/usb_api_transceiver.c @@ -166,11 +166,7 @@ usb_request_status_t usb_vendor_request_set_lna_gain( { if (stage == USB_TRANSFER_STAGE_SETUP) { uint8_t value; - if (detected_platform() == BOARD_ID_HACKRF1_R9) { - value = max2839_set_lna_gain(&max2839, endpoint->setup.index); - } else { - value = max2837_set_lna_gain(&max2837, endpoint->setup.index); - } + value = max283x_set_lna_gain(&max283x, endpoint->setup.index); endpoint->buffer[0] = value; if (value) { hackrf_ui()->set_bb_lna_gain(endpoint->setup.index); @@ -193,11 +189,7 @@ usb_request_status_t usb_vendor_request_set_vga_gain( { if (stage == USB_TRANSFER_STAGE_SETUP) { uint8_t value; - if (detected_platform() == BOARD_ID_HACKRF1_R9) { - value = max2839_set_vga_gain(&max2839, endpoint->setup.index); - } else { - value = max2837_set_vga_gain(&max2837, endpoint->setup.index); - } + value = max283x_set_vga_gain(&max283x, endpoint->setup.index); endpoint->buffer[0] = value; if (value) { hackrf_ui()->set_bb_vga_gain(endpoint->setup.index); @@ -220,11 +212,7 @@ usb_request_status_t usb_vendor_request_set_txvga_gain( { if (stage == USB_TRANSFER_STAGE_SETUP) { uint8_t value; - if (detected_platform() == BOARD_ID_HACKRF1_R9) { - value = max2839_set_txvga_gain(&max2839, endpoint->setup.index); - } else { - value = max2837_set_txvga_gain(&max2837, endpoint->setup.index); - } + value = max283x_set_txvga_gain(&max283x, endpoint->setup.index); endpoint->buffer[0] = value; if (value) { hackrf_ui()->set_bb_tx_vga_gain(endpoint->setup.index);