[linux-2.6-block.git] / drivers / input / touchscreen / ektf2127.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Driver for ELAN eKTF2127 i2c touchscreen controller
 *
 * For this driver the layout of the Chipone icn8318 i2c
 * touchscreencontroller is used.
 *
 * Author:
 * Michel Verlaan <michel.verl@gmail.com>
 * Siebren Vroegindeweij <siebren.vroegindeweij@hotmail.com>
 *
 * Original chipone_icn8318 driver:
 * Hans de Goede <hdegoede@redhat.com>
 */

#include <linux/gpio/consumer.h>
#include <linux/interrupt.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/of.h>
#include <linux/delay.h>

/* Packet header defines (first byte of data send / received) */
#define EKTF2127_NOISE			0x40
#define EKTF2127_RESPONSE		0x52
#define EKTF2127_REQUEST		0x53
#define EKTF2127_HELLO			0x55
#define EKTF2127_REPORT2		0x5a
#define EKTF2127_REPORT			0x5d
#define EKTF2127_CALIB_DONE		0x66

/* Register defines (second byte of data send / received) */
#define EKTF2127_ENV_NOISY		0x41
#define EKTF2127_HEIGHT			0x60
#define EKTF2127_WIDTH			0x63

/* 2 bytes header + 5 * 3 bytes coordinates + 3 bytes pressure info + footer */
#define EKTF2127_TOUCH_REPORT_SIZE	21
#define EKTF2127_MAX_TOUCHES		5

struct ektf2127_ts {
	struct i2c_client *client;
	struct input_dev *input;
	struct gpio_desc *power_gpios;
	struct touchscreen_properties prop;
};

static void ektf2127_parse_coordinates(const u8 *buf, unsigned int touch_count,
				       struct input_mt_pos *touches)
{
	int index = 0;
	int i;

	for (i = 0; i < touch_count; i++) {
		index = 2 + i * 3;

		touches[i].x = (buf[index] & 0x0f);
		touches[i].x <<= 8;
		touches[i].x |= buf[index + 2];

		touches[i].y = (buf[index] & 0xf0);
		touches[i].y <<= 4;
		touches[i].y |= buf[index + 1];
	}
}

static void ektf2127_report_event(struct ektf2127_ts *ts, const u8 *buf)
{
	struct input_mt_pos touches[EKTF2127_MAX_TOUCHES];
	int slots[EKTF2127_MAX_TOUCHES];
	unsigned int touch_count, i;

	touch_count = buf[1] & 0x07;
	if (touch_count > EKTF2127_MAX_TOUCHES) {
		dev_err(&ts->client->dev,
			"Too many touches %d > %d\n",
			touch_count, EKTF2127_MAX_TOUCHES);
		touch_count = EKTF2127_MAX_TOUCHES;
	}

	ektf2127_parse_coordinates(buf, touch_count, touches);
	input_mt_assign_slots(ts->input, slots, touches,
			      touch_count, 0);

	for (i = 0; i < touch_count; i++) {
		input_mt_slot(ts->input, slots[i]);
		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
		touchscreen_report_pos(ts->input, &ts->prop,
				       touches[i].x, touches[i].y, true);
	}

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

static void ektf2127_report2_contact(struct ektf2127_ts *ts, int slot,
				     const u8 *buf, bool active)
{
	input_mt_slot(ts->input, slot);
	input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, active);

	if (active) {
		int x = (buf[0] & 0xf0) << 4 | buf[1];
		int y = (buf[0] & 0x0f) << 8 | buf[2];

		touchscreen_report_pos(ts->input, &ts->prop, x, y, true);
	}
}

