| Kinetis SDK v.2.0 API Reference Manual Rev. 0 Freescale Semiconductor, Inc.

- Main Page
- Related Pages
- API Reference

All Data Structures Functions Variables Typedefs Enumerations Enumerator Groups Pages
Modules | Files | Data Structures | Macros | Typedefs | Enumerations
SPI Driver
SPI: Serial Peripheral Interface Driver

# Overview

More...

## Overview

SPI driver includes functional APIs and transactional APIs.

Functional APIs are feature/property target low level APIs. Functional APIs can be used for SPI initialization/configuration/operation for optimization/customization purpose. Using the functional API requires the knowledge of the SPI peripheral and how to organize functional APIs to meet the application requirements. All functional API use the peripheral base address as the first parameter. SPI functional operation groups provide the functional API set.

Transactional APIs are transaction target high level APIs. Transactional APIs can be used to enable the peripheral and in the application if the code size and performance of transactional APIs satisfy the requirements. If the code size and performance are a critical requirement, see the transactional API implementation and write a custom code. All transactional APIs use the spi_handle_t as the first parameter. Initialize the handle by calling the SPI_MasterTransferCreateHandle() or SPI_SlaveTransferCreateHandle() API.

Transactional APIs support asynchronous transfer. This means that the functions SPI_MasterTransferNonBlocking() and SPI_SlaveTransferNonBlocking() set up the interrupt for data transfer. When the transfer completes, the upper layer is notified through a callback function with the kStatus_SPI_Idle status.

# Typical use case

## SPI master transfer using an interrupt method

#define BUFFER_LEN (64)
spi_master_handle_t spiHandle;
spi_master_config_t masterConfig;
spi_transfer_t xfer;
volatile bool isFinished = false;
const uint8_t sendData[BUFFER_LEN] = [......];
uint8_t receiveBuff[BUFFER_LEN];
void SPI_UserCallback(SPI_Type *base, spi_master_handle_t *handle, status_t status, void *userData)
{
isFinished = true;
}
void main(void)
{
//...
SPI_MasterGetDefaultConfig(&masterConfig);
SPI_MasterInit(SPI0, &masterConfig);
SPI_MasterTransferCreateHandle(SPI0, &spiHandle, SPI_UserCallback, NULL);
// Prepare to send.
xfer.txData = sendData;
xfer.rxData = receiveBuff;
xfer.dataSize = BUFFER_LEN;
// Send out.
SPI_MasterTransferNonBlocking(SPI0, &spiHandle, &xfer);
// Wait send finished.
while (!isFinished)
{
}
// ...
}

## SPI Send/receive using a DMA method

