flexio_spi_driver.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014 - 2016, Freescale Semiconductor, Inc.
3  * Copyright 2016 NXP
4  * All rights reserved.
5  *
6  * THIS SOFTWARE IS PROVIDED BY NXP "AS IS" AND ANY EXPRESSED OR
7  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
8  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
9  * IN NO EVENT SHALL NXP OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
10  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
11  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
12  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
13  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
14  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
15  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
16  * THE POSSIBILITY OF SUCH DAMAGE.
17  */
18 
19 #ifndef FLEXIO_SPI_DRIVER_H
20 #define FLEXIO_SPI_DRIVER_H
21 
22 #include <stddef.h>
23 #include <stdbool.h>
24 #include "device_registers.h"
25 #include "flexio.h"
26 #include "edma_driver.h"
27 #include "callbacks.h"
28 
34 /*******************************************************************************
35  * Enumerations.
36  ******************************************************************************/
37 
38 
42 typedef enum
43 {
47 
51 typedef enum
52 {
57 
58 
59 /*******************************************************************************
60 * Definitions
61 ******************************************************************************/
62 
63 
70 typedef struct
71 {
72  uint32_t baudRate;
76  uint8_t clockPolarity;
77  uint8_t clockPhase;
78  uint8_t mosiPin;
79  uint8_t misoPin;
80  uint8_t sckPin;
81  uint8_t ssPin;
86  void *callbackParam;
87  uint8_t rxDMAChannel;
88  uint8_t txDMAChannel;
90 
97 typedef struct
98 {
102  uint8_t clockPolarity;
103  uint8_t clockPhase;
104  uint8_t mosiPin;
105  uint8_t misoPin;
106  uint8_t sckPin;
107  uint8_t ssPin;
113  uint8_t rxDMAChannel;
114  uint8_t txDMAChannel;
116 
117 
126 typedef struct
127 {
129  flexio_common_state_t flexioCommon; /* Common flexio drivers structure */
130  const uint8_t *txData; /* Transmit buffer. */
131  uint8_t *rxData; /* Receive buffer. */
132  uint32_t txRemainingBytes; /* Number of remaining bytes to be transmitted. */
133  uint32_t rxRemainingBytes; /* Number of remaining bytes to be received. */
134  uint32_t dummyDmaData; /* Dummy location for DMA transfers. */
135  uint8_t rxDMAChannel; /* Rx DMA channel number */
136  uint8_t txDMAChannel; /* Tx DMA channel number */
137  flexio_driver_type_t driverType; /* Driver type: interrupts/polling/DMA */
138  flexio_spi_transfer_bit_order_t bitOrder; /* Bit order: LSB-first / MSB-first */
139  flexio_spi_transfer_size_t transferSize; /* Transfer size in bytes: 1/2/4 */
140  status_t status; /* Current status of the driver */
141  bool driverIdle; /* Idle/busy state of the driver */
142  semaphore_t idleSemaphore; /* Semaphore used by blocking functions */
143  bool blocking; /* Specifies if the current transfer is blocking */
144  bool master; /* Specifies if the current instance was initialized as master */
145  spi_callback_t callback; /* User callback function */
146  void *callbackParam; /* Parameter for the callback function */
149 
159 
160 
161 
162 /*******************************************************************************
163  * API
164  ******************************************************************************/
170 #if defined(__cplusplus)
171 extern "C" {
172 #endif
173 
190 status_t FLEXIO_SPI_DRV_MasterInit(uint32_t instance,
191  const flexio_spi_master_user_config_t * userConfigPtr,
192  flexio_spi_master_state_t * master);
193 
194 
206 
207 
224 
225 
236 
237 
254  const uint8_t *txData,
255  uint8_t *rxData,
256  uint32_t dataSize);
257 
258 
275  const uint8_t *txData,
276  uint8_t *rxData,
277  uint32_t dataSize,
278  uint32_t timeout);
279 
280 
281 
291 
292 
307 status_t FLEXIO_SPI_DRV_MasterGetStatus(flexio_spi_master_state_t *master, uint32_t *bytesRemaining);
308 
309 
326 status_t FLEXIO_SPI_DRV_SlaveInit(uint32_t instance,
327  const flexio_spi_slave_user_config_t * userConfigPtr,
328  flexio_spi_slave_state_t * slave);
329 
342 {
343  return FLEXIO_SPI_DRV_MasterDeinit(slave);
344 }
345 
346 
364  const uint8_t *txData,
365  uint8_t *rxData,
366  uint32_t dataSize)
367 {
368  return FLEXIO_SPI_DRV_MasterTransfer(slave, txData, rxData, dataSize);
369 }
370 
371 
389  const uint8_t *txData,
390  uint8_t *rxData,
391  uint32_t dataSize,
392  uint32_t timeout)
393 {
394  return FLEXIO_SPI_DRV_MasterTransferBlocking(slave, txData, rxData, dataSize, timeout);
395 }
396 
397 
408 {
410 }
411 
412 
428 static inline status_t FLEXIO_SPI_DRV_SlaveGetStatus(flexio_spi_slave_state_t *slave, uint32_t *bytesRemaining)
429 {
430  return FLEXIO_SPI_DRV_MasterGetStatus(slave, bytesRemaining);
431 }
432 
433 
435 #if defined(__cplusplus)
436 }
437 #endif
438 
441 #endif /* FLEXIO_SPI_DRIVER_H */
442 /*******************************************************************************
443  * EOF
444  ******************************************************************************/
status_t FLEXIO_SPI_DRV_MasterGetBaudRate(flexio_spi_master_state_t *master, uint32_t *baudRate)
Get the currently configured baud rate.
flexio_spi_transfer_size_t transferSize
static status_t FLEXIO_SPI_DRV_SlaveGetStatus(flexio_spi_slave_state_t *slave, uint32_t *bytesRemaining)
Get the status of the current non-blocking SPI slave transaction.
status_t FLEXIO_SPI_DRV_MasterTransferBlocking(flexio_spi_master_state_t *master, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize, uint32_t timeout)
Perform a blocking SPI master transaction.
status_t FLEXIO_SPI_DRV_MasterTransfer(flexio_spi_master_state_t *master, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize)
Perform a non-blocking SPI master transaction.
flexio_spi_transfer_bit_order_t
Order in which the data bits are transferred Implements : flexio_spi_transfer_bit_order_t_Class.
flexio_spi_transfer_bit_order_t bitOrder
void(* spi_callback_t)(void *driverState, spi_event_t event, void *userData)
Definition: callbacks.h:81
flexio_spi_master_state_t flexio_spi_slave_state_t
Slave internal context structure.
status_t FLEXIO_SPI_DRV_MasterGetStatus(flexio_spi_master_state_t *master, uint32_t *bytesRemaining)
Get the status of the current non-blocking SPI master transaction.
Slave configuration structure.
static status_t FLEXIO_SPI_DRV_SlaveTransfer(flexio_spi_slave_state_t *slave, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize)
Perform a non-blocking SPI slave transaction.
flexio_driver_type_t driverType
flexio_spi_transfer_size_t transferSize
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
Definition: status.h:44
Master configuration structure.
static status_t FLEXIO_SPI_DRV_SlaveTransferBlocking(flexio_spi_slave_state_t *slave, const uint8_t *txData, uint8_t *rxData, uint32_t dataSize, uint32_t timeout)
Perform a blocking SPI slave transaction.
status_t FLEXIO_SPI_DRV_MasterSetBaudRate(flexio_spi_master_state_t *master, uint32_t baudRate)
Set the baud rate for any subsequent SPI communication.
status_t FLEXIO_SPI_DRV_SlaveInit(uint32_t instance, const flexio_spi_slave_user_config_t *userConfigPtr, flexio_spi_slave_state_t *slave)
Initialize the FLEXIO_SPI slave mode driver.
flexio_spi_transfer_bit_order_t bitOrder
flexio_spi_transfer_size_t
Size of transferred data in bytes Implements : flexio_spi_transfer_size_t_Class.
static status_t FLEXIO_SPI_DRV_SlaveDeinit(flexio_spi_slave_state_t *slave)
De-initialize the FLEXIO_SPI slave mode driver.
status_t FLEXIO_SPI_DRV_MasterInit(uint32_t instance, const flexio_spi_master_user_config_t *userConfigPtr, flexio_spi_master_state_t *master)
Initialize the FLEXIO_SPI master mode driver.
flexio_driver_type_t
Driver type: interrupts/polling/DMA Implements : flexio_driver_type_t_Class.
Definition: flexio.h:49
status_t FLEXIO_SPI_DRV_MasterDeinit(flexio_spi_master_state_t *master)
De-initialize the FLEXIO_SPI master mode driver.
status_t FLEXIO_SPI_DRV_MasterTransferAbort(flexio_spi_master_state_t *master)
Aborts a non-blocking SPI master transaction.
Master internal context structure.
static status_t FLEXIO_SPI_DRV_SlaveTransferAbort(flexio_spi_slave_state_t *slave)
Aborts a non-blocking SPI slave transaction.