From 844f2c76749cbc5ff611d8e69819af82b698089a Mon Sep 17 00:00:00 2001 From: Nick Date: Sat, 19 Sep 2020 19:14:59 -0500 Subject: Voltage divider driver initial implementation --- app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml (limited to 'app/drivers/zephyr/dts') diff --git a/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml b/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml new file mode 100644 index 0000000..f6e0642 --- /dev/null +++ b/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml @@ -0,0 +1,9 @@ +# 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 + \ No newline at end of file -- cgit v1.3.1 From 3082455aecc98532807aba3226321a94d2ed4b0c Mon Sep 17 00:00:00 2001 From: Nick Date: Fri, 23 Oct 2020 00:45:59 -0500 Subject: Refactor driver to use Sensor API --- app/boards/arm/bluemicro840/bluemicro840_v1.dts | 8 + app/boards/arm/nice_nano/nice_nano.dts | 1 + app/boards/arm/nrfmicro/nrfmicro_13.dts | 8 + app/drivers/zephyr/battery_voltage_divider.c | 179 ++++++++++++++++----- .../dts/bindings/zmk,battery-voltage-divider.yaml | 5 + 5 files changed, 158 insertions(+), 43 deletions(-) (limited to 'app/drivers/zephyr/dts') diff --git a/app/boards/arm/bluemicro840/bluemicro840_v1.dts b/app/boards/arm/bluemicro840/bluemicro840_v1.dts index c693662..ac8ba56 100644 --- a/app/boards/arm/bluemicro840/bluemicro840_v1.dts +++ b/app/boards/arm/bluemicro840/bluemicro840_v1.dts @@ -29,6 +29,14 @@ }; }; + vbatt { + compatible = "zmk,battery-voltage-divider"; + label = "VOLTAGE_DIVIDER"; + io-channels = <&adc 7>; + output-ohms = <2000000>; + full-ohms = <(2000000 + 806000)>; + }; + }; &gpio0 { diff --git a/app/boards/arm/nice_nano/nice_nano.dts b/app/boards/arm/nice_nano/nice_nano.dts index 18312ec..72804e3 100644 --- a/app/boards/arm/nice_nano/nice_nano.dts +++ b/app/boards/arm/nice_nano/nice_nano.dts @@ -31,6 +31,7 @@ vbatt { compatible = "zmk,battery-voltage-divider"; + label = "VOLTAGE_DIVIDER"; io-channels = <&adc 2>; output-ohms = <2000000>; full-ohms = <(2000000 + 806000)>; diff --git a/app/boards/arm/nrfmicro/nrfmicro_13.dts b/app/boards/arm/nrfmicro/nrfmicro_13.dts index 95bd8ad..840014a 100644 --- a/app/boards/arm/nrfmicro/nrfmicro_13.dts +++ b/app/boards/arm/nrfmicro/nrfmicro_13.dts @@ -26,6 +26,14 @@ }; }; + vbatt { + compatible = "zmk,battery-voltage-divider"; + label = "VOLTAGE_DIVIDER"; + io-channels = <&adc 2>; + output-ohms = <2000000>; + full-ohms = <(2000000 + 820000)>; + }; + }; &gpio0 { diff --git a/app/drivers/zephyr/battery_voltage_divider.c b/app/drivers/zephyr/battery_voltage_divider.c index 34de6cf..abe7cb5 100644 --- a/app/drivers/zephyr/battery_voltage_divider.c +++ b/app/drivers/zephyr/battery_voltage_divider.c @@ -16,97 +16,190 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); -#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) +struct io_channel_config { + const char *label; + uint8_t channel; +}; + +struct gpio_channel_config { + const char *label; + uint8_t pin; + uint8_t flags; +}; -#define VBATT DT_PATH(vbatt) +struct bvd_config { + struct io_channel_config io_channel; + struct gpio_channel_config power_gpios; + uint32_t output_ohm; + uint32_t full_ohm; +}; -struct battery_config { +struct bvd_data { struct device *adc; + struct device *gpio; struct adc_channel_cfg acc; struct adc_sequence as; - int16_t adc_raw; + uint16_t adc_raw; + uint16_t voltage; + uint8_t state_of_charge; }; -static struct battery_config battery_config; - -static int lithium_ion_mv_to_pct(int16_t bat_mv) { +static uint8_t lithium_ion_mv_to_pct(int16_t bat_mv) { // Magic function that maps mV to this discharge graph from adafruit: // https://learn.adafruit.com/li-ion-and-lipoly-batteries/voltages return round(106.818 + (-0.032685 - 106.818) / pow(1 + pow(bat_mv / 3679.35, 58.979), 0.347386)); } -static void battery_read(struct k_work *workd) { - struct battery_config *cfg = &battery_config; - struct adc_sequence *as = &cfg->as; +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; + + 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); - int rc = adc_read(cfg->adc, as); + 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 = cfg->adc_raw; + int32_t val = drv_data->adc_raw; - adc_raw_to_millivolts(adc_ref_internal(cfg->adc), cfg->acc.gain, as->resolution, &val); + adc_raw_to_millivolts(adc_ref_internal(drv_data->adc), drv_data->acc.gain, as->resolution, &val); - rc = val * (uint64_t)DT_PROP(VBATT, full_ohms) / DT_PROP(VBATT, output_ohms); - LOG_DBG("ADC raw %d ~ %d mV => %d mV\n", cfg->adc_raw, val, rc); - int percent = lithium_ion_mv_to_pct(rc); + 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) { + rc = gpio_pin_set(drv_data->gpio, drv_cfg->power_gpios.pin, 0); + + if (rc != 0) { + LOG_DBG("Failed to disable ADC power GPIO: %d", rc); + } + } + + return rc; } -K_WORK_DEFINE(battery_work, battery_read); +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; -static void battery_handler(struct k_timer *timer) { k_work_submit(&battery_work); } + case SENSOR_CHAN_GAUGE_STATE_OF_CHARGE: + val->val1 = drv_data->state_of_charge; + val->val2 = 0; + break; + + default: + return -ENOTSUP; + } -K_TIMER_DEFINE(battery_tick, battery_handler, NULL); + return 0; +} + +static const struct sensor_driver_api bvd_api = { + .sample_fetch = bvd_sample_fetch, + .channel_get = bvd_channel_get, +}; -static int battery_setup(struct device *_arg) { - struct battery_config *cfg = &battery_config; - struct adc_sequence *as = &cfg->as; - struct adc_channel_cfg *acc = &cfg->acc; - cfg->adc = device_get_binding(DT_IO_CHANNELS_LABEL(VBATT)); +static int bvd_init(struct device *dev) { + struct bvd_data *drv_data = dev->driver_data; + const struct bvd_config *drv_cfg = dev->config_info; - if (cfg->adc == NULL) { - LOG_ERR("ADC %s failed to retrieve", DT_IO_CHANNELS_LABEL(VBATT)); + 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 -ENOENT; } - *as = (struct adc_sequence){ + 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 -ENOENT; + } + 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 = &cfg->adc_raw, - .buffer_size = sizeof(cfg->adc_raw), + .buffer = &drv_data->adc_raw, + .buffer_size = sizeof(drv_data->adc_raw), .oversampling = 4, .calibrate = true, }; #ifdef CONFIG_ADC_NRFX_SAADC - *acc = (struct adc_channel_cfg){ + 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 + DT_IO_CHANNELS_INPUT(VBATT), + .input_positive = SAADC_CH_PSELP_PSELP_AnalogInput0 + drv_cfg->io_channel.channel, }; - as->resolution = 12; + drv_data->as.resolution = 12; #else #error Unsupported ADC #endif - int adc_rc = adc_channel_setup(cfg->adc, acc); - LOG_DBG("AIN%u setup returned %d", DT_IO_CHANNELS_INPUT(VBATT), adc_rc); - - if (adc_rc != 0) { - return adc_rc; - } - - k_timer_start(&battery_tick, K_NO_WAIT, K_SECONDS(5)); + rc = adc_channel_setup(drv_data->adc, &drv_data->acc); + LOG_DBG("AIN%u setup returned %d", drv_cfg->io_channel.channel, rc); - return 0; + return rc; } -SYS_INIT(battery_setup, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY); +static struct bvd_data bvd_data; +static const struct bvd_config bvd_cfg = { + .io_channel = { + DT_INST_IO_CHANNELS_LABEL(0), + DT_INST_IO_CHANNELS_INPUT(0), + }, +#if DT_INST_NODE_HAS_PROP(0, power_gpios) + .power_gpios = { + DT_INST_GPIO_LABEL(0, power_gpios), + DT_INST_PIN(0, power_gpios), + DT_INST_FLAGS(0, power_gpios), + }, +#endif + .output_ohm = DT_INST_PROP(0, output_ohms), + .full_ohm = DT_INST_PROP(0, full_ohms), +}; -#endif /* DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) */ \ No newline at end of file +DEVICE_AND_API_INIT(bvd_dev, DT_INST_LABEL(0), &bvd_init, + &bvd_data, &bvd_cfg, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, + &bvd_api); diff --git a/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml b/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml index f6e0642..3f391d7 100644 --- a/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml +++ b/app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml @@ -6,4 +6,9 @@ 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 -- cgit v1.3.1 From 1522c91d73d7f35643986daa508dd7704a5f2798 Mon Sep 17 00:00:00 2001 From: Jay Greco Date: Wed, 21 Oct 2020 20:15:55 -0700 Subject: Add new kscan_gpio_demux driver + zmk,kscan_gpio_demux is now a compatible kscan option + kscan_gpio_demux is based heavily off of the implementation of kscan_gpio_matrix, modified to address cols using an n-to-1 demultiplexer chip instead of discrete IO + Added zmk,kscan_gpio_demux.yaml file * modified CMakeLists to include new source files --- .vscode/settings.json | 4 +- app/drivers/zephyr/CMakeLists.txt | 1 + .../zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml | 22 ++ app/drivers/zephyr/kscan_gpio_demux.c | 270 +++++++++++++++++++++ 4 files changed, 296 insertions(+), 1 deletion(-) create mode 100644 app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml create mode 100644 app/drivers/zephyr/kscan_gpio_demux.c (limited to 'app/drivers/zephyr/dts') diff --git a/.vscode/settings.json b/.vscode/settings.json index 3642d28..2ec4553 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -2,5 +2,7 @@ "files.associations": { "*.overlay": "dts", "*.keymap": "dts" - } + }, + "C_Cpp.dimInactiveRegions": false, + "C_Cpp.errorSquiggles": "Disabled" } diff --git a/app/drivers/zephyr/CMakeLists.txt b/app/drivers/zephyr/CMakeLists.txt index fc43fb8..e3a192d 100644 --- a/app/drivers/zephyr/CMakeLists.txt +++ b/app/drivers/zephyr/CMakeLists.txt @@ -5,6 +5,7 @@ if(CONFIG_ZMK_KSCAN_GPIO_DRIVER) zephyr_library_sources( kscan_gpio_matrix.c kscan_gpio_direct.c + kscan_gpio_demux.c ) zephyr_library_sources_ifdef(CONFIG_EC11 ec11.c) diff --git a/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml b/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml new file mode 100644 index 0000000..a2d8d24 --- /dev/null +++ b/app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-demux.yaml @@ -0,0 +1,22 @@ +# Copyright (c) 2020, The ZMK Contributors +# SPDX-License-Identifier: MIT + +description: GPIO keyboard demux controller + +compatible: "zmk,kscan-gpio-demux" + +include: kscan.yaml + +properties: + input-gpios: + type: phandle-array + required: true + output-gpios: + type: phandle-array + required: true + debounce-period: + type: int + default: 5 + polling-interval-msec: + type: int + default: 25 diff --git a/app/drivers/zephyr/kscan_gpio_demux.c b/app/drivers/zephyr/kscan_gpio_demux.c new file mode 100644 index 0000000..98c04e6 --- /dev/null +++ b/app/drivers/zephyr/kscan_gpio_demux.c @@ -0,0 +1,270 @@ +/* + * 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; \ + }; \ + \ + static struct kscan_gpio_irq_callback_##n irq_callbacks_##n[INST_MATRIX_INPUTS(n)]; \ + \ + 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 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); \ + CHECK_DEBOUNCE_CFG(n, ({ 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_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; \ + 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); \ + } \ + 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; \ + } \ + } \ + /* 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) */ -- cgit v1.3.1