[proxmark3-svn] / common / usb.c

//-----------------------------------------------------------------------------
// My USB driver. This has to be common, because it exists in both the
// bootrom and the application.
// Jonathan Westhues, split Aug 14 2005
//-----------------------------------------------------------------------------
#include <proxmark3.h>

#define min(a, b) (((a) > (b)) ? (b) : (a))

#define USB_REPORT_PACKET_SIZE 64

typedef struct PACKED {
	BYTE	bmRequestType;
	BYTE	bRequest;
	WORD	wValue;
	WORD	wIndex;
	WORD	wLength;
} UsbSetupData;

#define USB_REQUEST_GET_STATUS					0
#define USB_REQUEST_CLEAR_FEATURE				1
#define USB_REQUEST_SET_FEATURE					3
#define USB_REQUEST_SET_ADDRESS					5
#define USB_REQUEST_GET_DESCRIPTOR				6
#define USB_REQUEST_SET_DESCRIPTOR				7
#define USB_REQUEST_GET_CONFIGURATION			8
#define USB_REQUEST_SET_CONFIGURATION			9
#define USB_REQUEST_GET_INTERFACE				10
#define USB_REQUEST_SET_INTERFACE				11
#define USB_REQUEST_SYNC_FRAME					12

#define USB_DESCRIPTOR_TYPE_DEVICE				1
#define USB_DESCRIPTOR_TYPE_CONFIGURATION		2
#define USB_DESCRIPTOR_TYPE_STRING				3
#define USB_DESCRIPTOR_TYPE_INTERFACE			4
#define USB_DESCRIPTOR_TYPE_ENDPOINT			5
#define USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER	6
#define USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONF	7
#define USB_DESCRIPTOR_TYPE_INTERFACE_POWER		8
#define USB_DESCRIPTOR_TYPE_HID					0x21
#define USB_DESCRIPTOR_TYPE_HID_REPORT			0x22

#define USB_DEVICE_CLASS_HID					0x03

static const BYTE HidReportDescriptor[] = {
	0x06,0xA0,0xFF,	// Usage Page (vendor defined) FFA0
	0x09,0x01,		// Usage (vendor defined)
	0xA1,0x01,	 	// Collection (Application)
	0x09,0x02,   	// Usage (vendor defined)
	0xA1,0x00,   	// Collection (Physical)
	0x06,0xA1,0xFF,	// Usage Page (vendor defined)

	//The,input report
	0x09,0x03,   	// usage - vendor defined
	0x09,0x04,   	// usage - vendor defined
	0x15,0x80,   	// Logical Minimum (-128)
	0x25,0x7F,   	// Logical Maximum (127)
	0x35,0x00,   	// Physical Minimum (0)
	0x45,0xFF,   	// Physical Maximum (255)
	0x75,0x08,   	// Report Size (8)  (bits)
	0x95,0x40,   	// Report Count (64)  (fields)
	0x81,0x02,   	// Input (Data,Variable,Absolute)

	//The,output report
	0x09,0x05,   	// usage - vendor defined
	0x09,0x06,   	// usage - vendor defined
	0x15,0x80,   	// Logical Minimum (-128)
	0x25,0x7F,   	// Logical Maximum (127)
	0x35,0x00,   	// Physical Minimum (0)
	0x45,0xFF,   	// Physical Maximum (255)
	0x75,0x08,   	// Report Size (8)  (bits)
	0x95,0x40,   	// Report Count (64)  (fields)
	0x91,0x02,   	// Output (Data,Variable,Absolute)

	0xC0,			// End Collection

	0xC0,			// End Collection
};

static const BYTE DeviceDescriptor[] = {
	0x12,			// Descriptor length (18 bytes)
	0x01,			// Descriptor type (Device)
	0x10,0x01,		// Complies with USB Spec. Release (0110h = release 1.10)
	0x00,			// Class code (0)
	0x00,			// Subclass code (0)
	0x00,			// Protocol (No specific protocol)
	0x08,			// Maximum packet size for Endpoint 0 (8 bytes)
	0xc4,0x9a,		// Vendor ID (random numbers)
	0x8f,0x4b,		// Product ID (random numbers)
	0x01,0x00,		// Device release number (0001)
	0x01,			// Manufacturer string descriptor index
	0x02,			// Product string descriptor index
	0x00,			// Serial Number string descriptor index (None)
	0x01,			// Number of possible configurations (1)
};

