Generic SPI Driver. More...

Collaboration diagram for SPI Driver:

Detailed Description

Generic SPI Driver.

This module implements a generic SPI (Serial Peripheral Interface) driver allowing bidirectional and monodirectional transfers, complex atomic transactions are supported as well.

Precondition: In order to use the SPI driver the HAL_USE_SPI option must be enabled in halconf.h.

Driver State Machine

The driver implements a state machine internally, not all the driver functionalities can be used in any moment, any transition not explicitly shown in the following diagram has to be considered an error and shall be captured by an assertion (if enabled).

The driver is not thread safe for performance reasons, if you need to access the SPI bus from multiple threads then use the spiAcquireBus() and spiReleaseBus() APIs in order to gain exclusive access.

Macros
#define	SPI_SUPPORTS_CIRCULAR TRUE
	Circular mode support flag. More...

Chip Select modes
#define	SPI_SELECT_MODE_NONE

#define	SPI_SELECT_MODE_PAD 1 /** @brief Legacy mode. */

#define	SPI_SELECT_MODE_PORT 2 /** @brief Fastest mode. */

#define	SPI_SELECT_MODE_LINE 3 /** @brief Packed mode. */

#define	SPI_SELECT_MODE_LLD 4 /** @brief LLD-defined mode.*/

SPI configuration options
#define	SPI_USE_WAIT TRUE
	Enables synchronous APIs. More...

#define	SPI_USE_CIRCULAR FALSE
	Enables circular transfers APIs. More...

#define	SPI_USE_MUTUAL_EXCLUSION TRUE
	Enables the `spiAcquireBus()` and `spiReleaseBus()` APIs. More...

#define	SPI_SELECT_MODE SPI_SELECT_MODE_PAD
	Handling method for SPI CS line. More...

Macro Functions
#define	spiSelectI(spip)
	Asserts the slave select signal and prepares for transfers. More...

#define	spiUnselectI(spip)
	Deasserts the slave select signal. More...

#define	spiStartIgnoreI(spip, n)
	Ignores data on the SPI bus. More...

#define	spiStartExchangeI(spip, n, txbuf, rxbuf)
	Exchanges data on the SPI bus. More...

#define	spiStartSendI(spip, n, txbuf)
	Sends data over the SPI bus. More...

#define	spiStartReceiveI(spip, n, rxbuf)
	Receives data from the SPI bus. More...

#define	spiPolledExchange(spip, frame) spi_lld_polled_exchange(spip, frame)
	Exchanges one frame using a polled wait. More...

Low level driver helper macros
#define	_spi_wakeup_isr(spip)
	Wakes up the waiting thread. More...

#define	_spi_isr_code(spip)
	Common ISR code. More...

#define	_spi_isr_code_half1(spip)
	Common ISR code in circular mode. More...

#define	_spi_isr_code_half2(spip)
	Common ISR code in circular mode. More...

PLATFORM configuration options
#define	PLATFORM_SPI_USE_SPI1 FALSE
	SPI1 driver enable switch. More...

Typedefs
typedef struct SPIDriver	SPIDriver
	Type of a structure representing an SPI driver. More...

typedef void(*	spicallback_t) (SPIDriver *spip)
	SPI notification callback type. More...

Data Structures
struct	SPIConfig
	Driver configuration structure. More...

struct	SPIDriver
	Structure representing an SPI driver. More...

Functions
void	spiInit (void)
	SPI Driver initialization. More...

void	spiObjectInit (SPIDriver *spip)
	Initializes the standard part of a `SPIDriver` structure. More...

void	spiStart (SPIDriver spip, const SPIConfig config)
	Configures and activates the SPI peripheral. More...

void	spiStop (SPIDriver *spip)
	Deactivates the SPI peripheral. More...

void	spiSelect (SPIDriver *spip)
	Asserts the slave select signal and prepares for transfers. More...

void	spiUnselect (SPIDriver *spip)
	Deasserts the slave select signal. More...

void	spiStartIgnore (SPIDriver *spip, size_t n)
	Ignores data on the SPI bus. More...

void	spiStartExchange (SPIDriver spip, size_t n, const void txbuf, void *rxbuf)
	Exchanges data on the SPI bus. More...

