/**
  ******************************************************************************
  * @file    usbd_cdc.c
  * @author  MCD Application Team
  * @version V2.4.0
  * @date    28-February-2015
  * @brief   
  *
  ******************************************************************************
  */ 

/* Includes ------------------------------------------------------------------*/
#include "usbd_comp.h"
#include  "usbd_def.h"

#include "USBD_CDC.h"
#include "usbd_hid.h"
#include "usbd_desc.h"

#include "usbd_ctlreq.h"

static uint8_t  USBD_COMP_Init (USBD_HandleTypeDef *pdev, 
                               uint8_t cfgidx);
static uint8_t  USBD_COMP_DeInit (USBD_HandleTypeDef *pdev, 
                                 uint8_t cfgidx);

static uint8_t  USBD_COMP_Setup (USBD_HandleTypeDef *pdev, 
                                USBD_SetupReqTypedef *req);

static uint8_t  USBD_COMP_DataIn (USBD_HandleTypeDef *pdev, 
                                 uint8_t epnum);

static uint8_t  USBD_COMP_DataOut (USBD_HandleTypeDef *pdev, 
                                 uint8_t epnum);
static uint8_t  USBD_COMP_EP0_RxReady (USBD_HandleTypeDef *pdev);

static uint8_t  *USBD_COMP_GetFSCfgDesc (uint16_t *length);

static uint8_t  *USBD_COMP_GetHSCfgDesc (uint16_t *length);

static uint8_t  *USBD_COMP_GetOtherSpeedCfgDesc (uint16_t *length);

static uint8_t  *USBD_COMP_GetOtherSpeedCfgDesc (uint16_t *length);

uint8_t  *USBD_COMP_GetDeviceQualifierDescriptor (uint16_t *length);

//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,
//};

//USBD_ClassTypeDef  USBD_HID = 
//{
//  USBD_HID_Init,
//  USBD_HID_DeInit,
//  USBD_HID_Setup,
//  NULL, /*EP0_TxSent*/  
//  NULL, /*EP0_RxReady*/
//  USBD_HID_DataIn, /*DataIn*/
//  NULL, /*DataOut*/
//  NULL, /*SOF */
//  NULL,
//  NULL,      
//  USBD_HID_GetCfgDesc,
//  USBD_HID_GetCfgDesc, 
//  USBD_HID_GetCfgDesc,
//  USBD_HID_GetDeviceQualifierDesc,
//};

USBD_ClassTypeDef  USBD_COMP = 
{
  USBD_COMP_Init,
  USBD_COMP_DeInit,
  USBD_COMP_Setup,
  NULL,                 /* EP0_TxSent, */
  USBD_COMP_EP0_RxReady,
  USBD_COMP_DataIn,
  USBD_COMP_DataOut,
  NULL,
  NULL,
  NULL,     
  USBD_COMP_GetHSCfgDesc,  
  USBD_COMP_GetHSCfgDesc,    
  USBD_COMP_GetOtherSpeedCfgDesc, 
  USBD_COMP_GetDeviceQualifierDescriptor,
};



