/**
* @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)
{
uint8_t *pbuf;
/* 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;
return USBD_OK;
}
/**
* @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;
}
/**
* @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_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;
}
/**
* @brief USBD_HID_MSC_Init
* Initialize the HID interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
static uint8_t USBD_HID_MSC_Init (void *pdev, uint8_t cfgidx)
{
USBD_HID_MSC_DeInit(pdev , cfgidx );
/* 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);
/* MSC */
/* 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);
/* Init the BOT layer */
MSC_BOT_Init(pdev);
return USBD_OK;
}
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 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;
}
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;
}
void PIOS_USBHOOK_RegisterEpOutCallback(uint8_t epnum, uint16_t max_len, pios_usbhook_epcb cb, uintptr_t context)
{
PIOS_Assert(epnum < NELEMENTS(usb_epout_table));
PIOS_Assert(cb);
usb_epout_table[epnum].cb = cb;
usb_epout_table[epnum].context = context;
usb_epout_table[epnum].max_len = max_len;
DCD_EP_Open(&pios_usb_otg_core_handle,
epnum,
max_len,
USB_OTG_EP_INT);
/*
* FIXME do not hardcode endpoint type
*/
/*
* Make sure we refuse OUT transactions until we explicitly
* connect a receive buffer with PIOS_USBHOOK_EndpointRx().
*
* Without this, the ST USB code will receive on this endpoint
* and blindly write the data to a NULL pointer which will
* have the side effect of placing the internal flash into an
* errored state. Address 0x0000_0000 is aliased into internal
* flash via the "Section 2.4 Boot configuration" BOOT0/1 pins.
*/
DCD_SetEPStatus(&pios_usb_otg_core_handle,
epnum,
USB_OTG_EP_RX_NAK);
}
/**
* @brief USBD_HID_Init
* Initialize the HID interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
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);
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_HID_Init
* Initialize the HID interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
static uint8_t USBD_HID_Init (void *pdev,
uint8_t cfgidx)
{
DCD_PMA_Config(pdev , HID_IN_EP,USB_SNG_BUF,HID_IN_TX_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);
return USBD_OK;
}
static uint8_t USBD_Reset(USB_OTG_CORE_HANDLE *pdev)
{
/* Open EP0 OUT */
DCD_EP_Open(pdev,
0x00,
USB_OTG_MAX_EP0_SIZE,
EP_TYPE_CTRL);
/* Open EP0 IN */
DCD_EP_Open(pdev,
0x80,
USB_OTG_MAX_EP0_SIZE,
EP_TYPE_CTRL);
/* Upon Reset call usr call back */
pdev->dev.device_status = USB_OTG_DEFAULT;
pdev->dev.usr_cb->DeviceReset(pdev->cfg.speed);
//
return USBD_OK;
}
/**
* @brief USBD_MSC_Init
* Initialize the mass storage configuration
* @param pdev: device instance
* @param cfgidx: configuration index
* @retval status
*/
uint8_t USBD_MSC_Init (void *pdev,
uint8_t cfgidx)
{
USBD_MSC_DeInit(pdev , cfgidx );
/* 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);
/* Init the BOT layer */
MSC_BOT_Init(pdev);
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_video_Init (void *pdev,
uint8_t cfgidx)
{
/* Open EP IN */
DCD_EP_Open(pdev,
USB_ENDPOINT_IN(1),
VIDEO_PACKET_SIZE,
USB_OTG_EP_ISOC);
/* Initialize the Video Hardware layer */
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;
}
uint8_t USBD_Dev_DS3_ClassInit (void *pcore , uint8_t cfgidx)
{
DCD_EP_Open(pcore,
USBD_Dev_DS3_D2H_EP,
USBD_Dev_DS3_D2H_EP_SZ,
USB_OTG_EP_INT);
DCD_EP_Open(pcore,
USBD_Dev_DS3_H2D_EP,
USBD_Dev_DS3_H2D_EP_SZ,
USB_OTG_EP_INT);
USBD_Host_Is_PS3 = 0;
USBD_Dev_DS3_IsActive = 1;
#ifdef ENABLE_DS3_ADDITIONAL_FEATURES
DCD_EP_Open(pcore,
USBD_Dev_DS3_D2H_EP_ADDITIONAL,
USBD_Dev_DS3_D2H_EP_ADDITIONAL_SZ,
USB_OTG_EP_INT);
#endif
return USBD_OK;
}
/**
* @brief USBD_HID_Init
* Initialize the HID interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
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);
/* Prepare Out endpoint to receive next packet */
DCD_EP_PrepareRx(pdev,
HID_OUT_EP,
(uint8_t*)(Buffer),
HID_OUT_PACKET);
return USBD_OK;
}
static uint8_t USBD_Reset(USB_CORE_HANDLE *pdev)
{
DCD_PMA_Config(pdev , 0x00 ,USB_SNG_BUF, ENDP0_RX_ADDRESS);
DCD_PMA_Config(pdev , 0x80 ,USB_SNG_BUF, ENDP0_TX_ADDRESS);
/* Open EP0 OUT */
DCD_EP_Open(pdev,
0x00,
USB_MAX_EP0_SIZE,
EP_TYPE_CTRL);
/* Open EP0 IN */
DCD_EP_Open(pdev,
0x80,
USB_MAX_EP0_SIZE,
EP_TYPE_CTRL);
/* Upon Reset call usr call back */
pdev->dev.device_status = USB_DEFAULT;
pdev->dev.usr_cb->DeviceReset(pdev->dev.speed);
return USBD_OK;
}
void PIOS_USBHOOK_RegisterEpOutCallback(uint8_t epnum, uint16_t max_len, pios_usbhook_epcb cb, uint32_t context)
{
PIOS_Assert(epnum < NELEMENTS(usb_epout_table));
PIOS_Assert(cb);
usb_epout_table[epnum].cb = cb;
usb_epout_table[epnum].context = context;
usb_epout_table[epnum].max_len = max_len;
DCD_EP_Open(&pios_usb_otg_core_handle,
epnum,
max_len,
USB_OTG_EP_INT);
/*
* FIXME do not hardcode endpoint type
*/
}
/**
* @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;
}
/**
* @brief usbd_cdc_Setup
* Handle the CDC specific requests
* @param pdev: instance
* @param req: usb requests
* @retval status
*/
static uint8_t usbd_cdc_msc_Setup (void *pdev,
USB_SETUP_REQ *req)
{
uint16_t len=USB_CDC_MSC_DESC_SIZ;
uint8_t *pbuf=usbd_cdc_msc_CfgDesc + 9;
switch (req->bmRequest & USB_REQ_TYPE_MASK)
{
/* CDC Class Requests -------------------------------*/
case USB_REQ_TYPE_CLASS :
switch (req->bRequest)
{
case BOT_GET_MAX_LUN :
if((req->wValue == 0) &&
(req->wLength == 1) &&
((req->bmRequest & 0x80) == 0x80))
{
USBD_MSC_MaxLun = USBD_STORAGE_fops->GetMaxLun();
if(USBD_MSC_MaxLun > 0)
{
USBD_CtlSendData (pdev,
&USBD_MSC_MaxLun,
1);
}
else
{
USBD_CtlError(pdev , req);
return USBD_FAIL;
}
}
else
{
USBD_CtlError(pdev , req);
return USBD_FAIL;
}
break;
case BOT_RESET :
if((req->wValue == 0) &&
(req->wLength == 0) &&
((req->bmRequest & 0x80) != 0x80))
{
MSC_BOT_Reset(pdev);
}
else
{
USBD_CtlError(pdev , req);
return USBD_FAIL;
}
break;
// CDC
default:
/* Check if the request is a data setup packet */
if (req->wLength)
{
/* Check if the request is Device-to-Host */
if (req->bmRequest & 0x80)
{
/* Get the data to be sent to Host from interface layer */
APP_FOPS.pIf_Ctrl(req->bRequest, CmdBuff, req->wLength);
/* Send the data to the host */
USBD_CtlSendData (pdev,
CmdBuff,
req->wLength);
}
else /* Host-to-Device requeset */
{
/* Set the value of the current command to be processed */
cdcCmd = req->bRequest;
cdcLen = req->wLength;
/* Prepare the reception of the buffer over EP0
Next step: the received data will be managed in usbd_cdc_EP0_TxSent()
function. */
USBD_CtlPrepareRx (pdev,
CmdBuff,
req->wLength);
}
}
else /* No Data request */
{
/* Transfer the command to the interface layer */
APP_FOPS.pIf_Ctrl(req->bRequest, NULL, 0);
// check for DTE present changes - NEZ
if (req->bRequest == SET_CONTROL_LINE_STATE) {
USB_DTE_Present = req->wValue & 0x01;
if (!USB_DTE_Present) {
DCD_EP_Flush (pdev, CDC_IN_EP);
USB_Tx_State = 0;
}
}
}
return USBD_OK;
break; // default
}
break; // case USB_REQ_TYPE_CLASS
/* Standard Requests -------------------------------*/
case USB_REQ_TYPE_STANDARD:
switch (req->bRequest)
{
case USB_REQ_GET_DESCRIPTOR:
if( (req->wValue >> 8) == CDC_DESCRIPTOR_TYPE)
{
#ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
pbuf = usbd_cdc_Desc;
#else
pbuf = usbd_cdc_msc_CfgDesc + 9 + (9 * USBD_ITF_MAX_NUM);
#endif
len = MIN(USB_CDC_MSC_DESC_SIZ , req->wLength);
}
USBD_CtlSendData (pdev,
pbuf,
len);
break;
case USB_REQ_GET_INTERFACE :
if ((uint8_t)req->wValue == CDC_IN_EP || (uint8_t)req->wValue == CDC_OUT_EP) {
USBD_CtlSendData (pdev,
(uint8_t *)&usbd_cdc_AltSet,
1);
}
else {
USBD_CtlSendData (pdev,
&USBD_MSC_AltSet,
1);
break;
}
break;
case USB_REQ_SET_INTERFACE :
if ((uint8_t)req->wValue == CDC_IN_EP || (uint8_t)req->wValue == CDC_OUT_EP) {
if ((uint8_t)(req->wValue) < USBD_ITF_MAX_NUM)
{
usbd_cdc_AltSet = (uint8_t)(req->wValue);
}
else
{
/* Call the error management function (command will be nacked */
USBD_CtlError (pdev, req);
}
}
else {
USBD_MSC_AltSet = (uint8_t)(req->wValue);
}
break;
case USB_REQ_CLEAR_FEATURE:
/* Flush the FIFO and Clear the stall status */
DCD_EP_Flush(pdev, (uint8_t)req->wIndex);
/* Re-activate the EP */
DCD_EP_Close (pdev , (uint8_t)req->wIndex);
if((((uint8_t)req->wIndex) & 0x80) == 0x80)
{
DCD_EP_Open(pdev,
((uint8_t)req->wIndex),
MSC_EPIN_SIZE,
USB_OTG_EP_BULK);
}
else
{
DCD_EP_Open(pdev,
((uint8_t)req->wIndex),
MSC_EPOUT_SIZE,
USB_OTG_EP_BULK);
}
/* Handle BOT error */
MSC_BOT_CplClrFeature(pdev, (uint8_t)req->wIndex);
break;
}
}
return USBD_OK;
}
/**
* @brief USBD_MSC_Setup
* Handle the MSC specific requests
* @param pdev: device instance
* @param req: USB request
* @retval status
*/
uint8_t USBD_MSC_Setup (void *pdev, USB_SETUP_REQ *req)
{
switch (req->bmRequest & USB_REQ_TYPE_MASK)
{
/* Class request */
case USB_REQ_TYPE_CLASS :
switch (req->bRequest)
{
case BOT_GET_MAX_LUN :
if((req->wValue == 0) &&
(req->wLength == 1) &&
((req->bmRequest & 0x80) == 0x80))
{
USBD_MSC_MaxLun = USBD_STORAGE_fops->GetMaxLun();
if(USBD_MSC_MaxLun > 0)
{
USBD_CtlSendData (pdev,
&USBD_MSC_MaxLun,
1);
}
else
{
USBD_CtlError(pdev , req);
return USBD_FAIL;
}
}
else
{
USBD_CtlError(pdev , req);
return USBD_FAIL;
}
break;
case BOT_RESET :
if((req->wValue == 0) &&
(req->wLength == 0) &&
((req->bmRequest & 0x80) != 0x80))
{
MSC_BOT_Reset(pdev);
}
else
{
USBD_CtlError(pdev , req);
return USBD_FAIL;
}
break;
default:
USBD_CtlError(pdev , req);
return USBD_FAIL;
}
break;
/* Interface & Endpoint request */
case USB_REQ_TYPE_STANDARD:
switch (req->bRequest)
{
case USB_REQ_GET_INTERFACE :
USBD_CtlSendData (pdev,
&USBD_MSC_AltSet,
1);
break;
case USB_REQ_SET_INTERFACE :
USBD_MSC_AltSet = (uint8_t)(req->wValue);
break;
case USB_REQ_CLEAR_FEATURE:
/* Flush the FIFO and Clear the stall status */
DCD_EP_Flush(pdev, (uint8_t)req->wIndex);
/* Re-activate the EP */
DCD_EP_Close (pdev , (uint8_t)req->wIndex);
if((((uint8_t)req->wIndex) & 0x80) == 0x80)
{
DCD_EP_Open(pdev,
((uint8_t)req->wIndex),
MSC_EPIN_SIZE,
USB_OTG_EP_BULK);
}
else
{
DCD_EP_Open(pdev,
((uint8_t)req->wIndex),
MSC_EPOUT_SIZE,
USB_OTG_EP_BULK);
}
/* Handle BOT error */
MSC_BOT_CplClrFeature(pdev, (uint8_t)req->wIndex);
break;
}
break;
default:
break;
}
return USBD_OK;
}
uint8_t USBPTD_SetupStage(USB_OTG_CORE_HANDLE* pcore, USB_SETUP_REQ* req)
{
// store for later use from another function
memcpy(USBPT_LastSetupPacket, pcore->dev.setup_packet, 24);
// print for monitoring
USBPT_printf("\b\r\n USBPT:SETUP:");
for (uint8_t i = 0; i < 8; i++) {
USBPT_printf(" 0x%02X", USBPT_LastSetupPacket[i]);
}
USBPT_printf("\r\n");
// prepare to be sent to the device
memcpy(USBPT_Dev->Control.setup.d8, USBPT_LastSetupPacket, 8);
// set address must be handled explicitly
if ((req->bmRequest & 0x7F) == (USB_REQ_RECIPIENT_DEVICE | USB_REQ_TYPE_STANDARD) && req->bRequest == USB_REQ_SET_ADDRESS)
{
// let the internal code handle it for the device interface
USBD_StdDevReq(pcore, req);
// pass it to the downstream device
USBH_CtlReq_Blocking(&USB_OTG_Core_host, USBPT_Dev, 0, 0, 100);
USBD_CtlSendStatus(pcore);
// modifiy our host channel to match
USBPT_Dev->device_prop.address = (uint8_t)(req->wValue) & 0x7F;
USBH_Modify_Channel (&USB_OTG_Core_host,
USBPT_Dev->Control.hc_num_in,
USBPT_Dev->device_prop.address,
0,
0,
0);
USBH_Modify_Channel (&USB_OTG_Core_host,
USBPT_Dev->Control.hc_num_out,
USBPT_Dev->device_prop.address,
0,
0,
0);
// modify all other channels to match
for (uint8_t i = 0; i < USBPTH_MAX_LISTENERS; i++)
{
USBPTH_HC_EP_t* pl = &USBPTH_Listeners[i];
uint8_t hc = pl->hc;
if (hc != 0 && hc != HC_ERROR) // if listener is actually allocated
{
USBH_EpDesc_TypeDef* epDesc = pl->epDesc;
uint8_t epType = 0;
if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_INTR) {
epType = EP_TYPE_INTR;
}
else if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_BULK) {
epType = EP_TYPE_BULK;
}
else if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_ISOC) {
epType = EP_TYPE_ISOC;
}
else if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_CTRL) {
epType = EP_TYPE_CTRL;
}
USBH_Modify_Channel( &USB_OTG_Core_host,
USBPTH_Listeners[i].hc,
USBPT_Dev->device_prop.address,
USBPT_Dev->device_prop.speed,
epType,
USBPTH_Listeners[i].epDesc->wMaxPacketSize);
}
}
// note: out direction channels are dynamically allocated only when needed
// so we don't need to modify those channel addresses
return USBD_OK;
}
// no data means we can just directly relay the data
if (req->wLength == 0) {
USBH_CtlReq_Blocking(&USB_OTG_Core_host, USBPT_Dev, 0, 0, 100);
USBD_CtlSendStatus(pcore);
return USBD_OK;
}
// there is extra data later
USBPT_CtrlDataLen = req->wLength;
if (USBPT_CtrlData != 0) free(USBPT_CtrlData);
USBPT_CtrlData = malloc(USBPT_CtrlDataLen);
USBH_Status status;
// wait until previous req is finished
delay_1ms_cnt = 100;
while (delay_1ms_cnt > 0 &&
USBPT_Dev->Control.state != CTRL_COMPLETE &&
USBPT_Dev->Control.state != CTRL_IDLE &&
USBPT_Dev->Control.state != CTRL_ERROR &&
USBPT_Dev->Control.state != CTRL_STALLED);
{
status = USBH_HandleControl(&USB_OTG_Core_host, USBPT_Dev);
}
// finalize previous ctrl req
if (USBPT_Dev->RequestState == CMD_WAIT) {
USBH_CtlReq(&USB_OTG_Core_host, USBPT_Dev, 0 , 0 );
}
// prepare new setup
USBH_SubmitSetupRequest(USBPT_Dev, USBPT_CtrlData, USBPT_CtrlDataLen);
USBPT_Dev->RequestState = CMD_WAIT;
USBH_CtlSendSetup (&USB_OTG_Core_host, USBPT_Dev->Control.setup.d8, USBPT_Dev->Control.hc_num_out);
USBPT_Dev->Control.state = CTRL_SETUP_WAIT;
USBPT_Dev->Control.timer = HCD_GetCurrentFrame(pcore);
USBPT_Dev->Control.timeout = 50;
if ((req->bmRequest & 0x80) == 0)
{ // H2D
// we need to obtain the data from EP0_RxReady first
USBD_CtlPrepareRx (pcore, USBPT_CtrlData, USBPT_CtrlDataLen);
return USBD_OK;
}
else
{ // D2H
// wait for request to finish
delay_1ms_cnt = 100;
do
{
status = USBH_CtlReq(&USB_OTG_Core_host, USBPT_Dev, USBPT_CtrlData , USBPT_CtrlDataLen );
if (status == USBH_OK || status == USBH_FAIL || status == USBH_STALL || status == USBH_NOT_SUPPORTED) {
break;
}
else
{
status = USBH_HandleControl(&USB_OTG_Core_host, USBPT_Dev);
if (status == USBH_FAIL || status == USBH_STALL || status == USBH_NOT_SUPPORTED) {
break;
}
}
}
while (delay_1ms_cnt > 0);
if (delay_1ms_cnt == 0)
{
// timeout
dbg_printf(DBGMODE_ERR, "USBPT Setup Timed Out \r\n");
USBD_CtlSendStatus(pcore); // we reply with nothing to simulate a timeout
return USBH_OK;
}
else if (status == USBH_OK)
{
// all good, send back the data
USBD_CtlSendData (pcore, USBPT_CtrlData, USBPT_CtrlDataLen);
// handle config descriptors specially, we need to know what channels to open based on endpoints
if ((req->bmRequest & 0x7F) == (USB_REQ_RECIPIENT_DEVICE | USB_REQ_TYPE_STANDARD) &&
req->bRequest == USB_REQ_GET_DESCRIPTOR &&
req->wValue == USB_DESC_CONFIGURATION &&
req->wLength > USB_CONFIGURATION_DESC_SIZE)
{
// this is a full length configuration descriptor
// we need this info to open as many D2H endpoints to channels
USBH_ParseCfgDesc(&USBPT_Dev->device_prop.Cfg_Desc,
USBPT_Dev->device_prop.Itf_Desc,
USBPT_Dev->device_prop.Ep_Desc,
USBPT_CtrlData,
USBPT_CtrlDataLen);
USBPTH_OutEPCnt = 0;
USBPT_GeneralInDataLen = 0;
for (uint8_t i = 0; i < USBPT_Dev->device_prop.Cfg_Desc.bNumInterfaces && i < USBH_MAX_NUM_INTERFACES; i++)
{
for (uint8_t j = 0; j < USBPT_Dev->device_prop.Itf_Desc[i].bNumEndpoints && j < USBH_MAX_NUM_ENDPOINTS; j++)
{
USBH_EpDesc_TypeDef* epDesc = &USBPT_Dev->device_prop.Ep_Desc[i][j];
for (uint8_t k = 0; k < USBPTH_MAX_LISTENERS; k++)
{
if ((epDesc->bEndpointAddress & USB_EP_DIR_MSK) == USB_D2H && USBPTH_Listeners[k].used == 0)
{
USBPTH_Listeners[k].epDesc = epDesc;
uint8_t epType = 0;
if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_INTR) {
epType = EP_TYPE_INTR;
}
else if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_BULK) {
epType = EP_TYPE_BULK;
}
else if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_ISOC) {
epType = EP_TYPE_ISOC;
}
else if ((epDesc->bmAttributes & USB_EP_TYPE_INTR) == USB_EP_TYPE_CTRL) {
epType = EP_TYPE_CTRL;
}
USBH_Open_Channel( &USB_OTG_Core_host,
&(USBPTH_Listeners[k].hc),
epDesc->bEndpointAddress,
USBPT_Dev->device_prop.address,
USBPT_Dev->device_prop.speed,
epType,
USBPTH_Listeners[k].epDesc->wMaxPacketSize);
if (USBPTH_Listeners[k].hc >= 0)
{
USBPTH_Listeners[k].used = 1;
DCD_EP_Open(&USB_OTG_Core_dev, epDesc->bEndpointAddress, epDesc->wMaxPacketSize, epType);
if (epDesc->wMaxPacketSize > USBPT_GeneralInDataMax) {
USBPT_GeneralInDataMax = epDesc->wMaxPacketSize;
}
}
}
}
if ((epDesc->bEndpointAddress & 0x80) == USB_H2D)
{
USBPTH_OutEPCnt++;
}
}
}
if (USBPT_GeneralInData != 0) free(USBPT_GeneralInData); // release memory if previously allocated
USBPT_GeneralInData = malloc(USBPT_GeneralInDataMax); // only allocate the memory we need
if (USBPTH_OutEP != 0) free(USBPTH_OutEP); // release memory if previously allocated
USBPTH_OutEP = malloc(sizeof(USBH_EpDesc_TypeDef*) * USBPTH_OutEPCnt); // only allocate the memory we need
uint8_t ec = 0;
for (uint8_t i = 0; i < USBPT_Dev->device_prop.Cfg_Desc.bNumInterfaces && i < USBH_MAX_NUM_INTERFACES; i++)
{
for (uint8_t j = 0; j < USBPT_Dev->device_prop.Itf_Desc[i].bNumEndpoints && j < USBH_MAX_NUM_ENDPOINTS; j++)
{
USBH_EpDesc_TypeDef* epDesc = &USBPT_Dev->device_prop.Ep_Desc[i][j];
if ((epDesc->bEndpointAddress & 0x80) == USB_H2D) {
// only save the H2D direction endpoints
USBPTH_OutEP[ec] = epDesc;
ec++;
}
}
}
}
return USBH_OK;
}
else
{
if (status == USBH_STALL || status == USBH_NOT_SUPPORTED) {
dbg_printf(DBGMODE_ERR, "USBPT Setup Stalled \r\n");
USBD_CtlError(pcore , req);
return USBH_OK;
}
}
return USBD_OK;
}
dbg_printf(DBGMODE_ERR, "USBPT Setup Unhandled Error \r\n");
USBD_CtlError(pcore , req);
return USBD_OK;
}
