Commit | Line | Data |
---|---|---|
42370681 JH |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * ILITEK Touch IC driver for 23XX, 25XX and Lego series | |
4 | * | |
5 | * Copyright (C) 2011 ILI Technology Corporation. | |
6 | * Copyright (C) 2020 Luca Hsu <luca_hsu@ilitek.com> | |
7 | * Copyright (C) 2021 Joe Hung <joe_hung@ilitek.com> | |
8 | */ | |
9 | ||
10 | #include <linux/kernel.h> | |
11 | #include <linux/module.h> | |
12 | #include <linux/input.h> | |
13 | #include <linux/input/mt.h> | |
14 | #include <linux/i2c.h> | |
15 | #include <linux/slab.h> | |
16 | #include <linux/delay.h> | |
17 | #include <linux/interrupt.h> | |
18 | #include <linux/gpio.h> | |
19 | #include <linux/gpio/consumer.h> | |
20 | #include <linux/errno.h> | |
21 | #include <linux/acpi.h> | |
22 | #include <linux/input/touchscreen.h> | |
23 | #include <asm/unaligned.h> | |
24 | ||
25 | ||
26 | #define ILITEK_TS_NAME "ilitek_ts" | |
27 | #define BL_V1_8 0x108 | |
28 | #define BL_V1_7 0x107 | |
29 | #define BL_V1_6 0x106 | |
30 | ||
31 | #define ILITEK_TP_CMD_GET_TP_RES 0x20 | |
32 | #define ILITEK_TP_CMD_GET_SCRN_RES 0x21 | |
33 | #define ILITEK_TP_CMD_SET_IC_SLEEP 0x30 | |
34 | #define ILITEK_TP_CMD_SET_IC_WAKE 0x31 | |
35 | #define ILITEK_TP_CMD_GET_FW_VER 0x40 | |
36 | #define ILITEK_TP_CMD_GET_PRL_VER 0x42 | |
37 | #define ILITEK_TP_CMD_GET_MCU_VER 0x61 | |
38 | #define ILITEK_TP_CMD_GET_IC_MODE 0xC0 | |
39 | ||
40 | #define REPORT_COUNT_ADDRESS 61 | |
41 | #define ILITEK_SUPPORT_MAX_POINT 40 | |
42 | ||
43 | struct ilitek_protocol_info { | |
44 | u16 ver; | |
45 | u8 ver_major; | |
46 | }; | |
47 | ||
48 | struct ilitek_ts_data { | |
49 | struct i2c_client *client; | |
50 | struct gpio_desc *reset_gpio; | |
51 | struct input_dev *input_dev; | |
52 | struct touchscreen_properties prop; | |
53 | ||
54 | const struct ilitek_protocol_map *ptl_cb_func; | |
55 | struct ilitek_protocol_info ptl; | |
56 | ||
57 | char product_id[30]; | |
58 | u16 mcu_ver; | |
59 | u8 ic_mode; | |
60 | u8 firmware_ver[8]; | |
61 | ||
62 | s32 reset_time; | |
63 | s32 screen_max_x; | |
64 | s32 screen_max_y; | |
65 | s32 screen_min_x; | |
66 | s32 screen_min_y; | |
67 | s32 max_tp; | |
68 | }; | |
69 | ||
70 | struct ilitek_protocol_map { | |
71 | u16 cmd; | |
72 | const char *name; | |
73 | int (*func)(struct ilitek_ts_data *ts, u16 cmd, u8 *inbuf, u8 *outbuf); | |
74 | }; | |
75 | ||
76 | enum ilitek_cmds { | |
77 | /* common cmds */ | |
78 | GET_PTL_VER = 0, | |
79 | GET_FW_VER, | |
80 | GET_SCRN_RES, | |
81 | GET_TP_RES, | |
82 | GET_IC_MODE, | |
83 | GET_MCU_VER, | |
84 | SET_IC_SLEEP, | |
85 | SET_IC_WAKE, | |
86 | ||
87 | /* ALWAYS keep at the end */ | |
88 | MAX_CMD_CNT | |
89 | }; | |
90 | ||
91 | /* ILITEK I2C R/W APIs */ | |
92 | static int ilitek_i2c_write_and_read(struct ilitek_ts_data *ts, | |
93 | u8 *cmd, int write_len, int delay, | |
94 | u8 *data, int read_len) | |
95 | { | |
96 | int error; | |
97 | struct i2c_client *client = ts->client; | |
98 | struct i2c_msg msgs[] = { | |
99 | { | |
100 | .addr = client->addr, | |
101 | .flags = 0, | |
102 | .len = write_len, | |
103 | .buf = cmd, | |
104 | }, | |
105 | { | |
106 | .addr = client->addr, | |
107 | .flags = I2C_M_RD, | |
108 | .len = read_len, | |
109 | .buf = data, | |
110 | }, | |
111 | }; | |
112 | ||
113 | if (delay == 0 && write_len > 0 && read_len > 0) { | |
114 | error = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); | |
115 | if (error < 0) | |
116 | return error; | |
117 | } else { | |
118 | if (write_len > 0) { | |
119 | error = i2c_transfer(client->adapter, msgs, 1); | |
120 | if (error < 0) | |
121 | return error; | |
122 | } | |
123 | if (delay > 0) | |
124 | mdelay(delay); | |
125 | ||
126 | if (read_len > 0) { | |
127 | error = i2c_transfer(client->adapter, msgs + 1, 1); | |
128 | if (error < 0) | |
129 | return error; | |
130 | } | |
131 | } | |
132 | ||
133 | return 0; | |
134 | } | |
135 | ||
136 | /* ILITEK ISR APIs */ | |
137 | static void ilitek_touch_down(struct ilitek_ts_data *ts, unsigned int id, | |
138 | unsigned int x, unsigned int y) | |
139 | { | |
140 | struct input_dev *input = ts->input_dev; | |
141 | ||
142 | input_mt_slot(input, id); | |
143 | input_mt_report_slot_state(input, MT_TOOL_FINGER, true); | |
144 | ||
145 | touchscreen_report_pos(input, &ts->prop, x, y, true); | |
146 | } | |
147 | ||
148 | static int ilitek_process_and_report_v6(struct ilitek_ts_data *ts) | |
149 | { | |
150 | int error = 0; | |
151 | u8 buf[512]; | |
152 | int packet_len = 5; | |
153 | int packet_max_point = 10; | |
154 | int report_max_point; | |
155 | int i, count; | |
156 | struct input_dev *input = ts->input_dev; | |
157 | struct device *dev = &ts->client->dev; | |
158 | unsigned int x, y, status, id; | |
159 | ||
160 | error = ilitek_i2c_write_and_read(ts, NULL, 0, 0, buf, 64); | |
161 | if (error) { | |
162 | dev_err(dev, "get touch info failed, err:%d\n", error); | |
163 | goto err_sync_frame; | |
164 | } | |
165 | ||
166 | report_max_point = buf[REPORT_COUNT_ADDRESS]; | |
167 | if (report_max_point > ts->max_tp) { | |
168 | dev_err(dev, "FW report max point:%d > panel info. max:%d\n", | |
169 | report_max_point, ts->max_tp); | |
170 | error = -EINVAL; | |
171 | goto err_sync_frame; | |
172 | } | |
173 | ||
174 | count = DIV_ROUND_UP(report_max_point, packet_max_point); | |
175 | for (i = 1; i < count; i++) { | |
176 | error = ilitek_i2c_write_and_read(ts, NULL, 0, 0, | |
177 | buf + i * 64, 64); | |
178 | if (error) { | |
179 | dev_err(dev, "get touch info. failed, cnt:%d, err:%d\n", | |
180 | count, error); | |
181 | goto err_sync_frame; | |
182 | } | |
183 | } | |
184 | ||
185 | for (i = 0; i < report_max_point; i++) { | |
186 | status = buf[i * packet_len + 1] & 0x40; | |
187 | if (!status) | |
188 | continue; | |
189 | ||
190 | id = buf[i * packet_len + 1] & 0x3F; | |
191 | ||
192 | x = get_unaligned_le16(buf + i * packet_len + 2); | |
193 | y = get_unaligned_le16(buf + i * packet_len + 4); | |
194 | ||
195 | if (x > ts->screen_max_x || x < ts->screen_min_x || | |
196 | y > ts->screen_max_y || y < ts->screen_min_y) { | |
197 | dev_warn(dev, "invalid position, X[%d,%u,%d], Y[%d,%u,%d]\n", | |
198 | ts->screen_min_x, x, ts->screen_max_x, | |
199 | ts->screen_min_y, y, ts->screen_max_y); | |
200 | continue; | |
201 | } | |
202 | ||
203 | ilitek_touch_down(ts, id, x, y); | |
204 | } | |
205 | ||
206 | err_sync_frame: | |
207 | input_mt_sync_frame(input); | |
208 | input_sync(input); | |
209 | return error; | |
210 | } | |
211 | ||
212 | /* APIs of cmds for ILITEK Touch IC */ | |
213 | static int api_protocol_set_cmd(struct ilitek_ts_data *ts, | |
214 | u16 idx, u8 *inbuf, u8 *outbuf) | |
215 | { | |
216 | u16 cmd; | |
217 | int error; | |
218 | ||
219 | if (idx >= MAX_CMD_CNT) | |
220 | return -EINVAL; | |
221 | ||
222 | cmd = ts->ptl_cb_func[idx].cmd; | |
223 | error = ts->ptl_cb_func[idx].func(ts, cmd, inbuf, outbuf); | |
224 | if (error) | |
225 | return error; | |
226 | ||
227 | return 0; | |
228 | } | |
229 | ||
230 | static int api_protocol_get_ptl_ver(struct ilitek_ts_data *ts, | |
231 | u16 cmd, u8 *inbuf, u8 *outbuf) | |
232 | { | |
233 | int error; | |
234 | u8 buf[64]; | |
235 | ||
236 | buf[0] = cmd; | |
237 | error = ilitek_i2c_write_and_read(ts, buf, 1, 5, outbuf, 3); | |
238 | if (error) | |
239 | return error; | |
240 | ||
241 | ts->ptl.ver = get_unaligned_be16(outbuf); | |
242 | ts->ptl.ver_major = outbuf[0]; | |
243 | ||
244 | return 0; | |
245 | } | |
246 | ||
247 | static int api_protocol_get_mcu_ver(struct ilitek_ts_data *ts, | |
248 | u16 cmd, u8 *inbuf, u8 *outbuf) | |
249 | { | |
250 | int error; | |
251 | u8 buf[64]; | |
252 | ||
253 | buf[0] = cmd; | |
254 | error = ilitek_i2c_write_and_read(ts, buf, 1, 5, outbuf, 32); | |
255 | if (error) | |
256 | return error; | |
257 | ||
258 | ts->mcu_ver = get_unaligned_le16(outbuf); | |
259 | memset(ts->product_id, 0, sizeof(ts->product_id)); | |
260 | memcpy(ts->product_id, outbuf + 6, 26); | |
261 | ||
262 | return 0; | |
263 | } | |
264 | ||
265 | static int api_protocol_get_fw_ver(struct ilitek_ts_data *ts, | |
266 | u16 cmd, u8 *inbuf, u8 *outbuf) | |
267 | { | |
268 | int error; | |
269 | u8 buf[64]; | |
270 | ||
271 | buf[0] = cmd; | |
272 | error = ilitek_i2c_write_and_read(ts, buf, 1, 5, outbuf, 8); | |
273 | if (error) | |
274 | return error; | |
275 | ||
276 | memcpy(ts->firmware_ver, outbuf, 8); | |
277 | ||
278 | return 0; | |
279 | } | |
280 | ||
281 | static int api_protocol_get_scrn_res(struct ilitek_ts_data *ts, | |
282 | u16 cmd, u8 *inbuf, u8 *outbuf) | |
283 | { | |
284 | int error; | |
285 | u8 buf[64]; | |
286 | ||
287 | buf[0] = cmd; | |
288 | error = ilitek_i2c_write_and_read(ts, buf, 1, 5, outbuf, 8); | |
289 | if (error) | |
290 | return error; | |
291 | ||
292 | ts->screen_min_x = get_unaligned_le16(outbuf); | |
293 | ts->screen_min_y = get_unaligned_le16(outbuf + 2); | |
294 | ts->screen_max_x = get_unaligned_le16(outbuf + 4); | |
295 | ts->screen_max_y = get_unaligned_le16(outbuf + 6); | |
296 | ||
297 | return 0; | |
298 | } | |
299 | ||
300 | static int api_protocol_get_tp_res(struct ilitek_ts_data *ts, | |
301 | u16 cmd, u8 *inbuf, u8 *outbuf) | |
302 | { | |
303 | int error; | |
304 | u8 buf[64]; | |
305 | ||
306 | buf[0] = cmd; | |
307 | error = ilitek_i2c_write_and_read(ts, buf, 1, 5, outbuf, 15); | |
308 | if (error) | |
309 | return error; | |
310 | ||
311 | ts->max_tp = outbuf[8]; | |
312 | if (ts->max_tp > ILITEK_SUPPORT_MAX_POINT) { | |
313 | dev_err(&ts->client->dev, "Invalid MAX_TP:%d from FW\n", | |
314 | ts->max_tp); | |
315 | return -EINVAL; | |
316 | } | |
317 | ||
318 | return 0; | |
319 | } | |
320 | ||
321 | static int api_protocol_get_ic_mode(struct ilitek_ts_data *ts, | |
322 | u16 cmd, u8 *inbuf, u8 *outbuf) | |
323 | { | |
324 | int error; | |
325 | u8 buf[64]; | |
326 | ||
327 | buf[0] = cmd; | |
328 | error = ilitek_i2c_write_and_read(ts, buf, 1, 5, outbuf, 2); | |
329 | if (error) | |
330 | return error; | |
331 | ||
332 | ts->ic_mode = outbuf[0]; | |
333 | return 0; | |
334 | } | |
335 | ||
336 | static int api_protocol_set_ic_sleep(struct ilitek_ts_data *ts, | |
337 | u16 cmd, u8 *inbuf, u8 *outbuf) | |
338 | { | |
339 | u8 buf[64]; | |
340 | ||
341 | buf[0] = cmd; | |
342 | return ilitek_i2c_write_and_read(ts, buf, 1, 0, NULL, 0); | |
343 | } | |
344 | ||
345 | static int api_protocol_set_ic_wake(struct ilitek_ts_data *ts, | |
346 | u16 cmd, u8 *inbuf, u8 *outbuf) | |
347 | { | |
348 | u8 buf[64]; | |
349 | ||
350 | buf[0] = cmd; | |
351 | return ilitek_i2c_write_and_read(ts, buf, 1, 0, NULL, 0); | |
352 | } | |
353 | ||
354 | static const struct ilitek_protocol_map ptl_func_map[] = { | |
355 | /* common cmds */ | |
356 | [GET_PTL_VER] = { | |
357 | ILITEK_TP_CMD_GET_PRL_VER, "GET_PTL_VER", | |
358 | api_protocol_get_ptl_ver | |
359 | }, | |
360 | [GET_FW_VER] = { | |
361 | ILITEK_TP_CMD_GET_FW_VER, "GET_FW_VER", | |
362 | api_protocol_get_fw_ver | |
363 | }, | |
364 | [GET_SCRN_RES] = { | |
365 | ILITEK_TP_CMD_GET_SCRN_RES, "GET_SCRN_RES", | |
366 | api_protocol_get_scrn_res | |
367 | }, | |
368 | [GET_TP_RES] = { | |
369 | ILITEK_TP_CMD_GET_TP_RES, "GET_TP_RES", | |
370 | api_protocol_get_tp_res | |
371 | }, | |
372 | [GET_IC_MODE] = { | |
373 | ILITEK_TP_CMD_GET_IC_MODE, "GET_IC_MODE", | |
374 | api_protocol_get_ic_mode | |
375 | }, | |
376 | [GET_MCU_VER] = { | |
377 | ILITEK_TP_CMD_GET_MCU_VER, "GET_MOD_VER", | |
378 | api_protocol_get_mcu_ver | |
379 | }, | |
380 | [SET_IC_SLEEP] = { | |
381 | ILITEK_TP_CMD_SET_IC_SLEEP, "SET_IC_SLEEP", | |
382 | api_protocol_set_ic_sleep | |
383 | }, | |
384 | [SET_IC_WAKE] = { | |
385 | ILITEK_TP_CMD_SET_IC_WAKE, "SET_IC_WAKE", | |
386 | api_protocol_set_ic_wake | |
387 | }, | |
388 | }; | |
389 | ||
390 | /* Probe APIs */ | |
391 | static void ilitek_reset(struct ilitek_ts_data *ts, int delay) | |
392 | { | |
393 | if (ts->reset_gpio) { | |
394 | gpiod_set_value(ts->reset_gpio, 1); | |
395 | mdelay(10); | |
396 | gpiod_set_value(ts->reset_gpio, 0); | |
397 | mdelay(delay); | |
398 | } | |
399 | } | |
400 | ||
401 | static int ilitek_protocol_init(struct ilitek_ts_data *ts) | |
402 | { | |
403 | int error; | |
404 | u8 outbuf[64]; | |
405 | ||
406 | ts->ptl_cb_func = ptl_func_map; | |
407 | ts->reset_time = 600; | |
408 | ||
409 | error = api_protocol_set_cmd(ts, GET_PTL_VER, NULL, outbuf); | |
410 | if (error) | |
411 | return error; | |
412 | ||
413 | /* Protocol v3 is not support currently */ | |
414 | if (ts->ptl.ver_major == 0x3 || | |
415 | ts->ptl.ver == BL_V1_6 || | |
416 | ts->ptl.ver == BL_V1_7) | |
417 | return -EINVAL; | |
418 | ||
419 | return 0; | |
420 | } | |
421 | ||
422 | static int ilitek_read_tp_info(struct ilitek_ts_data *ts, bool boot) | |
423 | { | |
424 | u8 outbuf[256]; | |
425 | int error; | |
426 | ||
427 | error = api_protocol_set_cmd(ts, GET_PTL_VER, NULL, outbuf); | |
428 | if (error) | |
429 | return error; | |
430 | ||
431 | error = api_protocol_set_cmd(ts, GET_MCU_VER, NULL, outbuf); | |
432 | if (error) | |
433 | return error; | |
434 | ||
435 | error = api_protocol_set_cmd(ts, GET_FW_VER, NULL, outbuf); | |
436 | if (error) | |
437 | return error; | |
438 | ||
439 | if (boot) { | |
440 | error = api_protocol_set_cmd(ts, GET_SCRN_RES, NULL, | |
441 | outbuf); | |
442 | if (error) | |
443 | return error; | |
444 | } | |
445 | ||
446 | error = api_protocol_set_cmd(ts, GET_TP_RES, NULL, outbuf); | |
447 | if (error) | |
448 | return error; | |
449 | ||
450 | error = api_protocol_set_cmd(ts, GET_IC_MODE, NULL, outbuf); | |
451 | if (error) | |
452 | return error; | |
453 | ||
454 | return 0; | |
455 | } | |
456 | ||
457 | static int ilitek_input_dev_init(struct device *dev, struct ilitek_ts_data *ts) | |
458 | { | |
459 | int error; | |
460 | struct input_dev *input; | |
461 | ||
462 | input = devm_input_allocate_device(dev); | |
463 | if (!input) | |
464 | return -ENOMEM; | |
465 | ||
466 | ts->input_dev = input; | |
467 | input->name = ILITEK_TS_NAME; | |
468 | input->id.bustype = BUS_I2C; | |
469 | ||
470 | __set_bit(INPUT_PROP_DIRECT, input->propbit); | |
471 | ||
472 | input_set_abs_params(input, ABS_MT_POSITION_X, | |
473 | ts->screen_min_x, ts->screen_max_x, 0, 0); | |
474 | input_set_abs_params(input, ABS_MT_POSITION_Y, | |
475 | ts->screen_min_y, ts->screen_max_y, 0, 0); | |
476 | ||
477 | touchscreen_parse_properties(input, true, &ts->prop); | |
478 | ||
479 | error = input_mt_init_slots(input, ts->max_tp, | |
480 | INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); | |
481 | if (error) { | |
482 | dev_err(dev, "initialize MT slots failed, err:%d\n", error); | |
483 | return error; | |
484 | } | |
485 | ||
486 | error = input_register_device(input); | |
487 | if (error) { | |
488 | dev_err(dev, "register input device failed, err:%d\n", error); | |
489 | return error; | |
490 | } | |
491 | ||
492 | return 0; | |
493 | } | |
494 | ||
495 | static irqreturn_t ilitek_i2c_isr(int irq, void *dev_id) | |
496 | { | |
497 | struct ilitek_ts_data *ts = dev_id; | |
498 | int error; | |
499 | ||
500 | error = ilitek_process_and_report_v6(ts); | |
501 | if (error < 0) { | |
502 | dev_err(&ts->client->dev, "[%s] err:%d\n", __func__, error); | |
503 | return IRQ_NONE; | |
504 | } | |
505 | ||
506 | return IRQ_HANDLED; | |
507 | } | |
508 | ||
509 | static ssize_t firmware_version_show(struct device *dev, | |
510 | struct device_attribute *attr, char *buf) | |
511 | { | |
512 | struct i2c_client *client = to_i2c_client(dev); | |
513 | struct ilitek_ts_data *ts = i2c_get_clientdata(client); | |
514 | ||
e50389f2 | 515 | return sysfs_emit(buf, |
516 | "fw version: [%02X%02X.%02X%02X.%02X%02X.%02X%02X]\n", | |
517 | ts->firmware_ver[0], ts->firmware_ver[1], | |
518 | ts->firmware_ver[2], ts->firmware_ver[3], | |
519 | ts->firmware_ver[4], ts->firmware_ver[5], | |
520 | ts->firmware_ver[6], ts->firmware_ver[7]); | |
42370681 JH |
521 | } |
522 | static DEVICE_ATTR_RO(firmware_version); | |
523 | ||
524 | static ssize_t product_id_show(struct device *dev, | |
525 | struct device_attribute *attr, char *buf) | |
526 | { | |
527 | struct i2c_client *client = to_i2c_client(dev); | |
528 | struct ilitek_ts_data *ts = i2c_get_clientdata(client); | |
529 | ||
e50389f2 | 530 | return sysfs_emit(buf, "product id: [%04X], module: [%s]\n", |
531 | ts->mcu_ver, ts->product_id); | |
42370681 JH |
532 | } |
533 | static DEVICE_ATTR_RO(product_id); | |
534 | ||
535 | static struct attribute *ilitek_sysfs_attrs[] = { | |
536 | &dev_attr_firmware_version.attr, | |
537 | &dev_attr_product_id.attr, | |
538 | NULL | |
539 | }; | |
e6ed1bf9 | 540 | ATTRIBUTE_GROUPS(ilitek_sysfs); |
42370681 | 541 | |
19a28e79 | 542 | static int ilitek_ts_i2c_probe(struct i2c_client *client) |
42370681 JH |
543 | { |
544 | struct ilitek_ts_data *ts; | |
545 | struct device *dev = &client->dev; | |
546 | int error; | |
547 | ||
548 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { | |
549 | dev_err(dev, "i2c check functionality failed\n"); | |
550 | return -ENXIO; | |
551 | } | |
552 | ||
553 | ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL); | |
554 | if (!ts) | |
555 | return -ENOMEM; | |
556 | ||
557 | ts->client = client; | |
558 | i2c_set_clientdata(client, ts); | |
559 | ||
560 | ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW); | |
561 | if (IS_ERR(ts->reset_gpio)) { | |
562 | error = PTR_ERR(ts->reset_gpio); | |
563 | dev_err(dev, "request gpiod failed: %d", error); | |
564 | return error; | |
565 | } | |
566 | ||
567 | ilitek_reset(ts, 1000); | |
568 | ||
569 | error = ilitek_protocol_init(ts); | |
570 | if (error) { | |
571 | dev_err(dev, "protocol init failed: %d", error); | |
572 | return error; | |
573 | } | |
574 | ||
575 | error = ilitek_read_tp_info(ts, true); | |
576 | if (error) { | |
577 | dev_err(dev, "read tp info failed: %d", error); | |
578 | return error; | |
579 | } | |
580 | ||
581 | error = ilitek_input_dev_init(dev, ts); | |
582 | if (error) { | |
583 | dev_err(dev, "input dev init failed: %d", error); | |
584 | return error; | |
585 | } | |
586 | ||
587 | error = devm_request_threaded_irq(dev, ts->client->irq, | |
588 | NULL, ilitek_i2c_isr, IRQF_ONESHOT, | |
589 | "ilitek_touch_irq", ts); | |
590 | if (error) { | |
591 | dev_err(dev, "request threaded irq failed: %d\n", error); | |
592 | return error; | |
593 | } | |
594 | ||
42370681 JH |
595 | return 0; |
596 | } | |
597 | ||
4024f848 | 598 | static int ilitek_suspend(struct device *dev) |
42370681 JH |
599 | { |
600 | struct i2c_client *client = to_i2c_client(dev); | |
601 | struct ilitek_ts_data *ts = i2c_get_clientdata(client); | |
602 | int error; | |
603 | ||
604 | disable_irq(client->irq); | |
605 | ||
606 | if (!device_may_wakeup(dev)) { | |
607 | error = api_protocol_set_cmd(ts, SET_IC_SLEEP, NULL, NULL); | |
608 | if (error) | |
609 | return error; | |
610 | } | |
611 | ||
612 | return 0; | |
613 | } | |
614 | ||
4024f848 | 615 | static int ilitek_resume(struct device *dev) |
42370681 JH |
616 | { |
617 | struct i2c_client *client = to_i2c_client(dev); | |
618 | struct ilitek_ts_data *ts = i2c_get_clientdata(client); | |
619 | int error; | |
620 | ||
621 | if (!device_may_wakeup(dev)) { | |
622 | error = api_protocol_set_cmd(ts, SET_IC_WAKE, NULL, NULL); | |
623 | if (error) | |
624 | return error; | |
625 | ||
626 | ilitek_reset(ts, ts->reset_time); | |
627 | } | |
628 | ||
629 | enable_irq(client->irq); | |
630 | ||
631 | return 0; | |
632 | } | |
633 | ||
4024f848 | 634 | static DEFINE_SIMPLE_DEV_PM_OPS(ilitek_pm_ops, ilitek_suspend, ilitek_resume); |
42370681 JH |
635 | |
636 | static const struct i2c_device_id ilitek_ts_i2c_id[] = { | |
5852f2af UKK |
637 | { ILITEK_TS_NAME }, |
638 | { } | |
42370681 JH |
639 | }; |
640 | MODULE_DEVICE_TABLE(i2c, ilitek_ts_i2c_id); | |
641 | ||
642 | #ifdef CONFIG_ACPI | |
643 | static const struct acpi_device_id ilitekts_acpi_id[] = { | |
644 | { "ILTK0001", 0 }, | |
645 | { }, | |
646 | }; | |
647 | MODULE_DEVICE_TABLE(acpi, ilitekts_acpi_id); | |
648 | #endif | |
649 | ||
650 | #ifdef CONFIG_OF | |
651 | static const struct of_device_id ilitek_ts_i2c_match[] = { | |
652 | {.compatible = "ilitek,ili2130",}, | |
653 | {.compatible = "ilitek,ili2131",}, | |
654 | {.compatible = "ilitek,ili2132",}, | |
655 | {.compatible = "ilitek,ili2316",}, | |
656 | {.compatible = "ilitek,ili2322",}, | |
657 | {.compatible = "ilitek,ili2323",}, | |
658 | {.compatible = "ilitek,ili2326",}, | |
659 | {.compatible = "ilitek,ili2520",}, | |
660 | {.compatible = "ilitek,ili2521",}, | |
661 | { }, | |
662 | }; | |
663 | MODULE_DEVICE_TABLE(of, ilitek_ts_i2c_match); | |
664 | #endif | |
665 | ||
666 | static struct i2c_driver ilitek_ts_i2c_driver = { | |
667 | .driver = { | |
668 | .name = ILITEK_TS_NAME, | |
e6ed1bf9 | 669 | .dev_groups = ilitek_sysfs_groups, |
4024f848 | 670 | .pm = pm_sleep_ptr(&ilitek_pm_ops), |
42370681 JH |
671 | .of_match_table = of_match_ptr(ilitek_ts_i2c_match), |
672 | .acpi_match_table = ACPI_PTR(ilitekts_acpi_id), | |
673 | }, | |
d8bde56d | 674 | .probe = ilitek_ts_i2c_probe, |
42370681 JH |
675 | .id_table = ilitek_ts_i2c_id, |
676 | }; | |
677 | module_i2c_driver(ilitek_ts_i2c_driver); | |
678 | ||
679 | MODULE_AUTHOR("ILITEK"); | |
680 | MODULE_DESCRIPTION("ILITEK I2C Touchscreen Driver"); | |
681 | MODULE_LICENSE("GPL"); |