text: /**
    ******************************************************************************
    * @file    usbd_req.c
    * @author  MCD Application Team
    * @version V1.2.0
    * @date    09-November-2015
    * @brief   This file provides the standard USB requests following chapter 9.
    ******************************************************************************
    * @attention
    *
    * <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
    *
    * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
    * You may not use this file except in compliance with the License.
    * You may obtain a copy of the License at:
    *
    *        http://www.st.com/software_license_agreement_liberty_v2
    *
    * Unless required by applicable law or agreed to in writing, software 
    * distributed under the License is distributed on an "AS IS" BASIS, 
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    *
    ******************************************************************************
    */ 
  
  /* Includes ------------------------------------------------------------------*/
  #include "usbd_req.h"
  #include "usbd_ioreq.h"
  #include "usbd_desc.h"
  
  
  /** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
    * @{
    */
  
  
  /** @defgroup USBD_REQ 
    * @brief USB standard requests module
    * @{
    */ 
  
  /** @defgroup USBD_REQ_Private_TypesDefinitions
    * @{
    */ 
  /**
    * @}
    */ 
  
  
  /** @defgroup USBD_REQ_Private_Defines
    * @{
    */ 
  
  /**
    * @}
    */ 
  
  
  /** @defgroup USBD_REQ_Private_Macros
    * @{
    */ 
  /**
    * @}
    */ 
  
  
  /** @defgroup USBD_REQ_Private_Variables
    * @{
    */ 
  extern __IO USB_OTG_DCTL_TypeDef SET_TEST_MODE;
  
  #ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
    #if defined ( __ICCARM__ ) /*!< IAR Compiler */
      #pragma data_alignment=4   
    #endif
  #endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */  
  __ALIGN_BEGIN uint32_t USBD_ep_status __ALIGN_END  = 0; 
  
  #ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
    #if defined ( __ICCARM__ ) /*!< IAR Compiler */
      #pragma data_alignment=4   
    #endif
  #endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
  __ALIGN_BEGIN uint32_t  USBD_default_cfg __ALIGN_END  = 0;
  
  #ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
    #if defined ( __ICCARM__ ) /*!< IAR Compiler */
      #pragma data_alignment=4   
    #endif
  #endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
  __ALIGN_BEGIN uint32_t  USBD_cfg_status __ALIGN_END  = 0;  
  
  __ALIGN_BEGIN uint8_t USBD_StrDesc[USB_MAX_STR_DESC_SIZ] __ALIGN_END ;
  /**
    * @}
    */ 
  
  
  /** @defgroup USBD_REQ_Private_FunctionPrototypes
    * @{
    */ 
  static void USBD_GetDescriptor(USB_OTG_CORE_HANDLE  *pdev, 
                                 USB_SETUP_REQ *req);
  
  static void USBD_SetAddress(USB_OTG_CORE_HANDLE  *pdev, 
                              USB_SETUP_REQ *req);
  
  static void USBD_SetConfig(USB_OTG_CORE_HANDLE  *pdev, 
                             USB_SETUP_REQ *req);
  
  static void USBD_GetConfig(USB_OTG_CORE_HANDLE  *pdev, 
                             USB_SETUP_REQ *req);
  
  static void USBD_GetStatus(USB_OTG_CORE_HANDLE  *pdev, 
                             USB_SETUP_REQ *req);
  
  static void USBD_SetFeature(USB_OTG_CORE_HANDLE  *pdev, 
                              USB_SETUP_REQ *req);
  
  static void USBD_ClrFeature(USB_OTG_CORE_HANDLE  *pdev, 
                              USB_SETUP_REQ *req);
  
  static uint8_t USBD_GetLen(uint8_t *buf);
  /**
    * @}
    */ 
  
  
  /** @defgroup USBD_REQ_Private_Functions
    * @{
    */ 
  
  
  /**
  * @brief  USBD_StdDevReq
  *         Handle standard usb device requests
  * @param  pdev: device instance
  * @param  req: usb request
  * @retval status
  */
  USBD_Status  USBD_StdDevReq (USB_OTG_CORE_HANDLE  *pdev, USB_SETUP_REQ  *req)
  {
    USBD_Status ret = USBD_OK;  
    
    switch (req->bRequest) 
    {
    case USB_REQ_GET_DESCRIPTOR: 
      
      USBD_GetDescriptor (pdev, req) ;
      break;
      
    case USB_REQ_SET_ADDRESS:                      
      USBD_SetAddress(pdev, req);
      break;
      
    case USB_REQ_SET_CONFIGURATION:                    
      USBD_SetConfig (pdev , req);
      break;
      
    case USB_REQ_GET_CONFIGURATION:                 
      USBD_GetConfig (pdev , req);
      break;
      
    case USB_REQ_GET_STATUS:                                  
      USBD_GetStatus (pdev , req);
      break;
      
      
    case USB_REQ_SET_FEATURE:   
      USBD_SetFeature (pdev , req);    
      break;
      
    case USB_REQ_CLEAR_FEATURE:                                   
      USBD_ClrFeature (pdev , req);
      break;
      
    default:  
      USBD_CtlError(pdev , req);
      break;
    }
    
    return ret;
  }
  
  /**
  * @brief  USBD_StdItfReq
  *         Handle standard usb interface requests
  * @param  pdev: USB OTG device instance
  * @param  req: usb request
  * @retval status
  */
  USBD_Status  USBD_StdItfReq (USB_OTG_CORE_HANDLE  *pdev, USB_SETUP_REQ  *req)
  {
    USBD_Status ret = USBD_OK; 
    
    switch (pdev->dev.device_status) 
    {
    case USB_OTG_CONFIGURED:
      
      if (LOBYTE(req->wIndex) <= USBD_ITF_MAX_NUM) 
      {
        pdev->dev.class_cb->Setup (pdev, req); 
        
        if((req->wLength == 0)&& (ret == USBD_OK))
        {
           USBD_CtlSendStatus(pdev);
        }
      } 
      else 
      {                                               
         USBD_CtlError(pdev , req);
      }
      break;
      
    default:
       USBD_CtlError(pdev , req);
      break;
    }
    return ret;
  }
  
  /**
  * @brief  USBD_StdEPReq
  *         Handle standard usb endpoint requests
  * @param  pdev: USB OTG device instance
  * @param  req: usb request
  * @retval status
  */
  USBD_Status  USBD_StdEPReq (USB_OTG_CORE_HANDLE  *pdev, USB_SETUP_REQ  *req)
  {
    
    uint8_t   ep_addr;
    USBD_Status ret = USBD_OK; 
    
    ep_addr  = LOBYTE(req->wIndex);   
  
    /* Check the class specific requests before going to standard request */
    if ((req->bmRequest & USB_REQ_TYPE_MASK) == USB_REQ_TYPE_CLASS)
    {
      pdev->dev.class_cb->Setup (pdev, req);
      return ret;
    }
  
    switch (req->bRequest) 
    {  
    case USB_REQ_SET_FEATURE :
      
      switch (pdev->dev.device_status) 
      {
      case USB_OTG_ADDRESSED:          
        if ((ep_addr != 0x00) && (ep_addr != 0x80)) 
        {
          DCD_EP_Stall(pdev , ep_addr);
        }
        break;	
        
      case USB_OTG_CONFIGURED:   
        if (req->wValue == USB_FEATURE_EP_HALT)
        {
          if ((ep_addr != 0x00) && (ep_addr != 0x80)) 
          { 
            DCD_EP_Stall(pdev , ep_addr);
            
          }
        }
        pdev->dev.class_cb->Setup (pdev, req);   
        USBD_CtlSendStatus(pdev);
        
        break;
        
      default:                         
        USBD_CtlError(pdev , req);
        break;    
      }
      break;
      
    case USB_REQ_CLEAR_FEATURE :
      
      switch (pdev->dev.device_status) 
      {
      case USB_OTG_ADDRESSED:          
        if ((ep_addr != 0x00) && (ep_addr != 0x80)) 
        {
          DCD_EP_Stall(pdev , ep_addr);
        }
        break;	
        
      case USB_OTG_CONFIGURED:   
        if (req->wValue == USB_FEATURE_EP_HALT)
        {
          if ((ep_addr != 0x00) && (ep_addr != 0x80)) 
          {        
            DCD_EP_ClrStall(pdev , ep_addr);
            pdev->dev.class_cb->Setup (pdev, req);
          }
          USBD_CtlSendStatus(pdev);
        }
        break;
        
      default:                         
         USBD_CtlError(pdev , req);
        break;    
      }
      break;
      
    case USB_REQ_GET_STATUS:                  
      switch (pdev->dev.device_status) 
      {
      case USB_OTG_ADDRESSED:          
        if ((ep_addr != 0x00) && (ep_addr != 0x80)) 
        {
          DCD_EP_Stall(pdev , ep_addr);
        }
        break;	
        
      case USB_OTG_CONFIGURED:         
        
        
        if ((ep_addr & 0x80)== 0x80)
        {
          if(pdev->dev.in_ep[ep_addr & 0x7F].is_stall)
          {
            USBD_ep_status = 0x0001;     
          }
          else
          {
            USBD_ep_status = 0x0000;  
          }
        }
        else if ((ep_addr & 0x80)== 0x00)
        {
          if(pdev->dev.out_ep[ep_addr].is_stall)
          {
            USBD_ep_status = 0x0001;     
          }
          
          else 
          {
            USBD_ep_status = 0x0000;     
          }      
        }
        
        else
        {
          /* Do Nothing */
        }
        
        USBD_CtlSendData (pdev,
                          (uint8_t *)&USBD_ep_status,
                          2);
        break;
        
      default:                         
         USBD_CtlError(pdev , req);
        break;
      }
      break;
      
    default:
      break;
    }
    return ret;
  }
  /**
  * @brief  USBD_GetDescriptor
  *         Handle Get Descriptor requests
  * @param  pdev: device instance
  * @param  req: usb request
  * @retval status
  */
  static void USBD_GetDescriptor(USB_OTG_CORE_HANDLE  *pdev, 
                                 USB_SETUP_REQ *req)
  {
    uint16_t len;
    uint8_t *pbuf;
    len = req->wLength ;
      
    switch (req->wValue >> 8)
    {
  #if (USBD_LPM_ENABLED == 1)
    case USB_DESC_TYPE_BOS:
      pbuf = pdev->pDesc->GetBOSDescriptor(pdev->dev_speed, &len);
      break;
  #endif
    case USB_DESC_TYPE_DEVICE:
      pbuf = pdev->dev.usr_device->GetDeviceDescriptor(pdev->cfg.speed, &len);
      break;
      
    case USB_DESC_TYPE_CONFIGURATION:
        pbuf   = (uint8_t *)pdev->dev.class_cb->GetConfigDescriptor(pdev->cfg.speed, &len);
  #ifdef USB_OTG_HS_CORE
      if((pdev->cfg.speed == USB_OTG_SPEED_FULL )&&
         (pdev->cfg.phy_itface  == USB_OTG_ULPI_PHY))
      {
        pbuf   = (uint8_t *)pdev->dev.class_cb->GetOtherConfigDescriptor(pdev->cfg.speed, &len);
      }
  #endif  
      pbuf[1] = USB_DESC_TYPE_CONFIGURATION;
      pdev->dev.pConfig_descriptor = pbuf;    
      break;
      
    case USB_DESC_TYPE_STRING:
      switch ((uint8_t)(req->wValue))
      {
      case USBD_IDX_LANGID_STR:
       pbuf = pdev->dev.usr_device->GetLangIDStrDescriptor(pdev->cfg.speed, &len);        
        break;
        
      case USBD_IDX_MFC_STR:
        pbuf = pdev->dev.usr_device->GetManufacturerStrDescriptor(pdev->cfg.speed, &len);
        break;
        
      case USBD_IDX_PRODUCT_STR:
        pbuf = pdev->dev.usr_device->GetProductStrDescriptor(pdev->cfg.speed, &len);
        break;
        
      case USBD_IDX_SERIAL_STR:
        pbuf = pdev->dev.usr_device->GetSerialStrDescriptor(pdev->cfg.speed, &len);
        break;
        
      case USBD_IDX_CONFIG_STR:
        pbuf = pdev->dev.usr_device->GetConfigurationStrDescriptor(pdev->cfg.speed, &len);
        break;
        
      case USBD_IDX_INTERFACE_STR:
        pbuf = pdev->dev.usr_device->GetInterfaceStrDescriptor(pdev->cfg.speed, &len);
        break;
        
      default:
  #ifdef USB_SUPPORT_USER_STRING_DESC
        pbuf = pdev->dev.class_cb->GetUsrStrDescriptor(pdev->cfg.speed, (req->wValue) , &len);
        break;
  #else      
         USBD_CtlError(pdev , req);
        return;
  #endif /* USBD_CtlError(pdev , req)*/      
      }
      break;
    case USB_DESC_TYPE_DEVICE_QUALIFIER:                   
  #ifdef USB_OTG_HS_CORE
      if(pdev->cfg.speed == USB_OTG_SPEED_HIGH  )   
      {
        
        pbuf   = (uint8_t *)pdev->dev.class_cb->GetConfigDescriptor(pdev->cfg.speed, &len);
              
        USBD_DeviceQualifierDesc[4]= pbuf[14];
        USBD_DeviceQualifierDesc[5]= pbuf[15];
        USBD_DeviceQualifierDesc[6]= pbuf[16];
        
        pbuf = USBD_DeviceQualifierDesc;
        len  = USB_LEN_DEV_QUALIFIER_DESC;
        break;
      }
      else
      {
        USBD_CtlError(pdev , req);
        return;
      }
  #else
        USBD_CtlError(pdev , req);
        return;
  #endif    
  
    case USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION:
  #ifdef USB_OTG_HS_CORE   
      
      if(pdev->cfg.speed == USB_OTG_SPEED_HIGH  )   
      {
        pbuf   = (uint8_t *)pdev->dev.class_cb->GetOtherConfigDescriptor(pdev->cfg.speed, &len);
        pbuf[1] = USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION;
        break; 
      }
      else
      {
        USBD_CtlError(pdev , req);
        return;
      }
  #else
        USBD_CtlError(pdev , req);
        return;
  #endif     
    default: 
       USBD_CtlError(pdev , req);
      return;
    }
    
    if((len != 0)&& (req->wLength != 0))
    {
      
      len = MIN(len , req->wLength);
      
      USBD_CtlSendData (pdev, 
                        pbuf,
                        len);
    }
    
  }
  
  /**
  * @brief  USBD_SetAddress
  *         Set device address
  * @param  pdev: device instance
  * @param  req: usb request
  * @retval status
  */
  static void USBD_SetAddress(USB_OTG_CORE_HANDLE  *pdev, 
                              USB_SETUP_REQ *req)
  {
    uint8_t  dev_addr; 
    
    if ((req->wIndex == 0) && (req->wLength == 0)) 
    {
      dev_addr = (uint8_t)(req->wValue) & 0x7F;     
      
      if (pdev->dev.device_status == USB_OTG_CONFIGURED) 
      {
        USBD_CtlError(pdev , req);
      } 
      else 
      {
        pdev->dev.device_address = dev_addr;
        DCD_EP_SetAddress(pdev, dev_addr);               
        USBD_CtlSendStatus(pdev);                         
        
        if (dev_addr != 0) 
        {
          pdev->dev.device_status  = USB_OTG_ADDRESSED;
        } 
        else 
        {
          pdev->dev.device_status  = USB_OTG_DEFAULT; 
        }
      }
    } 
    else 
    {
       USBD_CtlError(pdev , req);                        
    } 
  }
  
  /**
  * @brief  USBD_SetConfig
  *         Handle Set device configuration request
  * @param  pdev: device instance
  * @param  req: usb request
  * @retval status
  */
  static void USBD_SetConfig(USB_OTG_CORE_HANDLE  *pdev, 
                             USB_SETUP_REQ *req)
  {
    
    static uint8_t  cfgidx;
    
    cfgidx = (uint8_t)(req->wValue);                 
    
    if (cfgidx > USBD_CFG_MAX_NUM ) 
    {            
       USBD_CtlError(pdev , req);                              
    } 
    else 
    {
      switch (pdev->dev.device_status) 
      {
      case USB_OTG_ADDRESSED:
        if (cfgidx) 
        {                                			   							   							   				
          pdev->dev.device_config = cfgidx;
          pdev->dev.device_status = USB_OTG_CONFIGURED;
          USBD_SetCfg(pdev , cfgidx);
          USBD_CtlSendStatus(pdev);
        }
        else 
        {
           USBD_CtlSendStatus(pdev);
        }
        break;
        
      case USB_OTG_CONFIGURED:
        if (cfgidx == 0) 
        {                           
          pdev->dev.device_status = USB_OTG_ADDRESSED;
          pdev->dev.device_config = cfgidx;          
          USBD_ClrCfg(pdev , cfgidx);
          USBD_CtlSendStatus(pdev);
          
        } 
        else  if (cfgidx != pdev->dev.device_config) 
        {
          /* Clear old configuration */
          USBD_ClrCfg(pdev , pdev->dev.device_config);
          
          /* set new configuration */
          pdev->dev.device_config = cfgidx;
          USBD_SetCfg(pdev , cfgidx);
          USBD_CtlSendStatus(pdev);
        }
        else
        {
          USBD_CtlSendStatus(pdev);
        }
        break;
        
      default:					
         USBD_CtlError(pdev , req);                     
        break;
      }
    }
  }
  
  /**
  * @brief  USBD_GetConfig
  *         Handle Get device configuration request
  * @param  pdev: device instance
  * @param  req: usb request
  * @retval status
  */
  static void USBD_GetConfig(USB_OTG_CORE_HANDLE  *pdev, 
                             USB_SETUP_REQ *req)
  {
   
    if (req->wLength != 1) 
    {                   
       USBD_CtlError(pdev , req);
    }
    else 
    {
      switch (pdev->dev.device_status )  
      {
      case USB_OTG_ADDRESSED:                     
        
        USBD_CtlSendData (pdev, 
                          (uint8_t *)&USBD_default_cfg,
                          1);
        break;
        
      case USB_OTG_CONFIGURED:                   
        
        USBD_CtlSendData (pdev, 
                          &pdev->dev.device_config,
                          1);
        break;
        
      default:
         USBD_CtlError(pdev , req);
        break;
      }
    }
  }
  
  /**
  * @brief  USBD_GetStatus
  *         Handle Get Status request
  * @param  pdev: device instance
  * @param  req: usb request
  * @retval status
  */
  static void USBD_GetStatus(USB_OTG_CORE_HANDLE  *pdev, 
                             USB_SETUP_REQ *req)
  {
    
      
    switch (pdev->dev.device_status) 
    {
    case USB_OTG_ADDRESSED:
    case USB_OTG_CONFIGURED:
      
  #ifdef USBD_SELF_POWERED
      USBD_cfg_status = USB_CONFIG_SELF_POWERED;                                    
  #else
      USBD_cfg_status = 0x00;                                    
  #endif
                        
      if (pdev->dev.DevRemoteWakeup) 
      {
        USBD_cfg_status |= USB_CONFIG_REMOTE_WAKEUP;                                
      }
      
      USBD_CtlSendData (pdev, 
                        (uint8_t *)&USBD_cfg_status,
                        2);
      break;
      
    default :
      USBD_CtlError(pdev , req);                        
      break;
    }
  }
  
  
  /**
  * @brief  USBD_SetFeature
  *         Handle Set device feature request
  * @param  pdev: device instance
  * @param  req: usb request
  * @retval status
  */
  static void USBD_SetFeature(USB_OTG_CORE_HANDLE  *pdev, 
                              USB_SETUP_REQ *req)
  {
  
    USB_OTG_DCTL_TypeDef     dctl;
    uint8_t test_mode = 0;
   
    if (req->wValue == USB_FEATURE_REMOTE_WAKEUP)
    {
      pdev->dev.DevRemoteWakeup = 1;  
      pdev->dev.class_cb->Setup (pdev, req);   
      USBD_CtlSendStatus(pdev);
    }
  
    else if ((req->wValue == USB_FEATURE_TEST_MODE) && 
             ((req->wIndex & 0xFF) == 0))
    {
      dctl.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DCTL);
      
      test_mode = req->wIndex >> 8;
      switch (test_mode) 
      {
      case 1: /* TEST_J */
        dctl.b.tstctl = 1;
        break;
        
      case 2: /* TEST_K */	
        dctl.b.tstctl = 2;
        break;
        
      case 3: /* TEST_SE0_NAK */
        dctl.b.tstctl = 3;
        break;
        
      case 4: /* TEST_PACKET */
        dctl.b.tstctl = 4;
        break;
        
      case 5: /* TEST_FORCE_ENABLE */
        dctl.b.tstctl = 5;
        break;
        
      default :
        dctl.b.tstctl = 1;
        break;
      }
      SET_TEST_MODE = dctl;
      pdev->dev.test_mode = 1;
      USBD_CtlSendStatus(pdev);
    }
    else
    {
      /* Do Nothing */
    }
  }
  
  
  /**
  * @brief  USBD_ClrFeature
  *         Handle clear device feature request
  * @param  pdev: device instance
  * @param  req: usb request
  * @retval status
  */
  static void USBD_ClrFeature(USB_OTG_CORE_HANDLE  *pdev, 
                              USB_SETUP_REQ *req)
  {
    switch (pdev->dev.device_status)
    {
    case USB_OTG_ADDRESSED:
    case USB_OTG_CONFIGURED:
      if (req->wValue == USB_FEATURE_REMOTE_WAKEUP) 
      {
        pdev->dev.DevRemoteWakeup = 0; 
        pdev->dev.class_cb->Setup (pdev, req);   
        USBD_CtlSendStatus(pdev);
      }
      break;
      
    default :
       USBD_CtlError(pdev , req);
      break;
    }
  }
  
  /**
  * @brief  USBD_ParseSetupRequest 
  *         Copy buffer into setup structure
  * @param  pdev: device instance
  * @param  req: usb request
  * @retval None
  */
  
  void USBD_ParseSetupRequest( USB_OTG_CORE_HANDLE  *pdev,
                              USB_SETUP_REQ *req)
  {
    req->bmRequest     = *(uint8_t *)  (pdev->dev.setup_packet);
    req->bRequest      = *(uint8_t *)  (pdev->dev.setup_packet +  1);
    req->wValue        = SWAPBYTE      (pdev->dev.setup_packet +  2);
    req->wIndex        = SWAPBYTE      (pdev->dev.setup_packet +  4);
    req->wLength       = SWAPBYTE      (pdev->dev.setup_packet +  6);
    
    pdev->dev.in_ep[0].ctl_data_len = req->wLength  ;
    pdev->dev.device_state = USB_OTG_EP0_SETUP;
  }
  
  /**
  * @brief  USBD_CtlError 
  *         Handle USB low level Error
  * @param  pdev: device instance
  * @param  req: usb request
  * @retval None
  */
  
  void USBD_CtlError( USB_OTG_CORE_HANDLE  *pdev,
                              USB_SETUP_REQ *req)
  {
    (void)req;
    DCD_EP_Stall(pdev , 0x80);
    DCD_EP_Stall(pdev , 0);
    USB_OTG_EP0_OutStart(pdev);  
  }
  
  
  /**
    * @brief  USBD_GetString
    *         Convert Ascii string into unicode one
    * @param  desc : descriptor buffer
    * @param  unicode : Formatted string buffer (unicode)
    * @param  len : descriptor length
    * @retval None
    */
  void USBD_GetString(uint8_t *desc, uint8_t *unicode, uint16_t *len)
  {
    uint8_t idx = 0;
    
    if (desc != NULL) 
    {
      *len =  USBD_GetLen(desc) * 2 + 2;    
      unicode[idx++] = *len;
      unicode[idx++] =  USB_DESC_TYPE_STRING;
      
      while (*desc != NULL) 
      {
        unicode[idx++] = *desc++;
        unicode[idx++] =  0x00;
      }
    } 
  }
  
  /**
    * @brief  USBD_GetLen
    *         return the string length
     * @param  buf : pointer to the ascii string buffer
    * @retval string length
    */
  static uint8_t USBD_GetLen(uint8_t *buf)
  {
      uint8_t  len = 0;
  
      while (*buf != NULL) 
      {
          len++;
          buf++;
      }
  
      return len;
  }
  /**
    * @}
    */ 
  
  
  /**
    * @}
    */ 
  
  
  /**
    * @}
    */ 
  
  /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  