/**
* @brief usbd_cdc_Init
* Initilaize the CDC interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
static uint8_t usbd_composite_Init (void *pdev,
uint8_t cfgidx)
{
// CDC
/* Open EP IN */
DCD_EP_Open(pdev,
CDC_IN_EP,
CDC_DATA_IN_PACKET_SIZE,
USB_OTG_EP_BULK);
/* Open EP OUT */
DCD_EP_Open(pdev,
CDC_OUT_EP,
CDC_DATA_OUT_PACKET_SIZE,
USB_OTG_EP_BULK);
/* Open Command IN EP */
DCD_EP_Open(pdev,
CDC_CMD_EP,
CDC_CMD_PACKET_SZE,
USB_OTG_EP_INT);
/* Initialize the Interface physical components */
APP_FOPS.pIf_Init();
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(pdev,
CDC_OUT_EP,
(uint8_t*)(USB_Rx_Buffer),
CDC_DATA_OUT_PACKET_SIZE);
// HID
/* Open EP IN */
DCD_EP_Open(pdev,
HID_IN_EP,
HID_IN_PACKET,
USB_OTG_EP_INT);
/* Open EP OUT */
DCD_EP_Open(pdev,
HID_OUT_EP,
HID_OUT_PACKET,
USB_OTG_EP_INT);
DCD_EP_PrepareRx(pdev,
HID_OUT_EP,
(uint8_t*)(USB_hid_Rx_Buffer),
HID_OUT_PACKET);
return USBD_OK;
}
/**
* @brief usbd_cdc_Init
* Initilaize the CDC interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
static uint8_t usbd_cdc_Init (void *pdev, //初始化USB设备的端点及描述符
uint8_t cfgidx)
{
uint8_t *pbuf;
/* Open EP IN */
DCD_EP_Open(pdev, //设置输入端点1的端点地址、最大包为64、端点类型为批量端点，并激活端点
CDC_IN_EP, //0x81
VIRTUAL_COM_PORT_DATA_SIZE, //64
USB_OTG_EP_BULK); //批量端点
/* Open EP OUT */
DCD_EP_Open(pdev, //设置输出端点3的端点地址、最大包为64、端点类型为批量端点，并激活端点
CDC_OUT_EP, //0x03
VIRTUAL_COM_PORT_DATA_SIZE, //64
USB_OTG_EP_BULK); //批量端点
/* Open Command IN EP */
DCD_EP_Open(pdev, //设置输入端点2的端点地址、最大包为8、端点类型为中断端点，并激活端点
CDC_CMD_EP, //0x82
VIRTUAL_COM_PORT_INT_SIZE, //8
USB_OTG_EP_INT); //中断端点
pbuf = (uint8_t *)USBD_DeviceDesc; //设备描述符
pbuf[4] = DEVICE_CLASS_CDC; /*bDeviceClass:CDC设备类代码0x02*/
pbuf[5] = DEVICE_SUBCLASS_CDC; /*bDeviceSubClass子类代码0x00*/
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(pdev, //设备端点CDC_OUT_EP接收VIRTUAL_COM_PORT_DATA_SIZE个数据到USB_Rx_Buffer
CDC_OUT_EP,
(uint8_t*)(USB_Rx_Buffer),
VIRTUAL_COM_PORT_DATA_SIZE);
return USBD_OK;
}
/**
* @brief usbd_audio_DataOut
* Handles the Audio Out data stage.
* @param pdev: instance
* @param epnum: endpoint number
* @retval status
*/
static uint8_t usbd_audio_DataOut (void *pdev, uint8_t epnum)
{
if (epnum == AUDIO_OUT_EP)
{
/* Increment the Buffer pointer or roll it back when all buffers are full */
if (IsocOutWrPtr >= (IsocOutBuff + (AUDIO_OUT_PACKET * OUT_PACKET_NUM)))
{/* All buffers are full: roll back */
IsocOutWrPtr = IsocOutBuff;
}
else
{/* Increment the buffer pointer */
IsocOutWrPtr += AUDIO_OUT_PACKET;
}
/* Toggle the frame index */
((USB_OTG_CORE_HANDLE*)pdev)->dev.out_ep[epnum].even_odd_frame =
(((USB_OTG_CORE_HANDLE*)pdev)->dev.out_ep[epnum].even_odd_frame)? 0:1;
/* Prepare Out endpoint to receive next audio packet */
DCD_EP_PrepareRx(pdev,
AUDIO_OUT_EP,
(uint8_t*)(IsocOutWrPtr),
AUDIO_OUT_PACKET);
/* Trigger the start of streaming only when half buffer is full */
if ((PlayFlag == 0) && (IsocOutWrPtr >= (IsocOutBuff + ((AUDIO_OUT_PACKET * OUT_PACKET_NUM) / 2))))
{
/* Enable start of Streaming */
PlayFlag = 1;
}
}
return USBD_OK;
}
/**
* @brief CCID_Message_In
* Handle Bulk IN & Intr IN data stage
* @param pdev: device instance
* @param uint8_t epnum: endpoint index
* @retval None
*/
void CCID_BulkMessage_In (USB_CORE_HANDLE *pdev,
uint8_t epnum)
{
if (epnum == (CCID_BULK_IN_EP & 0x7F))
{/* Filter the epnum by masking with 0x7f (mask of IN Direction) */
/*************** Handle Bulk Transfer IN data completion *****************/
/* Toggle LED1 */
STM_EVAL_LEDToggle(LED1);
switch (Ccid_BulkState)
{
case CCID_STATE_SEND_RESP:
Ccid_BulkState = CCID_STATE_IDLE;
/* Prepare EP to Receive First Cmd */
DCD_EP_PrepareRx (pdev,
CCID_BULK_OUT_EP,
(uint8_t *)&BulkOut_Data_Buff[0],
CCID_BULK_EPOUT_SIZE);
break;
default:
break;
}
}
else if (epnum == (CCID_INTR_IN_EP & 0x7F))
{
/* Filter the epnum by masking with 0x7f (mask of IN Direction) */
CCID_SetIntrTransferStatus(1); /* Transfer Complete Status */
}
}
/**
* @brief usbd_midi_Init
* Initilaizes the MIDI interface.
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
static uint8_t usbd_midi_Init (void *pdev,
uint8_t cfgidx)
{
/* Open EP OUT */
/**
* @brief Configure an EP
* @param pdev : Device instance
* @param epdesc : Endpoint Descriptor
* @retval : status
*/
(void)cfgidx;
DCD_EP_Open(pdev,
MIDI_OUT_EP,
MIDI_PACKET_SIZE,
USB_OTG_EP_BULK);
DCD_EP_Open(pdev,
MIDI_IN_EP,
MIDI_PACKET_SIZE,
USB_OTG_EP_BULK);
/* Prepare Out endpoint to receive midi data */
DCD_EP_PrepareRx(pdev,
MIDI_OUT_EP,
(uint8_t*)usb_MidiOutBuff,
MIDI_PACKET_SIZE);
//No Hardware to init
return USBD_OK;
}
// Data received on non-control Out endpoint
static uint8_t usbd_rndis_data_out(void *pdev, uint8_t epnum)
{
static int rndis_received = 0;
if (epnum == RNDIS_DATA_OUT_EP)
{
PUSB_OTG_EP ep = &((USB_OTG_CORE_HANDLE*)pdev)->dev.out_ep[epnum];
if (rndis_received + ep->xfer_count > RNDIS_RX_BUFFER_SIZE)
{
usb_eth_stat.rxbad++;
rndis_received = 0;
}
else
{
if (rndis_received + ep->xfer_count <= RNDIS_RX_BUFFER_SIZE)
{
memcpy(&rndis_rx_buffer[rndis_received], usb_rx_buffer, ep->xfer_count);
rndis_received += ep->xfer_count;
if (ep->xfer_count != RNDIS_DATA_OUT_SZ)
{
handle_packet(rndis_rx_buffer, rndis_received);
rndis_received = 0;
}
}
else
{
rndis_received = 0;
usb_eth_stat.rxbad++;
}
}
DCD_EP_PrepareRx(pdev, RNDIS_DATA_OUT_EP, (uint8_t*)usb_rx_buffer, RNDIS_DATA_OUT_SZ);
}
return USBD_OK;
}
/**
* @brief USBD_CDC_ClassInit
* Initilaize the CDC interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
static uint8_t USBD_CDC_ClassInit (void* pdev, uint8_t cfgidx)
{
DCD_EP_Open(pdev,
USBD_Dev_CDC_D2H_EP,
USBD_Dev_CDC_D2H_EP_SZ,
USB_OTG_EP_BULK);
DCD_EP_Open(pdev,
USBD_Dev_CDC_H2D_EP,
USBD_Dev_CDC_H2D_EP_SZ,
USB_OTG_EP_BULK);
DCD_EP_Open(pdev,
USBD_Dev_CDC_CMD_EP,
USBD_Dev_CDC_CMD_EP_SZ,
USB_OTG_EP_INT);
USBD_CDC_InFlight = 0;
ringbuffer_init(&USBD_CDC_H2D_FIFO, malloc(CDC_DATA_IN_PACKET_SIZE), CDC_DATA_IN_PACKET_SIZE);
ringbuffer_init(&USBD_CDC_D2H_FIFO, malloc(CDC_DATA_MAX_PACKET_SIZE), CDC_DATA_MAX_PACKET_SIZE);
USBD_CDC_D2H_Buff = malloc(CDC_DATA_IN_PACKET_SIZE);
USBD_CDC_H2D_Buff = malloc(CDC_DATA_MAX_PACKET_SIZE);
USBD_CDC_CMD_Buff = malloc(CDC_CMD_PACKET_SZE);
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(pdev,
USBD_Dev_CDC_H2D_EP,
(uint8_t*)(USBD_CDC_H2D_Buff),
USBD_Dev_CDC_H2D_EP_SZ);
return USBD_OK;
}
//--------------------------------------------------------------
USBD_Status USBD_CtlContinueRx(USB_OTG_CORE_HANDLE * pdev, uint8_t * pbuf, uint16_t len)
{
USBD_Status ret = USBD_OK;
DCD_EP_PrepareRx(pdev, 0, pbuf, len);
return ret;
}
static uint8_t usbd_rndis_init(void *pdev, uint8_t cfgidx)
{
DCD_EP_Open(pdev, RNDIS_NOTIFICATION_IN_EP, RNDIS_NOTIFICATION_IN_SZ, USB_OTG_EP_INT);
DCD_EP_Open(pdev, RNDIS_DATA_IN_EP, RNDIS_DATA_IN_SZ, USB_OTG_EP_BULK);
DCD_EP_Open(pdev, RNDIS_DATA_OUT_EP, RNDIS_DATA_OUT_SZ, USB_OTG_EP_BULK);
DCD_EP_PrepareRx(pdev, RNDIS_DATA_OUT_EP, (uint8_t*)usb_rx_buffer, RNDIS_DATA_OUT_SZ);
return USBD_OK;
}
/**
* @brief usbd_cdc_Init
* Initilaize the CDC interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
static uint8_t usbd_cdc_msc_Init (void *pdev,
uint8_t cfgidx)
{
// uint8_t *pbuf;
// MSC_BOT_Data = (filerBuf + 60*1024);
MSC_BOT_Data = filerBuf;
/* Open EP IN */
DCD_EP_Open(pdev,
CDC_IN_EP,
CDC_DATA_IN_PACKET_SIZE,
USB_OTG_EP_BULK);
/* Open EP OUT */
DCD_EP_Open(pdev,
CDC_OUT_EP,
CDC_DATA_OUT_PACKET_SIZE,
USB_OTG_EP_BULK);
/* Open Command IN EP */
DCD_EP_Open(pdev,
CDC_CMD_EP,
CDC_CMD_PACKET_SZE,
USB_OTG_EP_INT);
/* Open EP IN */
DCD_EP_Open(pdev,
MSC_IN_EP,
MSC_EPIN_SIZE,
USB_OTG_EP_BULK);
/* Open EP OUT */
DCD_EP_Open(pdev,
MSC_OUT_EP,
MSC_EPOUT_SIZE,
USB_OTG_EP_BULK);
// pbuf = (uint8_t *)USBD_DeviceDesc;
// pbuf[4] = DEVICE_CLASS_CDC;
// pbuf[5] = DEVICE_SUBCLASS_CDC;
/* Initialize the Interface physical components */
APP_FOPS.pIf_Init();
// usbd_cdc_msc_DeInit(pdev , cfgidx );
/* Init the BOT layer */
MSC_BOT_Init(pdev);
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(pdev,
CDC_OUT_EP,
(uint8_t*)(USB_Rx_Buffer),
CDC_DATA_OUT_PACKET_SIZE);
return USBD_OK;
}
/**
* @brief MSC_BOT_Reset
* Reset the BOT Machine
* @param pdev: device instance
* @retval None
*/
void MSC_BOT_Reset (USB_OTG_CORE_HANDLE *pdev) {
MSC_BOT_State = BOT_IDLE;
MSC_BOT_Status = BOT_STATE_RECOVERY;
/* Prapare EP to Receive First BOT Cmd */
DCD_EP_PrepareRx (pdev,
MSC_OUT_EP,
(uint8_t *)&MSC_BOT_cbw,
BOT_CBW_LENGTH);
}
//--------------------------------------------------------------
USBD_Status USBD_CtlReceiveStatus(USB_OTG_CORE_HANDLE * pdev)
{
USBD_Status ret = USBD_OK;
pdev->dev.device_state = USB_OTG_EP0_STATUS_OUT;
DCD_EP_PrepareRx(pdev, 0, NULL, 0);
USB_OTG_EP0_OutStart(pdev);
return ret;
}
/**
* @brief MSC_BOT_Init
* Initialize the BOT Process
* @param pdev: device instance
* @retval None
*/
void MSC_BOT_Init (USB_CORE_HANDLE *pdev)
{
MSC_BOT_State = BOT_IDLE;
MSC_BOT_Status = BOT_STATE_NORMAL;
USBD_STORAGE_fops->Init(0);
/* Prepare EP to Receive First BOT Cmd */
DCD_EP_PrepareRx (pdev,
MSC_OUT_EP,
(uint8_t *)&MSC_BOT_cbw,
BOT_CBW_LENGTH);
}
//--------------------------------------------------------------
USBD_Status USBD_CtlPrepareRx(USB_OTG_CORE_HANDLE * pdev, uint8_t * pbuf, uint16_t len)
{
USBD_Status ret = USBD_OK;
pdev->dev.out_ep[0].total_data_len = len;
pdev->dev.out_ep[0].rem_data_len = len;
pdev->dev.device_state = USB_OTG_EP0_DATA_OUT;
DCD_EP_PrepareRx(pdev, 0, pbuf, len);
return ret;
}
/**
* @brief CCID_Init
* Initialize the CCID USB Layer
* @param pdev: device instance
* @retval None
*/
void CCID_Init (USB_CORE_HANDLE *pdev)
{
/* CCID Related Initialization */
CCID_SetIntrTransferStatus(1); /* Transfer Complete Status */
CCID_UpdSlotChange(1);
SC_InitParams();
/* Prepare EP to Receive First Cmd */
DCD_EP_PrepareRx (pdev,
CCID_BULK_OUT_EP,
(uint8_t *)&BulkOut_Data_Buff[0],
CCID_BULK_EPOUT_SIZE);
}
uint8_t USBD_HID_Init (void *pdev, uint8_t cfgidx)
{
DCD_PMA_Config(pdev, HID_IN_EP, USB_SNG_BUF, HID_IN_TX_ADDRESS);
DCD_PMA_Config(pdev, HID_OUT_EP, USB_SNG_BUF, HID_OUT_RX_ADDRESS);
DCD_EP_Open(pdev, HID_IN_EP, DAP_PACKET_SIZE, USB_EP_INT);
DCD_EP_Open(pdev, HID_OUT_EP, DAP_PACKET_SIZE, USB_EP_INT);
/* start the ball rolling by preparing the first receive buffer */
DCD_EP_PrepareRx(pdev, HID_OUT_EP, next_dap_queue_buffer(), DAP_PACKET_SIZE);
return USBD_OK;
}
/**
* @brief MSC_BOT_Init
* Initialize the BOT Process
* @param pdev: device instance
* @retval None
*/
void MSC_BOT_Init (USB_OTG_CORE_HANDLE *pdev) {
#ifdef SDIO_DMA
MSC_BOT_State = BOT_IDLE;
MSC_BOT_Status = BOT_STATE_NORMAL;
USBD_STORAGE_fops->Init(0);
DCD_EP_Flush(pdev, MSC_OUT_EP);
DCD_EP_Flush(pdev, MSC_IN_EP);
/* Prapare EP to Receive First BOT Cmd */
DCD_EP_PrepareRx (pdev,
MSC_OUT_EP,
(uint8_t *)&MSC_BOT_cbw,
BOT_CBW_LENGTH);
#endif
}
static void MSC_BOT_Abort (USB_OTG_CORE_HANDLE *pdev) {
if ((MSC_BOT_cbw.bmFlags == 0) &&
(MSC_BOT_cbw.dDataLength != 0) &&
(MSC_BOT_Status == BOT_STATE_NORMAL) ) {
DCD_EP_Stall(pdev, MSC_OUT_EP );
}
DCD_EP_Stall(pdev, MSC_IN_EP);
if(MSC_BOT_Status == BOT_STATE_ERROR) {
DCD_EP_PrepareRx (pdev,
MSC_OUT_EP,
(uint8_t *)&MSC_BOT_cbw,
BOT_CBW_LENGTH);
}
}
void SCSI_ProcessWriteComplete(uint32_t len) {
SCSI_blk_addr += len;
SCSI_blk_len -= len;
/* case 12 : Ho = Do */
MSC_BOT_csw.dDataResidue -= len;
if (SCSI_blk_len == 0) {
MSC_BOT_SendCSW (cdev, CSW_CMD_PASSED);
} else {
/* Prapare EP to Receive next packet */
DCD_EP_PrepareRx (cdev,
MSC_OUT_EP,
MSC_BOT_Data,
MIN (SCSI_blk_len, MSC_MEDIA_PACKET));
}
}
/**
* @brief usbd_cf_DataOut
* Data received on non-control Out endpoint
* @param pdev: device instance
* @param epnum: endpoint number
* @retval status
*/
static uint8_t usbd_cf_DataOut (void *pdev, uint8_t epnum)
{
portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
/* Get the received data buffer and update the counter */
inPacket.size = ((USB_OTG_CORE_HANDLE*)pdev)->dev.out_ep[epnum].xfer_count;
xQueueSendFromISR(usbDataRx, &inPacket, &xHigherPriorityTaskWoken);
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(pdev,
OUT_EP,
(uint8_t*)(inPacket.data),
USB_RX_TX_PACKET_SIZE);
return USBD_OK;
}
/**
* @brief MSC_BOT_SendCSW
* Send the Command Status Wrapper
* @param pdev: device instance
* @param status : CSW status
* @retval None
*/
void MSC_BOT_SendCSW (USB_OTG_CORE_HANDLE *pdev,
uint8_t CSW_Status) {
MSC_BOT_csw.dSignature = BOT_CSW_SIGNATURE;
MSC_BOT_csw.bStatus = CSW_Status;
MSC_BOT_State = BOT_IDLE;
DCD_EP_Tx (pdev,
MSC_IN_EP,
(uint8_t *)&MSC_BOT_csw,
BOT_CSW_LENGTH);
/* Prapare EP to Receive next Cmd */
DCD_EP_PrepareRx (pdev,
MSC_OUT_EP,
(uint8_t *)&MSC_BOT_cbw,
BOT_CBW_LENGTH);
}
static uint8_t USBD_HID_Init (void *pdev,
uint8_t cfgidx)
{
/* Open EP IN */
DCD_EP_Open(pdev,
HID_IN_EP,
HID_IN_PACKET,
USB_OTG_EP_INT);
/* Open EP OUT */
DCD_EP_Open(pdev,
HID_OUT_EP,
HID_OUT_PACKET,
USB_OTG_EP_INT);
DCD_EP_PrepareRx(pdev, HID_OUT_EP, usb_rx_buffer, HID_OUT_PACKET);
return USBD_OK;
}
/**
* @brief usbd_cdc_Init
* Initilaize the CDC interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
static uint8_t usbd_cdc_Init (void *pdev,
uint8_t cfgidx)
{
uint8_t *pbuf;
usbd_cdc_DeInit(pdev, cfgidx);
/* Open EP IN */
DCD_EP_Open(pdev,
CDC_IN_EP,
CDC_DATA_IN_PACKET_SIZE,
USB_OTG_EP_BULK);
/* Open EP OUT */
DCD_EP_Open(pdev,
CDC_OUT_EP,
CDC_DATA_OUT_PACKET_SIZE,
USB_OTG_EP_BULK);
/* Open Command IN EP */
DCD_EP_Open(pdev,
CDC_CMD_EP,
CDC_CMD_PACKET_SZE,
USB_OTG_EP_INT);
pbuf = (uint8_t *)USBD_DeviceDesc;
pbuf[4] = DEVICE_CLASS_CDC;
pbuf[5] = DEVICE_SUBCLASS_CDC;
/* Initialize the Interface physical components */
APP_FOPS.pIf_Init();
USB_Rx_State = 1;
cdcConfigured = 1;
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(pdev,
CDC_OUT_EP,
(uint8_t*)(USB_Rx_Buffer),
CDC_DATA_OUT_PACKET_SIZE);
return USBD_OK;
}
/**
* @brief usbd_audio_DataOut
* Data received on non-control Out endpoint
* @param pdev: device instance
* @param epnum: endpoint number
* @retval status
*/
static uint8_t usbd_cdc_DataOut (void *pdev, uint8_t epnum)
{
uint16_t USB_Rx_Cnt;
/* Get the received data buffer and update the counter */
USB_Rx_Cnt = ((USB_OTG_CORE_HANDLE*)pdev)->dev.out_ep[epnum].xfer_count;
/* USB data will be immediately processed, this allow next USB traffic being
NAKed till the end of the application Xfer */
APP_FOPS.pIf_DataRx(USB_Rx_Buffer, USB_Rx_Cnt);
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(pdev,
CDC_OUT_EP,
(uint8_t*)(USB_Rx_Buffer),
CDC_DATA_OUT_PACKET_SIZE);
return USBD_OK;
}
/*******************************************************************************
* Function Name : USB_USART_Receive_Data.
* Description : Return data sent by USB Host.
* Input : None
* Return : Data.
*******************************************************************************/
int32_t USB_USART_Receive_Data(uint8_t peek)
{
if(USB_Rx_State == 1)
{
if(!peek && ((USB_Rx_length - USB_Rx_ptr) == 1))
{
USB_Rx_State = 0;
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(&USB_OTG_dev,
CDC_OUT_EP,
(uint8_t*)(USB_Rx_Buffer),
CDC_DATA_OUT_PACKET_SIZE);
}
return USB_Rx_Buffer[peek ? USB_Rx_ptr : USB_Rx_ptr++];
}
return -1;
}
/**
* @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_CDC_DataOut (void *pdev, uint8_t epnum)
{
uint16_t USB_Rx_Cnt;
/* Get the received data buffer and update the counter */
USB_Rx_Cnt = ((USB_OTG_CORE_HANDLE*)pdev)->dev.out_ep[epnum].xfer_count;
for (uint16_t i = 0; i < USB_Rx_Cnt; i++) {
uint8_t c = USBD_CDC_H2D_Buff[i];
ringbuffer_push(&USBD_CDC_H2D_FIFO, c);
}
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(pdev,
USBD_Dev_CDC_H2D_EP,
(uint8_t*)(USBD_CDC_H2D_Buff),
CDC_DATA_OUT_PACKET_SIZE);
return USBD_OK;
}
/**
* @brief usbd_cdc_Init
* Initialize the CDC interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
uint8_t usbd_cdc_Init (void *pdev,
uint8_t cfgidx)
{
DCD_PMA_Config(pdev , CDC_IN_EP,USB_SNG_BUF,BULK_IN_TX_ADDRESS);
DCD_PMA_Config(pdev , CDC_CMD_EP,USB_SNG_BUF,INT_IN_TX_ADDRESS);
DCD_PMA_Config(pdev , CDC_OUT_EP,USB_SNG_BUF,BULK_OUT_RX_ADDRESS);
/* Open EP IN */
DCD_EP_Open(pdev,
CDC_IN_EP,
CDC_DATA_IN_PACKET_SIZE,
USB_EP_BULK);
/* Open EP OUT */
DCD_EP_Open(pdev,
CDC_OUT_EP,
CDC_DATA_OUT_PACKET_SIZE,
USB_EP_BULK);
/* Open Command IN EP */
DCD_EP_Open(pdev,
CDC_CMD_EP,
CDC_CMD_PACKET_SZE,
USB_EP_INT);
/* Initialize the Interface physical components */
APP_FOPS.pIf_Init();
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(pdev,
CDC_OUT_EP,
(uint8_t*)(USB_Rx_Buffer),
CDC_DATA_OUT_PACKET_SIZE);
return USBD_OK;
}
static uint8_t usbd_cf_Init (void *pdev,
uint8_t cfgidx)
{
/* Open EP IN */
DCD_EP_Open(pdev,
IN_EP,
USB_RX_TX_PACKET_SIZE,
USB_OTG_EP_BULK);
/* Open EP OUT */
DCD_EP_Open(pdev,
OUT_EP,
USB_RX_TX_PACKET_SIZE,
USB_OTG_EP_BULK);
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(pdev,
OUT_EP,
(uint8_t*)(inPacket.data),
USB_RX_TX_PACKET_SIZE);
return USBD_OK;
}
/**
* @brief USBD_HID_Init
* Initialize the HID interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
uint8_t USBD_HID_Init (void *pdev,
uint8_t cfgidx)
{
DCD_PMA_Config(pdev , HID_IN_EP,USB_SNG_BUF,HID_IN_TX_ADDRESS);
DCD_PMA_Config(pdev , HID_OUT_EP,USB_SNG_BUF,HID_OUT_RX_ADDRESS);
/* Open EP IN */
DCD_EP_Open(pdev,
HID_IN_EP,
HID_IN_PACKET,
USB_EP_INT);
/* Open EP OUT */
DCD_EP_Open(pdev,
HID_OUT_EP,
HID_OUT_PACKET,
USB_EP_INT);
/*Receive Data*/
DCD_EP_PrepareRx(pdev,HID_OUT_EP,Report_buf,2);
return USBD_OK;
}
/**
* @brief usbd_audio_Init
* Initilaizes the AUDIO interface.
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
static uint8_t usbd_audio_Init (void *pdev,
uint8_t cfgidx)
{
/* Open EP OUT */
DCD_EP_Open(pdev,
AUDIO_OUT_EP,
AUDIO_OUT_PACKET,
USB_OTG_EP_ISOC);
/* Initialize the Audio output Hardware layer */
if (AUDIO_OUT_fops.Init(USBD_AUDIO_FREQ, DEFAULT_VOLUME, 0) != USBD_OK)
{
return USBD_FAIL;
}
/* Prepare Out endpoint to receive audio data */
DCD_EP_PrepareRx(pdev,
AUDIO_OUT_EP,
(uint8_t*)IsocOutBuff,
AUDIO_OUT_PACKET);
return USBD_OK;
}
