device: Add new macros to instanciate device objects

In order to get rid of the manually inserted initialization priority,
device object generation need new macros.

Until now, 2 set of macros have co-existed because of legacy support.
Indeed, devices used to be created fully manually before devicetree
introduction. Once devicetree appeared, DT based macros were added.
Now is the time to get rid of such difference, and have a unique macro
for creating device objects.

So instead of DEVICE_DEFINE() and DEVICE_DT_DEFINE() there will be
DEVICE_INSTANCE(). Instead of DEVICE_DT_INST_DEFINE() there will be
DEVICE_INSTANCE_FROM_DT_INST(). Instead of DEVICE_GET() and
DEVICE_DT_GET(), there will be DEVICE_INSTANCE_GET().
Same for DEVICE_INIT_DT_GET() and DEVICE_INIT_GET(), there will be
DEVICE_INIT_ENTRY_GET()

In the future step of deprecating old macros, these are then identified:
- DEVICE_DEFINE
- DEVICE_DT_DEFINE
- DEVICE_GET
- DEVICE_DT_GET
- DEVICE_INIT_DT_GET
- DEVICE_INIT_GET
- DEVICE_NAME_GET() could be replaced by DEVICE_INSTANCE_NAME())
- DEVICE_DT_NAME_GET() could be replaced by DEVICE_INSTANCE_NAME())
- DEVICE_DECLARE() could be replaced as well

And probably some more, thus reducing the amount of macros which would
help to clean-up the header and have a more concise set.

The difference is now that priority parameter is removed, as well as the
name parameter (originaly from DEVICE_DEFINE legacy macro). In this case
it is just simpler to reuse the "unique token" dev_id.

Because of the dependency being fully computed _prior_ to building
zephyr, these new macros do not support CONFIG_DEVICE_DEPS anymore. This
feature was never really used anywhere and is a legacy thing. So new
macros do not accept variable arguments.

Signed-off-by: Tomasz Bursztyka <[email protected]>

Author: tbursztyka

include/zephyr/device.h

@@ -145,6 +145,24 @@ typedef int16_t device_handle_t;
 			config, level, prio, api,                              \
 			&Z_DEVICE_STATE_NAME(dev_id))
 
