devicetree.h

Go to the documentation of this file.

/*
 * SPDX-License-Identifier: Apache-2.0
 * Copyright (c) 2020 Nordic Semiconductor
 * Copyright (c) 2020, Linaro Ltd.
 *
 * Not a generated file. Feel free to modify.
 */
 
#ifndef DEVICETREE_H
#define DEVICETREE_H
 
#include <devicetree_generated.h>
#include <zephyr/irq_multilevel.h>
 
#if !defined(_LINKER) && !defined(_ASMLANGUAGE)
#include <stdint.h>
#endif
 
#include <zephyr/sys/util.h>
 
/*
 * Property suffixes
 * -----------------
 *
 * These are the optional parts that come after the _P_<property>
 * part in DT_N_<path-id>_P_<property-id> macros, or the "prop-suf"
 * nonterminal in the DT guide's macros.bnf file.
 *
 * Before adding new ones, check this list to avoid conflicts. If any
 * are missing from this list, please add them. It should be complete.
 *
 * _ENUM_IDX: property's value as an index into bindings enum
 * _ENUM_VAL_<val>_EXISTS property's value as a token exists
 * _ENUM_TOKEN: property's value as a token into bindings enum (string
 *              enum values are identifiers) [deprecated, use _STRING_TOKEN]
 * _ENUM_UPPER_TOKEN: like _ENUM_TOKEN, but uppercased [deprecated, use
 *                    _STRING_UPPER_TOKEN]
 * _EXISTS: property is defined
 * _FOREACH_PROP_ELEM: helper for "iterating" over values in the property
 * _FOREACH_PROP_ELEM_VARGS: foreach functions with variable number of arguments
 * _IDX_<i>: logical index into property
 * _IDX_<i>_EXISTS: logical index into property is defined
 * _IDX_<i>_PH: phandle array's phandle by index (or phandle, phandles)
 * _IDX_<i>_STRING_TOKEN: string array element value as a token
 * _IDX_<i>_STRING_UPPER_TOKEN: string array element value as a uppercased token
 * _IDX <i>_STRING_UNQUOTED: string array element value as a sequence of tokens, with no quotes
 * _IDX_<i>_VAL_<val>: phandle array's specifier value by index
 * _IDX_<i>_VAL_<val>_EXISTS: cell value exists, by index
 * _LEN: property logical length
 * _NAME_<name>_PH: phandle array's phandle by name
 * _NAME_<name>_VAL_<val>: phandle array's property specifier by name
 * _NAME_<name>_VAL_<val>_EXISTS: cell value exists, by name
 * _STRING_TOKEN: string property's value as a token
 * _STRING_UPPER_TOKEN: like _STRING_TOKEN, but uppercased
 * _STRING_UNQUOTED: string property's value as a sequence of tokens, with no quotes
 */
 
#define DT_INVALID_NODE _
 
#define DT_ROOT DT_N
 
#define DT_PATH(...) DT_PATH_INTERNAL(__VA_ARGS__)
 
#define DT_NODELABEL(label) DT_CAT(DT_N_NODELABEL_, label)
 
#define DT_ALIAS(alias) DT_CAT(DT_N_ALIAS_, alias)
 
#define DT_INST(inst, compat) UTIL_CAT(DT_N_INST, DT_DASH(inst, compat))
 
#define DT_PARENT(node_id) DT_CAT(node_id, _PARENT)
 
#define DT_GPARENT(node_id) DT_PARENT(DT_PARENT(node_id))
 
#define DT_CHILD(node_id, child) UTIL_CAT(node_id, DT_S_PREFIX(child))
 
#define DT_COMPAT_GET_ANY_STATUS_OKAY(compat)                   \
        COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(compat),  \
                    (DT_INST(0, compat)),               \
                    (DT_INVALID_NODE))
 
#define DT_NODE_PATH(node_id) DT_CAT(node_id, _PATH)
 
#define DT_NODE_FULL_NAME(node_id) DT_CAT(node_id, _FULL_NAME)
 
#define DT_NODE_CHILD_IDX(node_id) DT_CAT(node_id, _CHILD_IDX)
 
#define DT_SAME_NODE(node_id1, node_id2) \
        (DT_DEP_ORD(node_id1) == (DT_DEP_ORD(node_id2)))
 
#define DT_PROP(node_id, prop) DT_CAT3(node_id, _P_, prop)
 
#define DT_PROP_LEN(node_id, prop) DT_CAT4(node_id, _P_, prop, _LEN)
 
#define DT_PROP_LEN_OR(node_id, prop, default_value) \
        COND_CODE_1(DT_NODE_HAS_PROP(node_id, prop), \
                    (DT_PROP_LEN(node_id, prop)), (default_value))
 
#define DT_PROP_HAS_IDX(node_id, prop, idx) \
        IS_ENABLED(DT_CAT6(node_id, _P_, prop, _IDX_, idx, _EXISTS))
 
#define DT_PROP_HAS_NAME(node_id, prop, name) \
        IS_ENABLED(DT_CAT6(node_id, _P_, prop, _NAME_, name, _EXISTS))
 
#define DT_PROP_BY_IDX(node_id, prop, idx) \
        DT_CAT5(node_id, _P_, prop, _IDX_, idx)
 