///* USB COMP device Configuration Descriptor */
//__ALIGN_BEGIN uint8_t USBD_COMP_CfgHSDesc[USB_COMP_CONFIG_DESC_SIZ] __ALIGN_END =
//{
//  /*Configuration Descriptor*/
//  0x09,   /* bLength: Configuration Descriptor size */
//  USB_DESC_TYPE_CONFIGURATION,      /* bDescriptorType: Configuration */
//  USB_COMP_CONFIG_DESC_SIZ,                /* wTotalLength:no of returned bytes */
//  0x00,
//  BNUMINTERFACES,   /* bNumInterfaces: */
//  0x01,   /* bConfigurationValue: Configuration value */
//  0x00,   /* iConfiguration: Index of string descriptor describing the configuration */
//  0xC0,   /* bmAttributes: self powered */
//  0x32,   /* MaxPower 0 mA */
//  
//  /*---------------------------------------------------------------------------*/
//#if USE_CDC  
//  /*Interface Descriptor */
//  0x09,   /* bLength: Interface Descriptor size */
//  USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
//  /* Interface descriptor type */
//  0x00,   /* bInterfaceNumber: Number of Interface */
//  0x00,   /* bAlternateSetting: Alternate setting */
//  0x01,   /* bNumEndpoints: One endpoints used */
//  0x02,   /* bInterfaceClass: Communication Interface Class */
//  0x02,   /* bInterfaceSubClass: Abstract Control Model */
//  0x01,   /* bInterfaceProtocol: Common AT commands */
//  0x05,   /* iInterface: */
//  
//  /*Header Functional Descriptor*/
//  0x05,   /* bLength: Endpoint Descriptor size */
//  0x24,   /* bDescriptorType: CS_INTERFACE */
//  0x00,   /* bDescriptorSubtype: Header Func Desc */
//  0x10,   /* bcdCDC: spec release number */
//  0x01,
//  
//  /*Call Management Functional Descriptor*/
//  0x05,   /* bFunctionLength */
//  0x24,   /* bDescriptorType: CS_INTERFACE */
//  0x01,   /* bDescriptorSubtype: Call Management Func Desc */
//  0x00,   /* bmCapabilities: D0+D1 */
//  0x01,   /* bDataInterface: 1 */
//  
//  /*ACM Functional Descriptor*/
//  0x04,   /* bFunctionLength */
//  0x24,   /* bDescriptorType: CS_INTERFACE */
//  0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
//  0x02,   /* bmCapabilities */
//  
//  /*Union Functional Descriptor*/
//  0x05,   /* bFunctionLength */
//  0x24,   /* bDescriptorType: CS_INTERFACE */
//  0x06,   /* bDescriptorSubtype: Union func desc */
//  0x00,   /* bMasterInterface: Communication class interface */
//  0x01,   /* bSlaveInterface0: Data Class Interface */
//  
//  /*Endpoint 2 Descriptor*/
//  0x07,                           /* bLength: Endpoint Descriptor size */
//  USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
//  CDC_CMD_EP,                     /* bEndpointAddress */
//  0x03,                           /* bmAttributes: Interrupt */
//  LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
//  HIBYTE(CDC_CMD_PACKET_SIZE),
//  0x10,                           /* bInterval: */ 
//  /*---------------------------------------------------------------------------*/
//  
//  /*Data class interface descriptor*/
//  0x09,   /* bLength: Endpoint Descriptor size */
//  USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
//  0x01,   /* bInterfaceNumber: Number of Interface */
//  0x00,   /* bAlternateSetting: Alternate setting */
//  0x02,   /* bNumEndpoints: Two endpoints used */
//  0x0A,   /* bInterfaceClass: CDC */
//  0x00,   /* bInterfaceSubClass: */
//  0x00,   /* bInterfaceProtocol: */
//  0x07,   /* iInterface: */
//  
//  /*Endpoint OUT Descriptor*/
//  0x07,   /* bLength: Endpoint Descriptor size */
//  USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
//  CDC_OUT_EP,                        /* bEndpointAddress */
//  0x02,                              /* bmAttributes: Bulk */
//  LOBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
//  HIBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),
//  0x00,                              /* bInterval: ignore for Bulk transfer */
//  
//  /*Endpoint IN Descriptor*/
//  0x07,   /* bLength: Endpoint Descriptor size */
//  USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
//  CDC_IN_EP,                         /* bEndpointAddress */
//  0x02,                              /* bmAttributes: Bulk */
//  LOBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
//  HIBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),
//  0x00,                               /* bInterval: ignore for Bulk transfer */
//#endif
//#if USE_HID
//	  /* 09 */
//  0x09,         /*bLength: Interface Descriptor size*/
//  USB_DESC_TYPE_INTERFACE,/*bDescriptorType: Interface descriptor type*/
//  0x02,         /*bInterfaceNumber: Number of Interface*/
//  0x00,         /*bAlternateSetting: Alternate setting*/
//  0x01,         /*bNumEndpoints*/
//  0x03,         /*bInterfaceClass: HID*/
//  0x01,         /*bInterfaceSubClass : 1=BOOT, 0=no boot*/
//  0x02,         /*nInterfaceProtocol : 0=none, 1=keyboard, 2=mouse*/
//  6,            /*iInterface: Index of string descriptor*/
//  /******************** Descriptor of Joystick Mouse HID ********************/
//  /* 18 */
//  0x09,         /*bLength: HID Descriptor size*/
//  HID_DESCRIPTOR_TYPE, /*bDescriptorType: HID*/
//  0x11,         /*bcdHID: HID Class Spec release number*/
//  0x01,
//  0x00,         /*bCountryCode: Hardware target country*/
//  0x01,         /*bNumDescriptors: Number of HID class descriptors to follow*/
//  0x22,         /*bDescriptorType*/
//  HID_MOUSE_REPORT_DESC_SIZE,/*wItemLength: Total length of Report descriptor*/
//  0x00,
//  /******************** Descriptor of Mouse endpoint ********************/
//  /* 27 */
//  0x07,          /*bLength: Endpoint Descriptor size*/
//  USB_DESC_TYPE_ENDPOINT, /*bDescriptorType:*/
//  
//  HID_EPIN_ADDR,     /*bEndpointAddress: Endpoint Address (IN)*/
//  0x03,          /*bmAttributes: Interrupt endpoint*/
//  HID_EPIN_SIZE, /*wMaxPacketSize: 4 Byte max */
//  0x00,
//  HID_FS_BINTERVAL,          /*bInterval: Polling Interval (10 ms)*/
//  /* 34 */	
//#endif
//} ;

__ALIGN_BEGIN static uint8_t USBD_COMP_DeviceQualifierDesc[USB_LEN_DEV_QUALIFIER_DESC] __ALIGN_END =
{
  USB_LEN_DEV_QUALIFIER_DESC,
  USB_DESC_TYPE_DEVICE_QUALIFIER,
  0x00,
  0x02,
  0x00,
  0x00,
  0x00,
  0x40,
  0x01,
  0x00,
};

