drivers/input/touchscreen/himax_hx852x.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Himax HX852x(ES) Touchscreen Driver
 * Copyright (c) 2020-2024 Stephan Gerhold <stephan@gerhold.net>
 * Copyright (c) 2020 Jonathan Albrieux <jonathan.albrieux@gmail.com>
 *
 * Based on the Himax Android Driver Sample Code Ver 0.3 for HMX852xES chipset:
 * Copyright (c) 2014 Himax Corporation.
 */

#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/input/touchscreen.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/regulator/consumer.h>
#include <linux/unaligned.h>

#define HX852X_COORD_SIZE(fingers)	((fingers) * sizeof(struct hx852x_coord))
#define HX852X_WIDTH_SIZE(fingers)	ALIGN(fingers, 4)
#define HX852X_BUF_SIZE(fingers)	(HX852X_COORD_SIZE(fingers) + \
					 HX852X_WIDTH_SIZE(fingers) + \
					 sizeof(struct hx852x_touch_info))

#define HX852X_MAX_FINGERS		12
#define HX852X_MAX_KEY_COUNT		4
#define HX852X_MAX_BUF_SIZE		HX852X_BUF_SIZE(HX852X_MAX_FINGERS)

#define HX852X_TS_SLEEP_IN		0x80
#define HX852X_TS_SLEEP_OUT		0x81
#define HX852X_TS_SENSE_OFF		0x82
#define HX852X_TS_SENSE_ON		0x83
#define HX852X_READ_ONE_EVENT		0x85
#define HX852X_READ_ALL_EVENTS		0x86
#define HX852X_READ_LATEST_EVENT	0x87
#define HX852X_CLEAR_EVENT_STACK	0x88

#define HX852X_REG_SRAM_SWITCH		0x8c
#define HX852X_REG_SRAM_ADDR		0x8b
#define HX852X_REG_FLASH_RPLACE		0x5a

#define HX852X_SRAM_SWITCH_TEST_MODE	0x14
#define HX852X_SRAM_ADDR_CONFIG		0x7000

struct hx852x {
	struct i2c_client *client;
	struct input_dev *input_dev;
	struct touchscreen_properties props;
	struct gpio_desc *reset_gpiod;
	struct regulator_bulk_data supplies[2];
	unsigned int max_fingers;
	unsigned int keycount;
	unsigned int keycodes[HX852X_MAX_KEY_COUNT];
};

struct hx852x_config {
	u8 rx_num;
	u8 tx_num;
	u8 max_pt;
	u8 padding1[3];
	__be16 x_res;
	__be16 y_res;
	u8 padding2[2];
} __packed __aligned(4);

struct hx852x_coord {
	__be16 x;
	__be16 y;
} __packed __aligned(4);

struct hx852x_touch_info {
	u8 finger_num;
	__le16 finger_pressed;
	u8 padding;
} __packed __aligned(4);

static int hx852x_i2c_read(struct hx852x *hx, u8 cmd, void *data, u16 len)
{
	struct i2c_client *client = hx->client;
	int error;
	int ret;

	struct i2c_msg msg[] = {
		{
			.addr = client->addr,
			.flags = 0,
			.len = 1,
			.buf = &cmd,
		},
		{
			.addr = client->addr,
			.flags = I2C_M_RD,
			.len = len,
			.buf = data,
		},
	};

	ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
	if (ret != ARRAY_SIZE(msg)) {
		error = ret < 0 ? ret : -EIO;
		dev_err(&client->dev, "failed to read %#x: %d\n", cmd, error);
		return error;
	}

	return 0;
}

static int hx852x_power_on(struct hx852x *hx)
{
	struct device *dev = &hx->client->dev;
	int error;

	error = regulator_bulk_enable(ARRAY_SIZE(hx->supplies), hx->supplies);
	if (error) {
		dev_err(dev, "failed to enable regulators: %d\n", error);
		return error;
	}

	gpiod_set_value_cansleep(hx->reset_gpiod, 1);
	msleep(20);
	gpiod_set_value_cansleep(hx->reset_gpiod, 0);
	msleep(50);

	return 0;
}