+/**
+ * @brief Return the device id whether it's a devicetree based device or not
+ *
+ * @param ident Either a devicetree node identifier or a plain unique token
+ */
+#define Z_DEVICE_ID(ident)                                      \
+	COND_CODE_1(DT_NODE_EXISTS(ident),                      \
+		    (Z_DEVICE_DT_DEV_ID(ident)), (ident))
+
+/**
+ * @brief Return the device name whether it's a devicetree based device or not
+ *
+ * @param ident Either a devicetree node identifier or a plain unique token
+ */
+#define Z_DEVICE_NAME(ident)                                            \
+	COND_CODE_1(DT_NODE_EXISTS(ident),                              \
+		    (DEVICE_DT_NAME(ident)), (STRINGIFY(ident)))
+
 /**
  * @brief Return a string name for a devicetree node.
  *
@@ -210,6 +228,64 @@ typedef int16_t device_handle_t;
 			__VA_ARGS__)                                           \
 	IF_ENABLED(CONFIG_LLEXT_EXPORT_DEVICES, (Z_DEVICE_EXPORT(node_id);))
 
+/**
+ * @brief Create a device object and set it up for boot time initialization.
+ *
+ * @note This macro supports both devicetree based device as well as
+ * non-devicetree based device (legacy support).
+ *
+ * This macro defines a @ref device that is automatically configured by the
+ * kernel during system initialization. If the given identifier is a plain
+ * unique token, it will be used in the name of the global device structure
+ * as a C identifier as well as its @ref device.name.
+ * If the given identifier is a devicetree node itentifier, the global device
+ * object's name as a C will be derived from the node's dependency ordinal
+ * (DT based) and @ref device.name will be set to `DEVICE_DT_NAME(node_id)`.
+ *
+ * The device is declared with extern visibility, so a pointer to a global
+ * device object can be obtained either with `DEVICE_DT_GET(node_id)` in case
+ * the device is devicetree based, or with `DEVICE_GET(dev_id)` for
+ * non-devicetree legacy devices. And this from any source file that includes
+ * `<zephyr/device.h>`. Before using the pointer, the referenced object should
+ * be checked using device_is_ready().
+ *
+ * @param ident Either a devicetree node identifier or a plain unique token
+ * @param init_fn Pointer to the device's initialization function, which will be
+ * run by the kernel during system initialization. Can be `NULL`.
+ * @param pm Pointer to the device's power management resources, a
+ * @ref pm_device, which will be stored in @ref device.pm. Use `NULL` if the
+ * device does not use PM.
+ * @param data Pointer to the device's private mutable data, which will be
+ * stored in @ref device.data.
+ * @param config Pointer to the device's private constant data, which will be
+ * stored in @ref device.config field.
+ * @param level The device's initialization level (PRE_KERNEL_1, PRE_KERNEL_2 or
+ * POST_KERNEL).
+ * @param api Pointer to the device's API structure. Can be `NULL`.
+ */
+#define DEVICE_INSTANCE(ident, init_fn, pm, data, config, level, api)    \
+	Z_DEVICE_STATE_DEFINE(Z_DEVICE_ID(ident));                       \
+	Z_DEVICE_DEFINE(ident, Z_DEVICE_ID(ident),                       \
+			Z_DEVICE_NAME(ident), init_fn, pm, data, config, \
+			ZINIT_GET_LEVEL(Z_DEVICE_ID(ident), level),      \
+			ZINIT_GET_PRIORITY(ident, Z_DEVICE_ID(ident)),   \
+			api, &Z_DEVICE_STATE_NAME(Z_DEVICE_ID(ident)))
+
+/**
+ * @brief Like DEVICE_INSTANCE(), but with an extra parameter in order to
+ * provide an externaly defined device state object.
+ *
+ * First parameters are as expected by DEVICE_INSTANCE().
+ * @param state A pointer on the externally defined device state object
+ */
+#define DEVICE_INSTANCE_EXTERNAL_STATE(ident, init_fn, pm, data,         \
+				       config, level, api, state)	 \
+	Z_DEVICE_DEFINE(ident, Z_DEVICE_ID(ident),                       \
+			Z_DEVICE_NAME(ident), init_fn, pm, data, config, \
+			ZINIT_GET_LEVEL(Z_DEVICE_ID(ident), level),      \
+			ZINIT_GET_PRIORITY(ident, Z_DEVICE_ID(ident)),   \
+			api, state)
+
 /**
  * @brief Like DEVICE_DT_DEFINE(), but uses an instance of a `DT_DRV_COMPAT`
  * compatible instead of a node identifier.
@@ -221,6 +297,17 @@ typedef int16_t device_handle_t;
 #define DEVICE_DT_INST_DEFINE(inst, ...)                                       \
 	DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
 
+/**
+ * @brief Like DEVICE_INSTANCE, but uses an instance of a `DT_DRV_COMPAT`
+ * compatible instead of a node identifier.
+
+ * @param inst Instance number. The `ident` argument to DEVICE_INSTANCE() is
+ * set to `DT_DRV_INST(inst)`.
+ * @param ... Other parameters as expected by DEVICE_INSTANCE().
+ */
+#define DEVICE_INSTANCE_FROM_DT_INST(inst, init_fn, pm, data, config, level, api) \
+	DEVICE_INSTANCE(DT_DRV_INST(inst), init_fn, pm, data, config, level, api)
+
 /**
  * @brief The name of the global device object for @p node_id
  *
@@ -333,6 +420,15 @@ typedef int16_t device_handle_t;
  */
 #define DEVICE_GET(dev_id) (&DEVICE_NAME_GET(dev_id))
 
+/**
+ * @brief Obtain a pointer to a device object
+ *
+ * @param ident Either a devicetree node identifier or a plain unique token
+ */
+#define DEVICE_INSTANCE_GET(ident)                                      \
+	COND_CODE_1(DT_NODE_EXISTS(ident),                              \
+		    (&DEVICE_DT_NAME_GET(ident)), (&DEVICE_NAME_GET(ident)))
+
 /**
  * @brief Declare a static device object
  *
@@ -369,6 +465,16 @@ typedef int16_t device_handle_t;
  */
 #define DEVICE_INIT_GET(dev_id) (&Z_INIT_ENTRY_NAME(DEVICE_NAME_GET(dev_id)))
 
+/**
+ * @brief Get a @ref init_entry reference from a device
+ *
+ * @param ident Either a devicetree node identifier or a plain unique token
+ */
+#define DEVICE_INIT_ENTRY_GET(ident)                                    \
+	COND_CODE_1(DT_NODE_EXISTS(ident),                              \
+		    (&Z_INIT_ENTRY_NAME(DEVICE_DT_NAME_GET(ident))),    \
+		    (&Z_INIT_ENTRY_NAME(DEVICE_NAME_GET(ident))))
+
 /**
  * @brief Runtime device dynamic structure (in RAM) per driver instance
  *