summaryrefslogtreecommitdiff
path: root/drivers/zephyr/kscan_gpio.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/zephyr/kscan_gpio.c')
-rw-r--r--drivers/zephyr/kscan_gpio.c516
1 files changed, 516 insertions, 0 deletions
diff --git a/drivers/zephyr/kscan_gpio.c b/drivers/zephyr/kscan_gpio.c
new file mode 100644
index 0000000..71ea68b
--- /dev/null
+++ b/drivers/zephyr/kscan_gpio.c
@@ -0,0 +1,516 @@
+/*
+ * Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#define DT_DRV_COMPAT gpio_kscan
+
+#include <device.h>
+#include <drivers/kscan.h>
+#include <drivers/gpio.h>
+#include <logging/log.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+#define MATRIX_NODE_ID DT_DRV_INST(0)
+#define MATRIX_ROWS DT_PROP_LEN(MATRIX_NODE_ID, row_gpios)
+#define MATRIX_COLS DT_PROP_LEN(MATRIX_NODE_ID, col_gpios)
+
+#if DT_ENUM_IDX(MATRIX_NODE_ID, diode_direction) == 0
+#define SCAN_ROW_TO_COLUMN
+#else
+#define SCAN_COL_TO_ROW
+#endif
+
+struct kscan_gpio_item_config
+{
+ char *label;
+ gpio_pin_t pin;
+ gpio_flags_t flags;
+};
+
+struct kscan_gpio_config
+{
+ u8_t debounce_period;
+ struct kscan_gpio_item_config rows[MATRIX_ROWS];
+ struct kscan_gpio_item_config cols[MATRIX_COLS];
+};
+
+struct kscan_gpio_data
+{
+ kscan_callback_t callback;
+#if DT_PROP(MATRIX_NODE_ID, debounce_id) == 0
+ struct k_work work;
+#else
+ struct k_delayed_work work;
+#endif
+ bool matrix_state[MATRIX_ROWS][MATRIX_COLS];
+ struct device *rows[MATRIX_ROWS];
+ struct device *cols[MATRIX_COLS];
+ struct device *dev;
+};
+
+struct kscan_gpio_irq_callback
+{
+#if DT_PROP(MATRIX_NODE_ID, debounce_id) == 0
+ struct k_work *work;
+#else
+ struct k_delayed_work *work;
+#endif
+ struct gpio_callback callback;
+};
+
+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;
+}
+
+#ifdef SCAN_ROW_TO_COLUMN
+
+static struct kscan_gpio_irq_callback irq_callbacks[MATRIX_COLS];
+
+static int kscan_gpio_enable_interrupts(struct device *dev)
+{
+ struct kscan_gpio_data *data = dev->driver_data;
+ const struct kscan_gpio_config *cfg = dev->config_info;
+
+ return kscan_gpio_config_interrupts(
+ data->cols, cfg->cols, MATRIX_COLS,
+ GPIO_INT_DEBOUNCE | GPIO_INT_EDGE_BOTH);
+}
+
+static int kscan_gpio_disable_interrupts(struct device *dev)
+{
+ struct kscan_gpio_data *data = dev->driver_data;
+ const struct kscan_gpio_config *cfg = dev->config_info;
+
+ return kscan_gpio_config_interrupts(
+ data->cols, cfg->cols, MATRIX_COLS,
+ GPIO_INT_DISABLE);
+}
+
+static void kscan_gpio_set_row_state(struct device *dev, int value)
+{
+ struct kscan_gpio_data *data = dev->driver_data;
+ const struct kscan_gpio_config *cfg = dev->config_info;
+
+ for (int r = 0; r < MATRIX_ROWS; r++)
+ {
+ struct device *row = data->rows[r];
+ const struct kscan_gpio_item_config *row_cfg = &cfg->rows[r];
+
+ gpio_pin_set(row, row_cfg->pin, value);
+ }
+}
+
+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;
+
+ static bool read_state[MATRIX_ROWS][MATRIX_COLS];
+
+ LOG_DBG("Scanning the matrix for updated state");
+
+ /* 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_disable_interrupts(dev);
+ kscan_gpio_set_row_state(dev, 0);
+
+ for (int r = 0; r < MATRIX_ROWS; r++)
+ {
+ struct device *row = data->rows[r];
+ const struct kscan_gpio_item_config *row_cfg = &cfg->rows[r];
+
+ gpio_pin_set(row, row_cfg->pin, 1);
+ for (int c = 0; c < MATRIX_COLS; c++)
+ {
+ struct device *col = data->cols[c];
+ const struct kscan_gpio_item_config *col_cfg = &cfg->cols[c];
+
+ read_state[r][c] =
+ gpio_pin_get(col, col_cfg->pin) > 0;
+ }
+
+ gpio_pin_set(row, row_cfg->pin, 0);
+ }
+
+ /* Set all our outputs as active again, then re-enable interrupts, */
+ /* so we can trigger interrupts again for future press/release */
+ kscan_gpio_set_row_state(dev, 1);
+ kscan_gpio_enable_interrupts(dev);
+
+ for (int r = 0; r < MATRIX_ROWS; r++)
+ {
+ for (int c = 0; c < MATRIX_COLS; c++)
+ {
+ bool pressed = read_state[r][c];
+
+ 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);
+ }
+ }
+ }
+
+ return 0;
+}
+
+#else
+
+static struct kscan_gpio_irq_callback irq_callbacks[MATRIX_ROWS];
+
+static int kscan_gpio_enable_interrupts(struct device *dev)
+{
+ struct kscan_gpio_data *data = dev->driver_data;
+ const struct kscan_gpio_config *cfg = dev->config_info;
+
+ return kscan_gpio_config_interrupts(data->rows, cfg->rows, MATRIX_ROWS,
+ GPIO_INT_DEBOUNCE | GPIO_INT_EDGE_BOTH);
+}
+
+static int kscan_gpio_disable_interrupts(struct device *dev)
+{
+ struct kscan_gpio_data *data = dev->driver_data;
+ const struct kscan_gpio_config *cfg = dev->config_info;
+
+ return kscan_gpio_config_interrupts(data->rows, cfg->rows, MATRIX_ROWS,
+ GPIO_INT_DISABLE);
+}
+
+static void kscan_gpio_set_column_state(struct device *dev, int value)
+{
+ struct kscan_gpio_data *data = dev->driver_data;
+ const struct kscan_gpio_config *cfg = dev->config_info;
+
+ for (int c = 0; c < MATRIX_COLS; c++)
+ {
+ struct device *col = data->cols[c];
+ const struct kscan_gpio_item_config *col_cfg = &cfg->cols[c];
+
+ gpio_pin_set(col, col_cfg->pin, value);
+ }
+}
+
+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;
+
+ static bool read_state[MATRIX_ROWS][MATRIX_COLS];
+
+ LOG_DBG("Scanning the matrix for updated state");
+
+ /* 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_disable_interrupts(dev);
+ kscan_gpio_set_column_state(dev, 0);
+
+ for (int c = 0; c < MATRIX_COLS; c++)
+ {
+ struct device *col = data->cols[c];
+ const struct kscan_gpio_item_config *col_cfg = &cfg->cols[c];
+
+ gpio_pin_set(col, col_cfg->pin, 1);
+
+ for (int r = 0; r < MATRIX_ROWS; r++)
+ {
+ struct device *row = data->rows[r];
+ const struct kscan_gpio_item_config *row_cfg = &cfg->rows[r];
+
+ read_state[r][c] =
+ gpio_pin_get(row, row_cfg->pin) > 0;
+ }
+
+ gpio_pin_set(col, col_cfg->pin, 0);
+ }
+
+ /* Set all our outputs as active again, then re-enable interrupts, */
+ /* so we can trigger interrupts again for future press/release */
+ kscan_gpio_set_column_state(dev, 1);
+ kscan_gpio_enable_interrupts(dev);
+
+ for (int r = 0; r < MATRIX_ROWS; r++)
+ {
+ for (int c = 0; c < MATRIX_COLS; c++)
+ {
+ bool pressed = read_state[r][c];
+
+ 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);
+ }
+ }
+ }
+
+ return 0;
+}
+
+#endif
+
+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);
+
+#if DT_PROP(MATRIX_NODE_ID, debounce_id) == 0
+ k_work_submit(data->work);
+#else
+ k_delayed_work_cancel(data->work);
+ k_delayed_work_submit(data->work,
+ K_MSEC(DT_PROP(MATRIX_NODE_ID, debounce_id)));
+#endif
+}
+
+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 int kscan_gpio_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_init(struct device *dev)
+{
+ struct kscan_gpio_data *data = dev->driver_data;
+ const struct kscan_gpio_config *cfg = dev->config_info;
+ int err;
+
+#ifdef SCAN_ROW_TO_COLUMN
+ gpio_flags_t col_gpio_dir = GPIO_INPUT;
+ gpio_flags_t row_gpio_dir = GPIO_OUTPUT_ACTIVE;
+#else
+ gpio_flags_t col_gpio_dir = GPIO_OUTPUT_ACTIVE;
+ gpio_flags_t row_gpio_dir = GPIO_INPUT;
+#endif
+
+ for (int c = 0; c < MATRIX_COLS; c++)
+ {
+ const struct kscan_gpio_item_config *item_cfg = &cfg->cols[c];
+
+ data->cols[c] = device_get_binding(item_cfg->label);
+ if (data->cols[c] == NULL)
+ {
+ LOG_ERR("Unable to find column GPIO device\n");
+ return -EINVAL;
+ }
+
+ err = gpio_pin_configure(data->cols[c],
+ item_cfg->pin,
+ col_gpio_dir | item_cfg->flags);
+ if (err)
+ {
+ LOG_ERR("Unable to configure column GPIO pin");
+ return -EINVAL;
+ }
+
+#ifdef SCAN_ROW_TO_COLUMN
+ irq_callbacks[c].work = &data->work;
+ gpio_init_callback(&irq_callbacks[c].callback,
+ kscan_gpio_irq_callback_handler,
+ BIT(item_cfg->pin));
+ if (gpio_add_callback(data->cols[c], &irq_callbacks[c].callback))
+ {
+ LOG_ERR("Error adding the callback to the column device");
+ }
+#endif
+ }
+
+ for (int r = 0; r < MATRIX_ROWS; r++)
+ {
+ const struct kscan_gpio_item_config *item_cfg = &cfg->rows[r];
+
+ data->rows[r] = device_get_binding(item_cfg->label);
+ if (data->rows[r] == NULL)
+ {
+ LOG_ERR("Unable to find row GPIO device\n");
+ return -EINVAL;
+ }
+
+ int err = gpio_pin_configure(data->rows[r],
+ item_cfg->pin,
+ row_gpio_dir | item_cfg->flags);
+ if (err)
+ {
+ LOG_ERR("Unable to configure row GPIO pin");
+ return -EINVAL;
+ }
+
+#ifdef SCAN_COL_TO_ROW
+ irq_callbacks[r].work = &data->work;
+ gpio_init_callback(&irq_callbacks[r].callback,
+ kscan_gpio_irq_callback_handler,
+ BIT(item_cfg->pin));
+ gpio_add_callback(data->rows[r], &irq_callbacks[r].callback);
+#endif
+ }
+
+ data->dev = dev;
+
+#if DT_PROP(MATRIX_NODE_ID, debounce_id) == 0
+ k_work_init(&data->work, kscan_gpio_work_handler);
+#else
+ k_delayed_work_init(&data->work, kscan_gpio_work_handler);
+#endif
+
+ return 0;
+}
+
+static const struct kscan_driver_api gpio_driver_api = {
+ .config = kscan_gpio_configure,
+ .enable_callback = kscan_gpio_enable_interrupts,
+ .disable_callback = kscan_gpio_disable_interrupts,
+};
+
+#define _KSCAN_GPIO_ITEM_CFG_INIT(prop, idx) \
+ { \
+ .label = DT_GPIO_LABEL_BY_IDX(MATRIX_NODE_ID, prop, idx), \
+ .pin = DT_GPIO_PIN_BY_IDX(MATRIX_NODE_ID, prop, idx), \
+ .flags = DT_GPIO_FLAGS_BY_IDX(MATRIX_NODE_ID, prop, idx), \
+ }
+
+static const struct kscan_gpio_config kscan_gpio_config = {
+ .rows = {
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, row_gpios, 0)
+ _KSCAN_GPIO_ITEM_CFG_INIT(row_gpios, 0),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, row_gpios, 1)
+ _KSCAN_GPIO_ITEM_CFG_INIT(row_gpios, 1),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, row_gpios, 2)
+ _KSCAN_GPIO_ITEM_CFG_INIT(row_gpios, 2),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, row_gpios, 3)
+ _KSCAN_GPIO_ITEM_CFG_INIT(row_gpios, 3),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, row_gpios, 4)
+ _KSCAN_GPIO_ITEM_CFG_INIT(row_gpios, 4),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, row_gpios, 5)
+ _KSCAN_GPIO_ITEM_CFG_INIT(row_gpios, 5),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, row_gpios, 6)
+ _KSCAN_GPIO_ITEM_CFG_INIT(row_gpios, 6),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, row_gpios, 7)
+ _KSCAN_GPIO_ITEM_CFG_INIT(row_gpios, 7),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, row_gpios, 8)
+ _KSCAN_GPIO_ITEM_CFG_INIT(row_gpios, 8),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, row_gpios, 9)
+ _KSCAN_GPIO_ITEM_CFG_INIT(row_gpios, 9),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, row_gpios, 10)
+ _KSCAN_GPIO_ITEM_CFG_INIT(row_gpios, 10),
+#endif
+ },
+ .cols = {
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 0)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 0),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 1)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 1),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 2)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 2),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 3)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 3),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 4)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 4),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 5)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 5),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 6)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 6),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 7)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 7),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 8)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 8),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 9)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 9),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 10)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 10),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 11)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 11),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 12)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 12),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 13)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 13),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 14)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 14),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 15)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 15),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 16)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 16),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 17)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 17),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 18)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 18),
+#endif
+#if DT_PROP_HAS_IDX(MATRIX_NODE_ID, col_gpios, 19)
+ _KSCAN_GPIO_ITEM_CFG_INIT(col_gpios, 19),
+#endif
+ }};
+
+static struct kscan_gpio_data kscan_gpio_data;
+
+DEVICE_AND_API_INIT(kscan_gpio, DT_INST_LABEL(0), kscan_gpio_init,
+ &kscan_gpio_data, &kscan_gpio_config,
+ POST_KERNEL, CONFIG_ZMK_KSCAN_INIT_PRIORITY,
+ &gpio_driver_api);
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-30 07:14:52 +0000