#define BUFFER_LEN (64)
spi_dma_handle_t spiHandle;
dma_handle_t g_spiTxDmaHandle;
dma_handle_t g_spiRxDmaHandle;
spi_config_t masterConfig;
spi_transfer_t xfer;
volatile bool isFinished;
uint8_t sendData[BUFFER_LEN] = ...;
uint8_t receiveBuff[BUFFER_LEN];
void SPI_UserCallback(SPI_Type *base, spi_dma_handle_t *handle, status_t status, void *userData)
{
isFinished = true;
}
void main(void)
{
//...
SPI_MasterGetDefaultConfig(&masterConfig);
SPI_MasterInit(SPI0, &masterConfig);
// Sets up the DMA.
DMAMUX_Init(DMAMUX0);
DMAMUX_SetSource(DMAMUX0, SPI_TX_DMA_CHANNEL, SPI_TX_DMA_REQUEST);
DMAMUX_EnableChannel(DMAMUX0, SPI_TX_DMA_CHANNEL);
DMAMUX_SetSource(DMAMUX0, SPI_RX_DMA_CHANNEL, SPI_RX_DMA_REQUEST);
DMAMUX_EnableChannel(DMAMUX0, SPI_RX_DMA_CHANNEL);
DMA_Init(DMA0);
/* Creates the DMA handle.
DMA_CreateHandle(&g_spiTxDmaHandle, DMA0, SPI_TX_DMA_CHANNEL);
DMA_CreateHandle(&g_spiRxDmaHandle, DMA0, SPI_RX_DMA_CHANNEL);
SPI_MasterTransferCreateHandleDMA(SPI0, spiHandle, &g_spiTxDmaHandle, &g_spiRxDmaHandle, SPI_UserCallback, NULL);
// Prepares to send.
xfer.txData = sendData;
xfer.rxData = receiveBuff;
xfer.dataSize = BUFFER_LEN;
// Sends out.
SPI_MasterTransferDMA(SPI0, &spiHandle, &xfer);
// Waits for send to complete.
while (!isFinished)
{
}
// ...
}

## Modules
| SPI DMA Driver

## Files
file | fsl_spi.h

## Data Structures
struct | spi_master_config_t
| SPI master user configure structure. More...
struct | spi_slave_config_t
| SPI slave user configure structure. More...
struct | spi_transfer_t
| SPI transfer structure. More...
struct | spi_master_handle_t
| SPI transfer handle structure. More...

## Macros
#define | SPI_DUMMYDATA (0xFFU)
| SPI dummy transfer data, the data is sent while txBuff is NULL. More...

## Typedefs
typedef spi_master_handle_t | spi_slave_handle_t
| Slave handle is the same with master handle.
typedef void(* | spi_master_callback_t )(SPI_Type *base, spi_master_handle_t *handle, status_t status, void *userData)
| SPI master callback for finished transmit.
typedef void(* | spi_slave_callback_t )(SPI_Type *base, spi_slave_handle_t *handle, status_t status, void *userData)
| SPI master callback for finished transmit.

## Enumerations
enum | _spi_status { kStatus_SPI_Busy = MAKE_STATUS(kStatusGroup_SPI, 0), kStatus_SPI_Idle = MAKE_STATUS(kStatusGroup_SPI, 1), kStatus_SPI_Error = MAKE_STATUS(kStatusGroup_SPI, 2) }
| Return status for the SPI driver. More...
enum | spi_clock_polarity_t { kSPI_ClockPolarityActiveHigh = 0x0U, kSPI_ClockPolarityActiveLow }
| SPI clock polarity configuration. More...
enum | spi_clock_phase_t { kSPI_ClockPhaseFirstEdge = 0x0U, kSPI_ClockPhaseSecondEdge }
| SPI clock phase configuration. More...
enum | spi_shift_direction_t { kSPI_MsbFirst = 0x0U, kSPI_LsbFirst }
| SPI data shifter direction options. More...
enum | spi_ss_output_mode_t { kSPI_SlaveSelectAsGpio = 0x0U, kSPI_SlaveSelectFaultInput = 0x2U, kSPI_SlaveSelectAutomaticOutput = 0x3U }
| SPI slave select output mode options. More...
enum | spi_pin_mode_t { kSPI_PinModeNormal = 0x0U, kSPI_PinModeInput = 0x1U, kSPI_PinModeOutput = 0x3U }
| SPI pin mode options. More...
enum | spi_data_bitcount_mode_t { kSPI_8BitMode = 0x0U, kSPI_16BitMode }
| SPI data length mode options. More...
enum | _spi_interrupt_enable { kSPI_RxFullAndModfInterruptEnable = 0x1U, kSPI_TxEmptyInterruptEnable = 0x2U, kSPI_MatchInterruptEnable = 0x4U }
| SPI interrupt sources. More...
enum | _spi_flags { kSPI_RxBufferFullFlag = SPI_S_SPRF_MASK, kSPI_MatchFlag = SPI_S_SPMF_MASK, kSPI_TxBufferEmptyFlag = SPI_S_SPTEF_MASK, kSPI_ModeFaultFlag = SPI_S_MODF_MASK }
| SPI status flags. More...

## Driver version
#define | FSL_SPI_DRIVER_VERSION (MAKE_VERSION(2, 0, 0))
| SPI driver version 2.0.0. More...

## Initialization and deinitialization
void | SPI_MasterGetDefaultConfig (spi_master_config_t *config)
| Sets the SPI master configuration structure to default values. More...
void | SPI_MasterInit (SPI_Type *base, const spi_master_config_t *config, uint32_t srcClock_Hz)
| Initializes the SPI with master configuration. More...
void | SPI_SlaveGetDefaultConfig (spi_slave_config_t *config)
| Sets the SPI slave configuration structure to default values. More...
void | SPI_SlaveInit (SPI_Type *base, const spi_slave_config_t *config)
| Initializes the SPI with slave configuration. More...
void | SPI_Deinit (SPI_Type *base)
| De-initializes the SPI. More...
static void | SPI_Enable (I2C_Type *base, bool enable)
| Enables or disables the SPI. More...

## Status
uint32_t | SPI_GetStatusFlags (SPI_Type *base)
| Gets the status flag. More...

## Interrupts
void | SPI_EnableInterrupts (SPI_Type *base, uint32_t mask)
| Enables the interrupt for the SPI. More...
void | SPI_DisableInterrupts (SPI_Type *base, uint32_t mask)
| Disables the interrupt for the SPI. More...

## DMA Control
static uint32_t | SPI_GetDataRegisterAddress (SPI_Type *base)
| Gets the SPI tx/rx data register address. More...

## Bus Operations
void | SPI_MasterSetBaudRate (SPI_Type *base, uint32_t baudRate_Bps, uint32_t srcClock_Hz)
| Sets the baud rate for SPI transfer. More...
static void | SPI_SetMatchData (SPI_Type *base, uint32_t matchData)
| Sets the match data for SPI. More...
void | SPI_WriteBlocking (SPI_Type *base, uint8_t *buffer, size_t size)
| Sends a buffer of data bytes using a blocking method. More...
void | SPI_WriteData (SPI_Type *base, uint16_t data)
| Writes a data into the SPI data register. More...
uint16_t | SPI_ReadData (SPI_Type *base)
| Gets a data from the SPI data register. More...

## Transactional
void | SPI_MasterTransferCreateHandle (SPI_Type *base, spi_master_handle_t *handle, spi_master_callback_t callback, void *userData)
| Initializes the SPI master handle. More...
status_t | SPI_MasterTransferBlocking (SPI_Type *base, spi_transfer_t *xfer)
| Transfers a block of data using a polling method. More...
status_t | SPI_MasterTransferNonBlocking (SPI_Type *base, spi_master_handle_t *handle, spi_transfer_t *xfer)
| Performs a non-blocking SPI interrupt transfer. More...
status_t | SPI_MasterTransferGetCount (SPI_Type *base, spi_master_handle_t *handle, size_t *count)
| Gets the bytes of the SPI interrupt transferred. More...
void | SPI_MasterTransferAbort (SPI_Type *base, spi_master_handle_t *handle)
| Aborts an SPI transfer using interrupt. More...
void | SPI_MasterTransferHandleIRQ (SPI_Type *base, spi_master_handle_t *handle)
| Interrupts the handler for the SPI. More...
static void | SPI_SlaveTransferCreateHandle (SPI_Type *base, spi_slave_handle_t *handle, spi_slave_callback_t callback, void *userData)
| Initializes the SPI slave handle. More...
static status_t | SPI_SlaveTransferNonBlocking (SPI_Type *base, spi_slave_handle_t *handle, spi_transfer_t *xfer)
| Performs a non-blocking SPI slave interrupt transfer. More...
static status_t | SPI_SlaveTransferGetCount (SPI_Type *base, spi_slave_handle_t *handle, size_t *count)
| Gets the bytes of the SPI interrupt transferred. More...
static void | SPI_SlaveTransferAbort (SPI_Type *base, spi_slave_handle_t *handle)
| Aborts an SPI slave transfer using interrupt. More...
static void | SPI_SlaveTransferHandleIRQ (SPI_Type *base, spi_slave_handle_t *handle)
| Interrupts a handler for the SPI slave. More...

## Data Structure Documentation

struct spi_master_config_t

### Data Fields
bool | enableMaster
| Enable SPI at initialization time.
bool | enableStopInWaitMode
| SPI stop in wait mode.
spi_clock_polarity_t | polarity
| Clock polarity.
spi_clock_phase_t | phase
| Clock phase.
spi_shift_direction_t | direction
| MSB or LSB.
spi_ss_output_mode_t | outputMode
| SS pin setting.
spi_pin_mode_t | pinMode
| SPI pin mode select.
uint32_t | baudRate_Bps
| Baud Rate for SPI in Hz.

struct spi_slave_config_t

### Data Fields
bool | enableSlave
| Enable SPI at initialization time.
bool | enableStopInWaitMode
| SPI stop in wait mode.
spi_clock_polarity_t | polarity
| Clock polarity.
spi_clock_phase_t | phase
| Clock phase.
spi_shift_direction_t | direction
| MSB or LSB.

struct spi_transfer_t

### Data Fields
uint8_t * | txData
| Send buffer.
uint8_t * | rxData
| Receive buffer.
size_t | dataSize
| Transfer bytes.
uint32_t | flags
| SPI control flag, useless to SPI. More...

#### Field Documentation

uint32_t spi_transfer_t::flags

struct _spi_master_handle

### Data Fields
uint8_t *volatile | txData
| Transfer buffer.
uint8_t *volatile | rxData
| Receive buffer.
volatile size_t | txRemainingBytes
| Send data remaining in bytes.
volatile size_t | rxRemainingBytes
| Receive data remaining in bytes.
volatile uint32_t | state
| SPI internal state.
size_t | transferSize
| Bytes to be transferred.
uint8_t | bytePerFrame
| SPI mode, 2bytes or 1byte in a frame.
uint8_t | watermark
| Watermark value for SPI transfer.
spi_master_callback_t | callback
| SPI callback.
void * | userData
| Callback parameter.

## Macro Definition Documentation

#define FSL_SPI_DRIVER_VERSION (MAKE_VERSION(2, 0, 0))

#define SPI_DUMMYDATA (0xFFU)

## Enumeration Type Documentation

enum _spi_status

Enumerator
kStatus_SPI_Busy | SPI bus is busy.
kStatus_SPI_Idle | SPI is idle.
kStatus_SPI_Error | SPI error.

enum spi_clock_polarity_t

Enumerator
kSPI_ClockPolarityActiveHigh | Active-high SPI clock (idles low).
kSPI_ClockPolarityActiveLow | Active-low SPI clock (idles high).

enum spi_clock_phase_t

Enumerator
kSPI_ClockPhaseFirstEdge | First edge on SPSCK occurs at the middle of the first cycle of a data transfer.
kSPI_ClockPhaseSecondEdge | First edge on SPSCK occurs at the start of the first cycle of a data transfer.

enum spi_shift_direction_t

Enumerator
kSPI_MsbFirst | Data transfers start with most significant bit.
kSPI_LsbFirst | Data transfers start with least significant bit.

enum spi_ss_output_mode_t

Enumerator
kSPI_SlaveSelectAsGpio | Slave select pin configured as GPIO.
kSPI_SlaveSelectFaultInput | Slave select pin configured for fault detection.
kSPI_SlaveSelectAutomaticOutput | Slave select pin configured for automatic SPI output.

enum spi_pin_mode_t

Enumerator
kSPI_PinModeNormal | Pins operate in normal, single-direction mode.
kSPI_PinModeInput | Bidirectional mode. Master: MOSI pin is input; Slave: MISO pin is input.
kSPI_PinModeOutput | Bidirectional mode. Master: MOSI pin is output; Slave: MISO pin is output.

enum spi_data_bitcount_mode_t

Enumerator
kSPI_8BitMode | 8-bit data transmission mode
kSPI_16BitMode | 16-bit data transmission mode

enum _spi_interrupt_enable

Enumerator
kSPI_RxFullAndModfInterruptEnable | Receive buffer full (SPRF) and mode fault (MODF) interrupt.
kSPI_TxEmptyInterruptEnable | Transmit buffer empty interrupt.
kSPI_MatchInterruptEnable | Match interrupt.

enum _spi_flags

Enumerator
kSPI_RxBufferFullFlag | Read buffer full flag.
kSPI_MatchFlag | Match flag.
kSPI_TxBufferEmptyFlag | Transmit buffer empty flag.
kSPI_ModeFaultFlag | Mode fault flag.

## Function Documentation

void SPI_MasterGetDefaultConfig | ( | spi_master_config_t * | config | ) |

The purpose of this API is to get the configuration structure initialized for use in SPI_MasterInit(). User may use the initialized structure unchanged in SPI_MasterInit(), or modify some fields of the structure before calling SPI_MasterInit(). After calling this API, the master is ready to transfer. Example:

spi_master_config_t config;
SPI_MasterGetDefaultConfig(&config);

Parameters

  config | pointer to master config structure

void SPI_MasterInit | ( | SPI_Type * | base,
|  | const spi_master_config_t * | config,
|  | uint32_t | srcClock_Hz
| ) |  |

The configuration structure can be filled by user from scratch, or be set with default values by SPI_MasterGetDefaultConfig(). After calling this API, the slave is ready to transfer. Example

spi_master_config_t config = {
.baudRate_Bps = 400000,
...
};
SPI_MasterInit(SPI0, &config);

Parameters

  base | SPI base pointer
  config | pointer to master configuration structure
  srcClock_Hz | Source clock frequency.

void SPI_SlaveGetDefaultConfig | ( | spi_slave_config_t * | config | ) |

The purpose of this API is to get the configuration structure initialized for use in SPI_SlaveInit(). Modify some fields of the structure before calling SPI_SlaveInit(). Example:

spi_slave_config_t config;
SPI_SlaveGetDefaultConfig(&config);

Parameters

  config | pointer to slave configuration structure

void SPI_SlaveInit | ( | SPI_Type * | base,
|  | const spi_slave_config_t * | config
| ) |  |

The configuration structure can be filled by user from scratch or be set with default values by SPI_SlaveGetDefaultConfig(). After calling this API, the slave is ready to transfer. Example

spi_slave_config_t config = {
.polarity = kSPIClockPolarity_ActiveHigh;
.phase = kSPIClockPhase_FirstEdge;
.direction = kSPIMsbFirst;
...
};
SPI_MasterInit(SPI0, &config);

Parameters

  base | SPI base pointer
  config | pointer to master configuration structure

void SPI_Deinit | ( | SPI_Type * | base | ) |

Calling this API resets the SPI module, gates the SPI clock. The SPI module can't work unless calling the SPI_MasterInit/SPI_SlaveInit to initialize module.

Parameters

  base | SPI base pointer

static void SPI_Enable | ( | I2C_Type * | base,
|  | bool | enable
| ) |  |
| inline static

Parameters

  base | SPI base pointer
  enable | pass true to enable module, false to disable module

uint32_t SPI_GetStatusFlags | ( | SPI_Type * | base | ) |

Parameters

  base | SPI base pointer

Returns
  SPI Status, use status flag to AND _spi_flags could get the related status.

void SPI_EnableInterrupts | ( | SPI_Type * | base,
|  | uint32_t | mask
| ) |  |

Parameters

  base | SPI base pointer
  mask | SPI interrupt source. The parameter can be any combination of the following values: kSPI_RxFullAndModfInterruptEnable kSPI_TxEmptyInterruptEnable kSPI_MatchInterruptEnable kSPI_RxFifoNearFullInterruptEnable kSPI_TxFifoNearEmptyInterruptEnable

void SPI_DisableInterrupts | ( | SPI_Type * | base,
|  | uint32_t | mask
| ) |  |

Parameters

  base | SPI base pointer
  mask | SPI interrupt source. The parameter can be any combination of the following values: kSPI_RxFullAndModfInterruptEnable kSPI_TxEmptyInterruptEnable kSPI_MatchInterruptEnable kSPI_RxFifoNearFullInterruptEnable kSPI_TxFifoNearEmptyInterruptEnable

static uint32_t SPI_GetDataRegisterAddress | ( | SPI_Type * | base | ) |
| inline static

This API is used to provide a transfer address for the SPI DMA transfer configuration.

Parameters

  base | SPI base pointer

Returns
  data register address

void SPI_MasterSetBaudRate | ( | SPI_Type * | base,
|  | uint32_t | baudRate_Bps,
|  | uint32_t | srcClock_Hz
| ) |  |

This is only used in master.

Parameters

  base | SPI base pointer
  baudRate_Bps | baud rate needed in Hz.
  srcClock_Hz | SPI source clock frequency in Hz.

static void SPI_SetMatchData | ( | SPI_Type * | base,
|  | uint32_t | matchData
| ) |  |
| inline static

The match data is a hardware comparison value. When the value received in the SPI receive data buffer equals the hardware comparison value, the SPI Match Flag in the S register (S[SPMF]) sets. This can also generate an interrupt if the enable bit sets.

Parameters

  base | SPI base pointer
  matchData | Match data.

void SPI_WriteBlocking | ( | SPI_Type * | base,
|  | uint8_t * | buffer,
|  | size_t | size
| ) |  |

Note
  This function blocks via polling until all bytes have been sent.

Parameters

  base | SPI base pointer
  buffer | The data bytes to send
  size | The number of data bytes to send

void SPI_WriteData | ( | SPI_Type * | base,
|  | uint16_t | data
| ) |  |

Parameters

  base | SPI base pointer
  data | needs to be write.

uint16_t SPI_ReadData | ( | SPI_Type * | base | ) |

Parameters

  base | SPI base pointer

Returns
  Data in the register.

void SPI_MasterTransferCreateHandle | ( | SPI_Type * | base,
|  | spi_master_handle_t * | handle,
|  | spi_master_callback_t | callback,
|  | void * | userData
| ) |  |

This function initializes the SPI master handle which can be used for other SPI master transactional APIs. Usually, for a specified SPI instance, call this API once to get the initialized handle.

Parameters

  base | SPI peripheral base address.
  handle | SPI handle pointer.
  callback | Callback function.
  userData | User data.

status_t SPI_MasterTransferBlocking | ( | SPI_Type * | base,
|  | spi_transfer_t * | xfer
| ) |  |

Parameters

  base | SPI base pointer
  xfer | pointer to spi_xfer_config_t structure

Return values

  kStatus_Success | Successfully start a transfer.
  kStatus_InvalidArgument | Input argument is invalid.

status_t SPI_MasterTransferNonBlocking | ( | SPI_Type * | base,
|  | spi_master_handle_t * | handle,
|  | spi_transfer_t * | xfer
| ) |  |

Note
  The API immediately returns after transfer initialization is finished. Call SPI_GetStatusIRQ() to get the transfer status.
  If using the SPI with FIFO for the interrupt transfer, the transfer size is the integer times of the watermark. Otherwise, the last data may be lost because it cannot generate an interrupt request. Users can also call the functional API to get the last received data.

Parameters

  base | SPI peripheral base address.
  handle | pointer to spi_master_handle_t structure which stores the transfer state
  xfer | pointer to spi_xfer_config_t structure

Return values

  kStatus_Success | Successfully start a transfer.
  kStatus_InvalidArgument | Input argument is invalid.
  kStatus_SPI_Busy | SPI is not idle, is running another transfer.

status_t SPI_MasterTransferGetCount | ( | SPI_Type * | base,
|  | spi_master_handle_t * | handle,
|  | size_t * | count
| ) |  |

Parameters

  base | SPI peripheral base address.
  handle | Pointer to SPI transfer handle, this should be a static variable.
  count | Transferred bytes of SPI master.

Return values

  kStatus_SPI_Success | Succeed get the transfer count.
  kStatus_NoTransferInProgress | There is not a non-blocking transaction currently in progress.

void SPI_MasterTransferAbort | ( | SPI_Type * | base,
|  | spi_master_handle_t * | handle
| ) |  |

Parameters

  base | SPI peripheral base address.
  handle | Pointer to SPI transfer handle, this should be a static variable.

void SPI_MasterTransferHandleIRQ | ( | SPI_Type * | base,
|  | spi_master_handle_t * | handle
| ) |  |

Parameters

  base | SPI peripheral base address.
  handle | pointer to spi_master_handle_t structure which stores the transfer state.

static void SPI_SlaveTransferCreateHandle | ( | SPI_Type * | base,
|  | spi_slave_handle_t * | handle,
|  | spi_slave_callback_t | callback,
|  | void * | userData
| ) |  |
| inline static

This function initializes the SPI slave handle which can be used for other SPI slave transactional APIs. Usually, for a specified SPI instance, call this API once to get the initialized handle.

Parameters

  base | SPI peripheral base address.
  handle | SPI handle pointer.
  callback | Callback function.
  userData | User data.

static status_t SPI_SlaveTransferNonBlocking | ( | SPI_Type * | base,
|  | spi_slave_handle_t * | handle,
|  | spi_transfer_t * | xfer
| ) |  |
| inline static

Note
  The API returns immediately after the transfer initialization is finished. Call SPI_GetStatusIRQ() to get the transfer status.
  If using the SPI with FIFO for the interrupt transfer, the transfer size is the integer times the watermark. Otherwise, the last data may be lost because it cannot generate an interrupt request. Call the functional API to get the last several receive data.

Parameters

  base | SPI peripheral base address.
  handle | pointer to spi_master_handle_t structure which stores the transfer state
  xfer | pointer to spi_xfer_config_t structure

Return values

  kStatus_Success | Successfully start a transfer.
  kStatus_InvalidArgument | Input argument is invalid.
  kStatus_SPI_Busy | SPI is not idle, is running another transfer.

static status_t SPI_SlaveTransferGetCount | ( | SPI_Type * | base,
|  | spi_slave_handle_t * | handle,
|  | size_t * | count
| ) |  |
| inline static

Parameters

  base | SPI peripheral base address.
  handle | Pointer to SPI transfer handle, this should be a static variable.
  count | Transferred bytes of SPI slave.

Return values

  kStatus_SPI_Success | Succeed get the transfer count.
  kStatus_NoTransferInProgress | There is not a non-blocking transaction currently in progress.

static void SPI_SlaveTransferAbort | ( | SPI_Type * | base,
|  | spi_slave_handle_t * | handle
| ) |  |
| inline static

Parameters

  base | SPI peripheral base address.
  handle | Pointer to SPI transfer handle, this should be a static variable.

static void SPI_SlaveTransferHandleIRQ | ( | SPI_Type * | base,
|  | spi_slave_handle_t * | handle
| ) |  |
| inline static

Parameters

  base | SPI peripheral base address.
  handle | pointer to spi_slave_handle_t structure which stores the transfer state