1 // SPDX-License-Identifier: GPL-2.0-only
3 * Elan I2C/SMBus Touchpad driver
5 * Copyright (c) 2013 ELAN Microelectronics Corp.
7 * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw>
8 * Author: KT Liao <kt.liao@emc.com.tw>
11 * Based on cyapa driver:
12 * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
13 * copyright (c) 2011-2012 Google, Inc.
15 * Trademarks are the property of their respective owners.
18 #include <linux/acpi.h>
19 #include <linux/delay.h>
20 #include <linux/device.h>
21 #include <linux/firmware.h>
22 #include <linux/i2c.h>
23 #include <linux/init.h>
24 #include <linux/input/mt.h>
25 #include <linux/interrupt.h>
26 #include <linux/irq.h>
27 #include <linux/module.h>
28 #include <linux/slab.h>
29 #include <linux/kernel.h>
30 #include <linux/sched.h>
31 #include <linux/input.h>
32 #include <linux/uaccess.h>
33 #include <linux/jiffies.h>
34 #include <linux/completion.h>
36 #include <linux/property.h>
37 #include <linux/regulator/consumer.h>
38 #include <asm/unaligned.h>
42 #define DRIVER_NAME "elan_i2c"
43 #define ELAN_VENDOR_ID 0x04f3
44 #define ETP_MAX_PRESSURE 255
45 #define ETP_FWIDTH_REDUCE 90
46 #define ETP_FINGER_WIDTH 15
47 #define ETP_RETRY_COUNT 3
49 /* quirks to control the device */
50 #define ETP_QUIRK_QUICK_WAKEUP BIT(0)
52 /* The main device structure */
54 struct i2c_client
*client
;
55 struct input_dev
*input
;
56 struct input_dev
*tp_input
; /* trackpoint input node */
57 struct regulator
*vcc
;
59 const struct elan_transport_ops
*ops
;
62 struct completion fw_completion
;
65 struct mutex sysfs_mutex
;
80 unsigned int report_features
;
81 unsigned int report_len
;
82 int pressure_adjustment
;
85 u16 fw_validpage_count
;
87 u32 fw_signature_address
;
97 u32 quirks
; /* Various quirks */
100 static u32
elan_i2c_lookup_quirks(u16 ic_type
, u16 product_id
)
102 static const struct {
106 } elan_i2c_quirks
[] = {
107 { 0x0D, ETP_PRODUCT_ID_DELBIN
, ETP_QUIRK_QUICK_WAKEUP
},
108 { 0x0D, ETP_PRODUCT_ID_WHITEBOX
, ETP_QUIRK_QUICK_WAKEUP
},
109 { 0x10, ETP_PRODUCT_ID_VOXEL
, ETP_QUIRK_QUICK_WAKEUP
},
110 { 0x14, ETP_PRODUCT_ID_MAGPIE
, ETP_QUIRK_QUICK_WAKEUP
},
111 { 0x14, ETP_PRODUCT_ID_BOBBA
, ETP_QUIRK_QUICK_WAKEUP
},
116 for (i
= 0; i
< ARRAY_SIZE(elan_i2c_quirks
); i
++) {
117 if (elan_i2c_quirks
[i
].ic_type
== ic_type
&&
118 elan_i2c_quirks
[i
].product_id
== product_id
) {
119 quirks
= elan_i2c_quirks
[i
].quirks
;
123 if (ic_type
>= 0x0D && product_id
>= 0x123)
124 quirks
|= ETP_QUIRK_QUICK_WAKEUP
;
129 static int elan_get_fwinfo(u16 ic_type
, u8 iap_version
, u16
*validpage_count
,
130 u32
*signature_address
, u16
*page_size
)
136 *validpage_count
= 512;
144 *validpage_count
= 768;
147 *validpage_count
= 896;
150 *validpage_count
= 640;
153 *validpage_count
= 1024;
156 *validpage_count
= 1280;
159 *validpage_count
= 2048;
163 *validpage_count
= 1024;
166 /* unknown ic type clear value */
167 *validpage_count
= 0;
168 *signature_address
= 0;
174 (*validpage_count
* ETP_FW_PAGE_SIZE
) - ETP_FW_SIGNATURE_SIZE
;
176 if ((ic_type
== 0x14 || ic_type
== 0x15) && iap_version
>= 2) {
177 *validpage_count
/= 8;
178 *page_size
= ETP_FW_PAGE_SIZE_512
;
179 } else if (ic_type
>= 0x0D && iap_version
>= 1) {
180 *validpage_count
/= 2;
181 *page_size
= ETP_FW_PAGE_SIZE_128
;
183 *page_size
= ETP_FW_PAGE_SIZE
;
189 static int elan_set_power(struct elan_tp_data
*data
, bool on
)
191 int repeat
= ETP_RETRY_COUNT
;
195 error
= data
->ops
->power_control(data
->client
, on
);
200 } while (--repeat
> 0);
202 dev_err(&data
->client
->dev
, "failed to set power %s: %d\n",
203 on
? "on" : "off", error
);
207 static int elan_sleep(struct elan_tp_data
*data
)
209 int repeat
= ETP_RETRY_COUNT
;
213 error
= data
->ops
->sleep_control(data
->client
, true);
218 } while (--repeat
> 0);
223 static int elan_query_product(struct elan_tp_data
*data
)
227 error
= data
->ops
->get_product_id(data
->client
, &data
->product_id
);
231 error
= data
->ops
->get_pattern(data
->client
, &data
->pattern
);
235 error
= data
->ops
->get_sm_version(data
->client
, data
->pattern
,
236 &data
->ic_type
, &data
->sm_version
,
244 static int elan_check_ASUS_special_fw(struct elan_tp_data
*data
)
246 if (data
->ic_type
== 0x0E) {
247 switch (data
->product_id
) {
253 } else if (data
->ic_type
== 0x08 && data
->product_id
== 0x26) {
254 /* ASUS EeeBook X205TA */
261 static int __elan_initialize(struct elan_tp_data
*data
, bool skip_reset
)
263 struct i2c_client
*client
= data
->client
;
264 bool woken_up
= false;
268 error
= data
->ops
->initialize(client
);
270 dev_err(&client
->dev
, "device initialize failed: %d\n", error
);
275 error
= elan_query_product(data
);
280 * Some ASUS devices were shipped with firmware that requires
281 * touchpads to be woken up first, before attempting to switch
282 * them into absolute reporting mode.
284 if (elan_check_ASUS_special_fw(data
)) {
285 error
= data
->ops
->sleep_control(client
, false);
287 dev_err(&client
->dev
,
288 "failed to wake device up: %d\n", error
);
296 data
->mode
|= ETP_ENABLE_ABS
;
297 error
= data
->ops
->set_mode(client
, data
->mode
);
299 dev_err(&client
->dev
,
300 "failed to switch to absolute mode: %d\n", error
);
305 error
= data
->ops
->sleep_control(client
, false);
307 dev_err(&client
->dev
,
308 "failed to wake device up: %d\n", error
);
316 static int elan_initialize(struct elan_tp_data
*data
, bool skip_reset
)
318 int repeat
= ETP_RETRY_COUNT
;
322 error
= __elan_initialize(data
, skip_reset
);
328 } while (--repeat
> 0);
333 static int elan_query_device_info(struct elan_tp_data
*data
)
337 error
= data
->ops
->get_version(data
->client
, data
->pattern
, false,
342 error
= data
->ops
->get_checksum(data
->client
, false,
347 error
= data
->ops
->get_version(data
->client
, data
->pattern
,
348 true, &data
->iap_version
);
352 error
= data
->ops
->get_pressure_adjustment(data
->client
,
353 &data
->pressure_adjustment
);
357 error
= data
->ops
->get_report_features(data
->client
, data
->pattern
,
358 &data
->report_features
,
363 data
->quirks
= elan_i2c_lookup_quirks(data
->ic_type
, data
->product_id
);
365 error
= elan_get_fwinfo(data
->ic_type
, data
->iap_version
,
366 &data
->fw_validpage_count
,
367 &data
->fw_signature_address
,
368 &data
->fw_page_size
);
370 dev_warn(&data
->client
->dev
,
371 "unexpected iap version %#04x (ic type: %#04x), firmware update will not work\n",
372 data
->iap_version
, data
->ic_type
);
377 static unsigned int elan_convert_resolution(u8 val
, u8 pattern
)
381 * (value from firmware) * 10 + 790 = dpi
383 * ((value from firmware) + 3) * 100 = dpi
385 int res
= pattern
<= 0x01 ?
386 (int)(char)val
* 10 + 790 : ((int)(char)val
+ 3) * 100;
388 * We also have to convert dpi to dots/mm (*10/254 to avoid floating
391 return res
* 10 / 254;
394 static int elan_query_device_parameters(struct elan_tp_data
*data
)
396 struct i2c_client
*client
= data
->client
;
397 unsigned int x_traces
, y_traces
;
399 u8 hw_x_res
, hw_y_res
;
402 if (device_property_read_u32(&client
->dev
,
403 "touchscreen-size-x", &data
->max_x
) ||
404 device_property_read_u32(&client
->dev
,
405 "touchscreen-size-y", &data
->max_y
)) {
406 error
= data
->ops
->get_max(data
->client
,
412 /* size is the maximum + 1 */
417 if (device_property_read_u32(&client
->dev
,
420 device_property_read_u32(&client
->dev
,
423 error
= data
->ops
->get_num_traces(data
->client
,
424 &x_traces
, &y_traces
);
428 data
->width_x
= data
->max_x
/ x_traces
;
429 data
->width_y
= data
->max_y
/ y_traces
;
431 if (device_property_read_u32(&client
->dev
,
432 "touchscreen-x-mm", &x_mm
) ||
433 device_property_read_u32(&client
->dev
,
434 "touchscreen-y-mm", &y_mm
)) {
435 error
= data
->ops
->get_resolution(data
->client
,
436 &hw_x_res
, &hw_y_res
);
440 data
->x_res
= elan_convert_resolution(hw_x_res
, data
->pattern
);
441 data
->y_res
= elan_convert_resolution(hw_y_res
, data
->pattern
);
443 data
->x_res
= (data
->max_x
+ 1) / x_mm
;
444 data
->y_res
= (data
->max_y
+ 1) / y_mm
;
447 if (device_property_read_bool(&client
->dev
, "elan,clickpad"))
450 if (device_property_read_bool(&client
->dev
, "elan,middle-button"))
451 data
->middle_button
= true;
457 **********************************************************
458 * IAP firmware updater related routines
459 **********************************************************
461 static int elan_write_fw_block(struct elan_tp_data
*data
, u16 page_size
,
462 const u8
*page
, u16 checksum
, int idx
)
464 int retry
= ETP_RETRY_COUNT
;
468 error
= data
->ops
->write_fw_block(data
->client
, page_size
,
469 page
, checksum
, idx
);
473 dev_dbg(&data
->client
->dev
,
474 "IAP retrying page %d (error: %d)\n", idx
, error
);
475 } while (--retry
> 0);
480 static int __elan_update_firmware(struct elan_tp_data
*data
,
481 const struct firmware
*fw
)
483 struct i2c_client
*client
= data
->client
;
484 struct device
*dev
= &client
->dev
;
489 u16 sw_checksum
= 0, fw_checksum
= 0;
491 error
= data
->ops
->prepare_fw_update(client
, data
->ic_type
,
497 iap_start_addr
= get_unaligned_le16(&fw
->data
[ETP_IAP_START_ADDR
* 2]);
499 boot_page_count
= (iap_start_addr
* 2) / data
->fw_page_size
;
500 for (i
= boot_page_count
; i
< data
->fw_validpage_count
; i
++) {
502 const u8
*page
= &fw
->data
[i
* data
->fw_page_size
];
504 for (j
= 0; j
< data
->fw_page_size
; j
+= 2)
505 checksum
+= ((page
[j
+ 1] << 8) | page
[j
]);
507 error
= elan_write_fw_block(data
, data
->fw_page_size
,
510 dev_err(dev
, "write page %d fail: %d\n", i
, error
);
514 sw_checksum
+= checksum
;
517 /* Wait WDT reset and power on reset */
520 error
= data
->ops
->finish_fw_update(client
, &data
->fw_completion
);
524 error
= data
->ops
->get_checksum(client
, true, &fw_checksum
);
528 if (sw_checksum
!= fw_checksum
) {
529 dev_err(dev
, "checksum diff sw=[%04X], fw=[%04X]\n",
530 sw_checksum
, fw_checksum
);
537 static int elan_update_firmware(struct elan_tp_data
*data
,
538 const struct firmware
*fw
)
540 struct i2c_client
*client
= data
->client
;
543 dev_dbg(&client
->dev
, "Starting firmware update....\n");
545 disable_irq(client
->irq
);
546 data
->in_fw_update
= true;
548 retval
= __elan_update_firmware(data
, fw
);
550 dev_err(&client
->dev
, "firmware update failed: %d\n", retval
);
551 data
->ops
->iap_reset(client
);
553 /* Reinitialize TP after fw is updated */
554 elan_initialize(data
, false);
555 elan_query_device_info(data
);
558 data
->in_fw_update
= false;
559 enable_irq(client
->irq
);
565 *******************************************************************
567 *******************************************************************
569 static ssize_t
elan_sysfs_read_fw_checksum(struct device
*dev
,
570 struct device_attribute
*attr
,
573 struct i2c_client
*client
= to_i2c_client(dev
);
574 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
576 return sprintf(buf
, "0x%04x\n", data
->fw_checksum
);
579 static ssize_t
elan_sysfs_read_product_id(struct device
*dev
,
580 struct device_attribute
*attr
,
583 struct i2c_client
*client
= to_i2c_client(dev
);
584 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
586 return sprintf(buf
, ETP_PRODUCT_ID_FORMAT_STRING
"\n",
590 static ssize_t
elan_sysfs_read_fw_ver(struct device
*dev
,
591 struct device_attribute
*attr
,
594 struct i2c_client
*client
= to_i2c_client(dev
);
595 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
597 return sprintf(buf
, "%d.0\n", data
->fw_version
);
600 static ssize_t
elan_sysfs_read_sm_ver(struct device
*dev
,
601 struct device_attribute
*attr
,
604 struct i2c_client
*client
= to_i2c_client(dev
);
605 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
607 return sprintf(buf
, "%d.0\n", data
->sm_version
);
610 static ssize_t
elan_sysfs_read_iap_ver(struct device
*dev
,
611 struct device_attribute
*attr
,
614 struct i2c_client
*client
= to_i2c_client(dev
);
615 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
617 return sprintf(buf
, "%d.0\n", data
->iap_version
);
620 static ssize_t
elan_sysfs_update_fw(struct device
*dev
,
621 struct device_attribute
*attr
,
622 const char *buf
, size_t count
)
624 struct elan_tp_data
*data
= dev_get_drvdata(dev
);
625 const struct firmware
*fw
;
628 const u8
*fw_signature
;
629 static const u8 signature
[] = {0xAA, 0x55, 0xCC, 0x33, 0xFF, 0xFF};
631 if (data
->fw_validpage_count
== 0)
634 /* Look for a firmware with the product id appended. */
635 fw_name
= kasprintf(GFP_KERNEL
, ETP_FW_NAME
, data
->product_id
);
637 dev_err(dev
, "failed to allocate memory for firmware name\n");
641 dev_info(dev
, "requesting fw '%s'\n", fw_name
);
642 error
= request_firmware(&fw
, fw_name
, dev
);
645 dev_err(dev
, "failed to request firmware: %d\n", error
);
649 /* Firmware file must match signature data */
650 fw_signature
= &fw
->data
[data
->fw_signature_address
];
651 if (memcmp(fw_signature
, signature
, sizeof(signature
)) != 0) {
652 dev_err(dev
, "signature mismatch (expected %*ph, got %*ph)\n",
653 (int)sizeof(signature
), signature
,
654 (int)sizeof(signature
), fw_signature
);
659 error
= mutex_lock_interruptible(&data
->sysfs_mutex
);
663 error
= elan_update_firmware(data
, fw
);
665 mutex_unlock(&data
->sysfs_mutex
);
668 release_firmware(fw
);
669 return error
?: count
;
672 static ssize_t
calibrate_store(struct device
*dev
,
673 struct device_attribute
*attr
,
674 const char *buf
, size_t count
)
676 struct i2c_client
*client
= to_i2c_client(dev
);
677 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
681 u8 val
[ETP_CALIBRATE_MAX_LEN
];
683 retval
= mutex_lock_interruptible(&data
->sysfs_mutex
);
687 disable_irq(client
->irq
);
689 data
->mode
|= ETP_ENABLE_CALIBRATE
;
690 retval
= data
->ops
->set_mode(client
, data
->mode
);
692 dev_err(dev
, "failed to enable calibration mode: %d\n",
697 retval
= data
->ops
->calibrate(client
);
699 dev_err(dev
, "failed to start calibration: %d\n",
701 goto out_disable_calibrate
;
706 /* Wait 250ms before checking if calibration has completed. */
709 retval
= data
->ops
->calibrate_result(client
, val
);
711 dev_err(dev
, "failed to check calibration result: %d\n",
713 else if (val
[0] == 0)
714 break; /* calibration done */
719 dev_err(dev
, "failed to calibrate. Timeout.\n");
723 out_disable_calibrate
:
724 data
->mode
&= ~ETP_ENABLE_CALIBRATE
;
725 error
= data
->ops
->set_mode(data
->client
, data
->mode
);
727 dev_err(dev
, "failed to disable calibration mode: %d\n",
733 enable_irq(client
->irq
);
734 mutex_unlock(&data
->sysfs_mutex
);
735 return retval
?: count
;
738 static ssize_t
elan_sysfs_read_mode(struct device
*dev
,
739 struct device_attribute
*attr
,
742 struct i2c_client
*client
= to_i2c_client(dev
);
743 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
747 error
= mutex_lock_interruptible(&data
->sysfs_mutex
);
751 error
= data
->ops
->iap_get_mode(data
->client
, &mode
);
753 mutex_unlock(&data
->sysfs_mutex
);
758 return sprintf(buf
, "%d\n", (int)mode
);
761 static DEVICE_ATTR(product_id
, S_IRUGO
, elan_sysfs_read_product_id
, NULL
);
762 static DEVICE_ATTR(firmware_version
, S_IRUGO
, elan_sysfs_read_fw_ver
, NULL
);
763 static DEVICE_ATTR(sample_version
, S_IRUGO
, elan_sysfs_read_sm_ver
, NULL
);
764 static DEVICE_ATTR(iap_version
, S_IRUGO
, elan_sysfs_read_iap_ver
, NULL
);
765 static DEVICE_ATTR(fw_checksum
, S_IRUGO
, elan_sysfs_read_fw_checksum
, NULL
);
766 static DEVICE_ATTR(mode
, S_IRUGO
, elan_sysfs_read_mode
, NULL
);
767 static DEVICE_ATTR(update_fw
, S_IWUSR
, NULL
, elan_sysfs_update_fw
);
769 static DEVICE_ATTR_WO(calibrate
);
771 static struct attribute
*elan_sysfs_entries
[] = {
772 &dev_attr_product_id
.attr
,
773 &dev_attr_firmware_version
.attr
,
774 &dev_attr_sample_version
.attr
,
775 &dev_attr_iap_version
.attr
,
776 &dev_attr_fw_checksum
.attr
,
777 &dev_attr_calibrate
.attr
,
779 &dev_attr_update_fw
.attr
,
783 static const struct attribute_group elan_sysfs_group
= {
784 .attrs
= elan_sysfs_entries
,
787 static ssize_t
acquire_store(struct device
*dev
, struct device_attribute
*attr
,
788 const char *buf
, size_t count
)
790 struct i2c_client
*client
= to_i2c_client(dev
);
791 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
795 retval
= mutex_lock_interruptible(&data
->sysfs_mutex
);
799 disable_irq(client
->irq
);
801 data
->baseline_ready
= false;
803 data
->mode
|= ETP_ENABLE_CALIBRATE
;
804 retval
= data
->ops
->set_mode(data
->client
, data
->mode
);
806 dev_err(dev
, "Failed to enable calibration mode to get baseline: %d\n",
813 retval
= data
->ops
->get_baseline_data(data
->client
, true,
814 &data
->max_baseline
);
816 dev_err(dev
, "Failed to read max baseline form device: %d\n",
818 goto out_disable_calibrate
;
821 retval
= data
->ops
->get_baseline_data(data
->client
, false,
822 &data
->min_baseline
);
824 dev_err(dev
, "Failed to read min baseline form device: %d\n",
826 goto out_disable_calibrate
;
829 data
->baseline_ready
= true;
831 out_disable_calibrate
:
832 data
->mode
&= ~ETP_ENABLE_CALIBRATE
;
833 error
= data
->ops
->set_mode(data
->client
, data
->mode
);
835 dev_err(dev
, "Failed to disable calibration mode after acquiring baseline: %d\n",
841 enable_irq(client
->irq
);
842 mutex_unlock(&data
->sysfs_mutex
);
843 return retval
?: count
;
846 static ssize_t
min_show(struct device
*dev
,
847 struct device_attribute
*attr
, char *buf
)
849 struct i2c_client
*client
= to_i2c_client(dev
);
850 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
853 retval
= mutex_lock_interruptible(&data
->sysfs_mutex
);
857 if (!data
->baseline_ready
) {
862 retval
= snprintf(buf
, PAGE_SIZE
, "%d", data
->min_baseline
);
865 mutex_unlock(&data
->sysfs_mutex
);
869 static ssize_t
max_show(struct device
*dev
,
870 struct device_attribute
*attr
, char *buf
)
872 struct i2c_client
*client
= to_i2c_client(dev
);
873 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
876 retval
= mutex_lock_interruptible(&data
->sysfs_mutex
);
880 if (!data
->baseline_ready
) {
885 retval
= snprintf(buf
, PAGE_SIZE
, "%d", data
->max_baseline
);
888 mutex_unlock(&data
->sysfs_mutex
);
893 static DEVICE_ATTR_WO(acquire
);
894 static DEVICE_ATTR_RO(min
);
895 static DEVICE_ATTR_RO(max
);
897 static struct attribute
*elan_baseline_sysfs_entries
[] = {
898 &dev_attr_acquire
.attr
,
904 static const struct attribute_group elan_baseline_sysfs_group
= {
906 .attrs
= elan_baseline_sysfs_entries
,
909 static const struct attribute_group
*elan_sysfs_groups
[] = {
911 &elan_baseline_sysfs_group
,
916 ******************************************************************
918 ******************************************************************
920 static void elan_report_contact(struct elan_tp_data
*data
, int contact_num
,
921 bool contact_valid
, bool high_precision
,
922 u8
*packet
, u8
*finger_data
)
924 struct input_dev
*input
= data
->input
;
925 unsigned int pos_x
, pos_y
;
926 unsigned int pressure
, scaled_pressure
;
929 if (high_precision
) {
930 pos_x
= get_unaligned_be16(&finger_data
[0]);
931 pos_y
= get_unaligned_be16(&finger_data
[2]);
933 pos_x
= ((finger_data
[0] & 0xf0) << 4) | finger_data
[1];
934 pos_y
= ((finger_data
[0] & 0x0f) << 8) | finger_data
[2];
937 if (pos_x
> data
->max_x
|| pos_y
> data
->max_y
) {
938 dev_dbg(input
->dev
.parent
,
939 "[%d] x=%d y=%d over max (%d, %d)",
940 contact_num
, pos_x
, pos_y
,
941 data
->max_x
, data
->max_y
);
945 pressure
= finger_data
[4];
946 scaled_pressure
= pressure
+ data
->pressure_adjustment
;
947 if (scaled_pressure
> ETP_MAX_PRESSURE
)
948 scaled_pressure
= ETP_MAX_PRESSURE
;
950 input_mt_slot(input
, contact_num
);
951 input_mt_report_slot_state(input
, MT_TOOL_FINGER
, true);
952 input_report_abs(input
, ABS_MT_POSITION_X
, pos_x
);
953 input_report_abs(input
, ABS_MT_POSITION_Y
, data
->max_y
- pos_y
);
954 input_report_abs(input
, ABS_MT_PRESSURE
, scaled_pressure
);
956 if (data
->report_features
& ETP_FEATURE_REPORT_MK
) {
957 unsigned int mk_x
, mk_y
, area_x
, area_y
;
958 u8 mk_data
= high_precision
?
959 packet
[ETP_MK_DATA_OFFSET
+ contact_num
] :
962 mk_x
= mk_data
& 0x0f;
966 * To avoid treating large finger as palm, let's reduce
967 * the width x and y per trace.
969 area_x
= mk_x
* (data
->width_x
- ETP_FWIDTH_REDUCE
);
970 area_y
= mk_y
* (data
->width_y
- ETP_FWIDTH_REDUCE
);
972 input_report_abs(input
, ABS_TOOL_WIDTH
, mk_x
);
973 input_report_abs(input
, ABS_MT_TOUCH_MAJOR
,
974 max(area_x
, area_y
));
975 input_report_abs(input
, ABS_MT_TOUCH_MINOR
,
976 min(area_x
, area_y
));
979 input_mt_slot(input
, contact_num
);
980 input_mt_report_slot_inactive(input
);
984 static void elan_report_absolute(struct elan_tp_data
*data
, u8
*packet
,
987 struct input_dev
*input
= data
->input
;
988 u8
*finger_data
= &packet
[ETP_FINGER_DATA_OFFSET
];
990 u8 tp_info
= packet
[ETP_TOUCH_INFO_OFFSET
];
991 u8 hover_info
= packet
[ETP_HOVER_INFO_OFFSET
];
992 bool contact_valid
, hover_event
;
994 pm_wakeup_event(&data
->client
->dev
, 0);
996 hover_event
= hover_info
& BIT(6);
998 for (i
= 0; i
< ETP_MAX_FINGERS
; i
++) {
999 contact_valid
= tp_info
& BIT(3 + i
);
1000 elan_report_contact(data
, i
, contact_valid
, high_precision
,
1001 packet
, finger_data
);
1003 finger_data
+= ETP_FINGER_DATA_LEN
;
1006 input_report_key(input
, BTN_LEFT
, tp_info
& BIT(0));
1007 input_report_key(input
, BTN_MIDDLE
, tp_info
& BIT(2));
1008 input_report_key(input
, BTN_RIGHT
, tp_info
& BIT(1));
1009 input_report_abs(input
, ABS_DISTANCE
, hover_event
!= 0);
1010 input_mt_report_pointer_emulation(input
, true);
1014 static void elan_report_trackpoint(struct elan_tp_data
*data
, u8
*report
)
1016 struct input_dev
*input
= data
->tp_input
;
1017 u8
*packet
= &report
[ETP_REPORT_ID_OFFSET
+ 1];
1020 pm_wakeup_event(&data
->client
->dev
, 0);
1022 if (!data
->tp_input
) {
1023 dev_warn_once(&data
->client
->dev
,
1024 "received a trackpoint report while no trackpoint device has been created. Please report upstream.\n");
1028 input_report_key(input
, BTN_LEFT
, packet
[0] & 0x01);
1029 input_report_key(input
, BTN_RIGHT
, packet
[0] & 0x02);
1030 input_report_key(input
, BTN_MIDDLE
, packet
[0] & 0x04);
1032 if ((packet
[3] & 0x0F) == 0x06) {
1033 x
= packet
[4] - (int)((packet
[1] ^ 0x80) << 1);
1034 y
= (int)((packet
[2] ^ 0x80) << 1) - packet
[5];
1036 input_report_rel(input
, REL_X
, x
);
1037 input_report_rel(input
, REL_Y
, y
);
1043 static irqreturn_t
elan_isr(int irq
, void *dev_id
)
1045 struct elan_tp_data
*data
= dev_id
;
1047 u8 report
[ETP_MAX_REPORT_LEN
];
1050 * When device is connected to i2c bus, when all IAP page writes
1051 * complete, the driver will receive interrupt and must read
1052 * 0000 to confirm that IAP is finished.
1054 if (data
->in_fw_update
) {
1055 complete(&data
->fw_completion
);
1059 error
= data
->ops
->get_report(data
->client
, report
, data
->report_len
);
1063 switch (report
[ETP_REPORT_ID_OFFSET
]) {
1065 elan_report_absolute(data
, report
, false);
1067 case ETP_REPORT_ID2
:
1068 elan_report_absolute(data
, report
, true);
1070 case ETP_TP_REPORT_ID
:
1071 case ETP_TP_REPORT_ID2
:
1072 elan_report_trackpoint(data
, report
);
1075 dev_err(&data
->client
->dev
, "invalid report id data (%x)\n",
1076 report
[ETP_REPORT_ID_OFFSET
]);
1084 ******************************************************************
1085 * Elan initialization functions
1086 ******************************************************************
1089 static int elan_setup_trackpoint_input_device(struct elan_tp_data
*data
)
1091 struct device
*dev
= &data
->client
->dev
;
1092 struct input_dev
*input
;
1094 input
= devm_input_allocate_device(dev
);
1098 input
->name
= "Elan TrackPoint";
1099 input
->id
.bustype
= BUS_I2C
;
1100 input
->id
.vendor
= ELAN_VENDOR_ID
;
1101 input
->id
.product
= data
->product_id
;
1102 input_set_drvdata(input
, data
);
1104 input_set_capability(input
, EV_REL
, REL_X
);
1105 input_set_capability(input
, EV_REL
, REL_Y
);
1106 input_set_capability(input
, EV_KEY
, BTN_LEFT
);
1107 input_set_capability(input
, EV_KEY
, BTN_RIGHT
);
1108 input_set_capability(input
, EV_KEY
, BTN_MIDDLE
);
1110 __set_bit(INPUT_PROP_POINTER
, input
->propbit
);
1111 __set_bit(INPUT_PROP_POINTING_STICK
, input
->propbit
);
1113 data
->tp_input
= input
;
1118 static int elan_setup_input_device(struct elan_tp_data
*data
)
1120 struct device
*dev
= &data
->client
->dev
;
1121 struct input_dev
*input
;
1122 unsigned int max_width
= max(data
->width_x
, data
->width_y
);
1123 unsigned int min_width
= min(data
->width_x
, data
->width_y
);
1126 input
= devm_input_allocate_device(dev
);
1130 input
->name
= "Elan Touchpad";
1131 input
->id
.bustype
= BUS_I2C
;
1132 input
->id
.vendor
= ELAN_VENDOR_ID
;
1133 input
->id
.product
= data
->product_id
;
1134 input_set_drvdata(input
, data
);
1136 error
= input_mt_init_slots(input
, ETP_MAX_FINGERS
,
1137 INPUT_MT_POINTER
| INPUT_MT_DROP_UNUSED
);
1139 dev_err(dev
, "failed to initialize MT slots: %d\n", error
);
1143 __set_bit(EV_ABS
, input
->evbit
);
1144 __set_bit(INPUT_PROP_POINTER
, input
->propbit
);
1145 if (data
->clickpad
) {
1146 __set_bit(INPUT_PROP_BUTTONPAD
, input
->propbit
);
1148 __set_bit(BTN_RIGHT
, input
->keybit
);
1149 if (data
->middle_button
)
1150 __set_bit(BTN_MIDDLE
, input
->keybit
);
1152 __set_bit(BTN_LEFT
, input
->keybit
);
1154 /* Set up ST parameters */
1155 input_set_abs_params(input
, ABS_X
, 0, data
->max_x
, 0, 0);
1156 input_set_abs_params(input
, ABS_Y
, 0, data
->max_y
, 0, 0);
1157 input_abs_set_res(input
, ABS_X
, data
->x_res
);
1158 input_abs_set_res(input
, ABS_Y
, data
->y_res
);
1159 input_set_abs_params(input
, ABS_PRESSURE
, 0, ETP_MAX_PRESSURE
, 0, 0);
1160 if (data
->report_features
& ETP_FEATURE_REPORT_MK
)
1161 input_set_abs_params(input
, ABS_TOOL_WIDTH
,
1162 0, ETP_FINGER_WIDTH
, 0, 0);
1163 input_set_abs_params(input
, ABS_DISTANCE
, 0, 1, 0, 0);
1165 /* And MT parameters */
1166 input_set_abs_params(input
, ABS_MT_POSITION_X
, 0, data
->max_x
, 0, 0);
1167 input_set_abs_params(input
, ABS_MT_POSITION_Y
, 0, data
->max_y
, 0, 0);
1168 input_abs_set_res(input
, ABS_MT_POSITION_X
, data
->x_res
);
1169 input_abs_set_res(input
, ABS_MT_POSITION_Y
, data
->y_res
);
1170 input_set_abs_params(input
, ABS_MT_PRESSURE
, 0,
1171 ETP_MAX_PRESSURE
, 0, 0);
1172 if (data
->report_features
& ETP_FEATURE_REPORT_MK
) {
1173 input_set_abs_params(input
, ABS_MT_TOUCH_MAJOR
,
1174 0, ETP_FINGER_WIDTH
* max_width
, 0, 0);
1175 input_set_abs_params(input
, ABS_MT_TOUCH_MINOR
,
1176 0, ETP_FINGER_WIDTH
* min_width
, 0, 0);
1179 data
->input
= input
;
1184 static void elan_disable_regulator(void *_data
)
1186 struct elan_tp_data
*data
= _data
;
1188 regulator_disable(data
->vcc
);
1191 static int elan_probe(struct i2c_client
*client
,
1192 const struct i2c_device_id
*dev_id
)
1194 const struct elan_transport_ops
*transport_ops
;
1195 struct device
*dev
= &client
->dev
;
1196 struct elan_tp_data
*data
;
1197 unsigned long irqflags
;
1200 if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_I2C
) &&
1201 i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
)) {
1202 transport_ops
= &elan_i2c_ops
;
1203 } else if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_SMBUS
) &&
1204 i2c_check_functionality(client
->adapter
,
1205 I2C_FUNC_SMBUS_BYTE_DATA
|
1206 I2C_FUNC_SMBUS_BLOCK_DATA
|
1207 I2C_FUNC_SMBUS_I2C_BLOCK
)) {
1208 transport_ops
= &elan_smbus_ops
;
1210 dev_err(dev
, "not a supported I2C/SMBus adapter\n");
1214 data
= devm_kzalloc(dev
, sizeof(struct elan_tp_data
), GFP_KERNEL
);
1218 i2c_set_clientdata(client
, data
);
1220 data
->ops
= transport_ops
;
1221 data
->client
= client
;
1222 init_completion(&data
->fw_completion
);
1223 mutex_init(&data
->sysfs_mutex
);
1225 data
->vcc
= devm_regulator_get(dev
, "vcc");
1226 if (IS_ERR(data
->vcc
)) {
1227 error
= PTR_ERR(data
->vcc
);
1228 if (error
!= -EPROBE_DEFER
)
1229 dev_err(dev
, "Failed to get 'vcc' regulator: %d\n",
1234 error
= regulator_enable(data
->vcc
);
1236 dev_err(dev
, "Failed to enable regulator: %d\n", error
);
1240 error
= devm_add_action_or_reset(dev
, elan_disable_regulator
, data
);
1242 dev_err(dev
, "Failed to add disable regulator action: %d\n",
1247 /* Make sure there is something at this address */
1248 error
= i2c_smbus_read_byte(client
);
1250 dev_dbg(&client
->dev
, "nothing at this address: %d\n", error
);
1254 /* Initialize the touchpad. */
1255 error
= elan_initialize(data
, false);
1259 error
= elan_query_device_info(data
);
1263 error
= elan_query_device_parameters(data
);
1268 "Elan Touchpad: Module ID: 0x%04x, Firmware: 0x%04x, Sample: 0x%04x, IAP: 0x%04x\n",
1275 "Elan Touchpad Extra Information:\n"
1276 " Max ABS X,Y: %d,%d\n"
1277 " Width X,Y: %d,%d\n"
1278 " Resolution X,Y: %d,%d (dots/mm)\n"
1280 " info pattern: 0x%x\n",
1281 data
->max_x
, data
->max_y
,
1282 data
->width_x
, data
->width_y
,
1283 data
->x_res
, data
->y_res
,
1284 data
->ic_type
, data
->pattern
);
1286 /* Set up input device properties based on queried parameters. */
1287 error
= elan_setup_input_device(data
);
1291 if (device_property_read_bool(&client
->dev
, "elan,trackpoint")) {
1292 error
= elan_setup_trackpoint_input_device(data
);
1298 * Platform code (ACPI, DTS) should normally set up interrupt
1299 * for us, but in case it did not let's fall back to using falling
1300 * edge to be compatible with older Chromebooks.
1302 irqflags
= irq_get_trigger_type(client
->irq
);
1304 irqflags
= IRQF_TRIGGER_FALLING
;
1306 error
= devm_request_threaded_irq(dev
, client
->irq
, NULL
, elan_isr
,
1307 irqflags
| IRQF_ONESHOT
,
1308 client
->name
, data
);
1310 dev_err(dev
, "cannot register irq=%d\n", client
->irq
);
1314 error
= devm_device_add_groups(dev
, elan_sysfs_groups
);
1316 dev_err(dev
, "failed to create sysfs attributes: %d\n", error
);
1320 error
= input_register_device(data
->input
);
1322 dev_err(dev
, "failed to register input device: %d\n", error
);
1326 if (data
->tp_input
) {
1327 error
= input_register_device(data
->tp_input
);
1329 dev_err(&client
->dev
,
1330 "failed to register TrackPoint input device: %d\n",
1337 * Systems using device tree should set up wakeup via DTS,
1338 * the rest will configure device as wakeup source by default.
1341 device_init_wakeup(dev
, true);
1346 static int __maybe_unused
elan_suspend(struct device
*dev
)
1348 struct i2c_client
*client
= to_i2c_client(dev
);
1349 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
1353 * We are taking the mutex to make sure sysfs operations are
1354 * complete before we attempt to bring the device into low[er]
1357 ret
= mutex_lock_interruptible(&data
->sysfs_mutex
);
1361 disable_irq(client
->irq
);
1363 if (device_may_wakeup(dev
)) {
1364 ret
= elan_sleep(data
);
1365 /* Enable wake from IRQ */
1366 data
->irq_wake
= (enable_irq_wake(client
->irq
) == 0);
1368 ret
= elan_set_power(data
, false);
1372 ret
= regulator_disable(data
->vcc
);
1374 dev_err(dev
, "error %d disabling regulator\n", ret
);
1375 /* Attempt to power the chip back up */
1376 elan_set_power(data
, true);
1381 mutex_unlock(&data
->sysfs_mutex
);
1385 static int __maybe_unused
elan_resume(struct device
*dev
)
1387 struct i2c_client
*client
= to_i2c_client(dev
);
1388 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
1391 if (device_may_wakeup(dev
) && data
->irq_wake
) {
1392 disable_irq_wake(client
->irq
);
1393 data
->irq_wake
= false;
1396 error
= regulator_enable(data
->vcc
);
1398 dev_err(dev
, "error %d enabling regulator\n", error
);
1402 error
= elan_set_power(data
, true);
1404 dev_err(dev
, "power up when resuming failed: %d\n", error
);
1408 error
= elan_initialize(data
, data
->quirks
& ETP_QUIRK_QUICK_WAKEUP
);
1410 dev_err(dev
, "initialize when resuming failed: %d\n", error
);
1413 enable_irq(data
->client
->irq
);
1417 static SIMPLE_DEV_PM_OPS(elan_pm_ops
, elan_suspend
, elan_resume
);
1419 static const struct i2c_device_id elan_id
[] = {
1423 MODULE_DEVICE_TABLE(i2c
, elan_id
);
1426 #include <linux/input/elan-i2c-ids.h>
1427 MODULE_DEVICE_TABLE(acpi
, elan_acpi_id
);
1431 static const struct of_device_id elan_of_match
[] = {
1432 { .compatible
= "elan,ekth3000" },
1435 MODULE_DEVICE_TABLE(of
, elan_of_match
);
1438 static struct i2c_driver elan_driver
= {
1440 .name
= DRIVER_NAME
,
1442 .acpi_match_table
= ACPI_PTR(elan_acpi_id
),
1443 .of_match_table
= of_match_ptr(elan_of_match
),
1444 .probe_type
= PROBE_PREFER_ASYNCHRONOUS
,
1446 .probe
= elan_probe
,
1447 .id_table
= elan_id
,
1450 module_i2c_driver(elan_driver
);
1452 MODULE_AUTHOR("Duson Lin <dusonlin@emc.com.tw>");
1453 MODULE_DESCRIPTION("Elan I2C/SMBus Touchpad driver");
1454 MODULE_LICENSE("GPL");