removed dependency on 'readlink -f'
[rapper.git] / src / usb / core.c
1 /*----------------------------------------------------------------------------
2  *      U S B  -  K e r n e l
3  *----------------------------------------------------------------------------
4  * Name:    usbcore.c
5  * Purpose: USB Core Module
6  * Version: V1.20
7  *----------------------------------------------------------------------------
8  *      This software is supplied "AS IS" without any warranties, express,
9  *      implied or statutory, including but not limited to the implied
10  *      warranties of fitness for purpose, satisfactory quality and
11  *      noninfringement. Keil extends you a royalty-free right to reproduce
12  *      and distribute executable files created using this software for use
13  *      on NXP Semiconductors LPC family microcontroller devices only. Nothing
14  *      else gives you the right to use this software.
15  *
16  * Copyright (c) 2009 Keil - An ARM Company. All rights reserved.
17  *----------------------------------------------------------------------------
18  * History:
19  *          V1.20 Added vendor specific requests
20  *                Changed string descriptor handling
21  *                Reworked Endpoint0
22  *          V1.00 Initial Version
23  *----------------------------------------------------------------------------*/
24 #include "lpc_types.h"
25
26 #include "usb.h"
27 #include "cfg.h"
28 #include "hw.h"
29 #include "core.h"
30 #include "desc.h"
31 #include "user.h"
32
33 #if (USB_CLASS)
34
35 #if (USB_AUDIO)
36 #include "audio.h"
37 #include "adcuser.h"
38 #endif
39
40 #if (USB_HID)
41 #include "hid.h"
42 #include "hiduser.h"
43 #endif
44
45 #if (USB_MSC)
46 #include "msc.h"
47 #include "mscuser.h"
48 extern MSC_CSW CSW;
49 #endif
50
51 #if (USB_CDC)
52 #include "cdc.h"
53 #include "cdcuser.h"
54 #endif
55
56 #endif
57
58 #if (USB_VENDOR)
59 #include "vendor.h"
60 #endif
61
62 #if defined   (  __CC_ARM  )
63 #pragma diag_suppress 111,1441
64 #endif
65
66 #if defined   (  __GNUC__  )
67 #define __packed __attribute__((__packed__))
68 #endif
69
70 uint16_t  USB_DeviceStatus;
71 uint8_t  USB_DeviceAddress;
72 uint8_t  USB_Configuration;
73 uint32_t USB_EndPointMask;
74 uint32_t USB_EndPointHalt;
75 uint32_t USB_EndPointStall;                         /* EP must stay stalled */
76 uint8_t  USB_NumInterfaces;
77 uint8_t  USB_AltSetting[USB_IF_NUM];
78
79 uint8_t  EP0Buf[USB_MAX_PACKET0];
80
81
82 USB_EP_DATA EP0Data;
83
84 USB_SETUP_PACKET SetupPacket;
85
86
87 /*
88  *  Reset USB Core
89  *    Parameters:      None
90  *    Return Value:    None
91  */
92
93 void USB_ResetCore (void) {
94
95   USB_DeviceStatus  = USB_POWER;
96   USB_DeviceAddress = 0;
97   USB_Configuration = 0;
98   USB_EndPointMask  = 0x00010001;
99   USB_EndPointHalt  = 0x00000000;
100   USB_EndPointStall = 0x00000000;
101 }
102
103
104 /*
105  *  USB Request - Setup Stage
106  *    Parameters:      None (global SetupPacket)
107  *    Return Value:    None
108  */
109
110 void USB_SetupStage (void) {
111   USB_ReadEP(0x00, (uint8_t *)&SetupPacket);
112 }
113
114
115 /*
116  *  USB Request - Data In Stage
117  *    Parameters:      None (global EP0Data)
118  *    Return Value:    None
119  */
120
121 void USB_DataInStage (void) {
122   uint32_t cnt;
123
124   if (EP0Data.Count > USB_MAX_PACKET0) {
125     cnt = USB_MAX_PACKET0;
126   } else {
127     cnt = EP0Data.Count;
128   }
129   cnt = USB_WriteEP(0x80, EP0Data.pData, cnt);
130   EP0Data.pData += cnt;
131   EP0Data.Count -= cnt;
132 }
133
134
135 /*
136  *  USB Request - Data Out Stage
137  *    Parameters:      None (global EP0Data)
138  *    Return Value:    None
139  */
140
141 void USB_DataOutStage (void) {
142   uint32_t cnt;
143
144   cnt = USB_ReadEP(0x00, EP0Data.pData);
145   EP0Data.pData += cnt;
146   EP0Data.Count -= cnt;
147 }
148
149
150 /*
151  *  USB Request - Status In Stage
152  *    Parameters:      None
153  *    Return Value:    None
154  */
155
156 void USB_StatusInStage (void) {
157   USB_WriteEP(0x80, NULL, 0);
158 }
159
160
161 /*
162  *  USB Request - Status Out Stage
163  *    Parameters:      None
164  *    Return Value:    None
165  */
166
167 void USB_StatusOutStage (void) {
168   USB_ReadEP(0x00, EP0Buf);
169 }
170
171
172 /*
173  *  Get Status USB Request
174  *    Parameters:      None (global SetupPacket)
175  *    Return Value:    TRUE - Success, FALSE - Error
176  */
177
178 #if defined (  __IAR_SYSTEMS_ICC__  )
179 inline uint32_t USB_ReqGetStatus (void) {
180 #else
181 __inline uint32_t USB_ReqGetStatus (void) {
182 #endif
183   uint32_t n, m;
184
185   switch (SetupPacket.bmRequestType.BM.Recipient) {
186     case REQUEST_TO_DEVICE:
187       EP0Data.pData = (uint8_t *)&USB_DeviceStatus;
188       break;
189     case REQUEST_TO_INTERFACE:
190       if ((USB_Configuration != 0) && (SetupPacket.wIndex.WB.L < USB_NumInterfaces)) {
191         *((__packed uint16_t *)EP0Buf) = 0;
192           *((uint16_t *)EP0Buf) = 0;
193         EP0Data.pData = EP0Buf;
194       } else {
195         return (FALSE);
196       }
197       break;
198     case REQUEST_TO_ENDPOINT:
199       n = SetupPacket.wIndex.WB.L & 0x8F;
200       m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
201       if (((USB_Configuration != 0) || ((n & 0x0F) == 0)) && (USB_EndPointMask & m)) {
202         *((__packed uint16_t *)EP0Buf) = (USB_EndPointHalt & m) ? 1 : 0;
203           *((uint16_t *)EP0Buf) = (USB_EndPointHalt & m) ? 1 : 0;
204         EP0Data.pData = EP0Buf;
205       } else {
206         return (FALSE);
207       }
208       break;
209     default:
210       return (FALSE);
211   }
212   return (TRUE);
213 }
214
215
216 /*
217  *  Set/Clear Feature USB Request
218  *    Parameters:      sc:    0 - Clear, 1 - Set
219  *                            (global SetupPacket)
220  *    Return Value:    TRUE - Success, FALSE - Error
221  */
222
223 #if defined (  __IAR_SYSTEMS_ICC__  )
224 inline uint32_t USB_ReqSetClrFeature (uint32_t sc) {
225 #else
226 __inline uint32_t USB_ReqSetClrFeature (uint32_t sc) {
227 #endif
228   uint32_t n, m;
229
230   switch (SetupPacket.bmRequestType.BM.Recipient) {
231     case REQUEST_TO_DEVICE:
232       if (SetupPacket.wValue.W == USB_FEATURE_REMOTE_WAKEUP) {
233         if (sc) {
234           USB_WakeUpCfg(TRUE);
235           USB_DeviceStatus |=  USB_GETSTATUS_REMOTE_WAKEUP;
236         } else {
237           USB_WakeUpCfg(FALSE);
238           USB_DeviceStatus &= ~USB_GETSTATUS_REMOTE_WAKEUP;
239         }
240       } else {
241         return (FALSE);
242       }
243       break;
244     case REQUEST_TO_INTERFACE:
245       return (FALSE);
246     case REQUEST_TO_ENDPOINT:
247       n = SetupPacket.wIndex.WB.L & 0x8F;
248       m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
249       if ((USB_Configuration != 0) && ((n & 0x0F) != 0) && (USB_EndPointMask & m)) {
250         if (SetupPacket.wValue.W == USB_FEATURE_ENDPOINT_STALL) {
251           if (sc) {
252             USB_SetStallEP(n);
253             USB_EndPointHalt |=  m;
254           } else {
255             if ((USB_EndPointStall & m) != 0) {
256               return (TRUE);
257             }
258             USB_ClrStallEP(n);
259 #if (USB_MSC)
260             if ((n == MSC_EP_IN) && ((USB_EndPointHalt & m) != 0)) {
261               /* Compliance Test: rewrite CSW after unstall */
262               if (CSW.dSignature == MSC_CSW_Signature) {
263                 USB_WriteEP(MSC_EP_IN, (uint8_t *)&CSW, sizeof(CSW));
264               }
265             }
266 #endif
267             USB_EndPointHalt &= ~m;
268           }
269         } else {
270           return (FALSE);
271         }
272       } else {
273         return (FALSE);
274       }
275       break;
276     default:
277       return (FALSE);
278   }
279   return (TRUE);
280 }
281
282
283 /*
284  *  Set Address USB Request
285  *    Parameters:      None (global SetupPacket)
286  *    Return Value:    TRUE - Success, FALSE - Error
287  */
288
289 #if defined (  __IAR_SYSTEMS_ICC__  )
290 inline uint32_t USB_ReqSetAddress (void) {
291 #else
292 __inline uint32_t USB_ReqSetAddress (void) {
293 #endif
294   switch (SetupPacket.bmRequestType.BM.Recipient) {
295     case REQUEST_TO_DEVICE:
296       USB_DeviceAddress = 0x80 | SetupPacket.wValue.WB.L;
297       break;
298     default:
299       return (FALSE);
300   }
301   return (TRUE);
302 }
303
304
305 /*
306  *  Get Descriptor USB Request
307  *    Parameters:      None (global SetupPacket)
308  *    Return Value:    TRUE - Success, FALSE - Error
309  */
310
311 #if defined (  __IAR_SYSTEMS_ICC__  )
312 inline uint32_t USB_ReqGetDescriptor (void) {
313 #else
314 __inline uint32_t USB_ReqGetDescriptor (void) {
315 #endif
316   uint8_t  *pD;
317   uint32_t len, n;
318
319   switch (SetupPacket.bmRequestType.BM.Recipient) {
320     case REQUEST_TO_DEVICE:
321       switch (SetupPacket.wValue.WB.H) {
322         case USB_DEVICE_DESCRIPTOR_TYPE:
323           EP0Data.pData = (uint8_t *)USB_DeviceDescriptor;
324           len = USB_DEVICE_DESC_SIZE;
325           break;
326         case USB_CONFIGURATION_DESCRIPTOR_TYPE:
327           pD = (uint8_t *)USB_ConfigDescriptor;
328           for (n = 0; n != SetupPacket.wValue.WB.L; n++) {
329             if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bLength != 0) {
330               pD += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
331             }
332           }
333           if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bLength == 0) {
334             return (FALSE);
335           }
336           EP0Data.pData = pD;
337           len = ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
338           break;
339         case USB_STRING_DESCRIPTOR_TYPE:
340           pD = (uint8_t *)USB_StringDescriptor;
341           for (n = 0; n != SetupPacket.wValue.WB.L; n++) {
342             if (((USB_STRING_DESCRIPTOR *)pD)->bLength != 0) {
343               pD += ((USB_STRING_DESCRIPTOR *)pD)->bLength;
344             }
345           }
346           if (((USB_STRING_DESCRIPTOR *)pD)->bLength == 0) {
347             return (FALSE);
348           }
349           EP0Data.pData = pD;
350           len = ((USB_STRING_DESCRIPTOR *)EP0Data.pData)->bLength;
351           break;
352         default:
353           return (FALSE);
354       }
355       break;
356     case REQUEST_TO_INTERFACE:
357       switch (SetupPacket.wValue.WB.H) {
358 #if USB_HID
359         case HID_HID_DESCRIPTOR_TYPE:
360           if (SetupPacket.wIndex.WB.L != USB_HID_IF_NUM) {
361             return (FALSE);    /* Only Single HID Interface is supported */
362           }
363           EP0Data.pData = (uint8_t *)USB_ConfigDescriptor + HID_DESC_OFFSET;
364           len = HID_DESC_SIZE;
365           break;
366         case HID_REPORT_DESCRIPTOR_TYPE:
367           if (SetupPacket.wIndex.WB.L != USB_HID_IF_NUM) {
368             return (FALSE);    /* Only Single HID Interface is supported */
369           }
370           EP0Data.pData = (uint8_t *)HID_ReportDescriptor;
371           len = HID_ReportDescSize;
372           break;
373         case HID_PHYSICAL_DESCRIPTOR_TYPE:
374           return (FALSE);      /* HID Physical Descriptor is not supported */
375 #endif
376         default:
377           return (FALSE);
378       }
379 //      break;
380     default:
381       return (FALSE);
382   }
383
384   if (EP0Data.Count > len) {
385     EP0Data.Count = len;
386   }
387
388   return (TRUE);
389 }
390
391
392 /*
393  *  Get Configuration USB Request
394  *    Parameters:      None (global SetupPacket)
395  *    Return Value:    TRUE - Success, FALSE - Error
396  */
397
398 #if defined (  __IAR_SYSTEMS_ICC__  )
399 inline uint32_t USB_ReqGetConfiguration (void) {
400 #else
401 __inline uint32_t USB_ReqGetConfiguration (void) {
402 #endif
403   switch (SetupPacket.bmRequestType.BM.Recipient) {
404     case REQUEST_TO_DEVICE:
405       EP0Data.pData = &USB_Configuration;
406       break;
407     default:
408       return (FALSE);
409   }
410   return (TRUE);
411 }
412
413
414 /*
415  *  Set Configuration USB Request
416  *    Parameters:      None (global SetupPacket)
417  *    Return Value:    TRUE - Success, FALSE - Error
418  */
419
420 #if defined (  __IAR_SYSTEMS_ICC__  )
421 inline uint32_t USB_ReqSetConfiguration (void) {
422 #else
423 __inline uint32_t USB_ReqSetConfiguration (void) {
424 #endif
425   USB_COMMON_DESCRIPTOR *pD;
426   uint32_t alt = 0;
427   uint32_t n, m;
428   uint32_t tmp;
429
430   switch (SetupPacket.bmRequestType.BM.Recipient) {
431     case REQUEST_TO_DEVICE:
432
433       if (SetupPacket.wValue.WB.L) {
434         pD = (USB_COMMON_DESCRIPTOR *)USB_ConfigDescriptor;
435         while (pD->bLength) {
436           switch (pD->bDescriptorType) {
437             case USB_CONFIGURATION_DESCRIPTOR_TYPE:
438               if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bConfigurationValue == SetupPacket.wValue.WB.L) {
439                 USB_Configuration = SetupPacket.wValue.WB.L;
440                 USB_NumInterfaces = ((USB_CONFIGURATION_DESCRIPTOR *)pD)->bNumInterfaces;
441                 for (n = 0; n < USB_IF_NUM; n++) {
442                   USB_AltSetting[n] = 0;
443                 }
444                 for (n = 1; n < 16; n++) {
445                   if (USB_EndPointMask & (1 << n)) {
446                     USB_DisableEP(n);
447                   }
448                   if (USB_EndPointMask & ((1 << 16) << n)) {
449                     USB_DisableEP(n | 0x80);
450                   }
451                 }
452                 USB_EndPointMask = 0x00010001;
453                 USB_EndPointHalt = 0x00000000;
454                 USB_EndPointStall= 0x00000000;
455                 USB_Configure(TRUE);
456                 if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bmAttributes & USB_CONFIG_POWERED_MASK) {
457                   USB_DeviceStatus |=  USB_GETSTATUS_SELF_POWERED;
458                 } else {
459                   USB_DeviceStatus &= ~USB_GETSTATUS_SELF_POWERED;
460                 }
461               } else {
462 //                (uint8_t *)pD += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
463                   tmp = (uint32_t)pD;
464                   tmp += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
465                   pD = (USB_COMMON_DESCRIPTOR *)tmp;
466                   continue;
467               }
468               break;
469             case USB_INTERFACE_DESCRIPTOR_TYPE:
470               alt = ((USB_INTERFACE_DESCRIPTOR *)pD)->bAlternateSetting;
471               break;
472             case USB_ENDPOINT_DESCRIPTOR_TYPE:
473               if (alt == 0) {
474                 n = ((USB_ENDPOINT_DESCRIPTOR *)pD)->bEndpointAddress & 0x8F;
475                 m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
476                 USB_EndPointMask |= m;
477                 USB_ConfigEP((USB_ENDPOINT_DESCRIPTOR *)pD);
478                 USB_EnableEP(n);
479                 USB_ResetEP(n);
480               }
481               break;
482           }
483 //          (uint8_t *)pD += pD->bLength;
484                         tmp = (uint32_t)pD;
485                         tmp += pD->bLength;
486                         pD = (USB_COMMON_DESCRIPTOR *)tmp;
487         }
488       }
489       else {
490         USB_Configuration = 0;
491         for (n = 1; n < 16; n++) {
492           if (USB_EndPointMask & (1 << n)) {
493             USB_DisableEP(n);
494           }
495           if (USB_EndPointMask & ((1 << 16) << n)) {
496             USB_DisableEP(n | 0x80);
497           }
498         }
499         USB_EndPointMask  = 0x00010001;
500         USB_EndPointHalt  = 0x00000000;
501         USB_EndPointStall = 0x00000000;
502         USB_Configure(FALSE);
503       }
504
505       if (USB_Configuration != SetupPacket.wValue.WB.L) {
506         return (FALSE);
507       }
508       break;
509     default:
510       return (FALSE);
511   }
512   return (TRUE);
513 }
514
515
516 /*
517  *  Get Interface USB Request
518  *    Parameters:      None (global SetupPacket)
519  *    Return Value:    TRUE - Success, FALSE - Error
520  */
521
522 #if defined (  __IAR_SYSTEMS_ICC__  )
523 inline uint32_t USB_ReqGetInterface (void) {
524 #else
525 __inline uint32_t USB_ReqGetInterface (void) {
526 #endif
527   switch (SetupPacket.bmRequestType.BM.Recipient) {
528     case REQUEST_TO_INTERFACE:
529       if ((USB_Configuration != 0) && (SetupPacket.wIndex.WB.L < USB_NumInterfaces)) {
530         EP0Data.pData = USB_AltSetting + SetupPacket.wIndex.WB.L;
531       } else {
532         return (FALSE);
533       }
534       break;
535     default:
536       return (FALSE);
537   }
538   return (TRUE);
539 }
540
541
542 /*
543  *  Set Interface USB Request
544  *    Parameters:      None (global SetupPacket)
545  *    Return Value:    TRUE - Success, FALSE - Error
546  */
547 #if defined (  __IAR_SYSTEMS_ICC__  )
548 inline uint32_t USB_ReqSetInterface (void) {
549 #else
550 __inline uint32_t USB_ReqSetInterface (void) {
551 #endif
552   USB_COMMON_DESCRIPTOR *pD;
553   uint32_t ifn = 0, alt = 0, old = 0, msk = 0;
554   uint32_t n, m;
555   uint32_t set;
556   uint32_t tmp;
557
558   switch (SetupPacket.bmRequestType.BM.Recipient) {
559     case REQUEST_TO_INTERFACE:
560       if (USB_Configuration == 0) return (FALSE);
561       set = FALSE;
562       pD  = (USB_COMMON_DESCRIPTOR *)USB_ConfigDescriptor;
563       while (pD->bLength) {
564         switch (pD->bDescriptorType) {
565           case USB_CONFIGURATION_DESCRIPTOR_TYPE:
566             if (((USB_CONFIGURATION_DESCRIPTOR *)pD)->bConfigurationValue != USB_Configuration) {
567 //              (uint8_t *)pD += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
568                 tmp = (uint32_t)pD;
569                 tmp += ((USB_CONFIGURATION_DESCRIPTOR *)pD)->wTotalLength;
570                 pD = (USB_COMMON_DESCRIPTOR *)tmp;
571
572               continue;
573             }
574             break;
575           case USB_INTERFACE_DESCRIPTOR_TYPE:
576             ifn = ((USB_INTERFACE_DESCRIPTOR *)pD)->bInterfaceNumber;
577             alt = ((USB_INTERFACE_DESCRIPTOR *)pD)->bAlternateSetting;
578             msk = 0;
579             if ((ifn == SetupPacket.wIndex.WB.L) && (alt == SetupPacket.wValue.WB.L)) {
580               set = TRUE;
581               old = USB_AltSetting[ifn];
582               USB_AltSetting[ifn] = (uint8_t)alt;
583             }
584             break;
585           case USB_ENDPOINT_DESCRIPTOR_TYPE:
586             if (ifn == SetupPacket.wIndex.WB.L) {
587               n = ((USB_ENDPOINT_DESCRIPTOR *)pD)->bEndpointAddress & 0x8F;
588               m = (n & 0x80) ? ((1 << 16) << (n & 0x0F)) : (1 << n);
589               if (alt == SetupPacket.wValue.WB.L) {
590                 USB_EndPointMask |=  m;
591                 USB_EndPointHalt &= ~m;
592                 USB_ConfigEP((USB_ENDPOINT_DESCRIPTOR *)pD);
593                 USB_EnableEP(n);
594                 USB_ResetEP(n);
595                 msk |= m;
596               }
597               else if ((alt == old) && ((msk & m) == 0)) {
598                 USB_EndPointMask &= ~m;
599                 USB_EndPointHalt &= ~m;
600                 USB_DisableEP(n);
601               }
602             }
603            break;
604         }
605 //        (uint8_t *)pD += pD->bLength;
606                         tmp = (uint32_t)pD;
607                         tmp += pD->bLength;
608                         pD = (USB_COMMON_DESCRIPTOR *)tmp;
609       }
610       break;
611     default:
612       return (FALSE);
613   }
614
615   return (set);
616 }
617
618
619 /*
620  *  USB Endpoint 0 Event Callback
621  *    Parameters:      event
622  *    Return Value:    none
623  */
624
625 void USB_EndPoint0 (uint32_t event) {
626
627   switch (event) {
628     case USB_EVT_SETUP:
629       USB_SetupStage();
630       USB_DirCtrlEP(SetupPacket.bmRequestType.BM.Dir);
631       EP0Data.Count = SetupPacket.wLength;     /* Number of bytes to transfer */
632       switch (SetupPacket.bmRequestType.BM.Type) {
633
634         case REQUEST_STANDARD:
635           switch (SetupPacket.bRequest) {
636             case USB_REQUEST_GET_STATUS:
637               if (!USB_ReqGetStatus()) {
638                 goto stall_i;
639               }
640               USB_DataInStage();
641               break;
642
643             case USB_REQUEST_CLEAR_FEATURE:
644               if (!USB_ReqSetClrFeature(0)) {
645                 goto stall_i;
646               }
647               USB_StatusInStage();
648 #if USB_FEATURE_EVENT
649               USB_Feature_Event();
650 #endif
651               break;
652
653             case USB_REQUEST_SET_FEATURE:
654               if (!USB_ReqSetClrFeature(1)) {
655                 goto stall_i;
656               }
657               USB_StatusInStage();
658 #if USB_FEATURE_EVENT
659               USB_Feature_Event();
660 #endif
661               break;
662
663             case USB_REQUEST_SET_ADDRESS:
664               if (!USB_ReqSetAddress()) {
665                 goto stall_i;
666               }
667               USB_StatusInStage();
668               break;
669
670             case USB_REQUEST_GET_DESCRIPTOR:
671               if (!USB_ReqGetDescriptor()) {
672                 goto stall_i;
673               }
674               USB_DataInStage();
675               break;
676
677             case USB_REQUEST_SET_DESCRIPTOR:
678 /*stall_o:*/  USB_SetStallEP(0x00);            /* not supported */
679               EP0Data.Count = 0;
680               break;
681
682             case USB_REQUEST_GET_CONFIGURATION:
683               if (!USB_ReqGetConfiguration()) {
684                 goto stall_i;
685               }
686               USB_DataInStage();
687               break;
688
689             case USB_REQUEST_SET_CONFIGURATION:
690               if (!USB_ReqSetConfiguration()) {
691                 goto stall_i;
692               }
693               USB_StatusInStage();
694 #if USB_CONFIGURE_EVENT
695               USB_Configure_Event();
696 #endif
697               break;
698
699             case USB_REQUEST_GET_INTERFACE:
700               if (!USB_ReqGetInterface()) {
701                 goto stall_i;
702               }
703               USB_DataInStage();
704               break;
705
706             case USB_REQUEST_SET_INTERFACE:
707               if (!USB_ReqSetInterface()) {
708                 goto stall_i;
709               }
710               USB_StatusInStage();
711 #if USB_INTERFACE_EVENT
712               USB_Interface_Event();
713 #endif
714               break;
715
716             default:
717               goto stall_i;
718           }
719           break;  /* end case REQUEST_STANDARD */
720
721 #if USB_CLASS
722         case REQUEST_CLASS:
723           switch (SetupPacket.bmRequestType.BM.Recipient) {
724
725             case REQUEST_TO_DEVICE:
726               goto stall_i;                                              /* not supported */
727
728             case REQUEST_TO_INTERFACE:
729 #if USB_HID
730               if (SetupPacket.wIndex.WB.L == USB_HID_IF_NUM) {           /* IF number correct? */
731                 switch (SetupPacket.bRequest) {
732                   case HID_REQUEST_GET_REPORT:
733                     if (HID_GetReport()) {
734                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
735                       USB_DataInStage();                                 /* send requested data */
736                       goto setup_class_ok;
737                     }
738                     break;
739                   case HID_REQUEST_SET_REPORT:
740                     EP0Data.pData = EP0Buf;                              /* data to be received */
741                     goto setup_class_ok;
742                   case HID_REQUEST_GET_IDLE:
743                     if (HID_GetIdle()) {
744                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
745                       USB_DataInStage();                                 /* send requested data */
746                       goto setup_class_ok;
747                     }
748                     break;
749                   case HID_REQUEST_SET_IDLE:
750                     if (HID_SetIdle()) {
751                       USB_StatusInStage();                               /* send Acknowledge */
752                       goto setup_class_ok;
753                     }
754                     break;
755                   case HID_REQUEST_GET_PROTOCOL:
756                     if (HID_GetProtocol()) {
757                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
758                       USB_DataInStage();                                 /* send requested data */
759                       goto setup_class_ok;
760                     }
761                     break;
762                   case HID_REQUEST_SET_PROTOCOL:
763                     if (HID_SetProtocol()) {
764                       USB_StatusInStage();                               /* send Acknowledge */
765                       goto setup_class_ok;
766                     }
767                     break;
768                 }
769               }
770 #endif  /* USB_HID */
771 #if USB_MSC
772               if (SetupPacket.wIndex.WB.L == USB_MSC_IF_NUM) {           /* IF number correct? */
773                 switch (SetupPacket.bRequest) {
774                   case MSC_REQUEST_RESET:
775                     if ((SetupPacket.wValue.W == 0) &&                   /* RESET with invalid parameters -> STALL */
776                         (SetupPacket.wLength  == 0)) {
777                       if (MSC_Reset()) {
778                         USB_StatusInStage();
779                         goto setup_class_ok;
780                       }
781                     }
782                     break;
783                   case MSC_REQUEST_GET_MAX_LUN:
784                     if ((SetupPacket.wValue.W == 0) &&                   /* GET_MAX_LUN with invalid parameters -> STALL */
785                         (SetupPacket.wLength  == 1)) {
786                       if (MSC_GetMaxLUN()) {
787                         EP0Data.pData = EP0Buf;
788                         USB_DataInStage();
789                         goto setup_class_ok;
790                       }
791                     }
792                     break;
793                 }
794               }
795 #endif  /* USB_MSC */
796 #if USB_AUDIO
797               if ((SetupPacket.wIndex.WB.L == USB_ADC_CIF_NUM)  ||       /* IF number correct? */
798                   (SetupPacket.wIndex.WB.L == USB_ADC_SIF1_NUM) ||
799                   (SetupPacket.wIndex.WB.L == USB_ADC_SIF2_NUM)) {
800                 switch (SetupPacket.bRequest) {
801                   case AUDIO_REQUEST_GET_CUR:
802                   case AUDIO_REQUEST_GET_MIN:
803                   case AUDIO_REQUEST_GET_MAX:
804                   case AUDIO_REQUEST_GET_RES:
805                     if (ADC_IF_GetRequest()) {
806                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
807                       USB_DataInStage();                                 /* send requested data */
808                       goto setup_class_ok;
809                     }
810                     break;
811                   case AUDIO_REQUEST_SET_CUR:
812 //                case AUDIO_REQUEST_SET_MIN:
813 //                case AUDIO_REQUEST_SET_MAX:
814 //                case AUDIO_REQUEST_SET_RES:
815                     EP0Data.pData = EP0Buf;                              /* data to be received */
816                     goto setup_class_ok;
817                 }
818               }
819 #endif  /* USB_AUDIO */
820 #if USB_CDC
821               if ((SetupPacket.wIndex.WB.L == USB_CDC_CIF_NUM)  ||       /* IF number correct? */
822                   (SetupPacket.wIndex.WB.L == USB_CDC_DIF_NUM)) {
823                 switch (SetupPacket.bRequest) {
824                   case CDC_SEND_ENCAPSULATED_COMMAND:
825                     EP0Data.pData = EP0Buf;                              /* data to be received, see USB_EVT_OUT */
826                     goto setup_class_ok;
827                   case CDC_GET_ENCAPSULATED_RESPONSE:
828                     if (CDC_GetEncapsulatedResponse()) {
829                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
830                       USB_DataInStage();                                 /* send requested data */
831                       goto setup_class_ok;
832                     }
833                     break;
834                   case CDC_SET_COMM_FEATURE:
835                     EP0Data.pData = EP0Buf;                              /* data to be received, see USB_EVT_OUT */
836                     goto setup_class_ok;
837                   case CDC_GET_COMM_FEATURE:
838                     if (CDC_GetCommFeature(SetupPacket.wValue.W)) {
839                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
840                       USB_DataInStage();                                 /* send requested data */
841                       goto setup_class_ok;
842                     }
843                     break;
844                   case CDC_CLEAR_COMM_FEATURE:
845                     if (CDC_ClearCommFeature(SetupPacket.wValue.W)) {
846                       USB_StatusInStage();                               /* send Acknowledge */
847                       goto setup_class_ok;
848                     }
849                     break;
850                   case CDC_SET_LINE_CODING:
851                     EP0Data.pData = EP0Buf;                              /* data to be received, see USB_EVT_OUT */
852                     goto setup_class_ok;
853                   case CDC_GET_LINE_CODING:
854                     if (CDC_GetLineCoding()) {
855                       EP0Data.pData = EP0Buf;                            /* point to data to be sent */
856                       USB_DataInStage();                                 /* send requested data */
857                       goto setup_class_ok;
858                     }
859                     break;
860                   case CDC_SET_CONTROL_LINE_STATE:
861                     if (CDC_SetControlLineState(SetupPacket.wValue.W)) {
862                       USB_StatusInStage();                               /* send Acknowledge */
863                       goto setup_class_ok;
864                     }
865                     break;
866                   case CDC_SEND_BREAK:
867                     if (CDC_SendBreak(SetupPacket.wValue.W)) {
868                       USB_StatusInStage();                               /* send Acknowledge */
869                       goto setup_class_ok;
870                     }
871                     break;
872                 }
873               }
874 #endif  /* USB_CDC */
875               goto stall_i;                                              /* not supported */
876               /* end case REQUEST_TO_INTERFACE */
877
878             case REQUEST_TO_ENDPOINT:
879 #if USB_AUDIO
880               switch (SetupPacket.bRequest) {
881                 case AUDIO_REQUEST_GET_CUR:
882                 case AUDIO_REQUEST_GET_MIN:
883                 case AUDIO_REQUEST_GET_MAX:
884                 case AUDIO_REQUEST_GET_RES:
885                   if (ADC_EP_GetRequest()) {
886                     EP0Data.pData = EP0Buf;                              /* point to data to be sent */
887                     USB_DataInStage();                                   /* send requested data */
888                     goto setup_class_ok;
889                   }
890                   break;
891                 case AUDIO_REQUEST_SET_CUR:
892 //              case AUDIO_REQUEST_SET_MIN:
893 //              case AUDIO_REQUEST_SET_MAX:
894 //              case AUDIO_REQUEST_SET_RES:
895                   EP0Data.pData = EP0Buf;                                /* data to be received */
896                   goto setup_class_ok;
897               }
898 #endif  /* USB_AUDIO */
899               goto stall_i;
900               /* end case REQUEST_TO_ENDPOINT */
901
902             default:
903               goto stall_i;
904           }
905 setup_class_ok:                                                          /* request finished successfully */
906           break;  /* end case REQUEST_CLASS */
907 #endif  /* USB_CLASS */
908
909 #if USB_VENDOR
910         case REQUEST_VENDOR:
911           switch (SetupPacket.bmRequestType.BM.Recipient) {
912
913             case REQUEST_TO_DEVICE:
914               if (!USB_ReqVendorDev(TRUE)) {
915                 goto stall_i;                                            /* not supported */
916               }
917               break;
918
919             case REQUEST_TO_INTERFACE:
920               if (!USB_ReqVendorIF(TRUE)) {
921                 goto stall_i;                                            /* not supported */
922               }
923               break;
924
925             case REQUEST_TO_ENDPOINT:
926               if (!USB_ReqVendorEP(TRUE)) {
927                 goto stall_i;                                            /* not supported */
928               }
929               break;
930
931             default:
932               goto stall_i;
933           }
934
935           if (SetupPacket.wLength) {
936             if (SetupPacket.bmRequestType.BM.Dir == REQUEST_DEVICE_TO_HOST) {
937               USB_DataInStage();
938             }
939           } else {
940             USB_StatusInStage();
941           }
942
943           break;  /* end case REQUEST_VENDOR */
944 #endif  /* USB_VENDOR */
945
946         default:
947 stall_i:  USB_SetStallEP(0x80);
948           EP0Data.Count = 0;
949           break;
950       }
951       break;  /* end case USB_EVT_SETUP */
952
953     case USB_EVT_OUT:
954       if (SetupPacket.bmRequestType.BM.Dir == REQUEST_HOST_TO_DEVICE) {
955         if (EP0Data.Count) {                                             /* still data to receive ? */
956           USB_DataOutStage();                                            /* receive data */
957           if (EP0Data.Count == 0) {                                      /* data complete ? */
958             switch (SetupPacket.bmRequestType.BM.Type) {
959
960               case REQUEST_STANDARD:
961                 goto stall_i;                                            /* not supported */
962
963 #if (USB_CLASS)
964               case REQUEST_CLASS:
965                 switch (SetupPacket.bmRequestType.BM.Recipient) {
966                   case REQUEST_TO_DEVICE:
967                     goto stall_i;                                        /* not supported */
968
969                   case REQUEST_TO_INTERFACE:
970 #if USB_HID
971                     if (SetupPacket.wIndex.WB.L == USB_HID_IF_NUM) {     /* IF number correct? */
972                       switch (SetupPacket.bRequest) {
973                         case HID_REQUEST_SET_REPORT:
974                           if (HID_SetReport()) {
975                             USB_StatusInStage();                         /* send Acknowledge */
976                             goto out_class_ok;
977                           }
978                           break;
979                       }
980                     }
981 #endif  /* USB_HID */
982 #if USB_AUDIO
983                     if ((SetupPacket.wIndex.WB.L == USB_ADC_CIF_NUM)  || /* IF number correct? */
984                         (SetupPacket.wIndex.WB.L == USB_ADC_SIF1_NUM) ||
985                         (SetupPacket.wIndex.WB.L == USB_ADC_SIF2_NUM)) {
986                       switch (SetupPacket.bRequest) {
987                         case AUDIO_REQUEST_SET_CUR:
988 //                      case AUDIO_REQUEST_SET_MIN:
989 //                      case AUDIO_REQUEST_SET_MAX:
990 //                      case AUDIO_REQUEST_SET_RES:
991                           if (ADC_IF_SetRequest()) {
992                             USB_StatusInStage();                         /* send Acknowledge */
993                             goto out_class_ok;
994                           }
995                           break;
996                       }
997                     }
998 #endif  /* USB_AUDIO */
999 #if USB_CDC
1000                     if ((SetupPacket.wIndex.WB.L == USB_CDC_CIF_NUM)  || /* IF number correct? */
1001                         (SetupPacket.wIndex.WB.L == USB_CDC_DIF_NUM)) {
1002                       switch (SetupPacket.bRequest) {
1003                         case CDC_SEND_ENCAPSULATED_COMMAND:
1004                           if (CDC_SendEncapsulatedCommand()) {
1005                             USB_StatusInStage();                         /* send Acknowledge */
1006                             goto out_class_ok;
1007                           }
1008                           break;
1009                         case CDC_SET_COMM_FEATURE:
1010                           if (CDC_SetCommFeature(SetupPacket.wValue.W)) {
1011                             USB_StatusInStage();                         /* send Acknowledge */
1012                             goto out_class_ok;
1013                           }
1014                           break;
1015                         case CDC_SET_LINE_CODING:
1016                           if (CDC_SetLineCoding()) {
1017                             USB_StatusInStage();                         /* send Acknowledge */
1018                             goto out_class_ok;
1019                           }
1020                           break;
1021                       }
1022                     }
1023 #endif  /* USB_CDC */
1024                     goto stall_i;
1025                     /* end case REQUEST_TO_INTERFACE */
1026
1027                   case REQUEST_TO_ENDPOINT:
1028 #if USB_AUDIO
1029                     switch (SetupPacket.bRequest) {
1030                       case AUDIO_REQUEST_SET_CUR:
1031 //                    case AUDIO_REQUEST_SET_MIN:
1032 //                    case AUDIO_REQUEST_SET_MAX:
1033 //                    case AUDIO_REQUEST_SET_RES:
1034                         if (ADC_EP_SetRequest()) {
1035                           USB_StatusInStage();                           /* send Acknowledge */
1036                           goto out_class_ok;
1037                         }
1038                         break;
1039                     }
1040 #endif  /* USB_AUDIO */
1041                     goto stall_i;
1042                     /* end case REQUEST_TO_ENDPOINT */
1043
1044                   default:
1045                     goto stall_i;
1046                 }
1047 out_class_ok:                                                            /* request finished successfully */
1048                 break; /* end case REQUEST_CLASS */
1049 #endif  /* USB_CLASS */
1050
1051 #if USB_VENDOR
1052               case REQUEST_VENDOR:
1053                 switch (SetupPacket.bmRequestType.BM.Recipient) {
1054
1055                   case REQUEST_TO_DEVICE:
1056                     if (!USB_ReqVendorDev(FALSE)) {
1057                       goto stall_i;                                      /* not supported */
1058                     }
1059                     break;
1060
1061                   case REQUEST_TO_INTERFACE:
1062                     if (!USB_ReqVendorIF(FALSE)) {
1063                       goto stall_i;                                      /* not supported */
1064                     }
1065                     break;
1066
1067                   case REQUEST_TO_ENDPOINT:
1068                     if (!USB_ReqVendorEP(FALSE)) {
1069                       goto stall_i;                                      /* not supported */
1070                     }
1071                     break;
1072
1073                   default:
1074                     goto stall_i;
1075                 }
1076
1077                 USB_StatusInStage();
1078
1079                 break;  /* end case REQUEST_VENDOR */
1080 #endif  /* USB_VENDOR */
1081
1082               default:
1083                 goto stall_i;
1084             }
1085           }
1086         }
1087       } else {
1088         USB_StatusOutStage();                                            /* receive Acknowledge */
1089       }
1090       break;  /* end case USB_EVT_OUT */
1091
1092     case USB_EVT_IN :
1093       if (SetupPacket.bmRequestType.BM.Dir == REQUEST_DEVICE_TO_HOST) {
1094         USB_DataInStage();                                               /* send data */
1095       } else {
1096         if (USB_DeviceAddress & 0x80) {
1097           USB_DeviceAddress &= 0x7F;
1098           USB_SetAddress(USB_DeviceAddress);
1099         }
1100       }
1101       break;  /* end case USB_EVT_IN */
1102
1103     case USB_EVT_OUT_STALL:
1104       USB_ClrStallEP(0x00);
1105       break;
1106
1107     case USB_EVT_IN_STALL:
1108       USB_ClrStallEP(0x80);
1109       break;
1110
1111   }
1112 }