lib/main/STM32F1/Middlewares/ST/STM32_USB_Device_Library/Class/CDC/Src/usbd_cdc.c

   1 /**
   2   ******************************************************************************
   3   * @file    usbd_cdc.c
   4   * @author  MCD Application Team
   5   * @version V2.4.2
   6   * @date    11-December-2015
   7   * @brief   This file provides the high layer firmware functions to manage the
   8   *          following functionalities of the USB CDC Class:
   9   *           - Initialization and Configuration of high and low layer
  10   *           - Enumeration as CDC Device (and enumeration for each implemented memory interface)
  11   *           - OUT/IN data transfer
  12   *           - Command IN transfer (class requests management)
  13   *           - Error management
  14   *
  15   *  @verbatim
  16   *
  17   *          ===================================================================
  18   *                                CDC Class Driver Description
  19   *          ===================================================================
  20   *           This driver manages the "Universal Serial Bus Class Definitions for Communications Devices
  21   *           Revision 1.2 November 16, 2007" and the sub-protocol specification of "Universal Serial Bus
  22   *           Communications Class Subclass Specification for PSTN Devices Revision 1.2 February 9, 2007"
  23   *           This driver implements the following aspects of the specification:
  24   *             - Device descriptor management
  25   *             - Configuration descriptor management
  26   *             - Enumeration as CDC device with 2 data endpoints (IN and OUT) and 1 command endpoint (IN)
  27   *             - Requests management (as described in section 6.2 in specification)
  28   *             - Abstract Control Model compliant
  29   *             - Union Functional collection (using 1 IN endpoint for control)
  30   *             - Data interface class
  31   *
  32   *           These aspects may be enriched or modified for a specific user application.
  33   *
  34   *            This driver doesn't implement the following aspects of the specification
  35   *            (but it is possible to manage these features with some modifications on this driver):
  36   *             - Any class-specific aspect relative to communication classes should be managed by user application.
  37   *             - All communication classes other than PSTN are not managed
  38   *
  39   *  @endverbatim
  40   *
  41   ******************************************************************************
  42   * @attention
  43   *
  44   * <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
  45   *
  46   * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
  47   * You may not use this file except in compliance with the License.
  48   * You may obtain a copy of the License at:
  49   *
  50   *        http://www.st.com/software_license_agreement_liberty_v2
  51   *
  52   * Unless required by applicable law or agreed to in writing, software
  53   * distributed under the License is distributed on an "AS IS" BASIS,
  54   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  55   * See the License for the specific language governing permissions and
  56   * limitations under the License.
  57   *
  58   ******************************************************************************
  59   */
  60
  61 /* Includes ------------------------------------------------------------------*/
  62 #include "usbd_cdc.h"
  63 #include "usbd_desc.h"
  64 #include "usbd_ctlreq.h"
  65
  66
  67 /** @addtogroup STM32_USB_DEVICE_LIBRARY
  68   * @{
  69   */
  70
  71
  72 /** @defgroup USBD_CDC
  73   * @brief usbd core module
  74   * @{
  75   */
  76
  77 /** @defgroup USBD_CDC_Private_TypesDefinitions
  78   * @{
  79   */
  80 /**
  81   * @}
  82   */
  83
  84
  85 /** @defgroup USBD_CDC_Private_Defines
  86   * @{
  87   */
  88 /**
  89   * @}
  90   */
  91
  92
  93 /** @defgroup USBD_CDC_Private_Macros
  94   * @{
  95   */
  96
  97 /**
  98   * @}
  99   */
 100
 101
 102 /** @defgroup USBD_CDC_Private_FunctionPrototypes
 103   * @{
 104   */
 105
 106
 107 static uint8_t  USBD_CDC_Init (USBD_HandleTypeDef *pdev,
 108                                uint8_t cfgidx);
 109
 110 static uint8_t  USBD_CDC_DeInit (USBD_HandleTypeDef *pdev,
 111                                  uint8_t cfgidx);
 112
 113 static uint8_t  USBD_CDC_Setup (USBD_HandleTypeDef *pdev,
 114                                 USBD_SetupReqTypedef *req);
 115
 116 static uint8_t  USBD_CDC_DataIn (USBD_HandleTypeDef *pdev,
 117                                  uint8_t epnum);
 118
 119 static uint8_t  USBD_CDC_DataOut (USBD_HandleTypeDef *pdev,
 120                                  uint8_t epnum);
 121
 122 static uint8_t  USBD_CDC_EP0_RxReady (USBD_HandleTypeDef *pdev);
 123
 124 static uint8_t  *USBD_CDC_GetFSCfgDesc (uint16_t *length);
 125
 126 static uint8_t  *USBD_CDC_GetHSCfgDesc (uint16_t *length);
 127
 128 static uint8_t  *USBD_CDC_GetOtherSpeedCfgDesc (uint16_t *length);
 129
 130 static uint8_t  *USBD_CDC_GetOtherSpeedCfgDesc (uint16_t *length);
 131
 132 uint8_t  *USBD_CDC_GetDeviceQualifierDescriptor (uint16_t *length);
 133
 134 /* USB Standard Device Descriptor */
 135 __ALIGN_BEGIN static uint8_t USBD_CDC_DeviceQualifierDesc[USB_LEN_DEV_QUALIFIER_DESC] __ALIGN_END =
 136 {
 137   USB_LEN_DEV_QUALIFIER_DESC,
 138   USB_DESC_TYPE_DEVICE_QUALIFIER,
 139   0x00,
 140   0x02,
 141   0x00,
 142   0x00,
 143   0x00,
 144   0x40,
 145   0x01,
 146   0x00,
 147 };
 148
 149 /**
 150   * @}
 151   */
 152
 153 /** @defgroup USBD_CDC_Private_Variables
 154   * @{
 155   */
 156
 157
 158 /* CDC interface class callbacks structure */
 159 USBD_ClassTypeDef  USBD_CDC =
 160 {
 161   USBD_CDC_Init,
 162   USBD_CDC_DeInit,
 163   USBD_CDC_Setup,
 164   NULL,                 /* EP0_TxSent, */
 165   USBD_CDC_EP0_RxReady,
 166   USBD_CDC_DataIn,
 167   USBD_CDC_DataOut,
 168   NULL,
 169   NULL,
 170   NULL,
 171   USBD_CDC_GetHSCfgDesc,
 172   USBD_CDC_GetFSCfgDesc,
 173   USBD_CDC_GetOtherSpeedCfgDesc,
 174   USBD_CDC_GetDeviceQualifierDescriptor,
 175 };
 176
 177 /* USB CDC device Configuration Descriptor */
 178 __ALIGN_BEGIN uint8_t USBD_CDC_CfgHSDesc[USB_CDC_CONFIG_DESC_SIZ] __ALIGN_END =
 179 {
 180   /*Configuration Descriptor*/
 181   0x09,   /* bLength: Configuration Descriptor size */
 182   USB_DESC_TYPE_CONFIGURATION,      /* bDescriptorType: Configuration */
 183   USB_CDC_CONFIG_DESC_SIZ,                /* wTotalLength:no of returned bytes */
 184   0x00,
 185   0x02,   /* bNumInterfaces: 2 interface */
 186   0x01,   /* bConfigurationValue: Configuration value */
 187   0x00,   /* iConfiguration: Index of string descriptor describing the configuration */
 188   0xC0,   /* bmAttributes: self powered */
 189   0x32,   /* MaxPower 0 mA */
 190
 191   /*---------------------------------------------------------------------------*/
 192
 193   /*Interface Descriptor */
 194   0x09,   /* bLength: Interface Descriptor size */
 195   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
 196   /* Interface descriptor type */
 197   0x00,   /* bInterfaceNumber: Number of Interface */
 198   0x00,   /* bAlternateSetting: Alternate setting */
 199   0x01,   /* bNumEndpoints: One endpoints used */
 200   0x02,   /* bInterfaceClass: Communication Interface Class */
 201   0x02,   /* bInterfaceSubClass: Abstract Control Model */
 202   0x01,   /* bInterfaceProtocol: Common AT commands */
 203   0x00,   /* iInterface: */
 204
 205   /*Header Functional Descriptor*/
 206   0x05,   /* bLength: Endpoint Descriptor size */
 207   0x24,   /* bDescriptorType: CS_INTERFACE */
 208   0x00,   /* bDescriptorSubtype: Header Func Desc */
 209   0x10,   /* bcdCDC: spec release number */
 210   0x01,
 211
 212   /*Call Management Functional Descriptor*/
 213   0x05,   /* bFunctionLength */
 214   0x24,   /* bDescriptorType: CS_INTERFACE */
 215   0x01,   /* bDescriptorSubtype: Call Management Func Desc */
 216   0x00,   /* bmCapabilities: D0+D1 */
 217   0x01,   /* bDataInterface: 1 */
 218
 219   /*ACM Functional Descriptor*/
 220   0x04,   /* bFunctionLength */
 221   0x24,   /* bDescriptorType: CS_INTERFACE */
 222   0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
 223   0x02,   /* bmCapabilities */
 224
 225   /*Union Functional Descriptor*/
 226   0x05,   /* bFunctionLength */
 227   0x24,   /* bDescriptorType: CS_INTERFACE */
 228   0x06,   /* bDescriptorSubtype: Union func desc */
 229   0x00,   /* bMasterInterface: Communication class interface */
 230   0x01,   /* bSlaveInterface0: Data Class Interface */
 231
 232   /*Endpoint 2 Descriptor*/
 233   0x07,                           /* bLength: Endpoint Descriptor size */
 234   USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
 235   CDC_CMD_EP,                     /* bEndpointAddress */
 236   0x03,                           /* bmAttributes: Interrupt */
 237   LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
 238   HIBYTE(CDC_CMD_PACKET_SIZE),
 239   0x10,                           /* bInterval: */
 240   /*---------------------------------------------------------------------------*/
 241
 242   /*Data class interface descriptor*/
 243   0x09,   /* bLength: Endpoint Descriptor size */
 244   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
 245   0x01,   /* bInterfaceNumber: Number of Interface */
 246   0x00,   /* bAlternateSetting: Alternate setting */
 247   0x02,   /* bNumEndpoints: Two endpoints used */
 248   0x0A,   /* bInterfaceClass: CDC */
 249   0x00,   /* bInterfaceSubClass: */
 250   0x00,   /* bInterfaceProtocol: */
 251   0x00,   /* iInterface: */
 252
 253   /*Endpoint OUT Descriptor*/
 254   0x07,   /* bLength: Endpoint Descriptor size */
 255   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
 256   CDC_OUT_EP,                        /* bEndpointAddress */
 257   0x02,                              /* bmAttributes: Bulk */
 258   LOBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
 259   HIBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),
 260   0x00,                              /* bInterval: ignore for Bulk transfer */
 261
 262   /*Endpoint IN Descriptor*/
 263   0x07,   /* bLength: Endpoint Descriptor size */
 264   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
 265   CDC_IN_EP,                         /* bEndpointAddress */
 266   0x02,                              /* bmAttributes: Bulk */
 267   LOBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
 268   HIBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),
 269   0x00                               /* bInterval: ignore for Bulk transfer */
 270 } ;
 271
 272
 273 /* USB CDC device Configuration Descriptor */
 274 __ALIGN_BEGIN uint8_t USBD_CDC_CfgFSDesc[USB_CDC_CONFIG_DESC_SIZ] __ALIGN_END =
 275 {
 276   /*Configuration Descriptor*/
 277   0x09,   /* bLength: Configuration Descriptor size */
 278   USB_DESC_TYPE_CONFIGURATION,      /* bDescriptorType: Configuration */
 279   USB_CDC_CONFIG_DESC_SIZ,                /* wTotalLength:no of returned bytes */
 280   0x00,
 281   0x02,   /* bNumInterfaces: 2 interface */
 282   0x01,   /* bConfigurationValue: Configuration value */
 283   0x00,   /* iConfiguration: Index of string descriptor describing the configuration */
 284   0xC0,   /* bmAttributes: self powered */
 285   0x32,   /* MaxPower 0 mA */
 286
 287   /*---------------------------------------------------------------------------*/
 288
 289   /*Interface Descriptor */
 290   0x09,   /* bLength: Interface Descriptor size */
 291   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
 292   /* Interface descriptor type */
 293   0x00,   /* bInterfaceNumber: Number of Interface */
 294   0x00,   /* bAlternateSetting: Alternate setting */
 295   0x01,   /* bNumEndpoints: One endpoints used */
 296   0x02,   /* bInterfaceClass: Communication Interface Class */
 297   0x02,   /* bInterfaceSubClass: Abstract Control Model */
 298   0x01,   /* bInterfaceProtocol: Common AT commands */
 299   0x00,   /* iInterface: */
 300
 301   /*Header Functional Descriptor*/
 302   0x05,   /* bLength: Endpoint Descriptor size */
 303   0x24,   /* bDescriptorType: CS_INTERFACE */
 304   0x00,   /* bDescriptorSubtype: Header Func Desc */
 305   0x10,   /* bcdCDC: spec release number */
 306   0x01,
 307
 308   /*Call Management Functional Descriptor*/
 309   0x05,   /* bFunctionLength */
 310   0x24,   /* bDescriptorType: CS_INTERFACE */
 311   0x01,   /* bDescriptorSubtype: Call Management Func Desc */
 312   0x00,   /* bmCapabilities: D0+D1 */
 313   0x01,   /* bDataInterface: 1 */
 314
 315   /*ACM Functional Descriptor*/
 316   0x04,   /* bFunctionLength */
 317   0x24,   /* bDescriptorType: CS_INTERFACE */
 318   0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
 319   0x02,   /* bmCapabilities */
 320
 321   /*Union Functional Descriptor*/
 322   0x05,   /* bFunctionLength */
 323   0x24,   /* bDescriptorType: CS_INTERFACE */
 324   0x06,   /* bDescriptorSubtype: Union func desc */
 325   0x00,   /* bMasterInterface: Communication class interface */
 326   0x01,   /* bSlaveInterface0: Data Class Interface */
 327
 328   /*Endpoint 2 Descriptor*/
 329   0x07,                           /* bLength: Endpoint Descriptor size */
 330   USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
 331   CDC_CMD_EP,                     /* bEndpointAddress */
 332   0x03,                           /* bmAttributes: Interrupt */
 333   LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
 334   HIBYTE(CDC_CMD_PACKET_SIZE),
 335   0x10,                           /* bInterval: */
 336   /*---------------------------------------------------------------------------*/
 337
 338   /*Data class interface descriptor*/
 339   0x09,   /* bLength: Endpoint Descriptor size */
 340   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
 341   0x01,   /* bInterfaceNumber: Number of Interface */
 342   0x00,   /* bAlternateSetting: Alternate setting */
 343   0x02,   /* bNumEndpoints: Two endpoints used */
 344   0x0A,   /* bInterfaceClass: CDC */
 345   0x00,   /* bInterfaceSubClass: */
 346   0x00,   /* bInterfaceProtocol: */
 347   0x00,   /* iInterface: */
 348
 349   /*Endpoint OUT Descriptor*/
 350   0x07,   /* bLength: Endpoint Descriptor size */
 351   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
 352   CDC_OUT_EP,                        /* bEndpointAddress */
 353   0x02,                              /* bmAttributes: Bulk */
 354   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
 355   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
 356   0x00,                              /* bInterval: ignore for Bulk transfer */
 357
 358   /*Endpoint IN Descriptor*/
 359   0x07,   /* bLength: Endpoint Descriptor size */
 360   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
 361   CDC_IN_EP,                         /* bEndpointAddress */
 362   0x02,                              /* bmAttributes: Bulk */
 363   LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
 364   HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
 365   0x00                               /* bInterval: ignore for Bulk transfer */
 366 } ;
 367
 368 __ALIGN_BEGIN uint8_t USBD_CDC_OtherSpeedCfgDesc[USB_CDC_CONFIG_DESC_SIZ] __ALIGN_END =
 369 {
 370   0x09,   /* bLength: Configuation Descriptor size */
 371   USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION,
 372   USB_CDC_CONFIG_DESC_SIZ,
 373   0x00,
 374   0x02,   /* bNumInterfaces: 2 interfaces */
 375   0x01,   /* bConfigurationValue: */
 376   0x04,   /* iConfiguration: */
 377   0xC0,   /* bmAttributes: */
 378   0x32,   /* MaxPower 100 mA */
 379
 380   /*Interface Descriptor */
 381   0x09,   /* bLength: Interface Descriptor size */
 382   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
 383   /* Interface descriptor type */
 384   0x00,   /* bInterfaceNumber: Number of Interface */
 385   0x00,   /* bAlternateSetting: Alternate setting */
 386   0x01,   /* bNumEndpoints: One endpoints used */
 387   0x02,   /* bInterfaceClass: Communication Interface Class */
 388   0x02,   /* bInterfaceSubClass: Abstract Control Model */
 389   0x01,   /* bInterfaceProtocol: Common AT commands */
 390   0x00,   /* iInterface: */
 391
 392   /*Header Functional Descriptor*/
 393   0x05,   /* bLength: Endpoint Descriptor size */
 394   0x24,   /* bDescriptorType: CS_INTERFACE */
 395   0x00,   /* bDescriptorSubtype: Header Func Desc */
 396   0x10,   /* bcdCDC: spec release number */
 397   0x01,
 398
 399   /*Call Management Functional Descriptor*/
 400   0x05,   /* bFunctionLength */
 401   0x24,   /* bDescriptorType: CS_INTERFACE */
 402   0x01,   /* bDescriptorSubtype: Call Management Func Desc */
 403   0x00,   /* bmCapabilities: D0+D1 */
 404   0x01,   /* bDataInterface: 1 */
 405
 406   /*ACM Functional Descriptor*/
 407   0x04,   /* bFunctionLength */
 408   0x24,   /* bDescriptorType: CS_INTERFACE */
 409   0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
 410   0x02,   /* bmCapabilities */
 411
 412   /*Union Functional Descriptor*/
 413   0x05,   /* bFunctionLength */
 414   0x24,   /* bDescriptorType: CS_INTERFACE */
 415   0x06,   /* bDescriptorSubtype: Union func desc */
 416   0x00,   /* bMasterInterface: Communication class interface */
 417   0x01,   /* bSlaveInterface0: Data Class Interface */
 418
 419   /*Endpoint 2 Descriptor*/
 420   0x07,                           /* bLength: Endpoint Descriptor size */
 421   USB_DESC_TYPE_ENDPOINT      ,   /* bDescriptorType: Endpoint */
 422   CDC_CMD_EP,                     /* bEndpointAddress */
 423   0x03,                           /* bmAttributes: Interrupt */
 424   LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
 425   HIBYTE(CDC_CMD_PACKET_SIZE),
 426   0xFF,                           /* bInterval: */
 427
 428   /*---------------------------------------------------------------------------*/
 429
 430   /*Data class interface descriptor*/
 431   0x09,   /* bLength: Endpoint Descriptor size */
 432   USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
 433   0x01,   /* bInterfaceNumber: Number of Interface */
 434   0x00,   /* bAlternateSetting: Alternate setting */
 435   0x02,   /* bNumEndpoints: Two endpoints used */
 436   0x0A,   /* bInterfaceClass: CDC */
 437   0x00,   /* bInterfaceSubClass: */
 438   0x00,   /* bInterfaceProtocol: */
 439   0x00,   /* iInterface: */
 440
 441   /*Endpoint OUT Descriptor*/
 442   0x07,   /* bLength: Endpoint Descriptor size */
 443   USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
 444   CDC_OUT_EP,                        /* bEndpointAddress */
 445   0x02,                              /* bmAttributes: Bulk */
 446   0x40,                              /* wMaxPacketSize: */
 447   0x00,
 448   0x00,                              /* bInterval: ignore for Bulk transfer */
 449
 450   /*Endpoint IN Descriptor*/
 451   0x07,   /* bLength: Endpoint Descriptor size */
 452   USB_DESC_TYPE_ENDPOINT,     /* bDescriptorType: Endpoint */
 453   CDC_IN_EP,                        /* bEndpointAddress */
 454   0x02,                             /* bmAttributes: Bulk */
 455   0x40,                             /* wMaxPacketSize: */
 456   0x00,
 457   0x00                              /* bInterval */
 458 };
 459
 460 /**
 461   * @}
 462   */
 463
 464 /** @defgroup USBD_CDC_Private_Functions
 465   * @{
 466   */
 467
 468 /**
 469   * @brief  USBD_CDC_Init
 470   *         Initialize the CDC interface
 471   * @param  pdev: device instance
 472   * @param  cfgidx: Configuration index
 473   * @retval status
 474   */
 475 static uint8_t  USBD_CDC_Init (USBD_HandleTypeDef *pdev,
 476                                uint8_t cfgidx)
 477 {
 478   uint8_t ret = 0;
 479   USBD_CDC_HandleTypeDef   *hcdc;
 480
 481   if(pdev->dev_speed == USBD_SPEED_HIGH  )
 482   {
 483     /* Open EP IN */
 484     USBD_LL_OpenEP(pdev,
 485                    CDC_IN_EP,
 486                    USBD_EP_TYPE_BULK,
 487                    CDC_DATA_HS_IN_PACKET_SIZE);
 488
 489     /* Open EP OUT */
 490     USBD_LL_OpenEP(pdev,
 491                    CDC_OUT_EP,
 492                    USBD_EP_TYPE_BULK,
 493                    CDC_DATA_HS_OUT_PACKET_SIZE);
 494
 495   }
 496   else
 497   {
 498     /* Open EP IN */
 499     USBD_LL_OpenEP(pdev,
 500                    CDC_IN_EP,
 501                    USBD_EP_TYPE_BULK,
 502                    CDC_DATA_FS_IN_PACKET_SIZE);
 503
 504     /* Open EP OUT */
 505     USBD_LL_OpenEP(pdev,
 506                    CDC_OUT_EP,
 507                    USBD_EP_TYPE_BULK,
 508                    CDC_DATA_FS_OUT_PACKET_SIZE);
 509   }
 510   /* Open Command IN EP */
 511   USBD_LL_OpenEP(pdev,
 512                  CDC_CMD_EP,
 513                  USBD_EP_TYPE_INTR,
 514                  CDC_CMD_PACKET_SIZE);
 515
 516
 517   pdev->pClassData = USBD_malloc(sizeof (USBD_CDC_HandleTypeDef));
 518
 519   if(pdev->pClassData == NULL)
 520   {
 521     ret = 1;
 522   }
 523   else
 524   {
 525     hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
 526
 527     /* Init  physical Interface components */
 528     ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Init();
 529
 530     /* Init Xfer states */
 531     hcdc->TxState =0;
 532     hcdc->RxState =0;
 533
 534     if(pdev->dev_speed == USBD_SPEED_HIGH  )
 535     {
 536       /* Prepare Out endpoint to receive next packet */
 537       USBD_LL_PrepareReceive(pdev,
 538                              CDC_OUT_EP,
 539                              hcdc->RxBuffer,
 540                              CDC_DATA_HS_OUT_PACKET_SIZE);
 541     }
 542     else
 543     {
 544       /* Prepare Out endpoint to receive next packet */
 545       USBD_LL_PrepareReceive(pdev,
 546                              CDC_OUT_EP,
 547                              hcdc->RxBuffer,
 548                              CDC_DATA_FS_OUT_PACKET_SIZE);
 549     }
 550
 551
 552   }
 553   return ret;
 554 }
 555
 556 /**
 557   * @brief  USBD_CDC_Init
 558   *         DeInitialize the CDC layer
 559   * @param  pdev: device instance
 560   * @param  cfgidx: Configuration index
 561   * @retval status
 562   */
 563 static uint8_t  USBD_CDC_DeInit (USBD_HandleTypeDef *pdev,
 564                                  uint8_t cfgidx)
 565 {
 566   uint8_t ret = 0;
 567
 568   /* Open EP IN */
 569   USBD_LL_CloseEP(pdev,
 570               CDC_IN_EP);
 571
 572   /* Open EP OUT */
 573   USBD_LL_CloseEP(pdev,
 574               CDC_OUT_EP);
 575
 576   /* Open Command IN EP */
 577   USBD_LL_CloseEP(pdev,
 578               CDC_CMD_EP);
 579
 580
 581   /* DeInit  physical Interface components */
 582   if(pdev->pClassData != NULL)
 583   {
 584     ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->DeInit();
 585     USBD_free(pdev->pClassData);
 586     pdev->pClassData = NULL;
 587   }
 588
 589   return ret;
 590 }
 591
 592 /**
 593   * @brief  USBD_CDC_Setup
 594   *         Handle the CDC specific requests
 595   * @param  pdev: instance
 596   * @param  req: usb requests
 597   * @retval status
 598   */
 599 static uint8_t  USBD_CDC_Setup (USBD_HandleTypeDef *pdev,
 600                                 USBD_SetupReqTypedef *req)
 601 {
 602   USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
 603   static uint8_t ifalt = 0;
 604
 605   switch (req->bmRequest & USB_REQ_TYPE_MASK)
 606   {
 607   case USB_REQ_TYPE_CLASS :
 608     if (req->wLength)
 609     {
 610       if (req->bmRequest & 0x80)
 611       {
 612         ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(req->bRequest,
 613                                                           (uint8_t *)hcdc->data,
 614                                                           req->wLength);
 615           USBD_CtlSendData (pdev,
 616                             (uint8_t *)hcdc->data,
 617                             req->wLength);
 618       }
 619       else
 620       {
 621         hcdc->CmdOpCode = req->bRequest;
 622         hcdc->CmdLength = req->wLength;
 623
 624         USBD_CtlPrepareRx (pdev,
 625                            (uint8_t *)hcdc->data,
 626                            req->wLength);
 627       }
 628
 629     }
 630     else
 631     {
 632       ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(req->bRequest,
 633                                                         (uint8_t*)req,
 634                                                         0);
 635     }
 636     break;
 637
 638   case USB_REQ_TYPE_STANDARD:
 639     switch (req->bRequest)
 640     {
 641     case USB_REQ_GET_INTERFACE :
 642       USBD_CtlSendData (pdev,
 643                         &ifalt,
 644                         1);
 645       break;
 646
 647     case USB_REQ_SET_INTERFACE :
 648       break;
 649     }
 650
 651   default:
 652     break;
 653   }
 654   return USBD_OK;
 655 }
 656
 657 /**
 658   * @brief  USBD_CDC_DataIn
 659   *         Data sent on non-control IN endpoint
 660   * @param  pdev: device instance
 661   * @param  epnum: endpoint number
 662   * @retval status
 663   */
 664 static uint8_t  USBD_CDC_DataIn (USBD_HandleTypeDef *pdev, uint8_t epnum)
 665 {
 666   USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
 667
 668   if(pdev->pClassData != NULL)
 669   {
 670
 671     hcdc->TxState = 0;
 672
 673     return USBD_OK;
 674   }
 675   else
 676   {
 677     return USBD_FAIL;
 678   }
 679 }
 680
 681 /**
 682   * @brief  USBD_CDC_DataOut
 683   *         Data received on non-control Out endpoint
 684   * @param  pdev: device instance
 685   * @param  epnum: endpoint number
 686   * @retval status
 687   */
 688 static uint8_t  USBD_CDC_DataOut (USBD_HandleTypeDef *pdev, uint8_t epnum)
 689 {
 690   USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
 691
 692   /* Get the received data length */
 693   hcdc->RxLength = USBD_LL_GetRxDataSize (pdev, epnum);
 694
 695   /* USB data will be immediately processed, this allow next USB traffic being
 696   NAKed till the end of the application Xfer */
 697   if(pdev->pClassData != NULL)
 698   {
 699     ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Receive(hcdc->RxBuffer, &hcdc->RxLength);
 700
 701     return USBD_OK;
 702   }
 703   else
 704   {
 705     return USBD_FAIL;
 706   }
 707 }
 708
 709
 710
 711 /**
 712   * @brief  USBD_CDC_DataOut
 713   *         Data received on non-control Out endpoint
 714   * @param  pdev: device instance
 715   * @param  epnum: endpoint number
 716   * @retval status
 717   */
 718 static uint8_t  USBD_CDC_EP0_RxReady (USBD_HandleTypeDef *pdev)
 719 {
 720   USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
 721
 722   if((pdev->pUserData != NULL) && (hcdc->CmdOpCode != 0xFF))
 723   {
 724     ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(hcdc->CmdOpCode,
 725                                                       (uint8_t *)hcdc->data,
 726                                                       hcdc->CmdLength);
 727       hcdc->CmdOpCode = 0xFF;
 728
 729   }
 730   return USBD_OK;
 731 }
 732
 733 /**
 734   * @brief  USBD_CDC_GetFSCfgDesc
 735   *         Return configuration descriptor
 736   * @param  speed : current device speed
 737   * @param  length : pointer data length
 738   * @retval pointer to descriptor buffer
 739   */
 740 static uint8_t  *USBD_CDC_GetFSCfgDesc (uint16_t *length)
 741 {
 742   *length = sizeof (USBD_CDC_CfgFSDesc);
 743   return USBD_CDC_CfgFSDesc;
 744 }
 745
 746 /**
 747   * @brief  USBD_CDC_GetHSCfgDesc
 748   *         Return configuration descriptor
 749   * @param  speed : current device speed
 750   * @param  length : pointer data length
 751   * @retval pointer to descriptor buffer
 752   */
 753 static uint8_t  *USBD_CDC_GetHSCfgDesc (uint16_t *length)
 754 {
 755   *length = sizeof (USBD_CDC_CfgHSDesc);
 756   return USBD_CDC_CfgHSDesc;
 757 }
 758
 759 /**
 760   * @brief  USBD_CDC_GetCfgDesc
 761   *         Return configuration descriptor
 762   * @param  speed : current device speed
 763   * @param  length : pointer data length
 764   * @retval pointer to descriptor buffer
 765   */
 766 static uint8_t  *USBD_CDC_GetOtherSpeedCfgDesc (uint16_t *length)
 767 {
 768   *length = sizeof (USBD_CDC_OtherSpeedCfgDesc);
 769   return USBD_CDC_OtherSpeedCfgDesc;
 770 }
 771
 772 /**
 773 * @brief  DeviceQualifierDescriptor
 774 *         return Device Qualifier descriptor
 775 * @param  length : pointer data length
 776 * @retval pointer to descriptor buffer
 777 */
 778 uint8_t  *USBD_CDC_GetDeviceQualifierDescriptor (uint16_t *length)
 779 {
 780   *length = sizeof (USBD_CDC_DeviceQualifierDesc);
 781   return USBD_CDC_DeviceQualifierDesc;
 782 }
 783
 784 /**
 785 * @brief  USBD_CDC_RegisterInterface
 786   * @param  pdev: device instance
 787   * @param  fops: CD  Interface callback
 788   * @retval status
 789   */
 790 uint8_t  USBD_CDC_RegisterInterface  (USBD_HandleTypeDef   *pdev,
 791                                       USBD_CDC_ItfTypeDef *fops)
 792 {
 793   uint8_t  ret = USBD_FAIL;
 794
 795   if(fops != NULL)
 796   {
 797     pdev->pUserData= fops;
 798     ret = USBD_OK;
 799   }
 800
 801   return ret;
 802 }
 803
 804 /**
 805   * @brief  USBD_CDC_SetTxBuffer
 806   * @param  pdev: device instance
 807   * @param  pbuff: Tx Buffer
 808   * @retval status
 809   */
 810 uint8_t  USBD_CDC_SetTxBuffer  (USBD_HandleTypeDef   *pdev,
 811                                 uint8_t  *pbuff,
 812                                 uint16_t length)
 813 {
 814   USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
 815
 816   hcdc->TxBuffer = pbuff;
 817   hcdc->TxLength = length;
 818
 819   return USBD_OK;
 820 }
 821
 822
 823 /**
 824   * @brief  USBD_CDC_SetRxBuffer
 825   * @param  pdev: device instance
 826   * @param  pbuff: Rx Buffer
 827   * @retval status
 828   */
 829 uint8_t  USBD_CDC_SetRxBuffer  (USBD_HandleTypeDef   *pdev,
 830                                    uint8_t  *pbuff)
 831 {
 832   USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
 833
 834   hcdc->RxBuffer = pbuff;
 835
 836   return USBD_OK;
 837 }
 838
 839 /**
 840   * @brief  USBD_CDC_DataOut
 841   *         Data received on non-control Out endpoint
 842   * @param  pdev: device instance
 843   * @param  epnum: endpoint number
 844   * @retval status
 845   */
 846 uint8_t  USBD_CDC_TransmitPacket(USBD_HandleTypeDef *pdev)
 847 {
 848   USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
 849
 850   if(pdev->pClassData != NULL)
 851   {
 852     if(hcdc->TxState == 0)
 853     {
 854       /* Tx Transfer in progress */
 855       hcdc->TxState = 1;
 856
 857       /* Transmit next packet */
 858       USBD_LL_Transmit(pdev,
 859                        CDC_IN_EP,
 860                        hcdc->TxBuffer,
 861                        hcdc->TxLength);
 862
 863       return USBD_OK;
 864     }
 865     else
 866     {
 867       return USBD_BUSY;
 868     }
 869   }
 870   else
 871   {
 872     return USBD_FAIL;
 873   }
 874 }
 875
 876
 877 /**
 878   * @brief  USBD_CDC_ReceivePacket
 879   *         prepare OUT Endpoint for reception
 880   * @param  pdev: device instance
 881   * @retval status
 882   */
 883 uint8_t  USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev)
 884 {
 885   USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
 886
 887   /* Suspend or Resume USB Out process */
 888   if(pdev->pClassData != NULL)
 889   {
 890     if(pdev->dev_speed == USBD_SPEED_HIGH  )
 891     {
 892       /* Prepare Out endpoint to receive next packet */
 893       USBD_LL_PrepareReceive(pdev,
 894                              CDC_OUT_EP,
 895                              hcdc->RxBuffer,
 896                              CDC_DATA_HS_OUT_PACKET_SIZE);
 897     }
 898     else
 899     {
 900       /* Prepare Out endpoint to receive next packet */
 901       USBD_LL_PrepareReceive(pdev,
 902                              CDC_OUT_EP,
 903                              hcdc->RxBuffer,
 904                              CDC_DATA_FS_OUT_PACKET_SIZE);
 905     }
 906     return USBD_OK;
 907   }
 908   else
 909   {
 910     return USBD_FAIL;
 911   }
 912 }
 913 /**
 914   * @}
 915   */
 916
 917 /**
 918   * @}
 919   */
 920
 921 /**
 922   * @}
 923   */
 924
 925 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/