/* RX handler for USB bulk device */
unsigned int USBBulkRxHandler(void *pvCBData, unsigned int ulEvent,
unsigned int ulMsgValue, void *pvMsgData)
{
switch (ulEvent)
{
case USB_EVENT_CONNECTED:
/* Now connected so flush the stale buffers */
USBBufferFlush(&g_sTxBulkBuffer);
USBBufferFlush(&g_sRxBulkBuffer);
USBConfigured = 1;
break;
case USB_EVENT_DISCONNECTED:
/* Now disconnected - since the device is bus powered this shouldn't happen except for a reset */
USBConfigured = 0;
break;
case USB_EVENT_RX_AVAILABLE:
/* Data available - read it at the next available opportunity */
USBDataAvail = 1;
break;
case USB_EVENT_SUSPEND:
case USB_EVENT_RESUME:
// ignore suspend and resume
break;
default:
// ignore all other events
break;
}
return 0;
}
/************************************************************************************//**
** \brief Handles bulk driver notifications related to the receive channel (data from
** the USB host).
** \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.
** \return The return value is event-specific.
**
****************************************************************************************/
uint32_t UsbBulkRxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue, void *pvMsgData)
{
/* which event are we being sent? */
switch(ui32Event)
{
/* we are connected to a host and communication is now possible */
case USB_EVENT_CONNECTED:
{
/* flush our buffers */
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);
break;
}
/* the host has disconnected */
case USB_EVENT_DISCONNECTED:
{
break;
}
/* a new packet has been received */
case USB_EVENT_RX_AVAILABLE:
{
/* handle all newly received bytes */
UsbReceivePipeBulkOUT(pvMsgData, ui32MsgValue);
return ui32MsgValue;
}
/* ignore SUSPEND and RESUME for now */
case USB_EVENT_SUSPEND:
/* power-off system clocks and power */
UsbEnterLowPowerModeHook();
break;
case USB_EVENT_RESUME:
/* restore power and system clocks */
UsbLeaveLowPowerModeHook();
break;
/* ignore all other events and return 0 */
default:
break;
}
return 0;
} /*** end of UsbBulkRxHandler ***/
/*
* ======== cbSerialHandler ========
* Callback handler for the USB stack.
*
* Callback handler call by the USB stack to notify us on what has happened in
* regards to the keyboard.
*
* @param(cbData) A callback pointer provided by the client.
*
* @param(event) Identifies the event that occurred in regards to
* this device.
*
* @param(eventMsgData) A data value associated with a particular event.
*
* @param(eventMsgPtr) A data pointer associated with a particular event.
*
*/
static USBCDCD_LoggerIdleEventType cbSerialHandler(void *cbData, USBCDCD_LoggerIdleEventType event,
USBCDCD_LoggerIdleEventType eventMsg,
void *eventMsgPtr)
{
tLineCoding *psLineCoding;
/* Determine what event has happened */
switch (event) {
case USB_EVENT_CONNECTED:
state = USBCDCD_STATE_IDLE;
USBBufferFlush(&txBuffer);
break;
case USB_EVENT_DISCONNECTED:
state = USBCDCD_STATE_UNCONFIGURED;
break;
case USBD_CDC_EVENT_GET_LINE_CODING:
/* Create a pointer to the line coding information. */
psLineCoding = (tLineCoding *)eventMsgPtr;
/* Copy the current line coding information into the structure. */
*(psLineCoding) = g_sLineCoding;
break;
case USBD_CDC_EVENT_SET_LINE_CODING:
/* Create a pointer to the line coding information. */
psLineCoding = (tLineCoding *)eventMsgPtr;
/*
* Copy the line coding information into the current line coding
* structure.
*/
g_sLineCoding = *(psLineCoding);
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:
break;
}
return (0);
}
/******************************************************************************
* *
* \brief Generic event handler for the composite device.\n *
* *
* \param pvCBData : Is the event callback pointer provided during *
* USBDCompositeInit *
* *
* \param ulEvent : Identifies the event we are being called back for. *
* *
* \param ulMsgValue : Is an event-specific value. *
* *
* \param pvMsgData : Is an event-specific pointer. *
* *
* \return The return value is event-specific. *
* *
******************************************************************************/
unsigned int
EventHandler(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;
default:
break;
}
return(0);
}
/* Control handler for CDC device */
unsigned int USBCDCControlHandler(void *pvCBData, unsigned int ulEvent,
unsigned int 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:
/* Flush our buffers. */
USBBufferFlush(&g_sRxCDCBuffer);
USBBufferFlush(&g_sTxCDCBuffer);
break;
/* The host has disconnected. */
case USB_EVENT_DISCONNECTED:
break;
default:
break;
}
return 0;
}
void USB_resetPacketAssembler(void){
g_ucReadMode = WAITING;
g_ulCharIndex = 0;
g_ulParamIndex = 0;
g_ulReceiveMode = REC_MODE_NORMAL;
#ifdef __DEBUG__
UARTprintf("\nTx Buffer Space Available = %d",USBBufferSpaceAvailable((tUSBBuffer *)&g_sTxBuffer));
UARTprintf("\nRx Buffer Space Available = %d",USBBufferSpaceAvailable((tUSBBuffer *)&g_sRxBuffer));
UARTprintf("\nCLEARING USB BUFFERS...");
#endif
USBBufferFlush((tUSBBuffer *)&g_sTxBuffer);
USBBufferFlush((tUSBBuffer *)&g_sRxBuffer);
#ifdef __DEBUG__
UARTprintf("\nTx Buffer Space Available = %d",USBBufferSpaceAvailable((tUSBBuffer *)&g_sTxBuffer));
UARTprintf("\nRx Buffer Space Available = %d",USBBufferSpaceAvailable((tUSBBuffer *)&g_sRxBuffer));
#endif
}
//*****************************************************************************
//
// 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 bulk driver notifications related to the receive channel (data from
// the USB host).
//
// \param pvCBData is the client-supplied callback pointer for this channel.
// \param ulEvent identifies the event that has been sent.
// \param ulMsgValue is an event-specific value.
// \param pvMsgData is an event-specific pointer.
//
// This function is called by the bulk driver to notify us of any events
// related to operation of the receive data channel (the OUT channel carrying
// data from the USB host).
//
// \return The return value is event-specific.
//
//*****************************************************************************
unsigned long
RxHandler(void *pvCBData, unsigned long ulEvent, unsigned long ulMsgValue,
void *pvMsgData)
{
//
// Which event was sent?
//
switch(ulEvent)
{
//
// The host has connected.
//
case USB_EVENT_CONNECTED:
{
g_bUSBConfigured = true;
UARTprintf("Host connected.\n");
//
// Flush our buffers.
//
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);
break;
}
//
// The host has disconnected.
//
case USB_EVENT_DISCONNECTED:
{
g_bUSBConfigured = false;
UARTprintf("Host disconnected.\n");
break;
}
//
// A new packet has been received.
//
case USB_EVENT_RX_AVAILABLE:
{
tUSBDBulkDevice *psDevice;
//
// Get a pointer to our instance data from the callback data
// parameter.
//
psDevice = (tUSBDBulkDevice *)pvCBData;
//
// Read the new packet and echo it back to the host.
//
return(EchoNewDataToHost(psDevice, pvMsgData, ulMsgValue));
}
//
// Ignore SUSPEND and RESUME for now.
//
case USB_EVENT_SUSPEND:
case USB_EVENT_RESUME:
{
break;
}
//
// Ignore all other events and return 0.
//
default:
{
break;
}
}
return(0);
}
//*****************************************************************************
//
// Handles bulk driver notifications related to the receive channel (data from
// the USB host).
//
// \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 bulk driver to notify us of any events
// related to operation of the receive data channel (the OUT channel carrying
// data from the USB host).
//
// \return The return value is event-specific.
//
//*****************************************************************************
uint32_t
RxHandler(void *pvCBData, uint32_t ui32Event,
uint32_t ui32MsgValue, void *pvMsgData)
{
//
// Which event are we being sent?
//
switch(ui32Event)
{
//
// We are connected to a host and communication is now possible.
//
case USB_EVENT_CONNECTED:
{
g_bUSBConfigured = true;
UARTprintf("Host connected.\n");
//
// Flush our buffers.
//
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);
isUSB_ready=1;
break;
}
//
// The host has disconnected.
//
case USB_EVENT_DISCONNECTED:
{
g_bUSBConfigured = false;
UARTprintf("Host disconnected.\n");
break;
}
//
// A new packet has been received.
//
case USB_EVENT_RX_AVAILABLE:
{
//
// Get a pointer to our instance data from the callback data
// parameter.
//
//UARTprintf("pvCBData %p\n",pvCBData);
//UARTprintf("message value %d\n",ui32MsgValue);
memcpy(myInBuffer,pvMsgData,ui32MsgValue);
readBytes=ui32MsgValue;
rxReady=1;
//
// Read the new packet and echo it back to the host.
//
return ui32MsgValue;
}
//
// Ignore SUSPEND and RESUME for now.
//
case USB_EVENT_SUSPEND:
case USB_EVENT_RESUME:
{
break;
}
//
// Ignore all other events and return 0.
//
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
SerialHandler(void *pvCBData, unsigned long ulEvent, unsigned long ulMsgValue,
void *pvMsgData)
{
tLineCoding *psLineCoding;
//
// 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);
//
// Turn on the user LED.
//
LEDOn();
break;
}
case USB_EVENT_DISCONNECTED:
{
//
// Turn off the user LED.
//
LEDOff();
break;
}
//
// Return the current serial communication parameters.
//
case USBD_CDC_EVENT_GET_LINE_CODING:
{
//
// Create a pointer to the line coding information.
//
psLineCoding = (tLineCoding *)pvMsgData;
//
// Copy the current line coding information into the structure.
//
psLineCoding->ulRate = g_sLineCoding.ulRate;
psLineCoding->ucStop = g_sLineCoding.ucStop;
psLineCoding->ucParity = g_sLineCoding.ucParity;
psLineCoding->ucDatabits = g_sLineCoding.ucDatabits;
break;
}
//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_LINE_CODING:
{
//
// Create a pointer to the line coding information.
//
psLineCoding = (tLineCoding *)pvMsgData;
//
// Copy the line coding information into the current line coding
// structure.
//
g_sLineCoding.ulRate = psLineCoding->ulRate;
g_sLineCoding.ucStop = psLineCoding->ucStop;
g_sLineCoding.ucParity = psLineCoding->ucParity;
g_sLineCoding.ucDatabits = psLineCoding->ucDatabits;
break;
}
//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE:
{
break;
}
//
// All other events are 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);
}
//*****************************************************************************
//
// 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);
}
//*****************************************************************************
//
// Handles bulk driver notifications related to the receive channel (data from
// the USB host).
//
// \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 bulk driver to notify us of any events
// related to operation of the receive data channel (the OUT channel carrying
// data from the USB host).
//
// \return The return value is event-specific.
//
//*****************************************************************************
uint32_t
RxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue,
void *pvMsgData)
{
//
// Which event are we being sent?
//
switch(ui32Event)
{
//
// We are connected to a host and communication is now possible.
//
case USB_EVENT_CONNECTED:
{
g_bUSBConfigured = true;
g_pcStatus = "Host connected.";
g_ui32Flags |= COMMAND_STATUS_UPDATE;
//
// Flush our buffers.
//
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);
break;
}
//
// The host has disconnected.
//
case USB_EVENT_DISCONNECTED:
{
g_bUSBConfigured = false;
g_pcStatus = "Host disconn.";
g_ui32Flags |= COMMAND_STATUS_UPDATE;
break;
}
//
// A new packet has been received.
//
case USB_EVENT_RX_AVAILABLE:
{
tUSBDBulkDevice *psDevice;
//
// Get a pointer to our instance data from the callback data
// parameter.
//
psDevice = (tUSBDBulkDevice *)pvCBData;
//
// Read the new packet and echo it back to the host.
//
return(EchoNewDataToHost(psDevice, pvMsgData, ui32MsgValue));
}
//
// Ignore SUSPEND and RESUME for now.
//
case USB_EVENT_SUSPEND:
case USB_EVENT_RESUME:
break;
//
// Ignore all other events and return 0.
//
default:
break;
}
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);
}
