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/gpio/consumer.h>
18 #include <linux/i2c.h>
19 #include <linux/input.h>
20 #include <linux/input/mt.h>
21 #include <linux/input/touchscreen.h>
22 #include <linux/module.h>
23 #include <linux/delay.h>
24 #include <linux/irq.h>
25 #include <linux/interrupt.h>
26 #include <linux/regulator/consumer.h>
27 #include <linux/slab.h>
28 #include <linux/acpi.h>
30 #include <asm/unaligned.h>
32 #define GOODIX_GPIO_INT_NAME "irq"
33 #define GOODIX_GPIO_RST_NAME "reset"
35 #define GOODIX_MAX_HEIGHT 4096
36 #define GOODIX_MAX_WIDTH 4096
37 #define GOODIX_INT_TRIGGER 1
38 #define GOODIX_CONTACT_SIZE 8
39 #define GOODIX_MAX_CONTACT_SIZE 9
40 #define GOODIX_MAX_CONTACTS 10
41 #define GOODIX_MAX_KEYS 7
43 #define GOODIX_CONFIG_MIN_LENGTH 186
44 #define GOODIX_CONFIG_911_LENGTH 186
45 #define GOODIX_CONFIG_967_LENGTH 228
46 #define GOODIX_CONFIG_GT9X_LENGTH 240
47 #define GOODIX_CONFIG_MAX_LENGTH 240
49 /* Register defines */
50 #define GOODIX_REG_COMMAND 0x8040
51 #define GOODIX_CMD_SCREEN_OFF 0x05
53 #define GOODIX_READ_COOR_ADDR 0x814E
54 #define GOODIX_GT1X_REG_CONFIG_DATA 0x8050
55 #define GOODIX_GT9X_REG_CONFIG_DATA 0x8047
56 #define GOODIX_REG_ID 0x8140
58 #define GOODIX_BUFFER_STATUS_READY BIT(7)
59 #define GOODIX_HAVE_KEY BIT(4)
60 #define GOODIX_BUFFER_STATUS_TIMEOUT 20
62 #define RESOLUTION_LOC 1
63 #define MAX_CONTACTS_LOC 5
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
71 struct goodix_ts_data
;
73 enum goodix_irq_pin_access_method
{
76 IRQ_PIN_ACCESS_ACPI_GPIO
,
77 IRQ_PIN_ACCESS_ACPI_METHOD
,
80 struct goodix_chip_data
{
83 int (*check_config
)(struct goodix_ts_data
*ts
, const u8
*cfg
, int len
);
84 void (*calc_config_checksum
)(struct goodix_ts_data
*ts
);
87 struct goodix_chip_id
{
89 const struct goodix_chip_data
*data
;
92 #define GOODIX_ID_MAX_LEN 4
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
;
107 char id
[GOODIX_ID_MAX_LEN
+ 1];
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
];
120 static int goodix_check_cfg_8(struct goodix_ts_data
*ts
,
121 const u8
*cfg
, int len
);
122 static int goodix_check_cfg_16(struct goodix_ts_data
*ts
,
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
);
127 static const struct goodix_chip_data gt1x_chip_data
= {
128 .config_addr
= GOODIX_GT1X_REG_CONFIG_DATA
,
129 .config_len
= GOODIX_CONFIG_GT9X_LENGTH
,
130 .check_config
= goodix_check_cfg_16
,
131 .calc_config_checksum
= goodix_calc_cfg_checksum_16
,
134 static const struct goodix_chip_data gt911_chip_data
= {
135 .config_addr
= GOODIX_GT9X_REG_CONFIG_DATA
,
136 .config_len
= GOODIX_CONFIG_911_LENGTH
,
137 .check_config
= goodix_check_cfg_8
,
138 .calc_config_checksum
= goodix_calc_cfg_checksum_8
,
141 static const struct goodix_chip_data gt967_chip_data
= {
142 .config_addr
= GOODIX_GT9X_REG_CONFIG_DATA
,
143 .config_len
= GOODIX_CONFIG_967_LENGTH
,
144 .check_config
= goodix_check_cfg_8
,
145 .calc_config_checksum
= goodix_calc_cfg_checksum_8
,
148 static const struct goodix_chip_data gt9x_chip_data
= {
149 .config_addr
= GOODIX_GT9X_REG_CONFIG_DATA
,
150 .config_len
= GOODIX_CONFIG_GT9X_LENGTH
,
151 .check_config
= goodix_check_cfg_8
,
152 .calc_config_checksum
= goodix_calc_cfg_checksum_8
,
155 static const struct goodix_chip_id goodix_chip_ids
[] = {
156 { .id
= "1151", .data
= >1x_chip_data
},
157 { .id
= "5663", .data
= >1x_chip_data
},
158 { .id
= "5688", .data
= >1x_chip_data
},
159 { .id
= "917S", .data
= >1x_chip_data
},
161 { .id
= "911", .data
= >911_chip_data
},
162 { .id
= "9271", .data
= >911_chip_data
},
163 { .id
= "9110", .data
= >911_chip_data
},
164 { .id
= "927", .data
= >911_chip_data
},
165 { .id
= "928", .data
= >911_chip_data
},
167 { .id
= "912", .data
= >967_chip_data
},
168 { .id
= "9147", .data
= >967_chip_data
},
169 { .id
= "967", .data
= >967_chip_data
},
173 static const unsigned long goodix_irq_flags
[] = {
174 IRQ_TYPE_EDGE_RISING
,
175 IRQ_TYPE_EDGE_FALLING
,
181 * Those tablets have their coordinates origin at the bottom right
182 * of the tablet, as if rotated 180 degrees
184 static const struct dmi_system_id rotated_screen
[] = {
185 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
187 .ident
= "Teclast X89",
189 /* tPAD is too generic, also match on bios date */
190 DMI_MATCH(DMI_BOARD_VENDOR
, "TECLAST"),
191 DMI_MATCH(DMI_BOARD_NAME
, "tPAD"),
192 DMI_MATCH(DMI_BIOS_DATE
, "12/19/2014"),
196 .ident
= "Teclast X98 Pro",
199 * Only match BIOS date, because the manufacturers
200 * BIOS does not report the board name at all
203 DMI_MATCH(DMI_BOARD_VENDOR
, "TECLAST"),
204 DMI_MATCH(DMI_BIOS_DATE
, "10/28/2015"),
208 .ident
= "WinBook TW100",
210 DMI_MATCH(DMI_SYS_VENDOR
, "WinBook"),
211 DMI_MATCH(DMI_PRODUCT_NAME
, "TW100")
215 .ident
= "WinBook TW700",
217 DMI_MATCH(DMI_SYS_VENDOR
, "WinBook"),
218 DMI_MATCH(DMI_PRODUCT_NAME
, "TW700")
225 static const struct dmi_system_id nine_bytes_report
[] = {
226 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
228 .ident
= "Lenovo YogaBook",
229 /* YB1-X91L/F and YB1-X90L/F */
231 DMI_MATCH(DMI_PRODUCT_NAME
, "Lenovo YB1-X9")
239 * Those tablets have their x coordinate inverted
241 static const struct dmi_system_id inverted_x_screen
[] = {
242 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
244 .ident
= "Cube I15-TC",
246 DMI_MATCH(DMI_SYS_VENDOR
, "Cube"),
247 DMI_MATCH(DMI_PRODUCT_NAME
, "I15-TC")
255 * goodix_i2c_read - read data from a register of the i2c slave device.
257 * @client: i2c device.
258 * @reg: the register to read from.
259 * @buf: raw write data buffer.
260 * @len: length of the buffer to write
262 static int goodix_i2c_read(struct i2c_client
*client
,
263 u16 reg
, u8
*buf
, int len
)
265 struct i2c_msg msgs
[2];
266 __be16 wbuf
= cpu_to_be16(reg
);
270 msgs
[0].addr
= client
->addr
;
272 msgs
[0].buf
= (u8
*)&wbuf
;
274 msgs
[1].flags
= I2C_M_RD
;
275 msgs
[1].addr
= client
->addr
;
279 ret
= i2c_transfer(client
->adapter
, msgs
, 2);
280 return ret
< 0 ? ret
: (ret
!= ARRAY_SIZE(msgs
) ? -EIO
: 0);
284 * goodix_i2c_write - write data to a register of the i2c slave device.
286 * @client: i2c device.
287 * @reg: the register to write to.
288 * @buf: raw data buffer to write.
289 * @len: length of the buffer to write
291 static int goodix_i2c_write(struct i2c_client
*client
, u16 reg
, const u8
*buf
,
298 addr_buf
= kmalloc(len
+ 2, GFP_KERNEL
);
302 addr_buf
[0] = reg
>> 8;
303 addr_buf
[1] = reg
& 0xFF;
304 memcpy(&addr_buf
[2], buf
, len
);
307 msg
.addr
= client
->addr
;
311 ret
= i2c_transfer(client
->adapter
, &msg
, 1);
313 return ret
< 0 ? ret
: (ret
!= 1 ? -EIO
: 0);
316 static int goodix_i2c_write_u8(struct i2c_client
*client
, u16 reg
, u8 value
)
318 return goodix_i2c_write(client
, reg
, &value
, sizeof(value
));
321 static const struct goodix_chip_data
*goodix_get_chip_data(const char *id
)
325 for (i
= 0; goodix_chip_ids
[i
].id
; i
++) {
326 if (!strcmp(goodix_chip_ids
[i
].id
, id
))
327 return goodix_chip_ids
[i
].data
;
330 return >9x_chip_data
;
333 static int goodix_ts_read_input_report(struct goodix_ts_data
*ts
, u8
*data
)
335 unsigned long max_timeout
;
338 u16 addr
= GOODIX_READ_COOR_ADDR
;
340 * We are going to read 1-byte header,
341 * ts->contact_size * max(1, touch_num) bytes of coordinates
342 * and 1-byte footer which contains the touch-key code.
344 const int header_contact_keycode_size
= 1 + ts
->contact_size
+ 1;
347 * The 'buffer status' bit, which indicates that the data is valid, is
348 * not set as soon as the interrupt is raised, but slightly after.
349 * This takes around 10 ms to happen, so we poll for 20 ms.
351 max_timeout
= jiffies
+ msecs_to_jiffies(GOODIX_BUFFER_STATUS_TIMEOUT
);
353 error
= goodix_i2c_read(ts
->client
, addr
, data
,
354 header_contact_keycode_size
);
356 dev_err(&ts
->client
->dev
, "I2C transfer error: %d\n",
361 if (data
[0] & GOODIX_BUFFER_STATUS_READY
) {
362 touch_num
= data
[0] & 0x0f;
363 if (touch_num
> ts
->max_touch_num
)
367 addr
+= header_contact_keycode_size
;
368 data
+= header_contact_keycode_size
;
369 error
= goodix_i2c_read(ts
->client
,
380 usleep_range(1000, 2000); /* Poll every 1 - 2 ms */
381 } while (time_before(jiffies
, max_timeout
));
384 * The Goodix panel will send spurious interrupts after a
385 * 'finger up' event, which will always cause a timeout.
390 static void goodix_ts_report_touch_8b(struct goodix_ts_data
*ts
, u8
*coor_data
)
392 int id
= coor_data
[0] & 0x0F;
393 int input_x
= get_unaligned_le16(&coor_data
[1]);
394 int input_y
= get_unaligned_le16(&coor_data
[3]);
395 int input_w
= get_unaligned_le16(&coor_data
[5]);
397 input_mt_slot(ts
->input_dev
, id
);
398 input_mt_report_slot_state(ts
->input_dev
, MT_TOOL_FINGER
, true);
399 touchscreen_report_pos(ts
->input_dev
, &ts
->prop
,
400 input_x
, input_y
, true);
401 input_report_abs(ts
->input_dev
, ABS_MT_TOUCH_MAJOR
, input_w
);
402 input_report_abs(ts
->input_dev
, ABS_MT_WIDTH_MAJOR
, input_w
);
405 static void goodix_ts_report_touch_9b(struct goodix_ts_data
*ts
, u8
*coor_data
)
407 int id
= coor_data
[1] & 0x0F;
408 int input_x
= get_unaligned_le16(&coor_data
[3]);
409 int input_y
= get_unaligned_le16(&coor_data
[5]);
410 int input_w
= get_unaligned_le16(&coor_data
[7]);
412 input_mt_slot(ts
->input_dev
, id
);
413 input_mt_report_slot_state(ts
->input_dev
, MT_TOOL_FINGER
, true);
414 touchscreen_report_pos(ts
->input_dev
, &ts
->prop
,
415 input_x
, input_y
, true);
416 input_report_abs(ts
->input_dev
, ABS_MT_TOUCH_MAJOR
, input_w
);
417 input_report_abs(ts
->input_dev
, ABS_MT_WIDTH_MAJOR
, input_w
);
420 static void goodix_ts_report_key(struct goodix_ts_data
*ts
, u8
*data
)
426 if (data
[0] & GOODIX_HAVE_KEY
) {
427 touch_num
= data
[0] & 0x0f;
428 key_value
= data
[1 + ts
->contact_size
* touch_num
];
429 for (i
= 0; i
< GOODIX_MAX_KEYS
; i
++)
430 if (key_value
& BIT(i
))
431 input_report_key(ts
->input_dev
,
434 for (i
= 0; i
< GOODIX_MAX_KEYS
; i
++)
435 input_report_key(ts
->input_dev
, ts
->keymap
[i
], 0);
440 * goodix_process_events - Process incoming events
442 * @ts: our goodix_ts_data pointer
444 * Called when the IRQ is triggered. Read the current device state, and push
445 * the input events to the user space.
447 static void goodix_process_events(struct goodix_ts_data
*ts
)
449 u8 point_data
[2 + GOODIX_MAX_CONTACT_SIZE
* GOODIX_MAX_CONTACTS
];
453 touch_num
= goodix_ts_read_input_report(ts
, point_data
);
457 goodix_ts_report_key(ts
, point_data
);
459 for (i
= 0; i
< touch_num
; i
++)
460 if (ts
->contact_size
== 9)
461 goodix_ts_report_touch_9b(ts
,
462 &point_data
[1 + ts
->contact_size
* i
]);
464 goodix_ts_report_touch_8b(ts
,
465 &point_data
[1 + ts
->contact_size
* i
]);
467 input_mt_sync_frame(ts
->input_dev
);
468 input_sync(ts
->input_dev
);
472 * goodix_ts_irq_handler - The IRQ handler
474 * @irq: interrupt number.
475 * @dev_id: private data pointer.
477 static irqreturn_t
goodix_ts_irq_handler(int irq
, void *dev_id
)
479 struct goodix_ts_data
*ts
= dev_id
;
481 goodix_process_events(ts
);
483 if (goodix_i2c_write_u8(ts
->client
, GOODIX_READ_COOR_ADDR
, 0) < 0)
484 dev_err(&ts
->client
->dev
, "I2C write end_cmd error\n");
489 static void goodix_free_irq(struct goodix_ts_data
*ts
)
491 devm_free_irq(&ts
->client
->dev
, ts
->client
->irq
, ts
);
494 static int goodix_request_irq(struct goodix_ts_data
*ts
)
496 return devm_request_threaded_irq(&ts
->client
->dev
, ts
->client
->irq
,
497 NULL
, goodix_ts_irq_handler
,
498 ts
->irq_flags
, ts
->client
->name
, ts
);
501 static int goodix_check_cfg_8(struct goodix_ts_data
*ts
, const u8
*cfg
, int len
)
503 int i
, raw_cfg_len
= len
- 2;
506 for (i
= 0; i
< raw_cfg_len
; i
++)
508 check_sum
= (~check_sum
) + 1;
509 if (check_sum
!= cfg
[raw_cfg_len
]) {
510 dev_err(&ts
->client
->dev
,
511 "The checksum of the config fw is not correct");
515 if (cfg
[raw_cfg_len
+ 1] != 1) {
516 dev_err(&ts
->client
->dev
,
517 "Config fw must have Config_Fresh register set");
524 static void goodix_calc_cfg_checksum_8(struct goodix_ts_data
*ts
)
526 int i
, raw_cfg_len
= ts
->chip
->config_len
- 2;
529 for (i
= 0; i
< raw_cfg_len
; i
++)
530 check_sum
+= ts
->config
[i
];
531 check_sum
= (~check_sum
) + 1;
533 ts
->config
[raw_cfg_len
] = check_sum
;
534 ts
->config
[raw_cfg_len
+ 1] = 1; /* Set "config_fresh" bit */
537 static int goodix_check_cfg_16(struct goodix_ts_data
*ts
, const u8
*cfg
,
540 int i
, raw_cfg_len
= len
- 3;
543 for (i
= 0; i
< raw_cfg_len
; i
+= 2)
544 check_sum
+= get_unaligned_be16(&cfg
[i
]);
545 check_sum
= (~check_sum
) + 1;
546 if (check_sum
!= get_unaligned_be16(&cfg
[raw_cfg_len
])) {
547 dev_err(&ts
->client
->dev
,
548 "The checksum of the config fw is not correct");
552 if (cfg
[raw_cfg_len
+ 2] != 1) {
553 dev_err(&ts
->client
->dev
,
554 "Config fw must have Config_Fresh register set");
561 static void goodix_calc_cfg_checksum_16(struct goodix_ts_data
*ts
)
563 int i
, raw_cfg_len
= ts
->chip
->config_len
- 3;
566 for (i
= 0; i
< raw_cfg_len
; i
+= 2)
567 check_sum
+= get_unaligned_be16(&ts
->config
[i
]);
568 check_sum
= (~check_sum
) + 1;
570 put_unaligned_be16(check_sum
, &ts
->config
[raw_cfg_len
]);
571 ts
->config
[raw_cfg_len
+ 2] = 1; /* Set "config_fresh" bit */
575 * goodix_check_cfg - Checks if config fw is valid
577 * @ts: goodix_ts_data pointer
578 * @cfg: firmware config data
579 * @len: config data length
581 static int goodix_check_cfg(struct goodix_ts_data
*ts
, const u8
*cfg
, int len
)
583 if (len
< GOODIX_CONFIG_MIN_LENGTH
||
584 len
> GOODIX_CONFIG_MAX_LENGTH
) {
585 dev_err(&ts
->client
->dev
,
586 "The length of the config fw is not correct");
590 return ts
->chip
->check_config(ts
, cfg
, len
);
594 * goodix_send_cfg - Write fw config to device
596 * @ts: goodix_ts_data pointer
597 * @cfg: config firmware to write to device
598 * @len: config data length
600 static int goodix_send_cfg(struct goodix_ts_data
*ts
, const u8
*cfg
, int len
)
604 error
= goodix_check_cfg(ts
, cfg
, len
);
608 error
= goodix_i2c_write(ts
->client
, ts
->chip
->config_addr
, cfg
, len
);
610 dev_err(&ts
->client
->dev
, "Failed to write config data: %d",
614 dev_dbg(&ts
->client
->dev
, "Config sent successfully.");
616 /* Let the firmware reconfigure itself, so sleep for 10ms */
617 usleep_range(10000, 11000);
622 #ifdef ACPI_GPIO_SUPPORT
623 static int goodix_pin_acpi_direction_input(struct goodix_ts_data
*ts
)
625 acpi_handle handle
= ACPI_HANDLE(&ts
->client
->dev
);
628 status
= acpi_evaluate_object(handle
, "INTI", NULL
, NULL
);
629 return ACPI_SUCCESS(status
) ? 0 : -EIO
;
632 static int goodix_pin_acpi_output_method(struct goodix_ts_data
*ts
, int value
)
634 acpi_handle handle
= ACPI_HANDLE(&ts
->client
->dev
);
637 status
= acpi_execute_simple_method(handle
, "INTO", value
);
638 return ACPI_SUCCESS(status
) ? 0 : -EIO
;
641 static int goodix_pin_acpi_direction_input(struct goodix_ts_data
*ts
)
643 dev_err(&ts
->client
->dev
,
644 "%s called on device without ACPI support\n", __func__
);
648 static int goodix_pin_acpi_output_method(struct goodix_ts_data
*ts
, int value
)
650 dev_err(&ts
->client
->dev
,
651 "%s called on device without ACPI support\n", __func__
);
656 static int goodix_irq_direction_output(struct goodix_ts_data
*ts
, int value
)
658 switch (ts
->irq_pin_access_method
) {
659 case IRQ_PIN_ACCESS_NONE
:
660 dev_err(&ts
->client
->dev
,
661 "%s called without an irq_pin_access_method set\n",
664 case IRQ_PIN_ACCESS_GPIO
:
665 return gpiod_direction_output(ts
->gpiod_int
, value
);
666 case IRQ_PIN_ACCESS_ACPI_GPIO
:
668 * The IRQ pin triggers on a falling edge, so its gets marked
669 * as active-low, use output_raw to avoid the value inversion.
671 return gpiod_direction_output_raw(ts
->gpiod_int
, value
);
672 case IRQ_PIN_ACCESS_ACPI_METHOD
:
673 return goodix_pin_acpi_output_method(ts
, value
);
676 return -EINVAL
; /* Never reached */
679 static int goodix_irq_direction_input(struct goodix_ts_data
*ts
)
681 switch (ts
->irq_pin_access_method
) {
682 case IRQ_PIN_ACCESS_NONE
:
683 dev_err(&ts
->client
->dev
,
684 "%s called without an irq_pin_access_method set\n",
687 case IRQ_PIN_ACCESS_GPIO
:
688 return gpiod_direction_input(ts
->gpiod_int
);
689 case IRQ_PIN_ACCESS_ACPI_GPIO
:
690 return gpiod_direction_input(ts
->gpiod_int
);
691 case IRQ_PIN_ACCESS_ACPI_METHOD
:
692 return goodix_pin_acpi_direction_input(ts
);
695 return -EINVAL
; /* Never reached */
698 static int goodix_int_sync(struct goodix_ts_data
*ts
)
702 error
= goodix_irq_direction_output(ts
, 0);
706 msleep(50); /* T5: 50ms */
708 error
= goodix_irq_direction_input(ts
);
716 * goodix_reset - Reset device during power on
718 * @ts: goodix_ts_data pointer
720 static int goodix_reset(struct goodix_ts_data
*ts
)
724 /* begin select I2C slave addr */
725 error
= gpiod_direction_output(ts
->gpiod_rst
, 0);
729 msleep(20); /* T2: > 10ms */
731 /* HIGH: 0x28/0x29, LOW: 0xBA/0xBB */
732 error
= goodix_irq_direction_output(ts
, ts
->client
->addr
== 0x14);
736 usleep_range(100, 2000); /* T3: > 100us */
738 error
= gpiod_direction_output(ts
->gpiod_rst
, 1);
742 usleep_range(6000, 10000); /* T4: > 5ms */
744 /* end select I2C slave addr */
745 error
= gpiod_direction_input(ts
->gpiod_rst
);
749 error
= goodix_int_sync(ts
);
756 #ifdef ACPI_GPIO_SUPPORT
757 #include <asm/cpu_device_id.h>
758 #include <asm/intel-family.h>
760 static const struct x86_cpu_id baytrail_cpu_ids
[] = {
761 { X86_VENDOR_INTEL
, 6, INTEL_FAM6_ATOM_SILVERMONT
, X86_FEATURE_ANY
, },
765 static inline bool is_byt(void)
767 const struct x86_cpu_id
*id
= x86_match_cpu(baytrail_cpu_ids
);
772 static const struct acpi_gpio_params first_gpio
= { 0, 0, false };
773 static const struct acpi_gpio_params second_gpio
= { 1, 0, false };
775 static const struct acpi_gpio_mapping acpi_goodix_int_first_gpios
[] = {
776 { GOODIX_GPIO_INT_NAME
"-gpios", &first_gpio
, 1 },
777 { GOODIX_GPIO_RST_NAME
"-gpios", &second_gpio
, 1 },
781 static const struct acpi_gpio_mapping acpi_goodix_int_last_gpios
[] = {
782 { GOODIX_GPIO_RST_NAME
"-gpios", &first_gpio
, 1 },
783 { GOODIX_GPIO_INT_NAME
"-gpios", &second_gpio
, 1 },
787 static const struct acpi_gpio_mapping acpi_goodix_reset_only_gpios
[] = {
788 { GOODIX_GPIO_RST_NAME
"-gpios", &first_gpio
, 1 },
792 static int goodix_resource(struct acpi_resource
*ares
, void *data
)
794 struct goodix_ts_data
*ts
= data
;
795 struct device
*dev
= &ts
->client
->dev
;
796 struct acpi_resource_gpio
*gpio
;
798 switch (ares
->type
) {
799 case ACPI_RESOURCE_TYPE_GPIO
:
800 gpio
= &ares
->data
.gpio
;
801 if (gpio
->connection_type
== ACPI_RESOURCE_GPIO_TYPE_INT
) {
802 if (ts
->gpio_int_idx
== -1) {
803 ts
->gpio_int_idx
= ts
->gpio_count
;
805 dev_err(dev
, "More then one GpioInt resource, ignoring ACPI GPIO resources\n");
806 ts
->gpio_int_idx
= -2;
819 * This function gets called in case we fail to get the irq GPIO directly
820 * because the ACPI tables lack GPIO-name to APCI _CRS index mappings
821 * (no _DSD UUID daffd814-6eba-4d8c-8a91-bc9bbf4aa301 data).
822 * In that case we add our own mapping and then goodix_get_gpio_config()
823 * retries to get the GPIOs based on the added mapping.
825 static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data
*ts
)
827 const struct acpi_gpio_mapping
*gpio_mapping
= NULL
;
828 struct device
*dev
= &ts
->client
->dev
;
829 LIST_HEAD(resources
);
833 ts
->gpio_int_idx
= -1;
834 ret
= acpi_dev_get_resources(ACPI_COMPANION(dev
), &resources
,
835 goodix_resource
, ts
);
837 dev_err(dev
, "Error getting ACPI resources: %d\n", ret
);
841 acpi_dev_free_resource_list(&resources
);
843 if (ts
->gpio_count
== 2 && ts
->gpio_int_idx
== 0) {
844 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_ACPI_GPIO
;
845 gpio_mapping
= acpi_goodix_int_first_gpios
;
846 } else if (ts
->gpio_count
== 2 && ts
->gpio_int_idx
== 1) {
847 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_ACPI_GPIO
;
848 gpio_mapping
= acpi_goodix_int_last_gpios
;
849 } else if (ts
->gpio_count
== 1 && ts
->gpio_int_idx
== -1 &&
850 acpi_has_method(ACPI_HANDLE(dev
), "INTI") &&
851 acpi_has_method(ACPI_HANDLE(dev
), "INTO")) {
852 dev_info(dev
, "Using ACPI INTI and INTO methods for IRQ pin access\n");
853 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_ACPI_METHOD
;
854 gpio_mapping
= acpi_goodix_reset_only_gpios
;
855 } else if (is_byt() && ts
->gpio_count
== 2 && ts
->gpio_int_idx
== -1) {
856 dev_info(dev
, "No ACPI GpioInt resource, assuming that the GPIO order is reset, int\n");
857 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_ACPI_GPIO
;
858 gpio_mapping
= acpi_goodix_int_last_gpios
;
860 dev_warn(dev
, "Unexpected ACPI resources: gpio_count %d, gpio_int_idx %d\n",
861 ts
->gpio_count
, ts
->gpio_int_idx
);
865 return devm_acpi_dev_add_driver_gpios(dev
, gpio_mapping
);
868 static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data
*ts
)
872 #endif /* CONFIG_X86 && CONFIG_ACPI */
875 * goodix_get_gpio_config - Get GPIO config from ACPI/DT
877 * @ts: goodix_ts_data pointer
879 static int goodix_get_gpio_config(struct goodix_ts_data
*ts
)
883 struct gpio_desc
*gpiod
;
884 bool added_acpi_mappings
= false;
888 dev
= &ts
->client
->dev
;
890 ts
->avdd28
= devm_regulator_get(dev
, "AVDD28");
891 if (IS_ERR(ts
->avdd28
)) {
892 error
= PTR_ERR(ts
->avdd28
);
893 if (error
!= -EPROBE_DEFER
)
895 "Failed to get AVDD28 regulator: %d\n", error
);
899 ts
->vddio
= devm_regulator_get(dev
, "VDDIO");
900 if (IS_ERR(ts
->vddio
)) {
901 error
= PTR_ERR(ts
->vddio
);
902 if (error
!= -EPROBE_DEFER
)
904 "Failed to get VDDIO regulator: %d\n", error
);
909 /* Get the interrupt GPIO pin number */
910 gpiod
= devm_gpiod_get_optional(dev
, GOODIX_GPIO_INT_NAME
, GPIOD_IN
);
912 error
= PTR_ERR(gpiod
);
913 if (error
!= -EPROBE_DEFER
)
914 dev_dbg(dev
, "Failed to get %s GPIO: %d\n",
915 GOODIX_GPIO_INT_NAME
, error
);
918 if (!gpiod
&& has_acpi_companion(dev
) && !added_acpi_mappings
) {
919 added_acpi_mappings
= true;
920 if (goodix_add_acpi_gpio_mappings(ts
) == 0)
921 goto retry_get_irq_gpio
;
924 ts
->gpiod_int
= gpiod
;
926 /* Get the reset line GPIO pin number */
927 gpiod
= devm_gpiod_get_optional(dev
, GOODIX_GPIO_RST_NAME
, GPIOD_IN
);
929 error
= PTR_ERR(gpiod
);
930 if (error
!= -EPROBE_DEFER
)
931 dev_dbg(dev
, "Failed to get %s GPIO: %d\n",
932 GOODIX_GPIO_RST_NAME
, error
);
936 ts
->gpiod_rst
= gpiod
;
938 switch (ts
->irq_pin_access_method
) {
939 case IRQ_PIN_ACCESS_ACPI_GPIO
:
941 * We end up here if goodix_add_acpi_gpio_mappings() has
942 * called devm_acpi_dev_add_driver_gpios() because the ACPI
943 * tables did not contain name to index mappings.
944 * Check that we successfully got both GPIOs after we've
945 * added our own acpi_gpio_mapping and if we did not get both
946 * GPIOs reset irq_pin_access_method to IRQ_PIN_ACCESS_NONE.
948 if (!ts
->gpiod_int
|| !ts
->gpiod_rst
)
949 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_NONE
;
951 case IRQ_PIN_ACCESS_ACPI_METHOD
:
953 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_NONE
;
956 if (ts
->gpiod_int
&& ts
->gpiod_rst
) {
957 ts
->reset_controller_at_probe
= true;
958 ts
->load_cfg_from_disk
= true;
959 ts
->irq_pin_access_method
= IRQ_PIN_ACCESS_GPIO
;
967 * goodix_read_config - Read the embedded configuration of the panel
969 * @ts: our goodix_ts_data pointer
971 * Must be called during probe
973 static void goodix_read_config(struct goodix_ts_data
*ts
)
978 error
= goodix_i2c_read(ts
->client
, ts
->chip
->config_addr
,
979 ts
->config
, ts
->chip
->config_len
);
981 dev_warn(&ts
->client
->dev
, "Error reading config: %d\n",
983 ts
->int_trigger_type
= GOODIX_INT_TRIGGER
;
984 ts
->max_touch_num
= GOODIX_MAX_CONTACTS
;
988 ts
->int_trigger_type
= ts
->config
[TRIGGER_LOC
] & 0x03;
989 ts
->max_touch_num
= ts
->config
[MAX_CONTACTS_LOC
] & 0x0f;
991 x_max
= get_unaligned_le16(&ts
->config
[RESOLUTION_LOC
]);
992 y_max
= get_unaligned_le16(&ts
->config
[RESOLUTION_LOC
+ 2]);
993 if (x_max
&& y_max
) {
994 input_abs_set_max(ts
->input_dev
, ABS_MT_POSITION_X
, x_max
- 1);
995 input_abs_set_max(ts
->input_dev
, ABS_MT_POSITION_Y
, y_max
- 1);
998 ts
->chip
->calc_config_checksum(ts
);
1002 * goodix_read_version - Read goodix touchscreen version
1004 * @ts: our goodix_ts_data pointer
1006 static int goodix_read_version(struct goodix_ts_data
*ts
)
1010 char id_str
[GOODIX_ID_MAX_LEN
+ 1];
1012 error
= goodix_i2c_read(ts
->client
, GOODIX_REG_ID
, buf
, sizeof(buf
));
1014 dev_err(&ts
->client
->dev
, "read version failed: %d\n", error
);
1018 memcpy(id_str
, buf
, GOODIX_ID_MAX_LEN
);
1019 id_str
[GOODIX_ID_MAX_LEN
] = 0;
1020 strscpy(ts
->id
, id_str
, GOODIX_ID_MAX_LEN
+ 1);
1022 ts
->version
= get_unaligned_le16(&buf
[4]);
1024 dev_info(&ts
->client
->dev
, "ID %s, version: %04x\n", ts
->id
,
1031 * goodix_i2c_test - I2C test function to check if the device answers.
1033 * @client: the i2c client
1035 static int goodix_i2c_test(struct i2c_client
*client
)
1041 while (retry
++ < 2) {
1042 error
= goodix_i2c_read(client
, GOODIX_REG_ID
,
1047 dev_err(&client
->dev
, "i2c test failed attempt %d: %d\n",
1056 * goodix_configure_dev - Finish device initialization
1058 * @ts: our goodix_ts_data pointer
1060 * Must be called from probe to finish initialization of the device.
1061 * Contains the common initialization code for both devices that
1062 * declare gpio pins and devices that do not. It is either called
1063 * directly from probe or from request_firmware_wait callback.
1065 static int goodix_configure_dev(struct goodix_ts_data
*ts
)
1070 ts
->int_trigger_type
= GOODIX_INT_TRIGGER
;
1071 ts
->max_touch_num
= GOODIX_MAX_CONTACTS
;
1073 ts
->input_dev
= devm_input_allocate_device(&ts
->client
->dev
);
1074 if (!ts
->input_dev
) {
1075 dev_err(&ts
->client
->dev
, "Failed to allocate input device.");
1079 ts
->input_dev
->name
= "Goodix Capacitive TouchScreen";
1080 ts
->input_dev
->phys
= "input/ts";
1081 ts
->input_dev
->id
.bustype
= BUS_I2C
;
1082 ts
->input_dev
->id
.vendor
= 0x0416;
1083 if (kstrtou16(ts
->id
, 10, &ts
->input_dev
->id
.product
))
1084 ts
->input_dev
->id
.product
= 0x1001;
1085 ts
->input_dev
->id
.version
= ts
->version
;
1087 ts
->input_dev
->keycode
= ts
->keymap
;
1088 ts
->input_dev
->keycodesize
= sizeof(ts
->keymap
[0]);
1089 ts
->input_dev
->keycodemax
= GOODIX_MAX_KEYS
;
1091 /* Capacitive Windows/Home button on some devices */
1092 for (i
= 0; i
< GOODIX_MAX_KEYS
; ++i
) {
1094 ts
->keymap
[i
] = KEY_LEFTMETA
;
1096 ts
->keymap
[i
] = KEY_F1
+ (i
- 1);
1098 input_set_capability(ts
->input_dev
, EV_KEY
, ts
->keymap
[i
]);
1101 input_set_capability(ts
->input_dev
, EV_ABS
, ABS_MT_POSITION_X
);
1102 input_set_capability(ts
->input_dev
, EV_ABS
, ABS_MT_POSITION_Y
);
1103 input_set_abs_params(ts
->input_dev
, ABS_MT_WIDTH_MAJOR
, 0, 255, 0, 0);
1104 input_set_abs_params(ts
->input_dev
, ABS_MT_TOUCH_MAJOR
, 0, 255, 0, 0);
1106 /* Read configuration and apply touchscreen parameters */
1107 goodix_read_config(ts
);
1109 /* Try overriding touchscreen parameters via device properties */
1110 touchscreen_parse_properties(ts
->input_dev
, true, &ts
->prop
);
1112 if (!ts
->prop
.max_x
|| !ts
->prop
.max_y
|| !ts
->max_touch_num
) {
1113 dev_err(&ts
->client
->dev
,
1114 "Invalid config (%d, %d, %d), using defaults\n",
1115 ts
->prop
.max_x
, ts
->prop
.max_y
, ts
->max_touch_num
);
1116 ts
->prop
.max_x
= GOODIX_MAX_WIDTH
- 1;
1117 ts
->prop
.max_y
= GOODIX_MAX_HEIGHT
- 1;
1118 ts
->max_touch_num
= GOODIX_MAX_CONTACTS
;
1119 input_abs_set_max(ts
->input_dev
,
1120 ABS_MT_POSITION_X
, ts
->prop
.max_x
);
1121 input_abs_set_max(ts
->input_dev
,
1122 ABS_MT_POSITION_Y
, ts
->prop
.max_y
);
1125 if (dmi_check_system(rotated_screen
)) {
1126 ts
->prop
.invert_x
= true;
1127 ts
->prop
.invert_y
= true;
1128 dev_dbg(&ts
->client
->dev
,
1129 "Applying '180 degrees rotated screen' quirk\n");
1132 if (dmi_check_system(nine_bytes_report
)) {
1133 ts
->contact_size
= 9;
1135 dev_dbg(&ts
->client
->dev
,
1136 "Non-standard 9-bytes report format quirk\n");
1139 if (dmi_check_system(inverted_x_screen
)) {
1140 ts
->prop
.invert_x
= true;
1141 dev_dbg(&ts
->client
->dev
,
1142 "Applying 'inverted x screen' quirk\n");
1145 error
= input_mt_init_slots(ts
->input_dev
, ts
->max_touch_num
,
1146 INPUT_MT_DIRECT
| INPUT_MT_DROP_UNUSED
);
1148 dev_err(&ts
->client
->dev
,
1149 "Failed to initialize MT slots: %d", error
);
1153 error
= input_register_device(ts
->input_dev
);
1155 dev_err(&ts
->client
->dev
,
1156 "Failed to register input device: %d", error
);
1160 ts
->irq_flags
= goodix_irq_flags
[ts
->int_trigger_type
] | IRQF_ONESHOT
;
1161 error
= goodix_request_irq(ts
);
1163 dev_err(&ts
->client
->dev
, "request IRQ failed: %d\n", error
);
1171 * goodix_config_cb - Callback to finish device init
1173 * @cfg: firmware config
1174 * @ctx: our goodix_ts_data pointer
1176 * request_firmware_wait callback that finishes
1177 * initialization of the device.
1179 static void goodix_config_cb(const struct firmware
*cfg
, void *ctx
)
1181 struct goodix_ts_data
*ts
= ctx
;
1185 /* send device configuration to the firmware */
1186 error
= goodix_send_cfg(ts
, cfg
->data
, cfg
->size
);
1188 goto err_release_cfg
;
1191 goodix_configure_dev(ts
);
1194 release_firmware(cfg
);
1195 complete_all(&ts
->firmware_loading_complete
);
1198 static void goodix_disable_regulators(void *arg
)
1200 struct goodix_ts_data
*ts
= arg
;
1202 regulator_disable(ts
->vddio
);
1203 regulator_disable(ts
->avdd28
);
1206 static int goodix_ts_probe(struct i2c_client
*client
,
1207 const struct i2c_device_id
*id
)
1209 struct goodix_ts_data
*ts
;
1212 dev_dbg(&client
->dev
, "I2C Address: 0x%02x\n", client
->addr
);
1214 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
)) {
1215 dev_err(&client
->dev
, "I2C check functionality failed.\n");
1219 ts
= devm_kzalloc(&client
->dev
, sizeof(*ts
), GFP_KERNEL
);
1223 ts
->client
= client
;
1224 i2c_set_clientdata(client
, ts
);
1225 init_completion(&ts
->firmware_loading_complete
);
1226 ts
->contact_size
= GOODIX_CONTACT_SIZE
;
1228 error
= goodix_get_gpio_config(ts
);
1232 /* power up the controller */
1233 error
= regulator_enable(ts
->avdd28
);
1235 dev_err(&client
->dev
,
1236 "Failed to enable AVDD28 regulator: %d\n",
1241 error
= regulator_enable(ts
->vddio
);
1243 dev_err(&client
->dev
,
1244 "Failed to enable VDDIO regulator: %d\n",
1246 regulator_disable(ts
->avdd28
);
1250 error
= devm_add_action_or_reset(&client
->dev
,
1251 goodix_disable_regulators
, ts
);
1256 if (ts
->reset_controller_at_probe
) {
1257 /* reset the controller */
1258 error
= goodix_reset(ts
);
1260 dev_err(&client
->dev
, "Controller reset failed.\n");
1265 error
= goodix_i2c_test(client
);
1267 if (!ts
->reset_controller_at_probe
&&
1268 ts
->irq_pin_access_method
!= IRQ_PIN_ACCESS_NONE
) {
1269 /* Retry after a controller reset */
1270 ts
->reset_controller_at_probe
= true;
1273 dev_err(&client
->dev
, "I2C communication failure: %d\n", error
);
1277 error
= goodix_read_version(ts
);
1279 dev_err(&client
->dev
, "Read version failed.\n");
1283 ts
->chip
= goodix_get_chip_data(ts
->id
);
1285 if (ts
->load_cfg_from_disk
) {
1286 /* update device config */
1287 ts
->cfg_name
= devm_kasprintf(&client
->dev
, GFP_KERNEL
,
1288 "goodix_%s_cfg.bin", ts
->id
);
1292 error
= request_firmware_nowait(THIS_MODULE
, true, ts
->cfg_name
,
1293 &client
->dev
, GFP_KERNEL
, ts
,
1296 dev_err(&client
->dev
,
1297 "Failed to invoke firmware loader: %d\n",
1304 error
= goodix_configure_dev(ts
);
1312 static int goodix_ts_remove(struct i2c_client
*client
)
1314 struct goodix_ts_data
*ts
= i2c_get_clientdata(client
);
1316 if (ts
->load_cfg_from_disk
)
1317 wait_for_completion(&ts
->firmware_loading_complete
);
1322 static int __maybe_unused
goodix_suspend(struct device
*dev
)
1324 struct i2c_client
*client
= to_i2c_client(dev
);
1325 struct goodix_ts_data
*ts
= i2c_get_clientdata(client
);
1328 if (ts
->load_cfg_from_disk
)
1329 wait_for_completion(&ts
->firmware_loading_complete
);
1331 /* We need gpio pins to suspend/resume */
1332 if (ts
->irq_pin_access_method
== IRQ_PIN_ACCESS_NONE
) {
1333 disable_irq(client
->irq
);
1337 /* Free IRQ as IRQ pin is used as output in the suspend sequence */
1338 goodix_free_irq(ts
);
1340 /* Output LOW on the INT pin for 5 ms */
1341 error
= goodix_irq_direction_output(ts
, 0);
1343 goodix_request_irq(ts
);
1347 usleep_range(5000, 6000);
1349 error
= goodix_i2c_write_u8(ts
->client
, GOODIX_REG_COMMAND
,
1350 GOODIX_CMD_SCREEN_OFF
);
1352 dev_err(&ts
->client
->dev
, "Screen off command failed\n");
1353 goodix_irq_direction_input(ts
);
1354 goodix_request_irq(ts
);
1359 * The datasheet specifies that the interval between sending screen-off
1360 * command and wake-up should be longer than 58 ms. To avoid waking up
1361 * sooner, delay 58ms here.
1367 static int __maybe_unused
goodix_resume(struct device
*dev
)
1369 struct i2c_client
*client
= to_i2c_client(dev
);
1370 struct goodix_ts_data
*ts
= i2c_get_clientdata(client
);
1374 if (ts
->irq_pin_access_method
== IRQ_PIN_ACCESS_NONE
) {
1375 enable_irq(client
->irq
);
1380 * Exit sleep mode by outputting HIGH level to INT pin
1383 error
= goodix_irq_direction_output(ts
, 1);
1387 usleep_range(2000, 5000);
1389 error
= goodix_int_sync(ts
);
1393 error
= goodix_i2c_read(ts
->client
, ts
->chip
->config_addr
,
1396 dev_warn(dev
, "Error reading config version: %d, resetting controller\n",
1398 else if (config_ver
!= ts
->config
[0])
1399 dev_info(dev
, "Config version mismatch %d != %d, resetting controller\n",
1400 config_ver
, ts
->config
[0]);
1402 if (error
!= 0 || config_ver
!= ts
->config
[0]) {
1403 error
= goodix_reset(ts
);
1405 dev_err(dev
, "Controller reset failed.\n");
1409 error
= goodix_send_cfg(ts
, ts
->config
, ts
->chip
->config_len
);
1414 error
= goodix_request_irq(ts
);
1421 static SIMPLE_DEV_PM_OPS(goodix_pm_ops
, goodix_suspend
, goodix_resume
);
1423 static const struct i2c_device_id goodix_ts_id
[] = {
1424 { "GDIX1001:00", 0 },
1427 MODULE_DEVICE_TABLE(i2c
, goodix_ts_id
);
1430 static const struct acpi_device_id goodix_acpi_match
[] = {
1435 MODULE_DEVICE_TABLE(acpi
, goodix_acpi_match
);
1439 static const struct of_device_id goodix_of_match
[] = {
1440 { .compatible
= "goodix,gt1151" },
1441 { .compatible
= "goodix,gt5663" },
1442 { .compatible
= "goodix,gt5688" },
1443 { .compatible
= "goodix,gt911" },
1444 { .compatible
= "goodix,gt9110" },
1445 { .compatible
= "goodix,gt912" },
1446 { .compatible
= "goodix,gt9147" },
1447 { .compatible
= "goodix,gt917s" },
1448 { .compatible
= "goodix,gt927" },
1449 { .compatible
= "goodix,gt9271" },
1450 { .compatible
= "goodix,gt928" },
1451 { .compatible
= "goodix,gt967" },
1454 MODULE_DEVICE_TABLE(of
, goodix_of_match
);
1457 static struct i2c_driver goodix_ts_driver
= {
1458 .probe
= goodix_ts_probe
,
1459 .remove
= goodix_ts_remove
,
1460 .id_table
= goodix_ts_id
,
1462 .name
= "Goodix-TS",
1463 .acpi_match_table
= ACPI_PTR(goodix_acpi_match
),
1464 .of_match_table
= of_match_ptr(goodix_of_match
),
1465 .pm
= &goodix_pm_ops
,
1468 module_i2c_driver(goodix_ts_driver
);
1470 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
1471 MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
1472 MODULE_DESCRIPTION("Goodix touchscreen driver");
1473 MODULE_LICENSE("GPL v2");