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 0xD0
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
;
138 unsigned int x_res
; /* resolution in units/mm */
142 struct touchscreen_properties prop
;
144 enum elants_state state
;
145 enum elants_iap_mode iap_mode
;
147 /* Guards against concurrent access to the device via sysfs */
148 struct mutex sysfs_mutex
;
150 u8 cmd_resp
[HEADER_SIZE
];
151 struct completion cmd_done
;
153 bool wake_irq_enabled
;
154 bool keep_power_in_suspend
;
156 /* Must be last to be used for DMA operations */
157 u8 buf
[MAX_PACKET_SIZE
] ____cacheline_aligned
;
160 static int elants_i2c_send(struct i2c_client
*client
,
161 const void *data
, size_t size
)
165 ret
= i2c_master_send(client
, data
, size
);
172 dev_err(&client
->dev
, "%s failed (%*ph): %d\n",
173 __func__
, (int)size
, data
, ret
);
178 static int elants_i2c_read(struct i2c_client
*client
, void *data
, size_t size
)
182 ret
= i2c_master_recv(client
, data
, size
);
189 dev_err(&client
->dev
, "%s failed: %d\n", __func__
, ret
);
194 static int elants_i2c_execute_command(struct i2c_client
*client
,
195 const u8
*cmd
, size_t cmd_size
,
196 u8
*resp
, size_t resp_size
,
197 int retries
, const char *cmd_name
)
199 struct i2c_msg msgs
[2];
201 u8 expected_response
;
204 case CMD_HEADER_READ
:
205 expected_response
= CMD_HEADER_RESP
;
208 case CMD_HEADER_6B_READ
:
209 expected_response
= CMD_HEADER_6B_RESP
;
212 case CMD_HEADER_ROM_READ
:
213 expected_response
= CMD_HEADER_ROM_RESP
;
217 dev_err(&client
->dev
, "(%s): invalid command: %*ph\n",
218 cmd_name
, (int)cmd_size
, cmd
);
223 msgs
[0].addr
= client
->addr
;
224 msgs
[0].flags
= client
->flags
& I2C_M_TEN
;
225 msgs
[0].len
= cmd_size
;
226 msgs
[0].buf
= (u8
*)cmd
;
228 msgs
[1].addr
= client
->addr
;
229 msgs
[1].flags
= (client
->flags
& I2C_M_TEN
) | I2C_M_RD
;
230 msgs
[1].flags
|= I2C_M_RD
;
231 msgs
[1].len
= resp_size
;
234 ret
= i2c_transfer(client
->adapter
, msgs
, ARRAY_SIZE(msgs
));
237 dev_dbg(&client
->dev
,
238 "(%s) I2C transfer failed: %pe (retrying)\n",
239 cmd_name
, ERR_PTR(ret
));
243 dev_err(&client
->dev
,
244 "(%s) I2C transfer failed: %pe\n",
245 cmd_name
, ERR_PTR(ret
));
249 if (ret
!= ARRAY_SIZE(msgs
) ||
250 resp
[FW_HDR_TYPE
] != expected_response
) {
252 dev_dbg(&client
->dev
,
253 "(%s) unexpected response: %*ph (retrying)\n",
254 cmd_name
, ret
, resp
);
258 dev_err(&client
->dev
,
259 "(%s) unexpected response: %*ph\n",
260 cmd_name
, ret
, resp
);
268 static int elants_i2c_calibrate(struct elants_data
*ts
)
270 struct i2c_client
*client
= ts
->client
;
272 static const u8 w_flashkey
[] = { 0x54, 0xC0, 0xE1, 0x5A };
273 static const u8 rek
[] = { 0x54, 0x29, 0x00, 0x01 };
274 static const u8 rek_resp
[] = { CMD_HEADER_REK
, 0x66, 0x66, 0x66 };
276 disable_irq(client
->irq
);
278 ts
->state
= ELAN_WAIT_RECALIBRATION
;
279 reinit_completion(&ts
->cmd_done
);
281 elants_i2c_send(client
, w_flashkey
, sizeof(w_flashkey
));
282 elants_i2c_send(client
, rek
, sizeof(rek
));
284 enable_irq(client
->irq
);
286 ret
= wait_for_completion_interruptible_timeout(&ts
->cmd_done
,
287 msecs_to_jiffies(ELAN_CALI_TIMEOUT_MSEC
));
289 ts
->state
= ELAN_STATE_NORMAL
;
292 error
= ret
< 0 ? ret
: -ETIMEDOUT
;
293 dev_err(&client
->dev
,
294 "error while waiting for calibration to complete: %d\n",
299 if (memcmp(rek_resp
, ts
->cmd_resp
, sizeof(rek_resp
))) {
300 dev_err(&client
->dev
,
301 "unexpected calibration response: %*ph\n",
302 (int)sizeof(ts
->cmd_resp
), ts
->cmd_resp
);
309 static int elants_i2c_sw_reset(struct i2c_client
*client
)
311 const u8 soft_rst_cmd
[] = { 0x77, 0x77, 0x77, 0x77 };
314 error
= elants_i2c_send(client
, soft_rst_cmd
,
315 sizeof(soft_rst_cmd
));
317 dev_err(&client
->dev
, "software reset failed: %d\n", error
);
322 * We should wait at least 10 msec (but no more than 40) before
323 * sending fastboot or IAP command to the device.
330 static u16
elants_i2c_parse_version(u8
*buf
)
332 return get_unaligned_be32(buf
) >> 4;
335 static int elants_i2c_query_hw_version(struct elants_data
*ts
)
337 struct i2c_client
*client
= ts
->client
;
338 int retry_cnt
= MAX_RETRIES
;
339 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_FW_ID
, 0x00, 0x01 };
340 u8 resp
[HEADER_SIZE
];
343 while (retry_cnt
--) {
344 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
345 resp
, sizeof(resp
), 1,
350 ts
->hw_version
= elants_i2c_parse_version(resp
);
351 if (ts
->hw_version
!= 0xffff)
355 dev_err(&client
->dev
, "Invalid fw id: %#04x\n", ts
->hw_version
);
360 static int elants_i2c_query_fw_version(struct elants_data
*ts
)
362 struct i2c_client
*client
= ts
->client
;
363 int retry_cnt
= MAX_RETRIES
;
364 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_FW_VER
, 0x00, 0x01 };
365 u8 resp
[HEADER_SIZE
];
368 while (retry_cnt
--) {
369 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
370 resp
, sizeof(resp
), 1,
375 ts
->fw_version
= elants_i2c_parse_version(resp
);
376 if (ts
->fw_version
!= 0x0000 && ts
->fw_version
!= 0xffff)
379 dev_dbg(&client
->dev
, "(read fw version) resp %*phC\n",
380 (int)sizeof(resp
), resp
);
383 dev_err(&client
->dev
, "Invalid fw ver: %#04x\n", ts
->fw_version
);
388 static int elants_i2c_query_test_version(struct elants_data
*ts
)
390 struct i2c_client
*client
= ts
->client
;
393 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_TEST_VER
, 0x00, 0x01 };
394 u8 resp
[HEADER_SIZE
];
396 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
397 resp
, sizeof(resp
), MAX_RETRIES
,
398 "read test version");
400 dev_err(&client
->dev
, "Failed to read test version\n");
404 version
= elants_i2c_parse_version(resp
);
405 ts
->test_version
= version
>> 8;
406 ts
->solution_version
= version
& 0xff;
411 static int elants_i2c_query_bc_version(struct elants_data
*ts
)
413 struct i2c_client
*client
= ts
->client
;
414 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_BC_VER
, 0x00, 0x01 };
415 u8 resp
[HEADER_SIZE
];
419 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
420 resp
, sizeof(resp
), 1,
425 version
= elants_i2c_parse_version(resp
);
426 ts
->bc_version
= version
>> 8;
427 ts
->iap_version
= version
& 0xff;
432 static int elants_i2c_query_ts_info(struct elants_data
*ts
)
434 struct i2c_client
*client
= ts
->client
;
437 u16 phy_x
, phy_y
, rows
, cols
, osr
;
438 const u8 get_resolution_cmd
[] = {
439 CMD_HEADER_6B_READ
, 0x00, 0x00, 0x00, 0x00, 0x00
441 const u8 get_osr_cmd
[] = {
442 CMD_HEADER_READ
, E_INFO_OSR
, 0x00, 0x01
444 const u8 get_physical_scan_cmd
[] = {
445 CMD_HEADER_READ
, E_INFO_PHY_SCAN
, 0x00, 0x01
447 const u8 get_physical_drive_cmd
[] = {
448 CMD_HEADER_READ
, E_INFO_PHY_DRIVER
, 0x00, 0x01
451 /* Get trace number */
452 error
= elants_i2c_execute_command(client
,
454 sizeof(get_resolution_cmd
),
455 resp
, sizeof(resp
), 1,
460 rows
= resp
[2] + resp
[6] + resp
[10];
461 cols
= resp
[3] + resp
[7] + resp
[11];
463 /* Get report resolution value of ABS_MT_TOUCH_MAJOR */
464 ts
->major_res
= resp
[16];
466 /* Process mm_to_pixel information */
467 error
= elants_i2c_execute_command(client
,
468 get_osr_cmd
, sizeof(get_osr_cmd
),
469 resp
, sizeof(resp
), 1, "get osr");
475 error
= elants_i2c_execute_command(client
,
476 get_physical_scan_cmd
,
477 sizeof(get_physical_scan_cmd
),
478 resp
, sizeof(resp
), 1,
479 "get physical scan");
483 phy_x
= get_unaligned_be16(&resp
[2]);
485 error
= elants_i2c_execute_command(client
,
486 get_physical_drive_cmd
,
487 sizeof(get_physical_drive_cmd
),
488 resp
, sizeof(resp
), 1,
489 "get physical drive");
493 phy_y
= get_unaligned_be16(&resp
[2]);
495 dev_dbg(&client
->dev
, "phy_x=%d, phy_y=%d\n", phy_x
, phy_y
);
497 if (rows
== 0 || cols
== 0 || osr
== 0) {
498 dev_warn(&client
->dev
,
499 "invalid trace number data: %d, %d, %d\n",
502 /* translate trace number to TS resolution */
503 ts
->x_max
= ELAN_TS_RESOLUTION(rows
, osr
);
504 ts
->x_res
= DIV_ROUND_CLOSEST(ts
->x_max
, phy_x
);
505 ts
->y_max
= ELAN_TS_RESOLUTION(cols
, osr
);
506 ts
->y_res
= DIV_ROUND_CLOSEST(ts
->y_max
, phy_y
);
512 static int elants_i2c_fastboot(struct i2c_client
*client
)
514 const u8 boot_cmd
[] = { 0x4D, 0x61, 0x69, 0x6E };
517 error
= elants_i2c_send(client
, boot_cmd
, sizeof(boot_cmd
));
519 dev_err(&client
->dev
, "boot failed: %d\n", error
);
523 dev_dbg(&client
->dev
, "boot success -- 0x%x\n", client
->addr
);
527 static int elants_i2c_initialize(struct elants_data
*ts
)
529 struct i2c_client
*client
= ts
->client
;
530 int error
, error2
, retry_cnt
;
531 const u8 hello_packet
[] = { 0x55, 0x55, 0x55, 0x55 };
532 const u8 recov_packet
[] = { 0x55, 0x55, 0x80, 0x80 };
535 for (retry_cnt
= 0; retry_cnt
< MAX_RETRIES
; retry_cnt
++) {
536 error
= elants_i2c_sw_reset(client
);
538 /* Continue initializing if it's the last try */
539 if (retry_cnt
< MAX_RETRIES
- 1)
543 error
= elants_i2c_fastboot(client
);
545 /* Continue initializing if it's the last try */
546 if (retry_cnt
< MAX_RETRIES
- 1)
550 /* Wait for Hello packet */
551 msleep(BOOT_TIME_DELAY_MS
);
553 error
= elants_i2c_read(client
, buf
, sizeof(buf
));
555 dev_err(&client
->dev
,
556 "failed to read 'hello' packet: %d\n", error
);
557 } else if (!memcmp(buf
, hello_packet
, sizeof(hello_packet
))) {
558 ts
->iap_mode
= ELAN_IAP_OPERATIONAL
;
560 } else if (!memcmp(buf
, recov_packet
, sizeof(recov_packet
))) {
562 * Setting error code will mark device
563 * in recovery mode below.
569 dev_err(&client
->dev
,
570 "invalid 'hello' packet: %*ph\n",
571 (int)sizeof(buf
), buf
);
575 /* hw version is available even if device in recovery state */
576 error2
= elants_i2c_query_hw_version(ts
);
578 error2
= elants_i2c_query_bc_version(ts
);
583 error
= elants_i2c_query_fw_version(ts
);
585 error
= elants_i2c_query_test_version(ts
);
587 error
= elants_i2c_query_ts_info(ts
);
590 ts
->iap_mode
= ELAN_IAP_RECOVERY
;
596 * Firmware update interface.
599 static int elants_i2c_fw_write_page(struct i2c_client
*client
,
602 const u8 ack_ok
[] = { 0xaa, 0xaa };
607 for (retry
= 0; retry
< MAX_FW_UPDATE_RETRIES
; retry
++) {
608 error
= elants_i2c_send(client
, page
, ELAN_FW_PAGESIZE
);
610 dev_err(&client
->dev
,
611 "IAP Write Page failed: %d\n", error
);
615 error
= elants_i2c_read(client
, buf
, 2);
617 dev_err(&client
->dev
,
618 "IAP Ack read failed: %d\n", error
);
622 if (!memcmp(buf
, ack_ok
, sizeof(ack_ok
)))
626 dev_err(&client
->dev
,
627 "IAP Get Ack Error [%02x:%02x]\n",
634 static int elants_i2c_validate_remark_id(struct elants_data
*ts
,
635 const struct firmware
*fw
)
637 struct i2c_client
*client
= ts
->client
;
639 const u8 cmd
[] = { CMD_HEADER_ROM_READ
, 0x80, 0x1F, 0x00, 0x00, 0x21 };
641 u16 ts_remark_id
= 0;
642 u16 fw_remark_id
= 0;
644 /* Compare TS Remark ID and FW Remark ID */
645 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
647 1, "read Remark ID");
651 ts_remark_id
= get_unaligned_be16(&resp
[3]);
653 fw_remark_id
= get_unaligned_le16(&fw
->data
[fw
->size
- 4]);
655 if (fw_remark_id
!= ts_remark_id
) {
656 dev_err(&client
->dev
,
657 "Remark ID Mismatched: ts_remark_id=0x%04x, fw_remark_id=0x%04x.\n",
658 ts_remark_id
, fw_remark_id
);
665 static int elants_i2c_do_update_firmware(struct i2c_client
*client
,
666 const struct firmware
*fw
,
669 struct elants_data
*ts
= i2c_get_clientdata(client
);
670 const u8 enter_iap
[] = { 0x45, 0x49, 0x41, 0x50 };
671 const u8 enter_iap2
[] = { 0x54, 0x00, 0x12, 0x34 };
672 const u8 iap_ack
[] = { 0x55, 0xaa, 0x33, 0xcc };
673 const u8 close_idle
[] = { 0x54, 0x2c, 0x01, 0x01 };
676 int page
, n_fw_pages
;
678 bool check_remark_id
= ts
->iap_version
>= 0x60;
680 /* Recovery mode detection! */
682 dev_dbg(&client
->dev
, "Recovery mode procedure\n");
684 if (check_remark_id
) {
685 error
= elants_i2c_validate_remark_id(ts
, fw
);
690 error
= elants_i2c_send(client
, enter_iap2
, sizeof(enter_iap2
));
692 dev_err(&client
->dev
, "failed to enter IAP mode: %d\n",
697 /* Start IAP Procedure */
698 dev_dbg(&client
->dev
, "Normal IAP procedure\n");
700 /* Close idle mode */
701 error
= elants_i2c_send(client
, close_idle
, sizeof(close_idle
));
703 dev_err(&client
->dev
, "Failed close idle: %d\n", error
);
706 elants_i2c_sw_reset(client
);
709 if (check_remark_id
) {
710 error
= elants_i2c_validate_remark_id(ts
, fw
);
715 error
= elants_i2c_send(client
, enter_iap
, sizeof(enter_iap
));
717 dev_err(&client
->dev
, "failed to enter IAP mode: %d\n",
725 /* check IAP state */
726 error
= elants_i2c_read(client
, buf
, 4);
728 dev_err(&client
->dev
,
729 "failed to read IAP acknowledgement: %d\n",
734 if (memcmp(buf
, iap_ack
, sizeof(iap_ack
))) {
735 dev_err(&client
->dev
,
736 "failed to enter IAP: %*ph (expected %*ph)\n",
737 (int)sizeof(buf
), buf
, (int)sizeof(iap_ack
), iap_ack
);
741 dev_info(&client
->dev
, "successfully entered IAP mode");
743 send_id
= client
->addr
;
744 error
= elants_i2c_send(client
, &send_id
, 1);
746 dev_err(&client
->dev
, "sending dummy byte failed: %d\n",
751 /* Clear the last page of Master */
752 error
= elants_i2c_send(client
, fw
->data
, ELAN_FW_PAGESIZE
);
754 dev_err(&client
->dev
, "clearing of the last page failed: %d\n",
759 error
= elants_i2c_read(client
, buf
, 2);
761 dev_err(&client
->dev
,
762 "failed to read ACK for clearing the last page: %d\n",
767 n_fw_pages
= fw
->size
/ ELAN_FW_PAGESIZE
;
768 dev_dbg(&client
->dev
, "IAP Pages = %d\n", n_fw_pages
);
770 for (page
= 0; page
< n_fw_pages
; page
++) {
771 error
= elants_i2c_fw_write_page(client
,
772 fw
->data
+ page
* ELAN_FW_PAGESIZE
);
774 dev_err(&client
->dev
,
775 "failed to write FW page %d: %d\n",
781 /* Old iap needs to wait 200ms for WDT and rest is for hello packets */
784 dev_info(&client
->dev
, "firmware update completed\n");
788 static int elants_i2c_fw_update(struct elants_data
*ts
)
790 struct i2c_client
*client
= ts
->client
;
791 const struct firmware
*fw
;
795 fw_name
= kasprintf(GFP_KERNEL
, "elants_i2c_%04x.bin", ts
->hw_version
);
799 dev_info(&client
->dev
, "requesting fw name = %s\n", fw_name
);
800 error
= request_firmware(&fw
, fw_name
, &client
->dev
);
803 dev_err(&client
->dev
, "failed to request firmware: %d\n",
808 if (fw
->size
% ELAN_FW_PAGESIZE
) {
809 dev_err(&client
->dev
, "invalid firmware length: %zu\n",
815 disable_irq(client
->irq
);
817 error
= elants_i2c_do_update_firmware(client
, fw
,
818 ts
->iap_mode
== ELAN_IAP_RECOVERY
);
820 dev_err(&client
->dev
, "firmware update failed: %d\n", error
);
821 ts
->iap_mode
= ELAN_IAP_RECOVERY
;
825 error
= elants_i2c_initialize(ts
);
827 dev_err(&client
->dev
,
828 "failed to initialize device after firmware update: %d\n",
830 ts
->iap_mode
= ELAN_IAP_RECOVERY
;
834 ts
->iap_mode
= ELAN_IAP_OPERATIONAL
;
837 ts
->state
= ELAN_STATE_NORMAL
;
838 enable_irq(client
->irq
);
842 elants_i2c_calibrate(ts
);
844 release_firmware(fw
);
852 static void elants_i2c_mt_event(struct elants_data
*ts
, u8
*buf
)
854 struct input_dev
*input
= ts
->input
;
855 unsigned int n_fingers
;
856 unsigned int tool_type
;
860 n_fingers
= buf
[FW_POS_STATE
+ 1] & 0x0f;
861 finger_state
= ((buf
[FW_POS_STATE
+ 1] & 0x30) << 4) |
864 dev_dbg(&ts
->client
->dev
,
865 "n_fingers: %u, state: %04x\n", n_fingers
, finger_state
);
867 /* Note: all fingers have the same tool type */
868 tool_type
= buf
[FW_POS_TOOL_TYPE
] & BIT(0) ?
869 MT_TOOL_FINGER
: MT_TOOL_PALM
;
871 for (i
= 0; i
< MAX_CONTACT_NUM
&& n_fingers
; i
++) {
872 if (finger_state
& 1) {
873 unsigned int x
, y
, p
, w
;
876 pos
= &buf
[FW_POS_XY
+ i
* 3];
877 x
= (((u16
)pos
[0] & 0xf0) << 4) | pos
[1];
878 y
= (((u16
)pos
[0] & 0x0f) << 8) | pos
[2];
879 p
= buf
[FW_POS_PRESSURE
+ i
];
880 w
= buf
[FW_POS_WIDTH
+ i
];
882 dev_dbg(&ts
->client
->dev
, "i=%d x=%d y=%d p=%d w=%d\n",
885 input_mt_slot(input
, i
);
886 input_mt_report_slot_state(input
, tool_type
, true);
887 touchscreen_report_pos(input
, &ts
->prop
, x
, y
, true);
888 input_event(input
, EV_ABS
, ABS_MT_PRESSURE
, p
);
889 input_event(input
, EV_ABS
, ABS_MT_TOUCH_MAJOR
, w
);
897 input_mt_sync_frame(input
);
901 static u8
elants_i2c_calculate_checksum(u8
*buf
)
906 for (i
= 0; i
< FW_POS_CHECKSUM
; i
++)
912 static void elants_i2c_event(struct elants_data
*ts
, u8
*buf
)
914 u8 checksum
= elants_i2c_calculate_checksum(buf
);
916 if (unlikely(buf
[FW_POS_CHECKSUM
] != checksum
))
917 dev_warn(&ts
->client
->dev
,
918 "%s: invalid checksum for packet %02x: %02x vs. %02x\n",
919 __func__
, buf
[FW_POS_HEADER
],
920 checksum
, buf
[FW_POS_CHECKSUM
]);
921 else if (unlikely(buf
[FW_POS_HEADER
] != HEADER_REPORT_10_FINGER
))
922 dev_warn(&ts
->client
->dev
,
923 "%s: unknown packet type: %02x\n",
924 __func__
, buf
[FW_POS_HEADER
]);
926 elants_i2c_mt_event(ts
, buf
);
929 static irqreturn_t
elants_i2c_irq(int irq
, void *_dev
)
931 const u8 wait_packet
[] = { 0x64, 0x64, 0x64, 0x64 };
932 struct elants_data
*ts
= _dev
;
933 struct i2c_client
*client
= ts
->client
;
934 int report_count
, report_len
;
938 len
= i2c_master_recv_dmasafe(client
, ts
->buf
, sizeof(ts
->buf
));
940 dev_err(&client
->dev
, "%s: failed to read data: %d\n",
945 dev_dbg(&client
->dev
, "%s: packet %*ph\n",
946 __func__
, HEADER_SIZE
, ts
->buf
);
949 case ELAN_WAIT_RECALIBRATION
:
950 if (ts
->buf
[FW_HDR_TYPE
] == CMD_HEADER_REK
) {
951 memcpy(ts
->cmd_resp
, ts
->buf
, sizeof(ts
->cmd_resp
));
952 complete(&ts
->cmd_done
);
953 ts
->state
= ELAN_STATE_NORMAL
;
957 case ELAN_WAIT_QUEUE_HEADER
:
958 if (ts
->buf
[FW_HDR_TYPE
] != QUEUE_HEADER_NORMAL
)
961 ts
->state
= ELAN_STATE_NORMAL
;
964 case ELAN_STATE_NORMAL
:
966 switch (ts
->buf
[FW_HDR_TYPE
]) {
967 case CMD_HEADER_HELLO
:
968 case CMD_HEADER_RESP
:
972 case QUEUE_HEADER_WAIT
:
973 if (memcmp(ts
->buf
, wait_packet
, sizeof(wait_packet
))) {
974 dev_err(&client
->dev
,
975 "invalid wait packet %*ph\n",
976 HEADER_SIZE
, ts
->buf
);
978 ts
->state
= ELAN_WAIT_QUEUE_HEADER
;
983 case QUEUE_HEADER_SINGLE
:
984 elants_i2c_event(ts
, &ts
->buf
[HEADER_SIZE
]);
987 case QUEUE_HEADER_NORMAL
:
988 report_count
= ts
->buf
[FW_HDR_COUNT
];
989 if (report_count
== 0 || report_count
> 3) {
990 dev_err(&client
->dev
,
991 "bad report count: %*ph\n",
992 HEADER_SIZE
, ts
->buf
);
996 report_len
= ts
->buf
[FW_HDR_LENGTH
] / report_count
;
997 if (report_len
!= PACKET_SIZE
) {
998 dev_err(&client
->dev
,
999 "mismatching report length: %*ph\n",
1000 HEADER_SIZE
, ts
->buf
);
1004 for (i
= 0; i
< report_count
; i
++) {
1005 u8
*buf
= ts
->buf
+ HEADER_SIZE
+
1007 elants_i2c_event(ts
, buf
);
1012 dev_err(&client
->dev
, "unknown packet %*ph\n",
1013 HEADER_SIZE
, ts
->buf
);
1026 static ssize_t
calibrate_store(struct device
*dev
,
1027 struct device_attribute
*attr
,
1028 const char *buf
, size_t count
)
1030 struct i2c_client
*client
= to_i2c_client(dev
);
1031 struct elants_data
*ts
= i2c_get_clientdata(client
);
1034 error
= mutex_lock_interruptible(&ts
->sysfs_mutex
);
1038 error
= elants_i2c_calibrate(ts
);
1040 mutex_unlock(&ts
->sysfs_mutex
);
1041 return error
?: count
;
1044 static ssize_t
write_update_fw(struct device
*dev
,
1045 struct device_attribute
*attr
,
1046 const char *buf
, size_t count
)
1048 struct i2c_client
*client
= to_i2c_client(dev
);
1049 struct elants_data
*ts
= i2c_get_clientdata(client
);
1052 error
= mutex_lock_interruptible(&ts
->sysfs_mutex
);
1056 error
= elants_i2c_fw_update(ts
);
1057 dev_dbg(dev
, "firmware update result: %d\n", error
);
1059 mutex_unlock(&ts
->sysfs_mutex
);
1060 return error
?: count
;
1063 static ssize_t
show_iap_mode(struct device
*dev
,
1064 struct device_attribute
*attr
, char *buf
)
1066 struct i2c_client
*client
= to_i2c_client(dev
);
1067 struct elants_data
*ts
= i2c_get_clientdata(client
);
1069 return sprintf(buf
, "%s\n",
1070 ts
->iap_mode
== ELAN_IAP_OPERATIONAL
?
1071 "Normal" : "Recovery");
1074 static ssize_t
show_calibration_count(struct device
*dev
,
1075 struct device_attribute
*attr
, char *buf
)
1077 struct i2c_client
*client
= to_i2c_client(dev
);
1078 const u8 cmd
[] = { CMD_HEADER_READ
, E_ELAN_INFO_REK
, 0x00, 0x01 };
1079 u8 resp
[HEADER_SIZE
];
1083 error
= elants_i2c_execute_command(client
, cmd
, sizeof(cmd
),
1084 resp
, sizeof(resp
), 1,
1087 return sprintf(buf
, "%d\n", error
);
1089 rek_count
= get_unaligned_be16(&resp
[2]);
1090 return sprintf(buf
, "0x%04x\n", rek_count
);
1093 static DEVICE_ATTR_WO(calibrate
);
1094 static DEVICE_ATTR(iap_mode
, S_IRUGO
, show_iap_mode
, NULL
);
1095 static DEVICE_ATTR(calibration_count
, S_IRUGO
, show_calibration_count
, NULL
);
1096 static DEVICE_ATTR(update_fw
, S_IWUSR
, NULL
, write_update_fw
);
1098 struct elants_version_attribute
{
1099 struct device_attribute dattr
;
1100 size_t field_offset
;
1104 #define __ELANTS_FIELD_SIZE(_field) \
1105 sizeof(((struct elants_data *)NULL)->_field)
1106 #define __ELANTS_VERIFY_SIZE(_field) \
1107 (BUILD_BUG_ON_ZERO(__ELANTS_FIELD_SIZE(_field) > 2) + \
1108 __ELANTS_FIELD_SIZE(_field))
1109 #define ELANTS_VERSION_ATTR(_field) \
1110 struct elants_version_attribute elants_ver_attr_##_field = { \
1111 .dattr = __ATTR(_field, S_IRUGO, \
1112 elants_version_attribute_show, NULL), \
1113 .field_offset = offsetof(struct elants_data, _field), \
1114 .field_size = __ELANTS_VERIFY_SIZE(_field), \
1117 static ssize_t
elants_version_attribute_show(struct device
*dev
,
1118 struct device_attribute
*dattr
,
1121 struct i2c_client
*client
= to_i2c_client(dev
);
1122 struct elants_data
*ts
= i2c_get_clientdata(client
);
1123 struct elants_version_attribute
*attr
=
1124 container_of(dattr
, struct elants_version_attribute
, dattr
);
1125 u8
*field
= (u8
*)((char *)ts
+ attr
->field_offset
);
1126 unsigned int fmt_size
;
1129 if (attr
->field_size
== 1) {
1131 fmt_size
= 2; /* 2 HEX digits */
1133 val
= *(u16
*)field
;
1134 fmt_size
= 4; /* 4 HEX digits */
1137 return sprintf(buf
, "%0*x\n", fmt_size
, val
);
1140 static ELANTS_VERSION_ATTR(fw_version
);
1141 static ELANTS_VERSION_ATTR(hw_version
);
1142 static ELANTS_VERSION_ATTR(test_version
);
1143 static ELANTS_VERSION_ATTR(solution_version
);
1144 static ELANTS_VERSION_ATTR(bc_version
);
1145 static ELANTS_VERSION_ATTR(iap_version
);
1147 static struct attribute
*elants_attributes
[] = {
1148 &dev_attr_calibrate
.attr
,
1149 &dev_attr_update_fw
.attr
,
1150 &dev_attr_iap_mode
.attr
,
1151 &dev_attr_calibration_count
.attr
,
1153 &elants_ver_attr_fw_version
.dattr
.attr
,
1154 &elants_ver_attr_hw_version
.dattr
.attr
,
1155 &elants_ver_attr_test_version
.dattr
.attr
,
1156 &elants_ver_attr_solution_version
.dattr
.attr
,
1157 &elants_ver_attr_bc_version
.dattr
.attr
,
1158 &elants_ver_attr_iap_version
.dattr
.attr
,
1162 static const struct attribute_group elants_attribute_group
= {
1163 .attrs
= elants_attributes
,
1166 static int elants_i2c_power_on(struct elants_data
*ts
)
1171 * If we do not have reset gpio assume platform firmware
1172 * controls regulators and does power them on for us.
1174 if (IS_ERR_OR_NULL(ts
->reset_gpio
))
1177 gpiod_set_value_cansleep(ts
->reset_gpio
, 1);
1179 error
= regulator_enable(ts
->vcc33
);
1181 dev_err(&ts
->client
->dev
,
1182 "failed to enable vcc33 regulator: %d\n",
1184 goto release_reset_gpio
;
1187 error
= regulator_enable(ts
->vccio
);
1189 dev_err(&ts
->client
->dev
,
1190 "failed to enable vccio regulator: %d\n",
1192 regulator_disable(ts
->vcc33
);
1193 goto release_reset_gpio
;
1197 * We need to wait a bit after powering on controller before
1198 * we are allowed to release reset GPIO.
1200 udelay(ELAN_POWERON_DELAY_USEC
);
1203 gpiod_set_value_cansleep(ts
->reset_gpio
, 0);
1207 msleep(ELAN_RESET_DELAY_MSEC
);
1212 static void elants_i2c_power_off(void *_data
)
1214 struct elants_data
*ts
= _data
;
1216 if (!IS_ERR_OR_NULL(ts
->reset_gpio
)) {
1218 * Activate reset gpio to prevent leakage through the
1219 * pin once we shut off power to the controller.
1221 gpiod_set_value_cansleep(ts
->reset_gpio
, 1);
1222 regulator_disable(ts
->vccio
);
1223 regulator_disable(ts
->vcc33
);
1227 static int elants_i2c_probe(struct i2c_client
*client
,
1228 const struct i2c_device_id
*id
)
1230 union i2c_smbus_data dummy
;
1231 struct elants_data
*ts
;
1232 unsigned long irqflags
;
1235 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
)) {
1236 dev_err(&client
->dev
,
1237 "%s: i2c check functionality error\n", DEVICE_NAME
);
1241 ts
= devm_kzalloc(&client
->dev
, sizeof(struct elants_data
), GFP_KERNEL
);
1245 mutex_init(&ts
->sysfs_mutex
);
1246 init_completion(&ts
->cmd_done
);
1248 ts
->client
= client
;
1249 i2c_set_clientdata(client
, ts
);
1251 ts
->vcc33
= devm_regulator_get(&client
->dev
, "vcc33");
1252 if (IS_ERR(ts
->vcc33
)) {
1253 error
= PTR_ERR(ts
->vcc33
);
1254 if (error
!= -EPROBE_DEFER
)
1255 dev_err(&client
->dev
,
1256 "Failed to get 'vcc33' regulator: %d\n",
1261 ts
->vccio
= devm_regulator_get(&client
->dev
, "vccio");
1262 if (IS_ERR(ts
->vccio
)) {
1263 error
= PTR_ERR(ts
->vccio
);
1264 if (error
!= -EPROBE_DEFER
)
1265 dev_err(&client
->dev
,
1266 "Failed to get 'vccio' regulator: %d\n",
1271 ts
->reset_gpio
= devm_gpiod_get(&client
->dev
, "reset", GPIOD_OUT_LOW
);
1272 if (IS_ERR(ts
->reset_gpio
)) {
1273 error
= PTR_ERR(ts
->reset_gpio
);
1275 if (error
== -EPROBE_DEFER
)
1278 if (error
!= -ENOENT
&& error
!= -ENOSYS
) {
1279 dev_err(&client
->dev
,
1280 "failed to get reset gpio: %d\n",
1285 ts
->keep_power_in_suspend
= true;
1288 error
= elants_i2c_power_on(ts
);
1292 error
= devm_add_action(&client
->dev
, elants_i2c_power_off
, ts
);
1294 dev_err(&client
->dev
,
1295 "failed to install power off action: %d\n", error
);
1296 elants_i2c_power_off(ts
);
1300 /* Make sure there is something at this address */
1301 if (i2c_smbus_xfer(client
->adapter
, client
->addr
, 0,
1302 I2C_SMBUS_READ
, 0, I2C_SMBUS_BYTE
, &dummy
) < 0) {
1303 dev_err(&client
->dev
, "nothing at this address\n");
1307 error
= elants_i2c_initialize(ts
);
1309 dev_err(&client
->dev
, "failed to initialize: %d\n", error
);
1313 ts
->input
= devm_input_allocate_device(&client
->dev
);
1315 dev_err(&client
->dev
, "Failed to allocate input device\n");
1319 ts
->input
->name
= "Elan Touchscreen";
1320 ts
->input
->id
.bustype
= BUS_I2C
;
1322 /* Multitouch input params setup */
1324 input_set_abs_params(ts
->input
, ABS_MT_POSITION_X
, 0, ts
->x_max
, 0, 0);
1325 input_set_abs_params(ts
->input
, ABS_MT_POSITION_Y
, 0, ts
->y_max
, 0, 0);
1326 input_set_abs_params(ts
->input
, ABS_MT_TOUCH_MAJOR
, 0, 255, 0, 0);
1327 input_set_abs_params(ts
->input
, ABS_MT_PRESSURE
, 0, 255, 0, 0);
1328 input_set_abs_params(ts
->input
, ABS_MT_TOOL_TYPE
,
1329 0, MT_TOOL_PALM
, 0, 0);
1330 input_abs_set_res(ts
->input
, ABS_MT_POSITION_X
, ts
->x_res
);
1331 input_abs_set_res(ts
->input
, ABS_MT_POSITION_Y
, ts
->y_res
);
1332 if (ts
->major_res
> 0)
1333 input_abs_set_res(ts
->input
, ABS_MT_TOUCH_MAJOR
, ts
->major_res
);
1335 touchscreen_parse_properties(ts
->input
, true, &ts
->prop
);
1337 error
= input_mt_init_slots(ts
->input
, MAX_CONTACT_NUM
,
1338 INPUT_MT_DIRECT
| INPUT_MT_DROP_UNUSED
);
1340 dev_err(&client
->dev
,
1341 "failed to initialize MT slots: %d\n", error
);
1345 error
= input_register_device(ts
->input
);
1347 dev_err(&client
->dev
,
1348 "unable to register input device: %d\n", error
);
1353 * Platform code (ACPI, DTS) should normally set up interrupt
1354 * for us, but in case it did not let's fall back to using falling
1355 * edge to be compatible with older Chromebooks.
1357 irqflags
= irq_get_trigger_type(client
->irq
);
1359 irqflags
= IRQF_TRIGGER_FALLING
;
1361 error
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
1362 NULL
, elants_i2c_irq
,
1363 irqflags
| IRQF_ONESHOT
,
1366 dev_err(&client
->dev
, "Failed to register interrupt\n");
1371 * Systems using device tree should set up wakeup via DTS,
1372 * the rest will configure device as wakeup source by default.
1374 if (!client
->dev
.of_node
)
1375 device_init_wakeup(&client
->dev
, true);
1377 error
= devm_device_add_group(&client
->dev
, &elants_attribute_group
);
1379 dev_err(&client
->dev
, "failed to create sysfs attributes: %d\n",
1387 static int __maybe_unused
elants_i2c_suspend(struct device
*dev
)
1389 struct i2c_client
*client
= to_i2c_client(dev
);
1390 struct elants_data
*ts
= i2c_get_clientdata(client
);
1391 const u8 set_sleep_cmd
[] = { 0x54, 0x50, 0x00, 0x01 };
1395 /* Command not support in IAP recovery mode */
1396 if (ts
->iap_mode
!= ELAN_IAP_OPERATIONAL
)
1399 disable_irq(client
->irq
);
1401 if (device_may_wakeup(dev
)) {
1403 * The device will automatically enter idle mode
1404 * that has reduced power consumption.
1406 ts
->wake_irq_enabled
= (enable_irq_wake(client
->irq
) == 0);
1407 } else if (ts
->keep_power_in_suspend
) {
1408 for (retry_cnt
= 0; retry_cnt
< MAX_RETRIES
; retry_cnt
++) {
1409 error
= elants_i2c_send(client
, set_sleep_cmd
,
1410 sizeof(set_sleep_cmd
));
1414 dev_err(&client
->dev
,
1415 "suspend command failed: %d\n", error
);
1418 elants_i2c_power_off(ts
);
1424 static int __maybe_unused
elants_i2c_resume(struct device
*dev
)
1426 struct i2c_client
*client
= to_i2c_client(dev
);
1427 struct elants_data
*ts
= i2c_get_clientdata(client
);
1428 const u8 set_active_cmd
[] = { 0x54, 0x58, 0x00, 0x01 };
1432 if (device_may_wakeup(dev
)) {
1433 if (ts
->wake_irq_enabled
)
1434 disable_irq_wake(client
->irq
);
1435 elants_i2c_sw_reset(client
);
1436 } else if (ts
->keep_power_in_suspend
) {
1437 for (retry_cnt
= 0; retry_cnt
< MAX_RETRIES
; retry_cnt
++) {
1438 error
= elants_i2c_send(client
, set_active_cmd
,
1439 sizeof(set_active_cmd
));
1443 dev_err(&client
->dev
,
1444 "resume command failed: %d\n", error
);
1447 elants_i2c_power_on(ts
);
1448 elants_i2c_initialize(ts
);
1451 ts
->state
= ELAN_STATE_NORMAL
;
1452 enable_irq(client
->irq
);
1457 static SIMPLE_DEV_PM_OPS(elants_i2c_pm_ops
,
1458 elants_i2c_suspend
, elants_i2c_resume
);
1460 static const struct i2c_device_id elants_i2c_id
[] = {
1464 MODULE_DEVICE_TABLE(i2c
, elants_i2c_id
);
1467 static const struct acpi_device_id elants_acpi_id
[] = {
1471 MODULE_DEVICE_TABLE(acpi
, elants_acpi_id
);
1475 static const struct of_device_id elants_of_match
[] = {
1476 { .compatible
= "elan,ekth3500" },
1479 MODULE_DEVICE_TABLE(of
, elants_of_match
);
1482 static struct i2c_driver elants_i2c_driver
= {
1483 .probe
= elants_i2c_probe
,
1484 .id_table
= elants_i2c_id
,
1486 .name
= DEVICE_NAME
,
1487 .pm
= &elants_i2c_pm_ops
,
1488 .acpi_match_table
= ACPI_PTR(elants_acpi_id
),
1489 .of_match_table
= of_match_ptr(elants_of_match
),
1490 .probe_type
= PROBE_PREFER_ASYNCHRONOUS
,
1493 module_i2c_driver(elants_i2c_driver
);
1495 MODULE_AUTHOR("Scott Liu <scott.liu@emc.com.tw>");
1496 MODULE_DESCRIPTION("Elan I2c Touchscreen driver");
1497 MODULE_LICENSE("GPL");