static const BYTE ConfigurationDescriptor[] = {
	0x09,			// Descriptor length (9 bytes)
	0x02,			// Descriptor type (Configuration)
	0x29,0x00,		// Total data length (41 bytes)
	0x01,			// Interface supported (1)
	0x01,			// Configuration value (1)
	0x00,			// Index of string descriptor (None)
	0x80,			// Configuration (Bus powered)
	250,			// Maximum power consumption (500mA)

	//interface
	0x09,			// Descriptor length (9 bytes)
	0x04,			// Descriptor type (Interface)
	0x00,			// Number of interface (0)
	0x00,			// Alternate setting (0)
	0x02,			// Number of interface endpoint (2)
	0x03,			// Class code (HID)
	0x00,			// Subclass code ()
	0x00,			// Protocol code ()
	0x00,			// Index of string()

	// class
	0x09,			// Descriptor length (9 bytes)
	0x21,			// Descriptor type (HID)
	0x00,0x01,		// HID class release number (1.00)
	0x00,			// Localized country code (None)
	0x01,			// # of HID class dscrptr to follow (1)
	0x22,			// Report descriptor type (HID)
	// Total length of report descriptor
	sizeof(HidReportDescriptor),0x00,

	// endpoint 1
	0x07,			// Descriptor length (7 bytes)
	0x05,			// Descriptor type (Endpoint)
	0x01,			// Encoded address (Respond to OUT)
	0x03,			// Endpoint attribute (Interrupt transfer)
	0x08,0x00,		// Maximum packet size (8 bytes)
	0x01,			// Polling interval (1 ms)

	// endpoint 2
	0x07,			// Descriptor length (7 bytes)
	0x05,			// Descriptor type (Endpoint)
	0x82,			// Encoded address (Respond to IN)
	0x03,			// Endpoint attribute (Interrupt transfer)
	0x08,0x00,		// Maximum packet size (8 bytes)
	0x01,			// Polling interval (1 ms)
};

static const BYTE StringDescriptor0[] = {
	0x04,			// Length
	0x03,			// Type is string
	0x09,			// English
	0x04,			//  US
};

static const BYTE StringDescriptor1[] = {
	24,				// Length
	0x03,			// Type is string
	'J', 0x00,
	'.', 0x00,
	' ', 0x00,
	'W', 0x00,
	'e', 0x00,
	's', 0x00,
	't', 0x00,
	'h', 0x00,
	'u', 0x00,
	'e', 0x00,
	's', 0x00,
};

static const BYTE StringDescriptor2[] = {
	54,				// Length
	0x03,			// Type is string
	'P', 0x00,
	'r', 0x00,
	'o', 0x00,
	'x', 0x00,
	'M', 0x00,
	'a', 0x00,
	'r', 0x00,
	'k', 0x00,
	'-', 0x00,
	'3', 0x00,
	' ', 0x00,
	'R', 0x00,
	'F', 0x00,
	'I', 0x00,
	'D', 0x00,
	' ', 0x00,
	'I', 0x00,
	'n', 0x00,
	's', 0x00,
	't', 0x00,
	'r', 0x00,
	'u', 0x00,
	'm', 0x00,
	'e', 0x00,
	'n', 0x00,
	't', 0x00,
};

static const BYTE * const StringDescriptors[] = {
	StringDescriptor0,
	StringDescriptor1,
	StringDescriptor2,
};


static BYTE UsbBuffer[64];
static int  UsbSoFarCount;

static BYTE CurrentConfiguration;

static void UsbSendEp0(const BYTE *data, int len)
{
	int thisTime, i;

	do {
		thisTime = min(len, 8);
		len -= thisTime;

		for(i = 0; i < thisTime; i++) {
			AT91C_BASE_UDP->UDP_FDR[0] = *data;
			data++;
		}

		if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
			AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;
			while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
				;
		}

		AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY;

		do {
			if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RX_DATA_BK0) {
				// This means that the host is trying to write to us, so
				// abandon our write to them.
				AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_RX_DATA_BK0;
				return;
			}
		} while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP));
	} while(len > 0);

	if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
		AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;
		while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
			;
	}
}