#define DT_PROP_OR(node_id, prop, default_value) \
        COND_CODE_1(DT_NODE_HAS_PROP(node_id, prop), \
                    (DT_PROP(node_id, prop)), (default_value))
 
#define DT_ENUM_IDX(node_id, prop) DT_CAT4(node_id, _P_, prop, _ENUM_IDX)
 
#define DT_ENUM_IDX_OR(node_id, prop, default_idx_value) \
        COND_CODE_1(DT_NODE_HAS_PROP(node_id, prop), \
                    (DT_ENUM_IDX(node_id, prop)), (default_idx_value))
 
#define DT_ENUM_HAS_VALUE(node_id, prop, value) \
        IS_ENABLED(DT_CAT6(node_id, _P_, prop, _ENUM_VAL_, value, _EXISTS))
 
#define DT_STRING_TOKEN(node_id, prop) \
        DT_CAT4(node_id, _P_, prop, _STRING_TOKEN)
 
#define DT_STRING_TOKEN_OR(node_id, prop, default_value) \
        COND_CODE_1(DT_NODE_HAS_PROP(node_id, prop), \
                (DT_STRING_TOKEN(node_id, prop)), (default_value))
 
#define DT_STRING_UPPER_TOKEN(node_id, prop) \
        DT_CAT4(node_id, _P_, prop, _STRING_UPPER_TOKEN)
 
#define DT_STRING_UPPER_TOKEN_OR(node_id, prop, default_value) \
        COND_CODE_1(DT_NODE_HAS_PROP(node_id, prop), \
                (DT_STRING_UPPER_TOKEN(node_id, prop)), (default_value))
 
#define DT_STRING_UNQUOTED(node_id, prop) \
        DT_CAT4(node_id, _P_, prop, _STRING_UNQUOTED)
 
#define DT_STRING_UNQUOTED_OR(node_id, prop, default_value) \
        COND_CODE_1(DT_NODE_HAS_PROP(node_id, prop), \
                (DT_STRING_UNQUOTED(node_id, prop)), (default_value))
 
#define DT_STRING_TOKEN_BY_IDX(node_id, prop, idx) \
        DT_CAT6(node_id, _P_, prop, _IDX_, idx, _STRING_TOKEN)
 
#define DT_STRING_UPPER_TOKEN_BY_IDX(node_id, prop, idx) \
        DT_CAT6(node_id, _P_, prop, _IDX_, idx, _STRING_UPPER_TOKEN)
 
#define DT_STRING_UNQUOTED_BY_IDX(node_id, prop, idx) \
        DT_CAT6(node_id, _P_, prop, _IDX_, idx, _STRING_UNQUOTED)
 
/*
 * phandle properties
 *
 * These are special-cased to manage the impedance mismatch between
 * phandles, which are just uint32_t node properties that only make sense
 * within the tree itself, and C values.
 */
 
#define DT_PROP_BY_PHANDLE_IDX(node_id, phs, idx, prop) \
        DT_PROP(DT_PHANDLE_BY_IDX(node_id, phs, idx), prop)
 
#define DT_PROP_BY_PHANDLE_IDX_OR(node_id, phs, idx, prop, default_value) \
        DT_PROP_OR(DT_PHANDLE_BY_IDX(node_id, phs, idx), prop, default_value)
 
#define DT_PROP_BY_PHANDLE(node_id, ph, prop) \
        DT_PROP_BY_PHANDLE_IDX(node_id, ph, 0, prop)
 
#define DT_PHA_BY_IDX(node_id, pha, idx, cell) \
        DT_CAT7(node_id, _P_, pha, _IDX_, idx, _VAL_, cell)
 
#define DT_PHA_BY_IDX_OR(node_id, pha, idx, cell, default_value) \
        DT_PROP_OR(node_id, DT_CAT5(pha, _IDX_, idx, _VAL_, cell), default_value)
 
#define DT_PHA(node_id, pha, cell) DT_PHA_BY_IDX(node_id, pha, 0, cell)
 
#define DT_PHA_OR(node_id, pha, cell, default_value) \
        DT_PHA_BY_IDX_OR(node_id, pha, 0, cell, default_value)
 
#define DT_PHA_BY_NAME(node_id, pha, name, cell) \
        DT_CAT7(node_id, _P_, pha, _NAME_, name, _VAL_, cell)
 
#define DT_PHA_BY_NAME_OR(node_id, pha, name, cell, default_value) \
        DT_PROP_OR(node_id, DT_CAT5(pha, _NAME_, name, _VAL_, cell), default_value)
 
#define DT_PHANDLE_BY_NAME(node_id, pha, name) \
        DT_CAT6(node_id, _P_, pha, _NAME_, name, _PH)
 
#define DT_PHANDLE_BY_IDX(node_id, prop, idx) \
        DT_CAT6(node_id, _P_, prop, _IDX_, idx, _PH)
 
#define DT_PHANDLE(node_id, prop) DT_PHANDLE_BY_IDX(node_id, prop, 0)
 
#define DT_NUM_RANGES(node_id) DT_CAT(node_id, _RANGES_NUM)
 
#define DT_RANGES_HAS_IDX(node_id, idx) \
        IS_ENABLED(DT_CAT4(node_id, _RANGES_IDX_, idx, _EXISTS))
 
