jmg
/
lora-irrigation
1
0
Derivar 0
Código Questões 0 Pedidos de integração 0 Lançamentos 0 Wiki Trabalho
Implement a secure ICS protocol targeting LoRa Node151 microcontroller for controlling irrigation.
Não pode escolher mais do que 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
177 Cometimentos
4 Ramos
18 MiB
 
 
 
 
 
 
Árvore: a4f76dc0bb
Ramos Etiquetas
${ item.name }
Criar ramo ${ searchTerm }
de 'a4f76dc0bb'
${ noResults }
lora-irrigation/stm32/usb/usbd_ctlreq.c

849 linhas
18 KiB
Em bruto Responsabilidade Histórico 

  1. /**

  2.   ******************************************************************************

  3.   * @file    usbd_req.c

  4.   * @author  MCD Application Team

  5.   * @brief   This file provides the standard USB requests following chapter 9.

  6.   ******************************************************************************

  7.   * @attention

  8.   *

  9.   * <h2><center>&copy; Copyright (c) 2015 STMicroelectronics.

  10.   * All rights reserved.</center></h2>

  11.   *

  12.   * This software component is licensed by ST under Ultimate Liberty license

  13.   * SLA0044, the "License"; You may not use this file except in compliance with

  14.   * the License. You may obtain a copy of the License at:

  15.   *                      http://www.st.com/SLA0044

  16.   *

  17.   ******************************************************************************

  18.   */

  19. 

  20. /* Includes ------------------------------------------------------------------*/

  21. #include "usbd_ctlreq.h"

  22. #include "usbd_ioreq.h"

  23. 

  24. 

  25. /** @addtogroup STM32_USBD_STATE_DEVICE_LIBRARY

  26.   * @{

  27.   */

  28. 

  29. 

  30. /** @defgroup USBD_REQ

  31.   * @brief USB standard requests module

  32.   * @{

  33.   */

  34. 

  35. /** @defgroup USBD_REQ_Private_TypesDefinitions

  36.   * @{

  37.   */

  38. /**

  39.   * @}

  40.   */

  41. 

  42. 

  43. /** @defgroup USBD_REQ_Private_Defines

  44.   * @{

  45.   */

  46. 

  47. /**

  48.   * @}

  49.   */

  50. 

  51. 

  52. /** @defgroup USBD_REQ_Private_Macros

  53.   * @{

  54.   */

  55. /**

  56.   * @}

  57.   */

  58. 

  59. 

  60. /** @defgroup USBD_REQ_Private_Variables

  61.   * @{

  62.   */

  63. /**

  64.   * @}

  65.   */

  66. 

  67. 

  68. /** @defgroup USBD_REQ_Private_FunctionPrototypes

  69.   * @{

  70.   */

  71. static void USBD_GetDescriptor(USBD_HandleTypeDef *pdev ,

  72.                                USBD_SetupReqTypedef *req);

  73. 

  74. static void USBD_SetAddress(USBD_HandleTypeDef *pdev ,

  75.                             USBD_SetupReqTypedef *req);

  76. 

  77. static void USBD_SetConfig(USBD_HandleTypeDef *pdev ,

  78.                            USBD_SetupReqTypedef *req);

  79. 

  80. static void USBD_GetConfig(USBD_HandleTypeDef *pdev ,

  81.                            USBD_SetupReqTypedef *req);

  82. 

  83. static void USBD_GetStatus(USBD_HandleTypeDef *pdev ,

  84.                            USBD_SetupReqTypedef *req);

  85. 

  86. static void USBD_SetFeature(USBD_HandleTypeDef *pdev ,

  87.                             USBD_SetupReqTypedef *req);

  88. 

  89. static void USBD_ClrFeature(USBD_HandleTypeDef *pdev ,

  90.                             USBD_SetupReqTypedef *req);

  91. 

  92. static uint8_t USBD_GetLen(uint8_t *buf);

  93. 

  94. /**

  95.   * @}

  96.   */

  97. 

  98. 

  99. /** @defgroup USBD_REQ_Private_Functions

  100.   * @{

  101.   */

  102. 

  103. 

  104. /**

  105. * @brief  USBD_StdDevReq

  106. *         Handle standard usb device requests

  107. * @param  pdev: device instance

  108. * @param  req: usb request

  109. * @retval status

  110. */

  111. USBD_StatusTypeDef  USBD_StdDevReq (USBD_HandleTypeDef *pdev , USBD_SetupReqTypedef  *req)

  112. {

  113.   USBD_StatusTypeDef ret = USBD_OK;

  114. 

  115.   switch (req->bmRequest & USB_REQ_TYPE_MASK)

  116.   {

  117.   case USB_REQ_TYPE_CLASS:

  118.   case USB_REQ_TYPE_VENDOR:

  119.     pdev->pClass->Setup(pdev, req);

  120.     break;

  121. 

  122.   case USB_REQ_TYPE_STANDARD:

  123. 

  124.     switch (req->bRequest)

  125.     {

  126.     case USB_REQ_GET_DESCRIPTOR:

  127. 

  128.       USBD_GetDescriptor (pdev, req);

  129.       break;

  130. 

  131.     case USB_REQ_SET_ADDRESS:

  132.       USBD_SetAddress (pdev, req);

  133.       break;

  134. 

  135.     case USB_REQ_SET_CONFIGURATION:

  136.       USBD_SetConfig (pdev, req);

  137.       break;

  138. 

  139.     case USB_REQ_GET_CONFIGURATION:

  140.       USBD_GetConfig (pdev, req);

  141.       break;

  142. 

  143.     case USB_REQ_GET_STATUS:

  144.       USBD_GetStatus (pdev, req);

  145.       break;

  146. 

  147. 

  148.     case USB_REQ_SET_FEATURE:

  149.       USBD_SetFeature (pdev, req);

  150.       break;

  151. 

  152.     case USB_REQ_CLEAR_FEATURE:

  153.       USBD_ClrFeature (pdev, req);

  154.       break;

  155. 

  156.     default:

  157.       USBD_CtlError(pdev, req);

  158.       break;

  159.     }

  160.     break;

  161. 

  162.   default:

  163.     USBD_CtlError(pdev, req);

  164.     break;

  165.   }

  166. 

  167.   return ret;

  168. }

  169. 

  170. /**

  171. * @brief  USBD_StdItfReq

  172. *         Handle standard usb interface requests

  173. * @param  pdev: device instance

  174. * @param  req: usb request

  175. * @retval status

  176. */

  177. USBD_StatusTypeDef  USBD_StdItfReq (USBD_HandleTypeDef *pdev , USBD_SetupReqTypedef  *req)

  178. {

  179.   USBD_StatusTypeDef ret = USBD_OK;

  180. 

  181.   switch (req->bmRequest & USB_REQ_TYPE_MASK)

  182.   {

  183.   case USB_REQ_TYPE_CLASS:

  184.   case USB_REQ_TYPE_VENDOR:

  185.   case USB_REQ_TYPE_STANDARD:

  186.     switch (pdev->dev_state)

  187.     {

  188.     case USBD_STATE_DEFAULT:

  189.     case USBD_STATE_ADDRESSED:

  190.     case USBD_STATE_CONFIGURED:

  191. 

  192.       if (LOBYTE(req->wIndex) <= USBD_MAX_NUM_INTERFACES)

  193.       {

  194.         ret = (USBD_StatusTypeDef)pdev->pClass->Setup (pdev, req);

  195. 

  196.         if ((req->wLength == 0U) && (ret == USBD_OK))

  197.         {

  198.           USBD_CtlSendStatus(pdev);

  199.         }

  200.       }

  201.       else

  202.       {

  203.         USBD_CtlError(pdev, req);

  204.       }

  205.       break;

  206. 

  207.     default:

  208.       USBD_CtlError(pdev, req);

  209.       break;

  210.     }

  211.     break;

  212. 

  213.   default:

  214.     USBD_CtlError(pdev, req);

  215.     break;

  216.   }

  217. 

  218.   return USBD_OK;

  219. }

  220. 

  221. /**

  222. * @brief  USBD_StdEPReq

  223. *         Handle standard usb endpoint requests

  224. * @param  pdev: device instance

  225. * @param  req: usb request

  226. * @retval status

  227. */

  228. USBD_StatusTypeDef  USBD_StdEPReq (USBD_HandleTypeDef *pdev , USBD_SetupReqTypedef  *req)

  229. {

  230. 

  231.   uint8_t   ep_addr;

  232.   USBD_StatusTypeDef ret = USBD_OK;

  233.   USBD_EndpointTypeDef   *pep;

  234.   ep_addr  = LOBYTE(req->wIndex);

  235. 

  236.   switch (req->bmRequest & USB_REQ_TYPE_MASK)

  237.   {

  238. 

  239.   case USB_REQ_TYPE_CLASS:

  240.   case USB_REQ_TYPE_VENDOR:

  241.     pdev->pClass->Setup (pdev, req);

  242.     break;

  243. 

  244.   case USB_REQ_TYPE_STANDARD:

  245.     /* Check if it is a class request */

  246.     if ((req->bmRequest & 0x60U) == 0x20U)

  247.     {

  248.       ret = (USBD_StatusTypeDef)pdev->pClass->Setup (pdev, req);

  249. 

  250.       return ret;

  251.     }

  252. 

  253.     switch (req->bRequest)

  254.     {

  255. 

  256.     case USB_REQ_SET_FEATURE :

  257. 

  258.       switch (pdev->dev_state)

  259.       {

  260.       case USBD_STATE_ADDRESSED:

  261.         if ((ep_addr != 0x00U) && (ep_addr != 0x80U))

  262.         {

  263.           USBD_LL_StallEP(pdev, ep_addr);

  264.           USBD_LL_StallEP(pdev, 0x80U);

  265.         }

  266.         else

  267.         {

  268.           USBD_CtlError(pdev, req);

  269.         }

  270.         break;

  271. 

  272.       case USBD_STATE_CONFIGURED:

  273.         if (req->wValue == USB_FEATURE_EP_HALT)

  274.         {

  275.           if ((ep_addr != 0x00U) && (ep_addr != 0x80U) && (req->wLength == 0x00U))

  276.           {

  277.             USBD_LL_StallEP(pdev, ep_addr);

  278.           }

  279.         }

  280.         USBD_CtlSendStatus(pdev);

  281. 

  282.         break;

  283. 

  284.       default:

  285.         USBD_CtlError(pdev, req);

  286.         break;

  287.       }

  288.       break;

  289. 

  290.     case USB_REQ_CLEAR_FEATURE :

  291. 

  292.       switch (pdev->dev_state)

  293.       {

  294.       case USBD_STATE_ADDRESSED:

  295.         if ((ep_addr != 0x00U) && (ep_addr != 0x80U))

  296.         {

  297.           USBD_LL_StallEP(pdev, ep_addr);

  298.           USBD_LL_StallEP(pdev, 0x80U);

  299.         }

  300.         else

  301.         {

  302.           USBD_CtlError(pdev, req);

  303.         }

  304.         break;

  305. 

  306.       case USBD_STATE_CONFIGURED:

  307.         if (req->wValue == USB_FEATURE_EP_HALT)

  308.         {

  309.           if ((ep_addr & 0x7FU) != 0x00U)

  310.           {

  311.             USBD_LL_ClearStallEP(pdev, ep_addr);

  312.           }

  313.           USBD_CtlSendStatus(pdev);

  314.         }

  315.         break;

  316. 

  317.       default:

  318.         USBD_CtlError(pdev, req);

  319.         break;

  320.       }

  321.       break;

  322. 

  323.     case USB_REQ_GET_STATUS:

  324.       switch (pdev->dev_state)

  325.       {

  326.       case USBD_STATE_ADDRESSED:

  327.         if ((ep_addr != 0x00U) && (ep_addr != 0x80U))

  328.         {

  329.           USBD_CtlError(pdev, req);

  330.           break;

  331.         }

  332.         pep = ((ep_addr & 0x80U) == 0x80U) ? &pdev->ep_in[ep_addr & 0x7FU]:\

  333.           &pdev->ep_out[ep_addr & 0x7FU];

  334. 

  335.           pep->status = 0x0000U;

  336. 

  337.           USBD_CtlSendData (pdev, (uint8_t *)(void *)&pep->status, 2U);

  338.           break;

  339. 

  340.       case USBD_STATE_CONFIGURED:

  341.         if((ep_addr & 0x80U) == 0x80U)

  342.         {

  343.           if (pdev->ep_in[ep_addr & 0xFU].is_used == 0U)

  344.           {

  345.             USBD_CtlError(pdev, req);

  346.             break;

  347.           }

  348.         }

  349.         else

  350.         {

  351.           if (pdev->ep_out[ep_addr & 0xFU].is_used == 0U)

  352.           {

  353.             USBD_CtlError(pdev, req);

  354.             break;

  355.           }

  356.         }

  357. 

  358.         pep = ((ep_addr & 0x80U) == 0x80U) ? &pdev->ep_in[ep_addr & 0x7FU]:\

  359.           &pdev->ep_out[ep_addr & 0x7FU];

  360. 

  361.           if ((ep_addr == 0x00U) || (ep_addr == 0x80U))

  362.           {

  363.             pep->status = 0x0000U;

  364.           }

  365.           else if(USBD_LL_IsStallEP(pdev, ep_addr))

  366.           {

  367.             pep->status = 0x0001U;

  368.           }

  369.           else

  370.           {

  371.             pep->status = 0x0000U;

  372.           }

  373. 

  374.           USBD_CtlSendData (pdev, (uint8_t *)(void *)&pep->status, 2U);

  375.           break;

  376. 

  377.       default:

  378.         USBD_CtlError(pdev, req);

  379.         break;

  380.       }

  381.       break;

  382. 

  383.     default:

  384.       USBD_CtlError(pdev, req);

  385.       break;

  386.     }

  387.     break;

  388. 

  389.   default:

  390.     USBD_CtlError(pdev, req);

  391.     break;

  392.   }

  393. 

  394.   return ret;

  395. }

  396. /**

  397. * @brief  USBD_GetDescriptor

  398. *         Handle Get Descriptor requests

  399. * @param  pdev: device instance

  400. * @param  req: usb request

  401. * @retval status

  402. */

  403. static void USBD_GetDescriptor(USBD_HandleTypeDef *pdev ,

  404.                                USBD_SetupReqTypedef *req)

  405. {

  406.   uint16_t len;

  407.   uint8_t *pbuf;

  408. 

  409. 

  410.   switch (req->wValue >> 8)

  411.   {

  412. #if (USBD_LPM_ENABLED == 1U)

  413.   case USB_DESC_TYPE_BOS:

  414.     pbuf = pdev->pDesc->GetBOSDescriptor(pdev->dev_speed, &len);

  415.     break;

  416. #endif

  417.   case USB_DESC_TYPE_DEVICE:

  418.     pbuf = pdev->pDesc->GetDeviceDescriptor(pdev->dev_speed, &len);

  419.     break;

  420. 

  421.   case USB_DESC_TYPE_CONFIGURATION:

  422.     if(pdev->dev_speed == USBD_SPEED_HIGH )

  423.     {

  424.       pbuf   = (uint8_t *)pdev->pClass->GetHSConfigDescriptor(&len);

  425.       pbuf[1] = USB_DESC_TYPE_CONFIGURATION;

  426.     }

  427.     else

  428.     {

  429.       pbuf   = (uint8_t *)pdev->pClass->GetFSConfigDescriptor(&len);

  430.       pbuf[1] = USB_DESC_TYPE_CONFIGURATION;

  431.     }

  432.     break;

  433. 

  434.   case USB_DESC_TYPE_STRING:

  435.     switch ((uint8_t)(req->wValue))

  436.     {

  437.     case USBD_IDX_LANGID_STR:

  438.      pbuf = pdev->pDesc->GetLangIDStrDescriptor(pdev->dev_speed, &len);

  439.       break;

  440. 

  441.     case USBD_IDX_MFC_STR:

  442.       pbuf = pdev->pDesc->GetManufacturerStrDescriptor(pdev->dev_speed, &len);

  443.       break;

  444. 

  445.     case USBD_IDX_PRODUCT_STR:

  446.       pbuf = pdev->pDesc->GetProductStrDescriptor(pdev->dev_speed, &len);

  447.       break;

  448. 

  449.     case USBD_IDX_SERIAL_STR:

  450.       pbuf = pdev->pDesc->GetSerialStrDescriptor(pdev->dev_speed, &len);

  451.       break;

  452. 

  453.     case USBD_IDX_CONFIG_STR:

  454.       pbuf = pdev->pDesc->GetConfigurationStrDescriptor(pdev->dev_speed, &len);

  455.       break;

  456. 

  457.     case USBD_IDX_INTERFACE_STR:

  458.       pbuf = pdev->pDesc->GetInterfaceStrDescriptor(pdev->dev_speed, &len);

  459.       break;

  460. 

  461.     default:

  462. #if (USBD_SUPPORT_USER_STRING == 1U)

  463.       pbuf = pdev->pClass->GetUsrStrDescriptor(pdev, (req->wValue) , &len);

  464.       break;

  465. #else

  466.        USBD_CtlError(pdev , req);

  467.       return;

  468. #endif

  469.     }

  470.     break;

  471.   case USB_DESC_TYPE_DEVICE_QUALIFIER:

  472. 

  473.     if(pdev->dev_speed == USBD_SPEED_HIGH)

  474.     {

  475.       pbuf = (uint8_t *)pdev->pClass->GetDeviceQualifierDescriptor(&len);

  476.       break;

  477.     }

  478.     else

  479.     {

  480.       USBD_CtlError(pdev , req);

  481.       return;

  482.     }

  483. 

  484.   case USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION:

  485.     if(pdev->dev_speed == USBD_SPEED_HIGH  )

  486.     {

  487.       pbuf   = (uint8_t *)pdev->pClass->GetOtherSpeedConfigDescriptor(&len);

  488.       pbuf[1] = USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION;

  489.       break;

  490.     }

  491.     else

  492.     {

  493.       USBD_CtlError(pdev , req);

  494.       return;

  495.     }

  496. 

  497.   default:

  498.      USBD_CtlError(pdev , req);

  499.     return;

  500.   }

  501. 

  502.   if((len != 0U) && (req->wLength != 0U))

  503.   {

  504. 

  505.     len = MIN(len, req->wLength);

  506. 

  507.     USBD_CtlSendData (pdev, pbuf, len);

  508.   }

  509. 

  510.   if(req->wLength == 0U)

  511.   {

  512.    USBD_CtlSendStatus(pdev);

  513.   }

  514. }

  515. 

  516. /**

  517. * @brief  USBD_SetAddress

  518. *         Set device address

  519. * @param  pdev: device instance

  520. * @param  req: usb request

  521. * @retval status

  522. */

  523. static void USBD_SetAddress(USBD_HandleTypeDef *pdev ,

  524.                             USBD_SetupReqTypedef *req)

  525. {

  526.   uint8_t  dev_addr;

  527. 

  528.   if ((req->wIndex == 0U) && (req->wLength == 0U) && (req->wValue < 128U))

  529.   {

  530.     dev_addr = (uint8_t)(req->wValue) & 0x7FU;

  531. 

  532.     if (pdev->dev_state == USBD_STATE_CONFIGURED)

  533.     {

  534.       USBD_CtlError(pdev , req);

  535.     }

  536.     else

  537.     {

  538.       pdev->dev_address = dev_addr;

  539.       USBD_LL_SetUSBAddress(pdev, dev_addr);

  540.       USBD_CtlSendStatus(pdev);

  541. 

  542.       if (dev_addr != 0U)

  543.       {

  544.         pdev->dev_state = USBD_STATE_ADDRESSED;

  545.       }

  546.       else

  547.       {

  548.         pdev->dev_state = USBD_STATE_DEFAULT;

  549.       }

  550.     }

  551.   }

  552.   else

  553.   {

  554.     USBD_CtlError(pdev, req);

  555.   }

  556. }

  557. 

  558. /**

  559. * @brief  USBD_SetConfig

  560. *         Handle Set device configuration request

  561. * @param  pdev: device instance

  562. * @param  req: usb request

  563. * @retval status

  564. */

  565. static void USBD_SetConfig(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)

  566. {

  567.   static uint8_t cfgidx;

  568. 

  569.   cfgidx = (uint8_t)(req->wValue);

  570. 

  571.   if (cfgidx > USBD_MAX_NUM_CONFIGURATION)

  572.   {

  573.     USBD_CtlError(pdev, req);

  574.   }

  575.   else

  576.   {

  577.     switch (pdev->dev_state)

  578.     {

  579.     case USBD_STATE_ADDRESSED:

  580.       if (cfgidx)

  581.       {

  582.         pdev->dev_config = cfgidx;

  583.         pdev->dev_state = USBD_STATE_CONFIGURED;

  584.         if(USBD_SetClassConfig(pdev, cfgidx) == USBD_FAIL)

  585.         {

  586.           USBD_CtlError(pdev, req);

  587.           return;

  588.         }

  589.         USBD_CtlSendStatus(pdev);

  590.       }

  591.       else

  592.       {

  593.         USBD_CtlSendStatus(pdev);

  594.       }

  595.       break;

  596. 

  597.     case USBD_STATE_CONFIGURED:

  598.       if (cfgidx == 0U)

  599.       {

  600.         pdev->dev_state = USBD_STATE_ADDRESSED;

  601.         pdev->dev_config = cfgidx;

  602.         USBD_ClrClassConfig(pdev, cfgidx);

  603.         USBD_CtlSendStatus(pdev);

  604.       }

  605.       else if (cfgidx != pdev->dev_config)

  606.       {

  607.         /* Clear old configuration */

  608.         USBD_ClrClassConfig(pdev, (uint8_t)pdev->dev_config);

  609. 

  610.         /* set new configuration */

  611.         pdev->dev_config = cfgidx;

  612.         if(USBD_SetClassConfig(pdev, cfgidx) == USBD_FAIL)

  613.         {

  614.           USBD_CtlError(pdev, req);

  615.           return;

  616.         }

  617.         USBD_CtlSendStatus(pdev);

  618.       }

  619.       else

  620.       {

  621.         USBD_CtlSendStatus(pdev);

  622.       }

  623.       break;

  624. 

  625.     default:

  626.       USBD_CtlError(pdev, req);

  627.       USBD_ClrClassConfig(pdev, cfgidx);

  628.       break;

  629.     }

  630.   }

  631. }

  632. 

  633. /**

  634. * @brief  USBD_GetConfig

  635. *         Handle Get device configuration request

  636. * @param  pdev: device instance

  637. * @param  req: usb request

  638. * @retval status

  639. */

  640. static void USBD_GetConfig(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)

  641. {

  642.   if (req->wLength != 1U)

  643.   {

  644.     USBD_CtlError(pdev , req);

  645.   }

  646.   else

  647.   {

  648.     switch (pdev->dev_state)

  649.     {

  650.     case USBD_STATE_DEFAULT:

  651.     case USBD_STATE_ADDRESSED:

  652.       pdev->dev_default_config = 0U;

  653.       USBD_CtlSendData (pdev, (uint8_t *)(void *)&pdev->dev_default_config, 1U);

  654.       break;

  655. 

  656.     case USBD_STATE_CONFIGURED:

  657.       USBD_CtlSendData (pdev, (uint8_t *)(void *)&pdev->dev_config, 1U);

  658.       break;

  659. 

  660.     default:

  661.       USBD_CtlError(pdev , req);

  662.       break;

  663.     }

  664.   }

  665. }

  666. 

  667. /**

  668. * @brief  USBD_GetStatus

  669. *         Handle Get Status request

  670. * @param  pdev: device instance

  671. * @param  req: usb request

  672. * @retval status

  673. */

  674. static void USBD_GetStatus(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req)

  675. {

  676.   switch (pdev->dev_state)

  677.   {

  678.   case USBD_STATE_DEFAULT:

  679.   case USBD_STATE_ADDRESSED:

  680.   case USBD_STATE_CONFIGURED:

  681.     if(req->wLength != 0x2U)

  682.     {

  683.       USBD_CtlError(pdev, req);

  684.       break;

  685.     }

  686. 

  687. #if ( USBD_SELF_POWERED == 1U)

  688.     pdev->dev_config_status = USB_CONFIG_SELF_POWERED;

  689. #else

  690.     pdev->dev_config_status = 0U;

  691. #endif

  692. 

  693.     if (pdev->dev_remote_wakeup)

  694.     {

  695.       pdev->dev_config_status |= USB_CONFIG_REMOTE_WAKEUP;

  696.     }

  697. 

  698.     USBD_CtlSendData (pdev, (uint8_t *)(void *)&pdev->dev_config_status, 2U);

  699.     break;

  700. 

  701.   default :

  702.     USBD_CtlError(pdev , req);

  703.     break;

  704.   }

  705. }

  706. 

  707. 

  708. /**

  709. * @brief  USBD_SetFeature

  710. *         Handle Set device feature request

  711. * @param  pdev: device instance

  712. * @param  req: usb request

  713. * @retval status

  714. */

  715. static void USBD_SetFeature(USBD_HandleTypeDef *pdev ,

  716.                             USBD_SetupReqTypedef *req)

  717. {

  718. 

  719.   if (req->wValue == USB_FEATURE_REMOTE_WAKEUP)

  720.   {

  721.     pdev->dev_remote_wakeup = 1U;

  722.     USBD_CtlSendStatus(pdev);

  723.   }

  724. 

  725. }

  726. 

  727. 

  728. /**

  729. * @brief  USBD_ClrFeature

  730. *         Handle clear device feature request

  731. * @param  pdev: device instance

  732. * @param  req: usb request

  733. * @retval status

  734. */

  735. static void USBD_ClrFeature(USBD_HandleTypeDef *pdev ,

  736.                             USBD_SetupReqTypedef *req)

  737. {

  738.   switch (pdev->dev_state)

  739.   {

  740.   case USBD_STATE_DEFAULT:

  741.   case USBD_STATE_ADDRESSED:

  742.   case USBD_STATE_CONFIGURED:

  743.     if (req->wValue == USB_FEATURE_REMOTE_WAKEUP)

  744.     {

  745.       pdev->dev_remote_wakeup = 0U;

  746.       USBD_CtlSendStatus(pdev);

  747.     }

  748.     break;

  749. 

  750.   default :

  751.      USBD_CtlError(pdev , req);

  752.     break;

  753.   }

  754. }

  755. 

  756. /**

  757. * @brief  USBD_ParseSetupRequest

  758. *         Copy buffer into setup structure

  759. * @param  pdev: device instance

  760. * @param  req: usb request

  761. * @retval None

  762. */

  763. 

  764. void USBD_ParseSetupRequest(USBD_SetupReqTypedef *req, uint8_t *pdata)

  765. {

  766.   req->bmRequest     = *(uint8_t *)  (pdata);

  767.   req->bRequest      = *(uint8_t *)  (pdata +  1);

  768.   req->wValue        = SWAPBYTE      (pdata +  2);

  769.   req->wIndex        = SWAPBYTE      (pdata +  4);

  770.   req->wLength       = SWAPBYTE      (pdata +  6);

  771. 

  772. }

  773. 

  774. /**

  775. * @brief  USBD_CtlError

  776. *         Handle USB low level Error

  777. * @param  pdev: device instance

  778. * @param  req: usb request

  779. * @retval None

  780. */

  781. 

  782. void USBD_CtlError( USBD_HandleTypeDef *pdev ,

  783.                             USBD_SetupReqTypedef *req)

  784. {

  785.   USBD_LL_StallEP(pdev , 0x80U);

  786.   USBD_LL_StallEP(pdev , 0U);

  787. }

  788. 

  789. 

  790. /**

  791.   * @brief  USBD_GetString

  792.   *         Convert Ascii string into unicode one

  793.   * @param  desc : descriptor buffer

  794.   * @param  unicode : Formatted string buffer (unicode)

  795.   * @param  len : descriptor length

  796.   * @retval None

  797.   */

  798. void USBD_GetString(uint8_t *desc, uint8_t *unicode, uint16_t *len)

  799. {

  800.   uint8_t idx = 0U;

  801. 

  802.   if (desc != NULL)

  803.   {

  804.     *len = (uint16_t)USBD_GetLen(desc) * 2U + 2U;

  805.     unicode[idx++] = *(uint8_t *)(void *)len;

  806.     unicode[idx++] = USB_DESC_TYPE_STRING;

  807. 

  808.     while (*desc != '\0')

  809.     {

  810.       unicode[idx++] = *desc++;

  811.       unicode[idx++] =  0U;

  812.     }

  813.   }

  814. }

  815. 

  816. /**

  817.   * @brief  USBD_GetLen

  818.   *         return the string length

  819.    * @param  buf : pointer to the ascii string buffer

  820.   * @retval string length

  821.   */

  822. static uint8_t USBD_GetLen(uint8_t *buf)

  823. {

  824.     uint8_t  len = 0U;

  825. 

  826.     while (*buf != '\0')

  827.     {

  828.         len++;

  829.         buf++;

  830.     }

  831. 

  832.     return len;

  833. }

  834. /**

  835.   * @}

  836.   */

  837. 

  838. 

  839. /**

  840.   * @}

  841.   */

  842. 

  843. 

  844. /**

  845.   * @}

  846.   */

  847. 

  848. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/