drivers/input/input_paw32xx.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright 2024 Google LLC
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #define DT_DRV_COMPAT pixart_paw32xx

 #include <stdint.h>
 #include <stdlib.h>

 #include <zephyr/device.h>
 #include <zephyr/drivers/gpio.h>
 #include <zephyr/drivers/spi.h>
 #include <zephyr/input/input.h>
 #include <zephyr/input/input_paw32xx.h>
 #include <zephyr/kernel.h>
 #include <zephyr/logging/log.h>
 #include <zephyr/pm/device.h>
 #include <zephyr/pm/device_runtime.h>
 #include <zephyr/sys/util.h>

 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 if more data is available. */
 	if (gpio_pin_get_dt(&cfg->motion_gpio)) {
 		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)
	/*
	* Copyright 2024 Google LLC
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#define DT_DRV_COMPAT pixart_paw32xx

	#include <stdint.h>
	#include <stdlib.h>

	#include <zephyr/device.h>
	#include <zephyr/drivers/gpio.h>
	#include <zephyr/drivers/spi.h>
	#include <zephyr/input/input.h>
	#include <zephyr/input/input_paw32xx.h>
	#include <zephyr/kernel.h>
	#include <zephyr/logging/log.h>
	#include <zephyr/pm/device.h>
	#include <zephyr/pm/device_runtime.h>
	#include <zephyr/sys/util.h>

	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 if more data is available. */
	if (gpio_pin_get_dt(&cfg->motion_gpio)) {
	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)