#define DT_RANGES_HAS_CHILD_BUS_FLAGS_AT_IDX(node_id, idx) \
        IS_ENABLED(DT_CAT4(node_id, _RANGES_IDX_, idx, _VAL_CHILD_BUS_FLAGS_EXISTS))
 
#define DT_RANGES_CHILD_BUS_FLAGS_BY_IDX(node_id, idx) \
        DT_CAT4(node_id, _RANGES_IDX_, idx, _VAL_CHILD_BUS_FLAGS)
 
#define DT_RANGES_CHILD_BUS_ADDRESS_BY_IDX(node_id, idx) \
        DT_CAT4(node_id, _RANGES_IDX_, idx, _VAL_CHILD_BUS_ADDRESS)
 
#define DT_RANGES_PARENT_BUS_ADDRESS_BY_IDX(node_id, idx) \
        DT_CAT4(node_id, _RANGES_IDX_, idx, _VAL_PARENT_BUS_ADDRESS)
 
#define DT_RANGES_LENGTH_BY_IDX(node_id, idx) \
        DT_CAT4(node_id, _RANGES_IDX_, idx, _VAL_LENGTH)
 
#define DT_FOREACH_RANGE(node_id, fn) \
        DT_CAT(node_id, _FOREACH_RANGE)(fn)
 
#define DT_NODE_VENDOR_BY_IDX(node_id, idx) \
        DT_CAT3(node_id, _COMPAT_VENDOR_IDX_, idx)
 
#define DT_NODE_VENDOR_HAS_IDX(node_id, idx) \
        IS_ENABLED(DT_CAT4(node_id, _COMPAT_VENDOR_IDX_, idx, _EXISTS))
 
#define DT_NODE_VENDOR_BY_IDX_OR(node_id, idx, default_value) \
        COND_CODE_1(DT_NODE_VENDOR_HAS_IDX(node_id, idx), \
                    (DT_NODE_VENDOR_BY_IDX(node_id, idx)), (default_value))
 
#define DT_NODE_VENDOR_OR(node_id, default_value) \
        DT_NODE_VENDOR_BY_IDX_OR(node_id, 0, default_value)
 
#define DT_NODE_MODEL_BY_IDX(node_id, idx) \
        DT_CAT3(node_id, _COMPAT_MODEL_IDX_, idx)
 
#define DT_NODE_MODEL_HAS_IDX(node_id, idx) \
        IS_ENABLED(DT_CAT4(node_id, _COMPAT_MODEL_IDX_, idx, _EXISTS))
 
#define DT_NODE_MODEL_BY_IDX_OR(node_id, idx, default_value) \
        COND_CODE_1(DT_NODE_MODEL_HAS_IDX(node_id, idx), \
                    (DT_NODE_MODEL_BY_IDX(node_id, idx)), (default_value))
 
#define DT_NODE_MODEL_OR(node_id, default_value) \
        DT_NODE_MODEL_BY_IDX_OR(node_id, 0, default_value)
 
#define DT_NUM_REGS(node_id) DT_CAT(node_id, _REG_NUM)
 
#define DT_REG_HAS_IDX(node_id, idx) \
        IS_ENABLED(DT_CAT4(node_id, _REG_IDX_, idx, _EXISTS))
 
#define DT_REG_ADDR_BY_IDX(node_id, idx) \
        DT_CAT4(node_id, _REG_IDX_, idx, _VAL_ADDRESS)
 
#define DT_REG_SIZE_BY_IDX(node_id, idx) \
        DT_CAT4(node_id, _REG_IDX_, idx, _VAL_SIZE)
 
#define DT_REG_ADDR(node_id) DT_REG_ADDR_BY_IDX(node_id, 0)
 
#define DT_REG_ADDR_U64(node_id) DT_U64_C(DT_REG_ADDR(node_id))
 
#define DT_REG_SIZE(node_id) DT_REG_SIZE_BY_IDX(node_id, 0)
 
#define DT_REG_ADDR_BY_NAME(node_id, name) \
        DT_CAT4(node_id, _REG_NAME_, name, _VAL_ADDRESS)
 
#define DT_REG_ADDR_BY_NAME_U64(node_id, name) \
        DT_U64_C(DT_REG_ADDR_BY_NAME(node_id, name))
 
#define DT_REG_SIZE_BY_NAME(node_id, name) \
        DT_CAT4(node_id, _REG_NAME_, name, _VAL_SIZE)
 
#define DT_NUM_IRQS(node_id) DT_CAT(node_id, _IRQ_NUM)
 
#define DT_IRQ_LEVEL(node_id) DT_CAT(node_id, _IRQ_LEVEL)
 
#define DT_IRQ_HAS_IDX(node_id, idx) \
        IS_ENABLED(DT_CAT4(node_id, _IRQ_IDX_, idx, _EXISTS))
 
#define DT_IRQ_HAS_CELL_AT_IDX(node_id, idx, cell) \
        IS_ENABLED(DT_CAT6(node_id, _IRQ_IDX_, idx, _VAL_, cell, _EXISTS))
 
#define DT_IRQ_HAS_CELL(node_id, cell) DT_IRQ_HAS_CELL_AT_IDX(node_id, 0, cell)
 
