Merge branch 'branch-1.8' into debian

8 files changed, 441 insertions, 22 deletions

diff --git a/src/stm/ao_adc_single.h b/src/stm/ao_adc_single.h
new file mode 100644
index 00000000..f9d953ca
--- /dev/null
+++ b/src/stm/ao_adc_single.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright © 2018 Keith Packard <keithp@keithp.com>
+ *
+ * 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 of the License, 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.
+ */
+
+#ifndef _AO_ADC_SINGLE_H_
+#define _AO_ADC_SINGLE_H_
+
+void
+ao_adc_single_get(struct ao_adc *packet);
+
+void
+ao_adc_single_init(void);
+
+#endif /* _AO_ADC_SINGLE_H_ */
diff --git a/src/stm/ao_adc_single_stm.c b/src/stm/ao_adc_single_stm.c
new file mode 100644
index 00000000..8a7fda4a
--- /dev/null
+++ b/src/stm/ao_adc_single_stm.c
@@ -0,0 +1,297 @@
+/*
+ * Copyright © 2012 Keith Packard <keithp@keithp.com>
+ *
+ * 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 of the License, 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; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <ao.h>
+#include <ao_data.h>
+
+static uint8_t			ao_adc_ready;
+
+#define AO_ADC_CR2_VAL		((0 << STM_ADC_CR2_SWSTART) |		\
+				 (STM_ADC_CR2_EXTEN_DISABLE << STM_ADC_CR2_EXTEN) | \
+				 (0 << STM_ADC_CR2_EXTSEL) |		\
+				 (0 << STM_ADC_CR2_JWSTART) |		\
+				 (STM_ADC_CR2_JEXTEN_DISABLE << STM_ADC_CR2_JEXTEN) | \
+				 (0 << STM_ADC_CR2_JEXTSEL) |		\
+				 (0 << STM_ADC_CR2_ALIGN) |		\
+				 (0 << STM_ADC_CR2_EOCS) |		\
+				 (1 << STM_ADC_CR2_DDS) |		\
+				 (1 << STM_ADC_CR2_DMA) |		\
+				 (STM_ADC_CR2_DELS_UNTIL_READ << STM_ADC_CR2_DELS) | \
+				 (0 << STM_ADC_CR2_CONT) |		\
+				 (1 << STM_ADC_CR2_ADON))
+
+/*
+ * Callback from DMA ISR
+ *
+ * Shut down DMA engine, signal anyone waiting
+ */
+static void ao_adc_done(int index)
+{
+	(void) index;
+	ao_dma_done_transfer(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC1));
+	ao_adc_ready = 1;
+	ao_wakeup((void *) &ao_adc_ready);
+}
+
+/*
+ * Start the ADC sequence using the DMA engine
+ */
+static void
+ao_adc_poll(struct ao_adc *packet)
+{
+	ao_adc_ready = 0;
+	stm_adc.sr = 0;
+	ao_dma_set_transfer(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC1),
+			    &stm_adc.dr,
+			    (void *) packet,
+			    AO_NUM_ADC,
+			    (0 << STM_DMA_CCR_MEM2MEM) |
+			    (STM_DMA_CCR_PL_HIGH << STM_DMA_CCR_PL) |
+			    (STM_DMA_CCR_MSIZE_16 << STM_DMA_CCR_MSIZE) |
+			    (STM_DMA_CCR_PSIZE_16 << STM_DMA_CCR_PSIZE) |
+			    (1 << STM_DMA_CCR_MINC) |
+			    (0 << STM_DMA_CCR_PINC) |
+			    (0 << STM_DMA_CCR_CIRC) |
+			    (STM_DMA_CCR_DIR_PER_TO_MEM << STM_DMA_CCR_DIR));
+	ao_dma_set_isr(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC1), ao_adc_done);
+	ao_dma_start(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC1));
+
+	stm_adc.cr2 = AO_ADC_CR2_VAL | (1 << STM_ADC_CR2_SWSTART);
+}
+
+/*
+ * Fetch a copy of the most recent ADC data
+ */
+void
+ao_adc_single_get(struct ao_adc *packet)
+{
+	ao_adc_poll(packet);
+	ao_arch_block_interrupts();
+	while (!ao_adc_ready)
+		ao_sleep(&ao_adc_ready);
+	ao_arch_release_interrupts();
+}
+
+static void
+ao_adc_dump(void)
+{
+	struct ao_adc	packet;
+	ao_adc_single_get(&packet);
+	AO_ADC_DUMP(&packet);
+}
+
+__code struct ao_cmds ao_adc_cmds[] = {
+	{ ao_adc_dump,	"a\0Display current ADC values" },
+	{ 0, NULL },
+};
+
+void
+ao_adc_single_init(void)
+{
+#ifdef AO_ADC_PIN0_PORT
+	stm_rcc.ahbenr |= AO_ADC_RCC_AHBENR;
+#endif
+
+#ifdef AO_ADC_PIN0_PORT
+	stm_moder_set(AO_ADC_PIN0_PORT, AO_ADC_PIN0_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN1_PORT
+	stm_moder_set(AO_ADC_PIN1_PORT, AO_ADC_PIN1_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN2_PORT
+	stm_moder_set(AO_ADC_PIN2_PORT, AO_ADC_PIN2_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN3_PORT
+	stm_moder_set(AO_ADC_PIN3_PORT, AO_ADC_PIN3_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN4_PORT
+	stm_moder_set(AO_ADC_PIN4_PORT, AO_ADC_PIN4_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN5_PORT
+	stm_moder_set(AO_ADC_PIN5_PORT, AO_ADC_PIN5_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN6_PORT
+	stm_moder_set(AO_ADC_PIN6_PORT, AO_ADC_PIN6_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN7_PORT
+	stm_moder_set(AO_ADC_PIN7_PORT, AO_ADC_PIN7_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN8_PORT
+	stm_moder_set(AO_ADC_PIN8_PORT, AO_ADC_PIN8_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN9_PORT
+	stm_moder_set(AO_ADC_PIN9_PORT, AO_ADC_PIN9_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN10_PORT
+	stm_moder_set(AO_ADC_PIN10_PORT, AO_ADC_PIN10_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN11_PORT
+	stm_moder_set(AO_ADC_PIN11_PORT, AO_ADC_PIN11_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN12_PORT
+	stm_moder_set(AO_ADC_PIN12_PORT, AO_ADC_PIN12_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN13_PORT
+	stm_moder_set(AO_ADC_PIN13_PORT, AO_ADC_PIN13_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN14_PORT
+	stm_moder_set(AO_ADC_PIN14_PORT, AO_ADC_PIN14_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN15_PORT
+	stm_moder_set(AO_ADC_PIN15_PORT, AO_ADC_PIN15_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN16_PORT
+	stm_moder_set(AO_ADC_PIN16_PORT, AO_ADC_PIN16_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN17_PORT
+	stm_moder_set(AO_ADC_PIN17_PORT, AO_ADC_PIN17_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN18_PORT
+	stm_moder_set(AO_ADC_PIN18_PORT, AO_ADC_PIN18_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN19_PORT
+	stm_moder_set(AO_ADC_PIN19_PORT, AO_ADC_PIN19_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN20_PORT
+	stm_moder_set(AO_ADC_PIN20_PORT, AO_ADC_PIN20_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN21_PORT
+	stm_moder_set(AO_ADC_PIN21_PORT, AO_ADC_PIN21_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN22_PORT
+	stm_moder_set(AO_ADC_PIN22_PORT, AO_ADC_PIN22_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN23_PORT
+	stm_moder_set(AO_ADC_PIN23_PORT, AO_ADC_PIN23_PIN, STM_MODER_ANALOG);
+#endif
+#ifdef AO_ADC_PIN24_PORT
+	#error "Too many ADC ports"
+#endif
+
+	stm_rcc.apb2enr |= (1 << STM_RCC_APB2ENR_ADC1EN);
+
+	/* Turn off ADC during configuration */
+	stm_adc.cr2 = 0;
+
+	stm_adc.cr1 = ((0 << STM_ADC_CR1_OVRIE ) |
+		       (STM_ADC_CR1_RES_12 << STM_ADC_CR1_RES ) |
+		       (0 << STM_ADC_CR1_AWDEN ) |
+		       (0 << STM_ADC_CR1_JAWDEN ) |
+		       (0 << STM_ADC_CR1_PDI ) |
+		       (0 << STM_ADC_CR1_PDD ) |
+		       (0 << STM_ADC_CR1_DISCNUM ) |
+		       (0 << STM_ADC_CR1_JDISCEN ) |
+		       (0 << STM_ADC_CR1_DISCEN ) |
+		       (0 << STM_ADC_CR1_JAUTO ) |
+		       (0 << STM_ADC_CR1_AWDSGL ) |
+		       (1 << STM_ADC_CR1_SCAN ) |
+		       (0 << STM_ADC_CR1_JEOCIE ) |
+		       (0 << STM_ADC_CR1_AWDIE ) |
+		       (0 << STM_ADC_CR1_EOCIE ) |
+		       (0 << STM_ADC_CR1_AWDCH ));
+
+	/* 384 cycle sample time for everyone */
+	stm_adc.smpr1 = 0x3ffff;
+	stm_adc.smpr2 = 0x3fffffff;
+	stm_adc.smpr3 = 0x3fffffff;
+
+	stm_adc.sqr1 = ((AO_NUM_ADC - 1) << 20);
+	stm_adc.sqr2 = 0;
+	stm_adc.sqr3 = 0;
+	stm_adc.sqr4 = 0;
+	stm_adc.sqr5 = 0;
+#if AO_NUM_ADC > 0
+	stm_adc.sqr5 |= (AO_ADC_SQ1 << 0);
+#endif
+#if AO_NUM_ADC > 1
+	stm_adc.sqr5 |= (AO_ADC_SQ2 << 5);
+#endif
+#if AO_NUM_ADC > 2
+	stm_adc.sqr5 |= (AO_ADC_SQ3 << 10);
+#endif
+#if AO_NUM_ADC > 3
+	stm_adc.sqr5 |= (AO_ADC_SQ4 << 15);
+#endif
+#if AO_NUM_ADC > 4
+	stm_adc.sqr5 |= (AO_ADC_SQ5 << 20);
+#endif
+#if AO_NUM_ADC > 5
+	stm_adc.sqr5 |= (AO_ADC_SQ6 << 25);
+#endif
+#if AO_NUM_ADC > 6
+	stm_adc.sqr4 |= (AO_ADC_SQ7 << 0);
+#endif
+#if AO_NUM_ADC > 7
+	stm_adc.sqr4 |= (AO_ADC_SQ8 << 5);
+#endif
+#if AO_NUM_ADC > 8
+	stm_adc.sqr4 |= (AO_ADC_SQ9 << 10);
+#endif
+#if AO_NUM_ADC > 9
+	stm_adc.sqr4 |= (AO_ADC_SQ10 << 15);
+#endif
+#if AO_NUM_ADC > 10
+	stm_adc.sqr4 |= (AO_ADC_SQ11 << 20);
+#endif
+#if AO_NUM_ADC > 11
+	stm_adc.sqr4 |= (AO_ADC_SQ12 << 25);
+#endif
+#if AO_NUM_ADC > 12
+	stm_adc.sqr3 |= (AO_ADC_SQ13 << 0);
+#endif
+#if AO_NUM_ADC > 13
+	stm_adc.sqr3 |= (AO_ADC_SQ14 << 5);
+#endif
+#if AO_NUM_ADC > 14
+	stm_adc.sqr3 |= (AO_ADC_SQ15 << 10);
+#endif
+#if AO_NUM_ADC > 15
+	stm_adc.sqr3 |= (AO_ADC_SQ16 << 15);
+#endif
+#if AO_NUM_ADC > 16
+	stm_adc.sqr3 |= (AO_ADC_SQ17 << 20);
+#endif
+#if AO_NUM_ADC > 17
+	stm_adc.sqr3 |= (AO_ADC_SQ18 << 25);
+#endif
+#if AO_NUM_ADC > 18
+#error "need to finish stm_adc.sqr settings"
+#endif
+
+	/* Turn ADC on */
+	stm_adc.cr2 = AO_ADC_CR2_VAL;
+
+	/* Wait for ADC to be ready */
+	while (!(stm_adc.sr & (1 << STM_ADC_SR_ADONS)))
+		;
+
+#ifndef HAS_ADC_TEMP
+#error Please define HAS_ADC_TEMP
+#endif
+#if HAS_ADC_TEMP
+	stm_adc.ccr = ((1 << STM_ADC_CCR_TSVREFE));
+#else
+	stm_adc.ccr = 0;
+#endif
+	/* Clear any stale status bits */
+	stm_adc.sr = 0;
+
+	ao_dma_alloc(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC1));
+
+	ao_cmd_register(&ao_adc_cmds[0]);
+}
diff --git a/src/stm/ao_arch.h b/src/stm/ao_arch.h
index 5f033b66..679dba44 100644
--- a/src/stm/ao_arch.h
+++ b/src/stm/ao_arch.h
@@ -30,8 +30,6 @@
 #define AO_STACK_SIZE	512
 #endif
 
-#define AO_LED_TYPE	uint16_t
-
 #ifndef AO_TICK_TYPE
 #define AO_TICK_TYPE	uint16_t
 #define AO_TICK_SIGNED	int16_t
@@ -153,6 +151,10 @@ ao_adc_init();
 #define AO_BOOT_LOADER_BASE		((uint32_t *) 0x08000000)
 #define HAS_BOOT_LOADER			1
 
+#ifndef AO_LED_TYPE
+#define AO_LED_TYPE uint16_t
+#endif
+
 #endif /* _AO_ARCH_H_ */
 
 
diff --git a/src/stm/ao_led.c b/src/stm/ao_led.c
index 0f39befb..a7033dbb 100644
--- a/src/stm/ao_led.c
+++ b/src/stm/ao_led.c
@@ -18,11 +18,73 @@
 
 #include "ao.h"
 
-__pdata uint16_t ao_led_enable;
+#if LED_PER_LED
+static const struct {
+	struct stm_gpio	*port;
+	uint16_t	pin;
+} ao_leds[] = {
+#ifdef LED_0_PORT
+    [0] { LED_0_PORT, LED_0_PIN },
+#endif
+#ifdef LED_1_PORT
+    [1] { LED_1_PORT, LED_1_PIN },
+#endif
+#ifdef LED_2_PORT
+    [2] { LED_2_PORT, LED_2_PIN },
+#endif
+#ifdef LED_3_PORT
+    [3] { LED_3_PORT, LED_3_PIN },
+#endif
+#ifdef LED_4_PORT
+    [4] { LED_4_PORT, LED_4_PIN },
+#endif
+#ifdef LED_5_PORT
+    [5] { LED_5_PORT, LED_5_PIN },
+#endif
+#ifdef LED_6_PORT
+    [6] { LED_6_PORT, LED_6_PIN },
+#endif
+#ifdef LED_7_PORT
+    [7] { LED_7_PORT, LED_7_PIN },
+#endif
+#ifdef LED_8_PORT
+    [8] { LED_8_PORT, LED_8_PIN },
+#endif
+#ifdef LED_9_PORT
+    [9] { LED_9_PORT, LED_9_PIN },
+#endif
+#ifdef LED_10_PORT
+    [10] { LED_10_PORT, LED_10_PIN },
+#endif
+#ifdef LED_11_PORT
+    [11] { LED_11_PORT, LED_11_PIN },
+#endif
+#ifdef LED_12_PORT
+    [12] { LED_12_PORT, LED_12_PIN },
+#endif
+#ifdef LED_13_PORT
+    [13] { LED_13_PORT, LED_13_PIN },
+#endif
+#ifdef LED_14_PORT
+    [14] { LED_14_PORT, LED_14_PIN },
+#endif
+#ifdef LED_15_PORT
+    [15] { LED_15_PORT, LED_15_PIN },
+#endif
+};
+#define N_LED	(sizeof (ao_leds)/sizeof(ao_leds[0]))
+#endif
+static AO_LED_TYPE ao_led_enable;
 
 void
-ao_led_on(uint16_t colors)
+ao_led_on(AO_LED_TYPE colors)
 {
+#ifdef LED_PER_LED
+	AO_LED_TYPE i;
+	for (i = 0; i < N_LED; i++)
+		if (colors & (1 << i))
+			ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, 1);
+#else
 #ifdef LED_PORT
 	LED_PORT->bsrr = (colors & ao_led_enable);
 #else
@@ -33,11 +95,18 @@ ao_led_on(uint16_t colors)
 	LED_PORT_1->bsrr = ((colors & ao_led_enable) & LED_PORT_1_MASK) << LED_PORT_1_SHIFT;
 #endif
 #endif
+#endif
 }
 
 void
-ao_led_off(uint16_t colors)
+ao_led_off(AO_LED_TYPE colors)
 {
+#ifdef LED_PER_LED
+	AO_LED_TYPE i;
+	for (i = 0; i < N_LED; i++)
+		if (colors & (1 << i))
+			ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, 0);
+#else
 #ifdef LED_PORT
 	LED_PORT->bsrr = (uint32_t) (colors & ao_led_enable) << 16;
 #else
@@ -48,21 +117,28 @@ ao_led_off(uint16_t colors)
 	LED_PORT_1->bsrr = ((uint32_t) (colors & ao_led_enable) & LED_PORT_1_MASK) << (LED_PORT_1_SHIFT + 16);
 #endif
 #endif
+#endif
 }
 
 void
-ao_led_set(uint16_t colors)
+ao_led_set(AO_LED_TYPE colors)
 {
-	uint16_t	on = colors & ao_led_enable;
-	uint16_t	off = ~colors & ao_led_enable;
+	AO_LED_TYPE	on = colors & ao_led_enable;
+	AO_LED_TYPE	off = ~colors & ao_led_enable;
 
 	ao_led_off(off);
 	ao_led_on(on);
 }
 
 void
-ao_led_toggle(uint16_t colors)
+ao_led_toggle(AO_LED_TYPE colors)
 {
+#ifdef LED_PER_LED
+	AO_LED_TYPE i;
+	for (i = 0; i < N_LED; i++)
+		if (colors & (1 << i))
+			ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, ~ao_gpio_get(ao_leds[i].port, ao_leds[i].pin, foo));
+#else
 #ifdef LED_PORT
 	LED_PORT->odr ^= (colors & ao_led_enable);
 #else
@@ -73,10 +149,11 @@ ao_led_toggle(uint16_t colors)
 	LED_PORT_1->odr ^= ((colors & ao_led_enable) & LED_PORT_1_MASK) << LED_PORT_1_SHIFT;
 #endif
 #endif
+#endif
 }
 
 void
-ao_led_for(uint16_t colors, uint16_t ticks) __reentrant
+ao_led_for(AO_LED_TYPE colors, AO_LED_TYPE ticks) __reentrant
 {
 	ao_led_on(colors);
 	ao_delay(ticks);
@@ -89,11 +166,15 @@ ao_led_for(uint16_t colors, uint16_t ticks) __reentrant
 	} while (0)
 
 void
-ao_led_init(uint16_t enable)
+ao_led_init(AO_LED_TYPE enable)
 {
-	int	bit;
+	AO_LED_TYPE	bit;
 
 	ao_led_enable = enable;
+#if LED_PER_LED
+	for (bit = 0; bit < N_LED; bit++)
+		ao_enable_output(ao_leds[bit].port, ao_leds[bit].pin, foo, 0);
+#else
 #ifdef LED_PORT
 	stm_rcc.ahbenr |= (1 << LED_PORT_ENABLE);
 	LED_PORT->odr &= ~enable;
@@ -106,6 +187,10 @@ ao_led_init(uint16_t enable)
 	stm_rcc.ahbenr |= (1 << LED_PORT_1_ENABLE);
 	LED_PORT_1->odr &= ~((enable & ao_led_enable) & LED_PORT_1_MASK) << LED_PORT_1_SHIFT;
 #endif
+#ifdef LED_PORT_2
+	stm_rcc.ahbenr |= (1 << LED_PORT_1_ENABLE);
+	LED_PORT_1->odr &= ~((enable & ao_led_enable) & LED_PORT_1_MASK) << LED_PORT_1_SHIFT;
+#endif
 #endif
 	for (bit = 0; bit < 16; bit++) {
 		if (enable & (1 << bit)) {
@@ -120,7 +205,12 @@ ao_led_init(uint16_t enable)
 			if (LED_PORT_1_MASK & (1 << bit))
 				init_led_pin(LED_PORT_1, bit + LED_PORT_1_SHIFT);
 #endif
+#ifdef LED_PORT_2
+			if (LED_PORT_2_MASK & (1 << bit))
+				init_led_pin(LED_PORT_2, bit + LED_PORT_2_SHIFT);
+#endif
 #endif
 		}
 	}
+#endif
 }
diff --git a/src/stm/ao_romconfig.c b/src/stm/ao_romconfig.c
index 9d5fd6fb..63a48bec 100644
--- a/src/stm/ao_romconfig.c
+++ b/src/stm/ao_romconfig.c
@@ -24,5 +24,6 @@ AO_ROMCONFIG_SYMBOL (0) uint16_t ao_serial_number = 0;
 #ifndef AO_RADIO_CAL_DEFAULT
 #define AO_RADIO_CAL_DEFAULT 0x01020304
 #endif
+#if HAS_RADIO
 AO_ROMCONFIG_SYMBOL (0) uint32_t ao_radio_cal = AO_RADIO_CAL_DEFAULT;
-
+#endif
diff --git a/src/stm/ao_timer.c b/src/stm/ao_timer.c
index 1576a6c9..7b526902 100644
--- a/src/stm/ao_timer.c
+++ b/src/stm/ao_timer.c
@@ -149,7 +149,7 @@ ao_clock_init(void)
 #define STM_RCC_CFGR_PLLSRC_TARGET_CLOCK	(0 << STM_RCC_CFGR_PLLSRC)
 #endif
 
-#if !AO_HSE || HAS_ADC
+#if !AO_HSE || HAS_ADC || HAS_ADC_SINGLE
 	/* Enable HSI RC clock 16MHz */
 	stm_rcc.cr |= (1 << STM_RCC_CR_HSION);
 	while (!(stm_rcc.cr & (1 << STM_RCC_CR_HSIRDY)))
diff --git a/src/stm/ao_usb_stm.c b/src/stm/ao_usb_stm.c
index 595bddac..b06814d2 100644
--- a/src/stm/ao_usb_stm.c
+++ b/src/stm/ao_usb_stm.c
@@ -446,15 +446,11 @@ ao_usb_write_short(uint16_t data, uint32_t *base, uint16_t offset)
 }
 
 static void
-ao_usb_write(const uint8_t *src, uint32_t *base, uint16_t offset, uint16_t bytes)
+ao_usb_write(const uint8_t *src, uint32_t *base, uint16_t bytes)
 {
+	uint16_t offset = 0;
 	if (!bytes)
 		return;
-	if (offset & 1) {
-		debug_data (" %02x", src[0]);
-		ao_usb_write_byte(*src++, base, offset++);
-		bytes--;
-	}
 	while (bytes >= 2) {
 		debug_data (" %02x %02x", src[0], src[1]);
 		ao_usb_write_short((src[1] << 8) | src[0], base, offset);
@@ -531,7 +527,7 @@ ao_usb_ep0_flush(void)
 	ao_usb_ep0_in_len -= this_len;
 
 	debug_data ("Flush EP0 len %d:", this_len);
-	ao_usb_write(ao_usb_ep0_in_data, ao_usb_ep0_tx_buffer, 0, this_len);
+	ao_usb_write(ao_usb_ep0_in_data, ao_usb_ep0_tx_buffer, this_len);
 	debug_data ("\n");
 	ao_usb_ep0_in_data += this_len;
 
@@ -850,7 +846,7 @@ _ao_usb_in_send(void)
 	ao_usb_in_pending = 1;
 	if (ao_usb_tx_count != AO_USB_IN_SIZE)
 		ao_usb_in_flushed = 1;
-	ao_usb_write(ao_usb_tx_buffer, ao_usb_in_tx_buffer, 0, ao_usb_tx_count);
+	ao_usb_write(ao_usb_tx_buffer, ao_usb_in_tx_buffer, ao_usb_tx_count);
 	ao_usb_bdt[AO_USB_IN_EPR].single.count_tx = ao_usb_tx_count;
 	ao_usb_tx_count = 0;
 	_ao_usb_set_stat_tx(AO_USB_IN_EPR, STM_USB_EPR_STAT_TX_VALID);
@@ -974,6 +970,11 @@ ao_usb_getchar(void)
 	return c;
 }
 
+#ifndef HAS_USB_DISABLE
+#define HAS_USB_DISABLE 1
+#endif
+
+#if HAS_USB_DISABLE
 void
 ao_usb_disable(void)
 {
@@ -991,6 +992,7 @@ ao_usb_disable(void)
 	stm_rcc.apb1enr &= ~(1 << STM_RCC_APB1ENR_USBEN);
 	ao_arch_release_interrupts();
 }
+#endif
 
 void
 ao_usb_enable(void)
diff --git a/src/stm/stm32l.h b/src/stm/stm32l.h
index 201f4f36..1da817e7 100644
--- a/src/stm/stm32l.h
+++ b/src/stm/stm32l.h
@@ -1454,6 +1454,9 @@ struct stm_adc {
 
 extern struct stm_adc stm_adc;
 
+#define STM_ADC_SQ_TEMP		16
+#define STM_ADC_SQ_V_REF	17
+
 #define STM_ADC_SR_JCNR		9
 #define STM_ADC_SR_RCNR		8
 #define STM_ADC_SR_ADONS	6