static void ektf2127_report2_event(struct ektf2127_ts *ts, const u8 *buf)
{
	ektf2127_report2_contact(ts, 0, &buf[1], !!(buf[7] & 2));
	ektf2127_report2_contact(ts, 1, &buf[4], !!(buf[7] & 4));

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

static irqreturn_t ektf2127_irq(int irq, void *dev_id)
{
	struct ektf2127_ts *ts = dev_id;
	struct device *dev = &ts->client->dev;
	char buf[EKTF2127_TOUCH_REPORT_SIZE];
	int ret;

	ret = i2c_master_recv(ts->client, buf, EKTF2127_TOUCH_REPORT_SIZE);
	if (ret != EKTF2127_TOUCH_REPORT_SIZE) {
		dev_err(dev, "Error reading touch data: %d\n", ret);
		goto out;
	}

	switch (buf[0]) {
	case EKTF2127_REPORT:
		ektf2127_report_event(ts, buf);
		break;

	case EKTF2127_REPORT2:
		ektf2127_report2_event(ts, buf);
		break;

	case EKTF2127_NOISE:
		if (buf[1] == EKTF2127_ENV_NOISY)
			dev_dbg(dev, "Environment is electrically noisy\n");
		break;

	case EKTF2127_HELLO:
	case EKTF2127_CALIB_DONE:
		break;

	default:
		dev_err(dev, "Unexpected packet header byte %#02x\n", buf[0]);
		break;
	}

out:
	return IRQ_HANDLED;
}

static int ektf2127_start(struct input_dev *dev)
{
	struct ektf2127_ts *ts = input_get_drvdata(dev);

	enable_irq(ts->client->irq);
	gpiod_set_value_cansleep(ts->power_gpios, 1);

	return 0;
}

static void ektf2127_stop(struct input_dev *dev)
{
	struct ektf2127_ts *ts = input_get_drvdata(dev);

	disable_irq(ts->client->irq);
	gpiod_set_value_cansleep(ts->power_gpios, 0);
}

static int __maybe_unused ektf2127_suspend(struct device *dev)
{
	struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev));

	mutex_lock(&ts->input->mutex);
	if (input_device_enabled(ts->input))
		ektf2127_stop(ts->input);
	mutex_unlock(&ts->input->mutex);

	return 0;
}

static int __maybe_unused ektf2127_resume(struct device *dev)
{
	struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev));

	mutex_lock(&ts->input->mutex);
	if (input_device_enabled(ts->input))
		ektf2127_start(ts->input);
	mutex_unlock(&ts->input->mutex);

	return 0;
}

static SIMPLE_DEV_PM_OPS(ektf2127_pm_ops, ektf2127_suspend,
			 ektf2127_resume);

static int ektf2127_query_dimension(struct i2c_client *client, bool width)
{
	struct device *dev = &client->dev;
	const char *what = width ? "width" : "height";
	u8 what_code = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT;
	u8 buf[4];
	int ret;
	int error;

	/* Request dimension */
	buf[0] = EKTF2127_REQUEST;
	buf[1] = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT;
	buf[2] = 0x00;
	buf[3] = 0x00;
	ret = i2c_master_send(client, buf, sizeof(buf));
	if (ret != sizeof(buf)) {
		error = ret < 0 ? ret : -EIO;
		dev_err(dev, "Failed to request %s: %d\n", what, error);
		return error;
	}

	msleep(20);

	/* Read response */
	ret = i2c_master_recv(client, buf, sizeof(buf));
	if (ret != sizeof(buf)) {
		error = ret < 0 ? ret : -EIO;
		dev_err(dev, "Failed to receive %s data: %d\n", what, error);
		return error;
	}

	if (buf[0] != EKTF2127_RESPONSE || buf[1] != what_code) {
		dev_err(dev, "Unexpected %s data: %#02x %#02x\n",
			what, buf[0], buf[1]);
		return -EIO;
	}

	return (((buf[3] & 0xf0) << 4) | buf[2]) - 1;
}