#define DT_IRQ_HAS_NAME(node_id, name) \
        IS_ENABLED(DT_CAT4(node_id, _IRQ_NAME_, name, _VAL_irq_EXISTS))
 
#define DT_IRQ_BY_IDX(node_id, idx, cell)   \
        DT_CAT5(node_id, _IRQ_IDX_, idx, _VAL_, cell)
 
#define DT_IRQ_BY_NAME(node_id, name, cell) \
        DT_CAT5(node_id, _IRQ_NAME_, name, _VAL_, cell)
 
#define DT_IRQ(node_id, cell) DT_IRQ_BY_IDX(node_id, 0, cell)
 
#define DT_IRQ_INTC_BY_IDX(node_id, idx) \
        DT_CAT4(node_id, _IRQ_IDX_, idx, _CONTROLLER)
 
#define DT_IRQ_INTC_BY_NAME(node_id, name) \
        DT_CAT4(node_id, _IRQ_NAME_, name, _CONTROLLER)
 
#define DT_IRQ_INTC(node_id) \
        DT_IRQ_INTC_BY_IDX(node_id, 0)
 
/* DT helper macro to encode a node's IRQN to level 1 according to the multi-level scheme */
#define DT_IRQN_L1_INTERNAL(node_id, idx) DT_IRQ_BY_IDX(node_id, idx, irq)
/* DT helper macro to encode a node's IRQN to level 2 according to the multi-level scheme */
#define DT_IRQN_L2_INTERNAL(node_id, idx)                                                          \
        (IRQ_TO_L2(DT_IRQN_L1_INTERNAL(node_id, idx)) | DT_IRQ(DT_IRQ_INTC(node_id), irq))
/* DT helper macro to encode a node's IRQN to level 3 according to the multi-level scheme */
#define DT_IRQN_L3_INTERNAL(node_id, idx)                                                          \
        (IRQ_TO_L3(DT_IRQN_L1_INTERNAL(node_id, idx)) |                                            \
         IRQ_TO_L2(DT_IRQ(DT_IRQ_INTC(node_id), irq)) |                                            \
         DT_IRQ(DT_IRQ_INTC(DT_IRQ_INTC(node_id)), irq))
/* DT helper macro for the macros above */
#define DT_IRQN_LVL_INTERNAL(node_id, idx, level) DT_CAT3(DT_IRQN_L, level, _INTERNAL)(node_id, idx)
 
#define DT_MULTI_LEVEL_IRQN_INTERNAL(node_id, idx)                                                 \
        DT_IRQN_LVL_INTERNAL(node_id, idx, DT_IRQ_LEVEL(node_id))
 
#define DT_IRQN_BY_IDX(node_id, idx)                                                               \
        COND_CODE_1(IS_ENABLED(CONFIG_MULTI_LEVEL_INTERRUPTS),                                     \
                    (DT_MULTI_LEVEL_IRQN_INTERNAL(node_id, idx)),                                  \
                    (DT_IRQ_BY_IDX(node_id, idx, irq)))
 
#define DT_IRQN(node_id) DT_IRQN_BY_IDX(node_id, 0)
 
#define DT_CHOSEN(prop) DT_CAT(DT_CHOSEN_, prop)
 
#define DT_HAS_CHOSEN(prop) IS_ENABLED(DT_CAT3(DT_CHOSEN_, prop, _EXISTS))
 
#define DT_FOREACH_NODE(fn) DT_FOREACH_HELPER(fn)
 
#define DT_FOREACH_NODE_VARGS(fn, ...) DT_FOREACH_VARGS_HELPER(fn, __VA_ARGS__)
 
#define DT_FOREACH_STATUS_OKAY_NODE(fn) DT_FOREACH_OKAY_HELPER(fn)
 
#define DT_FOREACH_STATUS_OKAY_NODE_VARGS(fn, ...) DT_FOREACH_OKAY_VARGS_HELPER(fn, __VA_ARGS__)
 
#define DT_FOREACH_CHILD(node_id, fn) \
        DT_CAT(node_id, _FOREACH_CHILD)(fn)
 
#define DT_FOREACH_CHILD_SEP(node_id, fn, sep) \
        DT_CAT(node_id, _FOREACH_CHILD_SEP)(fn, sep)
 
#define DT_FOREACH_CHILD_VARGS(node_id, fn, ...) \
        DT_CAT(node_id, _FOREACH_CHILD_VARGS)(fn, __VA_ARGS__)
 
#define DT_FOREACH_CHILD_SEP_VARGS(node_id, fn, sep, ...) \
        DT_CAT(node_id, _FOREACH_CHILD_SEP_VARGS)(fn, sep, __VA_ARGS__)
 
#define DT_FOREACH_CHILD_STATUS_OKAY(node_id, fn) \
        DT_CAT(node_id, _FOREACH_CHILD_STATUS_OKAY)(fn)
 
#define DT_FOREACH_CHILD_STATUS_OKAY_SEP(node_id, fn, sep) \
        DT_CAT(node_id, _FOREACH_CHILD_STATUS_OKAY_SEP)(fn, sep)
 
#define DT_FOREACH_CHILD_STATUS_OKAY_VARGS(node_id, fn, ...) \
        DT_CAT(node_id, _FOREACH_CHILD_STATUS_OKAY_VARGS)(fn, __VA_ARGS__)
 
