X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Flpc%2Fao_usb_lpc.c;h=78fbac3985ea848e3a519c2c977562c193ab3774;hb=0671b3c8c24c9f33be77a10315c4669f33c516d7;hp=4e6b9c664b7e2d6e1d207fbd58d89e539f88cba0;hpb=9081d881bc48bf7fdce617d300ac02c1a5962239;p=fw%2Faltos

diff --git a/src/lpc/ao_usb_lpc.c b/src/lpc/ao_usb_lpc.c
index 4e6b9c66..78fbac39 100644
--- a/src/lpc/ao_usb_lpc.c
+++ b/src/lpc/ao_usb_lpc.c
@@ -19,6 +19,16 @@
 #include "ao_usb.h"
 #include "ao_product.h"
 
+#ifndef USE_USB_STDIO
+#define USE_USB_STDIO	1
+#endif
+
+#if USE_USB_STDIO
+#define AO_USB_OUT_SLEEP_ADDR	(&ao_stdin_ready)
+#else
+#define AO_USB_OUT_SLEEP_ADDR	(&ao_usb_out_avail)
+#endif
+
 #define USB_DEBUG 	0
 #define USB_DEBUG_DATA	0
 #define USB_ECHO	0
@@ -48,6 +58,7 @@ static uint8_t 	ao_usb_ep0_state;
 /* Pending EP0 IN data */
 static const uint8_t	*ao_usb_ep0_in_data;	/* Remaining data */
 static uint8_t 		ao_usb_ep0_in_len;	/* Remaining amount */
+static uint16_t		ao_usb_ep0_in_max;	/* Requested amount from host */
 
 /* Temp buffer for smaller EP0 in data */
 static uint8_t	ao_usb_ep0_in_buf[2];
@@ -98,9 +109,8 @@ static uint8_t	ao_usb_in_pending;
  * but not pulled to the shadow buffer.
  */
 static uint8_t	ao_usb_out_avail;
-static uint8_t	ao_usb_running;
+uint8_t		ao_usb_running;
 static uint8_t	ao_usb_configuration;
-static uint8_t	ueienx_0;
 
 #define AO_USB_EP0_GOT_RESET	1
 #define AO_USB_EP0_GOT_SETUP	2
@@ -224,46 +234,48 @@ ao_usb_ep0_in(void)
 }
 
 static inline vuint32_t *
-ao_usb_epn_out(uint8_t n)
+ao_usb_epn_out(uint8_t n, uint8_t i)
 {
-	return &lpc_usb_endpoint.epn[n-1].out[0];
+	return &lpc_usb_endpoint.epn[n-1].out[i];
 }
 
 static inline vuint32_t *
-ao_usb_epn_in(uint8_t n)
+ao_usb_epn_in(uint8_t n, uint8_t i)
 {
-	return &lpc_usb_endpoint.epn[n-1].in[0];
+	return &lpc_usb_endpoint.epn[n-1].in[i];
 }
 
+#if UNUSED
 static void
 ao_usb_set_epn_in(uint8_t n, uint8_t *addr, uint16_t nbytes)
 {
 	ao_usb_set_ep(ao_usb_epn_in(n), addr, nbytes);
 }
+#endif
 
 static void
 ao_usb_set_epn_out(uint8_t n, uint8_t *addr, uint16_t nbytes)
 {
-	ao_usb_set_ep(ao_usb_epn_out(n), addr, nbytes);
+	ao_usb_set_ep(ao_usb_epn_out(n, 0), addr, nbytes);
 }
 
 static inline uint16_t
 ao_usb_epn_out_count(uint8_t n)
 {
-	return ao_usb_ep_count(ao_usb_epn_out(n));
+	return ao_usb_ep_count(ao_usb_epn_out(n, 0));
 }
 
 static inline uint16_t
 ao_usb_epn_in_count(uint8_t n)
 {
-	return ao_usb_ep_count(ao_usb_epn_in(n));
+	return ao_usb_ep_count(ao_usb_epn_in(n, 0));
 }
 
 static uint8_t *
 ao_usb_enable_ep(vuint32_t *ep, uint16_t nbytes, uint16_t set_nbytes)
 {
 	uint8_t	*addr = ao_usb_alloc_sram(nbytes);
-	
+
 	ao_usb_set_ep(ep, addr, set_nbytes);
 	return addr;
 }