static void UsbSendZeroLength(void)
{
	AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY;

	while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP))
		;

	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;

	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
		;
}

static void UsbSendStall(void)
{
	AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_FORCESTALL;

	while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_STALLSENT))
		;

	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_STALLSENT;

	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_STALLSENT)
		;
}

static void HandleRxdSetupData(void)
{
	int i;
	UsbSetupData usd;

	for(i = 0; i < sizeof(usd); i++) {
		((BYTE *)&usd)[i] = AT91C_BASE_UDP->UDP_FDR[0];
	}

	if(usd.bmRequestType & 0x80) {
		AT91C_BASE_UDP->UDP_CSR[0] |= AT91C_UDP_DIR;
		while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_DIR))
			;
	}

	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_RXSETUP;
	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RXSETUP)
		;

	switch(usd.bRequest) {
		case USB_REQUEST_GET_DESCRIPTOR:
			if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_DEVICE) {
				UsbSendEp0((BYTE *)&DeviceDescriptor,
					min(sizeof(DeviceDescriptor), usd.wLength));
			} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_CONFIGURATION) {
				UsbSendEp0((BYTE *)&ConfigurationDescriptor,
					min(sizeof(ConfigurationDescriptor), usd.wLength));
			} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_STRING) {
				const BYTE *s = StringDescriptors[usd.wValue & 0xff];
				UsbSendEp0(s, min(s[0], usd.wLength));
			} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_HID_REPORT) {
				UsbSendEp0((BYTE *)&HidReportDescriptor,
					min(sizeof(HidReportDescriptor), usd.wLength));
			} else {
				*((DWORD *)0x00200000) = usd.wValue;
			}
			break;

		case USB_REQUEST_SET_ADDRESS:
			UsbSendZeroLength();
			AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN | usd.wValue ;
			if(usd.wValue != 0) {
				AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
			} else {
				AT91C_BASE_UDP->UDP_GLBSTATE = 0;
			}
			break;

		case USB_REQUEST_GET_CONFIGURATION:
			UsbSendEp0(&CurrentConfiguration, sizeof(CurrentConfiguration));
			break;

		case USB_REQUEST_GET_STATUS: {
			if(usd.bmRequestType & 0x80) {
				WORD w = 0;
				UsbSendEp0((BYTE *)&w, sizeof(w));
			}
			break;
		}
		case USB_REQUEST_SET_CONFIGURATION:
			CurrentConfiguration = usd.wValue;
			if(CurrentConfiguration) {
				AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_CONFG;
				AT91C_BASE_UDP->UDP_CSR[1] = AT91C_UDP_EPEDS |
					AT91C_UDP_EPTYPE_INT_OUT;
				AT91C_BASE_UDP->UDP_CSR[2] = AT91C_UDP_EPEDS |
					AT91C_UDP_EPTYPE_INT_IN;
			} else {
				AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
				AT91C_BASE_UDP->UDP_CSR[1] = 0;
				AT91C_BASE_UDP->UDP_CSR[2] = 0;
			}
			UsbSendZeroLength();
			break;

		case USB_REQUEST_GET_INTERFACE: {
			BYTE b = 0;
			UsbSendEp0(&b, sizeof(b));
			break;
		}

		case USB_REQUEST_SET_INTERFACE:
			UsbSendZeroLength();
			break;

		case USB_REQUEST_CLEAR_FEATURE:
		case USB_REQUEST_SET_FEATURE:
			UsbSendStall();
			break;
		case USB_REQUEST_SET_DESCRIPTOR:
		case USB_REQUEST_SYNC_FRAME:
		default:
			break;
	}
}

void UsbSendPacket(BYTE *packet, int len)
{
	int i, thisTime;

	while(len > 0) {
		thisTime = min(len, 8);

		for(i = 0; i < thisTime; i++) {
			AT91C_BASE_UDP->UDP_FDR[2] = packet[i];
		}
		AT91C_BASE_UDP->UDP_CSR[2] |= AT91C_UDP_TXPKTRDY;

		while(!(AT91C_BASE_UDP->UDP_CSR[2] & AT91C_UDP_TXCOMP))
			;
		AT91C_BASE_UDP->UDP_CSR[2] &= ~AT91C_UDP_TXCOMP;

		while(AT91C_BASE_UDP->UDP_CSR[2] & AT91C_UDP_TXCOMP)
			;

		len -= thisTime;
		packet += thisTime;
	}
}