#define DT_FOREACH_CHILD_STATUS_OKAY_SEP_VARGS(node_id, fn, sep, ...) \
        DT_CAT(node_id, _FOREACH_CHILD_STATUS_OKAY_SEP_VARGS)(fn, sep, __VA_ARGS__)
 
#define DT_FOREACH_PROP_ELEM(node_id, prop, fn)         \
        DT_CAT4(node_id, _P_, prop, _FOREACH_PROP_ELEM)(fn)
 
#define DT_FOREACH_PROP_ELEM_SEP(node_id, prop, fn, sep) \
        DT_CAT4(node_id, _P_, prop, _FOREACH_PROP_ELEM_SEP)(fn, sep)
 
#define DT_FOREACH_PROP_ELEM_VARGS(node_id, prop, fn, ...)              \
        DT_CAT4(node_id, _P_, prop, _FOREACH_PROP_ELEM_VARGS)(fn, __VA_ARGS__)
 
#define DT_FOREACH_PROP_ELEM_SEP_VARGS(node_id, prop, fn, sep, ...)     \
        DT_CAT4(node_id, _P_, prop, _FOREACH_PROP_ELEM_SEP_VARGS)(      \
                fn, sep, __VA_ARGS__)
 
#define DT_FOREACH_STATUS_OKAY(compat, fn)                              \
        COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(compat),                  \
                    (DT_CAT(DT_FOREACH_OKAY_, compat)(fn)),     \
                    ())
 
#define DT_FOREACH_STATUS_OKAY_VARGS(compat, fn, ...)                   \
        COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(compat),                  \
                    (DT_CAT(DT_FOREACH_OKAY_VARGS_,                     \
                              compat)(fn, __VA_ARGS__)),                \
                    ())
 
#define DT_NODE_EXISTS(node_id) IS_ENABLED(DT_CAT(node_id, _EXISTS))
 
#define DT_NODE_HAS_STATUS(node_id, status) \
        DT_NODE_HAS_STATUS_INTERNAL(node_id, status)
 
#define DT_HAS_COMPAT_STATUS_OKAY(compat) \
        IS_ENABLED(DT_CAT(DT_COMPAT_HAS_OKAY_, compat))
 
#define DT_NUM_INST_STATUS_OKAY(compat)                 \
        UTIL_AND(DT_HAS_COMPAT_STATUS_OKAY(compat),             \
                 UTIL_CAT(DT_N_INST, DT_DASH(compat, NUM_OKAY)))
 
#define DT_NODE_HAS_COMPAT(node_id, compat) \
        IS_ENABLED(DT_CAT3(node_id, _COMPAT_MATCHES_, compat))
 
#define DT_NODE_HAS_COMPAT_STATUS(node_id, compat, status) \
        DT_NODE_HAS_COMPAT(node_id, compat) && DT_NODE_HAS_STATUS(node_id, status)
 
#define DT_NODE_HAS_PROP(node_id, prop) \
        IS_ENABLED(DT_CAT4(node_id, _P_, prop, _EXISTS))
 
 
#define DT_PHA_HAS_CELL_AT_IDX(node_id, pha, idx, cell)             \
        IS_ENABLED(DT_CAT8(node_id, _P_, pha,                       \
                           _IDX_, idx, _VAL_, cell, _EXISTS))
 
#define DT_PHA_HAS_CELL(node_id, pha, cell) \
        DT_PHA_HAS_CELL_AT_IDX(node_id, pha, 0, cell)
 
#define DT_BUS(node_id) DT_CAT(node_id, _BUS)
 
#define DT_ON_BUS(node_id, bus) IS_ENABLED(DT_CAT3(node_id, _BUS_, bus))
 
#define DT_DRV_INST(inst) DT_INST(inst, DT_DRV_COMPAT)
 
#define DT_INST_PARENT(inst) DT_PARENT(DT_DRV_INST(inst))
 
#define DT_INST_GPARENT(inst) DT_GPARENT(DT_DRV_INST(inst))
 
#define DT_INST_CHILD(inst, child) \
        DT_CHILD(DT_DRV_INST(inst), child)
 
#define DT_INST_FOREACH_CHILD(inst, fn) \
        DT_FOREACH_CHILD(DT_DRV_INST(inst), fn)
 
#define DT_INST_FOREACH_CHILD_SEP(inst, fn, sep) \
        DT_FOREACH_CHILD_SEP(DT_DRV_INST(inst), fn, sep)
 
#define DT_INST_FOREACH_CHILD_VARGS(inst, fn, ...) \
        DT_FOREACH_CHILD_VARGS(DT_DRV_INST(inst), fn, __VA_ARGS__)
 
#define DT_INST_FOREACH_CHILD_SEP_VARGS(inst, fn, sep, ...) \
        DT_FOREACH_CHILD_SEP_VARGS(DT_DRV_INST(inst), fn, sep, __VA_ARGS__)
 
#define DT_INST_FOREACH_CHILD_STATUS_OKAY(inst, fn) \
        DT_FOREACH_CHILD_STATUS_OKAY(DT_DRV_INST(inst), fn)
 
#define DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP(inst, fn, sep) \
        DT_FOREACH_CHILD_STATUS_OKAY_SEP(DT_DRV_INST(inst), fn, sep)
 
