Merge branch 'branch-1.6' into debian

5 files changed, 243 insertions, 65 deletions

diff --git a/src/stmf0/ao_adc_fast.c b/src/stmf0/ao_adc_fast.c
index be9b5986..26e6691c 100644
--- a/src/stmf0/ao_adc_fast.c
+++ b/src/stmf0/ao_adc_fast.c
@@ -18,43 +18,53 @@
 #include <ao.h>
 #include <ao_adc_fast.h>
 
-uint16_t ao_adc_ring[AO_ADC_RING_SIZE];
+uint16_t ao_adc_ring[AO_ADC_RING_SIZE] __attribute__((aligned(4)));
 
-uint16_t ao_adc_ring_head, ao_adc_ring_tail;
-uint8_t ao_adc_running;
+/* Maximum number of samples fetched per _ao_adc_start call */
+#define AO_ADC_RING_CHUNK	(AO_ADC_RING_SIZE >> 1)
+
+uint16_t ao_adc_ring_head, ao_adc_ring_remain;
+uint16_t ao_adc_running;
 
 /*
  * Callback from DMA ISR
  *
- * Mark time in ring, shut down DMA engine
+ * Wakeup any waiting processes, mark the DMA as done, start the ADC
+ * if there's still lots of space in the ring
  */
 static void ao_adc_dma_done(int index)
 {
 	(void) index;
-	ao_adc_ring_head += AO_ADC_RING_CHUNK;
+	ao_adc_ring_head += ao_adc_running;
+	ao_adc_ring_remain += ao_adc_running;
 	if (ao_adc_ring_head == AO_ADC_RING_SIZE)
 		ao_adc_ring_head = 0;
 	ao_adc_running = 0;
 	ao_wakeup(&ao_adc_ring_head);
 	ao_dma_done_transfer(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC_1));
+	_ao_adc_start();
 }
 
 void
 _ao_adc_start(void)
 {
 	uint16_t	*buf;
+	uint16_t	count;
 
 	if (ao_adc_running)
 		return;
-	if (_ao_adc_space() < AO_ADC_RING_CHUNK)
+	count = _ao_adc_space();
+	if (count == 0)
 		return;
-	ao_adc_running = 1;
+	if (count > AO_ADC_RING_CHUNK)
+		count = AO_ADC_RING_CHUNK;
+	ao_adc_running = count;
 	buf = ao_adc_ring + ao_adc_ring_head;
 	stm_adc.isr = 0;
 	ao_dma_set_transfer(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC_1),
 			    &stm_adc.dr,
 			    buf,
-			    AO_ADC_RING_CHUNK,
+			    count,
 			    (0 << STM_DMA_CCR_MEM2MEM) |
 			    (STM_DMA_CCR_PL_HIGH << STM_DMA_CCR_PL) |
 			    (STM_DMA_CCR_MSIZE_16 << STM_DMA_CCR_MSIZE) |
@@ -140,7 +150,6 @@ ao_adc_init(void)
 #if AO_NUM_ADC > 8
 #error Need more ADC defines
 #endif
-	stm_adc.chselr = chselr;
 
 	/* Set the clock */
 	stm_adc.cfgr2 = STM_ADC_CFGR2_CKMODE_PCLK_2 << STM_ADC_CFGR2_CKMODE;
@@ -160,14 +169,16 @@ ao_adc_init(void)
 	while ((stm_adc.isr & (1 << STM_ADC_ISR_ADRDY)) == 0)
 		;
 
+	stm_adc.chselr = chselr;
+
 	stm_adc.cfgr1 = ((0 << STM_ADC_CFGR1_AWDCH) |
 			 (0 << STM_ADC_CFGR1_AWDEN) |
 			 (0 << STM_ADC_CFGR1_AWDSGL) |
 			 (0 << STM_ADC_CFGR1_DISCEN) |
 			 (0 << STM_ADC_CFGR1_AUTOOFF) |
-			 (1 << STM_ADC_CFGR1_WAIT) |
+			 (0 << STM_ADC_CFGR1_WAIT) |
 			 (1 << STM_ADC_CFGR1_CONT) |
-			 (0 << STM_ADC_CFGR1_OVRMOD) |
+			 (1 << STM_ADC_CFGR1_OVRMOD) |
 			 (STM_ADC_CFGR1_EXTEN_DISABLE << STM_ADC_CFGR1_EXTEN) |
 			 (0 << STM_ADC_CFGR1_ALIGN) |
 			 (STM_ADC_CFGR1_RES_12 << STM_ADC_CFGR1_RES) |
@@ -186,5 +197,4 @@ ao_adc_init(void)
 	stm_syscfg.cfgr1 &= ~(1 << STM_SYSCFG_CFGR1_ADC_DMA_RMP);
 
 	ao_dma_alloc(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC_1));
-	ao_dma_set_isr(STM_DMA_INDEX(STM_DMA_CHANNEL_ADC_1), ao_adc_dma_done);
 }
