Zephyr API Documentation 3.7.99
A Scalable Open Source RTOS
Loading...
Searching...
No Matches
spi.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2015 Intel Corporation
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
12#ifndef ZEPHYR_INCLUDE_DRIVERS_SPI_H_
13#define ZEPHYR_INCLUDE_DRIVERS_SPI_H_
14
24#include <zephyr/types.h>
25#include <stddef.h>
26#include <zephyr/device.h>
28#include <zephyr/drivers/gpio.h>
29#include <zephyr/kernel.h>
30#include <zephyr/sys/__assert.h>
31#include <zephyr/rtio/rtio.h>
32#include <zephyr/stats/stats.h>
33
34#ifdef __cplusplus
35extern "C" {
36#endif
37
42#define SPI_OP_MODE_MASTER 0U
43#define SPI_OP_MODE_SLAVE BIT(0)
45#define SPI_OP_MODE_MASK 0x1U
48#define SPI_OP_MODE_GET(_operation_) ((_operation_) & SPI_OP_MODE_MASK)
61#define SPI_MODE_CPOL BIT(1)
62
70#define SPI_MODE_CPHA BIT(2)
71
77#define SPI_MODE_LOOP BIT(3)
79#define SPI_MODE_MASK (0xEU)
82#define SPI_MODE_GET(_mode_) \
83 ((_mode_) & SPI_MODE_MASK)
84
91#define SPI_TRANSFER_MSB (0U)
92#define SPI_TRANSFER_LSB BIT(4)
100#define SPI_WORD_SIZE_SHIFT (5U)
101#define SPI_WORD_SIZE_MASK (0x3FU << SPI_WORD_SIZE_SHIFT)
104#define SPI_WORD_SIZE_GET(_operation_) \
105 (((_operation_) & SPI_WORD_SIZE_MASK) >> SPI_WORD_SIZE_SHIFT)
107#define SPI_WORD_SET(_word_size_) \
108 ((_word_size_) << SPI_WORD_SIZE_SHIFT)
116#define SPI_HOLD_ON_CS BIT(12)
122#define SPI_LOCK_ON BIT(13)
123
131#define SPI_CS_ACTIVE_HIGH BIT(14)
143#define SPI_LINES_SINGLE (0U << 16)
144#define SPI_LINES_DUAL (1U << 16)
145#define SPI_LINES_QUAD (2U << 16)
146#define SPI_LINES_OCTAL (3U << 16)
148#define SPI_LINES_MASK (0x3U << 16)
174
212#define SPI_CS_GPIOS_DT_SPEC_GET(spi_dev) \
213 GPIO_DT_SPEC_GET_BY_IDX_OR(DT_BUS(spi_dev), cs_gpios, \
214 DT_REG_ADDR_RAW(spi_dev), {})
215
225#define SPI_CS_GPIOS_DT_SPEC_INST_GET(inst) \
226 SPI_CS_GPIOS_DT_SPEC_GET(DT_DRV_INST(inst))
227
266#define SPI_CS_CONTROL_INIT(node_id, delay_) \
267 { \
268 .gpio = SPI_CS_GPIOS_DT_SPEC_GET(node_id), \
269 .delay = (delay_), \
270 }
271
285#define SPI_CS_CONTROL_INIT_INST(inst, delay_) \
286 SPI_CS_CONTROL_INIT(DT_DRV_INST(inst), delay_)
287
292#if defined(CONFIG_SPI_EXTENDED_MODES)
294#else
296#endif
297
333
347#define SPI_CONFIG_DT(node_id, operation_, delay_) \
348 { \
349 .frequency = DT_PROP(node_id, spi_max_frequency), \
350 .operation = (operation_) | \
351 DT_PROP(node_id, duplex) | \
352 DT_PROP(node_id, frame_format) | \
353 COND_CODE_1(DT_PROP(node_id, spi_cpol), SPI_MODE_CPOL, (0)) | \
354 COND_CODE_1(DT_PROP(node_id, spi_cpha), SPI_MODE_CPHA, (0)) | \
355 COND_CODE_1(DT_PROP(node_id, spi_hold_cs), SPI_HOLD_ON_CS, (0)), \
356 .slave = DT_REG_ADDR(node_id), \
357 .cs = SPI_CS_CONTROL_INIT(node_id, delay_), \
358 }
359
371#define SPI_CONFIG_DT_INST(inst, operation_, delay_) \
372 SPI_CONFIG_DT(DT_DRV_INST(inst), operation_, delay_)
373
379 const struct device *bus;
382};
383
401#define SPI_DT_SPEC_GET(node_id, operation_, delay_) \
402 { \
403 .bus = DEVICE_DT_GET(DT_BUS(node_id)), \
404 .config = SPI_CONFIG_DT(node_id, operation_, delay_) \
405 }
406
418#define SPI_DT_SPEC_INST_GET(inst, operation_, delay_) \
419 SPI_DT_SPEC_GET(DT_DRV_INST(inst), operation_, delay_)
420
424#define SPI_MOSI_OVERRUN_UNKNOWN 0x100
425
438#define SPI_MOSI_OVERRUN_DT(node_id) \
439 DT_PROP_OR(node_id, overrun_character, SPI_MOSI_OVERRUN_UNKNOWN)
440
452#define SPI_MOSI_OVERRUN_DT_INST(inst) \
453 DT_INST_PROP_OR(inst, overrun_character, SPI_MOSI_OVERRUN_UNKNOWN)
454
458struct spi_buf {
460 void *buf;
465 size_t len;
466};
467
473 const struct spi_buf *buffers;
475 size_t count;
476};
477
478#if defined(CONFIG_SPI_STATS)
480STATS_SECT_ENTRY32(rx_bytes)
481STATS_SECT_ENTRY32(tx_bytes)
482STATS_SECT_ENTRY32(transfer_error)
484
486STATS_NAME(spi, rx_bytes)
487STATS_NAME(spi, tx_bytes)
488STATS_NAME(spi, transfer_error)
489STATS_NAME_END(spi);
490
494struct spi_device_state {
495 struct device_state devstate;
496 struct stats_spi stats;
497};
498
502#define Z_SPI_GET_STATS(dev_) \
503 CONTAINER_OF(dev_->state, struct spi_device_state, devstate)->stats
504
510#define SPI_STATS_RX_BYTES_INCN(dev_, n) \
511 STATS_INCN(Z_SPI_GET_STATS(dev_), rx_bytes, n)
512
518#define SPI_STATS_TX_BYTES_INCN(dev_, n) \
519 STATS_INCN(Z_SPI_GET_STATS(dev_), tx_bytes, n)
520
528#define SPI_STATS_TRANSFER_ERROR_INC(dev_) \
529 STATS_INC(Z_SPI_GET_STATS(dev_), transfer_error)
530
534#define Z_SPI_DEVICE_STATE_DEFINE(dev_id) \
535 static struct spi_device_state Z_DEVICE_STATE_NAME(dev_id) \
536 __attribute__((__section__(".z_devstate")));
537
544#define Z_SPI_INIT_FN(dev_id, init_fn) \
545 static inline int UTIL_CAT(dev_id, _init)(const struct device *dev) \
546 { \
547 struct spi_device_state *state = \
548 CONTAINER_OF(dev->state, struct spi_device_state, devstate); \
549 stats_init(&state->stats.s_hdr, STATS_SIZE_32, 3, \
550 STATS_NAME_INIT_PARMS(spi)); \
551 stats_register(dev->name, &(state->stats.s_hdr)); \
552 return init_fn(dev); \
553 }
554
574#define SPI_DEVICE_DT_DEFINE(node_id, init_fn, pm_device, \
575 data_ptr, cfg_ptr, level, prio, \
576 api_ptr, ...) \
577 Z_SPI_DEVICE_STATE_DEFINE(Z_DEVICE_DT_DEV_ID(node_id)); \
578 Z_SPI_INIT_FN(Z_DEVICE_DT_DEV_ID(node_id), init_fn) \
579 Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
580 DEVICE_DT_NAME(node_id), \
581 &UTIL_CAT(Z_DEVICE_DT_DEV_ID(node_id), _init), \
582 pm_device, \
583 data_ptr, cfg_ptr, level, prio, \
584 api_ptr, \
585 &(Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_ID(node_id)).devstate), \
586 __VA_ARGS__)
587
588static inline void spi_transceive_stats(const struct device *dev, int error,
589 const struct spi_buf_set *tx_bufs,
590 const struct spi_buf_set *rx_bufs)
591{
592 uint32_t tx_bytes;
593 uint32_t rx_bytes;
594
595 if (error) {
597 }
598
599 if (tx_bufs) {
600 tx_bytes = tx_bufs->count ? tx_bufs->buffers->len : 0;
601 SPI_STATS_TX_BYTES_INCN(dev, tx_bytes);
602 }
603
604 if (rx_bufs) {
605 rx_bytes = rx_bufs->count ? rx_bufs->buffers->len : 0;
606 SPI_STATS_RX_BYTES_INCN(dev, rx_bytes);
607 }
608}
609
610#else /*CONFIG_SPI_STATS*/
611
612#define SPI_DEVICE_DT_DEFINE(node_id, init_fn, pm, \
613 data, config, level, prio, \
614 api, ...) \
615 Z_DEVICE_STATE_DEFINE(Z_DEVICE_DT_DEV_ID(node_id)); \
616 Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
617 DEVICE_DT_NAME(node_id), init_fn, pm, data, config, \
618 level, prio, api, \
619 &Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_ID(node_id)), \
620 __VA_ARGS__)
621
622#define SPI_STATS_RX_BYTES_INC(dev_)
623#define SPI_STATS_TX_BYTES_INC(dev_)
624#define SPI_STATS_TRANSFER_ERROR_INC(dev_)
625
626#define spi_transceive_stats(dev, error, tx_bufs, rx_bufs)
627
628#endif /*CONFIG_SPI_STATS*/
629
635typedef int (*spi_api_io)(const struct device *dev,
636 const struct spi_config *config,
637 const struct spi_buf_set *tx_bufs,
638 const struct spi_buf_set *rx_bufs);
639
647typedef void (*spi_callback_t)(const struct device *dev, int result, void *data);
648
654typedef int (*spi_api_io_async)(const struct device *dev,
655 const struct spi_config *config,
656 const struct spi_buf_set *tx_bufs,
657 const struct spi_buf_set *rx_bufs,
659 void *userdata);
660
661#if defined(CONFIG_SPI_RTIO) || defined(DOXYGEN)
662
667typedef void (*spi_api_iodev_submit)(const struct device *dev,
668 struct rtio_iodev_sqe *iodev_sqe);
669#endif /* CONFIG_SPI_RTIO */
670
676typedef int (*spi_api_release)(const struct device *dev,
677 const struct spi_config *config);
678
679
684__subsystem struct spi_driver_api {
686#ifdef CONFIG_SPI_ASYNC
687 spi_api_io_async transceive_async;
688#endif /* CONFIG_SPI_ASYNC */
689#ifdef CONFIG_SPI_RTIO
690 spi_api_iodev_submit iodev_submit;
691#endif /* CONFIG_SPI_RTIO */
693};
694
702static inline bool spi_cs_is_gpio(const struct spi_config *config)
703{
704 return config->cs.gpio.port != NULL;
705}
706
714static inline bool spi_cs_is_gpio_dt(const struct spi_dt_spec *spec)
715{
716 return spi_cs_is_gpio(&spec->config);
717}
718
727static inline bool spi_is_ready_dt(const struct spi_dt_spec *spec)
728{
729 /* Validate bus is ready */
730 if (!device_is_ready(spec->bus)) {
731 return false;
732 }
733 /* Validate CS gpio port is ready, if it is used */
734 if (spi_cs_is_gpio_dt(spec) &&
735 !gpio_is_ready_dt(&spec->config.cs.gpio)) {
736 return false;
737 }
738 return true;
739}
740
759__syscall int spi_transceive(const struct device *dev,
760 const struct spi_config *config,
761 const struct spi_buf_set *tx_bufs,
762 const struct spi_buf_set *rx_bufs);
763
764static inline int z_impl_spi_transceive(const struct device *dev,
765 const struct spi_config *config,
766 const struct spi_buf_set *tx_bufs,
767 const struct spi_buf_set *rx_bufs)
768{
769 const struct spi_driver_api *api =
770 (const struct spi_driver_api *)dev->api;
771 int ret;
772
773 ret = api->transceive(dev, config, tx_bufs, rx_bufs);
774 spi_transceive_stats(dev, ret, tx_bufs, rx_bufs);
775
776 return ret;
777}
778
794static inline int spi_transceive_dt(const struct spi_dt_spec *spec,
795 const struct spi_buf_set *tx_bufs,
796 const struct spi_buf_set *rx_bufs)
797{
798 return spi_transceive(spec->bus, &spec->config, tx_bufs, rx_bufs);
799}
800
818static inline int spi_read(const struct device *dev,
819 const struct spi_config *config,
820 const struct spi_buf_set *rx_bufs)
821{
822 return spi_transceive(dev, config, NULL, rx_bufs);
823}
824
837static inline int spi_read_dt(const struct spi_dt_spec *spec,
838 const struct spi_buf_set *rx_bufs)
839{
840 return spi_read(spec->bus, &spec->config, rx_bufs);
841}
842
859static inline int spi_write(const struct device *dev,
860 const struct spi_config *config,
861 const struct spi_buf_set *tx_bufs)
862{
863 return spi_transceive(dev, config, tx_bufs, NULL);
864}
865
878static inline int spi_write_dt(const struct spi_dt_spec *spec,
879 const struct spi_buf_set *tx_bufs)
880{
881 return spi_write(spec->bus, &spec->config, tx_bufs);
882}
883
884#if defined(CONFIG_SPI_ASYNC) || defined(__DOXYGEN__)
885
912static inline int spi_transceive_cb(const struct device *dev,
913 const struct spi_config *config,
914 const struct spi_buf_set *tx_bufs,
915 const struct spi_buf_set *rx_bufs,
916 spi_callback_t callback,
917 void *userdata)
918{
919 const struct spi_driver_api *api =
920 (const struct spi_driver_api *)dev->api;
921
922 return api->transceive_async(dev, config, tx_bufs, rx_bufs, callback, userdata);
923}
924
925#if defined(CONFIG_POLL) || defined(__DOXYGEN__)
926
928void z_spi_transfer_signal_cb(const struct device *dev, int result, void *userdata);
956static inline int spi_transceive_signal(const struct device *dev,
957 const struct spi_config *config,
958 const struct spi_buf_set *tx_bufs,
959 const struct spi_buf_set *rx_bufs,
960 struct k_poll_signal *sig)
961{
962 const struct spi_driver_api *api =
963 (const struct spi_driver_api *)dev->api;
964 spi_callback_t cb = (sig == NULL) ? NULL : z_spi_transfer_signal_cb;
965
966 return api->transceive_async(dev, config, tx_bufs, rx_bufs, cb, sig);
967}
968
993static inline int spi_read_signal(const struct device *dev,
994 const struct spi_config *config,
995 const struct spi_buf_set *rx_bufs,
996 struct k_poll_signal *sig)
997{
998 return spi_transceive_signal(dev, config, NULL, rx_bufs, sig);
999}
1000
1024static inline int spi_write_signal(const struct device *dev,
1025 const struct spi_config *config,
1026 const struct spi_buf_set *tx_bufs,
1027 struct k_poll_signal *sig)
1028{
1029 return spi_transceive_signal(dev, config, tx_bufs, NULL, sig);
1030}
1031
1032#endif /* CONFIG_POLL */
1033
1034#endif /* CONFIG_SPI_ASYNC */
1035
1036
1037#if defined(CONFIG_SPI_RTIO) || defined(__DOXYGEN__)
1038
1046static inline void spi_iodev_submit(struct rtio_iodev_sqe *iodev_sqe)
1047{
1048 const struct spi_dt_spec *dt_spec = iodev_sqe->sqe.iodev->data;
1049 const struct device *dev = dt_spec->bus;
1050 const struct spi_driver_api *api = (const struct spi_driver_api *)dev->api;
1051
1052 api->iodev_submit(dt_spec->bus, iodev_sqe);
1053}
1054
1055extern const struct rtio_iodev_api spi_iodev_api;
1056
1068#define SPI_DT_IODEV_DEFINE(name, node_id, operation_, delay_) \
1069 const struct spi_dt_spec _spi_dt_spec_##name = \
1070 SPI_DT_SPEC_GET(node_id, operation_, delay_); \
1071 RTIO_IODEV_DEFINE(name, &spi_iodev_api, (void *)&_spi_dt_spec_##name)
1072
1081static inline bool spi_is_ready_iodev(const struct rtio_iodev *spi_iodev)
1082{
1083 struct spi_dt_spec *spec = spi_iodev->data;
1084
1085 return spi_is_ready_dt(spec);
1086}
1087
1088#endif /* CONFIG_SPI_RTIO */
1089
1110__syscall int spi_release(const struct device *dev,
1111 const struct spi_config *config);
1112
1113static inline int z_impl_spi_release(const struct device *dev,
1114 const struct spi_config *config)
1115{
1116 const struct spi_driver_api *api =
1117 (const struct spi_driver_api *)dev->api;
1118
1119 return api->release(dev, config);
1120}
1121
1133static inline int spi_release_dt(const struct spi_dt_spec *spec)
1134{
1135 return spi_release(spec->bus, &spec->config);
1136}
1137
1138#ifdef __cplusplus
1139}
1140#endif
1141
1146#include <zephyr/syscalls/spi.h>
1147
1148#endif /* ZEPHYR_INCLUDE_DRIVERS_SPI_H_ */
Public APIs for GPIO drivers.
bool device_is_ready(const struct device *dev)
Verify that a device is ready for use.
static bool gpio_is_ready_dt(const struct gpio_dt_spec *spec)
Validate that GPIO port is ready.
Definition gpio.h:835
int(* spi_api_io_async)(const struct device *dev, const struct spi_config *config, const struct spi_buf_set *tx_bufs, const struct spi_buf_set *rx_bufs, spi_callback_t cb, void *userdata)
Definition spi.h:654
int spi_release(const struct device *dev, const struct spi_config *config)
Release the SPI device locked on and/or the CS by the current config.
void(* spi_callback_t)(const struct device *dev, int result, void *data)
SPI callback for asynchronous transfer requests.
Definition spi.h:647
static int spi_write_dt(const struct spi_dt_spec *spec, const struct spi_buf_set *tx_bufs)
Write data to a SPI bus specified in spi_dt_spec.
Definition spi.h:878
static bool spi_is_ready_dt(const struct spi_dt_spec *spec)
Validate that SPI bus (and CS gpio if defined) is ready.
Definition spi.h:727
uint16_t spi_operation_t
Opaque type to hold the SPI operation flags.
Definition spi.h:295
int(* spi_api_io)(const struct device *dev, const struct spi_config *config, const struct spi_buf_set *tx_bufs, const struct spi_buf_set *rx_bufs)
Callback API for I/O See spi_transceive() for argument descriptions.
Definition spi.h:635
static int spi_transceive_signal(const struct device *dev, const struct spi_config *config, const struct spi_buf_set *tx_bufs, const struct spi_buf_set *rx_bufs, struct k_poll_signal *sig)
Read/write the specified amount of data from the SPI driver.
Definition spi.h:956
static int spi_read(const struct device *dev, const struct spi_config *config, const struct spi_buf_set *rx_bufs)
Read the specified amount of data from the SPI driver.
Definition spi.h:818
static int spi_transceive_dt(const struct spi_dt_spec *spec, const struct spi_buf_set *tx_bufs, const struct spi_buf_set *rx_bufs)
Read/write data from an SPI bus specified in spi_dt_spec.
Definition spi.h:794
static int spi_transceive_cb(const struct device *dev, const struct spi_config *config, const struct spi_buf_set *tx_bufs, const struct spi_buf_set *rx_bufs, spi_callback_t callback, void *userdata)
Read/write the specified amount of data from the SPI driver.
Definition spi.h:912
#define SPI_STATS_TRANSFER_ERROR_INC(dev_)
Definition spi.h:624
static int spi_read_dt(const struct spi_dt_spec *spec, const struct spi_buf_set *rx_bufs)
Read data from a SPI bus specified in spi_dt_spec.
Definition spi.h:837
static int spi_write(const struct device *dev, const struct spi_config *config, const struct spi_buf_set *tx_bufs)
Write the specified amount of data from the SPI driver.
Definition spi.h:859
static int spi_release_dt(const struct spi_dt_spec *spec)
Release the SPI device specified in spi_dt_spec.
Definition spi.h:1133
static void spi_iodev_submit(struct rtio_iodev_sqe *iodev_sqe)
Submit a SPI device with a request.
Definition spi.h:1046
static int spi_read_signal(const struct device *dev, const struct spi_config *config, const struct spi_buf_set *rx_bufs, struct k_poll_signal *sig)
Read the specified amount of data from the SPI driver.
Definition spi.h:993
static bool spi_cs_is_gpio_dt(const struct spi_dt_spec *spec)
Check if SPI CS in spi_dt_spec is controlled using a GPIO.
Definition spi.h:714
int(* spi_api_release)(const struct device *dev, const struct spi_config *config)
Callback API for unlocking SPI device.
Definition spi.h:676
const struct rtio_iodev_api spi_iodev_api
int spi_transceive(const struct device *dev, const struct spi_config *config, const struct spi_buf_set *tx_bufs, const struct spi_buf_set *rx_bufs)
Read/write the specified amount of data from the SPI driver.
#define spi_transceive_stats(dev, error, tx_bufs, rx_bufs)
Definition spi.h:626
static int spi_write_signal(const struct device *dev, const struct spi_config *config, const struct spi_buf_set *tx_bufs, struct k_poll_signal *sig)
Write the specified amount of data from the SPI driver.
Definition spi.h:1024
static bool spi_cs_is_gpio(const struct spi_config *config)
Check if SPI CS is controlled using a GPIO.
Definition spi.h:702
static bool spi_is_ready_iodev(const struct rtio_iodev *spi_iodev)
Validate that SPI bus (and CS gpio if defined) is ready.
Definition spi.h:1081
Public kernel APIs.
Real-Time IO device API for moving bytes with low effort.
Statistics.
#define STATS_NAME_END(name__)
Definition stats.h:391
#define STATS_NAME(name__, entry__)
Definition stats.h:390
#define STATS_SECT_END
Ends a stats group struct definition.
Definition stats.h:89
#define STATS_SECT_ENTRY32(var__)
Definition stats.h:359
#define STATS_NAME_START(name__)
Definition stats.h:389
#define STATS_SECT_START(group__)
Definition stats.h:354
__UINT32_TYPE__ uint32_t
Definition stdint.h:90
__UINT16_TYPE__ uint16_t
Definition stdint.h:89
Runtime device dynamic structure (in RAM) per driver instance.
Definition device.h:380
Runtime device structure (in ROM) per driver instance.
Definition device.h:412
void * data
Address of the device instance private data.
Definition device.h:422
const void * api
Address of the API structure exposed by the device instance.
Definition device.h:418
Container for GPIO pin information specified in devicetree.
Definition gpio.h:288
const struct device * port
GPIO device controlling the pin.
Definition gpio.h:290
Definition kernel.h:5768
API that an RTIO IO device should implement.
Definition rtio.h:439
Compute the mempool block index for a given pointer.
Definition rtio.h:429
struct rtio_sqe sqe
Definition rtio.h:430
An IO device with a function table for submitting requests.
Definition rtio.h:454
void * data
Definition rtio.h:459
const struct rtio_iodev * iodev
Device to operation on.
Definition rtio.h:243
SPI buffer array structure.
Definition spi.h:471
const struct spi_buf * buffers
Pointer to an array of spi_buf, or NULL.
Definition spi.h:473
size_t count
Length of the array pointed by buffers.
Definition spi.h:475
SPI buffer structure.
Definition spi.h:458
size_t len
Length of the buffer buf.
Definition spi.h:465
void * buf
Valid pointer to a data buffer, or NULL otherwise.
Definition spi.h:460
SPI controller configuration structure.
Definition spi.h:301
uint16_t slave
Slave number from 0 to host controller slave limit.
Definition spi.h:326
struct spi_cs_control cs
GPIO chip-select line (optional, must be initialized to zero if not used).
Definition spi.h:331
spi_operation_t operation
Operation flags.
Definition spi.h:324
uint32_t frequency
Bus frequency in Hertz.
Definition spi.h:303
SPI Chip Select control structure.
Definition spi.h:159
uint32_t delay
Delay in microseconds to wait before starting the transmission and before releasing the CS line.
Definition spi.h:172
struct gpio_dt_spec gpio
GPIO devicetree specification of CS GPIO.
Definition spi.h:167
SPI driver API This is the mandatory API any SPI driver needs to expose.
Definition spi.h:684
spi_api_io transceive
Definition spi.h:685
spi_api_release release
Definition spi.h:692
Complete SPI DT information.
Definition spi.h:377
const struct device * bus
SPI bus.
Definition spi.h:379
struct spi_config config
Slave specific configuration.
Definition spi.h:381