jmg
/
lora-irrigation
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
Implement a secure ICS protocol targeting LoRa Node151 microcontroller for controlling irrigation.
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
177 Revize
4 Větve
18 MiB
 
 
 
 
 
 
Strom: a4f76dc0bb
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „a4f76dc0bb“
${ noResults }
lora-irrigation/stm32/usb/usbd_ctlreq.c

849 řádky
18 KiB
Surový Blame Historie 

  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****/