1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Driver for Goodix Touchscreens |
4 | * |
5 | * Copyright (c) 2014 Red Hat Inc. |
6 | * Copyright (c) 2015 K. Merker <merker@debian.org> |
7 | * |
8 | * This code is based on gt9xx.c authored by andrew@goodix.com: |
9 | * |
10 | * 2010 - 2012 Goodix Technology. |
11 | */ |
12 | |
13 | |
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> |
24 | #include <linux/of.h> |
25 | #include <asm/unaligned.h> |
26 | #include "goodix.h" |
27 | |
28 | #define GOODIX_GPIO_INT_NAME "irq" |
29 | #define GOODIX_GPIO_RST_NAME "reset" |
30 | |
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 |
37 | |
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 |
42 | |
43 | #define GOODIX_BUFFER_STATUS_READY BIT(7) |
44 | #define GOODIX_HAVE_KEY BIT(4) |
45 | #define GOODIX_BUFFER_STATUS_TIMEOUT 20 |
46 | |
47 | #define RESOLUTION_LOC 1 |
48 | #define MAX_CONTACTS_LOC 5 |
49 | #define TRIGGER_LOC 6 |
50 | |
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 |
54 | #endif |
55 | |
56 | struct goodix_chip_id { |
57 | const char *id; |
58 | const struct goodix_chip_data *data; |
59 | }; |
60 | |
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); |
67 | |
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, |
73 | }; |
74 | |
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, |
80 | }; |
81 | |
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, |
87 | }; |
88 | |
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, |
94 | }; |
95 | |
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 }, |
103 | |
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 }, |
110 | |
111 | { .id = "912" , .data = >967_chip_data }, |
112 | { .id = "9147" , .data = >967_chip_data }, |
113 | { .id = "967" , .data = >967_chip_data }, |
114 | { } |
115 | }; |
116 | |
117 | static const unsigned long goodix_irq_flags[] = { |
118 | IRQ_TYPE_EDGE_RISING, |
119 | IRQ_TYPE_EDGE_FALLING, |
120 | IRQ_TYPE_LEVEL_LOW, |
121 | IRQ_TYPE_LEVEL_HIGH, |
122 | }; |
123 | |
124 | static const struct dmi_system_id nine_bytes_report[] = { |
125 | #if defined(CONFIG_DMI) && defined(CONFIG_X86) |
126 | { |
127 | /* Lenovo Yoga Book X90F / X90L */ |
128 | .matches = { |
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" ), |
132 | } |
133 | }, |
134 | { |
135 | /* Lenovo Yoga Book X91F / X91L */ |
136 | .matches = { |
137 | /* Non exact match to match F + L versions */ |
138 | DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X91" ), |
139 | } |
140 | }, |
141 | #endif |
142 | {} |
143 | }; |
144 | |
145 | /* |
146 | * Those tablets have their x coordinate inverted |
147 | */ |
148 | static const struct dmi_system_id inverted_x_screen[] = { |
149 | #if defined(CONFIG_DMI) && defined(CONFIG_X86) |
150 | { |
151 | .ident = "Cube I15-TC" , |
152 | .matches = { |
153 | DMI_MATCH(DMI_SYS_VENDOR, "Cube" ), |
154 | DMI_MATCH(DMI_PRODUCT_NAME, "I15-TC" ) |
155 | }, |
156 | }, |
157 | #endif |
158 | {} |
159 | }; |
160 | |
161 | /** |
162 | * goodix_i2c_read - read data from a register of the i2c slave device. |
163 | * |
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 |
168 | */ |
169 | int goodix_i2c_read(struct i2c_client *client, u16 reg, u8 *buf, int len) |
170 | { |
171 | struct i2c_msg msgs[2]; |
172 | __be16 wbuf = cpu_to_be16(reg); |
173 | int ret; |
174 | |
175 | msgs[0].flags = 0; |
176 | msgs[0].addr = client->addr; |
177 | msgs[0].len = 2; |
178 | msgs[0].buf = (u8 *)&wbuf; |
179 | |
180 | msgs[1].flags = I2C_M_RD; |
181 | msgs[1].addr = client->addr; |
182 | msgs[1].len = len; |
183 | msgs[1].buf = buf; |
184 | |
185 | ret = i2c_transfer(adap: client->adapter, msgs, num: 2); |
186 | if (ret >= 0) |
187 | ret = (ret == ARRAY_SIZE(msgs) ? 0 : -EIO); |
188 | |
189 | if (ret) |
190 | dev_err(&client->dev, "Error reading %d bytes from 0x%04x: %d\n" , |
191 | len, reg, ret); |
192 | return ret; |
193 | } |
194 | |
195 | /** |
196 | * goodix_i2c_write - write data to a register of the i2c slave device. |
197 | * |
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 |
202 | */ |
203 | int goodix_i2c_write(struct i2c_client *client, u16 reg, const u8 *buf, int len) |
204 | { |
205 | u8 *addr_buf; |
206 | struct i2c_msg msg; |
207 | int ret; |
208 | |
209 | addr_buf = kmalloc(size: len + 2, GFP_KERNEL); |
210 | if (!addr_buf) |
211 | return -ENOMEM; |
212 | |
213 | addr_buf[0] = reg >> 8; |
214 | addr_buf[1] = reg & 0xFF; |
215 | memcpy(&addr_buf[2], buf, len); |
216 | |
217 | msg.flags = 0; |
218 | msg.addr = client->addr; |
219 | msg.buf = addr_buf; |
220 | msg.len = len + 2; |
221 | |
222 | ret = i2c_transfer(adap: client->adapter, msgs: &msg, num: 1); |
223 | if (ret >= 0) |
224 | ret = (ret == 1 ? 0 : -EIO); |
225 | |
226 | kfree(objp: addr_buf); |
227 | |
228 | if (ret) |
229 | dev_err(&client->dev, "Error writing %d bytes to 0x%04x: %d\n" , |
230 | len, reg, ret); |
231 | return ret; |
232 | } |
233 | |
234 | int goodix_i2c_write_u8(struct i2c_client *client, u16 reg, u8 value) |
235 | { |
236 | return goodix_i2c_write(client, reg, buf: &value, len: sizeof(value)); |
237 | } |
238 | |
239 | static const struct goodix_chip_data *goodix_get_chip_data(const char *id) |
240 | { |
241 | unsigned int i; |
242 | |
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; |
246 | } |
247 | |
248 | return >9x_chip_data; |
249 | } |
250 | |
251 | static int goodix_ts_read_input_report(struct goodix_ts_data *ts, u8 *data) |
252 | { |
253 | unsigned long max_timeout; |
254 | int touch_num; |
255 | int error; |
256 | u16 addr = GOODIX_READ_COOR_ADDR; |
257 | /* |
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. |
261 | */ |
262 | const int = 1 + ts->contact_size + 1; |
263 | |
264 | /* |
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. |
268 | */ |
269 | max_timeout = jiffies + msecs_to_jiffies(GOODIX_BUFFER_STATUS_TIMEOUT); |
270 | do { |
271 | error = goodix_i2c_read(client: ts->client, reg: addr, buf: data, |
272 | len: header_contact_keycode_size); |
273 | if (error) |
274 | return error; |
275 | |
276 | if (data[0] & GOODIX_BUFFER_STATUS_READY) { |
277 | touch_num = data[0] & 0x0f; |
278 | if (touch_num > ts->max_touch_num) |
279 | return -EPROTO; |
280 | |
281 | if (touch_num > 1) { |
282 | addr += header_contact_keycode_size; |
283 | data += header_contact_keycode_size; |
284 | error = goodix_i2c_read(client: ts->client, |
285 | reg: addr, buf: data, |
286 | len: ts->contact_size * |
287 | (touch_num - 1)); |
288 | if (error) |
289 | return error; |
290 | } |
291 | |
292 | return touch_num; |
293 | } |
294 | |
295 | if (data[0] == 0 && ts->firmware_name) { |
296 | if (goodix_handle_fw_request(ts)) |
297 | return 0; |
298 | } |
299 | |
300 | usleep_range(min: 1000, max: 2000); /* Poll every 1 - 2 ms */ |
301 | } while (time_before(jiffies, max_timeout)); |
302 | |
303 | /* |
304 | * The Goodix panel will send spurious interrupts after a |
305 | * 'finger up' event, which will always cause a timeout. |
306 | */ |
307 | return -ENOMSG; |
308 | } |
309 | |
310 | static int goodix_create_pen_input(struct goodix_ts_data *ts) |
311 | { |
312 | struct device *dev = &ts->client->dev; |
313 | struct input_dev *input; |
314 | |
315 | input = devm_input_allocate_device(dev); |
316 | if (!input) |
317 | return -ENOMEM; |
318 | |
319 | input_copy_abs(dst: input, ABS_X, src: ts->input_dev, ABS_MT_POSITION_X); |
320 | input_copy_abs(dst: input, ABS_Y, src: ts->input_dev, ABS_MT_POSITION_Y); |
321 | /* |
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. |
325 | */ |
326 | input_abs_set_res(dev: input, ABS_X, val: 10); |
327 | input_abs_set_res(dev: input, ABS_Y, val: 10); |
328 | input_set_abs_params(dev: input, ABS_PRESSURE, min: 0, max: 255, fuzz: 0, flat: 0); |
329 | |
330 | input_set_capability(dev: input, EV_KEY, BTN_TOUCH); |
331 | input_set_capability(dev: input, EV_KEY, BTN_TOOL_PEN); |
332 | input_set_capability(dev: input, EV_KEY, BTN_STYLUS); |
333 | input_set_capability(dev: input, EV_KEY, BTN_STYLUS2); |
334 | __set_bit(INPUT_PROP_DIRECT, input->propbit); |
335 | |
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(s: ts->id, base: 10, res: &input->id.product)) |
341 | input->id.product = 0x1001; |
342 | input->id.version = ts->version; |
343 | |
344 | ts->input_pen = input; |
345 | return 0; |
346 | } |
347 | |
348 | static void goodix_ts_report_pen_down(struct goodix_ts_data *ts, u8 *data) |
349 | { |
350 | int input_x, input_y, input_w, error; |
351 | u8 key_value; |
352 | |
353 | if (!ts->pen_input_registered) { |
354 | error = input_register_device(ts->input_pen); |
355 | ts->pen_input_registered = (error == 0) ? 1 : error; |
356 | } |
357 | |
358 | if (ts->pen_input_registered < 0) |
359 | return; |
360 | |
361 | if (ts->contact_size == 9) { |
362 | input_x = get_unaligned_le16(p: &data[4]); |
363 | input_y = get_unaligned_le16(p: &data[6]); |
364 | input_w = get_unaligned_le16(p: &data[8]); |
365 | } else { |
366 | input_x = get_unaligned_le16(p: &data[2]); |
367 | input_y = get_unaligned_le16(p: &data[4]); |
368 | input_w = get_unaligned_le16(p: &data[6]); |
369 | } |
370 | |
371 | touchscreen_report_pos(input: ts->input_pen, prop: &ts->prop, x: input_x, y: input_y, multitouch: false); |
372 | input_report_abs(dev: ts->input_pen, ABS_PRESSURE, value: input_w); |
373 | |
374 | input_report_key(dev: ts->input_pen, BTN_TOUCH, value: 1); |
375 | input_report_key(dev: ts->input_pen, BTN_TOOL_PEN, value: 1); |
376 | |
377 | if (data[0] & GOODIX_HAVE_KEY) { |
378 | key_value = data[1 + ts->contact_size]; |
379 | input_report_key(dev: ts->input_pen, BTN_STYLUS, value: key_value & 0x10); |
380 | input_report_key(dev: ts->input_pen, BTN_STYLUS2, value: key_value & 0x20); |
381 | } else { |
382 | input_report_key(dev: ts->input_pen, BTN_STYLUS, value: 0); |
383 | input_report_key(dev: ts->input_pen, BTN_STYLUS2, value: 0); |
384 | } |
385 | |
386 | input_sync(dev: ts->input_pen); |
387 | } |
388 | |
389 | static void goodix_ts_report_pen_up(struct goodix_ts_data *ts) |
390 | { |
391 | if (!ts->input_pen) |
392 | return; |
393 | |
394 | input_report_key(dev: ts->input_pen, BTN_TOUCH, value: 0); |
395 | input_report_key(dev: ts->input_pen, BTN_TOOL_PEN, value: 0); |
396 | input_report_key(dev: ts->input_pen, BTN_STYLUS, value: 0); |
397 | input_report_key(dev: ts->input_pen, BTN_STYLUS2, value: 0); |
398 | |
399 | input_sync(dev: ts->input_pen); |
400 | } |
401 | |
402 | static void goodix_ts_report_touch_8b(struct goodix_ts_data *ts, u8 *coor_data) |
403 | { |
404 | int id = coor_data[0] & 0x0F; |
405 | int input_x = get_unaligned_le16(p: &coor_data[1]); |
406 | int input_y = get_unaligned_le16(p: &coor_data[3]); |
407 | int input_w = get_unaligned_le16(p: &coor_data[5]); |
408 | |
409 | input_mt_slot(dev: ts->input_dev, slot: id); |
410 | input_mt_report_slot_state(dev: ts->input_dev, MT_TOOL_FINGER, active: true); |
411 | touchscreen_report_pos(input: ts->input_dev, prop: &ts->prop, |
412 | x: input_x, y: input_y, multitouch: true); |
413 | input_report_abs(dev: ts->input_dev, ABS_MT_TOUCH_MAJOR, value: input_w); |
414 | input_report_abs(dev: ts->input_dev, ABS_MT_WIDTH_MAJOR, value: input_w); |
415 | } |
416 | |
417 | static void goodix_ts_report_touch_9b(struct goodix_ts_data *ts, u8 *coor_data) |
418 | { |
419 | int id = coor_data[1] & 0x0F; |
420 | int input_x = get_unaligned_le16(p: &coor_data[3]); |
421 | int input_y = get_unaligned_le16(p: &coor_data[5]); |
422 | int input_w = get_unaligned_le16(p: &coor_data[7]); |
423 | |
424 | input_mt_slot(dev: ts->input_dev, slot: id); |
425 | input_mt_report_slot_state(dev: ts->input_dev, MT_TOOL_FINGER, active: true); |
426 | touchscreen_report_pos(input: ts->input_dev, prop: &ts->prop, |
427 | x: input_x, y: input_y, multitouch: true); |
428 | input_report_abs(dev: ts->input_dev, ABS_MT_TOUCH_MAJOR, value: input_w); |
429 | input_report_abs(dev: ts->input_dev, ABS_MT_WIDTH_MAJOR, value: input_w); |
430 | } |
431 | |
432 | static void goodix_ts_release_keys(struct goodix_ts_data *ts) |
433 | { |
434 | int i; |
435 | |
436 | for (i = 0; i < GOODIX_MAX_KEYS; i++) |
437 | input_report_key(dev: ts->input_dev, code: ts->keymap[i], value: 0); |
438 | } |
439 | |
440 | static void goodix_ts_report_key(struct goodix_ts_data *ts, u8 *data) |
441 | { |
442 | int touch_num; |
443 | u8 key_value; |
444 | int i; |
445 | |
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(dev: ts->input_dev, |
452 | code: ts->keymap[i], value: 1); |
453 | } else { |
454 | goodix_ts_release_keys(ts); |
455 | } |
456 | } |
457 | |
458 | /** |
459 | * goodix_process_events - Process incoming events |
460 | * |
461 | * @ts: our goodix_ts_data pointer |
462 | * |
463 | * Called when the IRQ is triggered. Read the current device state, and push |
464 | * the input events to the user space. |
465 | */ |
466 | static void goodix_process_events(struct goodix_ts_data *ts) |
467 | { |
468 | u8 point_data[2 + GOODIX_MAX_CONTACT_SIZE * GOODIX_MAX_CONTACTS]; |
469 | int touch_num; |
470 | int i; |
471 | |
472 | touch_num = goodix_ts_read_input_report(ts, data: point_data); |
473 | if (touch_num < 0) |
474 | return; |
475 | |
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, data: point_data); |
479 | goodix_ts_release_keys(ts); |
480 | goto sync; /* Release any previously registered touches */ |
481 | } else { |
482 | goodix_ts_report_pen_up(ts); |
483 | } |
484 | |
485 | goodix_ts_report_key(ts, data: point_data); |
486 | |
487 | for (i = 0; i < touch_num; i++) |
488 | if (ts->contact_size == 9) |
489 | goodix_ts_report_touch_9b(ts, |
490 | coor_data: &point_data[1 + ts->contact_size * i]); |
491 | else |
492 | goodix_ts_report_touch_8b(ts, |
493 | coor_data: &point_data[1 + ts->contact_size * i]); |
494 | |
495 | sync: |
496 | input_mt_sync_frame(dev: ts->input_dev); |
497 | input_sync(dev: ts->input_dev); |
498 | } |
499 | |
500 | /** |
501 | * goodix_ts_irq_handler - The IRQ handler |
502 | * |
503 | * @irq: interrupt number. |
504 | * @dev_id: private data pointer. |
505 | */ |
506 | static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id) |
507 | { |
508 | struct goodix_ts_data *ts = dev_id; |
509 | |
510 | goodix_process_events(ts); |
511 | goodix_i2c_write_u8(client: ts->client, GOODIX_READ_COOR_ADDR, value: 0); |
512 | |
513 | return IRQ_HANDLED; |
514 | } |
515 | |
516 | static void goodix_free_irq(struct goodix_ts_data *ts) |
517 | { |
518 | devm_free_irq(dev: &ts->client->dev, irq: ts->client->irq, dev_id: ts); |
519 | } |
520 | |
521 | static int goodix_request_irq(struct goodix_ts_data *ts) |
522 | { |
523 | return devm_request_threaded_irq(dev: &ts->client->dev, irq: ts->client->irq, |
524 | NULL, thread_fn: goodix_ts_irq_handler, |
525 | irqflags: ts->irq_flags, devname: ts->client->name, dev_id: ts); |
526 | } |
527 | |
528 | static int goodix_check_cfg_8(struct goodix_ts_data *ts, const u8 *cfg, int len) |
529 | { |
530 | int i, raw_cfg_len = len - 2; |
531 | u8 check_sum = 0; |
532 | |
533 | for (i = 0; i < raw_cfg_len; i++) |
534 | check_sum += cfg[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" ); |
539 | return -EINVAL; |
540 | } |
541 | |
542 | if (cfg[raw_cfg_len + 1] != 1) { |
543 | dev_err(&ts->client->dev, |
544 | "Config fw must have Config_Fresh register set" ); |
545 | return -EINVAL; |
546 | } |
547 | |
548 | return 0; |
549 | } |
550 | |
551 | static void goodix_calc_cfg_checksum_8(struct goodix_ts_data *ts) |
552 | { |
553 | int i, raw_cfg_len = ts->chip->config_len - 2; |
554 | u8 check_sum = 0; |
555 | |
556 | for (i = 0; i < raw_cfg_len; i++) |
557 | check_sum += ts->config[i]; |
558 | check_sum = (~check_sum) + 1; |
559 | |
560 | ts->config[raw_cfg_len] = check_sum; |
561 | ts->config[raw_cfg_len + 1] = 1; /* Set "config_fresh" bit */ |
562 | } |
563 | |
564 | static int goodix_check_cfg_16(struct goodix_ts_data *ts, const u8 *cfg, |
565 | int len) |
566 | { |
567 | int i, raw_cfg_len = len - 3; |
568 | u16 check_sum = 0; |
569 | |
570 | for (i = 0; i < raw_cfg_len; i += 2) |
571 | check_sum += get_unaligned_be16(p: &cfg[i]); |
572 | check_sum = (~check_sum) + 1; |
573 | if (check_sum != get_unaligned_be16(p: &cfg[raw_cfg_len])) { |
574 | dev_err(&ts->client->dev, |
575 | "The checksum of the config fw is not correct" ); |
576 | return -EINVAL; |
577 | } |
578 | |
579 | if (cfg[raw_cfg_len + 2] != 1) { |
580 | dev_err(&ts->client->dev, |
581 | "Config fw must have Config_Fresh register set" ); |
582 | return -EINVAL; |
583 | } |
584 | |
585 | return 0; |
586 | } |
587 | |
588 | static void goodix_calc_cfg_checksum_16(struct goodix_ts_data *ts) |
589 | { |
590 | int i, raw_cfg_len = ts->chip->config_len - 3; |
591 | u16 check_sum = 0; |
592 | |
593 | for (i = 0; i < raw_cfg_len; i += 2) |
594 | check_sum += get_unaligned_be16(p: &ts->config[i]); |
595 | check_sum = (~check_sum) + 1; |
596 | |
597 | put_unaligned_be16(val: check_sum, p: &ts->config[raw_cfg_len]); |
598 | ts->config[raw_cfg_len + 2] = 1; /* Set "config_fresh" bit */ |
599 | } |
600 | |
601 | /** |
602 | * goodix_check_cfg - Checks if config fw is valid |
603 | * |
604 | * @ts: goodix_ts_data pointer |
605 | * @cfg: firmware config data |
606 | * @len: config data length |
607 | */ |
608 | static int goodix_check_cfg(struct goodix_ts_data *ts, const u8 *cfg, int len) |
609 | { |
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" ); |
614 | return -EINVAL; |
615 | } |
616 | |
617 | return ts->chip->check_config(ts, cfg, len); |
618 | } |
619 | |
620 | /** |
621 | * goodix_send_cfg - Write fw config to device |
622 | * |
623 | * @ts: goodix_ts_data pointer |
624 | * @cfg: config firmware to write to device |
625 | * @len: config data length |
626 | */ |
627 | int goodix_send_cfg(struct goodix_ts_data *ts, const u8 *cfg, int len) |
628 | { |
629 | int error; |
630 | |
631 | error = goodix_check_cfg(ts, cfg, len); |
632 | if (error) |
633 | return error; |
634 | |
635 | error = goodix_i2c_write(client: ts->client, reg: ts->chip->config_addr, buf: cfg, len); |
636 | if (error) |
637 | return error; |
638 | |
639 | dev_dbg(&ts->client->dev, "Config sent successfully." ); |
640 | |
641 | /* Let the firmware reconfigure itself, so sleep for 10ms */ |
642 | usleep_range(min: 10000, max: 11000); |
643 | |
644 | return 0; |
645 | } |
646 | |
647 | #ifdef ACPI_GPIO_SUPPORT |
648 | static int goodix_pin_acpi_direction_input(struct goodix_ts_data *ts) |
649 | { |
650 | acpi_handle handle = ACPI_HANDLE(&ts->client->dev); |
651 | acpi_status status; |
652 | |
653 | status = acpi_evaluate_object(object: handle, pathname: "INTI" , NULL, NULL); |
654 | return ACPI_SUCCESS(status) ? 0 : -EIO; |
655 | } |
656 | |
657 | static int goodix_pin_acpi_output_method(struct goodix_ts_data *ts, int value) |
658 | { |
659 | acpi_handle handle = ACPI_HANDLE(&ts->client->dev); |
660 | acpi_status status; |
661 | |
662 | status = acpi_execute_simple_method(handle, method: "INTO" , arg: value); |
663 | return ACPI_SUCCESS(status) ? 0 : -EIO; |
664 | } |
665 | #else |
666 | static int goodix_pin_acpi_direction_input(struct goodix_ts_data *ts) |
667 | { |
668 | dev_err(&ts->client->dev, |
669 | "%s called on device without ACPI support\n" , __func__); |
670 | return -EINVAL; |
671 | } |
672 | |
673 | static int goodix_pin_acpi_output_method(struct goodix_ts_data *ts, int value) |
674 | { |
675 | dev_err(&ts->client->dev, |
676 | "%s called on device without ACPI support\n" , __func__); |
677 | return -EINVAL; |
678 | } |
679 | #endif |
680 | |
681 | static int goodix_irq_direction_output(struct goodix_ts_data *ts, int value) |
682 | { |
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" , |
687 | __func__); |
688 | return -EINVAL; |
689 | case IRQ_PIN_ACCESS_GPIO: |
690 | return gpiod_direction_output(desc: ts->gpiod_int, value); |
691 | case IRQ_PIN_ACCESS_ACPI_GPIO: |
692 | /* |
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. |
695 | */ |
696 | return gpiod_direction_output_raw(desc: ts->gpiod_int, value); |
697 | case IRQ_PIN_ACCESS_ACPI_METHOD: |
698 | return goodix_pin_acpi_output_method(ts, value); |
699 | } |
700 | |
701 | return -EINVAL; /* Never reached */ |
702 | } |
703 | |
704 | static int goodix_irq_direction_input(struct goodix_ts_data *ts) |
705 | { |
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" , |
710 | __func__); |
711 | return -EINVAL; |
712 | case IRQ_PIN_ACCESS_GPIO: |
713 | return gpiod_direction_input(desc: ts->gpiod_int); |
714 | case IRQ_PIN_ACCESS_ACPI_GPIO: |
715 | return gpiod_direction_input(desc: ts->gpiod_int); |
716 | case IRQ_PIN_ACCESS_ACPI_METHOD: |
717 | return goodix_pin_acpi_direction_input(ts); |
718 | } |
719 | |
720 | return -EINVAL; /* Never reached */ |
721 | } |
722 | |
723 | int goodix_int_sync(struct goodix_ts_data *ts) |
724 | { |
725 | int error; |
726 | |
727 | error = goodix_irq_direction_output(ts, value: 0); |
728 | if (error) |
729 | goto error; |
730 | |
731 | msleep(msecs: 50); /* T5: 50ms */ |
732 | |
733 | error = goodix_irq_direction_input(ts); |
734 | if (error) |
735 | goto error; |
736 | |
737 | return 0; |
738 | |
739 | error: |
740 | dev_err(&ts->client->dev, "Controller irq sync failed.\n" ); |
741 | return error; |
742 | } |
743 | |
744 | /** |
745 | * goodix_reset_no_int_sync - Reset device, leaving interrupt line in output mode |
746 | * |
747 | * @ts: goodix_ts_data pointer |
748 | */ |
749 | int goodix_reset_no_int_sync(struct goodix_ts_data *ts) |
750 | { |
751 | int error; |
752 | |
753 | /* begin select I2C slave addr */ |
754 | error = gpiod_direction_output(desc: ts->gpiod_rst, value: 0); |
755 | if (error) |
756 | goto error; |
757 | |
758 | msleep(msecs: 20); /* T2: > 10ms */ |
759 | |
760 | /* HIGH: 0x28/0x29, LOW: 0xBA/0xBB */ |
761 | error = goodix_irq_direction_output(ts, value: ts->client->addr == 0x14); |
762 | if (error) |
763 | goto error; |
764 | |
765 | usleep_range(min: 100, max: 2000); /* T3: > 100us */ |
766 | |
767 | error = gpiod_direction_output(desc: ts->gpiod_rst, value: 1); |
768 | if (error) |
769 | goto error; |
770 | |
771 | usleep_range(min: 6000, max: 10000); /* T4: > 5ms */ |
772 | |
773 | /* |
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. |
777 | */ |
778 | if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_GPIO) { |
779 | error = gpiod_direction_input(desc: ts->gpiod_rst); |
780 | if (error) |
781 | goto error; |
782 | } |
783 | |
784 | return 0; |
785 | |
786 | error: |
787 | dev_err(&ts->client->dev, "Controller reset failed.\n" ); |
788 | return error; |
789 | } |
790 | |
791 | /** |
792 | * goodix_reset - Reset device during power on |
793 | * |
794 | * @ts: goodix_ts_data pointer |
795 | */ |
796 | static int goodix_reset(struct goodix_ts_data *ts) |
797 | { |
798 | int error; |
799 | |
800 | error = goodix_reset_no_int_sync(ts); |
801 | if (error) |
802 | return error; |
803 | |
804 | return goodix_int_sync(ts); |
805 | } |
806 | |
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 }; |
810 | |
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 }, |
814 | { }, |
815 | }; |
816 | |
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 }, |
820 | { }, |
821 | }; |
822 | |
823 | static const struct acpi_gpio_mapping acpi_goodix_reset_only_gpios[] = { |
824 | { GOODIX_GPIO_RST_NAME "-gpios" , &first_gpio, 1 }, |
825 | { }, |
826 | }; |
827 | |
828 | static int goodix_resource(struct acpi_resource *ares, void *data) |
829 | { |
830 | struct goodix_ts_data *ts = data; |
831 | struct device *dev = &ts->client->dev; |
832 | struct acpi_resource_gpio *gpio; |
833 | |
834 | if (acpi_gpio_get_irq_resource(ares, agpio: &gpio)) { |
835 | if (ts->gpio_int_idx == -1) { |
836 | ts->gpio_int_idx = ts->gpio_count; |
837 | } else { |
838 | dev_err(dev, "More then one GpioInt resource, ignoring ACPI GPIO resources\n" ); |
839 | ts->gpio_int_idx = -2; |
840 | } |
841 | ts->gpio_count++; |
842 | } else if (acpi_gpio_get_io_resource(ares, agpio: &gpio)) |
843 | ts->gpio_count++; |
844 | |
845 | return 0; |
846 | } |
847 | |
848 | /* |
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. |
854 | */ |
855 | static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data *ts) |
856 | { |
857 | const struct acpi_gpio_mapping *gpio_mapping = NULL; |
858 | struct device *dev = &ts->client->dev; |
859 | LIST_HEAD(resources); |
860 | int irq, ret; |
861 | |
862 | ts->gpio_count = 0; |
863 | ts->gpio_int_idx = -1; |
864 | ret = acpi_dev_get_resources(ACPI_COMPANION(dev), list: &resources, |
865 | preproc: goodix_resource, preproc_data: ts); |
866 | if (ret < 0) { |
867 | dev_err(dev, "Error getting ACPI resources: %d\n" , ret); |
868 | return ret; |
869 | } |
870 | |
871 | acpi_dev_free_resource_list(list: &resources); |
872 | |
873 | /* |
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. |
878 | */ |
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), index: 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; |
884 | } |
885 | } |
886 | |
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), name: "INTI" ) && |
895 | acpi_has_method(ACPI_HANDLE(dev), name: "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) { |
904 | /* |
905 | * On newer devices there is only 1 GpioInt resource and _PS0 |
906 | * does the whole reset sequence for us. |
907 | */ |
908 | acpi_device_fix_up_power(ACPI_COMPANION(dev)); |
909 | |
910 | /* |
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. |
915 | * |
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. |
919 | */ |
920 | ts->irq_pin_access_method = IRQ_PIN_ACCESS_NONE; |
921 | gpio_mapping = acpi_goodix_int_first_gpios; |
922 | } else { |
923 | dev_warn(dev, "Unexpected ACPI resources: gpio_count %d, gpio_int_idx %d\n" , |
924 | ts->gpio_count, ts->gpio_int_idx); |
925 | /* |
926 | * On some devices _PS0 does a reset for us and |
927 | * sometimes this is necessary for things to work. |
928 | */ |
929 | acpi_device_fix_up_power(ACPI_COMPANION(dev)); |
930 | return -EINVAL; |
931 | } |
932 | |
933 | /* |
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. |
938 | */ |
939 | ts->gpiod_rst_flags = GPIOD_ASIS; |
940 | |
941 | return devm_acpi_dev_add_driver_gpios(dev, gpios: gpio_mapping); |
942 | } |
943 | #else |
944 | static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data *ts) |
945 | { |
946 | return -EINVAL; |
947 | } |
948 | #endif /* CONFIG_X86 && CONFIG_ACPI */ |
949 | |
950 | /** |
951 | * goodix_get_gpio_config - Get GPIO config from ACPI/DT |
952 | * |
953 | * @ts: goodix_ts_data pointer |
954 | */ |
955 | static int goodix_get_gpio_config(struct goodix_ts_data *ts) |
956 | { |
957 | struct device *dev; |
958 | struct gpio_desc *gpiod; |
959 | bool added_acpi_mappings = false; |
960 | |
961 | if (!ts->client) |
962 | return -EINVAL; |
963 | dev = &ts->client->dev; |
964 | |
965 | /* |
966 | * By default we request the reset pin as input, leaving it in |
967 | * high-impedance when not resetting the controller to save power. |
968 | */ |
969 | ts->gpiod_rst_flags = GPIOD_IN; |
970 | |
971 | ts->avdd28 = devm_regulator_get(dev, id: "AVDD28" ); |
972 | if (IS_ERR(ptr: ts->avdd28)) |
973 | return dev_err_probe(dev, err: PTR_ERR(ptr: ts->avdd28), fmt: "Failed to get AVDD28 regulator\n" ); |
974 | |
975 | ts->vddio = devm_regulator_get(dev, id: "VDDIO" ); |
976 | if (IS_ERR(ptr: ts->vddio)) |
977 | return dev_err_probe(dev, err: PTR_ERR(ptr: ts->vddio), fmt: "Failed to get VDDIO regulator\n" ); |
978 | |
979 | retry_get_irq_gpio: |
980 | /* Get the interrupt GPIO pin number */ |
981 | gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_INT_NAME, flags: GPIOD_IN); |
982 | if (IS_ERR(ptr: gpiod)) |
983 | return dev_err_probe(dev, err: PTR_ERR(ptr: gpiod), fmt: "Failed to get %s GPIO\n" , |
984 | GOODIX_GPIO_INT_NAME); |
985 | |
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; |
990 | } |
991 | |
992 | ts->gpiod_int = gpiod; |
993 | |
994 | /* Get the reset line GPIO pin number */ |
995 | gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_RST_NAME, flags: ts->gpiod_rst_flags); |
996 | if (IS_ERR(ptr: gpiod)) |
997 | return dev_err_probe(dev, err: PTR_ERR(ptr: gpiod), fmt: "Failed to get %s GPIO\n" , |
998 | GOODIX_GPIO_RST_NAME); |
999 | |
1000 | ts->gpiod_rst = gpiod; |
1001 | |
1002 | switch (ts->irq_pin_access_method) { |
1003 | case IRQ_PIN_ACCESS_ACPI_GPIO: |
1004 | /* |
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. |
1011 | */ |
1012 | if (!ts->gpiod_int || !ts->gpiod_rst) |
1013 | ts->irq_pin_access_method = IRQ_PIN_ACCESS_NONE; |
1014 | break; |
1015 | case IRQ_PIN_ACCESS_ACPI_METHOD: |
1016 | if (!ts->gpiod_rst) |
1017 | ts->irq_pin_access_method = IRQ_PIN_ACCESS_NONE; |
1018 | break; |
1019 | default: |
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; |
1024 | } |
1025 | } |
1026 | |
1027 | return 0; |
1028 | } |
1029 | |
1030 | /** |
1031 | * goodix_read_config - Read the embedded configuration of the panel |
1032 | * |
1033 | * @ts: our goodix_ts_data pointer |
1034 | * |
1035 | * Must be called during probe |
1036 | */ |
1037 | static void goodix_read_config(struct goodix_ts_data *ts) |
1038 | { |
1039 | int x_max, y_max; |
1040 | int error; |
1041 | |
1042 | /* |
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! |
1046 | */ |
1047 | if (!ts->firmware_name) { |
1048 | error = goodix_i2c_read(client: ts->client, reg: ts->chip->config_addr, |
1049 | buf: ts->config, len: ts->chip->config_len); |
1050 | if (error) { |
1051 | ts->int_trigger_type = GOODIX_INT_TRIGGER; |
1052 | ts->max_touch_num = GOODIX_MAX_CONTACTS; |
1053 | return; |
1054 | } |
1055 | } |
1056 | |
1057 | ts->int_trigger_type = ts->config[TRIGGER_LOC] & 0x03; |
1058 | ts->max_touch_num = ts->config[MAX_CONTACTS_LOC] & 0x0f; |
1059 | |
1060 | x_max = get_unaligned_le16(p: &ts->config[RESOLUTION_LOC]); |
1061 | y_max = get_unaligned_le16(p: &ts->config[RESOLUTION_LOC + 2]); |
1062 | if (x_max && y_max) { |
1063 | input_abs_set_max(dev: ts->input_dev, ABS_MT_POSITION_X, val: x_max - 1); |
1064 | input_abs_set_max(dev: ts->input_dev, ABS_MT_POSITION_Y, val: y_max - 1); |
1065 | } |
1066 | |
1067 | ts->chip->calc_config_checksum(ts); |
1068 | } |
1069 | |
1070 | /** |
1071 | * goodix_read_version - Read goodix touchscreen version |
1072 | * |
1073 | * @ts: our goodix_ts_data pointer |
1074 | */ |
1075 | static int goodix_read_version(struct goodix_ts_data *ts) |
1076 | { |
1077 | int error; |
1078 | u8 buf[6]; |
1079 | char id_str[GOODIX_ID_MAX_LEN + 1]; |
1080 | |
1081 | error = goodix_i2c_read(client: ts->client, GOODIX_REG_ID, buf, len: sizeof(buf)); |
1082 | if (error) |
1083 | return error; |
1084 | |
1085 | memcpy(id_str, buf, GOODIX_ID_MAX_LEN); |
1086 | id_str[GOODIX_ID_MAX_LEN] = 0; |
1087 | strscpy(p: ts->id, q: id_str, GOODIX_ID_MAX_LEN + 1); |
1088 | |
1089 | ts->version = get_unaligned_le16(p: &buf[4]); |
1090 | |
1091 | dev_info(&ts->client->dev, "ID %s, version: %04x\n" , ts->id, |
1092 | ts->version); |
1093 | |
1094 | return 0; |
1095 | } |
1096 | |
1097 | /** |
1098 | * goodix_i2c_test - I2C test function to check if the device answers. |
1099 | * |
1100 | * @client: the i2c client |
1101 | */ |
1102 | static int goodix_i2c_test(struct i2c_client *client) |
1103 | { |
1104 | int retry = 0; |
1105 | int error; |
1106 | u8 test; |
1107 | |
1108 | while (retry++ < 2) { |
1109 | error = goodix_i2c_read(client, GOODIX_REG_ID, buf: &test, len: 1); |
1110 | if (!error) |
1111 | return 0; |
1112 | |
1113 | msleep(msecs: 20); |
1114 | } |
1115 | |
1116 | return error; |
1117 | } |
1118 | |
1119 | /** |
1120 | * goodix_configure_dev - Finish device initialization |
1121 | * |
1122 | * @ts: our goodix_ts_data pointer |
1123 | * |
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. |
1128 | */ |
1129 | static int goodix_configure_dev(struct goodix_ts_data *ts) |
1130 | { |
1131 | int error; |
1132 | int i; |
1133 | |
1134 | ts->int_trigger_type = GOODIX_INT_TRIGGER; |
1135 | ts->max_touch_num = GOODIX_MAX_CONTACTS; |
1136 | |
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." ); |
1140 | return -ENOMEM; |
1141 | } |
1142 | |
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(s: ts->id, base: 10, res: &ts->input_dev->id.product)) |
1148 | ts->input_dev->id.product = 0x1001; |
1149 | ts->input_dev->id.version = ts->version; |
1150 | |
1151 | ts->input_dev->keycode = ts->keymap; |
1152 | ts->input_dev->keycodesize = sizeof(ts->keymap[0]); |
1153 | ts->input_dev->keycodemax = GOODIX_MAX_KEYS; |
1154 | |
1155 | /* Capacitive Windows/Home button on some devices */ |
1156 | for (i = 0; i < GOODIX_MAX_KEYS; ++i) { |
1157 | if (i == 0) |
1158 | ts->keymap[i] = KEY_LEFTMETA; |
1159 | else |
1160 | ts->keymap[i] = KEY_F1 + (i - 1); |
1161 | |
1162 | input_set_capability(dev: ts->input_dev, EV_KEY, code: ts->keymap[i]); |
1163 | } |
1164 | |
1165 | input_set_capability(dev: ts->input_dev, EV_ABS, ABS_MT_POSITION_X); |
1166 | input_set_capability(dev: ts->input_dev, EV_ABS, ABS_MT_POSITION_Y); |
1167 | input_set_abs_params(dev: ts->input_dev, ABS_MT_WIDTH_MAJOR, min: 0, max: 255, fuzz: 0, flat: 0); |
1168 | input_set_abs_params(dev: ts->input_dev, ABS_MT_TOUCH_MAJOR, min: 0, max: 255, fuzz: 0, flat: 0); |
1169 | |
1170 | retry_read_config: |
1171 | /* Read configuration and apply touchscreen parameters */ |
1172 | goodix_read_config(ts); |
1173 | |
1174 | /* Try overriding touchscreen parameters via device properties */ |
1175 | touchscreen_parse_properties(input: ts->input_dev, multitouch: true, prop: &ts->prop); |
1176 | |
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); |
1184 | if (error) |
1185 | return error; |
1186 | goto retry_read_config; |
1187 | } |
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(dev: ts->input_dev, |
1195 | ABS_MT_POSITION_X, val: ts->prop.max_x); |
1196 | input_abs_set_max(dev: ts->input_dev, |
1197 | ABS_MT_POSITION_Y, val: ts->prop.max_y); |
1198 | } |
1199 | |
1200 | if (dmi_check_system(list: nine_bytes_report)) { |
1201 | ts->contact_size = 9; |
1202 | |
1203 | dev_dbg(&ts->client->dev, |
1204 | "Non-standard 9-bytes report format quirk\n" ); |
1205 | } |
1206 | |
1207 | if (dmi_check_system(list: inverted_x_screen)) { |
1208 | ts->prop.invert_x = true; |
1209 | dev_dbg(&ts->client->dev, |
1210 | "Applying 'inverted x screen' quirk\n" ); |
1211 | } |
1212 | |
1213 | error = input_mt_init_slots(dev: ts->input_dev, num_slots: ts->max_touch_num, |
1214 | INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); |
1215 | if (error) { |
1216 | dev_err(&ts->client->dev, |
1217 | "Failed to initialize MT slots: %d" , error); |
1218 | return error; |
1219 | } |
1220 | |
1221 | error = input_register_device(ts->input_dev); |
1222 | if (error) { |
1223 | dev_err(&ts->client->dev, |
1224 | "Failed to register input device: %d" , error); |
1225 | return error; |
1226 | } |
1227 | |
1228 | /* |
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. |
1234 | */ |
1235 | error = goodix_create_pen_input(ts); |
1236 | if (error) |
1237 | return error; |
1238 | |
1239 | ts->irq_flags = goodix_irq_flags[ts->int_trigger_type] | IRQF_ONESHOT; |
1240 | error = goodix_request_irq(ts); |
1241 | if (error) { |
1242 | dev_err(&ts->client->dev, "request IRQ failed: %d\n" , error); |
1243 | return error; |
1244 | } |
1245 | |
1246 | return 0; |
1247 | } |
1248 | |
1249 | /** |
1250 | * goodix_config_cb - Callback to finish device init |
1251 | * |
1252 | * @cfg: firmware config |
1253 | * @ctx: our goodix_ts_data pointer |
1254 | * |
1255 | * request_firmware_wait callback that finishes |
1256 | * initialization of the device. |
1257 | */ |
1258 | static void goodix_config_cb(const struct firmware *cfg, void *ctx) |
1259 | { |
1260 | struct goodix_ts_data *ts = ctx; |
1261 | int error; |
1262 | |
1263 | if (ts->firmware_name) { |
1264 | if (!cfg) |
1265 | goto err_release_cfg; |
1266 | |
1267 | error = goodix_check_cfg(ts, cfg: cfg->data, len: cfg->size); |
1268 | if (error) |
1269 | goto err_release_cfg; |
1270 | |
1271 | memcpy(ts->config, cfg->data, cfg->size); |
1272 | } else if (cfg) { |
1273 | /* send device configuration to the firmware */ |
1274 | error = goodix_send_cfg(ts, cfg: cfg->data, len: cfg->size); |
1275 | if (error) |
1276 | goto err_release_cfg; |
1277 | } |
1278 | |
1279 | goodix_configure_dev(ts); |
1280 | |
1281 | err_release_cfg: |
1282 | release_firmware(fw: cfg); |
1283 | complete_all(&ts->firmware_loading_complete); |
1284 | } |
1285 | |
1286 | static void goodix_disable_regulators(void *arg) |
1287 | { |
1288 | struct goodix_ts_data *ts = arg; |
1289 | |
1290 | regulator_disable(regulator: ts->vddio); |
1291 | regulator_disable(regulator: ts->avdd28); |
1292 | } |
1293 | |
1294 | static int goodix_ts_probe(struct i2c_client *client) |
1295 | { |
1296 | struct goodix_ts_data *ts; |
1297 | const char *cfg_name; |
1298 | int error; |
1299 | |
1300 | dev_dbg(&client->dev, "I2C Address: 0x%02x\n" , client->addr); |
1301 | |
1302 | if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_I2C)) { |
1303 | dev_err(&client->dev, "I2C check functionality failed.\n" ); |
1304 | return -ENXIO; |
1305 | } |
1306 | |
1307 | ts = devm_kzalloc(dev: &client->dev, size: sizeof(*ts), GFP_KERNEL); |
1308 | if (!ts) |
1309 | return -ENOMEM; |
1310 | |
1311 | ts->client = client; |
1312 | i2c_set_clientdata(client, data: ts); |
1313 | init_completion(x: &ts->firmware_loading_complete); |
1314 | ts->contact_size = GOODIX_CONTACT_SIZE; |
1315 | |
1316 | error = goodix_get_gpio_config(ts); |
1317 | if (error) |
1318 | return error; |
1319 | |
1320 | /* power up the controller */ |
1321 | error = regulator_enable(regulator: ts->avdd28); |
1322 | if (error) { |
1323 | dev_err(&client->dev, |
1324 | "Failed to enable AVDD28 regulator: %d\n" , |
1325 | error); |
1326 | return error; |
1327 | } |
1328 | |
1329 | error = regulator_enable(regulator: ts->vddio); |
1330 | if (error) { |
1331 | dev_err(&client->dev, |
1332 | "Failed to enable VDDIO regulator: %d\n" , |
1333 | error); |
1334 | regulator_disable(regulator: ts->avdd28); |
1335 | return error; |
1336 | } |
1337 | |
1338 | error = devm_add_action_or_reset(&client->dev, |
1339 | goodix_disable_regulators, ts); |
1340 | if (error) |
1341 | return error; |
1342 | |
1343 | reset: |
1344 | if (ts->reset_controller_at_probe) { |
1345 | /* reset the controller */ |
1346 | error = goodix_reset(ts); |
1347 | if (error) |
1348 | return error; |
1349 | } |
1350 | |
1351 | error = goodix_i2c_test(client); |
1352 | if (error) { |
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; |
1357 | goto reset; |
1358 | } |
1359 | dev_err(&client->dev, "I2C communication failure: %d\n" , error); |
1360 | return error; |
1361 | } |
1362 | |
1363 | error = goodix_firmware_check(ts); |
1364 | if (error) |
1365 | return error; |
1366 | |
1367 | error = goodix_read_version(ts); |
1368 | if (error) |
1369 | return error; |
1370 | |
1371 | ts->chip = goodix_get_chip_data(id: ts->id); |
1372 | |
1373 | if (ts->load_cfg_from_disk) { |
1374 | /* update device config */ |
1375 | error = device_property_read_string(dev: &client->dev, |
1376 | propname: "goodix,config-name" , |
1377 | val: &cfg_name); |
1378 | if (!error) |
1379 | snprintf(buf: ts->cfg_name, size: sizeof(ts->cfg_name), |
1380 | fmt: "goodix/%s" , cfg_name); |
1381 | else |
1382 | snprintf(buf: ts->cfg_name, size: sizeof(ts->cfg_name), |
1383 | fmt: "goodix_%s_cfg.bin" , ts->id); |
1384 | |
1385 | error = request_firmware_nowait(THIS_MODULE, uevent: true, name: ts->cfg_name, |
1386 | device: &client->dev, GFP_KERNEL, context: ts, |
1387 | cont: goodix_config_cb); |
1388 | if (error) { |
1389 | dev_err(&client->dev, |
1390 | "Failed to invoke firmware loader: %d\n" , |
1391 | error); |
1392 | return error; |
1393 | } |
1394 | |
1395 | return 0; |
1396 | } else { |
1397 | error = goodix_configure_dev(ts); |
1398 | if (error) |
1399 | return error; |
1400 | } |
1401 | |
1402 | return 0; |
1403 | } |
1404 | |
1405 | static void goodix_ts_remove(struct i2c_client *client) |
1406 | { |
1407 | struct goodix_ts_data *ts = i2c_get_clientdata(client); |
1408 | |
1409 | if (ts->load_cfg_from_disk) |
1410 | wait_for_completion(&ts->firmware_loading_complete); |
1411 | } |
1412 | |
1413 | static int goodix_suspend(struct device *dev) |
1414 | { |
1415 | struct i2c_client *client = to_i2c_client(dev); |
1416 | struct goodix_ts_data *ts = i2c_get_clientdata(client); |
1417 | int error; |
1418 | |
1419 | if (ts->load_cfg_from_disk) |
1420 | wait_for_completion(&ts->firmware_loading_complete); |
1421 | |
1422 | /* We need gpio pins to suspend/resume */ |
1423 | if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_NONE) { |
1424 | disable_irq(irq: client->irq); |
1425 | return 0; |
1426 | } |
1427 | |
1428 | /* Free IRQ as IRQ pin is used as output in the suspend sequence */ |
1429 | goodix_free_irq(ts); |
1430 | |
1431 | /* Save reference (calibration) info if necessary */ |
1432 | goodix_save_bak_ref(ts); |
1433 | |
1434 | /* Output LOW on the INT pin for 5 ms */ |
1435 | error = goodix_irq_direction_output(ts, value: 0); |
1436 | if (error) { |
1437 | goodix_request_irq(ts); |
1438 | return error; |
1439 | } |
1440 | |
1441 | usleep_range(min: 5000, max: 6000); |
1442 | |
1443 | error = goodix_i2c_write_u8(client: ts->client, GOODIX_REG_COMMAND, |
1444 | GOODIX_CMD_SCREEN_OFF); |
1445 | if (error) { |
1446 | goodix_irq_direction_input(ts); |
1447 | goodix_request_irq(ts); |
1448 | return -EAGAIN; |
1449 | } |
1450 | |
1451 | /* |
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. |
1455 | */ |
1456 | msleep(msecs: 58); |
1457 | return 0; |
1458 | } |
1459 | |
1460 | static int goodix_resume(struct device *dev) |
1461 | { |
1462 | struct i2c_client *client = to_i2c_client(dev); |
1463 | struct goodix_ts_data *ts = i2c_get_clientdata(client); |
1464 | u8 config_ver; |
1465 | int error; |
1466 | |
1467 | if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_NONE) { |
1468 | enable_irq(irq: client->irq); |
1469 | return 0; |
1470 | } |
1471 | |
1472 | /* |
1473 | * Exit sleep mode by outputting HIGH level to INT pin |
1474 | * for 2ms~5ms. |
1475 | */ |
1476 | error = goodix_irq_direction_output(ts, value: 1); |
1477 | if (error) |
1478 | return error; |
1479 | |
1480 | usleep_range(min: 2000, max: 5000); |
1481 | |
1482 | error = goodix_int_sync(ts); |
1483 | if (error) |
1484 | return error; |
1485 | |
1486 | error = goodix_i2c_read(client: ts->client, reg: ts->chip->config_addr, |
1487 | buf: &config_ver, len: 1); |
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]); |
1491 | |
1492 | if (error != 0 || config_ver != ts->config[0]) { |
1493 | error = goodix_reset(ts); |
1494 | if (error) |
1495 | return error; |
1496 | |
1497 | error = goodix_send_cfg(ts, cfg: ts->config, len: ts->chip->config_len); |
1498 | if (error) |
1499 | return error; |
1500 | } |
1501 | |
1502 | error = goodix_request_irq(ts); |
1503 | if (error) |
1504 | return error; |
1505 | |
1506 | return 0; |
1507 | } |
1508 | |
1509 | static DEFINE_SIMPLE_DEV_PM_OPS(goodix_pm_ops, goodix_suspend, goodix_resume); |
1510 | |
1511 | static const struct i2c_device_id goodix_ts_id[] = { |
1512 | { "GDIX1001:00" , 0 }, |
1513 | { } |
1514 | }; |
1515 | MODULE_DEVICE_TABLE(i2c, goodix_ts_id); |
1516 | |
1517 | #ifdef CONFIG_ACPI |
1518 | static const struct acpi_device_id goodix_acpi_match[] = { |
1519 | { "GDIX1001" , 0 }, |
1520 | { "GDIX1002" , 0 }, |
1521 | { "GDX9110" , 0 }, |
1522 | { } |
1523 | }; |
1524 | MODULE_DEVICE_TABLE(acpi, goodix_acpi_match); |
1525 | #endif |
1526 | |
1527 | #ifdef CONFIG_OF |
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" }, |
1543 | { } |
1544 | }; |
1545 | MODULE_DEVICE_TABLE(of, goodix_of_match); |
1546 | #endif |
1547 | |
1548 | static struct i2c_driver goodix_ts_driver = { |
1549 | .probe = goodix_ts_probe, |
1550 | .remove = goodix_ts_remove, |
1551 | .id_table = goodix_ts_id, |
1552 | .driver = { |
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), |
1557 | }, |
1558 | }; |
1559 | module_i2c_driver(goodix_ts_driver); |
1560 | |
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" ); |
1565 | |