WebSVN – LedShow – Diff – /trunk/Middlewares/ST/STM32_USB_Device_Library/Class/CDC/Src/usbd_cdc.c

 /**
   ******************************************************************************
   * @file    usbd_cdc.c
   * @author  MCD Application Team
-  * @version V2.4.2
-  * @date    11-December-2015
   * @brief   This file provides the high layer firmware functions to manage the
   *          following functionalities of the USB CDC Class:
   *           - Initialization and Configuration of high and low layer
   *           - Enumeration as CDC Device (and enumeration for each implemented memory interface)
   *           - OUT/IN data transfer
   *           - Command IN transfer (class requests management)
   *           - Error management
   *
   *  @verbatim
   *
   *          ===================================================================
   *                                CDC Class Driver Description
   *          ===================================================================
   *           This driver manages the "Universal Serial Bus Class Definitions for Communications Devices
   *           Revision 1.2 November 16, 2007" and the sub-protocol specification of "Universal Serial Bus
   *           Communications Class Subclass Specification for PSTN Devices Revision 1.2 February 9, 2007"
   *           This driver implements the following aspects of the specification:
   *             - Device descriptor management
   *             - Configuration descriptor management
   *             - Enumeration as CDC device with 2 data endpoints (IN and OUT) and 1 command endpoint (IN)
   *             - Requests management (as described in section 6.2 in specification)
   *             - Abstract Control Model compliant
   *             - Union Functional collection (using 1 IN endpoint for control)
   *             - Data interface class
   *
   *           These aspects may be enriched or modified for a specific user application.
   *
   *            This driver doesn't implement the following aspects of the specification
   *            (but it is possible to manage these features with some modifications on this driver):
   *             - Any class-specific aspect relative to communication classes should be managed by user application.
   *             - All communication classes other than PSTN are not managed
   *
   *  @endverbatim
   *
   ******************************************************************************
   * @attention
+  *
-  * <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
+  * <h2><center>&copy; Copyright (c) 2015 STMicroelectronics.
-  *
-  * 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:
+  * All rights reserved.</center></h2>
+  *
-  *        http://www.st.com/software_license_agreement_liberty_v2
-  *
-  * Unless required by applicable law or agreed to in writing, software
+  * This software component is licensed by ST under Ultimate Liberty license
-  * distributed under the License is distributed on an "AS IS" BASIS,
+  * SLA0044, the "License"; You may not use this file except in compliance with
-  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  * See the License for the specific language governing permissions and
+  * the License. You may obtain a copy of the License at:
-  * limitations under the License.
+  *                      www.st.com/SLA0044
+  *
   ******************************************************************************
   */
+/* BSPDependencies
+- "stm32xxxxx_{eval}{discovery}{nucleo_144}.c"
+- "stm32xxxxx_{eval}{discovery}_io.c"
+EndBSPDependencies */
 /* Includes ------------------------------------------------------------------*/
 #include "usbd_cdc.h"
-#include "usbd_desc.h"
 #include "usbd_ctlreq.h"
 /** @addtogroup STM32_USB_DEVICE_LIBRARY
   * @{
   */
 /** @defgroup USBD_CDC
   * @brief usbd core module
   * @{
   */
 /** @defgroup USBD_CDC_Private_TypesDefinitions
   * @{
   */
 /**
   * @}
   */
 /** @defgroup USBD_CDC_Private_Defines
   * @{
   */
 /**
   * @}
   */
 /** @defgroup USBD_CDC_Private_Macros
   * @{
   */
 /**
   * @}
   */
 /** @defgroup USBD_CDC_Private_FunctionPrototypes
   * @{
   */