/* USB CDC device Configuration Descriptor */
__ALIGN_BEGIN uint8_t USBD_COMP_CfgHSDesc[USB_CDC_CONFIG_DESC_SIZ] __ALIGN_END =
{
  /*Configuration Descriptor*/
  0x09,   /* bLength: Configuration Descriptor size */
  USB_DESC_TYPE_CONFIGURATION,      /* bDescriptorType: Configuration */
  USB_CDC_CONFIG_DESC_SIZ,                /* wTotalLength:no of returned bytes */
  0x00,
  0x02,   /* bNumInterfaces: 2 interface */
  0x01,   /* bConfigurationValue: Configuration value */
  0x00,   /* iConfiguration: Index of string descriptor describing the configuration */
  0xC0,   /* bmAttributes: self powered */
  0x32,   /* MaxPower 0 mA */
  
  /*---------------------------------------------------------------------------*/
  
  /*Interface Descriptor */
  0x09,   /* bLength: Interface Descriptor size */
  USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
  /* Interface descriptor type */
  0x00,   /* bInterfaceNumber: Number of Interface */
  0x00,   /* bAlternateSetting: Alternate setting */
  0x01,   /* bNumEndpoints: One endpoints used */
  0x02,   /* bInterfaceClass: Communication Interface Class */
  0x02,   /* bInterfaceSubClass: Abstract Control Model */
  0x01,   /* bInterfaceProtocol: Common AT commands */
  0x00,   /* iInterface: */
  
  /*Header Functional Descriptor*/
  0x05,   /* bLength: Endpoint Descriptor size */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x00,   /* bDescriptorSubtype: Header Func Desc */
  0x10,   /* bcdCDC: spec release number */
  0x01,
  
  /*Call Management Functional Descriptor*/
  0x05,   /* bFunctionLength */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x01,   /* bDescriptorSubtype: Call Management Func Desc */
  0x00,   /* bmCapabilities: D0+D1 */
  0x01,   /* bDataInterface: 1 */
  
  /*ACM Functional Descriptor*/
  0x04,   /* bFunctionLength */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
  0x02,   /* bmCapabilities */
  
  /*Union Functional Descriptor*/
  0x05,   /* bFunctionLength */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x06,   /* bDescriptorSubtype: Union func desc */
  0x00,   /* bMasterInterface: Communication class interface */
  0x01,   /* bSlaveInterface0: Data Class Interface */
  
  /*Endpoint 2 Descriptor*/
  0x07,                           /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
  CDC_CMD_EP,                     /* bEndpointAddress */
  0x03,                           /* bmAttributes: Interrupt */
  LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
  HIBYTE(CDC_CMD_PACKET_SIZE),
  0x10,                           /* bInterval: */ 
  /*---------------------------------------------------------------------------*/
  
  /*Data class interface descriptor*/
  0x09,   /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
  0x01,   /* bInterfaceNumber: Number of Interface */
  0x00,   /* bAlternateSetting: Alternate setting */
  0x02,   /* bNumEndpoints: Two endpoints used */
  0x0A,   /* bInterfaceClass: CDC */
  0x00,   /* bInterfaceSubClass: */
  0x00,   /* bInterfaceProtocol: */
  0x00,   /* iInterface: */
  
  /*Endpoint OUT Descriptor*/
  0x07,   /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
  CDC_OUT_EP,                        /* bEndpointAddress */
  0x02,                              /* bmAttributes: Bulk */
  LOBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
  HIBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),
  0x00,                              /* bInterval: ignore for Bulk transfer */
  
  /*Endpoint IN Descriptor*/
  0x07,   /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
  CDC_IN_EP,                         /* bEndpointAddress */
  0x02,                              /* bmAttributes: Bulk */
  LOBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
  HIBYTE(CDC_DATA_HS_MAX_PACKET_SIZE),
  0x00                               /* bInterval: ignore for Bulk transfer */
} ;


/* USB CDC device Configuration Descriptor */
__ALIGN_BEGIN uint8_t USBD_COMP_CfgFSDesc[USB_CDC_CONFIG_DESC_SIZ] __ALIGN_END =
{
  /*Configuration Descriptor*/
  0x09,   /* bLength: Configuration Descriptor size */
  USB_DESC_TYPE_CONFIGURATION,      /* bDescriptorType: Configuration */
  USB_CDC_CONFIG_DESC_SIZ,                /* wTotalLength:no of returned bytes */
  0x00,
  0x02,   /* bNumInterfaces: 2 interface */
  0x01,   /* bConfigurationValue: Configuration value */
  0x00,   /* iConfiguration: Index of string descriptor describing the configuration */
  0xC0,   /* bmAttributes: self powered */
  0x32,   /* MaxPower 0 mA */
  
  /*---------------------------------------------------------------------------*/
  
  /*Interface Descriptor */
  0x09,   /* bLength: Interface Descriptor size */
  USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
  /* Interface descriptor type */
  0x00,   /* bInterfaceNumber: Number of Interface */
  0x00,   /* bAlternateSetting: Alternate setting */
  0x01,   /* bNumEndpoints: One endpoints used */
  0x02,   /* bInterfaceClass: Communication Interface Class */
  0x02,   /* bInterfaceSubClass: Abstract Control Model */
  0x01,   /* bInterfaceProtocol: Common AT commands */
  0x00,   /* iInterface: */
  
  /*Header Functional Descriptor*/
  0x05,   /* bLength: Endpoint Descriptor size */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x00,   /* bDescriptorSubtype: Header Func Desc */
  0x10,   /* bcdCDC: spec release number */
  0x01,
  
  /*Call Management Functional Descriptor*/
  0x05,   /* bFunctionLength */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x01,   /* bDescriptorSubtype: Call Management Func Desc */
  0x00,   /* bmCapabilities: D0+D1 */
  0x01,   /* bDataInterface: 1 */
  
  /*ACM Functional Descriptor*/
  0x04,   /* bFunctionLength */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
  0x02,   /* bmCapabilities */
  
  /*Union Functional Descriptor*/
  0x05,   /* bFunctionLength */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x06,   /* bDescriptorSubtype: Union func desc */
  0x00,   /* bMasterInterface: Communication class interface */
  0x01,   /* bSlaveInterface0: Data Class Interface */
  
  /*Endpoint 2 Descriptor*/
  0x07,                           /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_ENDPOINT,   /* bDescriptorType: Endpoint */
  CDC_CMD_EP,                     /* bEndpointAddress */
  0x03,                           /* bmAttributes: Interrupt */
  LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
  HIBYTE(CDC_CMD_PACKET_SIZE),
  0x10,                           /* bInterval: */ 
  /*---------------------------------------------------------------------------*/
  
  /*Data class interface descriptor*/
  0x09,   /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
  0x01,   /* bInterfaceNumber: Number of Interface */
  0x00,   /* bAlternateSetting: Alternate setting */
  0x02,   /* bNumEndpoints: Two endpoints used */
  0x0A,   /* bInterfaceClass: CDC */
  0x00,   /* bInterfaceSubClass: */
  0x00,   /* bInterfaceProtocol: */
  0x00,   /* iInterface: */
  
  /*Endpoint OUT Descriptor*/
  0x07,   /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
  CDC_OUT_EP,                        /* bEndpointAddress */
  0x02,                              /* bmAttributes: Bulk */
  LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
  HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
  0x00,                              /* bInterval: ignore for Bulk transfer */
  
  /*Endpoint IN Descriptor*/
  0x07,   /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
  CDC_IN_EP,                         /* bEndpointAddress */
  0x02,                              /* bmAttributes: Bulk */
  LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),  /* wMaxPacketSize: */
  HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
  0x00                               /* bInterval: ignore for Bulk transfer */
} ;

