Commit 351e0592 authored by Martin Kepplinger's avatar Martin Kepplinger Committed by Dmitry Torokhov
Browse files

Input: st1232 - add support for st1633 



Add support for the Sitronix ST1633 touchscreen controller to the st1232
driver. A protocol spec can be found here:
www.ampdisplay.com/documents/pdf/AM-320480B6TZQW-TC0H.pdf

Signed-off-by: default avatarMartin Kepplinger <martin.kepplinger@ginzinger.com>
Signed-off-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
parent b6eba860

Documentation/devicetree/bindings/input/touchscreen/sitronix-st1232.txt

+4 −2
Original line number Diff line number Diff line 
* Sitronix st1232 touchscreen controller

* Sitronix st1232 or st1633 touchscreen controller



Required properties:

- compatible: must be "sitronix,st1232"

- compatible: must contain one of

  * "sitronix,st1232"

  * "sitronix,st1633"

- reg: I2C address of the chip

- interrupts: interrupt to which the chip is connected

drivers/input/touchscreen/Kconfig

+3 −3
Original line number Diff line number Diff line
@@ -1168,11 +1168,11 @@ config TOUCHSCREEN_SIS_I2C 
	  module will be called sis_i2c.



config TOUCHSCREEN_ST1232

	tristate "Sitronix ST1232 touchscreen controllers"

	tristate "Sitronix ST1232 or ST1633 touchscreen controllers"

	depends on I2C

	help

	  Say Y here if you want to support Sitronix ST1232

	  touchscreen controller.

	  Say Y here if you want to support the Sitronix ST1232

	  or ST1633 touchscreen controller.



	  If unsure, say N.

drivers/input/touchscreen/st1232.c

+86 −34
Original line number Diff line number Diff line
@@ -23,13 +23,7 @@ 
#include <linux/types.h>



#define ST1232_TS_NAME	"st1232-ts"



#define MIN_X		0x00

#define MIN_Y		0x00

#define MAX_X		0x31f	/* (800 - 1) */

#define MAX_Y		0x1df	/* (480 - 1) */

#define MAX_AREA	0xff

#define MAX_FINGERS	2

#define ST1633_TS_NAME	"st1633-ts"



struct st1232_ts_finger {

	u16 x;
@@ -38,12 +32,24 @@ struct st1232_ts_finger { 
	bool is_valid;

};



struct st_chip_info {

	bool	have_z;

	u16	max_x;

	u16	max_y;

	u16	max_area;

	u16	max_fingers;

	u8	start_reg;

};



struct st1232_ts_data {

	struct i2c_client *client;

	struct input_dev *input_dev;

	struct st1232_ts_finger finger[MAX_FINGERS];

	struct dev_pm_qos_request low_latency_req;

	int reset_gpio;

	const struct st_chip_info *chip_info;

	int read_buf_len;

	u8 *read_buf;

	struct st1232_ts_finger *finger;

};



static int st1232_ts_read_data(struct st1232_ts_data *ts)
@@ -52,40 +58,35 @@ static int st1232_ts_read_data(struct st1232_ts_data *ts) 
	struct i2c_client *client = ts->client;

	struct i2c_msg msg[2];

	int error;

	u8 start_reg;

	u8 buf[10];

	int i, y;

	u8 start_reg = ts->chip_info->start_reg;

	u8 *buf = ts->read_buf;



	/* read touchscreen data from ST1232 */

	/* read touchscreen data */

	msg[0].addr = client->addr;

	msg[0].flags = 0;

	msg[0].len = 1;

	msg[0].buf = &start_reg;

	start_reg = 0x10;



	msg[1].addr = ts->client->addr;

	msg[1].flags = I2C_M_RD;

	msg[1].len = sizeof(buf);

	msg[1].len = ts->read_buf_len;

	msg[1].buf = buf;



	error = i2c_transfer(client->adapter, msg, 2);

	if (error < 0)

		return error;



	/* get "valid" bits */

	finger[0].is_valid = buf[2] >> 7;

	finger[1].is_valid = buf[5] >> 7;