static int hx852x_start(struct hx852x *hx)
{
	struct device *dev = &hx->client->dev;
	int error;

	error = i2c_smbus_write_byte(hx->client, HX852X_TS_SLEEP_OUT);
	if (error) {
		dev_err(dev, "failed to send TS_SLEEP_OUT: %d\n", error);
		return error;
	}
	msleep(30);

	error = i2c_smbus_write_byte(hx->client, HX852X_TS_SENSE_ON);
	if (error) {
		dev_err(dev, "failed to send TS_SENSE_ON: %d\n", error);
		return error;
	}
	msleep(20);

	return 0;
}

static int hx852x_stop(struct hx852x *hx)
{
	struct device *dev = &hx->client->dev;
	int error;

	error = i2c_smbus_write_byte(hx->client, HX852X_TS_SENSE_OFF);
	if (error) {
		dev_err(dev, "failed to send TS_SENSE_OFF: %d\n", error);
		return error;
	}
	msleep(20);

	error = i2c_smbus_write_byte(hx->client, HX852X_TS_SLEEP_IN);
	if (error) {
		dev_err(dev, "failed to send TS_SLEEP_IN: %d\n", error);
		return error;
	}
	msleep(30);

	return 0;
}

static int hx852x_power_off(struct hx852x *hx)
{
	struct device *dev = &hx->client->dev;
	int error;

	error = regulator_bulk_disable(ARRAY_SIZE(hx->supplies), hx->supplies);
	if (error) {
		dev_err(dev, "failed to disable regulators: %d\n", error);
		return error;
	}

	return 0;
}

static int hx852x_read_config(struct hx852x *hx)
{
	struct device *dev = &hx->client->dev;
	struct hx852x_config conf;
	int x_res, y_res;
	int error, error2;

	error = hx852x_power_on(hx);
	if (error)
		return error;

	/* Sensing must be turned on briefly to load the config */
	error = hx852x_start(hx);
	if (error)
		goto err_power_off;

	error = hx852x_stop(hx);
	if (error)
		goto err_power_off;

	error = i2c_smbus_write_byte_data(hx->client, HX852X_REG_SRAM_SWITCH,
					  HX852X_SRAM_SWITCH_TEST_MODE);
	if (error)
		goto err_power_off;

	error = i2c_smbus_write_word_data(hx->client, HX852X_REG_SRAM_ADDR,
					  HX852X_SRAM_ADDR_CONFIG);
	if (error)
		goto err_test_mode;

	error = hx852x_i2c_read(hx, HX852X_REG_FLASH_RPLACE, &conf, sizeof(conf));
	if (error)
		goto err_test_mode;

	x_res = be16_to_cpu(conf.x_res);
	y_res = be16_to_cpu(conf.y_res);
	hx->max_fingers = (conf.max_pt & 0xf0) >> 4;
	dev_dbg(dev, "x res: %u, y res: %u, max fingers: %u\n",
		x_res, y_res, hx->max_fingers);

	if (hx->max_fingers > HX852X_MAX_FINGERS) {
		dev_err(dev, "max supported fingers: %u, found: %u\n",
			HX852X_MAX_FINGERS, hx->max_fingers);
		error = -EINVAL;
		goto err_test_mode;
	}

	if (x_res && y_res) {
		input_set_abs_params(hx->input_dev, ABS_MT_POSITION_X, 0, x_res - 1, 0, 0);
		input_set_abs_params(hx->input_dev, ABS_MT_POSITION_Y, 0, y_res - 1, 0, 0);
	}

err_test_mode:
	error2 = i2c_smbus_write_byte_data(hx->client, HX852X_REG_SRAM_SWITCH, 0);
	error = error ?: error2;
err_power_off:
	error2 = hx852x_power_off(hx);
	return error ?: error2;
}