__ALIGN_BEGIN uint8_t USBD_COMP_OtherSpeedCfgDesc[USB_CDC_CONFIG_DESC_SIZ] __ALIGN_END =
{ 
  0x09,   /* bLength: Configuation Descriptor size */
  USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION,   
  USB_CDC_CONFIG_DESC_SIZ,
  0x00,
  0x02,   /* bNumInterfaces: 2 interfaces */
  0x01,   /* bConfigurationValue: */
  0x04,   /* iConfiguration: */
  0xC0,   /* bmAttributes: */
  0x32,   /* MaxPower 100 mA */  
  
  /*Interface Descriptor */
  0x09,   /* bLength: Interface Descriptor size */
  USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: Interface */
  /* Interface descriptor type */
  0x00,   /* bInterfaceNumber: Number of Interface */
  0x00,   /* bAlternateSetting: Alternate setting */
  0x01,   /* bNumEndpoints: One endpoints used */
  0x02,   /* bInterfaceClass: Communication Interface Class */
  0x02,   /* bInterfaceSubClass: Abstract Control Model */
  0x01,   /* bInterfaceProtocol: Common AT commands */
  0x00,   /* iInterface: */
  
  /*Header Functional Descriptor*/
  0x05,   /* bLength: Endpoint Descriptor size */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x00,   /* bDescriptorSubtype: Header Func Desc */
  0x10,   /* bcdCDC: spec release number */
  0x01,
  
  /*Call Management Functional Descriptor*/
  0x05,   /* bFunctionLength */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x01,   /* bDescriptorSubtype: Call Management Func Desc */
  0x00,   /* bmCapabilities: D0+D1 */
  0x01,   /* bDataInterface: 1 */
  
  /*ACM Functional Descriptor*/
  0x04,   /* bFunctionLength */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
  0x02,   /* bmCapabilities */
  
  /*Union Functional Descriptor*/
  0x05,   /* bFunctionLength */
  0x24,   /* bDescriptorType: CS_INTERFACE */
  0x06,   /* bDescriptorSubtype: Union func desc */
  0x00,   /* bMasterInterface: Communication class interface */
  0x01,   /* bSlaveInterface0: Data Class Interface */
  
  /*Endpoint 2 Descriptor*/
  0x07,                           /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_ENDPOINT      ,   /* bDescriptorType: Endpoint */
  CDC_CMD_EP,                     /* bEndpointAddress */
  0x03,                           /* bmAttributes: Interrupt */
  LOBYTE(CDC_CMD_PACKET_SIZE),     /* wMaxPacketSize: */
  HIBYTE(CDC_CMD_PACKET_SIZE),
  0xFF,                           /* bInterval: */
  
  /*---------------------------------------------------------------------------*/
  
  /*Data class interface descriptor*/
  0x09,   /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_INTERFACE,  /* bDescriptorType: */
  0x01,   /* bInterfaceNumber: Number of Interface */
  0x00,   /* bAlternateSetting: Alternate setting */
  0x02,   /* bNumEndpoints: Two endpoints used */
  0x0A,   /* bInterfaceClass: CDC */
  0x00,   /* bInterfaceSubClass: */
  0x00,   /* bInterfaceProtocol: */
  0x00,   /* iInterface: */
  
  /*Endpoint OUT Descriptor*/
  0x07,   /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_ENDPOINT,      /* bDescriptorType: Endpoint */
  CDC_OUT_EP,                        /* bEndpointAddress */
  0x02,                              /* bmAttributes: Bulk */
  0x40,                              /* wMaxPacketSize: */
  0x00,
  0x00,                              /* bInterval: ignore for Bulk transfer */
  
  /*Endpoint IN Descriptor*/
  0x07,   /* bLength: Endpoint Descriptor size */
  USB_DESC_TYPE_ENDPOINT,     /* bDescriptorType: Endpoint */
  CDC_IN_EP,                        /* bEndpointAddress */
  0x02,                             /* bmAttributes: Bulk */
  0x40,                             /* wMaxPacketSize: */
  0x00,
  0x00                              /* bInterval */
};


