X-Git-Url: https://git.gag.com/?p=fw%2Faltos;a=blobdiff_plain;f=src%2Fstmf0%2Fao_usb_stm.c;h=b8146c216f1a2b0538e964dd8bc24862895d984c;hp=b9d863685230383d111b3f64ad514e5211e5cc82;hb=476c5b87ea0901f70fe98b581ecca9afaf957607;hpb=02f03df6d089cafae99f8ce15dcbd87f6e78d749

diff --git a/src/stmf0/ao_usb_stm.c b/src/stmf0/ao_usb_stm.c
index b9d86368..b8146c21 100644
--- a/src/stmf0/ao_usb_stm.c
+++ b/src/stmf0/ao_usb_stm.c
@@ -23,6 +23,10 @@
 #define USB_DEBUG_DATA	0
 #define USB_ECHO	0
 
+#ifndef AO_PA11_PA12_RMP
+#error "must define AO_PA11_PA12_RMP"
+#endif
+
 #ifndef USE_USB_STDIO
 #define USE_USB_STDIO	1
 #endif
@@ -79,8 +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
@@ -141,6 +150,11 @@ static inline uint16_t *ao_usb_packet_buffer_addr(uint16_t sram_addr)
 	return (uint16_t *) (stm_usb_sram + sram_addr);
 }
 
+static inline uint16_t ao_usb_packet_buffer_offset(uint16_t *addr)
+{
+	return (uint16_t) ((uint8_t *) addr - stm_usb_sram);
+}
+
 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;
 }
@@ -311,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
@@ -358,6 +387,8 @@ ao_usb_set_ep0(void)
 	}
 
 	ao_usb_set_address(0);
+
+	ao_usb_running = 0;
 }
 
 static void
@@ -366,10 +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_in_tx_buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
-	ao_usb_sram_addr += AO_USB_INT_SIZE;
 
 	ao_usb_init_ep(AO_USB_INT_EPR,
 		       AO_USB_INT_EP,
@@ -378,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,
@@ -391,10 +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_buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
-	ao_usb_sram_addr += AO_USB_IN_SIZE;
 
 	ao_usb_init_ep(AO_USB_IN_EPR,
 		       AO_USB_IN_EP,
@@ -403,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;
@@ -415,7 +443,7 @@ static uint16_t	reset_count;
  */
 
 static void
-ao_usb_write(const uint8_t *src, uint16_t *base, uint16_t bytes)
+ao_usb_copy_tx(const uint8_t *src, uint16_t *base, uint16_t bytes)
 {
 	while (bytes >= 2) {
 		*base++ = src[0] | (src[1] << 8);
@@ -427,7 +455,7 @@ ao_usb_write(const uint8_t *src, uint16_t *base, uint16_t bytes)
 }
 
 static void
-ao_usb_read(uint8_t *dst, uint16_t *base, uint16_t bytes)
+ao_usb_copy_rx(uint8_t *dst, uint16_t *base, uint16_t bytes)
 {
 	while (bytes >= 2) {
 		uint16_t s = *base++;
@@ -462,7 +490,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, this_len);
+	ao_usb_copy_tx(ao_usb_ep0_in_data, ao_usb_ep0_tx_buffer, this_len);
 	debug_data ("\n");
 	ao_usb_ep0_in_data += this_len;
 
@@ -484,7 +512,7 @@ ao_usb_ep0_fill(void)
 
 	/* Pull all of the data out of the packet */
 	debug_data ("Fill EP0 len %d:", len);
-	ao_usb_read(ao_usb_ep0_out_data, ao_usb_ep0_rx_buffer, len);
+	ao_usb_copy_rx(ao_usb_ep0_out_data, ao_usb_ep0_rx_buffer, len);
 	debug_data ("\n");
 	ao_usb_ep0_out_data += len;
 
@@ -773,7 +801,8 @@ _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, ao_usb_tx_count);
+	ao_usb_copy_tx(ao_usb_tx_buffer, ao_usb_in_tx_buffer, ao_usb_tx_count);
+	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 = ao_usb_tx_count;
 	ao_usb_tx_count = 0;
 	_ao_usb_set_stat_tx(AO_USB_IN_EPR, STM_USB_EPR_STAT_TX_VALID);
@@ -851,7 +880,7 @@ _ao_usb_out_recv(void)
 	_rx_dbg1("out_recv count", ao_usb_rx_count);
 	debug ("recv %d\n", ao_usb_rx_count);
 	debug_data("Fill OUT len %d:", ao_usb_rx_count);
-	ao_usb_read(ao_usb_rx_buffer, ao_usb_out_rx_buffer, ao_usb_rx_count);
+	ao_usb_copy_rx(ao_usb_rx_buffer, ao_usb_out_rx_buffer, ao_usb_rx_count);
 	debug_data("\n");
 	ao_usb_rx_pos = 0;
 
@@ -897,6 +926,61 @@ ao_usb_getchar(void)
 	return c;
 }
 
+#if AO_USB_DIRECTIO
+uint16_t *
+ao_usb_alloc(void)
+{
+	uint16_t	*buffer;
+
+	buffer = ao_usb_packet_buffer_addr(ao_usb_sram_addr);
+	ao_usb_sram_addr += AO_USB_IN_SIZE;
+	return buffer;
+}
+
+void
+ao_usb_free(uint16_t *addr)
+{
+	uint16_t	offset = ao_usb_packet_buffer_offset(addr);
+	if (offset < ao_usb_sram_addr)
+		ao_usb_sram_addr = offset;
+}
+
+void
+ao_usb_write(uint16_t *buffer, uint16_t len)
+{
+	ao_arch_block_interrupts();
+
+	/* 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;
+	}
+
+	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);
+	ao_usb_bdt[AO_USB_IN_EPR].single.count_tx = len;
+	_ao_usb_set_stat_tx(AO_USB_IN_EPR, STM_USB_EPR_STAT_TX_VALID);
+	ao_arch_release_interrupts();
+}
+#endif
+
 void
 ao_usb_disable(void)
 {
@@ -1019,10 +1103,19 @@ __code struct ao_cmds ao_usb_cmds[] = {
 void
 ao_usb_init(void)
 {
+	/* Turn on syscfg */
+	stm_rcc.apb2enr |= (1 << STM_RCC_APB2ENR_SYSCFGCOMPEN);
+
+	/* Set PA11/PA12 remapping bit */
+	stm_syscfg.cfgr1 |= (AO_PA11_PA12_RMP << STM_SYSCFG_CFGR1_PA11_PA12_RMP);
+
 	ao_usb_enable();
 
 	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