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