Merge https://github.com/zmkfirmware/zmk into refactor_kconfig

7 files changed, 525 insertions, 13 deletions

diff --git a/app/drivers/zephyr/CMakeLists.txt b/app/drivers/zephyr/CMakeLists.txt
index 8778ded..e3a192d 100644
--- a/app/drivers/zephyr/CMakeLists.txt
+++ b/app/drivers/zephyr/CMakeLists.txt
@@ -5,8 +5,10 @@ if(CONFIG_ZMK_KSCAN_GPIO_DRIVER)
   zephyr_library_sources(
     kscan_gpio_matrix.c
     kscan_gpio_direct.c
+    kscan_gpio_demux.c
     )
 
   zephyr_library_sources_ifdef(CONFIG_EC11 ec11.c)
   zephyr_library_sources_ifdef(CONFIG_EC11_TRIGGER ec11_trigger.c)
+  zephyr_library_sources_ifdef(CONFIG_ZMK_BATTERY_VOLTAGE_DIVIDER battery_voltage_divider.c)
 endif()
diff --git a/app/drivers/zephyr/Kconfig b/app/drivers/zephyr/Kconfig
index 0534cab..6b177fb 100644
--- a/app/drivers/zephyr/Kconfig
+++ b/app/drivers/zephyr/Kconfig
@@ -21,6 +21,12 @@ config ZMK_KSCAN_INIT_PRIORITY
 	help
 	  Keyboard scan device driver initialization priority.
 
+config ZMK_BATTERY_VOLTAGE_DIVIDER
+	bool "ZMK battery voltage divider"
+	select ADC
+	help
+		Enable ZMK battery voltage divider driver for battery monitoring.
+
 menuconfig EC11
 	bool "EC11 Incremental Encoder Sensor"
 	depends on GPIO
