/**
* @brief USBH_CDC_ClassRequest
* The function is responsible for handling Standard requests
* for CDC class.
* @param phost: Host handle
* @retval USBH Status
*/
static USBH_StatusTypeDef USBH_CDC_ClassRequest (USBH_HandleTypeDef *phost)
{
USBH_StatusTypeDef status = USBH_FAIL ;
CDC_HandleTypeDef *CDC_Handle = (CDC_HandleTypeDef*) phost->pActiveClass->pData;
/*Issue the get line coding request*/
status = GetLineCoding(phost, &CDC_Handle->LineCoding);
if(status == USBH_OK)
{
phost->pUser(phost, HOST_USER_CLASS_ACTIVE);
}
return status;
}
//*****************************************************************************
//
// Handles CDC driver notifications related to control and setup of the device.
//
// \param pvCBData is the client-supplied callback pointer for this channel.
// \param ui32Event identifies the event we are being notified about.
// \param ui32MsgValue is an event-specific value.
// \param pvMsgData is an event-specific pointer.
//
// This function is called by the CDC driver to perform control-related
// operations on behalf of the USB host. These functions include setting
// and querying the serial communication parameters, setting handshake line
// states and sending break conditions.
//
// \return The return value is event-specific.
//
//*****************************************************************************
uint32_t
ControlHandler(void *pvCBData, uint32_t ui32Event,
uint32_t ui32MsgValue, void *pvMsgData)
{
uint32_t ui32IntsOff;
//
// Which event are we being asked to process?
//
switch(ui32Event)
{
//
// We are connected to a host and communication is now possible.
//
case USB_EVENT_CONNECTED:
g_bUSBConfigured = true;
//
// Flush our buffers.
//
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);
//
// Tell the main loop to update the display.
//
ui32IntsOff = ROM_IntMasterDisable();
g_pcStatus = "Connected";
g_ui32Flags |= COMMAND_STATUS_UPDATE;
if(!ui32IntsOff)
{
ROM_IntMasterEnable();
}
break;
//
// The host has disconnected.
//
case USB_EVENT_DISCONNECTED:
g_bUSBConfigured = false;
ui32IntsOff = ROM_IntMasterDisable();
g_pcStatus = "Disconnected";
g_ui32Flags |= COMMAND_STATUS_UPDATE;
if(!ui32IntsOff)
{
ROM_IntMasterEnable();
}
break;
//
// Return the current serial communication parameters.
//
case USBD_CDC_EVENT_GET_LINE_CODING:
GetLineCoding(pvMsgData);
break;
//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_LINE_CODING:
SetLineCoding(pvMsgData);
break;
//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE:
SetControlLineState((uint16_t)ui32MsgValue);
break;
//
// Send a break condition on the serial line.
//
case USBD_CDC_EVENT_SEND_BREAK:
SendBreak(true);
break;
//
// Clear the break condition on the serial line.
//
case USBD_CDC_EVENT_CLEAR_BREAK:
SendBreak(false);
break;
//
// Ignore SUSPEND and RESUME for now.
//
case USB_EVENT_SUSPEND:
case USB_EVENT_RESUME:
break;
//
// We don't expect to receive any other events. Ignore any that show
// up in a release build or hang in a debug build.
//
default:
#ifdef DEBUG
while(1);
#else
break;
#endif
}
return(0);
}
/**
* @brief USBH_CDC_Process
* The function is for managing state machine for CDC data transfers
* @param phost: Host handle
* @retval USBH Status
*/
static USBH_StatusTypeDef USBH_CDC_Process (USBH_HandleTypeDef *phost)
{
USBH_StatusTypeDef status = USBH_BUSY;
USBH_StatusTypeDef req_status = USBH_OK;
CDC_HandleTypeDef *CDC_Handle = (CDC_HandleTypeDef*) phost->pActiveClass->pData;
switch(CDC_Handle->state)
{
case CDC_IDLE_STATE:
status = USBH_OK;
break;
case CDC_SET_LINE_CODING_STATE:
req_status = SetLineCoding(phost, CDC_Handle->pUserLineCoding);
if(req_status == USBH_OK)
{
CDC_Handle->state = CDC_GET_LAST_LINE_CODING_STATE;
}
else if(req_status != USBH_BUSY)
{
CDC_Handle->state = CDC_ERROR_STATE;
}
break;
case CDC_GET_LAST_LINE_CODING_STATE:
req_status = GetLineCoding(phost, &(CDC_Handle->LineCoding));
if(req_status == USBH_OK)
{
CDC_Handle->state = CDC_IDLE_STATE;
if((CDC_Handle->LineCoding.b.bCharFormat == CDC_Handle->pUserLineCoding->b.bCharFormat) &&
(CDC_Handle->LineCoding.b.bDataBits == CDC_Handle->pUserLineCoding->b.bDataBits) &&
(CDC_Handle->LineCoding.b.bParityType == CDC_Handle->pUserLineCoding->b.bParityType) &&
(CDC_Handle->LineCoding.b.dwDTERate == CDC_Handle->pUserLineCoding->b.dwDTERate))
{
USBH_CDC_LineCodingChanged(phost);
}
}
else if(req_status != USBH_BUSY)
{
CDC_Handle->state = CDC_ERROR_STATE;
}
break;
case CDC_TRANSFER_DATA:
CDC_ProcessTransmission(phost);
CDC_ProcessReception(phost);
break;
case CDC_ERROR_STATE:
req_status = USBH_ClrFeature(phost, 0x00);
if(req_status == USBH_OK )
{
/*Change the state to waiting*/
CDC_Handle->state = CDC_IDLE_STATE ;
}
break;
default:
break;
}
return status;
}
//*****************************************************************************
//
// Handles CDC driver notifications related to control and setup of the device.
//
// \param pvCBData is the client-supplied callback pointer for this channel.
// \param ulEvent identifies the event we are being notified about.
// \param ulMsgValue is an event-specific value.
// \param pvMsgData is an event-specific pointer.
//
// This function is called by the CDC driver to perform control-related
// operations on behalf of the USB host. These functions include setting
// and querying the serial communication parameters, setting handshake line
// states and sending break conditions.
//
// \return The return value is event-specific.
//
//*****************************************************************************
uint32_t
ControlHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue,
void *pvMsgData)
{
//
// Which event are we being asked to process?
//
switch(ui32Event)
{
//
// We are connected to a host and communication is now possible.
//
case USB_EVENT_CONNECTED:
{
//
// Now connected and ready for normal operation.
//
HWREGBITW(&g_ui32Flags, FLAG_USB_CONFIGURED) = 1;
//
// Flush our buffers.
//
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);
//
// Tell the main loop to update the display.
//
g_pcStatus = "Host connected.";
//
// Set the command status update flag.
//
HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE) = 1;
break;
}
//
// The host has disconnected.
//
case USB_EVENT_DISCONNECTED:
{
//
// No longer connected.
//
HWREGBITW(&g_ui32Flags, FLAG_USB_CONFIGURED) = 0;
g_pcStatus = "Host disconnected.";
//
// Set the command status update flag.
//
HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE) = 1;
break;
}
//
// Return the current serial communication parameters.
//
case USBD_CDC_EVENT_GET_LINE_CODING:
{
GetLineCoding(pvMsgData, UART_CLOCK);
break;
}
//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_LINE_CODING:
{
SetLineCoding(pvMsgData, UART_CLOCK);
break;
}
//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE:
{
SetControlLineState((uint16_t)ui32MsgValue);
break;
}
//
// Send a break condition on the serial line.
//
case USBD_CDC_EVENT_SEND_BREAK:
{
SendBreak(true);
break;
}
//
// Clear the break condition on the serial line.
//
case USBD_CDC_EVENT_CLEAR_BREAK:
{
SendBreak(false);
break;
}
//
// Ignore SUSPEND and RESUME for now.
//
case USB_EVENT_SUSPEND:
case USB_EVENT_RESUME:
{
break;
}
//
// We don't expect to receive any other events. Ignore any that show
// up in a release build or hang in a debug build.
//
default:
{
#ifdef DEBUG
while(1);
#else
break;
#endif
}
}
return(0);
}
//*****************************************************************************
//
// Handles CDC driver notifications related to control and setup of the device.
//
// \param pvCBData is the client-supplied callback pointer for this channel.
// \param ulEvent identifies the notification event.
// \param ulMsgValue is an event-specific value.
// \param pvMsgData is an event-specific pointer.
//
// This function is called by the CDC driver to perform control-related
// operations on behalf of the USB host. These functions include setting
// and querying the serial communication parameters, setting handshake line
// states and sending break conditions.
//
// \return The return value is event-specific.
//
//*****************************************************************************
unsigned long
ControlHandler(void *pvCBData, unsigned long ulEvent, unsigned long ulMsgValue,
void *pvMsgData)
{
//
// Which event was sent?
//
switch(ulEvent)
{
//
// The host has connected.
//
case USB_EVENT_CONNECTED:
{
//
// Turn on the user LED.
//
GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, GPIO_PIN_0);
//
// Flush the buffers.
//
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);
break;
}
//
// The host has disconnected.
//
case USB_EVENT_DISCONNECTED:
{
//
// Turn off the user LED.
//
GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, 0);
break;
}
//
// Return the current serial communication parameters.
//
case USBD_CDC_EVENT_GET_LINE_CODING:
{
GetLineCoding(pvMsgData);
break;
}
//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_LINE_CODING:
{
SetLineCoding(pvMsgData);
break;
}
//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE:
{
break;
}
//
// Send a break condition on the serial line.
//
case USBD_CDC_EVENT_SEND_BREAK:
{
SendBreak(true);
break;
}
//
// Clear the break condition on the serial line.
//
case USBD_CDC_EVENT_CLEAR_BREAK:
{
SendBreak(false);
break;
}
//
// Ignore SUSPEND and RESUME for now.
//
case USB_EVENT_SUSPEND:
case USB_EVENT_RESUME:
{
break;
}
//
// Other events can be safely ignored.
//
default:
{
break;
}
}
return(0);
}
//*****************************************************************************
//
// Handles CDC driver notifications related to control and setup of the device.
//
// \param pvCBData is the client-supplied callback pointer for this channel.
// \param ulEvent identifies the notification event.
// \param ulMsgValue is an event-specific value.
// \param pvMsgData is an event-specific pointer.
//
// This function is called by the CDC driver to perform control-related
// operations on behalf of the USB host. These functions include setting
// and querying the serial communication parameters, setting handshake line
// states and sending break conditions.
//
// \return The return value is event-specific.
//
//*****************************************************************************
static unsigned long
ControlHandler(void *pvCBData, unsigned long ulEvent, unsigned long ulMsgValue,
void *pvMsgData)
{
//
// Which event was sent?
//
switch(ulEvent)
{
//
// The host has connected.
//
case USB_EVENT_CONNECTED:
{
//
// Indicate that the USB is connected.
//
g_bUSBConnected = true;
//
// Flush the buffers.
//
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);
break;
}
//
// The host has disconnected.
//
case USB_EVENT_DISCONNECTED:
{
//
// If USB is currently being used to play the game, then halt the
// Z-machine interpreter.
//
if(g_ulGameIF == GAME_IF_USB)
{
halt = 1;
}
//
// Indicate that the USB is no longer connected.
//
g_bUSBConnected = false;
break;
}
//
// Return the current serial communication parameters.
//
case USBD_CDC_EVENT_GET_LINE_CODING:
{
GetLineCoding(pvMsgData);
break;
}
//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_LINE_CODING:
{
break;
}
//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE:
{
break;
}
//
// Send a break condition on the serial line.
//
case USBD_CDC_EVENT_SEND_BREAK:
{
break;
}
//
// Clear the break condition on the serial line.
//
case USBD_CDC_EVENT_CLEAR_BREAK:
{
break;
}
//
// Ignore SUSPEND and RESUME for now.
//
case USB_EVENT_SUSPEND:
case USB_EVENT_RESUME:
{
break;
}
//
// Other events can be safely ignored.
//
default:
{
break;
}
}
return(0);
}
//*****************************************************************************
//
// Handles CDC driver notifications related to control and setup of the device.
//
// \param pvCBData is the client-supplied callback pointer for this channel.
// \param ulEvent identifies the event we are being notified about.
// \param ulMsgValue is an event-specific value.
// \param pvMsgData is an event-specific pointer.
//
// This function is called by the CDC driver to perform control-related
// operations on behalf of the USB host. These functions include setting
// and querying the serial communication parameters, setting handshake line
// states and sending break conditions.
//
// \return The return value is event-specific.
//
//*****************************************************************************
unsigned long
ControlHandler(void *pvCBData, unsigned long ulEvent,
unsigned long ulMsgValue, void *pvMsgData)
{
//
// Which event are we being asked to process?
//
switch(ulEvent)
{
//
// We are connected to a host and communication is now possible.
//
case USB_EVENT_CONNECTED:
{
g_bUSBDevConnected = true;
//
// Flush our buffers.
//
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);
break;
}
//
// The host has disconnected.
//
case USB_EVENT_DISCONNECTED:
{
g_bUSBDevConnected = false;
break;
}
//
// Return the current serial communication parameters.
//
case USBD_CDC_EVENT_GET_LINE_CODING:
{
GetLineCoding(pvMsgData);
break;
}
//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_LINE_CODING:
{
SetLineCoding(pvMsgData);
break;
}
//
// The following line control events can be ignored because there is
// no physical serial port to manage.
//
case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE:
case USBD_CDC_EVENT_SEND_BREAK:
case USBD_CDC_EVENT_CLEAR_BREAK:
{
break;
}
//
// Ignore SUSPEND and RESUME for now.
//
case USB_EVENT_SUSPEND:
case USB_EVENT_RESUME:
{
break;
}
//
// An unknown event occurred.
//
default:
{
break;
}
}
//
// Return control to USB stack
//
return(0);
}
unsigned long
USB_ControlHandler(void *pvCBData, unsigned long ulEvent,
unsigned long ulMsgValue, void *pvMsgData)
{
//
// Which event are we being asked to process?
//
switch(ulEvent)
{
//
// We are connected to a host and communication is now possible.
//
case USB_EVENT_CONNECTED:
g_bUSBConfigured = true;
// Flush our buffers.
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);
#ifdef __DEBUG__
UARTprintf("\nUSB Connected");
#ifdef __DEBUG_TRACEBACK__
UARTprintf(" File: %s Line: %d", __FILE__,__LINE__);
#endif
#endif
break;
//
// The host has disconnected.
//
case USB_EVENT_DISCONNECTED:
g_bUSBConfigured = false;
#ifdef __DEBUG__
UARTprintf("\nUSB Disconnected");
#ifdef __DEBUG_TRACEBACK__
UARTprintf(" File: %s Line: %d", __FILE__,__LINE__);
#endif
#endif
break;
//
// Return the current serial communication parameters.
//
case USBD_CDC_EVENT_GET_LINE_CODING:
GetLineCoding(pvMsgData);
break;
case USBD_CDC_EVENT_SET_LINE_CODING:
break;
case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE:
break;
case USBD_CDC_EVENT_SEND_BREAK:
break;
case USBD_CDC_EVENT_CLEAR_BREAK:
break;
case USB_EVENT_SUSPEND:
break;
case USB_EVENT_RESUME:
break;
default:
#ifdef DEBUG
#else
break;
#endif
}
return(0);
}
/******************************************************************************
* *
* \brief Handles CDC driver notifications related to control and setup of *
* the device.\n *
* *
* \param pvCBData is the client-supplied callback pointer for this channel. *
* *
* \param ulEvent identifies the event we are being notified about. *
* *
* \param ulMsgValue is an event-specific value. *
* *
* \param pvMsgData is an event-specific pointer. *
* *
* \return The return value is event-specific. *
* *
******************************************************************************/
unsigned int ControlHandler(void *pvCBData, unsigned int ulEvent,
unsigned int ulMsgValue, void *pvMsgData)
{
unsigned char ulIntsOff;
/* Which event are we being asked to process? */
switch(ulEvent)
{
/* We are connected to a host and communication is now possible. */
case USB_EVENT_CONNECTED:
/* Flush our buffers. */
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);
ulIntsOff = IntDisable();
g_pcStatus = "Host connected.";
g_ulFlags |= COMMAND_STATUS_UPDATE;
IntEnable(ulIntsOff);
break;
/* The host has disconnected. */
case USB_EVENT_DISCONNECTED:
ulIntsOff = IntDisable();
g_pcStatus = "Host disconnected.";
g_ulFlags |= COMMAND_STATUS_UPDATE;
IntEnable(ulIntsOff);
break;
/* Return the current serial communication parameters. */
case USBD_CDC_EVENT_GET_LINE_CODING:
GetLineCoding(pvMsgData);
break;
/* Set the current serial communication parameters. */
case USBD_CDC_EVENT_SET_LINE_CODING:
SetLineCoding(pvMsgData);
break;
/* Set the current serial communication parameters. */
case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE:
SetControlLineState((unsigned short)ulMsgValue);
break;
/* Send a break condition on the serial line.*/
case USBD_CDC_EVENT_SEND_BREAK:
SendBreak(true);
break;
/* Clear the break condition on the serial line. */
case USBD_CDC_EVENT_CLEAR_BREAK:
SendBreak(false);
break;
/* Ignore SUSPEND and RESUME for now. */
case USB_EVENT_SUSPEND:
case USB_EVENT_RESUME:
break;
/* We don't expect to receive any other events. Ignore any that show
up in a release build or hang in a debug build.
*/
default:
break;
}
return(0);
}