static int hx852x_handle_events(struct hx852x *hx)
{
	/*
	 * The event packets have variable size, depending on the amount of
	 * supported fingers (hx->max_fingers). They are laid out as follows:
	 *  - struct hx852x_coord[hx->max_fingers]: Coordinates for each finger
	 *  - u8[ALIGN(hx->max_fingers, 4)]: Touch width for each finger
	 *      with padding for 32-bit alignment
	 *  - struct hx852x_touch_info
	 *
	 * Load everything into a 32-bit aligned buffer so the coordinates
	 * can be assigned directly, without using get_unaligned_*().
	 */
	u8 buf[HX852X_MAX_BUF_SIZE] __aligned(4);
	struct hx852x_coord *coord = (struct hx852x_coord *)buf;
	u8 *width = &buf[HX852X_COORD_SIZE(hx->max_fingers)];
	struct hx852x_touch_info *info = (struct hx852x_touch_info *)
		&width[HX852X_WIDTH_SIZE(hx->max_fingers)];
	unsigned long finger_pressed, key_pressed;
	unsigned int i, x, y, w;
	int error;

	error = hx852x_i2c_read(hx, HX852X_READ_ALL_EVENTS, buf,
				HX852X_BUF_SIZE(hx->max_fingers));
	if (error)
		return error;

	finger_pressed = get_unaligned_le16(&info->finger_pressed);
	key_pressed = finger_pressed >> HX852X_MAX_FINGERS;

	/* All bits are set when no touch is detected */
	if (info->finger_num == 0xff || !(info->finger_num & 0x0f))
		finger_pressed = 0;
	if (key_pressed == 0xf)
		key_pressed = 0;

	for_each_set_bit(i, &finger_pressed, hx->max_fingers) {
		x = be16_to_cpu(coord[i].x);
		y = be16_to_cpu(coord[i].y);
		w = width[i];

		input_mt_slot(hx->input_dev, i);
		input_mt_report_slot_state(hx->input_dev, MT_TOOL_FINGER, 1);
		touchscreen_report_pos(hx->input_dev, &hx->props, x, y, true);
		input_report_abs(hx->input_dev, ABS_MT_TOUCH_MAJOR, w);
	}
	input_mt_sync_frame(hx->input_dev);

	for (i = 0; i < hx->keycount; i++)
		input_report_key(hx->input_dev, hx->keycodes[i], key_pressed & BIT(i));

	input_sync(hx->input_dev);
	return 0;
}

static irqreturn_t hx852x_interrupt(int irq, void *ptr)
{
	struct hx852x *hx = ptr;
	int error;

	error = hx852x_handle_events(hx);
	if (error) {
		dev_err_ratelimited(&hx->client->dev,
				    "failed to handle events: %d\n", error);
		return IRQ_NONE;
	}

	return IRQ_HANDLED;
}

static int hx852x_input_open(struct input_dev *dev)
{
	struct hx852x *hx = input_get_drvdata(dev);
	int error;

	error = hx852x_power_on(hx);
	if (error)
		return error;

	error = hx852x_start(hx);
	if (error) {
		hx852x_power_off(hx);
		return error;
	}

	enable_irq(hx->client->irq);
	return 0;
}

static void hx852x_input_close(struct input_dev *dev)
{
	struct hx852x *hx = input_get_drvdata(dev);

	hx852x_stop(hx);
	disable_irq(hx->client->irq);
	hx852x_power_off(hx);
}

static int hx852x_parse_properties(struct hx852x *hx)
{
	struct device *dev = &hx->client->dev;
	int error, count;

	count = device_property_count_u32(dev, "linux,keycodes");
	if (count == -EINVAL) {
		/* Property does not exist, keycodes are optional */
		return 0;
	} else if (count < 0) {
		dev_err(dev, "Failed to read linux,keycodes: %d\n", count);
		return count;
	} else if (count > HX852X_MAX_KEY_COUNT) {
		dev_err(dev, "max supported keys: %u, found: %u\n",
			HX852X_MAX_KEY_COUNT, hx->keycount);
		return -EINVAL;
	}
	hx->keycount = count;

	error = device_property_read_u32_array(dev, "linux,keycodes",
					       hx->keycodes, hx->keycount);
	if (error) {
		dev_err(dev, "failed to read linux,keycodes: %d\n", error);
		return error;
	}

	return 0;
}

