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

5 files changed, 76 insertions, 74 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;                                                                                  \
     }                                                                                              \