-static uint8_t  USBD_CDC_Init (USBD_HandleTypeDef *pdev,
+static uint8_t  USBD_CDC_Init(USBD_HandleTypeDef *pdev,
-                               uint8_t cfgidx);
+                              uint8_t cfgidx);
-static uint8_t  USBD_CDC_DeInit (USBD_HandleTypeDef *pdev,
+static uint8_t  USBD_CDC_DeInit(USBD_HandleTypeDef *pdev,
-                                 uint8_t cfgidx);
+                                uint8_t cfgidx);
-static uint8_t  USBD_CDC_Setup (USBD_HandleTypeDef *pdev,
+static uint8_t  USBD_CDC_Setup(USBD_HandleTypeDef *pdev,
-                                USBD_SetupReqTypedef *req);
+                               USBD_SetupReqTypedef *req);
-static uint8_t  USBD_CDC_DataIn (USBD_HandleTypeDef *pdev,
+static uint8_t  USBD_CDC_DataIn(USBD_HandleTypeDef *pdev,
-                                 uint8_t epnum);
+                                uint8_t epnum);
-static uint8_t  USBD_CDC_DataOut (USBD_HandleTypeDef *pdev,
+static uint8_t  USBD_CDC_DataOut(USBD_HandleTypeDef *pdev,
                                  uint8_t epnum);
-static uint8_t  USBD_CDC_EP0_RxReady (USBD_HandleTypeDef *pdev);
+static uint8_t  USBD_CDC_EP0_RxReady(USBD_HandleTypeDef *pdev);
-static uint8_t  *USBD_CDC_GetFSCfgDesc (uint16_t *length);
+static uint8_t  *USBD_CDC_GetFSCfgDesc(uint16_t *length);
-static uint8_t  *USBD_CDC_GetHSCfgDesc (uint16_t *length);
+static uint8_t  *USBD_CDC_GetHSCfgDesc(uint16_t *length);
-static uint8_t  *USBD_CDC_GetOtherSpeedCfgDesc (uint16_t *length);
+static uint8_t  *USBD_CDC_GetOtherSpeedCfgDesc(uint16_t *length);
-static uint8_t  *USBD_CDC_GetOtherSpeedCfgDesc (uint16_t *length);
+static uint8_t  *USBD_CDC_GetOtherSpeedCfgDesc(uint16_t *length);
-uint8_t  *USBD_CDC_GetDeviceQualifierDescriptor (uint16_t *length);
+uint8_t  *USBD_CDC_GetDeviceQualifierDescriptor(uint16_t *length);
 /* USB Standard Device Descriptor */
 __ALIGN_BEGIN static uint8_t USBD_CDC_DeviceQualifierDesc[USB_LEN_DEV_QUALIFIER_DESC] __ALIGN_END =
+{
   USB_LEN_DEV_QUALIFIER_DESC,
 x00,
 };
 /**
   * @}
   */
 /** @defgroup USBD_CDC_Private_Variables
   * @{
   */
 /* CDC interface class callbacks structure */
 USBD_ClassTypeDef  USBD_CDC =
+{
   USBD_CDC_Init,
   USBD_CDC_DeInit,
   USBD_CDC_Setup,
   NULL,                 /* EP0_TxSent, */
   USBD_CDC_EP0_RxReady,
   USBD_CDC_DataIn,
   USBD_CDC_DataOut,
   NULL,
   NULL,
   NULL,
   USBD_CDC_GetHSCfgDesc,
   USBD_CDC_GetFSCfgDesc,
   USBD_CDC_GetOtherSpeedCfgDesc,
   USBD_CDC_GetDeviceQualifierDescriptor,
 };
 /* USB CDC device Configuration Descriptor */
 __ALIGN_BEGIN uint8_t USBD_CDC_CfgHSDesc[USB_CDC_CONFIG_DESC_SIZ] __ALIGN_END =
 x02,   /* bNumInterfaces: 2 interface */
 x01,   /* bConfigurationValue: Configuration value */
 x00,   /* iConfiguration: Index of string descriptor describing the configuration */
 xC0,   /* bmAttributes: self powered */
 x32,   /* MaxPower 0 mA */
   /*---------------------------------------------------------------------------*/
   /*Interface Descriptor */
 x09,   /* bLength: Interface Descriptor size */
   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
   /* Interface descriptor type */
 x00,   /* bInterfaceNumber: Number of Interface */
 x01,   /* bNumEndpoints: One endpoints used */
 x02,   /* bInterfaceClass: Communication Interface Class */
 x02,   /* bInterfaceSubClass: Abstract Control Model */
 x01,   /* bInterfaceProtocol: Common AT commands */
 x00,   /* iInterface: */
   /*Header Functional Descriptor*/
 x05,   /* bLength: Endpoint Descriptor size */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x00,   /* bDescriptorSubtype: Header Func Desc */
 x10,   /* bcdCDC: spec release number */
 x01,
   /*Call Management Functional Descriptor*/
 x05,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x01,   /* bDescriptorSubtype: Call Management Func Desc */
 x00,   /* bmCapabilities: D0+D1 */
 x01,   /* bDataInterface: 1 */
   /*ACM Functional Descriptor*/
 x04,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x02,   /* bDescriptorSubtype: Abstract Control Management desc */
 x02,   /* bmCapabilities */
   /*Union Functional Descriptor*/
 x05,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x06,   /* bDescriptorSubtype: Union func desc */
 x00,   /* bMasterInterface: Communication class interface */
 x01,   /* bSlaveInterface0: Data Class Interface */
   /*Endpoint 2 Descriptor*/
 x07,                           /* bLength: Endpoint Descriptor size */
   USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
   CDC_CMD_EP,                     /* bEndpointAddress */
 x03,                           /* bmAttributes: Interrupt */
   LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
   HIBYTE(CDC_CMD_PACKET_SIZE),
-x10,                           /* bInterval: */
+  CDC_HS_BINTERVAL,                           /* bInterval: */
   /*---------------------------------------------------------------------------*/
   /*Data class interface descriptor*/
 x09,   /* bLength: Endpoint Descriptor size */
   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
 x01,   /* bInterfaceNumber: Number of Interface */
 x00,   /* bAlternateSetting: Alternate setting */
 x02,   /* bNumEndpoints: Two endpoints used */
 x0A,   /* bInterfaceClass: CDC */
 x00,   /* bInterfaceSubClass: */
 x00,   /* bInterfaceProtocol: */
 x00,   /* iInterface: */
   /*Endpoint OUT Descriptor*/
 x07,   /* bLength: Endpoint Descriptor size */
   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
   CDC_OUT_EP,                        /* bEndpointAddress */
 x02,                              /* bmAttributes: Bulk */
   LOBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
   HIBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),
 x00,                              /* bInterval: ignore for Bulk transfer */
   /*Endpoint IN Descriptor*/
 x07,   /* bLength: Endpoint Descriptor size */
   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
   CDC_IN_EP,                         /* bEndpointAddress */
 x02,                              /* bmAttributes: Bulk */
 x02,   /* bNumInterfaces: 2 interface */
 x01,   /* bConfigurationValue: Configuration value */
 x00,   /* iConfiguration: Index of string descriptor describing the configuration */
 xC0,   /* bmAttributes: self powered */
 x32,   /* MaxPower 0 mA */
   /*---------------------------------------------------------------------------*/
   /*Interface Descriptor */
 x09,   /* bLength: Interface Descriptor size */
   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
   /* Interface descriptor type */
 x00,   /* bInterfaceNumber: Number of Interface */
 x01,   /* bNumEndpoints: One endpoints used */
 x02,   /* bInterfaceClass: Communication Interface Class */
 x02,   /* bInterfaceSubClass: Abstract Control Model */
 x01,   /* bInterfaceProtocol: Common AT commands */
 x00,   /* iInterface: */
   /*Header Functional Descriptor*/
 x05,   /* bLength: Endpoint Descriptor size */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x00,   /* bDescriptorSubtype: Header Func Desc */
 x10,   /* bcdCDC: spec release number */
 x01,
   /*Call Management Functional Descriptor*/
 x05,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x01,   /* bDescriptorSubtype: Call Management Func Desc */
 x00,   /* bmCapabilities: D0+D1 */
 x01,   /* bDataInterface: 1 */
   /*ACM Functional Descriptor*/
 x04,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x02,   /* bDescriptorSubtype: Abstract Control Management desc */
 x02,   /* bmCapabilities */
   /*Union Functional Descriptor*/
 x05,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x06,   /* bDescriptorSubtype: Union func desc */
 x00,   /* bMasterInterface: Communication class interface */
 x01,   /* bSlaveInterface0: Data Class Interface */
   /*Endpoint 2 Descriptor*/
 x07,                           /* bLength: Endpoint Descriptor size */
   USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
   CDC_CMD_EP,                     /* bEndpointAddress */
 x03,                           /* bmAttributes: Interrupt */
   LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
   HIBYTE(CDC_CMD_PACKET_SIZE),
