spi.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_SPI_H_
#define ZEPHYR_INCLUDE_DRIVERS_SPI_H_
 
#include <zephyr/types.h>
#include <stddef.h>
#include <zephyr/device.h>
#include <zephyr/dt-bindings/spi/spi.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/rtio/rtio.h>
#include <zephyr/stats/stats.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define SPI_OP_MODE_MASTER      0U
#define SPI_OP_MODE_SLAVE       BIT(0)
#define SPI_OP_MODE_MASK        0x1U
#define SPI_OP_MODE_GET(_operation_) ((_operation_) & SPI_OP_MODE_MASK)
#define SPI_MODE_CPOL           BIT(1)
 
#define SPI_MODE_CPHA           BIT(2)
 
#define SPI_MODE_LOOP           BIT(3)
 
#define SPI_MODE_MASK           (0xEU)
#define SPI_MODE_GET(_mode_)                    \
        ((_mode_) & SPI_MODE_MASK)
 
#define SPI_TRANSFER_MSB        (0U)
#define SPI_TRANSFER_LSB        BIT(4)
#define SPI_WORD_SIZE_SHIFT     (5U)
#define SPI_WORD_SIZE_MASK      (0x3FU << SPI_WORD_SIZE_SHIFT)
#define SPI_WORD_SIZE_GET(_operation_)                                  \
        (((_operation_) & SPI_WORD_SIZE_MASK) >> SPI_WORD_SIZE_SHIFT)
 
#define SPI_WORD_SET(_word_size_)               \
        ((_word_size_) << SPI_WORD_SIZE_SHIFT)
/* Requests - if possible - to keep CS asserted after the transaction */
#define SPI_HOLD_ON_CS          BIT(12)
/* Keep the device locked after the transaction for the current config.
 * Use this with extreme caution (see spi_release() below) as it will
 * prevent other callers to access the SPI device until spi_release() is
 * properly called.
 */
#define SPI_LOCK_ON             BIT(13)
 
/* Active high logic on CS - Usually, and by default, CS logic is active
 * low. However, some devices may require the reverse logic: active high.
 * This bit will request the controller to use that logic. Note that not
 * all controllers are able to handle that natively. In this case deferring
 * the CS control to a gpio line through struct spi_cs_control would be
 * the solution.
 */
#define SPI_CS_ACTIVE_HIGH      BIT(14)
#define SPI_LINES_SINGLE        (0U << 16)
#define SPI_LINES_DUAL          (1U << 16)
#define SPI_LINES_QUAD          (2U << 16)
#define SPI_LINES_OCTAL         (3U << 16)
 
#define SPI_LINES_MASK          (0x3U << 16)
struct spi_cs_control {
        struct gpio_dt_spec gpio;
        uint32_t delay;
};
 
#define SPI_CS_GPIOS_DT_SPEC_GET(spi_dev)                       \
        GPIO_DT_SPEC_GET_BY_IDX_OR(DT_BUS(spi_dev), cs_gpios,   \
                                   DT_REG_ADDR(spi_dev), {})
 
#define SPI_CS_GPIOS_DT_SPEC_INST_GET(inst) \
        SPI_CS_GPIOS_DT_SPEC_GET(DT_DRV_INST(inst))
 
#define SPI_CS_CONTROL_INIT(node_id, delay_)                      \
        {                                                         \
                .gpio = SPI_CS_GPIOS_DT_SPEC_GET(node_id),        \
                .delay = (delay_),                                \
        }
 
#define SPI_CS_CONTROL_INIT_INST(inst, delay_)          \
        SPI_CS_CONTROL_INIT(DT_DRV_INST(inst), delay_)
 
#if defined(CONFIG_SPI_EXTENDED_MODES)
typedef uint32_t spi_operation_t;
#else
typedef uint16_t spi_operation_t;
#endif
 
struct spi_config {
        uint32_t frequency;
        spi_operation_t operation;
        uint16_t slave;
        struct spi_cs_control cs;
};
 
#define SPI_CONFIG_DT(node_id, operation_, delay_)                      \
        {                                                               \
                .frequency = DT_PROP(node_id, spi_max_frequency),       \
                .operation = (operation_) |                             \
                        DT_PROP(node_id, duplex) |                      \
                        DT_PROP(node_id, frame_format),                 \
                .slave = DT_REG_ADDR(node_id),                          \
                .cs = SPI_CS_CONTROL_INIT(node_id, delay_),             \
        }
 