#if USE_HID
__ALIGN_BEGIN static uint8_t HID_MOUSE_ReportDesc[HID_MOUSE_REPORT_DESC_SIZE]  __ALIGN_END =
{
  0x05,   0x01,
  0x09,   0x02,
  0xA1,   0x01,
  0x09,   0x01,
  
  0xA1,   0x00,
  0x05,   0x09,
  0x19,   0x01,
  0x29,   0x03,
  
  0x15,   0x00,
  0x25,   0x01,
  0x95,   0x03,
  0x75,   0x01,
  
  0x81,   0x02,
  0x95,   0x01,
  0x75,   0x05,
  0x81,   0x01,
  
  0x05,   0x01,
  0x09,   0x30,
  0x09,   0x31,
  0x09,   0x38,
  
  0x15,   0x81,
  0x25,   0x7F,
  0x75,   0x08,
  0x95,   0x03,
  
  0x81,   0x06,
  0xC0,   0x09,
  0x3c,   0x05,
  0xff,   0x09,
  
  0x01,   0x15,
  0x00,   0x25,
  0x01,   0x75,
  0x01,   0x95,
  
  0x02,   0xb1,
  0x22,   0x75,
  0x06,   0x95,
  0x01,   0xb1,
  
  0x01,   0xc0
}; 
#endif


/*TODO: descriptors remake*/
/* USB HID device Configuration Descriptor */
uint8_t *USBD_HID_Desc;
/* USB Standard Device Descriptor */
uint8_t *USBD_HID_DeviceQualifierDesc;
//uint8_t *HID_MOUSE_ReportDesc;
//uint8_t *USBD_COMP_CfgHSDesc;
//uint8_t *USBD_COMP_CfgFSDesc;
//uint8_t *USBD_COMP_OtherSpeedCfgDesc;
//uint8_t *USBD_COMP_DeviceQualifierDesc;

/*
--------------------------------
--------------------------------
--------------------------------
*/

//static uint8_t  USBD_COMP_Init (USBD_HandleTypeDef *pdev, 
//                               uint8_t cfgidx)
//{
//	uint8_t ret = 0;
//#if USE_CDC
//  USBD_COMP_HandleTypeDef   *hcomp;
//#endif

//#if USE_CDC
//  
//  if(pdev->dev_speed == USBD_SPEED_HIGH  ) 
//  {  
//    /* Open EP IN */
//    USBD_LL_OpenEP(pdev,
//                   CDC_IN_EP,
//                   USBD_EP_TYPE_BULK,
//                   CDC_DATA_HS_IN_PACKET_SIZE);
//    
//    /* Open EP OUT */
//    USBD_LL_OpenEP(pdev,
//                   CDC_OUT_EP,
//                   USBD_EP_TYPE_BULK,
//                   CDC_DATA_HS_OUT_PACKET_SIZE);
//    
//  }
//  else
//  {
//    /* Open EP IN */
//    USBD_LL_OpenEP(pdev,
//                   CDC_IN_EP,
//                   USBD_EP_TYPE_BULK,
//                   CDC_DATA_FS_IN_PACKET_SIZE);
//    
//    /* Open EP OUT */
//    USBD_LL_OpenEP(pdev,
//                   CDC_OUT_EP,
//                   USBD_EP_TYPE_BULK,
//                   CDC_DATA_FS_OUT_PACKET_SIZE);
//  }
//  /* Open Command IN EP */
//  USBD_LL_OpenEP(pdev,
//                 CDC_CMD_EP,
//                 USBD_EP_TYPE_INTR,
//                 CDC_CMD_PACKET_SIZE);
//#endif
//#if USE_HID
///* Open EP IN */
//  USBD_LL_OpenEP(pdev,
//                 HID_EPIN_ADDR,
//                 USBD_EP_TYPE_INTR,
//                 HID_EPIN_SIZE);
//#endif  
//    
//  pdev->pClassData = USBD_malloc(sizeof (USBD_COMP_HandleTypeDef));
//  
//  if(pdev->pClassData == NULL)
//  {
//    ret = 1; 
//  }
//  else
//  {
//#if USE_CDC
//    hcomp = (USBD_COMP_HandleTypeDef*) pdev->pClassData;
//    
//    /* Init  physical Interface components */
//    ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Init();
//    
//    /* Init Xfer states */
//    hcomp->TxState =0;
//    hcomp->RxState =0;
//       
//    if(pdev->dev_speed == USBD_SPEED_HIGH  ) 
//    {      
//      /* Prepare Out endpoint to receive next packet */
//      USBD_LL_PrepareReceive(pdev,
//                             CDC_OUT_EP,
//                             hcomp->RxBuffer,
//                             CDC_DATA_HS_OUT_PACKET_SIZE);
//    }
//    else
//    {
//      /* Prepare Out endpoint to receive next packet */
//      USBD_LL_PrepareReceive(pdev,
//                             CDC_OUT_EP,
//                             hcomp->RxBuffer,
//                             CDC_DATA_FS_OUT_PACKET_SIZE);
//    }
//    
//#endif
//#if USE_HID	
//		((USBD_COMP_HandleTypeDef *)pdev->pClassData)->state = HID_IDLE;
//#endif		
//  }
//  return ret;
//}

//static uint8_t  USBD_COMP_DeInit (USBD_HandleTypeDef *pdev, 
//                                 uint8_t cfgidx)
//{
//#if USE_CDC	  
//  /* Open EP IN */
//  USBD_LL_CloseEP(pdev,
//              CDC_IN_EP);
//  
//  /* Open EP OUT */
//  USBD_LL_CloseEP(pdev,
//              CDC_OUT_EP);
//  
//  /* Open Command IN EP */
//  USBD_LL_CloseEP(pdev,
//              CDC_CMD_EP);
//#endif
//#if USE_HID	
//		  /* Close HID EPs */
//  USBD_LL_CloseEP(pdev,
//                  HID_EPIN_ADDR);
//#endif	 
//  
//  /* DeInit  physical Interface components */
//  if(pdev->pClassData != NULL)
//  {
//#if USE_CDC
//    ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->DeInit();
//#endif		
//    USBD_free(pdev->pClassData);	
//    pdev->pClassData = NULL;
//  }
//  
//  return USBD_OK;
//}