diff --git a/app/drivers/zephyr/battery_voltage_divider.c b/app/drivers/zephyr/battery_voltage_divider.c
new file mode 100644
index 0000000..37ac024
--- /dev/null
+++ b/app/drivers/zephyr/battery_voltage_divider.c
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#define DT_DRV_COMPAT zmk_battery_voltage_divider
+
+#include <device.h>
+#include <drivers/gpio.h>
+#include <drivers/adc.h>
+#include <drivers/sensor.h>
+#include <logging/log.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+struct io_channel_config {
+    const char *label;
+    uint8_t channel;
+};
+
+struct gpio_channel_config {
+    const char *label;
+    uint8_t pin;
+    uint8_t flags;
+};
+
+struct bvd_config {
+    struct io_channel_config io_channel;
+    struct gpio_channel_config power_gpios;
+    uint32_t output_ohm;
+    uint32_t full_ohm;
+};
+
+struct bvd_data {
+    struct device *adc;
+    struct device *gpio;
+    struct adc_channel_cfg acc;
+    struct adc_sequence as;
+    uint16_t adc_raw;
+    uint16_t voltage;
+    uint8_t state_of_charge;
+};
+
+static uint8_t lithium_ion_mv_to_pct(int16_t bat_mv) {
+    // Simple linear approximation of a battery based off adafruit's discharge graph:
+    // https://learn.adafruit.com/li-ion-and-lipoly-batteries/voltages
+
+    if (bat_mv >= 4200) {
+        return 100;
+    } else if (bat_mv <= 3450) {
+        return 0;
+    }
+
+    return bat_mv * 2 / 15 - 459;
+}
+
+static int bvd_sample_fetch(struct device *dev, enum sensor_channel chan) {
+    struct bvd_data *drv_data = dev->driver_data;
+    const struct bvd_config *drv_cfg = dev->config_info;
+    struct adc_sequence *as = &drv_data->as;
+
+    // Make sure selected channel is supported
+    if (chan != SENSOR_CHAN_GAUGE_VOLTAGE && chan != SENSOR_CHAN_GAUGE_STATE_OF_CHARGE) {
+        return -ENOTSUP;
+    }
+
+    int rc = 0;
+
+    // Enable power GPIO if present
+    if (drv_data->gpio) {
+        rc = gpio_pin_set(drv_data->gpio, drv_cfg->power_gpios.pin, 1);
+
+        if (rc != 0) {
+            LOG_DBG("Failed to enable ADC power GPIO: %d", rc);
+            return rc;
+        }
+    }
+
+    // Read ADC
+    rc = adc_read(drv_data->adc, as);
+    as->calibrate = false;
+
+    if (rc == 0) {
+        int32_t val = drv_data->adc_raw;
+
+        adc_raw_to_millivolts(adc_ref_internal(drv_data->adc), drv_data->acc.gain, as->resolution,
+                              &val);
+
+        uint16_t millivolts = val * (uint64_t)drv_cfg->full_ohm / drv_cfg->output_ohm;
+        LOG_DBG("ADC raw %d ~ %d mV => %d mV\n", drv_data->adc_raw, val, millivolts);
+        uint8_t percent = lithium_ion_mv_to_pct(millivolts);
+        LOG_DBG("Percent: %d", percent);
+
+        drv_data->voltage = millivolts;
+        drv_data->state_of_charge = percent;
+    } else {
+        LOG_DBG("Failed to read ADC: %d", rc);
+    }
+
+    // Disable power GPIO if present
+    if (drv_data->gpio) {
+        int rc2 = gpio_pin_set(drv_data->gpio, drv_cfg->power_gpios.pin, 0);
+
+        if (rc2 != 0) {
+            LOG_DBG("Failed to disable ADC power GPIO: %d", rc2);
+            return rc2;
+        }
+    }
+
+    return rc;
+}
+
+static int bvd_channel_get(struct device *dev, enum sensor_channel chan, struct sensor_value *val) {
+    struct bvd_data *drv_data = dev->driver_data;
+
+    switch (chan) {
+    case SENSOR_CHAN_GAUGE_VOLTAGE:
+        val->val1 = drv_data->voltage / 1000;
+        val->val2 = (drv_data->voltage % 1000) * 1000U;
+        break;
+
+    case SENSOR_CHAN_GAUGE_STATE_OF_CHARGE:
+        val->val1 = drv_data->state_of_charge;
+        val->val2 = 0;
+        break;
+
+    default:
+        return -ENOTSUP;
+    }
+
+    return 0;
+}
+
+static const struct sensor_driver_api bvd_api = {
+    .sample_fetch = bvd_sample_fetch,
+    .channel_get = bvd_channel_get,
+};
+
+static int bvd_init(struct device *dev) {
+    struct bvd_data *drv_data = dev->driver_data;
+    const struct bvd_config *drv_cfg = dev->config_info;
+
+    drv_data->adc = device_get_binding(drv_cfg->io_channel.label);
+
+    if (drv_data->adc == NULL) {
+        LOG_ERR("ADC %s failed to retrieve", drv_cfg->io_channel.label);
+        return -ENODEV;
+    }
+
+    int rc = 0;
+
+    if (drv_cfg->power_gpios.label) {
+        drv_data->gpio = device_get_binding(drv_cfg->power_gpios.label);
+        if (drv_data->gpio == NULL) {
+            LOG_ERR("Failed to get GPIO %s", drv_cfg->power_gpios.label);
+            return -ENODEV;
+        }
+        rc = gpio_pin_configure(drv_data->gpio, drv_cfg->power_gpios.pin,
+                                GPIO_OUTPUT_INACTIVE | drv_cfg->power_gpios.flags);
+        if (rc != 0) {
+            LOG_ERR("Failed to control feed %s.%u: %d", drv_cfg->power_gpios.label,
+                    drv_cfg->power_gpios.pin, rc);
+            return rc;
+        }
+    }
+
+    drv_data->as = (struct adc_sequence){
+        .channels = BIT(0),
+        .buffer = &drv_data->adc_raw,
+        .buffer_size = sizeof(drv_data->adc_raw),
+        .oversampling = 4,
+        .calibrate = true,
+    };
+
+#ifdef CONFIG_ADC_NRFX_SAADC
+    drv_data->acc = (struct adc_channel_cfg){
+        .gain = ADC_GAIN_1_5,
+        .reference = ADC_REF_INTERNAL,
+        .acquisition_time = ADC_ACQ_TIME(ADC_ACQ_TIME_MICROSECONDS, 40),
+        .input_positive = SAADC_CH_PSELP_PSELP_AnalogInput0 + drv_cfg->io_channel.channel,
+    };
+
+    drv_data->as.resolution = 12;
+#else
+#error Unsupported ADC
+#endif
+
+    rc = adc_channel_setup(drv_data->adc, &drv_data->acc);
+    LOG_DBG("AIN%u setup returned %d", drv_cfg->io_channel.channel, rc);
+
+    return rc;
+}
+
+static struct bvd_data bvd_data;
+static const struct bvd_config bvd_cfg = {
+    .io_channel =
+        {
+            DT_INST_IO_CHANNELS_LABEL(0),
+            DT_INST_IO_CHANNELS_INPUT(0),
+        },
+#if DT_INST_NODE_HAS_PROP(0, power_gpios)
+    .power_gpios =
+        {
+            DT_INST_GPIO_LABEL(0, power_gpios),
+            DT_INST_PIN(0, power_gpios),
+            DT_INST_FLAGS(0, power_gpios),
+        },
+#endif
+    .output_ohm = DT_INST_PROP(0, output_ohms),
+    .full_ohm = DT_INST_PROP(0, full_ohms),
+};
+
+DEVICE_AND_API_INIT(bvd_dev, DT_INST_LABEL(0), &bvd_init, &bvd_data, &bvd_cfg, POST_KERNEL,
+                    CONFIG_SENSOR_INIT_PRIORITY, &bvd_api);
diff --git a/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml b/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml
new file mode 100644
index 0000000..3f391d7
--- /dev/null
+++ b/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml
@@ -0,0 +1,14 @@
+# Copyright (c) 2020 The ZMK Contributors
+# SPDX-License-Identifier: MIT
+
+description: Battery SoC monitoring using voltage divider
+
+compatible: "zmk,battery-voltage-divider"
+
+include: voltage-divider.yaml
+
+properties:
+  label:
+    required: true
+    type: string
+  
\ No newline at end of file
diff --git a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml b/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml
new file mode 100644
index 0000000..a2d8d24
--- /dev/null
+++ b/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml
@@ -0,0 +1,22 @@
+# Copyright (c) 2020, The ZMK Contributors
+# SPDX-License-Identifier: MIT
+
+description: GPIO keyboard demux controller
+
+compatible: "zmk,kscan-gpio-demux"
+
+include: kscan.yaml
+
+properties:
+  input-gpios:
+    type: phandle-array
+    required: true
+  output-gpios:
+    type: phandle-array
+    required: true
+  debounce-period:
+    type: int
+    default: 5
+  polling-interval-msec:
+    type: int
+    default: 25
diff --git a/app/drivers/zephyr/kscan_gpio_demux.c b/app/drivers/zephyr/kscan_gpio_demux.c
new file mode 100644
index 0000000..6113d7c
--- /dev/null
+++ b/app/drivers/zephyr/kscan_gpio_demux.c
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#define DT_DRV_COMPAT zmk_kscan_gpio_demux
+
+#include <device.h>
+#include <drivers/kscan.h>
+#include <drivers/gpio.h>
+#include <logging/log.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
+
+struct kscan_gpio_item_config {
+    char *label;
+    gpio_pin_t pin;
+    gpio_flags_t flags;
+};
+
+// Helper macro
+#define PWR_TWO(x) (1 << (x))
+
+// Define GPIO cfg
+#define _KSCAN_GPIO_ITEM_CFG_INIT(n, prop, idx)                                                    \
+    {                                                                                              \
+        .label = DT_INST_GPIO_LABEL_BY_IDX(n, prop, idx),                                          \
+        .pin = DT_INST_GPIO_PIN_BY_IDX(n, prop, idx),                                              \
+        .flags = DT_INST_GPIO_FLAGS_BY_IDX(n, prop, idx),                                          \
+    },
+
+// Define row and col cfg
+#define _KSCAN_GPIO_INPUT_CFG_INIT(idx, n) _KSCAN_GPIO_ITEM_CFG_INIT(n, input_gpios, idx)
+#define _KSCAN_GPIO_OUTPUT_CFG_INIT(idx, n) _KSCAN_GPIO_ITEM_CFG_INIT(n, output_gpios, idx)
+
+// Check debounce config
+#define CHECK_DEBOUNCE_CFG(n, a, b) COND_CODE_0(DT_INST_PROP(n, debounce_period), a, b)
+
+// Define the row and column lengths
+#define INST_MATRIX_INPUTS(n) DT_INST_PROP_LEN(n, input_gpios)
+#define INST_DEMUX_GPIOS(n) DT_INST_PROP_LEN(n, output_gpios)
+#define INST_MATRIX_OUTPUTS(n) PWR_TWO(INST_DEMUX_GPIOS(n))
+#define POLL_INTERVAL(n) DT_INST_PROP(n, polling_interval_msec)
+
+#define GPIO_INST_INIT(n)                                                                          \
+    struct kscan_gpio_irq_callback_##n {                                                           \
+        struct CHECK_DEBOUNCE_CFG(n, (k_work), (k_delayed_work)) * work;                           \
+        struct gpio_callback callback;                                                             \
+        struct device *dev;                                                                        \
+    };                                                                                             \
+                                                                                                   \
+    struct kscan_gpio_config_##n {                                                                 \
+        struct kscan_gpio_item_config rows[INST_MATRIX_INPUTS(n)];                                 \
+        struct kscan_gpio_item_config cols[INST_DEMUX_GPIOS(n)];                                   \
+    };                                                                                             \
+                                                                                                   \
+    struct kscan_gpio_data_##n {                                                                   \
+        kscan_callback_t callback;                                                                 \
+        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;                                                                        \
+    };                                                                                             \
+    /* IO/GPIO SETUP */                                                                            \
+    /* gpio_input_devices are PHYSICAL IO devices */                                               \
+    static struct device **kscan_gpio_input_devices_##n(struct device *dev) {                      \
+        struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
+        return data->rows;                                                                         \
+    }                                                                                              \
+                                                                                                   \
+    static const struct kscan_gpio_item_config *kscan_gpio_input_configs_##n(struct device *dev) { \
+        const struct kscan_gpio_config_##n *cfg = dev->config_info;                                \
+        return cfg->rows;                                                                          \
+    }                                                                                              \
+                                                                                                   \
+    /* gpio_output_devices are PHYSICAL IO devices */                                              \
+    static struct device **kscan_gpio_output_devices_##n(struct device *dev) {                     \
+        struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
+        return data->cols;                                                                         \
+    }                                                                                              \
+                                                                                                   \
+    static const struct kscan_gpio_item_config *kscan_gpio_output_configs_##n(                     \
+        struct device *dev) {                                                                      \
+        const struct kscan_gpio_config_##n *cfg = dev->config_info;                                \
+        /* If row2col, rows = outputs & cols = inputs */                                           \
+        return cfg->cols;                                                                          \
+    }                                                                                              \
+    /* POLLING SETUP */                                                                            \
+    static void kscan_gpio_timer_handler(struct k_timer *timer) {                                  \
+        struct kscan_gpio_data_##n *data =                                                         \
+            CONTAINER_OF(timer, struct kscan_gpio_data_##n, poll_timer);                           \
+        k_work_submit(&data->work.work);                                                           \
+    }                                                                                              \
+                                                                                                   \
+    /* Read the state of the input GPIOs */                                                        \
+    /* This is the core matrix_scan func */                                                        \
+    static int kscan_gpio_read_##n(struct device *dev) {                                           \
+        bool submit_follow_up_read = false;                                                        \
+        struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
+        static bool read_state[INST_MATRIX_INPUTS(n)][INST_MATRIX_OUTPUTS(n)];                     \
+        for (int o = 0; o < INST_MATRIX_OUTPUTS(n); o++) {                                         \
+            /* Iterate over bits and set GPIOs accordingly */                                      \
+            for (u8_t bit = 0; bit < INST_DEMUX_GPIOS(n); bit++) {                                 \
+                u8_t state = (o & (0b1 << bit)) >> bit;                                            \
+                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);                                        \
+            }                                                                                      \
+                                                                                                   \
+            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];                      \
+                /* Get the input device config (pin) */                                            \
+                const struct kscan_gpio_item_config *in_cfg =                                      \
+                    &kscan_gpio_input_configs_##n(dev)[i];                                         \
+                read_state[i][o] = gpio_pin_get(in_dev, in_cfg->pin) > 0;                          \
+            }                                                                                      \
+        }                                                                                          \
+        for (int r = 0; r < INST_MATRIX_INPUTS(n); r++) {                                          \
+            for (int c = 0; c < INST_MATRIX_OUTPUTS(n); c++) {                                     \
+                bool pressed = read_state[r][c];                                                   \
+                submit_follow_up_read = (submit_follow_up_read || pressed);                        \
+                if (pressed != data->matrix_state[r][c]) {                                         \
+                    LOG_DBG("Sending event at %d,%d state %s", r, c, (pressed ? "on" : "off"));    \
+                    data->matrix_state[r][c] = pressed;                                            \
+                    data->callback(dev, r, c, pressed);                                            \
+                }                                                                                  \
+            }                                                                                      \
+        }                                                                                          \
+        if (submit_follow_up_read) {                                                               \
+            CHECK_DEBOUNCE_CFG(n, ({ k_work_submit(&data->work); }), ({                            \
+                                   k_delayed_work_cancel(&data->work);                             \
+                                   k_delayed_work_submit(&data->work, K_MSEC(5));                  \
+                               }))                                                                 \
+        }                                                                                          \
+        return 0;                                                                                  \
+    }                                                                                              \
+                                                                                                   \
+    static void kscan_gpio_work_handler_##n(struct k_work *work) {                                 \
+        struct kscan_gpio_data_##n *data = CONTAINER_OF(work, struct kscan_gpio_data_##n, work);   \
+        kscan_gpio_read_##n(data->dev);                                                            \
+    }                                                                                              \
+                                                                                                   \
+    static struct kscan_gpio_data_##n kscan_gpio_data_##n = {                                      \
+        .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) {           \
+        LOG_DBG("KSCAN API configure");                                                            \
+        struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
+        if (!callback) {                                                                           \
+            return -EINVAL;                                                                        \
+        }                                                                                          \
+        data->callback = callback;                                                                 \
+        LOG_DBG("Configured GPIO %d", n);                                                          \
+        return 0;                                                                                  \
+    };                                                                                             \
+                                                                                                   \
+    /* KSCAN API enable function */                                                                \
+    static int kscan_gpio_enable_##n(struct device *dev) {                                         \
+        LOG_DBG("KSCAN API enable");                                                               \
+        struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
+        /* TODO: we might want a follow up to hook into the sleep state hooks in Zephyr, */        \
+        /* and disable this timer when we enter a sleep state */                                   \
+        k_timer_start(&data->poll_timer, K_MSEC(POLL_INTERVAL(n)), K_MSEC(POLL_INTERVAL(n)));      \
+        return 0;                                                                                  \
+    };                                                                                             \
+                                                                                                   \
+    /* KSCAN API disable function */                                                               \
+    static int kscan_gpio_disable_##n(struct device *dev) {                                        \
+        LOG_DBG("KSCAN API disable");                                                              \
+        struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
+        k_timer_stop(&data->poll_timer);                                                           \
+        return 0;                                                                                  \
+    };                                                                                             \
+                                                                                                   \
+    /* GPIO init function*/                                                                        \
+    static int kscan_gpio_init_##n(struct device *dev) {                                           \
+        LOG_DBG("KSCAN GPIO init");                                                                \
+        struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
+        int err;                                                                                   \
+        /* configure input devices*/                                                               \
+        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);                                  \
+            if (!input_devices[i]) {                                                               \
+                LOG_ERR("Unable to find input GPIO device");                                       \
+                return -EINVAL;                                                                    \
+            }                                                                                      \
+            err = gpio_pin_configure(input_devices[i], in_cfg->pin, GPIO_INPUT | in_cfg->flags);   \
+            if (err) {                                                                             \
+                LOG_ERR("Unable to configure pin %d on %s for input", in_cfg->pin, in_cfg->label); \
+                return err;                                                                        \
+            } else {                                                                               \
+                LOG_DBG("Configured pin %d on %s for input", in_cfg->pin, in_cfg->label);          \
+            }                                                                                      \
+            if (err) {                                                                             \
+                LOG_ERR("Error adding the callback to the column device");                         \
+                return err;                                                                        \
+            }                                                                                      \
+        }                                                                                          \
+        /* configure output devices*/                                                              \
+        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);                                \
+            if (!output_devices[o]) {                                                              \
+                LOG_ERR("Unable to find output GPIO device");                                      \
+                return -EINVAL;                                                                    \
+            }                                                                                      \
+            err = gpio_pin_configure(output_devices[o], out_cfg->pin,                              \
+                                     GPIO_OUTPUT_ACTIVE | out_cfg->flags);                         \
+            if (err) {                                                                             \
+                LOG_ERR("Unable to configure pin %d on %s for output", out_cfg->pin,               \
+                        out_cfg->label);                                                           \
+                return err;                                                                        \
+            } else {                                                                               \
+                LOG_DBG("Configured pin %d on %s for output", out_cfg->pin, out_cfg->label);       \
+            }                                                                                      \
+        }                                                                                          \
+        data->dev = dev;                                                                           \
+                                                                                                   \
+        k_timer_init(&data->poll_timer, kscan_gpio_timer_handler, NULL);                           \
+                                                                                                   \
+        (CHECK_DEBOUNCE_CFG(n, (k_work_init), (k_delayed_work_init)))(                             \
+            &data->work, kscan_gpio_work_handler_##n);                                             \
+        return 0;                                                                                  \
+    }                                                                                              \
+                                                                                                   \
+    static const struct kscan_driver_api gpio_driver_api_##n = {                                   \
+        .config = kscan_gpio_configure_##n,                                                        \
+        .enable_callback = kscan_gpio_enable_##n,                                                  \
+        .disable_callback = kscan_gpio_disable_##n,                                                \
+    };                                                                                             \
+                                                                                                   \
+    static const struct kscan_gpio_config_##n kscan_gpio_config_##n = {                            \
+        .rows = {UTIL_LISTIFY(INST_MATRIX_INPUTS(n), _KSCAN_GPIO_INPUT_CFG_INIT, n)},              \
+        .cols = {UTIL_LISTIFY(INST_DEMUX_GPIOS(n), _KSCAN_GPIO_OUTPUT_CFG_INIT, n)},               \
+    };                                                                                             \
+                                                                                                   \
+    DEVICE_AND_API_INIT(kscan_gpio_##n, DT_INST_LABEL(n), kscan_gpio_init_##n,                     \
+                        &kscan_gpio_data_##n, &kscan_gpio_config_##n, APPLICATION,                 \
+                        CONFIG_APPLICATION_INIT_PRIORITY, &gpio_driver_api_##n);
+
+DT_INST_FOREACH_STATUS_OKAY(GPIO_INST_INIT)
+
+#endif /* DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) */
diff --git a/app/drivers/zephyr/kscan_gpio_matrix.c b/app/drivers/zephyr/kscan_gpio_matrix.c
index a0b22e4..ec4fb39 100644
--- a/app/drivers/zephyr/kscan_gpio_matrix.c
+++ b/app/drivers/zephyr/kscan_gpio_matrix.c
@@ -181,19 +181,18 @@ 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);                                                            \
     }                                                                                              \
