jmg
/
lora-irrigation
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Implement a secure ICS protocol targeting LoRa Node151 microcontroller for controlling irrigation.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
177 Commits
4 Branches
18 MiB
 
 
 
 
 
 
Tree: a4f76dc0bb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a4f76dc0bb'
${ noResults }
lora-irrigation/stm32/usb/usbd_ctlreq_nodesc.c

854 lines
18 KiB
Raw Blame History 

  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. #if 0

  72. static

  73. #endif

  74. void USBD_GetDescriptor(USBD_HandleTypeDef *pdev ,

  75.                                USBD_SetupReqTypedef *req);

  76. 

  77. static void USBD_SetAddress(USBD_HandleTypeDef *pdev ,

  78.                             USBD_SetupReqTypedef *req);

  79. 

  80. static void USBD_SetConfig(USBD_HandleTypeDef *pdev ,

  81.                            USBD_SetupReqTypedef *req);

  82. 

  83. static void USBD_GetConfig(USBD_HandleTypeDef *pdev ,

  84.                            USBD_SetupReqTypedef *req);

  85. 

  86. static void USBD_GetStatus(USBD_HandleTypeDef *pdev ,

  87.                            USBD_SetupReqTypedef *req);

  88. 

  89. static void USBD_SetFeature(USBD_HandleTypeDef *pdev ,

  90.                             USBD_SetupReqTypedef *req);

  91. 

  92. static void USBD_ClrFeature(USBD_HandleTypeDef *pdev ,

  93.                             USBD_SetupReqTypedef *req);

  94. 

  95. static uint8_t USBD_GetLen(uint8_t *buf);

  96. 

  97. /**

  98.   * @}

  99.   */

  100. 

  101. 

  102. /** @defgroup USBD_REQ_Private_Functions

  103.   * @{

  104.   */

  105. 

  106. 

  107. /**

  108. * @brief  USBD_StdDevReq

  109. *         Handle standard usb device requests

  110. * @param  pdev: device instance

  111. * @param  req: usb request

  112. * @retval status

  113. */

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

  115. {

  116.   USBD_StatusTypeDef ret = USBD_OK;

  117. 

  118.   switch (req->bmRequest & USB_REQ_TYPE_MASK)

  119.   {

  120.   case USB_REQ_TYPE_CLASS:

  121.   case USB_REQ_TYPE_VENDOR:

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

  123.     break;

  124. 

  125.   case USB_REQ_TYPE_STANDARD:

  126. 

  127.     switch (req->bRequest)

  128.     {

  129.     case USB_REQ_GET_DESCRIPTOR:

  130. 

  131.       USBD_GetDescriptor (pdev, req);

  132.       break;

  133. 

  134.     case USB_REQ_SET_ADDRESS:

  135.       USBD_SetAddress (pdev, req);

  136.       break;

  137. 

  138.     case USB_REQ_SET_CONFIGURATION:

  139.       USBD_SetConfig (pdev, req);

  140.       break;

  141. 

  142.     case USB_REQ_GET_CONFIGURATION:

  143.       USBD_GetConfig (pdev, req);

  144.       break;

  145. 

  146.     case USB_REQ_GET_STATUS:

  147.       USBD_GetStatus (pdev, req);

  148.       break;

  149. 

  150. 

  151.     case USB_REQ_SET_FEATURE:

  152.       USBD_SetFeature (pdev, req);

  153.       break;

  154. 

  155.     case USB_REQ_CLEAR_FEATURE:

  156.       USBD_ClrFeature (pdev, req);

  157.       break;

  158. 

  159.     default:

  160.       USBD_CtlError(pdev, req);

  161.       break;

  162.     }

  163.     break;

  164. 

  165.   default:

  166.     USBD_CtlError(pdev, req);

  167.     break;

  168.   }

  169. 

  170.   return ret;

  171. }

  172. 

  173. /**

  174. * @brief  USBD_StdItfReq

  175. *         Handle standard usb interface requests

  176. * @param  pdev: device instance

  177. * @param  req: usb request

  178. * @retval status

  179. */

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

  181. {

  182.   USBD_StatusTypeDef ret = USBD_OK;

  183. 

  184.   switch (req->bmRequest & USB_REQ_TYPE_MASK)

  185.   {

  186.   case USB_REQ_TYPE_CLASS:

  187.   case USB_REQ_TYPE_VENDOR:

  188.   case USB_REQ_TYPE_STANDARD:

  189.     switch (pdev->dev_state)

  190.     {

  191.     case USBD_STATE_DEFAULT:

  192.     case USBD_STATE_ADDRESSED:

  193.     case USBD_STATE_CONFIGURED:

  194. 

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

  196.       {

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

  198. 

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

  200.         {

  201.           USBD_CtlSendStatus(pdev);

  202.         }

  203.       }

  204.       else

  205.       {

  206.         USBD_CtlError(pdev, req);

  207.       }

  208.       break;

  209. 

  210.     default:

  211.       USBD_CtlError(pdev, req);

  212.       break;

  213.     }

  214.     break;

  215. 

  216.   default:

  217.     USBD_CtlError(pdev, req);

  218.     break;

  219.   }

  220. 

  221.   return USBD_OK;

  222. }

  223. 

  224. /**

  225. * @brief  USBD_StdEPReq

  226. *         Handle standard usb endpoint requests

  227. * @param  pdev: device instance

  228. * @param  req: usb request

  229. * @retval status

  230. */

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

  232. {

  233. 

  234.   uint8_t   ep_addr;

  235.   USBD_StatusTypeDef ret = USBD_OK;

  236.   USBD_EndpointTypeDef   *pep;

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

  238. 

  239.   switch (req->bmRequest & USB_REQ_TYPE_MASK)

  240.   {

  241. 

  242.   case USB_REQ_TYPE_CLASS:

  243.   case USB_REQ_TYPE_VENDOR:

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

  245.     break;

  246. 

  247.   case USB_REQ_TYPE_STANDARD:

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

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

  250.     {

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

  252. 

  253.       return ret;

  254.     }

  255. 

  256.     switch (req->bRequest)

  257.     {

  258. 

  259.     case USB_REQ_SET_FEATURE :

  260. 

  261.       switch (pdev->dev_state)

  262.       {

  263.       case USBD_STATE_ADDRESSED:

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

  265.         {

  266.           USBD_LL_StallEP(pdev, ep_addr);

  267.           USBD_LL_StallEP(pdev, 0x80U);

  268.         }

  269.         else

  270.         {

  271.           USBD_CtlError(pdev, req);

  272.         }

  273.         break;

  274. 

  275.       case USBD_STATE_CONFIGURED:

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

  277.         {

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

  279.           {

  280.             USBD_LL_StallEP(pdev, ep_addr);

  281.           }

  282.         }

  283.         USBD_CtlSendStatus(pdev);

  284. 

  285.         break;

  286. 

  287.       default:

  288.         USBD_CtlError(pdev, req);

  289.         break;

  290.       }

  291.       break;

  292. 

  293.     case USB_REQ_CLEAR_FEATURE :

  294. 

  295.       switch (pdev->dev_state)

  296.       {

  297.       case USBD_STATE_ADDRESSED:

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

  299.         {

  300.           USBD_LL_StallEP(pdev, ep_addr);

  301.           USBD_LL_StallEP(pdev, 0x80U);

  302.         }

  303.         else

  304.         {

  305.           USBD_CtlError(pdev, req);

  306.         }

  307.         break;

  308. 

  309.       case USBD_STATE_CONFIGURED:

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

  311.         {

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

  313.           {

  314.             USBD_LL_ClearStallEP(pdev, ep_addr);

  315.           }

  316.           USBD_CtlSendStatus(pdev);

  317.         }

  318.         break;

  319. 

  320.       default:

  321.         USBD_CtlError(pdev, req);

  322.         break;

  323.       }

  324.       break;

  325. 

  326.     case USB_REQ_GET_STATUS:

  327.       switch (pdev->dev_state)

  328.       {

  329.       case USBD_STATE_ADDRESSED:

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

  331.         {

  332.           USBD_CtlError(pdev, req);

  333.           break;

  334.         }

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

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

  337. 

  338.           pep->status = 0x0000U;

  339. 

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

  341.           break;

  342. 

  343.       case USBD_STATE_CONFIGURED:

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

  345.         {

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

  347.           {

  348.             USBD_CtlError(pdev, req);

  349.             break;

  350.           }

  351.         }

  352.         else

  353.         {

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

  355.           {

  356.             USBD_CtlError(pdev, req);

  357.             break;

  358.           }

  359.         }

  360. 

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

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

  363. 

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

  365.           {

  366.             pep->status = 0x0000U;

  367.           }

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

  369.           {

  370.             pep->status = 0x0001U;

  371.           }

  372.           else

  373.           {

  374.             pep->status = 0x0000U;

  375.           }

  376. 

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

  378.           break;

  379. 

  380.       default:

  381.         USBD_CtlError(pdev, req);

  382.         break;

  383.       }

  384.       break;

  385. 

  386.     default:

  387.       USBD_CtlError(pdev, req);

  388.       break;

  389.     }

  390.     break;

  391. 

  392.   default:

  393.     USBD_CtlError(pdev, req);

  394.     break;

  395.   }

  396. 

  397.   return ret;

  398. }

  399. #if 0

  400. /**

  401. * @brief  USBD_GetDescriptor

  402. *         Handle Get Descriptor requests

  403. * @param  pdev: device instance

  404. * @param  req: usb request

  405. * @retval status

  406. */

  407. static void USBD_GetDescriptor(USBD_HandleTypeDef *pdev ,

  408.                                USBD_SetupReqTypedef *req)

  409. {

  410.   uint16_t len;

  411.   uint8_t *pbuf;

  412. 

  413. 

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

  415.   {

  416. #if (USBD_LPM_ENABLED == 1U)

  417.   case USB_DESC_TYPE_BOS:

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

  419.     break;

  420. #endif

  421.   case USB_DESC_TYPE_DEVICE:

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

  423.     break;

  424. 

  425.   case USB_DESC_TYPE_CONFIGURATION:

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

  427.     {

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

  429.       pbuf[1] = USB_DESC_TYPE_CONFIGURATION;

  430.     }

  431.     else

  432.     {

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

  434.       pbuf[1] = USB_DESC_TYPE_CONFIGURATION;

  435.     }

  436.     break;

  437. 

  438.   case USB_DESC_TYPE_STRING:

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

  440.     {

  441.     case USBD_IDX_LANGID_STR:

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

  443.       break;

  444. 

  445.     case USBD_IDX_MFC_STR:

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

  447.       break;

  448. 

  449.     case USBD_IDX_PRODUCT_STR:

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

  451.       break;

  452. 

  453.     case USBD_IDX_SERIAL_STR:

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

  455.       break;

  456. 

  457.     case USBD_IDX_CONFIG_STR:

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

  459.       break;

  460. 

  461.     case USBD_IDX_INTERFACE_STR:

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

  463.       break;

  464. 

  465.     default:

  466. #if (USBD_SUPPORT_USER_STRING == 1U)

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

  468.       break;

  469. #else

  470.        USBD_CtlError(pdev , req);

  471.       return;

  472. #endif

  473.     }

  474.     break;

  475.   case USB_DESC_TYPE_DEVICE_QUALIFIER:

  476. 

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

  478.     {

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

  480.       break;

  481.     }

  482.     else

  483.     {

  484.       USBD_CtlError(pdev , req);

  485.       return;

  486.     }

  487. 

  488.   case USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION:

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

  490.     {

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

  492.       pbuf[1] = USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION;

  493.       break;

  494.     }

  495.     else

  496.     {

  497.       USBD_CtlError(pdev , req);

  498.       return;

  499.     }

  500. 

  501.   default:

  502.      USBD_CtlError(pdev , req);

  503.     return;

  504.   }

  505. 

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

  507.   {

  508. 

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

  510. 

  511.     USBD_CtlSendData (pdev, pbuf, len);

  512.   }

  513. 

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

  515.   {

  516.    USBD_CtlSendStatus(pdev);

  517.   }

  518. }

  519. #endif

  520. 

  521. /**

  522. * @brief  USBD_SetAddress

  523. *         Set device address

  524. * @param  pdev: device instance

  525. * @param  req: usb request

  526. * @retval status

  527. */

  528. static void USBD_SetAddress(USBD_HandleTypeDef *pdev ,

  529.                             USBD_SetupReqTypedef *req)

  530. {

  531.   uint8_t  dev_addr;

  532. 

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

  534.   {

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

  536. 

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

  538.     {

  539.       USBD_CtlError(pdev , req);

  540.     }

  541.     else

  542.     {

  543.       pdev->dev_address = dev_addr;

  544.       USBD_LL_SetUSBAddress(pdev, dev_addr);

  545.       USBD_CtlSendStatus(pdev);

  546. 

  547.       if (dev_addr != 0U)

  548.       {

  549.         pdev->dev_state = USBD_STATE_ADDRESSED;

  550.       }

  551.       else

  552.       {

  553.         pdev->dev_state = USBD_STATE_DEFAULT;

  554.       }

  555.     }

  556.   }

  557.   else

  558.   {

  559.     USBD_CtlError(pdev, req);

  560.   }

  561. }

  562. 

  563. /**

  564. * @brief  USBD_SetConfig

  565. *         Handle Set device configuration request

  566. * @param  pdev: device instance

  567. * @param  req: usb request

  568. * @retval status

  569. */

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

  571. {

  572.   static uint8_t cfgidx;

  573. 

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

  575. 

  576.   if (cfgidx > USBD_MAX_NUM_CONFIGURATION)

  577.   {

  578.     USBD_CtlError(pdev, req);

  579.   }

  580.   else

  581.   {

  582.     switch (pdev->dev_state)

  583.     {

  584.     case USBD_STATE_ADDRESSED:

  585.       if (cfgidx)

  586.       {

  587.         pdev->dev_config = cfgidx;

  588.         pdev->dev_state = USBD_STATE_CONFIGURED;

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

  590.         {

  591.           USBD_CtlError(pdev, req);

  592.           return;

  593.         }

  594.         USBD_CtlSendStatus(pdev);

  595.       }

  596.       else

  597.       {

  598.         USBD_CtlSendStatus(pdev);

  599.       }

  600.       break;

  601. 

  602.     case USBD_STATE_CONFIGURED:

  603.       if (cfgidx == 0U)

  604.       {

  605.         pdev->dev_state = USBD_STATE_ADDRESSED;

  606.         pdev->dev_config = cfgidx;

  607.         USBD_ClrClassConfig(pdev, cfgidx);

  608.         USBD_CtlSendStatus(pdev);

  609.       }

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

  611.       {

  612.         /* Clear old configuration */

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

  614. 

  615.         /* set new configuration */

  616.         pdev->dev_config = cfgidx;

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

  618.         {

  619.           USBD_CtlError(pdev, req);

  620.           return;

  621.         }

  622.         USBD_CtlSendStatus(pdev);

  623.       }

  624.       else

  625.       {

  626.         USBD_CtlSendStatus(pdev);

  627.       }

  628.       break;

  629. 

  630.     default:

  631.       USBD_CtlError(pdev, req);

  632.       USBD_ClrClassConfig(pdev, cfgidx);

  633.       break;

  634.     }

  635.   }

  636. }

  637. 

  638. /**

  639. * @brief  USBD_GetConfig

  640. *         Handle Get device configuration request

  641. * @param  pdev: device instance

  642. * @param  req: usb request

  643. * @retval status

  644. */

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

  646. {

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

  648.   {

  649.     USBD_CtlError(pdev , req);

  650.   }

  651.   else

  652.   {

  653.     switch (pdev->dev_state)

  654.     {

  655.     case USBD_STATE_DEFAULT:

  656.     case USBD_STATE_ADDRESSED:

  657.       pdev->dev_default_config = 0U;

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

  659.       break;

  660. 

  661.     case USBD_STATE_CONFIGURED:

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

  663.       break;

  664. 

  665.     default:

  666.       USBD_CtlError(pdev , req);

  667.       break;

  668.     }

  669.   }

  670. }

  671. 

  672. /**

  673. * @brief  USBD_GetStatus

  674. *         Handle Get Status request

  675. * @param  pdev: device instance

  676. * @param  req: usb request

  677. * @retval status

  678. */

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

  680. {

  681.   switch (pdev->dev_state)

  682.   {

  683.   case USBD_STATE_DEFAULT:

  684.   case USBD_STATE_ADDRESSED:

  685.   case USBD_STATE_CONFIGURED:

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

  687.     {

  688.       USBD_CtlError(pdev, req);

  689.       break;

  690.     }

  691. 

  692. #if ( USBD_SELF_POWERED == 1U)

  693.     pdev->dev_config_status = USB_CONFIG_SELF_POWERED;

  694. #else

  695.     pdev->dev_config_status = 0U;

  696. #endif

  697. 

  698.     if (pdev->dev_remote_wakeup)

  699.     {

  700.       pdev->dev_config_status |= USB_CONFIG_REMOTE_WAKEUP;

  701.     }

  702. 

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

  704.     break;

  705. 

  706.   default :

  707.     USBD_CtlError(pdev , req);

  708.     break;

  709.   }

  710. }

  711. 

  712. 

  713. /**

  714. * @brief  USBD_SetFeature

  715. *         Handle Set device feature request

  716. * @param  pdev: device instance

  717. * @param  req: usb request

  718. * @retval status

  719. */

  720. static void USBD_SetFeature(USBD_HandleTypeDef *pdev ,

  721.                             USBD_SetupReqTypedef *req)

  722. {

  723. 

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

  725.   {

  726.     pdev->dev_remote_wakeup = 1U;

  727.     USBD_CtlSendStatus(pdev);

  728.   }

  729. 

  730. }

  731. 

  732. 

  733. /**

  734. * @brief  USBD_ClrFeature

  735. *         Handle clear device feature request

  736. * @param  pdev: device instance

  737. * @param  req: usb request

  738. * @retval status

  739. */

  740. static void USBD_ClrFeature(USBD_HandleTypeDef *pdev ,

  741.                             USBD_SetupReqTypedef *req)

  742. {

  743.   switch (pdev->dev_state)

  744.   {

  745.   case USBD_STATE_DEFAULT:

  746.   case USBD_STATE_ADDRESSED:

  747.   case USBD_STATE_CONFIGURED:

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

  749.     {

  750.       pdev->dev_remote_wakeup = 0U;

  751.       USBD_CtlSendStatus(pdev);

  752.     }

  753.     break;

  754. 

  755.   default :

  756.      USBD_CtlError(pdev , req);

  757.     break;

  758.   }

  759. }

  760. 

  761. /**

  762. * @brief  USBD_ParseSetupRequest

  763. *         Copy buffer into setup structure

  764. * @param  pdev: device instance

  765. * @param  req: usb request

  766. * @retval None

  767. */

  768. 

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

  770. {

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

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

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

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

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

  776. 

  777. }

  778. 

  779. /**

  780. * @brief  USBD_CtlError

  781. *         Handle USB low level Error

  782. * @param  pdev: device instance

  783. * @param  req: usb request

  784. * @retval None

  785. */

  786. 

  787. void USBD_CtlError( USBD_HandleTypeDef *pdev ,

  788.                             USBD_SetupReqTypedef *req)

  789. {

  790.   USBD_LL_StallEP(pdev , 0x80U);

  791.   USBD_LL_StallEP(pdev , 0U);

  792. }

  793. 

  794. 

  795. /**

  796.   * @brief  USBD_GetString

  797.   *         Convert Ascii string into unicode one

  798.   * @param  desc : descriptor buffer

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

  800.   * @param  len : descriptor length

  801.   * @retval None

  802.   */

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

  804. {

  805.   uint8_t idx = 0U;

  806. 

  807.   if (desc != NULL)

  808.   {

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

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

  811.     unicode[idx++] = USB_DESC_TYPE_STRING;

  812. 

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

  814.     {

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

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

  817.     }

  818.   }

  819. }

  820. 

  821. /**

  822.   * @brief  USBD_GetLen

  823.   *         return the string length

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

  825.   * @retval string length

  826.   */

  827. static uint8_t USBD_GetLen(uint8_t *buf)

  828. {

  829.     uint8_t  len = 0U;

  830. 

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

  832.     {

  833.         len++;

  834.         buf++;

  835.     }

  836. 

  837.     return len;

  838. }

  839. /**

  840.   * @}

  841.   */

  842. 

  843. 

  844. /**

  845.   * @}

  846.   */

  847. 

  848. 

  849. /**

  850.   * @}

  851.   */

  852. 

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