//static uint8_t  USBD_COMP_Setup (USBD_HandleTypeDef *pdev, 
//                                USBD_SetupReqTypedef *req)
//{
//	USBD_COMP_HandleTypeDef   *hcomp = (USBD_COMP_HandleTypeDef*) pdev->pClassData;
//#if USE_CDC
//  static uint8_t ifalt = 0;
//#endif
//#if USE_HID	
//	uint16_t len = 0;
//  uint8_t  *pbuf = NULL;
//#endif
//	if(req->wIndex==0x1){	//interface 0 - CDC
//		switch (req->bmRequest & USB_REQ_TYPE_MASK)
//		{
//		case USB_REQ_TYPE_CLASS :
//			if (req->wLength)
//			{
//				if (req->bmRequest & 0x80)
//				{
//					((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(req->bRequest,
//																														(uint8_t *)hcomp->data,
//																														req->wLength);
//						USBD_CtlSendData (pdev, 
//															(uint8_t *)hcomp->data,
//															req->wLength);
//				}
//				else
//				{
//					hcomp->CmdOpCode = req->bRequest;
//					hcomp->CmdLength = req->wLength;
//					
//					USBD_CtlPrepareRx (pdev, 
//														 (uint8_t *)hcomp->data,
//														 req->wLength);
//				}
//				
//			}
//			else
//			{
//				((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(req->bRequest,
//																													(uint8_t*)req,
//																													0);
//			}
//			break;

//		case USB_REQ_TYPE_STANDARD:
//			switch (req->bRequest)
//			{      
//			case USB_REQ_GET_INTERFACE :
//				USBD_CtlSendData (pdev,
//													&ifalt,
//													1);
//				break;
//				
//			case USB_REQ_SET_INTERFACE :
//				break;
//			}
//	 
//		default: 
//			break;
//		}
//	}else if(req->wIndex==0x2){	//interface 1 - HID
//#if USE_HID
//		switch (req->bmRequest & USB_REQ_TYPE_MASK)
//		{
//		case USB_REQ_TYPE_CLASS :  
//			switch (req->bRequest)
//			{
//				
//				
//			case HID_REQ_SET_PROTOCOL:
//				hcomp->Protocol = (uint8_t)(req->wValue);
//				break;
//				
//			case HID_REQ_GET_PROTOCOL:
//				USBD_CtlSendData (pdev, 
//													(uint8_t *)&hcomp->Protocol,
//													1);    
//				break;
//				
//			case HID_REQ_SET_IDLE:
//				hcomp->IdleState = (uint8_t)(req->wValue >> 8);
//				break;
//				
//			case HID_REQ_GET_IDLE:
//				USBD_CtlSendData (pdev, 
//													(uint8_t *)&hcomp->IdleState,
//													1);        
//				break;      
//				
//			default:
//				USBD_CtlError (pdev, req);
//				return USBD_FAIL; 
//			}
//			break;
//			
//		case USB_REQ_TYPE_STANDARD:
//			switch (req->bRequest)
//			{
//			case USB_REQ_GET_DESCRIPTOR: 
//				if( req->wValue >> 8 == HID_REPORT_DESC)
//				{
//					len = MIN(HID_MOUSE_REPORT_DESC_SIZE , req->wLength);
//					pbuf = HID_MOUSE_ReportDesc;
//				}
//				else if( req->wValue >> 8 == HID_DESCRIPTOR_TYPE)
//				{
//					pbuf = USBD_HID_Desc;   
//					len = MIN(USB_HID_DESC_SIZ , req->wLength);
//				}
//				
//				USBD_CtlSendData (pdev, 
//													pbuf,
//													len);
//				
//				break;
//				
//			case USB_REQ_GET_INTERFACE :
//				USBD_CtlSendData (pdev,
//													(uint8_t *)&hcomp->AltSetting,
//													1);
//				break;
//				
//			case USB_REQ_SET_INTERFACE :
//				hcomp->AltSetting = (uint8_t)(req->wValue);
//				break;
//			}
//		}
//#endif	
//	}
//	 return USBD_OK;
//}

//static uint8_t  USBD_COMP_DataIn (USBD_HandleTypeDef *pdev, uint8_t epnum)
//{
//	//choose the action according to the epnum
//	//TODO define ep numbers
//	if(epnum==0x81){	
//		USBD_COMP_HandleTypeDef   *hcomp = (USBD_COMP_HandleTypeDef*) pdev->pClassData;
//		
//		if(pdev->pClassData != NULL)
//		{
//			
//			hcomp->TxState = 0;

//			return USBD_OK;
//		}
//		else
//		{
//			return USBD_FAIL;
//		}
//	}
//	else if(epnum==0x82){
//#if USE_HID
//	  ((USBD_COMP_HandleTypeDef *)pdev->pClassData)->state = HID_IDLE;
//		return USBD_OK;
//#endif
//	}
//	 return USBD_OK;
//}

