altos-avr: Start writing USB driver.

Adapt ao_usb to new environment.

Signed-off-by: Keith Packard <keithp@keithp.com>

4 files changed, 531 insertions, 1 deletions

diff --git a/ChangeLog b/ChangeLog
index f98de6d6..7cd16387 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2011-05-15  Keith Packard  <keithp@keithp.com>
+
+	* src-avr/ao_usb_avr.c (ao_usb_set_configuration): o
+
 commit 0630e7d6d8cf6abf0fe07f9a6df40ee472cce1ef
 Author: Bdale Garbee <bdale@gag.com>
 Date:   Fri Feb 18 19:54:18 2011 -0700
diff --git a/src-avr/ao_pins.h b/src-avr/ao_pins.h
index d99592d4..11f12ef7 100644
--- a/src-avr/ao_pins.h
+++ b/src-avr/ao_pins.h
@@ -250,6 +250,20 @@
 	#define HAS_USB			0
 	#define PACKET_HAS_SLAVE	0
 	#define HAS_SERIAL_1		1
+	#define TEENSY			1
+	#define AVR_VCC_5V	       	1
+	#define AVR_VCC_3V3		0
+	#define AVR_CLOCK		16000000UL
+#endif
+
+#ifdef TELESCIENCE
+	#define AO_LED_RED		(1<<7)
+	#define LEDS_AVAILABLE		(AO_LED_RED)
+	#define HAS_USB			1
+	#define TEENSY			0
+	#define AVR_VCC_5V	       	0
+	#define AVR_VCC_3V3		1
+	#define AVR_CLOCK		8000000UL
 #endif
 
 #ifndef AVR
diff --git a/src-avr/ao_timer.c b/src-avr/ao_timer.c
index 01bf8e0c..9142a497 100644
--- a/src-avr/ao_timer.c
+++ b/src-avr/ao_timer.c
@@ -149,7 +149,7 @@ ao_clock_init(void)
 		  (0x4 << PDIV0));	/* 48MHz PLL clock */
 
 	/* Set the frequency of the crystal */
-#if TEENSY
+#if AVR_CLOCK > 12000000UL
 	PLLCSR |= (1 << PINDIV);	/* For 16MHz crystal on Teensy board */
 #else
 	PLLCSR &= ~(1 << PINDIV);	/* For 8MHz crystal on TeleScience board */