diff --git a/src/stmf0/ao_adc_fast.h b/src/stmf0/ao_adc_fast.h
index eec45505..c6903e9f 100644
--- a/src/stmf0/ao_adc_fast.h
+++ b/src/stmf0/ao_adc_fast.h
@@ -26,62 +26,59 @@ ao_adc_init(void);
 
 /* Total ring size in samples */
 #define AO_ADC_RING_SIZE	256
-/* Number of samples fetched per ao_adc_start call */
-#define AO_ADC_RING_CHUNK	(AO_ADC_RING_SIZE >> 1)
 
 extern uint16_t	ao_adc_ring[AO_ADC_RING_SIZE];
 
 #define ao_adc_ring_step(pos,inc)	(((pos) + (inc)) & (AO_ADC_RING_SIZE - 1))
 
-extern uint16_t	ao_adc_ring_head, ao_adc_ring_tail;
-extern uint8_t	ao_adc_running;
-
-void
-_ao_adc_start(void);
+extern uint16_t	ao_adc_ring_head, ao_adc_ring_remain;
+extern uint16_t	ao_adc_running;
 
+/*
+ * Place to start fetching values from
+ */
 static inline uint16_t
-_ao_adc_remain(void)
+ao_adc_ring_tail(void)
 {
-	if (ao_adc_ring_tail > ao_adc_ring_head)
-		return AO_ADC_RING_SIZE - ao_adc_ring_tail;
-	return ao_adc_ring_head - ao_adc_ring_tail;
+	return (ao_adc_ring_head - ao_adc_ring_remain) & (AO_ADC_RING_SIZE - 1);
 }
 
+void
+_ao_adc_start(void);
+
+/*
+ * Space available to write ADC values into
+ */
 static inline uint16_t
 _ao_adc_space(void)
 {
-	if (ao_adc_ring_head == ao_adc_ring_tail)
-		return AO_ADC_RING_SIZE;
-	if (ao_adc_ring_head > ao_adc_ring_tail)
+	/* Free to end of buffer? */
+	if (ao_adc_ring_remain <= ao_adc_ring_head)
 		return AO_ADC_RING_SIZE - ao_adc_ring_head;
-	return ao_adc_ring_tail - ao_adc_ring_head;
+
+	/* no, return just the unused entries beyond head */
+	return AO_ADC_RING_SIZE - ao_adc_ring_remain;
 }
 
