device.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DEVICE_H_
#define ZEPHYR_INCLUDE_DEVICE_H_
 
#include <init.h>
#include <linker/sections.h>
#include <pm/device.h>
#include <sys/device_mmio.h>
#include <sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef int16_t device_handle_t;
 
#define DEVICE_HANDLE_SEP INT16_MIN
 
#define DEVICE_HANDLE_ENDS INT16_MAX
 
#define DEVICE_HANDLE_NULL 0
 
#define Z_DEVICE_MAX_NAME_LEN   48
 
#define DEVICE_NAME_GET(name) _CONCAT(__device_, name)
 
#define SYS_DEVICE_DEFINE(drv_name, init_fn, pm_control_fn, level, prio) \
        DEVICE_DEFINE(Z_SYS_NAME(init_fn), drv_name, init_fn,           \
                      pm_control_fn,                                    \
                      NULL, NULL, level, prio, NULL)
 
#define DEVICE_DEFINE(dev_name, drv_name, init_fn, pm_control_fn,       \
                      data_ptr, cfg_ptr, level, prio, api_ptr)          \
        Z_DEVICE_DEFINE(DT_INVALID_NODE, dev_name, drv_name, init_fn,   \
                        pm_control_fn,                                  \
                        data_ptr, cfg_ptr, level, prio, api_ptr)
 
#define DEVICE_DT_NAME(node_id) \
        DT_PROP_OR(node_id, label, DT_NODE_FULL_NAME(node_id))
 
#define DEVICE_DT_DEFINE(node_id, init_fn, pm_control_fn,               \
                         data_ptr, cfg_ptr, level, prio,                \
                         api_ptr, ...)                                  \
        Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_NAME(node_id),         \
                        DEVICE_DT_NAME(node_id), init_fn,               \
                        pm_control_fn,                                  \
                        data_ptr, cfg_ptr, level, prio,                 \
                        api_ptr, __VA_ARGS__)
 
#define DEVICE_DT_INST_DEFINE(inst, ...) \
        DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
 
#define DEVICE_DT_NAME_GET(node_id) DEVICE_NAME_GET(Z_DEVICE_DT_DEV_NAME(node_id))
 
#define DEVICE_DT_GET(node_id) (&DEVICE_DT_NAME_GET(node_id))
 
#define DEVICE_DT_INST_GET(inst) DEVICE_DT_GET(DT_DRV_INST(inst))
 
#define DEVICE_DT_GET_ANY(compat)                                           \
        COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(compat),                      \
                    (DEVICE_DT_GET(DT_COMPAT_GET_ANY_STATUS_OKAY(compat))), \
                    (NULL))
 
#define DEVICE_DT_GET_ONE(compat)                                           \
        COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(compat),                      \
                    (DEVICE_DT_GET(DT_COMPAT_GET_ANY_STATUS_OKAY(compat))), \
                    (ZERO_OR_COMPILE_ERROR(0)))
 
#define DEVICE_GET(name) (&DEVICE_NAME_GET(name))
 
#define DEVICE_DECLARE(name) static const struct device DEVICE_NAME_GET(name)
 
struct device_state {
        unsigned int init_res : 8;
 
        bool initialized : 1;
 
#ifdef CONFIG_PM_DEVICE
        /* Power management data */
        struct pm_device pm;
#endif /* CONFIG_PM_DEVICE */
};
 
struct device {
        const char *name;
        const void *config;
        const void *api;
        struct device_state * const state;
        void * const data;
        const device_handle_t *const handles;
#ifdef CONFIG_PM_DEVICE
        pm_device_control_callback_t pm_control;
        struct pm_device * const pm;
#endif
};
 
static inline device_handle_t
device_handle_get(const struct device *dev)
{
        device_handle_t ret = DEVICE_HANDLE_NULL;
        extern const struct device __device_start[];
 
        /* TODO: If/when devices can be constructed that are not part of the
         * fixed sequence we'll need another solution.
         */
        if (dev != NULL) {
                ret = 1 + (device_handle_t)(dev - __device_start);
        }
 
        return ret;
}
 
static inline const struct device *
device_from_handle(device_handle_t dev_handle)
{
        extern const struct device __device_start[];
        extern const struct device __device_end[];
        const struct device *dev = NULL;
        size_t numdev = __device_end - __device_start;
 
        if ((dev_handle > 0) && ((size_t)dev_handle <= numdev)) {
                dev = &__device_start[dev_handle - 1];
        }
 
        return dev;
}
 
typedef int (*device_visitor_callback_t)(const struct device *dev, void *context);
 
static inline const device_handle_t *
device_required_handles_get(const struct device *dev,
                            size_t *count)
{
        const device_handle_t *rv = dev->handles;
 
        if (rv != NULL) {
                size_t i = 0;
 
                while (rv[i] != DEVICE_HANDLE_SEP) {
                        ++i;
                }
                *count = i;
        }
 
        return rv;
}
 
