1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Elan Microelectronics touch panels with I2C interface
4 *
5 * Copyright (C) 2014 Elan Microelectronics Corporation.
6 * Scott Liu <scott.liu@emc.com.tw>
7 *
8 * This code is partly based on hid-multitouch.c:
9 *
10 * Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
11 * Copyright (c) 2010-2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
12 * Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France
13 *
14 * This code is partly based on i2c-hid.c:
15 *
16 * Copyright (c) 2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
17 * Copyright (c) 2012 Ecole Nationale de l'Aviation Civile, France
18 * Copyright (c) 2012 Red Hat, Inc
19 */
20
21
22 #include <linux/module.h>
23 #include <linux/input.h>
24 #include <linux/interrupt.h>
25 #include <linux/irq.h>
26 #include <linux/platform_device.h>
27 #include <linux/async.h>
28 #include <linux/i2c.h>
29 #include <linux/delay.h>
30 #include <linux/uaccess.h>
31 #include <linux/buffer_head.h>
32 #include <linux/slab.h>
33 #include <linux/firmware.h>
34 #include <linux/input/mt.h>
35 #include <linux/acpi.h>
36 #include <linux/of.h>
37 #include <linux/gpio/consumer.h>
38 #include <linux/regulator/consumer.h>
39 #include <linux/uuid.h>
40 #include <asm/unaligned.h>
41
42 /* Device, Driver information */
43 #define DEVICE_NAME "elants_i2c"
44
45 /* Convert from rows or columns into resolution */
46 #define ELAN_TS_RESOLUTION(n, m) (((n) - 1) * (m))
47
48 /* FW header data */
49 #define HEADER_SIZE 4
50 #define FW_HDR_TYPE 0
51 #define FW_HDR_COUNT 1
52 #define FW_HDR_LENGTH 2
53
54 /* Buffer mode Queue Header information */
55 #define QUEUE_HEADER_SINGLE 0x62
56 #define QUEUE_HEADER_NORMAL 0X63
57 #define QUEUE_HEADER_WAIT 0x64
58
59 /* Command header definition */
60 #define CMD_HEADER_WRITE 0x54
61 #define CMD_HEADER_READ 0x53
62 #define CMD_HEADER_6B_READ 0x5B
63 #define CMD_HEADER_RESP 0x52
64 #define CMD_HEADER_6B_RESP 0x9B
65 #define CMD_HEADER_HELLO 0x55
66 #define CMD_HEADER_REK 0x66
67
68 /* FW position data */
69 #define PACKET_SIZE 55
70 #define MAX_CONTACT_NUM 10
71 #define FW_POS_HEADER 0
72 #define FW_POS_STATE 1
73 #define FW_POS_TOTAL 2
74 #define FW_POS_XY 3
75 #define FW_POS_CHECKSUM 34
76 #define FW_POS_WIDTH 35
77 #define FW_POS_PRESSURE 45
78
79 #define HEADER_REPORT_10_FINGER 0x62
80
81 /* Header (4 bytes) plus 3 fill 10-finger packets */
82 #define MAX_PACKET_SIZE 169
83
84 #define BOOT_TIME_DELAY_MS 50
85
86 /* FW read command, 0x53 0x?? 0x0, 0x01 */
87 #define E_ELAN_INFO_FW_VER 0x00
88 #define E_ELAN_INFO_BC_VER 0x10
89 #define E_ELAN_INFO_TEST_VER 0xE0
90 #define E_ELAN_INFO_FW_ID 0xF0
91 #define E_INFO_OSR 0xD6
92 #define E_INFO_PHY_SCAN 0xD7
93 #define E_INFO_PHY_DRIVER 0xD8
94
95 #define MAX_RETRIES 3
96 #define MAX_FW_UPDATE_RETRIES 30
97
98 #define ELAN_FW_PAGESIZE 132
99
100 /* calibration timeout definition */
101 #define ELAN_CALI_TIMEOUT_MSEC 12000
102
103 #define ELAN_POWERON_DELAY_USEC 500
104 #define ELAN_RESET_DELAY_MSEC 20
105
106 enum elants_state {
107 ELAN_STATE_NORMAL,
108 ELAN_WAIT_QUEUE_HEADER,
109 ELAN_WAIT_RECALIBRATION,
110 };
111
112 enum elants_iap_mode {
113 ELAN_IAP_OPERATIONAL,
114 ELAN_IAP_RECOVERY,
115 };
116
117 /* struct elants_data - represents state of Elan touchscreen device */
118 struct elants_data {
119 struct i2c_client *client;
120 struct input_dev *input;
121
122 struct regulator *vcc33;
123 struct regulator *vccio;
124 struct gpio_desc *reset_gpio;
125
126 u16 fw_version;
127 u8 test_version;
128 u8 solution_version;
129 u8 bc_version;
130 u8 iap_version;
131 u16 hw_version;
132 unsigned int x_res; /* resolution in units/mm */
133 unsigned int y_res;
134 unsigned int x_max;
135 unsigned int y_max;
136
137 enum elants_state state;
138 enum elants_iap_mode iap_mode;
139
140 /* Guards against concurrent access to the device via sysfs */
141 struct mutex sysfs_mutex;
142
143 u8 cmd_resp[HEADER_SIZE];
144 struct completion cmd_done;
145
146 bool wake_irq_enabled;
147 bool keep_power_in_suspend;
148
149 /* Must be last to be used for DMA operations */
150 u8 buf[MAX_PACKET_SIZE] ____cacheline_aligned;
151 };
152
elants_i2c_send(struct i2c_client * client,const void * data,size_t size)153 static int elants_i2c_send(struct i2c_client *client,
154 const void *data, size_t size)
155 {
156 int ret;
157
158 ret = i2c_master_send(client, data, size);
159 if (ret == size)
160 return 0;
161
162 if (ret >= 0)
163 ret = -EIO;
164
165 dev_err(&client->dev, "%s failed (%*ph): %d\n",
166 __func__, (int)size, data, ret);
167
168 return ret;
169 }
170
elants_i2c_read(struct i2c_client * client,void * data,size_t size)171 static int elants_i2c_read(struct i2c_client *client, void *data, size_t size)
172 {
173 int ret;
174
175 ret = i2c_master_recv(client, data, size);
176 if (ret == size)
177 return 0;
178
179 if (ret >= 0)
180 ret = -EIO;
181
182 dev_err(&client->dev, "%s failed: %d\n", __func__, ret);
183
184 return ret;
185 }
186
elants_i2c_execute_command(struct i2c_client * client,const u8 * cmd,size_t cmd_size,u8 * resp,size_t resp_size)187 static int elants_i2c_execute_command(struct i2c_client *client,
188 const u8 *cmd, size_t cmd_size,
189 u8 *resp, size_t resp_size)
190 {
191 struct i2c_msg msgs[2];
192 int ret;
193 u8 expected_response;
194
195 switch (cmd[0]) {
196 case CMD_HEADER_READ:
197 expected_response = CMD_HEADER_RESP;
198 break;
199
200 case CMD_HEADER_6B_READ:
201 expected_response = CMD_HEADER_6B_RESP;
202 break;
203
204 default:
205 dev_err(&client->dev, "%s: invalid command %*ph\n",
206 __func__, (int)cmd_size, cmd);
207 return -EINVAL;
208 }
209
210 msgs[0].addr = client->addr;
211 msgs[0].flags = client->flags & I2C_M_TEN;
212 msgs[0].len = cmd_size;
213 msgs[0].buf = (u8 *)cmd;
214
215 msgs[1].addr = client->addr;
216 msgs[1].flags = client->flags & I2C_M_TEN;
217 msgs[1].flags |= I2C_M_RD;
218 msgs[1].len = resp_size;
219 msgs[1].buf = resp;
220
221 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
222 if (ret < 0)
223 return ret;
224
225 if (ret != ARRAY_SIZE(msgs) || resp[FW_HDR_TYPE] != expected_response)
226 return -EIO;
227
228 return 0;
229 }
230
elants_i2c_calibrate(struct elants_data * ts)231 static int elants_i2c_calibrate(struct elants_data *ts)
232 {
233 struct i2c_client *client = ts->client;
234 int ret, error;
235 static const u8 w_flashkey[] = { 0x54, 0xC0, 0xE1, 0x5A };
236 static const u8 rek[] = { 0x54, 0x29, 0x00, 0x01 };
237 static const u8 rek_resp[] = { CMD_HEADER_REK, 0x66, 0x66, 0x66 };
238
239 disable_irq(client->irq);
240
241 ts->state = ELAN_WAIT_RECALIBRATION;
242 reinit_completion(&ts->cmd_done);
243
244 elants_i2c_send(client, w_flashkey, sizeof(w_flashkey));
245 elants_i2c_send(client, rek, sizeof(rek));
246
247 enable_irq(client->irq);
248
249 ret = wait_for_completion_interruptible_timeout(&ts->cmd_done,
250 msecs_to_jiffies(ELAN_CALI_TIMEOUT_MSEC));
251
252 ts->state = ELAN_STATE_NORMAL;
253
254 if (ret <= 0) {
255 error = ret < 0 ? ret : -ETIMEDOUT;
256 dev_err(&client->dev,
257 "error while waiting for calibration to complete: %d\n",
258 error);
259 return error;
260 }
261
262 if (memcmp(rek_resp, ts->cmd_resp, sizeof(rek_resp))) {
263 dev_err(&client->dev,
264 "unexpected calibration response: %*ph\n",
265 (int)sizeof(ts->cmd_resp), ts->cmd_resp);
266 return -EINVAL;
267 }
268
269 return 0;
270 }
271
elants_i2c_sw_reset(struct i2c_client * client)272 static int elants_i2c_sw_reset(struct i2c_client *client)
273 {
274 const u8 soft_rst_cmd[] = { 0x77, 0x77, 0x77, 0x77 };
275 int error;
276
277 error = elants_i2c_send(client, soft_rst_cmd,
278 sizeof(soft_rst_cmd));
279 if (error) {
280 dev_err(&client->dev, "software reset failed: %d\n", error);
281 return error;
282 }
283
284 /*
285 * We should wait at least 10 msec (but no more than 40) before
286 * sending fastboot or IAP command to the device.
287 */
288 msleep(30);
289
290 return 0;
291 }
292
elants_i2c_parse_version(u8 * buf)293 static u16 elants_i2c_parse_version(u8 *buf)
294 {
295 return get_unaligned_be32(buf) >> 4;
296 }
297
elants_i2c_query_hw_version(struct elants_data * ts)298 static int elants_i2c_query_hw_version(struct elants_data *ts)
299 {
300 struct i2c_client *client = ts->client;
301 int error, retry_cnt;
302 const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_FW_ID, 0x00, 0x01 };
303 u8 resp[HEADER_SIZE];
304
305 for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
306 error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
307 resp, sizeof(resp));
308 if (!error) {
309 ts->hw_version = elants_i2c_parse_version(resp);
310 if (ts->hw_version != 0xffff)
311 return 0;
312 }
313
314 dev_dbg(&client->dev, "read fw id error=%d, buf=%*phC\n",
315 error, (int)sizeof(resp), resp);
316 }
317
318 if (error) {
319 dev_err(&client->dev,
320 "Failed to read fw id: %d\n", error);
321 return error;
322 }
323
324 dev_err(&client->dev, "Invalid fw id: %#04x\n", ts->hw_version);
325
326 return -EINVAL;
327 }
328
elants_i2c_query_fw_version(struct elants_data * ts)329 static int elants_i2c_query_fw_version(struct elants_data *ts)
330 {
331 struct i2c_client *client = ts->client;
332 int error, retry_cnt;
333 const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_FW_VER, 0x00, 0x01 };
334 u8 resp[HEADER_SIZE];
335
336 for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
337 error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
338 resp, sizeof(resp));
339 if (!error) {
340 ts->fw_version = elants_i2c_parse_version(resp);
341 if (ts->fw_version != 0x0000 &&
342 ts->fw_version != 0xffff)
343 return 0;
344 }
345
346 dev_dbg(&client->dev, "read fw version error=%d, buf=%*phC\n",
347 error, (int)sizeof(resp), resp);
348 }
349
350 dev_err(&client->dev,
351 "Failed to read fw version or fw version is invalid\n");
352
353 return -EINVAL;
354 }
355
elants_i2c_query_test_version(struct elants_data * ts)356 static int elants_i2c_query_test_version(struct elants_data *ts)
357 {
358 struct i2c_client *client = ts->client;
359 int error, retry_cnt;
360 u16 version;
361 const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_TEST_VER, 0x00, 0x01 };
362 u8 resp[HEADER_SIZE];
363
364 for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
365 error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
366 resp, sizeof(resp));
367 if (!error) {
368 version = elants_i2c_parse_version(resp);
369 ts->test_version = version >> 8;
370 ts->solution_version = version & 0xff;
371
372 return 0;
373 }
374
375 dev_dbg(&client->dev,
376 "read test version error rc=%d, buf=%*phC\n",
377 error, (int)sizeof(resp), resp);
378 }
379
380 dev_err(&client->dev, "Failed to read test version\n");
381
382 return -EINVAL;
383 }
384
elants_i2c_query_bc_version(struct elants_data * ts)385 static int elants_i2c_query_bc_version(struct elants_data *ts)
386 {
387 struct i2c_client *client = ts->client;
388 const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_BC_VER, 0x00, 0x01 };
389 u8 resp[HEADER_SIZE];
390 u16 version;
391 int error;
392
393 error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
394 resp, sizeof(resp));
395 if (error) {
396 dev_err(&client->dev,
397 "read BC version error=%d, buf=%*phC\n",
398 error, (int)sizeof(resp), resp);
399 return error;
400 }
401
402 version = elants_i2c_parse_version(resp);
403 ts->bc_version = version >> 8;
404 ts->iap_version = version & 0xff;
405
406 return 0;
407 }
408
elants_i2c_query_ts_info(struct elants_data * ts)409 static int elants_i2c_query_ts_info(struct elants_data *ts)
410 {
411 struct i2c_client *client = ts->client;
412 int error;
413 u8 resp[17];
414 u16 phy_x, phy_y, rows, cols, osr;
415 const u8 get_resolution_cmd[] = {
416 CMD_HEADER_6B_READ, 0x00, 0x00, 0x00, 0x00, 0x00
417 };
418 const u8 get_osr_cmd[] = {
419 CMD_HEADER_READ, E_INFO_OSR, 0x00, 0x01
420 };
421 const u8 get_physical_scan_cmd[] = {
422 CMD_HEADER_READ, E_INFO_PHY_SCAN, 0x00, 0x01
423 };
424 const u8 get_physical_drive_cmd[] = {
425 CMD_HEADER_READ, E_INFO_PHY_DRIVER, 0x00, 0x01
426 };
427
428 /* Get trace number */
429 error = elants_i2c_execute_command(client,
430 get_resolution_cmd,
431 sizeof(get_resolution_cmd),
432 resp, sizeof(resp));
433 if (error) {
434 dev_err(&client->dev, "get resolution command failed: %d\n",
435 error);
436 return error;
437 }
438
439 rows = resp[2] + resp[6] + resp[10];
440 cols = resp[3] + resp[7] + resp[11];
441
442 /* Process mm_to_pixel information */
443 error = elants_i2c_execute_command(client,
444 get_osr_cmd, sizeof(get_osr_cmd),
445 resp, sizeof(resp));
446 if (error) {
447 dev_err(&client->dev, "get osr command failed: %d\n",
448 error);
449 return error;
450 }
451
452 osr = resp[3];
453
454 error = elants_i2c_execute_command(client,
455 get_physical_scan_cmd,
456 sizeof(get_physical_scan_cmd),
457 resp, sizeof(resp));
458 if (error) {
459 dev_err(&client->dev, "get physical scan command failed: %d\n",
460 error);
461 return error;
462 }
463
464 phy_x = get_unaligned_be16(&resp[2]);
465
466 error = elants_i2c_execute_command(client,
467 get_physical_drive_cmd,
468 sizeof(get_physical_drive_cmd),
469 resp, sizeof(resp));
470 if (error) {
471 dev_err(&client->dev, "get physical drive command failed: %d\n",
472 error);
473 return error;
474 }
475
476 phy_y = get_unaligned_be16(&resp[2]);
477
478 dev_dbg(&client->dev, "phy_x=%d, phy_y=%d\n", phy_x, phy_y);
479
480 if (rows == 0 || cols == 0 || osr == 0) {
481 dev_warn(&client->dev,
482 "invalid trace number data: %d, %d, %d\n",
483 rows, cols, osr);
484 } else {
485 /* translate trace number to TS resolution */
486 ts->x_max = ELAN_TS_RESOLUTION(rows, osr);
487 ts->x_res = DIV_ROUND_CLOSEST(ts->x_max, phy_x);
488 ts->y_max = ELAN_TS_RESOLUTION(cols, osr);
489 ts->y_res = DIV_ROUND_CLOSEST(ts->y_max, phy_y);
490 }
491
492 return 0;
493 }
494
elants_i2c_fastboot(struct i2c_client * client)495 static int elants_i2c_fastboot(struct i2c_client *client)
496 {
497 const u8 boot_cmd[] = { 0x4D, 0x61, 0x69, 0x6E };
498 int error;
499
500 error = elants_i2c_send(client, boot_cmd, sizeof(boot_cmd));
501 if (error) {
502 dev_err(&client->dev, "boot failed: %d\n", error);
503 return error;
504 }
505
506 dev_dbg(&client->dev, "boot success -- 0x%x\n", client->addr);
507 return 0;
508 }
509
elants_i2c_initialize(struct elants_data * ts)510 static int elants_i2c_initialize(struct elants_data *ts)
511 {
512 struct i2c_client *client = ts->client;
513 int error, error2, retry_cnt;
514 const u8 hello_packet[] = { 0x55, 0x55, 0x55, 0x55 };
515 const u8 recov_packet[] = { 0x55, 0x55, 0x80, 0x80 };
516 u8 buf[HEADER_SIZE];
517
518 for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
519 error = elants_i2c_sw_reset(client);
520 if (error) {
521 /* Continue initializing if it's the last try */
522 if (retry_cnt < MAX_RETRIES - 1)
523 continue;
524 }
525
526 error = elants_i2c_fastboot(client);
527 if (error) {
528 /* Continue initializing if it's the last try */
529 if (retry_cnt < MAX_RETRIES - 1)
530 continue;
531 }
532
533 /* Wait for Hello packet */
534 msleep(BOOT_TIME_DELAY_MS);
535
536 error = elants_i2c_read(client, buf, sizeof(buf));
537 if (error) {
538 dev_err(&client->dev,
539 "failed to read 'hello' packet: %d\n", error);
540 } else if (!memcmp(buf, hello_packet, sizeof(hello_packet))) {
541 ts->iap_mode = ELAN_IAP_OPERATIONAL;
542 break;
543 } else if (!memcmp(buf, recov_packet, sizeof(recov_packet))) {
544 /*
545 * Setting error code will mark device
546 * in recovery mode below.
547 */
548 error = -EIO;
549 break;
550 } else {
551 error = -EINVAL;
552 dev_err(&client->dev,
553 "invalid 'hello' packet: %*ph\n",
554 (int)sizeof(buf), buf);
555 }
556 }
557
558 /* hw version is available even if device in recovery state */
559 error2 = elants_i2c_query_hw_version(ts);
560 if (!error)
561 error = error2;
562
563 if (!error)
564 error = elants_i2c_query_fw_version(ts);
565 if (!error)
566 error = elants_i2c_query_test_version(ts);
567 if (!error)
568 error = elants_i2c_query_bc_version(ts);
569 if (!error)
570 error = elants_i2c_query_ts_info(ts);
571
572 if (error)
573 ts->iap_mode = ELAN_IAP_RECOVERY;
574
575 return 0;
576 }
577
578 /*
579 * Firmware update interface.
580 */
581
elants_i2c_fw_write_page(struct i2c_client * client,const void * page)582 static int elants_i2c_fw_write_page(struct i2c_client *client,
583 const void *page)
584 {
585 const u8 ack_ok[] = { 0xaa, 0xaa };
586 u8 buf[2];
587 int retry;
588 int error;
589
590 for (retry = 0; retry < MAX_FW_UPDATE_RETRIES; retry++) {
591 error = elants_i2c_send(client, page, ELAN_FW_PAGESIZE);
592 if (error) {
593 dev_err(&client->dev,
594 "IAP Write Page failed: %d\n", error);
595 continue;
596 }
597
598 error = elants_i2c_read(client, buf, 2);
599 if (error) {
600 dev_err(&client->dev,
601 "IAP Ack read failed: %d\n", error);
602 return error;
603 }
604
605 if (!memcmp(buf, ack_ok, sizeof(ack_ok)))
606 return 0;
607
608 error = -EIO;
609 dev_err(&client->dev,
610 "IAP Get Ack Error [%02x:%02x]\n",
611 buf[0], buf[1]);
612 }
613
614 return error;
615 }
616
elants_i2c_do_update_firmware(struct i2c_client * client,const struct firmware * fw,bool force)617 static int elants_i2c_do_update_firmware(struct i2c_client *client,
618 const struct firmware *fw,
619 bool force)
620 {
621 const u8 enter_iap[] = { 0x45, 0x49, 0x41, 0x50 };
622 const u8 enter_iap2[] = { 0x54, 0x00, 0x12, 0x34 };
623 const u8 iap_ack[] = { 0x55, 0xaa, 0x33, 0xcc };
624 const u8 close_idle[] = {0x54, 0x2c, 0x01, 0x01};
625 u8 buf[HEADER_SIZE];
626 u16 send_id;
627 int page, n_fw_pages;
628 int error;
629
630 /* Recovery mode detection! */
631 if (force) {
632 dev_dbg(&client->dev, "Recovery mode procedure\n");
633 error = elants_i2c_send(client, enter_iap2, sizeof(enter_iap2));
634 } else {
635 /* Start IAP Procedure */
636 dev_dbg(&client->dev, "Normal IAP procedure\n");
637 /* Close idle mode */
638 error = elants_i2c_send(client, close_idle, sizeof(close_idle));
639 if (error)
640 dev_err(&client->dev, "Failed close idle: %d\n", error);
641 msleep(60);
642 elants_i2c_sw_reset(client);
643 msleep(20);
644 error = elants_i2c_send(client, enter_iap, sizeof(enter_iap));
645 }
646
647 if (error) {
648 dev_err(&client->dev, "failed to enter IAP mode: %d\n", error);
649 return error;
650 }
651
652 msleep(20);
653
654 /* check IAP state */
655 error = elants_i2c_read(client, buf, 4);
656 if (error) {
657 dev_err(&client->dev,
658 "failed to read IAP acknowledgement: %d\n",
659 error);
660 return error;
661 }
662
663 if (memcmp(buf, iap_ack, sizeof(iap_ack))) {
664 dev_err(&client->dev,
665 "failed to enter IAP: %*ph (expected %*ph)\n",
666 (int)sizeof(buf), buf, (int)sizeof(iap_ack), iap_ack);
667 return -EIO;
668 }
669
670 dev_info(&client->dev, "successfully entered IAP mode");
671
672 send_id = client->addr;
673 error = elants_i2c_send(client, &send_id, 1);
674 if (error) {
675 dev_err(&client->dev, "sending dummy byte failed: %d\n",
676 error);
677 return error;
678 }
679
680 /* Clear the last page of Master */
681 error = elants_i2c_send(client, fw->data, ELAN_FW_PAGESIZE);
682 if (error) {
683 dev_err(&client->dev, "clearing of the last page failed: %d\n",
684 error);
685 return error;
686 }
687
688 error = elants_i2c_read(client, buf, 2);
689 if (error) {
690 dev_err(&client->dev,
691 "failed to read ACK for clearing the last page: %d\n",
692 error);
693 return error;
694 }
695
696 n_fw_pages = fw->size / ELAN_FW_PAGESIZE;
697 dev_dbg(&client->dev, "IAP Pages = %d\n", n_fw_pages);
698
699 for (page = 0; page < n_fw_pages; page++) {
700 error = elants_i2c_fw_write_page(client,
701 fw->data + page * ELAN_FW_PAGESIZE);
702 if (error) {
703 dev_err(&client->dev,
704 "failed to write FW page %d: %d\n",
705 page, error);
706 return error;
707 }
708 }
709
710 /* Old iap needs to wait 200ms for WDT and rest is for hello packets */
711 msleep(300);
712
713 dev_info(&client->dev, "firmware update completed\n");
714 return 0;
715 }
716
elants_i2c_fw_update(struct elants_data * ts)717 static int elants_i2c_fw_update(struct elants_data *ts)
718 {
719 struct i2c_client *client = ts->client;
720 const struct firmware *fw;
721 char *fw_name;
722 int error;
723
724 fw_name = kasprintf(GFP_KERNEL, "elants_i2c_%04x.bin", ts->hw_version);
725 if (!fw_name)
726 return -ENOMEM;
727
728 dev_info(&client->dev, "requesting fw name = %s\n", fw_name);
729 error = request_firmware(&fw, fw_name, &client->dev);
730 kfree(fw_name);
731 if (error) {
732 dev_err(&client->dev, "failed to request firmware: %d\n",
733 error);
734 return error;
735 }
736
737 if (fw->size % ELAN_FW_PAGESIZE) {
738 dev_err(&client->dev, "invalid firmware length: %zu\n",
739 fw->size);
740 error = -EINVAL;
741 goto out;
742 }
743
744 disable_irq(client->irq);
745
746 error = elants_i2c_do_update_firmware(client, fw,
747 ts->iap_mode == ELAN_IAP_RECOVERY);
748 if (error) {
749 dev_err(&client->dev, "firmware update failed: %d\n", error);
750 ts->iap_mode = ELAN_IAP_RECOVERY;
751 goto out_enable_irq;
752 }
753
754 error = elants_i2c_initialize(ts);
755 if (error) {
756 dev_err(&client->dev,
757 "failed to initialize device after firmware update: %d\n",
758 error);
759 ts->iap_mode = ELAN_IAP_RECOVERY;
760 goto out_enable_irq;
761 }
762
763 ts->iap_mode = ELAN_IAP_OPERATIONAL;
764
765 out_enable_irq:
766 ts->state = ELAN_STATE_NORMAL;
767 enable_irq(client->irq);
768 msleep(100);
769
770 if (!error)
771 elants_i2c_calibrate(ts);
772 out:
773 release_firmware(fw);
774 return error;
775 }
776
777 /*
778 * Event reporting.
779 */
780
elants_i2c_mt_event(struct elants_data * ts,u8 * buf)781 static void elants_i2c_mt_event(struct elants_data *ts, u8 *buf)
782 {
783 struct input_dev *input = ts->input;
784 unsigned int n_fingers;
785 u16 finger_state;
786 int i;
787
788 n_fingers = buf[FW_POS_STATE + 1] & 0x0f;
789 finger_state = ((buf[FW_POS_STATE + 1] & 0x30) << 4) |
790 buf[FW_POS_STATE];
791
792 dev_dbg(&ts->client->dev,
793 "n_fingers: %u, state: %04x\n", n_fingers, finger_state);
794
795 for (i = 0; i < MAX_CONTACT_NUM && n_fingers; i++) {
796 if (finger_state & 1) {
797 unsigned int x, y, p, w;
798 u8 *pos;
799
800 pos = &buf[FW_POS_XY + i * 3];
801 x = (((u16)pos[0] & 0xf0) << 4) | pos[1];
802 y = (((u16)pos[0] & 0x0f) << 8) | pos[2];
803 p = buf[FW_POS_PRESSURE + i];
804 w = buf[FW_POS_WIDTH + i];
805
806 dev_dbg(&ts->client->dev, "i=%d x=%d y=%d p=%d w=%d\n",
807 i, x, y, p, w);
808
809 input_mt_slot(input, i);
810 input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
811 input_event(input, EV_ABS, ABS_MT_POSITION_X, x);
812 input_event(input, EV_ABS, ABS_MT_POSITION_Y, y);
813 input_event(input, EV_ABS, ABS_MT_PRESSURE, p);
814 input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, w);
815
816 n_fingers--;
817 }
818
819 finger_state >>= 1;
820 }
821
822 input_mt_sync_frame(input);
823 input_sync(input);
824 }
825
elants_i2c_calculate_checksum(u8 * buf)826 static u8 elants_i2c_calculate_checksum(u8 *buf)
827 {
828 u8 checksum = 0;
829 u8 i;
830
831 for (i = 0; i < FW_POS_CHECKSUM; i++)
832 checksum += buf[i];
833
834 return checksum;
835 }
836
elants_i2c_event(struct elants_data * ts,u8 * buf)837 static void elants_i2c_event(struct elants_data *ts, u8 *buf)
838 {
839 u8 checksum = elants_i2c_calculate_checksum(buf);
840
841 if (unlikely(buf[FW_POS_CHECKSUM] != checksum))
842 dev_warn(&ts->client->dev,
843 "%s: invalid checksum for packet %02x: %02x vs. %02x\n",
844 __func__, buf[FW_POS_HEADER],
845 checksum, buf[FW_POS_CHECKSUM]);
846 else if (unlikely(buf[FW_POS_HEADER] != HEADER_REPORT_10_FINGER))
847 dev_warn(&ts->client->dev,
848 "%s: unknown packet type: %02x\n",
849 __func__, buf[FW_POS_HEADER]);
850 else
851 elants_i2c_mt_event(ts, buf);
852 }
853
elants_i2c_irq(int irq,void * _dev)854 static irqreturn_t elants_i2c_irq(int irq, void *_dev)
855 {
856 const u8 wait_packet[] = { 0x64, 0x64, 0x64, 0x64 };
857 struct elants_data *ts = _dev;
858 struct i2c_client *client = ts->client;
859 int report_count, report_len;
860 int i;
861 int len;
862
863 len = i2c_master_recv_dmasafe(client, ts->buf, sizeof(ts->buf));
864 if (len < 0) {
865 dev_err(&client->dev, "%s: failed to read data: %d\n",
866 __func__, len);
867 goto out;
868 }
869
870 dev_dbg(&client->dev, "%s: packet %*ph\n",
871 __func__, HEADER_SIZE, ts->buf);
872
873 switch (ts->state) {
874 case ELAN_WAIT_RECALIBRATION:
875 if (ts->buf[FW_HDR_TYPE] == CMD_HEADER_REK) {
876 memcpy(ts->cmd_resp, ts->buf, sizeof(ts->cmd_resp));
877 complete(&ts->cmd_done);
878 ts->state = ELAN_STATE_NORMAL;
879 }
880 break;
881
882 case ELAN_WAIT_QUEUE_HEADER:
883 if (ts->buf[FW_HDR_TYPE] != QUEUE_HEADER_NORMAL)
884 break;
885
886 ts->state = ELAN_STATE_NORMAL;
887 /* fall through */
888
889 case ELAN_STATE_NORMAL:
890
891 switch (ts->buf[FW_HDR_TYPE]) {
892 case CMD_HEADER_HELLO:
893 case CMD_HEADER_RESP:
894 case CMD_HEADER_REK:
895 break;
896
897 case QUEUE_HEADER_WAIT:
898 if (memcmp(ts->buf, wait_packet, sizeof(wait_packet))) {
899 dev_err(&client->dev,
900 "invalid wait packet %*ph\n",
901 HEADER_SIZE, ts->buf);
902 } else {
903 ts->state = ELAN_WAIT_QUEUE_HEADER;
904 udelay(30);
905 }
906 break;
907
908 case QUEUE_HEADER_SINGLE:
909 elants_i2c_event(ts, &ts->buf[HEADER_SIZE]);
910 break;
911
912 case QUEUE_HEADER_NORMAL:
913 report_count = ts->buf[FW_HDR_COUNT];
914 if (report_count == 0 || report_count > 3) {
915 dev_err(&client->dev,
916 "bad report count: %*ph\n",
917 HEADER_SIZE, ts->buf);
918 break;
919 }
920
921 report_len = ts->buf[FW_HDR_LENGTH] / report_count;
922 if (report_len != PACKET_SIZE) {
923 dev_err(&client->dev,
924 "mismatching report length: %*ph\n",
925 HEADER_SIZE, ts->buf);
926 break;
927 }
928
929 for (i = 0; i < report_count; i++) {
930 u8 *buf = ts->buf + HEADER_SIZE +
931 i * PACKET_SIZE;
932 elants_i2c_event(ts, buf);
933 }
934 break;
935
936 default:
937 dev_err(&client->dev, "unknown packet %*ph\n",
938 HEADER_SIZE, ts->buf);
939 break;
940 }
941 break;
942 }
943
944 out:
945 return IRQ_HANDLED;
946 }
947
948 /*
949 * sysfs interface
950 */
calibrate_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)951 static ssize_t calibrate_store(struct device *dev,
952 struct device_attribute *attr,
953 const char *buf, size_t count)
954 {
955 struct i2c_client *client = to_i2c_client(dev);
956 struct elants_data *ts = i2c_get_clientdata(client);
957 int error;
958
959 error = mutex_lock_interruptible(&ts->sysfs_mutex);
960 if (error)
961 return error;
962
963 error = elants_i2c_calibrate(ts);
964
965 mutex_unlock(&ts->sysfs_mutex);
966 return error ?: count;
967 }
968
write_update_fw(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)969 static ssize_t write_update_fw(struct device *dev,
970 struct device_attribute *attr,
971 const char *buf, size_t count)
972 {
973 struct i2c_client *client = to_i2c_client(dev);
974 struct elants_data *ts = i2c_get_clientdata(client);
975 int error;
976
977 error = mutex_lock_interruptible(&ts->sysfs_mutex);
978 if (error)
979 return error;
980
981 error = elants_i2c_fw_update(ts);
982 dev_dbg(dev, "firmware update result: %d\n", error);
983
984 mutex_unlock(&ts->sysfs_mutex);
985 return error ?: count;
986 }
987
show_iap_mode(struct device * dev,struct device_attribute * attr,char * buf)988 static ssize_t show_iap_mode(struct device *dev,
989 struct device_attribute *attr, char *buf)
990 {
991 struct i2c_client *client = to_i2c_client(dev);
992 struct elants_data *ts = i2c_get_clientdata(client);
993
994 return sprintf(buf, "%s\n",
995 ts->iap_mode == ELAN_IAP_OPERATIONAL ?
996 "Normal" : "Recovery");
997 }
998
999 static DEVICE_ATTR_WO(calibrate);
1000 static DEVICE_ATTR(iap_mode, S_IRUGO, show_iap_mode, NULL);
1001 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, write_update_fw);
1002
1003 struct elants_version_attribute {
1004 struct device_attribute dattr;
1005 size_t field_offset;
1006 size_t field_size;
1007 };
1008
1009 #define __ELANTS_FIELD_SIZE(_field) \
1010 sizeof(((struct elants_data *)NULL)->_field)
1011 #define __ELANTS_VERIFY_SIZE(_field) \
1012 (BUILD_BUG_ON_ZERO(__ELANTS_FIELD_SIZE(_field) > 2) + \
1013 __ELANTS_FIELD_SIZE(_field))
1014 #define ELANTS_VERSION_ATTR(_field) \
1015 struct elants_version_attribute elants_ver_attr_##_field = { \
1016 .dattr = __ATTR(_field, S_IRUGO, \
1017 elants_version_attribute_show, NULL), \
1018 .field_offset = offsetof(struct elants_data, _field), \
1019 .field_size = __ELANTS_VERIFY_SIZE(_field), \
1020 }
1021
elants_version_attribute_show(struct device * dev,struct device_attribute * dattr,char * buf)1022 static ssize_t elants_version_attribute_show(struct device *dev,
1023 struct device_attribute *dattr,
1024 char *buf)
1025 {
1026 struct i2c_client *client = to_i2c_client(dev);
1027 struct elants_data *ts = i2c_get_clientdata(client);
1028 struct elants_version_attribute *attr =
1029 container_of(dattr, struct elants_version_attribute, dattr);
1030 u8 *field = (u8 *)((char *)ts + attr->field_offset);
1031 unsigned int fmt_size;
1032 unsigned int val;
1033
1034 if (attr->field_size == 1) {
1035 val = *field;
1036 fmt_size = 2; /* 2 HEX digits */
1037 } else {
1038 val = *(u16 *)field;
1039 fmt_size = 4; /* 4 HEX digits */
1040 }
1041
1042 return sprintf(buf, "%0*x\n", fmt_size, val);
1043 }
1044
1045 static ELANTS_VERSION_ATTR(fw_version);
1046 static ELANTS_VERSION_ATTR(hw_version);
1047 static ELANTS_VERSION_ATTR(test_version);
1048 static ELANTS_VERSION_ATTR(solution_version);
1049 static ELANTS_VERSION_ATTR(bc_version);
1050 static ELANTS_VERSION_ATTR(iap_version);
1051
1052 static struct attribute *elants_attributes[] = {
1053 &dev_attr_calibrate.attr,
1054 &dev_attr_update_fw.attr,
1055 &dev_attr_iap_mode.attr,
1056
1057 &elants_ver_attr_fw_version.dattr.attr,
1058 &elants_ver_attr_hw_version.dattr.attr,
1059 &elants_ver_attr_test_version.dattr.attr,
1060 &elants_ver_attr_solution_version.dattr.attr,
1061 &elants_ver_attr_bc_version.dattr.attr,
1062 &elants_ver_attr_iap_version.dattr.attr,
1063 NULL
1064 };
1065
1066 static const struct attribute_group elants_attribute_group = {
1067 .attrs = elants_attributes,
1068 };
1069
elants_i2c_power_on(struct elants_data * ts)1070 static int elants_i2c_power_on(struct elants_data *ts)
1071 {
1072 int error;
1073
1074 /*
1075 * If we do not have reset gpio assume platform firmware
1076 * controls regulators and does power them on for us.
1077 */
1078 if (IS_ERR_OR_NULL(ts->reset_gpio))
1079 return 0;
1080
1081 error = regulator_enable(ts->vcc33);
1082 if (error) {
1083 dev_err(&ts->client->dev,
1084 "failed to enable vcc33 regulator: %d\n",
1085 error);
1086 return error;
1087 }
1088
1089 error = regulator_enable(ts->vccio);
1090 if (error) {
1091 dev_err(&ts->client->dev,
1092 "failed to enable vccio regulator: %d\n",
1093 error);
1094 regulator_disable(ts->vcc33);
1095 return error;
1096 }
1097
1098 /*
1099 * We need to wait a bit after powering on controller before
1100 * we are allowed to release reset GPIO.
1101 */
1102 udelay(ELAN_POWERON_DELAY_USEC);
1103
1104 gpiod_set_value_cansleep(ts->reset_gpio, 0);
1105 if (error)
1106 return error;
1107
1108 msleep(ELAN_RESET_DELAY_MSEC);
1109
1110 return 0;
1111 }
1112
elants_i2c_power_off(void * _data)1113 static void elants_i2c_power_off(void *_data)
1114 {
1115 struct elants_data *ts = _data;
1116
1117 if (!IS_ERR_OR_NULL(ts->reset_gpio)) {
1118 /*
1119 * Activate reset gpio to prevent leakage through the
1120 * pin once we shut off power to the controller.
1121 */
1122 gpiod_set_value_cansleep(ts->reset_gpio, 1);
1123 regulator_disable(ts->vccio);
1124 regulator_disable(ts->vcc33);
1125 }
1126 }
1127
1128 #ifdef CONFIG_ACPI
1129 static const struct acpi_device_id i2c_hid_ids[] = {
1130 {"ACPI0C50", 0 },
1131 {"PNP0C50", 0 },
1132 { },
1133 };
1134
1135 static const guid_t i2c_hid_guid =
1136 GUID_INIT(0x3CDFF6F7, 0x4267, 0x4555,
1137 0xAD, 0x05, 0xB3, 0x0A, 0x3D, 0x89, 0x38, 0xDE);
1138
elants_acpi_is_hid_device(struct device * dev)1139 static bool elants_acpi_is_hid_device(struct device *dev)
1140 {
1141 acpi_handle handle = ACPI_HANDLE(dev);
1142 union acpi_object *obj;
1143
1144 if (acpi_match_device_ids(ACPI_COMPANION(dev), i2c_hid_ids))
1145 return false;
1146
1147 obj = acpi_evaluate_dsm_typed(handle, &i2c_hid_guid, 1, 1, NULL, ACPI_TYPE_INTEGER);
1148 if (obj) {
1149 ACPI_FREE(obj);
1150 return true;
1151 }
1152
1153 return false;
1154 }
1155 #else
elants_acpi_is_hid_device(struct device * dev)1156 static bool elants_acpi_is_hid_device(struct device *dev)
1157 {
1158 return false;
1159 }
1160 #endif
1161
elants_i2c_probe(struct i2c_client * client,const struct i2c_device_id * id)1162 static int elants_i2c_probe(struct i2c_client *client,
1163 const struct i2c_device_id *id)
1164 {
1165 union i2c_smbus_data dummy;
1166 struct elants_data *ts;
1167 unsigned long irqflags;
1168 int error;
1169
1170 /* Don't bind to i2c-hid compatible devices, these are handled by the i2c-hid drv. */
1171 if (elants_acpi_is_hid_device(&client->dev)) {
1172 dev_warn(&client->dev, "This device appears to be an I2C-HID device, not binding\n");
1173 return -ENODEV;
1174 }
1175
1176 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1177 dev_err(&client->dev, "I2C check functionality error\n");
1178 return -ENXIO;
1179 }
1180
1181 ts = devm_kzalloc(&client->dev, sizeof(struct elants_data), GFP_KERNEL);
1182 if (!ts)
1183 return -ENOMEM;
1184
1185 mutex_init(&ts->sysfs_mutex);
1186 init_completion(&ts->cmd_done);
1187
1188 ts->client = client;
1189 i2c_set_clientdata(client, ts);
1190
1191 ts->vcc33 = devm_regulator_get(&client->dev, "vcc33");
1192 if (IS_ERR(ts->vcc33)) {
1193 error = PTR_ERR(ts->vcc33);
1194 if (error != -EPROBE_DEFER)
1195 dev_err(&client->dev,
1196 "Failed to get 'vcc33' regulator: %d\n",
1197 error);
1198 return error;
1199 }
1200
1201 ts->vccio = devm_regulator_get(&client->dev, "vccio");
1202 if (IS_ERR(ts->vccio)) {
1203 error = PTR_ERR(ts->vccio);
1204 if (error != -EPROBE_DEFER)
1205 dev_err(&client->dev,
1206 "Failed to get 'vccio' regulator: %d\n",
1207 error);
1208 return error;
1209 }
1210
1211 ts->reset_gpio = devm_gpiod_get(&client->dev, "reset", GPIOD_OUT_HIGH);
1212 if (IS_ERR(ts->reset_gpio)) {
1213 error = PTR_ERR(ts->reset_gpio);
1214
1215 if (error == -EPROBE_DEFER)
1216 return error;
1217
1218 if (error != -ENOENT && error != -ENOSYS) {
1219 dev_err(&client->dev,
1220 "failed to get reset gpio: %d\n",
1221 error);
1222 return error;
1223 }
1224
1225 ts->keep_power_in_suspend = true;
1226 }
1227
1228 error = elants_i2c_power_on(ts);
1229 if (error)
1230 return error;
1231
1232 error = devm_add_action(&client->dev, elants_i2c_power_off, ts);
1233 if (error) {
1234 dev_err(&client->dev,
1235 "failed to install power off action: %d\n", error);
1236 elants_i2c_power_off(ts);
1237 return error;
1238 }
1239
1240 /* Make sure there is something at this address */
1241 if (i2c_smbus_xfer(client->adapter, client->addr, 0,
1242 I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &dummy) < 0) {
1243 dev_err(&client->dev, "nothing at this address\n");
1244 return -ENXIO;
1245 }
1246
1247 error = elants_i2c_initialize(ts);
1248 if (error) {
1249 dev_err(&client->dev, "failed to initialize: %d\n", error);
1250 return error;
1251 }
1252
1253 ts->input = devm_input_allocate_device(&client->dev);
1254 if (!ts->input) {
1255 dev_err(&client->dev, "Failed to allocate input device\n");
1256 return -ENOMEM;
1257 }
1258
1259 ts->input->name = "Elan Touchscreen";
1260 ts->input->id.bustype = BUS_I2C;
1261
1262 __set_bit(BTN_TOUCH, ts->input->keybit);
1263 __set_bit(EV_ABS, ts->input->evbit);
1264 __set_bit(EV_KEY, ts->input->evbit);
1265
1266 /* Single touch input params setup */
1267 input_set_abs_params(ts->input, ABS_X, 0, ts->x_max, 0, 0);
1268 input_set_abs_params(ts->input, ABS_Y, 0, ts->y_max, 0, 0);
1269 input_set_abs_params(ts->input, ABS_PRESSURE, 0, 255, 0, 0);
1270 input_abs_set_res(ts->input, ABS_X, ts->x_res);
1271 input_abs_set_res(ts->input, ABS_Y, ts->y_res);
1272
1273 /* Multitouch input params setup */
1274 error = input_mt_init_slots(ts->input, MAX_CONTACT_NUM,
1275 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
1276 if (error) {
1277 dev_err(&client->dev,
1278 "failed to initialize MT slots: %d\n", error);
1279 return error;
1280 }
1281
1282 input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, ts->x_max, 0, 0);
1283 input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, ts->y_max, 0, 0);
1284 input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
1285 input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, 255, 0, 0);
1286 input_abs_set_res(ts->input, ABS_MT_POSITION_X, ts->x_res);
1287 input_abs_set_res(ts->input, ABS_MT_POSITION_Y, ts->y_res);
1288
1289 error = input_register_device(ts->input);
1290 if (error) {
1291 dev_err(&client->dev,
1292 "unable to register input device: %d\n", error);
1293 return error;
1294 }
1295
1296 /*
1297 * Platform code (ACPI, DTS) should normally set up interrupt
1298 * for us, but in case it did not let's fall back to using falling
1299 * edge to be compatible with older Chromebooks.
1300 */
1301 irqflags = irq_get_trigger_type(client->irq);
1302 if (!irqflags)
1303 irqflags = IRQF_TRIGGER_FALLING;
1304
1305 error = devm_request_threaded_irq(&client->dev, client->irq,
1306 NULL, elants_i2c_irq,
1307 irqflags | IRQF_ONESHOT,
1308 client->name, ts);
1309 if (error) {
1310 dev_err(&client->dev, "Failed to register interrupt\n");
1311 return error;
1312 }
1313
1314 /*
1315 * Systems using device tree should set up wakeup via DTS,
1316 * the rest will configure device as wakeup source by default.
1317 */
1318 if (!client->dev.of_node)
1319 device_init_wakeup(&client->dev, true);
1320
1321 error = devm_device_add_group(&client->dev, &elants_attribute_group);
1322 if (error) {
1323 dev_err(&client->dev, "failed to create sysfs attributes: %d\n",
1324 error);
1325 return error;
1326 }
1327
1328 return 0;
1329 }
1330
elants_i2c_suspend(struct device * dev)1331 static int __maybe_unused elants_i2c_suspend(struct device *dev)
1332 {
1333 struct i2c_client *client = to_i2c_client(dev);
1334 struct elants_data *ts = i2c_get_clientdata(client);
1335 const u8 set_sleep_cmd[] = { 0x54, 0x50, 0x00, 0x01 };
1336 int retry_cnt;
1337 int error;
1338
1339 /* Command not support in IAP recovery mode */
1340 if (ts->iap_mode != ELAN_IAP_OPERATIONAL)
1341 return -EBUSY;
1342
1343 disable_irq(client->irq);
1344
1345 if (device_may_wakeup(dev)) {
1346 /*
1347 * The device will automatically enter idle mode
1348 * that has reduced power consumption.
1349 */
1350 ts->wake_irq_enabled = (enable_irq_wake(client->irq) == 0);
1351 } else if (ts->keep_power_in_suspend) {
1352 for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
1353 error = elants_i2c_send(client, set_sleep_cmd,
1354 sizeof(set_sleep_cmd));
1355 if (!error)
1356 break;
1357
1358 dev_err(&client->dev,
1359 "suspend command failed: %d\n", error);
1360 }
1361 } else {
1362 elants_i2c_power_off(ts);
1363 }
1364
1365 return 0;
1366 }
1367
elants_i2c_resume(struct device * dev)1368 static int __maybe_unused elants_i2c_resume(struct device *dev)
1369 {
1370 struct i2c_client *client = to_i2c_client(dev);
1371 struct elants_data *ts = i2c_get_clientdata(client);
1372 const u8 set_active_cmd[] = { 0x54, 0x58, 0x00, 0x01 };
1373 int retry_cnt;
1374 int error;
1375
1376 if (device_may_wakeup(dev)) {
1377 if (ts->wake_irq_enabled)
1378 disable_irq_wake(client->irq);
1379 elants_i2c_sw_reset(client);
1380 } else if (ts->keep_power_in_suspend) {
1381 for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
1382 error = elants_i2c_send(client, set_active_cmd,
1383 sizeof(set_active_cmd));
1384 if (!error)
1385 break;
1386
1387 dev_err(&client->dev,
1388 "resume command failed: %d\n", error);
1389 }
1390 } else {
1391 elants_i2c_power_on(ts);
1392 elants_i2c_initialize(ts);
1393 }
1394
1395 ts->state = ELAN_STATE_NORMAL;
1396 enable_irq(client->irq);
1397
1398 return 0;
1399 }
1400
1401 static SIMPLE_DEV_PM_OPS(elants_i2c_pm_ops,
1402 elants_i2c_suspend, elants_i2c_resume);
1403
1404 static const struct i2c_device_id elants_i2c_id[] = {
1405 { DEVICE_NAME, 0 },
1406 { }
1407 };
1408 MODULE_DEVICE_TABLE(i2c, elants_i2c_id);
1409
1410 #ifdef CONFIG_ACPI
1411 static const struct acpi_device_id elants_acpi_id[] = {
1412 { "ELAN0001", 0 },
1413 { }
1414 };
1415 MODULE_DEVICE_TABLE(acpi, elants_acpi_id);
1416 #endif
1417
1418 #ifdef CONFIG_OF
1419 static const struct of_device_id elants_of_match[] = {
1420 { .compatible = "elan,ekth3500" },
1421 { /* sentinel */ }
1422 };
1423 MODULE_DEVICE_TABLE(of, elants_of_match);
1424 #endif
1425
1426 static struct i2c_driver elants_i2c_driver = {
1427 .probe = elants_i2c_probe,
1428 .id_table = elants_i2c_id,
1429 .driver = {
1430 .name = DEVICE_NAME,
1431 .pm = &elants_i2c_pm_ops,
1432 .acpi_match_table = ACPI_PTR(elants_acpi_id),
1433 .of_match_table = of_match_ptr(elants_of_match),
1434 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1435 },
1436 };
1437 module_i2c_driver(elants_i2c_driver);
1438
1439 MODULE_AUTHOR("Scott Liu <scott.liu@emc.com.tw>");
1440 MODULE_DESCRIPTION("Elan I2c Touchscreen driver");
1441 MODULE_LICENSE("GPL");
1442