//static uint8_t  USBD_COMP_DataOut (USBD_HandleTypeDef *pdev, uint8_t epnum)
//{ 
//	//choose the action according to the epnum
//	if(epnum==0x81){		
//		USBD_COMP_HandleTypeDef   *hcomp = (USBD_COMP_HandleTypeDef*) pdev->pClassData;
//		
//		/* Get the received data length */
//		hcomp->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)
//		{
//			((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Receive(hcomp->RxBuffer, &hcomp->RxLength);

//			return USBD_OK;
//		}
//		else
//		{
//			return USBD_FAIL;
//		}
//	}
//	else if(epnum==0x82){
//		//no code for HID, used in another class(MSC)
//	}
//	 return USBD_OK;
//}

//static uint8_t  USBD_COMP_EP0_RxReady (USBD_HandleTypeDef *pdev)
//{ 
//  USBD_COMP_HandleTypeDef   *hcomp = (USBD_COMP_HandleTypeDef*) pdev->pClassData;
//  
//  if((pdev->pUserData != NULL) && (hcomp->CmdOpCode != 0xFF))
//  {
//    ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(hcomp->CmdOpCode,
//                                                      (uint8_t *)hcomp->data,
//                                                      hcomp->CmdLength);
//      hcomp->CmdOpCode = 0xFF; 
//      
//  }
//  return USBD_OK;
//}

//uint8_t  USBD_COMP_RegisterInterface  (USBD_HandleTypeDef   *pdev, 
//                                      USBD_CDC_ItfTypeDef *fops)
//{
//  uint8_t  ret = USBD_FAIL;
//  
//  if(fops != NULL)
//  {
//    pdev->pUserData= fops;
//    ret = USBD_OK;    
//  }
//  
//  return ret;
//}



//static uint8_t  *USBD_COMP_GetFSCfgDesc (uint16_t *length)
//{
//  *length = sizeof (USBD_COMP_CfgFSDesc);
//  return USBD_COMP_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_COMP_GetHSCfgDesc (uint16_t *length)
//{
//  *length = sizeof (USBD_COMP_CfgHSDesc);
//  return USBD_COMP_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_COMP_GetOtherSpeedCfgDesc (uint16_t *length)
//{
//  *length = sizeof (USBD_COMP_OtherSpeedCfgDesc);
//  return USBD_COMP_OtherSpeedCfgDesc;
//}

///**
//* @brief  DeviceQualifierDescriptor 
//*         return Device Qualifier descriptor
//* @param  length : pointer data length
//* @retval pointer to descriptor buffer
//*/
//uint8_t  *USBD_COMP_GetDeviceQualifierDescriptor (uint16_t *length)
//{
//  *length = sizeof (USBD_COMP_DeviceQualifierDesc);
//  return USBD_COMP_DeviceQualifierDesc;
//}




static uint8_t  USBD_COMP_Init (USBD_HandleTypeDef *pdev, 
                               uint8_t cfgidx)
{
  uint8_t ret = 0;
  USBD_CDC_HandleTypeDef   *hcdc;
  
  if(pdev->dev_speed == USBD_SPEED_HIGH  ) 
  {  
    /* Open EP IN */
    USBD_LL_OpenEP(pdev,
                   CDC_IN_EP,
                   USBD_EP_TYPE_BULK,
                   CDC_DATA_HS_IN_PACKET_SIZE);
    
    /* Open EP OUT */
    USBD_LL_OpenEP(pdev,
                   CDC_OUT_EP,
                   USBD_EP_TYPE_BULK,
                   CDC_DATA_HS_OUT_PACKET_SIZE);
    
  }
  else
  {
    /* Open EP IN */
    USBD_LL_OpenEP(pdev,
                   CDC_IN_EP,
                   USBD_EP_TYPE_BULK,
                   CDC_DATA_FS_IN_PACKET_SIZE);
    
    /* Open EP OUT */
    USBD_LL_OpenEP(pdev,
                   CDC_OUT_EP,
                   USBD_EP_TYPE_BULK,
                   CDC_DATA_FS_OUT_PACKET_SIZE);
  }
  /* Open Command IN EP */
  USBD_LL_OpenEP(pdev,
                 CDC_CMD_EP,
                 USBD_EP_TYPE_INTR,
                 CDC_CMD_PACKET_SIZE);
  
    
  pdev->pClassData = USBD_malloc(sizeof (USBD_CDC_HandleTypeDef));
  
  if(pdev->pClassData == NULL)
  {
    ret = 1; 
  }
  else
  {
    hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
    
    /* Init  physical Interface components */
    ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Init();
    
    /* Init Xfer states */
    hcdc->TxState =0;
    hcdc->RxState =0;
       
    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);
    }
    else
    {
      /* Prepare Out endpoint to receive next packet */
      USBD_LL_PrepareReceive(pdev,
                             CDC_OUT_EP,
                             hcdc->RxBuffer,
                             CDC_DATA_FS_OUT_PACKET_SIZE);
    }
    
    
  }
  return ret;
}

/**
  * @brief  USBD_CDC_Init
  *         DeInitialize the CDC layer
  * @param  pdev: device instance
  * @param  cfgidx: Configuration index
  * @retval status
  */