static inline const device_handle_t *
device_supported_handles_get(const struct device *dev,
                             size_t *count)
{
        const device_handle_t *rv = dev->handles;
        size_t region = 0;
        size_t i = 0;
 
        if (rv != NULL) {
                /* Fast forward to supporting devices */
                while (region != 2) {
                        if (*rv == DEVICE_HANDLE_SEP) {
                                region++;
                        }
                        rv++;
                }
                /* Count supporting devices */
                while (rv[i] != DEVICE_HANDLE_ENDS) {
                        ++i;
                }
                *count = i;
        }
 
        return rv;
}
 
int device_required_foreach(const struct device *dev,
                          device_visitor_callback_t visitor_cb,
                          void *context);
 
int device_supported_foreach(const struct device *dev,
                             device_visitor_callback_t visitor_cb,
                             void *context);
 
__syscall const struct device *device_get_binding(const char *name);
 
size_t z_device_get_all_static(const struct device * *devices);
 
bool z_device_ready(const struct device *dev);
 
static inline int z_device_usable_check(const struct device *dev)
{
        return z_device_ready(dev) ? 0 : -ENODEV;
}
 
__syscall int device_usable_check(const struct device *dev);
 
static inline int z_impl_device_usable_check(const struct device *dev)
{
        return z_device_usable_check(dev);
}
 
static inline bool device_is_ready(const struct device *dev)
{
        return device_usable_check(dev) == 0;
}
 
/* Node paths can exceed the maximum size supported by device_get_binding() in user mode,
 * so synthesize a unique dev_name from the devicetree node.
 *
 * The ordinal used in this name can be mapped to the path by
 * examining zephyr/include/generated/device_extern.h header. If the
 * format of this conversion changes, gen_defines should be updated to
 * match it.
 */
#define Z_DEVICE_DT_DEV_NAME(node_id) _CONCAT(dts_ord_, DT_DEP_ORD(node_id))
 
/* Synthesize a unique name for the device state associated with
 * dev_name.
 */
#define Z_DEVICE_STATE_NAME(dev_name) _CONCAT(__devstate_, dev_name)
 
#define Z_DEVICE_HANDLE_NAME(node_id, dev_name)                         \
        _CONCAT(__devicehdl_,                                           \
                COND_CODE_1(DT_NODE_EXISTS(node_id),                    \
                            (node_id),                                  \
                            (dev_name)))
 
#define Z_DEVICE_EXTRA_HANDLES(...)                             \
        FOR_EACH_NONEMPTY_TERM(IDENTITY, (,), __VA_ARGS__)
 
#ifdef CONFIG_PM_DEVICE
#define Z_DEVICE_STATE_PM_INIT(node_id, dev_name)                       \
        .pm = Z_PM_DEVICE_INIT(Z_DEVICE_STATE_NAME(dev_name).pm, node_id),
#else
#define Z_DEVICE_STATE_PM_INIT(node_id, dev_name)
#endif
 
#define Z_DEVICE_STATE_DEFINE(node_id, dev_name)                        \
        static struct device_state Z_DEVICE_STATE_NAME(dev_name)        \
        __attribute__((__section__(".z_devstate"))) = {                 \
                Z_DEVICE_STATE_PM_INIT(node_id, dev_name)               \
        };
 
/* If device power management is enabled, this macro defines a pointer to a
 * device in the z_pm_device_slots region. When invoked for each device, this
 * will effectively result in a device pointer array with the same size of the
 * actual devices list. This is used internally by the device PM subsystem to
 * keep track of suspended devices during system power transitions.
 */
#if CONFIG_PM_DEVICE
#define Z_DEVICE_DEFINE_PM_SLOT(dev_name)                               \
        static const Z_DECL_ALIGN(struct device *)                      \
        _CONCAT(__pm_device_slot_, DEVICE_NAME_GET(dev_name)) __used    \
        __attribute__((__section__(".z_pm_device_slots")));
#else
#define Z_DEVICE_DEFINE_PM_SLOT(dev_name)
#endif
 
/* Construct objects that are referenced from struct device. These
 * include power management and dependency handles.
 */
#define Z_DEVICE_DEFINE_PRE(node_id, dev_name, ...)                     \
        Z_DEVICE_DEFINE_HANDLES(node_id, dev_name, __VA_ARGS__)         \
        Z_DEVICE_STATE_DEFINE(node_id, dev_name)                        \
        Z_DEVICE_DEFINE_PM_SLOT(dev_name)
 
 
