Add radio configuration update callback

Co-authored-by: Martin Ling <martin-git@earth.li>

Author: mossmann

firmware/common/radio.c

@@ -28,7 +28,6 @@
 #include "platform_detect.h"
 #include "radio.h"
 #include "fixed_point.h"
-#include "hackrf_ui.h"
 
 #define MIN(x, y) ((x) < (y) ? (x) : (y))
 #define MAX(x, y) ((x) > (y) ? (x) : (y))
@@ -225,11 +224,6 @@ static bool radio_update_sample_rate(radio_t* const radio, uint64_t* bank)
 	new_rate = (rate != radio->config[RADIO_BANK_APPLIED][RADIO_SAMPLE_RATE]);
 	if (new_rate) {
 		radio->config[RADIO_BANK_APPLIED][RADIO_SAMPLE_RATE] = rate;
-		if (rate != RADIO_UNSET) {
-			/* Round to the nearest Hz for display. */
-			const uint32_t rate_hz = (rate + (FP_ONE_HZ >> 1)) / FP_ONE_HZ;
-			hackrf_ui()->set_sample_rate(rate_hz);
-		}
 	}
 
 	return (new_afe_rate || new_rate || new_n);
@@ -613,6 +607,7 @@ bool radio_update(radio_t* const radio)
 	uint64_t tmp_bank[RADIO_NUM_REGS];
 	nvic_disable_irq(NVIC_USB0_IRQ);
 	uint32_t dirty = radio->regs_dirty;
