summaryrefslogtreecommitdiff
path: root/app/drivers/kscan
diff options
context:
space:
mode:
Diffstat (limited to 'app/drivers/kscan')
-rw-r--r--app/drivers/kscan/CMakeLists.txt8
-rw-r--r--app/drivers/kscan/Kconfig25
-rw-r--r--app/drivers/kscan/kscan_gpio_demux.c254
-rw-r--r--app/drivers/kscan/kscan_gpio_direct.c247
-rw-r--r--app/drivers/kscan/kscan_gpio_matrix.c294
5 files changed, 828 insertions, 0 deletions
diff --git a/app/drivers/kscan/CMakeLists.txt b/app/drivers/kscan/CMakeLists.txt
new file mode 100644
index 0000000..19933aa
--- /dev/null
+++ b/app/drivers/kscan/CMakeLists.txt
@@ -0,0 +1,8 @@
+# Copyright (c) 2020 The ZMK Contributors
+# SPDX-License-Identifier: MIT
+
+zephyr_library()
+
+zephyr_library_sources_ifdef(CONFIG_ZMK_KSCAN_GPIO_DRIVER kscan_gpio_matrix.c)
+zephyr_library_sources_ifdef(CONFIG_ZMK_KSCAN_GPIO_DRIVER kscan_gpio_direct.c)
+zephyr_library_sources_ifdef(CONFIG_ZMK_KSCAN_GPIO_DRIVER kscan_gpio_demux.c) \ No newline at end of file
diff --git a/app/drivers/kscan/Kconfig b/app/drivers/kscan/Kconfig
new file mode 100644
index 0000000..5b913f3
--- /dev/null
+++ b/app/drivers/kscan/Kconfig
@@ -0,0 +1,25 @@
+# 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. \ No newline at end of file
diff --git a/app/drivers/kscan/kscan_gpio_demux.c b/app/drivers/kscan/kscan_gpio_demux.c
new file mode 100644
index 0000000..6113d7c
--- /dev/null
+++ b/app/drivers/kscan/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/kscan/kscan_gpio_direct.c b/app/drivers/kscan/kscan_gpio_direct.c
new file mode 100644
index 0000000..8327161
--- /dev/null
+++ b/app/drivers/kscan/kscan_gpio_direct.c
@@ -0,0 +1,247 @@
+/*
+ * 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/kscan/kscan_gpio_matrix.c b/app/drivers/kscan/kscan_gpio_matrix.c
new file mode 100644
index 0000000..ec4fb39
--- /dev/null
+++ b/app/drivers/kscan/kscan_gpio_matrix.c
@@ -0,0 +1,294 @@
+/*
+ * 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) */
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-30 19:07:38 +0000