drivers/kscan/kscan_xpt2046.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2023 Seppo Takalo
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #define DT_DRV_COMPAT xptek_xpt2046

 #include <zephyr/kernel.h>
 #include <zephyr/drivers/spi.h>
 #include <zephyr/drivers/kscan.h>

 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(xpt2046, CONFIG_KSCAN_LOG_LEVEL);

 struct xpt2046_config {
 	const struct spi_dt_spec bus;
 	const struct gpio_dt_spec int_gpio;
 	uint16_t min_x;
 	uint16_t min_y;
 	uint16_t max_x;
 	uint16_t max_y;
 	uint16_t threshold;
 	uint16_t screen_size_x;
 	uint16_t screen_size_y;
 	uint16_t reads;
 };
 struct xpt2046_data {
 	const struct device *dev;
 	kscan_callback_t callback;
 	struct gpio_callback int_gpio_cb;
 	bool enabled;
 	struct k_work work;
 	struct k_work_delayable dwork;
 	uint8_t rbuf[9];
 	uint32_t last_x;
 	uint32_t last_y;
 	bool pressed;
 };

 enum xpt2046_channel {
 	CH_TEMP0 = 0,
 	CH_Y,
 	CH_VBAT,
 	CH_Z1,
 	CH_Z2,
 	CH_X,
 	CH_AUXIN,
 	CH_TEMP1
 };

 struct measurement {
 	uint32_t x;
 	uint32_t y;
 	uint32_t z;
 };

 #define START		      BIT(7)
 #define CHANNEL(ch)	      ((ch & 0x7) << 4)
 #define MODE_8_BIT	      BIT(3)
 #define SINGLE_ENDED	      BIT(2)
 #define POWER_OFF	      0
 #define POWER_ON	      0x03
 #define CONVERT_U16(buf, idx) ((uint16_t)((buf[idx] & 0x7f) << 5) | (buf[idx + 1] >> 3))

 /* Read all Z1, X, Y, Z2 channels using 16 Clocks-per-Conversion mode.
  * See the manual https://www.waveshare.com/w/upload/9/98/XPT2046-EN.pdf for details.
  * Each follow-up command interleaves with previous conversion.
  * So first command starts at byte 0. Second command starts at byte 2.
  */
 static uint8_t tbuf[9] = {
 	[0] = START | CHANNEL(CH_Z1) | POWER_ON,
 	[2] = START | CHANNEL(CH_Z2) | POWER_ON,
 	[4] = START | CHANNEL(CH_X) | POWER_ON,
 	[6] = START | CHANNEL(CH_Y) | POWER_OFF,
 };

 static void xpt2046_isr_handler(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
 {
 	struct xpt2046_data *data = CONTAINER_OF(cb, struct xpt2046_data, int_gpio_cb);
 	const struct xpt2046_config *config = data->dev->config;

 	gpio_remove_callback(config->int_gpio.port, &data->int_gpio_cb);
 	k_work_submit(&data->work);
 }

 static int xpt2046_read_and_cumulate(const struct spi_dt_spec *bus, const struct spi_buf_set *tx,
 				     const struct spi_buf_set *rx, struct measurement *meas)
 {
 	int ret = spi_transceive_dt(bus, tx, rx);

 	if (ret < 0) {
 		LOG_ERR("spi_transceive() %d\n", ret);
 		return ret;
 	}

 	uint8_t *buf = rx->buffers->buf;

 	meas->z += CONVERT_U16(buf, 1) + 4096 - CONVERT_U16(buf, 3);
 	meas->x += CONVERT_U16(buf, 5);
 	meas->y += CONVERT_U16(buf, 7);

 	return 0;
 }

 static void xpt2046_release_handler(struct k_work *kw)
 {
 	struct k_work_delayable *dw = k_work_delayable_from_work(kw);
 	struct xpt2046_data *data = CONTAINER_OF(dw, struct xpt2046_data, dwork);
 	struct xpt2046_config *config = (struct xpt2046_config *)data->dev->config;

 	if (!data->pressed || !data->enabled) {
 		return;
 	}

 	/* Check if touch is still pressed */
 	if (gpio_pin_get_dt(&config->int_gpio) == 0) {
 		data->pressed = false;
 		data->callback(data->dev, data->last_y, data->last_y, false);
 	} else {
 		/* Re-check later */
 		k_work_reschedule(&data->dwork, K_MSEC(10));
 	}
 }

 static void xpt2046_work_handler(struct k_work *kw)
 {
 	struct xpt2046_data *data = CONTAINER_OF(kw, struct xpt2046_data, work);
 	struct xpt2046_config *config = (struct xpt2046_config *)data->dev->config;

 	const struct spi_buf txb = {.buf = tbuf, .len = sizeof(tbuf)};
 	const struct spi_buf rxb = {.buf = data->rbuf, .len = sizeof(data->rbuf)};
 	const struct spi_buf_set tx_bufs = {.buffers = &txb, .count = 1};
 	const struct spi_buf_set rx_bufs = {.buffers = &rxb, .count = 1};

 	/* Run number of reads and calculate average */
 	int rounds = config->reads;
 	struct measurement meas = {0};

 	for (int i = 0; i < rounds; i++) {
 		if (xpt2046_read_and_cumulate(&config->bus, &tx_bufs, &rx_bufs, &meas) != 0) {
 			return;
 		}
 	}
 	meas.x /= rounds;
 	meas.y /= rounds;
 	meas.z /= rounds;

 	/* Calculate Xp = M * Xt + C using fixed point aritchmetics, where
 	 * Xp is the point in screen coordinates, Xt is the touch coordinates.
 	 * Use signed int32_t for calculation to ensure that we cover the roll-over to negative
 	 * values and return zero instead.
 	 */
 	int32_t mx = (config->screen_size_x << 16) / (config->max_x - config->min_x);
 	int32_t cx = (config->screen_size_x << 16) - mx * config->max_x;
 	int32_t x = mx * meas.x + cx;

 	x = (x < 0 ? 0 : x) >> 16;

 	int32_t my = (config->screen_size_y << 16) / (config->max_y - config->min_y);
 	int32_t cy = (config->screen_size_y << 16) - my * config->max_y;
 	int32_t y = my * meas.y + cy;

 	y = (y < 0 ? 0 : y) >> 16;

 	bool pressed = meas.z > config->threshold;

 	/* Don't send any other than "pressed" events.
 	 * releasing seem to cause just random noise
 	 */
 	if (data->enabled && pressed) {
 		LOG_DBG("raw: x=%4u y=%4u ==> x=%4d y=%4d", meas.x, meas.y, x, y);
 		data->last_x = x;
 		data->last_y = y;
 		data->pressed = pressed;
 		data->callback(data->dev, (uint32_t)y, (uint32_t)x, pressed);
 		/* Ensure that we send released event */
 		k_work_reschedule(&data->dwork, K_MSEC(100));
 	}
 	gpio_add_callback(config->int_gpio.port, &data->int_gpio_cb);
 }

 static int xpt2046_configure(const struct device *dev, kscan_callback_t callback)
 {
 	struct xpt2046_data *data = dev->data;

 	if (!callback) {
 		LOG_ERR("Callback is null");
 		return -EINVAL;
 	}
 	LOG_DBG("%s: set callback", dev->name);

 	data->callback = callback;

 	return 0;
 }

 static int xpt2046_enable_callback(const struct device *dev)
 {
 	struct xpt2046_data *data = dev->data;
 	const struct xpt2046_config *config = dev->config;

 	LOG_DBG("%s: enable cb", dev->name);
 	data->enabled = true;
 	gpio_add_callback(config->int_gpio.port, &data->int_gpio_cb);

 	return 0;
 }

 static int xpt2046_disable_callback(const struct device *dev)
 {
 	struct xpt2046_data *data = dev->data;
 	const struct xpt2046_config *config = dev->config;

 	gpio_remove_callback(config->int_gpio.port, &data->int_gpio_cb);
 	data->enabled = false;

 	LOG_DBG("%s: disable cb", dev->name);

 	return 0;
 }

 static int xpt2046_init(const struct device *dev)
 {
 	int r;
 	const struct xpt2046_config *config = dev->config;
 	struct xpt2046_data *data = dev->data;

 	if (!spi_is_ready_dt(&config->bus)) {
 		LOG_ERR("SPI controller device not ready");
 		return -ENODEV;
 	}

 	data->dev = dev;
 	k_work_init(&data->work, xpt2046_work_handler);
 	k_work_init_delayable(&data->dwork, xpt2046_release_handler);

 	if (!gpio_is_ready_dt(&config->int_gpio)) {
 		LOG_ERR("Interrupt GPIO controller device not ready");
 		return -ENODEV;
 	}

 	r = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
 	if (r < 0) {
 		LOG_ERR("Could not configure interrupt GPIO pin");
 		return r;
 	}

 	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, xpt2046_isr_handler, BIT(config->int_gpio.pin));

 	LOG_INF("Init '%s' device", dev->name);

 	return 0;
 }

 static const struct kscan_driver_api xpt2046_driver_api = {
 	.config = xpt2046_configure,
 	.enable_callback = xpt2046_enable_callback,
 	.disable_callback = xpt2046_disable_callback,
 };

 #define XPT2046_INIT(index)                                                                        \
 	static const struct xpt2046_config xpt2046_config_##index = {                              \
 		.bus = SPI_DT_SPEC_INST_GET(                                                       \
 			index, SPI_OP_MODE_MASTER | SPI_TRANSFER_MSB | SPI_WORD_SET(8), 0),        \
 		.int_gpio = GPIO_DT_SPEC_INST_GET(index, int_gpios),                               \
 		.min_x = DT_INST_PROP(index, min_x),                                               \
 		.min_y = DT_INST_PROP(index, min_y),                                               \
 		.max_x = DT_INST_PROP(index, max_x),                                               \
 		.max_y = DT_INST_PROP(index, max_y),                                               \
 		.threshold = DT_INST_PROP(index, z_threshold),                                     \
 		.screen_size_x = DT_INST_PROP(index, touchscreen_size_x),                          \
 		.screen_size_y = DT_INST_PROP(index, touchscreen_size_y),                          \
 		.reads = DT_INST_PROP(index, reads),                                               \
 	};                                                                                         \
 	static struct xpt2046_data xpt2046_data_##index;                                           \
 	DEVICE_DT_INST_DEFINE(index, xpt2046_init, NULL, &xpt2046_data_##index,                    \
 			      &xpt2046_config_##index, POST_KERNEL, CONFIG_KSCAN_INIT_PRIORITY,    \
 			      &xpt2046_driver_api);                                                \
 	BUILD_ASSERT(DT_INST_PROP(index, min_x) < DT_INST_PROP(index, max_x),                      \
 		     "min_x must be less than max_x");                                             \
 	BUILD_ASSERT(DT_INST_PROP(index, min_y) < DT_INST_PROP(index, max_y),                      \
 		     "min_y must be less than max_y");                                             \
 	BUILD_ASSERT(DT_INST_PROP(index, z_threshold) > 10, "Too small threshold");                \
 	BUILD_ASSERT(DT_INST_PROP(index, touchscreen_size_x) > 1 &&                                \
 			     DT_INST_PROP(index, touchscreen_size_y) > 1,                          \
 		     "Screen size undefined");                                                     \
 	BUILD_ASSERT(DT_INST_PROP(index, reads) > 0, "Number of reads must be at least one");

 DT_INST_FOREACH_STATUS_OKAY(XPT2046_INIT)
	/*
	* Copyright (c) 2023 Seppo Takalo
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#define DT_DRV_COMPAT xptek_xpt2046

	#include <zephyr/kernel.h>
	#include <zephyr/drivers/spi.h>
	#include <zephyr/drivers/kscan.h>

	#include <zephyr/logging/log.h>
	LOG_MODULE_REGISTER(xpt2046, CONFIG_KSCAN_LOG_LEVEL);

	struct xpt2046_config {
	const struct spi_dt_spec bus;
	const struct gpio_dt_spec int_gpio;
	uint16_t min_x;
	uint16_t min_y;
	uint16_t max_x;
	uint16_t max_y;
	uint16_t threshold;
	uint16_t screen_size_x;
	uint16_t screen_size_y;
	uint16_t reads;
	};
	struct xpt2046_data {
	const struct device *dev;
	kscan_callback_t callback;
	struct gpio_callback int_gpio_cb;
	bool enabled;
	struct k_work work;
	struct k_work_delayable dwork;
	uint8_t rbuf[9];
	uint32_t last_x;
	uint32_t last_y;
	bool pressed;
	};

	enum xpt2046_channel {
	CH_TEMP0 = 0,
	CH_Y,
	CH_VBAT,
	CH_Z1,
	CH_Z2,
	CH_X,
	CH_AUXIN,
	CH_TEMP1
	};

	struct measurement {
	uint32_t x;
	uint32_t y;
	uint32_t z;
	};

	#define START BIT(7)
	#define CHANNEL(ch) ((ch & 0x7) << 4)
	#define MODE_8_BIT BIT(3)
	#define SINGLE_ENDED BIT(2)
	#define POWER_OFF 0
	#define POWER_ON 0x03
	#define CONVERT_U16(buf, idx) ((uint16_t)((buf[idx] & 0x7f) << 5) \| (buf[idx + 1] >> 3))

	/* Read all Z1, X, Y, Z2 channels using 16 Clocks-per-Conversion mode.
	* See the manual https://www.waveshare.com/w/upload/9/98/XPT2046-EN.pdf for details.
	* Each follow-up command interleaves with previous conversion.
	* So first command starts at byte 0. Second command starts at byte 2.
	*/
	static uint8_t tbuf[9] = {
	[0] = START \| CHANNEL(CH_Z1) \| POWER_ON,
	[2] = START \| CHANNEL(CH_Z2) \| POWER_ON,
	[4] = START \| CHANNEL(CH_X) \| POWER_ON,
	[6] = START \| CHANNEL(CH_Y) \| POWER_OFF,
	};

	static void xpt2046_isr_handler(const struct device dev, struct gpio_callback cb, uint32_t pins)
	{
	struct xpt2046_data *data = CONTAINER_OF(cb, struct xpt2046_data, int_gpio_cb);
	const struct xpt2046_config *config = data->dev->config;

	gpio_remove_callback(config->int_gpio.port, &data->int_gpio_cb);
	k_work_submit(&data->work);
	}

	static int xpt2046_read_and_cumulate(const struct spi_dt_spec bus, const struct spi_buf_set tx,
	const struct spi_buf_set rx, struct measurement meas)
	{
	int ret = spi_transceive_dt(bus, tx, rx);

	if (ret < 0) {
	LOG_ERR("spi_transceive() %d\n", ret);
	return ret;
	}

	uint8_t *buf = rx->buffers->buf;

	meas->z += CONVERT_U16(buf, 1) + 4096 - CONVERT_U16(buf, 3);
	meas->x += CONVERT_U16(buf, 5);
	meas->y += CONVERT_U16(buf, 7);

	return 0;
	}

	static void xpt2046_release_handler(struct k_work *kw)
	{
	struct k_work_delayable *dw = k_work_delayable_from_work(kw);
	struct xpt2046_data *data = CONTAINER_OF(dw, struct xpt2046_data, dwork);
	struct xpt2046_config config = (struct xpt2046_config )data->dev->config;

	if (!data->pressed \|\| !data->enabled) {
	return;
	}

	/* Check if touch is still pressed */
	if (gpio_pin_get_dt(&config->int_gpio) == 0) {
	data->pressed = false;
	data->callback(data->dev, data->last_y, data->last_y, false);
	} else {
	/* Re-check later */
	k_work_reschedule(&data->dwork, K_MSEC(10));
	}
	}

	static void xpt2046_work_handler(struct k_work *kw)
	{
	struct xpt2046_data *data = CONTAINER_OF(kw, struct xpt2046_data, work);
	struct xpt2046_config config = (struct xpt2046_config )data->dev->config;

	const struct spi_buf txb = {.buf = tbuf, .len = sizeof(tbuf)};
	const struct spi_buf rxb = {.buf = data->rbuf, .len = sizeof(data->rbuf)};
	const struct spi_buf_set tx_bufs = {.buffers = &txb, .count = 1};
	const struct spi_buf_set rx_bufs = {.buffers = &rxb, .count = 1};

	/* Run number of reads and calculate average */
	int rounds = config->reads;
	struct measurement meas = {0};

	for (int i = 0; i < rounds; i++) {
	if (xpt2046_read_and_cumulate(&config->bus, &tx_bufs, &rx_bufs, &meas) != 0) {
	return;
	}
	}
	meas.x /= rounds;
	meas.y /= rounds;
	meas.z /= rounds;

	/* Calculate Xp = M * Xt + C using fixed point aritchmetics, where
	* Xp is the point in screen coordinates, Xt is the touch coordinates.
	* Use signed int32_t for calculation to ensure that we cover the roll-over to negative
	* values and return zero instead.
	*/
	int32_t mx = (config->screen_size_x << 16) / (config->max_x - config->min_x);
	int32_t cx = (config->screen_size_x << 16) - mx * config->max_x;
	int32_t x = mx * meas.x + cx;

	x = (x < 0 ? 0 : x) >> 16;

	int32_t my = (config->screen_size_y << 16) / (config->max_y - config->min_y);
	int32_t cy = (config->screen_size_y << 16) - my * config->max_y;
	int32_t y = my * meas.y + cy;

	y = (y < 0 ? 0 : y) >> 16;

	bool pressed = meas.z > config->threshold;

	/* Don't send any other than "pressed" events.
	* releasing seem to cause just random noise
	*/
	if (data->enabled && pressed) {
	LOG_DBG("raw: x=%4u y=%4u ==> x=%4d y=%4d", meas.x, meas.y, x, y);
	data->last_x = x;
	data->last_y = y;
	data->pressed = pressed;
	data->callback(data->dev, (uint32_t)y, (uint32_t)x, pressed);
	/* Ensure that we send released event */
	k_work_reschedule(&data->dwork, K_MSEC(100));
	}
	gpio_add_callback(config->int_gpio.port, &data->int_gpio_cb);
	}

	static int xpt2046_configure(const struct device *dev, kscan_callback_t callback)
	{
	struct xpt2046_data *data = dev->data;

	if (!callback) {
	LOG_ERR("Callback is null");
	return -EINVAL;
	}
	LOG_DBG("%s: set callback", dev->name);

	data->callback = callback;

	return 0;
	}

	static int xpt2046_enable_callback(const struct device *dev)
	{
	struct xpt2046_data *data = dev->data;
	const struct xpt2046_config *config = dev->config;

	LOG_DBG("%s: enable cb", dev->name);
	data->enabled = true;
	gpio_add_callback(config->int_gpio.port, &data->int_gpio_cb);

	return 0;
	}

	static int xpt2046_disable_callback(const struct device *dev)
	{
	struct xpt2046_data *data = dev->data;
	const struct xpt2046_config *config = dev->config;

	gpio_remove_callback(config->int_gpio.port, &data->int_gpio_cb);
	data->enabled = false;

	LOG_DBG("%s: disable cb", dev->name);

	return 0;
	}

	static int xpt2046_init(const struct device *dev)
	{
	int r;
	const struct xpt2046_config *config = dev->config;
	struct xpt2046_data *data = dev->data;

	if (!spi_is_ready_dt(&config->bus)) {
	LOG_ERR("SPI controller device not ready");
	return -ENODEV;
	}

	data->dev = dev;
	k_work_init(&data->work, xpt2046_work_handler);
	k_work_init_delayable(&data->dwork, xpt2046_release_handler);

	if (!gpio_is_ready_dt(&config->int_gpio)) {
	LOG_ERR("Interrupt GPIO controller device not ready");
	return -ENODEV;
	}

	r = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
	if (r < 0) {
	LOG_ERR("Could not configure interrupt GPIO pin");
	return r;
	}

	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, xpt2046_isr_handler, BIT(config->int_gpio.pin));

	LOG_INF("Init '%s' device", dev->name);

	return 0;
	}

	static const struct kscan_driver_api xpt2046_driver_api = {
	.config = xpt2046_configure,
	.enable_callback = xpt2046_enable_callback,
	.disable_callback = xpt2046_disable_callback,
	};

	#define XPT2046_INIT(index) \
	static const struct xpt2046_config xpt2046_config_##index = { \
	.bus = SPI_DT_SPEC_INST_GET( \
	index, SPI_OP_MODE_MASTER \| SPI_TRANSFER_MSB \| SPI_WORD_SET(8), 0), \
	.int_gpio = GPIO_DT_SPEC_INST_GET(index, int_gpios), \
	.min_x = DT_INST_PROP(index, min_x), \
	.min_y = DT_INST_PROP(index, min_y), \
	.max_x = DT_INST_PROP(index, max_x), \
	.max_y = DT_INST_PROP(index, max_y), \
	.threshold = DT_INST_PROP(index, z_threshold), \
	.screen_size_x = DT_INST_PROP(index, touchscreen_size_x), \
	.screen_size_y = DT_INST_PROP(index, touchscreen_size_y), \
	.reads = DT_INST_PROP(index, reads), \
	}; \
	static struct xpt2046_data xpt2046_data_##index; \
	DEVICE_DT_INST_DEFINE(index, xpt2046_init, NULL, &xpt2046_data_##index, \
	&xpt2046_config_##index, POST_KERNEL, CONFIG_KSCAN_INIT_PRIORITY, \
	&xpt2046_driver_api); \
	BUILD_ASSERT(DT_INST_PROP(index, min_x) < DT_INST_PROP(index, max_x), \
	"min_x must be less than max_x"); \
	BUILD_ASSERT(DT_INST_PROP(index, min_y) < DT_INST_PROP(index, max_y), \
	"min_y must be less than max_y"); \
	BUILD_ASSERT(DT_INST_PROP(index, z_threshold) > 10, "Too small threshold"); \
	BUILD_ASSERT(DT_INST_PROP(index, touchscreen_size_x) > 1 && \
	DT_INST_PROP(index, touchscreen_size_y) > 1, \
	"Screen size undefined"); \
	BUILD_ASSERT(DT_INST_PROP(index, reads) > 0, "Number of reads must be at least one");

	DT_INST_FOREACH_STATUS_OKAY(XPT2046_INIT)