void
USBUARTIntHandler(void)
{
unsigned int ulInts;
int lErrors;
//
// Get and clear the current interrupt source(s)
//
ulInts = UARTIntIdentityGet(SOC_UART_0_REGS);
/* Check if the cause is receiver line error condition.*/
if( UART_INTID_RX_LINE_STAT_ERROR == ulInts || UART_INTID_CHAR_TIMEOUT == ulInts)
{
UARTHandleError();
}
//
// Are we being interrupted because the TX FIFO has space available?
//
if(ulInts == UART_INTID_TX_THRES_REACH)
{
//
// Move as many bytes as we can into the transmit FIFO.
//
USBUARTPrimeTransmit(USB_UART_BASE);
//
// If the output buffer is empty, turn off the transmit interrupt.
//
if(!USBBufferDataAvailable(&g_sRxBuffer))
{
UARTIntDisable(USB_UART_BASE, UART_INTID_TX_THRES_REACH);
}
}
//
// Handle receive interrupts.
//
if(ulInts == UART_INTID_RX_THRES_REACH)
{
//
// Read the UART's characters into the buffer.
//
lErrors = ReadUARTData();
//
// Check to see if we need to notify the host of any errors we just
// detected.
//
CheckForSerialStateChange(&g_sCDCDevice, lErrors);
}
}
/******************************************************************************
* *
* \brief Handles CDC driver notifications related to the receive channel *
* (data from the USB host). *
* *
* This function is called by the CDC driver to notify us of any events *
* related to operation of the receive data channel (the OUT channel *
* carrying data from the USB host) *
* *
* \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 RxHandler(void *pvCBData, unsigned int ulEvent,
unsigned int ulMsgValue, void *pvMsgData)
{
/* Which event are we being sent? */
switch(ulEvent)
{
/* A new packet has been received. */
case USB_EVENT_RX_AVAILABLE:
{
/* Feed some characters into the UART TX FIFO and enable the
interrupt so we are told when there is more space.
*/
USBUARTPrimeTransmit(USB_UART_BASE);
UARTIntEnable(USB_UART_BASE, UART_INTID_TX_THRES_REACH);
break;
}
/* We are being asked how much unprocessed data we have still to
process. We return 0 if the UART is currently idle or 1 if it is
in the process of transmitting something. The actual number of
bytes in the UART FIFO is not important here, merely whether or
not everything previously sent to us has been transmitted.
*/
case USB_EVENT_DATA_REMAINING:
{
return(0);
}
/*
We are being asked to provide a buffer into which the next packet
can be read. We do not support this mode of receiving data so let
the driver know by returning 0. The CDC driver should not be sending
this message but this is included just for illustration and
completeness.
*/
case USB_EVENT_REQUEST_BUFFER:
{
return(0);
}
/*
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);
}
//*****************************************************************************
//
// Interrupt handler for the UART which we are redirecting via USB.
//
//*****************************************************************************
void
USBUARTIntHandler(void)
{
uint32_t ui32Ints;
int32_t i32Errors;
//
// Get and clear the current interrupt source(s)
//
ui32Ints = ROM_UARTIntStatus(USB_UART_BASE, true);
ROM_UARTIntClear(USB_UART_BASE, ui32Ints);
//
// Are we being interrupted because the TX FIFO has space available?
//
if(ui32Ints & UART_INT_TX)
{
//
// Move as many bytes as we can into the transmit FIFO.
//
USBUARTPrimeTransmit(USB_UART_BASE);
//
// If the output buffer is empty, turn off the transmit interrupt.
//
if(!USBBufferDataAvailable(&g_sRxBuffer))
{
ROM_UARTIntDisable(USB_UART_BASE, UART_INT_TX);
}
}
//
// Handle receive interrupts.
//
// gjs if(ui32Ints & (UART_INT_RX))
if(ui32Ints & (UART_INT_RX | UART_INT_RT))
{
//
// Read the UART's characters into the buffer.
//
i32Errors = ReadUARTData();
//
// Check to see if we need to notify the host of any errors we just
// detected.
//
CheckForSerialStateChange(&g_sCDCDevice, i32Errors);
}
}
//*****************************************************************************
//
// Interrupt handler for the UART which is being redirected via USB.
//
//*****************************************************************************
void
USBUARTIntHandler(void)
{
unsigned long ulInts;
long lErrors;
//
// Get and clear the current interrupt source(s)
//
ulInts = ROM_UARTIntStatus(UART0_BASE, true);
ROM_UARTIntClear(UART0_BASE, ulInts);
//
// Handle transmit interrupts.
//
if(ulInts & UART_INT_TX)
{
//
// Move as many bytes as possible into the transmit FIFO.
//
USBUARTPrimeTransmit();
//
// If the output buffer is empty, turn off the transmit interrupt.
//
if(!USBBufferDataAvailable(&g_sRxBuffer))
{
ROM_UARTIntDisable(UART0_BASE, UART_INT_TX);
}
}
//
// Handle receive interrupts.
//
if(ulInts & (UART_INT_RX | UART_INT_RT))
{
//
// Read the UART's characters into the buffer.
//
lErrors = ReadUARTData();
//
// Check to see if the host needs to be notified of any errors just
// detected.
//
CheckForSerialStateChange(&g_sCDCDevice, lErrors);
}
}
//*****************************************************************************
//
// Handles CDC driver notifications related to the receive channel (data from
// the USB host).
//
// \param pvCBData is the client-supplied callback data value 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 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)
{
uint32_t ui32Count;
//
// Which event are we being sent?
//
switch(ui32Event)
{
//
// A new packet has been received.
//
case USB_EVENT_RX_AVAILABLE:
{
//
// Feed some characters into the UART TX FIFO and enable the
// interrupt so we are told when there is more space.
//
USBUARTPrimeTransmit(USB_UART_BASE);
ROM_UARTIntEnable(USB_UART_BASE, UART_INT_TX);
break;
}
//
// We are being asked how much unprocessed data we have still to
// process. We return 0 if the UART is currently idle or 1 if it is
// in the process of transmitting something. The actual number of
// bytes in the UART FIFO is not important here, merely whether or
// not everything previously sent to us has been transmitted.
//
case USB_EVENT_DATA_REMAINING:
{
//
// Get the number of bytes in the buffer and add 1 if some data
// still has to clear the transmitter.
//
ui32Count = ROM_UARTBusy(USB_UART_BASE) ? 1 : 0;
return(ui32Count);
}
//
// We are being asked to provide a buffer into which the next packet
// can be read. We do not support this mode of receiving data so let
// the driver know by returning 0. The CDC driver should not be sending
// this message but this is included just for illustration and
// completeness.
//
case USB_EVENT_REQUEST_BUFFER:
{
return(0);
}
//
// 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 the receive channel (data from
// the USB host).
//
// \param ulCBData is the client-supplied callback data value 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 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)
{
unsigned long ulCount;
//
// Which event was sent?
//
switch(ulEvent)
{
//
// A new packet has been received.
//
case USB_EVENT_RX_AVAILABLE:
{
//
// Feed some characters into the UART TX FIFO and enable the
// interrupt.
//
USBUARTPrimeTransmit();
ROM_UARTIntEnable(UART0_BASE, UART_INT_TX);
break;
}
//
// This is a request for how much unprocessed data is still waiting to
// be processed. Return 0 if the UART is currently idle or 1 if it is
// in the process of transmitting something. The actual number of
// bytes in the UART FIFO is not important here, merely whether or
// not everything previously sent to us has been transmitted.
//
case USB_EVENT_DATA_REMAINING:
{
//
// Get the number of bytes in the buffer and add 1 if some data
// still has to clear the transmitter.
//
ulCount = UARTBusy(UART0_BASE) ? 1 : 0;
return(ulCount);
}
//
// This is a request for a buffer into which the next packet can be
// read. This mode of receiving data is not supported so let the
// driver know by returning 0. The CDC driver should not be sending
// this message but this is included just for illustration and
// completeness.
//
case USB_EVENT_REQUEST_BUFFER:
{
return(0);
}
//
// Other events can be safely ignored.
//
default:
{
break;
}
}
return(0);
}
