git.gag.com Git - fw/stlink/blob - example/stm32f4/STM32_USB_Device_Library/Core/src/usbd_req.c

   1 /**
   2   ******************************************************************************
   3   * @file    usbd_req.c
   4   * @author  MCD Application Team
   5   * @version V1.0.0
   6   * @date    22-July-2011
   7   * @brief   This file provides the standard USB requests following chapter 9.
   8   ******************************************************************************
   9   * @attention
  10   *
  11   * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  12   * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  13   * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  14   * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  15   * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  16   * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  17   *
  18   * <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2>
  19   ******************************************************************************
  20   */
  21
  22 /* Includes ------------------------------------------------------------------*/
  23 #include "usbd_req.h"
  24 #include "usbd_ioreq.h"
  25 #include "usbd_desc.h"
  26
  27
  28 /** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
  29   * @{
  30   */
  31
  32
  33 /** @defgroup USBD_REQ
  34   * @brief USB standard requests module
  35   * @{
  36   */
  37
  38 /** @defgroup USBD_REQ_Private_TypesDefinitions
  39   * @{
  40   */
  41 /**
  42   * @}
  43   */
  44
  45
  46 /** @defgroup USBD_REQ_Private_Defines
  47   * @{
  48   */
  49
  50 /**
  51   * @}
  52   */
  53
  54
  55 /** @defgroup USBD_REQ_Private_Macros
  56   * @{
  57   */
  58 /**
  59   * @}
  60   */
  61
  62
  63 /** @defgroup USBD_REQ_Private_Variables
  64   * @{
  65   */
  66
  67 #ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
  68   #if defined ( __ICCARM__ ) /*!< IAR Compiler */
  69     #pragma data_alignment=4
  70   #endif
  71 #endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
  72 __ALIGN_BEGIN uint32_t USBD_ep_status __ALIGN_END  = 0;
  73
  74 #ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
  75   #if defined ( __ICCARM__ ) /*!< IAR Compiler */
  76     #pragma data_alignment=4
  77   #endif
  78 #endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
  79 __ALIGN_BEGIN uint32_t  USBD_default_cfg __ALIGN_END  = 0;
  80
  81 #ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
  82   #if defined ( __ICCARM__ ) /*!< IAR Compiler */
  83     #pragma data_alignment=4
  84   #endif
  85 #endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
  86 __ALIGN_BEGIN uint32_t  USBD_cfg_status __ALIGN_END  = 0;
  87
  88 #ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
  89   #if defined ( __ICCARM__ ) /*!< IAR Compiler */
  90     #pragma data_alignment=4
  91   #endif
  92 #endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
  93 __ALIGN_BEGIN uint8_t USBD_StrDesc[USB_MAX_STR_DESC_SIZ] __ALIGN_END ;
  94 /**
  95   * @}
  96   */
  97
  98
  99 /** @defgroup USBD_REQ_Private_FunctionPrototypes
 100   * @{
 101   */
 102 static void USBD_GetDescriptor(USB_OTG_CORE_HANDLE  *pdev,
 103                                USB_SETUP_REQ *req);
 104
 105 static void USBD_SetAddress(USB_OTG_CORE_HANDLE  *pdev,
 106                             USB_SETUP_REQ *req);
 107
 108 static void USBD_SetConfig(USB_OTG_CORE_HANDLE  *pdev,
 109                            USB_SETUP_REQ *req);
 110
 111 static void USBD_GetConfig(USB_OTG_CORE_HANDLE  *pdev,
 112                            USB_SETUP_REQ *req);
 113
 114 static void USBD_GetStatus(USB_OTG_CORE_HANDLE  *pdev,
 115                            USB_SETUP_REQ *req);
 116
 117 static void USBD_SetFeature(USB_OTG_CORE_HANDLE  *pdev,
 118                             USB_SETUP_REQ *req);
 119
 120 static void USBD_ClrFeature(USB_OTG_CORE_HANDLE  *pdev,
 121                             USB_SETUP_REQ *req);
 122
 123 static uint8_t USBD_GetLen(uint8_t *buf);
 124 /**
 125   * @}
 126   */
 127
 128
 129 /** @defgroup USBD_REQ_Private_Functions
 130   * @{
 131   */
 132
 133
 134 /**
 135 * @brief  USBD_StdDevReq
 136 *         Handle standard usb device requests
 137 * @param  pdev: device instance
 138 * @param  req: usb request
 139 * @retval status
 140 */
 141 USBD_Status  USBD_StdDevReq (USB_OTG_CORE_HANDLE  *pdev, USB_SETUP_REQ  *req)
 142 {
 143   USBD_Status ret = USBD_OK;
 144
 145   switch (req->bRequest)
 146   {
 147   case USB_REQ_GET_DESCRIPTOR:
 148
 149     USBD_GetDescriptor (pdev, req) ;
 150     break;
 151
 152   case USB_REQ_SET_ADDRESS:
 153     USBD_SetAddress(pdev, req);
 154     break;
 155
 156   case USB_REQ_SET_CONFIGURATION:
 157     USBD_SetConfig (pdev , req);
 158     break;
 159
 160   case USB_REQ_GET_CONFIGURATION:
 161     USBD_GetConfig (pdev , req);
 162     break;
 163
 164   case USB_REQ_GET_STATUS:
 165     USBD_GetStatus (pdev , req);
 166     break;
 167
 168
 169   case USB_REQ_SET_FEATURE:
 170     USBD_SetFeature (pdev , req);
 171     break;
 172
 173   case USB_REQ_CLEAR_FEATURE:
 174     USBD_ClrFeature (pdev , req);
 175     break;
 176
 177   default:
 178     USBD_CtlError(pdev , req);
 179     break;
 180   }
 181
 182   return ret;
 183 }
 184
 185 /**
 186 * @brief  USBD_StdItfReq
 187 *         Handle standard usb interface requests
 188 * @param  pdev: USB OTG device instance
 189 * @param  req: usb request
 190 * @retval status
 191 */
 192 USBD_Status  USBD_StdItfReq (USB_OTG_CORE_HANDLE  *pdev, USB_SETUP_REQ  *req)
 193 {
 194   USBD_Status ret = USBD_OK;
 195
 196   switch (pdev->dev.device_status)
 197   {
 198   case USB_OTG_CONFIGURED:
 199
 200     if (LOBYTE(req->wIndex) <= USBD_ITF_MAX_NUM)
 201     {
 202       pdev->dev.class_cb->Setup (pdev, req);
 203
 204       if((req->wLength == 0)&& (ret == USBD_OK))
 205       {
 206          USBD_CtlSendStatus(pdev);
 207       }
 208     }
 209     else
 210     {
 211        USBD_CtlError(pdev , req);
 212     }
 213     break;
 214
 215   default:
 216      USBD_CtlError(pdev , req);
 217     break;
 218   }
 219   return ret;
 220 }
 221
 222 /**
 223 * @brief  USBD_StdEPReq
 224 *         Handle standard usb endpoint requests
 225 * @param  pdev: USB OTG device instance
 226 * @param  req: usb request
 227 * @retval status
 228 */
 229 USBD_Status  USBD_StdEPReq (USB_OTG_CORE_HANDLE  *pdev, USB_SETUP_REQ  *req)
 230 {
 231
 232   uint8_t   ep_addr;
 233   USBD_Status ret = USBD_OK;
 234
 235   ep_addr  = LOBYTE(req->wIndex);
 236
 237   switch (req->bRequest)
 238   {
 239
 240   case USB_REQ_SET_FEATURE :
 241
 242     switch (pdev->dev.device_status)
 243     {
 244     case USB_OTG_ADDRESSED:
 245       if ((ep_addr != 0x00) && (ep_addr != 0x80))
 246       {
 247         DCD_EP_Stall(pdev , ep_addr);
 248       }
 249       break;
 250
 251     case USB_OTG_CONFIGURED:
 252       if (req->wValue == USB_FEATURE_EP_HALT)
 253       {
 254         if ((ep_addr != 0x00) && (ep_addr != 0x80))
 255         {
 256           DCD_EP_Stall(pdev , ep_addr);
 257
 258         }
 259       }
 260       pdev->dev.class_cb->Setup (pdev, req);
 261       USBD_CtlSendStatus(pdev);
 262
 263       break;
 264
 265     default:
 266       USBD_CtlError(pdev , req);
 267       break;
 268     }
 269     break;
 270
 271   case USB_REQ_CLEAR_FEATURE :
 272
 273     switch (pdev->dev.device_status)
 274     {
 275     case USB_OTG_ADDRESSED:
 276       if ((ep_addr != 0x00) && (ep_addr != 0x80))
 277       {
 278         DCD_EP_Stall(pdev , ep_addr);
 279       }
 280       break;
 281
 282     case USB_OTG_CONFIGURED:
 283       if (req->wValue == USB_FEATURE_EP_HALT)
 284       {
 285         if ((ep_addr != 0x00) && (ep_addr != 0x80))
 286         {
 287           DCD_EP_ClrStall(pdev , ep_addr);
 288           pdev->dev.class_cb->Setup (pdev, req);
 289         }
 290         USBD_CtlSendStatus(pdev);
 291       }
 292       break;
 293
 294     default:
 295        USBD_CtlError(pdev , req);
 296       break;
 297     }
 298     break;
 299
 300   case USB_REQ_GET_STATUS:
 301     switch (pdev->dev.device_status)
 302     {
 303     case USB_OTG_ADDRESSED:
 304       if ((ep_addr != 0x00) && (ep_addr != 0x80))
 305       {
 306         DCD_EP_Stall(pdev , ep_addr);
 307       }
 308       break;
 309
 310     case USB_OTG_CONFIGURED:
 311
 312
 313       if ((ep_addr & 0x80)== 0x80)
 314       {
 315         if(pdev->dev.in_ep[ep_addr & 0x7F].is_stall)
 316         {
 317           USBD_ep_status = 0x0001;
 318         }
 319         else
 320         {
 321           USBD_ep_status = 0x0000;
 322         }
 323       }
 324       else if ((ep_addr & 0x80)== 0x00)
 325       {
 326         if(pdev->dev.out_ep[ep_addr].is_stall)
 327         {
 328           USBD_ep_status = 0x0001;
 329         }
 330
 331         else
 332         {
 333           USBD_ep_status = 0x0000;
 334         }
 335       }
 336       USBD_CtlSendData (pdev,
 337                         (uint8_t *)&USBD_ep_status,
 338                         2);
 339       break;
 340
 341     default:
 342        USBD_CtlError(pdev , req);
 343       break;
 344     }
 345     break;
 346
 347   default:
 348     break;
 349   }
 350   return ret;
 351 }
 352 /**
 353 * @brief  USBD_GetDescriptor
 354 *         Handle Get Descriptor requests
 355 * @param  pdev: device instance
 356 * @param  req: usb request
 357 * @retval status
 358 */
 359 static void USBD_GetDescriptor(USB_OTG_CORE_HANDLE  *pdev,
 360                                USB_SETUP_REQ *req)
 361 {
 362   uint16_t len;
 363   uint8_t *pbuf;
 364
 365   switch (req->wValue >> 8)
 366   {
 367   case USB_DESC_TYPE_DEVICE:
 368     pbuf = pdev->dev.usr_device->GetDeviceDescriptor(pdev->cfg.speed, &len);
 369     if ((req->wLength == 64) ||( pdev->dev.device_status == USB_OTG_DEFAULT))
 370     {
 371       len = 8;
 372     }
 373     break;
 374
 375   case USB_DESC_TYPE_CONFIGURATION:
 376       pbuf   = (uint8_t *)pdev->dev.class_cb->GetConfigDescriptor(pdev->cfg.speed, &len);
 377 #ifdef USB_OTG_HS_CORE
 378     if((pdev->cfg.speed == USB_OTG_SPEED_FULL )&&
 379        (pdev->cfg.phy_itface  == USB_OTG_ULPI_PHY))
 380     {
 381       pbuf   = (uint8_t *)pdev->dev.class_cb->GetOtherConfigDescriptor(pdev->cfg.speed, &len);
 382     }
 383 #endif
 384     pbuf[1] = USB_DESC_TYPE_CONFIGURATION;
 385     pdev->dev.pConfig_descriptor = pbuf;
 386     break;
 387
 388   case USB_DESC_TYPE_STRING:
 389     switch ((uint8_t)(req->wValue))
 390     {
 391     case USBD_IDX_LANGID_STR:
 392      pbuf = pdev->dev.usr_device->GetLangIDStrDescriptor(pdev->cfg.speed, &len);
 393       break;
 394
 395     case USBD_IDX_MFC_STR:
 396       pbuf = pdev->dev.usr_device->GetManufacturerStrDescriptor(pdev->cfg.speed, &len);
 397       break;
 398
 399     case USBD_IDX_PRODUCT_STR:
 400       pbuf = pdev->dev.usr_device->GetProductStrDescriptor(pdev->cfg.speed, &len);
 401       break;
 402
 403     case USBD_IDX_SERIAL_STR:
 404       pbuf = pdev->dev.usr_device->GetSerialStrDescriptor(pdev->cfg.speed, &len);
 405       break;
 406
 407     case USBD_IDX_CONFIG_STR:
 408       pbuf = pdev->dev.usr_device->GetConfigurationStrDescriptor(pdev->cfg.speed, &len);
 409       break;
 410
 411     case USBD_IDX_INTERFACE_STR:
 412       pbuf = pdev->dev.usr_device->GetInterfaceStrDescriptor(pdev->cfg.speed, &len);
 413       break;
 414
 415     default:
 416 #ifdef USB_SUPPORT_USER_STRING_DESC
 417       pbuf = pdev->dev.class_cb->GetUsrStrDescriptor(pdev->cfg.speed, (req->wValue) , &len);
 418       break;
 419 #else
 420        USBD_CtlError(pdev , req);
 421       return;
 422 #endif /* USBD_CtlError(pdev , req); */
 423     }
 424     break;
 425   case USB_DESC_TYPE_DEVICE_QUALIFIER:
 426 #ifdef USB_OTG_HS_CORE
 427     if(pdev->cfg.speed == USB_OTG_SPEED_HIGH  )
 428     {
 429
 430       pbuf   = (uint8_t *)pdev->dev.class_cb->GetConfigDescriptor(pdev->cfg.speed, &len);
 431
 432       USBD_DeviceQualifierDesc[4]= pbuf[14];
 433       USBD_DeviceQualifierDesc[5]= pbuf[15];
 434       USBD_DeviceQualifierDesc[6]= pbuf[16];
 435
 436       pbuf = USBD_DeviceQualifierDesc;
 437       len  = USB_LEN_DEV_QUALIFIER_DESC;
 438       break;
 439     }
 440     else
 441     {
 442       USBD_CtlError(pdev , req);
 443       return;
 444     }
 445 #else
 446       USBD_CtlError(pdev , req);
 447       return;
 448 #endif
 449
 450   case USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION:
 451 #ifdef USB_OTG_HS_CORE
 452
 453     if(pdev->cfg.speed == USB_OTG_SPEED_HIGH  )
 454     {
 455       pbuf   = (uint8_t *)pdev->dev.class_cb->GetOtherConfigDescriptor(pdev->cfg.speed, &len);
 456       pbuf[1] = USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION;
 457       break;
 458     }
 459     else
 460     {
 461       USBD_CtlError(pdev , req);
 462       return;
 463     }
 464 #else
 465       USBD_CtlError(pdev , req);
 466       return;
 467 #endif
 468
 469
 470   default:
 471      USBD_CtlError(pdev , req);
 472     return;
 473   }
 474
 475   if((len != 0)&& (req->wLength != 0))
 476   {
 477
 478     len = MIN(len , req->wLength);
 479
 480     USBD_CtlSendData (pdev,
 481                       pbuf,
 482                       len);
 483   }
 484
 485 }
 486
 487 /**
 488 * @brief  USBD_SetAddress
 489 *         Set device address
 490 * @param  pdev: device instance
 491 * @param  req: usb request
 492 * @retval status
 493 */
 494 static void USBD_SetAddress(USB_OTG_CORE_HANDLE  *pdev,
 495                             USB_SETUP_REQ *req)
 496 {
 497   uint8_t  dev_addr;
 498
 499   if ((req->wIndex == 0) && (req->wLength == 0))
 500   {
 501     dev_addr = (uint8_t)(req->wValue) & 0x7F;
 502
 503     if (pdev->dev.device_status == USB_OTG_CONFIGURED)
 504     {
 505       USBD_CtlError(pdev , req);
 506     }
 507     else
 508     {
 509       pdev->dev.device_address = dev_addr;
 510       DCD_EP_SetAddress(pdev, dev_addr);
 511       USBD_CtlSendStatus(pdev);
 512
 513       if (dev_addr != 0)
 514       {
 515         pdev->dev.device_status  = USB_OTG_ADDRESSED;
 516       }
 517       else
 518       {
 519         pdev->dev.device_status  = USB_OTG_DEFAULT;
 520       }
 521     }
 522   }
 523   else
 524   {
 525      USBD_CtlError(pdev , req);
 526   }
 527 }
 528
 529 /**
 530 * @brief  USBD_SetConfig
 531 *         Handle Set device configuration request
 532 * @param  pdev: device instance
 533 * @param  req: usb request
 534 * @retval status
 535 */
 536 static void USBD_SetConfig(USB_OTG_CORE_HANDLE  *pdev,
 537                            USB_SETUP_REQ *req)
 538 {
 539
 540   static uint8_t  cfgidx;
 541
 542   cfgidx = (uint8_t)(req->wValue);
 543
 544   if (cfgidx > USBD_CFG_MAX_NUM )
 545   {
 546      USBD_CtlError(pdev , req);
 547   }
 548   else
 549   {
 550     switch (pdev->dev.device_status)
 551     {
 552     case USB_OTG_ADDRESSED:
 553       if (cfgidx)
 554       {
 555         pdev->dev.device_config = cfgidx;
 556         pdev->dev.device_status = USB_OTG_CONFIGURED;
 557         USBD_SetCfg(pdev , cfgidx);
 558         USBD_CtlSendStatus(pdev);
 559       }
 560       else
 561       {
 562          USBD_CtlSendStatus(pdev);
 563       }
 564       break;
 565
 566     case USB_OTG_CONFIGURED:
 567       if (cfgidx == 0)
 568       {
 569         pdev->dev.device_status = USB_OTG_ADDRESSED;
 570         pdev->dev.device_config = cfgidx;
 571         USBD_ClrCfg(pdev , cfgidx);
 572         USBD_CtlSendStatus(pdev);
 573
 574       }
 575       else  if (cfgidx != pdev->dev.device_config)
 576       {
 577         /* Clear old configuration */
 578         USBD_ClrCfg(pdev , pdev->dev.device_config);
 579
 580         /* set new configuration */
 581         pdev->dev.device_config = cfgidx;
 582         USBD_SetCfg(pdev , cfgidx);
 583         USBD_CtlSendStatus(pdev);
 584       }
 585       else
 586       {
 587         USBD_CtlSendStatus(pdev);
 588       }
 589       break;
 590
 591     default:
 592        USBD_CtlError(pdev , req);
 593       break;
 594     }
 595   }
 596 }
 597
 598 /**
 599 * @brief  USBD_GetConfig
 600 *         Handle Get device configuration request
 601 * @param  pdev: device instance
 602 * @param  req: usb request
 603 * @retval status
 604 */
 605 static void USBD_GetConfig(USB_OTG_CORE_HANDLE  *pdev,
 606                            USB_SETUP_REQ *req)
 607 {
 608
 609   if (req->wLength != 1)
 610   {
 611      USBD_CtlError(pdev , req);
 612   }
 613   else
 614   {
 615     switch (pdev->dev.device_status )
 616     {
 617     case USB_OTG_ADDRESSED:
 618
 619       USBD_CtlSendData (pdev,
 620                         (uint8_t *)&USBD_default_cfg,
 621                         1);
 622       break;
 623
 624     case USB_OTG_CONFIGURED:
 625
 626       USBD_CtlSendData (pdev,
 627                         &pdev->dev.device_config,
 628                         1);
 629       break;
 630
 631     default:
 632        USBD_CtlError(pdev , req);
 633       break;
 634     }
 635   }
 636 }
 637
 638 /**
 639 * @brief  USBD_GetStatus
 640 *         Handle Get Status request
 641 * @param  pdev: device instance
 642 * @param  req: usb request
 643 * @retval status
 644 */
 645 static void USBD_GetStatus(USB_OTG_CORE_HANDLE  *pdev,
 646                            USB_SETUP_REQ *req)
 647 {
 648
 649   switch (pdev->dev.device_status)
 650   {
 651   case USB_OTG_ADDRESSED:
 652   case USB_OTG_CONFIGURED:
 653
 654     if (pdev->dev.DevRemoteWakeup)
 655     {
 656       USBD_cfg_status = USB_CONFIG_SELF_POWERED | USB_CONFIG_REMOTE_WAKEUP;
 657     }
 658     else
 659     {
 660       USBD_cfg_status = USB_CONFIG_SELF_POWERED;
 661     }
 662
 663     USBD_CtlSendData (pdev,
 664                       (uint8_t *)&USBD_cfg_status,
 665                       1);
 666     break;
 667
 668   default :
 669     USBD_CtlError(pdev , req);
 670     break;
 671   }
 672 }
 673
 674
 675 /**
 676 * @brief  USBD_SetFeature
 677 *         Handle Set device feature request
 678 * @param  pdev: device instance
 679 * @param  req: usb request
 680 * @retval status
 681 */
 682 static void USBD_SetFeature(USB_OTG_CORE_HANDLE  *pdev,
 683                             USB_SETUP_REQ *req)
 684 {
 685
 686   USB_OTG_DCTL_TypeDef     dctl;
 687   uint8_t test_mode = 0;
 688
 689   if (req->wValue == USB_FEATURE_REMOTE_WAKEUP)
 690   {
 691     pdev->dev.DevRemoteWakeup = 1;
 692     pdev->dev.class_cb->Setup (pdev, req);
 693     USBD_CtlSendStatus(pdev);
 694   }
 695
 696   else if ((req->wValue == USB_FEATURE_TEST_MODE) &&
 697            ((req->wIndex & 0xFF) == 0))
 698   {
 699     dctl.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DCTL);
 700
 701     test_mode = req->wIndex >> 8;
 702     switch (test_mode)
 703     {
 704     case 1: // TEST_J
 705       dctl.b.tstctl = 1;
 706       break;
 707
 708     case 2: // TEST_K
 709       dctl.b.tstctl = 2;
 710       break;
 711
 712     case 3: // TEST_SE0_NAK
 713       dctl.b.tstctl = 3;
 714       break;
 715
 716     case 4: // TEST_PACKET
 717       dctl.b.tstctl = 4;
 718       break;
 719
 720     case 5: // TEST_FORCE_ENABLE
 721       dctl.b.tstctl = 5;
 722       break;
 723     }
 724     USB_OTG_WRITE_REG32(&pdev->regs.DREGS->DCTL, dctl.d32);
 725     USBD_CtlSendStatus(pdev);
 726   }
 727
 728 }
 729
 730
 731 /**
 732 * @brief  USBD_ClrFeature
 733 *         Handle clear device feature request
 734 * @param  pdev: device instance
 735 * @param  req: usb request
 736 * @retval status
 737 */
 738 static void USBD_ClrFeature(USB_OTG_CORE_HANDLE  *pdev,
 739                             USB_SETUP_REQ *req)
 740 {
 741   switch (pdev->dev.device_status)
 742   {
 743   case USB_OTG_ADDRESSED:
 744   case USB_OTG_CONFIGURED:
 745     if (req->wValue == USB_FEATURE_REMOTE_WAKEUP)
 746     {
 747       pdev->dev.DevRemoteWakeup = 0;
 748       pdev->dev.class_cb->Setup (pdev, req);
 749       USBD_CtlSendStatus(pdev);
 750     }
 751     break;
 752
 753   default :
 754      USBD_CtlError(pdev , req);
 755     break;
 756   }
 757 }
 758
 759 /**
 760 * @brief  USBD_ParseSetupRequest
 761 *         Copy buffer into setup structure
 762 * @param  pdev: device instance
 763 * @param  req: usb request
 764 * @retval None
 765 */
 766
 767 void USBD_ParseSetupRequest( USB_OTG_CORE_HANDLE  *pdev,
 768                             USB_SETUP_REQ *req)
 769 {
 770   req->bmRequest     = *(uint8_t *)  (pdev->dev.setup_packet);
 771   req->bRequest      = *(uint8_t *)  (pdev->dev.setup_packet +  1);
 772   req->wValue        = SWAPBYTE      (pdev->dev.setup_packet +  2);
 773   req->wIndex        = SWAPBYTE      (pdev->dev.setup_packet +  4);
 774   req->wLength       = SWAPBYTE      (pdev->dev.setup_packet +  6);
 775
 776   pdev->dev.in_ep[0].ctl_data_len = req->wLength  ;
 777   pdev->dev.device_state = USB_OTG_EP0_SETUP;
 778 }
 779
 780 /**
 781 * @brief  USBD_CtlError
 782 *         Handle USB low level Error
 783 * @param  pdev: device instance
 784 * @param  req: usb request
 785 * @retval None
 786 */
 787
 788 void USBD_CtlError( USB_OTG_CORE_HANDLE  *pdev,
 789                             USB_SETUP_REQ *req)
 790 {
 791   if((req->bmRequest & 0x80) == 0x80)
 792   {
 793     DCD_EP_Stall(pdev , 0x80);
 794   }
 795   else
 796   {
 797     if(req->wLength == 0)
 798     {
 799        DCD_EP_Stall(pdev , 0x80);
 800     }
 801     else
 802     {
 803       DCD_EP_Stall(pdev , 0);
 804     }
 805   }
 806   USB_OTG_EP0_OutStart(pdev);
 807 }
 808
 809
 810 /**
 811   * @brief  USBD_GetString
 812   *         Convert Ascii string into unicode one
 813   * @param  desc : descriptor buffer
 814   * @param  unicode : Formatted string buffer (unicode)
 815   * @param  len : descriptor length
 816   * @retval None
 817   */
 818 void USBD_GetString(uint8_t *desc, uint8_t *unicode, uint16_t *len)
 819 {
 820   uint8_t idx = 0;
 821
 822   if (desc != NULL)
 823   {
 824     *len =  USBD_GetLen(desc) * 2 + 2;
 825     unicode[idx++] = *len;
 826     unicode[idx++] =  USB_DESC_TYPE_STRING;
 827
 828     while (*desc != NULL)
 829     {
 830       unicode[idx++] = *desc++;
 831       unicode[idx++] =  0x00;
 832     }
 833   }
 834 }
 835
 836 /**
 837   * @brief  USBD_GetLen
 838   *         return the string length
 839    * @param  buf : pointer to the ascii string buffer
 840   * @retval string length
 841   */
 842 static uint8_t USBD_GetLen(uint8_t *buf)
 843 {
 844     uint8_t  len = 0;
 845
 846     while (*buf != NULL)
 847     {
 848         len++;
 849         buf++;
 850     }
 851
 852     return len;
 853 }
 854 /**
 855   * @}
 856   */
 857
 858
 859 /**
 860   * @}
 861   */
 862
 863
 864 /**
 865   * @}
 866   */
 867
 868 /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/