1 // SPDX-License-Identifier: GPL-2.0-only
3 * Elan Microelectronics touch panels with I2C interface
5 * Copyright (C) 2014 Elan Microelectronics Corporation.
6 * Scott Liu <scott.liu@emc.com.tw>
8 * This code is partly based on hid-multitouch.c:
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
14 * This code is partly based on i2c-hid.c:
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
22 #include <linux/bits.h>
23 #include <linux/module.h>
24 #include <linux/input.h>
25 #include <linux/interrupt.h>
26 #include <linux/irq.h>
27 #include <linux/platform_device.h>
28 #include <linux/async.h>
29 #include <linux/i2c.h>
30 #include <linux/delay.h>
31 #include <linux/uaccess.h>
32 #include <linux/buffer_head.h>
33 #include <linux/slab.h>
34 #include <linux/firmware.h>
35 #include <linux/input/mt.h>
36 #include <linux/input/touchscreen.h>
37 #include <linux/acpi.h>
39 #include <linux/gpio/consumer.h>
40 #include <linux/regulator/consumer.h>
41 #include <asm/unaligned.h>
43 /* Device, Driver information */
44 #define DEVICE_NAME "elants_i2c"
46 /* Convert from rows or columns into resolution */
47 #define ELAN_TS_RESOLUTION(n, m) (((n) - 1) * (m))
52 #define FW_HDR_COUNT 1
53 #define FW_HDR_LENGTH 2
55 /* Buffer mode Queue Header information */
56 #define QUEUE_HEADER_SINGLE 0x62
57 #define QUEUE_HEADER_NORMAL 0X63
58 #define QUEUE_HEADER_WAIT 0x64
59 #define QUEUE_HEADER_NORMAL2 0x66
61 /* Command header definition */
62 #define CMD_HEADER_WRITE 0x54
63 #define CMD_HEADER_READ 0x53
64 #define CMD_HEADER_6B_READ 0x5B
65 #define CMD_HEADER_ROM_READ 0x96
66 #define CMD_HEADER_RESP 0x52
67 #define CMD_HEADER_6B_RESP 0x9B
68 #define CMD_HEADER_ROM_RESP 0x95
69 #define CMD_HEADER_HELLO 0x55
70 #define CMD_HEADER_REK 0x66
72 /* FW position data */
73 #define PACKET_SIZE_OLD 40
74 #define PACKET_SIZE 55
75 #define MAX_CONTACT_NUM 10
76 #define FW_POS_HEADER 0
77 #define FW_POS_STATE 1
78 #define FW_POS_TOTAL 2
80 #define FW_POS_TOOL_TYPE 33
81 #define FW_POS_CHECKSUM 34
82 #define FW_POS_WIDTH 35
83 #define FW_POS_PRESSURE 45
85 #define HEADER_REPORT_10_FINGER 0x62
87 /* Header (4 bytes) plus 3 full 10-finger packets */
88 #define MAX_PACKET_SIZE 169
90 #define BOOT_TIME_DELAY_MS 50
92 /* FW read command, 0x53 0x?? 0x0, 0x01 */
93 #define E_ELAN_INFO_FW_VER 0x00
94 #define E_ELAN_INFO_BC_VER 0x10
95 #define E_ELAN_INFO_X_RES 0x60
96 #define E_ELAN_INFO_Y_RES 0x63
97 #define E_ELAN_INFO_REK 0xD0
98 #define E_ELAN_INFO_TEST_VER 0xE0
99 #define E_ELAN_INFO_FW_ID 0xF0
100 #define E_INFO_OSR 0xD6
101 #define E_INFO_PHY_SCAN 0xD7
102 #define E_INFO_PHY_DRIVER 0xD8
104 /* FW write command, 0x54 0x?? 0x0, 0x01 */
105 #define E_POWER_STATE_SLEEP 0x50
106 #define E_POWER_STATE_RESUME 0x58
108 #define MAX_RETRIES 3
109 #define MAX_FW_UPDATE_RETRIES 30
111 #define ELAN_FW_PAGESIZE 132
113 /* calibration timeout definition */
114 #define ELAN_CALI_TIMEOUT_MSEC 12000
116 #define ELAN_POWERON_DELAY_USEC 500
117 #define ELAN_RESET_DELAY_MSEC 20
119 enum elants_chip_id
{
126 ELAN_WAIT_QUEUE_HEADER
,
127 ELAN_WAIT_RECALIBRATION
,
130 enum elants_iap_mode
{
131 ELAN_IAP_OPERATIONAL
,
135 /* struct elants_data - represents state of Elan touchscreen device */
137 struct i2c_client
*client
;
138 struct input_dev
*input
;
140 struct regulator
*vcc33
;
141 struct regulator
*vccio
;
142 struct gpio_desc
*reset_gpio
;
151 unsigned int x_res
; /* resolution in units/mm */
157 struct touchscreen_properties prop
;
159 enum elants_state state
;
160 enum elants_chip_id chip_id
;
161 enum elants_iap_mode iap_mode
;
163 /* Guards against concurrent access to the device via sysfs */
164 struct mutex sysfs_mutex
;
166 u8 cmd_resp
[HEADER_SIZE
];
167 struct completion cmd_done
;
169 bool wake_irq_enabled
;
170 bool keep_power_in_suspend
;
172 /* Must be last to be used for DMA operations */
173 u8 buf
[MAX_PACKET_SIZE
] ____cacheline_aligned
;
176 static int elants_i2c_send(struct i2c_client
*client
,
177 const void *data
, size_t size
)
181 ret
= i2c_master_send(client
, data
, size
);
188 dev_err(&client
->dev
, "%s failed (%*ph): %d\n",
189 __func__
, (int)size
, data
, ret
);
194 static int elants_i2c_read(struct i2c_client
*client
, void *data
, size_t size
)
198 ret
= i2c_master_recv(client
, data
, size
);
205 dev_err(&client
->dev
, "%s failed: %d\n", __func__
, ret
);
210 static int elants_i2c_execute_command(struct i2c_client
*client
,
211 const u8
*cmd
, size_t cmd_size
,
212 u8
*resp
, size_t resp_size
,
213 int retries
, const char *cmd_name
)
215 struct i2c_msg msgs
[2];
217 u8 expected_response
;
220 case CMD_HEADER_READ
:
221 expected_response
= CMD_HEADER_RESP
;
224 case CMD_HEADER_6B_READ
:
225 expected_response
= CMD_HEADER_6B_RESP
;
228 case CMD_HEADER_ROM_READ
:
229 expected_response
= CMD_HEADER_ROM_RESP
;
233 dev_err(&client
->dev
, "(%s): invalid command: %*ph\n",
234 cmd_name
, (int)cmd_size
, cmd
);
239 msgs
[0].addr
= client
->addr
;
240 msgs
[0].flags
= client
->flags
& I2C_M_TEN
;
241 msgs
[0].len
= cmd_size
;
242 msgs
[0].buf
= (u8
*)cmd
;
244 msgs
[1].addr
= client
->addr
;
245 msgs
[1].flags
= (client
->flags
& I2C_M_TEN
) | I2C_M_RD
;
246 msgs
[1].flags
|= I2C_M_RD
;
247 msgs
[1].len
= resp_size
;
250 ret
= i2c_transfer(client
->adapter
, msgs
, ARRAY_SIZE(msgs
));
253 dev_dbg(&client
->dev
,
254 "(%s) I2C transfer failed: %pe (retrying)\n",
255 cmd_name
, ERR_PTR(ret
));
259 dev_err(&client
->dev
,
260 "(%s) I2C transfer failed: %pe\n",
261 cmd_name
, ERR_PTR(ret
));
265 if (ret
!= ARRAY_SIZE(msgs
) ||
266 resp
[FW_HDR_TYPE
] != expected_response
) {
268 dev_dbg(&client
->dev
,
269 "(%s) unexpected response: %*ph (retrying)\n",
270 cmd_name
, ret
, resp
);
274 dev_err(&client
->dev
,
275 "(%s) unexpected response: %*ph\n",
276 cmd_name
, ret
, resp
);
284 static int elants_i2c_calibrate(struct elants_data
*ts
)
286 struct i2c_client
*client
= ts
->client
;
288 static const u8 w_flashkey
[] = { CMD_HEADER_WRITE
, 0xC0, 0xE1, 0x5A };
289 static const u8 rek
[] = { CMD_HEADER_WRITE
, 0x29, 0x00, 0x01 };
290 static const u8 rek_resp
[] = { CMD_HEADER_REK
, 0x66, 0x66, 0x66 };
292 disable_irq(client
->irq
);
294 ts
->state
= ELAN_WAIT_RECALIBRATION
;
295 reinit_completion(&ts
->cmd_done
);
297 elants_i2c_send(client
, w_flashkey
, sizeof(w_flashkey
));
298 elants_i2c_send(client
, rek
, sizeof(rek
));
300 enable_irq(client
->irq
);
302 ret
= wait_for_completion_interruptible_timeout(&ts
->cmd_done
,
303 msecs_to_jiffies(ELAN_CALI_TIMEOUT_MSEC
));
305 ts
->state
= ELAN_STATE_NORMAL
;
308 error
= ret
< 0 ? ret
: -ETIMEDOUT
;
309 dev_err(&client
->dev
,
310 "error while waiting for calibration to complete: %d\n",
315 if (memcmp(rek_resp
, ts
->cmd_resp
, sizeof(rek_resp
))) {
316 dev_err(&client
->dev
,
317 "unexpected calibration response: %*ph\n",
318 (int)sizeof(ts
->cmd_resp
), ts
->cmd_resp
);
325 static int elants_i2c_sw_reset(struct i2c_client
*client
)
327 const u8 soft_rst_cmd
[] = { 0x77, 0x77, 0x77, 0x77 };
330 error
= elants_i2c_send(client
, soft_rst_cmd
,
331 sizeof(soft_rst_cmd
));
333 dev_err(&client
->dev
, "software reset failed: %d\n", error
);
338 * We should wait at least 10 msec (but no more than 40) before
339 * sending fastboot or IAP command to the device.
346 static u16
elants_i2c_parse_version(u8
*buf
)
348 return get_unaligned_be32(buf
) >> 4;
351 static int elants_i2c_query_hw_version(struct elants_data
*ts
)
353 struct i2c_client
*client
= ts
->client
;
354 int retry_cnt
= MAX_RETRIES
;
355 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_FW_ID
, 0x00, 0x01 };
356 u8 resp
[HEADER_SIZE
];
359 while (retry_cnt
--) {
360 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
361 resp
, sizeof(resp
), 1,
366 ts
->hw_version
= elants_i2c_parse_version(resp
);
367 if (ts
->hw_version
!= 0xffff)
371 dev_err(&client
->dev
, "Invalid fw id: %#04x\n", ts
->hw_version
);
376 static int elants_i2c_query_fw_version(struct elants_data
*ts
)
378 struct i2c_client
*client
= ts
->client
;
379 int retry_cnt
= MAX_RETRIES
;
380 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_FW_VER
, 0x00, 0x01 };
381 u8 resp
[HEADER_SIZE
];
384 while (retry_cnt
--) {
385 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
386 resp
, sizeof(resp
), 1,
391 ts
->fw_version
= elants_i2c_parse_version(resp
);
392 if (ts
->fw_version
!= 0x0000 && ts
->fw_version
!= 0xffff)
395 dev_dbg(&client
->dev
, "(read fw version) resp %*phC\n",
396 (int)sizeof(resp
), resp
);
399 dev_err(&client
->dev
, "Invalid fw ver: %#04x\n", ts
->fw_version
);
404 static int elants_i2c_query_test_version(struct elants_data
*ts
)
406 struct i2c_client
*client
= ts
->client
;
409 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_TEST_VER
, 0x00, 0x01 };
410 u8 resp
[HEADER_SIZE
];
412 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
413 resp
, sizeof(resp
), MAX_RETRIES
,
414 "read test version");
416 dev_err(&client
->dev
, "Failed to read test version\n");
420 version
= elants_i2c_parse_version(resp
);
421 ts
->test_version
= version
>> 8;
422 ts
->solution_version
= version
& 0xff;
427 static int elants_i2c_query_bc_version(struct elants_data
*ts
)
429 struct i2c_client
*client
= ts
->client
;
430 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_BC_VER
, 0x00, 0x01 };
431 u8 resp
[HEADER_SIZE
];
435 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
436 resp
, sizeof(resp
), 1,
441 version
= elants_i2c_parse_version(resp
);
442 ts
->bc_version
= version
>> 8;
443 ts
->iap_version
= version
& 0xff;
448 static int elants_i2c_query_ts_info_ektf(struct elants_data
*ts
)
450 struct i2c_client
*client
= ts
->client
;
454 const u8 get_xres_cmd
[] = {
455 CMD_HEADER_READ
, E_ELAN_INFO_X_RES
, 0x00, 0x00
457 const u8 get_yres_cmd
[] = {
458 CMD_HEADER_READ
, E_ELAN_INFO_Y_RES
, 0x00, 0x00
461 /* Get X/Y size in mm */
462 error
= elants_i2c_execute_command(client
, get_xres_cmd
,
463 sizeof(get_xres_cmd
),
464 resp
, sizeof(resp
), 1,
469 phy_x
= resp
[2] | ((resp
[3] & 0xF0) << 4);
471 error
= elants_i2c_execute_command(client
, get_yres_cmd
,
472 sizeof(get_yres_cmd
),
473 resp
, sizeof(resp
), 1,
478 phy_y
= resp
[2] | ((resp
[3] & 0xF0) << 4);
480 dev_dbg(&client
->dev
, "phy_x=%d, phy_y=%d\n", phy_x
, phy_y
);
485 /* eKTF doesn't report max size, set it to default values */
486 ts
->x_max
= 2240 - 1;
487 ts
->y_max
= 1408 - 1;
492 static int elants_i2c_query_ts_info_ekth(struct elants_data
*ts
)
494 struct i2c_client
*client
= ts
->client
;
497 u16 phy_x
, phy_y
, rows
, cols
, osr
;
498 const u8 get_resolution_cmd
[] = {
499 CMD_HEADER_6B_READ
, 0x00, 0x00, 0x00, 0x00, 0x00
501 const u8 get_osr_cmd
[] = {
502 CMD_HEADER_READ
, E_INFO_OSR
, 0x00, 0x01
504 const u8 get_physical_scan_cmd
[] = {
505 CMD_HEADER_READ
, E_INFO_PHY_SCAN
, 0x00, 0x01
507 const u8 get_physical_drive_cmd
[] = {
508 CMD_HEADER_READ
, E_INFO_PHY_DRIVER
, 0x00, 0x01
511 /* Get trace number */
512 error
= elants_i2c_execute_command(client
,
514 sizeof(get_resolution_cmd
),
515 resp
, sizeof(resp
), 1,
520 rows
= resp
[2] + resp
[6] + resp
[10];
521 cols
= resp
[3] + resp
[7] + resp
[11];
523 /* Get report resolution value of ABS_MT_TOUCH_MAJOR */
524 ts
->major_res
= resp
[16];
526 /* Process mm_to_pixel information */
527 error
= elants_i2c_execute_command(client
,
528 get_osr_cmd
, sizeof(get_osr_cmd
),
529 resp
, sizeof(resp
), 1, "get osr");
535 error
= elants_i2c_execute_command(client
,
536 get_physical_scan_cmd
,
537 sizeof(get_physical_scan_cmd
),
538 resp
, sizeof(resp
), 1,
539 "get physical scan");
543 phy_x
= get_unaligned_be16(&resp
[2]);
545 error
= elants_i2c_execute_command(client
,
546 get_physical_drive_cmd
,
547 sizeof(get_physical_drive_cmd
),
548 resp
, sizeof(resp
), 1,
549 "get physical drive");
553 phy_y
= get_unaligned_be16(&resp
[2]);
555 dev_dbg(&client
->dev
, "phy_x=%d, phy_y=%d\n", phy_x
, phy_y
);
557 if (rows
== 0 || cols
== 0 || osr
== 0) {
558 dev_warn(&client
->dev
,
559 "invalid trace number data: %d, %d, %d\n",
562 /* translate trace number to TS resolution */
563 ts
->x_max
= ELAN_TS_RESOLUTION(rows
, osr
);
564 ts
->x_res
= DIV_ROUND_CLOSEST(ts
->x_max
, phy_x
);
565 ts
->y_max
= ELAN_TS_RESOLUTION(cols
, osr
);
566 ts
->y_res
= DIV_ROUND_CLOSEST(ts
->y_max
, phy_y
);
574 static int elants_i2c_fastboot(struct i2c_client
*client
)
576 const u8 boot_cmd
[] = { 0x4D, 0x61, 0x69, 0x6E };
579 error
= elants_i2c_send(client
, boot_cmd
, sizeof(boot_cmd
));
581 dev_err(&client
->dev
, "boot failed: %d\n", error
);
585 dev_dbg(&client
->dev
, "boot success -- 0x%x\n", client
->addr
);
589 static int elants_i2c_initialize(struct elants_data
*ts
)
591 struct i2c_client
*client
= ts
->client
;
592 int error
, error2
, retry_cnt
;
593 const u8 hello_packet
[] = { 0x55, 0x55, 0x55, 0x55 };
594 const u8 recov_packet
[] = { 0x55, 0x55, 0x80, 0x80 };
597 for (retry_cnt
= 0; retry_cnt
< MAX_RETRIES
; retry_cnt
++) {
598 error
= elants_i2c_sw_reset(client
);
600 /* Continue initializing if it's the last try */
601 if (retry_cnt
< MAX_RETRIES
- 1)
605 error
= elants_i2c_fastboot(client
);
607 /* Continue initializing if it's the last try */
608 if (retry_cnt
< MAX_RETRIES
- 1)
612 /* Wait for Hello packet */
613 msleep(BOOT_TIME_DELAY_MS
);
615 error
= elants_i2c_read(client
, buf
, sizeof(buf
));
617 dev_err(&client
->dev
,
618 "failed to read 'hello' packet: %d\n", error
);
619 } else if (!memcmp(buf
, hello_packet
, sizeof(hello_packet
))) {
620 ts
->iap_mode
= ELAN_IAP_OPERATIONAL
;
622 } else if (!memcmp(buf
, recov_packet
, sizeof(recov_packet
))) {
624 * Setting error code will mark device
625 * in recovery mode below.
631 dev_err(&client
->dev
,
632 "invalid 'hello' packet: %*ph\n",
633 (int)sizeof(buf
), buf
);
637 /* hw version is available even if device in recovery state */
638 error2
= elants_i2c_query_hw_version(ts
);
640 error2
= elants_i2c_query_bc_version(ts
);
645 error
= elants_i2c_query_fw_version(ts
);
647 error
= elants_i2c_query_test_version(ts
);
649 switch (ts
->chip_id
) {
652 error
= elants_i2c_query_ts_info_ekth(ts
);
656 error
= elants_i2c_query_ts_info_ektf(ts
);
664 ts
->iap_mode
= ELAN_IAP_RECOVERY
;
670 * Firmware update interface.
673 static int elants_i2c_fw_write_page(struct i2c_client
*client
,
676 const u8 ack_ok
[] = { 0xaa, 0xaa };
681 for (retry
= 0; retry
< MAX_FW_UPDATE_RETRIES
; retry
++) {
682 error
= elants_i2c_send(client
, page
, ELAN_FW_PAGESIZE
);
684 dev_err(&client
->dev
,
685 "IAP Write Page failed: %d\n", error
);
689 error
= elants_i2c_read(client
, buf
, 2);
691 dev_err(&client
->dev
,
692 "IAP Ack read failed: %d\n", error
);
696 if (!memcmp(buf
, ack_ok
, sizeof(ack_ok
)))
700 dev_err(&client
->dev
,
701 "IAP Get Ack Error [%02x:%02x]\n",
708 static int elants_i2c_validate_remark_id(struct elants_data
*ts
,
709 const struct firmware
*fw
)
711 struct i2c_client
*client
= ts
->client
;
713 const u8 cmd
[] = { CMD_HEADER_ROM_READ
, 0x80, 0x1F, 0x00, 0x00, 0x21 };
715 u16 ts_remark_id
= 0;
716 u16 fw_remark_id
= 0;
718 /* Compare TS Remark ID and FW Remark ID */
719 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
721 1, "read Remark ID");
725 ts_remark_id
= get_unaligned_be16(&resp
[3]);
727 fw_remark_id
= get_unaligned_le16(&fw
->data
[fw
->size
- 4]);
729 if (fw_remark_id
!= ts_remark_id
) {
730 dev_err(&client
->dev
,
731 "Remark ID Mismatched: ts_remark_id=0x%04x, fw_remark_id=0x%04x.\n",
732 ts_remark_id
, fw_remark_id
);
739 static int elants_i2c_do_update_firmware(struct i2c_client
*client
,
740 const struct firmware
*fw
,
743 struct elants_data
*ts
= i2c_get_clientdata(client
);
744 const u8 enter_iap
[] = { 0x45, 0x49, 0x41, 0x50 };
745 const u8 enter_iap2
[] = { 0x54, 0x00, 0x12, 0x34 };
746 const u8 iap_ack
[] = { 0x55, 0xaa, 0x33, 0xcc };
747 const u8 close_idle
[] = { 0x54, 0x2c, 0x01, 0x01 };
750 int page
, n_fw_pages
;
752 bool check_remark_id
= ts
->iap_version
>= 0x60;
754 /* Recovery mode detection! */
756 dev_dbg(&client
->dev
, "Recovery mode procedure\n");
758 if (check_remark_id
) {
759 error
= elants_i2c_validate_remark_id(ts
, fw
);
764 error
= elants_i2c_send(client
, enter_iap2
, sizeof(enter_iap2
));
766 dev_err(&client
->dev
, "failed to enter IAP mode: %d\n",
771 /* Start IAP Procedure */
772 dev_dbg(&client
->dev
, "Normal IAP procedure\n");
774 /* Close idle mode */
775 error
= elants_i2c_send(client
, close_idle
, sizeof(close_idle
));
777 dev_err(&client
->dev
, "Failed close idle: %d\n", error
);
780 elants_i2c_sw_reset(client
);
783 if (check_remark_id
) {
784 error
= elants_i2c_validate_remark_id(ts
, fw
);
789 error
= elants_i2c_send(client
, enter_iap
, sizeof(enter_iap
));
791 dev_err(&client
->dev
, "failed to enter IAP mode: %d\n",
799 /* check IAP state */
800 error
= elants_i2c_read(client
, buf
, 4);
802 dev_err(&client
->dev
,
803 "failed to read IAP acknowledgement: %d\n",
808 if (memcmp(buf
, iap_ack
, sizeof(iap_ack
))) {
809 dev_err(&client
->dev
,
810 "failed to enter IAP: %*ph (expected %*ph)\n",
811 (int)sizeof(buf
), buf
, (int)sizeof(iap_ack
), iap_ack
);
815 dev_info(&client
->dev
, "successfully entered IAP mode");
817 send_id
= client
->addr
;
818 error
= elants_i2c_send(client
, &send_id
, 1);
820 dev_err(&client
->dev
, "sending dummy byte failed: %d\n",
825 /* Clear the last page of Master */
826 error
= elants_i2c_send(client
, fw
->data
, ELAN_FW_PAGESIZE
);
828 dev_err(&client
->dev
, "clearing of the last page failed: %d\n",
833 error
= elants_i2c_read(client
, buf
, 2);
835 dev_err(&client
->dev
,
836 "failed to read ACK for clearing the last page: %d\n",
841 n_fw_pages
= fw
->size
/ ELAN_FW_PAGESIZE
;
842 dev_dbg(&client
->dev
, "IAP Pages = %d\n", n_fw_pages
);
844 for (page
= 0; page
< n_fw_pages
; page
++) {
845 error
= elants_i2c_fw_write_page(client
,
846 fw
->data
+ page
* ELAN_FW_PAGESIZE
);
848 dev_err(&client
->dev
,
849 "failed to write FW page %d: %d\n",
855 /* Old iap needs to wait 200ms for WDT and rest is for hello packets */
858 dev_info(&client
->dev
, "firmware update completed\n");
862 static int elants_i2c_fw_update(struct elants_data
*ts
)
864 struct i2c_client
*client
= ts
->client
;
865 const struct firmware
*fw
;
869 fw_name
= kasprintf(GFP_KERNEL
, "elants_i2c_%04x.bin", ts
->hw_version
);
873 dev_info(&client
->dev
, "requesting fw name = %s\n", fw_name
);
874 error
= request_firmware(&fw
, fw_name
, &client
->dev
);
877 dev_err(&client
->dev
, "failed to request firmware: %d\n",
882 if (fw
->size
% ELAN_FW_PAGESIZE
) {
883 dev_err(&client
->dev
, "invalid firmware length: %zu\n",
889 disable_irq(client
->irq
);
891 error
= elants_i2c_do_update_firmware(client
, fw
,
892 ts
->iap_mode
== ELAN_IAP_RECOVERY
);
894 dev_err(&client
->dev
, "firmware update failed: %d\n", error
);
895 ts
->iap_mode
= ELAN_IAP_RECOVERY
;
899 error
= elants_i2c_initialize(ts
);
901 dev_err(&client
->dev
,
902 "failed to initialize device after firmware update: %d\n",
904 ts
->iap_mode
= ELAN_IAP_RECOVERY
;
908 ts
->iap_mode
= ELAN_IAP_OPERATIONAL
;
911 ts
->state
= ELAN_STATE_NORMAL
;
912 enable_irq(client
->irq
);
916 elants_i2c_calibrate(ts
);
918 release_firmware(fw
);
926 static void elants_i2c_mt_event(struct elants_data
*ts
, u8
*buf
,
929 struct input_dev
*input
= ts
->input
;
930 unsigned int n_fingers
;
931 unsigned int tool_type
;
935 n_fingers
= buf
[FW_POS_STATE
+ 1] & 0x0f;
936 finger_state
= ((buf
[FW_POS_STATE
+ 1] & 0x30) << 4) |
939 dev_dbg(&ts
->client
->dev
,
940 "n_fingers: %u, state: %04x\n", n_fingers
, finger_state
);
942 /* Note: all fingers have the same tool type */
943 tool_type
= buf
[FW_POS_TOOL_TYPE
] & BIT(0) ?
944 MT_TOOL_FINGER
: MT_TOOL_PALM
;
946 for (i
= 0; i
< MAX_CONTACT_NUM
&& n_fingers
; i
++) {
947 if (finger_state
& 1) {
948 unsigned int x
, y
, p
, w
;
951 pos
= &buf
[FW_POS_XY
+ i
* 3];
952 x
= (((u16
)pos
[0] & 0xf0) << 4) | pos
[1];
953 y
= (((u16
)pos
[0] & 0x0f) << 8) | pos
[2];
956 * eKTF3624 may have use "old" touch-report format,
957 * depending on a device and TS firmware version.
958 * For example, ASUS Transformer devices use the "old"
959 * format, while ASUS Nexus 7 uses the "new" formant.
961 if (packet_size
== PACKET_SIZE_OLD
&&
962 ts
->chip_id
== EKTF3624
) {
963 w
= buf
[FW_POS_WIDTH
+ i
/ 2];
969 p
= buf
[FW_POS_PRESSURE
+ i
];
970 w
= buf
[FW_POS_WIDTH
+ i
];
973 dev_dbg(&ts
->client
->dev
, "i=%d x=%d y=%d p=%d w=%d\n",
976 input_mt_slot(input
, i
);
977 input_mt_report_slot_state(input
, tool_type
, true);
978 touchscreen_report_pos(input
, &ts
->prop
, x
, y
, true);
979 input_event(input
, EV_ABS
, ABS_MT_PRESSURE
, p
);
980 input_event(input
, EV_ABS
, ABS_MT_TOUCH_MAJOR
, w
);
988 input_mt_sync_frame(input
);
992 static u8
elants_i2c_calculate_checksum(u8
*buf
)
997 for (i
= 0; i
< FW_POS_CHECKSUM
; i
++)
1003 static void elants_i2c_event(struct elants_data
*ts
, u8
*buf
,
1006 u8 checksum
= elants_i2c_calculate_checksum(buf
);
1008 if (unlikely(buf
[FW_POS_CHECKSUM
] != checksum
))
1009 dev_warn(&ts
->client
->dev
,
1010 "%s: invalid checksum for packet %02x: %02x vs. %02x\n",
1011 __func__
, buf
[FW_POS_HEADER
],
1012 checksum
, buf
[FW_POS_CHECKSUM
]);
1013 else if (unlikely(buf
[FW_POS_HEADER
] != HEADER_REPORT_10_FINGER
))
1014 dev_warn(&ts
->client
->dev
,
1015 "%s: unknown packet type: %02x\n",
1016 __func__
, buf
[FW_POS_HEADER
]);
1018 elants_i2c_mt_event(ts
, buf
, packet_size
);
1021 static irqreturn_t
elants_i2c_irq(int irq
, void *_dev
)
1023 const u8 wait_packet
[] = { 0x64, 0x64, 0x64, 0x64 };
1024 struct elants_data
*ts
= _dev
;
1025 struct i2c_client
*client
= ts
->client
;
1026 int report_count
, report_len
;
1030 len
= i2c_master_recv_dmasafe(client
, ts
->buf
, sizeof(ts
->buf
));
1032 dev_err(&client
->dev
, "%s: failed to read data: %d\n",
1037 dev_dbg(&client
->dev
, "%s: packet %*ph\n",
1038 __func__
, HEADER_SIZE
, ts
->buf
);
1040 switch (ts
->state
) {
1041 case ELAN_WAIT_RECALIBRATION
:
1042 if (ts
->buf
[FW_HDR_TYPE
] == CMD_HEADER_REK
) {
1043 memcpy(ts
->cmd_resp
, ts
->buf
, sizeof(ts
->cmd_resp
));
1044 complete(&ts
->cmd_done
);
1045 ts
->state
= ELAN_STATE_NORMAL
;
1049 case ELAN_WAIT_QUEUE_HEADER
:
1050 if (ts
->buf
[FW_HDR_TYPE
] != QUEUE_HEADER_NORMAL
)
1053 ts
->state
= ELAN_STATE_NORMAL
;
1056 case ELAN_STATE_NORMAL
:
1058 switch (ts
->buf
[FW_HDR_TYPE
]) {
1059 case CMD_HEADER_HELLO
:
1060 case CMD_HEADER_RESP
:
1063 case QUEUE_HEADER_WAIT
:
1064 if (memcmp(ts
->buf
, wait_packet
, sizeof(wait_packet
))) {
1065 dev_err(&client
->dev
,
1066 "invalid wait packet %*ph\n",
1067 HEADER_SIZE
, ts
->buf
);
1069 ts
->state
= ELAN_WAIT_QUEUE_HEADER
;
1074 case QUEUE_HEADER_SINGLE
:
1075 elants_i2c_event(ts
, &ts
->buf
[HEADER_SIZE
],
1076 ts
->buf
[FW_HDR_LENGTH
]);
1079 case QUEUE_HEADER_NORMAL2
: /* CMD_HEADER_REK */
1081 * Depending on firmware version, eKTF3624 touchscreens
1082 * may utilize one of these opcodes for the touch events:
1083 * 0x63 (NORMAL) and 0x66 (NORMAL2). The 0x63 is used by
1084 * older firmware version and differs from 0x66 such that
1085 * touch pressure value needs to be adjusted. The 0x66
1086 * opcode of newer firmware is equal to 0x63 of eKTH3500.
1088 if (ts
->chip_id
!= EKTF3624
)
1093 case QUEUE_HEADER_NORMAL
:
1094 report_count
= ts
->buf
[FW_HDR_COUNT
];
1095 if (report_count
== 0 || report_count
> 3) {
1096 dev_err(&client
->dev
,
1097 "bad report count: %*ph\n",
1098 HEADER_SIZE
, ts
->buf
);
1102 report_len
= ts
->buf
[FW_HDR_LENGTH
] / report_count
;
1104 if (report_len
== PACKET_SIZE_OLD
&&
1105 ts
->chip_id
== EKTF3624
) {
1106 dev_dbg_once(&client
->dev
,
1107 "using old report format\n");
1108 } else if (report_len
!= PACKET_SIZE
) {
1109 dev_err(&client
->dev
,
1110 "mismatching report length: %*ph\n",
1111 HEADER_SIZE
, ts
->buf
);
1115 for (i
= 0; i
< report_count
; i
++) {
1116 u8
*buf
= ts
->buf
+ HEADER_SIZE
+
1118 elants_i2c_event(ts
, buf
, report_len
);
1123 dev_err(&client
->dev
, "unknown packet %*ph\n",
1124 HEADER_SIZE
, ts
->buf
);
1137 static ssize_t
calibrate_store(struct device
*dev
,
1138 struct device_attribute
*attr
,
1139 const char *buf
, size_t count
)
1141 struct i2c_client
*client
= to_i2c_client(dev
);
1142 struct elants_data
*ts
= i2c_get_clientdata(client
);
1145 error
= mutex_lock_interruptible(&ts
->sysfs_mutex
);
1149 error
= elants_i2c_calibrate(ts
);
1151 mutex_unlock(&ts
->sysfs_mutex
);
1152 return error
?: count
;
1155 static ssize_t
write_update_fw(struct device
*dev
,
1156 struct device_attribute
*attr
,
1157 const char *buf
, size_t count
)
1159 struct i2c_client
*client
= to_i2c_client(dev
);
1160 struct elants_data
*ts
= i2c_get_clientdata(client
);
1163 error
= mutex_lock_interruptible(&ts
->sysfs_mutex
);
1167 error
= elants_i2c_fw_update(ts
);
1168 dev_dbg(dev
, "firmware update result: %d\n", error
);
1170 mutex_unlock(&ts
->sysfs_mutex
);
1171 return error
?: count
;
1174 static ssize_t
show_iap_mode(struct device
*dev
,
1175 struct device_attribute
*attr
, char *buf
)
1177 struct i2c_client
*client
= to_i2c_client(dev
);
1178 struct elants_data
*ts
= i2c_get_clientdata(client
);
1180 return sprintf(buf
, "%s\n",
1181 ts
->iap_mode
== ELAN_IAP_OPERATIONAL
?
1182 "Normal" : "Recovery");
1185 static ssize_t
show_calibration_count(struct device
*dev
,
1186 struct device_attribute
*attr
, char *buf
)
1188 struct i2c_client
*client
= to_i2c_client(dev
);
1189 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_REK
, 0x00, 0x01 };
1190 u8 resp
[HEADER_SIZE
];
1194 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
1195 resp
, sizeof(resp
), 1,
1198 return sprintf(buf
, "%d\n", error
);
1200 rek_count
= get_unaligned_be16(&resp
[2]);
1201 return sprintf(buf
, "0x%04x\n", rek_count
);
1204 static DEVICE_ATTR_WO(calibrate
);
1205 static DEVICE_ATTR(iap_mode
, S_IRUGO
, show_iap_mode
, NULL
);
1206 static DEVICE_ATTR(calibration_count
, S_IRUGO
, show_calibration_count
, NULL
);
1207 static DEVICE_ATTR(update_fw
, S_IWUSR
, NULL
, write_update_fw
);
1209 struct elants_version_attribute
{
1210 struct device_attribute dattr
;
1211 size_t field_offset
;
1215 #define __ELANTS_FIELD_SIZE(_field) \
1216 sizeof(((struct elants_data *)NULL)->_field)
1217 #define __ELANTS_VERIFY_SIZE(_field) \
1218 (BUILD_BUG_ON_ZERO(__ELANTS_FIELD_SIZE(_field) > 2) + \
1219 __ELANTS_FIELD_SIZE(_field))
1220 #define ELANTS_VERSION_ATTR(_field) \
1221 struct elants_version_attribute elants_ver_attr_##_field = { \
1222 .dattr = __ATTR(_field, S_IRUGO, \
1223 elants_version_attribute_show, NULL), \
1224 .field_offset = offsetof(struct elants_data, _field), \
1225 .field_size = __ELANTS_VERIFY_SIZE(_field), \
1228 static ssize_t
elants_version_attribute_show(struct device
*dev
,
1229 struct device_attribute
*dattr
,
1232 struct i2c_client
*client
= to_i2c_client(dev
);
1233 struct elants_data
*ts
= i2c_get_clientdata(client
);
1234 struct elants_version_attribute
*attr
=
1235 container_of(dattr
, struct elants_version_attribute
, dattr
);
1236 u8
*field
= (u8
*)((char *)ts
+ attr
->field_offset
);
1237 unsigned int fmt_size
;
1240 if (attr
->field_size
== 1) {
1242 fmt_size
= 2; /* 2 HEX digits */
1244 val
= *(u16
*)field
;
1245 fmt_size
= 4; /* 4 HEX digits */
1248 return sprintf(buf
, "%0*x\n", fmt_size
, val
);
1251 static ELANTS_VERSION_ATTR(fw_version
);
1252 static ELANTS_VERSION_ATTR(hw_version
);
1253 static ELANTS_VERSION_ATTR(test_version
);
1254 static ELANTS_VERSION_ATTR(solution_version
);
1255 static ELANTS_VERSION_ATTR(bc_version
);
1256 static ELANTS_VERSION_ATTR(iap_version
);
1258 static struct attribute
*elants_attributes
[] = {
1259 &dev_attr_calibrate
.attr
,
1260 &dev_attr_update_fw
.attr
,
1261 &dev_attr_iap_mode
.attr
,
1262 &dev_attr_calibration_count
.attr
,
1264 &elants_ver_attr_fw_version
.dattr
.attr
,
1265 &elants_ver_attr_hw_version
.dattr
.attr
,
1266 &elants_ver_attr_test_version
.dattr
.attr
,
1267 &elants_ver_attr_solution_version
.dattr
.attr
,
1268 &elants_ver_attr_bc_version
.dattr
.attr
,
1269 &elants_ver_attr_iap_version
.dattr
.attr
,
1273 static const struct attribute_group elants_attribute_group
= {
1274 .attrs
= elants_attributes
,
1277 static int elants_i2c_power_on(struct elants_data
*ts
)
1282 * If we do not have reset gpio assume platform firmware
1283 * controls regulators and does power them on for us.
1285 if (IS_ERR_OR_NULL(ts
->reset_gpio
))
1288 gpiod_set_value_cansleep(ts
->reset_gpio
, 1);
1290 error
= regulator_enable(ts
->vcc33
);
1292 dev_err(&ts
->client
->dev
,
1293 "failed to enable vcc33 regulator: %d\n",
1295 goto release_reset_gpio
;
1298 error
= regulator_enable(ts
->vccio
);
1300 dev_err(&ts
->client
->dev
,
1301 "failed to enable vccio regulator: %d\n",
1303 regulator_disable(ts
->vcc33
);
1304 goto release_reset_gpio
;
1308 * We need to wait a bit after powering on controller before
1309 * we are allowed to release reset GPIO.
1311 udelay(ELAN_POWERON_DELAY_USEC
);
1314 gpiod_set_value_cansleep(ts
->reset_gpio
, 0);
1318 msleep(ELAN_RESET_DELAY_MSEC
);
1323 static void elants_i2c_power_off(void *_data
)
1325 struct elants_data
*ts
= _data
;
1327 if (!IS_ERR_OR_NULL(ts
->reset_gpio
)) {
1329 * Activate reset gpio to prevent leakage through the
1330 * pin once we shut off power to the controller.
1332 gpiod_set_value_cansleep(ts
->reset_gpio
, 1);
1333 regulator_disable(ts
->vccio
);
1334 regulator_disable(ts
->vcc33
);
1338 static int elants_i2c_probe(struct i2c_client
*client
,
1339 const struct i2c_device_id
*id
)
1341 union i2c_smbus_data dummy
;
1342 struct elants_data
*ts
;
1343 unsigned long irqflags
;
1346 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
)) {
1347 dev_err(&client
->dev
,
1348 "%s: i2c check functionality error\n", DEVICE_NAME
);
1352 ts
= devm_kzalloc(&client
->dev
, sizeof(struct elants_data
), GFP_KERNEL
);
1356 mutex_init(&ts
->sysfs_mutex
);
1357 init_completion(&ts
->cmd_done
);
1359 ts
->client
= client
;
1360 ts
->chip_id
= (enum elants_chip_id
)id
->driver_data
;
1361 i2c_set_clientdata(client
, ts
);
1363 ts
->vcc33
= devm_regulator_get(&client
->dev
, "vcc33");
1364 if (IS_ERR(ts
->vcc33
)) {
1365 error
= PTR_ERR(ts
->vcc33
);
1366 if (error
!= -EPROBE_DEFER
)
1367 dev_err(&client
->dev
,
1368 "Failed to get 'vcc33' regulator: %d\n",
1373 ts
->vccio
= devm_regulator_get(&client
->dev
, "vccio");
1374 if (IS_ERR(ts
->vccio
)) {
1375 error
= PTR_ERR(ts
->vccio
);
1376 if (error
!= -EPROBE_DEFER
)
1377 dev_err(&client
->dev
,
1378 "Failed to get 'vccio' regulator: %d\n",
1383 ts
->reset_gpio
= devm_gpiod_get(&client
->dev
, "reset", GPIOD_OUT_LOW
);
1384 if (IS_ERR(ts
->reset_gpio
)) {
1385 error
= PTR_ERR(ts
->reset_gpio
);
1387 if (error
== -EPROBE_DEFER
)
1390 if (error
!= -ENOENT
&& error
!= -ENOSYS
) {
1391 dev_err(&client
->dev
,
1392 "failed to get reset gpio: %d\n",
1397 ts
->keep_power_in_suspend
= true;
1400 error
= elants_i2c_power_on(ts
);
1404 error
= devm_add_action(&client
->dev
, elants_i2c_power_off
, ts
);
1406 dev_err(&client
->dev
,
1407 "failed to install power off action: %d\n", error
);
1408 elants_i2c_power_off(ts
);
1412 /* Make sure there is something at this address */
1413 if (i2c_smbus_xfer(client
->adapter
, client
->addr
, 0,
1414 I2C_SMBUS_READ
, 0, I2C_SMBUS_BYTE
, &dummy
) < 0) {
1415 dev_err(&client
->dev
, "nothing at this address\n");
1419 error
= elants_i2c_initialize(ts
);
1421 dev_err(&client
->dev
, "failed to initialize: %d\n", error
);
1425 ts
->input
= devm_input_allocate_device(&client
->dev
);
1427 dev_err(&client
->dev
, "Failed to allocate input device\n");
1431 ts
->input
->name
= "Elan Touchscreen";
1432 ts
->input
->id
.bustype
= BUS_I2C
;
1434 /* Multitouch input params setup */
1436 input_set_abs_params(ts
->input
, ABS_MT_POSITION_X
, 0, ts
->x_max
, 0, 0);
1437 input_set_abs_params(ts
->input
, ABS_MT_POSITION_Y
, 0, ts
->y_max
, 0, 0);
1438 input_set_abs_params(ts
->input
, ABS_MT_TOUCH_MAJOR
, 0, 255, 0, 0);
1439 input_set_abs_params(ts
->input
, ABS_MT_PRESSURE
, 0, 255, 0, 0);
1440 input_set_abs_params(ts
->input
, ABS_MT_TOOL_TYPE
,
1441 0, MT_TOOL_PALM
, 0, 0);
1443 touchscreen_parse_properties(ts
->input
, true, &ts
->prop
);
1445 if (ts
->chip_id
== EKTF3624
) {
1446 /* calculate resolution from size */
1447 ts
->x_res
= DIV_ROUND_CLOSEST(ts
->prop
.max_x
, ts
->phy_x
);
1448 ts
->y_res
= DIV_ROUND_CLOSEST(ts
->prop
.max_y
, ts
->phy_y
);
1451 input_abs_set_res(ts
->input
, ABS_MT_POSITION_X
, ts
->x_res
);
1452 input_abs_set_res(ts
->input
, ABS_MT_POSITION_Y
, ts
->y_res
);
1453 if (ts
->major_res
> 0)
1454 input_abs_set_res(ts
->input
, ABS_MT_TOUCH_MAJOR
, ts
->major_res
);
1456 error
= input_mt_init_slots(ts
->input
, MAX_CONTACT_NUM
,
1457 INPUT_MT_DIRECT
| INPUT_MT_DROP_UNUSED
);
1459 dev_err(&client
->dev
,
1460 "failed to initialize MT slots: %d\n", error
);
1464 error
= input_register_device(ts
->input
);
1466 dev_err(&client
->dev
,
1467 "unable to register input device: %d\n", error
);
1472 * Platform code (ACPI, DTS) should normally set up interrupt
1473 * for us, but in case it did not let's fall back to using falling
1474 * edge to be compatible with older Chromebooks.
1476 irqflags
= irq_get_trigger_type(client
->irq
);
1478 irqflags
= IRQF_TRIGGER_FALLING
;
1480 error
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
1481 NULL
, elants_i2c_irq
,
1482 irqflags
| IRQF_ONESHOT
,
1485 dev_err(&client
->dev
, "Failed to register interrupt\n");
1490 * Systems using device tree should set up wakeup via DTS,
1491 * the rest will configure device as wakeup source by default.
1493 if (!client
->dev
.of_node
)
1494 device_init_wakeup(&client
->dev
, true);
1496 error
= devm_device_add_group(&client
->dev
, &elants_attribute_group
);
1498 dev_err(&client
->dev
, "failed to create sysfs attributes: %d\n",
1506 static int __maybe_unused
elants_i2c_suspend(struct device
*dev
)
1508 struct i2c_client
*client
= to_i2c_client(dev
);
1509 struct elants_data
*ts
= i2c_get_clientdata(client
);
1510 const u8 set_sleep_cmd
[] = {
1511 CMD_HEADER_WRITE
, E_POWER_STATE_SLEEP
, 0x00, 0x01
1516 /* Command not support in IAP recovery mode */
1517 if (ts
->iap_mode
!= ELAN_IAP_OPERATIONAL
)
1520 disable_irq(client
->irq
);
1522 if (device_may_wakeup(dev
)) {
1524 * The device will automatically enter idle mode
1525 * that has reduced power consumption.
1527 ts
->wake_irq_enabled
= (enable_irq_wake(client
->irq
) == 0);
1528 } else if (ts
->keep_power_in_suspend
) {
1529 for (retry_cnt
= 0; retry_cnt
< MAX_RETRIES
; retry_cnt
++) {
1530 error
= elants_i2c_send(client
, set_sleep_cmd
,
1531 sizeof(set_sleep_cmd
));
1535 dev_err(&client
->dev
,
1536 "suspend command failed: %d\n", error
);
1539 elants_i2c_power_off(ts
);
1545 static int __maybe_unused
elants_i2c_resume(struct device
*dev
)
1547 struct i2c_client
*client
= to_i2c_client(dev
);
1548 struct elants_data
*ts
= i2c_get_clientdata(client
);
1549 const u8 set_active_cmd
[] = {
1550 CMD_HEADER_WRITE
, E_POWER_STATE_RESUME
, 0x00, 0x01
1555 if (device_may_wakeup(dev
)) {
1556 if (ts
->wake_irq_enabled
)
1557 disable_irq_wake(client
->irq
);
1558 elants_i2c_sw_reset(client
);
1559 } else if (ts
->keep_power_in_suspend
) {
1560 for (retry_cnt
= 0; retry_cnt
< MAX_RETRIES
; retry_cnt
++) {
1561 error
= elants_i2c_send(client
, set_active_cmd
,
1562 sizeof(set_active_cmd
));
1566 dev_err(&client
->dev
,
1567 "resume command failed: %d\n", error
);
1570 elants_i2c_power_on(ts
);
1571 elants_i2c_initialize(ts
);
1574 ts
->state
= ELAN_STATE_NORMAL
;
1575 enable_irq(client
->irq
);
1580 static SIMPLE_DEV_PM_OPS(elants_i2c_pm_ops
,
1581 elants_i2c_suspend
, elants_i2c_resume
);
1583 static const struct i2c_device_id elants_i2c_id
[] = {
1584 { DEVICE_NAME
, EKTH3500
},
1585 { "ekth3500", EKTH3500
},
1586 { "ektf3624", EKTF3624
},
1589 MODULE_DEVICE_TABLE(i2c
, elants_i2c_id
);
1592 static const struct acpi_device_id elants_acpi_id
[] = {
1593 { "ELAN0001", EKTH3500
},
1596 MODULE_DEVICE_TABLE(acpi
, elants_acpi_id
);
1600 static const struct of_device_id elants_of_match
[] = {
1601 { .compatible
= "elan,ekth3500" },
1602 { .compatible
= "elan,ektf3624" },
1605 MODULE_DEVICE_TABLE(of
, elants_of_match
);
1608 static struct i2c_driver elants_i2c_driver
= {
1609 .probe
= elants_i2c_probe
,
1610 .id_table
= elants_i2c_id
,
1612 .name
= DEVICE_NAME
,
1613 .pm
= &elants_i2c_pm_ops
,
1614 .acpi_match_table
= ACPI_PTR(elants_acpi_id
),
1615 .of_match_table
= of_match_ptr(elants_of_match
),
1616 .probe_type
= PROBE_PREFER_ASYNCHRONOUS
,
1619 module_i2c_driver(elants_i2c_driver
);
1621 MODULE_AUTHOR("Scott Liu <scott.liu@emc.com.tw>");
1622 MODULE_DESCRIPTION("Elan I2c Touchscreen driver");
1623 MODULE_LICENSE("GPL");