void	spiStartSend (SPIDriver spip, size_t n, const void txbuf)
	Sends data over the SPI bus. More...

void	spiStartReceive (SPIDriver spip, size_t n, void rxbuf)
	Receives data from the SPI bus. More...

void	spiAbortI (SPIDriver *spip)
	Aborts the ongoing SPI operation. More...

void	spiAbort (SPIDriver *spip)
	Aborts the ongoing SPI operation, if any. More...

void	spiIgnore (SPIDriver *spip, size_t n)
	Ignores data on the SPI bus. More...

void	spiExchange (SPIDriver spip, size_t n, const void txbuf, void *rxbuf)
	Exchanges data on the SPI bus. More...

void	spiSend (SPIDriver spip, size_t n, const void txbuf)
	Sends data over the SPI bus. More...

void	spiReceive (SPIDriver spip, size_t n, void rxbuf)
	Receives data from the SPI bus. More...

void	spiAcquireBus (SPIDriver *spip)
	Gains exclusive access to the SPI bus. More...

void	spiReleaseBus (SPIDriver *spip)
	Releases exclusive access to the SPI bus. More...

void	spi_lld_init (void)
	Low level SPI driver initialization. More...

void	spi_lld_start (SPIDriver *spip)
	Configures and activates the SPI peripheral. More...

void	spi_lld_stop (SPIDriver *spip)
	Deactivates the SPI peripheral. More...

void	spi_lld_select (SPIDriver *spip)
	Asserts the slave select signal and prepares for transfers. More...

void	spi_lld_unselect (SPIDriver *spip)
	Deasserts the slave select signal. More...

void	spi_lld_ignore (SPIDriver *spip, size_t n)
	Ignores data on the SPI bus. More...

void	spi_lld_exchange (SPIDriver spip, size_t n, const void txbuf, void *rxbuf)
	Exchanges data on the SPI bus. More...

void	spi_lld_send (SPIDriver spip, size_t n, const void txbuf)
	Sends data over the SPI bus. More...

void	spi_lld_receive (SPIDriver spip, size_t n, void rxbuf)
	Receives data from the SPI bus. More...

void	spi_lld_abort (SPIDriver *spip)
	Aborts the ongoing SPI operation, if any. More...

uint16_t	spi_lld_polled_exchange (SPIDriver *spip, uint16_t frame)
	Exchanges one frame using a polled wait. More...

Enumerations

Variables
SPIDriver	SPID1
	SPI1 driver identifier. More...

Macro Definition Documentation

#define SPI_USE_WAIT TRUE

Enables synchronous APIs.

Note: Disabling this option saves both code and data space.

Definition at line 60 of file hal_spi.h.

#define SPI_USE_CIRCULAR FALSE

Enables circular transfers APIs.

Note: Disabling this option saves both code and data space.

Definition at line 68 of file hal_spi.h.

#define SPI_USE_MUTUAL_EXCLUSION TRUE

Enables the spiAcquireBus() and spiReleaseBus() APIs.

Note: Disabling this option saves both code and data space.

Definition at line 76 of file hal_spi.h.

#define SPI_SELECT_MODE SPI_SELECT_MODE_PAD

Handling method for SPI CS line.

Note: Disabling this option saves both code and data space.

Definition at line 84 of file hal_spi.h.

#define spiSelectI ( spip )

Value:

do {                                                                        \
  spi_lld_select(spip);                                                     \
} while (false)

Asserts the slave select signal and prepares for transfers.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:This is an I-Class API, this function can be invoked from within a system lock zone by both threads and interrupt handlers.

Definition at line 139 of file hal_spi.h.

Referenced by spiSelect().

#define spiUnselectI ( spip )

Value:

do {                                                                        \
  spi_lld_unselect(spip);                                                   \
} while (false)

Deasserts the slave select signal.

The previously selected peripheral is unselected.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:This is an I-Class API, this function can be invoked from within a system lock zone by both threads and interrupt handlers.

Definition at line 152 of file hal_spi.h.

Referenced by spiUnselect().

#define spiStartIgnoreI	(	spip,
		n
	)

Value:

{                                          \
  (spip)->state = SPI_ACTIVE;                                               \
  spi_lld_ignore(spip, n);                                                  \
}

