void LPC22XX_USART_Driver::TxBufferEmptyInterruptEnable( int ComPortNum, BOOL Enable )
{
GLOBAL_LOCK(irq);
LPC22XX_USART& USARTC = LPC22XX::UART(ComPortNum);
ASSERT(LPC22XX_USART_Driver::IsValidPortNum(ComPortNum));
if (Enable)
{
USARTC.SEL2.IER.UART_IER |= (LPC22XX_USART::UART_IER_THREIE);
char c;
for (int i=0; i<2; i++)
{
if (USART_RemoveCharFromTxBuffer( ComPortNum, c ))
{
WriteCharToTxBuffer( ComPortNum, c );
Events_Set( SYSTEM_EVENT_FLAG_COM_OUT );
}
else
break;
}
}
else
{
USARTC.SEL2.IER.UART_IER &= ~(LPC22XX_USART::UART_IER_THREIE);
}
}
void LPC22XX_USART_Driver::UART_IntHandler (void *param)
{
GLOBAL_LOCK(irq);
ASSERT(LPC22XX_USART_Driver::IsValidPortNum((UINT32)param));
char c;
UINT32 ComNum = (UINT32)param;
UINT32 i,rxcnt;
LPC22XX_USART& USARTC = LPC22XX::UART(ComNum);
volatile UINT32 IIR_Value;
volatile UINT32 LSR_Value;
// Read data from Rx FIFO
LSR_Value = USARTC.UART_LSR;
while (LSR_Value & LPC22XX_USART::UART_LSR_RFDR)
{
UINT8 rxdata = (UINT8 )USARTC.SEL1.RBR.UART_RBR;
rxcnt++;
if ( 0 == (LSR_Value &
(
LPC22XX_USART::UART_LSR_PEI |
LPC22XX_USART::UART_LSR_OEI |
LPC22XX_USART::UART_LSR_FEI
)
)
)
{
// No errors in Rx data
USART_AddCharToRxBuffer(ComNum, rxdata);
Events_Set( SYSTEM_EVENT_FLAG_COM_IN );
}
LSR_Value = USARTC.UART_LSR;
}
// Send up to 2 bytes of Tx data
for (i = 0; i <2; i++)
{
if (USART_RemoveCharFromTxBuffer( ComNum, c ))
{
WriteCharToTxBuffer( ComNum, c );
Events_Set( SYSTEM_EVENT_FLAG_COM_OUT );
}
else
{
// Disable further TxBufferEmptyInterrupt. It will be
// enabled by the PAL uart driver when a character to the
// TxBuffer is added
TxBufferEmptyInterruptEnable( ComNum, FALSE );
break;
}
}
// Check if IIR read is required to clear the uart Rx interrupt
IIR_Value = USARTC.SEL3.IIR.UART_IIR;
}
// ---------------------------------------------------------------------------
void USART_IRQHandler(int ComPortNum, int Direction)
{
LPC_USART_T *usart = USART_REG(ComPortNum);
char c;
switch (Direction)
{
case 1: // Transmit
if (USART_RemoveCharFromTxBuffer(ComPortNum, c))
{
usart->THR = c; // Write data
} else {
CPU_USART_TxBufferEmptyInterruptEnable(ComPortNum, FALSE); // Disable interrupt
}
Events_Set(SYSTEM_EVENT_FLAG_COM_OUT);
break;
case 2: // Receive
c = (char)(usart->RBR); // Read data
USART_AddCharToRxBuffer(ComPortNum, c);
Events_Set(SYSTEM_EVENT_FLAG_COM_IN);
break;
default:
break;
}
}
void PXA271_USART_Driver::USART_ISR( void* param )
{
// we lock since we are low priority and anyone might try to add a char in another ISR
GLOBAL_LOCK(irq);
UINT32 comPort = (UINT32)param;
PXA271_USART& USART = PXA271::USART( comPort );
switch( USART.IIR & PXA271_USART::IIR__IID_MASK )
{
case PXA271_USART::IIR__IID_RECEIVE_DATA: // If data in input FIFO
// if the charger came in and turned off the serial port, bail now, as the source
// will be going away
if(c_RefFlagRx & g_PXA271_USART_Driver.m_RefFlags[comPort])
{
if(USART.LSR & PXA271_USART::LSR__DR)
{
USART_AddCharToRxBuffer( comPort, (char)(USART.RBR & PXA271_USART::RBR__DATA_MASK8) );
Events_Set( SYSTEM_EVENT_FLAG_COM_IN );
}
}
break;
case PXA271_USART::IIR__IID_TRANSMIT_FIFO: // If transmit FIFO can accept more characters
// if the charger came in and turned off the serial port, bail now, as the source
// will be going away
if(c_RefFlagTx & g_PXA271_USART_Driver.m_RefFlags[comPort])
{
char c;
if(USART_RemoveCharFromTxBuffer( comPort, c ))
{
WriteCharToTxBuffer( comPort, c );
}
else
{
// disable further Tx interrupts since we are level triggered
TxBufferEmptyInterruptEnable( comPort, FALSE );
}
Events_Set( SYSTEM_EVENT_FLAG_COM_OUT );
}
break;
#if defined(_DEBUG)
case PXA271_USART::IIR__IID_RECEIVE_ERROR: // If there was an error receiving a character
if(0 != (c_RefFlagRx & g_PXA271_USART_Driver.m_RefFlags[comPort]))
{
lcd_printf("\fLSR=%02x\r\n", USART.LSR & PXA271_USART::LSR__ERRORS);
}
break;
#endif
}
}
void STM32F4_USART_Handle_TX_IRQ (int ComPortNum, USART_TypeDef* uart)
{
INTERRUPT_START;
char c;
if (USART_RemoveCharFromTxBuffer(ComPortNum, c)) {
uart->DR = c; // write TX data
} else {
uart->CR1 &= ~USART_CR1_TXEIE; // TX int disable
}
Events_Set(SYSTEM_EVENT_FLAG_COM_OUT);
INTERRUPT_END;
}
void USART_TxISR( UINT32 port )
{
char c;
GLOBAL_LOCK(irq);
if(USART_RemoveCharFromTxBuffer( port, c ))
{
CPU_USART_WriteCharToTxBuffer( port, c );
Events_Set( SYSTEM_EVENT_FLAG_COM_OUT );
}
else
{
CPU_USART_TxBufferEmptyInterruptEnable( port, FALSE );
}
}
void LPC24XX_USART_Driver::UART_IntHandler (void *param)
{
GLOBAL_LOCK(irq);
ASSERT(LPC24XX_USART_Driver::IsValidPortNum((UINT32)param));
char c;
UINT32 ComNum = (UINT32)param;
UINT32 i;
UINT32 rxcnt=0;
LPC24XX_USART& USARTC = LPC24XX::UART(ComNum);
volatile UINT32 IIR_Value;
volatile UINT32 LSR_Value;
volatile register UINT32 * regRBR = &(USARTC.SEL1.RBR.UART_RBR);
volatile register UINT32 * regLSR = &(USARTC.UART_LSR);
IIR_Value = USARTC.SEL3.IIR.UART_IIR & LPC24XX_USART::UART_IIR_IID_mask;
if (IIR_Value & LPC24XX_USART::UART_IIR_NIP)
ASSERT(0);
// Read data from Rx FIFO
while (true)
{
LSR_Value = *regLSR ;
if (LSR_Value & LPC24XX_USART::UART_LSR_RFDR)
{
volatile UINT8 rxdata = (UINT8 ) *regRBR;
// No errors in Rx data
USART_AddCharToRxBuffer(ComNum, rxdata);
}
else
break;
}
// Send up to 2 bytes of Tx data
for (i = 0; i <2; i++)
{
if (USART_RemoveCharFromTxBuffer( ComNum, c ))
{
WriteCharToTxBuffer( ComNum, c );
Events_Set( SYSTEM_EVENT_FLAG_COM_OUT );
}
else
{
// Disable further TxBufferEmptyInterrupt. It will be
// enabled by the PAL uart driver when a character to the
// TxBuffer is added
TxBufferEmptyInterruptEnable( ComNum, FALSE );
break;
}
}
}