static void HandleRxdData(void)
{
	int i, len;

	if(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK0) {
		len = UDP_CSR_BYTES_RECEIVED(AT91C_BASE_UDP->UDP_CSR[1]);

		for(i = 0; i < len; i++) {
			UsbBuffer[UsbSoFarCount] = AT91C_BASE_UDP->UDP_FDR[1];
			UsbSoFarCount++;
		}

		AT91C_BASE_UDP->UDP_CSR[1] &= ~AT91C_UDP_RX_DATA_BK0;
		while(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK0)
			;

		if(UsbSoFarCount >= 64) {
			UsbPacketReceived(UsbBuffer, UsbSoFarCount);
			UsbSoFarCount = 0;
		}
	}

	if(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK1) {
		len = UDP_CSR_BYTES_RECEIVED(AT91C_BASE_UDP->UDP_CSR[1]);

		for(i = 0; i < len; i++) {
			UsbBuffer[UsbSoFarCount] = AT91C_BASE_UDP->UDP_FDR[1];
			UsbSoFarCount++;
		}

		AT91C_BASE_UDP->UDP_CSR[1] &= ~AT91C_UDP_RX_DATA_BK1;
		while(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK1)
			;

		if(UsbSoFarCount >= 64) {
			UsbPacketReceived(UsbBuffer, UsbSoFarCount);
			UsbSoFarCount = 0;
		}
	}
}

void UsbStart(void)
{
	volatile int i;

	UsbSoFarCount = 0;

	USB_D_PLUS_PULLUP_OFF();

	for(i = 0; i < 1000000; i++)
		;

	USB_D_PLUS_PULLUP_ON();

	if(AT91C_BASE_UDP->UDP_ISR & AT91C_UDP_ENDBUSRES) {
		AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES;
	}
}

BOOL UsbConnected()
{
	if (AT91C_BASE_UDP->UDP_GLBSTATE & AT91C_UDP_CONFG)
		return TRUE;
	else
		return FALSE;
}

