[1/2] Input: add zinitix touchscreen driver
diff mbox series

Message ID 20191012192739.10261-1-michael.srba@seznam.cz
State Superseded
Headers show
Series
  • [1/2] Input: add zinitix touchscreen driver
Related show

Commit Message

michael.srba@seznam.cz Oct. 12, 2019, 7:27 p.m. UTC
From: Michael Srba <Michael.Srba@seznam.cz>

Add support for the bt541 touchscreen IC from zinitix, loosely based
on downstream driver. The driver currently supports multitouch (5 touch points).
The bt541 seems to support touch keys, but the support was not added because 
that functionality is not being utilized by the touchscreen used for testing.
Based on the similartities between downstream drivers, it seems likely that 
other similar touchscreen ICs can be supported with this driver in the future.

Signed-off-by: Michael Srba <Michael.Srba@seznam.cz>
---
 bt541 is used in the Samsung Galaxy A3 (2015) that has recently gained 
 mainline support [1].

 The downstream driver this is loosely based on: 
 https://github.com/msm8916-mainline/android_kernel_qcom_msm8916/tree/SM-A300FU/drivers/input/touchscreen/zinitix

 [1]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1329c1ab0730b521e6cd3051c56a2ff3d55f21e6

 drivers/input/touchscreen/Kconfig   |  12 +
 drivers/input/touchscreen/Makefile  |   1 +
 drivers/input/touchscreen/zinitix.c | 508 ++++++++++++++++++++++++++++
 3 files changed, 521 insertions(+)
 create mode 100644 drivers/input/touchscreen/zinitix.c

Comments

Dmitry Torokhov Oct. 15, 2019, 9:47 p.m. UTC | #1
Hi Michael,