+	uint32_t changed = 0;
 	if (dirty == 0) {
 		nvic_enable_irq(NVIC_USB0_IRQ);
 		return false;
@@ -621,56 +616,57 @@ bool radio_update(radio_t* const radio)
 	memcpy(&tmp_bank[0], &(radio->config[RADIO_BANK_ACTIVE][0]), sizeof(tmp_bank));
 	nvic_enable_irq(NVIC_USB0_IRQ);
 
-	bool dir = false;
-	bool rate = false;
-	bool freq = false;
-	bool bw = false;
-	bool gain = false;
-	bool bias = false;
-	bool trig = false;
-	bool dc = false;
-
-	if ((dirty &
-	     ((1 << RADIO_SAMPLE_RATE) | (1 << RADIO_RESAMPLE_TX) |
-	      (1 << RADIO_RESAMPLE_RX))) ||
+	if ((dirty & RADIO_REG_GROUP_RATE) ||
 	    ((detected_platform() == BOARD_ID_PRALINE) &&
 	     (dirty & (1 << RADIO_OPMODE)))) {
-		rate = radio_update_sample_rate(radio, &tmp_bank[0]);
+		if (radio_update_sample_rate(radio, &tmp_bank[0])) {
+			changed |= RADIO_REG_GROUP_RATE;
+		}
 	}
-	if ((dirty &
-	     ((1 << RADIO_FREQUENCY_RF) | (1 << RADIO_FREQUENCY_IF) |
-	      (1 << RADIO_FREQUENCY_LO) | (1 << RADIO_IMAGE_REJECT) |
-	      (1 << RADIO_ROTATION))) ||
+	if ((dirty & RADIO_REG_GROUP_FREQ) ||
 	    ((detected_platform() == BOARD_ID_PRALINE) &&
-	     (rate || (dirty & (1 << RADIO_OPMODE))))) {
-		freq = radio_update_frequency(radio, &tmp_bank[0]);
+	     ((changed & RADIO_REG_GROUP_RATE) || (dirty & (1 << RADIO_OPMODE))))) {
+		if (radio_update_frequency(radio, &tmp_bank[0])) {
+			changed |= RADIO_REG_GROUP_FREQ;
+		}
 	}
-	if ((dirty &
-	     ((1 << RADIO_BB_BANDWIDTH_TX) | (1 << RADIO_BB_BANDWIDTH_RX) |
-	      (1 << RADIO_XCVR_TX_LPF) | (1 << RADIO_XCVR_RX_LPF) |
-	      (1 << RADIO_XCVR_RX_HPF) | (1 << RADIO_RX_NARROW_LPF))) ||
-	    ((detected_platform() == BOARD_ID_PRALINE) && (rate || freq))) {
-		bw = radio_update_bandwidth(radio, &tmp_bank[0]);
+	if ((dirty & RADIO_REG_GROUP_BW) ||
+	    ((detected_platform() == BOARD_ID_PRALINE) &&
+	     (changed & (RADIO_REG_GROUP_RATE | RADIO_REG_GROUP_FREQ)))) {
+		if (radio_update_bandwidth(radio, &tmp_bank[0])) {
+			changed |= RADIO_REG_GROUP_BW;
+		}
 	}
-	if (dirty &
-	    ((1 << RADIO_GAIN_TX_RF) | (1 << RADIO_GAIN_TX_IF) | (1 << RADIO_GAIN_RX_RF) |
-	     (1 << RADIO_GAIN_RX_IF) | (1 << RADIO_GAIN_RX_BB) | (1 << RADIO_OPMODE))) {
-		gain = radio_update_gain(radio, &tmp_bank[0]);
+	if (dirty & (RADIO_REG_GROUP_GAIN | (1 << RADIO_OPMODE))) {
+		if (radio_update_gain(radio, &tmp_bank[0])) {
+			changed |= RADIO_REG_GROUP_GAIN;
+		}
 	}
 	if (dirty & ((1 << RADIO_BIAS_TEE) | (1 << RADIO_OPMODE))) {
-		bias = radio_update_bias_tee(radio, &tmp_bank[0]);
+		if (radio_update_bias_tee(radio, &tmp_bank[0])) {
+			changed |= (1 << RADIO_BIAS_TEE);
+		}
 	}
 	if (dirty & (1 << RADIO_TRIGGER)) {
-		trig = radio_update_trigger(radio, &tmp_bank[0]);
+		if (radio_update_trigger(radio, &tmp_bank[0])) {
+			changed |= (1 << RADIO_TRIGGER);
+		}
 	}
 	if (dirty & (1 << RADIO_DC_BLOCK)) {
-		dc = radio_update_dc_block(radio, &tmp_bank[0]);
+		if (radio_update_dc_block(radio, &tmp_bank[0])) {
+			changed |= (1 << RADIO_DC_BLOCK);
+		}
 	}
 	if (dirty & (1 << RADIO_OPMODE)) {
-		dir = radio_update_direction(radio, &tmp_bank[0]);
+		if (radio_update_direction(radio, &tmp_bank[0])) {
+			changed |= (1 << RADIO_OPMODE);
+		}
 	}
 
-	return trig || dir || rate || freq || bw || gain || bias || dc;
+	if (radio->update_cb) {
+		radio->update_cb(changed);
+	}
+	return (changed != 0);
 }
 
 void radio_switch_opmode(radio_t* const radio, const transceiver_mode_t mode)

firmware/common/radio.h

@@ -186,6 +186,20 @@ typedef enum {
 #define RADIO_NUM_REGS (23)
 #define RADIO_UNSET    (0xffffffffffffffff)
 
+/* register groups for bitfield convenience */
+#define RADIO_REG_GROUP_RATE \
+	((1 << RADIO_SAMPLE_RATE) | (1 << RADIO_RESAMPLE_TX) | (1 << RADIO_RESAMPLE_RX))
+#define RADIO_REG_GROUP_FREQ                                     \
+	((1 << RADIO_FREQUENCY_RF) | (1 << RADIO_FREQUENCY_IF) | \
+	 (1 << RADIO_FREQUENCY_LO) | (1 << RADIO_IMAGE_REJECT) | (1 << RADIO_ROTATION))
+#define RADIO_REG_GROUP_BW                                             \
+	((1 << RADIO_BB_BANDWIDTH_TX) | (1 << RADIO_BB_BANDWIDTH_RX) | \
+	 (1 << RADIO_XCVR_TX_LPF) | (1 << RADIO_XCVR_RX_LPF) |         \
+	 (1 << RADIO_XCVR_RX_HPF) | (1 << RADIO_RX_NARROW_LPF))
+#define RADIO_REG_GROUP_GAIN                                                           \
+	((1 << RADIO_GAIN_TX_RF) | (1 << RADIO_GAIN_TX_IF) | (1 << RADIO_GAIN_RX_RF) | \
+	 (1 << RADIO_GAIN_RX_IF) | (1 << RADIO_GAIN_RX_BB))
+
 /**
  * Register bank RADIO_BANK_ACTIVE stores the active configuration. Active
  * register settings are copied to the applied register when applied.
@@ -216,11 +230,19 @@ typedef enum {
  */
 typedef fp_40_24_t (*sample_rate_fn)(const fp_40_24_t sample_rate, const bool program);
 
+/**
+ * An optional callback may be provided that is called after each time the
+ * radio configuration has been updated. The single argument is a bitfield
+ * indicating registers that have been changed.
+ */
+typedef void (*update_fn)(const uint32_t changed_regs);
+
 typedef struct radio_t {
 	radio_config_mode_t config_mode;
 	uint64_t config[RADIO_NUM_BANKS][RADIO_NUM_REGS];
 	volatile uint32_t regs_dirty;
 	sample_rate_fn sample_rate_cb;
+	update_fn update_cb;
 } radio_t;
 
 void radio_init(radio_t* const radio);

firmware/common/rf_path.c

@@ -27,7 +27,6 @@
 
 #include <hackrf_core.h>
 
-#include "hackrf_ui.h"
 #include "gpio_lpc.h"
 #include "platform_detect.h"
 #include "mixer.h"
@@ -533,8 +532,6 @@ void rf_path_set_direction(rf_path_t* const rf_path, const rf_path_direction_t d
 	}
 
 	switchctrl_set(rf_path, rf_path->switchctrl);
-
-	hackrf_ui()->set_direction(direction);
 }
 
 void rf_path_set_filter(rf_path_t* const rf_path, const rf_path_filter_t filter)
@@ -559,8 +556,6 @@ void rf_path_set_filter(rf_path_t* const rf_path, const rf_path_filter_t filter)
 	}
 
 	switchctrl_set(rf_path, rf_path->switchctrl);
-
-	hackrf_ui()->set_filter(filter);
 }
 
 void rf_path_set_lna(rf_path_t* const rf_path, const uint_fast8_t enable)
@@ -584,8 +579,6 @@ void rf_path_set_lna(rf_path_t* const rf_path, const uint_fast8_t enable)
 	}
 
 	switchctrl_set(rf_path, rf_path->switchctrl);