	for (i = 0, y = 0; i < ts->chip_info->max_fingers; i++, y += 3) {

		finger[i].is_valid = buf[i + y] >> 7;

		if (finger[i].is_valid) {

			finger[i].x = ((buf[i + y] & 0x0070) << 4) | buf[i + 1];

			finger[i].y = ((buf[i + y] & 0x0007) << 8) | buf[i + 2];



	/* get xy coordinate */

	if (finger[0].is_valid) {

		finger[0].x = ((buf[2] & 0x0070) << 4) | buf[3];

		finger[0].y = ((buf[2] & 0x0007) << 8) | buf[4];

		finger[0].t = buf[8];

			/* st1232 includes a z-axis / touch strength */

			if (ts->chip_info->have_z)

				finger[i].t = buf[i + 6];

		}



	if (finger[1].is_valid) {

		finger[1].x = ((buf[5] & 0x0070) << 4) | buf[6];

		finger[1].y = ((buf[5] & 0x0007) << 8) | buf[7];

		finger[1].t = buf[9];

	}



	return 0;
@@ -104,11 +105,14 @@ static irqreturn_t st1232_ts_irq_handler(int irq, void *dev_id) 
		goto end;



	/* multi touch protocol */

	for (i = 0; i < MAX_FINGERS; i++) {

	for (i = 0; i < ts->chip_info->max_fingers; i++) {

		if (!finger[i].is_valid)

			continue;



		input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, finger[i].t);

		if (ts->chip_info->have_z)

			input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR,

					 finger[i].t);



		input_report_abs(input_dev, ABS_MT_POSITION_X, finger[i].x);

		input_report_abs(input_dev, ABS_MT_POSITION_Y, finger[i].y);

		input_mt_sync(input_dev);
@@ -142,13 +146,41 @@ static void st1232_ts_power(struct st1232_ts_data *ts, bool poweron) 
		gpio_direction_output(ts->reset_gpio, poweron);

}



static const struct st_chip_info st1232_chip_info = {

	.have_z		= true,

	.max_x		= 0x31f, /* 800 - 1 */

	.max_y		= 0x1df, /* 480 -1 */

	.max_area	= 0xff,

	.max_fingers	= 2,

	.start_reg	= 0x12,

};



static const struct st_chip_info st1633_chip_info = {

	.have_z		= false,

	.max_x		= 0x13f, /* 320 - 1 */

	.max_y		= 0x1df, /* 480 -1 */

	.max_area	= 0x00,

	.max_fingers	= 5,

	.start_reg	= 0x12,

};



static int st1232_ts_probe(struct i2c_client *client,

			   const struct i2c_device_id *id)

{

	const struct st_chip_info *match;

	struct st1232_ts_data *ts;

	struct st1232_ts_finger *finger;

	struct input_dev *input_dev;

	int error;



	match = device_get_match_data(&client->dev);

	if (!match && id)

		match = (const void *)id->driver_data;

	if (!match) {

		dev_err(&client->dev, "unknown device model\n");

		return -ENODEV;

	}



	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {

		dev_err(&client->dev, "need I2C_FUNC_I2C\n");

		return -EIO;
@@ -163,6 +195,19 @@ static int st1232_ts_probe(struct i2c_client *client, 
	if (!ts)

		return -ENOMEM;



	ts->chip_info = match;

	ts->finger = devm_kcalloc(&client->dev,

				  ts->chip_info->max_fingers, sizeof(*finger),

				  GFP_KERNEL);

	if (!ts->finger)

		return -ENOMEM;



	/* allocate a buffer according to the number of registers to read */

	ts->read_buf_len = ts->chip_info->max_fingers * 4;

	ts->read_buf = devm_kzalloc(&client->dev, ts->read_buf_len, GFP_KERNEL);

	if (!ts->read_buf)

		return -ENOMEM;



	input_dev = devm_input_allocate_device(&client->dev);

	if (!input_dev)

		return -ENOMEM;
@@ -192,9 +237,14 @@ static int st1232_ts_probe(struct i2c_client *client, 
	__set_bit(EV_KEY, input_dev->evbit);

	__set_bit(EV_ABS, input_dev->evbit);



	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);

	input_set_abs_params(input_dev, ABS_MT_POSITION_X, MIN_X, MAX_X, 0, 0);

	input_set_abs_params(input_dev, ABS_MT_POSITION_Y, MIN_Y, MAX_Y, 0, 0);

	if (ts->chip_info->have_z)

		input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0,

				     ts->chip_info->max_area, 0, 0);



	input_set_abs_params(input_dev, ABS_MT_POSITION_X,

			     0, ts->chip_info->max_x, 0, 0);

	input_set_abs_params(input_dev, ABS_MT_POSITION_Y,

			     0, ts->chip_info->max_y, 0, 0);



	error = devm_request_threaded_irq(&client->dev, client->irq,

					  NULL, st1232_ts_irq_handler,
@@ -261,13 +311,15 @@ static SIMPLE_DEV_PM_OPS(st1232_ts_pm_ops, 
			 st1232_ts_suspend, st1232_ts_resume);



static const struct i2c_device_id st1232_ts_id[] = {

	{ ST1232_TS_NAME, 0 },

	{ ST1232_TS_NAME, (unsigned long)&st1232_chip_info },

	{ ST1633_TS_NAME, (unsigned long)&st1633_chip_info },

	{ }

};

MODULE_DEVICE_TABLE(i2c, st1232_ts_id);



static const struct of_device_id st1232_ts_dt_ids[] = {

	{ .compatible = "sitronix,st1232", },

	{ .compatible = "sitronix,st1232", .data = &st1232_chip_info },

	{ .compatible = "sitronix,st1633", .data = &st1633_chip_info },

	{ }

};

MODULE_DEVICE_TABLE(of, st1232_ts_dt_ids);

CRA Git | Maintained and supported by SUSTech CRA and CCSE