-static inline uint16_t *
+static inline uint16_t
 ao_adc_get(uint16_t n)
 {
-	if (ao_adc_ring_tail + n > AO_ADC_RING_SIZE)
-		ao_panic(AO_PANIC_ADC);
 	ao_arch_block_interrupts();
-	while (_ao_adc_remain() < n) {
+	while (ao_adc_ring_remain < n) {
 		if (!ao_adc_running)
 			_ao_adc_start();
 		ao_sleep(&ao_adc_ring_head);
 	}
 	ao_arch_release_interrupts();
-	return &ao_adc_ring[ao_adc_ring_tail];
+	return ao_adc_ring_tail();
 }
 
 static inline void
 ao_adc_ack(uint16_t n)
 {
-	if (ao_adc_ring_tail + n > AO_ADC_RING_SIZE)
-		ao_panic(AO_PANIC_ADC);
 	ao_arch_block_interrupts();
-	ao_adc_ring_tail += n;
-	if (ao_adc_ring_tail == AO_ADC_RING_SIZE)
-		ao_adc_ring_tail = 0;
-	if (!ao_adc_running && _ao_adc_space() >= AO_ADC_RING_CHUNK)
+	ao_adc_ring_remain -= n;
+	if (!ao_adc_running)
 		_ao_adc_start();
 	ao_arch_release_interrupts();
 }
diff --git a/src/stmf0/ao_crc_stm.c b/src/stmf0/ao_crc_stm.c
new file mode 100644
index 00000000..863f5ef5
--- /dev/null
+++ b/src/stmf0/ao_crc_stm.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright © 2015 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; version 2 of the License.
+ *
+ * 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_crc.h>
+
+#ifndef AO_CRC_WIDTH
+#error "Must define AO_CRC_WIDTH"
+#endif
+
+/* Only the STM32F07x and ST32F09x series have
+ * programmable CRC units. Others can only do the ANSI CRC-32 computation
+ */
+
+#if !AO_HAVE_PROGRAMMABLE_CRC_UNIT && AO_CRC_WIDTH != 32
+#error "Target hardware does not have programmable CRC unit"
+#endif
+
+#ifndef AO_CRC_POLY
+#if AO_CRC_WIDTH == 16
+#define AO_CRC_POLY	AO_CRC_16_DEFAULT
+#endif
+#if AO_CRC_WIDTH == 32
+#define AO_CRC_POLY	AO_CRC_32_DEFAULT
+#endif
+#endif
+
+#if !AO_HAVE_PROGRAMMABLE_CRC_UNIT && (AO_CRC_WIDTH != 32 || AO_CRC_POLY != AO_CRC_32_ANSI)
+#error "Target hardware does not have programmable CRC unit"
+#endif
+
+#if AO_CRC_WIDTH == 32
+#define AO_CRC_CR_POLYSIZE	STM_CRC_CR_POLYSIZE_32
+#endif
+
+#if AO_CRC_WIDTH == 16
+#define AO_CRC_CR_POLYSIZE	STM_CRC_CR_POLYSIZE_16
+#endif
+
+#if AO_CRC_WIDTH == 8
+#define AO_CRC_CR_POLYSIZE	STM_CRC_CR_POLYSIZE_8
+#endif
+
+#if AO_CRC_WIDTH == 7
+#define AO_CRC_CR_POLYSIZE	STM_CRC_CR_POLYSIZE_7
+#endif
+
+#ifndef AO_CRC_INIT
+#define AO_CRC_INIT	0xffffffff
+#endif
+
+void
+ao_crc_reset(void)
+{
+	stm_crc.cr |= (1 << STM_CRC_CR_RESET);
+	while ((stm_crc.cr & (1 << STM_CRC_CR_RESET)) != 0)
+		;
+}
+
+void
+ao_crc_init(void)
+{
+	/* Turn on the CRC clock */
+	stm_rcc.ahbenr |= (1 << STM_RCC_AHBENR_CRCEN);
+
+	/* Need to initialize CR even on non-programmable hardware,
+	 * the write to the POLYSIZE bits will be ignored in that
+	 * case
+	 */
+	stm_crc.cr = (AO_CRC_CR_POLYSIZE << STM_CRC_CR_POLYSIZE);
+	stm_crc.init = AO_CRC_INIT;
+#if AO_HAVE_PROGRAMMABLE_CRC_UNIT
+	stm_crc.pol = AO_CRC_POLY;
+#endif
+	ao_crc_reset();
+}
diff --git a/src/stmf0/ao_exti.h b/src/stmf0/ao_exti.h
new file mode 100644
index 00000000..ebea224d
--- /dev/null
+++ b/src/stmf0/ao_exti.h
@@ -0,0 +1,48 @@
+/*
+ * 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; version 2 of the License.
+ *
+ * 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.
+ */
+
+#ifndef _AO_EXTI_H_
+#define _AO_EXTI_H_
+
+#define AO_EXTI_MODE_RISING	1
+#define AO_EXTI_MODE_FALLING	2
+#define AO_EXTI_MODE_PULL_UP	4
+#define AO_EXTI_MODE_PULL_DOWN	8
+#define AO_EXTI_PRIORITY_LOW	16
+#define AO_EXTI_PRIORITY_MED	0
+#define AO_EXTI_PRIORITY_HIGH	32
+#define AO_EXTI_PIN_NOCONFIGURE	64
+
+void
+ao_exti_setup(struct stm_gpio *gpio, uint8_t pin, uint8_t mode, void (*callback)());
+
+void
+ao_exti_set_mode(struct stm_gpio *gpio, uint8_t pin, uint8_t mode);
+
+void
+ao_exti_set_callback(struct stm_gpio *gpio, uint8_t pin, void (*callback)());
+
+void
+ao_exti_enable(struct stm_gpio *gpio, uint8_t pin);
+
+void
+ao_exti_disable(struct stm_gpio *gpio, uint8_t pin);
+
+void
+ao_exti_init(void);
+
+#endif /* _AO_EXTI_H_ */
diff --git a/src/stmf0/ao_usb_stm.c b/src/stmf0/ao_usb_stm.c
index 3ea7da5e..b8146c21 100644
--- a/src/stmf0/ao_usb_stm.c
+++ b/src/stmf0/ao_usb_stm.c
@@ -83,9 +83,13 @@ static uint16_t	ao_usb_sram_addr;
 static uint16_t	*ao_usb_ep0_tx_buffer;
 static uint16_t	*ao_usb_ep0_rx_buffer;
 
+/* Pointer to interrupt buffer in USB memory */
+static uint16_t ao_usb_int_tx_offset;
+
 /* Pointer to bulk data tx/rx buffers in USB memory */
 static uint16_t ao_usb_in_tx_offset;
 static uint16_t	*ao_usb_in_tx_buffer;
+static uint16_t ao_usb_out_rx_offset;
 static uint16_t	*ao_usb_out_rx_buffer;
 
 /* System ram shadow of USB buffer; writing individual bytes is
@@ -146,12 +150,10 @@ static inline uint16_t *ao_usb_packet_buffer_addr(uint16_t sram_addr)
 	return (uint16_t *) (stm_usb_sram + sram_addr);
 }
 
-#if AO_USB_DIRECTIO
 static inline uint16_t ao_usb_packet_buffer_offset(uint16_t *addr)
 {
 	return (uint16_t) ((uint8_t *) addr - stm_usb_sram);
 }
-#endif
 
 static inline uint32_t ao_usb_epr_stat_rx(uint32_t epr) {
 	return (epr >> STM_USB_EPR_STAT_RX) & STM_USB_EPR_STAT_RX_MASK;
@@ -323,27 +325,42 @@ ao_usb_init_ep(uint8_t ep, uint32_t addr, uint32_t type, uint32_t stat_rx, uint3
 }
 
 static void
-ao_usb_init_btable(void)
+ao_usb_alloc_buffers(void)
 {
 	ao_usb_sram_addr = 0;
 
 	ao_usb_bdt = (void *) stm_usb_sram;
-
 	ao_usb_sram_addr += 8 * STM_USB_BDT_SIZE;
 
-	/* Set up EP 0 - a Control end point with 32 bytes of in and out buffers */
-
-	ao_usb_bdt[0].single.addr_tx = ao_usb_sram_addr;
-	ao_usb_bdt[0].single.count_tx = 0;
 	ao_usb_ep0_tx_buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
 	ao_usb_sram_addr += AO_USB_CONTROL_SIZE;
 
-	ao_usb_bdt[0].single.addr_rx = ao_usb_sram_addr;
-	ao_usb_bdt[0].single.count_rx = ((1 << STM_USB_BDT_COUNT_RX_BL_SIZE) |
-				  (((AO_USB_CONTROL_SIZE / 32) - 1) << STM_USB_BDT_COUNT_RX_NUM_BLOCK));
 	ao_usb_ep0_rx_buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
 	ao_usb_sram_addr += AO_USB_CONTROL_SIZE;
 
+	ao_usb_int_tx_offset = ao_usb_sram_addr;
+	ao_usb_sram_addr += AO_USB_INT_SIZE;
+
+	ao_usb_out_rx_buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
+	ao_usb_out_rx_offset = ao_usb_sram_addr;
+	ao_usb_sram_addr += AO_USB_OUT_SIZE;
+
+	ao_usb_in_tx_buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
+	ao_usb_in_tx_offset = ao_usb_sram_addr;
+	ao_usb_sram_addr += AO_USB_IN_SIZE;
+}
+
+static void
+ao_usb_init_btable(void)
+{
+	/* Set up EP 0 - a Control end point with 32 bytes of in and out buffers */
+
+	ao_usb_bdt[0].single.addr_tx = ao_usb_packet_buffer_offset(ao_usb_ep0_tx_buffer);
+	ao_usb_bdt[0].single.count_tx = 0;
+
+	ao_usb_bdt[0].single.addr_rx = ao_usb_packet_buffer_offset(ao_usb_ep0_rx_buffer);
+	ao_usb_bdt[0].single.count_rx = ((1 << STM_USB_BDT_COUNT_RX_BL_SIZE) |
+				  (((AO_USB_CONTROL_SIZE / 32) - 1) << STM_USB_BDT_COUNT_RX_NUM_BLOCK));
 }
 
 static void
