// -----------------------------------------------------------------------------
//! \brief This routine initializes and begins a SPI transaction
//!
//! \param[in] len - Number of bytes to write.
//!
//! \return uint8 - number of bytes written to transport
// -----------------------------------------------------------------------------
uint16 NPITLSPI_writeTransport(uint16 len)
{
int16 i = 0;
ICall_CSState key;
key = ICall_enterCriticalSection();
TransportTxBufLen = len + SPI_TX_FIELD_LEN;
// Shift TX message two bytes to give room for SPI header
for( i = ( TransportTxBufLen - 1 ) ; i >= 0 ; i-- )
{
TransportTxBuf[i + SPI_TX_HDR_LEN] = TransportTxBuf[i];
}
// Add header (including a zero padding byte required by the SPI driver)
TransportTxBuf[SPI_TX_ZERO_PAD_INDEX] = 0x00;
TransportTxBuf[SPI_TX_SOF_INDEX] = SPI_SOF;
TransportTxBuf[SPI_TX_LEN_INDEX] = len;
// Calculate and append FCS at end of Frame
TransportTxBuf[TransportTxBufLen - 1] =
NPITLSPI_calcFCS(&TransportTxBuf[SPI_TX_LEN_INDEX],len + 1);
// Clear DMA Rx buffer and clear extra Tx buffer bytes to ensure clean buffer
// for next RX/TX
memset(TransportRxBuf, 0, NPI_TL_BUF_SIZE);
memset(&TransportTxBuf[TransportTxBufLen], 0, NPI_TL_BUF_SIZE - TransportTxBufLen);
// set up the SPI Transaction
spiTransaction.count = NPI_TL_BUF_SIZE;
spiTransaction.txBuf = TransportTxBuf;
spiTransaction.rxBuf = TransportRxBuf;
// Check to see if transport is successful. If not, reset TxBufLen to allow
// another write to be processed
if( ! SPI_transfer(spiHandle, &spiTransaction) )
{
TransportTxBufLen = 0;
}
ICall_leaveCriticalSection(key);
return TransportTxBufLen;
}
// -----------------------------------------------------------------------------
//! \brief This routine initializes and begins a SPI transaction
//!
//! \param[in] len - Number of bytes to write.
//!
//! \return uint16_t - number of bytes written to transport
// -----------------------------------------------------------------------------
uint16_t NPITLSPI_writeTransport(uint16_t len)
{
int16 i = 0;
ICall_CSState key;
key = ICall_enterCriticalSection();
// Shift all bytes in TX Buffer up ZERO_PAD indexes. SPI Driver clips off
// first byte
// NPI TL already shifts bytes up 1 index for SOF before calling write()
for (i = len + 1; i > 0; i--)
{
npiTxBuf[i + ZERO_PAD] = npiTxBuf[i];
}
// Clear zero pad bytes
memset(npiTxBuf, 0, ZERO_PAD);
npiTxBuf[NPI_SPI_MSG_SOF_IDX + ZERO_PAD] = NPI_SPI_MSG_SOF;
npiTxBuf[len + ZERO_PAD + 1] = NPITLSPI_calcFCS((uint8_t *)&npiTxBuf[2],len);
tlWriteLen = len + ZERO_PAD + 2; // 2 = SOF + FCS
// Clear DMA Rx buffer and clear extra Tx buffer bytes to ensure clean buffer
// for next RX/TX
memset(npiRxBuf, 0, npiBufSize);
memset(&npiTxBuf[tlWriteLen], 0, npiBufSize - tlWriteLen);
// set up the SPI Transaction
spiTransaction.count = npiBufSize;
spiTransaction.txBuf = npiTxBuf;
spiTransaction.rxBuf = npiRxBuf;
// Check to see if transport is successful. If not, reset TxBufLen to allow
// another write to be processed
if (!SPI_transfer(spiHandle, &spiTransaction))
{
tlWriteLen = 0;
}
ICall_leaveCriticalSection(key);
return len;
}
// -----------------------------------------------------------------------------
//! \brief This callback is invoked on transmission completion
//!
//! \param[in] handle - handle to the SPI port
//! \param[in] objTransaction - handle for SPI transmission
//!
//! \return void
// -----------------------------------------------------------------------------
static void NPITLSPI_CallBack(SPI_Handle handle, SPI_Transaction *objTransaction)
{
uint16_t i;
uint16_t readLen = 0;
uint16_t storeWriteLen;
// Check if a valid packet was found
// SOF:
if (npiRxBuf[NPI_SPI_MSG_SOF_IDX] == NPI_SPI_MSG_SOF &&
objTransaction->count)
{
// Length:
readLen = npiRxBuf[NPI_SPI_MSG_LEN_LSB_IDX];
readLen += ((uint16)npiRxBuf[NPI_SPI_MSG_LEN_MSB_IDX] << 8);
readLen += NPI_SPI_MSG_HDR_NOSOF_LEN; // Include the header w/o SOF
// FCS:
if (npiRxBuf[readLen + 1] ==
NPITLSPI_calcFCS(&npiRxBuf[NPI_SPI_MSG_LEN_LSB_IDX],readLen))
{
// Message is valid. Shift bytes to remove SOF
for (i = 0 ; i < readLen; i++)
{
npiRxBuf[i] = npiRxBuf[i + 1];
}
}
else
{
// Invalid FCS. Discard message
readLen = 0;
}
}
//All bytes in TxBuf must be sent by this point
storeWriteLen = tlWriteLen;
tlWriteLen = 0;
RxActive = FALSE;
if (npiTransmitCB)
{
npiTransmitCB(readLen,storeWriteLen);
}
}
// -----------------------------------------------------------------------------
//! \brief This callback is invoked on transmission completion
//!
//! \param[in] handle - handle to the SPI port
//! \param[in] objTransaction - handle for SPI transmission
//!
//! \return void
// -----------------------------------------------------------------------------
static void NPITLSPI_CallBack(SPI_Handle handle, SPI_Transaction *objTransaction)
{
uint8 i;
uint16 readLen = 0;
uint16 storeTxLen = TransportTxBufLen;
// Check if a valid packet was found
// SOF:
if ( TransportRxBuf[SPI_RX_SOF_INDEX] == SPI_SOF &&
objTransaction->count)
{
// Length:
readLen = TransportRxBuf[SPI_RX_LEN_INDEX];
// FCS:
if ( TransportRxBuf[readLen + SPI_RX_HDR_LEN] ==
NPITLSPI_calcFCS(&TransportRxBuf[SPI_RX_LEN_INDEX],readLen + 1) )
{
// Message is valid. Shift bytes to remove header
for( i = 0 ; i < readLen ; i++)
{
TransportRxBuf[i] = TransportRxBuf[i + SPI_RX_HDR_LEN];
}
}
else
{
// Invalid FCS. Discard message
readLen = 0;
}
}
//All bytes in TxBuf must be sent by this point
TransportTxBufLen = 0;
RxActive = FALSE;
if ( npiTransmitCB )
{
npiTransmitCB(readLen,storeTxLen);
}
}