static int ektf2127_probe(struct i2c_client *client,
			  const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct ektf2127_ts *ts;
	struct input_dev *input;
	u8 buf[4];
	int max_x, max_y;
	int error;

	if (!client->irq) {
		dev_err(dev, "Error no irq specified\n");
		return -EINVAL;
	}

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

	/* This requests the gpio *and* turns on the touchscreen controller */
	ts->power_gpios = devm_gpiod_get(dev, "power", GPIOD_OUT_HIGH);
	if (IS_ERR(ts->power_gpios)) {
		error = PTR_ERR(ts->power_gpios);
		if (error != -EPROBE_DEFER)
			dev_err(dev, "Error getting power gpio: %d\n", error);
		return error;
	}

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

	input->name = client->name;
	input->id.bustype = BUS_I2C;
	input->open = ektf2127_start;
	input->close = ektf2127_stop;

	ts->client = client;

	/* Read hello (ignore result, depends on initial power state) */
	msleep(20);
	i2c_master_recv(ts->client, buf, sizeof(buf));

	/* Read resolution from chip */
	max_x = ektf2127_query_dimension(client, true);
	if (max_x < 0)
		return max_x;

	max_y = ektf2127_query_dimension(client, false);
	if (max_y < 0)
		return max_y;

	input_set_abs_params(input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
	input_set_abs_params(input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
	touchscreen_parse_properties(input, true, &ts->prop);

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

	ts->input = input;
	input_set_drvdata(input, ts);

	error = devm_request_threaded_irq(dev, client->irq,
					  NULL, ektf2127_irq,
					  IRQF_ONESHOT, client->name, ts);
	if (error) {
		dev_err(dev, "Error requesting irq: %d\n", error);
		return error;
	}

	/* Stop device till opened */
	ektf2127_stop(ts->input);

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

	i2c_set_clientdata(client, ts);

	return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id ektf2127_of_match[] = {
	{ .compatible = "elan,ektf2127" },
	{ .compatible = "elan,ektf2132" },
	{}
};
MODULE_DEVICE_TABLE(of, ektf2127_of_match);
#endif

static const struct i2c_device_id ektf2127_i2c_id[] = {
	{ "ektf2127", 0 },
	{ "ektf2132", 0 },
	{}
};
MODULE_DEVICE_TABLE(i2c, ektf2127_i2c_id);

static struct i2c_driver ektf2127_driver = {
	.driver = {
		.name	= "elan_ektf2127",
		.pm	= &ektf2127_pm_ops,
		.of_match_table = of_match_ptr(ektf2127_of_match),
	},
	.probe = ektf2127_probe,
	.id_table = ektf2127_i2c_id,
};
module_i2c_driver(ektf2127_driver);

MODULE_DESCRIPTION("ELAN eKTF2127/eKTF2132 I2C Touchscreen Driver");
MODULE_AUTHOR("Michel Verlaan, Siebren Vroegindeweij");
MODULE_LICENSE("GPL");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
9ca5bf50 SV	2	/*
	3	* Driver for ELAN eKTF2127 i2c touchscreen controller
	4	*
	5	* For this driver the layout of the Chipone icn8318 i2c
	6	* touchscreencontroller is used.
	7	*
9ca5bf50 SV	8	* Author:
	9	* Michel Verlaan <michel.verl@gmail.com>
	10	* Siebren Vroegindeweij <siebren.vroegindeweij@hotmail.com>
	11	*
	12	* Original chipone_icn8318 driver:
	13	* Hans de Goede <hdegoede@redhat.com>
	14	*/
	15
	16	#include <linux/gpio/consumer.h>
	17	#include <linux/interrupt.h>
	18	#include <linux/i2c.h>
	19	#include <linux/input.h>
	20	#include <linux/input/mt.h>
	21	#include <linux/input/touchscreen.h>
	22	#include <linux/module.h>
	23	#include <linux/of.h>
	24	#include <linux/delay.h>
	25
	26	/* Packet header defines (first byte of data send / received) */
	27	#define EKTF2127_NOISE 0x40
	28	#define EKTF2127_RESPONSE 0x52
	29	#define EKTF2127_REQUEST 0x53
	30	#define EKTF2127_HELLO 0x55
af5689fb	31	#define EKTF2127_REPORT2 0x5a
9ca5bf50 SV	32	#define EKTF2127_REPORT 0x5d
	33	#define EKTF2127_CALIB_DONE 0x66
	34
	35	/* Register defines (second byte of data send / received) */
	36	#define EKTF2127_ENV_NOISY 0x41
	37	#define EKTF2127_HEIGHT 0x60
	38	#define EKTF2127_WIDTH 0x63
	39
	40	/* 2 bytes header + 5 * 3 bytes coordinates + 3 bytes pressure info + footer */
	41	#define EKTF2127_TOUCH_REPORT_SIZE 21
	42	#define EKTF2127_MAX_TOUCHES 5
	43
	44	struct ektf2127_ts {
	45	struct i2c_client *client;
	46	struct input_dev *input;
	47	struct gpio_desc *power_gpios;
	48	struct touchscreen_properties prop;
	49	};
	50
249d1bb2	51	static void ektf2127_parse_coordinates(const u8 *buf, unsigned int touch_count,
9ca5bf50 SV	52	struct input_mt_pos *touches)
	53	{
	54	int index = 0;
	55	int i;
	56
	57	for (i = 0; i < touch_count; i++) {
	58	index = 2 + i * 3;
	59
	60	touches[i].x = (buf[index] & 0x0f);
	61	touches[i].x <<= 8;
	62	touches[i].x \|= buf[index + 2];
	63
	64	touches[i].y = (buf[index] & 0xf0);
	65	touches[i].y <<= 4;
	66	touches[i].y \|= buf[index + 1];
	67	}
	68	}
	69
	70	static void ektf2127_report_event(struct ektf2127_ts ts, const u8 buf)
	71	{
	72	struct input_mt_pos touches[EKTF2127_MAX_TOUCHES];
	73	int slots[EKTF2127_MAX_TOUCHES];
	74	unsigned int touch_count, i;
	75
	76	touch_count = buf[1] & 0x07;
	77	if (touch_count > EKTF2127_MAX_TOUCHES) {
	78	dev_err(&ts->client->dev,
	79	"Too many touches %d > %d\n",
	80	touch_count, EKTF2127_MAX_TOUCHES);
	81	touch_count = EKTF2127_MAX_TOUCHES;
	82	}
	83
	84	ektf2127_parse_coordinates(buf, touch_count, touches);
	85	input_mt_assign_slots(ts->input, slots, touches,
	86	touch_count, 0);
	87
	88	for (i = 0; i < touch_count; i++) {
	89	input_mt_slot(ts->input, slots[i]);
	90	input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
	91	touchscreen_report_pos(ts->input, &ts->prop,
	92	touches[i].x, touches[i].y, true);
	93	}
	94
	95	input_mt_sync_frame(ts->input);
	96	input_sync(ts->input);
	97	}
	98
af5689fb JN	99	static void ektf2127_report2_contact(struct ektf2127_ts *ts, int slot,
	100	const u8 *buf, bool active)
	101	{
	102	input_mt_slot(ts->input, slot);
	103	input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, active);
	104
	105	if (active) {
	106	int x = (buf[0] & 0xf0) << 4 \| buf[1];
	107	int y = (buf[0] & 0x0f) << 8 \| buf[2];
	108
	109	touchscreen_report_pos(ts->input, &ts->prop, x, y, true);
	110	}
	111	}
	112
	113	static void ektf2127_report2_event(struct ektf2127_ts ts, const u8 buf)
	114	{
	115	ektf2127_report2_contact(ts, 0, &buf[1], !!(buf[7] & 2));
	116	ektf2127_report2_contact(ts, 1, &buf[4], !!(buf[7] & 4));
	117
	118	input_mt_sync_frame(ts->input);
	119	input_sync(ts->input);
	120	}
	121
9ca5bf50 SV	122	static irqreturn_t ektf2127_irq(int irq, void *dev_id)
	123	{
	124	struct ektf2127_ts *ts = dev_id;
	125	struct device *dev = &ts->client->dev;
	126	char buf[EKTF2127_TOUCH_REPORT_SIZE];
	127	int ret;
	128
	129	ret = i2c_master_recv(ts->client, buf, EKTF2127_TOUCH_REPORT_SIZE);
	130	if (ret != EKTF2127_TOUCH_REPORT_SIZE) {
	131	dev_err(dev, "Error reading touch data: %d\n", ret);
	132	goto out;
	133	}
	134
	135	switch (buf[0]) {
	136	case EKTF2127_REPORT:
	137	ektf2127_report_event(ts, buf);
	138	break;
	139
af5689fb JN	140	case EKTF2127_REPORT2:
	141	ektf2127_report2_event(ts, buf);
	142	break;
	143
9ca5bf50 SV	144	case EKTF2127_NOISE:
	145	if (buf[1] == EKTF2127_ENV_NOISY)
	146	dev_dbg(dev, "Environment is electrically noisy\n");
	147	break;
	148
	149	case EKTF2127_HELLO:
	150	case EKTF2127_CALIB_DONE:
	151	break;
	152
	153	default:
	154	dev_err(dev, "Unexpected packet header byte %#02x\n", buf[0]);
	155	break;
	156	}
	157
	158	out:
	159	return IRQ_HANDLED;
	160	}
	161
	162	static int ektf2127_start(struct input_dev *dev)
	163	{
	164	struct ektf2127_ts *ts = input_get_drvdata(dev);
	165
	166	enable_irq(ts->client->irq);
	167	gpiod_set_value_cansleep(ts->power_gpios, 1);
	168
	169	return 0;
	170	}
	171
	172	static void ektf2127_stop(struct input_dev *dev)
	173	{
	174	struct ektf2127_ts *ts = input_get_drvdata(dev);
	175
	176	disable_irq(ts->client->irq);
	177	gpiod_set_value_cansleep(ts->power_gpios, 0);
	178	}
	179
979987de	180	static int __maybe_unused ektf2127_suspend(struct device *dev)
9ca5bf50 SV	181	{
	182	struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev));
	183
	184	mutex_lock(&ts->input->mutex);
d69f0a43	185	if (input_device_enabled(ts->input))
9ca5bf50 SV	186	ektf2127_stop(ts->input);
	187	mutex_unlock(&ts->input->mutex);
	188
	189	return 0;
	190	}
	191