#define DT_INST_FOREACH_CHILD_STATUS_OKAY_VARGS(inst, fn, ...) \
        DT_FOREACH_CHILD_STATUS_OKAY_VARGS(DT_DRV_INST(inst), fn, __VA_ARGS__)
 
#define DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP_VARGS(inst, fn, sep, ...) \
        DT_FOREACH_CHILD_STATUS_OKAY_SEP_VARGS(DT_DRV_INST(inst), fn, sep, __VA_ARGS__)
 
#define DT_INST_ENUM_IDX(inst, prop) \
        DT_ENUM_IDX(DT_DRV_INST(inst), prop)
 
#define DT_INST_ENUM_IDX_OR(inst, prop, default_idx_value) \
        DT_ENUM_IDX_OR(DT_DRV_INST(inst), prop, default_idx_value)
 
#define DT_INST_ENUM_HAS_VALUE(inst, prop, value) \
        DT_ENUM_HAS_VALUE(DT_DRV_INST(inst), prop, value)
 
#define DT_INST_PROP(inst, prop) DT_PROP(DT_DRV_INST(inst), prop)
 
#define DT_INST_PROP_LEN(inst, prop) DT_PROP_LEN(DT_DRV_INST(inst), prop)
 
#define DT_INST_PROP_HAS_IDX(inst, prop, idx) \
        DT_PROP_HAS_IDX(DT_DRV_INST(inst), prop, idx)
 
#define DT_INST_PROP_HAS_NAME(inst, prop, name) \
        DT_PROP_HAS_NAME(DT_DRV_INST(inst), prop, name)
 
#define DT_INST_PROP_BY_IDX(inst, prop, idx) \
        DT_PROP_BY_IDX(DT_DRV_INST(inst), prop, idx)
 
#define DT_INST_PROP_OR(inst, prop, default_value) \
        DT_PROP_OR(DT_DRV_INST(inst), prop, default_value)
 
#define DT_INST_PROP_LEN_OR(inst, prop, default_value) \
        DT_PROP_LEN_OR(DT_DRV_INST(inst), prop, default_value)
 
#define DT_INST_STRING_TOKEN(inst, prop) \
        DT_STRING_TOKEN(DT_DRV_INST(inst), prop)
 
#define DT_INST_STRING_UPPER_TOKEN(inst, prop) \
        DT_STRING_UPPER_TOKEN(DT_DRV_INST(inst), prop)
 
#define DT_INST_STRING_UNQUOTED(inst, prop) \
        DT_STRING_UNQUOTED(DT_DRV_INST(inst), prop)
 
#define DT_INST_STRING_TOKEN_BY_IDX(inst, prop, idx) \
        DT_STRING_TOKEN_BY_IDX(DT_DRV_INST(inst), prop, idx)
 
#define DT_INST_STRING_UPPER_TOKEN_BY_IDX(inst, prop, idx) \
        DT_STRING_UPPER_TOKEN_BY_IDX(DT_DRV_INST(inst), prop, idx)
 
#define DT_INST_STRING_UNQUOTED_BY_IDX(inst, prop, idx) \
        DT_STRING_UNQUOTED_BY_IDX(DT_DRV_INST(inst), prop, idx)
 
#define DT_INST_PROP_BY_PHANDLE(inst, ph, prop) \
        DT_INST_PROP_BY_PHANDLE_IDX(inst, ph, 0, prop)
 
#define DT_INST_PROP_BY_PHANDLE_IDX(inst, phs, idx, prop) \
        DT_PROP_BY_PHANDLE_IDX(DT_DRV_INST(inst), phs, idx, prop)
 
#define DT_INST_PHA_BY_IDX(inst, pha, idx, cell) \
        DT_PHA_BY_IDX(DT_DRV_INST(inst), pha, idx, cell)
 
#define DT_INST_PHA_BY_IDX_OR(inst, pha, idx, cell, default_value) \
        DT_PHA_BY_IDX_OR(DT_DRV_INST(inst), pha, idx, cell, default_value)
 
#define DT_INST_PHA(inst, pha, cell) DT_INST_PHA_BY_IDX(inst, pha, 0, cell)
 
#define DT_INST_PHA_OR(inst, pha, cell, default_value) \
        DT_INST_PHA_BY_IDX_OR(inst, pha, 0, cell, default_value)
 
#define DT_INST_PHA_BY_NAME(inst, pha, name, cell) \
        DT_PHA_BY_NAME(DT_DRV_INST(inst), pha, name, cell)
 
#define DT_INST_PHA_BY_NAME_OR(inst, pha, name, cell, default_value) \
        DT_PHA_BY_NAME_OR(DT_DRV_INST(inst), pha, name, cell, default_value)
 
#define DT_INST_PHANDLE_BY_NAME(inst, pha, name) \
        DT_PHANDLE_BY_NAME(DT_DRV_INST(inst), pha, name) \
 
#define DT_INST_PHANDLE_BY_IDX(inst, prop, idx) \
        DT_PHANDLE_BY_IDX(DT_DRV_INST(inst), prop, idx)
 
#define DT_INST_PHANDLE(inst, prop) DT_INST_PHANDLE_BY_IDX(inst, prop, 0)
 
#define DT_INST_REG_HAS_IDX(inst, idx) DT_REG_HAS_IDX(DT_DRV_INST(inst), idx)
 
