h1r9: add MAX283x abstraction layer

firmware/common/hackrf_core.c

@@ -26,10 +26,7 @@
 #include "sgpio.h"
 #include "si5351c.h"
 #include "spi_ssp.h"
-#include "max2837.h"
+#include "max283x.h"
-#include "max2837_target.h"
-#include "max2839.h"
-#include "max2839_target.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 = {
+max283x_driver_t max283x = {};
-	.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,
-};
 
 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 = max283x_set_lpf_bandwidth(&max283x, bandwidth_hz);
-		bandwidth_hz_real = max2839_set_lpf_bandwidth(&max2839, bandwidth_hz);
-	} else {
-		bandwidth_hz_real = max2837_set_lpf_bandwidth(&max2837, bandwidth_hz);
-	}
 
 	if (bandwidth_hz_real) {
 		hackrf_ui()->set_filter_bw(bandwidth_hz_real);

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;

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;

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);

firmware/common/max283x.c

@@ -0,0 +1,280 @@
+/*
+ * Copyright 2012-2022 Great Scott Gadgets <info@greatscottgadgets.com>
+ * Copyright 2012 Will Code <willcode4@gmail.com>
+ * Copyright 2014 Jared Boone <jared@sharebrained.com>
+ *
+ * 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;
+	}
+}

firmware/common/max283x.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2012-2022 Great Scott Gadgets <info@greatscottgadgets.com>
+ * Copyright 2012 Will Code <willcode4@gmail.com>
+ * Copyright 2014 Jared Boone <jared@sharebrained.com>
+ *
+ * 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 <stdint.h>
+#include <stdbool.h>
+#include <string.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"
+
+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

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);
+		max283x_setup(&max283x, MAX2839_VARIANT);
-		max2839_start(&max2839);
 	} else {
 		ssp1_set_mode_max2837();
-		max2837_setup(&max2837);
+		max283x_setup(&max283x, MAX2837_VARIANT);
-		max2837_start(&max2837);
 	}
+	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;
 	}

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;
+	max283x_mode_t prior_max283x_mode = max283x_mode(&max283x);
-	max2837_mode_t prior_max2837_mode = MAX2837_MODE_STANDBY;
+	max283x_set_mode(&max283x, MAX283x_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);
-	}
 	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) {
+		max283x_set_frequency(&max283x, real_mixer_freq_hz - freq);
-			max2839_set_frequency(&max2839, real_mixer_freq_hz - freq);
-		} else {
-			max2837_set_frequency(&max2837, 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) {
+		max283x_set_frequency(&max283x, MAX2837_freq_hz);
-			max2839_set_frequency(&max2839, MAX2837_freq_hz);
-		} else {
-			max2837_set_frequency(&max2837, 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) {
+		max283x_set_frequency(&max283x, freq - real_mixer_freq_hz);
-			max2839_set_frequency(&max2839, freq - real_mixer_freq_hz);
-		} else {
-			max2837_set_frequency(&max2837, 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) {
+	max283x_set_mode(&max283x, prior_max283x_mode);
-		max2839_set_mode(&max2839, prior_max2839_mode);
-	} else {
-		max2837_set_mode(&max2837, prior_max2837_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) {
+	max283x_set_frequency(&max283x, if_freq_hz);
-		max2839_set_frequency(&max2839, if_freq_hz);
-	} else {
-		max2837_set_frequency(&max2837, if_freq_hz);
-	}
 	if (lo_freq_hz > if_freq_hz) {
 		sgpio_cpld_stream_rx_set_q_invert(&sgpio_config, 1);
 	} else {

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

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 = max283x_set_lna_gain(&max283x, endpoint->setup.index);
-			value = max2839_set_lna_gain(&max2839, endpoint->setup.index);
-		} else {
-			value = max2837_set_lna_gain(&max2837, 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 = max283x_set_vga_gain(&max283x, endpoint->setup.index);
-			value = max2839_set_vga_gain(&max2839, endpoint->setup.index);
-		} else {
-			value = max2837_set_vga_gain(&max2837, 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 = max283x_set_txvga_gain(&max283x, endpoint->setup.index);
-			value = max2839_set_txvga_gain(&max2839, endpoint->setup.index);
-		} else {
-			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);