@@ -370,6 +387,8 @@ ao_usb_set_ep0(void)
 	}
 
 	ao_usb_set_address(0);
+
+	ao_usb_running = 0;
 }
 
 static void
@@ -378,9 +397,8 @@ ao_usb_set_configuration(void)
 	debug ("ao_usb_set_configuration\n");
 
 	/* Set up the INT end point */
-	ao_usb_bdt[AO_USB_INT_EPR].single.addr_tx = ao_usb_sram_addr;
+	ao_usb_bdt[AO_USB_INT_EPR].single.addr_tx = ao_usb_int_tx_offset;
 	ao_usb_bdt[AO_USB_INT_EPR].single.count_tx = 0;
-	ao_usb_sram_addr += AO_USB_INT_SIZE;
 
 	ao_usb_init_ep(AO_USB_INT_EPR,
 		       AO_USB_INT_EP,
@@ -389,11 +407,9 @@ ao_usb_set_configuration(void)
 		       STM_USB_EPR_STAT_TX_NAK);
 
 	/* Set up the OUT end point */
-	ao_usb_bdt[AO_USB_OUT_EPR].single.addr_rx = ao_usb_sram_addr;
+	ao_usb_bdt[AO_USB_OUT_EPR].single.addr_rx = ao_usb_out_rx_offset;
 	ao_usb_bdt[AO_USB_OUT_EPR].single.count_rx = ((1 << STM_USB_BDT_COUNT_RX_BL_SIZE) |
 						      (((AO_USB_OUT_SIZE / 32) - 1) << STM_USB_BDT_COUNT_RX_NUM_BLOCK));