#define SPI_CONFIG_DT_INST(inst, operation_, delay_)    \
        SPI_CONFIG_DT(DT_DRV_INST(inst), operation_, delay_)
 
struct spi_dt_spec {
        const struct device *bus;
        struct spi_config config;
};
 
#define SPI_DT_SPEC_GET(node_id, operation_, delay_)                 \
        {                                                            \
                .bus = DEVICE_DT_GET(DT_BUS(node_id)),               \
                .config = SPI_CONFIG_DT(node_id, operation_, delay_) \
        }
 
#define SPI_DT_SPEC_INST_GET(inst, operation_, delay_) \
        SPI_DT_SPEC_GET(DT_DRV_INST(inst), operation_, delay_)
 
struct spi_buf {
        void *buf;
        size_t len;
};
 
struct spi_buf_set {
        const struct spi_buf *buffers;
        size_t count;
};
 
#if defined(CONFIG_SPI_STATS)
STATS_SECT_START(spi)
STATS_SECT_ENTRY32(rx_bytes)
STATS_SECT_ENTRY32(tx_bytes)
STATS_SECT_ENTRY32(transfer_error)
STATS_SECT_END;
 
STATS_NAME_START(spi)
STATS_NAME(spi, rx_bytes)
STATS_NAME(spi, tx_bytes)
STATS_NAME(spi, transfer_error)
STATS_NAME_END(spi);
 
struct spi_device_state {
        struct device_state devstate;
        struct stats_spi stats;
};
 
#define Z_SPI_GET_STATS(dev_)                           \
        CONTAINER_OF(dev_->state, struct spi_device_state, devstate)->stats
 
#define SPI_STATS_RX_BYTES_INCN(dev_, n)                        \
        STATS_INCN(Z_SPI_GET_STATS(dev_), rx_bytes, n)
 
#define SPI_STATS_TX_BYTES_INCN(dev_, n)                        \
        STATS_INCN(Z_SPI_GET_STATS(dev_), tx_bytes, n)
 
#define SPI_STATS_TRANSFER_ERROR_INC(dev_)                      \
        STATS_INC(Z_SPI_GET_STATS(dev_), transfer_error)
 
#define Z_SPI_DEVICE_STATE_DEFINE(dev_id)       \
        static struct spi_device_state Z_DEVICE_STATE_NAME(dev_id)      \
        __attribute__((__section__(".z_devstate")));
 
#define Z_SPI_INIT_FN(dev_id, init_fn)                                  \
        static inline int UTIL_CAT(dev_id, _init)(const struct device *dev) \
        {                                                               \
                struct spi_device_state *state =                        \
                        CONTAINER_OF(dev->state, struct spi_device_state, devstate); \
                stats_init(&state->stats.s_hdr, STATS_SIZE_32, 3,       \
                           STATS_NAME_INIT_PARMS(spi));                 \
                stats_register(dev->name, &(state->stats.s_hdr));       \
                return init_fn(dev);                                    \
        }
 
#define SPI_DEVICE_DT_DEFINE(node_id, init_fn, pm_device,               \
                             data_ptr, cfg_ptr, level, prio,            \
                             api_ptr, ...)                              \
        Z_SPI_DEVICE_STATE_DEFINE(Z_DEVICE_DT_DEV_ID(node_id));         \
        Z_SPI_INIT_FN(Z_DEVICE_DT_DEV_ID(node_id), init_fn)             \
        Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_ID(node_id),           \
                        DEVICE_DT_NAME(node_id),                        \
                        &UTIL_CAT(Z_DEVICE_DT_DEV_ID(node_id), _init),  \
                        pm_device,                                      \
                        data_ptr, cfg_ptr, level, prio,                 \
                        api_ptr,                                        \
                        &(Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_ID(node_id)).devstate), \
                        __VA_ARGS__)
 
static inline void spi_transceive_stats(const struct device *dev, int error,
                                        const struct spi_buf_set *tx_bufs,
                                        const struct spi_buf_set *rx_bufs)
{
        uint32_t tx_bytes;
        uint32_t rx_bytes;
 
        if (error) {
                SPI_STATS_TRANSFER_ERROR_INC(dev);
        }
 
        if (tx_bufs) {
                tx_bytes = tx_bufs->count ? tx_bufs->buffers->len : 0;
                SPI_STATS_TX_BYTES_INCN(dev, tx_bytes);
        }
 
        if (rx_bufs) {
                rx_bytes = rx_bufs->count ? rx_bufs->buffers->len : 0;
                SPI_STATS_RX_BYTES_INCN(dev, rx_bytes);
        }
}
 