On Sat, Oct 12, 2019 at 09:27:38PM +0200, michael.srba@seznam.cz wrote:
> From: Michael Srba <Michael.Srba@seznam.cz>
> 
> Add support for the bt541 touchscreen IC from zinitix, loosely based
> on downstream driver. The driver currently supports multitouch (5 touch points).
> The bt541 seems to support touch keys, but the support was not added because 
> that functionality is not being utilized by the touchscreen used for testing.
> Based on the similartities between downstream drivers, it seems likely that 
> other similar touchscreen ICs can be supported with this driver in the future.
> 
> Signed-off-by: Michael Srba <Michael.Srba@seznam.cz>
> ---
>  bt541 is used in the Samsung Galaxy A3 (2015) that has recently gained 
>  mainline support [1].
> 
>  The downstream driver this is loosely based on: 
>  https://github.com/msm8916-mainline/android_kernel_qcom_msm8916/tree/SM-A300FU/drivers/input/touchscreen/zinitix
> 
>  [1]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1329c1ab0730b521e6cd3051c56a2ff3d55f21e6
> 
>  drivers/input/touchscreen/Kconfig   |  12 +
>  drivers/input/touchscreen/Makefile  |   1 +
>  drivers/input/touchscreen/zinitix.c | 508 ++++++++++++++++++++++++++++
>  3 files changed, 521 insertions(+)
>  create mode 100644 drivers/input/touchscreen/zinitix.c
> 
> diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
> index 46ad9090493b..6203e0764d5f 100644
> --- a/drivers/input/touchscreen/Kconfig
> +++ b/drivers/input/touchscreen/Kconfig
> @@ -1314,4 +1314,16 @@ config TOUCHSCREEN_IQS5XX
>  	  To compile this driver as a module, choose M here: the
>  	  module will be called iqs5xx.
>  
> +config TOUCHSCREEN_ZINITIX
> +	tristate "Zinitix touchscreen support"
> +	depends on I2C
> +	help
> +	  Say Y here if you have a touchscreen using Zinitix bt541,
> +	  or something similar enough.
> +
> +	  If unsure, say N.
> +
> +	  To compile this driver as a module, choose M here: the
> +	  module will be called zinitix.
> +
>  endif
> diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
> index 94c6162409b3..bafe9d76ed03 100644
> --- a/drivers/input/touchscreen/Makefile
> +++ b/drivers/input/touchscreen/Makefile
> @@ -110,3 +110,4 @@ obj-$(CONFIG_TOUCHSCREEN_COLIBRI_VF50)	+= colibri-vf50-ts.o
>  obj-$(CONFIG_TOUCHSCREEN_ROHM_BU21023)	+= rohm_bu21023.o
>  obj-$(CONFIG_TOUCHSCREEN_RASPBERRYPI_FW)	+= raspberrypi-ts.o
>  obj-$(CONFIG_TOUCHSCREEN_IQS5XX)	+= iqs5xx.o
> +obj-$(CONFIG_TOUCHSCREEN_ZINITIX)	+= zinitix.o
> diff --git a/drivers/input/touchscreen/zinitix.c b/drivers/input/touchscreen/zinitix.c
> new file mode 100644
> index 000000000000..55b1816b39d4
> --- /dev/null
> +++ b/drivers/input/touchscreen/zinitix.c
> @@ -0,0 +1,508 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +
> +#include <linux/kernel.h>
> +#include <linux/i2c.h>
> +#include <linux/input.h>
> +#include <linux/input/mt.h>
> +#include <linux/input/touchscreen.h>
> +#include <linux/module.h>
> +#include <linux/delay.h>
> +#include <linux/irq.h>
> +#include <linux/interrupt.h>
> +#include <linux/regulator/consumer.h>
> +#include <linux/slab.h>
> +#include <linux/of.h>
> +#include <asm/unaligned.h>
> +
> +/* Register Map */
> +
> +#define BT541_SWRESET_CMD			0x0000
> +#define BT541_WAKEUP_CMD			0x0001
> +
> +#define BT541_IDLE_CMD				0x0004
> +#define BT541_SLEEP_CMD				0x0005
> +
> +#define BT541_CLEAR_INT_STATUS_CMD		0x0003
> +#define BT541_CALIBRATE_CMD			0x0006
> +#define BT541_SAVE_STATUS_CMD			0x0007
> +#define BT541_SAVE_CALIBRATION_CMD		0x0008
> +#define BT541_RECALL_FACTORY_CMD		0x000f
> +
> +#define BT541_THRESHOLD				0x0020
> +
> +#define BT541_LARGE_PALM_REJECT_AREA_TH		0x003F
> +
> +#define BT541_DEBUG_REG				0x0115 /* 0~7 */
> +
> +#define BT541_TOUCH_MODE			0x0010
> +#define BT541_CHIP_REVISION			0x0011
> +#define BT541_FIRMWARE_VERSION			0x0012
> +
> +#define ZINITIX_USB_DETECT			0x116
> +
> +#define BT541_MINOR_FW_VERSION			0x0121
> +
> +#define BT541_VENDOR_ID				0x001C
> +#define BT541_HW_ID				0x0014
> +
> +#define BT541_DATA_VERSION_REG			0x0013
> +#define BT541_SUPPORTED_FINGER_NUM		0x0015
> +#define BT541_EEPROM_INFO			0x0018
> +#define BT541_INITIAL_TOUCH_MODE		0x0019
> +
> +#define BT541_TOTAL_NUMBER_OF_X			0x0060
> +#define BT541_TOTAL_NUMBER_OF_Y			0x0061
> +
> +#define BT541_DELAY_RAW_FOR_HOST		0x007f
> +
> +#define BT541_BUTTON_SUPPORTED_NUM		0x00B0
> +#define BT541_BUTTON_SENSITIVITY		0x00B2
> +#define BT541_DUMMY_BUTTON_SENSITIVITY		0X00C8
> +
> +#define BT541_X_RESOLUTION			0x00C0
> +#define BT541_Y_RESOLUTION			0x00C1
> +
> +#define BT541_POINT_STATUS_REG			0x0080
> +#define BT541_ICON_STATUS_REG			0x00AA
> +
> +#define BT541_POINT_COORD_REG			(BT541_POINT_STATUS_REG + 2)
> +
> +#define BT541_AFE_FREQUENCY			0x0100
> +#define BT541_DND_N_COUNT			0x0122
> +#define BT541_DND_U_COUNT			0x0135
> +
> +#define BT541_RAWDATA_REG			0x0200
> +
> +#define BT541_EEPROM_INFO_REG			0x0018
> +
> +#define BT541_INT_ENABLE_FLAG			0x00f0
> +#define BT541_PERIODICAL_INTERRUPT_INTERVAL	0x00f1
> +
> +#define BT541_BTN_WIDTH				0x016d
> +
> +#define BT541_CHECKSUM_RESULT			0x012c
> +
> +#define BT541_INIT_FLASH			0x01d0
> +#define BT541_WRITE_FLASH			0x01d1
> +#define BT541_READ_FLASH			0x01d2
> +
> +#define ZINITIX_INTERNAL_FLAG_02		0x011e
> +#define ZINITIX_INTERNAL_FLAG_03		0x011f
> +
> +#define ZINITIX_I2C_CHECKSUM_WCNT		0x016a
> +#define ZINITIX_I2C_CHECKSUM_RESULT		0x016c
> +
> +/* Interrupt & status register flags */
> +
> +#define BIT_PT_CNT_CHANGE	BIT(0)
> +#define BIT_DOWN		BIT(1)
> +#define BIT_MOVE		BIT(2)
> +#define BIT_UP			BIT(3)
> +#define BIT_PALM		BIT(4)
> +#define BIT_PALM_REJECT		BIT(5)
> +#define BIT_RESERVED_0		BIT(6)
> +#define BIT_RESERVED_1		BIT(7)
> +#define BIT_WEIGHT_CHANGE	BIT(8)
> +#define BIT_PT_NO_CHANGE	BIT(9)
> +#define BIT_REJECT		BIT(10)
> +#define BIT_PT_EXIST		BIT(11)
> +#define BIT_RESERVED_2		BIT(12)
> +#define BIT_ERROR		BIT(13)
> +#define BIT_DEBUG		BIT(14)
> +#define BIT_ICON_EVENT		BIT(15)
> +
> +#define SUB_BIT_EXIST		BIT(0)
> +#define SUB_BIT_DOWN		BIT(1)
> +#define SUB_BIT_MOVE		BIT(2)
> +#define SUB_BIT_UP		BIT(3)
> +#define SUB_BIT_UPDATE		BIT(4)
> +#define SUB_BIT_WAIT		BIT(5)
> +
> +#define TOUCH_POINT_MODE		1
> +#define MAX_SUPPORTED_FINGER_NUM	5
> +
> +#define CHIP_ON_DELAY	15 // ms
> +#define FIRMWARE_ON_DELAY 40 // ms
> +
> +#define DELAY_FOR_TRANSACTION		50 // μs
> +#define DELAY_FOR_POST_TRANSCATION	10 // μs
> +
> +struct point_coord {
> +	__le16	x;
> +	__le16	y;
> +	u8	width;
> +	u8	sub_status;
> +	// not used on this model, but needed as padding:
> +	u8	minor_width;
> +	u8	angle;
> +} __packed;

I do not think you need to declare this as packed.

> +
> +struct point_status {
> +	__le16	status;
> +	__le16	event_flag;
> +} __packed;

And neither this.

