new_cmsis/usb/usbcore.c

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