-x10,                           /* bInterval: */
+  CDC_FS_BINTERVAL,                           /* bInterval: */
   /*---------------------------------------------------------------------------*/
   /*Data class interface descriptor*/
 x09,   /* bLength: Endpoint Descriptor size */
   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
 x01,   /* bInterfaceNumber: Number of Interface */
 x00,   /* bAlternateSetting: Alternate setting */
 x02,   /* bNumEndpoints: Two endpoints used */
 x0A,   /* bInterfaceClass: CDC */
 x00,   /* bInterfaceSubClass: */
 x00,   /* bInterfaceProtocol: */
 x00,   /* iInterface: */
   /*Endpoint OUT Descriptor*/
 x07,   /* bLength: Endpoint Descriptor size */
   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
   CDC_OUT_EP,                        /* bEndpointAddress */
 x02,                              /* bmAttributes: Bulk */
   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
 x00,                              /* bInterval: ignore for Bulk transfer */
   /*Endpoint IN Descriptor*/
 x07,   /* bLength: Endpoint Descriptor size */
   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
   CDC_IN_EP,                         /* bEndpointAddress */
 x02,                              /* bmAttributes: Bulk */
   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
 x00                               /* bInterval: ignore for Bulk transfer */
 } ;
 __ALIGN_BEGIN uint8_t USBD_CDC_OtherSpeedCfgDesc[USB_CDC_CONFIG_DESC_SIZ] __ALIGN_END =
 {
 x09,   /* bLength: Configuation Descriptor size */
   USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION,
   USB_CDC_CONFIG_DESC_SIZ,
 x00,
 x02,   /* bNumInterfaces: 2 interfaces */
 x01,   /* bConfigurationValue: */
 x04,   /* iConfiguration: */
 xC0,   /* bmAttributes: */
 x32,   /* MaxPower 100 mA */
   /*Interface Descriptor */
 x09,   /* bLength: Interface Descriptor size */
   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
   /* Interface descriptor type */
 x00,   /* bInterfaceNumber: Number of Interface */
 x01,   /* bNumEndpoints: One endpoints used */
 x02,   /* bInterfaceClass: Communication Interface Class */
 x02,   /* bInterfaceSubClass: Abstract Control Model */
 x01,   /* bInterfaceProtocol: Common AT commands */
 x00,   /* iInterface: */
   /*Header Functional Descriptor*/
 x05,   /* bLength: Endpoint Descriptor size */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x00,   /* bDescriptorSubtype: Header Func Desc */
 x10,   /* bcdCDC: spec release number */
 x01,
   /*Call Management Functional Descriptor*/
 x05,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x01,   /* bDescriptorSubtype: Call Management Func Desc */
 x00,   /* bmCapabilities: D0+D1 */
 x01,   /* bDataInterface: 1 */
   /*ACM Functional Descriptor*/
 x04,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x02,   /* bDescriptorSubtype: Abstract Control Management desc */
 x02,   /* bmCapabilities */
   /*Union Functional Descriptor*/
 x05,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x06,   /* bDescriptorSubtype: Union func desc */
 x00,   /* bMasterInterface: Communication class interface */
 x01,   /* bSlaveInterface0: Data Class Interface */
   /*Endpoint 2 Descriptor*/
 x07,                           /* bLength: Endpoint Descriptor size */
-  USB_DESC_TYPE_ENDPOINT      ,   /* bDescriptorType: Endpoint */
+  USB_DESC_TYPE_ENDPOINT,         /* bDescriptorType: Endpoint */
   CDC_CMD_EP,                     /* bEndpointAddress */
 x03,                           /* bmAttributes: Interrupt */
   LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
   HIBYTE(CDC_CMD_PACKET_SIZE),
-xFF,                           /* bInterval: */
+  CDC_FS_BINTERVAL,                           /* bInterval: */
   /*---------------------------------------------------------------------------*/
   /*Data class interface descriptor*/
 x09,   /* bLength: Endpoint Descriptor size */
   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
 x01,   /* bInterfaceNumber: Number of Interface */
 x00,   /* bAlternateSetting: Alternate setting */
 x02,   /* bNumEndpoints: Two endpoints used */
 x0A,   /* bInterfaceClass: CDC */
 x00,   /* bInterfaceSubClass: */
 x00,   /* bInterfaceProtocol: */
 x00,   /* iInterface: */
   /*Endpoint OUT Descriptor*/
 x07,   /* bLength: Endpoint Descriptor size */
   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
   CDC_OUT_EP,                        /* bEndpointAddress */
 x02,                              /* bmAttributes: Bulk */
 x40,                              /* wMaxPacketSize: */
 x00,
 x00,                              /* bInterval: ignore for Bulk transfer */
   /*Endpoint IN Descriptor*/
 x07,   /* bLength: Endpoint Descriptor size */
   USB_DESC_TYPE_ENDPOINT,     /* bDescriptorType: Endpoint */
   CDC_IN_EP,                        /* bEndpointAddress */
 x02,                             /* bmAttributes: Bulk */
 x00                              /* bInterval */
 };
 /**
   * @}
   */
 /** @defgroup USBD_CDC_Private_Functions
   * @{
   */
 /**
   * @brief  USBD_CDC_Init
   *         Initialize the CDC interface
   * @param  pdev: device instance
   * @param  cfgidx: Configuration index
   * @retval status
   */
