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
60 /* Command header definition */
61 #define CMD_HEADER_WRITE 0x54
62 #define CMD_HEADER_READ 0x53
63 #define CMD_HEADER_6B_READ 0x5B
64 #define CMD_HEADER_ROM_READ 0x96
65 #define CMD_HEADER_RESP 0x52
66 #define CMD_HEADER_6B_RESP 0x9B
67 #define CMD_HEADER_ROM_RESP 0x95
68 #define CMD_HEADER_HELLO 0x55
69 #define CMD_HEADER_REK 0x66
71 /* FW position data */
72 #define PACKET_SIZE 55
73 #define MAX_CONTACT_NUM 10
74 #define FW_POS_HEADER 0
75 #define FW_POS_STATE 1
76 #define FW_POS_TOTAL 2
78 #define FW_POS_TOOL_TYPE 33
79 #define FW_POS_CHECKSUM 34
80 #define FW_POS_WIDTH 35
81 #define FW_POS_PRESSURE 45
83 #define HEADER_REPORT_10_FINGER 0x62
85 /* Header (4 bytes) plus 3 fill 10-finger packets */
86 #define MAX_PACKET_SIZE 169
88 #define BOOT_TIME_DELAY_MS 50
90 /* FW read command, 0x53 0x?? 0x0, 0x01 */
91 #define E_ELAN_INFO_FW_VER 0x00
92 #define E_ELAN_INFO_BC_VER 0x10
93 #define E_ELAN_INFO_REK 0xE0
94 #define E_ELAN_INFO_TEST_VER 0xE0
95 #define E_ELAN_INFO_FW_ID 0xF0
96 #define E_INFO_OSR 0xD6
97 #define E_INFO_PHY_SCAN 0xD7
98 #define E_INFO_PHY_DRIVER 0xD8
100 #define MAX_RETRIES 3
101 #define MAX_FW_UPDATE_RETRIES 30
103 #define ELAN_FW_PAGESIZE 132
105 /* calibration timeout definition */
106 #define ELAN_CALI_TIMEOUT_MSEC 12000
108 #define ELAN_POWERON_DELAY_USEC 500
109 #define ELAN_RESET_DELAY_MSEC 20
113 ELAN_WAIT_QUEUE_HEADER
,
114 ELAN_WAIT_RECALIBRATION
,
117 enum elants_iap_mode
{
118 ELAN_IAP_OPERATIONAL
,
122 /* struct elants_data - represents state of Elan touchscreen device */
124 struct i2c_client
*client
;
125 struct input_dev
*input
;
127 struct regulator
*vcc33
;
128 struct regulator
*vccio
;
129 struct gpio_desc
*reset_gpio
;
137 unsigned int x_res
; /* resolution in units/mm */
141 struct touchscreen_properties prop
;
143 enum elants_state state
;
144 enum elants_iap_mode iap_mode
;
146 /* Guards against concurrent access to the device via sysfs */
147 struct mutex sysfs_mutex
;
149 u8 cmd_resp
[HEADER_SIZE
];
150 struct completion cmd_done
;
152 bool wake_irq_enabled
;
153 bool keep_power_in_suspend
;
155 /* Must be last to be used for DMA operations */
156 u8 buf
[MAX_PACKET_SIZE
] ____cacheline_aligned
;
159 static int elants_i2c_send(struct i2c_client
*client
,
160 const void *data
, size_t size
)
164 ret
= i2c_master_send(client
, data
, size
);
171 dev_err(&client
->dev
, "%s failed (%*ph): %d\n",
172 __func__
, (int)size
, data
, ret
);
177 static int elants_i2c_read(struct i2c_client
*client
, void *data
, size_t size
)
181 ret
= i2c_master_recv(client
, data
, size
);
188 dev_err(&client
->dev
, "%s failed: %d\n", __func__
, ret
);
193 static int elants_i2c_execute_command(struct i2c_client
*client
,
194 const u8
*cmd
, size_t cmd_size
,
195 u8
*resp
, size_t resp_size
,
196 int retries
, const char *cmd_name
)
198 struct i2c_msg msgs
[2];
200 u8 expected_response
;
203 case CMD_HEADER_READ
:
204 expected_response
= CMD_HEADER_RESP
;
207 case CMD_HEADER_6B_READ
:
208 expected_response
= CMD_HEADER_6B_RESP
;
211 case CMD_HEADER_ROM_READ
:
212 expected_response
= CMD_HEADER_ROM_RESP
;
216 dev_err(&client
->dev
, "(%s): invalid command: %*ph\n",
217 cmd_name
, (int)cmd_size
, cmd
);
222 msgs
[0].addr
= client
->addr
;
223 msgs
[0].flags
= client
->flags
& I2C_M_TEN
;
224 msgs
[0].len
= cmd_size
;
225 msgs
[0].buf
= (u8
*)cmd
;
227 msgs
[1].addr
= client
->addr
;
228 msgs
[1].flags
= (client
->flags
& I2C_M_TEN
) | I2C_M_RD
;
229 msgs
[1].flags
|= I2C_M_RD
;
230 msgs
[1].len
= resp_size
;
233 ret
= i2c_transfer(client
->adapter
, msgs
, ARRAY_SIZE(msgs
));
236 dev_dbg(&client
->dev
,
237 "(%s) I2C transfer failed: %pe (retrying)\n",
238 cmd_name
, ERR_PTR(ret
));
242 dev_err(&client
->dev
,
243 "(%s) I2C transfer failed: %pe\n",
244 cmd_name
, ERR_PTR(ret
));
248 if (ret
!= ARRAY_SIZE(msgs
) ||
249 resp
[FW_HDR_TYPE
] != expected_response
) {
251 dev_dbg(&client
->dev
,
252 "(%s) unexpected response: %*ph (retrying)\n",
253 cmd_name
, ret
, resp
);
257 dev_err(&client
->dev
,
258 "(%s) unexpected response: %*ph\n",
259 cmd_name
, ret
, resp
);
267 static int elants_i2c_calibrate(struct elants_data
*ts
)
269 struct i2c_client
*client
= ts
->client
;
271 static const u8 w_flashkey
[] = { 0x54, 0xC0, 0xE1, 0x5A };
272 static const u8 rek
[] = { 0x54, 0x29, 0x00, 0x01 };
273 static const u8 rek_resp
[] = { CMD_HEADER_REK
, 0x66, 0x66, 0x66 };
275 disable_irq(client
->irq
);
277 ts
->state
= ELAN_WAIT_RECALIBRATION
;
278 reinit_completion(&ts
->cmd_done
);
280 elants_i2c_send(client
, w_flashkey
, sizeof(w_flashkey
));
281 elants_i2c_send(client
, rek
, sizeof(rek
));
283 enable_irq(client
->irq
);
285 ret
= wait_for_completion_interruptible_timeout(&ts
->cmd_done
,
286 msecs_to_jiffies(ELAN_CALI_TIMEOUT_MSEC
));
288 ts
->state
= ELAN_STATE_NORMAL
;
291 error
= ret
< 0 ? ret
: -ETIMEDOUT
;
292 dev_err(&client
->dev
,
293 "error while waiting for calibration to complete: %d\n",
298 if (memcmp(rek_resp
, ts
->cmd_resp
, sizeof(rek_resp
))) {
299 dev_err(&client
->dev
,
300 "unexpected calibration response: %*ph\n",
301 (int)sizeof(ts
->cmd_resp
), ts
->cmd_resp
);
308 static int elants_i2c_sw_reset(struct i2c_client
*client
)
310 const u8 soft_rst_cmd
[] = { 0x77, 0x77, 0x77, 0x77 };
313 error
= elants_i2c_send(client
, soft_rst_cmd
,
314 sizeof(soft_rst_cmd
));
316 dev_err(&client
->dev
, "software reset failed: %d\n", error
);
321 * We should wait at least 10 msec (but no more than 40) before
322 * sending fastboot or IAP command to the device.
329 static u16
elants_i2c_parse_version(u8
*buf
)
331 return get_unaligned_be32(buf
) >> 4;
334 static int elants_i2c_query_hw_version(struct elants_data
*ts
)
336 struct i2c_client
*client
= ts
->client
;
337 int retry_cnt
= MAX_RETRIES
;
338 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_FW_ID
, 0x00, 0x01 };
339 u8 resp
[HEADER_SIZE
];
342 while (retry_cnt
--) {
343 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
344 resp
, sizeof(resp
), 1,
349 ts
->hw_version
= elants_i2c_parse_version(resp
);
350 if (ts
->hw_version
!= 0xffff)
354 dev_err(&client
->dev
, "Invalid fw id: %#04x\n", ts
->hw_version
);
359 static int elants_i2c_query_fw_version(struct elants_data
*ts
)
361 struct i2c_client
*client
= ts
->client
;
362 int retry_cnt
= MAX_RETRIES
;
363 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_FW_VER
, 0x00, 0x01 };
364 u8 resp
[HEADER_SIZE
];
367 while (retry_cnt
--) {
368 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
369 resp
, sizeof(resp
), 1,
374 ts
->fw_version
= elants_i2c_parse_version(resp
);
375 if (ts
->fw_version
!= 0x0000 && ts
->fw_version
!= 0xffff)
378 dev_dbg(&client
->dev
, "(read fw version) resp %*phC\n",
379 (int)sizeof(resp
), resp
);
382 dev_err(&client
->dev
, "Invalid fw ver: %#04x\n", ts
->fw_version
);
387 static int elants_i2c_query_test_version(struct elants_data
*ts
)
389 struct i2c_client
*client
= ts
->client
;
392 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_TEST_VER
, 0x00, 0x01 };
393 u8 resp
[HEADER_SIZE
];
395 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
396 resp
, sizeof(resp
), MAX_RETRIES
,
397 "read test version");
399 dev_err(&client
->dev
, "Failed to read test version\n");
403 version
= elants_i2c_parse_version(resp
);
404 ts
->test_version
= version
>> 8;
405 ts
->solution_version
= version
& 0xff;
410 static int elants_i2c_query_bc_version(struct elants_data
*ts
)
412 struct i2c_client
*client
= ts
->client
;
413 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_BC_VER
, 0x00, 0x01 };
414 u8 resp
[HEADER_SIZE
];
418 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
419 resp
, sizeof(resp
), 1,
424 version
= elants_i2c_parse_version(resp
);
425 ts
->bc_version
= version
>> 8;
426 ts
->iap_version
= version
& 0xff;
431 static int elants_i2c_query_ts_info(struct elants_data
*ts
)
433 struct i2c_client
*client
= ts
->client
;
436 u16 phy_x
, phy_y
, rows
, cols
, osr
;
437 const u8 get_resolution_cmd
[] = {
438 CMD_HEADER_6B_READ
, 0x00, 0x00, 0x00, 0x00, 0x00
440 const u8 get_osr_cmd
[] = {
441 CMD_HEADER_READ
, E_INFO_OSR
, 0x00, 0x01
443 const u8 get_physical_scan_cmd
[] = {
444 CMD_HEADER_READ
, E_INFO_PHY_SCAN
, 0x00, 0x01
446 const u8 get_physical_drive_cmd
[] = {
447 CMD_HEADER_READ
, E_INFO_PHY_DRIVER
, 0x00, 0x01
450 /* Get trace number */
451 error
= elants_i2c_execute_command(client
,
453 sizeof(get_resolution_cmd
),
454 resp
, sizeof(resp
), 1,
459 rows
= resp
[2] + resp
[6] + resp
[10];
460 cols
= resp
[3] + resp
[7] + resp
[11];
462 /* Process mm_to_pixel information */
463 error
= elants_i2c_execute_command(client
,
464 get_osr_cmd
, sizeof(get_osr_cmd
),
465 resp
, sizeof(resp
), 1, "get osr");
471 error
= elants_i2c_execute_command(client
,
472 get_physical_scan_cmd
,
473 sizeof(get_physical_scan_cmd
),
474 resp
, sizeof(resp
), 1,
475 "get physical scan");
479 phy_x
= get_unaligned_be16(&resp
[2]);
481 error
= elants_i2c_execute_command(client
,
482 get_physical_drive_cmd
,
483 sizeof(get_physical_drive_cmd
),
484 resp
, sizeof(resp
), 1,
485 "get physical drive");
489 phy_y
= get_unaligned_be16(&resp
[2]);
491 dev_dbg(&client
->dev
, "phy_x=%d, phy_y=%d\n", phy_x
, phy_y
);
493 if (rows
== 0 || cols
== 0 || osr
== 0) {
494 dev_warn(&client
->dev
,
495 "invalid trace number data: %d, %d, %d\n",
498 /* translate trace number to TS resolution */
499 ts
->x_max
= ELAN_TS_RESOLUTION(rows
, osr
);
500 ts
->x_res
= DIV_ROUND_CLOSEST(ts
->x_max
, phy_x
);
501 ts
->y_max
= ELAN_TS_RESOLUTION(cols
, osr
);
502 ts
->y_res
= DIV_ROUND_CLOSEST(ts
->y_max
, phy_y
);
508 static int elants_i2c_fastboot(struct i2c_client
*client
)
510 const u8 boot_cmd
[] = { 0x4D, 0x61, 0x69, 0x6E };
513 error
= elants_i2c_send(client
, boot_cmd
, sizeof(boot_cmd
));
515 dev_err(&client
->dev
, "boot failed: %d\n", error
);
519 dev_dbg(&client
->dev
, "boot success -- 0x%x\n", client
->addr
);
523 static int elants_i2c_initialize(struct elants_data
*ts
)
525 struct i2c_client
*client
= ts
->client
;
526 int error
, error2
, retry_cnt
;
527 const u8 hello_packet
[] = { 0x55, 0x55, 0x55, 0x55 };
528 const u8 recov_packet
[] = { 0x55, 0x55, 0x80, 0x80 };
531 for (retry_cnt
= 0; retry_cnt
< MAX_RETRIES
; retry_cnt
++) {
532 error
= elants_i2c_sw_reset(client
);
534 /* Continue initializing if it's the last try */
535 if (retry_cnt
< MAX_RETRIES
- 1)
539 error
= elants_i2c_fastboot(client
);
541 /* Continue initializing if it's the last try */
542 if (retry_cnt
< MAX_RETRIES
- 1)
546 /* Wait for Hello packet */
547 msleep(BOOT_TIME_DELAY_MS
);
549 error
= elants_i2c_read(client
, buf
, sizeof(buf
));
551 dev_err(&client
->dev
,
552 "failed to read 'hello' packet: %d\n", error
);
553 } else if (!memcmp(buf
, hello_packet
, sizeof(hello_packet
))) {
554 ts
->iap_mode
= ELAN_IAP_OPERATIONAL
;
556 } else if (!memcmp(buf
, recov_packet
, sizeof(recov_packet
))) {
558 * Setting error code will mark device
559 * in recovery mode below.
565 dev_err(&client
->dev
,
566 "invalid 'hello' packet: %*ph\n",
567 (int)sizeof(buf
), buf
);
571 /* hw version is available even if device in recovery state */
572 error2
= elants_i2c_query_hw_version(ts
);
574 error2
= elants_i2c_query_bc_version(ts
);
579 error
= elants_i2c_query_fw_version(ts
);
581 error
= elants_i2c_query_test_version(ts
);
583 error
= elants_i2c_query_ts_info(ts
);
586 ts
->iap_mode
= ELAN_IAP_RECOVERY
;
592 * Firmware update interface.
595 static int elants_i2c_fw_write_page(struct i2c_client
*client
,
598 const u8 ack_ok
[] = { 0xaa, 0xaa };
603 for (retry
= 0; retry
< MAX_FW_UPDATE_RETRIES
; retry
++) {
604 error
= elants_i2c_send(client
, page
, ELAN_FW_PAGESIZE
);
606 dev_err(&client
->dev
,
607 "IAP Write Page failed: %d\n", error
);
611 error
= elants_i2c_read(client
, buf
, 2);
613 dev_err(&client
->dev
,
614 "IAP Ack read failed: %d\n", error
);
618 if (!memcmp(buf
, ack_ok
, sizeof(ack_ok
)))
622 dev_err(&client
->dev
,
623 "IAP Get Ack Error [%02x:%02x]\n",
630 static int elants_i2c_validate_remark_id(struct elants_data
*ts
,
631 const struct firmware
*fw
)
633 struct i2c_client
*client
= ts
->client
;
635 const u8 cmd
[] = { CMD_HEADER_ROM_READ
, 0x80, 0x1F, 0x00, 0x00, 0x21 };
637 u16 ts_remark_id
= 0;
638 u16 fw_remark_id
= 0;
640 /* Compare TS Remark ID and FW Remark ID */
641 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
643 1, "read Remark ID");
647 ts_remark_id
= get_unaligned_be16(&resp
[3]);
649 fw_remark_id
= get_unaligned_le16(&fw
->data
[fw
->size
- 4]);
651 if (fw_remark_id
!= ts_remark_id
) {
652 dev_err(&client
->dev
,
653 "Remark ID Mismatched: ts_remark_id=0x%04x, fw_remark_id=0x%04x.\n",
654 ts_remark_id
, fw_remark_id
);
661 static int elants_i2c_do_update_firmware(struct i2c_client
*client
,
662 const struct firmware
*fw
,
665 struct elants_data
*ts
= i2c_get_clientdata(client
);
666 const u8 enter_iap
[] = { 0x45, 0x49, 0x41, 0x50 };
667 const u8 enter_iap2
[] = { 0x54, 0x00, 0x12, 0x34 };
668 const u8 iap_ack
[] = { 0x55, 0xaa, 0x33, 0xcc };
669 const u8 close_idle
[] = { 0x54, 0x2c, 0x01, 0x01 };
672 int page
, n_fw_pages
;
674 bool check_remark_id
= ts
->iap_version
>= 0x60;
676 /* Recovery mode detection! */
678 dev_dbg(&client
->dev
, "Recovery mode procedure\n");
680 if (check_remark_id
) {
681 error
= elants_i2c_validate_remark_id(ts
, fw
);
686 error
= elants_i2c_send(client
, enter_iap2
, sizeof(enter_iap2
));
688 dev_err(&client
->dev
, "failed to enter IAP mode: %d\n",
693 /* Start IAP Procedure */
694 dev_dbg(&client
->dev
, "Normal IAP procedure\n");
696 /* Close idle mode */
697 error
= elants_i2c_send(client
, close_idle
, sizeof(close_idle
));
699 dev_err(&client
->dev
, "Failed close idle: %d\n", error
);
702 elants_i2c_sw_reset(client
);
705 if (check_remark_id
) {
706 error
= elants_i2c_validate_remark_id(ts
, fw
);
711 error
= elants_i2c_send(client
, enter_iap
, sizeof(enter_iap
));
713 dev_err(&client
->dev
, "failed to enter IAP mode: %d\n",
721 /* check IAP state */
722 error
= elants_i2c_read(client
, buf
, 4);
724 dev_err(&client
->dev
,
725 "failed to read IAP acknowledgement: %d\n",
730 if (memcmp(buf
, iap_ack
, sizeof(iap_ack
))) {
731 dev_err(&client
->dev
,
732 "failed to enter IAP: %*ph (expected %*ph)\n",
733 (int)sizeof(buf
), buf
, (int)sizeof(iap_ack
), iap_ack
);
737 dev_info(&client
->dev
, "successfully entered IAP mode");
739 send_id
= client
->addr
;
740 error
= elants_i2c_send(client
, &send_id
, 1);
742 dev_err(&client
->dev
, "sending dummy byte failed: %d\n",
747 /* Clear the last page of Master */
748 error
= elants_i2c_send(client
, fw
->data
, ELAN_FW_PAGESIZE
);
750 dev_err(&client
->dev
, "clearing of the last page failed: %d\n",
755 error
= elants_i2c_read(client
, buf
, 2);
757 dev_err(&client
->dev
,
758 "failed to read ACK for clearing the last page: %d\n",
763 n_fw_pages
= fw
->size
/ ELAN_FW_PAGESIZE
;
764 dev_dbg(&client
->dev
, "IAP Pages = %d\n", n_fw_pages
);
766 for (page
= 0; page
< n_fw_pages
; page
++) {
767 error
= elants_i2c_fw_write_page(client
,
768 fw
->data
+ page
* ELAN_FW_PAGESIZE
);
770 dev_err(&client
->dev
,
771 "failed to write FW page %d: %d\n",
777 /* Old iap needs to wait 200ms for WDT and rest is for hello packets */
780 dev_info(&client
->dev
, "firmware update completed\n");
784 static int elants_i2c_fw_update(struct elants_data
*ts
)
786 struct i2c_client
*client
= ts
->client
;
787 const struct firmware
*fw
;
791 fw_name
= kasprintf(GFP_KERNEL
, "elants_i2c_%04x.bin", ts
->hw_version
);
795 dev_info(&client
->dev
, "requesting fw name = %s\n", fw_name
);
796 error
= request_firmware(&fw
, fw_name
, &client
->dev
);
799 dev_err(&client
->dev
, "failed to request firmware: %d\n",
804 if (fw
->size
% ELAN_FW_PAGESIZE
) {
805 dev_err(&client
->dev
, "invalid firmware length: %zu\n",
811 disable_irq(client
->irq
);
813 error
= elants_i2c_do_update_firmware(client
, fw
,
814 ts
->iap_mode
== ELAN_IAP_RECOVERY
);
816 dev_err(&client
->dev
, "firmware update failed: %d\n", error
);
817 ts
->iap_mode
= ELAN_IAP_RECOVERY
;
821 error
= elants_i2c_initialize(ts
);
823 dev_err(&client
->dev
,
824 "failed to initialize device after firmware update: %d\n",
826 ts
->iap_mode
= ELAN_IAP_RECOVERY
;
830 ts
->iap_mode
= ELAN_IAP_OPERATIONAL
;
833 ts
->state
= ELAN_STATE_NORMAL
;
834 enable_irq(client
->irq
);
838 elants_i2c_calibrate(ts
);
840 release_firmware(fw
);
848 static void elants_i2c_mt_event(struct elants_data
*ts
, u8
*buf
)
850 struct input_dev
*input
= ts
->input
;
851 unsigned int n_fingers
;
852 unsigned int tool_type
;
856 n_fingers
= buf
[FW_POS_STATE
+ 1] & 0x0f;
857 finger_state
= ((buf
[FW_POS_STATE
+ 1] & 0x30) << 4) |
860 dev_dbg(&ts
->client
->dev
,
861 "n_fingers: %u, state: %04x\n", n_fingers
, finger_state
);
863 /* Note: all fingers have the same tool type */
864 tool_type
= buf
[FW_POS_TOOL_TYPE
] & BIT(0) ?
865 MT_TOOL_FINGER
: MT_TOOL_PALM
;
867 for (i
= 0; i
< MAX_CONTACT_NUM
&& n_fingers
; i
++) {
868 if (finger_state
& 1) {
869 unsigned int x
, y
, p
, w
;
872 pos
= &buf
[FW_POS_XY
+ i
* 3];
873 x
= (((u16
)pos
[0] & 0xf0) << 4) | pos
[1];
874 y
= (((u16
)pos
[0] & 0x0f) << 8) | pos
[2];
875 p
= buf
[FW_POS_PRESSURE
+ i
];
876 w
= buf
[FW_POS_WIDTH
+ i
];
878 dev_dbg(&ts
->client
->dev
, "i=%d x=%d y=%d p=%d w=%d\n",
881 input_mt_slot(input
, i
);
882 input_mt_report_slot_state(input
, tool_type
, true);
883 touchscreen_report_pos(input
, &ts
->prop
, x
, y
, true);
884 input_event(input
, EV_ABS
, ABS_MT_PRESSURE
, p
);
885 input_event(input
, EV_ABS
, ABS_MT_TOUCH_MAJOR
, w
);
893 input_mt_sync_frame(input
);
897 static u8
elants_i2c_calculate_checksum(u8
*buf
)
902 for (i
= 0; i
< FW_POS_CHECKSUM
; i
++)
908 static void elants_i2c_event(struct elants_data
*ts
, u8
*buf
)
910 u8 checksum
= elants_i2c_calculate_checksum(buf
);
912 if (unlikely(buf
[FW_POS_CHECKSUM
] != checksum
))
913 dev_warn(&ts
->client
->dev
,
914 "%s: invalid checksum for packet %02x: %02x vs. %02x\n",
915 __func__
, buf
[FW_POS_HEADER
],
916 checksum
, buf
[FW_POS_CHECKSUM
]);
917 else if (unlikely(buf
[FW_POS_HEADER
] != HEADER_REPORT_10_FINGER
))
918 dev_warn(&ts
->client
->dev
,
919 "%s: unknown packet type: %02x\n",
920 __func__
, buf
[FW_POS_HEADER
]);
922 elants_i2c_mt_event(ts
, buf
);
925 static irqreturn_t
elants_i2c_irq(int irq
, void *_dev
)
927 const u8 wait_packet
[] = { 0x64, 0x64, 0x64, 0x64 };
928 struct elants_data
*ts
= _dev
;
929 struct i2c_client
*client
= ts
->client
;
930 int report_count
, report_len
;
934 len
= i2c_master_recv_dmasafe(client
, ts
->buf
, sizeof(ts
->buf
));
936 dev_err(&client
->dev
, "%s: failed to read data: %d\n",
941 dev_dbg(&client
->dev
, "%s: packet %*ph\n",
942 __func__
, HEADER_SIZE
, ts
->buf
);
945 case ELAN_WAIT_RECALIBRATION
:
946 if (ts
->buf
[FW_HDR_TYPE
] == CMD_HEADER_REK
) {
947 memcpy(ts
->cmd_resp
, ts
->buf
, sizeof(ts
->cmd_resp
));
948 complete(&ts
->cmd_done
);
949 ts
->state
= ELAN_STATE_NORMAL
;
953 case ELAN_WAIT_QUEUE_HEADER
:
954 if (ts
->buf
[FW_HDR_TYPE
] != QUEUE_HEADER_NORMAL
)
957 ts
->state
= ELAN_STATE_NORMAL
;
960 case ELAN_STATE_NORMAL
:
962 switch (ts
->buf
[FW_HDR_TYPE
]) {
963 case CMD_HEADER_HELLO
:
964 case CMD_HEADER_RESP
:
968 case QUEUE_HEADER_WAIT
:
969 if (memcmp(ts
->buf
, wait_packet
, sizeof(wait_packet
))) {
970 dev_err(&client
->dev
,
971 "invalid wait packet %*ph\n",
972 HEADER_SIZE
, ts
->buf
);
974 ts
->state
= ELAN_WAIT_QUEUE_HEADER
;
979 case QUEUE_HEADER_SINGLE
:
980 elants_i2c_event(ts
, &ts
->buf
[HEADER_SIZE
]);
983 case QUEUE_HEADER_NORMAL
:
984 report_count
= ts
->buf
[FW_HDR_COUNT
];
985 if (report_count
== 0 || report_count
> 3) {
986 dev_err(&client
->dev
,
987 "bad report count: %*ph\n",
988 HEADER_SIZE
, ts
->buf
);
992 report_len
= ts
->buf
[FW_HDR_LENGTH
] / report_count
;
993 if (report_len
!= PACKET_SIZE
) {
994 dev_err(&client
->dev
,
995 "mismatching report length: %*ph\n",
996 HEADER_SIZE
, ts
->buf
);
1000 for (i
= 0; i
< report_count
; i
++) {
1001 u8
*buf
= ts
->buf
+ HEADER_SIZE
+
1003 elants_i2c_event(ts
, buf
);
1008 dev_err(&client
->dev
, "unknown packet %*ph\n",
1009 HEADER_SIZE
, ts
->buf
);
1022 static ssize_t
calibrate_store(struct device
*dev
,
1023 struct device_attribute
*attr
,
1024 const char *buf
, size_t count
)
1026 struct i2c_client
*client
= to_i2c_client(dev
);
1027 struct elants_data
*ts
= i2c_get_clientdata(client
);
1030 error
= mutex_lock_interruptible(&ts
->sysfs_mutex
);
1034 error
= elants_i2c_calibrate(ts
);
1036 mutex_unlock(&ts
->sysfs_mutex
);
1037 return error
?: count
;
1040 static ssize_t
write_update_fw(struct device
*dev
,
1041 struct device_attribute
*attr
,
1042 const char *buf
, size_t count
)
1044 struct i2c_client
*client
= to_i2c_client(dev
);
1045 struct elants_data
*ts
= i2c_get_clientdata(client
);
1048 error
= mutex_lock_interruptible(&ts
->sysfs_mutex
);
1052 error
= elants_i2c_fw_update(ts
);
1053 dev_dbg(dev
, "firmware update result: %d\n", error
);
1055 mutex_unlock(&ts
->sysfs_mutex
);
1056 return error
?: count
;
1059 static ssize_t
show_iap_mode(struct device
*dev
,
1060 struct device_attribute
*attr
, char *buf
)
1062 struct i2c_client
*client
= to_i2c_client(dev
);
1063 struct elants_data
*ts
= i2c_get_clientdata(client
);
1065 return sprintf(buf
, "%s\n",
1066 ts
->iap_mode
== ELAN_IAP_OPERATIONAL
?
1067 "Normal" : "Recovery");
1070 static ssize_t
show_calibration_count(struct device
*dev
,
1071 struct device_attribute
*attr
, char *buf
)
1073 struct i2c_client
*client
= to_i2c_client(dev
);
1074 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_REK
, 0x00, 0x01 };
1075 u8 resp
[HEADER_SIZE
];
1079 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
1080 resp
, sizeof(resp
), 1,
1083 return sprintf(buf
, "%d\n", error
);
1085 rek_count
= get_unaligned_be16(&resp
[2]);
1086 return sprintf(buf
, "0x%04x\n", rek_count
);
1089 static DEVICE_ATTR_WO(calibrate
);
1090 static DEVICE_ATTR(iap_mode
, S_IRUGO
, show_iap_mode
, NULL
);
1091 static DEVICE_ATTR(calibration_count
, S_IRUGO
, show_calibration_count
, NULL
);
1092 static DEVICE_ATTR(update_fw
, S_IWUSR
, NULL
, write_update_fw
);
1094 struct elants_version_attribute
{
1095 struct device_attribute dattr
;
1096 size_t field_offset
;
1100 #define __ELANTS_FIELD_SIZE(_field) \
1101 sizeof(((struct elants_data *)NULL)->_field)
1102 #define __ELANTS_VERIFY_SIZE(_field) \
1103 (BUILD_BUG_ON_ZERO(__ELANTS_FIELD_SIZE(_field) > 2) + \
1104 __ELANTS_FIELD_SIZE(_field))
1105 #define ELANTS_VERSION_ATTR(_field) \
1106 struct elants_version_attribute elants_ver_attr_##_field = { \
1107 .dattr = __ATTR(_field, S_IRUGO, \
1108 elants_version_attribute_show, NULL), \
1109 .field_offset = offsetof(struct elants_data, _field), \
1110 .field_size = __ELANTS_VERIFY_SIZE(_field), \
1113 static ssize_t
elants_version_attribute_show(struct device
*dev
,
1114 struct device_attribute
*dattr
,
1117 struct i2c_client
*client
= to_i2c_client(dev
);
1118 struct elants_data
*ts
= i2c_get_clientdata(client
);
1119 struct elants_version_attribute
*attr
=
1120 container_of(dattr
, struct elants_version_attribute
, dattr
);
1121 u8
*field
= (u8
*)((char *)ts
+ attr
->field_offset
);
1122 unsigned int fmt_size
;
1125 if (attr
->field_size
== 1) {
1127 fmt_size
= 2; /* 2 HEX digits */
1129 val
= *(u16
*)field
;
1130 fmt_size
= 4; /* 4 HEX digits */
1133 return sprintf(buf
, "%0*x\n", fmt_size
, val
);
1136 static ELANTS_VERSION_ATTR(fw_version
);
1137 static ELANTS_VERSION_ATTR(hw_version
);
1138 static ELANTS_VERSION_ATTR(test_version
);
1139 static ELANTS_VERSION_ATTR(solution_version
);
1140 static ELANTS_VERSION_ATTR(bc_version
);
1141 static ELANTS_VERSION_ATTR(iap_version
);
1143 static struct attribute
*elants_attributes
[] = {
1144 &dev_attr_calibrate
.attr
,
1145 &dev_attr_update_fw
.attr
,
1146 &dev_attr_iap_mode
.attr
,
1147 &dev_attr_calibration_count
.attr
,
1149 &elants_ver_attr_fw_version
.dattr
.attr
,
1150 &elants_ver_attr_hw_version
.dattr
.attr
,
1151 &elants_ver_attr_test_version
.dattr
.attr
,
1152 &elants_ver_attr_solution_version
.dattr
.attr
,
1153 &elants_ver_attr_bc_version
.dattr
.attr
,
1154 &elants_ver_attr_iap_version
.dattr
.attr
,
1158 static const struct attribute_group elants_attribute_group
= {
1159 .attrs
= elants_attributes
,
1162 static int elants_i2c_power_on(struct elants_data
*ts
)
1167 * If we do not have reset gpio assume platform firmware
1168 * controls regulators and does power them on for us.
1170 if (IS_ERR_OR_NULL(ts
->reset_gpio
))
1173 gpiod_set_value_cansleep(ts
->reset_gpio
, 1);
1175 error
= regulator_enable(ts
->vcc33
);
1177 dev_err(&ts
->client
->dev
,
1178 "failed to enable vcc33 regulator: %d\n",
1180 goto release_reset_gpio
;
1183 error
= regulator_enable(ts
->vccio
);
1185 dev_err(&ts
->client
->dev
,
1186 "failed to enable vccio regulator: %d\n",
1188 regulator_disable(ts
->vcc33
);
1189 goto release_reset_gpio
;
1193 * We need to wait a bit after powering on controller before
1194 * we are allowed to release reset GPIO.
1196 udelay(ELAN_POWERON_DELAY_USEC
);
1199 gpiod_set_value_cansleep(ts
->reset_gpio
, 0);
1203 msleep(ELAN_RESET_DELAY_MSEC
);
1208 static void elants_i2c_power_off(void *_data
)
1210 struct elants_data
*ts
= _data
;
1212 if (!IS_ERR_OR_NULL(ts
->reset_gpio
)) {
1214 * Activate reset gpio to prevent leakage through the
1215 * pin once we shut off power to the controller.
1217 gpiod_set_value_cansleep(ts
->reset_gpio
, 1);
1218 regulator_disable(ts
->vccio
);
1219 regulator_disable(ts
->vcc33
);
1223 static int elants_i2c_probe(struct i2c_client
*client
,
1224 const struct i2c_device_id
*id
)
1226 union i2c_smbus_data dummy
;
1227 struct elants_data
*ts
;
1228 unsigned long irqflags
;
1231 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
)) {
1232 dev_err(&client
->dev
,
1233 "%s: i2c check functionality error\n", DEVICE_NAME
);
1237 ts
= devm_kzalloc(&client
->dev
, sizeof(struct elants_data
), GFP_KERNEL
);
1241 mutex_init(&ts
->sysfs_mutex
);
1242 init_completion(&ts
->cmd_done
);
1244 ts
->client
= client
;
1245 i2c_set_clientdata(client
, ts
);
1247 ts
->vcc33
= devm_regulator_get(&client
->dev
, "vcc33");
1248 if (IS_ERR(ts
->vcc33
)) {
1249 error
= PTR_ERR(ts
->vcc33
);
1250 if (error
!= -EPROBE_DEFER
)
1251 dev_err(&client
->dev
,
1252 "Failed to get 'vcc33' regulator: %d\n",
1257 ts
->vccio
= devm_regulator_get(&client
->dev
, "vccio");
1258 if (IS_ERR(ts
->vccio
)) {
1259 error
= PTR_ERR(ts
->vccio
);
1260 if (error
!= -EPROBE_DEFER
)
1261 dev_err(&client
->dev
,
1262 "Failed to get 'vccio' regulator: %d\n",
1267 ts
->reset_gpio
= devm_gpiod_get(&client
->dev
, "reset", GPIOD_OUT_LOW
);
1268 if (IS_ERR(ts
->reset_gpio
)) {
1269 error
= PTR_ERR(ts
->reset_gpio
);
1271 if (error
== -EPROBE_DEFER
)
1274 if (error
!= -ENOENT
&& error
!= -ENOSYS
) {
1275 dev_err(&client
->dev
,
1276 "failed to get reset gpio: %d\n",
1281 ts
->keep_power_in_suspend
= true;
1284 error
= elants_i2c_power_on(ts
);
1288 error
= devm_add_action(&client
->dev
, elants_i2c_power_off
, ts
);
1290 dev_err(&client
->dev
,
1291 "failed to install power off action: %d\n", error
);
1292 elants_i2c_power_off(ts
);
1296 /* Make sure there is something at this address */
1297 if (i2c_smbus_xfer(client
->adapter
, client
->addr
, 0,
1298 I2C_SMBUS_READ
, 0, I2C_SMBUS_BYTE
, &dummy
) < 0) {
1299 dev_err(&client
->dev
, "nothing at this address\n");
1303 error
= elants_i2c_initialize(ts
);
1305 dev_err(&client
->dev
, "failed to initialize: %d\n", error
);
1309 ts
->input
= devm_input_allocate_device(&client
->dev
);
1311 dev_err(&client
->dev
, "Failed to allocate input device\n");
1315 ts
->input
->name
= "Elan Touchscreen";
1316 ts
->input
->id
.bustype
= BUS_I2C
;
1318 /* Multitouch input params setup */
1320 input_set_abs_params(ts
->input
, ABS_MT_POSITION_X
, 0, ts
->x_max
, 0, 0);
1321 input_set_abs_params(ts
->input
, ABS_MT_POSITION_Y
, 0, ts
->y_max
, 0, 0);
1322 input_set_abs_params(ts
->input
, ABS_MT_TOUCH_MAJOR
, 0, 255, 0, 0);
1323 input_set_abs_params(ts
->input
, ABS_MT_PRESSURE
, 0, 255, 0, 0);
1324 input_set_abs_params(ts
->input
, ABS_MT_TOOL_TYPE
,
1325 0, MT_TOOL_PALM
, 0, 0);
1326 input_abs_set_res(ts
->input
, ABS_MT_POSITION_X
, ts
->x_res
);
1327 input_abs_set_res(ts
->input
, ABS_MT_POSITION_Y
, ts
->y_res
);
1329 touchscreen_parse_properties(ts
->input
, true, &ts
->prop
);
1331 error
= input_mt_init_slots(ts
->input
, MAX_CONTACT_NUM
,
1332 INPUT_MT_DIRECT
| INPUT_MT_DROP_UNUSED
);
1334 dev_err(&client
->dev
,
1335 "failed to initialize MT slots: %d\n", error
);
1339 error
= input_register_device(ts
->input
);
1341 dev_err(&client
->dev
,
1342 "unable to register input device: %d\n", error
);
1347 * Platform code (ACPI, DTS) should normally set up interrupt
1348 * for us, but in case it did not let's fall back to using falling
1349 * edge to be compatible with older Chromebooks.
1351 irqflags
= irq_get_trigger_type(client
->irq
);
1353 irqflags
= IRQF_TRIGGER_FALLING
;
1355 error
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
1356 NULL
, elants_i2c_irq
,
1357 irqflags
| IRQF_ONESHOT
,
1360 dev_err(&client
->dev
, "Failed to register interrupt\n");
1365 * Systems using device tree should set up wakeup via DTS,
1366 * the rest will configure device as wakeup source by default.
1368 if (!client
->dev
.of_node
)
1369 device_init_wakeup(&client
->dev
, true);
1371 error
= devm_device_add_group(&client
->dev
, &elants_attribute_group
);
1373 dev_err(&client
->dev
, "failed to create sysfs attributes: %d\n",
1381 static int __maybe_unused
elants_i2c_suspend(struct device
*dev
)
1383 struct i2c_client
*client
= to_i2c_client(dev
);
1384 struct elants_data
*ts
= i2c_get_clientdata(client
);
1385 const u8 set_sleep_cmd
[] = { 0x54, 0x50, 0x00, 0x01 };
1389 /* Command not support in IAP recovery mode */
1390 if (ts
->iap_mode
!= ELAN_IAP_OPERATIONAL
)
1393 disable_irq(client
->irq
);
1395 if (device_may_wakeup(dev
)) {
1397 * The device will automatically enter idle mode
1398 * that has reduced power consumption.
1400 ts
->wake_irq_enabled
= (enable_irq_wake(client
->irq
) == 0);
1401 } else if (ts
->keep_power_in_suspend
) {
1402 for (retry_cnt
= 0; retry_cnt
< MAX_RETRIES
; retry_cnt
++) {
1403 error
= elants_i2c_send(client
, set_sleep_cmd
,
1404 sizeof(set_sleep_cmd
));
1408 dev_err(&client
->dev
,
1409 "suspend command failed: %d\n", error
);
1412 elants_i2c_power_off(ts
);
1418 static int __maybe_unused
elants_i2c_resume(struct device
*dev
)
1420 struct i2c_client
*client
= to_i2c_client(dev
);
1421 struct elants_data
*ts
= i2c_get_clientdata(client
);
1422 const u8 set_active_cmd
[] = { 0x54, 0x58, 0x00, 0x01 };
1426 if (device_may_wakeup(dev
)) {
1427 if (ts
->wake_irq_enabled
)
1428 disable_irq_wake(client
->irq
);
1429 elants_i2c_sw_reset(client
);
1430 } else if (ts
->keep_power_in_suspend
) {
1431 for (retry_cnt
= 0; retry_cnt
< MAX_RETRIES
; retry_cnt
++) {
1432 error
= elants_i2c_send(client
, set_active_cmd
,
1433 sizeof(set_active_cmd
));
1437 dev_err(&client
->dev
,
1438 "resume command failed: %d\n", error
);
1441 elants_i2c_power_on(ts
);
1442 elants_i2c_initialize(ts
);
1445 ts
->state
= ELAN_STATE_NORMAL
;
1446 enable_irq(client
->irq
);
1451 static SIMPLE_DEV_PM_OPS(elants_i2c_pm_ops
,
1452 elants_i2c_suspend
, elants_i2c_resume
);
1454 static const struct i2c_device_id elants_i2c_id
[] = {
1458 MODULE_DEVICE_TABLE(i2c
, elants_i2c_id
);
1461 static const struct acpi_device_id elants_acpi_id
[] = {
1465 MODULE_DEVICE_TABLE(acpi
, elants_acpi_id
);
1469 static const struct of_device_id elants_of_match
[] = {
1470 { .compatible
= "elan,ekth3500" },
1473 MODULE_DEVICE_TABLE(of
, elants_of_match
);
1476 static struct i2c_driver elants_i2c_driver
= {
1477 .probe
= elants_i2c_probe
,
1478 .id_table
= elants_i2c_id
,
1480 .name
= DEVICE_NAME
,
1481 .pm
= &elants_i2c_pm_ops
,
1482 .acpi_match_table
= ACPI_PTR(elants_acpi_id
),
1483 .of_match_table
= of_match_ptr(elants_of_match
),
1484 .probe_type
= PROBE_PREFER_ASYNCHRONOUS
,
1487 module_i2c_driver(elants_i2c_driver
);
1489 MODULE_AUTHOR("Scott Liu <scott.liu@emc.com.tw>");
1490 MODULE_DESCRIPTION("Elan I2c Touchscreen driver");
1491 MODULE_LICENSE("GPL");