drivers/input/touchscreen/cy8ctma140.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Driver for Cypress CY8CTMA140 (TMA140) touchscreen
  * (C) 2020 Linus Walleij <linus.walleij@linaro.org>
  * (C) 2007 Cypress
  * (C) 2007 Google, Inc.
  *
  * Inspired by the tma140_skomer.c driver in the Samsung GT-S7710 code
  * drop. The GT-S7710 is codenamed "Skomer", the code also indicates
  * that the same touchscreen was used in a product called "Lucas".
  *
  * The code drop for GT-S7710 also contains a firmware downloader and
  * 15 (!) versions of the firmware drop from Cypress. But here we assume
  * the firmware got downloaded to the touchscreen flash successfully and
  * just use it to read the fingers. The shipped vendor driver does the
  * same.
  */

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

 #define CY8CTMA140_NAME			"cy8ctma140"

 #define CY8CTMA140_MAX_FINGERS		4

 #define CY8CTMA140_GET_FINGERS		0x00
 #define CY8CTMA140_GET_FW_INFO		0x19

 /* This message also fits some bytes for touchkeys, if used */
 #define CY8CTMA140_PACKET_SIZE		31

 #define CY8CTMA140_INVALID_BUFFER_BIT	5

 struct cy8ctma140 {
 	struct input_dev *input;
 	struct touchscreen_properties props;
 	struct device *dev;
 	struct i2c_client *client;
 	struct regulator_bulk_data regulators[2];
 	u8 prev_fingers;
 	u8 prev_f1id;
 	u8 prev_f2id;
 };

 static void cy8ctma140_report(struct cy8ctma140 *ts, u8 *data, int n_fingers)
 {
 	static const u8 contact_offsets[] = { 0x03, 0x09, 0x10, 0x16 };
 	u8 *buf;
 	u16 x, y;
 	u8 w;
 	u8 id;
 	int slot;
 	int i;

 	for (i = 0; i < n_fingers; i++) {
 		buf = &data[contact_offsets[i]];

 		/*
 		 * Odd contacts have contact ID in the lower nibble of
 		 * the preceding byte, whereas even contacts have it in
 		 * the upper nibble of the following byte.
 		 */
 		id = i % 2 ? buf[-1] & 0x0f : buf[5] >> 4;
 		slot = input_mt_get_slot_by_key(ts->input, id);
 		if (slot < 0)
 			continue;

 		x = get_unaligned_be16(buf);
 		y = get_unaligned_be16(buf + 2);
 		w = buf[4];

 		dev_dbg(ts->dev, "finger %d: ID %02x (%d, %d) w: %d\n",
 			slot, id, x, y, w);

 		input_mt_slot(ts->input, slot);
 		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
 		touchscreen_report_pos(ts->input, &ts->props, x, y, true);
 		input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, w);
 	}

 	input_mt_sync_frame(ts->input);
 	input_sync(ts->input);
 }

 static irqreturn_t cy8ctma140_irq_thread(int irq, void *d)
 {
 	struct cy8ctma140 *ts = d;
 	u8 cmdbuf[] = { CY8CTMA140_GET_FINGERS };
 	u8 buf[CY8CTMA140_PACKET_SIZE];
 	struct i2c_msg msg[] = {
 		{
 			.addr = ts->client->addr,
 			.flags = 0,
 			.len = sizeof(cmdbuf),
 			.buf = cmdbuf,
 		}, {
 			.addr = ts->client->addr,
 			.flags = I2C_M_RD,
 			.len = sizeof(buf),
 			.buf = buf,
 		},
 	};
 	u8 n_fingers;
 	int ret;

 	ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg));
 	if (ret != ARRAY_SIZE(msg)) {
 		if (ret < 0)
 			dev_err(ts->dev, "error reading message: %d\n", ret);
 		else
 			dev_err(ts->dev, "wrong number of messages\n");
 		goto out;
 	}

 	if (buf[1] & BIT(CY8CTMA140_INVALID_BUFFER_BIT)) {
 		dev_dbg(ts->dev, "invalid event\n");
 		goto out;
 	}

 	n_fingers = buf[2] & 0x0f;
 	if (n_fingers > CY8CTMA140_MAX_FINGERS) {
 		dev_err(ts->dev, "unexpected number of fingers: %d\n",
 			n_fingers);
 		goto out;
 	}

 	cy8ctma140_report(ts, buf, n_fingers);

 out:
 	return IRQ_HANDLED;
 }

 static int cy8ctma140_init(struct cy8ctma140 *ts)
 {
 	u8 addr[1];
 	u8 buf[5];
 	int ret;

 	addr[0] = CY8CTMA140_GET_FW_INFO;
 	ret = i2c_master_send(ts->client, addr, 1);
 	if (ret < 0) {
 		dev_err(ts->dev, "error sending FW info message\n");
 		return ret;
 	}
 	ret = i2c_master_recv(ts->client, buf, 5);
 	if (ret < 0) {
 		dev_err(ts->dev, "error receiving FW info message\n");
 		return ret;
 	}
 	if (ret != 5) {
 		dev_err(ts->dev, "got only %d bytes\n", ret);
 		return -EIO;
 	}

 	dev_dbg(ts->dev, "vendor %c%c, HW ID %.2d, FW ver %.4d\n",
 		buf[0], buf[1], buf[3], buf[4]);

 	return 0;
 }

 static int cy8ctma140_power_up(struct cy8ctma140 *ts)
 {
 	int error;

 	error = regulator_bulk_enable(ARRAY_SIZE(ts->regulators),
 				      ts->regulators);
 	if (error) {
 		dev_err(ts->dev, "failed to enable regulators\n");
 		return error;
 	}

 	msleep(250);

 	return 0;
 }

 static void cy8ctma140_power_down(struct cy8ctma140 *ts)
 {
 	regulator_bulk_disable(ARRAY_SIZE(ts->regulators),
 			       ts->regulators);
 }

 /* Called from the registered devm action */
 static void cy8ctma140_power_off_action(void *d)
 {
 	struct cy8ctma140 *ts = d;

 	cy8ctma140_power_down(ts);
 }

 static int cy8ctma140_probe(struct i2c_client *client)
 {
 	struct cy8ctma140 *ts;
 	struct input_dev *input;
 	struct device *dev = &client->dev;
 	int error;

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

 	input = devm_input_allocate_device(dev);
 	if (!input)
 		return -ENOMEM;

 	ts->dev = dev;
 	ts->client = client;
 	ts->input = input;

 	input_set_capability(input, EV_ABS, ABS_MT_POSITION_X);
 	input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y);
 	/* One byte for width 0..255 so this is the limit */
 	input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 	/*
 	 * This sets up event max/min capabilities and fuzz.
 	 * Some DT properties are compulsory so we do not need
 	 * to provide defaults for X/Y max or pressure max.
 	 *
 	 * We just initialize a very simple MT touchscreen here,
 	 * some devices use the capability of this touchscreen to
 	 * provide touchkeys, and in that case this needs to be
 	 * extended to handle touchkey input.
 	 *
 	 * The firmware takes care of finger tracking and dropping
 	 * invalid ranges.
 	 */
 	touchscreen_parse_properties(input, true, &ts->props);
 	input_abs_set_fuzz(input, ABS_MT_POSITION_X, 0);
 	input_abs_set_fuzz(input, ABS_MT_POSITION_Y, 0);

 	error = input_mt_init_slots(input, CY8CTMA140_MAX_FINGERS,
 				  INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
 	if (error)
 		return error;

 	input->name = CY8CTMA140_NAME;
 	input->id.bustype = BUS_I2C;
 	input_set_drvdata(input, ts);

 	/*
 	 * VCPIN is the analog voltage supply
 	 * VDD is the digital voltage supply
 	 * since the voltage range of VDD overlaps that of VCPIN,
 	 * many designs to just supply both with a single voltage
 	 * source of ~3.3 V.
 	 */
 	ts->regulators[0].supply = "vcpin";
 	ts->regulators[1].supply = "vdd";
 	error = devm_regulator_bulk_get(dev, ARRAY_SIZE(ts->regulators),
 				      ts->regulators);
 	if (error)
 		return dev_err_probe(dev, error, "Failed to get regulators\n");

 	error = cy8ctma140_power_up(ts);
 	if (error)
 		return error;

 	error = devm_add_action_or_reset(dev, cy8ctma140_power_off_action, ts);
 	if (error) {
 		dev_err(dev, "failed to install power off handler\n");
 		return error;
 	}

 	error = devm_request_threaded_irq(dev, client->irq,
 					  NULL, cy8ctma140_irq_thread,
 					  IRQF_ONESHOT, CY8CTMA140_NAME, ts);
 	if (error) {
 		dev_err(dev, "irq %d busy? error %d\n", client->irq, error);
 		return error;
 	}

 	error = cy8ctma140_init(ts);
 	if (error)
 		return error;

 	error = input_register_device(input);
 	if (error)
 		return error;

 	i2c_set_clientdata(client, ts);

 	return 0;
 }

 static int cy8ctma140_suspend(struct device *dev)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct cy8ctma140 *ts = i2c_get_clientdata(client);

 	if (!device_may_wakeup(&client->dev))
 		cy8ctma140_power_down(ts);

 	return 0;
 }

 static int cy8ctma140_resume(struct device *dev)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct cy8ctma140 *ts = i2c_get_clientdata(client);
 	int error;

 	if (!device_may_wakeup(&client->dev)) {
 		error = cy8ctma140_power_up(ts);
 		if (error)
 			return error;
 	}

 	return 0;
 }

 static DEFINE_SIMPLE_DEV_PM_OPS(cy8ctma140_pm,
 				cy8ctma140_suspend, cy8ctma140_resume);

 static const struct i2c_device_id cy8ctma140_idtable[] = {
 	{ CY8CTMA140_NAME },
 	{ /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(i2c, cy8ctma140_idtable);

 static const struct of_device_id cy8ctma140_of_match[] = {
 	{ .compatible = "cypress,cy8ctma140", },
 	{ /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, cy8ctma140_of_match);

 static struct i2c_driver cy8ctma140_driver = {
 	.driver		= {
 		.name	= CY8CTMA140_NAME,
 		.pm	= pm_sleep_ptr(&cy8ctma140_pm),
 		.of_match_table = cy8ctma140_of_match,
 	},
 	.id_table	= cy8ctma140_idtable,
 	.probe		= cy8ctma140_probe,
 };
 module_i2c_driver(cy8ctma140_driver);

 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
 MODULE_DESCRIPTION("CY8CTMA140 TouchScreen Driver");
 MODULE_LICENSE("GPL v2");
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* Driver for Cypress CY8CTMA140 (TMA140) touchscreen
	* (C) 2020 Linus Walleij <linus.walleij@linaro.org>
	* (C) 2007 Cypress
	* (C) 2007 Google, Inc.
	*
	* Inspired by the tma140_skomer.c driver in the Samsung GT-S7710 code
	* drop. The GT-S7710 is codenamed "Skomer", the code also indicates
	* that the same touchscreen was used in a product called "Lucas".
	*
	* The code drop for GT-S7710 also contains a firmware downloader and
	* 15 (!) versions of the firmware drop from Cypress. But here we assume
	* the firmware got downloaded to the touchscreen flash successfully and
	* just use it to read the fingers. The shipped vendor driver does the
	* same.
	*/

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

	#define CY8CTMA140_NAME "cy8ctma140"

	#define CY8CTMA140_MAX_FINGERS 4

	#define CY8CTMA140_GET_FINGERS 0x00
	#define CY8CTMA140_GET_FW_INFO 0x19

	/* This message also fits some bytes for touchkeys, if used */
	#define CY8CTMA140_PACKET_SIZE 31

	#define CY8CTMA140_INVALID_BUFFER_BIT 5

	struct cy8ctma140 {
	struct input_dev *input;
	struct touchscreen_properties props;
	struct device *dev;
	struct i2c_client *client;
	struct regulator_bulk_data regulators[2];
	u8 prev_fingers;
	u8 prev_f1id;
	u8 prev_f2id;
	};

	static void cy8ctma140_report(struct cy8ctma140 ts, u8 data, int n_fingers)
	{
	static const u8 contact_offsets[] = { 0x03, 0x09, 0x10, 0x16 };
	u8 *buf;
	u16 x, y;
	u8 w;
	u8 id;
	int slot;
	int i;

	for (i = 0; i < n_fingers; i++) {
	buf = &data[contact_offsets[i]];

	/*
	* Odd contacts have contact ID in the lower nibble of
	* the preceding byte, whereas even contacts have it in
	* the upper nibble of the following byte.
	*/
	id = i % 2 ? buf[-1] & 0x0f : buf[5] >> 4;
	slot = input_mt_get_slot_by_key(ts->input, id);
	if (slot < 0)
	continue;

	x = get_unaligned_be16(buf);
	y = get_unaligned_be16(buf + 2);
	w = buf[4];

	dev_dbg(ts->dev, "finger %d: ID %02x (%d, %d) w: %d\n",
	slot, id, x, y, w);

	input_mt_slot(ts->input, slot);
	input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
	touchscreen_report_pos(ts->input, &ts->props, x, y, true);
	input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, w);
	}

	input_mt_sync_frame(ts->input);
	input_sync(ts->input);
	}

	static irqreturn_t cy8ctma140_irq_thread(int irq, void *d)
	{
	struct cy8ctma140 *ts = d;
	u8 cmdbuf[] = { CY8CTMA140_GET_FINGERS };
	u8 buf[CY8CTMA140_PACKET_SIZE];
	struct i2c_msg msg[] = {
	{
	.addr = ts->client->addr,
	.flags = 0,
	.len = sizeof(cmdbuf),
	.buf = cmdbuf,
	}, {
	.addr = ts->client->addr,
	.flags = I2C_M_RD,
	.len = sizeof(buf),
	.buf = buf,
	},
	};
	u8 n_fingers;
	int ret;

	ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg));
	if (ret != ARRAY_SIZE(msg)) {
	if (ret < 0)
	dev_err(ts->dev, "error reading message: %d\n", ret);
	else
	dev_err(ts->dev, "wrong number of messages\n");
	goto out;
	}

	if (buf[1] & BIT(CY8CTMA140_INVALID_BUFFER_BIT)) {
	dev_dbg(ts->dev, "invalid event\n");
	goto out;
	}

	n_fingers = buf[2] & 0x0f;
	if (n_fingers > CY8CTMA140_MAX_FINGERS) {
	dev_err(ts->dev, "unexpected number of fingers: %d\n",
	n_fingers);
	goto out;
	}

	cy8ctma140_report(ts, buf, n_fingers);

	out:
	return IRQ_HANDLED;
	}

	static int cy8ctma140_init(struct cy8ctma140 *ts)
	{
	u8 addr[1];
	u8 buf[5];
	int ret;

	addr[0] = CY8CTMA140_GET_FW_INFO;
	ret = i2c_master_send(ts->client, addr, 1);
	if (ret < 0) {
	dev_err(ts->dev, "error sending FW info message\n");
	return ret;
	}
	ret = i2c_master_recv(ts->client, buf, 5);
	if (ret < 0) {
	dev_err(ts->dev, "error receiving FW info message\n");
	return ret;
	}
	if (ret != 5) {
	dev_err(ts->dev, "got only %d bytes\n", ret);
	return -EIO;
	}

	dev_dbg(ts->dev, "vendor %c%c, HW ID %.2d, FW ver %.4d\n",
	buf[0], buf[1], buf[3], buf[4]);

	return 0;
	}

	static int cy8ctma140_power_up(struct cy8ctma140 *ts)
	{
	int error;

	error = regulator_bulk_enable(ARRAY_SIZE(ts->regulators),
	ts->regulators);
	if (error) {
	dev_err(ts->dev, "failed to enable regulators\n");
	return error;
	}

	msleep(250);

	return 0;
	}

	static void cy8ctma140_power_down(struct cy8ctma140 *ts)
	{
	regulator_bulk_disable(ARRAY_SIZE(ts->regulators),
	ts->regulators);
	}

	/* Called from the registered devm action */
	static void cy8ctma140_power_off_action(void *d)
	{
	struct cy8ctma140 *ts = d;

	cy8ctma140_power_down(ts);
	}

	static int cy8ctma140_probe(struct i2c_client *client)
	{
	struct cy8ctma140 *ts;
	struct input_dev *input;
	struct device *dev = &client->dev;
	int error;

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

	input = devm_input_allocate_device(dev);
	if (!input)
	return -ENOMEM;

	ts->dev = dev;
	ts->client = client;
	ts->input = input;

	input_set_capability(input, EV_ABS, ABS_MT_POSITION_X);
	input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y);
	/* One byte for width 0..255 so this is the limit */
	input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
	/*
	* This sets up event max/min capabilities and fuzz.
	* Some DT properties are compulsory so we do not need
	* to provide defaults for X/Y max or pressure max.
	*
	* We just initialize a very simple MT touchscreen here,
	* some devices use the capability of this touchscreen to
	* provide touchkeys, and in that case this needs to be
	* extended to handle touchkey input.
	*
	* The firmware takes care of finger tracking and dropping
	* invalid ranges.
	*/
	touchscreen_parse_properties(input, true, &ts->props);
	input_abs_set_fuzz(input, ABS_MT_POSITION_X, 0);
	input_abs_set_fuzz(input, ABS_MT_POSITION_Y, 0);

	error = input_mt_init_slots(input, CY8CTMA140_MAX_FINGERS,
	INPUT_MT_DIRECT \| INPUT_MT_DROP_UNUSED);
	if (error)
	return error;

	input->name = CY8CTMA140_NAME;
	input->id.bustype = BUS_I2C;
	input_set_drvdata(input, ts);

	/*
	* VCPIN is the analog voltage supply
	* VDD is the digital voltage supply
	* since the voltage range of VDD overlaps that of VCPIN,
	* many designs to just supply both with a single voltage
	* source of ~3.3 V.
	*/
	ts->regulators[0].supply = "vcpin";
	ts->regulators[1].supply = "vdd";
	error = devm_regulator_bulk_get(dev, ARRAY_SIZE(ts->regulators),
	ts->regulators);
	if (error)
	return dev_err_probe(dev, error, "Failed to get regulators\n");

	error = cy8ctma140_power_up(ts);
	if (error)
	return error;

	error = devm_add_action_or_reset(dev, cy8ctma140_power_off_action, ts);
	if (error) {
	dev_err(dev, "failed to install power off handler\n");
	return error;
	}

	error = devm_request_threaded_irq(dev, client->irq,
	NULL, cy8ctma140_irq_thread,
	IRQF_ONESHOT, CY8CTMA140_NAME, ts);
	if (error) {
	dev_err(dev, "irq %d busy? error %d\n", client->irq, error);
	return error;
	}

	error = cy8ctma140_init(ts);
	if (error)
	return error;

	error = input_register_device(input);
	if (error)
	return error;

	i2c_set_clientdata(client, ts);

	return 0;
	}

	static int cy8ctma140_suspend(struct device *dev)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct cy8ctma140 *ts = i2c_get_clientdata(client);

	if (!device_may_wakeup(&client->dev))
	cy8ctma140_power_down(ts);

	return 0;
	}

	static int cy8ctma140_resume(struct device *dev)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct cy8ctma140 *ts = i2c_get_clientdata(client);
	int error;

	if (!device_may_wakeup(&client->dev)) {
	error = cy8ctma140_power_up(ts);
	if (error)
	return error;
	}

	return 0;
	}

	static DEFINE_SIMPLE_DEV_PM_OPS(cy8ctma140_pm,
	cy8ctma140_suspend, cy8ctma140_resume);

	static const struct i2c_device_id cy8ctma140_idtable[] = {
	{ CY8CTMA140_NAME },
	{ /* sentinel */ }
	};
	MODULE_DEVICE_TABLE(i2c, cy8ctma140_idtable);

	static const struct of_device_id cy8ctma140_of_match[] = {
	{ .compatible = "cypress,cy8ctma140", },
	{ /* sentinel */ }
	};
	MODULE_DEVICE_TABLE(of, cy8ctma140_of_match);

	static struct i2c_driver cy8ctma140_driver = {
	.driver = {
	.name = CY8CTMA140_NAME,
	.pm = pm_sleep_ptr(&cy8ctma140_pm),
	.of_match_table = cy8ctma140_of_match,
	},
	.id_table = cy8ctma140_idtable,
	.probe = cy8ctma140_probe,
	};
	module_i2c_driver(cy8ctma140_driver);

	MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
	MODULE_DESCRIPTION("CY8CTMA140 TouchScreen Driver");
	MODULE_LICENSE("GPL v2");