diff --git a/app/boards/arm/dz60rgb/pinmux.c b/app/boards/arm/dz60rgb/pinmux.c
index f59a31bf..241c4ce1 100644
--- a/app/boards/arm/dz60rgb/pinmux.c
+++ b/app/boards/arm/dz60rgb/pinmux.c
@@ -56,7 +56,7 @@ static const struct pin_config pinconf[] = {
 #endif
 };
 
-static int pinmux_stm32_init(struct device *port) {
+static int pinmux_stm32_init(const struct device *port) {
     ARG_UNUSED(port);
 
     stm32_setup_pins(pinconf, ARRAY_SIZE(pinconf));
diff --git a/app/boards/arm/nrfmicro/pinmux.c b/app/boards/arm/nrfmicro/pinmux.c
index 30117d0f..dc3bf6c2 100644
--- a/app/boards/arm/nrfmicro/pinmux.c
+++ b/app/boards/arm/nrfmicro/pinmux.c
@@ -11,11 +11,11 @@
 #include <sys/sys_io.h>
 #include <devicetree.h>
 
-static int pinmux_nrfmicro_init(struct device *port) {
+static int pinmux_nrfmicro_init(const struct device *port) {
     ARG_UNUSED(port);
 
 #if CONFIG_BOARD_NRFMICRO_13
-    struct device *p0 = device_get_binding("GPIO_0");
+    const struct device *p0 = device_get_binding("GPIO_0");
 #if CONFIG_BOARD_NRFMICRO_CHARGER
     gpio_pin_configure(p0, 5, GPIO_OUTPUT);
     gpio_pin_set(p0, 5, 0);
diff --git a/app/boards/arm/planck/pinmux.c b/app/boards/arm/planck/pinmux.c
index 61cc16ae..9080aa45 100644
--- a/app/boards/arm/planck/pinmux.c
+++ b/app/boards/arm/planck/pinmux.c
@@ -56,7 +56,7 @@ static const struct pin_config pinconf[] = {
 #endif /* CONFIG_CAN_1 */
 };
 
-static int pinmux_stm32_init(struct device *port) {
+static int pinmux_stm32_init(const struct device *port) {
     ARG_UNUSED(port);
 
     stm32_setup_pins(pinconf, ARRAY_SIZE(pinconf));
diff --git a/app/boards/arm/proton_c/pinmux.c b/app/boards/arm/proton_c/pinmux.c
index 9ffabd73..4e32b32b 100644
--- a/app/boards/arm/proton_c/pinmux.c
+++ b/app/boards/arm/proton_c/pinmux.c
@@ -56,7 +56,7 @@ static const struct pin_config pinconf[] = {
 #endif
 };
 
-static int pinmux_stm32_init(struct device *port) {
+static int pinmux_stm32_init(const struct device *port) {
     ARG_UNUSED(port);
 
     stm32_setup_pins(pinconf, ARRAY_SIZE(pinconf));
diff --git a/app/drivers/kscan/kscan_composite.c b/app/drivers/kscan/kscan_composite.c
index b9383d1c..d699cfa8 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 f48a09dd..7e3515f5 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 041c900c..0802d0e5 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 84120434..6697cf69 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 0d687a3b..8b40ab44 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 87bd1d83..0618687e 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 80e75aa0..38a0578d 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 029f66b2..1cb9c5f7 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 c4934fb5..00bebb12 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;
 
diff --git a/app/include/drivers/behavior.h b/app/include/drivers/behavior.h
index 56ff7afc..bc135fd3 100644
--- a/app/include/drivers/behavior.h
+++ b/app/include/drivers/behavior.h
@@ -23,7 +23,8 @@
 typedef int (*behavior_keymap_binding_callback_t)(struct zmk_behavior_binding *binding,
                                                   struct zmk_behavior_binding_event event);
 typedef int (*behavior_sensor_keymap_binding_callback_t)(struct zmk_behavior_binding *binding,
-                                                         struct device *sensor, int64_t timestamp);
+                                                         const struct device *sensor,
+                                                         int64_t timestamp);
 
 __subsystem struct behavior_driver_api {
     behavior_keymap_binding_callback_t binding_pressed;
@@ -48,7 +49,7 @@ __syscall int behavior_keymap_binding_pressed(struct zmk_behavior_binding *bindi
 
 static inline int z_impl_behavior_keymap_binding_pressed(struct zmk_behavior_binding *binding,
                                                          struct zmk_behavior_binding_event event) {
-    struct device *dev = device_get_binding(binding->behavior_dev);
+    const struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->api;
 
     if (api->binding_pressed == NULL) {
@@ -71,7 +72,7 @@ __syscall int behavior_keymap_binding_released(struct zmk_behavior_binding *bind
 
 static inline int z_impl_behavior_keymap_binding_released(struct zmk_behavior_binding *binding,
                                                           struct zmk_behavior_binding_event event) {
-    struct device *dev = device_get_binding(binding->behavior_dev);
+    const struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->api;
 
     if (api->binding_released == NULL) {
@@ -92,12 +93,13 @@ static inline int z_impl_behavior_keymap_binding_released(struct zmk_behavior_bi
  * @retval Negative errno code if failure.
  */
 __syscall int behavior_sensor_keymap_binding_triggered(struct zmk_behavior_binding *binding,
-                                                       struct device *sensor, int64_t timestamp);
+                                                       const struct device *sensor,
+                                                       int64_t timestamp);
 
 static inline int
 z_impl_behavior_sensor_keymap_binding_triggered(struct zmk_behavior_binding *binding,
-                                                struct device *sensor, int64_t timestamp) {
-    struct device *dev = device_get_binding(binding->behavior_dev);
+                                                const struct device *sensor, int64_t timestamp) {
+    const struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->api;
 
     if (api->sensor_binding_triggered == NULL) {
diff --git a/app/include/drivers/ext_power.h b/app/include/drivers/ext_power.h
index ddc85a35..b422750c 100644
--- a/app/include/drivers/ext_power.h
+++ b/app/include/drivers/ext_power.h
@@ -22,9 +22,9 @@ extern "C" {
  * (Internal use only.)
  */
 
-typedef int (*ext_power_enable_t)(struct device *dev);
-typedef int (*ext_power_disable_t)(struct device *dev);
-typedef int (*ext_power_get_t)(struct device *dev);
+typedef int (*ext_power_enable_t)(const struct device *dev);
+typedef int (*ext_power_disable_t)(const struct device *dev);
+typedef int (*ext_power_get_t)(const struct device *dev);
 
 __subsystem struct ext_power_api {
     ext_power_enable_t enable;
@@ -42,9 +42,9 @@ __subsystem struct ext_power_api {
  * @retval 0 If successful.
  * @retval Negative errno code if failure.
  */
-__syscall int ext_power_enable(struct device *dev);
+__syscall int ext_power_enable(const struct device *dev);
 
-static inline int z_impl_ext_power_enable(struct device *dev) {
+static inline int z_impl_ext_power_enable(const struct device *dev) {
     const struct ext_power_api *api = (const struct ext_power_api *)dev->api;
 
     if (api->enable == NULL) {
@@ -61,9 +61,9 @@ static inline int z_impl_ext_power_enable(struct device *dev) {
  * @retval 0 If successful.
  * @retval Negative errno code if failure.
  */
-__syscall int ext_power_disable(struct device *dev);
+__syscall int ext_power_disable(const struct device *dev);
 
-static inline int z_impl_ext_power_disable(struct device *dev) {
+static inline int z_impl_ext_power_disable(const struct device *dev) {
     const struct ext_power_api *api = (const struct ext_power_api *)dev->api;
 
     if (api->disable == NULL) {
@@ -81,9 +81,9 @@ static inline int z_impl_ext_power_disable(struct device *dev) {
  * @retval 1 if ext power is enabled.
  * @retval Negative errno code if failure.
  */
-__syscall int ext_power_get(struct device *dev);
+__syscall int ext_power_get(const struct device *dev);
 
-static inline int z_impl_ext_power_get(struct device *dev) {
+static inline int z_impl_ext_power_get(const struct device *dev) {
     const struct ext_power_api *api = (const struct ext_power_api *)dev->api;
 
     if (api->get == NULL) {
diff --git a/app/include/zmk/events/sensor-event.h b/app/include/zmk/events/sensor-event.h
index d1d72f41..0bd3ccf0 100644
--- a/app/include/zmk/events/sensor-event.h
+++ b/app/include/zmk/events/sensor-event.h
@@ -13,7 +13,7 @@
 struct sensor_event {
     struct zmk_event_header header;
     uint8_t sensor_number;
-    struct device *sensor;
+    const struct device *sensor;
     int64_t timestamp;
 };
 
diff --git a/app/src/battery.c b/app/src/battery.c
index e78b2fba..777dbdb6 100644
--- a/app/src/battery.c
+++ b/app/src/battery.c
@@ -17,9 +17,9 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 #include <zmk/event-manager.h>
 #include <zmk/events/battery-state-changed.h>
 
-struct device *battery;
+const struct device *battery;
 
-static int zmk_battery_update(struct device *battery) {
+static int zmk_battery_update(const struct device *battery) {
     struct sensor_value state_of_charge;
 
     int rc = sensor_sample_fetch_chan(battery, SENSOR_CHAN_GAUGE_STATE_OF_CHARGE);
@@ -64,7 +64,7 @@ static void zmk_battery_timer(struct k_timer *timer) { k_work_submit(&battery_wo
 
 K_TIMER_DEFINE(battery_timer, zmk_battery_timer, NULL);
 
-static int zmk_battery_init(struct device *_arg) {
+static int zmk_battery_init(const struct device *_arg) {
     battery = device_get_binding("BATTERY");
 
     if (battery == NULL) {
diff --git a/app/src/behaviors/behavior_bt.c b/app/src/behaviors/behavior_bt.c
index 066c4371..bfafc4b3 100644
--- a/app/src/behaviors/behavior_bt.c
+++ b/app/src/behaviors/behavior_bt.c
@@ -35,7 +35,7 @@ static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
     return -ENOTSUP;
 }
 
-static int behavior_bt_init(struct device *dev) { return 0; };
+static int behavior_bt_init(const struct device *dev) { return 0; };
 
 static int on_keymap_binding_released(struct zmk_behavior_binding *binding,
                                       struct zmk_behavior_binding_event event) {
diff --git a/app/src/behaviors/behavior_ext_power.c b/app/src/behaviors/behavior_ext_power.c
index 825f9834..dbc6fd94 100644
--- a/app/src/behaviors/behavior_ext_power.c
+++ b/app/src/behaviors/behavior_ext_power.c
@@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
                                      struct zmk_behavior_binding_event event) {
-    struct device *ext_power = device_get_binding("EXT_POWER");
+    const struct device *ext_power = device_get_binding("EXT_POWER");
     if (ext_power == NULL) {
         LOG_ERR("Unable to retrieve ext_power device: %d", binding->param1);
         return -EIO;
@@ -46,7 +46,7 @@ static int on_keymap_binding_released(struct zmk_behavior_binding *binding,
     return 0;
 }
 
-static int behavior_ext_power_init(struct device *dev) { return 0; };
+static int behavior_ext_power_init(const struct device *dev) { return 0; };
 
 static const struct behavior_driver_api behavior_ext_power_driver_api = {
     .binding_pressed = on_keymap_binding_pressed,
diff --git a/app/src/behaviors/behavior_hold_tap.c b/app/src/behaviors/behavior_hold_tap.c
index 44a51175..556273ec 100644
--- a/app/src/behaviors/behavior_hold_tap.c
+++ b/app/src/behaviors/behavior_hold_tap.c
@@ -304,7 +304,7 @@ static void decide_hold_tap(struct active_hold_tap *hold_tap, enum decision_mome
 
 static int on_hold_tap_binding_pressed(struct zmk_behavior_binding *binding,
                                        struct zmk_behavior_binding_event event) {
-    struct device *dev = device_get_binding(binding->behavior_dev);
+    const struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_hold_tap_config *cfg = dev->config;
 
     if (undecided_hold_tap != NULL) {
@@ -479,7 +479,7 @@ void behavior_hold_tap_timer_work_handler(struct k_work *item) {
     }
 }
 
-static int behavior_hold_tap_init(struct device *dev) {
+static int behavior_hold_tap_init(const struct device *dev) {
     static bool init_first_run = true;
 
     if (init_first_run) {
diff --git a/app/src/behaviors/behavior_key_press.c b/app/src/behaviors/behavior_key_press.c
index 8559a514..aa19ca96 100644
--- a/app/src/behaviors/behavior_key_press.c
+++ b/app/src/behaviors/behavior_key_press.c
@@ -16,7 +16,7 @@
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-static int behavior_key_press_init(struct device *dev) { return 0; };
+static int behavior_key_press_init(const struct device *dev) { return 0; };
 
 static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
                                      struct zmk_behavior_binding_event event) {
diff --git a/app/src/behaviors/behavior_momentary_layer.c b/app/src/behaviors/behavior_momentary_layer.c
index b1fb14b0..2b0206d0 100644
--- a/app/src/behaviors/behavior_momentary_layer.c
+++ b/app/src/behaviors/behavior_momentary_layer.c
@@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 struct behavior_mo_config {};
 struct behavior_mo_data {};
 
-static int behavior_mo_init(struct device *dev) { return 0; };
+static int behavior_mo_init(const struct device *dev) { return 0; };
 
 static int mo_keymap_binding_pressed(struct zmk_behavior_binding *binding,
                                      struct zmk_behavior_binding_event event) {
diff --git a/app/src/behaviors/behavior_none.c b/app/src/behaviors/behavior_none.c
index 96ea9d5d..12542f05 100644
--- a/app/src/behaviors/behavior_none.c
+++ b/app/src/behaviors/behavior_none.c
@@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 struct behavior_none_config {};
 struct behavior_none_data {};
 
-static int behavior_none_init(struct device *dev) { return 0; };
+static int behavior_none_init(const struct device *dev) { return 0; };
 
 static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
                                      struct zmk_behavior_binding_event event) {
diff --git a/app/src/behaviors/behavior_outputs.c b/app/src/behaviors/behavior_outputs.c
index e5182bd4..3a45b7fd 100644
--- a/app/src/behaviors/behavior_outputs.c
+++ b/app/src/behaviors/behavior_outputs.c
@@ -34,7 +34,7 @@ static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
     return -ENOTSUP;
 }
 
-static int behavior_out_init(struct device *dev) { return 0; }
+static int behavior_out_init(const struct device *dev) { return 0; }
 
 static const struct behavior_driver_api behavior_outputs_driver_api = {
     .binding_pressed = on_keymap_binding_pressed,
diff --git a/app/src/behaviors/behavior_reset.c b/app/src/behaviors/behavior_reset.c
index 97d0a1d9..cb77a838 100644
--- a/app/src/behaviors/behavior_reset.c
+++ b/app/src/behaviors/behavior_reset.c
@@ -19,11 +19,11 @@ struct behavior_reset_config {
     int type;
 };
 
-static int behavior_reset_init(struct device *dev) { return 0; };
+static int behavior_reset_init(const struct device *dev) { return 0; };
 
 static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
                                      struct zmk_behavior_binding_event event) {
-    struct device *dev = device_get_binding(binding->behavior_dev);
+    const struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_reset_config *cfg = dev->config;
 
     // TODO: Correct magic code for going into DFU?
diff --git a/app/src/behaviors/behavior_rgb_underglow.c b/app/src/behaviors/behavior_rgb_underglow.c
index 80839a77..a0db9a9b 100644
--- a/app/src/behaviors/behavior_rgb_underglow.c
+++ b/app/src/behaviors/behavior_rgb_underglow.c
@@ -16,7 +16,7 @@
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-static int behavior_rgb_underglow_init(struct device *dev) { return 0; }
+static int behavior_rgb_underglow_init(const struct device *dev) { return 0; }
 
 static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
                                      struct zmk_behavior_binding_event event) {
diff --git a/app/src/behaviors/behavior_sensor_rotate_key_press.c b/app/src/behaviors/behavior_sensor_rotate_key_press.c
index 85af24a4..a0e0accc 100644
--- a/app/src/behaviors/behavior_sensor_rotate_key_press.c
+++ b/app/src/behaviors/behavior_sensor_rotate_key_press.c
@@ -16,10 +16,10 @@
 
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
-static int behavior_sensor_rotate_key_press_init(struct device *dev) { return 0; };
+static int behavior_sensor_rotate_key_press_init(const struct device *dev) { return 0; };
 
-static int on_sensor_binding_triggered(struct zmk_behavior_binding *binding, struct device *sensor,
-                                       int64_t timestamp) {
+static int on_sensor_binding_triggered(struct zmk_behavior_binding *binding,
+                                       const struct device *sensor, int64_t timestamp) {
     struct sensor_value value;
     int err;
     uint32_t keycode;
diff --git a/app/src/behaviors/behavior_sticky_key.c b/app/src/behaviors/behavior_sticky_key.c
index 51c78ff0..920f6f2b 100644
--- a/app/src/behaviors/behavior_sticky_key.c
+++ b/app/src/behaviors/behavior_sticky_key.c
@@ -127,7 +127,7 @@ static int stop_timer(struct active_sticky_key *sticky_key) {
 
 static int on_sticky_key_binding_pressed(struct zmk_behavior_binding *binding,
                                          struct zmk_behavior_binding_event event) {
-    struct device *dev = device_get_binding(binding->behavior_dev);
+    const struct device *dev = device_get_binding(binding->behavior_dev);
     const struct behavior_sticky_key_config *cfg = dev->config;
     struct active_sticky_key *sticky_key;
     sticky_key = find_sticky_key(event.position);
@@ -242,7 +242,7 @@ void behavior_sticky_key_timer_handler(struct k_work *item) {
     }
 }
 
-static int behavior_sticky_key_init(struct device *dev) {
+static int behavior_sticky_key_init(const struct device *dev) {
     static bool init_first_run = true;
     if (init_first_run) {
         for (int i = 0; i < ZMK_BHV_STICKY_KEY_MAX_HELD; i++) {
diff --git a/app/src/behaviors/behavior_toggle_layer.c b/app/src/behaviors/behavior_toggle_layer.c
index b3c69614..32833775 100644
--- a/app/src/behaviors/behavior_toggle_layer.c
+++ b/app/src/behaviors/behavior_toggle_layer.c
@@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 struct behavior_tog_config {};
 struct behavior_tog_data {};
 
-static int behavior_tog_init(struct device *dev) { return 0; };
+static int behavior_tog_init(const struct device *dev) { return 0; };
 
 static int tog_keymap_binding_pressed(struct zmk_behavior_binding *binding,
                                       struct zmk_behavior_binding_event event) {
diff --git a/app/src/behaviors/behavior_transparent.c b/app/src/behaviors/behavior_transparent.c
index cede3699..17a5e436 100644
--- a/app/src/behaviors/behavior_transparent.c
+++ b/app/src/behaviors/behavior_transparent.c
@@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 struct behavior_transparent_config {};
 struct behavior_transparent_data {};
 
-static int behavior_transparent_init(struct device *dev) { return 0; };
+static int behavior_transparent_init(const struct device *dev) { return 0; };
 
 static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
                                      struct zmk_behavior_binding_event event) {
diff --git a/app/src/ble.c b/app/src/ble.c
index 5f5f94a9..d335f947 100644
--- a/app/src/ble.c
+++ b/app/src/ble.c
@@ -509,7 +509,7 @@ static void zmk_ble_ready(int err) {
     update_advertising();
 }
 
-static int zmk_ble_init(struct device *_arg) {
+static int zmk_ble_init(const struct device *_arg) {
     int err = bt_enable(NULL);
 
     if (err) {
diff --git a/app/src/display/main.c b/app/src/display/main.c
index d64fb2a2..36838973 100644
--- a/app/src/display/main.c
+++ b/app/src/display/main.c
@@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 #define ZMK_DISPLAY_NAME CONFIG_LVGL_DISPLAY_DEV_NAME
 
-static struct device *display;
+static const struct device *display;
 
 static lv_obj_t *screen;
 
diff --git a/app/src/endpoints.c b/app/src/endpoints.c
index 030b27a9..f432ac2f 100644
--- a/app/src/endpoints.c
+++ b/app/src/endpoints.c
@@ -156,7 +156,7 @@ static int endpoints_handle_set(const char *name, size_t len, settings_read_cb r
 struct settings_handler endpoints_handler = {.name = "endpoints", .h_set = endpoints_handle_set};
 #endif /* IS_ENABLED(CONFIG_SETTINGS) */
 
-static int zmk_endpoints_init(struct device *_arg) {
+static int zmk_endpoints_init(const struct device *_arg) {
 #if IS_ENABLED(CONFIG_SETTINGS)
     settings_subsys_init();
 
diff --git a/app/src/ext_power_generic.c b/app/src/ext_power_generic.c
index ca44d208..71d12091 100644
--- a/app/src/ext_power_generic.c
+++ b/app/src/ext_power_generic.c
@@ -26,7 +26,7 @@ struct ext_power_generic_config {
 };
 
 struct ext_power_generic_data {
-    struct device *gpio;
+    const struct device *gpio;
     bool status;
 #if IS_ENABLED(CONFIG_SETTINGS)
     bool settings_init;
@@ -36,7 +36,7 @@ struct ext_power_generic_data {
 #if IS_ENABLED(CONFIG_SETTINGS)
 static void ext_power_save_state_work(struct k_work *work) {
     char setting_path[40];
-    struct device *ext_power = device_get_binding(DT_INST_LABEL(0));
+    const struct device *ext_power = device_get_binding(DT_INST_LABEL(0));
     struct ext_power_generic_data *data = ext_power->data;
 
     snprintf(setting_path, 40, "ext_power/state/%s", DT_INST_LABEL(0));
@@ -55,7 +55,7 @@ int ext_power_save_state() {
 #endif
 }
 
-static int ext_power_generic_enable(struct device *dev) {
+static int ext_power_generic_enable(const struct device *dev) {
     struct ext_power_generic_data *data = dev->data;
     const struct ext_power_generic_config *config = dev->config;
 
@@ -67,7 +67,7 @@ static int ext_power_generic_enable(struct device *dev) {
     return ext_power_save_state();
 }
 
-static int ext_power_generic_disable(struct device *dev) {
+static int ext_power_generic_disable(const struct device *dev) {
     struct ext_power_generic_data *data = dev->data;
     const struct ext_power_generic_config *config = dev->config;
 
@@ -79,7 +79,7 @@ static int ext_power_generic_disable(struct device *dev) {
     return ext_power_save_state();
 }
 
-static int ext_power_generic_get(struct device *dev) {
+static int ext_power_generic_get(const struct device *dev) {
     struct ext_power_generic_data *data = dev->data;
     return data->status;
 }
@@ -91,7 +91,7 @@ static int ext_power_settings_set(const char *name, size_t len, settings_read_cb
     int rc;
 
     if (settings_name_steq(name, DT_INST_LABEL(0), &next) && !next) {
-        struct device *ext_power = device_get_binding(DT_INST_LABEL(0));
+        const struct device *ext_power = device_get_binding(DT_INST_LABEL(0));
         struct ext_power_generic_data *data = ext_power->data;
 
         if (len != sizeof(data->status)) {
@@ -124,7 +124,7 @@ struct settings_handler ext_power_conf = {.name = "ext_power/state",
                                           .h_set = ext_power_settings_set};
 #endif
 
-static int ext_power_generic_init(struct device *dev) {
+static int ext_power_generic_init(const struct device *dev) {
     struct ext_power_generic_data *data = dev->data;
     const struct ext_power_generic_config *config = dev->config;
 
diff --git a/app/src/keymap.c b/app/src/keymap.c
index 0dc7c1a1..cab6d474 100644
--- a/app/src/keymap.c
+++ b/app/src/keymap.c
@@ -121,7 +121,7 @@ bool is_active_layer(uint8_t layer, zmk_keymap_layers_state layer_state) {
 
 int zmk_keymap_apply_position_state(int layer, uint32_t position, bool pressed, int64_t timestamp) {
     struct zmk_behavior_binding *binding = &zmk_keymap[layer][position];
-    struct device *behavior;
+    const struct device *behavior;
     struct zmk_behavior_binding_event event = {
         .layer = layer,
         .position = position,
@@ -168,13 +168,14 @@ int zmk_keymap_position_state_changed(uint32_t position, bool pressed, int64_t t
 }
 
 #if ZMK_KEYMAP_HAS_SENSORS
-int zmk_keymap_sensor_triggered(uint8_t sensor_number, struct device *sensor, int64_t timestamp) {
+int zmk_keymap_sensor_triggered(uint8_t sensor_number, const struct device *sensor,
+                                int64_t timestamp) {
     for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= _zmk_keymap_layer_default; layer--) {
         if (((_zmk_keymap_layer_state & BIT(layer)) == BIT(layer) ||
              layer == _zmk_keymap_layer_default) &&
             zmk_sensor_keymap[layer] != NULL) {
             struct zmk_behavior_binding *binding = &zmk_sensor_keymap[layer][sensor_number];
-            struct device *behavior;
+            const struct device *behavior;
             int ret;
 
             LOG_DBG("layer: %d sensor_number: %d, binding name: %s", layer, sensor_number,
diff --git a/app/src/kscan.c b/app/src/kscan.c
index b6ffc37f..c22d71b4 100644
--- a/app/src/kscan.c
+++ b/app/src/kscan.c
@@ -30,7 +30,8 @@ struct zmk_kscan_msg_processor {
 
 K_MSGQ_DEFINE(zmk_kscan_msgq, sizeof(struct zmk_kscan_event), CONFIG_ZMK_KSCAN_EVENT_QUEUE_SIZE, 4);
 
-static void zmk_kscan_callback(struct device *dev, uint32_t row, uint32_t column, bool pressed) {
+static void zmk_kscan_callback(const struct device *dev, uint32_t row, uint32_t column,
+                               bool pressed) {
     struct zmk_kscan_event ev = {
         .row = row,
         .column = column,
@@ -58,7 +59,7 @@ void zmk_kscan_process_msgq(struct k_work *item) {
 }
 
 int zmk_kscan_init(char *name) {
-    struct device *dev = device_get_binding(name);
+    const struct device *dev = device_get_binding(name);
     if (dev == NULL) {
         LOG_ERR("Failed to get the KSCAN device");
         return -EINVAL;
diff --git a/app/src/rgb_underglow.c b/app/src/rgb_underglow.c
index b2943e6a..f5ed9ced 100644
--- a/app/src/rgb_underglow.c
+++ b/app/src/rgb_underglow.c
@@ -46,14 +46,14 @@ struct rgb_underglow_state {
     bool on;
 };
 
-static struct device *led_strip;
+static const struct device *led_strip;
 
 static struct led_rgb pixels[STRIP_NUM_PIXELS];
 
 static struct rgb_underglow_state state;
 
 #if IS_ENABLED(CONFIG_ZMK_RGB_UNDERGLOW_EXT_POWER)
-static struct device *ext_power;
+static const struct device *ext_power;
 #endif
 
 static struct led_rgb hsb_to_rgb(struct led_hsb hsb) {
@@ -238,7 +238,7 @@ static void zmk_rgb_underglow_save_state_work() {
 static struct k_delayed_work underglow_save_work;
 #endif
 
-static int zmk_rgb_underglow_init(struct device *_arg) {
+static int zmk_rgb_underglow_init(const struct device *_arg) {
     led_strip = device_get_binding(STRIP_LABEL);
     if (led_strip) {
         LOG_INF("Found LED strip device %s", STRIP_LABEL);
diff --git a/app/src/sensors.c b/app/src/sensors.c
index 5bccc854..5b4f683b 100644
--- a/app/src/sensors.c
+++ b/app/src/sensors.c
@@ -20,7 +20,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
 struct sensors_data_item {
     uint8_t sensor_number;
-    struct device *dev;
+    const struct device *dev;
     struct sensor_trigger trigger;
 };
 
@@ -32,7 +32,7 @@ struct sensors_data_item {
 
 static struct sensors_data_item sensors[] = {UTIL_LISTIFY(ZMK_KEYMAP_SENSORS_LEN, SENSOR_ITEM, 0)};
 
-static void zmk_sensors_trigger_handler(struct device *dev, struct sensor_trigger *trigger) {
+static void zmk_sensors_trigger_handler(const struct device *dev, struct sensor_trigger *trigger) {
     int err;
     struct sensors_data_item *item = CONTAINER_OF(trigger, struct sensors_data_item, trigger);
     struct sensor_event *event;
@@ -72,7 +72,7 @@ static void zmk_sensors_init_item(const char *node, uint8_t i, uint8_t abs_i) {
     COND_CODE_1(DT_NODE_HAS_STATUS(ZMK_KEYMAP_SENSORS_BY_IDX(idx), okay),                          \
                 (_SENSOR_INIT(ZMK_KEYMAP_SENSORS_BY_IDX(idx))), (absolute_index++;))
 
-static int zmk_sensors_init(struct device *_arg) {
+static int zmk_sensors_init(const struct device *_arg) {
     int local_index = 0;
     int absolute_index = 0;
 
diff --git a/app/src/settings.c b/app/src/settings.c
index 8914ccc3..9366dd23 100644
--- a/app/src/settings.c
+++ b/app/src/settings.c
@@ -3,6 +3,6 @@
 #include <kernel.h>
 #include <settings/settings.h>
 
-static int zmk_settings_init(struct device *_arg) { return settings_load(); }
+static int zmk_settings_init(const struct device *_arg) { return settings_load(); }
 
 SYS_INIT(zmk_settings_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);
diff --git a/app/src/split/bluetooth/central.c b/app/src/split/bluetooth/central.c
index f3c860f0..c41894f2 100644
--- a/app/src/split/bluetooth/central.c
+++ b/app/src/split/bluetooth/central.c
@@ -315,7 +315,7 @@ static struct bt_conn_cb conn_callbacks = {
     .disconnected = split_central_disconnected,
 };
 
-int zmk_split_bt_central_init(struct device *_arg) {
+int zmk_split_bt_central_init(const struct device *_arg) {
     bt_conn_cb_register(&conn_callbacks);
 
     return start_scan();
diff --git a/app/src/usb.c b/app/src/usb.c
index d0253b55..009d7af7 100644
--- a/app/src/usb.c
+++ b/app/src/usb.c
@@ -21,7 +21,7 @@ static enum usb_dc_status_code usb_status = USB_DC_UNKNOWN;
 
 #ifdef CONFIG_ZMK_USB
 
-static struct device *hid_dev;
+static const struct device *hid_dev;
 
 static K_SEM_DEFINE(hid_sem, 1, 1);
 
@@ -83,7 +83,7 @@ void usb_status_cb(enum usb_dc_status_code status, const uint8_t *params) {
     raise_usb_status_changed_event();
 };
 
-static int zmk_usb_init(struct device *_arg) {
+static int zmk_usb_init(const struct device *_arg) {
     int usb_enable_ret;
 
 #ifdef CONFIG_ZMK_USB