#else /*CONFIG_SPI_STATS*/
 
#define SPI_DEVICE_DT_DEFINE(node_id, init_fn, pm,              \
                                data, config, level, prio,      \
                                api, ...)                       \
        Z_DEVICE_STATE_DEFINE(Z_DEVICE_DT_DEV_ID(node_id));                     \
        Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_ID(node_id),                   \
                        DEVICE_DT_NAME(node_id), init_fn, pm, data, config,     \
                        level, prio, api,                                       \
                        &Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_ID(node_id)),      \
                        __VA_ARGS__)
 
#define SPI_STATS_RX_BYTES_INC(dev_)
#define SPI_STATS_TX_BYTES_INC(dev_)
#define SPI_STATS_TRANSFER_ERROR_INC(dev_)
 
#define spi_transceive_stats(dev, error, tx_bufs, rx_bufs)
 
#endif /*CONFIG_SPI_STATS*/
 
typedef 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);
 
typedef void (*spi_callback_t)(const struct device *dev, int result, void *data);
 
typedef 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);
 
#if defined(CONFIG_SPI_RTIO) || defined(DOXYGEN)
 
typedef void (*spi_api_iodev_submit)(const struct device *dev,
                                     struct rtio_iodev_sqe *iodev_sqe);
#endif /* CONFIG_SPI_RTIO */
 
typedef int (*spi_api_release)(const struct device *dev,
                               const struct spi_config *config);
 
 
__subsystem struct spi_driver_api {
        spi_api_io transceive;
#ifdef CONFIG_SPI_ASYNC
        spi_api_io_async transceive_async;
#endif /* CONFIG_SPI_ASYNC */
#ifdef CONFIG_SPI_RTIO
        spi_api_iodev_submit iodev_submit;
#endif /* CONFIG_SPI_RTIO */
        spi_api_release release;
};
 
static inline bool spi_cs_is_gpio(const struct spi_config *config)
{
        return config->cs.gpio.port != NULL;
}
 
static inline bool spi_cs_is_gpio_dt(const struct spi_dt_spec *spec)
{
        return spi_cs_is_gpio(&spec->config);
}
 
__deprecated
static inline bool spi_is_ready(const struct spi_dt_spec *spec)
{
        /* Validate bus is ready */
        if (!device_is_ready(spec->bus)) {
                return false;
        }
        /* Validate CS gpio port is ready, if it is used */
        if (spi_cs_is_gpio_dt(spec) &&
            !gpio_is_ready_dt(&spec->config.cs.gpio)) {
                return false;
        }
        return true;
}
 
static inline bool spi_is_ready_dt(const struct spi_dt_spec *spec)
{
        /* Validate bus is ready */
        if (!device_is_ready(spec->bus)) {
                return false;
        }
        /* Validate CS gpio port is ready, if it is used */
        if (spi_cs_is_gpio_dt(spec) &&
            !gpio_is_ready_dt(&spec->config.cs.gpio)) {
                return false;
        }
        return true;
}
 
__syscall 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);
 
static inline int z_impl_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)
{
        const struct spi_driver_api *api =
                (const struct spi_driver_api *)dev->api;
        int ret;
 
        ret = api->transceive(dev, config, tx_bufs, rx_bufs);
        spi_transceive_stats(dev, ret, tx_bufs, rx_bufs);
 
        return ret;
}
 
static inline int spi_transceive_dt(const struct spi_dt_spec *spec,
                                    const struct spi_buf_set *tx_bufs,
                                    const struct spi_buf_set *rx_bufs)
{
        return spi_transceive(spec->bus, &spec->config, tx_bufs, rx_bufs);
}
 
static inline int spi_read(const struct device *dev,
                           const struct spi_config *config,
                           const struct spi_buf_set *rx_bufs)
{
        return spi_transceive(dev, config, NULL, rx_bufs);
}
 
static inline int spi_read_dt(const struct spi_dt_spec *spec,
                              const struct spi_buf_set *rx_bufs)
{
        return spi_read(spec->bus, &spec->config, rx_bufs);
}
 
static inline int spi_write(const struct device *dev,
                            const struct spi_config *config,
                            const struct spi_buf_set *tx_bufs)
{
        return spi_transceive(dev, config, tx_bufs, NULL);
}
 
static inline int spi_write_dt(const struct spi_dt_spec *spec,
                               const struct spi_buf_set *tx_bufs)
{
        return spi_write(spec->bus, &spec->config, tx_bufs);
}
 
