~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2	3	* Driver for Goodix Touchscreens
3	4	*
..	..	@@ -9,11 +10,6 @@
9	10	* 2010 - 2012 Goodix Technology.
10	11	*/
11	12
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	13
18	14	#include <linux/kernel.h>
19	15	#include <linux/dmi.h>
..	..	@@ -27,34 +23,11 @@
27	23	#include <linux/delay.h>
28	24	#include <linux/irq.h>
29	25	#include <linux/interrupt.h>
	26	+#include <linux/regulator/consumer.h>
30	27	#include <linux/slab.h>
31	28	#include <linux/acpi.h>
32	29	#include <linux/of.h>
33	30	#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	31
59	32	#define GOODIX_GPIO_INT_NAME "irq"
60	33	#define GOODIX_GPIO_RST_NAME "reset"
..	..	@@ -63,11 +36,15 @@
63	36	#define GOODIX_MAX_WIDTH 4096
64	37	#define GOODIX_INT_TRIGGER 1
65	38	#define GOODIX_CONTACT_SIZE 8
	39	+#define GOODIX_MAX_CONTACT_SIZE 9
66	40	#define GOODIX_MAX_CONTACTS 10
	41	+#define GOODIX_MAX_KEYS 7
67	42
68		-#define GOODIX_CONFIG_MAX_LENGTH 240
	43	+#define GOODIX_CONFIG_MIN_LENGTH 186
69	44	#define GOODIX_CONFIG_911_LENGTH 186
70	45	#define GOODIX_CONFIG_967_LENGTH 228
	46	+#define GOODIX_CONFIG_GT9X_LENGTH 240
	47	+#define GOODIX_CONFIG_MAX_LENGTH 240
71	48
72	49	/* Register defines */
73	50	#define GOODIX_REG_COMMAND 0x8040
..	..	@@ -79,39 +56,121 @@
79	56	#define GOODIX_REG_ID 0x8140
80	57
81	58	#define GOODIX_BUFFER_STATUS_READY BIT(7)
	59	+#define GOODIX_HAVE_KEY BIT(4)
82	60	#define GOODIX_BUFFER_STATUS_TIMEOUT 20
83	61
84	62	#define RESOLUTION_LOC 1
85	63	#define MAX_CONTACTS_LOC 5
86	64	#define TRIGGER_LOC 6
87	65
	66	+/* Our special handling for GPIO accesses through ACPI is x86 specific */
	67	+#if defined CONFIG_X86 && defined CONFIG_ACPI
	68	+#define ACPI_GPIO_SUPPORT
	69	+#endif
	70	+
	71	+struct goodix_ts_data;
	72	+
	73	+enum goodix_irq_pin_access_method {
	74	+ IRQ_PIN_ACCESS_NONE,
	75	+ IRQ_PIN_ACCESS_GPIO,
	76	+ IRQ_PIN_ACCESS_ACPI_GPIO,
	77	+ IRQ_PIN_ACCESS_ACPI_METHOD,
	78	+};
	79	+
	80	+struct goodix_chip_data {
	81	+ u16 config_addr;
	82	+ int config_len;
	83	+ int (check_config)(struct goodix_ts_data ts, const u8 *cfg, int len);
	84	+ void (calc_config_checksum)(struct goodix_ts_data ts);
	85	+};
	86	+
	87	+struct goodix_chip_id {
	88	+ const char *id;
	89	+ const struct goodix_chip_data *data;
	90	+};
	91	+
	92	+#define GOODIX_ID_MAX_LEN 4
	93	+
	94	+struct goodix_ts_data {
	95	+ struct i2c_client *client;
	96	+ struct input_dev *input_dev;
	97	+ const struct goodix_chip_data *chip;
	98	+ struct touchscreen_properties prop;
	99	+ unsigned int max_touch_num;
	100	+ unsigned int int_trigger_type;
	101	+ struct regulator *avdd28;
	102	+ struct regulator *vddio;
	103	+ struct gpio_desc *gpiod_int;
	104	+ struct gpio_desc *gpiod_rst;
	105	+ int gpio_count;
	106	+ int gpio_int_idx;
	107	+ char id[GOODIX_ID_MAX_LEN + 1];
	108	+ u16 version;
	109	+ const char *cfg_name;
	110	+ bool reset_controller_at_probe;
	111	+ bool load_cfg_from_disk;
	112	+ struct completion firmware_loading_complete;
	113	+ unsigned long irq_flags;
	114	+ enum goodix_irq_pin_access_method irq_pin_access_method;
	115	+ unsigned int contact_size;
	116	+ u8 config[GOODIX_CONFIG_MAX_LENGTH];
	117	+ unsigned short keymap[GOODIX_MAX_KEYS];
	118	+};
	119	+
88	120	static int goodix_check_cfg_8(struct goodix_ts_data *ts,
89		- const struct firmware *cfg);
	121	+ const u8 *cfg, int len);
90	122	static int goodix_check_cfg_16(struct goodix_ts_data *ts,
91		- const struct firmware *cfg);
	123	+ const u8 *cfg, int len);
	124	+static void goodix_calc_cfg_checksum_8(struct goodix_ts_data *ts);
	125	+static void goodix_calc_cfg_checksum_16(struct goodix_ts_data *ts);