-	ao_usb_out_rx_buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
-	ao_usb_sram_addr += AO_USB_OUT_SIZE;
 
 	ao_usb_init_ep(AO_USB_OUT_EPR,
 		       AO_USB_OUT_EP,
@@ -402,11 +418,8 @@ ao_usb_set_configuration(void)
 		       STM_USB_EPR_STAT_TX_DISABLED);
 
 	/* Set up the IN end point */
-	ao_usb_bdt[AO_USB_IN_EPR].single.addr_tx = ao_usb_sram_addr;
+	ao_usb_bdt[AO_USB_IN_EPR].single.addr_tx = ao_usb_in_tx_offset;
 	ao_usb_bdt[AO_USB_IN_EPR].single.count_tx = 0;
-	ao_usb_in_tx_offset = ao_usb_sram_addr;
-	ao_usb_in_tx_buffer = ao_usb_packet_buffer_addr(ao_usb_in_tx_offset);
-	ao_usb_sram_addr += AO_USB_IN_SIZE;
 
 	ao_usb_init_ep(AO_USB_IN_EPR,
 		       AO_USB_IN_EP,
@@ -415,6 +428,9 @@ ao_usb_set_configuration(void)
 		       STM_USB_EPR_STAT_TX_NAK);
 
 	ao_usb_running = 1;
+#if AO_USB_DIRECTIO
+	ao_wakeup(&ao_usb_running);
+#endif
 }
 
 static uint16_t	control_count;
@@ -916,8 +932,6 @@ ao_usb_alloc(void)
 {
 	uint16_t	*buffer;
 
-	if (!ao_usb_running)
-		return NULL;
 	buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
 	ao_usb_sram_addr += AO_USB_IN_SIZE;
 	return buffer;
@@ -936,12 +950,28 @@ ao_usb_write(uint16_t *buffer, uint16_t len)
 {
 	ao_arch_block_interrupts();
 
-	/* Flush any pending regular */
-	if (ao_usb_tx_count)
-		_ao_usb_in_send();
+	/* Wait for everything to be ready at the same time */
+	for (;;) {
+		/* Make sure USB is connected */
+		if (!ao_usb_running) {
+			ao_sleep(&ao_usb_running);
+			continue;
+		}
+
+		/* Flush any pending regular I/O */
+		if (ao_usb_tx_count) {
+			_ao_usb_in_send();
+			continue;
+		}
+
+		/* Wait for an idle IN buffer */
+		if (ao_usb_in_pending) {
+			ao_sleep(&ao_usb_in_pending);
+			continue;
+		}
+		break;
+	}
 
-	while (ao_usb_in_pending)
-		ao_sleep(&ao_usb_in_pending);
 	ao_usb_in_pending = 1;
 	ao_usb_in_flushed = (len != AO_USB_IN_SIZE);
 	ao_usb_bdt[AO_USB_IN_EPR].single.addr_tx = ao_usb_packet_buffer_offset(buffer);
@@ -1083,6 +1113,9 @@ ao_usb_init(void)
 
 	debug ("ao_usb_init\n");
 	ao_usb_ep0_state = AO_USB_EP0_IDLE;
+
+	ao_usb_alloc_buffers();
+
 #if USB_ECHO
 	ao_add_task(&ao_usb_echo_task, ao_usb_echo, "usb echo");
 #endif