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


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