From c552379f0e4c1bf4b1b993e4c765e7690592feae Mon Sep 17 00:00:00 2001 From: Lothar Felten Date: Thu, 28 Nov 2024 12:33:24 +0100 Subject: [PATCH] drivers: input: cap12xx, support 3 to 8 channels MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The Microchip CAP12xx series are available in 3, 6 or 8 channel versions. Co-authored-by: Benjamin Cabé Signed-off-by: Lothar Felten --- doc/releases/migration-guide-4.1.rst | 12 ++ drivers/input/Kconfig.cap12xx | 22 +-- drivers/input/input_cap12xx.c | 202 ++++++++++++---------- dts/bindings/input/microchip,cap12xx.yaml | 16 +- 4 files changed, 139 insertions(+), 113 deletions(-) diff --git a/doc/releases/migration-guide-4.1.rst b/doc/releases/migration-guide-4.1.rst index 72f9dbd98e2..d999f086274 100644 --- a/doc/releases/migration-guide-4.1.rst +++ b/doc/releases/migration-guide-4.1.rst @@ -27,6 +27,18 @@ Boards Devicetree ********** +* The :dtcompatible:`microchip,cap1203` driver has changed its compatible to + :dtcompatible:`microchip,cap12xx` and has been updated to support multiple + channels. + The number of available channels is derived from the length of the devicetree + array property ``input-codes``. + The :kconfig:option:`CONFIG_INPUT_CAP1203_POLL` has been removed: + If the devicetree property ``int-gpios`` is present, interrupt mode is used + otherwise, polling is used. + The :kconfig:option:`CONFIG_INPUT_CAP1203_PERIOD` has been replaced with + the devicetree property ``poll-interval-ms``. + In interrupt mode, the devicetree property ``repeat`` is supported. + STM32 ===== diff --git a/drivers/input/Kconfig.cap12xx b/drivers/input/Kconfig.cap12xx index eb716435b73..a217bc266ba 100644 --- a/drivers/input/Kconfig.cap12xx +++ b/drivers/input/Kconfig.cap12xx @@ -1,27 +1,11 @@ # Copyright (c) 2022 Keiya Nobuta # SPDX-License-Identifier: Apache-2.0 -menuconfig INPUT_CAP12XX - bool "cap12xx 3-cannel capacitive touch sensor driver" +config INPUT_CAP12XX + bool "Microchip CAP12xx multi-channel capacitive touch sensor driver" default y depends on DT_HAS_MICROCHIP_CAP12XX_ENABLED select I2C help - Enable driver for microchip cap12xx 3-cannel capacitive + Enable driver for Microchip CAP12xx multi-channel capacitive touch sensor. - -if INPUT_CAP12XX - -config INPUT_CAP12XX_POLL - bool "Polling" - help - Enable polling mode when interrupt GPIO is not specified. - -config INPUT_CAP1XX3_PERIOD - int "Sample period" - depends on INPUT_CAP12XX_POLL - default 10 - help - Sample period in milliseconds when in polling mode. - -endif # INPUT_CAP12XX diff --git a/drivers/input/input_cap12xx.c b/drivers/input/input_cap12xx.c index 91965d3c255..8b0a2313091 100644 --- a/drivers/input/input_cap12xx.c +++ b/drivers/input/input_cap12xx.c @@ -4,45 +4,45 @@ * SPDX-License-Identifier: Apache-2.0 */ -#define DT_DRV_COMPAT microchip_cap1203 +#define DT_DRV_COMPAT microchip_cap12xx #include #include #include - #include -LOG_MODULE_REGISTER(cap1203, CONFIG_INPUT_LOG_LEVEL); +LOG_MODULE_REGISTER(cap12xx, CONFIG_INPUT_LOG_LEVEL); -#define REG_MAIN_CONTROL 0x0 -#define CONTROL_INT 0x1 +#define REG_MAIN_CONTROL 0x00 +#define CONTROL_INT 0x01 #define REG_INPUT_STATUS 0x03 #define REG_INTERRUPT_ENABLE 0x27 -#define INTERRUPT_ENABLE 0x7 -#define INTERRUPT_DISABLE 0x0 +#define INTERRUPT_ENABLE 0xFF +#define INTERRUPT_DISABLE 0x00 -#define TOUCH_INPUT_COUNT 3 +#define REG_REPEAT_ENABLE 0x28 +#define REPEAT_ENABLE 0xFF +#define REPEAT_DISABLE 0x00 -struct cap1203_config { +struct cap12xx_config { struct i2c_dt_spec i2c; - struct gpio_dt_spec int_gpio; + const uint8_t input_channels; const uint16_t *input_codes; + struct gpio_dt_spec *int_gpio; + bool repeat; + const uint16_t poll_interval_ms; }; -struct cap1203_data { +struct cap12xx_data { const struct device *dev; struct k_work work; - /* Interrupt GPIO callback. */ - struct gpio_callback int_gpio_cb; uint8_t prev_input_state; -#ifdef CONFIG_INPUT_CAP1203_POLL - /* Timer (polling mode). */ - struct k_timer timer; -#endif + struct gpio_callback int_gpio_cb; + struct k_timer poll_timer; }; -static int cap1203_clear_interrupt(const struct i2c_dt_spec *i2c) +static int cap12xx_clear_interrupt(const struct i2c_dt_spec *i2c) { uint8_t ctrl; int r; @@ -56,77 +56,79 @@ static int cap1203_clear_interrupt(const struct i2c_dt_spec *i2c) return i2c_reg_write_byte_dt(i2c, REG_MAIN_CONTROL, ctrl); } -static int cap1203_enable_interrupt(const struct i2c_dt_spec *i2c, bool enable) +static int cap12xx_enable_interrupt(const struct i2c_dt_spec *i2c, bool enable) { uint8_t intr = enable ? INTERRUPT_ENABLE : INTERRUPT_DISABLE; return i2c_reg_write_byte_dt(i2c, REG_INTERRUPT_ENABLE, intr); } -static int cap1203_process(const struct device *dev) +static int cap12xx_process(const struct device *dev) { - const struct cap1203_config *config = dev->config; - struct cap1203_data *data = dev->data; + const struct cap12xx_config *config = dev->config; + struct cap12xx_data *data = dev->data; int r; - uint8_t input; - uint8_t single_input_state; + uint8_t input_state; + + /* + * Clear INT bit to clear SENSOR INPUT STATUS bits. + * Note that this is also required in polling mode. + */ + r = cap12xx_clear_interrupt(&config->i2c); - r = i2c_reg_read_byte_dt(&config->i2c, REG_INPUT_STATUS, &input); + if (r < 0) { + return r; + } + r = i2c_reg_read_byte_dt(&config->i2c, REG_INPUT_STATUS, &input_state); if (r < 0) { return r; } - for (uint8_t i = 0; i < TOUCH_INPUT_COUNT; i++) { - single_input_state = input & BIT(i); - if (single_input_state != (data->prev_input_state & BIT(i))) { - input_report_key(dev, config->input_codes[i], single_input_state, true, - K_FOREVER); + if (config->int_gpio == NULL) { + if (data->prev_input_state == input_state) { + return 0; } } - data->prev_input_state = input; - - LOG_DBG("event: input: %d\n", input); - /* - * Clear INT bit to clear SENSOR INPUT STATUS bits. - * Note that this is also required in polling mode. - */ - r = cap1203_clear_interrupt(&config->i2c); - if (r < 0) { - return r; + for (uint8_t i = 0; i < config->input_channels; i++) { + if (input_state & BIT(i)) { + input_report_key(dev, config->input_codes[i], input_state & BIT(i), true, + K_FOREVER); + } else if (data->prev_input_state & BIT(i)) { + input_report_key(dev, config->input_codes[i], input_state & BIT(i), true, + K_FOREVER); + } } + data->prev_input_state = input_state; return 0; } -static void cap1203_work_handler(struct k_work *work) +static void cap12xx_work_handler(struct k_work *work) { - struct cap1203_data *data = CONTAINER_OF(work, struct cap1203_data, work); + struct cap12xx_data *data = CONTAINER_OF(work, struct cap12xx_data, work); - cap1203_process(data->dev); + cap12xx_process(data->dev); } -static void cap1203_isr_handler(const struct device *dev, - struct gpio_callback *cb, uint32_t pins) +static void cap12xx_timer_handler(struct k_timer *poll_timer) { - struct cap1203_data *data = CONTAINER_OF(cb, struct cap1203_data, int_gpio_cb); + struct cap12xx_data *data = CONTAINER_OF(poll_timer, struct cap12xx_data, poll_timer); k_work_submit(&data->work); } -#ifdef CONFIG_INPUT_CAP1203_POLL -static void cap1203_timer_handler(struct k_timer *timer) +static void cap12xx_isr_handler(const struct device *dev, struct gpio_callback *cb, uint32_t pins) { - struct cap1203_data *data = CONTAINER_OF(timer, struct cap1203_data, timer); + struct cap12xx_data *data = CONTAINER_OF(cb, struct cap12xx_data, int_gpio_cb); k_work_submit(&data->work); } -#endif -static int cap1203_init(const struct device *dev) +static int cap12xx_init(const struct device *dev) { - const struct cap1203_config *config = dev->config; - struct cap1203_data *data = dev->data; + const struct cap12xx_config *config = dev->config; + struct cap12xx_data *data = dev->data; int r; if (!device_is_ready(config->i2c.bus)) { @@ -136,77 +138,93 @@ static int cap1203_init(const struct device *dev) data->dev = dev; - k_work_init(&data->work, cap1203_work_handler); + k_work_init(&data->work, cap12xx_work_handler); - if (config->int_gpio.port != NULL) { - if (!gpio_is_ready_dt(&config->int_gpio)) { - LOG_ERR("Interrupt GPIO controller device not ready"); + if (config->int_gpio == NULL) { + LOG_DBG("cap12xx driver in polling mode"); + k_timer_init(&data->poll_timer, cap12xx_timer_handler, NULL); + r = cap12xx_enable_interrupt(&config->i2c, true); + if (r < 0) { + LOG_ERR("Could not configure interrupt"); + return r; + } + k_timer_start(&data->poll_timer, K_MSEC(config->poll_interval_ms), + K_MSEC(config->poll_interval_ms)); + } else { + LOG_DBG("cap12xx driver in interrupt mode"); + if (!gpio_is_ready_dt(config->int_gpio)) { + LOG_ERR("Interrupt GPIO controller device not ready (missing device tree " + "node?)"); return -ENODEV; } - r = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT); + r = gpio_pin_configure_dt(config->int_gpio, GPIO_INPUT); if (r < 0) { - LOG_ERR("Could not confighure interrupt GPIO pin"); + LOG_ERR("Could not configure interrupt GPIO pin"); return r; } - r = gpio_pin_interrupt_configure_dt(&config->int_gpio, - GPIO_INT_EDGE_TO_ACTIVE); + r = gpio_pin_interrupt_configure_dt(config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE); if (r < 0) { LOG_ERR("Could not configure interrupt GPIO interrupt"); return r; } - gpio_init_callback(&data->int_gpio_cb, cap1203_isr_handler, - BIT(config->int_gpio.pin)); + gpio_init_callback(&data->int_gpio_cb, cap12xx_isr_handler, + BIT(config->int_gpio->pin)); - r = gpio_add_callback(config->int_gpio.port, &data->int_gpio_cb); + r = gpio_add_callback_dt(config->int_gpio, &data->int_gpio_cb); if (r < 0) { LOG_ERR("Could not set gpio callback"); return r; } - r = cap1203_clear_interrupt(&config->i2c); + r = cap12xx_clear_interrupt(&config->i2c); if (r < 0) { LOG_ERR("Could not clear interrupt"); return r; } - - r = cap1203_enable_interrupt(&config->i2c, true); + r = cap12xx_enable_interrupt(&config->i2c, true); if (r < 0) { LOG_ERR("Could not configure interrupt"); return r; } - } -#ifdef CONFIG_INPUT_CAP1203_POLL - else { - k_timer_init(&data->timer, cap1203_timer_handler, NULL); - - r = cap1203_enable_interrupt(&config->i2c, false); - if (r < 0) { - LOG_ERR("Could not configure interrupt"); - return r; + if (config->repeat) { + r = i2c_reg_write_byte_dt(&config->i2c, REG_REPEAT_ENABLE, REPEAT_ENABLE); + if (r < 0) { + LOG_ERR("Could not disable repeated interrupts"); + return r; + } + LOG_DBG("cap12xx enabled repeated interrupts"); + } else { + r = i2c_reg_write_byte_dt(&config->i2c, REG_REPEAT_ENABLE, REPEAT_DISABLE); + if (r < 0) { + LOG_ERR("Could not enable repeated interrupts"); + return r; + } + LOG_DBG("cap12xx disabled repeated interrupts"); } - - k_timer_start(&data->timer, K_MSEC(CONFIG_INPUT_CAP1203_PERIOD), - K_MSEC(CONFIG_INPUT_CAP1203_PERIOD)); } -#endif - + LOG_DBG("%d channels configured", config->input_channels); return 0; } -#define CAP1203_INIT(index) \ - static const uint16_t cap1203_input_codes_##inst[] = DT_INST_PROP(index, input_codes); \ - BUILD_ASSERT(DT_INST_PROP_LEN(index, input_codes) == TOUCH_INPUT_COUNT); \ - static const struct cap1203_config cap1203_config_##index = { \ +#define CAP12XX_INIT(index) \ + IF_ENABLED(DT_INST_NODE_HAS_PROP(index, int_gpios), ( \ + static struct gpio_dt_spec cap12xx_int_gpio_##index = \ + GPIO_DT_SPEC_INST_GET(index, int_gpios);)) \ + static const uint16_t cap12xx_input_codes_##index[] = DT_INST_PROP(index, input_codes); \ + static const struct cap12xx_config cap12xx_config_##index = { \ .i2c = I2C_DT_SPEC_INST_GET(index), \ - .int_gpio = GPIO_DT_SPEC_INST_GET_OR(index, int_gpios, {0}), \ - .input_codes = cap1203_input_codes_##inst, \ - }; \ - static struct cap1203_data cap1203_data_##index; \ - DEVICE_DT_INST_DEFINE(index, cap1203_init, NULL, &cap1203_data_##index, \ - &cap1203_config_##index, POST_KERNEL, CONFIG_INPUT_INIT_PRIORITY, \ + .input_channels = DT_INST_PROP_LEN(index, input_codes), \ + .input_codes = cap12xx_input_codes_##index, \ + IF_ENABLED(DT_INST_NODE_HAS_PROP(index, int_gpios), ( \ + .int_gpio = &cap12xx_int_gpio_##index,)) \ + .repeat = DT_INST_PROP(index, repeat), \ + .poll_interval_ms = DT_INST_PROP_OR(index, poll_interval_ms, 10)}; \ + static struct cap12xx_data cap12xx_data_##index; \ + DEVICE_DT_INST_DEFINE(index, cap12xx_init, NULL, &cap12xx_data_##index, \ + &cap12xx_config_##index, POST_KERNEL, CONFIG_INPUT_INIT_PRIORITY, \ NULL); -DT_INST_FOREACH_STATUS_OKAY(CAP1203_INIT) +DT_INST_FOREACH_STATUS_OKAY(CAP12XX_INIT) diff --git a/dts/bindings/input/microchip,cap12xx.yaml b/dts/bindings/input/microchip,cap12xx.yaml index b40fd6cff20..8e5eefcfb4d 100644 --- a/dts/bindings/input/microchip,cap12xx.yaml +++ b/dts/bindings/input/microchip,cap12xx.yaml @@ -1,7 +1,7 @@ # Copyright (c) 2022 Keiya Nobuta # SPDX-License-Identifier: Apache-2.0 -description: cap12xx 3-channel capacitive touch sensor +description: Microchip CAP12xx family of 3, 6 and 8-channel capacitive touch sensors. compatible: "microchip,cap12xx" @@ -10,9 +10,21 @@ include: i2c-device.yaml properties: int-gpios: type: phandle-array + description: | + Interrupt GPIO when not using polling mode. + + repeat: + type: boolean + description: | + Property to enable the interrupt repeat mode for prolonged touch events. + + poll-interval-ms: + type: int + description: | + Polling interval in ms when not using interrupt mode. input-codes: type: array required: true description: | - array of input event key codes (INPUT_KEY_* or INPUT_BTN_*). + Array of input event key codes (INPUT_KEY_* or INPUT_BTN_*).