From 4a5fa016948442b861be7956290e249bd8168dea Mon Sep 17 00:00:00 2001 From: Fabio Baltieri Date: Fri, 19 Apr 2024 22:30:31 +0100 Subject: [PATCH] input: add a paw32xx driver Add a driver for PAW32xx sensors. Signed-off-by: Fabio Baltieri --- drivers/input/CMakeLists.txt | 1 + drivers/input/Kconfig | 1 + drivers/input/Kconfig.paw32xx | 10 + drivers/input/input_paw32xx.c | 467 ++++++++++++++++++++++ dts/bindings/input/pixart,paw32xx.yaml | 52 +++ include/zephyr/input/input_paw32xx.h | 26 ++ tests/drivers/build_all/input/app.overlay | 15 +- 7 files changed, 571 insertions(+), 1 deletion(-) create mode 100644 drivers/input/Kconfig.paw32xx create mode 100644 drivers/input/input_paw32xx.c create mode 100644 dts/bindings/input/pixart,paw32xx.yaml create mode 100644 include/zephyr/input/input_paw32xx.h diff --git a/drivers/input/CMakeLists.txt b/drivers/input/CMakeLists.txt index 4131cca963..bab58e5c6d 100644 --- a/drivers/input/CMakeLists.txt +++ b/drivers/input/CMakeLists.txt @@ -21,6 +21,7 @@ zephyr_library_sources_ifdef(CONFIG_INPUT_ITE_IT8XXX2_KBD input_ite_it8xxx2_kbd. zephyr_library_sources_ifdef(CONFIG_INPUT_KBD_MATRIX input_kbd_matrix.c) zephyr_library_sources_ifdef(CONFIG_INPUT_NPCX_KBD input_npcx_kbd.c) zephyr_library_sources_ifdef(CONFIG_INPUT_PAT912X input_pat912x.c) +zephyr_library_sources_ifdef(CONFIG_INPUT_PAW32XX input_paw32xx.c) zephyr_library_sources_ifdef(CONFIG_INPUT_PINNACLE input_pinnacle.c) zephyr_library_sources_ifdef(CONFIG_INPUT_PMW3610 input_pmw3610.c) zephyr_library_sources_ifdef(CONFIG_INPUT_STMPE811 input_stmpe811.c) diff --git a/drivers/input/Kconfig b/drivers/input/Kconfig index 2312767cea..e810b5b091 100644 --- a/drivers/input/Kconfig +++ b/drivers/input/Kconfig @@ -23,6 +23,7 @@ source "drivers/input/Kconfig.it8xxx2" source "drivers/input/Kconfig.kbd_matrix" source "drivers/input/Kconfig.npcx" source "drivers/input/Kconfig.pat912x" +source "drivers/input/Kconfig.paw32xx" source "drivers/input/Kconfig.pinnacle" source "drivers/input/Kconfig.pmw3610" source "drivers/input/Kconfig.sdl" diff --git a/drivers/input/Kconfig.paw32xx b/drivers/input/Kconfig.paw32xx new file mode 100644 index 0000000000..652f3e773f --- /dev/null +++ b/drivers/input/Kconfig.paw32xx @@ -0,0 +1,10 @@ +# Copyright 2024 Google LLC +# SPDX-License-Identifier: Apache-2.0 + +config INPUT_PAW32XX + bool "PAW32xx ultra low power wireless mouse chip" + default y + depends on DT_HAS_PIXART_PAW32XX_ENABLED + select SPI + help + PAW32XX low power laser mouse sensor input driver diff --git a/drivers/input/input_paw32xx.c b/drivers/input/input_paw32xx.c new file mode 100644 index 0000000000..277da93bd5 --- /dev/null +++ b/drivers/input/input_paw32xx.c @@ -0,0 +1,467 @@ +/* + * Copyright 2024 Google LLC + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#define DT_DRV_COMPAT pixart_paw32xx + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +LOG_MODULE_REGISTER(input_paw32xx, CONFIG_INPUT_LOG_LEVEL); + +#define PAW32XX_PRODUCT_ID1 0x00 +#define PAW32XX_PRODUCT_ID2 0x01 +#define PAW32XX_MOTION 0x02 +#define PAW32XX_DELTA_X 0x03 +#define PAW32XX_DELTA_Y 0x04 +#define PAW32XX_OPERATION_MODE 0x05 +#define PAW32XX_CONFIGURATION 0x06 +#define PAW32XX_WRITE_PROTECT 0x09 +#define PAW32XX_SLEEP1 0x0a +#define PAW32XX_SLEEP2 0x0b +#define PAW32XX_SLEEP3 0x0c +#define PAW32XX_CPI_X 0x0d +#define PAW32XX_CPI_Y 0x0e +#define PAW32XX_DELTA_XY_HI 0x12 +#define PAW32XX_MOUSE_OPTION 0x19 + +#define PRODUCT_ID_PAW32XX 0x30 +#define SPI_WRITE BIT(7) + +#define MOTION_STATUS_MOTION BIT(7) +#define OPERATION_MODE_SLP_ENH BIT(4) +#define OPERATION_MODE_SLP2_ENH BIT(3) +#define OPERATION_MODE_SLP_MASK (OPERATION_MODE_SLP_ENH | OPERATION_MODE_SLP2_ENH) +#define CONFIGURATION_PD_ENH BIT(3) +#define CONFIGURATION_RESET BIT(7) +#define WRITE_PROTECT_ENABLE 0x00 +#define WRITE_PROTECT_DISABLE 0x5a +#define MOUSE_OPTION_MOVX_INV_BIT 3 +#define MOUSE_OPTION_MOVY_INV_BIT 4 + +#define PAW32XX_DATA_SIZE_BITS 12 + +#define RESET_DELAY_MS 2 + +#define RES_STEP 38 +#define RES_MIN (16 * RES_STEP) +#define RES_MAX (127 * RES_STEP) + +struct paw32xx_config { + struct spi_dt_spec spi; + struct gpio_dt_spec motion_gpio; + uint16_t axis_x; + uint16_t axis_y; + int16_t res_cpi; + bool invert_x; + bool invert_y; + bool force_awake; +}; + +struct paw32xx_data { + const struct device *dev; + struct k_work motion_work; + struct gpio_callback motion_cb; +}; + +static int paw32xx_read_reg(const struct device *dev, uint8_t addr, uint8_t *value) +{ + const struct paw32xx_config *cfg = dev->config; + + const struct spi_buf tx_buf = { + .buf = &addr, + .len = sizeof(addr), + }; + const struct spi_buf_set tx = { + .buffers = &tx_buf, + .count = 1, + }; + + struct spi_buf rx_buf[] = { + { + .buf = NULL, + .len = sizeof(addr), + }, + { + .buf = value, + .len = 1, + }, + }; + const struct spi_buf_set rx = { + .buffers = rx_buf, + .count = ARRAY_SIZE(rx_buf), + }; + + return spi_transceive_dt(&cfg->spi, &tx, &rx); +} + +static int paw32xx_write_reg(const struct device *dev, uint8_t addr, uint8_t value) +{ + const struct paw32xx_config *cfg = dev->config; + + uint8_t write_buf[] = {addr | SPI_WRITE, value}; + const struct spi_buf tx_buf = { + .buf = write_buf, + .len = sizeof(write_buf), + }; + const struct spi_buf_set tx = { + .buffers = &tx_buf, + .count = 1, + }; + + return spi_write_dt(&cfg->spi, &tx); +} + +static int paw32xx_update_reg(const struct device *dev, uint8_t addr, uint8_t mask, uint8_t value) +{ + uint8_t val; + int ret; + + ret = paw32xx_read_reg(dev, addr, &val); + if (ret < 0) { + return ret; + } + + val = (val & ~mask) | (value & mask); + + ret = paw32xx_write_reg(dev, addr, val); + if (ret < 0) { + return ret; + } + + return 0; +} + +static int paw32xx_read_xy(const struct device *dev, int16_t *x, int16_t *y) +{ + const struct paw32xx_config *cfg = dev->config; + int ret; + + uint8_t tx_data[] = { + PAW32XX_DELTA_X, + 0xff, + PAW32XX_DELTA_Y, + 0xff, + PAW32XX_DELTA_XY_HI, + 0xff, + }; + uint8_t rx_data[sizeof(tx_data)]; + + const struct spi_buf tx_buf = { + .buf = tx_data, + .len = sizeof(tx_data), + }; + const struct spi_buf_set tx = { + .buffers = &tx_buf, + .count = 1, + }; + + struct spi_buf rx_buf = { + .buf = rx_data, + .len = sizeof(rx_data), + }; + const struct spi_buf_set rx = { + .buffers = &rx_buf, + .count = 1, + }; + + ret = spi_transceive_dt(&cfg->spi, &tx, &rx); + if (ret < 0) { + return ret; + } + + *x = ((rx_data[5] << 4) & 0xf00) | rx_data[1]; + *y = ((rx_data[5] << 8) & 0xf00) | rx_data[3]; + + *x = sign_extend(*x, PAW32XX_DATA_SIZE_BITS - 1); + *y = sign_extend(*y, PAW32XX_DATA_SIZE_BITS - 1); + + return 0; +} + +static void paw32xx_motion_work_handler(struct k_work *work) +{ + struct paw32xx_data *data = CONTAINER_OF( + work, struct paw32xx_data, motion_work); + const struct device *dev = data->dev; + const struct paw32xx_config *cfg = dev->config; + uint8_t val; + int16_t x, y; + int ret; + + ret = paw32xx_read_reg(dev, PAW32XX_MOTION, &val); + if (ret < 0) { + return; + } + + if ((val & MOTION_STATUS_MOTION) == 0x00) { + return; + } + + ret = paw32xx_read_xy(dev, &x, &y); + if (ret < 0) { + return; + } + + LOG_DBG("x=%4d y=%4d", x, y); + + input_report_rel(data->dev, cfg->axis_x, x, false, K_FOREVER); + input_report_rel(data->dev, cfg->axis_y, y, true, K_FOREVER); + + /* Trigger one more scan in case more data is available. */ + k_work_submit(&data->motion_work); +} + +static void paw32xx_motion_handler(const struct device *gpio_dev, + struct gpio_callback *cb, + uint32_t pins) +{ + struct paw32xx_data *data = CONTAINER_OF( + cb, struct paw32xx_data, motion_cb); + + k_work_submit(&data->motion_work); +} + +int paw32xx_set_resolution(const struct device *dev, uint16_t res_cpi) +{ + uint8_t val; + int ret; + + if (!IN_RANGE(res_cpi, RES_MIN, RES_MAX)) { + LOG_ERR("res_cpi out of range: %d", res_cpi); + return -EINVAL; + } + + val = res_cpi / RES_STEP; + + ret = paw32xx_write_reg(dev, PAW32XX_WRITE_PROTECT, WRITE_PROTECT_DISABLE); + if (ret < 0) { + return ret; + } + + ret = paw32xx_write_reg(dev, PAW32XX_CPI_X, val); + if (ret < 0) { + return ret; + } + + ret = paw32xx_write_reg(dev, PAW32XX_CPI_Y, val); + if (ret < 0) { + return ret; + } + + ret = paw32xx_write_reg(dev, PAW32XX_WRITE_PROTECT, WRITE_PROTECT_ENABLE); + if (ret < 0) { + return ret; + } + + return 0; +} + +int paw32xx_force_awake(const struct device *dev, bool enable) +{ + uint8_t val = enable ? 0 : OPERATION_MODE_SLP_MASK; + int ret; + + ret = paw32xx_write_reg(dev, PAW32XX_WRITE_PROTECT, WRITE_PROTECT_DISABLE); + if (ret < 0) { + return ret; + } + + ret = paw32xx_update_reg(dev, PAW32XX_OPERATION_MODE, + OPERATION_MODE_SLP_MASK, val); + if (ret < 0) { + return ret; + } + + ret = paw32xx_write_reg(dev, PAW32XX_WRITE_PROTECT, WRITE_PROTECT_ENABLE); + if (ret < 0) { + return ret; + } + + return 0; +} + +static int paw32xx_configure(const struct device *dev) +{ + const struct paw32xx_config *cfg = dev->config; + uint8_t val; + int ret; + + ret = paw32xx_read_reg(dev, PAW32XX_PRODUCT_ID1, &val); + if (ret < 0) { + return ret; + } + + if (val != PRODUCT_ID_PAW32XX) { + LOG_ERR("Invalid product id: %02x", val); + return -ENOTSUP; + } + + ret = paw32xx_update_reg(dev, PAW32XX_CONFIGURATION, + CONFIGURATION_RESET, CONFIGURATION_RESET); + if (ret < 0) { + return ret; + } + + k_sleep(K_MSEC(RESET_DELAY_MS)); + + if (cfg->invert_x || cfg->invert_y) { + ret = paw32xx_write_reg(dev, PAW32XX_WRITE_PROTECT, WRITE_PROTECT_DISABLE); + if (ret < 0) { + return ret; + } + + ret = paw32xx_read_reg(dev, PAW32XX_MOUSE_OPTION, &val); + if (ret < 0) { + return ret; + } + + WRITE_BIT(val, MOUSE_OPTION_MOVX_INV_BIT, cfg->invert_x); + WRITE_BIT(val, MOUSE_OPTION_MOVY_INV_BIT, cfg->invert_y); + + ret = paw32xx_write_reg(dev, PAW32XX_MOUSE_OPTION, val); + if (ret < 0) { + return ret; + } + + ret = paw32xx_write_reg(dev, PAW32XX_WRITE_PROTECT, WRITE_PROTECT_ENABLE); + if (ret < 0) { + return ret; + } + } + + if (cfg->res_cpi > 0) { + paw32xx_set_resolution(dev, cfg->res_cpi); + } + + paw32xx_force_awake(dev, cfg->force_awake); + + return 0; +} + +static int paw32xx_init(const struct device *dev) +{ + const struct paw32xx_config *cfg = dev->config; + struct paw32xx_data *data = dev->data; + int ret; + + if (!spi_is_ready_dt(&cfg->spi)) { + LOG_ERR("%s is not ready", cfg->spi.bus->name); + return -ENODEV; + } + + data->dev = dev; + + k_work_init(&data->motion_work, paw32xx_motion_work_handler); + + if (!gpio_is_ready_dt(&cfg->motion_gpio)) { + LOG_ERR("%s is not ready", cfg->motion_gpio.port->name); + return -ENODEV; + } + + ret = gpio_pin_configure_dt(&cfg->motion_gpio, GPIO_INPUT); + if (ret != 0) { + LOG_ERR("Motion pin configuration failed: %d", ret); + return ret; + } + + gpio_init_callback(&data->motion_cb, paw32xx_motion_handler, + BIT(cfg->motion_gpio.pin)); + + ret = gpio_add_callback_dt(&cfg->motion_gpio, &data->motion_cb); + if (ret < 0) { + LOG_ERR("Could not set motion callback: %d", ret); + return ret; + } + + ret = paw32xx_configure(dev); + if (ret != 0) { + LOG_ERR("Device configuration failed: %d", ret); + return ret; + } + + ret = gpio_pin_interrupt_configure_dt(&cfg->motion_gpio, + GPIO_INT_EDGE_TO_ACTIVE); + if (ret != 0) { + LOG_ERR("Motion interrupt configuration failed: %d", ret); + return ret; + } + + ret = pm_device_runtime_enable(dev); + if (ret < 0) { + LOG_ERR("Failed to enable runtime power management: %d", ret); + return ret; + } + + return 0; +} + +#ifdef CONFIG_PM_DEVICE +static int paw32xx_pm_action(const struct device *dev, + enum pm_device_action action) +{ + int ret; + uint8_t val; + + switch (action) { + case PM_DEVICE_ACTION_SUSPEND: + val = CONFIGURATION_PD_ENH; + break; + case PM_DEVICE_ACTION_RESUME: + val = 0; + break; + default: + return -ENOTSUP; + } + + ret = paw32xx_update_reg(dev, PAW32XX_CONFIGURATION, + CONFIGURATION_PD_ENH, val); + if (ret < 0) { + return ret; + } + + return 0; +} +#endif + +#define PAW32XX_SPI_MODE (SPI_OP_MODE_MASTER | SPI_WORD_SET(8) | \ + SPI_MODE_CPOL | SPI_MODE_CPHA | SPI_TRANSFER_MSB) + +#define PAW32XX_INIT(n) \ + BUILD_ASSERT(IN_RANGE(DT_INST_PROP_OR(n, res_cpi, RES_MIN), \ + RES_MIN, RES_MAX), "invalid res-cpi"); \ + \ + static const struct paw32xx_config paw32xx_cfg_##n = { \ + .spi = SPI_DT_SPEC_INST_GET(n, PAW32XX_SPI_MODE, 0), \ + .motion_gpio = GPIO_DT_SPEC_INST_GET(n, motion_gpios), \ + .axis_x = DT_INST_PROP(n, zephyr_axis_x), \ + .axis_y = DT_INST_PROP(n, zephyr_axis_y), \ + .res_cpi = DT_INST_PROP_OR(n, res_cpi, -1), \ + .invert_x = DT_INST_PROP(n, invert_x), \ + .invert_y = DT_INST_PROP(n, invert_y), \ + .force_awake = DT_INST_PROP(n, force_awake), \ + }; \ + \ + static struct paw32xx_data paw32xx_data_##n; \ + \ + PM_DEVICE_DT_INST_DEFINE(n, paw32xx_pm_action); \ + \ + DEVICE_DT_INST_DEFINE(n, paw32xx_init, PM_DEVICE_DT_INST_GET(n), \ + &paw32xx_data_##n, &paw32xx_cfg_##n, \ + POST_KERNEL, CONFIG_INPUT_INIT_PRIORITY, \ + NULL); + +DT_INST_FOREACH_STATUS_OKAY(PAW32XX_INIT) diff --git a/dts/bindings/input/pixart,paw32xx.yaml b/dts/bindings/input/pixart,paw32xx.yaml new file mode 100644 index 0000000000..0df4424a3c --- /dev/null +++ b/dts/bindings/input/pixart,paw32xx.yaml @@ -0,0 +1,52 @@ +# Copyright 2024 Google LLC +# SPDX-License-Identifier: Apache-2.0 + +description: PAW32xx ultra low power wireless mouse chip + +compatible: "pixart,paw32xx" + +include: spi-device.yaml + +properties: + motion-gpios: + type: phandle-array + required: true + description: + GPIO connected to the motion pin, active low. + + zephyr,axis-x: + type: int + required: true + description: | + The input code for the X axis to report for the device, typically any of + INPUT_REL_*. No report produced for the device X axis if unspecified. + + zephyr,axis-y: + type: int + required: true + description: | + The input code for the Y axis to report for the device, typically any of + INPUT_REL_*. No report produced for the device Y axis if unspecified. + + res-cpi: + type: int + description: | + CPI resolution for the sensor. This can also be changed in runtime using + the paw32xx_set_resolution() API. + + invert-x: + type: boolean + description: | + Invert X axis values. + + invert-y: + type: boolean + description: | + Invert Y axis values. + + force-awake: + type: boolean + description: | + Initialize the sensor in "force awake" mode. This can also be enabled or + disabled in runtime by the application using the paw32xx_force_awake() + API. diff --git a/include/zephyr/input/input_paw32xx.h b/include/zephyr/input/input_paw32xx.h new file mode 100644 index 0000000000..ff425bda8b --- /dev/null +++ b/include/zephyr/input/input_paw32xx.h @@ -0,0 +1,26 @@ +/* + * Copyright 2024 Google LLC + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#ifndef ZEPHYR_INCLUDE_INPUT_PAW32XX_H_ +#define ZEPHYR_INCLUDE_INPUT_PAW32XX_H_ + +/** + * @brief Set resolution on a paw32xx device + * + * @param dev paw32xx device. + * @param res_cpi CPI resolution, 200 to 3200. + */ +int paw32xx_set_resolution(const struct device *dev, uint16_t res_cpi); + +/** + * @brief Set force awake mode on a paw32xx device + * + * @param dev paw32xx device. + * @param enable whether to enable or disable force awake mode. + */ +int paw32xx_force_awake(const struct device *dev, bool enable); + +#endif /* ZEPHYR_INCLUDE_INPUT_PAW32XX_H_ */ diff --git a/tests/drivers/build_all/input/app.overlay b/tests/drivers/build_all/input/app.overlay index 93e7bf1c14..23bd36a307 100644 --- a/tests/drivers/build_all/input/app.overlay +++ b/tests/drivers/build_all/input/app.overlay @@ -245,7 +245,8 @@ /* one entry for every devices */ cs-gpios = <&test_gpio 0 0>, <&test_gpio 1 0>, - <&test_gpio 2 0>; + <&test_gpio 2 0>, + <&test_gpio 3 0>; xpt2046@0 { compatible = "xptek,xpt2046"; @@ -286,6 +287,18 @@ invert-x; invert-y; }; + + paw32xx@3 { + compatible = "pixart,paw32xx"; + reg = <3>; + spi-max-frequency = <0>; + motion-gpios = <&test_gpio 0 0>; + zephyr,axis-x = <0>; + zephyr,axis-y = <1>; + invert-x; + invert-y; + res-cpi = <800>; + }; }; }; };