-    COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                               \
-                (static void kscan_gpio_irq_callback_handler_##n(                                  \
-                    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);            \
-                    kscan_gpio_disable_interrupts_##n(data->dev);                                  \
-                    COND_CODE_0(DT_INST_PROP(n, debounce_period),                                  \
-                                ({ k_work_submit(data->work); }), ({                               \
-                                    k_delayed_work_cancel(data->work);                             \
-                                    k_delayed_work_submit(                                         \
-                                        data->work, K_MSEC(DT_INST_PROP(n, debounce_period)));     \
-                                }))                                                                \
-                }))                                                                                \
+    static void kscan_gpio_irq_callback_handler_##n(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, (),                                           \
+                    (kscan_gpio_disable_interrupts_##n(data->dev);))                               \
+        COND_CODE_0(DT_INST_PROP(n, debounce_period), ({ k_work_submit(data->work); }), ({         \
+                        k_delayed_work_cancel(data->work);                                         \
+                        k_delayed_work_submit(data->work,                                          \
+                                              K_MSEC(DT_INST_PROP(n, debounce_period)));           \
+                    }))                                                                            \
+    }                                                                                              \
                                                                                                    \
     static struct kscan_gpio_data_##n kscan_gpio_data_##n = {                                      \
         .rows = {[INST_MATRIX_ROWS(n) - 1] = NULL}, .cols = {[INST_MATRIX_COLS(n) - 1] = NULL}};   \