@@ -286,24 +298,31 @@ ao_usb_enable_epn(uint8_t n, uint16_t out_bytes, uint8_t **out_addr, uint16_t in
 {
 	uint8_t	*addr;
 
-	addr = ao_usb_enable_ep(ao_usb_epn_out(n), out_bytes, out_bytes);
+	addr = ao_usb_enable_ep(ao_usb_epn_out(n, 0), out_bytes, out_bytes);
 	if (out_addr)
 		*out_addr = addr;
-	ao_usb_disable_ep(&lpc_usb_endpoint.epn[n-1].out[1]);
+	ao_usb_disable_ep(ao_usb_epn_out(n, 1));
 
-	addr = ao_usb_enable_ep(ao_usb_epn_in(n), in_bytes, 0);
+	addr = ao_usb_enable_ep(ao_usb_epn_in(n, 0), in_bytes, 0);
 	if (in_addr)
 		*in_addr = addr;
-	ao_usb_disable_ep(&lpc_usb_endpoint.epn[n-1].in[1]);
+	ao_usb_disable_ep(ao_usb_epn_in(n, 1));
 }
 
 static void
 ao_usb_disable_epn(uint8_t n)
 {
-	ao_usb_disable_ep(ao_usb_epn_out(n));
-	ao_usb_disable_ep(&lpc_usb_endpoint.epn[n-1].out[1]);
-	ao_usb_disable_ep(ao_usb_epn_in(n));
-	ao_usb_disable_ep(&lpc_usb_endpoint.epn[n-1].in[1]);
+	ao_usb_disable_ep(ao_usb_epn_out(n, 0));
+	ao_usb_disable_ep(ao_usb_epn_out(n, 1));
+	ao_usb_disable_ep(ao_usb_epn_in(n, 0));
+	ao_usb_disable_ep(ao_usb_epn_in(n, 1));
+}
+
+static void
+ao_usb_reset(void)
+{
+	ao_usb_set_address(0);
+	ao_usb_configuration = 0;
 }
 
 static void
@@ -316,11 +335,8 @@ ao_usb_set_ep0(void)
 	lpc_usb.epinuse = 0;
 	lpc_usb.epskip = 0xffffffff;
 
-	ao_usb_set_address(0);
 	lpc_usb.intstat = 0xc00003ff;
 
-	ao_usb_configuration = 0;
-
 	ao_usb_sram = lpc_usb_sram;
 
 	lpc_usb.epliststart = (uint32_t) (intptr_t) &lpc_usb_endpoint;
@@ -336,7 +352,7 @@ ao_usb_set_ep0(void)
 	/* Clear all of the other endpoints */
 	for (e = 1; e <= 4; e++)
 		ao_usb_disable_epn(e);
-
+	ao_usb_reset();
 }
 
 static void
@@ -366,10 +382,11 @@ ao_usb_ep0_flush(void)
 	if (this_len > AO_USB_CONTROL_SIZE)
 		this_len = AO_USB_CONTROL_SIZE;
 
-	if (this_len < AO_USB_CONTROL_SIZE)
-		ao_usb_ep0_state = AO_USB_EP0_IDLE;
-
 	ao_usb_ep0_in_len -= this_len;
+	ao_usb_ep0_in_max -= this_len;
+
+	if (this_len < AO_USB_CONTROL_SIZE || ao_usb_ep0_in_max == 0)
+		ao_usb_ep0_state = AO_USB_EP0_IDLE;
 
 	debug_data ("Flush EP0 len %d:", this_len);
 	memcpy(ao_usb_ep0_tx_buffer, ao_usb_ep0_in_data, this_len);
@@ -440,8 +457,9 @@ ao_usb_ep0_out_set(uint8_t *data, uint8_t len)
 }
 
 static void
-ao_usb_ep0_in_start(uint8_t max)
+ao_usb_ep0_in_start(uint16_t max)
 {
+	ao_usb_ep0_in_max = max;
 	/* Don't send more than asked for */
 	if (ao_usb_ep0_in_len > max)
 		ao_usb_ep0_in_len = max;
@@ -580,7 +598,7 @@ ao_usb_ep0_handle(uint8_t receive)
 
 	if (receive & AO_USB_EP0_GOT_RESET) {
 		debug ("\treset\n");
-		ao_usb_set_ep0();
+		ao_usb_reset();
 		return;
 	}
 	if (receive & AO_USB_EP0_GOT_SETUP) {
@@ -616,11 +634,12 @@ ao_usb_ep0_handle(uint8_t receive)
 	}
 }
 
-static uint16_t	control_count;
+#if USB_DEBUG
 static uint16_t int_count;
 static uint16_t	in_count;
 static uint16_t	out_count;
 static uint16_t	reset_count;
+#endif
 
 void
 lpc_usb_irq_isr(void)
