SPI PeripheralDriver

Description

SPI Peripheral Interface driver.

Flexible SPI Peripheral driver implementation for use in an NCP scenario.

This driver will support both blocking and non-blocking operation, with LDMA backing the background transfers to support nonblocking.

Functions

void spi_peripheral_init (void)
 
void spi_peripheral_deinit (void)
 
int32_t spi_peripheral_sendBuffer (uint8_t *buffer, size_t length)
 
int32_t spi_peripheral_sendByte (uint8_t byte)
 
size_t spi_peripheral_getTxBytesLeft (void)
 
void spi_peripheral_enableTransmitter (bool enable)
 
void spi_peripheral_enableReceiver (bool enable)
 
size_t spi_peripheral_getRxAvailableBytes (void)
 
int32_t spi_peripheral_receiveBuffer (uint8_t *buffer, size_t requestedLength, size_t *receivedLength, bool blocking, uint32_t timeout)
 
int32_t spi_peripheral_receiveByte (uint8_t *byte)
 
void spi_peripheral_flush (bool flushTx, bool flushRx)
 

Function Documentation

void spi_peripheral_init ( void  )

Initialize the configured USART peripheral for SPI peripheral operation. Also sets up GPIO settings for MOSI, MISO, SCLK and SS. After initialization, the SPI peripheral will have RX enabled.

Returns
BOOTLOADER_OK if succesful, error code otherwise
void spi_peripheral_deinit ( void  )

Disable the configured USART peripheral for SPI operation.

int32_t spi_peripheral_sendBuffer ( uint8_t *  buffer,
size_t  length 
)

Write a data buffer to the controller next time the controller starts clocking SCLK. This transfer will be non-blocking, and its progress can be tracked through spi_peripheral_getTxBytesLeft

Parameters
[in]bufferThe data buffer to send
[in]lengthNumber of bytes in the buffer to send
Returns
BOOTLOADER_OK if successful, error code otherwise
int32_t spi_peripheral_sendByte ( uint8_t  byte)

Write one byte to the controller in a blocking fashion.

Warning
If the controller goes down, this will block forever.
Parameters
[in]byteThe byte to send
Returns
BOOTLOADER_OK if succesful, error code otherwise
size_t spi_peripheral_getTxBytesLeft ( void  )

Gets the amount of bytes left in the TX data buffer.

Returns
Number of bytes in the transmit buffer still needing to go out
void spi_peripheral_enableTransmitter ( bool  enable)

Enable/disable MISO output

Parameters
[in]enableTrue to enable the transmitter, false to disable
void spi_peripheral_enableReceiver ( bool  enable)

Enable/disable receiving bytes from the controller into our internal buffer. The purpose of this function is to avoid filling up the buffer with 0xFF while a controller is polling for new data.

Parameters
[in]enableTrue to enable the receiver, false to disable
size_t spi_peripheral_getRxAvailableBytes ( void  )

Gets the amount of bytes ready for reading.

Returns
Number of bytes in the receive buffer available for reading with spi_peripheral_receiveBuffer
int32_t spi_peripheral_receiveBuffer ( uint8_t *  buffer,
size_t  requestedLength,
size_t *  receivedLength,
bool  blocking,
uint32_t  timeout 
)

Read from the RX buffer into a local buffer.

Parameters
[out]bufferThe data buffer to receive into
[in]requestedLengthNumber of bytes we'd like to read
[out]receivedLengthNumber of bytes read
[in]blockingIndicate whether we should wait for requestedLength bytes to be available and read before returning, or we can read out whatever is currently in the buffer and return.
[in]timeoutNumber of milliseconds to wait for data in blocking mode
Returns
BOOTLOADER_OK if succesful, error code otherwise
int32_t spi_peripheral_receiveByte ( uint8_t *  byte)

Get one byte from the SPI peripheral in a blocking fashion.

Warning
If the controller never clocks in a byte, this function will block forever.
Parameters
[out]bytePointer to where to put the received byte
Returns
BOOTLOADER_OK if succesful, error code otherwise
void spi_peripheral_flush ( bool  flushTx,
bool  flushRx 
)

Flush one or both buffers.

Parameters
[in]flushTxFlush the transmit buffer when true
[in]flushRxFlush the receive buffer when true