BOOL UsbPoll(BOOL blinkLeds)
{
	BOOL ret = FALSE;

	if(AT91C_BASE_UDP->UDP_ISR & AT91C_UDP_ENDBUSRES) {
		AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES;

		// following a reset we should be ready to receive a setup packet
		AT91C_BASE_UDP->UDP_RSTEP = 0xf;
		AT91C_BASE_UDP->UDP_RSTEP = 0;

		AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;

		AT91C_BASE_UDP->UDP_CSR[0] = AT91C_UDP_EPTYPE_CTRL | AT91C_UDP_EPEDS;

		CurrentConfiguration = 0;

		ret = TRUE;
	}

	if(AT91C_BASE_UDP->UDP_ISR & UDP_INTERRUPT_ENDPOINT(0)) {
		if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RXSETUP) {
			HandleRxdSetupData();
			ret = TRUE;
		}
	}

	if(AT91C_BASE_UDP->UDP_ISR & UDP_INTERRUPT_ENDPOINT(1)) {
		HandleRxdData();
		ret = TRUE;
	}

	return ret;
}
Commit	Line	Data
fdcc61d3	1	//-----------------------------------------------------------------------------
	2	// My USB driver. This has to be common, because it exists in both the
	3	// bootrom and the application.
	4	// Jonathan Westhues, split Aug 14 2005
	5	//-----------------------------------------------------------------------------
	6	#include <proxmark3.h>
	7
	8	#define min(a, b) (((a) > (b)) ? (b) : (a))
	9
	10	#define USB_REPORT_PACKET_SIZE 64
	11
	12	typedef struct PACKED {
	13	BYTE bmRequestType;
	14	BYTE bRequest;
	15	WORD wValue;
	16	WORD wIndex;
	17	WORD wLength;
	18	} UsbSetupData;
	19
	20	#define USB_REQUEST_GET_STATUS 0
	21	#define USB_REQUEST_CLEAR_FEATURE 1
	22	#define USB_REQUEST_SET_FEATURE 3
	23	#define USB_REQUEST_SET_ADDRESS 5
	24	#define USB_REQUEST_GET_DESCRIPTOR 6
	25	#define USB_REQUEST_SET_DESCRIPTOR 7
	26	#define USB_REQUEST_GET_CONFIGURATION 8
	27	#define USB_REQUEST_SET_CONFIGURATION 9
	28	#define USB_REQUEST_GET_INTERFACE 10
	29	#define USB_REQUEST_SET_INTERFACE 11
	30	#define USB_REQUEST_SYNC_FRAME 12
	31
	32	#define USB_DESCRIPTOR_TYPE_DEVICE 1
	33	#define USB_DESCRIPTOR_TYPE_CONFIGURATION 2
	34	#define USB_DESCRIPTOR_TYPE_STRING 3
	35	#define USB_DESCRIPTOR_TYPE_INTERFACE 4
	36	#define USB_DESCRIPTOR_TYPE_ENDPOINT 5
	37	#define USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER 6
	38	#define USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONF 7
	39	#define USB_DESCRIPTOR_TYPE_INTERFACE_POWER 8
	40	#define USB_DESCRIPTOR_TYPE_HID 0x21
	41	#define USB_DESCRIPTOR_TYPE_HID_REPORT 0x22
	42
	43	#define USB_DEVICE_CLASS_HID 0x03
	44
	45	static const BYTE HidReportDescriptor[] = {
	46	0x06,0xA0,0xFF, // Usage Page (vendor defined) FFA0
	47	0x09,0x01, // Usage (vendor defined)
	48	0xA1,0x01, // Collection (Application)
	49	0x09,0x02, // Usage (vendor defined)
	50	0xA1,0x00, // Collection (Physical)
	51	0x06,0xA1,0xFF, // Usage Page (vendor defined)
	52
	53	//The,input report
	54	0x09,0x03, // usage - vendor defined
	55	0x09,0x04, // usage - vendor defined
	56	0x15,0x80, // Logical Minimum (-128)
	57	0x25,0x7F, // Logical Maximum (127)
	58	0x35,0x00, // Physical Minimum (0)
	59	0x45,0xFF, // Physical Maximum (255)
	60	0x75,0x08, // Report Size (8) (bits)
	61	0x95,0x40, // Report Count (64) (fields)
	62	0x81,0x02, // Input (Data,Variable,Absolute)
	63
	64	//The,output report
65	0x09,0x05, // usage - vendor defined
66	0x09,0x06, // usage - vendor defined
67	0x15,0x80, // Logical Minimum (-128)
68	0x25,0x7F, // Logical Maximum (127)
69	0x35,0x00, // Physical Minimum (0)
70	0x45,0xFF, // Physical Maximum (255)
71	0x75,0x08, // Report Size (8) (bits)
72	0x95,0x40, // Report Count (64) (fields)
73	0x91,0x02, // Output (Data,Variable,Absolute)
74
75	0xC0, // End Collection
76
77	0xC0, // End Collection
78	};
79
80	static const BYTE DeviceDescriptor[] = {
81	0x12, // Descriptor length (18 bytes)
82	0x01, // Descriptor type (Device)
83	0x10,0x01, // Complies with USB Spec. Release (0110h = release 1.10)
84	0x00, // Class code (0)
85	0x00, // Subclass code (0)
86	0x00, // Protocol (No specific protocol)
87	0x08, // Maximum packet size for Endpoint 0 (8 bytes)
88	0xc4,0x9a, // Vendor ID (random numbers)
89	0x8f,0x4b, // Product ID (random numbers)
90	0x01,0x00, // Device release number (0001)
91	0x01, // Manufacturer string descriptor index
92	0x02, // Product string descriptor index
93	0x00, // Serial Number string descriptor index (None)
94	0x01, // Number of possible configurations (1)
95	};
96
97	static const BYTE ConfigurationDescriptor[] = {
98	0x09, // Descriptor length (9 bytes)
99	0x02, // Descriptor type (Configuration)
100	0x29,0x00, // Total data length (41 bytes)
101	0x01, // Interface supported (1)
102	0x01, // Configuration value (1)
103	0x00, // Index of string descriptor (None)
104	0x80, // Configuration (Bus powered)
105	250, // Maximum power consumption (500mA)
106
107	//interface
108	0x09, // Descriptor length (9 bytes)
109	0x04, // Descriptor type (Interface)
110	0x00, // Number of interface (0)
111	0x00, // Alternate setting (0)
112	0x02, // Number of interface endpoint (2)
113	0x03, // Class code (HID)
114	0x00, // Subclass code ()
115	0x00, // Protocol code ()
116	0x00, // Index of string()
117
118	// class
119	0x09, // Descriptor length (9 bytes)
120	0x21, // Descriptor type (HID)
121	0x00,0x01, // HID class release number (1.00)
122	0x00, // Localized country code (None)
123	0x01, // # of HID class dscrptr to follow (1)
124	0x22, // Report descriptor type (HID)
125	// Total length of report descriptor
126	sizeof(HidReportDescriptor),0x00,
127
128	// endpoint 1
129	0x07, // Descriptor length (7 bytes)
130	0x05, // Descriptor type (Endpoint)
131	0x01, // Encoded address (Respond to OUT)
132	0x03, // Endpoint attribute (Interrupt transfer)
133	0x08,0x00, // Maximum packet size (8 bytes)
134	0x01, // Polling interval (1 ms)
135
136	// endpoint 2
137	0x07, // Descriptor length (7 bytes)
138	0x05, // Descriptor type (Endpoint)
139	0x82, // Encoded address (Respond to IN)
140	0x03, // Endpoint attribute (Interrupt transfer)
141	0x08,0x00, // Maximum packet size (8 bytes)
142	0x01, // Polling interval (1 ms)
143	};
144
145	static const BYTE StringDescriptor0[] = {
146	0x04, // Length
147	0x03, // Type is string
148	0x09, // English
149	0x04, // US
150	};
151
152	static const BYTE StringDescriptor1[] = {
153	24, // Length
154	0x03, // Type is string
155	'J', 0x00,
156	'.', 0x00,
157	' ', 0x00,
158	'W', 0x00,
159	'e', 0x00,
160	's', 0x00,
161	't', 0x00,
162	'h', 0x00,
163	'u', 0x00,
164	'e', 0x00,
165	's', 0x00,
166	};
167
168	static const BYTE StringDescriptor2[] = {
169	54, // Length
170	0x03, // Type is string
171	'P', 0x00,
172	'r', 0x00,
173	'o', 0x00,
174	'x', 0x00,
175	'M', 0x00,
176	'a', 0x00,
177	'r', 0x00,
178	'k', 0x00,
179	'-', 0x00,
180	'3', 0x00,
181	' ', 0x00,
182	'R', 0x00,
183	'F', 0x00,
184	'I', 0x00,
185	'D', 0x00,
186	' ', 0x00,
187	'I', 0x00,
188	'n', 0x00,
189	's', 0x00,
190	't', 0x00,
191	'r', 0x00,
192	'u', 0x00,
193	'm', 0x00,
194	'e', 0x00,
195	'n', 0x00,
196	't', 0x00,
197	};
198
199	static const BYTE * const StringDescriptors[] = {
200	StringDescriptor0,
201	StringDescriptor1,
202	StringDescriptor2,
203	};
204
205
206	static BYTE UsbBuffer[64];
207	static int UsbSoFarCount;
208
209	static BYTE CurrentConfiguration;
210
211	static void UsbSendEp0(const BYTE *data, int len)
212	{
213	int thisTime, i;
214
215	do {
216	thisTime = min(len, 8);
217	len -= thisTime;
218
219	for(i = 0; i < thisTime; i++) {
220	AT91C_BASE_UDP->UDP_FDR[0] = *data;
221	data++;
222	}
223
224	if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
225	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;
226	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
227	;
228	}
229
230	AT91C_BASE_UDP->UDP_CSR[0] \|= AT91C_UDP_TXPKTRDY;
231
232	do {
233	if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RX_DATA_BK0) {
234	// This means that the host is trying to write to us, so
235	// abandon our write to them.
236	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_RX_DATA_BK0;
237	return;
238	}
239	} while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP));
240	} while(len > 0);
241
242	if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
243	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;
244	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
245	;
246	}
247	}
248
249	static void UsbSendZeroLength(void)
250	{
251	AT91C_BASE_UDP->UDP_CSR[0] \|= AT91C_UDP_TXPKTRDY;
252
253	while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP))
254	;
255
256	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_TXCOMP;
257
258	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_TXCOMP)
259	;
260	}
261
262	static void UsbSendStall(void)
263	{
264	AT91C_BASE_UDP->UDP_CSR[0] \|= AT91C_UDP_FORCESTALL;
265
266	while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_STALLSENT))
267	;
268
269	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_STALLSENT;
270
271	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_STALLSENT)
272	;
273	}
274
275	static void HandleRxdSetupData(void)
276	{
277	int i;
278	UsbSetupData usd;
279
280	for(i = 0; i < sizeof(usd); i++) {
281	((BYTE *)&usd)[i] = AT91C_BASE_UDP->UDP_FDR[0];
282	}
283
284	if(usd.bmRequestType & 0x80) {
285	AT91C_BASE_UDP->UDP_CSR[0] \|= AT91C_UDP_DIR;
286	while(!(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_DIR))
287	;
288	}
289
290	AT91C_BASE_UDP->UDP_CSR[0] &= ~AT91C_UDP_RXSETUP;
291	while(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RXSETUP)
292	;
293
294	switch(usd.bRequest) {
295	case USB_REQUEST_GET_DESCRIPTOR:
296	if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_DEVICE) {
297	UsbSendEp0((BYTE *)&DeviceDescriptor,
298	min(sizeof(DeviceDescriptor), usd.wLength));
299	} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_CONFIGURATION) {
300	UsbSendEp0((BYTE *)&ConfigurationDescriptor,
301	min(sizeof(ConfigurationDescriptor), usd.wLength));
302	} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_STRING) {
303	const BYTE *s = StringDescriptors[usd.wValue & 0xff];
304	UsbSendEp0(s, min(s[0], usd.wLength));
305	} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_HID_REPORT) {
306	UsbSendEp0((BYTE *)&HidReportDescriptor,
307	min(sizeof(HidReportDescriptor), usd.wLength));
308	} else {
309	((DWORD )0x00200000) = usd.wValue;
310	}
311	break;
312
313	case USB_REQUEST_SET_ADDRESS:
314	UsbSendZeroLength();
315	AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN \| usd.wValue ;
316	if(usd.wValue != 0) {
317	AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
318	} else {
319	AT91C_BASE_UDP->UDP_GLBSTATE = 0;
320	}
321	break;
322
323	case USB_REQUEST_GET_CONFIGURATION:
324	UsbSendEp0(&CurrentConfiguration, sizeof(CurrentConfiguration));
325	break;
326
327	case USB_REQUEST_GET_STATUS: {
328	if(usd.bmRequestType & 0x80) {
329	WORD w = 0;
330	UsbSendEp0((BYTE *)&w, sizeof(w));
331	}
332	break;
333	}
334	case USB_REQUEST_SET_CONFIGURATION:
335	CurrentConfiguration = usd.wValue;
336	if(CurrentConfiguration) {
337	AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_CONFG;
338	AT91C_BASE_UDP->UDP_CSR[1] = AT91C_UDP_EPEDS \|
339	AT91C_UDP_EPTYPE_INT_OUT;
340	AT91C_BASE_UDP->UDP_CSR[2] = AT91C_UDP_EPEDS \|
341	AT91C_UDP_EPTYPE_INT_IN;
342	} else {
343	AT91C_BASE_UDP->UDP_GLBSTATE = AT91C_UDP_FADDEN;
344	AT91C_BASE_UDP->UDP_CSR[1] = 0;
345	AT91C_BASE_UDP->UDP_CSR[2] = 0;
346	}
347	UsbSendZeroLength();
348	break;
349
350	case USB_REQUEST_GET_INTERFACE: {
351	BYTE b = 0;
352	UsbSendEp0(&b, sizeof(b));
353	break;
354	}
355
356	case USB_REQUEST_SET_INTERFACE:
357	UsbSendZeroLength();
358	break;
359
360	case USB_REQUEST_CLEAR_FEATURE:
361	case USB_REQUEST_SET_FEATURE:
362	UsbSendStall();
363	break;
364	case USB_REQUEST_SET_DESCRIPTOR:
365	case USB_REQUEST_SYNC_FRAME:
366	default:
367	break;
368	}
369	}
370
371	void UsbSendPacket(BYTE *packet, int len)
372	{
373	int i, thisTime;
374
375	while(len > 0) {
376	thisTime = min(len, 8);
377
378	for(i = 0; i < thisTime; i++) {
379	AT91C_BASE_UDP->UDP_FDR[2] = packet[i];
380	}
381	AT91C_BASE_UDP->UDP_CSR[2] \|= AT91C_UDP_TXPKTRDY;
382
383	while(!(AT91C_BASE_UDP->UDP_CSR[2] & AT91C_UDP_TXCOMP))
384	;
385	AT91C_BASE_UDP->UDP_CSR[2] &= ~AT91C_UDP_TXCOMP;
386
387	while(AT91C_BASE_UDP->UDP_CSR[2] & AT91C_UDP_TXCOMP)
388	;
389
390	len -= thisTime;
391	packet += thisTime;
392	}
393	}
394
395	static void HandleRxdData(void)
396	{
397	int i, len;
398
399	if(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK0) {
400	len = UDP_CSR_BYTES_RECEIVED(AT91C_BASE_UDP->UDP_CSR[1]);
401
402	for(i = 0; i < len; i++) {
403	UsbBuffer[UsbSoFarCount] = AT91C_BASE_UDP->UDP_FDR[1];
404	UsbSoFarCount++;
405	}
406
407	AT91C_BASE_UDP->UDP_CSR[1] &= ~AT91C_UDP_RX_DATA_BK0;
408	while(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK0)
409	;
410
411	if(UsbSoFarCount >= 64) {
412	UsbPacketReceived(UsbBuffer, UsbSoFarCount);
413	UsbSoFarCount = 0;
414	}
415	}
416
417	if(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK1) {
418	len = UDP_CSR_BYTES_RECEIVED(AT91C_BASE_UDP->UDP_CSR[1]);
419
420	for(i = 0; i < len; i++) {
421	UsbBuffer[UsbSoFarCount] = AT91C_BASE_UDP->UDP_FDR[1];
422	UsbSoFarCount++;
423	}
424
425	AT91C_BASE_UDP->UDP_CSR[1] &= ~AT91C_UDP_RX_DATA_BK1;
426	while(AT91C_BASE_UDP->UDP_CSR[1] & AT91C_UDP_RX_DATA_BK1)
427	;
428
429	if(UsbSoFarCount >= 64) {
430	UsbPacketReceived(UsbBuffer, UsbSoFarCount);
431	UsbSoFarCount = 0;
432	}
433	}
434	}
435
436	void UsbStart(void)
437	{
438	volatile int i;
439
440	UsbSoFarCount = 0;
441
442	USB_D_PLUS_PULLUP_OFF();
443
444	for(i = 0; i < 1000000; i++)
445	;
446
447	USB_D_PLUS_PULLUP_ON();
448
449	if(AT91C_BASE_UDP->UDP_ISR & AT91C_UDP_ENDBUSRES) {
450	AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES;
451	}
452	}
453
454	BOOL UsbConnected()
455	{
456	if (AT91C_BASE_UDP->UDP_GLBSTATE & AT91C_UDP_CONFG)
457	return TRUE;
458	else
459	return FALSE;
460	}
461
462	BOOL UsbPoll(BOOL blinkLeds)
463	{
464	BOOL ret = FALSE;
465
466	if(AT91C_BASE_UDP->UDP_ISR & AT91C_UDP_ENDBUSRES) {
467	AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES;
468
469	// following a reset we should be ready to receive a setup packet
470	AT91C_BASE_UDP->UDP_RSTEP = 0xf;
471	AT91C_BASE_UDP->UDP_RSTEP = 0;
472
473	AT91C_BASE_UDP->UDP_FADDR = AT91C_UDP_FEN;
474
475	AT91C_BASE_UDP->UDP_CSR[0] = AT91C_UDP_EPTYPE_CTRL \| AT91C_UDP_EPEDS;
476
477	CurrentConfiguration = 0;
478
479	ret = TRUE;
480	}
481
482	if(AT91C_BASE_UDP->UDP_ISR & UDP_INTERRUPT_ENDPOINT(0)) {
483	if(AT91C_BASE_UDP->UDP_CSR[0] & AT91C_UDP_RXSETUP) {
484	HandleRxdSetupData();
485	ret = TRUE;
486	}
487	}
488
489	if(AT91C_BASE_UDP->UDP_ISR & UDP_INTERRUPT_ENDPOINT(1)) {
490	HandleRxdData();
491	ret = TRUE;
492	}
493
494	return ret;
495	}