// -----------------------------------------------------------------------------
//! \brief This routine writes copies buffer addr to the transport layer.
//!
//! \param[in] len - Number of bytes to write.
//!
//! \return uint8 - number of bytes written to transport
// -----------------------------------------------------------------------------
uint16 NPITLUART_writeTransport(uint16 len)
{
ICall_CSState key;
key = ICall_enterCriticalSection();
TransportTxLen = len;
#ifdef POWER_SAVING
TxActive = TRUE;
// Start reading prior to impending write transaction
// We can only call UART_write() once MRDY has been signaled from Master
// device
NPITLUART_readTransport();
#else
// Check to see if transport is successful. If not, reset TxLen to allow
// another write to be processed
if(UART_write(uartHandle, TransportTxBuf, TransportTxLen) == UART_ERROR )
{
TransportTxLen = 0;
}
#endif //POWER_SAVING
ICall_leaveCriticalSection(key);
return TransportTxLen;
}
// -----------------------------------------------------------------------------
//! \brief This routine initializes the transport layer and opens the port
//! of the device.
//!
//! \param[in] tRxBuf - pointer to NPI TL Tx Buffer
//! \param[in] tTxBuf - pointer to NPI TL Rx Buffer
//! \param[in] npiCBack - NPI TL call back function to be invoked at the end of
//! a UART transaction
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITLUART_initializeTransport(Char *tRxBuf, Char *tTxBuf, npiCB_t npiCBack)
{
UART_Params params;
TransportRxBuf = tRxBuf;
TransportTxBuf = tTxBuf;
npiTransmitCB = npiCBack;
// Configure UART parameters.
UART_Params_init(¶ms);
params.baudRate = NPI_UART_BR;
params.readDataMode = UART_DATA_BINARY;
params.writeDataMode = UART_DATA_BINARY;
params.dataLength = UART_LEN_8;
params.stopBits = UART_STOP_ONE;
params.readMode = UART_MODE_CALLBACK;
params.writeMode = UART_MODE_CALLBACK;
params.readEcho = UART_ECHO_OFF;
params.readCallback = NPITLUART_readCallBack;
params.writeCallback = NPITLUART_writeCallBack;
// Open / power on the UART.
uartHandle = UART_open(Board_UART, ¶ms);
//Enable Partial Reads on all subsequent UART_read()
UART_control(uartHandle, UARTCC26XX_CMD_RETURN_PARTIAL_ENABLE, NULL);
#ifndef POWER_SAVING
// This call will start repeated Uart Reads when Power Savings is disabled
NPITLUART_readTransport();
#endif //!POWER_SAVING
return;
}
// -----------------------------------------------------------------------------
//! \brief This routine is called from the application context when REM RDY
//! is de-asserted
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITLUART_handleRemRdyEvent(void)
{
_npiCSKey_t key;
key = NPIUtil_EnterCS();
remRdy_flag = 0;
// If we haven't already begun reading, now is the time before Master
// potentially starts to send data
// The !TxActive condition is because we will call UART_npiRead() prior to setting
// TxActive true. There is the possibility that REM RDY gets set high which
// clears RxActive prior to us getting to this event. This will cause us to
// read twice per transaction which will cause the transaction to never
// complete
if (!RxActive && !TxActive)
{
NPITLUART_readTransport();
}
// If we have something to write, then the Master has signalled it is ready
// to receive. Time to write.
if (TxActive)
{
// Check to see if transport is successful. If not, reset TxLen to allow
// another write to be processed
if (UART_write(uartHandle, npiTxBuf, TransportTxLen) == UART_ERROR)
{
TxActive = FALSE;
TransportTxLen = 0;
}
}
NPIUtil_ExitCS(key);
}
// -----------------------------------------------------------------------------
//! \brief This routine writes copies buffer addr to the transport layer.
//!
//! \param[in] len - Number of bytes to write.
//!
//! \return uint16_t - number of bytes written to transport
// -----------------------------------------------------------------------------
uint16_t NPITLUART_writeTransport(uint16_t len)
{
_npiCSKey_t key;
key = NPIUtil_EnterCS();
npiTxBuf[NPI_UART_MSG_SOF_IDX] = NPI_UART_MSG_SOF;
npiTxBuf[len + 1] = NPITLUART_calcFCS((uint8_t *)&npiTxBuf[1],len);
TransportTxLen = len + 2;
#ifdef POWER_SAVING
TxActive = TRUE;
// Start reading prior to impending write transaction
// We can only call UART_write() once REM RDY has been signaled from Master
// device
NPITLUART_readTransport();
#else
// Check to see if transport is successful. If not, reset TxLen to allow
// another write to be processed
if(UART_write(uartHandle, npiTxBuf, TransportTxLen) == UART_ERROR)
{
TransportTxLen = NPI_BUSY;
}
#endif //POWER_SAVING
NPIUtil_ExitCS(key);
return len;
}
// -----------------------------------------------------------------------------
//! \brief This routine is called from the application context when REM RDY
//! is de-asserted
//!
//! \return void
// -----------------------------------------------------------------------------
void NPITLUART_handleRemRdyEvent(void)
{
_npiCSKey_t key;
key = NPIUtil_EnterCS();
// If read has not yet been started, now is the time before Master
// potentially starts to send data
// There is the possibility that MRDY gets set high which
// clears RxActive prior to us getting to this event. This will cause us to
// read twice per transaction which will cause the transaction to never
// complete
if (!RxActive && !TxActive)
{
NPITLUART_readTransport();
}
// If write has already been initialized then kick off the driver write
// now that Master has signalled it is ready
if (TxActive)
{
// Check to see if transport is successful. If not, reset TxLen to allow
// another write to be processed
if (UART_write(uartHandle, npiTxBuf, TransportTxLen) == UART_ERROR)
{
TxActive = FALSE;
TransportTxLen = 0;
}
}
NPIUtil_ExitCS(key);
}