92	126
93	127	static const struct goodix_chip_data gt1x_chip_data = {
94	128	.config_addr = GOODIX_GT1X_REG_CONFIG_DATA,
95		- .config_len = GOODIX_CONFIG_MAX_LENGTH,
	129	+ .config_len = GOODIX_CONFIG_GT9X_LENGTH,
96	130	.check_config = goodix_check_cfg_16,
	131	+ .calc_config_checksum = goodix_calc_cfg_checksum_16,
97	132	};
98	133
99	134	static const struct goodix_chip_data gt911_chip_data = {
100	135	.config_addr = GOODIX_GT9X_REG_CONFIG_DATA,
101	136	.config_len = GOODIX_CONFIG_911_LENGTH,
102	137	.check_config = goodix_check_cfg_8,
	138	+ .calc_config_checksum = goodix_calc_cfg_checksum_8,
103	139	};
104	140
105	141	static const struct goodix_chip_data gt967_chip_data = {
106	142	.config_addr = GOODIX_GT9X_REG_CONFIG_DATA,
107	143	.config_len = GOODIX_CONFIG_967_LENGTH,
108	144	.check_config = goodix_check_cfg_8,
	145	+ .calc_config_checksum = goodix_calc_cfg_checksum_8,
109	146	};
110	147
111	148	static const struct goodix_chip_data gt9x_chip_data = {
112	149	.config_addr = GOODIX_GT9X_REG_CONFIG_DATA,
113		- .config_len = GOODIX_CONFIG_MAX_LENGTH,
	150	+ .config_len = GOODIX_CONFIG_GT9X_LENGTH,
114	151	.check_config = goodix_check_cfg_8,
	152	+ .calc_config_checksum = goodix_calc_cfg_checksum_8,
	153	+};
	154	+
	155	+static const struct goodix_chip_id goodix_chip_ids[] = {
	156	+ { .id = "1151", .data = &gt1x_chip_data },
	157	+ { .id = "1158", .data = &gt1x_chip_data },
	158	+ { .id = "5663", .data = &gt1x_chip_data },
	159	+ { .id = "5688", .data = &gt1x_chip_data },
	160	+ { .id = "917S", .data = &gt1x_chip_data },
	161	+ { .id = "9286", .data = &gt1x_chip_data },
	162	+
	163	+ { .id = "911", .data = &gt911_chip_data },
	164	+ { .id = "9271", .data = &gt911_chip_data },
	165	+ { .id = "9110", .data = &gt911_chip_data },
	166	+ { .id = "9111", .data = &gt911_chip_data },
	167	+ { .id = "927", .data = &gt911_chip_data },
	168	+ { .id = "928", .data = &gt911_chip_data },
	169	+
	170	+ { .id = "912", .data = &gt967_chip_data },
	171	+ { .id = "9147", .data = &gt967_chip_data },
	172	+ { .id = "967", .data = &gt967_chip_data },
	173	+ { }
115	174	};
116	175
117	176	static const unsigned long goodix_irq_flags[] = {
..	..	@@ -121,45 +180,29 @@
121	180	IRQ_TYPE_LEVEL_HIGH,
122	181	};
123	182
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[] = {
	183	+static const struct dmi_system_id nine_bytes_report[] = {
129	184	#if defined(CONFIG_DMI) && defined(CONFIG_X86)
130	185	{
131		- .ident = "Teclast X89",
	186	+ .ident = "Lenovo YogaBook",
	187	+ /* YB1-X91L/F and YB1-X90L/F */
132	188	.matches = {
133		- /* tPAD is too generic, also match on bios date */
134		- DMI_MATCH(DMI_BOARD_VENDOR, "TECLAST"),
135		- DMI_MATCH(DMI_BOARD_NAME, "tPAD"),
136		- DMI_MATCH(DMI_BIOS_DATE, "12/19/2014"),
137		- },
138		- },
139		- {
140		- .ident = "Teclast X98 Pro",
141		- .matches = {
142		- /*
143		- * Only match BIOS date, because the manufacturers
144		- * BIOS does not report the board name at all
145		- * (sometimes)...
146		- */
147		- DMI_MATCH(DMI_BOARD_VENDOR, "TECLAST"),
148		- DMI_MATCH(DMI_BIOS_DATE, "10/28/2015"),
149		- },
150		- },
151		- {
152		- .ident = "WinBook TW100",
153		- .matches = {
154		- DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),
155		- DMI_MATCH(DMI_PRODUCT_NAME, "TW100")
	189	+ DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X9")
156	190	}
157	191	},
	192	+#endif
	193	+ {}
	194	+};
	195	+
	196	+/*
	197	+ * Those tablets have their x coordinate inverted
	198	+ */
	199	+static const struct dmi_system_id inverted_x_screen[] = {
	200	+#if defined(CONFIG_DMI) && defined(CONFIG_X86)
158	201	{
159		- .ident = "WinBook TW700",
	202	+ .ident = "Cube I15-TC",
160	203	.matches = {
161		- DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),
162		- DMI_MATCH(DMI_PRODUCT_NAME, "TW700")
	204	+ DMI_MATCH(DMI_SYS_VENDOR, "Cube"),
	205	+ DMI_MATCH(DMI_PRODUCT_NAME, "I15-TC")
163	206	},
164	207	},
165	208	#endif
..	..	@@ -233,26 +276,16 @@
233	276	return goodix_i2c_write(client, reg, &value, sizeof(value));
234	277	}
235	278
236		-static const struct goodix_chip_data *goodix_get_chip_data(u16 id)
	279	+static const struct goodix_chip_data goodix_get_chip_data(const char id)