-static uint8_t  USBD_CDC_Init (USBD_HandleTypeDef *pdev,
+static uint8_t  USBD_CDC_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
-                               uint8_t cfgidx)
+{
-  uint8_t ret = 0;
+  uint8_t ret = 0U;
   USBD_CDC_HandleTypeDef   *hcdc;
-  if(pdev->dev_speed == USBD_SPEED_HIGH  )
+  if (pdev->dev_speed == USBD_SPEED_HIGH)
   {
     /* Open EP IN */
-    USBD_LL_OpenEP(pdev,
-                   CDC_IN_EP,
-                   USBD_EP_TYPE_BULK,
+    USBD_LL_OpenEP(pdev, CDC_IN_EP, USBD_EP_TYPE_BULK,
                    CDC_DATA_HS_IN_PACKET_SIZE);
+    pdev->ep_in[CDC_IN_EP & 0xFU].is_used = 1U;
     /* Open EP OUT */
-    USBD_LL_OpenEP(pdev,
-                   CDC_OUT_EP,
-                   USBD_EP_TYPE_BULK,
+    USBD_LL_OpenEP(pdev, CDC_OUT_EP, USBD_EP_TYPE_BULK,
                    CDC_DATA_HS_OUT_PACKET_SIZE);
+    pdev->ep_out[CDC_OUT_EP & 0xFU].is_used = 1U;
+  }
   else
+  {
     /* Open EP IN */
-    USBD_LL_OpenEP(pdev,
-                   CDC_IN_EP,
-                   USBD_EP_TYPE_BULK,
+    USBD_LL_OpenEP(pdev, CDC_IN_EP, USBD_EP_TYPE_BULK,
                    CDC_DATA_FS_IN_PACKET_SIZE);
+    pdev->ep_in[CDC_IN_EP & 0xFU].is_used = 1U;
     /* Open EP OUT */
-    USBD_LL_OpenEP(pdev,
-                   CDC_OUT_EP,
-                   USBD_EP_TYPE_BULK,
+    USBD_LL_OpenEP(pdev, CDC_OUT_EP, USBD_EP_TYPE_BULK,
                    CDC_DATA_FS_OUT_PACKET_SIZE);
+    pdev->ep_out[CDC_OUT_EP & 0xFU].is_used = 1U;
+  }
   /* Open Command IN EP */
-  USBD_LL_OpenEP(pdev,
-                 CDC_CMD_EP,
-                 USBD_EP_TYPE_INTR,
+  USBD_LL_OpenEP(pdev, CDC_CMD_EP, USBD_EP_TYPE_INTR, CDC_CMD_PACKET_SIZE);
-                 CDC_CMD_PACKET_SIZE);
+  pdev->ep_in[CDC_CMD_EP & 0xFU].is_used = 1U;
-  pdev->pClassData = USBD_malloc(sizeof (USBD_CDC_HandleTypeDef));
+  pdev->pClassData = USBD_malloc(sizeof(USBD_CDC_HandleTypeDef));
-  if(pdev->pClassData == NULL)
+  if (pdev->pClassData == NULL)
+  {
-    ret = 1;
+    ret = 1U;
+  }
   else
+  {
-    hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
+    hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
     /* Init  physical Interface components */
     ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Init();
     /* Init Xfer states */
-    hcdc->TxState =0;
+    hcdc->TxState = 0U;
-    hcdc->RxState =0;
+    hcdc->RxState = 0U;
-    if(pdev->dev_speed == USBD_SPEED_HIGH  )
+    if (pdev->dev_speed == USBD_SPEED_HIGH)
     {
       /* Prepare Out endpoint to receive next packet */
-      USBD_LL_PrepareReceive(pdev,
+      USBD_LL_PrepareReceive(pdev, CDC_OUT_EP, hcdc->RxBuffer,
-                             CDC_OUT_EP,
-                             hcdc->RxBuffer,
                              CDC_DATA_HS_OUT_PACKET_SIZE);
+    }
     else
+    {
       /* Prepare Out endpoint to receive next packet */
-      USBD_LL_PrepareReceive(pdev,
+      USBD_LL_PrepareReceive(pdev, CDC_OUT_EP, hcdc->RxBuffer,
-                             CDC_OUT_EP,
-                             hcdc->RxBuffer,
                              CDC_DATA_FS_OUT_PACKET_SIZE);
+    }
+  }
   return ret;
+}
 /**
   *         DeInitialize the CDC layer
   * @param  pdev: device instance
   * @param  cfgidx: Configuration index
   * @retval status
   */
-static uint8_t  USBD_CDC_DeInit (USBD_HandleTypeDef *pdev,
+static uint8_t  USBD_CDC_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
-                                 uint8_t cfgidx)
+{
-  uint8_t ret = 0;
+  uint8_t ret = 0U;
-  /* Open EP IN */
+  /* Close EP IN */
-  USBD_LL_CloseEP(pdev,
+  USBD_LL_CloseEP(pdev, CDC_IN_EP);
-              CDC_IN_EP);
+  pdev->ep_in[CDC_IN_EP & 0xFU].is_used = 0U;
-  /* Open EP OUT */
+  /* Close EP OUT */
-  USBD_LL_CloseEP(pdev,
+  USBD_LL_CloseEP(pdev, CDC_OUT_EP);
-              CDC_OUT_EP);
+  pdev->ep_out[CDC_OUT_EP & 0xFU].is_used = 0U;
-  /* Open Command IN EP */
+  /* Close Command IN EP */
-  USBD_LL_CloseEP(pdev,
+  USBD_LL_CloseEP(pdev, CDC_CMD_EP);
-              CDC_CMD_EP);
+  pdev->ep_in[CDC_CMD_EP & 0xFU].is_used = 0U;
   /* DeInit  physical Interface components */
-  if(pdev->pClassData != NULL)
+  if (pdev->pClassData != NULL)
+  {
     ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->DeInit();
     USBD_free(pdev->pClassData);
     pdev->pClassData = NULL;
+  }
   return ret;
+}
 /**
   * @brief  USBD_CDC_Setup
   *         Handle the CDC specific requests
   * @param  pdev: instance
   * @param  req: usb requests
   * @retval status
   */
-static uint8_t  USBD_CDC_Setup (USBD_HandleTypeDef *pdev,
+static uint8_t  USBD_CDC_Setup(USBD_HandleTypeDef *pdev,
-                                USBD_SetupReqTypedef *req)
+                               USBD_SetupReqTypedef *req)
+{
-  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
+  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
-  static uint8_t ifalt = 0;
+  uint8_t ifalt = 0U;
+  uint16_t status_info = 0U;
+  uint8_t ret = USBD_OK;
   switch (req->bmRequest & USB_REQ_TYPE_MASK)
+  {
-  case USB_REQ_TYPE_CLASS :
+    case USB_REQ_TYPE_CLASS :
-    if (req->wLength)
+      if (req->wLength)
-    {
-      if (req->bmRequest & 0x80)
+      {
+        if (req->bmRequest & 0x80U)
+        {
-        ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(req->bRequest,
+          ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(req->bRequest,
-                                                          (uint8_t *)hcdc->data,
+                                                            (uint8_t *)(void *)hcdc->data,
-                                                          req->wLength);
+                                                            req->wLength);
+          USBD_CtlSendData(pdev, (uint8_t *)(void *)hcdc->data, req->wLength);
+        }
+        else
+        {
-          USBD_CtlSendData (pdev,
+          hcdc->CmdOpCode = req->bRequest;
-                            (uint8_t *)hcdc->data,
+          hcdc->CmdLength = (uint8_t)req->wLength;
-                            req->wLength);
+          USBD_CtlPrepareRx(pdev, (uint8_t *)(void *)hcdc->data, req->wLength);
+        }
+      }
       else
+      {
-        hcdc->CmdOpCode = req->bRequest;
+        ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(req->bRequest,
-        hcdc->CmdLength = req->wLength;
-        USBD_CtlPrepareRx (pdev,
-                           (uint8_t *)hcdc->data,
+                                                          (uint8_t *)(void *)req, 0U);
-                           req->wLength);
+      }
-    }
-    else
-    {
-      ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(req->bRequest,
-                                                        (uint8_t*)req,
-);
-    }
-    break;
+      break;
-  case USB_REQ_TYPE_STANDARD:
+    case USB_REQ_TYPE_STANDARD:
-    switch (req->bRequest)
+      switch (req->bRequest)
+      {
+        case USB_REQ_GET_STATUS:
+          if (pdev->dev_state == USBD_STATE_CONFIGURED)
+          {
+            USBD_CtlSendData(pdev, (uint8_t *)(void *)&status_info, 2U);
+          }
+          else
+          {
+            USBD_CtlError(pdev, req);
+            ret = USBD_FAIL;
-    {
+          }
+          break;
-    case USB_REQ_GET_INTERFACE :
+        case USB_REQ_GET_INTERFACE:
+          if (pdev->dev_state == USBD_STATE_CONFIGURED)
+          {
-      USBD_CtlSendData (pdev,
+            USBD_CtlSendData(pdev, &ifalt, 1U);
+          }
+          else
+          {
+            USBD_CtlError(pdev, req);
-                        &ifalt,
+            ret = USBD_FAIL;
+          }
+          break;
+        case USB_REQ_SET_INTERFACE:
+          if (pdev->dev_state != USBD_STATE_CONFIGURED)
+          {
+            USBD_CtlError(pdev, req);
-);
+            ret = USBD_FAIL;
+          }
+          break;
+        default:
+          USBD_CtlError(pdev, req);
+          ret = USBD_FAIL;
+          break;
+      }
       break;
+    default:
-    case USB_REQ_SET_INTERFACE :
+      USBD_CtlError(pdev, req);
+      ret = USBD_FAIL;
       break;
-    }
-  default:
-    break;
+  }
-  return USBD_OK;
+  return ret;
+}
 /**
   * @brief  USBD_CDC_DataIn
   *         Data sent on non-control IN endpoint
   * @param  pdev: device instance
   * @param  epnum: endpoint number
   * @retval status
   */
-static uint8_t  USBD_CDC_DataIn (USBD_HandleTypeDef *pdev, uint8_t epnum)
+static uint8_t  USBD_CDC_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
+{
-  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
+  USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef *)pdev->pClassData;
+  PCD_HandleTypeDef *hpcd = pdev->pData;
-  if(pdev->pClassData != NULL)
+  if (pdev->pClassData != NULL)
+  {
+    if ((pdev->ep_in[epnum].total_length > 0U) && ((pdev->ep_in[epnum].total_length % hpcd->IN_ep[epnum].maxpacket) == 0U))
+    {
+      /* Update the packet total length */
-    hcdc->TxState = 0;
+      pdev->ep_in[epnum].total_length = 0U;
+      /* Send ZLP */
+      USBD_LL_Transmit(pdev, epnum, NULL, 0U);
+    }
+    else
+    {
+      hcdc->TxState = 0U;
+    }
     return USBD_OK;
+  }
   else
+  {
     return USBD_FAIL;
   *         Data received on non-control Out endpoint
   * @param  pdev: device instance
   * @param  epnum: endpoint number
   * @retval status
   */
-static uint8_t  USBD_CDC_DataOut (USBD_HandleTypeDef *pdev, uint8_t epnum)
+static uint8_t  USBD_CDC_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
 {
-  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
+  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
   /* Get the received data length */
-  hcdc->RxLength = USBD_LL_GetRxDataSize (pdev, epnum);
+  hcdc->RxLength = USBD_LL_GetRxDataSize(pdev, epnum);
   /* USB data will be immediately processed, this allow next USB traffic being
   NAKed till the end of the application Xfer */
-  if(pdev->pClassData != NULL)
+  if (pdev->pClassData != NULL)
+  {
     ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Receive(hcdc->RxBuffer, &hcdc->RxLength);
     return USBD_OK;
+  }
+  {
     return USBD_FAIL;
+  }
+}
 /**
-  * @brief  USBD_CDC_DataOut
+  * @brief  USBD_CDC_EP0_RxReady
-  *         Data received on non-control Out endpoint
+  *         Handle EP0 Rx Ready event
   * @param  pdev: device instance
-  * @param  epnum: endpoint number
   * @retval status
   */
-static uint8_t  USBD_CDC_EP0_RxReady (USBD_HandleTypeDef *pdev)
+static uint8_t  USBD_CDC_EP0_RxReady(USBD_HandleTypeDef *pdev)
 {
-  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
+  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
-  if((pdev->pUserData != NULL) && (hcdc->CmdOpCode != 0xFF))
+  if ((pdev->pUserData != NULL) && (hcdc->CmdOpCode != 0xFFU))
+  {
     ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(hcdc->CmdOpCode,
-                                                      (uint8_t *)hcdc->data,
+                                                      (uint8_t *)(void *)hcdc->data,
-                                                      hcdc->CmdLength);
+                                                      (uint16_t)hcdc->CmdLength);
-      hcdc->CmdOpCode = 0xFF;
+    hcdc->CmdOpCode = 0xFFU;
+  }
   return USBD_OK;
+}
 /**
   * @brief  USBD_CDC_GetFSCfgDesc
   *         Return configuration descriptor
   * @param  speed : current device speed
   * @param  length : pointer data length
   * @retval pointer to descriptor buffer
   */
-static uint8_t  *USBD_CDC_GetFSCfgDesc (uint16_t *length)
+static uint8_t  *USBD_CDC_GetFSCfgDesc(uint16_t *length)
+{
-  *length = sizeof (USBD_CDC_CfgFSDesc);
+  *length = sizeof(USBD_CDC_CfgFSDesc);
   return USBD_CDC_CfgFSDesc;
+}
 /**
   * @brief  USBD_CDC_GetHSCfgDesc
   *         Return configuration descriptor
   * @param  speed : current device speed
   * @param  length : pointer data length
   * @retval pointer to descriptor buffer
   */
-static uint8_t  *USBD_CDC_GetHSCfgDesc (uint16_t *length)
+static uint8_t  *USBD_CDC_GetHSCfgDesc(uint16_t *length)
+{
-  *length = sizeof (USBD_CDC_CfgHSDesc);
+  *length = sizeof(USBD_CDC_CfgHSDesc);
   return USBD_CDC_CfgHSDesc;
+}
 /**
   * @brief  USBD_CDC_GetCfgDesc
   *         Return configuration descriptor
   * @param  speed : current device speed
   * @param  length : pointer data length
   * @retval pointer to descriptor buffer
   */
-static uint8_t  *USBD_CDC_GetOtherSpeedCfgDesc (uint16_t *length)
+static uint8_t  *USBD_CDC_GetOtherSpeedCfgDesc(uint16_t *length)
+{
-  *length = sizeof (USBD_CDC_OtherSpeedCfgDesc);
+  *length = sizeof(USBD_CDC_OtherSpeedCfgDesc);
   return USBD_CDC_OtherSpeedCfgDesc;
+}
 /**
 * @brief  DeviceQualifierDescriptor
 *         return Device Qualifier descriptor
 * @param  length : pointer data length
 * @retval pointer to descriptor buffer
 */
-uint8_t  *USBD_CDC_GetDeviceQualifierDescriptor (uint16_t *length)
+uint8_t  *USBD_CDC_GetDeviceQualifierDescriptor(uint16_t *length)
+{
-  *length = sizeof (USBD_CDC_DeviceQualifierDesc);
+  *length = sizeof(USBD_CDC_DeviceQualifierDesc);
   return USBD_CDC_DeviceQualifierDesc;
+}
 /**
 * @brief  USBD_CDC_RegisterInterface
   * @param  pdev: device instance
   * @param  fops: CD  Interface callback
   * @retval status
   */
-uint8_t  USBD_CDC_RegisterInterface  (USBD_HandleTypeDef   *pdev,
+uint8_t  USBD_CDC_RegisterInterface(USBD_HandleTypeDef   *pdev,
-                                      USBD_CDC_ItfTypeDef *fops)
+                                    USBD_CDC_ItfTypeDef *fops)
+{
   uint8_t  ret = USBD_FAIL;
-  if(fops != NULL)
+  if (fops != NULL)
+  {
-    pdev->pUserData= fops;
+    pdev->pUserData = fops;
     ret = USBD_OK;
+  }
   return ret;
+}
 /**
   * @brief  USBD_CDC_SetTxBuffer
   * @param  pdev: device instance
   * @param  pbuff: Tx Buffer
   * @retval status
   */
-uint8_t  USBD_CDC_SetTxBuffer  (USBD_HandleTypeDef   *pdev,
+uint8_t  USBD_CDC_SetTxBuffer(USBD_HandleTypeDef   *pdev,
-                                uint8_t  *pbuff,
+                              uint8_t  *pbuff,
-                                uint16_t length)
+                              uint16_t length)
+{
-  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
+  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
   hcdc->TxBuffer = pbuff;
   hcdc->TxLength = length;
   return USBD_OK;
+}
 /**
   * @brief  USBD_CDC_SetRxBuffer
   * @param  pdev: device instance
   * @param  pbuff: Rx Buffer
   * @retval status
   */
-uint8_t  USBD_CDC_SetRxBuffer  (USBD_HandleTypeDef   *pdev,
+uint8_t  USBD_CDC_SetRxBuffer(USBD_HandleTypeDef   *pdev,
-                                   uint8_t  *pbuff)
+                              uint8_t  *pbuff)
+{
-  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
+  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
   hcdc->RxBuffer = pbuff;
   return USBD_OK;
+}
 /**
-  * @brief  USBD_CDC_DataOut
+  * @brief  USBD_CDC_TransmitPacket
-  *         Data received on non-control Out endpoint
+  *         Transmit packet on IN endpoint
   * @param  pdev: device instance
-  * @param  epnum: endpoint number
   * @retval status
   */
 uint8_t  USBD_CDC_TransmitPacket(USBD_HandleTypeDef *pdev)
 {
-  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
+  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
-  if(pdev->pClassData != NULL)
+  if (pdev->pClassData != NULL)
+  {
-    if(hcdc->TxState == 0)
+    if (hcdc->TxState == 0U)
+    {
       /* Tx Transfer in progress */
-      hcdc->TxState = 1;
+      hcdc->TxState = 1U;
+      /* Update the packet total length */
+      pdev->ep_in[CDC_IN_EP & 0xFU].total_length = hcdc->TxLength;
       /* Transmit next packet */
-      USBD_LL_Transmit(pdev,
+      USBD_LL_Transmit(pdev, CDC_IN_EP, hcdc->TxBuffer,
-                       CDC_IN_EP,
-                       hcdc->TxBuffer,
-                       hcdc->TxLength);
+                       (uint16_t)hcdc->TxLength);
       return USBD_OK;
+    }
     else
+    {
       return USBD_BUSY;
   *         prepare OUT Endpoint for reception
   * @param  pdev: device instance
   * @retval status
   */
 uint8_t  USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev)
 {
-  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
+  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef *) pdev->pClassData;
   /* Suspend or Resume USB Out process */
-  if(pdev->pClassData != NULL)
+  if (pdev->pClassData != NULL)
+  {
-    if(pdev->dev_speed == USBD_SPEED_HIGH  )
+    if (pdev->dev_speed == USBD_SPEED_HIGH)
     {
       /* Prepare Out endpoint to receive next packet */
       USBD_LL_PrepareReceive(pdev,
                              CDC_OUT_EP,
                              hcdc->RxBuffer,
                              CDC_DATA_HS_OUT_PACKET_SIZE);
     return USBD_FAIL;
+  }
+}
 /**
   * @}
   */
 /**
   * @}
   */
 /**
   * @}
   */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

Subversion Repositories LedShow

(root)/trunk/Middlewares/ST/STM32_USB_Device_Library/Class/CDC/Src/usbd_cdc.c – Rev 2 → 9