1 files changed, 508 insertions, 0 deletions
diff --git a/bootloaders/diskloader/src/USBCore.cpp b/bootloaders/diskloader/src/USBCore.cpp
new file mode 100644
index 0000000..ca74721
--- /dev/null
+++ b/bootloaders/diskloader/src/USBCore.cpp
@@ -0,0 +1,508 @@
+
+
+/* Copyright (c) 2010, Peter Barrett  
+**  
+** Permission to use, copy, modify, and/or distribute this software for  
+** any purpose with or without fee is hereby granted, provided that the  
+** above copyright notice and this permission notice appear in all copies.  
+** 
+** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL  
+** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED  
+** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR  
+** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES  
+** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,  
+** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,  
+** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS  
+** SOFTWARE.  
+*/
+
+#include "Platform.h"
+
+#define CDC_TX CDC_ENDPOINT_IN
+#define CDC_RX CDC_ENDPOINT_OUT
+
+#define EP_TYPE_CONTROL				0x00
+#define EP_TYPE_BULK_IN				0x81
+#define EP_TYPE_BULK_OUT			0x80
+#define EP_TYPE_INTERRUPT_IN		0xC1
+#define EP_TYPE_INTERRUPT_OUT		0xC0
+#define EP_TYPE_ISOCHRONOUS_IN		0x41
+#define EP_TYPE_ISOCHRONOUS_OUT		0x40
+
+/** Pulse generation counters to keep track of the number of milliseconds remaining for each pulse type */
+#define TX_RX_LED_PULSE_MS 100
+u8 TxLEDPulse; /**< Milliseconds remaining for data Tx LED pulse */
+u8 RxLEDPulse; /**< Milliseconds remaining for data Rx LED pulse */
+
+void Reboot();
+
+//==================================================================
+//==================================================================
+
+typedef struct
+{
+	u32	dwDTERate;
+	u8	bCharFormat;
+	u8 	bParityType;
+	u8 	bDataBits;
+	u8	lineState;
+} LineInfo;
+
+static volatile LineInfo _usbLineInfo = { 57600, 0x00, 0x00, 0x00, 0x00 };
+
+//==================================================================
+//==================================================================
+
+//	4 bytes of RAM
+volatile u8 _usbConfiguration;
+volatile u8 _ejected;
+volatile u16 _timeout;
+
+static inline void WaitIN(void)
+{
+	while (!(UEINTX & (1<<TXINI)));
+}
+
+static inline void ClearIN(void)
+{
+	UEINTX = ~(1<<TXINI);
+}
+
+static inline void WaitOUT(void)
+{
+	while (!(UEINTX & (1<<RXOUTI)))
+		;
+}
+
+static inline u8 WaitForINOrOUT()
+{
+	while (!(UEINTX & ((1<<TXINI)|(1<<RXOUTI))))
+		;
+	return (UEINTX & (1<<RXOUTI)) == 0;
+}
+
+static inline void ClearOUT(void)
+{
+	UEINTX = ~(1<<RXOUTI);
+}
+
+static
+void Send(volatile const u8* data, u8 count)
+{
+	TXLED1;					// light the TX LED
+	TxLEDPulse = TX_RX_LED_PULSE_MS;
+	while (count--)
+		UEDATX = *data++;
+}
+
+void Recv(volatile u8* data, u8 count)
+{
+	RXLED1;					// light the RX LED
+	RxLEDPulse = TX_RX_LED_PULSE_MS;
+	while (count--)
+		*data++ = UEDATX;
+}
+
+static inline u8 Recv8()
+{
+	RXLED1;					// light the RX LED
+	RxLEDPulse = TX_RX_LED_PULSE_MS;
+	return UEDATX;
+}
+
+static inline void Send8(u8 d)
+{
+	TXLED1;					// light the TX LED
+	TxLEDPulse = TX_RX_LED_PULSE_MS;
+	UEDATX = d;
+}
+
+static inline void SetEP(u8 ep)
+{
+	UENUM = ep;
+}
+
+static inline u8 FifoByteCount()
+{
+	return UEBCLX;
+}
+
+static inline u8 ReceivedSetupInt()
+{
+	return UEINTX & (1<<RXSTPI);
+}
+
+static inline void ClearSetupInt()
+{
+	UEINTX = ~((1<<RXSTPI) | (1<<RXOUTI) | (1<<TXINI));
+}
+
+static inline void Stall()
+{
+	UECONX = (1<<STALLRQ) | (1<<EPEN);
+}
+
+static inline u8 ReadWriteAllowed()
+{
+	return UEINTX & (1<<RWAL);
+}
+
+static inline u8 Stalled()
+{
+	return UEINTX & (1<<STALLEDI);
+}
+
+static inline u8 FifoFree()
+{
+	return UEINTX & (1<<FIFOCON);
+}
+
+static inline void ReleaseRX()
+{
+	UEINTX = 0x6B;	// FIFOCON=0 NAKINI=1 RWAL=1 NAKOUTI=0 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=1
+}
+
+static inline void ReleaseTX()
+{
+	UEINTX = 0x3A;	// FIFOCON=0 NAKINI=0 RWAL=1 NAKOUTI=1 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=0
+}
+
+static inline u8 FrameNumber()
+{
+	return UDFNUML;
+}
+
+//==================================================================
+//==================================================================
+
+#define EP_SINGLE_64 0x32	// EP0
+#define EP_DOUBLE_64 0x36	// Other endpoints
+
+static void InitEP(u8 index, u8 type, u8 size)
+{
+	UENUM = index;
+	UECONX = 1;
+	UECFG0X = type;
+	UECFG1X = size;
+}
+
+//	API
+void USBInit(void)
+{
+	_timeout = 0;
+	_usbConfiguration = 0;
+	_ejected = 0;
+	
+	UHWCON = 0x01;						// power internal reg (don't need this?)
+	USBCON = (1<<USBE)|(1<<FRZCLK);		// clock frozen, usb enabled
+	PLLCSR = 0x12;						// Need 16 MHz xtal
+	while (!(PLLCSR & (1<<PLOCK)))		// wait for lock pll
+		;
+	USBCON = ((1<<USBE)|(1<<OTGPADE));	// start USB clock
+	UDCON = 0;							// enable attach resistor
+}
+
+u8 USBGetConfiguration(void)
+{
+	return _usbConfiguration;
+}
+
+u8 HasData(u8 ep)
+{
+	SetEP(ep);
+	return ReadWriteAllowed();	// count in fifo
+}
+
+int USBGetChar();
+void Recv(u8 ep, u8* dst, u8 len)
+{
+	SetEP(ep);
+	while (len--)
+	{
+		while (!ReadWriteAllowed())
+			;
+		*dst++ = Recv8();
+		if (!ReadWriteAllowed())	// release empty buffer
+			ReleaseRX();
+	}
+}
+
+//	Transmit a packet to endpoint
+void Transfer(u8 ep, const u8* data, int len)
+{
+	u8 zero = ep & TRANSFER_ZERO;
+	SetEP(ep & 7);
+	while (len--)
+	{
+		while (!ReadWriteAllowed())
+			;	// TODO Check for STALL etc
+
+		u8 d = (ep & TRANSFER_PGM) ? pgm_read_byte(data) : data[0];
+		data++;
+		if (zero)
+			d = 0;
+		Send8(d);
+
+		if (!ReadWriteAllowed())
+			ReleaseTX();
+	}
+	if (ep & TRANSFER_RELEASE)
+		ReleaseTX();
+}
+
+extern const u8 _initEndpoints[] PROGMEM;
+const u8 _initEndpoints[] = 
+{
+	0,
+
+#ifdef CDC_ENABLED
+	EP_TYPE_INTERRUPT_IN,		// CDC_ENDPOINT_ACM
+	EP_TYPE_BULK_OUT,			// CDC_ENDPOINT_OUT
+	EP_TYPE_BULK_IN,			// CDC_ENDPOINT_IN
+#endif
+
+	EP_TYPE_INTERRUPT_IN,		// HID_ENDPOINT_INT
+};
+
+static void InitEndpoints()
+{
+	for (u8 i = 1; i < sizeof(_initEndpoints); i++)
+	{
+		UENUM = i;
+		UECONX = 1;
+		UECFG0X = pgm_read_byte(_initEndpoints+i);
+		UECFG1X = EP_DOUBLE_64;
+	}
+	UERST = 0x7E;	// And reset them
+	UERST = 0;
+}
+
+typedef struct
+{
+	u8 bmRequestType;
+	u8 bRequest;
+	u8 wValueL;
+	u8 wValueH;
+	u16 wIndex;
+	u16 wLength;
+} Setup;
+Setup _setup;
+
+//bool USBHook(Setup& setup)
+bool USBHook()
+{
+	Setup& setup = _setup;
+	u8 r = setup.bRequest;
+
+	//	CDC Requests
+	if (CDC_GET_LINE_CODING == r)
+	{
+		Send((const volatile u8*)&_usbLineInfo,7);
+	}
+
+	else if (CDC_SET_LINE_CODING ==  r)
+	{
+		WaitOUT();
+		Recv((volatile u8*)&_usbLineInfo,7);
+		ClearOUT();
+	}
+
+	else if (CDC_SET_CONTROL_LINE_STATE == r)
+	{
+		_usbLineInfo.lineState = setup.wValueL;
+	}
+
+	return true;
+}
+
+extern const u8 _rawHID[] PROGMEM;
+#define LSB(_x) ((_x) & 0xFF)
+#define MSB(_x) ((_x) >> 8)
+
+#define RAWHID_USAGE_PAGE	0xFFC0
+#define RAWHID_USAGE		0x0C00
+#define RAWHID_TX_SIZE 64
+#define RAWHID_RX_SIZE 64
+
+const u8 _rawHID[] =
+{
+	//	RAW HID
+	0x06, LSB(RAWHID_USAGE_PAGE), MSB(RAWHID_USAGE_PAGE),	// 30
+	0x0A, LSB(RAWHID_USAGE), MSB(RAWHID_USAGE),
+
+	0xA1, 0x01,				// Collection 0x01
+    0x85, 0x03,             // REPORT_ID (3)
+	0x75, 0x08,				// report size = 8 bits
+	0x15, 0x00,				// logical minimum = 0
+	0x26, 0xFF, 0x00,		// logical maximum = 255
+
+	0x95, 64,				// report count TX
+	0x09, 0x01,				// usage
+	0x81, 0x02,				// Input (array)
+
+	0x95, 64,				// report count RX
+	0x09, 0x02,				// usage
+	0x91, 0x02,				// Output (array)
+	0xC0					// end collection
+};
+
+u8 _cdcComposite = 0;
+
+bool SendDescriptor()
+{
+	Setup& setup = _setup;
+	u8 desc_length = 0;
+	const u8* desc_addr = 0;
+
+	u8 t = setup.wValueH;
+	if (0x22 == t)
+	{
+		desc_addr = _rawHID;
+		desc_length = sizeof(desc_length);
+	} else if (USB_DEVICE_DESCRIPTOR_TYPE == t)
+	{
+		if (setup.wLength == 8)
+			_cdcComposite = 1;
+		desc_addr = _cdcComposite ?  (const u8*)&USB_DeviceDescriptorA : (const u8*)&USB_DeviceDescriptor;
+	}
+	else if (USB_CONFIGURATION_DESCRIPTOR_TYPE == t)
+	{
+		desc_addr = (const u8*)&USB_ConfigDescriptor;
+		desc_length = sizeof(USB_ConfigDescriptor);
+	}
+	else if (USB_STRING_DESCRIPTOR_TYPE == t)
+	{
+		if (setup.wValueL == 0)
+			desc_addr = (const u8*)&STRING_LANGUAGE;
+		else if (setup.wValueL == IPRODUCT) 
+			desc_addr = (const u8*)&STRING_IPRODUCT;
+		else if (setup.wValueL == IMANUFACTURER)
+			desc_addr = (const u8*)&STRING_IMANUFACTURER;
+		else
+			return false;
+	} else 
+		return false;
+
+	if (desc_length == 0)
+		desc_length = pgm_read_byte(desc_addr);
+	if ((u8)setup.wLength < desc_length)		// bit of a cheat limiting to 255 bytes TODO (saved 8 bytes)
+		desc_length = (u8)setup.wLength;
+
+	//	Send descriptor
+	//	EP0 is 64 bytes long
+	//	RWAL and FIFOCON don't work on EP0
+	u8 n = 0;
+	do
+	{
+		if (!WaitForINOrOUT())
+			return false;
+		Send8(pgm_read_byte(&desc_addr[n++]));
+		u8 clr = n & 0x3F;
+		if (!clr)
+			ClearIN();	// Fifo is full, release this packet
+	} while (n < desc_length);
+	return true;
+}
+
+void USBSetupInterrupt()
+{
+    SetEP(0);
+	if (!ReceivedSetupInt())
+		return;
+
+	Setup& setup = _setup;	// global saves ~30 bytes
+	Recv((u8*)&setup,8);
+	ClearSetupInt();
+
+	if (setup.bmRequestType & DEVICETOHOST)
+		WaitIN();
+	else
+		ClearIN();
+
+    bool ok = true;
+	u8 r = setup.bRequest;
+	if (SET_ADDRESS == r)
+	{
+		WaitIN();
+		UDADDR = setup.wValueL | (1<<ADDEN);
+	}
+	else if (SET_CONFIGURATION == r)
+	{
+		_usbConfiguration = setup.wValueL;
+		InitEndpoints();
+	}
+	else if (GET_CONFIGURATION == r)
+	{
+		Send8(_usbConfiguration);
+	}
+	else if (GET_STATUS == r)
+	{
+		Send8(0);		// All good as far as I know
+	}
+	else if (GET_DESCRIPTOR == r)
+	{
+		ok = SendDescriptor();
+	}
+	else
+	{
+		ok = USBHook();
+	}
+
+	if (ok)
+		ClearIN();
+	else
+		Stall();
+}
+
+void USBGeneralInterrupt()
+{
+	u8 udint = UDINT;
+	UDINT = 0;
+
+	//	End of Reset
+	if (udint & (1<<EORSTI))
+	{
+		InitEP(0,EP_TYPE_CONTROL,EP_SINGLE_64);	// init ep0
+		_usbConfiguration = 0;			// not configured yet
+	}
+
+	//	Start of Frame - happens every millisecond so we use it for TX and RX LED one-shot timing, too
+	if (udint & (1<<SOFI))
+	{
+		// check whether the one-shot period has elapsed.  if so, turn off the LED
+		if (TxLEDPulse && !(--TxLEDPulse))
+			TXLED0;
+		if (RxLEDPulse && !(--RxLEDPulse))
+			RXLED0;
+		
+		if (!_ejected)
+			_timeout = 0;
+	}
+}
+
+void LEDPulse();
+int USBGetChar()
+{
+	for(;;)
+	{
+		USBSetupInterrupt();
+		USBGeneralInterrupt();
+
+		//	Read a char
+		if (HasData(CDC_RX))
+		{
+			u8 c = Recv8();
+			if (!ReadWriteAllowed())
+				ReleaseRX();
+			return c;
+		} 
+
+		if (!--_timeout) {
+			Reboot();	// USB not connected, run firmware
+		}
+		
+		_delay_us(100);	// stretch out the bootloader period to about 5 seconds after enumeration
+		LEDPulse();
+	}
+	return -1;
+}