refactor: Align drivers with Zephyr file system conventions

PR: #400

15 files changed, 2 insertions, 1461 deletions

diff --git a/app/drivers/zephyr/CMakeLists.txt b/app/drivers/zephyr/CMakeLists.txt
deleted file mode 100644
index e3a192d..0000000
--- a/app/drivers/zephyr/CMakeLists.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-if(CONFIG_ZMK_KSCAN_GPIO_DRIVER)
-  zephyr_include_directories(.)
-
-  zephyr_library()
-  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
deleted file mode 100644
index b8b2b1b..0000000
--- a/app/drivers/zephyr/Kconfig
+++ /dev/null
@@ -1,79 +0,0 @@
-# Copyright (c) 2020 The ZMK Contributors
-# SPDX-License-Identifier: MIT
-
-config ZMK_KSCAN_GPIO_DRIVER
-	bool "Enable GPIO kscan driver to simulate key presses"
-	default y
-	select GPIO
-
-if ZMK_KSCAN_GPIO_DRIVER
-
-config ZMK_KSCAN_MATRIX_POLLING
-	bool "Poll for key event triggers instead of using interrupts on matrix boards."
-	default n
-
-config ZMK_KSCAN_DIRECT_POLLING
-	bool "Poll for key event triggers instead of using interrupts on direct wired boards."
-    default n
-
-endif
-
-config ZMK_KSCAN_INIT_PRIORITY
-	int "Keyboard scan driver init priority"
-	default 40
-	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
-	help
-	  Enable driver for EC11 incremental encoder sensors.
-
-if EC11
-
-choice
-	prompt "Trigger mode"
-	default EC11_TRIGGER_NONE
-	help
-	  Specify the type of triggering to be used by the driver.
-
-config EC11_TRIGGER_NONE
-	bool "No trigger"
-
-config EC11_TRIGGER_GLOBAL_THREAD
-	bool "Use global thread"
-	depends on GPIO
-	select EC11_TRIGGER
-
-config EC11_TRIGGER_OWN_THREAD
-	bool "Use own thread"
-	depends on GPIO
-	select EC11_TRIGGER
-
-endchoice
-
-config EC11_TRIGGER
-	bool
-
-config EC11_THREAD_PRIORITY
-	int "Thread priority"
-	depends on EC11_TRIGGER_OWN_THREAD
-	default 10
-	help
-	  Priority of thread used by the driver to handle interrupts.
-
-config EC11_THREAD_STACK_SIZE
-	int "Thread stack size"
-	depends on EC11_TRIGGER_OWN_THREAD
-	default 1024
-	help
-	  Stack size of thread used by the driver to handle interrupts.
-
-endif # EC11
diff --git a/app/drivers/zephyr/battery_voltage_divider.c b/app/drivers/zephyr/battery_voltage_divider.c
deleted file mode 100644
index d634dfd..0000000
--- a/app/drivers/zephyr/battery_voltage_divider.c
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * 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 &&
-        chan != SENSOR_CHAN_ALL) {
-        LOG_DBG("Selected channel is not supported: %d.", chan);
-        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_GPIO_PIN(0, power_gpios),
-            DT_INST_GPIO_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,kscan-gpio-demux.yaml b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-demux.yaml
index a2d8d24..a2d8d24 100644
--- a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml
+++ b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-demux.yaml
diff --git a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-direct.yaml b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-direct.yaml
index 09a9b6c..09a9b6c 100644
--- a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-direct.yaml
+++ b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-direct.yaml
diff --git a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-matrix.yaml b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-matrix.yaml
index 5ebcbdd..5ebcbdd 100644
--- a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-matrix.yaml
+++ b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-matrix.yaml
diff --git a/app/drivers/zephyr/dts/bindings/alps,ec11.yaml b/app/drivers/zephyr/dts/bindings/sensor/alps,ec11.yaml
index 5cbe77a..5cbe77a 100644
--- a/app/drivers/zephyr/dts/bindings/alps,ec11.yaml
+++ b/app/drivers/zephyr/dts/bindings/sensor/alps,ec11.yaml
diff --git a/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml b/app/drivers/zephyr/dts/bindings/sensor/zmk,battery-voltage-divider.yaml
index 3f391d7..3f391d7 100644
--- a/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml
+++ b/app/drivers/zephyr/dts/bindings/sensor/zmk,battery-voltage-divider.yaml
diff --git a/app/drivers/zephyr/ec11.c b/app/drivers/zephyr/ec11.c
deleted file mode 100644
index 00d0090..0000000
--- a/app/drivers/zephyr/ec11.c
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * Copyright (c) 2020 The ZMK Contributors
- *
- * SPDX-License-Identifier: MIT
- */
-
-#define DT_DRV_COMPAT alps_ec11
-
-#include <device.h>
-#include <drivers/gpio.h>
-#include <sys/util.h>
-#include <kernel.h>
-#include <drivers/sensor.h>
-#include <sys/__assert.h>
-#include <logging/log.h>
-
-#include "ec11.h"
-
-LOG_MODULE_REGISTER(EC11, CONFIG_SENSOR_LOG_LEVEL);
-
-static int ec11_get_ab_state(struct device *dev) {
-    struct ec11_data *drv_data = dev->driver_data;
-    const struct ec11_config *drv_cfg = dev->config_info;
-
-    return (gpio_pin_get(drv_data->a, drv_cfg->a_pin) << 1) |
-           gpio_pin_get(drv_data->b, drv_cfg->b_pin);
-}
-
-static int ec11_sample_fetch(struct device *dev, enum sensor_channel chan) {
-    struct ec11_data *drv_data = dev->driver_data;
-    const struct ec11_config *drv_cfg = dev->config_info;
-    u8_t val;
-    s8_t delta;
-
-    __ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_ROTATION);
-
-    val = ec11_get_ab_state(dev);
-
-    LOG_DBG("prev: %d, new: %d", drv_data->ab_state, val);
-
-    switch (val | (drv_data->ab_state << 2)) {
-    case 0b0010:
-    case 0b0100:
-    case 0b1101:
-    case 0b1011:
-        delta = -1;
-        break;
-    case 0b0001:
-    case 0b0111:
-    case 0b1110:
-    case 0b1000:
-        delta = 1;
-        break;
-    default:
-        delta = 0;
-        break;
-    }
-
-    LOG_DBG("Delta: %d", delta);
-
-    drv_data->pulses += delta;
-    drv_data->ab_state = val;
-
-    drv_data->ticks = drv_data->pulses / drv_cfg->resolution;
-    drv_data->delta = delta;
-    drv_data->pulses %= drv_cfg->resolution;
-
-    return 0;
-}
-
-static int ec11_channel_get(struct device *dev, enum sensor_channel chan,
-                            struct sensor_value *val) {
-    struct ec11_data *drv_data = dev->driver_data;
-
-    if (chan != SENSOR_CHAN_ROTATION) {
-        return -ENOTSUP;
-    }
-
-    val->val1 = drv_data->ticks;
-    val->val2 = drv_data->delta;
-
-    return 0;
-}
-
-static const struct sensor_driver_api ec11_driver_api = {
-#ifdef CONFIG_EC11_TRIGGER
-    .trigger_set = ec11_trigger_set,
-#endif
-    .sample_fetch = ec11_sample_fetch,
-    .channel_get = ec11_channel_get,
-};
-
-int ec11_init(struct device *dev) {
-    struct ec11_data *drv_data = dev->driver_data;
-    const struct ec11_config *drv_cfg = dev->config_info;
-
-    LOG_DBG("A: %s %d B: %s %d resolution %d", drv_cfg->a_label, drv_cfg->a_pin, drv_cfg->b_label,
-            drv_cfg->b_pin, drv_cfg->resolution);
-
-    drv_data->a = device_get_binding(drv_cfg->a_label);
-    if (drv_data->a == NULL) {
-        LOG_ERR("Failed to get pointer to A GPIO device");
-        return -EINVAL;
-    }
-
-    drv_data->b = device_get_binding(drv_cfg->b_label);
-    if (drv_data->b == NULL) {
-        LOG_ERR("Failed to get pointer to B GPIO device");
-        return -EINVAL;
-    }
-
-    if (gpio_pin_configure(drv_data->a, drv_cfg->a_pin, drv_cfg->a_flags | GPIO_INPUT)) {
-        LOG_DBG("Failed to configure A pin");
-        return -EIO;
-    }
-
-    if (gpio_pin_configure(drv_data->b, drv_cfg->b_pin, drv_cfg->b_flags | GPIO_INPUT)) {
-        LOG_DBG("Failed to configure B pin");
-        return -EIO;
-    }
-
-#ifdef CONFIG_EC11_TRIGGER
-    if (ec11_init_interrupt(dev) < 0) {
-        LOG_DBG("Failed to initialize interrupt!");
-        return -EIO;
-    }
-#endif
-
-    drv_data->ab_state = ec11_get_ab_state(dev);
-
-    return 0;
-}
-
-#define EC11_INST(n)                                                                               \
-    struct ec11_data ec11_data_##n;                                                                \
-    const struct ec11_config ec11_cfg_##n = {                                                      \
-        .a_label = DT_INST_GPIO_LABEL(n, a_gpios),                                                 \
-        .a_pin = DT_INST_GPIO_PIN(n, a_gpios),                                                     \
-        .a_flags = DT_INST_GPIO_FLAGS(n, a_gpios),                                                 \
-        .b_label = DT_INST_GPIO_LABEL(n, b_gpios),                                                 \
-        .b_pin = DT_INST_GPIO_PIN(n, b_gpios),                                                     \
-        .b_flags = DT_INST_GPIO_FLAGS(n, b_gpios),                                                 \
-        COND_CODE_0(DT_INST_NODE_HAS_PROP(n, resolution), (1), (DT_INST_PROP(n, resolution))),     \
-    };                                                                                             \
-    DEVICE_AND_API_INIT(ec11_##n, DT_INST_LABEL(n), ec11_init, &ec11_data_##n, &ec11_cfg_##n,      \
-                        POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &ec11_driver_api);
-
-DT_INST_FOREACH_STATUS_OKAY(EC11_INST)
\ No newline at end of file
diff --git a/app/drivers/zephyr/ec11.h b/app/drivers/zephyr/ec11.h
deleted file mode 100644
index e62e733..0000000
--- a/app/drivers/zephyr/ec11.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2020 The ZMK Contributors
- *
- * SPDX-License-Identifier: MIT
- */
-
-#pragma once
-
-#include <device.h>
-#include <drivers/gpio.h>
-#include <sys/util.h>
-
-struct ec11_config {
-    const char *a_label;
-    const u8_t a_pin;
-    const u8_t a_flags;
-
-    const char *b_label;
-    const u8_t b_pin;
-    const u8_t b_flags;
-
-    const u8_t resolution;
-};
-
-struct ec11_data {
-    struct device *a;
-    struct device *b;
-    u8_t ab_state;
-    s8_t pulses;
-    s8_t ticks;
-    s8_t delta;
-
-#ifdef CONFIG_EC11_TRIGGER
-    struct gpio_callback a_gpio_cb;
-    struct gpio_callback b_gpio_cb;
-    struct device *dev;
-
-    sensor_trigger_handler_t handler;
-    const struct sensor_trigger *trigger;
-
-#if defined(CONFIG_EC11_TRIGGER_OWN_THREAD)
-    K_THREAD_STACK_MEMBER(thread_stack, CONFIG_EC11_THREAD_STACK_SIZE);
-    struct k_sem gpio_sem;
-    struct k_thread thread;
-#elif defined(CONFIG_EC11_TRIGGER_GLOBAL_THREAD)
-    struct k_work work;
-#endif
-
-#endif /* CONFIG_EC11_TRIGGER */
-};
-
-#ifdef CONFIG_EC11_TRIGGER
-
-int ec11_trigger_set(struct device *dev, const struct sensor_trigger *trig,
-                     sensor_trigger_handler_t handler);
-
-int ec11_init_interrupt(struct device *dev);
-#endif
diff --git a/app/drivers/zephyr/ec11_trigger.c b/app/drivers/zephyr/ec11_trigger.c
deleted file mode 100644
index 248ac32..0000000
--- a/app/drivers/zephyr/ec11_trigger.c
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * Copyright (c) 2020 The ZMK Contributors
- *
- * SPDX-License-Identifier: MIT
- */
-
-#define DT_DRV_COMPAT alps_ec11
-
-#include <device.h>
-#include <drivers/gpio.h>
-#include <sys/util.h>
-#include <kernel.h>
-#include <drivers/sensor.h>
-
-#include "ec11.h"
-
-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) {
-    struct ec11_data *data = dev->driver_data;
-    const struct ec11_config *cfg = dev->config_info;
-
-    LOG_DBG("enabled %s", (enable ? "true" : "false"));
-
-    if (gpio_pin_interrupt_configure(data->a, cfg->a_pin,
-                                     enable ? GPIO_INT_EDGE_BOTH : GPIO_INT_DISABLE)) {
-        LOG_WRN("Unable to set A pin GPIO interrupt");
-    }
-
-    if (gpio_pin_interrupt_configure(data->b, cfg->b_pin,
-                                     enable ? GPIO_INT_EDGE_BOTH : GPIO_INT_DISABLE)) {
-        LOG_WRN("Unable to set A pin GPIO interrupt");
-    }
-}
-
-static void ec11_a_gpio_callback(struct device *dev, struct gpio_callback *cb, u32_t pins) {
-    struct ec11_data *drv_data = CONTAINER_OF(cb, struct ec11_data, a_gpio_cb);
-
-    LOG_DBG("");
-
-    setup_int(drv_data->dev, false);
-
-#if defined(CONFIG_EC11_TRIGGER_OWN_THREAD)
-    k_sem_give(&drv_data->gpio_sem);
-#elif defined(CONFIG_EC11_TRIGGER_GLOBAL_THREAD)
-    k_work_submit(&drv_data->work);
-#endif
-}
-
-static void ec11_b_gpio_callback(struct device *dev, struct gpio_callback *cb, u32_t pins) {
-    struct ec11_data *drv_data = CONTAINER_OF(cb, struct ec11_data, b_gpio_cb);
-
-    LOG_DBG("");
-
-    setup_int(drv_data->dev, false);
-
-#if defined(CONFIG_EC11_TRIGGER_OWN_THREAD)
-    k_sem_give(&drv_data->gpio_sem);
-#elif defined(CONFIG_EC11_TRIGGER_GLOBAL_THREAD)
-    k_work_submit(&drv_data->work);
-#endif
-}
-
-static void ec11_thread_cb(void *arg) {
-    struct device *dev = arg;
-    struct ec11_data *drv_data = dev->driver_data;
-
-    drv_data->handler(dev, drv_data->trigger);
-
-    setup_int(dev, true);
-}
-
-#ifdef CONFIG_EC11_TRIGGER_OWN_THREAD
-static void ec11_thread(int dev_ptr, int unused) {
-    struct device *dev = INT_TO_POINTER(dev_ptr);
-    struct ec11_data *drv_data = dev->driver_data;
-
-    ARG_UNUSED(unused);
-
-    while (1) {
-        k_sem_take(&drv_data->gpio_sem, K_FOREVER);
-        ec11_thread_cb(dev);
-    }
-}
-#endif
-
-#ifdef CONFIG_EC11_TRIGGER_GLOBAL_THREAD
-static void ec11_work_cb(struct k_work *work) {
-    struct ec11_data *drv_data = CONTAINER_OF(work, struct ec11_data, work);
-
-    LOG_DBG("");
-
-    ec11_thread_cb(drv_data->dev);
-}
-#endif
-
-int ec11_trigger_set(struct device *dev, const struct sensor_trigger *trig,
-                     sensor_trigger_handler_t handler) {
-    struct ec11_data *drv_data = dev->driver_data;
-
-    setup_int(dev, false);
-
-    k_msleep(5);
-
-    drv_data->trigger = trig;
-    drv_data->handler = handler;
-
-    setup_int(dev, true);
-
-    return 0;
-}
-
-int ec11_init_interrupt(struct device *dev) {
-    struct ec11_data *drv_data = dev->driver_data;
-    const struct ec11_config *drv_cfg = dev->config_info;
-
-    drv_data->dev = dev;
-    /* setup gpio interrupt */
-
-    gpio_init_callback(&drv_data->a_gpio_cb, ec11_a_gpio_callback, BIT(drv_cfg->a_pin));
-
-    if (gpio_add_callback(drv_data->a, &drv_data->a_gpio_cb) < 0) {
-        LOG_DBG("Failed to set A callback!");
-        return -EIO;
-    }
-
-    gpio_init_callback(&drv_data->b_gpio_cb, ec11_b_gpio_callback, BIT(drv_cfg->b_pin));
-
-    if (gpio_add_callback(drv_data->b, &drv_data->b_gpio_cb) < 0) {
-        LOG_DBG("Failed to set B callback!");
-        return -EIO;
-    }
-
-#if defined(CONFIG_EC11_TRIGGER_OWN_THREAD)
-    k_sem_init(&drv_data->gpio_sem, 0, UINT_MAX);
-
-    k_thread_create(&drv_data->thread, drv_data->thread_stack, CONFIG_EC11_THREAD_STACK_SIZE,
-                    (k_thread_entry_t)ec11_thread, dev, 0, NULL,
-                    K_PRIO_COOP(CONFIG_EC11_THREAD_PRIORITY), 0, K_NO_WAIT);
-#elif defined(CONFIG_EC11_TRIGGER_GLOBAL_THREAD)
-    k_work_init(&drv_data->work, ec11_work_cb);
-#endif
-
-    return 0;
-}
diff --git a/app/drivers/zephyr/kscan_gpio_demux.c b/app/drivers/zephyr/kscan_gpio_demux.c
deleted file mode 100644
index 6113d7c..0000000
--- a/app/drivers/zephyr/kscan_gpio_demux.c
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
- * 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_direct.c b/app/drivers/zephyr/kscan_gpio_direct.c
deleted file mode 100644
index 8327161..0000000
--- a/app/drivers/zephyr/kscan_gpio_direct.c
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
- * Copyright (c) 2020 The ZMK Contributors
- *
- * SPDX-License-Identifier: MIT
- */
-
-#define DT_DRV_COMPAT zmk_kscan_gpio_direct
-
-#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;
-};
-
-union work_reference {
-    struct k_delayed_work delayed;
-    struct k_work direct;
-};
-
-struct kscan_gpio_config {
-    u8_t num_of_inputs;
-    u8_t debounce_period;
-    struct kscan_gpio_item_config inputs[];
-};
-
-struct kscan_gpio_data {
-#if defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING)
-    struct k_timer poll_timer;
-#endif /* defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */
-    kscan_callback_t callback;
-    union work_reference work;
-    struct device *dev;
-    u32_t pin_state;
-    struct device *inputs[];
-};
-
-static struct device **kscan_gpio_input_devices(struct device *dev) {
-    struct kscan_gpio_data *data = dev->driver_data;
-    return data->inputs;
-}
-
-static const struct kscan_gpio_item_config *kscan_gpio_input_configs(struct device *dev) {
-    const struct kscan_gpio_config *cfg = dev->config_info;
-    return cfg->inputs;
-}
-
-static void kscan_gpio_direct_queue_read(union work_reference *work, u8_t debounce_period) {
-    if (debounce_period > 0) {
-        k_delayed_work_cancel(&work->delayed);
-        k_delayed_work_submit(&work->delayed, K_MSEC(debounce_period));
-    } else {
-        k_work_submit(&work->direct);
-    }
-}
-
-#if !defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING)
-
-struct kscan_gpio_irq_callback {
-    struct device *dev;
-    union work_reference *work;
-    u8_t debounce_period;
-    struct gpio_callback callback;
-};
-
-static int kscan_gpio_config_interrupts(struct device *dev, gpio_flags_t flags) {
-    const struct kscan_gpio_config *cfg = dev->config_info;
-    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 kscan_gpio_item_config *cfg = &configs[i];
-
-        int err = gpio_pin_interrupt_configure(dev, cfg->pin, flags);
-
-        if (err) {
-            LOG_ERR("Unable to enable matrix GPIO interrupt");
-            return err;
-        }
-    }
-
-    return 0;
-}
-
-static int kscan_gpio_direct_enable(struct device *dev) {
-    return kscan_gpio_config_interrupts(dev, GPIO_INT_LEVEL_ACTIVE);
-}
-static int kscan_gpio_direct_disable(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,
-                                            gpio_port_pins_t pin) {
-    struct kscan_gpio_irq_callback *data =
-        CONTAINER_OF(cb, struct kscan_gpio_irq_callback, callback);
-
-    kscan_gpio_direct_disable(data->dev);
-    kscan_gpio_direct_queue_read(data->work, data->debounce_period);
-}
-
-#else /* !defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */
-
-static void kscan_gpio_timer_handler(struct k_timer *timer) {
-    struct kscan_gpio_data *data = CONTAINER_OF(timer, struct kscan_gpio_data, poll_timer);
-
-    kscan_gpio_direct_queue_read(&data->work, 0);
-}
-
-static int kscan_gpio_direct_enable(struct device *dev) {
-    struct kscan_gpio_data *data = dev->driver_data;
-    k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10));
-    return 0;
-}
-static int kscan_gpio_direct_disable(struct device *dev) {
-    struct kscan_gpio_data *data = dev->driver_data;
-    k_timer_stop(&data->poll_timer);
-    return 0;
-}
-
-#endif /* defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING) */
-
-static int kscan_gpio_direct_configure(struct device *dev, kscan_callback_t callback) {
-    struct kscan_gpio_data *data = dev->driver_data;
-    if (!callback) {
-        return -EINVAL;
-    }
-    data->callback = callback;
-    return 0;
-}
-
-static int kscan_gpio_read(struct device *dev) {
-    struct kscan_gpio_data *data = dev->driver_data;
-    const struct kscan_gpio_config *cfg = dev->config_info;
-    u32_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 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);
-    }
-    for (int i = 0; i < cfg->num_of_inputs; i++) {
-        bool prev_pressed = BIT(i) & data->pin_state;
-        bool pressed = (BIT(i) & read_state) != 0;
-        submit_follow_up_read = (submit_follow_up_read || pressed);
-        if (pressed != prev_pressed) {
-            LOG_DBG("Sending event at %d,%d state %s", 0, i, (pressed ? "on" : "off"));
-            WRITE_BIT(data->pin_state, i, pressed);
-            data->callback(dev, 0, i, pressed);
-        }
-    }
-
-#if !defined(CONFIG_ZMK_KSCAN_DIRECT_POLLING)
-    if (submit_follow_up_read) {
-        kscan_gpio_direct_queue_read(&data->work, cfg->debounce_period);
-    } else {
-        kscan_gpio_direct_enable(dev);
-    }
-#endif
-
-    return 0;
-}
-
-static void kscan_gpio_work_handler(struct k_work *work) {
-    struct kscan_gpio_data *data = CONTAINER_OF(work, struct kscan_gpio_data, work);
-    kscan_gpio_read(data->dev);
-}
-
-static const struct kscan_driver_api gpio_driver_api = {
-    .config = kscan_gpio_direct_configure,
-    .enable_callback = kscan_gpio_direct_enable,
-    .disable_callback = kscan_gpio_direct_disable,
-};
-
-#define KSCAN_DIRECT_INPUT_ITEM(i, n)                                                              \
-    {                                                                                              \
-        .label = DT_INST_GPIO_LABEL_BY_IDX(n, input_gpios, i),                                     \
-        .pin = DT_INST_GPIO_PIN_BY_IDX(n, input_gpios, i),                                         \
-        .flags = DT_INST_GPIO_FLAGS_BY_IDX(n, input_gpios, i),                                     \
-    },
-
-#define INST_INPUT_LEN(n) DT_INST_PROP_LEN(n, input_gpios)
-
-#define GPIO_INST_INIT(n)                                                                          \
-    COND_CODE_0(IS_ENABLED(CONFIG_ZMK_KSCAN_DIRECT_POLLING),                                       \
-                (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) {                                           \
-        struct kscan_gpio_data *data = dev->driver_data;                                           \
-        const struct kscan_gpio_config *cfg = dev->config_info;                                    \
-        int err;                                                                                   \
-        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);                                  \
-            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;                                                                        \
-            }                                                                                      \
-            COND_CODE_0(                                                                           \
-                IS_ENABLED(CONFIG_ZMK_KSCAN_DIRECT_POLLING),                                       \
-                (irq_callbacks_##n[i].work = &data->work; irq_callbacks_##n[i].dev = dev;          \
-                 irq_callbacks_##n[i].debounce_period = cfg->debounce_period;                      \
-                 gpio_init_callback(&irq_callbacks_##n[i].callback,                                \
-                                    kscan_gpio_irq_callback_handler, BIT(in_cfg->pin));            \
-                 err = gpio_add_callback(input_devices[i], &irq_callbacks_##n[i].callback);        \
-                 if (err) {                                                                        \
-                     LOG_ERR("Error adding the callback to the column device");                    \
-                     return err;                                                                   \
-                 }),                                                                               \
-                ())                                                                                \
-        }                                                                                          \
-        data->dev = dev;                                                                           \
-        COND_CODE_1(IS_ENABLED(CONFIG_ZMK_KSCAN_DIRECT_POLLING),                                   \
-                    (k_timer_init(&data->poll_timer, kscan_gpio_timer_handler, NULL);), ())        \
-        if (cfg->debounce_period > 0) {                                                            \
-            k_delayed_work_init(&data->work.delayed, kscan_gpio_work_handler);                     \
-        } else {                                                                                   \
-            k_work_init(&data->work.direct, kscan_gpio_work_handler);                              \
-        }                                                                                          \
-        return 0;                                                                                  \
-    }                                                                                              \
-    static const struct kscan_gpio_config kscan_gpio_config_##n = {                                \
-        .inputs = {UTIL_LISTIFY(INST_INPUT_LEN(n), KSCAN_DIRECT_INPUT_ITEM, n)},                   \
-        .num_of_inputs = INST_INPUT_LEN(n),                                                        \
-        .debounce_period = DT_INST_PROP(n, debounce_period)};                                      \
-    DEVICE_AND_API_INIT(kscan_gpio_##n, DT_INST_LABEL(n), kscan_gpio_init_##n,                     \
-                        &kscan_gpio_data_##n, &kscan_gpio_config_##n, POST_KERNEL,                 \
-                        CONFIG_ZMK_KSCAN_INIT_PRIORITY, &gpio_driver_api);
-
-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
deleted file mode 100644
index ec4fb39..0000000
--- a/app/drivers/zephyr/kscan_gpio_matrix.c
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
- * Copyright (c) 2020 The ZMK Contributors
- *
- * SPDX-License-Identifier: MIT
- */
-
-#define DT_DRV_COMPAT zmk_kscan_gpio_matrix
-
-#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;
-};
-
-#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 _KSCAN_GPIO_ROW_CFG_INIT(idx, n) _KSCAN_GPIO_ITEM_CFG_INIT(n, row_gpios, idx)
-#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,
-                                        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 kscan_gpio_item_config *cfg = &configs[i];
-
-        int err = gpio_pin_interrupt_configure(dev, cfg->pin, flags);
-
-        if (err) {
-            LOG_ERR("Unable to enable matrix GPIO interrupt");
-            return err;
-        }
-    }
-
-    return 0;
-}
-#endif
-
-#define INST_MATRIX_ROWS(n) DT_INST_PROP_LEN(n, row_gpios)
-#define INST_MATRIX_COLS(n) DT_INST_PROP_LEN(n, col_gpios)
-#define INST_OUTPUT_LEN(n)                                                                         \
-    COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (INST_MATRIX_ROWS(n)),               \
-                (INST_MATRIX_COLS(n)))
-#define INST_INPUT_LEN(n)                                                                          \
-    COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (INST_MATRIX_COLS(n)),               \
-                (INST_MATRIX_ROWS(n)))
-
-#define GPIO_INST_INIT(n)                                                                          \
-    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;                                                                        \
-    };                                                                                             \
-    static struct kscan_gpio_irq_callback_##n irq_callbacks_##n[INST_INPUT_LEN(n)];                \
-    struct kscan_gpio_config_##n {                                                                 \
-        struct kscan_gpio_item_config rows[INST_MATRIX_ROWS(n)];                                   \
-        struct kscan_gpio_item_config cols[INST_MATRIX_COLS(n)];                                   \
-    };                                                                                             \
-    struct kscan_gpio_data_##n {                                                                   \
-        kscan_callback_t callback;                                                                 \
-        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;                                                                        \
-    };                                                                                             \
-    static struct device **kscan_gpio_input_devices_##n(struct device *dev) {                      \
-        struct kscan_gpio_data_##n *data = dev->driver_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) { \
-        const struct kscan_gpio_config_##n *cfg = dev->config_info;                                \
-        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) {                     \
-        struct kscan_gpio_data_##n *data = dev->driver_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 kscan_gpio_config_##n *cfg = dev->config_info;                                \
-        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) {              \
-                        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) {           \
-                        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) {                   \
-        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 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);                           \
-            }                                                                                      \
-        }                                                                                          \
-    }                                                                                              \
-    static void kscan_gpio_set_matrix_state_##n(                                                   \
-        bool state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)], u32_t input_index,                   \
-        u32_t output_index, bool value) {                                                          \
-        state[COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (output_index),            \
-                          (input_index))]                                                          \
-             [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) {                                           \
-        bool submit_follow_up_read = false;                                                        \
-        struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
-        static bool read_state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)];                          \
-        /* Disable our interrupts temporarily while we scan, to avoid       */                     \
-        /* re-entry while we iterate columns and set them active one by one */                     \
-        /* 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 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 kscan_gpio_item_config *in_cfg =                                      \
-                    &kscan_gpio_input_configs_##n(dev)[i];                                         \
-                kscan_gpio_set_matrix_state_##n(read_state, i, o,                                  \
-                                                gpio_pin_get(in_dev, in_cfg->pin) > 0);            \
-            }                                                                                      \
-            gpio_pin_set(out_dev, out_cfg->pin, 0);                                                \
-        }                                                                                          \
-        /* Set all our outputs as active again. */                                                 \
-        kscan_gpio_set_output_state_##n(dev, 1);                                                   \
-        for (int r = 0; r < INST_MATRIX_ROWS(n); r++) {                                            \
-            for (int c = 0; c < INST_MATRIX_COLS(n); c++) {                                        \
-                bool pressed = read_state[r][c];                                                   \
-                /* Follow up reads needed because further interrupts won't fire on already tripped \
-                 * input GPIO pins */                                                              \
-                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) {                                                               \
-            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(5));                         \
-                        }))                                                                        \
-        } else {                                                                                   \
-            COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING, (),                                       \
-                        (kscan_gpio_enable_interrupts_##n(dev);))                                  \
-        }                                                                                          \
-        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 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}};   \
-    static int kscan_gpio_configure_##n(struct device *dev, kscan_callback_t callback) {           \
-        struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
-        if (!callback) {                                                                           \
-            return -EINVAL;                                                                        \
-        }                                                                                          \
-        data->callback = callback;                                                                 \
-        LOG_DBG("Configured GPIO %d", n);                                                          \
-        return 0;                                                                                  \
-    };                                                                                             \
-    static int kscan_gpio_enable_##n(struct device *dev) {                                         \
-        COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
-                    (struct kscan_gpio_data_##n *data = dev->driver_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) {                                        \
-        COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
-                    (struct kscan_gpio_data_##n *data = dev->driver_data;                          \
-                     k_timer_stop(&data->poll_timer); return 0;),                                  \
-                    (return kscan_gpio_disable_interrupts_##n(dev);))                              \
-    };                                                                                             \
-    COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                                   \
-                (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);                                               \
-                }),                                                                                \
-                ())                                                                                \
-    static int kscan_gpio_init_##n(struct device *dev) {                                           \
-        struct kscan_gpio_data_##n *data = dev->driver_data;                                       \
-        int err;                                                                                   \
-        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);                                  \
-            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);          \
-            }                                                                                      \
-            irq_callbacks_##n[i].work = &data->work;                                               \
-            irq_callbacks_##n[i].dev = dev;                                                        \
-            gpio_init_callback(&irq_callbacks_##n[i].callback,                                     \
-                               kscan_gpio_irq_callback_handler_##n, BIT(in_cfg->pin));             \
-            err = gpio_add_callback(input_devices[i], &irq_callbacks_##n[i].callback);             \
-            if (err) {                                                                             \
-                LOG_ERR("Error adding the callback to the column device");                         \
-                return err;                                                                        \
-            }                                                                                      \
-        }                                                                                          \
-        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);                                \
-            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;                                                                        \
-            }                                                                                      \
-        }                                                                                          \
-        data->dev = dev;                                                                           \
-        COND_CODE_1(CONFIG_ZMK_KSCAN_MATRIX_POLLING,                                               \
-                    (k_timer_init(&data->poll_timer, kscan_gpio_timer_handler, NULL);), ())        \
-        (COND_CODE_0(DT_INST_PROP(n, debounce_period), (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_ROWS(n), _KSCAN_GPIO_ROW_CFG_INIT, n)},                  \
-        .cols = {UTIL_LISTIFY(INST_MATRIX_COLS(n), _KSCAN_GPIO_COL_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/module.yml b/app/drivers/zephyr/module.yml
index cbff6a1..0b66059 100644
--- a/app/drivers/zephyr/module.yml
+++ b/app/drivers/zephyr/module.yml
@@ -1,3 +1,3 @@
 build:
-  cmake: zephyr
-  kconfig: zephyr/Kconfig
+  cmake: .
+  kconfig: Kconfig