#if defined(CONFIG_SPI_ASYNC) || defined(__DOXYGEN__)
 
static inline 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)
{
        const struct spi_driver_api *api =
                (const struct spi_driver_api *)dev->api;
 
        return api->transceive_async(dev, config, tx_bufs, rx_bufs, callback, userdata);
}
 
#if defined(CONFIG_POLL) || defined(__DOXYGEN__)
 
void z_spi_transfer_signal_cb(const struct device *dev, int result, void *userdata);
static inline 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)
{
        const struct spi_driver_api *api =
                (const struct spi_driver_api *)dev->api;
        spi_callback_t cb = (sig == NULL) ? NULL : z_spi_transfer_signal_cb;
 
        return api->transceive_async(dev, config, tx_bufs, rx_bufs, cb, sig);
}
 
__deprecated static inline int spi_transceive_async(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)
{
        return spi_transceive_signal(dev, config, tx_bufs, rx_bufs, sig);
}
 
static inline 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)
{
        return spi_transceive_signal(dev, config, NULL, rx_bufs, sig);
}
 
__deprecated static inline int spi_read_async(const struct device *dev,
                                 const struct spi_config *config,
                                 const struct spi_buf_set *rx_bufs,
                                 struct k_poll_signal *sig)
{
        return spi_read_signal(dev, config, rx_bufs, sig);
}
 
static inline 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)
{
        return spi_transceive_signal(dev, config, tx_bufs, NULL, sig);
}
 
__deprecated static inline int spi_write_async(const struct device *dev,
                                 const struct spi_config *config,
                                 const struct spi_buf_set *tx_bufs,
                                 struct k_poll_signal *sig)
{
        return spi_write_signal(dev, config, tx_bufs, sig);
}
 
#endif /* CONFIG_POLL */
 
#endif /* CONFIG_SPI_ASYNC */
 
 
#if defined(CONFIG_SPI_RTIO) || defined(__DOXYGEN__)
 
static inline void spi_iodev_submit(struct rtio_iodev_sqe *iodev_sqe)
{
        const struct spi_dt_spec *dt_spec = iodev_sqe->sqe.iodev->data;
        const struct device *dev = dt_spec->bus;
        const struct spi_driver_api *api = (const struct spi_driver_api *)dev->api;
 
        api->iodev_submit(dt_spec->bus, iodev_sqe);
}
 
extern const struct rtio_iodev_api spi_iodev_api;
 
