fix USB descriptors
[proxmark3-svn] / common / usb_cdc.c
1 /*
2 * at91sam7s USB CDC device implementation
3 *
4 * Copyright (c) 2012, Roel Verdult
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the name of the copyright holders nor the
15 * names of its contributors may be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
19 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
22 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 *
29 * based on the "Basic USB Example" from ATMEL (doc6123.pdf)
30 *
31 * @file usb_cdc.c
32 * @brief
33 */
34
35 #include "usb_cdc.h"
36 #include "at91sam7s512.h"
37 #include "config_gpio.h"
38
39 #define AT91C_EP_IN_SIZE 0x40
40 #define AT91C_EP_OUT 1
41 #define AT91C_EP_OUT_SIZE 0x40
42 #define AT91C_EP_IN 2
43
44 static const char devDescriptor[] = {
45 /* Device descriptor */
46 0x12, // bLength
47 0x01, // bDescriptorType
48 0x00,0x02, // Complies with USB Spec. Release (0200h = release 2.0)
49 0x02, // bDeviceClass: CDC class code
50 0x00, // bDeviceSubclass: CDC class sub code
51 0x00, // bDeviceProtocol: CDC Device protocol
52 0x08, // bMaxPacketSize0
53 0xc4,0x9a, // Vendor ID (0x9ac4 = J. Westhues)
54 0x8f,0x4b, // Product ID (0x4b8f = Proxmark-3 RFID Instrument)
55 0x01,0x00, // Device release number (0001)
56 0x01, // iManufacturer
57 0x02, // iProduct
58 0x00, // iSerialNumber
59 0x01 // bNumConfigs
60 };
61
62 static const char cfgDescriptor[] = {
63 /* ============== CONFIGURATION 1 =========== */
64 /* Configuration 1 descriptor */
65 0x09, // CbLength
66 0x02, // CbDescriptorType
67 0x43, // CwTotalLength 2 EP + Control
68 0x00,
69 0x02, // CbNumInterfaces
70 0x01, // CbConfigurationValue
71 0x00, // CiConfiguration
72 0xC0, // CbmAttributes 0xA0
73 0xFA, // CMaxPower
74
75 /* Communication Class Interface Descriptor Requirement */
76 0x09, // bLength
77 0x04, // bDescriptorType
78 0x00, // bInterfaceNumber
79 0x00, // bAlternateSetting
80 0x01, // bNumEndpoints
81 0x02, // bInterfaceClass
82 0x02, // bInterfaceSubclass
83 0x01, // bInterfaceProtocol
84 0x00, // iInterface
85
86 /* Header Functional Descriptor */
87 0x05, // bFunction Length
88 0x24, // bDescriptor type: CS_INTERFACE
89 0x00, // bDescriptor subtype: Header Func Desc
90 0x10, // bcdCDC:1.1
91 0x01,
92
93 /* ACM Functional Descriptor */
94 0x04, // bFunctionLength
95 0x24, // bDescriptor Type: CS_INTERFACE
96 0x02, // bDescriptor Subtype: ACM Func Desc
97 0x02, // bmCapabilities
98
99 /* Union Functional Descriptor */
100 0x05, // bFunctionLength
101 0x24, // bDescriptorType: CS_INTERFACE
102 0x06, // bDescriptor Subtype: Union Func Desc
103 0x00, // bMasterInterface: Communication Class Interface
104 0x01, // bSlaveInterface0: Data Class Interface
105
106 /* Call Management Functional Descriptor */
107 0x05, // bFunctionLength
108 0x24, // bDescriptor Type: CS_INTERFACE
109 0x01, // bDescriptor Subtype: Call Management Func Desc
110 0x00, // bmCapabilities: D1 + D0
111 0x01, // bDataInterface: Data Class Interface 1
112
113 /* Endpoint 1 descriptor */
114 0x07, // bLength
115 0x05, // bDescriptorType
116 0x83, // bEndpointAddress, Endpoint 03 - IN
117 0x03, // bmAttributes INT
118 0x08, // wMaxPacketSize
119 0x00,
120 0xFF, // bInterval
121
122 /* Data Class Interface Descriptor Requirement */
123 0x09, // bLength
124 0x04, // bDescriptorType
125 0x01, // bInterfaceNumber
126 0x00, // bAlternateSetting
127 0x02, // bNumEndpoints
128 0x0A, // bInterfaceClass
129 0x00, // bInterfaceSubclass
130 0x00, // bInterfaceProtocol
131 0x00, // iInterface
132
133 /* First alternate setting */
134 /* Endpoint 1 descriptor */
135 0x07, // bLength
136 0x05, // bDescriptorType
137 0x01, // bEndpointAddress, Endpoint 01 - OUT
138 0x02, // bmAttributes BULK
139 AT91C_EP_OUT_SIZE, // wMaxPacketSize
140 0x00,
141 0x00, // bInterval
142
143 /* Endpoint 2 descriptor */
144 0x07, // bLength
145 0x05, // bDescriptorType
146 0x82, // bEndpointAddress, Endpoint 02 - IN
147 0x02, // bmAttributes BULK
148 AT91C_EP_IN_SIZE, // wMaxPacketSize
149 0x00,
150 0x00 // bInterval
151 };
152
153 static const char StrDescLanguageCodes[] = {
154 4, // Length
155 0x03, // Type is string
156 0x09, 0x04 // supported language Code 0 = 0x0409 (English)
157 };
158
159 static const char StrDescManufacturer[] = {
160 26, // Length
161 0x03, // Type is string
162 'p', 0x00,
163 'r', 0x00,
164 'o', 0x00,
165 'x', 0x00,
166 'm', 0x00,
167 'a', 0x00,
168 'r', 0x00,
169 'k', 0x00,
170 '.', 0x00,
171 'o', 0x00,
172 'r', 0x00,
173 'g', 0x00
174 };
175
176 static const char StrDescProduct[] = {
177 8, // Length
178 0x03, // Type is string
179 'P', 0x00,
180 'M', 0x00,
181 '3', 0x00
182 };
183
184 static const char* const pStrings[] =
185 {
186 StrDescLanguageCodes,
187 StrDescManufacturer,
188 StrDescProduct
189 };
190
191 const char* getStringDescriptor(uint8_t idx)
192 {
193 if(idx >= (sizeof(pStrings) / sizeof(pStrings[0]))) {
194 return(NULL);
195 } else {
196 return(pStrings[idx]);
197 }
198 }
199
200 /* USB standard request code */
201 #define STD_GET_STATUS_ZERO 0x0080
202 #define STD_GET_STATUS_INTERFACE 0x0081
203 #define STD_GET_STATUS_ENDPOINT 0x0082
204
205 #define STD_CLEAR_FEATURE_ZERO 0x0100
206 #define STD_CLEAR_FEATURE_INTERFACE 0x0101
207 #define STD_CLEAR_FEATURE_ENDPOINT 0x0102
208
209 #define STD_SET_FEATURE_ZERO 0x0300
210 #define STD_SET_FEATURE_INTERFACE 0x0301
211 #define STD_SET_FEATURE_ENDPOINT 0x0302
212
213 #define STD_SET_ADDRESS 0x0500
214 #define STD_GET_DESCRIPTOR 0x0680
215 #define STD_SET_DESCRIPTOR 0x0700
216 #define STD_GET_CONFIGURATION 0x0880
217 #define STD_SET_CONFIGURATION 0x0900
218 #define STD_GET_INTERFACE 0x0A81
219 #define STD_SET_INTERFACE 0x0B01
220 #define STD_SYNCH_FRAME 0x0C82
221
222 /* CDC Class Specific Request Code */
223 #define GET_LINE_CODING 0x21A1
224 #define SET_LINE_CODING 0x2021
225 #define SET_CONTROL_LINE_STATE 0x2221
226
227 typedef struct {
228 unsigned int dwDTERRate;
229 char bCharFormat;
230 char bParityType;
231 char bDataBits;
232 } AT91S_CDC_LINE_CODING, *AT91PS_CDC_LINE_CODING;
233
234 AT91S_CDC_LINE_CODING line = {
235 115200, // baudrate
236 0, // 1 Stop Bit
237 0, // None Parity
238 8}; // 8 Data bits
239
240 void AT91F_CDC_Enumerate();
241
242 AT91PS_UDP pUdp = AT91C_BASE_UDP;
243 byte_t btConfiguration = 0;
244 byte_t btConnection = 0;
245 byte_t btReceiveBank = AT91C_UDP_RX_DATA_BK0;
246
247 //*----------------------------------------------------------------------------
248 //* \fn usb_disable
249 //* \brief This function deactivates the USB device
250 //*----------------------------------------------------------------------------
251 void usb_disable() {
252 // Disconnect the USB device
253 AT91C_BASE_PIOA->PIO_ODR = GPIO_USB_PU;
254
255 // Clear all lingering interrupts
256 if(pUdp->UDP_ISR & AT91C_UDP_ENDBUSRES) {
257 pUdp->UDP_ICR = AT91C_UDP_ENDBUSRES;
258 }
259 }
260
261 //*----------------------------------------------------------------------------
262 //* \fn usb_enable
263 //* \brief This function Activates the USB device
264 //*----------------------------------------------------------------------------
265 void usb_enable() {
266 // Set the PLL USB Divider
267 AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1 ;
268
269 // Specific Chip USB Initialisation
270 // Enables the 48MHz USB clock UDPCK and System Peripheral USB Clock
271 AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_UDP;
272 AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_UDP);
273
274 // Enable UDP PullUp (USB_DP_PUP) : enable & Clear of the corresponding PIO
275 // Set in PIO mode and Configure in Output
276 AT91C_BASE_PIOA->PIO_PER = GPIO_USB_PU; // Set in PIO mode
277 AT91C_BASE_PIOA->PIO_OER = GPIO_USB_PU; // Configure as Output
278
279 // Clear for set the Pullup resistor
280 AT91C_BASE_PIOA->PIO_CODR = GPIO_USB_PU;
281
282 // Disconnect and reconnect USB controller for 100ms
283 usb_disable();
284
285 // Wait for a short while
286 for (volatile size_t i=0; i<0x100000; i++);
287
288 // Reconnect USB reconnect
289 AT91C_BASE_PIOA->PIO_SODR = GPIO_USB_PU;
290 AT91C_BASE_PIOA->PIO_OER = GPIO_USB_PU;
291 }
292
293 //*----------------------------------------------------------------------------
294 //* \fn usb_check
295 //* \brief Test if the device is configured and handle enumeration
296 //*----------------------------------------------------------------------------
297 bool usb_check() {
298 AT91_REG isr = pUdp->UDP_ISR;
299
300 if (isr & AT91C_UDP_ENDBUSRES) {
301 pUdp->UDP_ICR = AT91C_UDP_ENDBUSRES;
302 // reset all endpoints
303 pUdp->UDP_RSTEP = (unsigned int)-1;
304 pUdp->UDP_RSTEP = 0;
305 // Enable the function
306 pUdp->UDP_FADDR = AT91C_UDP_FEN;
307 // Configure endpoint 0
308 pUdp->UDP_CSR[0] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL);
309 }
310 else if (isr & AT91C_UDP_EPINT0) {
311 pUdp->UDP_ICR = AT91C_UDP_EPINT0;
312 AT91F_CDC_Enumerate();
313 }
314 return (btConfiguration) ? true : false;
315 }
316
317
318 bool usb_poll()
319 {
320 if (!usb_check()) return false;
321 return (pUdp->UDP_CSR[AT91C_EP_OUT] & btReceiveBank);
322 }
323
324 /**
325 In github PR #129, some users appears to get a false positive from
326 usb_poll, which returns true, but the usb_read operation
327 still returns 0.
328 This check is basically the same as above, but also checks
329 that the length available to read is non-zero, thus hopefully fixes the
330 bug.
331 **/
332 bool usb_poll_validate_length()
333 {
334
335 if (!usb_check()) return false;
336 if (!(pUdp->UDP_CSR[AT91C_EP_OUT] & btReceiveBank)) return false;
337 return (pUdp->UDP_CSR[AT91C_EP_OUT] >> 16) > 0;
338 }
339
340 //*----------------------------------------------------------------------------
341 //* \fn usb_read
342 //* \brief Read available data from Endpoint OUT
343 //*----------------------------------------------------------------------------
344 uint32_t usb_read(byte_t* data, size_t len) {
345 byte_t bank = btReceiveBank;
346 uint32_t packetSize, nbBytesRcv = 0;
347 uint32_t time_out = 0;
348
349 while (len) {
350 if (!usb_check()) break;
351
352 if ( pUdp->UDP_CSR[AT91C_EP_OUT] & bank ) {
353 packetSize = MIN(pUdp->UDP_CSR[AT91C_EP_OUT] >> 16, len);
354 len -= packetSize;
355 while(packetSize--)
356 data[nbBytesRcv++] = pUdp->UDP_FDR[AT91C_EP_OUT];
357 pUdp->UDP_CSR[AT91C_EP_OUT] &= ~(bank);
358 if (bank == AT91C_UDP_RX_DATA_BK0) {
359 bank = AT91C_UDP_RX_DATA_BK1;
360 } else {
361 bank = AT91C_UDP_RX_DATA_BK0;
362 }
363 }
364 if (time_out++ == 0x1fff) break;
365 }
366
367 btReceiveBank = bank;
368 return nbBytesRcv;
369 }
370
371 //*----------------------------------------------------------------------------
372 //* \fn usb_write
373 //* \brief Send through endpoint 2
374 //*----------------------------------------------------------------------------
375 uint32_t usb_write(const byte_t* data, const size_t len) {
376 size_t length = len;
377 uint32_t cpt = 0;
378
379 if (!length) return 0;
380 if (!usb_check()) return 0;
381
382 // Send the first packet
383 cpt = MIN(length, AT91C_EP_IN_SIZE-1);
384 length -= cpt;
385 while (cpt--) pUdp->UDP_FDR[AT91C_EP_IN] = *data++;
386 pUdp->UDP_CSR[AT91C_EP_IN] |= AT91C_UDP_TXPKTRDY;
387
388 while (length) {
389 // Fill the second bank
390 cpt = MIN(length, AT91C_EP_IN_SIZE-1);
391 length -= cpt;
392 while (cpt--) pUdp->UDP_FDR[AT91C_EP_IN] = *data++;
393 // Wait for the first bank to be sent
394 while (!(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP)) {
395 if (!usb_check()) return length;
396 }
397 pUdp->UDP_CSR[AT91C_EP_IN] &= ~(AT91C_UDP_TXCOMP);
398 while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP);
399 pUdp->UDP_CSR[AT91C_EP_IN] |= AT91C_UDP_TXPKTRDY;
400 }
401
402 // Wait for the end of transfer
403 while (!(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP)) {
404 if (!usb_check()) return length;
405 }
406
407 pUdp->UDP_CSR[AT91C_EP_IN] &= ~(AT91C_UDP_TXCOMP);
408 while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP);
409
410 return length;
411 }
412
413 //*----------------------------------------------------------------------------
414 //* \fn AT91F_USB_SendData
415 //* \brief Send Data through the control endpoint
416 //*----------------------------------------------------------------------------
417 unsigned int csrTab[100] = {0x00};
418 unsigned char csrIdx = 0;
419
420 static void AT91F_USB_SendData(AT91PS_UDP pUdp, const char *pData, uint32_t length) {
421 uint32_t cpt = 0;
422 AT91_REG csr;
423
424 do {
425 cpt = MIN(length, 8);
426 length -= cpt;
427
428 while (cpt--)
429 pUdp->UDP_FDR[0] = *pData++;
430
431 if (pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
432 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_TXCOMP);
433 while (pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP);
434 }
435
436 pUdp->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY;
437 do {
438 csr = pUdp->UDP_CSR[0];
439
440 // Data IN stage has been stopped by a status OUT
441 if (csr & AT91C_UDP_RX_DATA_BK0) {
442 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_RX_DATA_BK0);
443 return;
444 }
445 } while ( !(csr & AT91C_UDP_TXCOMP) );
446
447 } while (length);
448
449 if (pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
450 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_TXCOMP);
451 while (pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP);
452 }
453 }
454
455 //*----------------------------------------------------------------------------
456 //* \fn AT91F_USB_SendZlp
457 //* \brief Send zero length packet through the control endpoint
458 //*----------------------------------------------------------------------------
459 void AT91F_USB_SendZlp(AT91PS_UDP pUdp) {
460 pUdp->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY;
461 while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP) );
462 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_TXCOMP);
463 while (pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP);
464 }
465
466 //*----------------------------------------------------------------------------
467 //* \fn AT91F_USB_SendStall
468 //* \brief Stall the control endpoint
469 //*----------------------------------------------------------------------------
470 void AT91F_USB_SendStall(AT91PS_UDP pUdp) {
471 pUdp->UDP_CSR[0] |= AT91C_UDP_FORCESTALL;
472 while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_ISOERROR) );
473 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_FORCESTALL | AT91C_UDP_ISOERROR);
474 while (pUdp->UDP_CSR[0] & (AT91C_UDP_FORCESTALL | AT91C_UDP_ISOERROR));
475 }
476
477 //*----------------------------------------------------------------------------
478 //* \fn AT91F_CDC_Enumerate
479 //* \brief This function is a callback invoked when a SETUP packet is received
480 //*----------------------------------------------------------------------------
481 void AT91F_CDC_Enumerate() {
482 byte_t bmRequestType, bRequest;
483 uint16_t wValue, wIndex, wLength, wStatus;
484
485 if ( !(pUdp->UDP_CSR[0] & AT91C_UDP_RXSETUP) )
486 return;
487
488 bmRequestType = pUdp->UDP_FDR[0];
489 bRequest = pUdp->UDP_FDR[0];
490 wValue = (pUdp->UDP_FDR[0] & 0xFF);
491 wValue |= (pUdp->UDP_FDR[0] << 8);
492 wIndex = (pUdp->UDP_FDR[0] & 0xFF);
493 wIndex |= (pUdp->UDP_FDR[0] << 8);
494 wLength = (pUdp->UDP_FDR[0] & 0xFF);
495 wLength |= (pUdp->UDP_FDR[0] << 8);
496
497 if (bmRequestType & 0x80) {
498 pUdp->UDP_CSR[0] |= AT91C_UDP_DIR;
499 while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_DIR) );
500 }
501 pUdp->UDP_CSR[0] &= ~AT91C_UDP_RXSETUP;
502 while ( (pUdp->UDP_CSR[0] & AT91C_UDP_RXSETUP) );
503
504 // Handle supported standard device request Cf Table 9-3 in USB specification Rev 1.1
505 switch ((bRequest << 8) | bmRequestType) {
506 case STD_GET_DESCRIPTOR:
507 if (wValue == 0x100) // Return Device Descriptor
508 AT91F_USB_SendData(pUdp, devDescriptor, MIN(sizeof(devDescriptor), wLength));
509 else if (wValue == 0x200) // Return Configuration Descriptor
510 AT91F_USB_SendData(pUdp, cfgDescriptor, MIN(sizeof(cfgDescriptor), wLength));
511 else if ((wValue & 0xF00) == 0x300) { // Return String Descriptor
512 const char *strDescriptor = getStringDescriptor(wValue & 0xff);
513 if (strDescriptor != NULL) {
514 AT91F_USB_SendData(pUdp, strDescriptor, MIN(strDescriptor[0], wLength));
515 } else {
516 AT91F_USB_SendStall(pUdp);
517 }
518 }
519 else
520 AT91F_USB_SendStall(pUdp);
521 break;
522 case STD_SET_ADDRESS:
523 AT91F_USB_SendZlp(pUdp);
524 pUdp->UDP_FADDR = (AT91C_UDP_FEN | wValue);
525 pUdp->UDP_GLBSTATE = (wValue) ? AT91C_UDP_FADDEN : 0;
526 break;
527 case STD_SET_CONFIGURATION:
528 btConfiguration = wValue;
529 AT91F_USB_SendZlp(pUdp);
530 pUdp->UDP_GLBSTATE = (wValue) ? AT91C_UDP_CONFG : AT91C_UDP_FADDEN;
531 pUdp->UDP_CSR[1] = (wValue) ? (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_OUT) : 0;
532 pUdp->UDP_CSR[2] = (wValue) ? (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_IN) : 0;
533 pUdp->UDP_CSR[3] = (wValue) ? (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_INT_IN) : 0;
534 break;
535 case STD_GET_CONFIGURATION:
536 AT91F_USB_SendData(pUdp, (char *) &(btConfiguration), sizeof(btConfiguration));
537 break;
538 case STD_GET_STATUS_ZERO:
539 wStatus = 0;
540 AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus));
541 break;
542 case STD_GET_STATUS_INTERFACE:
543 wStatus = 0;
544 AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus));
545 break;
546 case STD_GET_STATUS_ENDPOINT:
547 wStatus = 0;
548 wIndex &= 0x0F;
549 if ((pUdp->UDP_GLBSTATE & AT91C_UDP_CONFG) && (wIndex <= 3)) {
550 wStatus = (pUdp->UDP_CSR[wIndex] & AT91C_UDP_EPEDS) ? 0 : 1;
551 AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus));
552 }
553 else if ((pUdp->UDP_GLBSTATE & AT91C_UDP_FADDEN) && (wIndex == 0)) {
554 wStatus = (pUdp->UDP_CSR[wIndex] & AT91C_UDP_EPEDS) ? 0 : 1;
555 AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus));
556 }
557 else
558 AT91F_USB_SendStall(pUdp);
559 break;
560 case STD_SET_FEATURE_ZERO:
561 AT91F_USB_SendStall(pUdp);
562 break;
563 case STD_SET_FEATURE_INTERFACE:
564 AT91F_USB_SendZlp(pUdp);
565 break;
566 case STD_SET_FEATURE_ENDPOINT:
567 wIndex &= 0x0F;
568 if ((wValue == 0) && wIndex && (wIndex <= 3)) {
569 pUdp->UDP_CSR[wIndex] = 0;
570 AT91F_USB_SendZlp(pUdp);
571 }
572 else
573 AT91F_USB_SendStall(pUdp);
574 break;
575 case STD_CLEAR_FEATURE_ZERO:
576 AT91F_USB_SendStall(pUdp);
577 break;
578 case STD_CLEAR_FEATURE_INTERFACE:
579 AT91F_USB_SendZlp(pUdp);
580 break;
581 case STD_CLEAR_FEATURE_ENDPOINT:
582 wIndex &= 0x0F;
583 if ((wValue == 0) && wIndex && (wIndex <= 3)) {
584 if (wIndex == 1)
585 pUdp->UDP_CSR[1] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_OUT);
586 else if (wIndex == 2)
587 pUdp->UDP_CSR[2] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_IN);
588 else if (wIndex == 3)
589 pUdp->UDP_CSR[3] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_ISO_IN);
590 AT91F_USB_SendZlp(pUdp);
591 }
592 else
593 AT91F_USB_SendStall(pUdp);
594 break;
595
596 // handle CDC class requests
597 case SET_LINE_CODING:
598 while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_RX_DATA_BK0) );
599 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_RX_DATA_BK0);
600 AT91F_USB_SendZlp(pUdp);
601 break;
602 case GET_LINE_CODING:
603 AT91F_USB_SendData(pUdp, (char *) &line, MIN(sizeof(line), wLength));
604 break;
605 case SET_CONTROL_LINE_STATE:
606 btConnection = wValue;
607 AT91F_USB_SendZlp(pUdp);
608 break;
609 default:
610 AT91F_USB_SendStall(pUdp);
611 break;
612 }
613 }
Impressum, Datenschutz