-
-	hackrf_ui()->set_lna_power(enable);
 }
 
 /* antenna port power control */
@@ -598,6 +591,4 @@ void rf_path_set_antenna(rf_path_t* const rf_path, const uint_fast8_t enable)
 	}
 
 	switchctrl_set(rf_path, rf_path->switchctrl);
-
-	hackrf_ui()->set_antenna_bias(enable);
 }

firmware/common/tuning.c

@@ -22,11 +22,9 @@
  */
 
 #include "tuning.h"
-#include "hackrf_ui.h"
 #include "hackrf_core.h"
 #include "mixer.h"
 #include "sgpio.h"
-#include "operacake.h"
 #include "platform_detect.h"
 
 #ifndef PRALINE
@@ -129,12 +127,6 @@ bool set_freq(const uint64_t freq)
 		success = false;
 	}
 	max283x_set_mode(&max283x, prior_max283x_mode);
-	if (success) {
-		hackrf_ui()->set_frequency(freq);
-	#ifdef HACKRF_ONE
-		operacake_set_range(freq_mhz);
-	#endif
-	}
 	return success;
 }
 
@@ -194,8 +186,6 @@ bool tuning_set_frequency(
 	}
 
 	max283x_set_mode(&max283x, prior_max283x_mode);
-	hackrf_ui()->set_frequency(freq);
-	operacake_set_range(freq_mhz);
 	return true;
 }
 #endif

firmware/hackrf_usb/hackrf_usb.c

@@ -256,6 +256,108 @@ static void m0_rom_to_ram(void)
 	memcpy(dest, (uint32_t*) (base + src), len);
 }
 