static uint8_t  USBD_COMP_DeInit (USBD_HandleTypeDef *pdev, 
                                 uint8_t cfgidx)
{
  uint8_t ret = 0;
  
  /* Open EP IN */
  USBD_LL_CloseEP(pdev,
              CDC_IN_EP);
  
  /* Open EP OUT */
  USBD_LL_CloseEP(pdev,
              CDC_OUT_EP);
  
  /* Open Command IN EP */
  USBD_LL_CloseEP(pdev,
              CDC_CMD_EP);
  
  
  /* DeInit  physical Interface components */
  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_COMP_Setup (USBD_HandleTypeDef *pdev, 
                                USBD_SetupReqTypedef *req)
{
  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
  static uint8_t ifalt = 0;
    
  switch (req->bmRequest & USB_REQ_TYPE_MASK)
  {
  case USB_REQ_TYPE_CLASS :
    if (req->wLength)
    {
      if (req->bmRequest & 0x80)
      {
        ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(req->bRequest,
                                                          (uint8_t *)hcdc->data,
                                                          req->wLength);
          USBD_CtlSendData (pdev, 
                            (uint8_t *)hcdc->data,
                            req->wLength);
      }
      else
      {
        hcdc->CmdOpCode = req->bRequest;
        hcdc->CmdLength = req->wLength;
        
        USBD_CtlPrepareRx (pdev, 
                           (uint8_t *)hcdc->data,
                           req->wLength);
      }
      
    }
    else
    {
      ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(req->bRequest,
                                                        (uint8_t*)req,
                                                        0);
    }
    break;

  case USB_REQ_TYPE_STANDARD:
    switch (req->bRequest)
    {      
    case USB_REQ_GET_INTERFACE :
      USBD_CtlSendData (pdev,
                        &ifalt,
                        1);
      break;
      
    case USB_REQ_SET_INTERFACE :
      break;
    }
 
  default: 
    break;
  }
  return USBD_OK;
}

/**
  * @brief  usbd_audio_DataIn
  *         Data sent on non-control IN endpoint
  * @param  pdev: device instance
  * @param  epnum: endpoint number
  * @retval status
  */
static uint8_t  USBD_COMP_DataIn (USBD_HandleTypeDef *pdev, uint8_t epnum)
{
  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
  
  if(pdev->pClassData != NULL)
  {
    
    hcdc->TxState = 0;

    return USBD_OK;
  }
  else
  {
    return USBD_FAIL;
  }
}

/**
  * @brief  USBD_CDC_DataOut
  *         Data received on non-control Out endpoint
  * @param  pdev: device instance
  * @param  epnum: endpoint number
  * @retval status
  */
static uint8_t  USBD_COMP_DataOut (USBD_HandleTypeDef *pdev, uint8_t epnum)
{      
  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
  
  /* Get the received data length */
  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)
  {
    ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Receive(hcdc->RxBuffer, &hcdc->RxLength);

    return USBD_OK;
  }
  else
  {
    return USBD_FAIL;
  }
}



/**
  * @brief  USBD_CDC_DataOut
  *         Data received on non-control Out endpoint
  * @param  pdev: device instance
  * @param  epnum: endpoint number
  * @retval status
  */
static uint8_t  USBD_COMP_EP0_RxReady (USBD_HandleTypeDef *pdev)
{ 
  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
  
  if((pdev->pUserData != NULL) && (hcdc->CmdOpCode != 0xFF))
  {
    ((USBD_CDC_ItfTypeDef *)pdev->pUserData)->Control(hcdc->CmdOpCode,
                                                      (uint8_t *)hcdc->data,
                                                      hcdc->CmdLength);
      hcdc->CmdOpCode = 0xFF; 
      
  }
  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_COMP_GetFSCfgDesc (uint16_t *length)
{
  *length = sizeof (USBD_COMP_CfgFSDesc);
  return USBD_COMP_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_COMP_GetHSCfgDesc (uint16_t *length)
{
  *length = sizeof (USBD_COMP_CfgHSDesc);
  return USBD_COMP_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_COMP_GetOtherSpeedCfgDesc (uint16_t *length)
{
  *length = sizeof (USBD_COMP_OtherSpeedCfgDesc);
  return USBD_COMP_OtherSpeedCfgDesc;
}

/**
* @brief  DeviceQualifierDescriptor 
*         return Device Qualifier descriptor
* @param  length : pointer data length
* @retval pointer to descriptor buffer
*/
uint8_t  *USBD_COMP_GetDeviceQualifierDescriptor (uint16_t *length)
{
  *length = sizeof (USBD_COMP_DeviceQualifierDesc);
  return USBD_COMP_DeviceQualifierDesc;
}

/**
* @brief  USBD_CDC_RegisterInterface
  * @param  pdev: device instance
  * @param  fops: CD  Interface callback
  * @retval status
  */
uint8_t  USBD_COMP_RegisterInterface  (USBD_HandleTypeDef   *pdev, 
                                      USBD_CDC_ItfTypeDef *fops)
{
  uint8_t  ret = USBD_FAIL;
  
  if(fops != NULL)
  {
    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  *pbuff,
//                                uint16_t length)
//{
//  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  *pbuff)
//{
//  USBD_CDC_HandleTypeDef   *hcdc = (USBD_CDC_HandleTypeDef*) pdev->pClassData;
//  
//  hcdc->RxBuffer = pbuff;
//  
//  return USBD_OK;
//}

/**
  * @brief  USBD_CDC_DataOut
  *         Data received on non-control Out 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;
//  
//  if(pdev->pClassData != NULL)
//  {
//    if(hcdc->TxState == 0)
//    {
//      /* Tx Transfer in progress */
//      hcdc->TxState = 1;
//      
//      /* Transmit next packet */
//      USBD_LL_Transmit(pdev,
//                       CDC_IN_EP,
//                       hcdc->TxBuffer,
//                       hcdc->TxLength);
//      
//      return USBD_OK;
//    }
//    else
//    {
//      return USBD_BUSY;
//    }
//  }
//  else
//  {
//    return USBD_FAIL;
//  }
//}

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