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