diff --git a/src-avr/ao_usb_avr.c b/src-avr/ao_usb_avr.c
new file mode 100644
index 00000000..ba9361ee
--- /dev/null
+++ b/src-avr/ao_usb_avr.c
@@ -0,0 +1,512 @@
+/*
+ * Copyright © 2011 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"
+
+struct ao_task __xdata ao_usb_task;
+
+static __xdata uint16_t	ao_usb_in_bytes;
+static __xdata uint16_t ao_usb_in_bytes_last;
+static __xdata uint16_t	ao_usb_out_bytes;
+static __xdata uint8_t	ao_usb_iif;
+static __xdata uint8_t	ao_usb_running;
+
+static void
+ao_usb_set_interrupts(void)
+{
+	/* IN interrupts on the control an IN endpoints */
+	USBIIE = (1 << AO_USB_CONTROL_EP) | (1 << AO_USB_IN_EP);
+
+	/* OUT interrupts on the OUT endpoint */
+	USBOIE = (1 << AO_USB_OUT_EP);
+
+	/* Only care about reset */
+	USBCIE = USBCIE_RSTIE;
+}
+
+void
+ao_usb_set_address(uint8_t address)
+{
+	UDADD = (0 << ADDEN) | address;
+	ao_usb_running = 1;
+}
+
+#define EP_SIZE(s)	((s) == 64 ? 0x30 :	\
+			((s) == 32 ? 0x20 :	\
+			((s) == 16 ? 0x10 :	\
+			             0x00)))
+
+static void
+ao_usb_set_ep0(void)
+{
+	/* Set the CONTROL max packet size, single buffered */
+	UENUM = 0;
+	UECONX = (1 << EPEN);					/* Enable */
+
+	UECFG0X = ((0 << EPTYPE0) |				/* Control */
+		   (0 << EPDIR));				/* Out (ish) */
+
+	UECFG1X = ((EP_SIZE(AO_USB_CONTROL_SIZE) << EPSIZE0) |	/* Size */
+		   (0 << EPBK));				/* Single bank */
+
+	UEIENX = ((1 << RXSTPE) |	/* Enable SETUP interrupt */
+		  (1 << RXOUTE) |	/* Enable OUT interrupt */
+		  (1 << TXINE));	/* Enable IN complete interrupt */
+}
+
+static void
+ao_usb_set_configuration(void)
+{
+	/* Set the IN max packet size, double buffered */
+	UENUM = AO_USB_IN_EP;
+	UECONX = (1 << EPEN);					/* Enable */
+
+	UECFG0X = ((2 << EPTYPE0) |				/* Bulk */
+		   (1 << EPDIR));				/* In */
+
+	UECFG1X = ((EP_SIZE(AO_USB_IN_SIZE) << EPSIZE0) |	/* Size */
+		   (1 << EPBK) |				/* Double bank */
+		   (1 << ALLOC));				/* Allocate */
+
+	/* Set the OUT max packet size, double buffered */
+	UENUM = AO_USB_OUT_EP;
+	UECONX |= (1 << EPEN);					/* Enable */
+
+	UECFG0X = ((2 << EPTYPE0) |				/* Bulk */
+		   (0 << EPDIR));				/* Out */
+
+	UECFG1X = ((EP_SIZE(AO_USB_OUT_SIZE) << EPSIZE0) |	/* Size */
+		   (1 << EPBK) |				/* Double bank */
+		   (1 << ALLOC));				/* Allocate */
+}
+
+ISR(USB_GEN_vect)
+{
+	uint8_t intbits;
+
+        intbits = UDINT;
+        UDINT = 0;
+        if (intbits & (1<<EORSTI)) {
+		ao_usb_set_ep0();
+		usb_configuration = 0;
+        }
+	if (intbits & (1<<SOFI)) {
+		if (usb_configuration) {
+			t = transmit_flush_timer;
+			if (t) {
+				transmit_flush_timer = --t;
+				if (!t) {
+					UENUM = CDC_TX_ENDPOINT;
+					UEINTX = 0x3A;
+				}
+			}
+		}
+	}
+}
+
+struct ao_usb_setup {
+	uint8_t		dir_type_recip;
+	uint8_t		request;
+	uint16_t	value;
+	uint16_t	index;
+	uint16_t	length;
+} __xdata ao_usb_setup;
+
+__xdata uint8_t ao_usb_ep0_state;
+uint8_t * __xdata ao_usb_ep0_in_data;
+__xdata uint8_t ao_usb_ep0_in_len;
+__xdata uint8_t	ao_usb_ep0_in_buf[2];
+__xdata uint8_t ao_usb_ep0_out_len;
+__xdata uint8_t *__xdata ao_usb_ep0_out_data;
+__xdata uint8_t ao_usb_configuration;
+
+/* Send an IN data packet */
+static void
+ao_usb_ep0_flush(void)
+{
+	__xdata uint8_t this_len;
+	__xdata uint8_t	cs0;
+
+	/* If the IN packet hasn't been picked up, just return */
+	UENUM = 0;
+	if (!(UEINTX & (1 << TXINI)))
+		return;
+
+	this_len = ao_usb_ep0_in_len;
+	if (this_len > AO_USB_CONTROL_SIZE)
+		this_len = AO_USB_CONTROL_SIZE;
+
+	ao_usb_ep0_in_len -= this_len;
+	while (this_len--)
+		UEDATX = *ao_usb_ep0_in_data++;
+
+	/* Clear the TXINI bit to send the packet */
+	UEINTX &= ~(1 << TXINI);
+}
+
+__xdata static struct ao_usb_line_coding ao_usb_line_coding = {115200, 0, 0, 8};
+
+/* Walk through the list of descriptors and find a match
+ */
+static void
+ao_usb_get_descriptor(uint16_t value)
+{
+	const uint8_t		*__xdata descriptor;
+	__xdata uint8_t		type = value >> 8;
+	__xdata uint8_t		index = value;
+
+	descriptor = ao_usb_descriptors;
+	while (descriptor[0] != 0) {
+		if (descriptor[1] == type && index-- == 0) {
+			if (type == AO_USB_DESC_CONFIGURATION)
+				ao_usb_ep0_in_len = descriptor[2];
+			else
+				ao_usb_ep0_in_len = descriptor[0];
+			ao_usb_ep0_in_data = descriptor;
+			break;
+		}
+		descriptor += descriptor[0];
+	}
+}
+
+/* Read data from the ep0 OUT fifo
+ */
+static void
+ao_usb_ep0_fill(void)
+{
+	__xdata uint8_t	len;
+
+	UENUM = 0;
+	len = UEBCLX;	/* read length */
+	if (len > ao_usb_ep0_out_len)
+		len = ao_usb_ep0_out_len;
+	ao_usb_ep0_out_len -= len;
+
+	/* Pull all of the data out of the packet */
+	while (len--)
+		*ao_usb_ep0_out_data++ = UEDATX;
+}
+
+void
+ao_usb_ep0_queue_byte(uint8_t a)
+{
+	ao_usb_ep0_in_buf[ao_usb_ep0_in_len++] = a;
+}
+
+static void
+ao_usb_ep0_setup(void)
+{
+	/* Pull the setup packet out of the fifo */
+	ao_usb_ep0_out_data = (__xdata uint8_t *) &ao_usb_setup;
+	ao_usb_ep0_out_len = 8;
+	ao_usb_ep0_fill();
+	UENUM = 0;
+	UEINTX &= ~(1 << RXSTPI);
+	if (ao_usb_ep0_out_len != 0)
+		return;
+
+	/* Figure out how to ACK the setup packet */
+	if (ao_usb_setup.dir_type_recip & AO_USB_DIR_IN) {
+		if (ao_usb_setup.length)
+			ao_usb_ep0_state = AO_USB_EP0_DATA_IN;
+		else
+			ao_usb_ep0_state = AO_USB_EP0_IDLE;
+	} else {
+		if (ao_usb_setup.length)
+			ao_usb_ep0_state = AO_USB_EP0_DATA_OUT;
+		else
+			ao_usb_ep0_state = AO_USB_EP0_IDLE;
+	}
+	UENUM = 0;
+/*
+	if (ao_usb_ep0_state == AO_USB_EP0_IDLE)
+		USBCS0 = USBCS0_CLR_OUTPKT_RDY | USBCS0_DATA_END;
+	else
+		USBCS0 = USBCS0_CLR_OUTPKT_RDY;
+*/
+
+	ao_usb_ep0_in_data = ao_usb_ep0_in_buf;
+	ao_usb_ep0_in_len = 0;
+	switch(ao_usb_setup.dir_type_recip & AO_USB_SETUP_TYPE_MASK) {
+	case AO_USB_TYPE_STANDARD:
+		switch(ao_usb_setup.dir_type_recip & AO_USB_SETUP_RECIP_MASK) {
+		case AO_USB_RECIP_DEVICE:
+			switch(ao_usb_setup.request) {
+			case AO_USB_REQ_GET_STATUS:
+				ao_usb_ep0_queue_byte(0);
+				ao_usb_ep0_queue_byte(0);
+				break;
+			case AO_USB_REQ_SET_ADDRESS:
+				ao_usb_set_address(ao_usb_setup.value);
+				break;
+			case AO_USB_REQ_GET_DESCRIPTOR:
+				ao_usb_get_descriptor(ao_usb_setup.value);
+				break;
+			case AO_USB_REQ_GET_CONFIGURATION:
+				ao_usb_ep0_queue_byte(ao_usb_configuration);
+				break;
+			case AO_USB_REQ_SET_CONFIGURATION:
+				ao_usb_configuration = ao_usb_setup.value;
+				ao_usb_set_configuration();
+				break;
+			}
+			break;
+		case AO_USB_RECIP_INTERFACE:
+			#pragma disable_warning 110
+			switch(ao_usb_setup.request) {
+			case AO_USB_REQ_GET_STATUS:
+				ao_usb_ep0_queue_byte(0);
+				ao_usb_ep0_queue_byte(0);
+				break;
+			case AO_USB_REQ_GET_INTERFACE:
+				ao_usb_ep0_queue_byte(0);
+				break;
+			case AO_USB_REQ_SET_INTERFACE:
+				break;
+			}
+			break;
+		case AO_USB_RECIP_ENDPOINT:
+			switch(ao_usb_setup.request) {
+			case AO_USB_REQ_GET_STATUS:
+				ao_usb_ep0_queue_byte(0);
+				ao_usb_ep0_queue_byte(0);
+				break;
+			}
+			break;
+		}
+		break;
+	case AO_USB_TYPE_CLASS:
+		switch (ao_usb_setup.request) {
+		case SET_LINE_CODING:
+			ao_usb_ep0_out_len = 7;
+			ao_usb_ep0_out_data = (__xdata uint8_t *) &ao_usb_line_coding;
+			break;
+		case GET_LINE_CODING:
+			ao_usb_ep0_in_len = 7;
+			ao_usb_ep0_in_data = (uint8_t *) &ao_usb_line_coding;
+			break;
+		case SET_CONTROL_LINE_STATE:
+			break;
+		}
+		break;
+	}
+	if (ao_usb_ep0_state != AO_USB_EP0_DATA_OUT) {
+		if (ao_usb_setup.length < ao_usb_ep0_in_len)
+			ao_usb_ep0_in_len = ao_usb_setup.length;
+		ao_usb_ep0_flush();
+	}
+}
+
+/* End point 0 receives all of the control messages. */
+static void
+ao_usb_ep0(void)
+{
+	__xdata uint8_t	intx;
+
+	ao_usb_ep0_state = AO_USB_EP0_IDLE;
+	for (;;) {
+		cli();
+		for (;;) {
+			UENUM = 0;
+			intx = UEINTX;
+			if (intx & ((1 << RXOUTI) | (1 <<RXSTPI)))
+			    break;
+			ao_sleep(&ao_usb_task);
+		}
+		sei();
+		if (intx & (1 << RXSTPI)) {
+			ao_usb_ep0_setup();
+			UENUM = 0;
+			UEINTX &= ~(1 << RXSTPI);
+		}
+		if (intx & (1 << RXOUTI)) {
+			ao_usb_ep0_fill();
+			UENUM = 0;
+			UEINTX &= ~(1 << RXOUTI);
+		}
+	}
+}
+
+/* Wait for a free IN buffer */
+static void
+ao_usb_in_wait(void)
+{
+	for (;;) {
+		UENUM = AO_USB_IN_EP;
+		if ((UEINTX & (1 << RWAL)))
+			break;
+		ao_sleep(&ao_usb_in_bytes);
+	}
+}
+
+void
+ao_usb_flush(void) __critical
+{
+	if (!ao_usb_running)
+		return;
+
+	/* If there are pending bytes, or if the last packet was full,
+	 * send another IN packet
+	 */
+	if (ao_usb_in_bytes || (ao_usb_in_bytes_last == AO_USB_IN_SIZE)) {
+		ao_usb_in_wait();
+		ao_usb_in_send();
+	}
+}
+
+void
+ao_usb_putchar(char c) __critical __reentrant
+{
+	if (!ao_usb_running)
+		return;
+
+	ao_usb_in_wait();
+
+	/* Queue a byte, sending the packet when full */
+	UENUM = AO_USB_IN_EP;
+	UEDATX = c;
+	if (++ao_usb_in_bytes == AO_USB_IN_SIZE)
+		ao_usb_in_send();
+}
+
+char
+ao_usb_pollchar(void) __critical
+{
+	char c;
+	if (ao_usb_out_bytes == 0) {
+		/* Check to see if a packet has arrived */
+		UENUM = AO_USB_OUT_EP;
+		if ((UEINTX & (1 << RXOUTI)) == 0)
+			return AO_READ_AGAIN;
+		ao_usb_out_bytes = (UEBCHX << 8) | UEBCLX;
+		if (ao_usb_out_bytes == 0) {
+			UEINTX &= ~(1 << RXOUTI);
+			return AO_READ_AGAIN;
+		}
+	}
+	--ao_usb_out_bytes;
+	UENUM = AO_USB_OUT_EP;
+	c = UEDATX;
+	if (ao_usb_out_bytes == 0) {
+		UENUM = AO_USB_OUT_EP;
+		UEINTX &= ~(1 << RXOUTI);
+	}
+	return c;
+}
+
+char
+ao_usb_getchar(void) __critical
+{
+	char	c;
+
+	while ((c = ao_usb_pollchar()) == AO_READ_AGAIN)
+		ao_sleep(&ao_stdin_ready);
+	return c;
+}
+
+// Misc functions to wait for ready and send/receive packets
+static inline void usb_wait_in_ready(void)
+{
+	while (!(UEINTX & (1<<TXINI))) ;
+}
+static inline void usb_send_in(void)
+{
+	UEINTX = ~(1<<TXINI);
+}
+static inline void usb_wait_receive_out(void)
+{
+	while (!(UEINTX & (1<<RXOUTI))) ;
+}
+static inline void usb_ack_out(void)
+{
+	UEINTX = ~(1<<RXOUTI);
+}
+
+/* Endpoint 0 interrupt */
+
+ISR(USB_COM_vect)
+{
+	ao_wakeup(&ao_usb_task);
+}
+
+#if AVR_VCC_5V
+#define AO_PAD_REGULATOR_INIT	(1 << UVREGE)	/* Turn on pad regulator */
+#endif
+#if AVR_VCC_3V3
+#define AO_PAD_REGULATOR_INIT	0		/* Turn off pad regulator */
+#endif
+
+#if AVR_CLOCK == 16000000UL
+#define AO_USB_PLL_INPUT_PRESCALER	(1 << PINDIV)	/* Divide 16MHz clock by 2 */
+#endif
+#if AVR_CLOCK == 8000000UL
+#define AO_USB_PLL_INPUT_PRESCALER	0		/* Don't divide clock */
+#endif
+
+void
+ao_usb_disable(void)
+{
+	/* Unplug from the bus */
+	UDCON = (1 << DETACH);
+	ao_usb_detatch_interface();
+
+	/* Disable the interface */
+	USBCON = 0;
+
+	/* Disable the PLL */
+	PLLCSR = 0;
+
+	/* Turn off the pad regulator */
+	UHWCON = 0;
+}
+
+#define AO_USB_CON ((1 << USBE) |	/* USB enable */ \
+		    (0 << RSTCPU) |	/* do not reset CPU */	\
+		    (0 << LSM) |	/* Full speed mode */	\
+		    (0 << RMWKUP))	/* no remote wake-up */ \
+
+void
+ao_usb_enable(void)
+{
+	/* Configure pad regulator */
+	UHWCON = AO_PAD_REGULATOR_INIT;
+
+	/* Enable USB device, but freeze the clocks until initialized */
+	USBCON = AO_USB_CON | (1 <<FRZCLK);
+
+	/* Enable PLL with appropriate divider */
+	PLLCSR = AO_USB_PLL_INPUT_PRESCALER | (1 << PLLE);
+
+	/* Wait for PLL to lock */
+	loop_until_bit_is_set(PLLCSR, (1 << PLOCK));
+
+	/* Enable USB, enable the VBUS pad */
+	USBCON = AO_USB_CON | (1 << OTGPADE);
+
+	UDCON = (0 << DETACH);	/* Clear the DETACH bit to plug into the bus */
+
+	usb_configuration = 0;
+}
+
+void
+ao_usb_init(void)
+{
+	ao_usb_enable();
+
+	ao_add_task(&ao_usb_task, ao_usb_ep0, "usb");
+	ao_add_stdio(ao_usb_pollchar, ao_usb_putchar, ao_usb_flush);
+}