#define DT_INST_REG_ADDR_BY_IDX(inst, idx) DT_REG_ADDR_BY_IDX(DT_DRV_INST(inst), idx)
 
#define DT_INST_REG_SIZE_BY_IDX(inst, idx) \
        DT_REG_SIZE_BY_IDX(DT_DRV_INST(inst), idx)
 
#define DT_INST_REG_ADDR_BY_NAME(inst, name) \
        DT_REG_ADDR_BY_NAME(DT_DRV_INST(inst), name)
 
#define DT_INST_REG_ADDR_BY_NAME_U64(inst, name) \
        DT_U64_C(DT_INST_REG_ADDR_BY_NAME(inst, name))
 
#define DT_INST_REG_SIZE_BY_NAME(inst, name) \
        DT_REG_SIZE_BY_NAME(DT_DRV_INST(inst), name)
 
#define DT_INST_REG_ADDR(inst) DT_INST_REG_ADDR_BY_IDX(inst, 0)
 
#define DT_INST_REG_ADDR_U64(inst) DT_U64_C(DT_INST_REG_ADDR(inst))
 
#define DT_INST_REG_SIZE(inst) DT_INST_REG_SIZE_BY_IDX(inst, 0)
 
#define DT_INST_IRQ_LEVEL(inst) DT_IRQ_LEVEL(DT_DRV_INST(inst))
 
#define DT_INST_IRQ_BY_IDX(inst, idx, cell) \
        DT_IRQ_BY_IDX(DT_DRV_INST(inst), idx, cell)
 
#define DT_INST_IRQ_INTC_BY_IDX(inst, idx) \
        DT_IRQ_INTC_BY_IDX(DT_DRV_INST(inst), idx)
 
#define DT_INST_IRQ_INTC_BY_NAME(inst, name) \
        DT_IRQ_INTC_BY_NAME(DT_DRV_INST(inst), name)
 
#define DT_INST_IRQ_INTC(inst) \
        DT_INST_IRQ_INTC_BY_IDX(inst, 0)
 
#define DT_INST_IRQ_BY_NAME(inst, name, cell) \
        DT_IRQ_BY_NAME(DT_DRV_INST(inst), name, cell)
 
#define DT_INST_IRQ(inst, cell) DT_INST_IRQ_BY_IDX(inst, 0, cell)
 
#define DT_INST_IRQN(inst) DT_IRQN(DT_DRV_INST(inst))
 
#define DT_INST_IRQN_BY_IDX(inst, idx) DT_IRQN_BY_IDX(DT_DRV_INST(inst), idx)
 
#define DT_INST_BUS(inst) DT_BUS(DT_DRV_INST(inst))
 
#define DT_INST_ON_BUS(inst, bus) DT_ON_BUS(DT_DRV_INST(inst), bus)
 
#define DT_INST_STRING_TOKEN_OR(inst, name, default_value) \
        DT_STRING_TOKEN_OR(DT_DRV_INST(inst), name, default_value)
 
#define DT_INST_STRING_UPPER_TOKEN_OR(inst, name, default_value) \
        DT_STRING_UPPER_TOKEN_OR(DT_DRV_INST(inst), name, default_value)
 
#define DT_INST_STRING_UNQUOTED_OR(inst, name, default_value) \
        DT_STRING_UNQUOTED_OR(DT_DRV_INST(inst), name, default_value)
 
/*
 * @brief Test if any enabled node with the given compatible is on
 *        the given bus type
 *
 * This is like DT_ANY_INST_ON_BUS_STATUS_OKAY(), except it can also
 * be useful for handling multiple compatibles in single source file.
 *
 * Example devicetree overlay:
 *
 * @code{.dts}
 *     &i2c0 {
 *            temp: temperature-sensor@76 {
 *                     compatible = "vnd,some-sensor";
 *                     reg = <0x76>;
 *            };
 *     };
 * @endcode
 *
 * Example usage, assuming `i2c0` is an I2C bus controller node, and
 * therefore `temp` is on an I2C bus:
 *
 * @code{.c}
 *     DT_HAS_COMPAT_ON_BUS_STATUS_OKAY(vnd_some_sensor, i2c) // 1
 * @endcode
 *
 * @param compat lowercase-and-underscores compatible, without quotes
 * @param bus a binding's bus type as a C token, lowercased and without quotes
 * @return 1 if any enabled node with that compatible is on that bus type,
 *         0 otherwise
 */
#define DT_HAS_COMPAT_ON_BUS_STATUS_OKAY(compat, bus) \
        IS_ENABLED(DT_CAT4(DT_COMPAT_, compat, _BUS_, bus))
 
#define DT_ANY_INST_ON_BUS_STATUS_OKAY(bus) \
        DT_HAS_COMPAT_ON_BUS_STATUS_OKAY(DT_DRV_COMPAT, bus)
 
#define DT_ANY_INST_HAS_PROP_STATUS_OKAY(prop) \
        (DT_INST_FOREACH_STATUS_OKAY_VARGS(DT_INST_NODE_HAS_PROP_AND_OR, prop) 0)
 
#define DT_INST_FOREACH_STATUS_OKAY(fn) \
        COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT),   \
                    (UTIL_CAT(DT_FOREACH_OKAY_INST_,            \
                              DT_DRV_COMPAT)(fn)),              \
                    ())
 
