自学教程：C++ DCD_EP_PrepareRx函数代码示例

/**  * @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 endpointstatic 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;}