+void radio_changed(const uint32_t changed)
+{
+	const uint64_t opmode = radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_OPMODE);
+
+	if (changed & (1 << RADIO_OPMODE)) {
+		switch (opmode) {
+		case TRANSCEIVER_MODE_TX:
+		case TRANSCEIVER_MODE_SS:
+			hackrf_ui()->set_direction(RF_PATH_DIRECTION_TX);
+			break;
+		case TRANSCEIVER_MODE_RX:
+		case TRANSCEIVER_MODE_RX_SWEEP:
+			hackrf_ui()->set_direction(RF_PATH_DIRECTION_RX);
+			break;
+		default:
+			hackrf_ui()->set_direction(RF_PATH_DIRECTION_OFF);
+			break;
+		}
+	}
+	if (changed & (1 << RADIO_SAMPLE_RATE)) {
+		const uint64_t rate =
+			radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_SAMPLE_RATE);
+		hackrf_ui()->set_sample_rate(rate / FP_ONE_HZ);
+	}
+	if (changed & (1 << RADIO_FREQUENCY_RF)) {
+		const uint64_t freq =
+			radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_FREQUENCY_RF);
+		hackrf_ui()->set_frequency(freq / FP_ONE_HZ);
+#if defined(HACKRF_ONE) || defined(PRALINE)
+		operacake_set_range(freq / FP_ONE_MHZ);
+#endif
+	}
+	if (changed & (1 << RADIO_IMAGE_REJECT)) {
+		const uint64_t img_reject =
+			radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_IMAGE_REJECT);
+		hackrf_ui()->set_filter(img_reject);
+	}
+	if (changed &
+	    ((1 << RADIO_BB_BANDWIDTH_TX) | (1 << RADIO_BB_BANDWIDTH_RX) |
+	     (1 << RADIO_OPMODE))) {
+		uint64_t bw;
+
+		switch (opmode) {
+		case TRANSCEIVER_MODE_TX:
+		case TRANSCEIVER_MODE_SS:
+			bw = radio_reg_read(
+				&radio,
+				RADIO_BANK_APPLIED,
+				RADIO_BB_BANDWIDTH_TX);
+			break;
+		default:
+			bw = radio_reg_read(
+				&radio,
+				RADIO_BANK_APPLIED,
+				RADIO_BB_BANDWIDTH_RX);
+		}
+		hackrf_ui()->set_filter_bw(bw);
+	}
+	if (changed &
+	    ((1 << RADIO_GAIN_TX_RF) | (1 << RADIO_GAIN_RX_RF) | (1 << RADIO_OPMODE))) {
+		const uint64_t tx_rf =
+			radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_GAIN_TX_RF);
+		const uint64_t rx_rf =
+			radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_GAIN_RX_RF);
+		bool enable;
+
+		switch (opmode) {
+		case TRANSCEIVER_MODE_TX:
+		case TRANSCEIVER_MODE_SS:
+			enable = tx_rf;
+			break;
+		case TRANSCEIVER_MODE_RX:
+		case TRANSCEIVER_MODE_RX_SWEEP:
+			enable = rx_rf;
+			break;
+		default:
+			enable = false;
+		}
+		hackrf_ui()->set_lna_power(enable);
+	}
+	if (changed & (1 << RADIO_GAIN_TX_IF)) {
+		const uint64_t tx_if =
+			radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_GAIN_TX_IF);
+		hackrf_ui()->set_bb_tx_vga_gain(tx_if);
+	}
+	if (changed & (1 << RADIO_GAIN_RX_IF)) {
+		const uint64_t rx_if =
+			radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_GAIN_RX_IF);
+		hackrf_ui()->set_bb_lna_gain(rx_if);
+	}
+	if (changed & (1 << RADIO_GAIN_RX_BB)) {
+		const uint64_t rx_bb =
+			radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_GAIN_RX_BB);
+		hackrf_ui()->set_bb_vga_gain(rx_bb);
+	}
+	if (changed & (1 << RADIO_BIAS_TEE)) {
+		const uint64_t enable =
+			radio_reg_read(&radio, RADIO_BANK_APPLIED, RADIO_BIAS_TEE);
+		hackrf_ui()->set_antenna_bias(enable);
+	}
+}
+
 int main(void)
 {
 	// Copy M0 image from ROM before SPIFI is disabled
@@ -320,6 +422,7 @@ int main(void)
 	fpga_spi_selftest();
 	fpga_sgpio_selftest();
 #endif
+	radio.update_cb = radio_changed;
 	radio_init(&radio);
 
 #if (defined HACKRF_ONE || defined PRALINE)