#define DT_INST_FOREACH_STATUS_OKAY_VARGS(fn, ...) \
        COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT),   \
                    (UTIL_CAT(DT_FOREACH_OKAY_INST_VARGS_,      \
                              DT_DRV_COMPAT)(fn, __VA_ARGS__)), \
                    ())
 
#define DT_INST_FOREACH_PROP_ELEM(inst, prop, fn) \
        DT_FOREACH_PROP_ELEM(DT_DRV_INST(inst), prop, fn)
 
#define DT_INST_FOREACH_PROP_ELEM_SEP(inst, prop, fn, sep) \
        DT_FOREACH_PROP_ELEM_SEP(DT_DRV_INST(inst), prop, fn, sep)
 
#define DT_INST_FOREACH_PROP_ELEM_VARGS(inst, prop, fn, ...) \
        DT_FOREACH_PROP_ELEM_VARGS(DT_DRV_INST(inst), prop, fn, __VA_ARGS__)
 
#define DT_INST_FOREACH_PROP_ELEM_SEP_VARGS(inst, prop, fn, sep, ...)           \
        DT_FOREACH_PROP_ELEM_SEP_VARGS(DT_DRV_INST(inst), prop, fn, sep,        \
                                       __VA_ARGS__)
 
#define DT_INST_NODE_HAS_PROP(inst, prop) \
        DT_NODE_HAS_PROP(DT_DRV_INST(inst), prop)
 
#define DT_INST_PHA_HAS_CELL_AT_IDX(inst, pha, idx, cell) \
        DT_PHA_HAS_CELL_AT_IDX(DT_DRV_INST(inst), pha, idx, cell)
 
#define DT_INST_PHA_HAS_CELL(inst, pha, cell) \
        DT_INST_PHA_HAS_CELL_AT_IDX(inst, pha, 0, cell)
 
#define DT_INST_IRQ_HAS_IDX(inst, idx) DT_IRQ_HAS_IDX(DT_DRV_INST(inst), idx)
 
#define DT_INST_IRQ_HAS_CELL_AT_IDX(inst, idx, cell) \
        DT_IRQ_HAS_CELL_AT_IDX(DT_DRV_INST(inst), idx, cell)
 
#define DT_INST_IRQ_HAS_CELL(inst, cell) \
        DT_INST_IRQ_HAS_CELL_AT_IDX(inst, 0, cell)
 
#define DT_INST_IRQ_HAS_NAME(inst, name) \
        DT_IRQ_HAS_NAME(DT_DRV_INST(inst), name)
 
#define DT_PATH_INTERNAL(...) \
        UTIL_CAT(DT_ROOT, MACRO_MAP_CAT(DT_S_PREFIX, __VA_ARGS__))
#define DT_S_PREFIX(name) _S_##name
 
#define DT_CAT(a1, a2) a1 ## a2
#define DT_CAT3(a1, a2, a3) a1 ## a2 ## a3
#define DT_CAT4(a1, a2, a3, a4) a1 ## a2 ## a3 ## a4
#define DT_CAT5(a1, a2, a3, a4, a5) a1 ## a2 ## a3 ## a4 ## a5
#define DT_CAT6(a1, a2, a3, a4, a5, a6) a1 ## a2 ## a3 ## a4 ## a5 ## a6
#define DT_CAT7(a1, a2, a3, a4, a5, a6, a7) \
        a1 ## a2 ## a3 ## a4 ## a5 ## a6 ## a7
#define DT_CAT8(a1, a2, a3, a4, a5, a6, a7, a8) \
        a1 ## a2 ## a3 ## a4 ## a5 ## a6 ## a7 ## a8
/*
 * If you need to define a bigger DT_CATN(), do so here. Don't leave
 * any "holes" of undefined macros, please.
 */
 
#define DT_DASH(...) MACRO_MAP_CAT(DT_DASH_PREFIX, __VA_ARGS__)
#define DT_DASH_PREFIX(name) _##name
#define DT_NODE_HAS_STATUS_INTERNAL(node_id, status) \
        IS_ENABLED(DT_CAT3(node_id, _STATUS_, status))
 
#define DT_INST_NODE_HAS_PROP_AND_OR(inst, prop) \
        DT_INST_NODE_HAS_PROP(inst, prop) ||
 
#if defined(_LINKER) || defined(_ASMLANGUAGE)
#define DT_U64_C(_v) (_v)
#else
#define DT_U64_C(_v) UINT64_C(_v)
#endif
 
/* have these last so they have access to all previously defined macros */
#include <zephyr/devicetree/io-channels.h>
#include <zephyr/devicetree/clocks.h>
#include <zephyr/devicetree/gpio.h>
#include <zephyr/devicetree/spi.h>
#include <zephyr/devicetree/dma.h>
#include <zephyr/devicetree/pwms.h>
#include <zephyr/devicetree/fixed-partitions.h>
#include <zephyr/devicetree/ordinals.h>
#include <zephyr/devicetree/pinctrl.h>
#include <zephyr/devicetree/can.h>
#include <zephyr/devicetree/reset.h>
#include <zephyr/devicetree/mbox.h>
 
#endif /* DEVICETREE_H */