1 // SPDX-License-Identifier: GPL-2.0-only
3 * Driver for Goodix Touchscreens
5 * Copyright (c) 2014 Red Hat Inc.
6 * Copyright (c) 2015 K. Merker <merker@debian.org>
8 * This code is based on gt9xx.c authored by andrew@goodix.com:
10 * 2010 - 2012 Goodix Technology.
14 #include <linux/kernel.h>
15 #include <linux/dmi.h>
16 #include <linux/firmware.h>
17 #include <linux/module.h>
18 #include <linux/delay.h>
19 #include <linux/irq.h>
20 #include <linux/interrupt.h>
21 #include <linux/platform_data/x86/soc.h>
22 #include <linux/slab.h>
23 #include <linux/acpi.h>
25 #include <asm/unaligned.h>
28 #define GOODIX_GPIO_INT_NAME "irq"
29 #define GOODIX_GPIO_RST_NAME "reset"
31 #define GOODIX_MAX_HEIGHT 4096
32 #define GOODIX_MAX_WIDTH 4096
33 #define GOODIX_INT_TRIGGER 1
34 #define GOODIX_CONTACT_SIZE 8
35 #define GOODIX_MAX_CONTACT_SIZE 9
36 #define GOODIX_MAX_CONTACTS 10
38 #define GOODIX_CONFIG_MIN_LENGTH 186
39 #define GOODIX_CONFIG_911_LENGTH 186
40 #define GOODIX_CONFIG_967_LENGTH 228
41 #define GOODIX_CONFIG_GT9X_LENGTH 240
43 #define GOODIX_BUFFER_STATUS_READY BIT(7)
44 #define GOODIX_HAVE_KEY BIT(4)
45 #define GOODIX_BUFFER_STATUS_TIMEOUT 20
47 #define RESOLUTION_LOC 1
48 #define MAX_CONTACTS_LOC 5
51 /* Our special handling for GPIO accesses through ACPI is x86 specific */
52 #if defined CONFIG_X86 && defined CONFIG_ACPI
53 #define ACPI_GPIO_SUPPORT
56 struct goodix_chip_id
{
58 const struct goodix_chip_data
*data
;
61 static int goodix_check_cfg_8(struct goodix_ts_data
*ts
,
62 const u8
*cfg
, int len
);
63 static int goodix_check_cfg_16(struct goodix_ts_data
*ts
,
64 const u8
*cfg
, int len
);
65 static void goodix_calc_cfg_checksum_8(struct goodix_ts_data
*ts
);
66 static void goodix_calc_cfg_checksum_16(struct goodix_ts_data
*ts
);
68 static const struct goodix_chip_data gt1x_chip_data
= {
69 .config_addr
= GOODIX_GT1X_REG_CONFIG_DATA
,
70 .config_len
= GOODIX_CONFIG_GT9X_LENGTH
,
71 .check_config
= goodix_check_cfg_16
,
72 .calc_config_checksum
= goodix_calc_cfg_checksum_16
,
75 static const struct goodix_chip_data gt911_chip_data
= {
76 .config_addr
= GOODIX_GT9X_REG_CONFIG_DATA
,
77 .config_len
= GOODIX_CONFIG_911_LENGTH
,
78 .check_config
= goodix_check_cfg_8
,
79 .calc_config_checksum
= goodix_calc_cfg_checksum_8
,
82 static const struct goodix_chip_data gt967_chip_data
= {
83 .config_addr
= GOODIX_GT9X_REG_CONFIG_DATA
,
84 .config_len
= GOODIX_CONFIG_967_LENGTH
,
85 .check_config
= goodix_check_cfg_8
,
86 .calc_config_checksum
= goodix_calc_cfg_checksum_8
,
89 static const struct goodix_chip_data gt9x_chip_data
= {
90 .config_addr
= GOODIX_GT9X_REG_CONFIG_DATA
,
91 .config_len
= GOODIX_CONFIG_GT9X_LENGTH
,
92 .check_config
= goodix_check_cfg_8
,
93 .calc_config_checksum
= goodix_calc_cfg_checksum_8
,
96 static const struct goodix_chip_id goodix_chip_ids
[] = {
97 { .id
= "1151", .data
= >1x_chip_data
},
98 { .id
= "1158", .data
= >1x_chip_data
},
99 { .id
= "5663", .data
= >1x_chip_data
},
100 { .id
= "5688", .data
= >1x_chip_data
},
101 { .id
= "917S", .data
= >1x_chip_data
},
102 { .id
= "9286", .data
= >1x_chip_data
},
104 { .id
= "911", .data
= >911_chip_data
},
105 { .id
= "9271", .data
= >911_chip_data
},
106 { .id
= "9110", .data
= >911_chip_data
},
107 { .id
= "9111", .data
= >911_chip_data
},
108 { .id
= "927", .data
= >911_chip_data
},
109 { .id
= "928", .data
= >911_chip_data
},
111 { .id
= "912", .data
= >967_chip_data
},
112 { .id
= "9147", .data
= >967_chip_data
},
113 { .id
= "967", .data
= >967_chip_data
},
117 static const unsigned long goodix_irq_flags
[] = {
118 IRQ_TYPE_EDGE_RISING
,
119 IRQ_TYPE_EDGE_FALLING
,
124 static const struct dmi_system_id nine_bytes_report
[] = {
125 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
127 /* Lenovo Yoga Book X90F / X90L */
129 DMI_EXACT_MATCH(DMI_SYS_VENDOR
, "Intel Corporation"),
130 DMI_EXACT_MATCH(DMI_PRODUCT_NAME
, "CHERRYVIEW D1 PLATFORM"),
131 DMI_EXACT_MATCH(DMI_PRODUCT_VERSION
, "YETI-11"),
135 /* Lenovo Yoga Book X91F / X91L */
137 /* Non exact match to match F + L versions */
138 DMI_MATCH(DMI_PRODUCT_NAME
, "Lenovo YB1-X91"),
146 * Those tablets have their x coordinate inverted
148 static const struct dmi_system_id inverted_x_screen
[] = {
149 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
151 .ident
= "Cube I15-TC",
153 DMI_MATCH(DMI_SYS_VENDOR
, "Cube"),
154 DMI_MATCH(DMI_PRODUCT_NAME
, "I15-TC")
162 * goodix_i2c_read - read data from a register of the i2c slave device.
164 * @client: i2c device.
165 * @reg: the register to read from.
166 * @buf: raw write data buffer.
167 * @len: length of the buffer to write
169 int goodix_i2c_read(struct i2c_client
*client
, u16 reg
, u8
*buf
, int len
)
171 struct i2c_msg msgs
[2];
172 __be16 wbuf
= cpu_to_be16(reg
);
176 msgs
[0].addr
= client
->addr
;
178 msgs
[0].buf
= (u8
*)&wbuf
;
180 msgs
[1].flags
= I2C_M_RD
;
181 msgs
[1].addr
= client
->addr
;
185 ret
= i2c_transfer(client
->adapter
, msgs
, 2);
187 ret
= (ret
== ARRAY_SIZE(msgs
) ? 0 : -EIO
);
190 dev_err(&client
->dev
, "Error reading %d bytes from 0x%04x: %d\n",
196 * goodix_i2c_write - write data to a register of the i2c slave device.
198 * @client: i2c device.
199 * @reg: the register to write to.
200 * @buf: raw data buffer to write.
201 * @len: length of the buffer to write
203 int goodix_i2c_write(struct i2c_client
*client
, u16 reg
, const u8
*buf
, int len
)
209 addr_buf
= kmalloc(len
+ 2, GFP_KERNEL
);
213 addr_buf
[0] = reg
>> 8;
214 addr_buf
[1] = reg
& 0xFF;
215 memcpy(&addr_buf
[2], buf
, len
);
218 msg
.addr
= client
->addr
;
222 ret
= i2c_transfer(client
->adapter
, &msg
, 1);
224 ret
= (ret
== 1 ? 0 : -EIO
);
229 dev_err(&client
->dev
, "Error writing %d bytes to 0x%04x: %d\n",
234 int goodix_i2c_write_u8(struct i2c_client
*client
, u16 reg
, u8 value
)
236 return goodix_i2c_write(client
, reg
, &value
, sizeof(value
));
239 static const struct goodix_chip_data
*goodix_get_chip_data(const char *id
)
243 for (i
= 0; goodix_chip_ids
[i
].id
; i
++) {
244 if (!strcmp(goodix_chip_ids
[i
].id
, id
))
245 return goodix_chip_ids
[i
].data
;
248 return >9x_chip_data
;
251 static int goodix_ts_read_input_report(struct goodix_ts_data
*ts
, u8
*data
)
253 unsigned long max_timeout
;
256 u16 addr
= GOODIX_READ_COOR_ADDR
;
258 * We are going to read 1-byte header,
259 * ts->contact_size * max(1, touch_num) bytes of coordinates
260 * and 1-byte footer which contains the touch-key code.
262 const int header_contact_keycode_size
= 1 + ts
->contact_size
+ 1;
265 * The 'buffer status' bit, which indicates that the data is valid, is
266 * not set as soon as the interrupt is raised, but slightly after.
267 * This takes around 10 ms to happen, so we poll for 20 ms.
269 max_timeout
= jiffies
+ msecs_to_jiffies(GOODIX_BUFFER_STATUS_TIMEOUT
);
271 error
= goodix_i2c_read(ts
->client
, addr
, data
,
272 header_contact_keycode_size
);
276 if (data
[0] & GOODIX_BUFFER_STATUS_READY
) {
277 touch_num
= data
[0] & 0x0f;
278 if (touch_num
> ts
->max_touch_num
)
282 addr
+= header_contact_keycode_size
;
283 data
+= header_contact_keycode_size
;
284 error
= goodix_i2c_read(ts
->client
,
295 if (data
[0] == 0 && ts
->firmware_name
) {
296 if (goodix_handle_fw_request(ts
))
300 usleep_range(1000, 2000); /* Poll every 1 - 2 ms */
301 } while (time_before(jiffies
, max_timeout
));
304 * The Goodix panel will send spurious interrupts after a
305 * 'finger up' event, which will always cause a timeout.
310 static int goodix_create_pen_input(struct goodix_ts_data
*ts
)
312 struct device
*dev
= &ts
->client
->dev
;
313 struct input_dev
*input
;
315 input
= devm_input_allocate_device(dev
);
319 input_copy_abs(input
, ABS_X
, ts
->input_dev
, ABS_MT_POSITION_X
);
320 input_copy_abs(input
, ABS_Y
, ts
->input_dev
, ABS_MT_POSITION_Y
);
322 * The resolution of these touchscreens is about 10 units/mm, the actual
323 * resolution does not matter much since we set INPUT_PROP_DIRECT.
324 * Userspace wants something here though, so just set it to 10 units/mm.
326 input_abs_set_res(input
, ABS_X
, 10);
327 input_abs_set_res(input
, ABS_Y
, 10);
328 input_set_abs_params(input
, ABS_PRESSURE
, 0, 255, 0, 0);
330 input_set_capability(input
, EV_KEY
, BTN_TOUCH
);
331 input_set_capability(input
, EV_KEY
, BTN_TOOL_PEN
);
332 input_set_capability(input
, EV_KEY
, BTN_STYLUS
);
333 input_set_capability(input
, EV_KEY
, BTN_STYLUS2
);
334 __set_bit(INPUT_PROP_DIRECT
, input
->propbit
);
336 input
->name
= "Goodix Active Pen";
337 input
->phys
= "input/pen";
338 input
->id
.bustype
= BUS_I2C
;
339 input
->id
.vendor
= 0x0416;
340 if (kstrtou16(ts
->id
, 10, &input
->id
.product
))
341 input
->id
.product
= 0x1001;
342 input
->id
.version
= ts
->version
;
344 ts
->input_pen
= input
;
348 static void goodix_ts_report_pen_down(struct goodix_ts_data
*ts
, u8
*data
)
350 int input_x
, input_y
, input_w
, error
;
353 if (!ts
->pen_input_registered
) {
354 error
= input_register_device(ts
->input_pen
);
355 ts
->pen_input_registered
= (error
== 0) ? 1 : error
;
358 if (ts
->pen_input_registered
< 0)
361 if (ts
->contact_size
== 9) {
362 input_x
= get_unaligned_le16(&data
[4]);
363 input_y
= get_unaligned_le16(&data
[6]);
364 input_w
= get_unaligned_le16(&data
[8]);
366 input_x
= get_unaligned_le16(&data
[2]);
367 input_y
= get_unaligned_le16(&data
[4]);
368 input_w
= get_unaligned_le16(&data
[6]);
371 touchscreen_report_pos(ts
->input_pen
, &ts
->prop
, input_x
, input_y
, false);
372 input_report_abs(ts
->input_pen
, ABS_PRESSURE
, input_w
);
374 input_report_key(ts
->input_pen
, BTN_TOUCH
, 1);
375 input_report_key(ts
->input_pen
, BTN_TOOL_PEN
, 1);
377 if (data
[0] & GOODIX_HAVE_KEY
) {
378 key_value
= data
[1 + ts
->contact_size
];
379 input_report_key(ts
->input_pen
, BTN_STYLUS
, key_value
& 0x10);
380 input_report_key(ts
->input_pen
, BTN_STYLUS2
, key_value
& 0x20);
382 input_report_key(ts
->input_pen
, BTN_STYLUS
, 0);
383 input_report_key(ts
->input_pen
, BTN_STYLUS2
, 0);
386 input_sync(ts
->input_pen
);
389 static void goodix_ts_report_pen_up(struct goodix_ts_data
*ts
)
394 input_report_key(ts
->input_pen
, BTN_TOUCH
, 0);
395 input_report_key(ts
->input_pen
, BTN_TOOL_PEN
, 0);
396 input_report_key(ts
->input_pen
, BTN_STYLUS
, 0);
397 input_report_key(ts
->input_pen
, BTN_STYLUS2
, 0);
399 input_sync(ts
->input_pen
);
402 static void goodix_ts_report_touch_8b(struct goodix_ts_data
*ts
, u8
*coor_data
)
404 int id
= coor_data
[0] & 0x0F;
405 int input_x
= get_unaligned_le16(&coor_data
[1]);
406 int input_y
= get_unaligned_le16(&coor_data
[3]);
407 int input_w
= get_unaligned_le16(&coor_data
[5]);
409 input_mt_slot(ts
->input_dev
, id
);
410 input_mt_report_slot_state(ts
->input_dev
, MT_TOOL_FINGER
, true);
411 touchscreen_report_pos(ts
->input_dev
, &ts
->prop
,
412 input_x
, input_y
, true);
413 input_report_abs(ts
->input_dev
, ABS_MT_TOUCH_MAJOR
, input_w
);
414 input_report_abs(ts
->input_dev
, ABS_MT_WIDTH_MAJOR
, input_w
);
417 static void goodix_ts_report_touch_9b(struct goodix_ts_data
*ts
, u8
*coor_data
)
419 int id
= coor_data
[1] & 0x0F;
420 int input_x
= get_unaligned_le16(&coor_data
[3]);
421 int input_y
= get_unaligned_le16(&coor_data
[5]);
422 int input_w
= get_unaligned_le16(&coor_data
[7]);
424 input_mt_slot(ts
->input_dev
, id
);
425 input_mt_report_slot_state(ts
->input_dev
, MT_TOOL_FINGER
, true);
426 touchscreen_report_pos(ts
->input_dev
, &ts
->prop
,
427 input_x
, input_y
, true);
428 input_report_abs(ts
->input_dev
, ABS_MT_TOUCH_MAJOR
, input_w
);
429 input_report_abs(ts
->input_dev
, ABS_MT_WIDTH_MAJOR
, input_w
);
432 static void goodix_ts_release_keys(struct goodix_ts_data
*ts
)
436 for (i
= 0; i
< GOODIX_MAX_KEYS
; i
++)
437 input_report_key(ts
->input_dev
, ts
->keymap
[i
], 0);
440 static void goodix_ts_report_key(struct goodix_ts_data
*ts
, u8
*data
)
446 if (data
[0] & GOODIX_HAVE_KEY
) {
447 touch_num
= data
[0] & 0x0f;
448 key_value
= data
[1 + ts
->contact_size
* touch_num
];
449 for (i
= 0; i
< GOODIX_MAX_KEYS
; i
++)
450 if (key_value
& BIT(i
))
451 input_report_key(ts
->input_dev
,
454 goodix_ts_release_keys(ts
);
459 * goodix_process_events - Process incoming events
461 * @ts: our goodix_ts_data pointer
463 * Called when the IRQ is triggered. Read the current device state, and push
464 * the input events to the user space.
466 static void goodix_process_events(struct goodix_ts_data
*ts
)
468 u8 point_data
[2 + GOODIX_MAX_CONTACT_SIZE
* GOODIX_MAX_CONTACTS
];
472 touch_num
= goodix_ts_read_input_report(ts
, point_data
);
476 /* The pen being down is always reported as a single touch */
477 if (touch_num
== 1 && (point_data
[1] & 0x80)) {
478 goodix_ts_report_pen_down(ts
, point_data
);
479 goodix_ts_release_keys(ts
);
480 goto sync
; /* Release any previously registered touches */
482 goodix_ts_report_pen_up(ts
);
485 goodix_ts_report_key(ts
, point_data
);
487 for (i
= 0; i
< touch_num
; i
++)
488 if (ts
->contact_size
== 9)
489 goodix_ts_report_touch_9b(ts
,
490 &point_data
[1 + ts
->contact_size
* i
]);
492 goodix_ts_report_touch_8b(ts
,
493 &point_data
[1 + ts
->contact_size
* i
]);
496 input_mt_sync_frame(ts
->input_dev
);
497 input_sync(ts
->input_dev
);
501 * goodix_ts_irq_handler - The IRQ handler
503 * @irq: interrupt number.
504 * @dev_id: private data pointer.
506 static irqreturn_t
goodix_ts_irq_handler(int irq
, void *dev_id
)
508 struct goodix_ts_data
*ts
= dev_id
;
510 goodix_process_events(ts
);
511 goodix_i2c_write_u8(ts
->client
, GOODIX_READ_COOR_ADDR
, 0);
516 static void goodix_free_irq(struct goodix_ts_data
*ts
)
518 devm_free_irq(&ts
->client
->dev
, ts
->client
->irq
, ts
);
521 static int goodix_request_irq(struct goodix_ts_data
*ts
)
523 return devm_request_threaded_irq(&ts
->client
->dev
, ts
->client
->irq
,
524 NULL
, goodix_ts_irq_handler
,
525 ts
->irq_flags
, ts
->client
->name
, ts
);
528 static int goodix_check_cfg_8(struct goodix_ts_data
*ts
, const u8
*cfg
, int len
)
530 int i
, raw_cfg_len
= len
- 2;
533 for (i
= 0; i
< raw_cfg_len
; i
++)
535 check_sum
= (~check_sum
) + 1;
536 if (check_sum
!= cfg
[raw_cfg_len
]) {
537 dev_err(&ts
->client
->dev
,
538 "The checksum of the config fw is not correct");
542 if (cfg
[raw_cfg_len
+ 1] != 1) {
543 dev_err(&ts
->client
->dev
,
544 "Config fw must have Config_Fresh register set");
551 static void goodix_calc_cfg_checksum_8(struct goodix_ts_data
*ts
)
553 int i
, raw_cfg_len
= ts
->chip
->config_len
- 2;
556 for (i
= 0; i
< raw_cfg_len
; i
++)
557 check_sum
+= ts
->config
[i
];
558 check_sum
= (~check_sum
) + 1;
560 ts
->config
[raw_cfg_len
] = check_sum
;
561 ts
->config
[raw_cfg_len
+ 1] = 1; /* Set "config_fresh" bit */
564 static int goodix_check_cfg_16(struct goodix_ts_data
*ts
, const u8
*cfg
,
567 int i
, raw_cfg_len
= len
- 3;
570 for (i
= 0; i
< raw_cfg_len
; i
+= 2)
571 check_sum
+= get_unaligned_be16(&cfg
[i
]);
572 check_sum
= (~check_sum
) + 1;
573 if (check_sum
!= get_unaligned_be16(&cfg
[raw_cfg_len
])) {
574 dev_err(&ts
->client
->dev
,
575 "The checksum of the config fw is not correct");
579 if (cfg
[raw_cfg_len
+ 2] != 1) {
580 dev_err(&ts
->client
->dev
,
581 "Config fw must have Config_Fresh register set");
588 static void goodix_calc_cfg_checksum_16(struct goodix_ts_data
*ts
)
590 int i
, raw_cfg_len
= ts
->chip
->config_len
- 3;
593 for (i
= 0; i
< raw_cfg_len
; i
+= 2)
594 check_sum
+= get_unaligned_be16(&ts
->config
[i
]);
595 check_sum
= (~check_sum
) + 1;
597 put_unaligned_be16(check_sum
, &ts
->config
[raw_cfg_len
]);
598 ts
->config
[raw_cfg_len
+ 2] = 1; /* Set "config_fresh" bit */
602 * goodix_check_cfg - Checks if config fw is valid
604 * @ts: goodix_ts_data pointer
605 * @cfg: firmware config data
606 * @len: config data length
608 static int goodix_check_cfg(struct goodix_ts_data
*ts
, const u8
*cfg
, int len
)
610 if (len
< GOODIX_CONFIG_MIN_LENGTH
||
611 len
> GOODIX_CONFIG_MAX_LENGTH
) {
612 dev_err(&ts
->client
->dev
,
613 "The length of the config fw is not correct");
617 return ts
->chip
->check_config(ts
, cfg
, len
);
621 * goodix_send_cfg - Write fw config to device
623 * @ts: goodix_ts_data pointer
624 * @cfg: config firmware to write to device
625 * @len: config data length
627 int goodix_send_cfg(struct goodix_ts_data
*ts
, const u8
*cfg
, int len
)
631 error
= goodix_check_cfg(ts
, cfg
, len
);
635 error
= goodix_i2c_write(ts
->client
, ts
->chip
->config_addr
, cfg
, len
);
639 dev_dbg(&ts
->client
->dev
, "Config sent successfully.");
641 /* Let the firmware reconfigure itself, so sleep for 10ms */
642 usleep_range(10000, 11000);
647 #ifdef ACPI_GPIO_SUPPORT
648 static int goodix_pin_acpi_direction_input(struct goodix_ts_data
*ts
)
650 acpi_handle handle
= ACPI_HANDLE(&ts
->client
->dev
);
653 status
= acpi_evaluate_object(handle
, "INTI", NULL
, NULL
);
654 return ACPI_SUCCESS(status
) ? 0 : -EIO
;
657 static int goodix_pin_acpi_output_method(struct goodix_ts_data
*ts
, int value
)
659 acpi_handle handle
= ACPI_HANDLE(&ts
->client
->dev
);
662 status
= acpi_execute_simple_method(handle
, "INTO", value
);
663 return ACPI_SUCCESS(status
) ? 0 : -EIO
;
666 static int goodix_pin_acpi_direction_input(struct goodix_ts_data
*ts
)
668 dev_err(&ts
->client
->dev
,
669 "%s called on device without ACPI support\n", __func__
);
673 static int goodix_pin_acpi_output_method(struct goodix_ts_data
*ts
, int value
)
675 dev_err(&ts
->client
->dev
,
676 "%s called on device without ACPI support\n", __func__
);
681 static int goodix_irq_direction_output(struct goodix_ts_data
*ts
, int value
)
683 switch (ts
->irq_pin_access_method
) {
684 case IRQ_PIN_ACCESS_NONE
:
685 dev_err(&ts
->client
->dev
,
686 "%s called without an irq_pin_access_method set\n",
689 case IRQ_PIN_ACCESS_GPIO
:
690 return gpiod_direction_output(ts
->gpiod_int
, value
);
691 case IRQ_PIN_ACCESS_ACPI_GPIO
:
693 * The IRQ pin triggers on a falling edge, so its gets marked
694 * as active-low, use output_raw to avoid the value inversion.
696 return gpiod_direction_output_raw(ts
->gpiod_int
, value
);
697 case IRQ_PIN_ACCESS_ACPI_METHOD
:
698 return goodix_pin_acpi_output_method(ts
, value
);
701 return -EINVAL
; /* Never reached */
704 static int goodix_irq_direction_input(struct goodix_ts_data
*ts
)
706 switch (ts
->irq_pin_access_method
) {
707 case IRQ_PIN_ACCESS_NONE
:
708 dev_err(&ts
->client
->dev
,
709 "%s called without an irq_pin_access_method set\n",
712 case IRQ_PIN_ACCESS_GPIO
:
713 return gpiod_direction_input(ts
->gpiod_int
);
714 case IRQ_PIN_ACCESS_ACPI_GPIO
:
715 return gpiod_direction_input(ts
->gpiod_int
);
716 case IRQ_PIN_ACCESS_ACPI_METHOD
:
717 return goodix_pin_acpi_direction_input(ts
);
720 return -EINVAL
; /* Never reached */
723 int goodix_int_sync(struct goodix_ts_data
*ts
)
727 error
= goodix_irq_direction_output(ts
, 0);
731 msleep(50); /* T5: 50ms */
733 error
= goodix_irq_direction_input(ts
);
740 dev_err(&ts
->client
->dev
, "Controller irq sync failed.\n");
745 * goodix_reset_no_int_sync - Reset device, leaving interrupt line in output mode
747 * @ts: goodix_ts_data pointer
749 int goodix_reset_no_int_sync(struct goodix_ts_data
*ts
)
753 /* begin select I2C slave addr */
754 error
= gpiod_direction_output(ts
->gpiod_rst
, 0);
758 msleep(20); /* T2: > 10ms */
760 /* HIGH: 0x28/0x29, LOW: 0xBA/0xBB */
761 error
= goodix_irq_direction_output(ts
, ts
->client
->addr
== 0x14);
765 usleep_range(100, 2000); /* T3: > 100us */
767 error
= gpiod_direction_output(ts
->gpiod_rst
, 1);
771 usleep_range(6000, 10000); /* T4: > 5ms */
774 * Put the reset pin back in to input / high-impedance mode to save
775 * power. Only do this in the non ACPI case since some ACPI boards
776 * don't have a pull-up, so there the reset pin must stay active-high.
778 if (ts
->irq_pin_access_method
== IRQ_PIN_ACCESS_GPIO
) {
779 error
= gpiod_direction_input(ts
->gpiod_rst
);
787 dev_err(&ts
->client
->dev
, "Controller reset failed.\n");
792 * goodix_reset - Reset device during power on
794 * @ts: goodix_ts_data pointer
796 static int goodix_reset(struct goodix_ts_data
*ts
)
800 error
= goodix_reset_no_int_sync(ts
);
804 return goodix_int_sync(ts
);
807 #ifdef ACPI_GPIO_SUPPORT
808 static const struct acpi_gpio_params first_gpio
= { 0, 0, false };
809 static const struct acpi_gpio_params second_gpio
= { 1, 0, false };
811 static const struct acpi_gpio_mapping acpi_goodix_int_first_gpios
[] = {
812 { GOODIX_GPIO_INT_NAME
"-gpios", &first_gpio
, 1 },
813 { GOODIX_GPIO_RST_NAME
"-gpios", &second_gpio
, 1 },
817 static const struct acpi_gpio_mapping acpi_goodix_int_last_gpios
[] = {
818 { GOODIX_GPIO_RST_NAME
"-gpios", &first_gpio
, 1 },
819 { GOODIX_GPIO_INT_NAME
"-gpios", &second_gpio
, 1 },
823 static const struct acpi_gpio_mapping acpi_goodix_reset_only_gpios
[] = {
824 { GOODIX_GPIO_RST_NAME
"-gpios", &first_gpio
, 1 },
828 static int goodix_resource(struct acpi_resource
*ares
, void *data
)
830 struct goodix_ts_data
*ts
= data
;
831 struct device
*dev
= &ts
->client
->dev
;
832 struct acpi_resource_gpio
*gpio
;
834 if (acpi_gpio_get_irq_resource(ares
, &gpio
)) {
835 if (ts
->gpio_int_idx
== -1) {
836 ts
->gpio_int_idx
= ts
->gpio_count
;
838 dev_err(dev
, "More then one GpioInt resource, ignoring ACPI GPIO resources\n");
839 ts
->gpio_int_idx
= -2;
842 } else if (acpi_gpio_get_io_resource(ares
, &gpio
))
849 * This function gets called in case we fail to get the irq GPIO directly
850 * because the ACPI tables lack GPIO-name to APCI _CRS index mappings
851 * (no _DSD UUID daffd814-6eba-4d8c-8a91-bc9bbf4aa301 data).
852 * In that case we add our own mapping and then goodix_get_gpio_config()
853 * retries to get the GPIOs based on the added mapping.
855 static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data
*ts
)
857 const struct acpi_gpio_mapping
*gpio_mapping
= NULL
;
858 struct device
*dev
= &ts
->client
->dev
;
859 LIST_HEAD(resources
);
863 ts
->gpio_int_idx
= -1;
864 ret
= acpi_dev_get_resources(ACPI_COMPANION(dev
), &resources
,
865 goodix_resource
, ts
);
867 dev_err(dev
, "Error getting ACPI resources: %d\n", ret
);
871 acpi_dev_free_resource_list(&resources
);
874 * CHT devices should have a GpioInt + a regular GPIO ACPI resource.
875 * Some CHT devices have a bug (where the also is bogus Interrupt
876 * resource copied from a previous BYT based generation). i2c-core-acpi
877 * will use the non-working Interrupt resource, fix this up.
879 if (soc_intel_is_cht() && ts
->gpio_count
== 2 && ts
->gpio_int_idx
!= -1) {
880 irq
= acpi_dev_gpio_irq_get(ACPI_COMPANION(dev
), 0);
881 if (irq
> 0 && irq
!= ts
->client
->irq
) {
882 dev_warn(dev
, "Overriding IRQ %d -> %d\n", ts
->client
->irq
, irq
);
883 ts
->client
->irq
= irq
;
887 if (ts
->gpio_count
== 2 && ts
->gpio_int_idx
== 0) {
888 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_ACPI_GPIO
;
889 gpio_mapping
= acpi_goodix_int_first_gpios
;
890 } else if (ts
->gpio_count
== 2 && ts
->gpio_int_idx
== 1) {
891 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_ACPI_GPIO
;
892 gpio_mapping
= acpi_goodix_int_last_gpios
;
893 } else if (ts
->gpio_count
== 1 && ts
->gpio_int_idx
== -1 &&
894 acpi_has_method(ACPI_HANDLE(dev
), "INTI") &&
895 acpi_has_method(ACPI_HANDLE(dev
), "INTO")) {
896 dev_info(dev
, "Using ACPI INTI and INTO methods for IRQ pin access\n");
897 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_ACPI_METHOD
;
898 gpio_mapping
= acpi_goodix_reset_only_gpios
;
899 } else if (soc_intel_is_byt() && ts
->gpio_count
== 2 && ts
->gpio_int_idx
== -1) {
900 dev_info(dev
, "No ACPI GpioInt resource, assuming that the GPIO order is reset, int\n");
901 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_ACPI_GPIO
;
902 gpio_mapping
= acpi_goodix_int_last_gpios
;
903 } else if (ts
->gpio_count
== 1 && ts
->gpio_int_idx
== 0) {
905 * On newer devices there is only 1 GpioInt resource and _PS0
906 * does the whole reset sequence for us.
908 acpi_device_fix_up_power(ACPI_COMPANION(dev
));
911 * Before the _PS0 call the int GPIO may have been in output
912 * mode and the call should have put the int GPIO in input mode,
913 * but the GPIO subsys cached state may still think it is
914 * in output mode, causing gpiochip_lock_as_irq() failure.
916 * Add a mapping for the int GPIO to make the
917 * gpiod_int = gpiod_get(..., GPIOD_IN) call succeed,
918 * which will explicitly set the direction to input.
920 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_NONE
;
921 gpio_mapping
= acpi_goodix_int_first_gpios
;
923 dev_warn(dev
, "Unexpected ACPI resources: gpio_count %d, gpio_int_idx %d\n",
924 ts
->gpio_count
, ts
->gpio_int_idx
);
926 * On some devices _PS0 does a reset for us and
927 * sometimes this is necessary for things to work.
929 acpi_device_fix_up_power(ACPI_COMPANION(dev
));
934 * Normally we put the reset pin in input / high-impedance mode to save
935 * power. But some x86/ACPI boards don't have a pull-up, so for the ACPI
936 * case, leave the pin as is. This results in the pin not being touched
937 * at all on x86/ACPI boards, except when needed for error-recover.
939 ts
->gpiod_rst_flags
= GPIOD_ASIS
;
941 return devm_acpi_dev_add_driver_gpios(dev
, gpio_mapping
);
944 static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data
*ts
)
948 #endif /* CONFIG_X86 && CONFIG_ACPI */
951 * goodix_get_gpio_config - Get GPIO config from ACPI/DT
953 * @ts: goodix_ts_data pointer
955 static int goodix_get_gpio_config(struct goodix_ts_data
*ts
)
958 struct gpio_desc
*gpiod
;
959 bool added_acpi_mappings
= false;
963 dev
= &ts
->client
->dev
;
966 * By default we request the reset pin as input, leaving it in
967 * high-impedance when not resetting the controller to save power.
969 ts
->gpiod_rst_flags
= GPIOD_IN
;
971 ts
->avdd28
= devm_regulator_get(dev
, "AVDD28");
972 if (IS_ERR(ts
->avdd28
))
973 return dev_err_probe(dev
, PTR_ERR(ts
->avdd28
), "Failed to get AVDD28 regulator\n");
975 ts
->vddio
= devm_regulator_get(dev
, "VDDIO");
976 if (IS_ERR(ts
->vddio
))
977 return dev_err_probe(dev
, PTR_ERR(ts
->vddio
), "Failed to get VDDIO regulator\n");
980 /* Get the interrupt GPIO pin number */
981 gpiod
= devm_gpiod_get_optional(dev
, GOODIX_GPIO_INT_NAME
, GPIOD_IN
);
983 return dev_err_probe(dev
, PTR_ERR(gpiod
), "Failed to get %s GPIO\n",
984 GOODIX_GPIO_INT_NAME
);
986 if (!gpiod
&& has_acpi_companion(dev
) && !added_acpi_mappings
) {
987 added_acpi_mappings
= true;
988 if (goodix_add_acpi_gpio_mappings(ts
) == 0)
989 goto retry_get_irq_gpio
;
992 ts
->gpiod_int
= gpiod
;
994 /* Get the reset line GPIO pin number */
995 gpiod
= devm_gpiod_get_optional(dev
, GOODIX_GPIO_RST_NAME
, ts
->gpiod_rst_flags
);
997 return dev_err_probe(dev
, PTR_ERR(gpiod
), "Failed to get %s GPIO\n",
998 GOODIX_GPIO_RST_NAME
);
1000 ts
->gpiod_rst
= gpiod
;
1002 switch (ts
->irq_pin_access_method
) {
1003 case IRQ_PIN_ACCESS_ACPI_GPIO
:
1005 * We end up here if goodix_add_acpi_gpio_mappings() has
1006 * called devm_acpi_dev_add_driver_gpios() because the ACPI
1007 * tables did not contain name to index mappings.
1008 * Check that we successfully got both GPIOs after we've
1009 * added our own acpi_gpio_mapping and if we did not get both
1010 * GPIOs reset irq_pin_access_method to IRQ_PIN_ACCESS_NONE.
1012 if (!ts
->gpiod_int
|| !ts
->gpiod_rst
)
1013 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_NONE
;
1015 case IRQ_PIN_ACCESS_ACPI_METHOD
:
1017 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_NONE
;
1020 if (ts
->gpiod_int
&& ts
->gpiod_rst
) {
1021 ts
->reset_controller_at_probe
= true;
1022 ts
->load_cfg_from_disk
= true;
1023 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_GPIO
;
1031 * goodix_read_config - Read the embedded configuration of the panel
1033 * @ts: our goodix_ts_data pointer
1035 * Must be called during probe
1037 static void goodix_read_config(struct goodix_ts_data
*ts
)
1043 * On controllers where we need to upload the firmware
1044 * (controllers without flash) ts->config already has the config
1045 * at this point and the controller itself does not have it yet!
1047 if (!ts
->firmware_name
) {
1048 error
= goodix_i2c_read(ts
->client
, ts
->chip
->config_addr
,
1049 ts
->config
, ts
->chip
->config_len
);
1051 ts
->int_trigger_type
= GOODIX_INT_TRIGGER
;
1052 ts
->max_touch_num
= GOODIX_MAX_CONTACTS
;
1057 ts
->int_trigger_type
= ts
->config
[TRIGGER_LOC
] & 0x03;
1058 ts
->max_touch_num
= ts
->config
[MAX_CONTACTS_LOC
] & 0x0f;
1060 x_max
= get_unaligned_le16(&ts
->config
[RESOLUTION_LOC
]);
1061 y_max
= get_unaligned_le16(&ts
->config
[RESOLUTION_LOC
+ 2]);
1062 if (x_max
&& y_max
) {
1063 input_abs_set_max(ts
->input_dev
, ABS_MT_POSITION_X
, x_max
- 1);
1064 input_abs_set_max(ts
->input_dev
, ABS_MT_POSITION_Y
, y_max
- 1);
1067 ts
->chip
->calc_config_checksum(ts
);
1071 * goodix_read_version - Read goodix touchscreen version
1073 * @ts: our goodix_ts_data pointer
1075 static int goodix_read_version(struct goodix_ts_data
*ts
)
1079 char id_str
[GOODIX_ID_MAX_LEN
+ 1];
1081 error
= goodix_i2c_read(ts
->client
, GOODIX_REG_ID
, buf
, sizeof(buf
));
1085 memcpy(id_str
, buf
, GOODIX_ID_MAX_LEN
);
1086 id_str
[GOODIX_ID_MAX_LEN
] = 0;
1087 strscpy(ts
->id
, id_str
, GOODIX_ID_MAX_LEN
+ 1);
1089 ts
->version
= get_unaligned_le16(&buf
[4]);
1091 dev_info(&ts
->client
->dev
, "ID %s, version: %04x\n", ts
->id
,
1098 * goodix_i2c_test - I2C test function to check if the device answers.
1100 * @client: the i2c client
1102 static int goodix_i2c_test(struct i2c_client
*client
)
1108 while (retry
++ < 2) {
1109 error
= goodix_i2c_read(client
, GOODIX_REG_ID
, &test
, 1);
1120 * goodix_configure_dev - Finish device initialization
1122 * @ts: our goodix_ts_data pointer
1124 * Must be called from probe to finish initialization of the device.
1125 * Contains the common initialization code for both devices that
1126 * declare gpio pins and devices that do not. It is either called
1127 * directly from probe or from request_firmware_wait callback.
1129 static int goodix_configure_dev(struct goodix_ts_data
*ts
)
1134 ts
->int_trigger_type
= GOODIX_INT_TRIGGER
;
1135 ts
->max_touch_num
= GOODIX_MAX_CONTACTS
;
1137 ts
->input_dev
= devm_input_allocate_device(&ts
->client
->dev
);
1138 if (!ts
->input_dev
) {
1139 dev_err(&ts
->client
->dev
, "Failed to allocate input device.");
1143 ts
->input_dev
->name
= "Goodix Capacitive TouchScreen";
1144 ts
->input_dev
->phys
= "input/ts";
1145 ts
->input_dev
->id
.bustype
= BUS_I2C
;
1146 ts
->input_dev
->id
.vendor
= 0x0416;
1147 if (kstrtou16(ts
->id
, 10, &ts
->input_dev
->id
.product
))
1148 ts
->input_dev
->id
.product
= 0x1001;
1149 ts
->input_dev
->id
.version
= ts
->version
;
1151 ts
->input_dev
->keycode
= ts
->keymap
;
1152 ts
->input_dev
->keycodesize
= sizeof(ts
->keymap
[0]);
1153 ts
->input_dev
->keycodemax
= GOODIX_MAX_KEYS
;
1155 /* Capacitive Windows/Home button on some devices */
1156 for (i
= 0; i
< GOODIX_MAX_KEYS
; ++i
) {
1158 ts
->keymap
[i
] = KEY_LEFTMETA
;
1160 ts
->keymap
[i
] = KEY_F1
+ (i
- 1);
1162 input_set_capability(ts
->input_dev
, EV_KEY
, ts
->keymap
[i
]);
1165 input_set_capability(ts
->input_dev
, EV_ABS
, ABS_MT_POSITION_X
);
1166 input_set_capability(ts
->input_dev
, EV_ABS
, ABS_MT_POSITION_Y
);
1167 input_set_abs_params(ts
->input_dev
, ABS_MT_WIDTH_MAJOR
, 0, 255, 0, 0);
1168 input_set_abs_params(ts
->input_dev
, ABS_MT_TOUCH_MAJOR
, 0, 255, 0, 0);
1171 /* Read configuration and apply touchscreen parameters */
1172 goodix_read_config(ts
);
1174 /* Try overriding touchscreen parameters via device properties */
1175 touchscreen_parse_properties(ts
->input_dev
, true, &ts
->prop
);
1177 if (!ts
->prop
.max_x
|| !ts
->prop
.max_y
|| !ts
->max_touch_num
) {
1178 if (!ts
->reset_controller_at_probe
&&
1179 ts
->irq_pin_access_method
!= IRQ_PIN_ACCESS_NONE
) {
1180 dev_info(&ts
->client
->dev
, "Config not set, resetting controller\n");
1181 /* Retry after a controller reset */
1182 ts
->reset_controller_at_probe
= true;
1183 error
= goodix_reset(ts
);
1186 goto retry_read_config
;
1188 dev_err(&ts
->client
->dev
,
1189 "Invalid config (%d, %d, %d), using defaults\n",
1190 ts
->prop
.max_x
, ts
->prop
.max_y
, ts
->max_touch_num
);
1191 ts
->prop
.max_x
= GOODIX_MAX_WIDTH
- 1;
1192 ts
->prop
.max_y
= GOODIX_MAX_HEIGHT
- 1;
1193 ts
->max_touch_num
= GOODIX_MAX_CONTACTS
;
1194 input_abs_set_max(ts
->input_dev
,
1195 ABS_MT_POSITION_X
, ts
->prop
.max_x
);
1196 input_abs_set_max(ts
->input_dev
,
1197 ABS_MT_POSITION_Y
, ts
->prop
.max_y
);
1200 if (dmi_check_system(nine_bytes_report
)) {
1201 ts
->contact_size
= 9;
1203 dev_dbg(&ts
->client
->dev
,
1204 "Non-standard 9-bytes report format quirk\n");
1207 if (dmi_check_system(inverted_x_screen
)) {
1208 ts
->prop
.invert_x
= true;
1209 dev_dbg(&ts
->client
->dev
,
1210 "Applying 'inverted x screen' quirk\n");
1213 error
= input_mt_init_slots(ts
->input_dev
, ts
->max_touch_num
,
1214 INPUT_MT_DIRECT
| INPUT_MT_DROP_UNUSED
);
1216 dev_err(&ts
->client
->dev
,
1217 "Failed to initialize MT slots: %d", error
);
1221 error
= input_register_device(ts
->input_dev
);
1223 dev_err(&ts
->client
->dev
,
1224 "Failed to register input device: %d", error
);
1229 * Create the input_pen device before goodix_request_irq() calls
1230 * devm_request_threaded_irq() so that the devm framework frees
1231 * it after disabling the irq.
1232 * Unfortunately there is no way to detect if the touchscreen has pen
1233 * support, so registering the dev is delayed till the first pen event.
1235 error
= goodix_create_pen_input(ts
);
1239 ts
->irq_flags
= goodix_irq_flags
[ts
->int_trigger_type
] | IRQF_ONESHOT
;
1240 error
= goodix_request_irq(ts
);
1242 dev_err(&ts
->client
->dev
, "request IRQ failed: %d\n", error
);
1250 * goodix_config_cb - Callback to finish device init
1252 * @cfg: firmware config
1253 * @ctx: our goodix_ts_data pointer
1255 * request_firmware_wait callback that finishes
1256 * initialization of the device.
1258 static void goodix_config_cb(const struct firmware
*cfg
, void *ctx
)
1260 struct goodix_ts_data
*ts
= ctx
;
1263 if (ts
->firmware_name
) {
1265 goto err_release_cfg
;
1267 error
= goodix_check_cfg(ts
, cfg
->data
, cfg
->size
);
1269 goto err_release_cfg
;
1271 memcpy(ts
->config
, cfg
->data
, cfg
->size
);
1273 /* send device configuration to the firmware */
1274 error
= goodix_send_cfg(ts
, cfg
->data
, cfg
->size
);
1276 goto err_release_cfg
;
1279 goodix_configure_dev(ts
);
1282 release_firmware(cfg
);
1283 complete_all(&ts
->firmware_loading_complete
);
1286 static void goodix_disable_regulators(void *arg
)
1288 struct goodix_ts_data
*ts
= arg
;
1290 regulator_disable(ts
->vddio
);
1291 regulator_disable(ts
->avdd28
);
1294 static int goodix_ts_probe(struct i2c_client
*client
)
1296 struct goodix_ts_data
*ts
;
1297 const char *cfg_name
;
1300 dev_dbg(&client
->dev
, "I2C Address: 0x%02x\n", client
->addr
);
1302 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
)) {
1303 dev_err(&client
->dev
, "I2C check functionality failed.\n");
1307 ts
= devm_kzalloc(&client
->dev
, sizeof(*ts
), GFP_KERNEL
);
1311 ts
->client
= client
;
1312 i2c_set_clientdata(client
, ts
);
1313 init_completion(&ts
->firmware_loading_complete
);
1314 ts
->contact_size
= GOODIX_CONTACT_SIZE
;
1316 error
= goodix_get_gpio_config(ts
);
1320 /* power up the controller */
1321 error
= regulator_enable(ts
->avdd28
);
1323 dev_err(&client
->dev
,
1324 "Failed to enable AVDD28 regulator: %d\n",
1329 error
= regulator_enable(ts
->vddio
);
1331 dev_err(&client
->dev
,
1332 "Failed to enable VDDIO regulator: %d\n",
1334 regulator_disable(ts
->avdd28
);
1338 error
= devm_add_action_or_reset(&client
->dev
,
1339 goodix_disable_regulators
, ts
);
1344 if (ts
->reset_controller_at_probe
) {
1345 /* reset the controller */
1346 error
= goodix_reset(ts
);
1351 error
= goodix_i2c_test(client
);
1353 if (!ts
->reset_controller_at_probe
&&
1354 ts
->irq_pin_access_method
!= IRQ_PIN_ACCESS_NONE
) {
1355 /* Retry after a controller reset */
1356 ts
->reset_controller_at_probe
= true;
1359 dev_err(&client
->dev
, "I2C communication failure: %d\n", error
);
1363 error
= goodix_firmware_check(ts
);
1367 error
= goodix_read_version(ts
);
1371 ts
->chip
= goodix_get_chip_data(ts
->id
);
1373 if (ts
->load_cfg_from_disk
) {
1374 /* update device config */
1375 error
= device_property_read_string(&client
->dev
,
1376 "goodix,config-name",
1379 snprintf(ts
->cfg_name
, sizeof(ts
->cfg_name
),
1380 "goodix/%s", cfg_name
);
1382 snprintf(ts
->cfg_name
, sizeof(ts
->cfg_name
),
1383 "goodix_%s_cfg.bin", ts
->id
);
1385 error
= request_firmware_nowait(THIS_MODULE
, true, ts
->cfg_name
,
1386 &client
->dev
, GFP_KERNEL
, ts
,
1389 dev_err(&client
->dev
,
1390 "Failed to invoke firmware loader: %d\n",
1397 error
= goodix_configure_dev(ts
);
1405 static void goodix_ts_remove(struct i2c_client
*client
)
1407 struct goodix_ts_data
*ts
= i2c_get_clientdata(client
);
1409 if (ts
->load_cfg_from_disk
)
1410 wait_for_completion(&ts
->firmware_loading_complete
);
1413 static int goodix_suspend(struct device
*dev
)
1415 struct i2c_client
*client
= to_i2c_client(dev
);
1416 struct goodix_ts_data
*ts
= i2c_get_clientdata(client
);
1419 if (ts
->load_cfg_from_disk
)
1420 wait_for_completion(&ts
->firmware_loading_complete
);
1422 /* We need gpio pins to suspend/resume */
1423 if (ts
->irq_pin_access_method
== IRQ_PIN_ACCESS_NONE
) {
1424 disable_irq(client
->irq
);
1428 /* Free IRQ as IRQ pin is used as output in the suspend sequence */
1429 goodix_free_irq(ts
);
1431 /* Save reference (calibration) info if necessary */
1432 goodix_save_bak_ref(ts
);
1434 /* Output LOW on the INT pin for 5 ms */
1435 error
= goodix_irq_direction_output(ts
, 0);
1437 goodix_request_irq(ts
);
1441 usleep_range(5000, 6000);
1443 error
= goodix_i2c_write_u8(ts
->client
, GOODIX_REG_COMMAND
,
1444 GOODIX_CMD_SCREEN_OFF
);
1446 goodix_irq_direction_input(ts
);
1447 goodix_request_irq(ts
);
1452 * The datasheet specifies that the interval between sending screen-off
1453 * command and wake-up should be longer than 58 ms. To avoid waking up
1454 * sooner, delay 58ms here.
1460 static int goodix_resume(struct device
*dev
)
1462 struct i2c_client
*client
= to_i2c_client(dev
);
1463 struct goodix_ts_data
*ts
= i2c_get_clientdata(client
);
1467 if (ts
->irq_pin_access_method
== IRQ_PIN_ACCESS_NONE
) {
1468 enable_irq(client
->irq
);
1473 * Exit sleep mode by outputting HIGH level to INT pin
1476 error
= goodix_irq_direction_output(ts
, 1);
1480 usleep_range(2000, 5000);
1482 error
= goodix_int_sync(ts
);
1486 error
= goodix_i2c_read(ts
->client
, ts
->chip
->config_addr
,
1488 if (!error
&& config_ver
!= ts
->config
[0])
1489 dev_info(dev
, "Config version mismatch %d != %d, resetting controller\n",
1490 config_ver
, ts
->config
[0]);
1492 if (error
!= 0 || config_ver
!= ts
->config
[0]) {
1493 error
= goodix_reset(ts
);
1497 error
= goodix_send_cfg(ts
, ts
->config
, ts
->chip
->config_len
);
1502 error
= goodix_request_irq(ts
);
1509 static DEFINE_SIMPLE_DEV_PM_OPS(goodix_pm_ops
, goodix_suspend
, goodix_resume
);
1511 static const struct i2c_device_id goodix_ts_id
[] = {
1512 { "GDIX1001:00", 0 },
1515 MODULE_DEVICE_TABLE(i2c
, goodix_ts_id
);
1518 static const struct acpi_device_id goodix_acpi_match
[] = {
1524 MODULE_DEVICE_TABLE(acpi
, goodix_acpi_match
);
1528 static const struct of_device_id goodix_of_match
[] = {
1529 { .compatible
= "goodix,gt1151" },
1530 { .compatible
= "goodix,gt1158" },
1531 { .compatible
= "goodix,gt5663" },
1532 { .compatible
= "goodix,gt5688" },
1533 { .compatible
= "goodix,gt911" },
1534 { .compatible
= "goodix,gt9110" },
1535 { .compatible
= "goodix,gt912" },
1536 { .compatible
= "goodix,gt9147" },
1537 { .compatible
= "goodix,gt917s" },
1538 { .compatible
= "goodix,gt927" },
1539 { .compatible
= "goodix,gt9271" },
1540 { .compatible
= "goodix,gt928" },
1541 { .compatible
= "goodix,gt9286" },
1542 { .compatible
= "goodix,gt967" },
1545 MODULE_DEVICE_TABLE(of
, goodix_of_match
);
1548 static struct i2c_driver goodix_ts_driver
= {
1549 .probe
= goodix_ts_probe
,
1550 .remove
= goodix_ts_remove
,
1551 .id_table
= goodix_ts_id
,
1553 .name
= "Goodix-TS",
1554 .acpi_match_table
= ACPI_PTR(goodix_acpi_match
),
1555 .of_match_table
= of_match_ptr(goodix_of_match
),
1556 .pm
= pm_sleep_ptr(&goodix_pm_ops
),
1559 module_i2c_driver(goodix_ts_driver
);
1561 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
1562 MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
1563 MODULE_DESCRIPTION("Goodix touchscreen driver");
1564 MODULE_LICENSE("GPL v2");