#include <stdint.h>
#include <zephyr/devicetree.h>
#include <zephyr/init.h>
#include <zephyr/linker/sections.h>
#include <zephyr/pm/state.h>
#include <zephyr/sys/device_mmio.h>
#include <zephyr/sys/iterable_sections.h>
#include <zephyr/sys/util.h>
#include <zephyr/toolchain.h>
#include <zephyr/syscalls/device.h>

Data Structures
struct	device_state
	Runtime device dynamic structure (in RAM) per driver instance. More...

struct	device_ops
	Device operations. More...

struct	device
	Runtime device structure (in ROM) per driver instance. More...

Macros
#define	DEVICE_HANDLE_NULL 0
	Flag value used to identify an unknown device.

#define	DEVICE_NAME_GET(dev_id) _CONCAT(__device_, dev_id)
	Expands to the name of a global device object.

#define	DEVICE_DEINIT_DEFINE(dev_id, name, init_fn, deinit_fn, pm, data, config, level, prio, api)
	Create a device object and set it up for boot time initialization, with de-init capabilities.

#define	DEVICE_DEFINE(dev_id, name, init_fn, pm, data, config, level, prio, api)
	Create a device object and set it up for boot time initialization.

#define	DEVICE_DT_NAME(node_id) DT_PROP_OR(node_id, label, DT_NODE_FULL_NAME(node_id))
	Return a string name for a devicetree node.

#define	DEVICE_DT_DEINIT_DEFINE(node_id, init_fn, deinit_fn, pm, data, config, level, prio, api, ...)
	Create a device object from a devicetree node identifier and set it up for boot time initialization.

#define	DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, prio, api, ...)
	Create a device object from a devicetree node identifier and set it up for boot time initialization.

#define	DEVICE_DT_INST_DEINIT_DEFINE(inst, ...) DEVICE_DT_DEINIT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
	Like DEVICE_DT_DEINIT_DEFINE(), but uses an instance of a `DT_DRV_COMPAT` compatible instead of a node identifier.

#define	DEVICE_DT_INST_DEFINE(inst, ...) DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
	Like DEVICE_DT_DEFINE(), but uses an instance of a `DT_DRV_COMPAT` compatible instead of a node identifier.

#define	DEVICE_DT_NAME_GET(node_id) DEVICE_NAME_GET(Z_DEVICE_DT_DEV_ID(node_id))
	The name of the global device object for `node_id`.

#define	DEVICE_DT_GET(node_id) (&DEVICE_DT_NAME_GET(node_id))
	Get a device reference from a devicetree node identifier.

#define	DEVICE_DT_INST_GET(inst) DEVICE_DT_GET(DT_DRV_INST(inst))
	Get a device reference for an instance of a `DT_DRV_COMPAT` compatible.

#define	DEVICE_DT_GET_ANY(compat)
	Get a device reference from a devicetree compatible.

#define	DEVICE_DT_GET_ONE(compat)
	Get a device reference from a devicetree compatible.

#define	DEVICE_DT_GET_OR_NULL(node_id)
	Utility macro to obtain an optional reference to a device.

#define	DEVICE_DT_GET_BY_IDX(node_id, prop, idx) DEVICE_DT_GET(DT_PHANDLE_BY_IDX(node_id, prop, idx))
	Get a device reference from a devicetree phandles by idx.

#define	DEVICE_GET(dev_id) (&DEVICE_NAME_GET(dev_id))
	Obtain a pointer to a device object by name.

#define	DEVICE_DECLARE(dev_id) static const struct device DEVICE_NAME_GET(dev_id)
	Declare a static device object.

#define	DEVICE_INIT_DT_GET(node_id) (&Z_INIT_ENTRY_NAME(DEVICE_DT_NAME_GET(node_id)))
	Get a init_entry reference from a devicetree node.

#define	DEVICE_INIT_GET(dev_id) (&Z_INIT_ENTRY_NAME(DEVICE_NAME_GET(dev_id)))
	Get a init_entry reference from a device identifier.

#define	DEVICE_API(_class, _name) const STRUCT_SECTION_ITERABLE(Z_DEVICE_API_TYPE(_class), _name)
	Wrapper macro for declaring device API structs inside iterable sections.

#define	DEVICE_API_GET(_class, _dev) ((const struct Z_DEVICE_API_TYPE(_class) *)_dev->api)
	Expands to the pointer of a device's API for a given class.

#define	DEVICE_API_IS(_class, _dev)
	Macro that evaluates to a boolean that can be used to check if a device is of a particular class.

Device flags
#define	DEVICE_FLAG_INIT_DEFERRED BIT(0)
	Device initialization is deferred.

Typedefs
typedef int16_t	device_handle_t
	Type used to represent a "handle" for a device.

typedef uint8_t	device_flags_t
	Device flags.

typedef int(*	device_visitor_callback_t) (const struct device dev, void context)
	Prototype for functions used when iterating over a set of devices.

Functions
static device_handle_t	device_handle_get (const struct device *dev)
	Get the handle for a given device.

static const struct device *	device_from_handle (device_handle_t dev_handle)
	Get the device corresponding to a handle.

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.

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.

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.

int	device_required_foreach (const struct device dev, device_visitor_callback_t visitor_cb, void context)
	Visit every device that `dev` directly requires.

int	device_supported_foreach (const struct device dev, device_visitor_callback_t visitor_cb, void context)
	Visit every device that `dev` directly supports.

const struct device *	device_get_binding (const char *name)
	Get a device reference from its device::name field.

bool	device_is_ready (const struct device *dev)
	Verify that a device is ready for use.

int	device_init (const struct device *dev)
	Initialize a device.

int	device_deinit (const struct device *dev)
	De-initialize a device.

Macro Definition Documentation

◆ DEVICE_API

#define DEVICE_API	(	_class,
		_name
	)	const STRUCT_SECTION_ITERABLE(Z_DEVICE_API_TYPE(_class), _name)

Wrapper macro for declaring device API structs inside iterable sections.

Parameters

_class	The device API class.
_name	The API instance name.

◆ DEVICE_API_GET

#define DEVICE_API_GET	(	_class,
		_dev
	)	((const struct Z_DEVICE_API_TYPE(_class) *)_dev->api)

Expands to the pointer of a device's API for a given class.

Parameters

_class	The device API class.
_dev	The device instance pointer.

Returns: the pointer to the device API.

◆ DEVICE_API_IS

#define DEVICE_API_IS	(	_class,
		_dev
	)

Value:

        ({                                                                                         \
                STRUCT_SECTION_START_EXTERN(Z_DEVICE_API_TYPE(_class));                            \
                STRUCT_SECTION_END_EXTERN(Z_DEVICE_API_TYPE(_class));                              \
                (DEVICE_API_GET(_class, _dev) < STRUCT_SECTION_END(Z_DEVICE_API_TYPE(_class)) &&   \
                 DEVICE_API_GET(_class, _dev) >= STRUCT_SECTION_START(Z_DEVICE_API_TYPE(_class))); \
        })

Macro that evaluates to a boolean that can be used to check if a device is of a particular class.

Parameters

_class	The device API class.
_dev	The device instance pointer.

Return values

true	If the device is of the given class
false	If the device is not of the given class

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ DEVICE_API

◆ DEVICE_API_GET

◆ DEVICE_API_IS