979987de	192	static int __maybe_unused ektf2127_resume(struct device *dev)
9ca5bf50 SV	193	{
	194	struct ektf2127_ts *ts = i2c_get_clientdata(to_i2c_client(dev));
	195
	196	mutex_lock(&ts->input->mutex);
d69f0a43	197	if (input_device_enabled(ts->input))
9ca5bf50 SV	198	ektf2127_start(ts->input);
	199	mutex_unlock(&ts->input->mutex);
	200
	201	return 0;
	202	}
	203
	204	static SIMPLE_DEV_PM_OPS(ektf2127_pm_ops, ektf2127_suspend,
	205	ektf2127_resume);
	206
	207	static int ektf2127_query_dimension(struct i2c_client *client, bool width)
	208	{
	209	struct device *dev = &client->dev;
	210	const char *what = width ? "width" : "height";
	211	u8 what_code = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT;
	212	u8 buf[4];
	213	int ret;
	214	int error;
	215
	216	/* Request dimension */
	217	buf[0] = EKTF2127_REQUEST;
	218	buf[1] = width ? EKTF2127_WIDTH : EKTF2127_HEIGHT;
	219	buf[2] = 0x00;
	220	buf[3] = 0x00;
	221	ret = i2c_master_send(client, buf, sizeof(buf));
	222	if (ret != sizeof(buf)) {
	223	error = ret < 0 ? ret : -EIO;
	224	dev_err(dev, "Failed to request %s: %d\n", what, error);
	225	return error;
	226	}
	227
	228	msleep(20);
	229
	230	/* Read response */
	231	ret = i2c_master_recv(client, buf, sizeof(buf));
	232	if (ret != sizeof(buf)) {
	233	error = ret < 0 ? ret : -EIO;
	234	dev_err(dev, "Failed to receive %s data: %d\n", what, error);
	235	return error;
	236	}
	237
	238	if (buf[0] != EKTF2127_RESPONSE \|\| buf[1] != what_code) {
	239	dev_err(dev, "Unexpected %s data: %#02x %#02x\n",
	240	what, buf[0], buf[1]);
	241	return -EIO;
	242	}
	243
	244	return (((buf[3] & 0xf0) << 4) \| buf[2]) - 1;
	245	}
	246
	247	static int ektf2127_probe(struct i2c_client *client,
	248	const struct i2c_device_id *id)
	249	{
	250	struct device *dev = &client->dev;
	251	struct ektf2127_ts *ts;
	252	struct input_dev *input;
	253	u8 buf[4];
	254	int max_x, max_y;
	255	int error;
	256
	257	if (!client->irq) {
	258	dev_err(dev, "Error no irq specified\n");
	259	return -EINVAL;
	260	}
	261
262	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
263	if (!ts)
264	return -ENOMEM;
265
266	/* This requests the gpio and turns on the touchscreen controller */
267	ts->power_gpios = devm_gpiod_get(dev, "power", GPIOD_OUT_HIGH);
268	if (IS_ERR(ts->power_gpios)) {
269	error = PTR_ERR(ts->power_gpios);
270	if (error != -EPROBE_DEFER)
271	dev_err(dev, "Error getting power gpio: %d\n", error);
272	return error;
273	}
274
275	input = devm_input_allocate_device(dev);
276	if (!input)
277	return -ENOMEM;
278
279	input->name = client->name;
280	input->id.bustype = BUS_I2C;
281	input->open = ektf2127_start;
282	input->close = ektf2127_stop;
283
284	ts->client = client;
285
286	/* Read hello (ignore result, depends on initial power state) */
287	msleep(20);
288	i2c_master_recv(ts->client, buf, sizeof(buf));
289
290	/* Read resolution from chip */
291	max_x = ektf2127_query_dimension(client, true);
292	if (max_x < 0)
293	return max_x;
294
295	max_y = ektf2127_query_dimension(client, false);
296	if (max_y < 0)
297	return max_y;
298
299	input_set_abs_params(input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
300	input_set_abs_params(input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
301	touchscreen_parse_properties(input, true, &ts->prop);
302
303	error = input_mt_init_slots(input, EKTF2127_MAX_TOUCHES,
304	INPUT_MT_DIRECT \|
305	INPUT_MT_DROP_UNUSED \|
306	INPUT_MT_TRACK);
307	if (error)
308	return error;
309
310	ts->input = input;
311	input_set_drvdata(input, ts);
312
313	error = devm_request_threaded_irq(dev, client->irq,
314	NULL, ektf2127_irq,
315	IRQF_ONESHOT, client->name, ts);
316	if (error) {
317	dev_err(dev, "Error requesting irq: %d\n", error);
318	return error;
319	}
320
321	/* Stop device till opened */
322	ektf2127_stop(ts->input);
323
324	error = input_register_device(input);
325	if (error)
326	return error;
327
328	i2c_set_clientdata(client, ts);
329
330	return 0;
331	}
332
333	#ifdef CONFIG_OF
334	static const struct of_device_id ektf2127_of_match[] = {
335	{ .compatible = "elan,ektf2127" },
af5689fb	336	{ .compatible = "elan,ektf2132" },
9ca5bf50 SV	337	{}
	338	};
	339	MODULE_DEVICE_TABLE(of, ektf2127_of_match);
	340	#endif
	341
	342	static const struct i2c_device_id ektf2127_i2c_id[] = {
	343	{ "ektf2127", 0 },
af5689fb	344	{ "ektf2132", 0 },
9ca5bf50 SV	345	{}
	346	};
	347	MODULE_DEVICE_TABLE(i2c, ektf2127_i2c_id);
	348
	349	static struct i2c_driver ektf2127_driver = {
	350	.driver = {
	351	.name = "elan_ektf2127",
	352	.pm = &ektf2127_pm_ops,
	353	.of_match_table = of_match_ptr(ektf2127_of_match),
	354	},
	355	.probe = ektf2127_probe,
	356	.id_table = ektf2127_i2c_id,
	357	};
	358	module_i2c_driver(ektf2127_driver);
	359
af5689fb	360	MODULE_DESCRIPTION("ELAN eKTF2127/eKTF2132 I2C Touchscreen Driver");
9ca5bf50 SV	361	MODULE_AUTHOR("Michel Verlaan, Siebren Vroegindeweij");
9ca5bf50 SV	362	MODULE_LICENSE("GPL");