237	280	{
238		- switch (id) {
239		- case 1151:
240		- return &gt1x_chip_data;
	281	+ unsigned int i;
241	282
242		- case 911:
243		- case 9271:
244		- case 9110:
245		- case 927:
246		- case 928:
247		- return &gt911_chip_data;
248		-
249		- case 912:
250		- case 967:
251		- return &gt967_chip_data;
252		-
253		- default:
254		- return &gt9x_chip_data;
	283	+ for (i = 0; goodix_chip_ids[i].id; i++) {
	284	+ if (!strcmp(goodix_chip_ids[i].id, id))
	285	+ return goodix_chip_ids[i].data;
255	286	}
	287	+
	288	+ return &gt9x_chip_data;
256	289	}
257	290
258	291	static int goodix_ts_read_input_report(struct goodix_ts_data ts, u8 data)
..	..	@@ -260,6 +293,13 @@
260	293	unsigned long max_timeout;
261	294	int touch_num;
262	295	int error;
	296	+ u16 addr = GOODIX_READ_COOR_ADDR;
	297	+ /*
	298	+ * We are going to read 1-byte header,
	299	+ * ts->contact_size * max(1, touch_num) bytes of coordinates
	300	+ * and 1-byte footer which contains the touch-key code.
	301	+ */
	302	+ const int header_contact_keycode_size = 1 + ts->contact_size + 1;
263	303
264	304	/*
265	305	* The 'buffer status' bit, which indicates that the data is valid, is
..	..	@@ -268,8 +308,8 @@
268	308	*/
269	309	max_timeout = jiffies + msecs_to_jiffies(GOODIX_BUFFER_STATUS_TIMEOUT);
270	310	do {
271		- error = goodix_i2c_read(ts->client, GOODIX_READ_COOR_ADDR,
272		- data, GOODIX_CONTACT_SIZE + 1);
	311	+ error = goodix_i2c_read(ts->client, addr, data,
	312	+ header_contact_keycode_size);
273	313	if (error) {
274	314	dev_err(&ts->client->dev, "I2C transfer error: %d\n",
275	315	error);
..	..	@@ -282,12 +322,11 @@
282	322	return -EPROTO;
283	323
284	324	if (touch_num > 1) {
285		- data += 1 + GOODIX_CONTACT_SIZE;
	325	+ addr += header_contact_keycode_size;
	326	+ data += header_contact_keycode_size;
286	327	error = goodix_i2c_read(ts->client,
287		- GOODIX_READ_COOR_ADDR +
288		- 1 + GOODIX_CONTACT_SIZE,
289		- data,
290		- GOODIX_CONTACT_SIZE *
	328	+ addr, data,
	329	+ ts->contact_size *
291	330	(touch_num - 1));
292	331	if (error)
293	332	return error;
..	..	@@ -303,10 +342,10 @@
303	342	* The Goodix panel will send spurious interrupts after a
304	343	* 'finger up' event, which will always cause a timeout.
305	344	*/
306		- return 0;
	345	+ return -ENOMSG;
307	346	}
308	347
309		-static void goodix_ts_report_touch(struct goodix_ts_data ts, u8 coor_data)
	348	+static void goodix_ts_report_touch_8b(struct goodix_ts_data ts, u8 coor_data)
310	349	{
311	350	int id = coor_data[0] & 0x0F;
312	351	int input_x = get_unaligned_le16(&coor_data[1]);
..	..	@@ -321,6 +360,40 @@
321	360	input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
322	361	}
323	362
	363	+static void goodix_ts_report_touch_9b(struct goodix_ts_data ts, u8 coor_data)
	364	+{
	365	+ int id = coor_data[1] & 0x0F;
	366	+ int input_x = get_unaligned_le16(&coor_data[3]);
	367	+ int input_y = get_unaligned_le16(&coor_data[5]);
	368	+ int input_w = get_unaligned_le16(&coor_data[7]);
	369	+
	370	+ input_mt_slot(ts->input_dev, id);
	371	+ input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
	372	+ touchscreen_report_pos(ts->input_dev, &ts->prop,
	373	+ input_x, input_y, true);
	374	+ input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
	375	+ input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
	376	+}
	377	+
	378	+static void goodix_ts_report_key(struct goodix_ts_data ts, u8 data)
	379	+{
	380	+ int touch_num;
	381	+ u8 key_value;
	382	+ int i;
	383	+
	384	+ if (data[0] & GOODIX_HAVE_KEY) {
	385	+ touch_num = data[0] & 0x0f;
	386	+ key_value = data[1 + ts->contact_size * touch_num];
	387	+ for (i = 0; i < GOODIX_MAX_KEYS; i++)
	388	+ if (key_value & BIT(i))
	389	+ input_report_key(ts->input_dev,
	390	+ ts->keymap[i], 1);
	391	+ } else {
	392	+ for (i = 0; i < GOODIX_MAX_KEYS; i++)
	393	+ input_report_key(ts->input_dev, ts->keymap[i], 0);
	394	+ }
	395	+}
	396	+
324	397	/**
325	398	* goodix_process_events - Process incoming events
326	399	*
..	..	@@ -331,7 +404,7 @@
331	404	*/
332	405	static void goodix_process_events(struct goodix_ts_data *ts)
333	406	{
334		- u8 point_data[1 + GOODIX_CONTACT_SIZE * GOODIX_MAX_CONTACTS];
	407	+ u8 point_data[2 + GOODIX_MAX_CONTACT_SIZE * GOODIX_MAX_CONTACTS];
335	408	int touch_num;
336	409	int i;
337	410
..	..	@@ -339,15 +412,15 @@
339	412	if (touch_num < 0)
340	413	return;
341	414
342		- /*
343		- * Bit 4 of the first byte reports the status of the capacitive
344		- * Windows/Home button.
345		- */
346		- input_report_key(ts->input_dev, KEY_LEFTMETA, point_data[0] & BIT(4));
	415	+ goodix_ts_report_key(ts, point_data);
347	416
348	417	for (i = 0; i < touch_num; i++)
349		- goodix_ts_report_touch(ts,
350		- &point_data[1 + GOODIX_CONTACT_SIZE * i]);
	418	+ if (ts->contact_size == 9)
	419	+ goodix_ts_report_touch_9b(ts,
	420	+ &point_data[1 + ts->contact_size * i]);
	421	+ else
	422	+ goodix_ts_report_touch_8b(ts,
	423	+ &point_data[1 + ts->contact_size * i]);
351	424
352	425	input_mt_sync_frame(ts->input_dev);
353	426	input_sync(ts->input_dev);
..	..	@@ -383,22 +456,21 @@
383	456	ts->irq_flags, ts->client->name, ts);
384	457	}
385	458
386		-static int goodix_check_cfg_8(struct goodix_ts_data *ts,
387		- const struct firmware *cfg)
	459	+static int goodix_check_cfg_8(struct goodix_ts_data ts, const u8 cfg, int len)
388	460	{
389		- int i, raw_cfg_len = cfg->size - 2;
	461	+ int i, raw_cfg_len = len - 2;
390	462	u8 check_sum = 0;
391	463
392	464	for (i = 0; i < raw_cfg_len; i++)
393		- check_sum += cfg->data[i];
	465	+ check_sum += cfg[i];
394	466	check_sum = (~check_sum) + 1;
395		- if (check_sum != cfg->data[raw_cfg_len]) {
	467	+ if (check_sum != cfg[raw_cfg_len]) {
396	468	dev_err(&ts->client->dev,
397	469	"The checksum of the config fw is not correct");
398	470	return -EINVAL;
399	471	}
400	472
401		- if (cfg->data[raw_cfg_len + 1] != 1) {
	473	+ if (cfg[raw_cfg_len + 1] != 1) {
402	474	dev_err(&ts->client->dev,
403	475	"Config fw must have Config_Fresh register set");
404	476	return -EINVAL;
..	..	@@ -407,28 +479,54 @@
407	479	return 0;
408	480	}
409	481
410		-static int goodix_check_cfg_16(struct goodix_ts_data *ts,
411		- const struct firmware *cfg)
	482	+static void goodix_calc_cfg_checksum_8(struct goodix_ts_data *ts)
412	483	{
413		- int i, raw_cfg_len = cfg->size - 3;
	484	+ int i, raw_cfg_len = ts->chip->config_len - 2;
	485	+ u8 check_sum = 0;
	486	+
	487	+ for (i = 0; i < raw_cfg_len; i++)
	488	+ check_sum += ts->config[i];
	489	+ check_sum = (~check_sum) + 1;
	490	+
	491	+ ts->config[raw_cfg_len] = check_sum;
	492	+ ts->config[raw_cfg_len + 1] = 1; /* Set "config_fresh" bit */
	493	+}
	494	+
	495	+static int goodix_check_cfg_16(struct goodix_ts_data ts, const u8 cfg,
	496	+ int len)
	497	+{
	498	+ int i, raw_cfg_len = len - 3;
414	499	u16 check_sum = 0;
415	500
416	501	for (i = 0; i < raw_cfg_len; i += 2)
417		- check_sum += get_unaligned_be16(&cfg->data[i]);
	502	+ check_sum += get_unaligned_be16(&cfg[i]);
418	503	check_sum = (~check_sum) + 1;
419		- if (check_sum != get_unaligned_be16(&cfg->data[raw_cfg_len])) {
	504	+ if (check_sum != get_unaligned_be16(&cfg[raw_cfg_len])) {
420	505	dev_err(&ts->client->dev,
421	506	"The checksum of the config fw is not correct");
422	507	return -EINVAL;
423	508	}
424	509
425		- if (cfg->data[raw_cfg_len + 2] != 1) {
	510	+ if (cfg[raw_cfg_len + 2] != 1) {
426	511	dev_err(&ts->client->dev,
427	512	"Config fw must have Config_Fresh register set");
428	513	return -EINVAL;
429	514	}
430	515
431	516	return 0;
	517	+}
	518	+
	519	+static void goodix_calc_cfg_checksum_16(struct goodix_ts_data *ts)
	520	+{
	521	+ int i, raw_cfg_len = ts->chip->config_len - 3;
	522	+ u16 check_sum = 0;
	523	+
	524	+ for (i = 0; i < raw_cfg_len; i += 2)
	525	+ check_sum += get_unaligned_be16(&ts->config[i]);
	526	+ check_sum = (~check_sum) + 1;
	527	+
	528	+ put_unaligned_be16(check_sum, &ts->config[raw_cfg_len]);
	529	+ ts->config[raw_cfg_len + 2] = 1; /* Set "config_fresh" bit */
432	530	}
433	531
434	532	/**
..	..	@@ -437,16 +535,16 @@
437	535	* @ts: goodix_ts_data pointer
438	536	* @cfg: firmware config data
439	537	*/
440		-static int goodix_check_cfg(struct goodix_ts_data *ts,
441		- const struct firmware *cfg)
	538	+static int goodix_check_cfg(struct goodix_ts_data ts, const u8 cfg, int len)
442	539	{
443		- if (cfg->size > GOODIX_CONFIG_MAX_LENGTH) {
	540	+ if (len < GOODIX_CONFIG_MIN_LENGTH \|\|
	541	+ len > GOODIX_CONFIG_MAX_LENGTH) {
444	542	dev_err(&ts->client->dev,
445	543	"The length of the config fw is not correct");
446	544	return -EINVAL;
447	545	}
448	546
449		- return ts->chip->check_config(ts, cfg);
	547	+ return ts->chip->check_config(ts, cfg, len);
450	548	}
451	549
452	550	/**
..	..	@@ -455,17 +553,15 @@
455	553	* @ts: goodix_ts_data pointer
456	554	* @cfg: config firmware to write to device
457	555	*/
458		-static int goodix_send_cfg(struct goodix_ts_data *ts,
459		- const struct firmware *cfg)
	556	+static int goodix_send_cfg(struct goodix_ts_data ts, const u8 cfg, int len)
460	557	{
461	558	int error;
462	559
463		- error = goodix_check_cfg(ts, cfg);
	560	+ error = goodix_check_cfg(ts, cfg, len);
464	561	if (error)
465	562	return error;
466	563
467		- error = goodix_i2c_write(ts->client, ts->chip->config_addr, cfg->data,
468		- cfg->size);
	564	+ error = goodix_i2c_write(ts->client, ts->chip->config_addr, cfg, len);
469	565	if (error) {
470	566	dev_err(&ts->client->dev, "Failed to write config data: %d",
471	567	error);
..	..	@@ -479,17 +575,93 @@
479	575	return 0;
480	576	}
481	577
	578	+#ifdef ACPI_GPIO_SUPPORT
	579	+static int goodix_pin_acpi_direction_input(struct goodix_ts_data *ts)
	580	+{
	581	+ acpi_handle handle = ACPI_HANDLE(&ts->client->dev);
	582	+ acpi_status status;
	583	+
	584	+ status = acpi_evaluate_object(handle, "INTI", NULL, NULL);
	585	+ return ACPI_SUCCESS(status) ? 0 : -EIO;
	586	+}
	587	+
	588	+static int goodix_pin_acpi_output_method(struct goodix_ts_data *ts, int value)
	589	+{
	590	+ acpi_handle handle = ACPI_HANDLE(&ts->client->dev);
	591	+ acpi_status status;
	592	+
	593	+ status = acpi_execute_simple_method(handle, "INTO", value);
	594	+ return ACPI_SUCCESS(status) ? 0 : -EIO;
	595	+}
	596	+#else
	597	+static int goodix_pin_acpi_direction_input(struct goodix_ts_data *ts)
	598	+{
	599	+ dev_err(&ts->client->dev,
	600	+ "%s called on device without ACPI support\n", __func__);
	601	+ return -EINVAL;
	602	+}
	603	+
	604	+static int goodix_pin_acpi_output_method(struct goodix_ts_data *ts, int value)
	605	+{
	606	+ dev_err(&ts->client->dev,
	607	+ "%s called on device without ACPI support\n", __func__);
	608	+ return -EINVAL;
	609	+}
	610	+#endif
	611	+
	612	+static int goodix_irq_direction_output(struct goodix_ts_data *ts, int value)
	613	+{
	614	+ switch (ts->irq_pin_access_method) {
	615	+ case IRQ_PIN_ACCESS_NONE:
	616	+ dev_err(&ts->client->dev,
	617	+ "%s called without an irq_pin_access_method set\n",
	618	+ __func__);
	619	+ return -EINVAL;
	620	+ case IRQ_PIN_ACCESS_GPIO:
	621	+ return gpiod_direction_output(ts->gpiod_int, value);
	622	+ case IRQ_PIN_ACCESS_ACPI_GPIO:
	623	+ /*
	624	+ * The IRQ pin triggers on a falling edge, so its gets marked
	625	+ * as active-low, use output_raw to avoid the value inversion.
	626	+ */
	627	+ return gpiod_direction_output_raw(ts->gpiod_int, value);
	628	+ case IRQ_PIN_ACCESS_ACPI_METHOD:
	629	+ return goodix_pin_acpi_output_method(ts, value);
	630	+ }
	631	+
	632	+ return -EINVAL; /* Never reached */
	633	+}
	634	+
	635	+static int goodix_irq_direction_input(struct goodix_ts_data *ts)
	636	+{
	637	+ switch (ts->irq_pin_access_method) {
	638	+ case IRQ_PIN_ACCESS_NONE:
	639	+ dev_err(&ts->client->dev,
	640	+ "%s called without an irq_pin_access_method set\n",
	641	+ __func__);
	642	+ return -EINVAL;
	643	+ case IRQ_PIN_ACCESS_GPIO:
	644	+ return gpiod_direction_input(ts->gpiod_int);
	645	+ case IRQ_PIN_ACCESS_ACPI_GPIO:
	646	+ return gpiod_direction_input(ts->gpiod_int);
	647	+ case IRQ_PIN_ACCESS_ACPI_METHOD:
	648	+ return goodix_pin_acpi_direction_input(ts);
	649	+ }
	650	+
	651	+ return -EINVAL; /* Never reached */
	652	+}
	653	+
482	654	static int goodix_int_sync(struct goodix_ts_data *ts)
483	655	{
484	656	int error;
485	657
486		- error = gpiod_direction_output(ts->gpiod_int, 0);
	658	+ error = goodix_irq_direction_output(ts, 0);
487	659	if (error)
488	660	return error;
489	661
490	662	msleep(50); /* T5: 50ms */
491	663
492		- error = gpiod_direction_input(ts->gpiod_int);
	664	+ error = goodix_irq_direction_input(ts);
493	665	if (error)
494	666	return error;
495	667
..	..	@@ -513,7 +685,7 @@
513	685	msleep(20); /* T2: > 10ms */
514	686
515	687	/* HIGH: 0x28/0x29, LOW: 0xBA/0xBB */
516		- error = gpiod_direction_output(ts->gpiod_int, ts->client->addr == 0x14);
	688	+ error = goodix_irq_direction_output(ts, ts->client->addr == 0x14);
517	689	if (error)
518	690	return error;
519	691
..	..	@@ -537,6 +709,124 @@
537	709	return 0;
538	710	}
539	711
	712	+#ifdef ACPI_GPIO_SUPPORT
	713	+#include <asm/cpu_device_id.h>
	714	+#include <asm/intel-family.h>
	715	+
	716	+static const struct x86_cpu_id baytrail_cpu_ids[] = {
	717	+ { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_SILVERMONT, X86_FEATURE_ANY, },
	718	+ {}
	719	+};
	720	+
	721	+static inline bool is_byt(void)
	722	+{
	723	+ const struct x86_cpu_id *id = x86_match_cpu(baytrail_cpu_ids);
	724	+
	725	+ return !!id;
	726	+}
	727	+
	728	+static const struct acpi_gpio_params first_gpio = { 0, 0, false };
	729	+static const struct acpi_gpio_params second_gpio = { 1, 0, false };
	730	+
	731	+static const struct acpi_gpio_mapping acpi_goodix_int_first_gpios[] = {
	732	+ { GOODIX_GPIO_INT_NAME "-gpios", &first_gpio, 1 },
	733	+ { GOODIX_GPIO_RST_NAME "-gpios", &second_gpio, 1 },
	734	+ { },
	735	+};
	736	+
	737	+static const struct acpi_gpio_mapping acpi_goodix_int_last_gpios[] = {
	738	+ { GOODIX_GPIO_RST_NAME "-gpios", &first_gpio, 1 },
	739	+ { GOODIX_GPIO_INT_NAME "-gpios", &second_gpio, 1 },
	740	+ { },
	741	+};
	742	+
	743	+static const struct acpi_gpio_mapping acpi_goodix_reset_only_gpios[] = {
	744	+ { GOODIX_GPIO_RST_NAME "-gpios", &first_gpio, 1 },
	745	+ { },
	746	+};
	747	+
	748	+static int goodix_resource(struct acpi_resource ares, void data)
	749	+{
	750	+ struct goodix_ts_data *ts = data;
	751	+ struct device *dev = &ts->client->dev;
	752	+ struct acpi_resource_gpio *gpio;
	753	+
	754	+ switch (ares->type) {
	755	+ case ACPI_RESOURCE_TYPE_GPIO:
	756	+ gpio = &ares->data.gpio;
	757	+ if (gpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT) {
	758	+ if (ts->gpio_int_idx == -1) {
	759	+ ts->gpio_int_idx = ts->gpio_count;
	760	+ } else {
	761	+ dev_err(dev, "More then one GpioInt resource, ignoring ACPI GPIO resources\n");
	762	+ ts->gpio_int_idx = -2;
	763	+ }
	764	+ }
	765	+ ts->gpio_count++;
	766	+ break;
	767	+ default:
	768	+ break;
	769	+ }
	770	+
	771	+ return 0;
	772	+}
	773	+
	774	+/*
	775	+ * This function gets called in case we fail to get the irq GPIO directly
	776	+ * because the ACPI tables lack GPIO-name to APCI _CRS index mappings
	777	+ * (no _DSD UUID daffd814-6eba-4d8c-8a91-bc9bbf4aa301 data).
	778	+ * In that case we add our own mapping and then goodix_get_gpio_config()
	779	+ * retries to get the GPIOs based on the added mapping.
	780	+ */
	781	+static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data *ts)
	782	+{
	783	+ const struct acpi_gpio_mapping *gpio_mapping = NULL;
	784	+ struct device *dev = &ts->client->dev;
	785	+ LIST_HEAD(resources);
	786	+ int ret;
	787	+
	788	+ ts->gpio_count = 0;
	789	+ ts->gpio_int_idx = -1;
	790	+ ret = acpi_dev_get_resources(ACPI_COMPANION(dev), &resources,
	791	+ goodix_resource, ts);
	792	+ if (ret < 0) {
	793	+ dev_err(dev, "Error getting ACPI resources: %d\n", ret);
	794	+ return ret;
	795	+ }
	796	+
	797	+ acpi_dev_free_resource_list(&resources);
	798	+
	799	+ if (ts->gpio_count == 2 && ts->gpio_int_idx == 0) {
	800	+ ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_GPIO;
	801	+ gpio_mapping = acpi_goodix_int_first_gpios;
	802	+ } else if (ts->gpio_count == 2 && ts->gpio_int_idx == 1) {
	803	+ ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_GPIO;
	804	+ gpio_mapping = acpi_goodix_int_last_gpios;
	805	+ } else if (ts->gpio_count == 1 && ts->gpio_int_idx == -1 &&
	806	+ acpi_has_method(ACPI_HANDLE(dev), "INTI") &&
	807	+ acpi_has_method(ACPI_HANDLE(dev), "INTO")) {
	808	+ dev_info(dev, "Using ACPI INTI and INTO methods for IRQ pin access\n");
	809	+ ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_METHOD;
	810	+ gpio_mapping = acpi_goodix_reset_only_gpios;
	811	+ } else if (is_byt() && ts->gpio_count == 2 && ts->gpio_int_idx == -1) {
	812	+ dev_info(dev, "No ACPI GpioInt resource, assuming that the GPIO order is reset, int\n");
	813	+ ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_GPIO;
	814	+ gpio_mapping = acpi_goodix_int_last_gpios;
	815	+ } else {
	816	+ dev_warn(dev, "Unexpected ACPI resources: gpio_count %d, gpio_int_idx %d\n",
	817	+ ts->gpio_count, ts->gpio_int_idx);
	818	+ return -EINVAL;
	819	+ }
	820	+
	821	+ return devm_acpi_dev_add_driver_gpios(dev, gpio_mapping);
	822	+}
	823	+#else
	824	+static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data *ts)
	825	+{
	826	+ return -EINVAL;
	827	+}
	828	+#endif /* CONFIG_X86 && CONFIG_ACPI */
	829	+
540	830	/**
541	831	* goodix_get_gpio_config - Get GPIO config from ACPI/DT
542	832	*
..	..	@@ -547,11 +837,31 @@
547	837	int error;
548	838	struct device *dev;
549	839	struct gpio_desc *gpiod;
	840	+ bool added_acpi_mappings = false;
550	841
551	842	if (!ts->client)
552	843	return -EINVAL;
553	844	dev = &ts->client->dev;
554	845
	846	+ ts->avdd28 = devm_regulator_get(dev, "AVDD28");
	847	+ if (IS_ERR(ts->avdd28)) {
	848	+ error = PTR_ERR(ts->avdd28);
	849	+ if (error != -EPROBE_DEFER)
	850	+ dev_err(dev,
	851	+ "Failed to get AVDD28 regulator: %d\n", error);
	852	+ return error;
	853	+ }
	854	+
	855	+ ts->vddio = devm_regulator_get(dev, "VDDIO");
	856	+ if (IS_ERR(ts->vddio)) {
	857	+ error = PTR_ERR(ts->vddio);
	858	+ if (error != -EPROBE_DEFER)
	859	+ dev_err(dev,
	860	+ "Failed to get VDDIO regulator: %d\n", error);
	861	+ return error;
	862	+ }
	863	+
	864	+retry_get_irq_gpio:
555	865	/* Get the interrupt GPIO pin number */
556	866	gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_INT_NAME, GPIOD_IN);
557	867	if (IS_ERR(gpiod)) {
..	..	@@ -560,6 +870,11 @@
560	870	dev_dbg(dev, "Failed to get %s GPIO: %d\n",
561	871	GOODIX_GPIO_INT_NAME, error);
562	872	return error;
	873	+ }
	874	+ if (!gpiod && has_acpi_companion(dev) && !added_acpi_mappings) {
	875	+ added_acpi_mappings = true;
	876	+ if (goodix_add_acpi_gpio_mappings(ts) == 0)
	877	+ goto retry_get_irq_gpio;
563	878	}
564	879
565	880	ts->gpiod_int = gpiod;
..	..	@@ -576,6 +891,31 @@
576	891
577	892	ts->gpiod_rst = gpiod;
578	893
	894	+ switch (ts->irq_pin_access_method) {
	895	+ case IRQ_PIN_ACCESS_ACPI_GPIO:
	896	+ /*
	897	+ * We end up here if goodix_add_acpi_gpio_mappings() has
	898	+ * called devm_acpi_dev_add_driver_gpios() because the ACPI
	899	+ * tables did not contain name to index mappings.
	900	+ * Check that we successfully got both GPIOs after we've
	901	+ * added our own acpi_gpio_mapping and if we did not get both
	902	+ * GPIOs reset irq_pin_access_method to IRQ_PIN_ACCESS_NONE.
	903	+ */
	904	+ if (!ts->gpiod_int \|\| !ts->gpiod_rst)
	905	+ ts->irq_pin_access_method = IRQ_PIN_ACCESS_NONE;
	906	+ break;
	907	+ case IRQ_PIN_ACCESS_ACPI_METHOD:
	908	+ if (!ts->gpiod_rst)
	909	+ ts->irq_pin_access_method = IRQ_PIN_ACCESS_NONE;
	910	+ break;
	911	+ default:
	912	+ if (ts->gpiod_int && ts->gpiod_rst) {
	913	+ ts->reset_controller_at_probe = true;
	914	+ ts->load_cfg_from_disk = true;
	915	+ ts->irq_pin_access_method = IRQ_PIN_ACCESS_GPIO;
	916	+ }
	917	+ }
	918	+
579	919	return 0;
580	920	}
581	921
..	..	@@ -588,12 +928,11 @@
588	928	*/
589	929	static void goodix_read_config(struct goodix_ts_data *ts)
590	930	{
591		- u8 config[GOODIX_CONFIG_MAX_LENGTH];
592	931	int x_max, y_max;
593	932	int error;
594	933
595	934	error = goodix_i2c_read(ts->client, ts->chip->config_addr,
596		- config, ts->chip->config_len);
	935	+ ts->config, ts->chip->config_len);
597	936	if (error) {
598	937	dev_warn(&ts->client->dev, "Error reading config: %d\n",
599	938	error);
..	..	@@ -602,15 +941,17 @@
602	941	return;
603	942	}
604	943
605		- ts->int_trigger_type = config[TRIGGER_LOC] & 0x03;
606		- ts->max_touch_num = config[MAX_CONTACTS_LOC] & 0x0f;
	944	+ ts->int_trigger_type = ts->config[TRIGGER_LOC] & 0x03;
	945	+ ts->max_touch_num = ts->config[MAX_CONTACTS_LOC] & 0x0f;
607	946
608		- x_max = get_unaligned_le16(&config[RESOLUTION_LOC]);
609		- y_max = get_unaligned_le16(&config[RESOLUTION_LOC + 2]);
	947	+ x_max = get_unaligned_le16(&ts->config[RESOLUTION_LOC]);
	948	+ y_max = get_unaligned_le16(&ts->config[RESOLUTION_LOC + 2]);
610	949	if (x_max && y_max) {
611	950	input_abs_set_max(ts->input_dev, ABS_MT_POSITION_X, x_max - 1);
612	951	input_abs_set_max(ts->input_dev, ABS_MT_POSITION_Y, y_max - 1);
613	952	}
	953	+
	954	+ ts->chip->calc_config_checksum(ts);
614	955	}
615	956
616	957	/**
..	..	@@ -622,7 +963,7 @@
622	963	{
623	964	int error;
624	965	u8 buf[6];
625		- char id_str[5];
	966	+ char id_str[GOODIX_ID_MAX_LEN + 1];
626	967
627	968	error = goodix_i2c_read(ts->client, GOODIX_REG_ID, buf, sizeof(buf));
628	969	if (error) {
..	..	@@ -630,14 +971,13 @@
630	971	return error;
631	972	}
632	973
633		- memcpy(id_str, buf, 4);
634		- id_str[4] = 0;
635		- if (kstrtou16(id_str, 10, &ts->id))
636		- ts->id = 0x1001;
	974	+ memcpy(id_str, buf, GOODIX_ID_MAX_LEN);
	975	+ id_str[GOODIX_ID_MAX_LEN] = 0;
	976	+ strscpy(ts->id, id_str, GOODIX_ID_MAX_LEN + 1);
637	977
638	978	ts->version = get_unaligned_le16(&buf[4]);
639	979
640		- dev_info(&ts->client->dev, "ID %d, version: %04x\n", ts->id,
	980	+ dev_info(&ts->client->dev, "ID %s, version: %04x\n", ts->id,
641	981	ts->version);
642	982
643	983	return 0;
..	..	@@ -681,6 +1021,7 @@
681	1021	static int goodix_configure_dev(struct goodix_ts_data *ts)
682	1022	{
683	1023	int error;
	1024	+ int i;
684	1025
685	1026	ts->int_trigger_type = GOODIX_INT_TRIGGER;
686	1027	ts->max_touch_num = GOODIX_MAX_CONTACTS;
..	..	@@ -695,17 +1036,30 @@
695	1036	ts->input_dev->phys = "input/ts";
696	1037	ts->input_dev->id.bustype = BUS_I2C;
697	1038	ts->input_dev->id.vendor = 0x0416;
698		- ts->input_dev->id.product = ts->id;
	1039	+ if (kstrtou16(ts->id, 10, &ts->input_dev->id.product))
	1040	+ ts->input_dev->id.product = 0x1001;
699	1041	ts->input_dev->id.version = ts->version;
700	1042
	1043	+ ts->input_dev->keycode = ts->keymap;
	1044	+ ts->input_dev->keycodesize = sizeof(ts->keymap[0]);
	1045	+ ts->input_dev->keycodemax = GOODIX_MAX_KEYS;
	1046	+
701	1047	/* Capacitive Windows/Home button on some devices */
702		- input_set_capability(ts->input_dev, EV_KEY, KEY_LEFTMETA);
	1048	+ for (i = 0; i < GOODIX_MAX_KEYS; ++i) {
	1049	+ if (i == 0)
	1050	+ ts->keymap[i] = KEY_LEFTMETA;
	1051	+ else
	1052	+ ts->keymap[i] = KEY_F1 + (i - 1);
	1053	+
	1054	+ input_set_capability(ts->input_dev, EV_KEY, ts->keymap[i]);
	1055	+ }
703	1056
704	1057	input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_X);
705	1058	input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_Y);
706	1059	input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
707	1060	input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
708	1061
	1062	+retry_read_config:
709	1063	/* Read configuration and apply touchscreen parameters */
710	1064	goodix_read_config(ts);
711	1065
..	..	@@ -713,7 +1067,19 @@
713	1067	touchscreen_parse_properties(ts->input_dev, true, &ts->prop);
714	1068
715	1069	if (!ts->prop.max_x \|\| !ts->prop.max_y \|\| !ts->max_touch_num) {
716		- dev_err(&ts->client->dev, "Invalid config, using defaults\n");
	1070	+ if (!ts->reset_controller_at_probe &&
	1071	+ ts->irq_pin_access_method != IRQ_PIN_ACCESS_NONE) {
	1072	+ dev_info(&ts->client->dev, "Config not set, resetting controller\n");
	1073	+ /* Retry after a controller reset */
	1074	+ ts->reset_controller_at_probe = true;
	1075	+ error = goodix_reset(ts);
	1076	+ if (error)
	1077	+ return error;
	1078	+ goto retry_read_config;
	1079	+ }
	1080	+ dev_err(&ts->client->dev,
	1081	+ "Invalid config (%d, %d, %d), using defaults\n",
	1082	+ ts->prop.max_x, ts->prop.max_y, ts->max_touch_num);
717	1083	ts->prop.max_x = GOODIX_MAX_WIDTH - 1;
718	1084	ts->prop.max_y = GOODIX_MAX_HEIGHT - 1;
719	1085	ts->max_touch_num = GOODIX_MAX_CONTACTS;
..	..	@@ -723,11 +1089,17 @@
723	1089	ABS_MT_POSITION_Y, ts->prop.max_y);
724	1090	}
725	1091
726		- if (dmi_check_system(rotated_screen)) {
727		- ts->prop.invert_x = true;
728		- ts->prop.invert_y = true;
	1092	+ if (dmi_check_system(nine_bytes_report)) {
	1093	+ ts->contact_size = 9;
	1094	+
729	1095	dev_dbg(&ts->client->dev,
730		- "Applying '180 degrees rotated screen' quirk\n");
	1096	+ "Non-standard 9-bytes report format quirk\n");
	1097	+ }
	1098	+
	1099	+ if (dmi_check_system(inverted_x_screen)) {
	1100	+ ts->prop.invert_x = true;
	1101	+ dev_dbg(&ts->client->dev,
	1102	+ "Applying 'inverted x screen' quirk\n");
731	1103	}
732	1104
733	1105	error = input_mt_init_slots(ts->input_dev, ts->max_touch_num,
..	..	@@ -770,7 +1142,7 @@
770	1142
771	1143	if (cfg) {
772	1144	/* send device configuration to the firmware */
773		- error = goodix_send_cfg(ts, cfg);
	1145	+ error = goodix_send_cfg(ts, cfg->data, cfg->size);
774	1146	if (error)
775	1147	goto err_release_cfg;
776	1148	}
..	..	@@ -780,6 +1152,14 @@
780	1152	err_release_cfg:
781	1153	release_firmware(cfg);
782	1154	complete_all(&ts->firmware_loading_complete);
	1155	+}
	1156	+
	1157	+static void goodix_disable_regulators(void *arg)
	1158	+{
	1159	+ struct goodix_ts_data *ts = arg;
	1160	+
	1161	+ regulator_disable(ts->vddio);
	1162	+ regulator_disable(ts->avdd28);
783	1163	}
784	1164
785	1165	static int goodix_ts_probe(struct i2c_client *client,
..	..	@@ -802,12 +1182,37 @@
802	1182	ts->client = client;
803	1183	i2c_set_clientdata(client, ts);
804	1184	init_completion(&ts->firmware_loading_complete);
	1185	+ ts->contact_size = GOODIX_CONTACT_SIZE;
805	1186
806	1187	error = goodix_get_gpio_config(ts);
807	1188	if (error)
808	1189	return error;
809	1190
810		- if (ts->gpiod_int && ts->gpiod_rst) {
	1191	+ /* power up the controller */
	1192	+ error = regulator_enable(ts->avdd28);
	1193	+ if (error) {
	1194	+ dev_err(&client->dev,
	1195	+ "Failed to enable AVDD28 regulator: %d\n",
	1196	+ error);
	1197	+ return error;
	1198	+ }
	1199	+
	1200	+ error = regulator_enable(ts->vddio);
	1201	+ if (error) {
	1202	+ dev_err(&client->dev,
	1203	+ "Failed to enable VDDIO regulator: %d\n",
	1204	+ error);
	1205	+ regulator_disable(ts->avdd28);
	1206	+ return error;
	1207	+ }
	1208	+
	1209	+ error = devm_add_action_or_reset(&client->dev,
	1210	+ goodix_disable_regulators, ts);
	1211	+ if (error)
	1212	+ return error;
	1213	+
	1214	+reset:
	1215	+ if (ts->reset_controller_at_probe) {
811	1216	/* reset the controller */
812	1217	error = goodix_reset(ts);
813	1218	if (error) {
..	..	@@ -818,6 +1223,12 @@
818	1223
819	1224	error = goodix_i2c_test(client);
820	1225	if (error) {
	1226	+ if (!ts->reset_controller_at_probe &&
	1227	+ ts->irq_pin_access_method != IRQ_PIN_ACCESS_NONE) {
	1228	+ /* Retry after a controller reset */
	1229	+ ts->reset_controller_at_probe = true;
	1230	+ goto reset;
	1231	+ }
821	1232	dev_err(&client->dev, "I2C communication failure: %d\n", error);
822	1233	return error;
823	1234	}
..	..	@@ -830,10 +1241,10 @@
830	1241
831	1242	ts->chip = goodix_get_chip_data(ts->id);
832	1243
833		- if (ts->gpiod_int && ts->gpiod_rst) {
	1244	+ if (ts->load_cfg_from_disk) {
834	1245	/* update device config */
835	1246	ts->cfg_name = devm_kasprintf(&client->dev, GFP_KERNEL,
836		- "goodix_%d_cfg.bin", ts->id);
	1247	+ "goodix_%s_cfg.bin", ts->id);
837	1248	if (!ts->cfg_name)
838	1249	return -ENOMEM;
839	1250
..	..	@@ -861,7 +1272,7 @@
861	1272	{
862	1273	struct goodix_ts_data *ts = i2c_get_clientdata(client);
863	1274
864		- if (ts->gpiod_int && ts->gpiod_rst)
	1275	+ if (ts->load_cfg_from_disk)
865	1276	wait_for_completion(&ts->firmware_loading_complete);
866	1277
867	1278	return 0;
..	..	@@ -873,19 +1284,20 @@
873	1284	struct goodix_ts_data *ts = i2c_get_clientdata(client);
874	1285	int error;
875	1286
	1287	+ if (ts->load_cfg_from_disk)
	1288	+ wait_for_completion(&ts->firmware_loading_complete);
	1289	+
876	1290	/* We need gpio pins to suspend/resume */
877		- if (!ts->gpiod_int \|\| !ts->gpiod_rst) {
	1291	+ if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_NONE) {
878	1292	disable_irq(client->irq);
879	1293	return 0;
880	1294	}
881		-
882		- wait_for_completion(&ts->firmware_loading_complete);
883	1295
884	1296	/* Free IRQ as IRQ pin is used as output in the suspend sequence */
885	1297	goodix_free_irq(ts);
886	1298
887	1299	/* Output LOW on the INT pin for 5 ms */
888		- error = gpiod_direction_output(ts->gpiod_int, 0);
	1300	+ error = goodix_irq_direction_output(ts, 0);
889	1301	if (error) {
890	1302	goodix_request_irq(ts);
891	1303	return error;
..	..	@@ -897,7 +1309,7 @@
897	1309	GOODIX_CMD_SCREEN_OFF);
898	1310	if (error) {
899	1311	dev_err(&ts->client->dev, "Screen off command failed\n");
900		- gpiod_direction_input(ts->gpiod_int);
	1312	+ goodix_irq_direction_input(ts);
901	1313	goodix_request_irq(ts);
902	1314	return -EAGAIN;
903	1315	}
..	..	@@ -915,9 +1327,10 @@
915	1327	{
916	1328	struct i2c_client *client = to_i2c_client(dev);
917	1329	struct goodix_ts_data *ts = i2c_get_clientdata(client);
	1330	+ u8 config_ver;
918	1331	int error;
919	1332
920		- if (!ts->gpiod_int \|\| !ts->gpiod_rst) {
	1333	+ if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_NONE) {
921	1334	enable_irq(client->irq);
922	1335	return 0;
923	1336	}
..	..	@@ -926,7 +1339,7 @@
926	1339	* Exit sleep mode by outputting HIGH level to INT pin
927	1340	* for 2ms~5ms.
928	1341	*/
929		- error = gpiod_direction_output(ts->gpiod_int, 1);
	1342	+ error = goodix_irq_direction_output(ts, 1);
930	1343	if (error)
931	1344	return error;
932	1345
..	..	@@ -935,6 +1348,27 @@
935	1348	error = goodix_int_sync(ts);
936	1349	if (error)
937	1350	return error;
	1351	+
	1352	+ error = goodix_i2c_read(ts->client, ts->chip->config_addr,
	1353	+ &config_ver, 1);
	1354	+ if (error)
	1355	+ dev_warn(dev, "Error reading config version: %d, resetting controller\n",
	1356	+ error);
	1357	+ else if (config_ver != ts->config[0])
	1358	+ dev_info(dev, "Config version mismatch %d != %d, resetting controller\n",
	1359	+ config_ver, ts->config[0]);
	1360	+
	1361	+ if (error != 0 \|\| config_ver != ts->config[0]) {
	1362	+ error = goodix_reset(ts);
	1363	+ if (error) {
	1364	+ dev_err(dev, "Controller reset failed.\n");
	1365	+ return error;
	1366	+ }
	1367	+
	1368	+ error = goodix_send_cfg(ts, ts->config, ts->chip->config_len);
	1369	+ if (error)
	1370	+ return error;
	1371	+ }
938	1372
939	1373	error = goodix_request_irq(ts);
940	1374	if (error)
..	..	@@ -963,12 +1397,18 @@
963	1397	#ifdef CONFIG_OF
964	1398	static const struct of_device_id goodix_of_match[] = {
965	1399	{ .compatible = "goodix,gt1151" },
	1400	+ { .compatible = "goodix,gt1158" },
	1401	+ { .compatible = "goodix,gt5663" },
	1402	+ { .compatible = "goodix,gt5688" },
966	1403	{ .compatible = "goodix,gt911" },
967	1404	{ .compatible = "goodix,gt9110" },
968	1405	{ .compatible = "goodix,gt912" },
	1406	+ { .compatible = "goodix,gt9147" },
	1407	+ { .compatible = "goodix,gt917s" },
969	1408	{ .compatible = "goodix,gt927" },
970	1409	{ .compatible = "goodix,gt9271" },
971	1410	{ .compatible = "goodix,gt928" },
	1411	+ { .compatible = "goodix,gt9286" },
972	1412	{ .compatible = "goodix,gt967" },
973	1413	{ }
974	1414	};