Zephyr API Documentation  3.7.99
A Scalable Open Source RTOS
Loading...
Searching...
No Matches
device.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2015 Intel Corporation.
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7#ifndef ZEPHYR_INCLUDE_DEVICE_H_
8#define ZEPHYR_INCLUDE_DEVICE_H_
9
10#include <stdint.h>
11
12#include <zephyr/devicetree.h>
13#include <zephyr/init.h>
14#include <zephyr/linker/sections.h>
15#include <zephyr/pm/state.h>
16#include <zephyr/sys/device_mmio.h>
17#include <zephyr/sys/iterable_sections.h>
18#include <zephyr/sys/util.h>
19#include <zephyr/toolchain.h>
20
21#ifdef __cplusplus
22extern "C" {
23#endif
24
39#define Z_DEVICE_DEPS_SEP INT16_MIN
40
45#define Z_DEVICE_DEPS_ENDS INT16_MAX
46
48#define Z_DEVICE_IS_MUTABLE(node_id) \
49 COND_CODE_1(IS_ENABLED(CONFIG_DEVICE_MUTABLE), (DT_PROP(node_id, zephyr_mutable)), (0))
50
68typedef int16_t device_handle_t;
69
71#define DEVICE_HANDLE_NULL 0
72
92#define DEVICE_NAME_GET(dev_id) _CONCAT(__device_, dev_id)
93
94/* Node paths can exceed the maximum size supported by
95 * device_get_binding() in user mode; this macro synthesizes a unique
96 * dev_id from a devicetree node while staying within this maximum
97 * size.
98 *
99 * The ordinal used in this name can be mapped to the path by
100 * examining zephyr/include/generated/zephyr/devicetree_generated.h.
101 */
102#define Z_DEVICE_DT_DEV_ID(node_id) _CONCAT(dts_ord_, DT_DEP_ORD(node_id))
103
134#define DEVICE_DEFINE(dev_id, name, init_fn, pm, data, config, level, prio, \
135 api) \
136 Z_DEVICE_STATE_DEFINE(dev_id); \
137 Z_DEVICE_DEFINE(DT_INVALID_NODE, dev_id, name, init_fn, pm, data, \
138 config, level, prio, api, \
139 &Z_DEVICE_STATE_NAME(dev_id))
140
152#define DEVICE_DT_NAME(node_id) \
153 DT_PROP_OR(node_id, label, DT_NODE_FULL_NAME(node_id))
154
162#define DEVICE_DT_DEFER(node_id) \
163 DT_PROP(node_id, zephyr_deferred_init)
164
195#define DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, prio, api, \
196 ...) \
197 Z_DEVICE_STATE_DEFINE(Z_DEVICE_DT_DEV_ID(node_id)); \
198 Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
199 DEVICE_DT_NAME(node_id), init_fn, pm, data, config, \
200 level, prio, api, \
201 &Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_ID(node_id)), \
202 __VA_ARGS__)
203
212#define DEVICE_DT_INST_DEFINE(inst, ...) \
213 DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
214
229#define DEVICE_DT_NAME_GET(node_id) DEVICE_NAME_GET(Z_DEVICE_DT_DEV_ID(node_id))
230
246#define DEVICE_DT_GET(node_id) (&DEVICE_DT_NAME_GET(node_id))
247
257#define DEVICE_DT_INST_GET(inst) DEVICE_DT_GET(DT_DRV_INST(inst))
258
275#define DEVICE_DT_GET_ANY(compat) \
276 COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(compat), \
277 (DEVICE_DT_GET(DT_COMPAT_GET_ANY_STATUS_OKAY(compat))), \
278 (NULL))
279
296#define DEVICE_DT_GET_ONE(compat) \
297 COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(compat), \
298 (DEVICE_DT_GET(DT_COMPAT_GET_ANY_STATUS_OKAY(compat))), \
299 (ZERO_OR_COMPILE_ERROR(0)))
300
311#define DEVICE_DT_GET_OR_NULL(node_id) \
312 COND_CODE_1(DT_NODE_HAS_STATUS(node_id, okay), \
313 (DEVICE_DT_GET(node_id)), (NULL))
314
325#define DEVICE_GET(dev_id) (&DEVICE_NAME_GET(dev_id))
326
341#define DEVICE_DECLARE(dev_id) \
342 static const struct device DEVICE_NAME_GET(dev_id)
343
351#define DEVICE_INIT_DT_GET(node_id) \
352 (&Z_INIT_ENTRY_NAME(DEVICE_DT_NAME_GET(node_id)))
353
361#define DEVICE_INIT_GET(dev_id) (&Z_INIT_ENTRY_NAME(DEVICE_NAME_GET(dev_id)))
362
371struct device_state {
379 uint8_t init_res;
380
384 bool initialized : 1;
385};
386
387struct pm_device_base;
388struct pm_device;
389struct pm_device_isr;
390#if defined(CONFIG_DEVICE_DT_METADATA) || defined(__DOXYGEN__)
391struct device_dt_metadata;
392#endif
393
394#ifdef CONFIG_DEVICE_DEPS_DYNAMIC
395#define Z_DEVICE_DEPS_CONST
396#else
397#define Z_DEVICE_DEPS_CONST const
398#endif
399
403struct device {
405 const char *name;
407 const void *config;
409 const void *api;
411 struct device_state *state;
413 void *data;
414#if defined(CONFIG_DEVICE_DEPS) || defined(__DOXYGEN__)
423 Z_DEVICE_DEPS_CONST device_handle_t *deps;
424#endif /* CONFIG_DEVICE_DEPS */
425#if defined(CONFIG_PM_DEVICE) || defined(__DOXYGEN__)
430 union {
431 struct pm_device_base *pm_base;
432 struct pm_device *pm;
433 struct pm_device_isr *pm_isr;
434 };
435#endif
436#if defined(CONFIG_DEVICE_DT_METADATA) || defined(__DOXYGEN__)
437 const struct device_dt_metadata *dt_meta;
438#endif /* CONFIG_DEVICE_DT_METADATA */
439};
440
449static inline device_handle_t device_handle_get(const struct device *dev)
450{
451 device_handle_t ret = DEVICE_HANDLE_NULL;
452 STRUCT_SECTION_START_EXTERN(device);
453
454 /* TODO: If/when devices can be constructed that are not part of the
455 * fixed sequence we'll need another solution.
456 */
457 if (dev != NULL) {
458 ret = 1 + (device_handle_t)(dev - STRUCT_SECTION_START(device));
459 }
460
461 return ret;
462}
463
472static inline const struct device *
473device_from_handle(device_handle_t dev_handle)
474{
475 STRUCT_SECTION_START_EXTERN(device);
476 const struct device *dev = NULL;
477 size_t numdev;
478
479 STRUCT_SECTION_COUNT(device, &numdev);
480
481 if ((dev_handle > 0) && ((size_t)dev_handle <= numdev)) {
482 dev = &STRUCT_SECTION_START(device)[dev_handle - 1];
483 }
484
485 return dev;
486}
487
488#if defined(CONFIG_DEVICE_DEPS) || defined(__DOXYGEN__)
489
508typedef int (*device_visitor_callback_t)(const struct device *dev,
509 void *context);
510
529static inline const device_handle_t *
530device_required_handles_get(const struct device *dev, size_t *count)
531{
532 const device_handle_t *rv = dev->deps;
533
534 if (rv != NULL) {
535 size_t i = 0;
536
537 while ((rv[i] != Z_DEVICE_DEPS_ENDS) &&
538 (rv[i] != Z_DEVICE_DEPS_SEP)) {
539 ++i;
540 }
541 *count = i;
542 }
543
544 return rv;
545}
546
565static inline const device_handle_t *
566device_injected_handles_get(const struct device *dev, size_t *count)
567{
568 const device_handle_t *rv = dev->deps;
569 size_t region = 0;
570 size_t i = 0;
571
572 if (rv != NULL) {
573 /* Fast forward to injected devices */
574 while (region != 1) {
575 if (*rv == Z_DEVICE_DEPS_SEP) {
576 region++;
577 }
578 rv++;
579 }
580 while ((rv[i] != Z_DEVICE_DEPS_ENDS) &&
581 (rv[i] != Z_DEVICE_DEPS_SEP)) {
582 ++i;
583 }
584 *count = i;
585 }
586
587 return rv;
588}
589
609static inline const device_handle_t *
610device_supported_handles_get(const struct device *dev, size_t *count)
611{
612 const device_handle_t *rv = dev->deps;
613 size_t region = 0;
614 size_t i = 0;
615
616 if (rv != NULL) {
617 /* Fast forward to supporting devices */
618 while (region != 2) {
619 if (*rv == Z_DEVICE_DEPS_SEP) {
620 region++;
621 }
622 rv++;
623 }
624 /* Count supporting devices.
625 * Trailing NULL's can be injected by gen_device_deps.py due to
626 * CONFIG_PM_DEVICE_POWER_DOMAIN_DYNAMIC_NUM
627 */
628 while ((rv[i] != Z_DEVICE_DEPS_ENDS) &&
629 (rv[i] != DEVICE_HANDLE_NULL)) {
630 ++i;
631 }
632 *count = i;
633 }
634
635 return rv;
636}
637
668int device_required_foreach(const struct device *dev,
669 device_visitor_callback_t visitor_cb,
670 void *context);
671
701int device_supported_foreach(const struct device *dev,
702 device_visitor_callback_t visitor_cb,
703 void *context);
704
705#endif /* CONFIG_DEVICE_DEPS */
706
727__syscall const struct device *device_get_binding(const char *name);
728
737size_t z_device_get_all_static(const struct device **devices);
738
755__syscall bool device_is_ready(const struct device *dev);
756
771__syscall int device_init(const struct device *dev);
772
783#define Z_DEVICE_STATE_NAME(dev_id) _CONCAT(__devstate_, dev_id)
784
790#define Z_DEVICE_STATE_DEFINE(dev_id) \
791 static Z_DECL_ALIGN(struct device_state) Z_DEVICE_STATE_NAME(dev_id) \
792 __attribute__((__section__(".z_devstate")))
793
794#if defined(CONFIG_DEVICE_DEPS) || defined(__DOXYGEN__)
795
802#define Z_DEVICE_DEPS_NAME(dev_id) _CONCAT(__devicedeps_, dev_id)
803
809#define Z_DEVICE_EXTRA_DEPS(...) \
810 FOR_EACH_NONEMPTY_TERM(IDENTITY, (,), __VA_ARGS__)
811
813#define Z_DEVICE_DEPS_SECTION \
814 __attribute__((__section__(".__device_deps_pass1")))
815
816#ifdef __cplusplus
817#define Z_DEVICE_DEPS_EXTERN extern
818#else
819#define Z_DEVICE_DEPS_EXTERN
820#endif
821
857#define Z_DEVICE_DEPS_DEFINE(node_id, dev_id, ...) \
858 extern Z_DEVICE_DEPS_CONST device_handle_t Z_DEVICE_DEPS_NAME( \
859 dev_id)[]; \
860 Z_DEVICE_DEPS_CONST Z_DECL_ALIGN(device_handle_t) \
861 Z_DEVICE_DEPS_SECTION Z_DEVICE_DEPS_EXTERN __weak \
862 Z_DEVICE_DEPS_NAME(dev_id)[] = { \
863 COND_CODE_1( \
864 DT_NODE_EXISTS(node_id), \
865 (DT_DEP_ORD(node_id), DT_REQUIRES_DEP_ORDS(node_id)), \
866 (DEVICE_HANDLE_NULL,)) \
867 Z_DEVICE_DEPS_SEP, \
868 Z_DEVICE_EXTRA_DEPS(__VA_ARGS__) \
869 Z_DEVICE_DEPS_SEP, \
870 COND_CODE_1(DT_NODE_EXISTS(node_id), \
871 (DT_SUPPORTS_DEP_ORDS(node_id)), ()) \
872 }
873
874#endif /* CONFIG_DEVICE_DEPS */
875#if defined(CONFIG_DEVICE_DT_METADATA) || defined(__DOXYGEN__)
879struct device_dt_nodelabels {
880 /* @brief number of elements in the nodelabels array */
881 size_t num_nodelabels;
882 /* @brief array of node labels as strings, exactly as they
883 * appear in the final devicetree
884 */
885 const char *nodelabels[];
886};
887
895struct device_dt_metadata {
900 const struct device_dt_nodelabels *nl;
901};
902
921__syscall const struct device *device_get_by_dt_nodelabel(const char *nodelabel);
922
928static inline const struct device_dt_nodelabels *
929device_get_dt_nodelabels(const struct device *dev)
930{
931 return dev->dt_meta->nl;
932}
933
940#define Z_DEVICE_MAX_NODELABEL_LEN Z_DEVICE_MAX_NAME_LEN
941
946#define Z_DEVICE_DT_METADATA_NAME_GET(dev_id) UTIL_CAT(__dev_dt_meta_, dev_id)
947
952#define Z_DEVICE_DT_NODELABELS_NAME_GET(dev_id) UTIL_CAT(__dev_dt_nodelabels_, dev_id)
953
960#define Z_DEVICE_DT_METADATA_DEFINE(node_id, dev_id) \
961 static const struct device_dt_nodelabels \
962 Z_DEVICE_DT_NODELABELS_NAME_GET(dev_id) = { \
963 .num_nodelabels = DT_NUM_NODELABELS(node_id), \
964 .nodelabels = DT_NODELABEL_STRING_ARRAY(node_id), \
965 }; \
966 \
967 static const struct device_dt_metadata \
968 Z_DEVICE_DT_METADATA_NAME_GET(dev_id) = { \
969 .nl = &Z_DEVICE_DT_NODELABELS_NAME_GET(dev_id), \
970 };
971#endif /* CONFIG_DEVICE_DT_METADATA */
972
980#define Z_DEVICE_INIT_SUB_PRIO(node_id) \
981 COND_CODE_1(DT_NODE_EXISTS(node_id), \
982 (DT_DEP_ORD_STR_SORTABLE(node_id)), (0))
983
990#define Z_DEVICE_MAX_NAME_LEN 48U
991
997#define Z_DEVICE_NAME_CHECK(name) \
998 BUILD_ASSERT(sizeof(Z_STRINGIFY(name)) <= Z_DEVICE_MAX_NAME_LEN, \
999 Z_STRINGIFY(DEVICE_NAME_GET(name)) " too long")
1000
1014#define Z_DEVICE_INIT(name_, pm_, data_, config_, api_, state_, deps_, node_id_, \
1015 dev_id_) \
1016 { \
1017 .name = name_, \
1018 .config = (config_), \
1019 .api = (api_), \
1020 .state = (state_), \
1021 .data = (data_), \
1022 IF_ENABLED(CONFIG_DEVICE_DEPS, (.deps = (deps_),)) \
1023 IF_ENABLED(CONFIG_PM_DEVICE, Z_DEVICE_INIT_PM_BASE(pm_)) \
1024 IF_ENABLED(CONFIG_DEVICE_DT_METADATA, \
1025 (IF_ENABLED(DT_NODE_EXISTS(node_id_), \
1026 (.dt_meta = &Z_DEVICE_DT_METADATA_NAME_GET( \
1027 dev_id_),)))) \
1028 }
1029
1030/*
1031 * Anonymous unions require C11. Some pre-C11 gcc versions have early support for anonymous
1032 * unions but they require these braces when combined with C99 designated initializers. For
1033 * more details see https://docs.zephyrproject.org/latest/develop/languages/cpp/
1034 */
1035#if defined(__STDC_VERSION__) && (__STDC_VERSION__) < 201100
1036# define Z_DEVICE_INIT_PM_BASE(pm_) ({ .pm_base = (pm_),},)
1037#else
1038# define Z_DEVICE_INIT_PM_BASE(pm_) (.pm_base = (pm_),)
1039#endif
1040
1047#define Z_DEVICE_SECTION_NAME(level, prio) \
1048 _CONCAT(INIT_LEVEL_ORD(level), _##prio)
1049
1066#define Z_DEVICE_BASE_DEFINE(node_id, dev_id, name, pm, data, config, level, prio, api, state, \
1067 deps) \
1068 COND_CODE_1(DT_NODE_EXISTS(node_id), (), (static)) \
1069 COND_CODE_1(Z_DEVICE_IS_MUTABLE(node_id), (), (const)) \
1070 STRUCT_SECTION_ITERABLE_NAMED_ALTERNATE( \
1071 device, COND_CODE_1(Z_DEVICE_IS_MUTABLE(node_id), (device_mutable), (device)), \
1072 Z_DEVICE_SECTION_NAME(level, prio), DEVICE_NAME_GET(dev_id)) = \
1073 Z_DEVICE_INIT(name, pm, data, config, api, state, deps, node_id, dev_id)
1074
1075/* deprecated device initialization levels */
1076#define Z_DEVICE_LEVEL_DEPRECATED_EARLY \
1077 __WARN("EARLY device driver level is deprecated")
1078#define Z_DEVICE_LEVEL_DEPRECATED_PRE_KERNEL_1
1079#define Z_DEVICE_LEVEL_DEPRECATED_PRE_KERNEL_2
1080#define Z_DEVICE_LEVEL_DEPRECATED_POST_KERNEL
1081#define Z_DEVICE_LEVEL_DEPRECATED_APPLICATION \
1082 __WARN("APPLICATION device driver level is deprecated")
1083#define Z_DEVICE_LEVEL_DEPRECATED_SMP \
1084 __WARN("SMP device driver level is deprecated")
1085
1091#define Z_DEVICE_LEVEL_CHECK_DEPRECATED_LEVEL(level) \
1092 Z_DEVICE_LEVEL_DEPRECATED_##level
1093
1104#define Z_DEVICE_INIT_ENTRY_DEFINE(node_id, dev_id, init_fn_, level, prio) \
1105 Z_DEVICE_LEVEL_CHECK_DEPRECATED_LEVEL(level) \
1106 \
1107 static const Z_DECL_ALIGN(struct init_entry) __used __noasan Z_INIT_ENTRY_SECTION( \
1108 level, prio, Z_DEVICE_INIT_SUB_PRIO(node_id)) \
1109 Z_INIT_ENTRY_NAME(DEVICE_NAME_GET(dev_id)) = { \
1110 .init_fn = {COND_CODE_1(Z_DEVICE_IS_MUTABLE(node_id), (.dev_rw), (.dev)) = \
1111 (init_fn_)}, \
1112 Z_DEVICE_INIT_ENTRY_DEV(node_id, dev_id), \
1113 }
1114
1115#define Z_DEFER_DEVICE_INIT_ENTRY_DEFINE(node_id, dev_id, init_fn_) \
1116 static const Z_DECL_ALIGN(struct init_entry) __used __noasan \
1117 __attribute__((__section__(".z_deferred_init"))) \
1118 Z_INIT_ENTRY_NAME(DEVICE_NAME_GET(dev_id)) = { \
1119 .init_fn = {COND_CODE_1(Z_DEVICE_IS_MUTABLE(node_id), (.dev_rw), (.dev)) = \
1120 (init_fn_)}, \
1121 Z_DEVICE_INIT_ENTRY_DEV(node_id, dev_id), \
1122 }
1123
1124/*
1125 * Anonymous unions require C11. Some pre-C11 gcc versions have early support for anonymous
1126 * unions but they require these braces when combined with C99 designated initializers. For
1127 * more details see https://docs.zephyrproject.org/latest/develop/languages/cpp/
1128 */
1129#if defined(__STDC_VERSION__) && (__STDC_VERSION__) < 201100
1130# define Z_DEVICE_INIT_ENTRY_DEV(node_id, dev_id) { Z_DEV_ENTRY_DEV(node_id, dev_id) }
1131#else
1132# define Z_DEVICE_INIT_ENTRY_DEV(node_id, dev_id) Z_DEV_ENTRY_DEV(node_id, dev_id)
1133#endif
1134
1135#define Z_DEV_ENTRY_DEV(node_id, dev_id) \
1136 COND_CODE_1(Z_DEVICE_IS_MUTABLE(node_id), (.dev_rw), (.dev)) = &DEVICE_NAME_GET(dev_id)
1137
1159#define Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, pm, data, config, \
1160 level, prio, api, state, ...) \
1161 Z_DEVICE_NAME_CHECK(name); \
1162 \
1163 IF_ENABLED(CONFIG_DEVICE_DEPS, \
1164 (Z_DEVICE_DEPS_DEFINE(node_id, dev_id, __VA_ARGS__);)) \
1165 \
1166 IF_ENABLED(CONFIG_DEVICE_DT_METADATA, \
1167 (IF_ENABLED(DT_NODE_EXISTS(node_id), \
1168 (Z_DEVICE_DT_METADATA_DEFINE(node_id, dev_id);))))\
1169 \
1170 Z_DEVICE_BASE_DEFINE(node_id, dev_id, name, pm, data, config, level, \
1171 prio, api, state, Z_DEVICE_DEPS_NAME(dev_id)); \
1172 COND_CODE_1(DEVICE_DT_DEFER(node_id), \
1173 (Z_DEFER_DEVICE_INIT_ENTRY_DEFINE(node_id, dev_id, \
1174 init_fn)), \
1175 (Z_DEVICE_INIT_ENTRY_DEFINE(node_id, dev_id, init_fn, \
1176 level, prio)));
1177
1188#define Z_MAYBE_DEVICE_DECLARE_INTERNAL(node_id) \
1189 extern COND_CODE_1(Z_DEVICE_IS_MUTABLE(node_id), (), \
1190 (const)) struct device DEVICE_DT_NAME_GET(node_id);
1191
1192DT_FOREACH_STATUS_OKAY_NODE(Z_MAYBE_DEVICE_DECLARE_INTERNAL)
1193
1194
1196#ifdef __cplusplus
1197}
1198#endif
1199
1200#include <zephyr/syscalls/device.h>
1201
1202#endif /* ZEPHYR_INCLUDE_DEVICE_H_ */
device_mmio.h
devicetree.h
Devicetree main header.
device_get_binding
const struct device * device_get_binding(const char *name)
Get a device reference from its device::name field.
device_handle_t
int16_t device_handle_t
Type used to represent a "handle" for a device.
Definition: device.h:68
device_required_handles_get
static const device_handle_t * device_required_handles_get(const struct device *dev, size_t *count)
Get the device handles for devicetree dependencies of this device.
Definition: device.h:530
device_supported_handles_get
static const device_handle_t * device_supported_handles_get(const struct device *dev, size_t *count)
Get the set of handles that this device supports.
Definition: device.h:610
device_handle_get
static device_handle_t device_handle_get(const struct device *dev)
Get the handle for a given device.
Definition: device.h:449
DEVICE_HANDLE_NULL
#define DEVICE_HANDLE_NULL
Flag value used to identify an unknown device.
Definition: device.h:71
device_required_foreach
int device_required_foreach(const struct device *dev, device_visitor_callback_t visitor_cb, void *context)
Visit every device that dev directly requires.
device_from_handle
static const struct device * device_from_handle(device_handle_t dev_handle)
Get the device corresponding to a handle.
Definition: device.h:473
device_visitor_callback_t
int(* device_visitor_callback_t)(const struct device *dev, void *context)
Prototype for functions used when iterating over a set of devices.
Definition: device.h:508
device_is_ready
bool device_is_ready(const struct device *dev)
Verify that a device is ready for use.
device_injected_handles_get
static const device_handle_t * device_injected_handles_get(const struct device *dev, size_t *count)
Get the device handles for injected dependencies of this device.
Definition: device.h:566
device_init
int device_init(const struct device *dev)
Initialize a device.
device_supported_foreach
int device_supported_foreach(const struct device *dev, device_visitor_callback_t visitor_cb, void *context)
Visit every device that dev directly supports.
DT_FOREACH_STATUS_OKAY_NODE
#define DT_FOREACH_STATUS_OKAY_NODE(fn)
Invokes fn for every status okay node in the tree.
Definition: devicetree.h:2785
STRUCT_SECTION_START_EXTERN
#define STRUCT_SECTION_START_EXTERN(struct_type)
iterable section extern for start symbol for a struct
Definition: iterable_sections.h:159
STRUCT_SECTION_START
#define STRUCT_SECTION_START(struct_type)
iterable section start symbol for a struct type
Definition: iterable_sections.h:149
STRUCT_SECTION_COUNT
#define STRUCT_SECTION_COUNT(struct_type, dst)
Count elements in a section.
Definition: iterable_sections.h:291
sections.h
Definitions of various linker Sections.
uint8_t
__UINT8_TYPE__ uint8_t
Definition: stdint.h:88
int16_t
__INT16_TYPE__ int16_t
Definition: stdint.h:73
device_state
Runtime device dynamic structure (in RAM) per driver instance.
Definition: device.h:371
device_state::initialized
bool initialized
Indicates the device initialization function has been invoked.
Definition: device.h:384
device_state::init_res
uint8_t init_res
Device initialization return code (positive errno value).
Definition: device.h:379
device
Runtime device structure (in ROM) per driver instance.
Definition: device.h:403
device::pm_base
struct pm_device_base * pm_base
Definition: device.h:431
device::deps
const device_handle_t * deps
Optional pointer to dependencies associated with the device.
Definition: device.h:423
device::pm_isr
struct pm_device_isr * pm_isr
Definition: device.h:433
device::name
const char * name
Name of the device instance.
Definition: device.h:405
device::pm
struct pm_device * pm
Definition: device.h:432
device::data
void * data
Address of the device instance private data.
Definition: device.h:413
device::api
const void * api
Address of the API structure exposed by the device instance.
Definition: device.h:409
device::state
struct device_state * state
Address of the common device state.
Definition: device.h:411
device::config
const void * config
Address of device instance config information.
Definition: device.h:407
device::dt_meta
const struct device_dt_metadata * dt_meta
Definition: device.h:437
pm_device_base
Device PM info.
Definition: device.h:139
pm_device_isr
Runtime PM info for device with synchronous PM.
Definition: device.h:185
pm_device
Runtime PM info for device with generic PM.
Definition: device.h:163
iterable_sections.h
toolchain.h
Macros to abstract toolchain specific capabilities.
util.h
Misc utilities.