emul.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Nordic Semiconductor ASA
 * Copyright 2020 Google LLC
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_EMUL_H_
#define ZEPHYR_INCLUDE_DRIVERS_EMUL_H_
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
struct emul;
 
/* #includes required after forward-declaration of struct emul later defined in this header. */
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/espi_emul.h>
#include <zephyr/drivers/i2c_emul.h>
#include <zephyr/drivers/spi_emul.h>
#include <zephyr/drivers/mspi_emul.h>
#include <zephyr/drivers/uart_emul.h>
#include <zephyr/sys/iterable_sections.h>
 
enum emul_bus_type {
        EMUL_BUS_TYPE_I2C,
        EMUL_BUS_TYPE_ESPI,
        EMUL_BUS_TYPE_SPI,
        EMUL_BUS_TYPE_MSPI,
        EMUL_BUS_TYPE_UART,
        EMUL_BUS_TYPE_NONE,
};
 
struct emul_link_for_bus {
        const struct device *dev;
};
 
struct emul_list_for_bus {
        const struct emul_link_for_bus *children;
        unsigned int num_children;
};
 
typedef int (*emul_init_t)(const struct emul *emul, const struct device *parent);
 
struct no_bus_emul {
        void *api;
        uint16_t addr;
};
 
struct emul {
        emul_init_t init;
        const struct device *dev;
        const void *cfg;
        void *data;
        enum emul_bus_type bus_type;
        union bus {
                struct i2c_emul *i2c;
                struct espi_emul *espi;
                struct spi_emul *spi;
                struct mspi_emul *mspi;
                struct uart_emul *uart;
                struct no_bus_emul *none;
        } bus;
        const void *backend_api;
};
 
#define EMUL_DT_NAME_GET(node_id) _CONCAT(__emulreg_, node_id)
 
/* Get a unique identifier based on the given _dev_node_id's reg property and
 * the bus its on. Intended for use in other internal macros when declaring {bus}_emul
 * structs in peripheral emulators.
 */
#define Z_EMUL_REG_BUS_IDENTIFIER(_dev_node_id) _CONCAT(_CONCAT(__emulreg_, _dev_node_id), _bus)
 
/* Conditionally places text based on what bus _dev_node_id is on. */
#define Z_EMUL_BUS(_dev_node_id, _i2c, _espi, _spi, _mspi, _uart, _none)                           \
        COND_CODE_1(DT_ON_BUS(_dev_node_id, i2c), (_i2c),                                          \
        (COND_CODE_1(DT_ON_BUS(_dev_node_id, espi), (_espi),                                       \
        (COND_CODE_1(DT_ON_BUS(_dev_node_id, spi), (_spi),                                         \
        (COND_CODE_1(DT_ON_BUS(_dev_node_id, mspi), (_mspi),                                       \
        (COND_CODE_1(DT_ON_BUS(_dev_node_id, uart), (_uart),                                       \
        (_none))))))))))
 
#define EMUL_DT_DEFINE(node_id, init_fn, data_ptr, cfg_ptr, bus_api, _backend_api)                 \
        static struct Z_EMUL_BUS(node_id, i2c_emul, espi_emul, spi_emul, mspi_emul, uart_emul,     \
                                 no_bus_emul) Z_EMUL_REG_BUS_IDENTIFIER(node_id) = {               \
                .api = bus_api,                                                                    \
                IF_ENABLED(DT_NODE_HAS_PROP(node_id, reg),                                         \
                           (.Z_EMUL_BUS(node_id, addr, chipsel, chipsel, dev_idx, dummy, addr) =   \
                                    DT_REG_ADDR(node_id),))};                                      \
        const STRUCT_SECTION_ITERABLE(emul, EMUL_DT_NAME_GET(node_id)) __used = {                  \
                .init = (init_fn),                                                                 \
                .dev = DEVICE_DT_GET(node_id),                                                     \
                .cfg = (cfg_ptr),                                                                  \
                .data = (data_ptr),                                                                \
                .bus_type = Z_EMUL_BUS(node_id, EMUL_BUS_TYPE_I2C, EMUL_BUS_TYPE_ESPI,             \
                                       EMUL_BUS_TYPE_SPI, EMUL_BUS_TYPE_MSPI, EMUL_BUS_TYPE_UART,  \
                                       EMUL_BUS_TYPE_NONE),                                        \
                .bus = {.Z_EMUL_BUS(node_id, i2c, espi, spi, mspi, uart, none) =                   \
                                &(Z_EMUL_REG_BUS_IDENTIFIER(node_id))},                            \
                .backend_api = (_backend_api),                                                     \
        };
 
#define EMUL_DT_INST_DEFINE(inst, ...) EMUL_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
 
#define EMUL_DT_GET(node_id) (&EMUL_DT_NAME_GET(node_id))
 
#define EMUL_DT_GET_OR_NULL(node_id)                                                               \
        COND_CODE_1(DT_NODE_HAS_STATUS(node_id, okay), (EMUL_DT_GET(node_id)), (NULL))
 
int emul_init_for_bus(const struct device *dev);
 
const struct emul *emul_get_binding(const char *name);
 
#define Z_MAYBE_EMUL_DECLARE_INTERNAL(node_id) extern const struct emul EMUL_DT_NAME_GET(node_id);
 
DT_FOREACH_STATUS_OKAY_NODE(Z_MAYBE_EMUL_DECLARE_INTERNAL);
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_EMUL_H_ */