Ignores data on the SPI bus.

This asynchronous function starts the transmission of a series of idle words on the SPI bus and ignores the received data.

Precondition: A slave must have been selected using spiSelect() or spiSelectI().

Postcondition: At the end of the operation the configured callback is invoked.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to be ignored

Function Class:This is an I-Class API, this function can be invoked from within a system lock zone by both threads and interrupt handlers.

Definition at line 209 of file hal_spi.h.

Referenced by spiIgnore(), and spiStartIgnore().

#define spiStartExchangeI	(	spip,
		n,
		txbuf,
		rxbuf
	)

Value:

{                          \
  (spip)->state = SPI_ACTIVE;                                               \
  spi_lld_exchange(spip, n, txbuf, rxbuf);                                  \
}

Exchanges data on the SPI bus.

This asynchronous function starts a simultaneous transmit/receive operation.

Precondition: A slave must have been selected using spiSelect() or spiSelectI().

Postcondition: At the end of the operation the configured callback is invoked.

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to be exchanged
[in]	txbuf	the pointer to the transmit buffer
[out]	rxbuf	the pointer to the receive buffer

Function Class:This is an I-Class API, this function can be invoked from within a system lock zone by both threads and interrupt handlers.

Definition at line 231 of file hal_spi.h.

Referenced by spiExchange(), and spiStartExchange().

#define spiStartSendI	(	spip,
		n,
		txbuf
	)

Value:

{                                     \
  (spip)->state = SPI_ACTIVE;                                               \
  spi_lld_send(spip, n, txbuf);                                             \
}

Sends data over the SPI bus.

This asynchronous function starts a transmit operation.

Precondition: A slave must have been selected using spiSelect() or spiSelectI().

Postcondition: At the end of the operation the configured callback is invoked.

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to send
[in]	txbuf	the pointer to the transmit buffer

Function Class:This is an I-Class API, this function can be invoked from within a system lock zone by both threads and interrupt handlers.

Definition at line 251 of file hal_spi.h.

Referenced by spiSend(), and spiStartSend().

#define spiStartReceiveI	(	spip,
		n,
		rxbuf
	)

Value:

{                                  \
  (spip)->state = SPI_ACTIVE;                                               \
  spi_lld_receive(spip, n, rxbuf);                                          \
}

Receives data from the SPI bus.

This asynchronous function starts a receive operation.

Precondition: A slave must have been selected using spiSelect() or spiSelectI().

Postcondition: At the end of the operation the configured callback is invoked.

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to receive
[out]	rxbuf	the pointer to the receive buffer

Function Class:This is an I-Class API, this function can be invoked from within a system lock zone by both threads and interrupt handlers.

Definition at line 271 of file hal_spi.h.

Referenced by spiReceive(), and spiStartReceive().

#define spiPolledExchange	(	spip,
		frame
	)	spi_lld_polled_exchange(spip, frame)

Exchanges one frame using a polled wait.

This synchronous function exchanges one frame using a polled synchronization method. This function is useful when exchanging small amount of data on high speed channels, usually in this situation is much more efficient just wait for completion using polling than suspending the thread waiting for an interrupt.

Note: This API is implemented as a macro in order to minimize latency.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	frame	the data frame to send over the SPI bus

Returns: The received data frame from the SPI bus.

Definition at line 289 of file hal_spi.h.

#define _spi_wakeup_isr ( spip )

Value:

{                                             \
  osalSysLockFromISR();                                                     \
  osalThreadResumeI(&(spip)->thread, MSG_OK);                               \
  osalSysUnlockFromISR();                                                   \
}

Wakes up the waiting thread.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Not an API, this function is for internal use only.

Definition at line 304 of file hal_spi.h.

#define _spi_isr_code ( spip )

Value:

{                                               \
  if ((spip)->config->end_cb) {                                             \
    (spip)->state = SPI_COMPLETE;                                           \
    (spip)->config->end_cb(spip);                                           \
    if ((spip)->state == SPI_COMPLETE)                                      \
      (spip)->state = SPI_READY;                                            \
  }                                                                         \
  else                                                                      \
    (spip)->state = SPI_READY;                                              \
  _spi_wakeup_isr(spip);                                                    \
}

