1 /*
2  *  Driver for Goodix Touchscreens
3  *
4  *  Copyright (c) 2014 Red Hat Inc.
5  *  Copyright (c) 2015 K. Merker <merker@debian.org>
6  *
7  *  This code is based on gt9xx.c authored by andrew@goodix.com:
8  *
9  *  2010 - 2012 Goodix Technology.
10  */
11 
12 /*
13  * This program is free software; you can redistribute it and/or modify it
14  * under the terms of the GNU General Public License as published by the Free
15  * Software Foundation; version 2 of the License.
16  */
17 
18 #include <linux/kernel.h>
19 #include <linux/dmi.h>
20 #include <linux/firmware.h>
21 #include <linux/gpio/consumer.h>
22 #include <linux/i2c.h>
23 #include <linux/input.h>
24 #include <linux/input/mt.h>
25 #include <linux/input/touchscreen.h>
26 #include <linux/module.h>
27 #include <linux/delay.h>
28 #include <linux/irq.h>
29 #include <linux/interrupt.h>
30 #include <linux/slab.h>
31 #include <linux/acpi.h>
32 #include <linux/of.h>
33 #include <asm/unaligned.h>
34 
35 struct goodix_ts_data;
36 
37 struct goodix_chip_data {
38 	u16 config_addr;
39 	int config_len;
40 	int (*check_config)(struct goodix_ts_data *, const struct firmware *);
41 };
42 
43 struct goodix_ts_data {
44 	struct i2c_client *client;
45 	struct input_dev *input_dev;
46 	const struct goodix_chip_data *chip;
47 	struct touchscreen_properties prop;
48 	unsigned int max_touch_num;
49 	unsigned int int_trigger_type;
50 	struct gpio_desc *gpiod_int;
51 	struct gpio_desc *gpiod_rst;
52 	u16 id;
53 	u16 version;
54 	const char *cfg_name;
55 	struct completion firmware_loading_complete;
56 	unsigned long irq_flags;
57 };
58 
59 #define GOODIX_GPIO_INT_NAME		"irq"
60 #define GOODIX_GPIO_RST_NAME		"reset"
61 
62 #define GOODIX_MAX_HEIGHT		4096
63 #define GOODIX_MAX_WIDTH		4096
64 #define GOODIX_INT_TRIGGER		1
65 #define GOODIX_CONTACT_SIZE		8
66 #define GOODIX_MAX_CONTACTS		10
67 
68 #define GOODIX_CONFIG_MAX_LENGTH	240
69 #define GOODIX_CONFIG_911_LENGTH	186
70 #define GOODIX_CONFIG_967_LENGTH	228
71 
72 /* Register defines */
73 #define GOODIX_REG_COMMAND		0x8040
74 #define GOODIX_CMD_SCREEN_OFF		0x05
75 
76 #define GOODIX_READ_COOR_ADDR		0x814E
77 #define GOODIX_GT1X_REG_CONFIG_DATA	0x8050
78 #define GOODIX_GT9X_REG_CONFIG_DATA	0x8047
79 #define GOODIX_REG_ID			0x8140
80 
81 #define GOODIX_BUFFER_STATUS_READY	BIT(7)
82 #define GOODIX_BUFFER_STATUS_TIMEOUT	20
83 
84 #define RESOLUTION_LOC		1
85 #define MAX_CONTACTS_LOC	5
86 #define TRIGGER_LOC		6
87 
88 static int goodix_check_cfg_8(struct goodix_ts_data *ts,
89 			const struct firmware *cfg);
90 static int goodix_check_cfg_16(struct goodix_ts_data *ts,
91 			const struct firmware *cfg);
92 
93 static const struct goodix_chip_data gt1x_chip_data = {
94 	.config_addr		= GOODIX_GT1X_REG_CONFIG_DATA,
95 	.config_len		= GOODIX_CONFIG_MAX_LENGTH,
96 	.check_config		= goodix_check_cfg_16,
97 };
98 
99 static const struct goodix_chip_data gt911_chip_data = {
100 	.config_addr		= GOODIX_GT9X_REG_CONFIG_DATA,
101 	.config_len		= GOODIX_CONFIG_911_LENGTH,
102 	.check_config		= goodix_check_cfg_8,
103 };
104 
105 static const struct goodix_chip_data gt967_chip_data = {
106 	.config_addr		= GOODIX_GT9X_REG_CONFIG_DATA,
107 	.config_len		= GOODIX_CONFIG_967_LENGTH,
108 	.check_config		= goodix_check_cfg_8,
109 };
110 
111 static const struct goodix_chip_data gt9x_chip_data = {
112 	.config_addr		= GOODIX_GT9X_REG_CONFIG_DATA,
113 	.config_len		= GOODIX_CONFIG_MAX_LENGTH,
114 	.check_config		= goodix_check_cfg_8,
115 };
116 
117 static const unsigned long goodix_irq_flags[] = {
118 	IRQ_TYPE_EDGE_RISING,
119 	IRQ_TYPE_EDGE_FALLING,
120 	IRQ_TYPE_LEVEL_LOW,
121 	IRQ_TYPE_LEVEL_HIGH,
122 };
123 
124 /*
125  * Those tablets have their coordinates origin at the bottom right
126  * of the tablet, as if rotated 180 degrees
127  */
128 static const struct dmi_system_id rotated_screen[] = {
129 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
130 	{
131 		.ident = "WinBook TW100",
132 		.matches = {
133 			DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),
134 			DMI_MATCH(DMI_PRODUCT_NAME, "TW100")
135 		}
136 	},
137 	{
138 		.ident = "WinBook TW700",
139 		.matches = {
140 			DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),
141 			DMI_MATCH(DMI_PRODUCT_NAME, "TW700")
142 		},
143 	},
144 #endif
145 	{}
146 };
147 
148 /**
149  * goodix_i2c_read - read data from a register of the i2c slave device.
150  *
151  * @client: i2c device.
152  * @reg: the register to read from.
153  * @buf: raw write data buffer.
154  * @len: length of the buffer to write
155  */
156 static int goodix_i2c_read(struct i2c_client *client,
157 			   u16 reg, u8 *buf, int len)
158 {
159 	struct i2c_msg msgs[2];
160 	__be16 wbuf = cpu_to_be16(reg);
161 	int ret;
162 
163 	msgs[0].flags = 0;
164 	msgs[0].addr  = client->addr;
165 	msgs[0].len   = 2;
166 	msgs[0].buf   = (u8 *)&wbuf;
167 
168 	msgs[1].flags = I2C_M_RD;
169 	msgs[1].addr  = client->addr;
170 	msgs[1].len   = len;
171 	msgs[1].buf   = buf;
172 
173 	ret = i2c_transfer(client->adapter, msgs, 2);
174 	return ret < 0 ? ret : (ret != ARRAY_SIZE(msgs) ? -EIO : 0);
175 }
176 
177 /**
178  * goodix_i2c_write - write data to a register of the i2c slave device.
179  *
180  * @client: i2c device.
181  * @reg: the register to write to.
182  * @buf: raw data buffer to write.
183  * @len: length of the buffer to write
184  */
185 static int goodix_i2c_write(struct i2c_client *client, u16 reg, const u8 *buf,
186 			    unsigned len)
187 {
188 	u8 *addr_buf;
189 	struct i2c_msg msg;
190 	int ret;
191 
192 	addr_buf = kmalloc(len + 2, GFP_KERNEL);
193 	if (!addr_buf)
194 		return -ENOMEM;
195 
196 	addr_buf[0] = reg >> 8;
197 	addr_buf[1] = reg & 0xFF;
198 	memcpy(&addr_buf[2], buf, len);
199 
200 	msg.flags = 0;
201 	msg.addr = client->addr;
202 	msg.buf = addr_buf;
203 	msg.len = len + 2;
204 
205 	ret = i2c_transfer(client->adapter, &msg, 1);
206 	kfree(addr_buf);
207 	return ret < 0 ? ret : (ret != 1 ? -EIO : 0);
208 }
209 
210 static int goodix_i2c_write_u8(struct i2c_client *client, u16 reg, u8 value)
211 {
212 	return goodix_i2c_write(client, reg, &value, sizeof(value));
213 }
214 
215 static const struct goodix_chip_data *goodix_get_chip_data(u16 id)
216 {
217 	switch (id) {
218 	case 1151:
219 		return &gt1x_chip_data;
220 
221 	case 911:
222 	case 9271:
223 	case 9110:
224 	case 927:
225 	case 928:
226 		return &gt911_chip_data;
227 
228 	case 912:
229 	case 967:
230 		return &gt967_chip_data;
231 
232 	default:
233 		return &gt9x_chip_data;
234 	}
235 }
236 
237 static int goodix_ts_read_input_report(struct goodix_ts_data *ts, u8 *data)
238 {
239 	unsigned long max_timeout;
240 	int touch_num;
241 	int error;
242 
243 	/*
244 	 * The 'buffer status' bit, which indicates that the data is valid, is
245 	 * not set as soon as the interrupt is raised, but slightly after.
246 	 * This takes around 10 ms to happen, so we poll for 20 ms.
247 	 */
248 	max_timeout = jiffies + msecs_to_jiffies(GOODIX_BUFFER_STATUS_TIMEOUT);
249 	do {
250 		error = goodix_i2c_read(ts->client, GOODIX_READ_COOR_ADDR,
251 					data, GOODIX_CONTACT_SIZE + 1);
252 		if (error) {
253 			dev_err(&ts->client->dev, "I2C transfer error: %d\n",
254 					error);
255 			return error;
256 		}
257 
258 		if (data[0] & GOODIX_BUFFER_STATUS_READY) {
259 			touch_num = data[0] & 0x0f;
260 			if (touch_num > ts->max_touch_num)
261 				return -EPROTO;
262 
263 			if (touch_num > 1) {
264 				data += 1 + GOODIX_CONTACT_SIZE;
265 				error = goodix_i2c_read(ts->client,
266 						GOODIX_READ_COOR_ADDR +
267 							1 + GOODIX_CONTACT_SIZE,
268 						data,
269 						GOODIX_CONTACT_SIZE *
270 							(touch_num - 1));
271 				if (error)
272 					return error;
273 			}
274 
275 			return touch_num;
276 		}
277 
278 		usleep_range(1000, 2000); /* Poll every 1 - 2 ms */
279 	} while (time_before(jiffies, max_timeout));
280 
281 	/*
282 	 * The Goodix panel will send spurious interrupts after a
283 	 * 'finger up' event, which will always cause a timeout.
284 	 */
285 	return 0;
286 }
287 
288 static void goodix_ts_report_touch(struct goodix_ts_data *ts, u8 *coor_data)
289 {
290 	int id = coor_data[0] & 0x0F;
291 	int input_x = get_unaligned_le16(&coor_data[1]);
292 	int input_y = get_unaligned_le16(&coor_data[3]);
293 	int input_w = get_unaligned_le16(&coor_data[5]);
294 
295 	input_mt_slot(ts->input_dev, id);
296 	input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
297 	touchscreen_report_pos(ts->input_dev, &ts->prop,
298 			       input_x, input_y, true);
299 	input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
300 	input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
301 }
302 
303 /**
304  * goodix_process_events - Process incoming events
305  *
306  * @ts: our goodix_ts_data pointer
307  *
308  * Called when the IRQ is triggered. Read the current device state, and push
309  * the input events to the user space.
310  */
311 static void goodix_process_events(struct goodix_ts_data *ts)
312 {
313 	u8  point_data[1 + GOODIX_CONTACT_SIZE * GOODIX_MAX_CONTACTS];
314 	int touch_num;
315 	int i;
316 
317 	touch_num = goodix_ts_read_input_report(ts, point_data);
318 	if (touch_num < 0)
319 		return;
320 
321 	/*
322 	 * Bit 4 of the first byte reports the status of the capacitive
323 	 * Windows/Home button.
324 	 */
325 	input_report_key(ts->input_dev, KEY_LEFTMETA, point_data[0] & BIT(4));
326 
327 	for (i = 0; i < touch_num; i++)
328 		goodix_ts_report_touch(ts,
329 				&point_data[1 + GOODIX_CONTACT_SIZE * i]);
330 
331 	input_mt_sync_frame(ts->input_dev);
332 	input_sync(ts->input_dev);
333 }
334 
335 /**
336  * goodix_ts_irq_handler - The IRQ handler
337  *
338  * @irq: interrupt number.
339  * @dev_id: private data pointer.
340  */
341 static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id)
342 {
343 	struct goodix_ts_data *ts = dev_id;
344 
345 	goodix_process_events(ts);
346 
347 	if (goodix_i2c_write_u8(ts->client, GOODIX_READ_COOR_ADDR, 0) < 0)
348 		dev_err(&ts->client->dev, "I2C write end_cmd error\n");
349 
350 	return IRQ_HANDLED;
351 }
352 
353 static void goodix_free_irq(struct goodix_ts_data *ts)
354 {
355 	devm_free_irq(&ts->client->dev, ts->client->irq, ts);
356 }
357 
358 static int goodix_request_irq(struct goodix_ts_data *ts)
359 {
360 	return devm_request_threaded_irq(&ts->client->dev, ts->client->irq,
361 					 NULL, goodix_ts_irq_handler,
362 					 ts->irq_flags, ts->client->name, ts);
363 }
364 
365 static int goodix_check_cfg_8(struct goodix_ts_data *ts,
366 			const struct firmware *cfg)
367 {
368 	int i, raw_cfg_len = cfg->size - 2;
369 	u8 check_sum = 0;
370 
371 	for (i = 0; i < raw_cfg_len; i++)
372 		check_sum += cfg->data[i];
373 	check_sum = (~check_sum) + 1;
374 	if (check_sum != cfg->data[raw_cfg_len]) {
375 		dev_err(&ts->client->dev,
376 			"The checksum of the config fw is not correct");
377 		return -EINVAL;
378 	}
379 
380 	if (cfg->data[raw_cfg_len + 1] != 1) {
381 		dev_err(&ts->client->dev,
382 			"Config fw must have Config_Fresh register set");
383 		return -EINVAL;
384 	}
385 
386 	return 0;
387 }
388 
389 static int goodix_check_cfg_16(struct goodix_ts_data *ts,
390 			const struct firmware *cfg)
391 {
392 	int i, raw_cfg_len = cfg->size - 3;
393 	u16 check_sum = 0;
394 
395 	for (i = 0; i < raw_cfg_len; i += 2)
396 		check_sum += get_unaligned_be16(&cfg->data[i]);
397 	check_sum = (~check_sum) + 1;
398 	if (check_sum != get_unaligned_be16(&cfg->data[raw_cfg_len])) {
399 		dev_err(&ts->client->dev,
400 			"The checksum of the config fw is not correct");
401 		return -EINVAL;
402 	}
403 
404 	if (cfg->data[raw_cfg_len + 2] != 1) {
405 		dev_err(&ts->client->dev,
406 			"Config fw must have Config_Fresh register set");
407 		return -EINVAL;
408 	}
409 
410 	return 0;
411 }
412 
413 /**
414  * goodix_check_cfg - Checks if config fw is valid
415  *
416  * @ts: goodix_ts_data pointer
417  * @cfg: firmware config data
418  */
419 static int goodix_check_cfg(struct goodix_ts_data *ts,
420 			    const struct firmware *cfg)
421 {
422 	if (cfg->size > GOODIX_CONFIG_MAX_LENGTH) {
423 		dev_err(&ts->client->dev,
424 			"The length of the config fw is not correct");
425 		return -EINVAL;
426 	}
427 
428 	return ts->chip->check_config(ts, cfg);
429 }
430 
431 /**
432  * goodix_send_cfg - Write fw config to device
433  *
434  * @ts: goodix_ts_data pointer
435  * @cfg: config firmware to write to device
436  */
437 static int goodix_send_cfg(struct goodix_ts_data *ts,
438 			   const struct firmware *cfg)
439 {
440 	int error;
441 
442 	error = goodix_check_cfg(ts, cfg);
443 	if (error)
444 		return error;
445 
446 	error = goodix_i2c_write(ts->client, ts->chip->config_addr, cfg->data,
447 				 cfg->size);
448 	if (error) {
449 		dev_err(&ts->client->dev, "Failed to write config data: %d",
450 			error);
451 		return error;
452 	}
453 	dev_dbg(&ts->client->dev, "Config sent successfully.");
454 
455 	/* Let the firmware reconfigure itself, so sleep for 10ms */
456 	usleep_range(10000, 11000);
457 
458 	return 0;
459 }
460 
461 static int goodix_int_sync(struct goodix_ts_data *ts)
462 {
463 	int error;
464 
465 	error = gpiod_direction_output(ts->gpiod_int, 0);
466 	if (error)
467 		return error;
468 
469 	msleep(50);				/* T5: 50ms */
470 
471 	error = gpiod_direction_input(ts->gpiod_int);
472 	if (error)
473 		return error;
474 
475 	return 0;
476 }
477 
478 /**
479  * goodix_reset - Reset device during power on
480  *
481  * @ts: goodix_ts_data pointer
482  */
483 static int goodix_reset(struct goodix_ts_data *ts)
484 {
485 	int error;
486 
487 	/* begin select I2C slave addr */
488 	error = gpiod_direction_output(ts->gpiod_rst, 0);
489 	if (error)
490 		return error;
491 
492 	msleep(20);				/* T2: > 10ms */
493 
494 	/* HIGH: 0x28/0x29, LOW: 0xBA/0xBB */
495 	error = gpiod_direction_output(ts->gpiod_int, ts->client->addr == 0x14);
496 	if (error)
497 		return error;
498 
499 	usleep_range(100, 2000);		/* T3: > 100us */
500 
501 	error = gpiod_direction_output(ts->gpiod_rst, 1);
502 	if (error)
503 		return error;
504 
505 	usleep_range(6000, 10000);		/* T4: > 5ms */
506 
507 	/* end select I2C slave addr */
508 	error = gpiod_direction_input(ts->gpiod_rst);
509 	if (error)
510 		return error;
511 
512 	error = goodix_int_sync(ts);
513 	if (error)
514 		return error;
515 
516 	return 0;
517 }
518 
519 /**
520  * goodix_get_gpio_config - Get GPIO config from ACPI/DT
521  *
522  * @ts: goodix_ts_data pointer
523  */
524 static int goodix_get_gpio_config(struct goodix_ts_data *ts)
525 {
526 	int error;
527 	struct device *dev;
528 	struct gpio_desc *gpiod;
529 
530 	if (!ts->client)
531 		return -EINVAL;
532 	dev = &ts->client->dev;
533 
534 	/* Get the interrupt GPIO pin number */
535 	gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_INT_NAME, GPIOD_IN);
536 	if (IS_ERR(gpiod)) {
537 		error = PTR_ERR(gpiod);
538 		if (error != -EPROBE_DEFER)
539 			dev_dbg(dev, "Failed to get %s GPIO: %d\n",
540 				GOODIX_GPIO_INT_NAME, error);
541 		return error;
542 	}
543 
544 	ts->gpiod_int = gpiod;
545 
546 	/* Get the reset line GPIO pin number */
547 	gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_RST_NAME, GPIOD_IN);
548 	if (IS_ERR(gpiod)) {
549 		error = PTR_ERR(gpiod);
550 		if (error != -EPROBE_DEFER)
551 			dev_dbg(dev, "Failed to get %s GPIO: %d\n",
552 				GOODIX_GPIO_RST_NAME, error);
553 		return error;
554 	}
555 
556 	ts->gpiod_rst = gpiod;
557 
558 	return 0;
559 }
560 
561 /**
562  * goodix_read_config - Read the embedded configuration of the panel
563  *
564  * @ts: our goodix_ts_data pointer
565  *
566  * Must be called during probe
567  */
568 static void goodix_read_config(struct goodix_ts_data *ts)
569 {
570 	u8 config[GOODIX_CONFIG_MAX_LENGTH];
571 	int x_max, y_max;
572 	int error;
573 
574 	error = goodix_i2c_read(ts->client, ts->chip->config_addr,
575 				config, ts->chip->config_len);
576 	if (error) {
577 		dev_warn(&ts->client->dev, "Error reading config: %d\n",
578 			 error);
579 		ts->int_trigger_type = GOODIX_INT_TRIGGER;
580 		ts->max_touch_num = GOODIX_MAX_CONTACTS;
581 		return;
582 	}
583 
584 	ts->int_trigger_type = config[TRIGGER_LOC] & 0x03;
585 	ts->max_touch_num = config[MAX_CONTACTS_LOC] & 0x0f;
586 
587 	x_max = get_unaligned_le16(&config[RESOLUTION_LOC]);
588 	y_max = get_unaligned_le16(&config[RESOLUTION_LOC + 2]);
589 	if (x_max && y_max) {
590 		input_abs_set_max(ts->input_dev, ABS_MT_POSITION_X, x_max - 1);
591 		input_abs_set_max(ts->input_dev, ABS_MT_POSITION_Y, y_max - 1);
592 	}
593 }
594 
595 /**
596  * goodix_read_version - Read goodix touchscreen version
597  *
598  * @ts: our goodix_ts_data pointer
599  */
600 static int goodix_read_version(struct goodix_ts_data *ts)
601 {
602 	int error;
603 	u8 buf[6];
604 	char id_str[5];
605 
606 	error = goodix_i2c_read(ts->client, GOODIX_REG_ID, buf, sizeof(buf));
607 	if (error) {
608 		dev_err(&ts->client->dev, "read version failed: %d\n", error);
609 		return error;
610 	}
611 
612 	memcpy(id_str, buf, 4);
613 	id_str[4] = 0;
614 	if (kstrtou16(id_str, 10, &ts->id))
615 		ts->id = 0x1001;
616 
617 	ts->version = get_unaligned_le16(&buf[4]);
618 
619 	dev_info(&ts->client->dev, "ID %d, version: %04x\n", ts->id,
620 		 ts->version);
621 
622 	return 0;
623 }
624 
625 /**
626  * goodix_i2c_test - I2C test function to check if the device answers.
627  *
628  * @client: the i2c client
629  */
630 static int goodix_i2c_test(struct i2c_client *client)
631 {
632 	int retry = 0;
633 	int error;
634 	u8 test;
635 
636 	while (retry++ < 2) {
637 		error = goodix_i2c_read(client, GOODIX_REG_ID,
638 					&test, 1);
639 		if (!error)
640 			return 0;
641 
642 		dev_err(&client->dev, "i2c test failed attempt %d: %d\n",
643 			retry, error);
644 		msleep(20);
645 	}
646 
647 	return error;
648 }
649 
650 /**
651  * goodix_configure_dev - Finish device initialization
652  *
653  * @ts: our goodix_ts_data pointer
654  *
655  * Must be called from probe to finish initialization of the device.
656  * Contains the common initialization code for both devices that
657  * declare gpio pins and devices that do not. It is either called
658  * directly from probe or from request_firmware_wait callback.
659  */
660 static int goodix_configure_dev(struct goodix_ts_data *ts)
661 {
662 	int error;
663 
664 	ts->int_trigger_type = GOODIX_INT_TRIGGER;
665 	ts->max_touch_num = GOODIX_MAX_CONTACTS;
666 
667 	ts->input_dev = devm_input_allocate_device(&ts->client->dev);
668 	if (!ts->input_dev) {
669 		dev_err(&ts->client->dev, "Failed to allocate input device.");
670 		return -ENOMEM;
671 	}
672 
673 	ts->input_dev->name = "Goodix Capacitive TouchScreen";
674 	ts->input_dev->phys = "input/ts";
675 	ts->input_dev->id.bustype = BUS_I2C;
676 	ts->input_dev->id.vendor = 0x0416;
677 	ts->input_dev->id.product = ts->id;
678 	ts->input_dev->id.version = ts->version;
679 
680 	/* Capacitive Windows/Home button on some devices */
681 	input_set_capability(ts->input_dev, EV_KEY, KEY_LEFTMETA);
682 
683 	input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_X);
684 	input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_Y);
685 	input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
686 	input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
687 
688 	/* Read configuration and apply touchscreen parameters */
689 	goodix_read_config(ts);
690 
691 	/* Try overriding touchscreen parameters via device properties */
692 	touchscreen_parse_properties(ts->input_dev, true, &ts->prop);
693 
694 	if (!ts->prop.max_x || !ts->prop.max_y || !ts->max_touch_num) {
695 		dev_err(&ts->client->dev, "Invalid config, using defaults\n");
696 		ts->prop.max_x = GOODIX_MAX_WIDTH - 1;
697 		ts->prop.max_y = GOODIX_MAX_HEIGHT - 1;
698 		ts->max_touch_num = GOODIX_MAX_CONTACTS;
699 		input_abs_set_max(ts->input_dev,
700 				  ABS_MT_POSITION_X, ts->prop.max_x);
701 		input_abs_set_max(ts->input_dev,
702 				  ABS_MT_POSITION_Y, ts->prop.max_y);
703 	}
704 
705 	if (dmi_check_system(rotated_screen)) {
706 		ts->prop.invert_x = true;
707 		ts->prop.invert_y = true;
708 		dev_dbg(&ts->client->dev,
709 			"Applying '180 degrees rotated screen' quirk\n");
710 	}
711 
712 	error = input_mt_init_slots(ts->input_dev, ts->max_touch_num,
713 				    INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
714 	if (error) {
715 		dev_err(&ts->client->dev,
716 			"Failed to initialize MT slots: %d", error);
717 		return error;
718 	}
719 
720 	error = input_register_device(ts->input_dev);
721 	if (error) {
722 		dev_err(&ts->client->dev,
723 			"Failed to register input device: %d", error);
724 		return error;
725 	}
726 
727 	ts->irq_flags = goodix_irq_flags[ts->int_trigger_type] | IRQF_ONESHOT;
728 	error = goodix_request_irq(ts);
729 	if (error) {
730 		dev_err(&ts->client->dev, "request IRQ failed: %d\n", error);
731 		return error;
732 	}
733 
734 	return 0;
735 }
736 
737 /**
738  * goodix_config_cb - Callback to finish device init
739  *
740  * @ts: our goodix_ts_data pointer
741  *
742  * request_firmware_wait callback that finishes
743  * initialization of the device.
744  */
745 static void goodix_config_cb(const struct firmware *cfg, void *ctx)
746 {
747 	struct goodix_ts_data *ts = ctx;
748 	int error;
749 
750 	if (cfg) {
751 		/* send device configuration to the firmware */
752 		error = goodix_send_cfg(ts, cfg);
753 		if (error)
754 			goto err_release_cfg;
755 	}
756 
757 	goodix_configure_dev(ts);
758 
759 err_release_cfg:
760 	release_firmware(cfg);
761 	complete_all(&ts->firmware_loading_complete);
762 }
763 
764 static int goodix_ts_probe(struct i2c_client *client,
765 			   const struct i2c_device_id *id)
766 {
767 	struct goodix_ts_data *ts;
768 	int error;
769 
770 	dev_dbg(&client->dev, "I2C Address: 0x%02x\n", client->addr);
771 
772 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
773 		dev_err(&client->dev, "I2C check functionality failed.\n");
774 		return -ENXIO;
775 	}
776 
777 	ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
778 	if (!ts)
779 		return -ENOMEM;
780 
781 	ts->client = client;
782 	i2c_set_clientdata(client, ts);
783 	init_completion(&ts->firmware_loading_complete);
784 
785 	error = goodix_get_gpio_config(ts);
786 	if (error)
787 		return error;
788 
789 	if (ts->gpiod_int && ts->gpiod_rst) {
790 		/* reset the controller */
791 		error = goodix_reset(ts);
792 		if (error) {
793 			dev_err(&client->dev, "Controller reset failed.\n");
794 			return error;
795 		}
796 	}
797 
798 	error = goodix_i2c_test(client);
799 	if (error) {
800 		dev_err(&client->dev, "I2C communication failure: %d\n", error);
801 		return error;
802 	}
803 
804 	error = goodix_read_version(ts);
805 	if (error) {
806 		dev_err(&client->dev, "Read version failed.\n");
807 		return error;
808 	}
809 
810 	ts->chip = goodix_get_chip_data(ts->id);
811 
812 	if (ts->gpiod_int && ts->gpiod_rst) {
813 		/* update device config */
814 		ts->cfg_name = devm_kasprintf(&client->dev, GFP_KERNEL,
815 					      "goodix_%d_cfg.bin", ts->id);
816 		if (!ts->cfg_name)
817 			return -ENOMEM;
818 
819 		error = request_firmware_nowait(THIS_MODULE, true, ts->cfg_name,
820 						&client->dev, GFP_KERNEL, ts,
821 						goodix_config_cb);
822 		if (error) {
823 			dev_err(&client->dev,
824 				"Failed to invoke firmware loader: %d\n",
825 				error);
826 			return error;
827 		}
828 
829 		return 0;
830 	} else {
831 		error = goodix_configure_dev(ts);
832 		if (error)
833 			return error;
834 	}
835 
836 	return 0;
837 }
838 
839 static int goodix_ts_remove(struct i2c_client *client)
840 {
841 	struct goodix_ts_data *ts = i2c_get_clientdata(client);
842 
843 	if (ts->gpiod_int && ts->gpiod_rst)
844 		wait_for_completion(&ts->firmware_loading_complete);
845 
846 	return 0;
847 }
848 
849 static int __maybe_unused goodix_suspend(struct device *dev)
850 {
851 	struct i2c_client *client = to_i2c_client(dev);
852 	struct goodix_ts_data *ts = i2c_get_clientdata(client);
853 	int error;
854 
855 	/* We need gpio pins to suspend/resume */
856 	if (!ts->gpiod_int || !ts->gpiod_rst) {
857 		disable_irq(client->irq);
858 		return 0;
859 	}
860 
861 	wait_for_completion(&ts->firmware_loading_complete);
862 
863 	/* Free IRQ as IRQ pin is used as output in the suspend sequence */
864 	goodix_free_irq(ts);
865 
866 	/* Output LOW on the INT pin for 5 ms */
867 	error = gpiod_direction_output(ts->gpiod_int, 0);
868 	if (error) {
869 		goodix_request_irq(ts);
870 		return error;
871 	}
872 
873 	usleep_range(5000, 6000);
874 
875 	error = goodix_i2c_write_u8(ts->client, GOODIX_REG_COMMAND,
876 				    GOODIX_CMD_SCREEN_OFF);
877 	if (error) {
878 		dev_err(&ts->client->dev, "Screen off command failed\n");
879 		gpiod_direction_input(ts->gpiod_int);
880 		goodix_request_irq(ts);
881 		return -EAGAIN;
882 	}
883 
884 	/*
885 	 * The datasheet specifies that the interval between sending screen-off
886 	 * command and wake-up should be longer than 58 ms. To avoid waking up
887 	 * sooner, delay 58ms here.
888 	 */
889 	msleep(58);
890 	return 0;
891 }
892 
893 static int __maybe_unused goodix_resume(struct device *dev)
894 {
895 	struct i2c_client *client = to_i2c_client(dev);
896 	struct goodix_ts_data *ts = i2c_get_clientdata(client);
897 	int error;
898 
899 	if (!ts->gpiod_int || !ts->gpiod_rst) {
900 		enable_irq(client->irq);
901 		return 0;
902 	}
903 
904 	/*
905 	 * Exit sleep mode by outputting HIGH level to INT pin
906 	 * for 2ms~5ms.
907 	 */
908 	error = gpiod_direction_output(ts->gpiod_int, 1);
909 	if (error)
910 		return error;
911 
912 	usleep_range(2000, 5000);
913 
914 	error = goodix_int_sync(ts);
915 	if (error)
916 		return error;
917 
918 	error = goodix_request_irq(ts);
919 	if (error)
920 		return error;
921 
922 	return 0;
923 }
924 
925 static SIMPLE_DEV_PM_OPS(goodix_pm_ops, goodix_suspend, goodix_resume);
926 
927 static const struct i2c_device_id goodix_ts_id[] = {
928 	{ "GDIX1001:00", 0 },
929 	{ }
930 };
931 MODULE_DEVICE_TABLE(i2c, goodix_ts_id);
932 
933 #ifdef CONFIG_ACPI
934 static const struct acpi_device_id goodix_acpi_match[] = {
935 	{ "GDIX1001", 0 },
936 	{ }
937 };
938 MODULE_DEVICE_TABLE(acpi, goodix_acpi_match);
939 #endif
940 
941 #ifdef CONFIG_OF
942 static const struct of_device_id goodix_of_match[] = {
943 	{ .compatible = "goodix,gt1151" },
944 	{ .compatible = "goodix,gt911" },
945 	{ .compatible = "goodix,gt9110" },
946 	{ .compatible = "goodix,gt912" },
947 	{ .compatible = "goodix,gt927" },
948 	{ .compatible = "goodix,gt9271" },
949 	{ .compatible = "goodix,gt928" },
950 	{ .compatible = "goodix,gt967" },
951 	{ }
952 };
953 MODULE_DEVICE_TABLE(of, goodix_of_match);
954 #endif
955 
956 static struct i2c_driver goodix_ts_driver = {
957 	.probe = goodix_ts_probe,
958 	.remove = goodix_ts_remove,
959 	.id_table = goodix_ts_id,
960 	.driver = {
961 		.name = "Goodix-TS",
962 		.acpi_match_table = ACPI_PTR(goodix_acpi_match),
963 		.of_match_table = of_match_ptr(goodix_of_match),
964 		.pm = &goodix_pm_ops,
965 	},
966 };
967 module_i2c_driver(goodix_ts_driver);
968 
969 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
970 MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
971 MODULE_DESCRIPTION("Goodix touchscreen driver");
972 MODULE_LICENSE("GPL v2");
973