@@ -648,17 +667,21 @@ lpc_usb_irq_isr(void)
 
 	/* Handle OUT packets */
 	if (intstat & (1 << LPC_USB_INT_EPOUT(AO_USB_OUT_EP))) {
+#if USB_DEBUG
 		++out_count;
+#endif
 		_rx_dbg1("RX ISR", *ao_usb_epn_out(AO_USB_OUT_EP));
 		ao_usb_out_avail = 1;
 		_rx_dbg0("out avail set");
-		ao_wakeup(&ao_stdin_ready);
+		ao_wakeup(AO_USB_OUT_SLEEP_ADDR)
 		_rx_dbg0("stdin awoken");
 	}
 
 	/* Handle IN packets */
 	if (intstat & (1 << LPC_USB_INT_EPIN(AO_USB_IN_EP))) {
+#if USB_DEBUG
 		++in_count;
+#endif
 		_tx_dbg1("TX ISR", *ao_usb_epn_in(AO_USB_IN_EP));
 		ao_usb_in_pending = 0;
 		ao_wakeup(&ao_usb_in_pending);
@@ -694,7 +717,7 @@ _ao_usb_in_send(void)
 	if (ao_usb_tx_count != AO_USB_IN_SIZE)
 		ao_usb_in_flushed = 1;
 	memcpy(ao_usb_in_tx_buffer, ao_usb_tx_buffer, ao_usb_tx_count);
-	ao_usb_set_ep(ao_usb_epn_in(AO_USB_IN_EP), ao_usb_in_tx_buffer, ao_usb_tx_count);
+	ao_usb_set_ep(ao_usb_epn_in(AO_USB_IN_EP, 0), ao_usb_in_tx_buffer, ao_usb_tx_count);
 	ao_usb_tx_count = 0;
 	_tx_dbg0("in_send end");
 }
@@ -811,7 +834,7 @@ ao_usb_getchar(void)
 
 	ao_arch_block_interrupts();
 	while ((c = _ao_usb_pollchar()) == AO_READ_AGAIN)
-		ao_sleep(&ao_stdin_ready);
+		ao_sleep(AO_USB_OUT_SLEEP_ADDR);
 	ao_arch_release_interrupts();
 	return c;
 }
@@ -821,6 +844,9 @@ ao_usb_disable(void)
 {
 	ao_arch_block_interrupts();
 
+#if HAS_USB_PULLUP
+	ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 0);
+#endif
 	/* Disable interrupts */
 	lpc_usb.inten = 0;
 
@@ -849,7 +875,7 @@ ao_usb_enable(void)
 	int	t;
 
 	/* Enable USB pins */
-#if HAS_USB_CONNECT
+#if HAS_LPC_USB_CONNECT
 	lpc_ioconf.pio0_6 = ((LPC_IOCONF_FUNC_USB_CONNECT << LPC_IOCONF_FUNC) |
 			     (LPC_IOCONF_MODE_INACTIVE << LPC_IOCONF_MODE) |
 			     (0 << LPC_IOCONF_HYS) |
@@ -871,7 +897,7 @@ ao_usb_enable(void)
 
 	/* Enable USB PHY */
 	lpc_scb.pdruncfg &= ~(1 << LPC_SCB_PDRUNCFG_USBPAD_PD);
-	
+
 	/* Turn on USB PLL */
 	lpc_scb.pdruncfg &= ~(1 << LPC_SCB_PDRUNCFG_USBPLL_PD);
 
@@ -924,6 +950,10 @@ ao_usb_enable(void)
 		ao_arch_nop();
 
 	ao_usb_set_ep0();
+
+#if HAS_USB_PULLUP
+	ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 1);
+#endif
 }
 
 #if USB_ECHO
@@ -959,6 +989,10 @@ __code struct ao_cmds ao_usb_cmds[] = {
 void
 ao_usb_init(void)
 {
+#if HAS_USB_PULLUP
+	ao_enable_output(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 0);
+#endif
+
 	ao_usb_enable();
 
 	debug ("ao_usb_init\n");
@@ -968,7 +1002,7 @@ ao_usb_init(void)
 #if USB_DEBUG
 	ao_cmd_register(&ao_usb_cmds[0]);
 #endif
-#if !USB_ECHO
+#if USE_USB_STDIO
 	ao_add_stdio(_ao_usb_pollchar, ao_usb_putchar, ao_usb_flush);
 #endif
 }
@@ -1010,7 +1044,7 @@ static void _dbg(int line, char *msg, uint32_t value)
 	dbg[dbg_i].primask = primask;
 #if TX_DBG
 	dbg[dbg_i].in_count = in_count;
-	dbg[dbg_i].in_ep = *ao_usb_epn_in(AO_USB_IN_EP);
+	dbg[dbg_i].in_ep = *ao_usb_epn_in(AO_USB_IN_EP, 0);
 	dbg[dbg_i].in_pending = ao_usb_in_pending;
 	dbg[dbg_i].tx_count = ao_usb_tx_count;
 	dbg[dbg_i].in_flushed = ao_usb_in_flushed;
@@ -1019,7 +1053,7 @@ static void _dbg(int line, char *msg, uint32_t value)
 	dbg[dbg_i].rx_count = ao_usb_rx_count;
 	dbg[dbg_i].rx_pos = ao_usb_rx_pos;
 	dbg[dbg_i].out_avail = ao_usb_out_avail;
-	dbg[dbg_i].out_ep = *ao_usb_epn_out(AO_USB_OUT_EP);
+	dbg[dbg_i].out_ep = *ao_usb_epn_out(AO_USB_OUT_EP, 0);
 #endif
 	if (++dbg_i == NUM_USB_DBG)
 		dbg_i = 0;