#define SPI_DT_IODEV_DEFINE(name, node_id, operation_, delay_)                  \
        const struct spi_dt_spec _spi_dt_spec_##name =                          \
                SPI_DT_SPEC_GET(node_id, operation_, delay_);                   \
        RTIO_IODEV_DEFINE(name, &spi_iodev_api, (void *)&_spi_dt_spec_##name)
 
static inline bool spi_is_ready_iodev(const struct rtio_iodev *spi_iodev)
{
        struct spi_dt_spec *spec = spi_iodev->data;
 
        return spi_is_ready_dt(spec);
}
 
static inline int spi_rtio_copy(struct rtio *r,
                                struct rtio_iodev *iodev,
                                const struct spi_buf_set *tx_bufs,
                                const struct spi_buf_set *rx_bufs,
                                struct rtio_sqe **last_sqe)
{
        int ret = 0;
        size_t tx_count = tx_bufs ? tx_bufs->count : 0;
        size_t rx_count = rx_bufs ? rx_bufs->count : 0;
 
        uint32_t tx = 0, tx_len = 0;
        uint32_t rx = 0, rx_len = 0;
        uint8_t *tx_buf, *rx_buf;
 
        struct rtio_sqe *sqe = NULL;
 
        if (tx < tx_count) {
                tx_buf = tx_bufs->buffers[tx].buf;
                tx_len = tx_bufs->buffers[tx].len;
        } else {
                tx_buf = NULL;
                tx_len = rx_bufs->buffers[rx].len;
        }
 
        if (rx < rx_count) {
                rx_buf = rx_bufs->buffers[rx].buf;
                rx_len = rx_bufs->buffers[rx].len;
        } else {
                rx_buf = NULL;
                rx_len = tx_bufs->buffers[tx].len;
        }
 
 
        while ((tx < tx_count || rx < rx_count) && (tx_len > 0 || rx_len > 0)) {
                sqe = rtio_sqe_acquire(r);
 
                if (sqe == NULL) {
                        ret = -ENOMEM;
                        rtio_sqe_drop_all(r);
                        goto out;
                }
 
                ret++;
 
                /* If tx/rx len are same, we can do a simple transceive */
                if (tx_len == rx_len) {
                        if (tx_buf == NULL) {
                                rtio_sqe_prep_read(sqe, iodev, RTIO_PRIO_NORM,
                                                   rx_buf, rx_len, NULL);
                        } else if (rx_buf == NULL) {
                                rtio_sqe_prep_write(sqe, iodev, RTIO_PRIO_NORM,
                                                    tx_buf, tx_len, NULL);
                        } else {
                                rtio_sqe_prep_transceive(sqe, iodev, RTIO_PRIO_NORM,
                                                         tx_buf, rx_buf, rx_len, NULL);
                        }
                        tx++;
                        rx++;
                        if (rx < rx_count) {
                                rx_buf = rx_bufs->buffers[rx].buf;
                                rx_len = rx_bufs->buffers[rx].len;
                        } else {
                                rx_buf = NULL;
                                rx_len = 0;
                        }
                        if (tx < tx_count) {
                                tx_buf = tx_bufs->buffers[tx].buf;
                                tx_len = tx_bufs->buffers[tx].len;
                        } else {
                                tx_buf = NULL;
                                tx_len = 0;
                        }
                } else if (tx_len == 0) {
                        rtio_sqe_prep_read(sqe, iodev, RTIO_PRIO_NORM,
                                           (uint8_t *)rx_buf,
                                           (uint32_t)rx_len,
                                           NULL);
                        rx++;
                        if (rx < rx_count) {
                                rx_buf = rx_bufs->buffers[rx].buf;
                                rx_len = rx_bufs->buffers[rx].len;
                        } else {
                                rx_buf = NULL;
                                rx_len = 0;
                        }
                } else if (rx_len == 0) {
                        rtio_sqe_prep_write(sqe, iodev, RTIO_PRIO_NORM,
                                            (uint8_t *)tx_buf,
                                            (uint32_t)tx_len,
                                            NULL);
                        tx++;
                        if (tx < tx_count) {
                                tx_buf = rx_bufs->buffers[rx].buf;
                                tx_len = rx_bufs->buffers[rx].len;
                        } else {
                                tx_buf = NULL;
                                tx_len = 0;
                        }
                } else if (tx_len > rx_len) {
                        rtio_sqe_prep_transceive(sqe, iodev, RTIO_PRIO_NORM,
                                                 (uint8_t *)tx_buf,
                                                 (uint8_t *)rx_buf,
                                                 (uint32_t)rx_len,
                                                 NULL);
                        tx_len -= rx_len;
                        tx_buf += rx_len;
                        rx++;
                        if (rx < rx_count) {
                                rx_buf = rx_bufs->buffers[rx].buf;
                                rx_len = rx_bufs->buffers[rx].len;
                        } else {
                                rx_buf = NULL;
                                rx_len = tx_len;
                        }
                } else if (rx_len > tx_len) {
                        rtio_sqe_prep_transceive(sqe, iodev, RTIO_PRIO_NORM,
                                                 (uint8_t *)tx_buf,
                                                 (uint8_t *)rx_buf,
                                                 (uint32_t)tx_len,
                                                 NULL);
                        rx_len -= tx_len;
                        rx_buf += tx_len;
                        tx++;
                        if (tx < tx_count) {
                                tx_buf = tx_bufs->buffers[tx].buf;
                                tx_len = tx_bufs->buffers[tx].len;
                        } else {
                                tx_buf = NULL;
                                tx_len = rx_len;
                        }
                } else {
                        __ASSERT_NO_MSG("Invalid spi_rtio_copy state");
                }
 
                sqe->flags = RTIO_SQE_TRANSACTION;
        }
 
        if (sqe != NULL) {
                sqe->flags = 0;
                *last_sqe = sqe;
        }
 
out:
        return ret;
}
 
#endif /* CONFIG_SPI_RTIO */
 
__syscall int spi_release(const struct device *dev,
                          const struct spi_config *config);
 
static inline int z_impl_spi_release(const struct device *dev,
                                     const struct spi_config *config)
{
        const struct spi_driver_api *api =
                (const struct spi_driver_api *)dev->api;
 
        return api->release(dev, config);
}
 
static inline int spi_release_dt(const struct spi_dt_spec *spec)
{
        return spi_release(spec->bus, &spec->config);
}
 
#ifdef __cplusplus
}
#endif
 
#include <syscalls/spi.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_SPI_H_ */