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_

 
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>
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

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_CASE_1(DT_ON_BUS(_dev_node_id, i2c), (_i2c),                                          \
                    DT_ON_BUS(_dev_node_id, espi), (_espi),                                        \
                    DT_ON_BUS(_dev_node_id, spi), (_spi),                                          \
                    DT_ON_BUS(_dev_node_id, mspi), (_mspi),                                        \
                    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_OKAY(node_id), (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_ */