refactor(app): replace `struct device *` with `const struct device *`

Replaced with RegExp: /(?<!const )(struct device \*)/g

See: https://docs.zephyrproject.org/latest/releases/release-notes-2.4.html
PR: #467

9 files changed, 100 insertions, 95 deletions

diff --git a/app/drivers/kscan/kscan_composite.c b/app/drivers/kscan/kscan_composite.c
index b9383d1..d699cfa 100644
--- a/app/drivers/kscan/kscan_composite.c
+++ b/app/drivers/kscan/kscan_composite.c
@@ -34,10 +34,10 @@ struct kscan_composite_config {};
 struct kscan_composite_data {
     kscan_callback_t callback;
 
-    struct device *dev;
+    const struct device *dev;
 };
 
-static int kscan_composite_enable_callback(struct device *dev) {
+static int kscan_composite_enable_callback(const struct device *dev) {
     for (int i = 0; i < ARRAY_SIZE(kscan_composite_children); i++) {
         const struct kscan_composite_child_config *cfg = &kscan_composite_children[i];
 
@@ -46,7 +46,7 @@ static int kscan_composite_enable_callback(struct device *dev) {
     return 0;
 }
 
-static int kscan_composite_disable_callback(struct device *dev) {
+static int kscan_composite_disable_callback(const struct device *dev) {
     for (int i = 0; i < ARRAY_SIZE(kscan_composite_children); i++) {
         const struct kscan_composite_child_config *cfg = &kscan_composite_children[i];
 
@@ -55,10 +55,10 @@ static int kscan_composite_disable_callback(struct device *dev) {
     return 0;
 }
 
-static void kscan_composite_child_callback(struct device *child_dev, uint32_t row, uint32_t column,
-                                           bool pressed) {
+static void kscan_composite_child_callback(const struct device *child_dev, uint32_t row,
+                                           uint32_t column, bool pressed) {
     // TODO: Ideally we can get this passed into our callback!
-    struct device *dev = device_get_binding(DT_INST_LABEL(0));
+    const struct device *dev = device_get_binding(DT_INST_LABEL(0));
     struct kscan_composite_data *data = dev->data;
 
     for (int i = 0; i < ARRAY_SIZE(kscan_composite_children); i++) {
@@ -72,7 +72,7 @@ static void kscan_composite_child_callback(struct device *child_dev, uint32_t ro
     }
 }
 
-static int kscan_composite_configure(struct device *dev, kscan_callback_t callback) {
+static int kscan_composite_configure(const struct device *dev, kscan_callback_t callback) {
     struct kscan_composite_data *data = dev->data;
 
     if (!callback) {
@@ -90,7 +90,7 @@ static int kscan_composite_configure(struct device *dev, kscan_callback_t callba
     return 0;
 }
 
-static int kscan_composite_init(struct device *dev) {
+static int kscan_composite_init(const struct device *dev) {
     struct kscan_composite_data *data = dev->data;
 
     data->dev = dev;
diff --git a/app/drivers/kscan/kscan_gpio_demux.c b/app/drivers/kscan/kscan_gpio_demux.c
index f48a09d..7e3515f 100644
--- a/app/drivers/kscan/kscan_gpio_demux.c
+++ b/app/drivers/kscan/kscan_gpio_demux.c
@@ -49,7 +49,7 @@ struct kscan_gpio_item_config {
     struct kscan_gpio_irq_callback_##n {                                                           \
         struct CHECK_DEBOUNCE_CFG(n, (k_work), (k_delayed_work)) * work;                           \
         struct gpio_callback callback;                                                             \
-        struct device *dev;                                                                        \
+        const struct device *dev;                                                                  \
     };                                                                                             \
                                                                                                    \
     struct kscan_gpio_config_##n {                                                                 \
@@ -62,30 +62,31 @@ struct kscan_gpio_item_config {
         struct k_timer poll_timer;                                                                 \
         struct CHECK_DEBOUNCE_CFG(n, (k_work), (k_delayed_work)) work;                             \
         bool matrix_state[INST_MATRIX_INPUTS(n)][INST_MATRIX_OUTPUTS(n)];                          \
-        struct device *rows[INST_MATRIX_INPUTS(n)];                                                \
-        struct device *cols[INST_MATRIX_OUTPUTS(n)];                                               \
-        struct device *dev;                                                                        \
+        const struct device *rows[INST_MATRIX_INPUTS(n)];                                          \
+        const struct device *cols[INST_MATRIX_OUTPUTS(n)];                                         \
+        const struct device *dev;                                                                  \
     };                                                                                             \
     /* IO/GPIO SETUP */                                                                            \
     /* gpio_input_devices are PHYSICAL IO devices */                                               \
-    static struct device **kscan_gpio_input_devices_##n(struct device *dev) {                      \
+    static const struct device **kscan_gpio_input_devices_##n(const struct device *dev) {          \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         return data->rows;                                                                         \
     }                                                                                              \
                                                                                                    \
-    static const struct kscan_gpio_item_config *kscan_gpio_input_configs_##n(struct device *dev) { \
+    static const struct kscan_gpio_item_config *kscan_gpio_input_configs_##n(                      \
+        const struct device *dev) {                                                                \
         const struct kscan_gpio_config_##n *cfg = dev->config;                                     \
         return cfg->rows;                                                                          \
     }                                                                                              \
                                                                                                    \
     /* gpio_output_devices are PHYSICAL IO devices */                                              \
-    static struct device **kscan_gpio_output_devices_##n(struct device *dev) {                     \
+    static const struct device **kscan_gpio_output_devices_##n(const struct device *dev) {         \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         return data->cols;                                                                         \
     }                                                                                              \
                                                                                                    \
     static const struct kscan_gpio_item_config *kscan_gpio_output_configs_##n(                     \
-        struct device *dev) {                                                                      \
+        const struct device *dev) {                                                                \
         const struct kscan_gpio_config_##n *cfg = dev->config;                                     \
         /* If row2col, rows = outputs & cols = inputs */                                           \
         return cfg->cols;                                                                          \
@@ -99,7 +100,7 @@ struct kscan_gpio_item_config {
                                                                                                    \
     /* Read the state of the input GPIOs */                                                        \
     /* This is the core matrix_scan func */                                                        \
-    static int kscan_gpio_read_##n(struct device *dev) {                                           \
+    static int kscan_gpio_read_##n(const struct device *dev) {                                     \
         bool submit_follow_up_read = false;                                                        \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         static bool read_state[INST_MATRIX_INPUTS(n)][INST_MATRIX_OUTPUTS(n)];                     \
@@ -107,7 +108,7 @@ struct kscan_gpio_item_config {
             /* Iterate over bits and set GPIOs accordingly */                                      \
             for (uint8_t bit = 0; bit < INST_DEMUX_GPIOS(n); bit++) {                              \
                 uint8_t state = (o & (0b1 << bit)) >> bit;                                         \
-                struct device *out_dev = kscan_gpio_output_devices_##n(dev)[bit];                  \
+                const struct device *out_dev = kscan_gpio_output_devices_##n(dev)[bit];            \
                 const struct kscan_gpio_item_config *out_cfg =                                     \
                     &kscan_gpio_output_configs_##n(dev)[bit];                                      \
                 gpio_pin_set(out_dev, out_cfg->pin, state);                                        \
@@ -115,7 +116,7 @@ struct kscan_gpio_item_config {
                                                                                                    \
             for (int i = 0; i < INST_MATRIX_INPUTS(n); i++) {                                      \
                 /* Get the input device (port) */                                                  \
-                struct device *in_dev = kscan_gpio_input_devices_##n(dev)[i];                      \
+                const struct device *in_dev = kscan_gpio_input_devices_##n(dev)[i];                \
                 /* Get the input device config (pin) */                                            \
                 const struct kscan_gpio_item_config *in_cfg =                                      \
                     &kscan_gpio_input_configs_##n(dev)[i];                                         \
@@ -151,7 +152,7 @@ struct kscan_gpio_item_config {
         .rows = {[INST_MATRIX_INPUTS(n) - 1] = NULL}, .cols = {[INST_DEMUX_GPIOS(n) - 1] = NULL}}; \
                                                                                                    \
     /* KSCAN API configure function */                                                             \
-    static int kscan_gpio_configure_##n(struct device *dev, kscan_callback_t callback) {           \
+    static int kscan_gpio_configure_##n(const struct device *dev, kscan_callback_t callback) {     \
         LOG_DBG("KSCAN API configure");                                                            \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         if (!callback) {                                                                           \
@@ -163,7 +164,7 @@ struct kscan_gpio_item_config {
     };                                                                                             \
                                                                                                    \
     /* KSCAN API enable function */                                                                \
-    static int kscan_gpio_enable_##n(struct device *dev) {                                         \
+    static int kscan_gpio_enable_##n(const struct device *dev) {                                   \
         LOG_DBG("KSCAN API enable");                                                               \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         /* TODO: we might want a follow up to hook into the sleep state hooks in Zephyr, */        \
@@ -173,7 +174,7 @@ struct kscan_gpio_item_config {
     };                                                                                             \
                                                                                                    \
     /* KSCAN API disable function */                                                               \
-    static int kscan_gpio_disable_##n(struct device *dev) {                                        \
+    static int kscan_gpio_disable_##n(const struct device *dev) {                                  \
         LOG_DBG("KSCAN API disable");                                                              \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         k_timer_stop(&data->poll_timer);                                                           \
@@ -181,12 +182,12 @@ struct kscan_gpio_item_config {
     };                                                                                             \
                                                                                                    \
     /* GPIO init function*/                                                                        \
-    static int kscan_gpio_init_##n(struct device *dev) {                                           \
+    static int kscan_gpio_init_##n(const struct device *dev) {                                     \
         LOG_DBG("KSCAN GPIO init");                                                                \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         int err;                                                                                   \
         /* configure input devices*/                                                               \
-        struct device **input_devices = kscan_gpio_input_devices_##n(dev);                         \
+        const struct device **input_devices = kscan_gpio_input_devices_##n(dev);                   \
         for (int i = 0; i < INST_MATRIX_INPUTS(n); i++) {                                          \
             const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs_##n(dev)[i];   \
             input_devices[i] = device_get_binding(in_cfg->label);                                  \
@@ -207,7 +208,7 @@ struct kscan_gpio_item_config {
             }                                                                                      \
         }                                                                                          \
         /* configure output devices*/                                                              \
-        struct device **output_devices = kscan_gpio_output_devices_##n(dev);                       \
+        const struct device **output_devices = kscan_gpio_output_devices_##n(dev);                 \
         for (int o = 0; o < INST_DEMUX_GPIOS(n); o++) {                                            \
             const struct kscan_gpio_item_config *out_cfg = &kscan_gpio_output_configs_##n(dev)[o]; \
             output_devices[o] = device_get_binding(out_cfg->label);                                \
diff --git a/app/drivers/kscan/kscan_gpio_direct.c b/app/drivers/kscan/kscan_gpio_direct.c
index 041c900..0802d0e 100644
--- a/app/drivers/kscan/kscan_gpio_direct.c
+++ b/app/drivers/kscan/kscan_gpio_direct.c
@@ -38,17 +38,17 @@ struct kscan_gpio_data {
 #endif /* defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */
     kscan_callback_t callback;
     union work_reference work;
-    struct device *dev;
+    const struct device *dev;
     uint32_t pin_state;
-    struct device *inputs[];
+    const struct device *inputs[];
 };
 
-static struct device **kscan_gpio_input_devices(struct device *dev) {
+static const struct device **kscan_gpio_input_devices(const struct device *dev) {
     struct kscan_gpio_data *data = dev->data;
     return data->inputs;
 }
 
-static const struct kscan_gpio_item_config *kscan_gpio_input_configs(struct device *dev) {
+static const struct kscan_gpio_item_config *kscan_gpio_input_configs(const struct device *dev) {
     const struct kscan_gpio_config *cfg = dev->config;
     return cfg->inputs;
 }
@@ -65,19 +65,19 @@ static void kscan_gpio_direct_queue_read(union work_reference *work, uint8_t deb
 #if !defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING)
 
 struct kscan_gpio_irq_callback {
-    struct device *dev;
+    const struct device *dev;
     union work_reference *work;
     uint8_t debounce_period;
     struct gpio_callback callback;
 };
 
-static int kscan_gpio_config_interrupts(struct device *dev, gpio_flags_t flags) {
+static int kscan_gpio_config_interrupts(const struct device *dev, gpio_flags_t flags) {
     const struct kscan_gpio_config *cfg = dev->config;
-    struct device **devices = kscan_gpio_input_devices(dev);
+    const struct device **devices = kscan_gpio_input_devices(dev);
     const struct kscan_gpio_item_config *configs = kscan_gpio_input_configs(dev);
 
     for (int i = 0; i < cfg->num_of_inputs; i++) {
-        struct device *dev = devices[i];
+        const struct device *dev = devices[i];
         const struct kscan_gpio_item_config *cfg = &configs[i];
 
         int err = gpio_pin_interrupt_configure(dev, cfg->pin, flags);
@@ -91,14 +91,14 @@ static int kscan_gpio_config_interrupts(struct device *dev, gpio_flags_t flags)
     return 0;
 }
 
-static int kscan_gpio_direct_enable(struct device *dev) {
+static int kscan_gpio_direct_enable(const struct device *dev) {
     return kscan_gpio_config_interrupts(dev, GPIO_INT_LEVEL_ACTIVE);
 }
-static int kscan_gpio_direct_disable(struct device *dev) {
+static int kscan_gpio_direct_disable(const struct device *dev) {
     return kscan_gpio_config_interrupts(dev, GPIO_INT_DISABLE);
 }
 
-static void kscan_gpio_irq_callback_handler(struct device *dev, struct gpio_callback *cb,
+static void kscan_gpio_irq_callback_handler(const struct device *dev, struct gpio_callback *cb,
                                             gpio_port_pins_t pin) {
     struct kscan_gpio_irq_callback *data =
         CONTAINER_OF(cb, struct kscan_gpio_irq_callback, callback);
@@ -115,12 +115,12 @@ static void kscan_gpio_timer_handler(struct k_timer *timer) {
     kscan_gpio_direct_queue_read(&data->work, 0);
 }
 
-static int kscan_gpio_direct_enable(struct device *dev) {
+static int kscan_gpio_direct_enable(const struct device *dev) {
     struct kscan_gpio_data *data = dev->data;
     k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10));
     return 0;
 }
-static int kscan_gpio_direct_disable(struct device *dev) {
+static int kscan_gpio_direct_disable(const struct device *dev) {
     struct kscan_gpio_data *data = dev->data;
     k_timer_stop(&data->poll_timer);
     return 0;
@@ -128,7 +128,7 @@ static int kscan_gpio_direct_disable(struct device *dev) {
 
 #endif /* defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */
 
-static int kscan_gpio_direct_configure(struct device *dev, kscan_callback_t callback) {
+static int kscan_gpio_direct_configure(const struct device *dev, kscan_callback_t callback) {
     struct kscan_gpio_data *data = dev->data;
     if (!callback) {
         return -EINVAL;
@@ -137,13 +137,13 @@ static int kscan_gpio_direct_configure(struct device *dev, kscan_callback_t call
     return 0;
 }
 
-static int kscan_gpio_read(struct device *dev) {
+static int kscan_gpio_read(const struct device *dev) {
     struct kscan_gpio_data *data = dev->data;
     const struct kscan_gpio_config *cfg = dev->config;
     uint32_t read_state = data->pin_state;
     bool submit_follow_up_read = false;
     for (int i = 0; i < cfg->num_of_inputs; i++) {
-        struct device *in_dev = kscan_gpio_input_devices(dev)[i];
+        const struct device *in_dev = kscan_gpio_input_devices(dev)[i];
         const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs(dev)[i];
         WRITE_BIT(read_state, i, gpio_pin_get(in_dev, in_cfg->pin) > 0);
     }
@@ -194,11 +194,11 @@ static const struct kscan_driver_api gpio_driver_api = {
                 (static struct kscan_gpio_irq_callback irq_callbacks_##n[INST_INPUT_LEN(n)];), ()) \
     static struct kscan_gpio_data kscan_gpio_data_##n = {                                          \
         .inputs = {[INST_INPUT_LEN(n) - 1] = NULL}};                                               \
-    static int kscan_gpio_init_##n(struct device *dev) {                                           \
+    static int kscan_gpio_init_##n(const struct device *dev) {                                     \
         struct kscan_gpio_data *data = dev->data;                                                  \
         const struct kscan_gpio_config *cfg = dev->config;                                         \
         int err;                                                                                   \
-        struct device **input_devices = kscan_gpio_input_devices(dev);                             \
+        const struct device **input_devices = kscan_gpio_input_devices(dev);                       \
         for (int i = 0; i < cfg->num_of_inputs; i++) {                                             \
             const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs(dev)[i];       \
             input_devices[i] = device_get_binding(in_cfg->label);                                  \
diff --git a/app/drivers/kscan/kscan_gpio_matrix.c b/app/drivers/kscan/kscan_gpio_matrix.c
index 8412043..6697cf6 100644
--- a/app/drivers/kscan/kscan_gpio_matrix.c
+++ b/app/drivers/kscan/kscan_gpio_matrix.c
@@ -32,11 +32,11 @@ struct kscan_gpio_item_config {
 #define _KSCAN_GPIO_COL_CFG_INIT(idx, n) _KSCAN_GPIO_ITEM_CFG_INIT(n, col_gpios, idx)
 
 #if !defined(CONFIG_ZMK_KSCAN_MATRIX_POLLING)
-static int kscan_gpio_config_interrupts(struct device **devices,
+static int kscan_gpio_config_interrupts(const struct device **devices,
                                         const struct kscan_gpio_item_config *configs, size_t len,
                                         gpio_flags_t flags) {
     for (int i = 0; i < len; i++) {
-        struct device *dev = devices[i];
+        const struct device *dev = devices[i];
         const struct kscan_gpio_item_config *cfg = &configs[i];
 
         int err = gpio_pin_interrupt_configure(dev, cfg->pin, flags);
@@ -64,7 +64,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
     struct kscan_gpio_irq_callback_##n {                                                           \
         struct COND_CODE_0(DT_INST_PROP(n, debounce_period), (k_work), (k_delayed_work)) * work;   \
         struct gpio_callback callback;                                                             \
-        struct device *dev;                                                                        \
+        const struct device *dev;                                                                  \
     };                                                                                             \
     static struct kscan_gpio_irq_callback_##n irq_callbacks_##n[INST_INPUT_LEN(n)];                \
     struct kscan_gpio_config_##n {                                                                 \
@@ -76,46 +76,47 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (struct k_timer poll_timer;), ())             \
         struct COND_CODE_0(DT_INST_PROP(n, debounce_period), (k_work), (k_delayed_work)) work;     \
         bool matrix_state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)];                               \
-        struct device *rows[INST_MATRIX_ROWS(n)];                                                  \
-        struct device *cols[INST_MATRIX_COLS(n)];                                                  \
-        struct device *dev;                                                                        \
+        const struct device *rows[INST_MATRIX_ROWS(n)];                                            \
+        const struct device *cols[INST_MATRIX_COLS(n)];                                            \
+        const struct device *dev;                                                                  \
     };                                                                                             \
-    static struct device **kscan_gpio_input_devices_##n(struct device *dev) {                      \
+    static const struct device **kscan_gpio_input_devices_##n(const struct device *dev) {          \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         return (COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (data->cols),            \
                             (data->rows)));                                                        \
     }                                                                                              \
-    static const struct kscan_gpio_item_config *kscan_gpio_input_configs_##n(struct device *dev) { \
+    static const struct kscan_gpio_item_config *kscan_gpio_input_configs_##n(                      \
+        const struct device *dev) {                                                                \
         const struct kscan_gpio_config_##n *cfg = dev->config;                                     \
         return ((                                                                                  \
             COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (cfg->cols), (cfg->rows)))); \
     }                                                                                              \
-    static struct device **kscan_gpio_output_devices_##n(struct device *dev) {                     \
+    static const struct device **kscan_gpio_output_devices_##n(const struct device *dev) {         \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         return (COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (data->rows),            \
                             (data->cols)));                                                        \
     }                                                                                              \
     static const struct kscan_gpio_item_config *kscan_gpio_output_configs_##n(                     \
-        struct device *dev) {                                                                      \
+        const struct device *dev) {                                                                \
         const struct kscan_gpio_config_##n *cfg = dev->config;                                     \
         return (                                                                                   \
             COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (cfg->rows), (cfg->cols)));  \
     }                                                                                              \
     COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                               \
                 (                                                                                  \
-                    static int kscan_gpio_enable_interrupts_##n(struct device *dev) {              \
+                    static int kscan_gpio_enable_interrupts_##n(const struct device *dev) {        \
                         return kscan_gpio_config_interrupts(                                       \
                             kscan_gpio_input_devices_##n(dev), kscan_gpio_input_configs_##n(dev),  \
                             INST_INPUT_LEN(n), GPIO_INT_LEVEL_ACTIVE);                             \
-                    } static int kscan_gpio_disable_interrupts_##n(struct device *dev) {           \
+                    } static int kscan_gpio_disable_interrupts_##n(const struct device *dev) {     \
                         return kscan_gpio_config_interrupts(kscan_gpio_input_devices_##n(dev),     \
                                                             kscan_gpio_input_configs_##n(dev),     \
                                                             INST_INPUT_LEN(n), GPIO_INT_DISABLE);  \
                     }))                                                                            \
-    static void kscan_gpio_set_output_state_##n(struct device *dev, int value) {                   \
+    static void kscan_gpio_set_output_state_##n(const struct device *dev, int value) {             \
         int err;                                                                                   \
         for (int i = 0; i < INST_OUTPUT_LEN(n); i++) {                                             \
-            struct device *in_dev = kscan_gpio_output_devices_##n(dev)[i];                         \
+            const struct device *in_dev = kscan_gpio_output_devices_##n(dev)[i];                   \
             const struct kscan_gpio_item_config *cfg = &kscan_gpio_output_configs_##n(dev)[i];     \
             if ((err = gpio_pin_set(in_dev, cfg->pin, value))) {                                   \
                 LOG_DBG("FAILED TO SET OUTPUT %d to %d", cfg->pin, err);                           \
@@ -130,7 +131,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
              [COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (input_index),             \
                           (output_index))] = value;                                                \
     }                                                                                              \
-    static int kscan_gpio_read_##n(struct device *dev) {                                           \
+    static int kscan_gpio_read_##n(const struct device *dev) {                                     \
         bool submit_follow_up_read = false;                                                        \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         static bool read_state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)];                          \
@@ -139,11 +140,11 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         /* to get pressed state for each matrix cell.                       */                     \
         kscan_gpio_set_output_state_##n(dev, 0);                                                   \
         for (int o = 0; o < INST_OUTPUT_LEN(n); o++) {                                             \
-            struct device *out_dev = kscan_gpio_output_devices_##n(dev)[o];                        \
+            const struct device *out_dev = kscan_gpio_output_devices_##n(dev)[o];                  \
             const struct kscan_gpio_item_config *out_cfg = &kscan_gpio_output_configs_##n(dev)[o]; \
             gpio_pin_set(out_dev, out_cfg->pin, 1);                                                \
             for (int i = 0; i < INST_INPUT_LEN(n); i++) {                                          \
-                struct device *in_dev = kscan_gpio_input_devices_##n(dev)[i];                      \
+                const struct device *in_dev = kscan_gpio_input_devices_##n(dev)[i];                \
                 const struct kscan_gpio_item_config *in_cfg =                                      \
                     &kscan_gpio_input_configs_##n(dev)[i];                                         \
                 kscan_gpio_set_matrix_state_##n(read_state, i, o,                                  \
@@ -181,8 +182,8 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         struct kscan_gpio_data_##n *data = CONTAINER_OF(work, struct kscan_gpio_data_##n, work);   \
         kscan_gpio_read_##n(data->dev);                                                            \
     }                                                                                              \
-    static void kscan_gpio_irq_callback_handler_##n(struct device *dev, struct gpio_callback *cb,  \
-                                                    gpio_port_pins_t pin) {                        \
+    static void kscan_gpio_irq_callback_handler_##n(                                               \
+        const struct device *dev, struct gpio_callback *cb, gpio_port_pins_t pin) {                \
         struct kscan_gpio_irq_callback_##n *data =                                                 \
             CONTAINER_OF(cb, struct kscan_gpio_irq_callback_##n, callback);                        \
         COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                           \
@@ -196,7 +197,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
                                                                                                    \
     static struct kscan_gpio_data_##n kscan_gpio_data_##n = {                                      \
         .rows = {[INST_MATRIX_ROWS(n) - 1] = NULL}, .cols = {[INST_MATRIX_COLS(n) - 1] = NULL}};   \
-    static int kscan_gpio_configure_##n(struct device *dev, kscan_callback_t callback) {           \
+    static int kscan_gpio_configure_##n(const struct device *dev, kscan_callback_t callback) {     \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         if (!callback) {                                                                           \
             return -EINVAL;                                                                        \
@@ -205,14 +206,14 @@ static int kscan_gpio_config_interrupts(struct device **devices,
         LOG_DBG("Configured GPIO %d", n);                                                          \
         return 0;                                                                                  \
     };                                                                                             \
-    static int kscan_gpio_enable_##n(struct device *dev) {                                         \
+    static int kscan_gpio_enable_##n(const struct device *dev) {                                   \
         COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
                     (struct kscan_gpio_data_##n *data = dev->data;                                 \
                      k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10)); return 0;),         \
                     (int err = kscan_gpio_enable_interrupts_##n(dev);                              \
                      if (err) { return err; } return kscan_gpio_read_##n(dev);))                   \
     };                                                                                             \
-    static int kscan_gpio_disable_##n(struct device *dev) {                                        \
+    static int kscan_gpio_disable_##n(const struct device *dev) {                                  \
         COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
                     (struct kscan_gpio_data_##n *data = dev->data;                                 \
                      k_timer_stop(&data->poll_timer); return 0;),                                  \
@@ -225,10 +226,10 @@ static int kscan_gpio_config_interrupts(struct device **devices,
                     k_work_submit(&data->work.work);                                               \
                 }),                                                                                \
                 ())                                                                                \
-    static int kscan_gpio_init_##n(struct device *dev) {                                           \
+    static int kscan_gpio_init_##n(const struct device *dev) {                                     \
         struct kscan_gpio_data_##n *data = dev->data;                                              \
         int err;                                                                                   \
-        struct device **input_devices = kscan_gpio_input_devices_##n(dev);                         \
+        const struct device **input_devices = kscan_gpio_input_devices_##n(dev);                   \
         for (int i = 0; i < INST_INPUT_LEN(n); i++) {                                              \
             const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs_##n(dev)[i];   \
             input_devices[i] = device_get_binding(in_cfg->label);                                  \
@@ -253,7 +254,7 @@ static int kscan_gpio_config_interrupts(struct device **devices,
                 return err;                                                                        \
             }                                                                                      \
         }                                                                                          \
-        struct device **output_devices = kscan_gpio_output_devices_##n(dev);                       \
+        const struct device **output_devices = kscan_gpio_output_devices_##n(dev);                 \
         for (int o = 0; o < INST_OUTPUT_LEN(n); o++) {                                             \
             const struct kscan_gpio_item_config *out_cfg = &kscan_gpio_output_configs_##n(dev)[o]; \
             output_devices[o] = device_get_binding(out_cfg->label);                                \
diff --git a/app/drivers/kscan/kscan_mock.c b/app/drivers/kscan/kscan_mock.c
index 0d687a3..8b40ab4 100644
--- a/app/drivers/kscan/kscan_mock.c
+++ b/app/drivers/kscan/kscan_mock.c
@@ -20,17 +20,17 @@ struct kscan_mock_data {
 
     uint32_t event_index;
     struct k_delayed_work work;
-    struct device *dev;
+    const struct device *dev;
 };
 
-static int kscan_mock_disable_callback(struct device *dev) {
+static int kscan_mock_disable_callback(const struct device *dev) {
     struct kscan_mock_data *data = dev->data;
 
     k_delayed_work_cancel(&data->work);
     return 0;
 }
 
-static int kscan_mock_configure(struct device *dev, kscan_callback_t callback) {
+static int kscan_mock_configure(const struct device *dev, kscan_callback_t callback) {
     struct kscan_mock_data *data = dev->data;
 
     if (!callback) {
@@ -48,7 +48,7 @@ static int kscan_mock_configure(struct device *dev, kscan_callback_t callback) {
         uint32_t events[DT_INST_PROP_LEN(n, events)];                                              \
         bool exit_after;                                                                           \
     };                                                                                             \
-    static void kscan_mock_schedule_next_event_##n(struct device *dev) {                           \
+    static void kscan_mock_schedule_next_event_##n(const struct device *dev) {                     \
         struct kscan_mock_data *data = dev->data;                                                  \
         const struct kscan_mock_config_##n *cfg = dev->config;                                     \
         if (data->event_index < DT_INST_PROP_LEN(n, events)) {                                     \
@@ -70,13 +70,13 @@ static int kscan_mock_configure(struct device *dev, kscan_callback_t callback) {
         kscan_mock_schedule_next_event_##n(data->dev);                                             \
         data->event_index++;                                                                       \
     }                                                                                              \
-    static int kscan_mock_init_##n(struct device *dev) {                                           \
+    static int kscan_mock_init_##n(const struct device *dev) {                                     \
         struct kscan_mock_data *data = dev->data;                                                  \
         data->dev = dev;                                                                           \
         k_delayed_work_init(&data->work, kscan_mock_work_handler_##n);                             \
         return 0;                                                                                  \
     }                                                                                              \
-    static int kscan_mock_enable_callback_##n(struct device *dev) {                                \
+    static int kscan_mock_enable_callback_##n(const struct device *dev) {                          \
         kscan_mock_schedule_next_event_##n(dev);                                                   \
         return 0;                                                                                  \
     }                                                                                              \
diff --git a/app/drivers/sensor/battery_voltage_divider/battery_voltage_divider.c b/app/drivers/sensor/battery_voltage_divider/battery_voltage_divider.c
index 87bd1d8..0618687 100644
--- a/app/drivers/sensor/battery_voltage_divider/battery_voltage_divider.c
+++ b/app/drivers/sensor/battery_voltage_divider/battery_voltage_divider.c
@@ -33,8 +33,8 @@ struct bvd_config {
 };
 
 struct bvd_data {
-    struct device *adc;
-    struct device *gpio;
+    const struct device *adc;
+    const struct device *gpio;
     struct adc_channel_cfg acc;
     struct adc_sequence as;
     uint16_t adc_raw;
@@ -55,7 +55,7 @@ static uint8_t lithium_ion_mv_to_pct(int16_t bat_mv) {
     return bat_mv * 2 / 15 - 459;
 }
 
-static int bvd_sample_fetch(struct device *dev, enum sensor_channel chan) {
+static int bvd_sample_fetch(const struct device *dev, enum sensor_channel chan) {
     struct bvd_data *drv_data = dev->data;
     const struct bvd_config *drv_cfg = dev->config;
     struct adc_sequence *as = &drv_data->as;
@@ -113,7 +113,8 @@ static int bvd_sample_fetch(struct device *dev, enum sensor_channel chan) {
     return rc;
 }
 
-static int bvd_channel_get(struct device *dev, enum sensor_channel chan, struct sensor_value *val) {
+static int bvd_channel_get(const struct device *dev, enum sensor_channel chan,
+                           struct sensor_value *val) {
     struct bvd_data *drv_data = dev->data;
 
     switch (chan) {
@@ -139,7 +140,7 @@ static const struct sensor_driver_api bvd_api = {
     .channel_get = bvd_channel_get,
 };
 
-static int bvd_init(struct device *dev) {
+static int bvd_init(const struct device *dev) {
     struct bvd_data *drv_data = dev->data;
     const struct bvd_config *drv_cfg = dev->config;
 
diff --git a/app/drivers/sensor/ec11/ec11.c b/app/drivers/sensor/ec11/ec11.c
index 80e75aa..38a0578 100644
--- a/app/drivers/sensor/ec11/ec11.c
+++ b/app/drivers/sensor/ec11/ec11.c
@@ -18,7 +18,7 @@
 
 LOG_MODULE_REGISTER(EC11, CONFIG_SENSOR_LOG_LEVEL);
 
-static int ec11_get_ab_state(struct device *dev) {
+static int ec11_get_ab_state(const struct device *dev) {
     struct ec11_data *drv_data = dev->data;
     const struct ec11_config *drv_cfg = dev->config;
 
@@ -26,7 +26,7 @@ static int ec11_get_ab_state(struct device *dev) {
            gpio_pin_get(drv_data->b, drv_cfg->b_pin);
 }
 
-static int ec11_sample_fetch(struct device *dev, enum sensor_channel chan) {
+static int ec11_sample_fetch(const struct device *dev, enum sensor_channel chan) {
     struct ec11_data *drv_data = dev->data;
     const struct ec11_config *drv_cfg = dev->config;
     uint8_t val;
@@ -68,7 +68,7 @@ static int ec11_sample_fetch(struct device *dev, enum sensor_channel chan) {
     return 0;
 }
 
-static int ec11_channel_get(struct device *dev, enum sensor_channel chan,
+static int ec11_channel_get(const struct device *dev, enum sensor_channel chan,
                             struct sensor_value *val) {
     struct ec11_data *drv_data = dev->data;
 
@@ -90,7 +90,7 @@ static const struct sensor_driver_api ec11_driver_api = {
     .channel_get = ec11_channel_get,
 };
 
-int ec11_init(struct device *dev) {
+int ec11_init(const struct device *dev) {
     struct ec11_data *drv_data = dev->data;
     const struct ec11_config *drv_cfg = dev->config;
 
diff --git a/app/drivers/sensor/ec11/ec11.h b/app/drivers/sensor/ec11/ec11.h
index 029f66b..1cb9c5f 100644
--- a/app/drivers/sensor/ec11/ec11.h
+++ b/app/drivers/sensor/ec11/ec11.h
@@ -23,8 +23,8 @@ struct ec11_config {
 };
 
 struct ec11_data {
-    struct device *a;
-    struct device *b;
+    const struct device *a;
+    const struct device *b;
     uint8_t ab_state;
     int8_t pulses;
     int8_t ticks;
@@ -33,7 +33,7 @@ struct ec11_data {
 #ifdef CONFIG_EC11_TRIGGER
     struct gpio_callback a_gpio_cb;
     struct gpio_callback b_gpio_cb;
-    struct device *dev;
+    const struct device *dev;
 
     sensor_trigger_handler_t handler;
     const struct sensor_trigger *trigger;
@@ -51,8 +51,8 @@ struct ec11_data {
 
 #ifdef CONFIG_EC11_TRIGGER
 
-int ec11_trigger_set(struct device *dev, const struct sensor_trigger *trig,
+int ec11_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
                      sensor_trigger_handler_t handler);
 
-int ec11_init_interrupt(struct device *dev);
+int ec11_init_interrupt(const struct device *dev);
 #endif
diff --git a/app/drivers/sensor/ec11/ec11_trigger.c b/app/drivers/sensor/ec11/ec11_trigger.c
index c4934fb..00bebb1 100644
--- a/app/drivers/sensor/ec11/ec11_trigger.c
+++ b/app/drivers/sensor/ec11/ec11_trigger.c
@@ -19,7 +19,7 @@ extern struct ec11_data ec11_driver;
 #include <logging/log.h>
 LOG_MODULE_DECLARE(EC11, CONFIG_SENSOR_LOG_LEVEL);
 
-static inline void setup_int(struct device *dev, bool enable) {
+static inline void setup_int(const struct device *dev, bool enable) {
     struct ec11_data *data = dev->data;
     const struct ec11_config *cfg = dev->config;
 
@@ -36,7 +36,8 @@ static inline void setup_int(struct device *dev, bool enable) {
     }
 }
 
-static void ec11_a_gpio_callback(struct device *dev, struct gpio_callback *cb, uint32_t pins) {
+static void ec11_a_gpio_callback(const struct device *dev, struct gpio_callback *cb,
+                                 uint32_t pins) {
     struct ec11_data *drv_data = CONTAINER_OF(cb, struct ec11_data, a_gpio_cb);
 
     LOG_DBG("");
@@ -50,7 +51,8 @@ static void ec11_a_gpio_callback(struct device *dev, struct gpio_callback *cb, u
 #endif
 }
 
-static void ec11_b_gpio_callback(struct device *dev, struct gpio_callback *cb, uint32_t pins) {
+static void ec11_b_gpio_callback(const struct device *dev, struct gpio_callback *cb,
+                                 uint32_t pins) {
     struct ec11_data *drv_data = CONTAINER_OF(cb, struct ec11_data, b_gpio_cb);
 
     LOG_DBG("");
@@ -65,7 +67,7 @@ static void ec11_b_gpio_callback(struct device *dev, struct gpio_callback *cb, u
 }
 
 static void ec11_thread_cb(void *arg) {
-    struct device *dev = arg;
+    const struct device *dev = arg;
     struct ec11_data *drv_data = dev->data;
 
     drv_data->handler(dev, drv_data->trigger);
@@ -75,7 +77,7 @@ static void ec11_thread_cb(void *arg) {
 
 #ifdef CONFIG_EC11_TRIGGER_OWN_THREAD
 static void ec11_thread(int dev_ptr, int unused) {
-    struct device *dev = INT_TO_POINTER(dev_ptr);
+    const struct device *dev = INT_TO_POINTER(dev_ptr);
     struct ec11_data *drv_data = dev->data;
 
     ARG_UNUSED(unused);
@@ -97,7 +99,7 @@ static void ec11_work_cb(struct k_work *work) {
 }
 #endif
 
-int ec11_trigger_set(struct device *dev, const struct sensor_trigger *trig,
+int ec11_trigger_set(const struct device *dev, const struct sensor_trigger *trig,
                      sensor_trigger_handler_t handler) {
     struct ec11_data *drv_data = dev->data;
 
@@ -113,7 +115,7 @@ int ec11_trigger_set(struct device *dev, const struct sensor_trigger *trig,
     return 0;
 }
 
-int ec11_init_interrupt(struct device *dev) {
+int ec11_init_interrupt(const struct device *dev) {
     struct ec11_data *drv_data = dev->data;
     const struct ec11_config *drv_cfg = dev->config;