1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* Copyright (C) 2012 Simon Budig, <simon.budig@kernelconcepts.de>
4	* Daniel Wagener <daniel.wagener@kernelconcepts.de> (M09 firmware support)
5	* Lothar Waßmann <LW@KARO-electronics.de> (DT support)
6	* Dario Binacchi <dario.binacchi@amarulasolutions.com> (regmap support)
7	*/
8
9	/*
10	* This is a driver for the EDT "Polytouch" family of touch controllers
11	* based on the FocalTech FT5x06 line of chips.
12	*
13	* Development of this driver has been sponsored by Glyn:
14	* http://www.glyn.com/Products/Displays
15	*/
16
17	#include <linux/debugfs.h>
18	#include <linux/delay.h>
19	#include <linux/gpio/consumer.h>
20	#include <linux/i2c.h>
21	#include <linux/interrupt.h>
22	#include <linux/input.h>
23	#include <linux/input/mt.h>
24	#include <linux/input/touchscreen.h>
25	#include <linux/irq.h>
26	#include <linux/kernel.h>
27	#include <linux/module.h>
28	#include <linux/property.h>
29	#include <linux/ratelimit.h>
30	#include <linux/regmap.h>
31	#include <linux/regulator/consumer.h>
32	#include <linux/slab.h>
33	#include <linux/uaccess.h>
34
35	#include <asm/unaligned.h>
36
37	#define WORK_REGISTER_THRESHOLD 0x00
38	#define WORK_REGISTER_REPORT_RATE 0x08
39	#define WORK_REGISTER_GAIN 0x30
40	#define WORK_REGISTER_OFFSET 0x31
41	#define WORK_REGISTER_NUM_X 0x33
42	#define WORK_REGISTER_NUM_Y 0x34
43
44	#define PMOD_REGISTER_ACTIVE 0x00
45	#define PMOD_REGISTER_HIBERNATE 0x03
46
47	#define M09_REGISTER_THRESHOLD 0x80
48	#define M09_REGISTER_GAIN 0x92
49	#define M09_REGISTER_OFFSET 0x93
50	#define M09_REGISTER_NUM_X 0x94
51	#define M09_REGISTER_NUM_Y 0x95
52
53	#define M12_REGISTER_REPORT_RATE 0x88
54
55	#define EV_REGISTER_THRESHOLD 0x40
56	#define EV_REGISTER_GAIN 0x41
57	#define EV_REGISTER_OFFSET_Y 0x45
58	#define EV_REGISTER_OFFSET_X 0x46
59
60	#define NO_REGISTER 0xff
61
62	#define WORK_REGISTER_OPMODE 0x3c
63	#define FACTORY_REGISTER_OPMODE 0x01
64	#define PMOD_REGISTER_OPMODE 0xa5
65
66	#define TOUCH_EVENT_DOWN 0x00
67	#define TOUCH_EVENT_UP 0x01
68	#define TOUCH_EVENT_ON 0x02
69	#define TOUCH_EVENT_RESERVED 0x03
70
71	#define EDT_NAME_LEN 23
72	#define EDT_SWITCH_MODE_RETRIES 10
73	#define EDT_SWITCH_MODE_DELAY 5 /* msec */
74	#define EDT_RAW_DATA_RETRIES 100
75	#define EDT_RAW_DATA_DELAY 1000 /* usec */
76
77	#define EDT_DEFAULT_NUM_X 1024
78	#define EDT_DEFAULT_NUM_Y 1024
79
80	#define M06_REG_CMD(factory) ((factory) ? 0xf3 : 0xfc)
81	#define M06_REG_ADDR(factory, addr) ((factory) ? (addr) & 0x7f : (addr) & 0x3f)
82
83	enum edt_pmode {
84	EDT_PMODE_NOT_SUPPORTED,
85	EDT_PMODE_HIBERNATE,
86	EDT_PMODE_POWEROFF,
87	};
88
89	enum edt_ver {
90	EDT_M06,
91	EDT_M09,
92	EDT_M12,
93	EV_FT,
94	GENERIC_FT,
95	};
96
97	struct edt_reg_addr {
98	int reg_threshold;
99	int reg_report_rate;
100	int reg_gain;
101	int reg_offset;
102	int reg_offset_x;
103	int reg_offset_y;
104	int reg_num_x;
105	int reg_num_y;
106	};
107
108	struct edt_ft5x06_ts_data {
109	struct i2c_client *client;
110	struct input_dev *input;
111	struct touchscreen_properties prop;
112	u16 num_x;
113	u16 num_y;
114	struct regulator *vcc;
115	struct regulator *iovcc;
116
117	struct gpio_desc *reset_gpio;
118	struct gpio_desc *wake_gpio;
119
120	struct regmap *regmap;
121
122	#if defined(CONFIG_DEBUG_FS)
123	struct dentry *debug_dir;
124	u8 *raw_buffer;
125	size_t raw_bufsize;
126	#endif
127
128	struct mutex mutex;
129	bool factory_mode;
130	enum edt_pmode suspend_mode;
131	int threshold;
132	int gain;
133	int offset;
134	int offset_x;
135	int offset_y;
136	int report_rate;
137	int max_support_points;
138	int point_len;
139	u8 tdata_cmd;
140	int tdata_len;
141	int tdata_offset;
142
143	char name[EDT_NAME_LEN];
144	char fw_version[EDT_NAME_LEN];
145
146	struct edt_reg_addr reg_addr;
147	enum edt_ver version;
148	unsigned int crc_errors;
149	unsigned int header_errors;
150	};
151
152	struct edt_i2c_chip_data {
153	int max_support_points;
154	};
155
156	static const struct regmap_config edt_ft5x06_i2c_regmap_config = {
157	.reg_bits = 8,
158	.val_bits = 8,
159	};
160
161	static bool edt_ft5x06_ts_check_crc(struct edt_ft5x06_ts_data *tsdata,
162	u8 *buf, int buflen)
163	{
164	int i;
165	u8 crc = 0;
166
167	for (i = 0; i < buflen - 1; i++)
168	crc ^= buf[i];
169
170	if (crc != buf[buflen - 1]) {
171	tsdata->crc_errors++;
172	dev_err_ratelimited(&tsdata->client->dev,
173	"crc error: 0x%02x expected, got 0x%02x\n",
174	crc, buf[buflen - 1]);
175	return false;
176	}
177
178	return true;
179	}
180
181	static int edt_M06_i2c_read(void *context, const void *reg_buf, size_t reg_size,
182	void *val_buf, size_t val_size)
183	{
184	struct device *dev = context;
185	struct i2c_client *i2c = to_i2c_client(dev);
186	struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client: i2c);
187	struct i2c_msg xfer[2];
188	bool reg_read = false;
189	u8 addr;
190	u8 wlen;
191	u8 wbuf[4], rbuf[3];
192	int ret;
193
194	addr = *((u8 *)reg_buf);
195	wbuf[0] = addr;
196	switch (addr) {
197	case 0xf5:
198	wlen = 3;
199	wbuf[0] = 0xf5;
200	wbuf[1] = 0xe;
201	wbuf[2] = *((u8 *)val_buf);
202	break;
203	case 0xf9:
204	wlen = 1;
205	break;
206	default:
207	wlen = 2;
208	reg_read = true;
209	wbuf[0] = M06_REG_CMD(tsdata->factory_mode);
210	wbuf[1] = M06_REG_ADDR(tsdata->factory_mode, addr);
211	wbuf[1] |= tsdata->factory_mode ? 0x80 : 0x40;
212	}
213
214	xfer[0].addr = i2c->addr;
215	xfer[0].flags = 0;
216	xfer[0].len = wlen;
217	xfer[0].buf = wbuf;
218
219	xfer[1].addr = i2c->addr;
220	xfer[1].flags = I2C_M_RD;
221	xfer[1].len = reg_read ? 2 : val_size;
222	xfer[1].buf = reg_read ? rbuf : val_buf;
223
224	ret = i2c_transfer(adap: i2c->adapter, msgs: xfer, num: 2);
225	if (ret != 2) {
226	if (ret < 0)
227	return ret;
228
229	return -EIO;
230	}
231
232	if (addr == 0xf9) {
233	u8 *buf = (u8 *)val_buf;
234
235	if (buf[0] != 0xaa || buf[1] != 0xaa ||
236	buf[2] != val_size) {
237	tsdata->header_errors++;
238	dev_err_ratelimited(dev,
239	"Unexpected header: %02x%02x%02x\n",
240	buf[0], buf[1], buf[2]);
241	return -EIO;
242	}
243
244	if (!edt_ft5x06_ts_check_crc(tsdata, buf: val_buf, buflen: val_size))
245	return -EIO;
246	} else if (reg_read) {
247	wbuf[2] = rbuf[0];
248	wbuf[3] = rbuf[1];
249	if (!edt_ft5x06_ts_check_crc(tsdata, buf: wbuf, buflen: 4))
250	return -EIO;
251
252	*((u8 *)val_buf) = rbuf[0];
253	}
254
255	return 0;
256	}
257
258	static int edt_M06_i2c_write(void *context, const void *data, size_t count)
259	{
260	struct device *dev = context;
261	struct i2c_client *i2c = to_i2c_client(dev);
262	struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client: i2c);
263	u8 addr, val;
264	u8 wbuf[4];
265	struct i2c_msg xfer;
266	int ret;
267
268	addr = *((u8 *)data);
269	val = *((u8 *)data + 1);
270
271	wbuf[0] = M06_REG_CMD(tsdata->factory_mode);
272	wbuf[1] = M06_REG_ADDR(tsdata->factory_mode, addr);
273	wbuf[2] = val;
274	wbuf[3] = wbuf[0] ^ wbuf[1] ^ wbuf[2];
275
276	xfer.addr = i2c->addr;
277	xfer.flags = 0;
278	xfer.len = 4;
279	xfer.buf = wbuf;
280
281	ret = i2c_transfer(adap: i2c->adapter, msgs: &xfer, num: 1);
282	if (ret != 1) {
283	if (ret < 0)
284	return ret;
285
286	return -EIO;
287	}
288
289	return 0;
290	}
291
292	static const struct regmap_config edt_M06_i2c_regmap_config = {
293	.reg_bits = 8,
294	.val_bits = 8,
295	.read = edt_M06_i2c_read,
296	.write = edt_M06_i2c_write,
297	};
298
299	static irqreturn_t edt_ft5x06_ts_isr(int irq, void *dev_id)
300	{
301	struct edt_ft5x06_ts_data *tsdata = dev_id;
302	struct device *dev = &tsdata->client->dev;
303	u8 rdbuf[63];
304	int i, type, x, y, id;
305	int error;
306
307	memset(rdbuf, 0, sizeof(rdbuf));
308	error = regmap_bulk_read(map: tsdata->regmap, reg: tsdata->tdata_cmd, val: rdbuf,
309	val_count: tsdata->tdata_len);
310	if (error) {
311	dev_err_ratelimited(dev, "Unable to fetch data, error: %d\n",
312	error);
313	goto out;
314	}
315
316	for (i = 0; i < tsdata->max_support_points; i++) {
317	u8 *buf = &rdbuf[i * tsdata->point_len + tsdata->tdata_offset];
318
319	type = buf[0] >> 6;
320	/* ignore Reserved events */
321	if (type == TOUCH_EVENT_RESERVED)
322	continue;
323
324	/* M06 sometimes sends bogus coordinates in TOUCH_DOWN */
325	if (tsdata->version == EDT_M06 && type == TOUCH_EVENT_DOWN)
326	continue;
327
328	x = get_unaligned_be16(p: buf) & 0x0fff;
329	y = get_unaligned_be16(p: buf + 2) & 0x0fff;
330	/* The FT5x26 send the y coordinate first */
331	if (tsdata->version == EV_FT)
332	swap(x, y);
333
334	id = (buf[2] >> 4) & 0x0f;
335
336	input_mt_slot(dev: tsdata->input, slot: id);
337	if (input_mt_report_slot_state(dev: tsdata->input, MT_TOOL_FINGER,
338	active: type != TOUCH_EVENT_UP))
339	touchscreen_report_pos(input: tsdata->input, prop: &tsdata->prop,
340	x, y, multitouch: true);
341	}
342
343	input_mt_report_pointer_emulation(dev: tsdata->input, use_count: true);
344	input_sync(dev: tsdata->input);
345
346	out:
347	return IRQ_HANDLED;
348	}
349
350	struct edt_ft5x06_attribute {
351	struct device_attribute dattr;
352	size_t field_offset;
353	u8 limit_low;
354	u8 limit_high;
355	u8 addr_m06;
356	u8 addr_m09;
357	u8 addr_ev;
358	};
359
360	#define EDT_ATTR(_field, _mode, _addr_m06, _addr_m09, _addr_ev, \
361	_limit_low, _limit_high) \
362	struct edt_ft5x06_attribute edt_ft5x06_attr_##_field = { \
363	.dattr = __ATTR(_field, _mode, \
364	edt_ft5x06_setting_show, \
365	edt_ft5x06_setting_store), \
366	.field_offset = offsetof(struct edt_ft5x06_ts_data, _field), \
367	.addr_m06 = _addr_m06, \
368	.addr_m09 = _addr_m09, \
369	.addr_ev = _addr_ev, \
370	.limit_low = _limit_low, \
371	.limit_high = _limit_high, \
372	}
373
374	static ssize_t edt_ft5x06_setting_show(struct device *dev,
375	struct device_attribute *dattr,
376	char *buf)
377	{
378	struct i2c_client *client = to_i2c_client(dev);
379	struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
380	struct edt_ft5x06_attribute *attr =
381	container_of(dattr, struct edt_ft5x06_attribute, dattr);
382	u8 *field = (u8 *)tsdata + attr->field_offset;
383	unsigned int val;
384	size_t count = 0;
385	int error = 0;
386	u8 addr;
387
388	mutex_lock(&tsdata->mutex);
389
390	if (tsdata->factory_mode) {
391	error = -EIO;
392	goto out;
393	}
394
395	switch (tsdata->version) {
396	case EDT_M06:
397	addr = attr->addr_m06;
398	break;
399
400	case EDT_M09:
401	case EDT_M12:
402	case GENERIC_FT:
403	addr = attr->addr_m09;
404	break;
405
406	case EV_FT:
407	addr = attr->addr_ev;
408	break;
409
410	default:
411	error = -ENODEV;
412	goto out;
413	}
414
415	if (addr != NO_REGISTER) {
416	error = regmap_read(map: tsdata->regmap, reg: addr, val: &val);
417	if (error) {
418	dev_err(&tsdata->client->dev,
419	"Failed to fetch attribute %s, error %d\n",
420	dattr->attr.name, error);
421	goto out;
422	}
423	} else {
424	val = *field;
425	}
426
427	if (val != *field) {
428	dev_warn(&tsdata->client->dev,
429	"%s: read (%d) and stored value (%d) differ\n",
430	dattr->attr.name, val, *field);
431	*field = val;
432	}
433
434	count = scnprintf(buf, PAGE_SIZE, fmt: "%d\n", val);
435	out:
436	mutex_unlock(lock: &tsdata->mutex);
437	return error ?: count;
438	}
439
440	static ssize_t edt_ft5x06_setting_store(struct device *dev,
441	struct device_attribute *dattr,
442	const char *buf, size_t count)
443	{
444	struct i2c_client *client = to_i2c_client(dev);
445	struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
446	struct edt_ft5x06_attribute *attr =
447	container_of(dattr, struct edt_ft5x06_attribute, dattr);
448	u8 *field = (u8 *)tsdata + attr->field_offset;
449	unsigned int val;
450	int error;
451	u8 addr;
452
453	mutex_lock(&tsdata->mutex);
454
455	if (tsdata->factory_mode) {
456	error = -EIO;
457	goto out;
458	}
459
460	error = kstrtouint(s: buf, base: 0, res: &val);
461	if (error)
462	goto out;
463
464	if (val < attr->limit_low || val > attr->limit_high) {
465	error = -ERANGE;
466	goto out;
467	}
468
469	switch (tsdata->version) {
470	case EDT_M06:
471	addr = attr->addr_m06;
472	break;
473
474	case EDT_M09:
475	case EDT_M12:
476	case GENERIC_FT:
477	addr = attr->addr_m09;
478	break;
479
480	case EV_FT:
481	addr = attr->addr_ev;
482	break;
483
484	default:
485	error = -ENODEV;
486	goto out;
487	}
488
489	if (addr != NO_REGISTER) {
490	error = regmap_write(map: tsdata->regmap, reg: addr, val);
491	if (error) {
492	dev_err(&tsdata->client->dev,
493	"Failed to update attribute %s, error: %d\n",
494	dattr->attr.name, error);
495	goto out;
496	}
497	}
498	*field = val;
499
500	out:
501	mutex_unlock(lock: &tsdata->mutex);
502	return error ?: count;
503	}
504
505	/* m06, m09: range 0-31, m12: range 0-5 */
506	static EDT_ATTR(gain, S_IWUSR | S_IRUGO, WORK_REGISTER_GAIN,
507	M09_REGISTER_GAIN, EV_REGISTER_GAIN, 0, 31);
508	/* m06, m09: range 0-31, m12: range 0-16 */
509	static EDT_ATTR(offset, S_IWUSR | S_IRUGO, WORK_REGISTER_OFFSET,
510	M09_REGISTER_OFFSET, NO_REGISTER, 0, 31);
511	/* m06, m09, m12: no supported, ev_ft: range 0-80 */
512	static EDT_ATTR(offset_x, S_IWUSR | S_IRUGO, NO_REGISTER, NO_REGISTER,
513	EV_REGISTER_OFFSET_X, 0, 80);
514	/* m06, m09, m12: no supported, ev_ft: range 0-80 */
515	static EDT_ATTR(offset_y, S_IWUSR | S_IRUGO, NO_REGISTER, NO_REGISTER,
516	EV_REGISTER_OFFSET_Y, 0, 80);
517	/* m06: range 20 to 80, m09: range 0 to 30, m12: range 1 to 255... */
518	static EDT_ATTR(threshold, S_IWUSR | S_IRUGO, WORK_REGISTER_THRESHOLD,
519	M09_REGISTER_THRESHOLD, EV_REGISTER_THRESHOLD, 0, 255);
520	/* m06: range 3 to 14, m12: range 1 to 255 */
521	static EDT_ATTR(report_rate, S_IWUSR | S_IRUGO, WORK_REGISTER_REPORT_RATE,
522	M12_REGISTER_REPORT_RATE, NO_REGISTER, 0, 255);
523
524	static ssize_t model_show(struct device *dev, struct device_attribute *attr,
525	char *buf)
526	{
527	struct i2c_client *client = to_i2c_client(dev);
528	struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
529
530	return sysfs_emit(buf, fmt: "%s\n", tsdata->name);
531	}
532
533	static DEVICE_ATTR_RO(model);
534
535	static ssize_t fw_version_show(struct device *dev,
536	struct device_attribute *attr, char *buf)
537	{
538	struct i2c_client *client = to_i2c_client(dev);
539	struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
540
541	return sysfs_emit(buf, fmt: "%s\n", tsdata->fw_version);
542	}
543
544	static DEVICE_ATTR_RO(fw_version);
545
546	/* m06 only */
547	static ssize_t header_errors_show(struct device *dev,
548	struct device_attribute *attr, char *buf)
549	{
550	struct i2c_client *client = to_i2c_client(dev);
551	struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
552
553	return sysfs_emit(buf, fmt: "%d\n", tsdata->header_errors);
554	}
555
556	static DEVICE_ATTR_RO(header_errors);
557
558	/* m06 only */
559	static ssize_t crc_errors_show(struct device *dev,
560	struct device_attribute *attr, char *buf)
561	{
562	struct i2c_client *client = to_i2c_client(dev);
563	struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
564
565	return sysfs_emit(buf, fmt: "%d\n", tsdata->crc_errors);
566	}
567
568	static DEVICE_ATTR_RO(crc_errors);
569
570	static struct attribute *edt_ft5x06_attrs[] = {
571	&edt_ft5x06_attr_gain.dattr.attr,
572	&edt_ft5x06_attr_offset.dattr.attr,
573	&edt_ft5x06_attr_offset_x.dattr.attr,
574	&edt_ft5x06_attr_offset_y.dattr.attr,
575	&edt_ft5x06_attr_threshold.dattr.attr,
576	&edt_ft5x06_attr_report_rate.dattr.attr,
577	&dev_attr_model.attr,
578	&dev_attr_fw_version.attr,
579	&dev_attr_header_errors.attr,
580	&dev_attr_crc_errors.attr,
581	NULL
582	};
583
584	static const struct attribute_group edt_ft5x06_attr_group = {
585	.attrs = edt_ft5x06_attrs,
586	};
587
588	static void edt_ft5x06_restore_reg_parameters(struct edt_ft5x06_ts_data *tsdata)
589	{
590	struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
591	struct regmap *regmap = tsdata->regmap;
592
593	regmap_write(map: regmap, reg: reg_addr->reg_threshold, val: tsdata->threshold);
594	regmap_write(map: regmap, reg: reg_addr->reg_gain, val: tsdata->gain);
595	if (reg_addr->reg_offset != NO_REGISTER)
596	regmap_write(map: regmap, reg: reg_addr->reg_offset, val: tsdata->offset);
597	if (reg_addr->reg_offset_x != NO_REGISTER)
598	regmap_write(map: regmap, reg: reg_addr->reg_offset_x, val: tsdata->offset_x);
599	if (reg_addr->reg_offset_y != NO_REGISTER)
600	regmap_write(map: regmap, reg: reg_addr->reg_offset_y, val: tsdata->offset_y);
601	if (reg_addr->reg_report_rate != NO_REGISTER)
602	regmap_write(map: regmap, reg: reg_addr->reg_report_rate,
603	val: tsdata->report_rate);
604	}
605
606	#ifdef CONFIG_DEBUG_FS
607	static int edt_ft5x06_factory_mode(struct edt_ft5x06_ts_data *tsdata)
608	{
609	struct i2c_client *client = tsdata->client;
610	int retries = EDT_SWITCH_MODE_RETRIES;
611	unsigned int val;
612	int error;
613
614	if (tsdata->version != EDT_M06) {
615	dev_err(&client->dev,
616	"No factory mode support for non-M06 devices\n");
617	return -EINVAL;
618	}
619
620	disable_irq(irq: client->irq);
621
622	if (!tsdata->raw_buffer) {
623	tsdata->raw_bufsize = tsdata->num_x * tsdata->num_y *
624	sizeof(u16);
625	tsdata->raw_buffer = kzalloc(size: tsdata->raw_bufsize, GFP_KERNEL);
626	if (!tsdata->raw_buffer) {
627	error = -ENOMEM;
628	goto err_out;
629	}
630	}
631
632	/* mode register is 0x3c when in the work mode */
633	error = regmap_write(map: tsdata->regmap, WORK_REGISTER_OPMODE, val: 0x03);
634	if (error) {
635	dev_err(&client->dev,
636	"failed to switch to factory mode, error %d\n", error);
637	goto err_out;
638	}
639
640	tsdata->factory_mode = true;
641	do {
642	mdelay(EDT_SWITCH_MODE_DELAY);
643	/* mode register is 0x01 when in factory mode */
644	error = regmap_read(map: tsdata->regmap, FACTORY_REGISTER_OPMODE,
645	val: &val);
646	if (!error && val == 0x03)
647	break;
648	} while (--retries > 0);
649
650	if (retries == 0) {
651	dev_err(&client->dev, "not in factory mode after %dms.\n",
652	EDT_SWITCH_MODE_RETRIES * EDT_SWITCH_MODE_DELAY);
653	error = -EIO;
654	goto err_out;
655	}
656
657	return 0;
658
659	err_out:
660	kfree(objp: tsdata->raw_buffer);
661	tsdata->raw_buffer = NULL;
662	tsdata->factory_mode = false;
663	enable_irq(irq: client->irq);
664
665	return error;
666	}
667
668	static int edt_ft5x06_work_mode(struct edt_ft5x06_ts_data *tsdata)
669	{
670	struct i2c_client *client = tsdata->client;
671	int retries = EDT_SWITCH_MODE_RETRIES;
672	unsigned int val;
673	int error;
674
675	/* mode register is 0x01 when in the factory mode */
676	error = regmap_write(map: tsdata->regmap, FACTORY_REGISTER_OPMODE, val: 0x1);
677	if (error) {
678	dev_err(&client->dev,
679	"failed to switch to work mode, error: %d\n", error);
680	return error;
681	}
682
683	tsdata->factory_mode = false;
684
685	do {
686	mdelay(EDT_SWITCH_MODE_DELAY);
687	/* mode register is 0x01 when in factory mode */
688	error = regmap_read(map: tsdata->regmap, WORK_REGISTER_OPMODE, val: &val);
689	if (!error && val == 0x01)
690	break;
691	} while (--retries > 0);
692
693	if (retries == 0) {
694	dev_err(&client->dev, "not in work mode after %dms.\n",
695	EDT_SWITCH_MODE_RETRIES * EDT_SWITCH_MODE_DELAY);
696	tsdata->factory_mode = true;
697	return -EIO;
698	}
699
700	kfree(objp: tsdata->raw_buffer);
701	tsdata->raw_buffer = NULL;
702
703	edt_ft5x06_restore_reg_parameters(tsdata);
704	enable_irq(irq: client->irq);
705
706	return 0;
707	}
708
709	static int edt_ft5x06_debugfs_mode_get(void *data, u64 *mode)
710	{
711	struct edt_ft5x06_ts_data *tsdata = data;
712
713	*mode = tsdata->factory_mode;
714
715	return 0;
716	};
717
718	static int edt_ft5x06_debugfs_mode_set(void *data, u64 mode)
719	{
720	struct edt_ft5x06_ts_data *tsdata = data;
721	int retval = 0;
722
723	if (mode > 1)
724	return -ERANGE;
725
726	mutex_lock(&tsdata->mutex);
727
728	if (mode != tsdata->factory_mode) {
729	retval = mode ? edt_ft5x06_factory_mode(tsdata) :
730	edt_ft5x06_work_mode(tsdata);
731	}
732
733	mutex_unlock(lock: &tsdata->mutex);
734
735	return retval;
736	};
737
738	DEFINE_SIMPLE_ATTRIBUTE(debugfs_mode_fops, edt_ft5x06_debugfs_mode_get,
739	edt_ft5x06_debugfs_mode_set, "%llu\n");
740
741	static ssize_t edt_ft5x06_debugfs_raw_data_read(struct file *file,
742	char __user *buf, size_t count,
743	loff_t *off)
744	{
745	struct edt_ft5x06_ts_data *tsdata = file->private_data;
746	struct i2c_client *client = tsdata->client;
747	int retries = EDT_RAW_DATA_RETRIES;
748	unsigned int val;
749	int i, error;
750	size_t read = 0;
751	int colbytes;
752	u8 *rdbuf;
753
754	if (*off < 0 || *off >= tsdata->raw_bufsize)
755	return 0;
756
757	mutex_lock(&tsdata->mutex);
758
759	if (!tsdata->factory_mode || !tsdata->raw_buffer) {
760	error = -EIO;
761	goto out;
762	}
763
764	error = regmap_write(map: tsdata->regmap, reg: 0x08, val: 0x01);
765	if (error) {
766	dev_err(&client->dev,
767	"failed to write 0x08 register, error %d\n", error);
768	goto out;
769	}
770
771	do {
772	usleep_range(EDT_RAW_DATA_DELAY, EDT_RAW_DATA_DELAY + 100);
773	error = regmap_read(map: tsdata->regmap, reg: 0x08, val: &val);
774	if (error) {
775	dev_err(&client->dev,
776	"failed to read 0x08 register, error %d\n",
777	error);
778	goto out;
779	}
780
781	if (val == 1)
782	break;
783	} while (--retries > 0);
784
785	if (retries == 0) {
786	dev_err(&client->dev,
787	"timed out waiting for register to settle\n");
788	error = -ETIMEDOUT;
789	goto out;
790	}
791
792	rdbuf = tsdata->raw_buffer;
793	colbytes = tsdata->num_y * sizeof(u16);
794
795	for (i = 0; i < tsdata->num_x; i++) {
796	rdbuf[0] = i; /* column index */
797	error = regmap_bulk_read(map: tsdata->regmap, reg: 0xf5, val: rdbuf, val_count: colbytes);
798	if (error)
799	goto out;
800
801	rdbuf += colbytes;
802	}
803
804	read = min_t(size_t, count, tsdata->raw_bufsize - *off);
805	if (copy_to_user(to: buf, from: tsdata->raw_buffer + *off, n: read)) {
806	error = -EFAULT;
807	goto out;
808	}
809
810	*off += read;
811	out:
812	mutex_unlock(lock: &tsdata->mutex);
813	return error ?: read;
814	};
815
816	static const struct file_operations debugfs_raw_data_fops = {
817	.open = simple_open,
818	.read = edt_ft5x06_debugfs_raw_data_read,
819	};
820
821	static void edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata,
822	const char *debugfs_name)
823	{
824	tsdata->debug_dir = debugfs_create_dir(name: debugfs_name, NULL);
825
826	debugfs_create_u16(name: "num_x", S_IRUSR, parent: tsdata->debug_dir, value: &tsdata->num_x);
827	debugfs_create_u16(name: "num_y", S_IRUSR, parent: tsdata->debug_dir, value: &tsdata->num_y);
828
829	debugfs_create_file(name: "mode", S_IRUSR | S_IWUSR,
830	parent: tsdata->debug_dir, data: tsdata, fops: &debugfs_mode_fops);
831	debugfs_create_file(name: "raw_data", S_IRUSR,
832	parent: tsdata->debug_dir, data: tsdata, fops: &debugfs_raw_data_fops);
833	}
834
835	static void edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata)
836	{
837	debugfs_remove_recursive(dentry: tsdata->debug_dir);
838	kfree(objp: tsdata->raw_buffer);
839	}
840
841	#else
842
843	static int edt_ft5x06_factory_mode(struct edt_ft5x06_ts_data *tsdata)
844	{
845	return -ENOSYS;
846	}
847
848	static void edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata,
849	const char *debugfs_name)
850	{
851	}
852
853	static void edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata)
854	{
855	}
856
857	#endif /* CONFIG_DEBUGFS */
858
859	static int edt_ft5x06_ts_identify(struct i2c_client *client,
860	struct edt_ft5x06_ts_data *tsdata)
861	{
862	u8 rdbuf[EDT_NAME_LEN];
863	char *p;
864	int error;
865	char *model_name = tsdata->name;
866	char *fw_version = tsdata->fw_version;
867
868	/* see what we find if we assume it is a M06 *
869	* if we get less than EDT_NAME_LEN, we don't want
870	* to have garbage in there
871	*/
872	memset(rdbuf, 0, sizeof(rdbuf));
873	error = regmap_bulk_read(map: tsdata->regmap, reg: 0xBB, val: rdbuf, EDT_NAME_LEN - 1);
874	if (error)
875	return error;
876
877	/* Probe content for something consistent.
878	* M06 starts with a response byte, M12 gives the data directly.
879	* M09/Generic does not provide model number information.
880	*/
881	if (!strncasecmp(s1: rdbuf + 1, s2: "EP0", n: 3)) {
882	tsdata->version = EDT_M06;
883
884	/* remove last '$' end marker */
885	rdbuf[EDT_NAME_LEN - 1] = '\0';
886	if (rdbuf[EDT_NAME_LEN - 2] == '$')
887	rdbuf[EDT_NAME_LEN - 2] = '\0';
888
889	/* look for Model/Version separator */
890	p = strchr(rdbuf, '*');
891	if (p)
892	*p++ = '\0';
893	strscpy(p: model_name, q: rdbuf + 1, EDT_NAME_LEN);
894	strscpy(p: fw_version, q: p ? p : "", EDT_NAME_LEN);
895
896	regmap_exit(map: tsdata->regmap);
897	tsdata->regmap = regmap_init_i2c(client,
898	&edt_M06_i2c_regmap_config);
899	if (IS_ERR(ptr: tsdata->regmap)) {
900	dev_err(&client->dev, "regmap allocation failed\n");
901	return PTR_ERR(ptr: tsdata->regmap);
902	}
903	} else if (!strncasecmp(s1: rdbuf, s2: "EP0", n: 3)) {
904	tsdata->version = EDT_M12;
905
906	/* remove last '$' end marker */
907	rdbuf[EDT_NAME_LEN - 2] = '\0';
908	if (rdbuf[EDT_NAME_LEN - 3] == '$')
909	rdbuf[EDT_NAME_LEN - 3] = '\0';
910
911	/* look for Model/Version separator */
912	p = strchr(rdbuf, '*');
913	if (p)
914	*p++ = '\0';
915	strscpy(p: model_name, q: rdbuf, EDT_NAME_LEN);
916	strscpy(p: fw_version, q: p ? p : "", EDT_NAME_LEN);
917	} else {
918	/* If it is not an EDT M06/M12 touchscreen, then the model
919	* detection is a bit hairy. The different ft5x06
920	* firmwares around don't reliably implement the
921	* identification registers. Well, we'll take a shot.
922	*
923	* The main difference between generic focaltec based
924	* touches and EDT M09 is that we know how to retrieve
925	* the max coordinates for the latter.
926	*/
927	tsdata->version = GENERIC_FT;
928
929	error = regmap_bulk_read(map: tsdata->regmap, reg: 0xA6, val: rdbuf, val_count: 2);
930	if (error)
931	return error;
932
933	strscpy(p: fw_version, q: rdbuf, size: 2);
934
935	error = regmap_bulk_read(map: tsdata->regmap, reg: 0xA8, val: rdbuf, val_count: 1);
936	if (error)
937	return error;
938
939	/* This "model identification" is not exact. Unfortunately
940	* not all firmwares for the ft5x06 put useful values in
941	* the identification registers.
942	*/
943	switch (rdbuf[0]) {
944	case 0x11: /* EDT EP0110M09 */
945	case 0x35: /* EDT EP0350M09 */
946	case 0x43: /* EDT EP0430M09 */
947	case 0x50: /* EDT EP0500M09 */
948	case 0x57: /* EDT EP0570M09 */
949	case 0x70: /* EDT EP0700M09 */
950	tsdata->version = EDT_M09;
951	snprintf(buf: model_name, EDT_NAME_LEN, fmt: "EP0%i%i0M09",
952	rdbuf[0] >> 4, rdbuf[0] & 0x0F);
953	break;
954	case 0xa1: /* EDT EP1010ML00 */
955	tsdata->version = EDT_M09;
956	snprintf(buf: model_name, EDT_NAME_LEN, fmt: "EP%i%i0ML00",
957	rdbuf[0] >> 4, rdbuf[0] & 0x0F);
958	break;
959	case 0x5a: /* Solomon Goldentek Display */
960	snprintf(buf: model_name, EDT_NAME_LEN, fmt: "GKTW50SCED1R0");
961	break;
962	case 0x59: /* Evervision Display with FT5xx6 TS */
963	tsdata->version = EV_FT;
964	error = regmap_bulk_read(map: tsdata->regmap, reg: 0x53, val: rdbuf, val_count: 1);
965	if (error)
966	return error;
967	strscpy(p: fw_version, q: rdbuf, size: 1);
968	snprintf(buf: model_name, EDT_NAME_LEN,
969	fmt: "EVERVISION-FT5726NEi");
970	break;
971	default:
972	snprintf(buf: model_name, EDT_NAME_LEN,
973	fmt: "generic ft5x06 (%02x)",
974	rdbuf[0]);
975	break;
976	}
977	}
978
979	return 0;
980	}
981
982	static void edt_ft5x06_ts_get_defaults(struct device *dev,
983	struct edt_ft5x06_ts_data *tsdata)
984	{
985	struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
986	struct regmap *regmap = tsdata->regmap;
987	u32 val;
988	int error;
989
990	error = device_property_read_u32(dev, propname: "threshold", val: &val);
991	if (!error) {
992	regmap_write(map: regmap, reg: reg_addr->reg_threshold, val);
993	tsdata->threshold = val;
994	}
995
996	error = device_property_read_u32(dev, propname: "gain", val: &val);
997	if (!error) {
998	regmap_write(map: regmap, reg: reg_addr->reg_gain, val);
999	tsdata->gain = val;
1000	}
1001
1002	error = device_property_read_u32(dev, propname: "offset", val: &val);
1003	if (!error) {
1004	if (reg_addr->reg_offset != NO_REGISTER)
1005	regmap_write(map: regmap, reg: reg_addr->reg_offset, val);
1006	tsdata->offset = val;
1007	}
1008
1009	error = device_property_read_u32(dev, propname: "offset-x", val: &val);
1010	if (!error) {
1011	if (reg_addr->reg_offset_x != NO_REGISTER)
1012	regmap_write(map: regmap, reg: reg_addr->reg_offset_x, val);
1013	tsdata->offset_x = val;
1014	}
1015
1016	error = device_property_read_u32(dev, propname: "offset-y", val: &val);
1017	if (!error) {
1018	if (reg_addr->reg_offset_y != NO_REGISTER)
1019	regmap_write(map: regmap, reg: reg_addr->reg_offset_y, val);
1020	tsdata->offset_y = val;
1021	}
1022	}
1023
1024	static void edt_ft5x06_ts_get_parameters(struct edt_ft5x06_ts_data *tsdata)
1025	{
1026	struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
1027	struct regmap *regmap = tsdata->regmap;
1028	unsigned int val;
1029
1030	regmap_read(map: regmap, reg: reg_addr->reg_threshold, val: &tsdata->threshold);
1031	regmap_read(map: regmap, reg: reg_addr->reg_gain, val: &tsdata->gain);
1032	if (reg_addr->reg_offset != NO_REGISTER)
1033	regmap_read(map: regmap, reg: reg_addr->reg_offset, val: &tsdata->offset);
1034	if (reg_addr->reg_offset_x != NO_REGISTER)
1035	regmap_read(map: regmap, reg: reg_addr->reg_offset_x, val: &tsdata->offset_x);
1036	if (reg_addr->reg_offset_y != NO_REGISTER)
1037	regmap_read(map: regmap, reg: reg_addr->reg_offset_y, val: &tsdata->offset_y);
1038	if (reg_addr->reg_report_rate != NO_REGISTER)
1039	regmap_read(map: regmap, reg: reg_addr->reg_report_rate,
1040	val: &tsdata->report_rate);
1041	tsdata->num_x = EDT_DEFAULT_NUM_X;
1042	if (reg_addr->reg_num_x != NO_REGISTER) {
1043	if (!regmap_read(map: regmap, reg: reg_addr->reg_num_x, val: &val))
1044	tsdata->num_x = val;
1045	}
1046	tsdata->num_y = EDT_DEFAULT_NUM_Y;
1047	if (reg_addr->reg_num_y != NO_REGISTER) {
1048	if (!regmap_read(map: regmap, reg: reg_addr->reg_num_y, val: &val))
1049	tsdata->num_y = val;
1050	}
1051	}
1052
1053	static void edt_ft5x06_ts_set_tdata_parameters(struct edt_ft5x06_ts_data *tsdata)
1054	{
1055	int crclen;
1056
1057	if (tsdata->version == EDT_M06) {
1058	tsdata->tdata_cmd = 0xf9;
1059	tsdata->tdata_offset = 5;
1060	tsdata->point_len = 4;
1061	crclen = 1;
1062	} else {
1063	tsdata->tdata_cmd = 0x0;
1064	tsdata->tdata_offset = 3;
1065	tsdata->point_len = 6;
1066	crclen = 0;
1067	}
1068
1069	tsdata->tdata_len = tsdata->point_len * tsdata->max_support_points +
1070	tsdata->tdata_offset + crclen;
1071	}
1072
1073	static void edt_ft5x06_ts_set_regs(struct edt_ft5x06_ts_data *tsdata)
1074	{
1075	struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
1076
1077	switch (tsdata->version) {
1078	case EDT_M06:
1079	reg_addr->reg_threshold = WORK_REGISTER_THRESHOLD;
1080	reg_addr->reg_report_rate = WORK_REGISTER_REPORT_RATE;
1081	reg_addr->reg_gain = WORK_REGISTER_GAIN;
1082	reg_addr->reg_offset = WORK_REGISTER_OFFSET;
1083	reg_addr->reg_offset_x = NO_REGISTER;
1084	reg_addr->reg_offset_y = NO_REGISTER;
1085	reg_addr->reg_num_x = WORK_REGISTER_NUM_X;
1086	reg_addr->reg_num_y = WORK_REGISTER_NUM_Y;
1087	break;
1088
1089	case EDT_M09:
1090	case EDT_M12:
1091	reg_addr->reg_threshold = M09_REGISTER_THRESHOLD;
1092	reg_addr->reg_report_rate = tsdata->version == EDT_M12 ?
1093	M12_REGISTER_REPORT_RATE : NO_REGISTER;
1094	reg_addr->reg_gain = M09_REGISTER_GAIN;
1095	reg_addr->reg_offset = M09_REGISTER_OFFSET;
1096	reg_addr->reg_offset_x = NO_REGISTER;
1097	reg_addr->reg_offset_y = NO_REGISTER;
1098	reg_addr->reg_num_x = M09_REGISTER_NUM_X;
1099	reg_addr->reg_num_y = M09_REGISTER_NUM_Y;
1100	break;
1101
1102	case EV_FT:
1103	reg_addr->reg_threshold = EV_REGISTER_THRESHOLD;
1104	reg_addr->reg_report_rate = NO_REGISTER;
1105	reg_addr->reg_gain = EV_REGISTER_GAIN;
1106	reg_addr->reg_offset = NO_REGISTER;
1107	reg_addr->reg_offset_x = EV_REGISTER_OFFSET_X;
1108	reg_addr->reg_offset_y = EV_REGISTER_OFFSET_Y;
1109	reg_addr->reg_num_x = NO_REGISTER;
1110	reg_addr->reg_num_y = NO_REGISTER;
1111	break;
1112
1113	case GENERIC_FT:
1114	/* this is a guesswork */
1115	reg_addr->reg_threshold = M09_REGISTER_THRESHOLD;
1116	reg_addr->reg_report_rate = NO_REGISTER;
1117	reg_addr->reg_gain = M09_REGISTER_GAIN;
1118	reg_addr->reg_offset = M09_REGISTER_OFFSET;
1119	reg_addr->reg_offset_x = NO_REGISTER;
1120	reg_addr->reg_offset_y = NO_REGISTER;
1121	reg_addr->reg_num_x = NO_REGISTER;
1122	reg_addr->reg_num_y = NO_REGISTER;
1123	break;
1124	}
1125	}
1126
1127	static void edt_ft5x06_disable_regulators(void *arg)
1128	{
1129	struct edt_ft5x06_ts_data *data = arg;
1130
1131	regulator_disable(regulator: data->vcc);
1132	regulator_disable(regulator: data->iovcc);
1133	}
1134
1135	static int edt_ft5x06_ts_probe(struct i2c_client *client)
1136	{
1137	const struct i2c_device_id *id = i2c_client_get_device_id(client);
1138	const struct edt_i2c_chip_data *chip_data;
1139	struct edt_ft5x06_ts_data *tsdata;
1140	unsigned int val;
1141	struct input_dev *input;
1142	unsigned long irq_flags;
1143	int error;
1144	u32 report_rate;
1145
1146	dev_dbg(&client->dev, "probing for EDT FT5x06 I2C\n");
1147
1148	tsdata = devm_kzalloc(dev: &client->dev, size: sizeof(*tsdata), GFP_KERNEL);
1149	if (!tsdata) {
1150	dev_err(&client->dev, "failed to allocate driver data.\n");
1151	return -ENOMEM;
1152	}
1153
1154	tsdata->regmap = regmap_init_i2c(client, &edt_ft5x06_i2c_regmap_config);
1155	if (IS_ERR(ptr: tsdata->regmap)) {
1156	dev_err(&client->dev, "regmap allocation failed\n");
1157	return PTR_ERR(ptr: tsdata->regmap);
1158	}
1159
1160	chip_data = device_get_match_data(dev: &client->dev);
1161	if (!chip_data)
1162	chip_data = (const struct edt_i2c_chip_data *)id->driver_data;
1163	if (!chip_data || !chip_data->max_support_points) {
1164	dev_err(&client->dev, "invalid or missing chip data\n");
1165	return -EINVAL;
1166	}
1167
1168	tsdata->max_support_points = chip_data->max_support_points;
1169
1170	tsdata->vcc = devm_regulator_get(dev: &client->dev, id: "vcc");
1171	if (IS_ERR(ptr: tsdata->vcc))
1172	return dev_err_probe(dev: &client->dev, err: PTR_ERR(ptr: tsdata->vcc),
1173	fmt: "failed to request regulator\n");
1174
1175	tsdata->iovcc = devm_regulator_get(dev: &client->dev, id: "iovcc");
1176	if (IS_ERR(ptr: tsdata->iovcc)) {
1177	error = PTR_ERR(ptr: tsdata->iovcc);
1178	if (error != -EPROBE_DEFER)
1179	dev_err(&client->dev,
1180	"failed to request iovcc regulator: %d\n", error);
1181	return error;
1182	}
1183
1184	error = regulator_enable(regulator: tsdata->iovcc);
1185	if (error < 0) {
1186	dev_err(&client->dev, "failed to enable iovcc: %d\n", error);
1187	return error;
1188	}
1189
1190	/* Delay enabling VCC for > 10us (T_ivd) after IOVCC */
1191	usleep_range(min: 10, max: 100);
1192
1193	error = regulator_enable(regulator: tsdata->vcc);
1194	if (error < 0) {
1195	dev_err(&client->dev, "failed to enable vcc: %d\n", error);
1196	regulator_disable(regulator: tsdata->iovcc);
1197	return error;
1198	}
1199
1200	error = devm_add_action_or_reset(&client->dev,
1201	edt_ft5x06_disable_regulators,
1202	tsdata);
1203	if (error)
1204	return error;
1205
1206	tsdata->reset_gpio = devm_gpiod_get_optional(dev: &client->dev,
1207	con_id: "reset", flags: GPIOD_OUT_HIGH);
1208	if (IS_ERR(ptr: tsdata->reset_gpio)) {
1209	error = PTR_ERR(ptr: tsdata->reset_gpio);
1210	dev_err(&client->dev,
1211	"Failed to request GPIO reset pin, error %d\n", error);
1212	return error;
1213	}
1214
1215	tsdata->wake_gpio = devm_gpiod_get_optional(dev: &client->dev,
1216	con_id: "wake", flags: GPIOD_OUT_LOW);
1217	if (IS_ERR(ptr: tsdata->wake_gpio)) {
1218	error = PTR_ERR(ptr: tsdata->wake_gpio);
1219	dev_err(&client->dev,
1220	"Failed to request GPIO wake pin, error %d\n", error);
1221	return error;
1222	}
1223
1224	/*
1225	* Check which sleep modes we can support. Power-off requieres the
1226	* reset-pin to ensure correct power-down/power-up behaviour. Start with
1227	* the EDT_PMODE_POWEROFF test since this is the deepest possible sleep
1228	* mode.
1229	*/
1230	if (tsdata->reset_gpio)
1231	tsdata->suspend_mode = EDT_PMODE_POWEROFF;
1232	else if (tsdata->wake_gpio)
1233	tsdata->suspend_mode = EDT_PMODE_HIBERNATE;
1234	else
1235	tsdata->suspend_mode = EDT_PMODE_NOT_SUPPORTED;
1236
1237	if (tsdata->wake_gpio) {
1238	usleep_range(min: 5000, max: 6000);
1239	gpiod_set_value_cansleep(desc: tsdata->wake_gpio, value: 1);
1240	usleep_range(min: 5000, max: 6000);
1241	}
1242
1243	if (tsdata->reset_gpio) {
1244	usleep_range(min: 5000, max: 6000);
1245	gpiod_set_value_cansleep(desc: tsdata->reset_gpio, value: 0);
1246	msleep(msecs: 300);
1247	}
1248
1249	input = devm_input_allocate_device(&client->dev);
1250	if (!input) {
1251	dev_err(&client->dev, "failed to allocate input device.\n");
1252	return -ENOMEM;
1253	}
1254
1255	mutex_init(&tsdata->mutex);
1256	tsdata->client = client;
1257	tsdata->input = input;
1258	tsdata->factory_mode = false;
1259	i2c_set_clientdata(client, data: tsdata);
1260
1261	error = edt_ft5x06_ts_identify(client, tsdata);
1262	if (error) {
1263	dev_err(&client->dev, "touchscreen probe failed\n");
1264	return error;
1265	}
1266
1267	/*
1268	* Dummy read access. EP0700MLP1 returns bogus data on the first
1269	* register read access and ignores writes.
1270	*/
1271	regmap_read(map: tsdata->regmap, reg: 0x00, val: &val);
1272
1273	edt_ft5x06_ts_set_tdata_parameters(tsdata);
1274	edt_ft5x06_ts_set_regs(tsdata);
1275	edt_ft5x06_ts_get_defaults(dev: &client->dev, tsdata);
1276	edt_ft5x06_ts_get_parameters(tsdata);
1277
1278	if (tsdata->reg_addr.reg_report_rate != NO_REGISTER &&
1279	!device_property_read_u32(dev: &client->dev,
1280	propname: "report-rate-hz", val: &report_rate)) {
1281	if (tsdata->version == EDT_M06)
1282	tsdata->report_rate = clamp_val(report_rate, 30, 140);
1283	else
1284	tsdata->report_rate = clamp_val(report_rate, 1, 255);
1285
1286	if (report_rate != tsdata->report_rate)
1287	dev_warn(&client->dev,
1288	"report-rate %dHz is unsupported, use %dHz\n",
1289	report_rate, tsdata->report_rate);
1290
1291	if (tsdata->version == EDT_M06)
1292	tsdata->report_rate /= 10;
1293
1294	regmap_write(map: tsdata->regmap, reg: tsdata->reg_addr.reg_report_rate,
1295	val: tsdata->report_rate);
1296	}
1297
1298	dev_dbg(&client->dev,
1299	"Model \"%s\", Rev. \"%s\", %dx%d sensors\n",
1300	tsdata->name, tsdata->fw_version, tsdata->num_x, tsdata->num_y);
1301
1302	input->name = tsdata->name;
1303	input->id.bustype = BUS_I2C;
1304	input->dev.parent = &client->dev;
1305
1306	input_set_abs_params(dev: input, ABS_MT_POSITION_X,
1307	min: 0, max: tsdata->num_x * 64 - 1, fuzz: 0, flat: 0);
1308	input_set_abs_params(dev: input, ABS_MT_POSITION_Y,
1309	min: 0, max: tsdata->num_y * 64 - 1, fuzz: 0, flat: 0);
1310
1311	touchscreen_parse_properties(input, multitouch: true, prop: &tsdata->prop);
1312
1313	error = input_mt_init_slots(dev: input, num_slots: tsdata->max_support_points,
1314	INPUT_MT_DIRECT);
1315	if (error) {
1316	dev_err(&client->dev, "Unable to init MT slots.\n");
1317	return error;
1318	}
1319
1320	irq_flags = irq_get_trigger_type(irq: client->irq);
1321	if (irq_flags == IRQF_TRIGGER_NONE)
1322	irq_flags = IRQF_TRIGGER_FALLING;
1323	irq_flags |= IRQF_ONESHOT;
1324
1325	error = devm_request_threaded_irq(dev: &client->dev, irq: client->irq,
1326	NULL, thread_fn: edt_ft5x06_ts_isr, irqflags: irq_flags,
1327	devname: client->name, dev_id: tsdata);
1328	if (error) {
1329	dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
1330	return error;
1331	}
1332
1333	error = devm_device_add_group(dev: &client->dev, grp: &edt_ft5x06_attr_group);
1334	if (error)
1335	return error;
1336
1337	error = input_register_device(input);
1338	if (error)
1339	return error;
1340
1341	edt_ft5x06_ts_prepare_debugfs(tsdata, debugfs_name: dev_driver_string(dev: &client->dev));
1342
1343	dev_dbg(&client->dev,
1344	"EDT FT5x06 initialized: IRQ %d, WAKE pin %d, Reset pin %d.\n",
1345	client->irq,
1346	tsdata->wake_gpio ? desc_to_gpio(tsdata->wake_gpio) : -1,
1347	tsdata->reset_gpio ? desc_to_gpio(tsdata->reset_gpio) : -1);
1348
1349	return 0;
1350	}
1351
1352	static void edt_ft5x06_ts_remove(struct i2c_client *client)
1353	{
1354	struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
1355
1356	edt_ft5x06_ts_teardown_debugfs(tsdata);
1357	regmap_exit(map: tsdata->regmap);
1358	}
1359
1360	static int edt_ft5x06_ts_suspend(struct device *dev)
1361	{
1362	struct i2c_client *client = to_i2c_client(dev);
1363	struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
1364	struct gpio_desc *reset_gpio = tsdata->reset_gpio;
1365	int ret;
1366
1367	if (device_may_wakeup(dev))
1368	return 0;
1369
1370	if (tsdata->suspend_mode == EDT_PMODE_NOT_SUPPORTED)
1371	return 0;
1372
1373	/* Enter hibernate mode. */
1374	ret = regmap_write(map: tsdata->regmap, PMOD_REGISTER_OPMODE,
1375	PMOD_REGISTER_HIBERNATE);
1376	if (ret)
1377	dev_warn(dev, "Failed to set hibernate mode\n");
1378
1379	if (tsdata->suspend_mode == EDT_PMODE_HIBERNATE)
1380	return 0;
1381
1382	/*
1383	* Power-off according the datasheet. Cut the power may leaf the irq
1384	* line in an undefined state depending on the host pull resistor
1385	* settings. Disable the irq to avoid adjusting each host till the
1386	* device is back in a full functional state.
1387	*/
1388	disable_irq(irq: tsdata->client->irq);
1389
1390	gpiod_set_value_cansleep(desc: reset_gpio, value: 1);
1391	usleep_range(min: 1000, max: 2000);
1392
1393	ret = regulator_disable(regulator: tsdata->vcc);
1394	if (ret)
1395	dev_warn(dev, "Failed to disable vcc\n");
1396	ret = regulator_disable(regulator: tsdata->iovcc);
1397	if (ret)
1398	dev_warn(dev, "Failed to disable iovcc\n");
1399
1400	return 0;
1401	}
1402
1403	static int edt_ft5x06_ts_resume(struct device *dev)
1404	{
1405	struct i2c_client *client = to_i2c_client(dev);
1406	struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
1407	int ret = 0;
1408
1409	if (device_may_wakeup(dev))
1410	return 0;
1411
1412	if (tsdata->suspend_mode == EDT_PMODE_NOT_SUPPORTED)
1413	return 0;
1414
1415	if (tsdata->suspend_mode == EDT_PMODE_POWEROFF) {
1416	struct gpio_desc *reset_gpio = tsdata->reset_gpio;
1417
1418	/*
1419	* We can't check if the regulator is a dummy or a real
1420	* regulator. So we need to specify the 5ms reset time (T_rst)
1421	* here instead of the 100us T_rtp time. We also need to wait
1422	* 300ms in case it was a real supply and the power was cutted
1423	* of. Toggle the reset pin is also a way to exit the hibernate
1424	* mode.
1425	*/
1426	gpiod_set_value_cansleep(desc: reset_gpio, value: 1);
1427	usleep_range(min: 5000, max: 6000);
1428
1429	ret = regulator_enable(regulator: tsdata->iovcc);
1430	if (ret) {
1431	dev_err(dev, "Failed to enable iovcc\n");
1432	return ret;
1433	}
1434
1435	/* Delay enabling VCC for > 10us (T_ivd) after IOVCC */
1436	usleep_range(min: 10, max: 100);
1437
1438	ret = regulator_enable(regulator: tsdata->vcc);
1439	if (ret) {
1440	dev_err(dev, "Failed to enable vcc\n");
1441	regulator_disable(regulator: tsdata->iovcc);
1442	return ret;
1443	}
1444
1445	usleep_range(min: 1000, max: 2000);
1446	gpiod_set_value_cansleep(desc: reset_gpio, value: 0);
1447	msleep(msecs: 300);
1448
1449	edt_ft5x06_restore_reg_parameters(tsdata);
1450	enable_irq(irq: tsdata->client->irq);
1451
1452	if (tsdata->factory_mode)
1453	ret = edt_ft5x06_factory_mode(tsdata);
1454	} else {
1455	struct gpio_desc *wake_gpio = tsdata->wake_gpio;
1456
1457	gpiod_set_value_cansleep(desc: wake_gpio, value: 0);
1458	usleep_range(min: 5000, max: 6000);
1459	gpiod_set_value_cansleep(desc: wake_gpio, value: 1);
1460	}
1461
1462	return ret;
1463	}
1464
1465	static DEFINE_SIMPLE_DEV_PM_OPS(edt_ft5x06_ts_pm_ops,
1466	edt_ft5x06_ts_suspend, edt_ft5x06_ts_resume);
1467
1468	static const struct edt_i2c_chip_data edt_ft5x06_data = {
1469	.max_support_points = 5,
1470	};
1471
1472	static const struct edt_i2c_chip_data edt_ft5506_data = {
1473	.max_support_points = 10,
1474	};
1475
1476	static const struct edt_i2c_chip_data edt_ft6236_data = {
1477	.max_support_points = 2,
1478	};
1479
1480	static const struct i2c_device_id edt_ft5x06_ts_id[] = {
1481	{ .name = "edt-ft5x06", .driver_data = (long)&edt_ft5x06_data },
1482	{ .name = "edt-ft5506", .driver_data = (long)&edt_ft5506_data },
1483	{ .name = "ev-ft5726", .driver_data = (long)&edt_ft5506_data },
1484	/* Note no edt- prefix for compatibility with the ft6236.c driver */
1485	{ .name = "ft6236", .driver_data = (long)&edt_ft6236_data },
1486	{ /* sentinel */ }
1487	};
1488	MODULE_DEVICE_TABLE(i2c, edt_ft5x06_ts_id);
1489
1490	static const struct of_device_id edt_ft5x06_of_match[] = {
1491	{ .compatible = "edt,edt-ft5206", .data = &edt_ft5x06_data },
1492	{ .compatible = "edt,edt-ft5306", .data = &edt_ft5x06_data },
1493	{ .compatible = "edt,edt-ft5406", .data = &edt_ft5x06_data },
1494	{ .compatible = "edt,edt-ft5506", .data = &edt_ft5506_data },
1495	{ .compatible = "evervision,ev-ft5726", .data = &edt_ft5506_data },
1496	/* Note focaltech vendor prefix for compatibility with ft6236.c */
1497	{ .compatible = "focaltech,ft6236", .data = &edt_ft6236_data },
1498	{ /* sentinel */ }
1499	};
1500	MODULE_DEVICE_TABLE(of, edt_ft5x06_of_match);
1501
1502	static struct i2c_driver edt_ft5x06_ts_driver = {
1503	.driver = {
1504	.name = "edt_ft5x06",
1505	.of_match_table = edt_ft5x06_of_match,
1506	.pm = pm_sleep_ptr(&edt_ft5x06_ts_pm_ops),
1507	.probe_type = PROBE_PREFER_ASYNCHRONOUS,
1508	},
1509	.id_table = edt_ft5x06_ts_id,
1510	.probe = edt_ft5x06_ts_probe,
1511	.remove = edt_ft5x06_ts_remove,
1512	};
1513
1514	module_i2c_driver(edt_ft5x06_ts_driver);
1515
1516	MODULE_AUTHOR("Simon Budig <simon.budig@kernelconcepts.de>");
1517	MODULE_DESCRIPTION("EDT FT5x06 I2C Touchscreen Driver");
1518	MODULE_LICENSE("GPL v2");
1519