SPI.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015-2019, Texas Instruments Incorporated
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * * Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * * Neither the name of Texas Instruments Incorporated nor the names of
17  * its contributors may be used to endorse or promote products derived
18  * from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32 /*!*****************************************************************************
33  * @file SPI.h
34  *
35  * @brief Serial Peripheral Interface (SPI) Driver Interface
36  *
37  * @anchor ti_drivers_SPI_Overview
38  * # Overview
39  * The Serial Peripheral Interface (SPI) driver is a generic, full-duplex
40  * driver that transmits and receives data on a SPI bus. SPI is sometimes
41  * called SSI (Synchronous Serial Interface).
42  * The SPI protocol defines the format of a data transfer over the SPI bus,
43  * but it leaves flow control, data formatting, and handshaking mechanisms
44  * to higher-level software layers.
45  *
46  * The SPI driver operates on some key definitions and assumptions:
47  * - The driver operates transparently from the chip select. Some SPI
48  * controllers feature a hardware chip select to assert SPI slave
49  * peripherals. See the specific device implementations on chip
50  * select requirements.
51  *
52  * - The SPI protocol does not account for a built-in handshaking mechanism
53  * and neither does this SPI driver. Therefore, when operating in
54  * #SPI_SLAVE mode, the application must provide such a mechanism to
55  * ensure that the SPI slave is ready for the SPI master. The SPI slave
56  * must call #SPI_transfer() *before* the SPI master starts transmitting.
57  * Some example application mechanisms could include:
58  * - Timed delays on the SPI master to guarantee the SPI slave is ready
59  * for a SPI transaction.
60  * - A form of GPIO flow control from the slave to the SPI master to notify
61  * the master when ready.
62  *
63  * <hr>
64  * @anchor ti_drivers_SPI_Usage
65  * # Usage
66  *
67  * To use the SPI driver to send data over the SPI bus, the application
68  * calls the following APIs:
69  * - SPI_init(): Initialize the SPI driver.
70  * - SPI_Params_init(): Initialize a #SPI_Params structure with default
71  * values. Then change the parameters from non-default values as
72  * needed.
73  * - SPI_open(): Open an instance of the SPI driver, passing the
74  * initialized parameters, or NULL, and an index to the configuration to
75  * open (detailed later).
76  * - SPI_transfer(): Transmit/receive data. This function takes a
77  * #SPI_Transaction argument that describes the transfer that is requested.
78  * - SPI_close(): De-initialize the SPI instance.
79  *
80  * @anchor ti_drivers_SPI_Synopsis
81  * ## Synopsis
82  * The following code example opens a SPI instance as a master SPI,
83  * and issues a transaction.
84  *
85  * @code
86  * SPI_Handle spi;
87  * SPI_Params spiParams;
88  * SPI_Transaction spiTransaction;
89  * uint8_t transmitBuffer[MSGSIZE];
90  * uint8_t receiveBuffer[MSGSIZE];
91  * bool transferOK;
92  *
93  * SPI_init(); // Initialize the SPI driver
94  *
95  * SPI_Params_init(&spiParams); // Initialize SPI parameters
96  * spiParams.dataSize = 8; // 8-bit data size
97  *
98  * spi = SPI_open(CONFIG_SPI0, &spiParams);
99  * if (spi == NULL) {
100  * while (1); // SPI_open() failed
101  * }
102  *
103  * // Fill in transmitBuffer
104  * spiTransaction.count = MSGSIZE;
105  * spiTransaction.txBuf = (void *)transmitBuffer;
106  * spiTransaction.rxBuf = (void *)receiveBuffer;
107  *
108  * transferOK = SPI_transfer(spi, &spiTransaction);
109  * if (!transferOK) {
110  * // Error in SPI or transfer already in progress.
111  * while (1);
112  * }
113  * @endcode
114  *
115  * More details on usage are provided in the following subsections.
116  *
117  * @anchor ti_drivers_SPI_Examples
118  * ## Examples #
119  * * @ref ti_drivers_SPI_Synopsis "Usage Synopsis"
120  * * @ref ti_drivers_SPI_Example_openblocking "Open in blocking mode"
121  * * @ref ti_drivers_SPI_Example_opencallback "Open in callback mode"
122  * * @ref ti_drivers_SPI_Example_6bitframes "Sending 6 bit frames"
123  * * @ref ti_drivers_SPI_Example_12bitframes "Sending 12 bit frames"
124  * * @ref ti_drivers_SPI_Example_callbackarg "Callback function using arg"
125  *
126  * ## Initializing the SPI Driver
127  *
128  * SPI_init() must be called before any other SPI APIs. This function
129  * iterates through the elements of the @p SPI_config[] array, calling
130  * the element's device implementation SPI initialization function.
131  *
132  * ## Opening the SPI Driver
133  * After initializing the SPI driver by calling SPI_init(), the application
134  * can open a SPI instance by calling SPI_open(). This function
135  * takes an index into the @p SPI_config[] array, and a SPI parameters data
136  * structure. The SPI instance is specified by the index of the SPI in
137  * @p SPI_config[]. Calling SPI_open() a second time with the same index
138  * previously passed to SPI_open() will result in an error. You can,
139  * though, re-use the index if the instance is closed via SPI_close().
140  *
141  * If no #SPI_Params structure is passed to SPI_open(), default values are
142  * used. If the open call is successful, it returns a non-NULL value.
143  *
144  * @anchor ti_drivers_SPI_Example_openblocking
145  * Example opening a SPI driver instance in blocking mode:
146  * @code
147  * SPI_Handle spi;
148  * SPI_Params spiParams;
149  *
150  * SPI_Params_init(&spiParams);
151  * spiParams.transferMode = SPI_MODE_BLOCKING;
152  * spi = SPI_open(CONFIG_SPI0, &spiParams);
153  *
154  * if (spi == NULL) {
155  * // Error opening SPI
156  * while(1);
157  * }
158  * @endcode
159  *
160  * @anchor ti_drivers_SPI_Example_opencallback
161  * Example opening a SPI driver instance in callback mode:
162  * @code
163  * SPI_Handle spi;
164  * SPI_Params spiParams;
165  *
166  * SPI_Params_init(&spiParams);
167  * spiParams.transferMode = SPI_MODE_CALLBACK;
168  * spiParams.transferCallbackFxn = UserCallbackFxn;
169  *
170  * spi = SPI_open(CONFIG_SPI0, &spiParams);
171  * if (spi == NULL) {
172  * // Error opening SPI
173  * while (1);
174  * }
175  * @endcode
176  *
177  * ## SPI Parameters
178  *
179  * The #SPI_Params structure is passed to the SPI_open() call. If NULL
180  * is passed for the parameters, SPI_open() uses default parameters.
181  * A #SPI_Params structure is initialized with default values by passing
182  * it to SPI_Params_init().
183  * Some of the SPI parameters are described below. To see brief descriptions
184  * of all the parameters, see #SPI_Params.
185  *
186  * ### SPI Mode
187  * The SPI driver operates in both SPI master and SPI slave modes.
188  * Logically, the implementation is identical, however the difference
189  * between these two modes is driven by hardware. The default mode is
190  * #SPI_MASTER, but can be set to slave mode by setting #SPI_Params.mode
191  * to #SPI_SLAVE in the parameters passed to SPI_open(). See
192  * @ref ti_drivers_SPI_MasterSlaveModes "Master/Slave Modes" for further
193  * details.
194  *
195  * ### SPI Transfer Mode
196  * The SPI driver supports two transfer modes of operation: blocking and
197  * callback. The transfer mode is determined by the transferMode parameter
198  * in the #SPI_Params data structure. The SPI driver
199  * defaults to blocking mode, if the application does not set it.
200  * Once a SPI driver is opened, the only way to change the operation mode
201  * is to close and re-open the SPI instance with the new transfer mode.
202  *
203  * In blocking mode, a task's code execution is blocked until a SPI
204  * transaction has completed or a timeout has occurred. This ensures
205  * that only one SPI transfer operates at a given time. Other tasks requesting
206  * SPI transfers while a transfer is currently taking place will receive
207  * a FALSE return value. If a timeout occurs the transfer is canceled, the
208  * task is unblocked & will receive a FALSE return value. The transaction
209  * count field will have the amount of frames which were transferred
210  * successfully before the timeout. In blocking mode, transfers cannot be
211  * performed in software or hardware ISR context.
212  *
213  * In callback mode, a SPI transaction functions asynchronously, which
214  * means that it does not block code execution. After a SPI transaction
215  * has been completed, the SPI driver calls a user-provided hook function.
216  * Callback mode is supported in the execution context of tasks and
217  * hardware interrupt routines.
218  *
219  * ### SPI Frame Formats and Data Size
220  * The SPI driver can configure the device's SPI peripheral to transfer
221  * data in several SPI format options: SPI (with various polarity and phase
222  * settings), TI, and Micro-wire. The frame format is set with
223  * #SPI_Params.frameFormat. Some SPI implementations may not support all frame
224  * formats & the SPI driver will fail to opened. Refer to the device specific
225  * implementation documentation for details on which frame formats are
226  * supported.
227  *
228  * The smallest single unit of data transmitted onto the SPI bus is called
229  * a SPI frame and is of size #SPI_Params.dataSize. A series of SPI frames
230  * transmitted/received on a SPI bus is referred to as a SPI transaction.
231  *
232  * ## SPI Transactions
233  *
234  * A SPI transaction consists of a series of SPI frames
235  * transmitted/received on a SPI bus. A SPI transaction is performed
236  * using SPI_transfer(). SPI_transfer() accepts a pointer to a
237  * #SPI_Transaction structure that dictates the quantity of data to be
238  * sent and received.
239  * The #SPI_Transaction.txBuf and #SPI_Transaction.rxBuf are both pointers
240  * to data buffers. If txBuf is NULL, the driver sends SPI frames with all
241  * data set to the default value specified in the hardware attributes. If
242  * rxBuf is NULL, the driver discards all SPI frames received. SPI_transfer()
243  * of a SPI transaction is performed atomically.
244  *
245  * @warning The use of NULL as a sentinel txBuf or rxBuf value to determine
246  * whether the SPI transaction includes a tx or rx component implies
247  * that it is not possible to perform a transmit or receive transfer
248  * directly from/to a buffer with a base address of 0x00000000. To support
249  * this rare use-case, the application will have to manually copy the
250  * contents of location 0x00000000 to/from a temporary buffer before/after
251  * the tx/rx SPI transaction.
252  *
253  * When the SPI is opened, the dataSize value determines the element types
254  * of txBuf and rxBuf. If the dataSize is from 4 to 8 bits, the driver
255  * assumes the data buffers are of type uint8_t (unsigned char). If the
256  * dataSize is from 8 to 16 bits, the driver assumes the data buffers are
257  * of type uint16_t (unsigned short). If the dataSize is greater than
258  * 16 bits, the driver assumes the data buffers are uint32_t (unsigned long).
259  * Some SPI driver implementations may not support all data sizes; refer
260  * to device specific SPI implementation documentation for details on
261  * what data sizes are supported.
262  *
263  * The optional #SPI_Transaction.arg variable can only be used when the
264  * SPI driver has been opened in callback mode. This variable is used to
265  * pass a user-defined value into the user-defined callback function.
266  *
267  * SPI_transfer() always performs full-duplex SPI transactions. This means
268  * the SPI simultaneously receives data as it transmits data. The application
269  * is responsible for formatting the data to be transmitted as well as
270  * determining whether the data received is meaningful.
271  * Specifics about SPI frame formatting and data sizes are provided in
272  * device-specific data sheets and technical reference manuals.
273  *
274  * The following code snippets perform SPI transactions.
275  *
276  * @anchor ti_drivers_SPI_Example_6bitframes
277  * Example transferring 6-bit SPI frames. The transmit and receive
278  * buffers are of type uint8_t.
279  * @code
280  * SPI_Transaction spiTransaction;
281  * uint8_t transmitBuffer[BUFSIZE];
282  * uint8_t receiveBuffer[BUFSIZE];
283  * bool transferOK;
284  *
285  * SPI_Params_init(&spiParams);
286  * spiParams.dataSize = 6;
287  * spi = SPI_open(CONFIG_SPI0, &spiParams);
288  * ...
289  * spiTransaction.count = someIntegerValue;
290  * spiTransaction.txBuf = transmitBuffer;
291  * spiTransaction.rxBuf = receiveBuffer;
292  *
293  * transferOK = SPI_transfer(spi, &spiTransaction);
294  * if (!transferOK) {
295  * // Error in SPI or transfer already in progress.
296  * }
297  * @endcode
298  *
299  * @anchor ti_drivers_SPI_Example_12bitframes
300  * Example transferring 12-bit SPI frames. The transmit and receive
301  * buffers are of type uint16_t.
302  * @code
303  * SPI_Transaction spiTransaction;
304  * uint16_t transmitBuffer[BUFSIZE];
305  * uint16_t receiveBuffer[BUFSIZE];
306  * bool transferOK;
307  *
308  * SPI_Params_init(&spiParams);
309  * spiParams.dataSize = 12;
310  * spi = SPI_open(CONFIG_SPI0, &spiParams);
311  * ...
312  * spiTransaction.count = someIntegerValue;
313  * spiTransaction.txBuf = transmitBuffer;
314  * spiTransaction.rxBuf = receiveBuffer;
315  *
316  * transferOK = SPI_transfer(spi, &spiTransaction);
317  * if (!transferOK) {
318  * // Error in SPI or transfer already in progress.
319  * }
320  * @endcode
321  *
322  * The following example shows an example of a callback function that
323  * utilizes the arg parameter.
324  * @anchor ti_drivers_SPI_Example_callbackarg
325  * @code
326  * // SPI is opened with callback function as seen in other examples
327  * // Our goal is to post a semaphore when transfer with sufficient size
328  * // completes.
329  * ...
330  * // Pass pointer to an initialized semaphore to callback via arg
331  * spiTransaction.count = someIntegerValue;
332  * spiTransaction.txBuf = transmitBuffer;
333  * spiTransaction.rxBuf = receiveBuffer;
334  * spiTransaction.arg = &mySemaphore;
335  *
336  * ...
337  *
338  * // Our callback function is defined here
339  * void spiCallbackFxn(SPI_Handle spi, SPI_Transaction *tran)
340  * {
341  * sem_t *semPtr = (sem_t *)(tran->arg);
342  *
343  * // Post the semaphore if our transaction was more than LIMIT
344  * if (tran->status == SPI_STATUS_SUCCESS &&
345  * tran->count > LIMIT) {
346  * sem_post(semPtr);
347  * }
348  * }
349  * @endcode
350  *
351  * ## Canceling a transaction
352  * SPI_transferCancel() is used to cancel a SPI transaction when the driver is
353  * used in #SPI_MODE_CALLBACK mode.
354  *
355  * Calling this API while no transfer is in progress has no effect. If a
356  * transfer is in progress, it is canceled and the callback functions is
357  * called.
358  * The #SPI_Status status field in the #SPI_Transaction structure
359  * can be examined within the callback to determine if the transaction
360  * succeeded.
361  *
362  * Example:
363  * @code
364  * SPI_transferCancel(spi);
365  * @endcode
366  *
367  * @anchor ti_drivers_SPI_MasterSlaveModes
368  * ## Master/Slave Modes
369  * This SPI driver functions in both SPI master and SPI slave modes.
370  * Logically, the implementation is identical, however the difference between
371  * these two modes is driven by hardware. As a SPI master, the peripheral is
372  * in control of the clock signal and therefore will commence communications
373  * to the SPI slave immediately. As a SPI slave, the SPI driver prepares
374  * the peripheral to transmit and receive data in a way such that the
375  * peripheral is ready to transfer data when the SPI master initiates a
376  * transaction.
377  *
378  * ## Asserting on Chip Select
379  * The SPI protocol requires that the SPI master asserts a SPI slave's chip
380  * select pin prior to starting a SPI transaction. While this protocol is
381  * generally followed, various types of SPI peripherals have different
382  * timing requirements as to when and for how long the chip select pin must
383  * remain asserted for a SPI transaction.
384  *
385  * Commonly, the SPI master uses a hardware chip select to assert and
386  * de-assert the SPI slave for every data frame. In other cases, a SPI slave
387  * imposes the requirement of asserting the chip select over several SPI
388  * data frames. This is generally accomplished by using a regular,
389  * general-purpose output pin. Due to the complexity of such SPI peripheral
390  * implementations, this SPI driver has been designed to operate
391  * transparently to the SPI chip select. When the hardware chip
392  * select is used, the peripheral automatically selects/enables the
393  * peripheral. When using a software chip select, the application needs to
394  * handle the proper chip select and pin configuration. Chip select support
395  * will vary per SPI peripheral, refer to the device specific implementation
396  * documentation for details on chip select support.
397  *
398  * - _Hardware chip select_ No additional action by the application is
399  * required.
400  * - _Software chip select_ The application needs to handle the chip select
401  * assertion and de-assertion for the proper SPI peripheral.
402  *
403  * <hr>
404  * @anchor ti_drivers_SPI_Configuration
405  * # Configuration
406  *
407  * In order to use the SPI APIs, the application is required to provide
408  * device-specific SPI configuration in the ti_drivers_config.c file.
409  * The SPI driver interface defines a configuration data structure:
410  *
411  * @code
412  * typedef struct {
413  * SPI_FxnTable const *fxnTablePtr;
414  * void *object;
415  * void const *hwAttrs;
416  * } SPI_Config;
417  * @endcode
418  *
419  * The application must declare an array of #SPI_Config elements, named
420  * @p SPI_config[]. Each element of @p SPI_config[] must be populated with
421  * pointers to a device specific SPI driver implementation's function
422  * table, driver object, and hardware attributes. The hardware attributes
423  * define properties such as the SPI peripheral's base address, and
424  * the MOSI and MISO pins. Each element in @p SPI_config[] corresponds to
425  * a SPI instance, and none of the elements should have NULL pointers.
426  * There is no correlation between the index and the
427  * peripheral designation (such as SPI0 or SPI1). For example, it is
428  * possible to use SPI_config[0] for SPI1.
429  *
430  * Because the SPI configuration is very device dependent, you will need to
431  * check the doxygen for the device specific SPI implementation. There you
432  * will find a description of the SPI hardware attributes. Please also
433  * refer to the ti_drivers_config.c file of any of your examples to see the
434  * SPI configuration.
435  *
436  *******************************************************************************
437  */
438 
439 #ifndef ti_drivers_SPI__include
440 #define ti_drivers_SPI__include
441 
442 #include <stdbool.h>
443 #include <stddef.h>
444 #include <stdint.h>
445 
446 #ifdef __cplusplus
447 extern "C" {
448 #endif
449 
467 #define SPI_CMD_RESERVED (32)
468 
481 #define SPI_STATUS_RESERVED (-32)
482 
496 #define SPI_STATUS_SUCCESS (0)
497 
504 #define SPI_STATUS_ERROR (-1)
505 
513 #define SPI_STATUS_UNDEFINEDCMD (-2)
514 
524 /* Add SPI_CMD_<commands> here */
525 
533 #define SPI_WAIT_FOREVER (~(0U))
534 
538 typedef struct SPI_Config_ *SPI_Handle;
539 
543 typedef enum {
553 } SPI_Status;
554 
563 typedef struct {
564  /* User input (write-only) fields */
565  size_t count;
566  void *txBuf;
567  void *rxBuf;
568  void *arg;
570  /* User output (read-only) fields */
571  SPI_Status status;
573  void *nextPtr;
576 
584 typedef void (*SPI_CallbackFxn) (SPI_Handle handle,
585  SPI_Transaction *transaction);
590 typedef enum {
593 } SPI_Mode;
594 
599 typedef enum {
604  SPI_TI = 4,
606  SPI_MW = 5
609 
620 typedef enum {
633 
642 typedef struct {
643  SPI_TransferMode transferMode;
644  uint32_t transferTimeout;
661  uint32_t bitRate;
662  uint32_t dataSize;
664  void *custom;
666 } SPI_Params;
667 
672 typedef void (*SPI_CloseFxn) (SPI_Handle handle);
673 
678 typedef int_fast16_t (*SPI_ControlFxn) (SPI_Handle handle, uint_fast16_t cmd,
679  void *arg);
680 
685 typedef void (*SPI_InitFxn) (SPI_Handle handle);
686 
691 typedef SPI_Handle (*SPI_OpenFxn) (SPI_Handle handle, SPI_Params *params);
692 
697 typedef bool (*SPI_TransferFxn) (SPI_Handle handle,
698  SPI_Transaction *transaction);
699 
704 typedef void (*SPI_TransferCancelFxn) (SPI_Handle handle);
705 
711 typedef struct {
714 
717 
720 
723 
726 
729 } SPI_FxnTable;
730 
742 typedef struct SPI_Config_ {
745 
747  void *object;
748 
750  void const *hwAttrs;
751 } SPI_Config;
752 
762 extern void SPI_close(SPI_Handle handle);
763 
801 extern int_fast16_t SPI_control(SPI_Handle handle, uint_fast16_t cmd,
802  void *controlArg);
803 
812 extern void SPI_init(void);
813 
831 extern SPI_Handle SPI_open(uint_least8_t index, SPI_Params *params);
832 
848 extern void SPI_Params_init(SPI_Params *params);
849 
894 extern bool SPI_transfer(SPI_Handle handle, SPI_Transaction *transaction);
895 
915 extern void SPI_transferCancel(SPI_Handle handle);
916 
917 #ifdef __cplusplus
918 }
919 #endif
920 
921 #endif /* ti_drivers_SPI__include */
Definition: SPI.h:604
void SPI_init(void)
This function initializes the SPI module.
uint32_t bitRate
SPI bit rate in Hz.
Definition: SPI.h:661
size_t count
Definition: SPI.h:565
void const * hwAttrs
Definition: SPI.h:750
void(* SPI_CallbackFxn)(SPI_Handle handle, SPI_Transaction *transaction)
The definition of a callback function used by the SPI driver when used in SPI_MODE_CALLBACK.
Definition: SPI.h:584
SPI_FrameFormat frameFormat
Definition: SPI.h:663
void SPI_transferCancel(SPI_Handle handle)
Function to cancel SPI transactions.
uint32_t transferTimeout
Definition: SPI.h:644
Definition: SPI.h:550
SPI_TransferMode
SPI transfer mode determines the whether the SPI controller operates synchronously or asynchronously...
Definition: SPI.h:620
SPI_TransferMode transferMode
Definition: SPI.h:643
SPI_FxnTable const * fxnTablePtr
Definition: SPI.h:744
void SPI_Params_init(SPI_Params *params)
Function to initialize the SPI_Params struct to its defaults.
SPI_CloseFxn closeFxn
Definition: SPI.h:713
SPI_TransferCancelFxn transferCancelFxn
Definition: SPI.h:728
SPI Parameters.
Definition: SPI.h:642
SPI_Status
Status codes that are set by the SPI driver.
Definition: SPI.h:543
bool(* SPI_TransferFxn)(SPI_Handle handle, SPI_Transaction *transaction)
A function pointer to a driver specific implementation of SPI_transfer().
Definition: SPI.h:697
void * arg
Definition: SPI.h:568
void * nextPtr
Definition: SPI.h:573
SPI_ControlFxn controlFxn
Definition: SPI.h:716
Definition: SPI.h:625
void(* SPI_TransferCancelFxn)(SPI_Handle handle)
A function pointer to a driver specific implementation of SPI_transferCancel().
Definition: SPI.h:704
void * txBuf
Definition: SPI.h:566
The definition of a SPI function table that contains the required set of functions to control a speci...
Definition: SPI.h:711
Definition: SPI.h:548
void(* SPI_CloseFxn)(SPI_Handle handle)
A function pointer to a driver specific implementation of SPI_close().
Definition: SPI.h:672
uint32_t dataSize
Definition: SPI.h:662
int_fast16_t SPI_control(SPI_Handle handle, uint_fast16_t cmd, void *controlArg)
Function performs implementation specific features on a given SPI_Handle.
Definition: SPI.h:591
Definition: SPI.h:603
A SPI_Transaction data structure is used with SPI_transfer(). It indicates how many SPI_FrameFormat f...
Definition: SPI.h:563
SPI_OpenFxn openFxn
Definition: SPI.h:722
bool SPI_transfer(SPI_Handle handle, SPI_Transaction *transaction)
Function to perform SPI transactions.
struct SPI_Config_ SPI_Config
SPI Global configuration.
SPI_Mode
Definitions for various SPI modes of operation.
Definition: SPI.h:590
Definition: SPI.h:631
SPI Global configuration.
Definition: SPI.h:742
Definition: SPI.h:601
Definition: SPI.h:606
void * rxBuf
Definition: SPI.h:567
void SPI_close(SPI_Handle handle)
Function to close a SPI peripheral specified by the SPI handle.
struct SPI_Config_ * SPI_Handle
A handle that is returned from a SPI_open() call.
Definition: SPI.h:538
Definition: SPI.h:602
SPI_Handle SPI_open(uint_least8_t index, SPI_Params *params)
This function opens a given SPI peripheral.
Definition: SPI.h:547
int_fast16_t(* SPI_ControlFxn)(SPI_Handle handle, uint_fast16_t cmd, void *arg)
A function pointer to a driver specific implementation of SPI_control().
Definition: SPI.h:678
void(* SPI_InitFxn)(SPI_Handle handle)
A function pointer to a driver specific implementation of SPI_init().
Definition: SPI.h:685
SPI_TransferFxn transferFxn
Definition: SPI.h:725
void * custom
Definition: SPI.h:664
Definition: SPI.h:545
SPI_Handle(* SPI_OpenFxn)(SPI_Handle handle, SPI_Params *params)
A function pointer to a driver specific implementation of SPI_open().
Definition: SPI.h:691
SPI_CallbackFxn transferCallbackFxn
Definition: SPI.h:646
Definition: SPI.h:544
SPI_Status status
Definition: SPI.h:571
Definition: SPI.h:552
Definition: SPI.h:546
SPI_FrameFormat
Definitions for various SPI data frame formats.
Definition: SPI.h:599
SPI_Mode mode
Definition: SPI.h:647
Definition: SPI.h:600
SPI_InitFxn initFxn
Definition: SPI.h:719
void * object
Definition: SPI.h:747
Definition: SPI.h:592
© Copyright 1995-2019, Texas Instruments Incorporated. All rights reserved.
Trademarks | Privacy policy | Terms of use | Terms of sale