]> cvs.zerfleddert.de Git - proxmark3-svn/blob - armsrc/usb_cdc.c
projects / proxmark3-svn / blob
? search:


85c5d493bfb2bd63a0d6952a118f6b3612a39e6d
[proxmark3-svn] / armsrc / 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 "util.h"
37
38 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
39 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
40 #define AT91C_EP_IN_SIZE 0x40
41 #define AT91C_EP_OUT 1
42 #define AT91C_EP_OUT_SIZE 0x40
43 #define AT91C_EP_IN 2
44
45 const char devDescriptor[] = {
46 /* Device descriptor */
47 0x12, // bLength
48 0x01, // bDescriptorType
49 0x10,0x01, // Complies with USB Spec. Release (0110h = release 1.10)
50 0x02, // bDeviceClass: CDC class code
51 0x00, // bDeviceSubclass: CDC class sub code
52 0x00, // bDeviceProtocol: CDC Device protocol
53 0x08, // bMaxPacketSize0
54 0xeb,0x03, // Vendor ID (random numbers)
55 0x25,0x61, // Product ID (random numbers)
56 0x01,0x00, // Device release number (0001)
57 0x01, // iManufacturer // 0x01
58 0x00, // iProduct
59 0x00, // SerialNumber
60 0x01 // bNumConfigs
61 };
62
63 const char cfgDescriptor[] = {
64 /* ============== CONFIGURATION 1 =========== */
65 /* Configuration 1 descriptor */
66 0x09, // CbLength
67 0x02, // CbDescriptorType
68 0x43, // CwTotalLength 2 EP + Control
69 0x00,
70 0x02, // CbNumInterfaces
71 0x01, // CbConfigurationValue
72 0x00, // CiConfiguration
73 0xC0, // CbmAttributes 0xA0
74 0x00, // CMaxPower
75
76 /* Communication Class Interface Descriptor Requirement */
77 0x09, // bLength
78 0x04, // bDescriptorType
79 0x00, // bInterfaceNumber
80 0x00, // bAlternateSetting
81 0x01, // bNumEndpoints
82 0x02, // bInterfaceClass
83 0x02, // bInterfaceSubclass
84 0x00, // bInterfaceProtocol
85 0x00, // iInterface
86
87 /* Header Functional Descriptor */
88 0x05, // bFunction Length
89 0x24, // bDescriptor type: CS_INTERFACE
90 0x00, // bDescriptor subtype: Header Func Desc
91 0x10, // bcdCDC:1.1
92 0x01,
93
94 /* ACM Functional Descriptor */
95 0x04, // bFunctionLength
96 0x24, // bDescriptor Type: CS_INTERFACE
97 0x02, // bDescriptor Subtype: ACM Func Desc
98 0x00, // bmCapabilities
99
100 /* Union Functional Descriptor */
101 0x05, // bFunctionLength
102 0x24, // bDescriptorType: CS_INTERFACE
103 0x06, // bDescriptor Subtype: Union Func Desc
104 0x00, // bMasterInterface: Communication Class Interface
105 0x01, // bSlaveInterface0: Data Class Interface
106
107 /* Call Management Functional Descriptor */
108 0x05, // bFunctionLength
109 0x24, // bDescriptor Type: CS_INTERFACE
110 0x01, // bDescriptor Subtype: Call Management Func Desc
111 0x00, // bmCapabilities: D1 + D0
112 0x01, // bDataInterface: Data Class Interface 1
113
114 /* Endpoint 1 descriptor */
115 0x07, // bLength
116 0x05, // bDescriptorType
117 0x83, // bEndpointAddress, Endpoint 03 - IN
118 0x03, // bmAttributes INT
119 0x08, // wMaxPacketSize
120 0x00,
121 0xFF, // bInterval
122
123 /* Data Class Interface Descriptor Requirement */
124 0x09, // bLength
125 0x04, // bDescriptorType
126 0x01, // bInterfaceNumber
127 0x00, // bAlternateSetting
128 0x02, // bNumEndpoints
129 0x0A, // bInterfaceClass
130 0x00, // bInterfaceSubclass
131 0x00, // bInterfaceProtocol
132 0x00, // iInterface
133
134 /* First alternate setting */
135 /* Endpoint 1 descriptor */
136 0x07, // bLength
137 0x05, // bDescriptorType
138 0x01, // bEndpointAddress, Endpoint 01 - OUT
139 0x02, // bmAttributes BULK
140 AT91C_EP_OUT_SIZE, // wMaxPacketSize
141 0x00,
142 0x00, // bInterval
143
144 /* Endpoint 2 descriptor */
145 0x07, // bLength
146 0x05, // bDescriptorType
147 0x82, // bEndpointAddress, Endpoint 02 - IN
148 0x02, // bmAttributes BULK
149 AT91C_EP_IN_SIZE, // wMaxPacketSize
150 0x00,
151 0x00 // bInterval
152 };
153
154 const char strDescriptor[] = {
155 26, // Length
156 0x03, // Type is string
157 'p', 0x00,
158 'r', 0x00,
159 'o', 0x00,
160 'x', 0x00,
161 'm', 0x00,
162 'a', 0x00,
163 'r', 0x00,
164 'k', 0x00,
165 '.', 0x00,
166 'o', 0x00,
167 'r', 0x00,
168 'g', 0x00,
169 };
170
171
172 /* USB standard request code */
173 #define STD_GET_STATUS_ZERO 0x0080
174 #define STD_GET_STATUS_INTERFACE 0x0081
175 #define STD_GET_STATUS_ENDPOINT 0x0082
176
177 #define STD_CLEAR_FEATURE_ZERO 0x0100
178 #define STD_CLEAR_FEATURE_INTERFACE 0x0101
179 #define STD_CLEAR_FEATURE_ENDPOINT 0x0102
180
181 #define STD_SET_FEATURE_ZERO 0x0300
182 #define STD_SET_FEATURE_INTERFACE 0x0301
183 #define STD_SET_FEATURE_ENDPOINT 0x0302
184
185 #define STD_SET_ADDRESS 0x0500
186 #define STD_GET_DESCRIPTOR 0x0680
187 #define STD_SET_DESCRIPTOR 0x0700
188 #define STD_GET_CONFIGURATION 0x0880
189 #define STD_SET_CONFIGURATION 0x0900
190 #define STD_GET_INTERFACE 0x0A81
191 #define STD_SET_INTERFACE 0x0B01
192 #define STD_SYNCH_FRAME 0x0C82
193
194 /* CDC Class Specific Request Code */
195 #define GET_LINE_CODING 0x21A1
196 #define SET_LINE_CODING 0x2021
197 #define SET_CONTROL_LINE_STATE 0x2221
198
199 typedef struct {
200 unsigned int dwDTERRate;
201 char bCharFormat;
202 char bParityType;
203 char bDataBits;
204 } AT91S_CDC_LINE_CODING, *AT91PS_CDC_LINE_CODING;
205
206 AT91S_CDC_LINE_CODING line = {
207 115200, // baudrate
208 0, // 1 Stop Bit
209 0, // None Parity
210 8}; // 8 Data bits
211
212 void AT91F_CDC_Enumerate();
213
214 AT91PS_UDP pUdp = AT91C_BASE_UDP;
215 byte_t btConfiguration = 0;
216 byte_t btConnection = 0;
217 byte_t btReceiveBank = AT91C_UDP_RX_DATA_BK0;
218
219 //*----------------------------------------------------------------------------
220 //* \fn AT91F_USB_Disable
221 //* \brief This function deactivates the USB device
222 //*----------------------------------------------------------------------------
223 void usb_disable() {
224 // Disconnect and reconnect USB controller for 100ms
225 AT91C_BASE_PIOA->PIO_ODR = AT91C_PIO_PA24;
226 SpinDelay(100);
227
228 // Clear all lingering interrupts
229 if(pUdp->UDP_ISR & AT91C_UDP_ENDBUSRES) {
230 pUdp->UDP_ICR = AT91C_UDP_ENDBUSRES;
231 }
232 }
233
234 //*----------------------------------------------------------------------------
235 //* \fn AT91F_USB_Enable
236 //* \brief This function Activates the USB device
237 //*----------------------------------------------------------------------------
238 void usb_enable() {
239 // Set the PLL USB Divider
240 AT91C_BASE_CKGR->CKGR_PLLR |= AT91C_CKGR_USBDIV_1 ;
241
242 // Specific Chip USB Initialisation
243 // Enables the 48MHz USB clock UDPCK and System Peripheral USB Clock
244 AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_UDP;
245 AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_UDP);
246
247 // Enable UDP PullUp (USB_DP_PUP) : enable & Clear of the corresponding PIO
248 // Set in PIO mode and Configure in Output
249 AT91C_BASE_PIOA->PIO_PER = AT91C_PIO_PA16; // Set in PIO mode
250 AT91C_BASE_PIOA->PIO_OER = AT91C_PIO_PA16; // Configure as Output
251
252 // Clear for set the Pul up resistor
253 AT91C_BASE_PIOA->PIO_CODR = AT91C_PIO_PA16;
254
255 // Disconnect and USB device
256 usb_disable();
257
258 // Wait for a short while
259 SpinDelay(100);
260
261 // Reconnect USB reconnect
262 AT91C_BASE_PIOA->PIO_SODR = AT91C_PIO_PA24;
263 AT91C_BASE_PIOA->PIO_OER = AT91C_PIO_PA24;
264 }
265
266 //*----------------------------------------------------------------------------
267 //* \fn AT91F_UDP_IsConfigured
268 //* \brief Test if the device is configured and handle enumeration
269 //*----------------------------------------------------------------------------
270 bool usb_check() {
271 AT91_REG isr = pUdp->UDP_ISR;
272
273 if (isr & AT91C_UDP_ENDBUSRES) {
274 pUdp->UDP_ICR = AT91C_UDP_ENDBUSRES;
275 // reset all endpoints
276 pUdp->UDP_RSTEP = (unsigned int)-1;
277 pUdp->UDP_RSTEP = 0;
278 // Enable the function
279 pUdp->UDP_FADDR = AT91C_UDP_FEN;
280 // Configure endpoint 0
281 pUdp->UDP_CSR[0] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_CTRL);
282 }
283 else if (isr & AT91C_UDP_EPINT0) {
284 pUdp->UDP_ICR = AT91C_UDP_EPINT0;
285 AT91F_CDC_Enumerate();
286 }
287 return (btConfiguration) ? true : false;
288 }
289
290
291 bool usb_poll()
292 {
293 if (!usb_check()) return false;
294 return (pUdp->UDP_CSR[AT91C_EP_OUT] & btReceiveBank);
295 }
296
297 //*----------------------------------------------------------------------------
298 //* \fn AT91F_UDP_Read
299 //* \brief Read available data from Endpoint OUT
300 //*----------------------------------------------------------------------------
301 uint32_t usb_read(byte_t* data, size_t len) {
302 byte_t bank = btReceiveBank;
303 uint32_t packetSize, nbBytesRcv = 0;
304 uint32_t time_out = 0;
305
306 while (len)
307 {
308 if (!usb_check()) break;
309
310 if ( pUdp->UDP_CSR[AT91C_EP_OUT] & bank ) {
311 packetSize = MIN(pUdp->UDP_CSR[AT91C_EP_OUT] >> 16, len);
312 len -= packetSize;
313 while(packetSize--)
314 data[nbBytesRcv++] = pUdp->UDP_FDR[AT91C_EP_OUT];
315 pUdp->UDP_CSR[AT91C_EP_OUT] &= ~(bank);
316 if (bank == AT91C_UDP_RX_DATA_BK0)
317 {
318 bank = AT91C_UDP_RX_DATA_BK1;
319 } else {
320 bank = AT91C_UDP_RX_DATA_BK0;
321 }
322 }
323 if (time_out++ == 0x1fff) break;
324 }
325
326 btReceiveBank = bank;
327 return nbBytesRcv;
328 }
329
330 //*----------------------------------------------------------------------------
331 //* \fn AT91F_CDC_Write
332 //* \brief Send through endpoint 2
333 //*----------------------------------------------------------------------------
334 uint32_t usb_write(const byte_t* data, const size_t len) {
335 size_t length = len;
336 uint32_t cpt = 0;
337
338 if (!length) return 0;
339 if (!usb_check()) return 0;
340
341 // Send the first packet
342 cpt = MIN(length, AT91C_EP_IN_SIZE-1);
343 length -= cpt;
344 while (cpt--) pUdp->UDP_FDR[AT91C_EP_IN] = *data++;
345 pUdp->UDP_CSR[AT91C_EP_IN] |= AT91C_UDP_TXPKTRDY;
346
347 while (length) {
348 // Fill the second bank
349 cpt = MIN(length, AT91C_EP_IN_SIZE-1);
350 length -= cpt;
351 while (cpt--) pUdp->UDP_FDR[AT91C_EP_IN] = *data++;
352 // Wait for the the first bank to be sent
353 while (!(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP)) {
354 if (!usb_check()) return length;
355 }
356 pUdp->UDP_CSR[AT91C_EP_IN] &= ~(AT91C_UDP_TXCOMP);
357 while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP);
358 pUdp->UDP_CSR[AT91C_EP_IN] |= AT91C_UDP_TXPKTRDY;
359 }
360
361 // Wait for the end of transfer
362 while (!(pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP)) {
363 if (!usb_check()) return length;
364 }
365
366 pUdp->UDP_CSR[AT91C_EP_IN] &= ~(AT91C_UDP_TXCOMP);
367 while (pUdp->UDP_CSR[AT91C_EP_IN] & AT91C_UDP_TXCOMP);
368
369 return length;
370 }
371
372 //*----------------------------------------------------------------------------
373 //* \fn AT91F_USB_SendData
374 //* \brief Send Data through the control endpoint
375 //*----------------------------------------------------------------------------
376 unsigned int csrTab[100];
377 unsigned char csrIdx = 0;
378
379 static void AT91F_USB_SendData(AT91PS_UDP pUdp, const char *pData, uint32_t length) {
380 uint32_t cpt = 0;
381 AT91_REG csr;
382
383 do {
384 cpt = MIN(length, 8);
385 length -= cpt;
386
387 while (cpt--)
388 pUdp->UDP_FDR[0] = *pData++;
389
390 if (pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
391 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_TXCOMP);
392 while (pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP);
393 }
394
395 pUdp->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY;
396 do {
397 csr = pUdp->UDP_CSR[0];
398
399 // Data IN stage has been stopped by a status OUT
400 if (csr & AT91C_UDP_RX_DATA_BK0) {
401 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_RX_DATA_BK0);
402 return;
403 }
404 } while ( !(csr & AT91C_UDP_TXCOMP) );
405
406 } while (length);
407
408 if (pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP) {
409 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_TXCOMP);
410 while (pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP);
411 }
412 }
413
414 //*----------------------------------------------------------------------------
415 //* \fn AT91F_USB_SendZlp
416 //* \brief Send zero length packet through the control endpoint
417 //*----------------------------------------------------------------------------
418 void AT91F_USB_SendZlp(AT91PS_UDP pUdp) {
419 pUdp->UDP_CSR[0] |= AT91C_UDP_TXPKTRDY;
420 while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP) );
421 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_TXCOMP);
422 while (pUdp->UDP_CSR[0] & AT91C_UDP_TXCOMP);
423 }
424
425 //*----------------------------------------------------------------------------
426 //* \fn AT91F_USB_SendStall
427 //* \brief Stall the control endpoint
428 //*----------------------------------------------------------------------------
429 void AT91F_USB_SendStall(AT91PS_UDP pUdp) {
430 pUdp->UDP_CSR[0] |= AT91C_UDP_FORCESTALL;
431 while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_ISOERROR) );
432 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_FORCESTALL | AT91C_UDP_ISOERROR);
433 while (pUdp->UDP_CSR[0] & (AT91C_UDP_FORCESTALL | AT91C_UDP_ISOERROR));
434 }
435
436 //*----------------------------------------------------------------------------
437 //* \fn AT91F_CDC_Enumerate
438 //* \brief This function is a callback invoked when a SETUP packet is received
439 //*----------------------------------------------------------------------------
440 void AT91F_CDC_Enumerate() {
441 byte_t bmRequestType, bRequest;
442 uint16_t wValue, wIndex, wLength, wStatus;
443
444 if ( !(pUdp->UDP_CSR[0] & AT91C_UDP_RXSETUP) )
445 return;
446
447 bmRequestType = pUdp->UDP_FDR[0];
448 bRequest = pUdp->UDP_FDR[0];
449 wValue = (pUdp->UDP_FDR[0] & 0xFF);
450 wValue |= (pUdp->UDP_FDR[0] << 8);
451 wIndex = (pUdp->UDP_FDR[0] & 0xFF);
452 wIndex |= (pUdp->UDP_FDR[0] << 8);
453 wLength = (pUdp->UDP_FDR[0] & 0xFF);
454 wLength |= (pUdp->UDP_FDR[0] << 8);
455
456 if (bmRequestType & 0x80) {
457 pUdp->UDP_CSR[0] |= AT91C_UDP_DIR;
458 while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_DIR) );
459 }
460 pUdp->UDP_CSR[0] &= ~AT91C_UDP_RXSETUP;
461 while ( (pUdp->UDP_CSR[0] & AT91C_UDP_RXSETUP) );
462
463 // Handle supported standard device request Cf Table 9-3 in USB specification Rev 1.1
464 switch ((bRequest << 8) | bmRequestType) {
465 case STD_GET_DESCRIPTOR:
466 if (wValue == 0x100) // Return Device Descriptor
467 AT91F_USB_SendData(pUdp, devDescriptor, MIN(sizeof(devDescriptor), wLength));
468 else if (wValue == 0x200) // Return Configuration Descriptor
469 AT91F_USB_SendData(pUdp, cfgDescriptor, MIN(sizeof(cfgDescriptor), wLength));
470 else if ((wValue & 0x300) == 0x300) // Return String Descriptor
471 AT91F_USB_SendData(pUdp, strDescriptor, MIN(sizeof(strDescriptor), wLength));
472 else
473 AT91F_USB_SendStall(pUdp);
474 break;
475 case STD_SET_ADDRESS:
476 AT91F_USB_SendZlp(pUdp);
477 pUdp->UDP_FADDR = (AT91C_UDP_FEN | wValue);
478 pUdp->UDP_GLBSTATE = (wValue) ? AT91C_UDP_FADDEN : 0;
479 break;
480 case STD_SET_CONFIGURATION:
481 btConfiguration = wValue;
482 AT91F_USB_SendZlp(pUdp);
483 pUdp->UDP_GLBSTATE = (wValue) ? AT91C_UDP_CONFG : AT91C_UDP_FADDEN;
484 pUdp->UDP_CSR[1] = (wValue) ? (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_OUT) : 0;
485 pUdp->UDP_CSR[2] = (wValue) ? (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_IN) : 0;
486 pUdp->UDP_CSR[3] = (wValue) ? (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_INT_IN) : 0;
487 break;
488 case STD_GET_CONFIGURATION:
489 AT91F_USB_SendData(pUdp, (char *) &(btConfiguration), sizeof(btConfiguration));
490 break;
491 case STD_GET_STATUS_ZERO:
492 wStatus = 0;
493 AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus));
494 break;
495 case STD_GET_STATUS_INTERFACE:
496 wStatus = 0;
497 AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus));
498 break;
499 case STD_GET_STATUS_ENDPOINT:
500 wStatus = 0;
501 wIndex &= 0x0F;
502 if ((pUdp->UDP_GLBSTATE & AT91C_UDP_CONFG) && (wIndex <= 3)) {
503 wStatus = (pUdp->UDP_CSR[wIndex] & AT91C_UDP_EPEDS) ? 0 : 1;
504 AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus));
505 }
506 else if ((pUdp->UDP_GLBSTATE & AT91C_UDP_FADDEN) && (wIndex == 0)) {
507 wStatus = (pUdp->UDP_CSR[wIndex] & AT91C_UDP_EPEDS) ? 0 : 1;
508 AT91F_USB_SendData(pUdp, (char *) &wStatus, sizeof(wStatus));
509 }
510 else
511 AT91F_USB_SendStall(pUdp);
512 break;
513 case STD_SET_FEATURE_ZERO:
514 AT91F_USB_SendStall(pUdp);
515 break;
516 case STD_SET_FEATURE_INTERFACE:
517 AT91F_USB_SendZlp(pUdp);
518 break;
519 case STD_SET_FEATURE_ENDPOINT:
520 wIndex &= 0x0F;
521 if ((wValue == 0) && wIndex && (wIndex <= 3)) {
522 pUdp->UDP_CSR[wIndex] = 0;
523 AT91F_USB_SendZlp(pUdp);
524 }
525 else
526 AT91F_USB_SendStall(pUdp);
527 break;
528 case STD_CLEAR_FEATURE_ZERO:
529 AT91F_USB_SendStall(pUdp);
530 break;
531 case STD_CLEAR_FEATURE_INTERFACE:
532 AT91F_USB_SendZlp(pUdp);
533 break;
534 case STD_CLEAR_FEATURE_ENDPOINT:
535 wIndex &= 0x0F;
536 if ((wValue == 0) && wIndex && (wIndex <= 3)) {
537 if (wIndex == 1)
538 pUdp->UDP_CSR[1] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_OUT);
539 else if (wIndex == 2)
540 pUdp->UDP_CSR[2] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_BULK_IN);
541 else if (wIndex == 3)
542 pUdp->UDP_CSR[3] = (AT91C_UDP_EPEDS | AT91C_UDP_EPTYPE_ISO_IN);
543 AT91F_USB_SendZlp(pUdp);
544 }
545 else
546 AT91F_USB_SendStall(pUdp);
547 break;
548
549 // handle CDC class requests
550 case SET_LINE_CODING:
551 while ( !(pUdp->UDP_CSR[0] & AT91C_UDP_RX_DATA_BK0) );
552 pUdp->UDP_CSR[0] &= ~(AT91C_UDP_RX_DATA_BK0);
553 AT91F_USB_SendZlp(pUdp);
554 break;
555 case GET_LINE_CODING:
556 AT91F_USB_SendData(pUdp, (char *) &line, MIN(sizeof(line), wLength));
557 break;
558 case SET_CONTROL_LINE_STATE:
559 btConnection = wValue;
560 AT91F_USB_SendZlp(pUdp);
561 break;
562 default:
563 AT91F_USB_SendStall(pUdp);
564 break;
565 }
566 }
Proxmark3 GIT tracking
Impressum, Datenschutz