Common ISR code.

This code handles the portable part of the ISR code:

Callback invocation.
Waiting thread wakeup, if any.
Driver state transitions.

Note: This macro is meant to be used in the low level drivers implementation only.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Not an API, this function is for internal use only.

Definition at line 327 of file hal_spi.h.

#define _spi_isr_code_half1 ( spip )

Value:

{                                         \
  if ((spip)->config->end_cb) {                                             \
    (spip)->config->end_cb(spip);                                           \
  }                                                                         \
}

Common ISR code in circular mode.

This code handles the portable part of the ISR code:

Callback invocation.

Note: This macro is meant to be used in the low level drivers implementation only.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Not an API, this function is for internal use only.

Definition at line 351 of file hal_spi.h.

#define _spi_isr_code_half2 ( spip )

Value:

{                                         \
  if ((spip)->config->end_cb) {                                             \
    (spip)->state = SPI_COMPLETE;                                           \
    (spip)->config->end_cb(spip);                                           \
    if ((spip)->state == SPI_COMPLETE)                                      \
      (spip)->state = SPI_ACTIVE;                                           \
  }                                                                         \
}

Common ISR code in circular mode.

This code handles the portable part of the ISR code:

Callback invocation.
Driver state transitions.

Note: This macro is meant to be used in the low level drivers implementation only.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Not an API, this function is for internal use only.

Definition at line 370 of file hal_spi.h.

#define SPI_SUPPORTS_CIRCULAR TRUE

Circular mode support flag.

Definition at line 37 of file hal_spi_lld.h.

#define PLATFORM_SPI_USE_SPI1 FALSE

SPI1 driver enable switch.

If set to TRUE the support for SPI1 is included.

Note: The default is FALSE.

Definition at line 53 of file hal_spi_lld.h.

Typedef Documentation

typedef struct SPIDriver SPIDriver

Type of a structure representing an SPI driver.

Definition at line 68 of file hal_spi_lld.h.

typedef void(* spicallback_t) (SPIDriver *spip)

SPI notification callback type.

Parameters

[in] spip pointer to the SPIDriver object triggering the callback

Definition at line 76 of file hal_spi_lld.h.

Enumeration Type Documentation

enum spistate_t

Driver state machine possible states.

Enumerator
SPI_UNINIT	Not initialized.
SPI_STOP	Stopped.
SPI_READY	Ready.
SPI_ACTIVE	Exchanging data.
SPI_COMPLETE	Asynchronous operation complete.

Definition at line 107 of file hal_spi.h.

Function Documentation

void spiInit ( void )

SPI Driver initialization.

Note: This function is implicitly invoked by halInit(), there is no need to explicitly initialize the driver.

Function Class:Initializer, this function just initializes an object and can be invoked before the kernel is initialized.

Definition at line 56 of file hal_spi.c.

References spi_lld_init().

Referenced by halInit().

Here is the call graph for this function:

void spiObjectInit ( SPIDriver * spip )

Initializes the standard part of a SPIDriver structure.

Parameters

[out] spip pointer to the SPIDriver object

Function Class:Initializer, this function just initializes an object and can be invoked before the kernel is initialized.

Definition at line 68 of file hal_spi.c.

References SPIDriver::config, SPIDriver::mutex, osalMutexObjectInit(), SPI_STOP, SPIDriver::state, and SPIDriver::thread.

Referenced by spi_lld_init().

Here is the call graph for this function:

void spiStart	(	SPIDriver *	spip,
		const SPIConfig *	config
	)

Configures and activates the SPI peripheral.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	config	pointer to the `SPIConfig` object

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 91 of file hal_spi.c.

References SPIDriver::config, osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), spi_lld_start(), SPI_READY, SPI_STOP, and SPIDriver::state.

Referenced by mmcConnect(), mmcDisconnect(), mmcStartSequentialRead(), mmcStartSequentialWrite(), and mmcSync().

Here is the call graph for this function:

void spiStop ( SPIDriver * spip )

Deactivates the SPI peripheral.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 111 of file hal_spi.c.

References SPIDriver::config, osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), spi_lld_stop(), SPI_READY, SPI_STOP, and SPIDriver::state.