static int hx852x_probe(struct i2c_client *client)
{
	struct device *dev = &client->dev;
	struct hx852x *hx;
	int error, i;

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
				     I2C_FUNC_SMBUS_WRITE_BYTE |
				     I2C_FUNC_SMBUS_WRITE_BYTE_DATA |
				     I2C_FUNC_SMBUS_WRITE_WORD_DATA)) {
		dev_err(dev, "not all required i2c functionality supported\n");
		return -ENXIO;
	}

	hx = devm_kzalloc(dev, sizeof(*hx), GFP_KERNEL);
	if (!hx)
		return -ENOMEM;

	hx->client = client;
	hx->input_dev = devm_input_allocate_device(dev);
	if (!hx->input_dev)
		return -ENOMEM;

	hx->input_dev->name = "Himax HX852x";
	hx->input_dev->id.bustype = BUS_I2C;
	hx->input_dev->open = hx852x_input_open;
	hx->input_dev->close = hx852x_input_close;

	i2c_set_clientdata(client, hx);
	input_set_drvdata(hx->input_dev, hx);

	hx->supplies[0].supply = "vcca";
	hx->supplies[1].supply = "vccd";
	error = devm_regulator_bulk_get(dev, ARRAY_SIZE(hx->supplies), hx->supplies);
	if (error)
		return dev_err_probe(dev, error, "failed to get regulators\n");

	hx->reset_gpiod = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
	if (IS_ERR(hx->reset_gpiod))
		return dev_err_probe(dev, PTR_ERR(hx->reset_gpiod),
				     "failed to get reset gpio\n");

	error = devm_request_threaded_irq(dev, client->irq, NULL, hx852x_interrupt,
					  IRQF_ONESHOT | IRQF_NO_AUTOEN, NULL, hx);
	if (error)
		return dev_err_probe(dev, error, "failed to request irq %d", client->irq);

	error = hx852x_read_config(hx);
	if (error)
		return error;

	input_set_capability(hx->input_dev, EV_ABS, ABS_MT_POSITION_X);
	input_set_capability(hx->input_dev, EV_ABS, ABS_MT_POSITION_Y);
	input_set_abs_params(hx->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);

	touchscreen_parse_properties(hx->input_dev, true, &hx->props);
	error = hx852x_parse_properties(hx);
	if (error)
		return error;

	hx->input_dev->keycode = hx->keycodes;
	hx->input_dev->keycodemax = hx->keycount;
	hx->input_dev->keycodesize = sizeof(hx->keycodes[0]);
	for (i = 0; i < hx->keycount; i++)
		input_set_capability(hx->input_dev, EV_KEY, hx->keycodes[i]);

	error = input_mt_init_slots(hx->input_dev, hx->max_fingers,
				    INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
	if (error)
		return dev_err_probe(dev, error, "failed to init MT slots\n");

	error = input_register_device(hx->input_dev);
	if (error)
		return dev_err_probe(dev, error, "failed to register input device\n");

	return 0;
}

static int hx852x_suspend(struct device *dev)
{
	struct hx852x *hx = dev_get_drvdata(dev);

	guard(mutex)(&hx->input_dev->mutex);

	if (input_device_enabled(hx->input_dev))
		return hx852x_stop(hx);

	return 0;
}

static int hx852x_resume(struct device *dev)
{
	struct hx852x *hx = dev_get_drvdata(dev);

	guard(mutex)(&hx->input_dev->mutex);

	if (input_device_enabled(hx->input_dev))
		return hx852x_start(hx);

	return 0;
}

static DEFINE_SIMPLE_DEV_PM_OPS(hx852x_pm_ops, hx852x_suspend, hx852x_resume);

#ifdef CONFIG_OF
static const struct of_device_id hx852x_of_match[] = {
	{ .compatible = "himax,hx852es" },
	{ }
};
MODULE_DEVICE_TABLE(of, hx852x_of_match);
#endif

static struct i2c_driver hx852x_driver = {
	.probe = hx852x_probe,
	.driver = {
		.name = "himax_hx852x",
		.pm = pm_sleep_ptr(&hx852x_pm_ops),
		.of_match_table = of_match_ptr(hx852x_of_match),
	},
};
module_i2c_driver(hx852x_driver);

MODULE_DESCRIPTION("Himax HX852x(ES) Touchscreen Driver");
MODULE_AUTHOR("Jonathan Albrieux <jonathan.albrieux@gmail.com>");
MODULE_AUTHOR("Stephan Gerhold <stephan@gerhold.net>");
MODULE_LICENSE("GPL");