X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fstmf0%2Fao_usb_stm.c;h=b0f4c516ab151754bff7a3c8437f3bbd250e56e1;hb=2ad756bd1b63a2c8450edd7001628b92279fd1b8;hp=3ea7da5e3caa030d5adcca5884b8ec06995a639a;hpb=8f9e192e9d1c6fab9843939ff9117f6bb3725943;p=fw%2Faltos

diff --git a/src/stmf0/ao_usb_stm.c b/src/stmf0/ao_usb_stm.c
index 3ea7da5e..b0f4c516 100644
--- a/src/stmf0/ao_usb_stm.c
+++ b/src/stmf0/ao_usb_stm.c
@@ -18,8 +18,10 @@
 #include "ao.h"
 #include "ao_usb.h"
 #include "ao_product.h"
+#include "ao_power.h"
 
 #define USB_DEBUG 	0
+#define USB_STATUS	0
 #define USB_DEBUG_DATA	0
 #define USB_ECHO	0
 
@@ -27,6 +29,10 @@
 #error "must define AO_PA11_PA12_RMP"
 #endif
 
+#ifndef AO_POWER_MANAGEMENT
+#define AO_POWER_MANAGEMENT	0
+#endif
+
 #ifndef USE_USB_STDIO
 #define USE_USB_STDIO	1
 #endif
@@ -83,9 +89,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
@@ -125,10 +135,9 @@ static uint8_t	ao_usb_out_avail;
 uint8_t		ao_usb_running;
 static uint8_t	ao_usb_configuration;
 
-#define AO_USB_EP0_GOT_RESET	1
-#define AO_USB_EP0_GOT_SETUP	2
-#define AO_USB_EP0_GOT_RX_DATA	4
-#define AO_USB_EP0_GOT_TX_ACK	8
+#define AO_USB_EP0_GOT_SETUP	1
+#define AO_USB_EP0_GOT_RX_DATA	2
+#define AO_USB_EP0_GOT_TX_ACK	4
 
 static uint8_t	ao_usb_ep0_receive;
 static uint8_t	ao_usb_address;
@@ -146,12 +155,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 +330,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 +392,8 @@ ao_usb_set_ep0(void)
 	}
 
 	ao_usb_set_address(0);
+
+	ao_usb_running = 0;
 }
 
 static void
@@ -377,44 +401,47 @@ ao_usb_set_configuration(void)
 {
 	debug ("ao_usb_set_configuration\n");
 
+#if AO_USB_HAS_INT
 	/* 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,
 		       STM_USB_EPR_EP_TYPE_INTERRUPT,
 		       STM_USB_EPR_STAT_RX_DISABLED,
 		       STM_USB_EPR_STAT_TX_NAK);
+#endif
 
+#if AO_USB_HAS_OUT
 	/* 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,
 		       STM_USB_EPR_EP_TYPE_BULK,
 		       STM_USB_EPR_STAT_RX_VALID,
 		       STM_USB_EPR_STAT_TX_DISABLED);
+#endif
 
+#if AO_USB_HAS_IN
 	/* 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,
 		       STM_USB_EPR_EP_TYPE_BULK,
 		       STM_USB_EPR_STAT_RX_DISABLED,
 		       STM_USB_EPR_STAT_TX_NAK);
+#endif
 
 	ao_usb_running = 1;
+#if AO_USB_DIRECTIO
+	ao_wakeup(&ao_usb_running);
+#endif
 }
 
 static uint16_t	control_count;
@@ -670,11 +697,6 @@ static void
 ao_usb_ep0_handle(uint8_t receive)
 {
 	ao_usb_ep0_receive = 0;
-	if (receive & AO_USB_EP0_GOT_RESET) {
-		debug ("\treset\n");
-		ao_usb_set_ep0();
-		return;
-	}
 	if (receive & AO_USB_EP0_GOT_SETUP) {
 		debug ("\tsetup\n");
 		ao_usb_ep0_setup();
@@ -705,6 +727,25 @@ ao_usb_ep0_handle(uint8_t receive)
 	}
 }
 
+#if AO_POWER_MANAGEMENT
+void
+ao_usb_suspend(void)
+{
+	stm_usb.cntr |= (1 << STM_USB_CNTR_FSUSP);
+	ao_power_suspend();
+	stm_usb.cntr |= (1 << STM_USB_CNTR_LP_MODE);
+	ao_clock_suspend();
+}
+
+void
+ao_usb_wakeup(void)
+{
+	ao_clock_resume();
+	stm_usb.cntr &= ~(1 << STM_USB_CNTR_FSUSP);
+	ao_power_resume();
+}
+#endif
+
 void
 stm_usb_isr(void)
 {
@@ -768,10 +809,19 @@ stm_usb_isr(void)
 
 	if (istr & (1 << STM_USB_ISTR_RESET)) {
 		++reset_count;
-		ao_usb_ep0_receive |= AO_USB_EP0_GOT_RESET;
-		ao_usb_ep0_handle(ao_usb_ep0_receive);
+		debug ("\treset\n");
+		ao_usb_set_ep0();
 	}
-
+#if AO_POWER_MANAGEMENT
+	if (istr & (1 << STM_USB_ISTR_SUSP)) {
+		debug ("\tsuspend\n");
+		ao_usb_suspend();
+	}
+	if (istr & (1 << STM_USB_ISTR_WKUP)) {
+		debug ("\twakeup\n");
+		ao_usb_wakeup();
+	}
+#endif
 }
 
 /* Queue the current IN buffer for transmission */
@@ -916,8 +966,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 +984,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);
@@ -1020,8 +1084,8 @@ ao_usb_enable(void)
 	stm_usb.cntr = ((1 << STM_USB_CNTR_CTRM) |
 			(0 << STM_USB_CNTR_PMAOVRM) |
 			(0 << STM_USB_CNTR_ERRM) |
-			(0 << STM_USB_CNTR_WKUPM) |
-			(0 << STM_USB_CNTR_SUSPM) |
+			(AO_POWER_MANAGEMENT << STM_USB_CNTR_WKUPM) |
+			(AO_POWER_MANAGEMENT << STM_USB_CNTR_SUSPM) |
 			(1 << STM_USB_CNTR_RESETM) |
 			(0 << STM_USB_CNTR_SOFM) |
 			(0 << STM_USB_CNTR_ESOFM) |
@@ -1056,7 +1120,7 @@ ao_usb_echo(void)
 }
 #endif
 
-#if USB_DEBUG
+#if USB_STATUS
 static void
 ao_usb_irq(void)
 {
@@ -1083,10 +1147,13 @@ 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
-#if USB_DEBUG
+#if USB_STATUS
 	ao_cmd_register(&ao_usb_cmds[0]);
 #endif
 #if !USB_ECHO