Referenced by mmcConnect(), mmcDisconnect(), mmcErase(), mmcSequentialRead(), mmcSequentialWrite(), mmcStartSequentialRead(), mmcStartSequentialWrite(), and mmcStop().

Here is the call graph for this function:

void spiSelect ( SPIDriver * spip )

Asserts the slave select signal and prepares for transfers.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 134 of file hal_spi.c.

References osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), SPI_READY, spiSelectI, and SPIDriver::state.

Referenced by mmcStartSequentialRead(), mmcStartSequentialWrite(), read_CxD(), send_command_R1(), send_command_R3(), and sync().

Here is the call graph for this function:

void spiUnselect ( SPIDriver * spip )

Deasserts the slave select signal.

The previously selected peripheral is unselected.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 152 of file hal_spi.c.

References osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), SPI_READY, spiUnselectI, and SPIDriver::state.

Referenced by mmcSequentialRead(), mmcSequentialWrite(), mmcStopSequentialRead(), mmcStopSequentialWrite(), read_CxD(), send_command_R1(), send_command_R3(), and sync().

Here is the call graph for this function:

void spiStartIgnore	(	SPIDriver *	spip,
		size_t	n
	)

Ignores data on the SPI bus.

This asynchronous function starts the transmission of a series of idle words on the SPI bus and ignores the received data.

Precondition: A slave must have been selected using spiSelect() or spiSelectI().

Postcondition: At the end of the operation the configured callback is invoked.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to be ignored

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 175 of file hal_spi.c.

References osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), SPI_READY, spiStartIgnoreI, and SPIDriver::state.

Here is the call graph for this function:

void spiStartExchange	(	SPIDriver *	spip,
		size_t	n,
		const void *	txbuf,
		void *	rxbuf
	)

Exchanges data on the SPI bus.

This asynchronous function starts a simultaneous transmit/receive operation.

Precondition: A slave must have been selected using spiSelect() or spiSelectI().

Postcondition: At the end of the operation the configured callback is invoked.

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to be exchanged
[in]	txbuf	the pointer to the transmit buffer
[out]	rxbuf	the pointer to the receive buffer

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 202 of file hal_spi.c.

References osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), SPI_READY, spiStartExchangeI, and SPIDriver::state.

Here is the call graph for this function:

void spiStartSend	(	SPIDriver *	spip,
		size_t	n,
		const void *	txbuf
	)

Sends data over the SPI bus.

This asynchronous function starts a transmit operation.

Precondition: A slave must have been selected using spiSelect() or spiSelectI().

Postcondition: At the end of the operation the configured callback is invoked.

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to send
[in]	txbuf	the pointer to the transmit buffer

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 229 of file hal_spi.c.

References osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), SPI_READY, spiStartSendI, and SPIDriver::state.

Here is the call graph for this function:

void spiStartReceive	(	SPIDriver *	spip,
		size_t	n,
		void *	rxbuf
	)

Receives data from the SPI bus.

This asynchronous function starts a receive operation.

Precondition: A slave must have been selected using spiSelect() or spiSelectI().

Postcondition: At the end of the operation the configured callback is invoked.

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to receive
[out]	rxbuf	the pointer to the receive buffer

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 254 of file hal_spi.c.

References osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), SPI_READY, spiStartReceiveI, and SPIDriver::state.

Here is the call graph for this function:

void spiAbortI ( SPIDriver * spip )

Aborts the ongoing SPI operation.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:This is an I-Class API, this function can be invoked from within a system lock zone by both threads and interrupt handlers.

Definition at line 272 of file hal_spi.c.

References osalDbgAssert, osalDbgCheck, osalDbgCheckClassI, osalThreadResumeI(), SPI_ACTIVE, SPI_COMPLETE, spi_lld_abort(), SPI_READY, SPIDriver::state, and SPIDriver::thread.

Referenced by spiAbort().

Here is the call graph for this function:

void spiAbort ( SPIDriver * spip )

Aborts the ongoing SPI operation, if any.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 294 of file hal_spi.c.

References osalDbgAssert, osalOsRescheduleS(), osalSysLock(), osalSysUnlock(), SPI_ACTIVE, SPI_READY, spiAbortI(), and SPIDriver::state.