> +
> +struct bt541_ts_data {
> +	struct i2c_client *client;
> +	struct input_dev *input_dev;
> +	struct touchscreen_properties prop;
> +	struct regulator_bulk_data supplies[2];
> +};
> +
> +static inline s32 zinitix_read_data(struct i2c_client *client,

No need to mark it inline, let's trust the compiler to do its job.
Also, it returns error code or 0, just use int for return type and not
s32.

> +				    u16 reg, u8 *values, u16 length)

Why exactly u16 for length and not int or size_t?

> +{
> +	int ret;

Let's call it "error" here and elsewhere.

> +	__le16 reg_le = cpu_to_le16(reg);
> +
> +	ret = i2c_master_send(client, (u8 *)&reg_le, sizeof(reg_le));
> +	if (ret < 0)
> +		return ret;
> +
> +	udelay(DELAY_FOR_TRANSACTION);
> +	ret = i2c_master_recv(client, values, length);
> +	if (ret < 0)

Ideally we check that if ret >= 0 but ret != length we return -EIO.

> +		return ret;
> +
> +	udelay(DELAY_FOR_POST_TRANSCATION);
> +	return 0;
> +}
> +
> +static inline s32 zinitix_write_data(struct i2c_client *client,
> +				     u16 reg, u8 *values, u16 length)
> +{
> +	int ret;
> +	u8 *packet;
> +	__le16 reg_le = cpu_to_le16(reg);
> +
> +	packet = kmalloc(length + sizeof(reg_le), GFP_KERNEL);

Need to handle memory allocation error;


> +	memcpy(packet, (u8 *)&reg_le, sizeof(reg_le));
> +	memcpy(packet + sizeof(reg_le), values, length);
> +
> +	ret = i2c_master_send(client, packet, length + sizeof(reg_le));

Since you kmalloc()ed the data you can use _dmasafe() here.

> +	kfree(packet);
> +	if (ret < 0)
> +		return ret;
> +
> +	udelay(DELAY_FOR_POST_TRANSCATION);
> +	return 0;
> +}
> +
> +static inline s32 zinitix_write_u16(struct i2c_client *client, u16 reg, u16 value)
> +{
> +	__le16 value_le = cpu_to_le16(value);
> +
> +	return zinitix_write_data(client, reg, (u8 *)&value_le, sizeof(reg));
> +}
> +
> +static inline s32 zinitix_write_cmd(struct i2c_client *client, u16 reg)
> +{
> +	int ret;
> +	__le16 reg_le = cpu_to_le16(reg);
> +
> +	ret = i2c_master_send(client, (u8 *)&reg_le, sizeof(reg_le));
> +	if (ret < 0)
> +		return ret;
> +
> +	udelay(DELAY_FOR_POST_TRANSCATION);
> +	return 0;
> +}
> +
> +static bool zinitix_init_touch(struct bt541_ts_data *bt541)
> +{
> +	struct i2c_client *client = bt541->client;
> +	int i;
> +	int ret;
> +
> +	ret = zinitix_write_cmd(client, BT541_SWRESET_CMD);
> +	if (ret) {
> +		dev_err(&client->dev, "Failed to write reset command\n");
> +		return ret;
> +	}
> +
> +	ret = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG, 0x0);
> +	if (ret) {
> +		dev_err(&client->dev, "failed to reset interrupt enable flag\n");
> +		return ret;
> +	}
> +
> +	/* initialize */
> +	ret = zinitix_write_u16(client, BT541_X_RESOLUTION, (u16)bt541->prop.max_x);
> +	if (ret)
> +		return ret;
> +
> +	ret = zinitix_write_u16(client, BT541_Y_RESOLUTION, (u16)bt541->prop.max_y);
> +	if (ret)
> +		return ret;
> +
> +	ret = zinitix_write_u16(client, BT541_SUPPORTED_FINGER_NUM,
> +				(u16)MAX_SUPPORTED_FINGER_NUM);
> +	if (ret)
> +		return ret;
> +
> +	ret = zinitix_write_u16(client, BT541_INITIAL_TOUCH_MODE, TOUCH_POINT_MODE);
> +	if (ret)
> +		return ret;
> +
> +	ret = zinitix_write_u16(client, BT541_TOUCH_MODE, TOUCH_POINT_MODE);
> +	if (ret)
> +		return ret;
> +
> +	ret = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG,
> +				BIT_PT_CNT_CHANGE | BIT_DOWN | BIT_MOVE | BIT_UP);
> +	if (ret)
> +		return ret;
> +
> +	/* clear queue */
> +	for (i = 0; i < 10; i++) {
> +		zinitix_write_cmd(client, BT541_CLEAR_INT_STATUS_CMD);
> +		udelay(10);
> +	}
> +
> +	return 0;
> +}
> +
> +static int zinitix_init_regulators(struct bt541_ts_data *bt541)
> +{
> +	struct i2c_client *client = bt541->client;
> +	int ret;
> +
> +	bt541->supplies[0].supply = "vdd";
> +	bt541->supplies[1].supply = "vddo";
> +	ret = devm_regulator_bulk_get(&client->dev, ARRAY_SIZE(bt541->supplies),
> +				      bt541->supplies);
> +	if (ret < 0) {
> +		dev_err(&client->dev, "Failed to get regulators: %d\n", ret);
> +		return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +static int zinitix_send_power_on_sequence(struct bt541_ts_data *bt541)
> +{
> +	int ret;
> +	struct i2c_client *client = bt541->client;
> +
> +	ret = zinitix_write_u16(client, 0xc000, 0x0001);
> +	if (ret) {
> +		dev_err(&client->dev, "Failed to send power sequence(vendor cmd enable)\n");
> +		return ret;
> +	}
> +	udelay(10);
> +
> +	ret = zinitix_write_cmd(client, 0xc004);
> +	if (ret) {
> +		dev_err(&client->dev, "Failed to send power sequence(intn clear)\n");
> +		return ret;
> +	}
> +	udelay(10);
> +
> +	ret = zinitix_write_u16(client, 0xc002, 0x0001);
> +	if (ret) {
> +		dev_err(&client->dev, "Failed to send power sequence(nvm init)\n");
> +		return ret;
> +	}
> +	mdelay(2);
> +
> +	ret = zinitix_write_u16(client, 0xc001, 0x0001);
> +	if (ret) {
> +		dev_err(&client->dev, "Failed to send power sequence(program start)\n");
> +		return ret;
> +	}
> +	msleep(FIRMWARE_ON_DELAY);	/* wait for checksum cal */
> +
> +	return 0;
> +}
> +
> +static irqreturn_t zinitix_ts_irq_handler(int irq, void *bt541_handler)
> +{
> +	struct bt541_ts_data *bt541 = (struct bt541_ts_data *)bt541_handler;
> +	struct i2c_client *client = bt541->client;
> +	int i;
> +	int ret;
> +	struct point_status point_status;
> +	struct point_coord point_coord[MAX_SUPPORTED_FINGER_NUM] = {0};
> +
> +	memset(&point_status, 0, sizeof(struct point_status));
> +
> +	ret = zinitix_read_data(bt541->client, BT541_POINT_STATUS_REG,
> +				(u8 *)&point_status, sizeof(struct point_status));
> +	if (ret) {
> +		dev_err(&client->dev, "%s: Failed to read point status\n", __func__);

		goto out;

> +
> +		zinitix_write_cmd(bt541->client, BT541_CLEAR_INT_STATUS_CMD);
> +		return IRQ_HANDLED;

Combine this with normal exit code flow.

> +	}
> +
> +	for (i = 0; i < MAX_SUPPORTED_FINGER_NUM; i++) {
> +		if (!(le16_to_cpu(point_status.event_flag) & BIT(i)))

I'd do le->cpu conversion outside the loop, and then use
for_each_set_bit(...).

> +			continue;
> +
> +		ret = zinitix_read_data(bt541->client, BT541_POINT_COORD_REG +
> +					(i * sizeof(struct point_coord) / sizeof(u16)),
> +					(u8 *)&point_coord[i], sizeof(struct point_coord));
> +		if (ret) {
> +			dev_err(&client->dev, "%s: Failed to read point info\n", __func__);
> +
> +			zinitix_write_cmd(bt541->client, BT541_CLEAR_INT_STATUS_CMD);
> +			return IRQ_HANDLED;
> +		}
> +
> +		if (!(point_coord[i].sub_status & SUB_BIT_EXIST))
> +			continue;
> +
> +		input_mt_slot(bt541->input_dev, i);
> +		input_mt_report_slot_state(bt541->input_dev, MT_TOOL_FINGER, true);
> +		touchscreen_report_pos(bt541->input_dev, &bt541->prop,
> +				       le16_to_cpu(point_coord[i].x),
> +				       le16_to_cpu(point_coord[i].y), true);
> +		input_report_abs(bt541->input_dev, ABS_MT_TOUCH_MAJOR, point_coord[i].width);
> +		input_report_abs(bt541->input_dev, ABS_MT_WIDTH_MAJOR, point_coord[i].width);

Why do you report both? I think ABS_MT_TOUCH_MAJOR should be enough.

> +	}
> +
> +	zinitix_write_cmd(bt541->client, BT541_CLEAR_INT_STATUS_CMD);
> +
> +	input_mt_sync_frame(bt541->input_dev);
> +	input_sync(bt541->input_dev);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int zinitix_init_input_dev(struct bt541_ts_data *bt541)
> +{
> +	int ret;
> +
> +	bt541->input_dev = devm_input_allocate_device(&bt541->client->dev);
> +	if (!bt541->input_dev) {
> +		dev_err(&bt541->client->dev, "Failed to allocate input device.");
> +		return -ENOMEM;
> +	}
> +
> +	bt541->input_dev->name = "Zinitix Capacitive TouchScreen";
> +	bt541->input_dev->phys = "input/ts";
> +	bt541->input_dev->id.bustype = BUS_I2C;
> +
> +	input_set_capability(bt541->input_dev, EV_ABS, ABS_MT_POSITION_X);
> +	input_set_capability(bt541->input_dev, EV_ABS, ABS_MT_POSITION_Y);
> +	input_set_abs_params(bt541->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
> +	input_set_abs_params(bt541->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
> +
> +	touchscreen_parse_properties(bt541->input_dev, true, &bt541->prop);
> +
> +	if (!bt541->prop.max_x || !bt541->prop.max_y) {
> +		dev_err(&bt541->client->dev, "touchscreen-size-x and/or touchscreen-size-y not set in dts\n");
> +		return -EINVAL;
> +	}
> +
> +	ret = input_mt_init_slots(bt541->input_dev, MAX_SUPPORTED_FINGER_NUM,
> +				  INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
> +	if (ret) {
> +		dev_err(&bt541->client->dev,
> +			"Failed to initialize MT slots: %d", ret);
> +		return ret;
> +	}
> +
> +	ret = input_register_device(bt541->input_dev);
> +	if (ret) {
> +		dev_err(&bt541->client->dev,
> +			"Failed to register input device: %d", ret);
> +		return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +static int zinitix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
> +{
> +	struct bt541_ts_data *bt541;
> +	int ret;
> +
> +	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
> +		dev_err(&client->dev, "I2C check functionality failed.\n");
> +		return -ENXIO;
> +	}
> +
> +	bt541 = devm_kzalloc(&client->dev, sizeof(*bt541), GFP_KERNEL);
> +	if (!bt541)
> +		return -ENOMEM;
> +
> +	bt541->client = client;
> +	i2c_set_clientdata(client, bt541);
> +
> +	ret = zinitix_init_regulators(bt541);
> +	if (ret) {
> +		dev_err(&client->dev, "regulator initialization failed: %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = regulator_bulk_enable(ARRAY_SIZE(bt541->supplies), bt541->supplies);
> +	if (ret < 0) {
> +		dev_err(&client->dev, "Failed to enable regulators: %d\n", ret);
> +		return ret;
> +	}
> +
> +	msleep(CHIP_ON_DELAY);
> +
> +	ret = zinitix_send_power_on_sequence(bt541);
> +	if (ret) {
> +		dev_err(&client->dev, "sending power-on sequence failed: %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = zinitix_init_input_dev(bt541);
> +	if (ret) {
> +		dev_err(&client->dev, "input dev initialization failed: %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = zinitix_init_touch(bt541);
> +	if (ret) {
> +		dev_err(&client->dev, "Failed to init touchscreen ic\n");
> +		return ret;
> +	}
> +
> +	ret = devm_request_threaded_irq(&bt541->client->dev, bt541->client->irq,
> +					NULL, zinitix_ts_irq_handler,
> +					IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
> +					bt541->client->name, bt541);
> +	if (ret) {
> +		dev_err(&client->dev, "request IRQ failed: %d\n", ret);
> +		return ret;
> +	}
> +
> +	dev_info(&client->dev, "initialized a zinitix touchscreen\n");
> +
> +	return 0;
> +}
> +
> +static int zinitix_ts_remove(struct i2c_client *client)
> +{
> +	struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
> +
> +	regulator_bulk_disable(ARRAY_SIZE(bt541->supplies), bt541->supplies);

Doing it here means you cut off power to the device while interrupts are
still enabled, etc. Unfortunately we do not have devm interface for
disabling regulators. Please use devm_add_action_or_reset() in
zinitix_ts_probe() and install a custom handler calling
regulator_bulk_disable() and drop zinitix_ts_remove().

> +
> +	return 0;
> +}
> +
> +#ifdef CONFIG_OF
> +static const struct of_device_id zinitix_of_match[] = {
> +	{ .compatible = "zinitix,bt541" },
> +	{ }
> +};
> +MODULE_DEVICE_TABLE(of, zinitix_of_match);
> +#endif
> +
> +static struct i2c_driver zinitix_ts_driver = {
> +	.probe = zinitix_ts_probe,
> +	.remove = zinitix_ts_remove,
> +	.driver = {
> +		.name = "Zinitix-TS",
> +		.of_match_table = of_match_ptr(zinitix_of_match),
> +	},
> +};
> +module_i2c_driver(zinitix_ts_driver);
> +
> +MODULE_AUTHOR("Michael Srba <Michael.Srba@seznam.cz>");
> +MODULE_DESCRIPTION("Zinitix touchscreen driver");
> +MODULE_LICENSE("GPL v2");
> -- 
> 2.23.0
> 

Thanks.

Patch
diff mbox series

diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 46ad9090493b..6203e0764d5f 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -1314,4 +1314,16 @@  config TOUCHSCREEN_IQS5XX
 	  To compile this driver as a module, choose M here: the
 	  module will be called iqs5xx.
 
+config TOUCHSCREEN_ZINITIX
+	tristate "Zinitix touchscreen support"
+	depends on I2C
+	help
+	  Say Y here if you have a touchscreen using Zinitix bt541,
+	  or something similar enough.
+
+	  If unsure, say N.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called zinitix.
+
 endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 94c6162409b3..bafe9d76ed03 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -110,3 +110,4 @@  obj-$(CONFIG_TOUCHSCREEN_COLIBRI_VF50)	+= colibri-vf50-ts.o
 obj-$(CONFIG_TOUCHSCREEN_ROHM_BU21023)	+= rohm_bu21023.o
 obj-$(CONFIG_TOUCHSCREEN_RASPBERRYPI_FW)	+= raspberrypi-ts.o
 obj-$(CONFIG_TOUCHSCREEN_IQS5XX)	+= iqs5xx.o
+obj-$(CONFIG_TOUCHSCREEN_ZINITIX)	+= zinitix.o
diff --git a/drivers/input/touchscreen/zinitix.c b/drivers/input/touchscreen/zinitix.c
new file mode 100644
index 000000000000..55b1816b39d4
--- /dev/null
+++ b/drivers/input/touchscreen/zinitix.c
@@ -0,0 +1,508 @@ 
+// SPDX-License-Identifier: GPL-2.0-only
+
+#include <linux/kernel.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/input/mt.h>
+#include <linux/input/touchscreen.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <linux/of.h>
+#include <asm/unaligned.h>
+
+/* Register Map */
+
+#define BT541_SWRESET_CMD			0x0000
+#define BT541_WAKEUP_CMD			0x0001
+
+#define BT541_IDLE_CMD				0x0004
+#define BT541_SLEEP_CMD				0x0005
+
+#define BT541_CLEAR_INT_STATUS_CMD		0x0003
+#define BT541_CALIBRATE_CMD			0x0006
+#define BT541_SAVE_STATUS_CMD			0x0007
+#define BT541_SAVE_CALIBRATION_CMD		0x0008
+#define BT541_RECALL_FACTORY_CMD		0x000f
+
+#define BT541_THRESHOLD				0x0020
+
+#define BT541_LARGE_PALM_REJECT_AREA_TH		0x003F
+
+#define BT541_DEBUG_REG				0x0115 /* 0~7 */
+
+#define BT541_TOUCH_MODE			0x0010
+#define BT541_CHIP_REVISION			0x0011
+#define BT541_FIRMWARE_VERSION			0x0012
+
+#define ZINITIX_USB_DETECT			0x116
+
+#define BT541_MINOR_FW_VERSION			0x0121
+
+#define BT541_VENDOR_ID				0x001C
+#define BT541_HW_ID				0x0014
+
+#define BT541_DATA_VERSION_REG			0x0013
+#define BT541_SUPPORTED_FINGER_NUM		0x0015
+#define BT541_EEPROM_INFO			0x0018
+#define BT541_INITIAL_TOUCH_MODE		0x0019
+
+#define BT541_TOTAL_NUMBER_OF_X			0x0060
+#define BT541_TOTAL_NUMBER_OF_Y			0x0061
+
+#define BT541_DELAY_RAW_FOR_HOST		0x007f
+
+#define BT541_BUTTON_SUPPORTED_NUM		0x00B0
+#define BT541_BUTTON_SENSITIVITY		0x00B2
+#define BT541_DUMMY_BUTTON_SENSITIVITY		0X00C8
+
+#define BT541_X_RESOLUTION			0x00C0
+#define BT541_Y_RESOLUTION			0x00C1
+
+#define BT541_POINT_STATUS_REG			0x0080
+#define BT541_ICON_STATUS_REG			0x00AA
+
+#define BT541_POINT_COORD_REG			(BT541_POINT_STATUS_REG + 2)
+
+#define BT541_AFE_FREQUENCY			0x0100
+#define BT541_DND_N_COUNT			0x0122
+#define BT541_DND_U_COUNT			0x0135
+
+#define BT541_RAWDATA_REG			0x0200
+
+#define BT541_EEPROM_INFO_REG			0x0018
+
+#define BT541_INT_ENABLE_FLAG			0x00f0
+#define BT541_PERIODICAL_INTERRUPT_INTERVAL	0x00f1
+
+#define BT541_BTN_WIDTH				0x016d
+
+#define BT541_CHECKSUM_RESULT			0x012c
+
+#define BT541_INIT_FLASH			0x01d0
+#define BT541_WRITE_FLASH			0x01d1
+#define BT541_READ_FLASH			0x01d2
+
+#define ZINITIX_INTERNAL_FLAG_02		0x011e
+#define ZINITIX_INTERNAL_FLAG_03		0x011f
+
+#define ZINITIX_I2C_CHECKSUM_WCNT		0x016a
+#define ZINITIX_I2C_CHECKSUM_RESULT		0x016c
+
+/* Interrupt & status register flags */
+
+#define BIT_PT_CNT_CHANGE	BIT(0)
+#define BIT_DOWN		BIT(1)
+#define BIT_MOVE		BIT(2)
+#define BIT_UP			BIT(3)
+#define BIT_PALM		BIT(4)
+#define BIT_PALM_REJECT		BIT(5)
+#define BIT_RESERVED_0		BIT(6)
+#define BIT_RESERVED_1		BIT(7)
+#define BIT_WEIGHT_CHANGE	BIT(8)
+#define BIT_PT_NO_CHANGE	BIT(9)
+#define BIT_REJECT		BIT(10)
+#define BIT_PT_EXIST		BIT(11)
+#define BIT_RESERVED_2		BIT(12)
+#define BIT_ERROR		BIT(13)
+#define BIT_DEBUG		BIT(14)
+#define BIT_ICON_EVENT		BIT(15)
+
+#define SUB_BIT_EXIST		BIT(0)
+#define SUB_BIT_DOWN		BIT(1)
+#define SUB_BIT_MOVE		BIT(2)
+#define SUB_BIT_UP		BIT(3)
+#define SUB_BIT_UPDATE		BIT(4)
+#define SUB_BIT_WAIT		BIT(5)
+
+#define TOUCH_POINT_MODE		1
+#define MAX_SUPPORTED_FINGER_NUM	5
+
+#define CHIP_ON_DELAY	15 // ms
+#define FIRMWARE_ON_DELAY 40 // ms
+
+#define DELAY_FOR_TRANSACTION		50 // μs
+#define DELAY_FOR_POST_TRANSCATION	10 // μs
+
+struct point_coord {
+	__le16	x;
+	__le16	y;
+	u8	width;
+	u8	sub_status;
+	// not used on this model, but needed as padding:
+	u8	minor_width;
+	u8	angle;
+} __packed;
+
+struct point_status {
+	__le16	status;
+	__le16	event_flag;
+} __packed;
+
+struct bt541_ts_data {
+	struct i2c_client *client;
+	struct input_dev *input_dev;
+	struct touchscreen_properties prop;
+	struct regulator_bulk_data supplies[2];
+};
+
+static inline s32 zinitix_read_data(struct i2c_client *client,
+				    u16 reg, u8 *values, u16 length)
+{
+	int ret;
+	__le16 reg_le = cpu_to_le16(reg);
+
+	ret = i2c_master_send(client, (u8 *)&reg_le, sizeof(reg_le));
+	if (ret < 0)
+		return ret;
+
+	udelay(DELAY_FOR_TRANSACTION);
+	ret = i2c_master_recv(client, values, length);
+	if (ret < 0)
+		return ret;
+
+	udelay(DELAY_FOR_POST_TRANSCATION);
+	return 0;
+}
+
+static inline s32 zinitix_write_data(struct i2c_client *client,
+				     u16 reg, u8 *values, u16 length)
+{
+	int ret;
+	u8 *packet;
+	__le16 reg_le = cpu_to_le16(reg);
+
+	packet = kmalloc(length + sizeof(reg_le), GFP_KERNEL);
+	memcpy(packet, (u8 *)&reg_le, sizeof(reg_le));
+	memcpy(packet + sizeof(reg_le), values, length);
+
+	ret = i2c_master_send(client, packet, length + sizeof(reg_le));
+	kfree(packet);
+	if (ret < 0)
+		return ret;
+
+	udelay(DELAY_FOR_POST_TRANSCATION);
+	return 0;
+}
+
+static inline s32 zinitix_write_u16(struct i2c_client *client, u16 reg, u16 value)
+{
+	__le16 value_le = cpu_to_le16(value);
+
+	return zinitix_write_data(client, reg, (u8 *)&value_le, sizeof(reg));
+}
+
+static inline s32 zinitix_write_cmd(struct i2c_client *client, u16 reg)
+{
+	int ret;
+	__le16 reg_le = cpu_to_le16(reg);
+
+	ret = i2c_master_send(client, (u8 *)&reg_le, sizeof(reg_le));
+	if (ret < 0)
+		return ret;
+
+	udelay(DELAY_FOR_POST_TRANSCATION);
+	return 0;
+}
+
+static bool zinitix_init_touch(struct bt541_ts_data *bt541)
+{
+	struct i2c_client *client = bt541->client;
+	int i;
+	int ret;
+
+	ret = zinitix_write_cmd(client, BT541_SWRESET_CMD);
+	if (ret) {
+		dev_err(&client->dev, "Failed to write reset command\n");
+		return ret;
+	}
+
+	ret = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG, 0x0);
+	if (ret) {
+		dev_err(&client->dev, "failed to reset interrupt enable flag\n");
+		return ret;
+	}
+
+	/* initialize */
+	ret = zinitix_write_u16(client, BT541_X_RESOLUTION, (u16)bt541->prop.max_x);
+	if (ret)
+		return ret;
+
+	ret = zinitix_write_u16(client, BT541_Y_RESOLUTION, (u16)bt541->prop.max_y);
+	if (ret)
+		return ret;
+
+	ret = zinitix_write_u16(client, BT541_SUPPORTED_FINGER_NUM,
+				(u16)MAX_SUPPORTED_FINGER_NUM);
+	if (ret)
+		return ret;
+
+	ret = zinitix_write_u16(client, BT541_INITIAL_TOUCH_MODE, TOUCH_POINT_MODE);
+	if (ret)
+		return ret;
+
+	ret = zinitix_write_u16(client, BT541_TOUCH_MODE, TOUCH_POINT_MODE);
+	if (ret)
+		return ret;
+
+	ret = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG,
+				BIT_PT_CNT_CHANGE | BIT_DOWN | BIT_MOVE | BIT_UP);
+	if (ret)
+		return ret;
+
+	/* clear queue */
+	for (i = 0; i < 10; i++) {
+		zinitix_write_cmd(client, BT541_CLEAR_INT_STATUS_CMD);
+		udelay(10);
+	}
+
+	return 0;
+}
+
+static int zinitix_init_regulators(struct bt541_ts_data *bt541)
+{
+	struct i2c_client *client = bt541->client;
+	int ret;
+
+	bt541->supplies[0].supply = "vdd";
+	bt541->supplies[1].supply = "vddo";
+	ret = devm_regulator_bulk_get(&client->dev, ARRAY_SIZE(bt541->supplies),
+				      bt541->supplies);
+	if (ret < 0) {
+		dev_err(&client->dev, "Failed to get regulators: %d\n", ret);
+		return ret;
+	}
+
+	return 0;
+}
+
+static int zinitix_send_power_on_sequence(struct bt541_ts_data *bt541)
+{
+	int ret;
+	struct i2c_client *client = bt541->client;
+
+	ret = zinitix_write_u16(client, 0xc000, 0x0001);
+	if (ret) {
+		dev_err(&client->dev, "Failed to send power sequence(vendor cmd enable)\n");
+		return ret;
+	}
+	udelay(10);
+
+	ret = zinitix_write_cmd(client, 0xc004);
+	if (ret) {
+		dev_err(&client->dev, "Failed to send power sequence(intn clear)\n");
+		return ret;
+	}
+	udelay(10);
+
+	ret = zinitix_write_u16(client, 0xc002, 0x0001);
+	if (ret) {
+		dev_err(&client->dev, "Failed to send power sequence(nvm init)\n");
+		return ret;
+	}
+	mdelay(2);
+
+	ret = zinitix_write_u16(client, 0xc001, 0x0001);
+	if (ret) {
+		dev_err(&client->dev, "Failed to send power sequence(program start)\n");
+		return ret;
+	}
+	msleep(FIRMWARE_ON_DELAY);	/* wait for checksum cal */
+
+	return 0;
+}
+
+static irqreturn_t zinitix_ts_irq_handler(int irq, void *bt541_handler)
+{
+	struct bt541_ts_data *bt541 = (struct bt541_ts_data *)bt541_handler;
+	struct i2c_client *client = bt541->client;
+	int i;
+	int ret;
+	struct point_status point_status;
+	struct point_coord point_coord[MAX_SUPPORTED_FINGER_NUM] = {0};
+
+	memset(&point_status, 0, sizeof(struct point_status));
+
+	ret = zinitix_read_data(bt541->client, BT541_POINT_STATUS_REG,
+				(u8 *)&point_status, sizeof(struct point_status));
+	if (ret) {
+		dev_err(&client->dev, "%s: Failed to read point status\n", __func__);
+
+		zinitix_write_cmd(bt541->client, BT541_CLEAR_INT_STATUS_CMD);
+		return IRQ_HANDLED;
+	}
+
+	for (i = 0; i < MAX_SUPPORTED_FINGER_NUM; i++) {
+		if (!(le16_to_cpu(point_status.event_flag) & BIT(i)))
+			continue;
+
+		ret = zinitix_read_data(bt541->client, BT541_POINT_COORD_REG +
+					(i * sizeof(struct point_coord) / sizeof(u16)),
+					(u8 *)&point_coord[i], sizeof(struct point_coord));
+		if (ret) {
+			dev_err(&client->dev, "%s: Failed to read point info\n", __func__);
+
+			zinitix_write_cmd(bt541->client, BT541_CLEAR_INT_STATUS_CMD);
+			return IRQ_HANDLED;
+		}
+
+		if (!(point_coord[i].sub_status & SUB_BIT_EXIST))
+			continue;
+
+		input_mt_slot(bt541->input_dev, i);
+		input_mt_report_slot_state(bt541->input_dev, MT_TOOL_FINGER, true);
+		touchscreen_report_pos(bt541->input_dev, &bt541->prop,
+				       le16_to_cpu(point_coord[i].x),
+				       le16_to_cpu(point_coord[i].y), true);
+		input_report_abs(bt541->input_dev, ABS_MT_TOUCH_MAJOR, point_coord[i].width);
+		input_report_abs(bt541->input_dev, ABS_MT_WIDTH_MAJOR, point_coord[i].width);
+	}
+
+	zinitix_write_cmd(bt541->client, BT541_CLEAR_INT_STATUS_CMD);
+
+	input_mt_sync_frame(bt541->input_dev);
+	input_sync(bt541->input_dev);
+
+	return IRQ_HANDLED;
+}
+
+static int zinitix_init_input_dev(struct bt541_ts_data *bt541)
+{
+	int ret;
+
+	bt541->input_dev = devm_input_allocate_device(&bt541->client->dev);
+	if (!bt541->input_dev) {
+		dev_err(&bt541->client->dev, "Failed to allocate input device.");
+		return -ENOMEM;
+	}
+
+	bt541->input_dev->name = "Zinitix Capacitive TouchScreen";
+	bt541->input_dev->phys = "input/ts";
+	bt541->input_dev->id.bustype = BUS_I2C;
+
+	input_set_capability(bt541->input_dev, EV_ABS, ABS_MT_POSITION_X);
+	input_set_capability(bt541->input_dev, EV_ABS, ABS_MT_POSITION_Y);
+	input_set_abs_params(bt541->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
+	input_set_abs_params(bt541->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
+
+	touchscreen_parse_properties(bt541->input_dev, true, &bt541->prop);
+
+	if (!bt541->prop.max_x || !bt541->prop.max_y) {
+		dev_err(&bt541->client->dev, "touchscreen-size-x and/or touchscreen-size-y not set in dts\n");
+		return -EINVAL;
+	}
+
+	ret = input_mt_init_slots(bt541->input_dev, MAX_SUPPORTED_FINGER_NUM,
+				  INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
+	if (ret) {
+		dev_err(&bt541->client->dev,
+			"Failed to initialize MT slots: %d", ret);
+		return ret;
+	}
+
+	ret = input_register_device(bt541->input_dev);
+	if (ret) {
+		dev_err(&bt541->client->dev,
+			"Failed to register input device: %d", ret);
+		return ret;
+	}
+
+	return 0;
+}
+
+static int zinitix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+	struct bt541_ts_data *bt541;
+	int ret;
+
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+		dev_err(&client->dev, "I2C check functionality failed.\n");
+		return -ENXIO;
+	}
+
+	bt541 = devm_kzalloc(&client->dev, sizeof(*bt541), GFP_KERNEL);
+	if (!bt541)
+		return -ENOMEM;
+
+	bt541->client = client;
+	i2c_set_clientdata(client, bt541);
+
+	ret = zinitix_init_regulators(bt541);
+	if (ret) {
+		dev_err(&client->dev, "regulator initialization failed: %d\n", ret);
+		return ret;
+	}
+
+	ret = regulator_bulk_enable(ARRAY_SIZE(bt541->supplies), bt541->supplies);
+	if (ret < 0) {
+		dev_err(&client->dev, "Failed to enable regulators: %d\n", ret);
+		return ret;
+	}
+
+	msleep(CHIP_ON_DELAY);
+
+	ret = zinitix_send_power_on_sequence(bt541);
+	if (ret) {
+		dev_err(&client->dev, "sending power-on sequence failed: %d\n", ret);
+		return ret;
+	}
+
+	ret = zinitix_init_input_dev(bt541);
+	if (ret) {
+		dev_err(&client->dev, "input dev initialization failed: %d\n", ret);
+		return ret;
+	}
+
+	ret = zinitix_init_touch(bt541);
+	if (ret) {
+		dev_err(&client->dev, "Failed to init touchscreen ic\n");
+		return ret;
+	}
+
+	ret = devm_request_threaded_irq(&bt541->client->dev, bt541->client->irq,
+					NULL, zinitix_ts_irq_handler,
+					IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+					bt541->client->name, bt541);
+	if (ret) {
+		dev_err(&client->dev, "request IRQ failed: %d\n", ret);
+		return ret;
+	}
+
+	dev_info(&client->dev, "initialized a zinitix touchscreen\n");
+
+	return 0;
+}
+
+static int zinitix_ts_remove(struct i2c_client *client)
+{
+	struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
+
+	regulator_bulk_disable(ARRAY_SIZE(bt541->supplies), bt541->supplies);
+
+	return 0;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id zinitix_of_match[] = {
+	{ .compatible = "zinitix,bt541" },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, zinitix_of_match);
+#endif
+
+static struct i2c_driver zinitix_ts_driver = {
+	.probe = zinitix_ts_probe,
+	.remove = zinitix_ts_remove,
+	.driver = {
+		.name = "Zinitix-TS",
+		.of_match_table = of_match_ptr(zinitix_of_match),
+	},
+};
+module_i2c_driver(zinitix_ts_driver);
+
+MODULE_AUTHOR("Michael Srba <Michael.Srba@seznam.cz>");
+MODULE_DESCRIPTION("Zinitix touchscreen driver");
+MODULE_LICENSE("GPL v2");