/* Initial build provides a record that associates the device object
 * with its devicetree ordinal, and provides the dependency ordinals.
 * These are provided as weak definitions (to prevent the reference
 * from being captured when the original object file is compiled), and
 * in a distinct pass1 section (which will be replaced by
 * postprocessing).
 *
 * Before processing in gen_handles.py, the array format is:
 * {
 *     DEVICE_ORDINAL (or DEVICE_HANDLE_NULL if not a devicetree node),
 *     List of devicetree dependency ordinals (if any),
 *     DEVICE_HANDLE_SEP,
 *     List of injected dependency ordinals (if any),
 *     DEVICE_HANDLE_SEP,
 *     List of devicetree supporting ordinals (if any),
 * }
 *
 * After processing in gen_handles.py, the format is updated to:
 * {
 *     List of existing devicetree dependency handles (if any),
 *     DEVICE_HANDLE_SEP,
 *     List of injected dependency ordinals (if any),
 *     DEVICE_HANDLE_SEP,
 *     List of existing devicetree support handles (if any),
 *     DEVICE_HANDLE_NULL padding to original length (at least one)
 * }
 *
 * It is also (experimentally) necessary to provide explicit alignment
 * on each object. Otherwise x86-64 builds will introduce padding
 * between objects in the same input section in individual object
 * files, which will be retained in subsequent links both wasting
 * space and resulting in aggregate size changes relative to pass2
 * when all objects will be in the same input section.
 *
 * The build assert will fail if device_handle_t changes size, which
 * means the alignment directives in the linker scripts and in
 * `gen_handles.py` must be updated.
 */
BUILD_ASSERT(sizeof(device_handle_t) == 2, "fix the linker scripts");
#define Z_DEVICE_DEFINE_HANDLES(node_id, dev_name, ...)                 \
        extern const device_handle_t                                    \
                Z_DEVICE_HANDLE_NAME(node_id, dev_name)[];              \
        const device_handle_t                                           \
        __aligned(sizeof(device_handle_t))                              \
        __attribute__((__weak__,                                        \
                       __section__(".__device_handles_pass1")))         \
        Z_DEVICE_HANDLE_NAME(node_id, dev_name)[] = {                   \
        COND_CODE_1(DT_NODE_EXISTS(node_id), (                          \
                        DT_DEP_ORD(node_id),                            \
                        DT_REQUIRES_DEP_ORDS(node_id)                   \
                ), (                                                    \
                        DEVICE_HANDLE_NULL,                             \
                ))                                                      \
                        DEVICE_HANDLE_SEP,                              \
                        Z_DEVICE_EXTRA_HANDLES(__VA_ARGS__)             \
                        DEVICE_HANDLE_SEP,                              \
        COND_CODE_1(DT_NODE_EXISTS(node_id),                            \
                        (DT_SUPPORTS_DEP_ORDS(node_id)), ())            \
                };
 
#ifdef CONFIG_PM_DEVICE
#define Z_DEVICE_DEFINE_PM_INIT(dev_name, pm_control_fn)                \
        .pm_control = (pm_control_fn),                                  \
        .pm = &Z_DEVICE_STATE_NAME(dev_name).pm,
#else
#define Z_DEVICE_DEFINE_PM_INIT(dev_name, pm_control_fn)
#endif
 
#define Z_DEVICE_DEFINE_INIT(node_id, dev_name, pm_control_fn)          \
                .handles = Z_DEVICE_HANDLE_NAME(node_id, dev_name),     \
                Z_DEVICE_DEFINE_PM_INIT(dev_name, pm_control_fn)
 
/* Like DEVICE_DEFINE but takes a node_id AND a dev_name, and trailing
 * dependency handles that come from outside devicetree.
 */
#define Z_DEVICE_DEFINE(node_id, dev_name, drv_name, init_fn, pm_control_fn, \
                        data_ptr, cfg_ptr, level, prio, api_ptr, ...)   \
        Z_DEVICE_DEFINE_PRE(node_id, dev_name, __VA_ARGS__)             \
        COND_CODE_1(DT_NODE_EXISTS(node_id), (), (static))              \
                const Z_DECL_ALIGN(struct device)                       \
                DEVICE_NAME_GET(dev_name) __used                        \
        __attribute__((__section__(".z_device_" #level STRINGIFY(prio)"_"))) = { \
                .name = drv_name,                                       \
                .config = (cfg_ptr),                                    \
                .api = (api_ptr),                                       \
                .state = &Z_DEVICE_STATE_NAME(dev_name),                \
                .data = (data_ptr),                                     \
                Z_DEVICE_DEFINE_INIT(node_id, dev_name, pm_control_fn)  \
        };                                                              \
        BUILD_ASSERT(sizeof(Z_STRINGIFY(drv_name)) <= Z_DEVICE_MAX_NAME_LEN, \
                     Z_STRINGIFY(DEVICE_NAME_GET(drv_name)) " too long"); \
        Z_INIT_ENTRY_DEFINE(DEVICE_NAME_GET(dev_name), init_fn,         \
                (&DEVICE_NAME_GET(dev_name)), level, prio)
 
#ifdef __cplusplus
}
#endif
 
/* device_extern is generated based on devicetree nodes */
#include <device_extern.h>
 
#include <syscalls/device.h>
 
#endif /* ZEPHYR_INCLUDE_DEVICE_H_ */