Here is the call graph for this function:

void spiIgnore	(	SPIDriver *	spip,
		size_t	n
	)

Ignores data on the SPI bus.

This synchronous function performs the transmission of a series of idle words on the SPI bus and ignores the received data.

Precondition: In order to use this function the option SPI_USE_WAIT must be enabled.; In order to use this function the driver must have been configured without callbacks (end_cb = NULL).

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to be ignored

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 322 of file hal_spi.c.

References SPIConfig::circular, SPIDriver::config, osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), osalThreadSuspendS(), SPI_READY, spiStartIgnoreI, SPIDriver::state, and SPIDriver::thread.

Referenced by mmcConnect(), mmcSequentialRead(), mmcSequentialWrite(), and read_CxD().

Here is the call graph for this function:

void spiExchange	(	SPIDriver *	spip,
		size_t	n,
		const void *	txbuf,
		void *	rxbuf
	)

Exchanges data on the SPI bus.

This synchronous function performs a simultaneous transmit/receive operation.

Precondition: In order to use this function the option SPI_USE_WAIT must be enabled.; In order to use this function the driver must have been configured without callbacks (end_cb = NULL).

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to be exchanged
[in]	txbuf	the pointer to the transmit buffer
[out]	rxbuf	the pointer to the receive buffer

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 354 of file hal_spi.c.

References SPIConfig::circular, SPIDriver::config, osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), osalThreadSuspendS(), SPI_READY, spiStartExchangeI, SPIDriver::state, and SPIDriver::thread.

Here is the call graph for this function:

void spiSend	(	SPIDriver *	spip,
		size_t	n,
		const void *	txbuf
	)

Sends data over the SPI bus.

This synchronous function performs a transmit operation.

Precondition: In order to use this function the option SPI_USE_WAIT must be enabled.; In order to use this function the driver must have been configured without callbacks (end_cb = NULL).

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to send
[in]	txbuf	the pointer to the transmit buffer

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 386 of file hal_spi.c.

References SPIConfig::circular, SPIDriver::config, osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), osalThreadSuspendS(), SPI_READY, spiStartSendI, SPIDriver::state, and SPIDriver::thread.

Referenced by mmcSequentialWrite(), mmcStopSequentialRead(), mmcStopSequentialWrite(), and send_hdr().

Here is the call graph for this function:

void spiReceive	(	SPIDriver *	spip,
		size_t	n,
		void *	rxbuf
	)

Receives data from the SPI bus.

This synchronous function performs a receive operation.

Precondition: In order to use this function the option SPI_USE_WAIT must be enabled.; In order to use this function the driver must have been configured without callbacks (end_cb = NULL).

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to receive
[out]	rxbuf	the pointer to the receive buffer

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 416 of file hal_spi.c.

References SPIConfig::circular, SPIDriver::config, osalDbgAssert, osalDbgCheck, osalSysLock(), osalSysUnlock(), osalThreadSuspendS(), SPI_READY, spiStartReceiveI, SPIDriver::state, and SPIDriver::thread.

Referenced by mmcSequentialRead(), mmcSequentialWrite(), read_CxD(), recvr1(), recvr3(), sync(), and wait().

Here is the call graph for this function:

void spiAcquireBus ( SPIDriver * spip )

Gains exclusive access to the SPI bus.

This function tries to gain ownership to the SPI bus, if the bus is already being used then the invoking thread is queued.

Precondition: In order to use this function the option SPI_USE_MUTUAL_EXCLUSION must be enabled.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 443 of file hal_spi.c.

References SPIDriver::mutex, osalDbgCheck, and osalMutexLock().

Here is the call graph for this function:

void spiReleaseBus ( SPIDriver * spip )

Releases exclusive access to the SPI bus.

Precondition: In order to use this function the option SPI_USE_MUTUAL_EXCLUSION must be enabled.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Normal API, this function can be invoked by regular system threads but not from within a lock zone.

Definition at line 459 of file hal_spi.c.

References SPIDriver::mutex, osalDbgCheck, and osalMutexUnlock().

Here is the call graph for this function:

void spi_lld_init ( void )

Low level SPI driver initialization.

Function Class:Not an API, this function is for internal use only.

