From 8d9ae1fdf379020d4743b4f85f465e88b148ac29 Mon Sep 17 00:00:00 2001 From: innovaker <66737976+innovaker@users.noreply.github.com> Date: Thu, 19 Nov 2020 17:20:43 +0000 Subject: refactor: Align drivers with Zephyr file system conventions PR: #400 --- app/drivers/CMakeLists.txt | 5 + app/drivers/Kconfig | 5 + app/drivers/kscan/CMakeLists.txt | 8 + app/drivers/kscan/Kconfig | 25 ++ app/drivers/kscan/kscan_gpio_demux.c | 254 ++++++++++++++++++ app/drivers/kscan/kscan_gpio_direct.c | 247 +++++++++++++++++ app/drivers/kscan/kscan_gpio_matrix.c | 294 +++++++++++++++++++++ app/drivers/sensor/CMakeLists.txt | 5 + app/drivers/sensor/Kconfig | 5 + .../sensor/battery_voltage_divider/CMakeLists.txt | 6 + app/drivers/sensor/battery_voltage_divider/Kconfig | 8 + .../battery_voltage_divider.c | 217 +++++++++++++++ app/drivers/sensor/ec11/CMakeLists.txt | 9 + app/drivers/sensor/ec11/Kconfig | 50 ++++ app/drivers/sensor/ec11/ec11.c | 148 +++++++++++ app/drivers/sensor/ec11/ec11.h | 58 ++++ app/drivers/sensor/ec11/ec11_trigger.c | 148 +++++++++++ app/drivers/zephyr/CMakeLists.txt | 14 - app/drivers/zephyr/Kconfig | 79 ------ app/drivers/zephyr/battery_voltage_divider.c | 217 --------------- app/drivers/zephyr/dts/bindings/alps,ec11.yaml | 21 -- .../dts/bindings/kscan/zmk,kscan-gpio-demux.yaml | 22 ++ .../dts/bindings/kscan/zmk,kscan-gpio-direct.yaml | 16 ++ .../dts/bindings/kscan/zmk,kscan-gpio-matrix.yaml | 25 ++ .../zephyr/dts/bindings/sensor/alps,ec11.yaml | 21 ++ .../sensor/zmk,battery-voltage-divider.yaml | 14 + .../dts/bindings/zmk,battery-voltage-divider.yaml | 14 - .../zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml | 22 -- .../zephyr/dts/bindings/zmk,kscan-gpio-direct.yaml | 16 -- .../zephyr/dts/bindings/zmk,kscan-gpio-matrix.yaml | 25 -- app/drivers/zephyr/ec11.c | 148 ----------- app/drivers/zephyr/ec11.h | 58 ---- app/drivers/zephyr/ec11_trigger.c | 148 ----------- app/drivers/zephyr/kscan_gpio_demux.c | 254 ------------------ app/drivers/zephyr/kscan_gpio_direct.c | 247 ----------------- app/drivers/zephyr/kscan_gpio_matrix.c | 294 --------------------- app/drivers/zephyr/module.yml | 4 +- 37 files changed, 1592 insertions(+), 1559 deletions(-) create mode 100644 app/drivers/CMakeLists.txt create mode 100644 app/drivers/Kconfig create mode 100644 app/drivers/kscan/CMakeLists.txt create mode 100644 app/drivers/kscan/Kconfig create mode 100644 app/drivers/kscan/kscan_gpio_demux.c create mode 100644 app/drivers/kscan/kscan_gpio_direct.c create mode 100644 app/drivers/kscan/kscan_gpio_matrix.c create mode 100644 app/drivers/sensor/CMakeLists.txt create mode 100644 app/drivers/sensor/Kconfig create mode 100644 app/drivers/sensor/battery_voltage_divider/CMakeLists.txt create mode 100644 app/drivers/sensor/battery_voltage_divider/Kconfig create mode 100644 app/drivers/sensor/battery_voltage_divider/battery_voltage_divider.c create mode 100644 app/drivers/sensor/ec11/CMakeLists.txt create mode 100644 app/drivers/sensor/ec11/Kconfig create mode 100644 app/drivers/sensor/ec11/ec11.c create mode 100644 app/drivers/sensor/ec11/ec11.h create mode 100644 app/drivers/sensor/ec11/ec11_trigger.c delete mode 100644 app/drivers/zephyr/CMakeLists.txt delete mode 100644 app/drivers/zephyr/Kconfig delete mode 100644 app/drivers/zephyr/battery_voltage_divider.c delete mode 100644 app/drivers/zephyr/dts/bindings/alps,ec11.yaml create mode 100644 app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-demux.yaml create mode 100644 app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-direct.yaml create mode 100644 app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-matrix.yaml create mode 100644 app/drivers/zephyr/dts/bindings/sensor/alps,ec11.yaml create mode 100644 app/drivers/zephyr/dts/bindings/sensor/zmk,battery-voltage-divider.yaml delete mode 100644 app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml delete mode 100644 app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml delete mode 100644 app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-direct.yaml delete mode 100644 app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-matrix.yaml delete mode 100644 app/drivers/zephyr/ec11.c delete mode 100644 app/drivers/zephyr/ec11.h delete mode 100644 app/drivers/zephyr/ec11_trigger.c delete mode 100644 app/drivers/zephyr/kscan_gpio_demux.c delete mode 100644 app/drivers/zephyr/kscan_gpio_direct.c delete mode 100644 app/drivers/zephyr/kscan_gpio_matrix.c (limited to 'app/drivers') diff --git a/app/drivers/CMakeLists.txt b/app/drivers/CMakeLists.txt new file mode 100644 index 0000000..13f04f8 --- /dev/null +++ b/app/drivers/CMakeLists.txt @@ -0,0 +1,5 @@ +# Copyright (c) 2020 The ZMK Contributors +# SPDX-License-Identifier: MIT + +add_subdirectory_ifdef(CONFIG_KSCAN kscan) +add_subdirectory_ifdef(CONFIG_SENSOR sensor) \ No newline at end of file diff --git a/app/drivers/Kconfig b/app/drivers/Kconfig new file mode 100644 index 0000000..7ad7699 --- /dev/null +++ b/app/drivers/Kconfig @@ -0,0 +1,5 @@ +# Copyright (c) 2020 The ZMK Contributors +# SPDX-License-Identifier: MIT + +rsource "kscan/Kconfig" +rsource "sensor/Kconfig" \ No newline at end of file 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 +#include +#include +#include + +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 +#include +#include +#include + +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 +#include +#include +#include + +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/sensor/CMakeLists.txt b/app/drivers/sensor/CMakeLists.txt new file mode 100644 index 0000000..a4c2ba8 --- /dev/null +++ b/app/drivers/sensor/CMakeLists.txt @@ -0,0 +1,5 @@ +# Copyright (c) 2020 The ZMK Contributors +# SPDX-License-Identifier: MIT + +add_subdirectory_ifdef(CONFIG_ZMK_BATTERY_VOLTAGE_DIVIDER battery_voltage_divider) +add_subdirectory_ifdef(CONFIG_EC11 ec11) \ No newline at end of file diff --git a/app/drivers/sensor/Kconfig b/app/drivers/sensor/Kconfig new file mode 100644 index 0000000..7b6a0d0 --- /dev/null +++ b/app/drivers/sensor/Kconfig @@ -0,0 +1,5 @@ +# Copyright (c) 2020 The ZMK Contributors +# SPDX-License-Identifier: MIT + +rsource "battery_voltage_divider/Kconfig" +rsource "ec11/Kconfig" \ No newline at end of file diff --git a/app/drivers/sensor/battery_voltage_divider/CMakeLists.txt b/app/drivers/sensor/battery_voltage_divider/CMakeLists.txt new file mode 100644 index 0000000..4b7f042 --- /dev/null +++ b/app/drivers/sensor/battery_voltage_divider/CMakeLists.txt @@ -0,0 +1,6 @@ +# Copyright (c) 2020 The ZMK Contributors +# SPDX-License-Identifier: MIT + +zephyr_library() + +zephyr_library_sources(battery_voltage_divider.c) \ No newline at end of file diff --git a/app/drivers/sensor/battery_voltage_divider/Kconfig b/app/drivers/sensor/battery_voltage_divider/Kconfig new file mode 100644 index 0000000..18c4ea3 --- /dev/null +++ b/app/drivers/sensor/battery_voltage_divider/Kconfig @@ -0,0 +1,8 @@ +# Copyright (c) 2020 The ZMK Contributors +# SPDX-License-Identifier: MIT + +config ZMK_BATTERY_VOLTAGE_DIVIDER + bool "ZMK battery voltage divider" + select ADC + help + Enable ZMK battery voltage divider driver for battery monitoring. \ No newline at end of file diff --git a/app/drivers/sensor/battery_voltage_divider/battery_voltage_divider.c b/app/drivers/sensor/battery_voltage_divider/battery_voltage_divider.c new file mode 100644 index 0000000..d634dfd --- /dev/null +++ b/app/drivers/sensor/battery_voltage_divider/battery_voltage_divider.c @@ -0,0 +1,217 @@ +/* + * Copyright (c) 2020 The ZMK Contributors + * + * SPDX-License-Identifier: MIT + */ + +#define DT_DRV_COMPAT zmk_battery_voltage_divider + +#include +#include +#include +#include +#include + +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/sensor/ec11/CMakeLists.txt b/app/drivers/sensor/ec11/CMakeLists.txt new file mode 100644 index 0000000..de291fe --- /dev/null +++ b/app/drivers/sensor/ec11/CMakeLists.txt @@ -0,0 +1,9 @@ +# Copyright (c) 2020 The ZMK Contributors +# SPDX-License-Identifier: MIT + +zephyr_include_directories(.) + +zephyr_library() + +zephyr_library_sources(ec11.c) +zephyr_library_sources_ifdef(CONFIG_EC11_TRIGGER ec11_trigger.c) \ No newline at end of file diff --git a/app/drivers/sensor/ec11/Kconfig b/app/drivers/sensor/ec11/Kconfig new file mode 100644 index 0000000..6854e53 --- /dev/null +++ b/app/drivers/sensor/ec11/Kconfig @@ -0,0 +1,50 @@ +# Copyright (c) 2020 The ZMK Contributors +# SPDX-License-Identifier: MIT + +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 \ No newline at end of file diff --git a/app/drivers/sensor/ec11/ec11.c b/app/drivers/sensor/ec11/ec11.c new file mode 100644 index 0000000..00d0090 --- /dev/null +++ b/app/drivers/sensor/ec11/ec11.c @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2020 The ZMK Contributors + * + * SPDX-License-Identifier: MIT + */ + +#define DT_DRV_COMPAT alps_ec11 + +#include +#include +#include +#include +#include +#include +#include + +#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/sensor/ec11/ec11.h b/app/drivers/sensor/ec11/ec11.h new file mode 100644 index 0000000..e62e733 --- /dev/null +++ b/app/drivers/sensor/ec11/ec11.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2020 The ZMK Contributors + * + * SPDX-License-Identifier: MIT + */ + +#pragma once + +#include +#include +#include + +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/sensor/ec11/ec11_trigger.c b/app/drivers/sensor/ec11/ec11_trigger.c new file mode 100644 index 0000000..248ac32 --- /dev/null +++ b/app/drivers/sensor/ec11/ec11_trigger.c @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2020 The ZMK Contributors + * + * SPDX-License-Identifier: MIT + */ + +#define DT_DRV_COMPAT alps_ec11 + +#include +#include +#include +#include +#include + +#include "ec11.h" + +extern struct ec11_data ec11_driver; + +#include +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/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 -#include -#include -#include -#include - -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/alps,ec11.yaml b/app/drivers/zephyr/dts/bindings/alps,ec11.yaml deleted file mode 100644 index 5cbe77a..0000000 --- a/app/drivers/zephyr/dts/bindings/alps,ec11.yaml +++ /dev/null @@ -1,21 +0,0 @@ -description: | - Sensor driver for the Alps EC11 rotary encoder - -compatible: "alps,ec11" - -properties: - label: - type: string - required: true - a-gpios: - type: phandle-array - required: true - description: A pin for the encoder - b-gpios: - type: phandle-array - required: true - description: A pin for the encoder - resolution: - type: int - description: Number of pulses per tick - required: false diff --git a/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-demux.yaml b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-demux.yaml new file mode 100644 index 0000000..a2d8d24 --- /dev/null +++ b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-demux.yaml @@ -0,0 +1,22 @@ +# Copyright (c) 2020, The ZMK Contributors +# SPDX-License-Identifier: MIT + +description: GPIO keyboard demux controller + +compatible: "zmk,kscan-gpio-demux" + +include: kscan.yaml + +properties: + input-gpios: + type: phandle-array + required: true + output-gpios: + type: phandle-array + required: true + debounce-period: + type: int + default: 5 + polling-interval-msec: + type: int + default: 25 diff --git a/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-direct.yaml b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-direct.yaml new file mode 100644 index 0000000..09a9b6c --- /dev/null +++ b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-direct.yaml @@ -0,0 +1,16 @@ +# Copyright (c) 2020, Pete Johanson +# SPDX-License-Identifier: MIT + +description: Direct GPIO keyboard KSCAN controller + +compatible: "zmk,kscan-gpio-direct" + +include: kscan.yaml + +properties: + input-gpios: + type: phandle-array + required: true + debounce-period: + type: int + default: 5 diff --git a/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-matrix.yaml b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-matrix.yaml new file mode 100644 index 0000000..5ebcbdd --- /dev/null +++ b/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-matrix.yaml @@ -0,0 +1,25 @@ +# Copyright (c) 2020, Pete Johanson +# SPDX-License-Identifier: MIT + +description: GPIO keyboard matrix controller + +compatible: "zmk,kscan-gpio-matrix" + +include: kscan.yaml + +properties: + row-gpios: + type: phandle-array + required: true + col-gpios: + type: phandle-array + required: true + debounce-period: + type: int + default: 5 + diode-direction: + type: string + default: row2col + enum: + - row2col + - col2row diff --git a/app/drivers/zephyr/dts/bindings/sensor/alps,ec11.yaml b/app/drivers/zephyr/dts/bindings/sensor/alps,ec11.yaml new file mode 100644 index 0000000..5cbe77a --- /dev/null +++ b/app/drivers/zephyr/dts/bindings/sensor/alps,ec11.yaml @@ -0,0 +1,21 @@ +description: | + Sensor driver for the Alps EC11 rotary encoder + +compatible: "alps,ec11" + +properties: + label: + type: string + required: true + a-gpios: + type: phandle-array + required: true + description: A pin for the encoder + b-gpios: + type: phandle-array + required: true + description: A pin for the encoder + resolution: + type: int + description: Number of pulses per tick + required: false diff --git a/app/drivers/zephyr/dts/bindings/sensor/zmk,battery-voltage-divider.yaml b/app/drivers/zephyr/dts/bindings/sensor/zmk,battery-voltage-divider.yaml new file mode 100644 index 0000000..3f391d7 --- /dev/null +++ b/app/drivers/zephyr/dts/bindings/sensor/zmk,battery-voltage-divider.yaml @@ -0,0 +1,14 @@ +# Copyright (c) 2020 The ZMK Contributors +# SPDX-License-Identifier: MIT + +description: Battery SoC monitoring using voltage divider + +compatible: "zmk,battery-voltage-divider" + +include: voltage-divider.yaml + +properties: + label: + required: true + type: string + \ No newline at end of file diff --git a/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml b/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml deleted file mode 100644 index 3f391d7..0000000 --- a/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml +++ /dev/null @@ -1,14 +0,0 @@ -# Copyright (c) 2020 The ZMK Contributors -# SPDX-License-Identifier: MIT - -description: Battery SoC monitoring using voltage divider - -compatible: "zmk,battery-voltage-divider" - -include: voltage-divider.yaml - -properties: - label: - required: true - type: string - \ No newline at end of file diff --git a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml b/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml deleted file mode 100644 index a2d8d24..0000000 --- a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml +++ /dev/null @@ -1,22 +0,0 @@ -# Copyright (c) 2020, The ZMK Contributors -# SPDX-License-Identifier: MIT - -description: GPIO keyboard demux controller - -compatible: "zmk,kscan-gpio-demux" - -include: kscan.yaml - -properties: - input-gpios: - type: phandle-array - required: true - output-gpios: - type: phandle-array - required: true - debounce-period: - type: int - default: 5 - polling-interval-msec: - type: int - default: 25 diff --git a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-direct.yaml b/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-direct.yaml deleted file mode 100644 index 09a9b6c..0000000 --- a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-direct.yaml +++ /dev/null @@ -1,16 +0,0 @@ -# Copyright (c) 2020, Pete Johanson -# SPDX-License-Identifier: MIT - -description: Direct GPIO keyboard KSCAN controller - -compatible: "zmk,kscan-gpio-direct" - -include: kscan.yaml - -properties: - input-gpios: - type: phandle-array - required: true - debounce-period: - type: int - default: 5 diff --git a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-matrix.yaml b/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-matrix.yaml deleted file mode 100644 index 5ebcbdd..0000000 --- a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-matrix.yaml +++ /dev/null @@ -1,25 +0,0 @@ -# Copyright (c) 2020, Pete Johanson -# SPDX-License-Identifier: MIT - -description: GPIO keyboard matrix controller - -compatible: "zmk,kscan-gpio-matrix" - -include: kscan.yaml - -properties: - row-gpios: - type: phandle-array - required: true - col-gpios: - type: phandle-array - required: true - debounce-period: - type: int - default: 5 - diode-direction: - type: string - default: row2col - enum: - - row2col - - col2row 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 -#include -#include -#include -#include -#include -#include - -#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 -#include -#include - -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 -#include -#include -#include -#include - -#include "ec11.h" - -extern struct ec11_data ec11_driver; - -#include -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 -#include -#include -#include - -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 -#include -#include -#include - -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 -#include -#include -#include - -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 -- cgit v1.2.3