SPI Slave#

This module includes the platform abstraction for SPI slave communication.

Typedefs#

typedef bool(*
otPlatSpiSlaveTransactionCompleteCallback)(void *aContext, uint8_t *aOutputBuf, uint16_t aOutputBufLen, uint8_t *aInputBuf, uint16_t aInputBufLen, uint16_t aTransactionLength)

Indicates that a SPI transaction has completed with the given length.

typedef void(*

Invoked after a transaction complete callback is called and returns TRUE to do any further processing required.

Functions#

otPlatSpiSlaveEnable(otPlatSpiSlaveTransactionCompleteCallback aCompleteCallback, otPlatSpiSlaveTransactionProcessCallback aProcessCallback, void *aContext)

Initialize the SPI slave interface.

void

Shutdown and disable the SPI slave interface.

otPlatSpiSlavePrepareTransaction(uint8_t *aOutputBuf, uint16_t aOutputBufLen, uint8_t *aInputBuf, uint16_t aInputBufLen, bool aRequestTransactionFlag)

Prepare data for the next SPI transaction.

Typedef Documentation#

otPlatSpiSlaveTransactionCompleteCallback#

typedef bool(* otPlatSpiSlaveTransactionCompleteCallback) (void *aContext, uint8_t *aOutputBuf, uint16_t aOutputBufLen, uint8_t *aInputBuf, uint16_t aInputBufLen, uint16_t aTransactionLength) )(void *aContext, uint8_t *aOutputBuf, uint16_t aOutputBufLen, uint8_t *aInputBuf, uint16_t aInputBufLen, uint16_t aTransactionLength)

Indicates that a SPI transaction has completed with the given length.

Parameters
[in]aContext

Context pointer passed into otPlatSpiSlaveEnable().

[in]aOutputBuf

Value of aOutputBuf from last call to otPlatSpiSlavePrepareTransaction().

[in]aOutputBufLen

Value of aOutputBufLen from last call to otPlatSpiSlavePrepareTransaction().

[in]aInputBuf

Value of aInputBuf from last call to otPlatSpiSlavePrepareTransaction().

[in]aInputBufLen

Value of aInputBufLen from last call to otPlatSpiSlavePrepareTransaction()

[in]aTransactionLength

Length of the completed transaction, in bytes.

The data written to the slave has been written to the pointer indicated by the aInputBuf argument to the previous call to otPlatSpiSlavePrepareTransaction().

Once this function is called, otPlatSpiSlavePrepareTransaction() is invalid and must be called again for the next transaction to be valid.

Note that this function is always called at the end of a transaction, even if otPlatSpiSlavePrepareTransaction() has not yet been called. In such cases, aOutputBufLen and aInputBufLen will be zero.

This callback can be called from ISR context. The return value from this function indicates if any further processing is required. If TRUE is returned the platform spi-slave driver implementation must invoke the transaction process callback (aProcessCallback set in otPlatSpiSlaveEnable()) which unlike this callback must be called from the same OS context that any other OpenThread API/callback is called.

Returns

  • TRUE if after this call returns the platform should invoke the process callback aProcessCallback, FALSE if there is nothing to process and no need to invoke the process callback.


Definition at line 82 of file include/openthread/platform/spi-slave.h

otPlatSpiSlaveTransactionProcessCallback#

typedef void(* otPlatSpiSlaveTransactionProcessCallback) (void *aContext) )(void *aContext)

Invoked after a transaction complete callback is called and returns TRUE to do any further processing required.

Parameters
[in]aContext

Context pointer passed into otPlatSpiSlaveEnable().

Unlike otPlatSpiSlaveTransactionCompleteCallback which can be called from any OS context (e.g., ISR), this callback MUST be called from the same OS context as any other OpenThread API/callback.


Definition at line 97 of file include/openthread/platform/spi-slave.h

Function Documentation#

otPlatSpiSlaveEnable#

otError otPlatSpiSlaveEnable (otPlatSpiSlaveTransactionCompleteCallback aCompleteCallback, otPlatSpiSlaveTransactionProcessCallback aProcessCallback, void * aContext)

Initialize the SPI slave interface.

Parameters
[in]aCompleteCallback

Pointer to transaction complete callback.

[in]aProcessCallback

Pointer to process callback.

[in]aContext

Context pointer to be passed to callbacks.

Note that SPI slave is not fully ready until a transaction is prepared using otPlatSPISlavePrepareTransaction().

If otPlatSPISlavePrepareTransaction() is not called before the master begins a transaction, the resulting SPI transaction will send all0xFF` bytes and discard all received bytes.


Definition at line 116 of file include/openthread/platform/spi-slave.h

otPlatSpiSlaveDisable#

void otPlatSpiSlaveDisable (void )

Shutdown and disable the SPI slave interface.

Parameters
N/A

Definition at line 123 of file include/openthread/platform/spi-slave.h

otPlatSpiSlavePrepareTransaction#

otError otPlatSpiSlavePrepareTransaction (uint8_t * aOutputBuf, uint16_t aOutputBufLen, uint8_t * aInputBuf, uint16_t aInputBufLen, bool aRequestTransactionFlag)

Prepare data for the next SPI transaction.

Parameters
[in]aOutputBuf

Data to be written to MISO pin

[in]aOutputBufLen

Size of the output buffer, in bytes

[in]aInputBuf

Data to be read from MOSI pin

[in]aInputBufLen

Size of the input buffer, in bytes

[in]aRequestTransactionFlag

Set to true if host interrupt should be set

Data pointers MUST remain valid until the transaction complete callback is called by the SPI slave driver, or until after the next call to otPlatSpiSlavePrepareTransaction().

This function may be called more than once before the SPI master initiates the transaction. Each successful call to this function will cause the previous values from earlier calls to be discarded.

Not calling this function after a completed transaction is the same as if this function was previously called with both buffer lengths set to zero and aRequestTransactionFlag set to false.

Once aOutputBufLen bytes of aOutputBuf has been clocked out, the MISO pin shall be set high until the master finishes the SPI transaction. This is the functional equivalent of padding the end of aOutputBuf with 0xFF bytes out to the length of the transaction.

Once aInputBufLen bytes of aInputBuf have been clocked in from MOSI, all subsequent values from the MOSI pin are ignored until the SPI master finishes the transaction.

Note that even if aInputBufLen or aOutputBufLen (or both) are exhausted before the SPI master finishes a transaction, the ongoing size of the transaction must still be kept track of to be passed to the transaction complete callback. For example, if aInputBufLen is equal to 10 and aOutputBufLen equal to 20 and the SPI master clocks out 30 bytes, the value 30 is passed to the transaction complete callback.

If a NULL pointer is passed in as aOutputBuf or aInputBuf it means that that buffer pointer should not change from its previous/current value. In this case, the corresponding length argument should be ignored. For example, otPlatSpiSlavePrepareTransaction(NULL, 0, aInputBuf, aInputLen, false) changes the input buffer pointer and its length but keeps the output buffer pointer same as before.

Any call to this function while a transaction is in progress will cause all of the arguments to be ignored and the return value to be OT_ERROR_BUSY.


Definition at line 166 of file include/openthread/platform/spi-slave.h