Definition at line 65 of file hal_spi_lld.c.

References spiObjectInit().

Referenced by spiInit().

Here is the call graph for this function:

void spi_lld_start ( SPIDriver * spip )

Configures and activates the SPI peripheral.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Not an API, this function is for internal use only.

Definition at line 80 of file hal_spi_lld.c.

References SPI_STOP, and SPIDriver::state.

Referenced by spiStart().

void spi_lld_stop ( SPIDriver * spip )

Deactivates the SPI peripheral.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Not an API, this function is for internal use only.

Definition at line 101 of file hal_spi_lld.c.

References SPI_READY, and SPIDriver::state.

Referenced by spiStop().

void spi_lld_select ( SPIDriver * spip )

Asserts the slave select signal and prepares for transfers.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Not an API, this function is for internal use only.

Definition at line 120 of file hal_spi_lld.c.

void spi_lld_unselect ( SPIDriver * spip )

Deasserts the slave select signal.

The previously selected peripheral is unselected.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Not an API, this function is for internal use only.

Definition at line 134 of file hal_spi_lld.c.

void spi_lld_ignore	(	SPIDriver *	spip,
		size_t	n
	)

Ignores data on the SPI bus.

This asynchronous function starts the transmission of a series of idle words on the SPI bus and ignores the received data.

Postcondition: At the end of the operation the configured callback is invoked.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to be ignored

Function Class:Not an API, this function is for internal use only.

Definition at line 151 of file hal_spi_lld.c.

void spi_lld_exchange	(	SPIDriver *	spip,
		size_t	n,
		const void *	txbuf,
		void *	rxbuf
	)

Exchanges data on the SPI bus.

This asynchronous function starts a simultaneous transmit/receive operation.

Postcondition: At the end of the operation the configured callback is invoked.

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to be exchanged
[in]	txbuf	the pointer to the transmit buffer
[out]	rxbuf	the pointer to the receive buffer

Function Class:Not an API, this function is for internal use only.

Definition at line 173 of file hal_spi_lld.c.

void spi_lld_send	(	SPIDriver *	spip,
		size_t	n,
		const void *	txbuf
	)

Sends data over the SPI bus.

This asynchronous function starts a transmit operation.

Postcondition: At the end of the operation the configured callback is invoked.

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to send
[in]	txbuf	the pointer to the transmit buffer

Function Class:Not an API, this function is for internal use only.

Definition at line 196 of file hal_spi_lld.c.

void spi_lld_receive	(	SPIDriver *	spip,
		size_t	n,
		void *	rxbuf
	)

Receives data from the SPI bus.

This asynchronous function starts a receive operation.

Postcondition: At the end of the operation the configured callback is invoked.

Note: The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	n	number of words to receive
[out]	rxbuf	the pointer to the receive buffer

Function Class:Not an API, this function is for internal use only.

Definition at line 217 of file hal_spi_lld.c.

void spi_lld_abort ( SPIDriver * spip )

Aborts the ongoing SPI operation, if any.

Parameters

[in] spip pointer to the SPIDriver object

Function Class:Not an API, this function is for internal use only.

Definition at line 233 of file hal_spi_lld.c.

Referenced by spiAbortI().

uint16_t spi_lld_polled_exchange	(	SPIDriver *	spip,
		uint16_t	frame
	)

Exchanges one frame using a polled wait.

This synchronous function exchanges one frame using a polled synchronization method. This function is useful when exchanging small amount of data on high speed channels, usually in this situation is much more efficient just wait for completion using polling than suspending the thread waiting for an interrupt.

Parameters

[in]	spip	pointer to the `SPIDriver` object
[in]	frame	the data frame to send over the SPI bus

Returns: The received data frame from the SPI bus.

Function Class:Not an API, this function is for internal use only.

Definition at line 253 of file hal_spi_lld.c.

Variable Documentation

SPIDriver SPID1

SPI1 driver identifier.

Definition at line 41 of file hal_spi_lld.c.

Detailed Description

Driver State Machine

Macros

Chip Select modes

SPI configuration options

Macro Functions

Low level driver helper macros

PLATFORM configuration options

Typedefs

Data Structures

Functions

Enumerations

Variables

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation