2 * Elan I2C/SMBus Touchpad driver
4 * Copyright (c) 2013 ELAN Microelectronics Corp.
6 * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw>
9 * Based on cyapa driver:
10 * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
11 * copyright (c) 2011-2012 Google, Inc.
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License version 2 as published
15 * by the Free Software Foundation.
17 * Trademarks are the property of their respective owners.
20 #include <linux/acpi.h>
21 #include <linux/delay.h>
22 #include <linux/device.h>
23 #include <linux/firmware.h>
24 #include <linux/i2c.h>
25 #include <linux/init.h>
26 #include <linux/input/mt.h>
27 #include <linux/interrupt.h>
28 #include <linux/module.h>
29 #include <linux/slab.h>
30 #include <linux/kernel.h>
31 #include <linux/sched.h>
32 #include <linux/input.h>
33 #include <linux/uaccess.h>
34 #include <linux/jiffies.h>
35 #include <linux/completion.h>
37 #include <linux/regulator/consumer.h>
38 #include <asm/unaligned.h>
42 #define DRIVER_NAME "elan_i2c"
43 #define ELAN_DRIVER_VERSION "1.5.9"
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 #define ETP_MAX_FINGERS 5
50 #define ETP_FINGER_DATA_LEN 5
51 #define ETP_REPORT_ID 0x5D
52 #define ETP_REPORT_ID_OFFSET 2
53 #define ETP_TOUCH_INFO_OFFSET 3
54 #define ETP_FINGER_DATA_OFFSET 4
55 #define ETP_HOVER_INFO_OFFSET 30
56 #define ETP_MAX_REPORT_LEN 34
58 /* The main device structure */
60 struct i2c_client
*client
;
61 struct input_dev
*input
;
62 struct regulator
*vcc
;
64 const struct elan_transport_ops
*ops
;
67 struct completion fw_completion
;
70 struct mutex sysfs_mutex
;
84 int pressure_adjustment
;
87 u16 fw_vaildpage_count
;
88 u16 fw_signature_address
;
97 static int elan_get_fwinfo(u8 ic_type
, u16
*vaildpage_count
,
98 u16
*signature_address
)
102 *vaildpage_count
= 768;
105 *vaildpage_count
= 896;
108 /* unknown ic type clear value */
109 *vaildpage_count
= 0;
110 *signature_address
= 0;
115 (*vaildpage_count
* ETP_FW_PAGE_SIZE
) - ETP_FW_SIGNATURE_SIZE
;
120 static int elan_enable_power(struct elan_tp_data
*data
)
122 int repeat
= ETP_RETRY_COUNT
;
125 error
= regulator_enable(data
->vcc
);
127 dev_err(&data
->client
->dev
,
128 "failed to enable regulator: %d\n", error
);
133 error
= data
->ops
->power_control(data
->client
, true);
138 } while (--repeat
> 0);
140 dev_err(&data
->client
->dev
, "failed to enable power: %d\n", error
);
144 static int elan_disable_power(struct elan_tp_data
*data
)
146 int repeat
= ETP_RETRY_COUNT
;
150 error
= data
->ops
->power_control(data
->client
, false);
152 error
= regulator_disable(data
->vcc
);
154 dev_err(&data
->client
->dev
,
155 "failed to disable regulator: %d\n",
157 /* Attempt to power the chip back up */
158 data
->ops
->power_control(data
->client
, true);
166 } while (--repeat
> 0);
168 dev_err(&data
->client
->dev
, "failed to disable power: %d\n", error
);
172 static int elan_sleep(struct elan_tp_data
*data
)
174 int repeat
= ETP_RETRY_COUNT
;
178 error
= data
->ops
->sleep_control(data
->client
, true);
183 } while (--repeat
> 0);
188 static int __elan_initialize(struct elan_tp_data
*data
)
190 struct i2c_client
*client
= data
->client
;
193 error
= data
->ops
->initialize(client
);
195 dev_err(&client
->dev
, "device initialize failed: %d\n", error
);
199 data
->mode
|= ETP_ENABLE_ABS
;
200 error
= data
->ops
->set_mode(client
, data
->mode
);
202 dev_err(&client
->dev
,
203 "failed to switch to absolute mode: %d\n", error
);
207 error
= data
->ops
->sleep_control(client
, false);
209 dev_err(&client
->dev
,
210 "failed to wake device up: %d\n", error
);
217 static int elan_initialize(struct elan_tp_data
*data
)
219 int repeat
= ETP_RETRY_COUNT
;
223 error
= __elan_initialize(data
);
228 } while (--repeat
> 0);
233 static int elan_query_device_info(struct elan_tp_data
*data
)
237 error
= data
->ops
->get_product_id(data
->client
, &data
->product_id
);
241 error
= data
->ops
->get_version(data
->client
, false, &data
->fw_version
);
245 error
= data
->ops
->get_checksum(data
->client
, false,
250 error
= data
->ops
->get_sm_version(data
->client
, &data
->ic_type
,
255 error
= data
->ops
->get_version(data
->client
, true, &data
->iap_version
);
259 error
= data
->ops
->get_pressure_adjustment(data
->client
,
260 &data
->pressure_adjustment
);
264 error
= elan_get_fwinfo(data
->ic_type
, &data
->fw_vaildpage_count
,
265 &data
->fw_signature_address
);
267 dev_err(&data
->client
->dev
,
268 "unknown ic type %d\n", data
->ic_type
);
275 static unsigned int elan_convert_resolution(u8 val
)
278 * (value from firmware) * 10 + 790 = dpi
280 * We also have to convert dpi to dots/mm (*10/254 to avoid floating
284 return ((int)(char)val
* 10 + 790) * 10 / 254;
287 static int elan_query_device_parameters(struct elan_tp_data
*data
)
289 unsigned int x_traces
, y_traces
;
290 u8 hw_x_res
, hw_y_res
;
293 error
= data
->ops
->get_max(data
->client
, &data
->max_x
, &data
->max_y
);
297 error
= data
->ops
->get_num_traces(data
->client
, &x_traces
, &y_traces
);
301 data
->width_x
= data
->max_x
/ x_traces
;
302 data
->width_y
= data
->max_y
/ y_traces
;
304 error
= data
->ops
->get_resolution(data
->client
, &hw_x_res
, &hw_y_res
);
308 data
->x_res
= elan_convert_resolution(hw_x_res
);
309 data
->y_res
= elan_convert_resolution(hw_y_res
);
315 **********************************************************
316 * IAP firmware updater related routines
317 **********************************************************
319 static int elan_write_fw_block(struct elan_tp_data
*data
,
320 const u8
*page
, u16 checksum
, int idx
)
322 int retry
= ETP_RETRY_COUNT
;
326 error
= data
->ops
->write_fw_block(data
->client
,
327 page
, checksum
, idx
);
331 dev_dbg(&data
->client
->dev
,
332 "IAP retrying page %d (error: %d)\n", idx
, error
);
333 } while (--retry
> 0);
338 static int __elan_update_firmware(struct elan_tp_data
*data
,
339 const struct firmware
*fw
)
341 struct i2c_client
*client
= data
->client
;
342 struct device
*dev
= &client
->dev
;
347 u16 sw_checksum
= 0, fw_checksum
= 0;
349 error
= data
->ops
->prepare_fw_update(client
);
353 iap_start_addr
= get_unaligned_le16(&fw
->data
[ETP_IAP_START_ADDR
* 2]);
355 boot_page_count
= (iap_start_addr
* 2) / ETP_FW_PAGE_SIZE
;
356 for (i
= boot_page_count
; i
< data
->fw_vaildpage_count
; i
++) {
358 const u8
*page
= &fw
->data
[i
* ETP_FW_PAGE_SIZE
];
360 for (j
= 0; j
< ETP_FW_PAGE_SIZE
; j
+= 2)
361 checksum
+= ((page
[j
+ 1] << 8) | page
[j
]);
363 error
= elan_write_fw_block(data
, page
, checksum
, i
);
365 dev_err(dev
, "write page %d fail: %d\n", i
, error
);
369 sw_checksum
+= checksum
;
372 /* Wait WDT reset and power on reset */
375 error
= data
->ops
->finish_fw_update(client
, &data
->fw_completion
);
379 error
= data
->ops
->get_checksum(client
, true, &fw_checksum
);
383 if (sw_checksum
!= fw_checksum
) {
384 dev_err(dev
, "checksum diff sw=[%04X], fw=[%04X]\n",
385 sw_checksum
, fw_checksum
);
392 static int elan_update_firmware(struct elan_tp_data
*data
,
393 const struct firmware
*fw
)
395 struct i2c_client
*client
= data
->client
;
398 dev_dbg(&client
->dev
, "Starting firmware update....\n");
400 disable_irq(client
->irq
);
401 data
->in_fw_update
= true;
403 retval
= __elan_update_firmware(data
, fw
);
405 dev_err(&client
->dev
, "firmware update failed: %d\n", retval
);
406 data
->ops
->iap_reset(client
);
408 /* Reinitialize TP after fw is updated */
409 elan_initialize(data
);
410 elan_query_device_info(data
);
413 data
->in_fw_update
= false;
414 enable_irq(client
->irq
);
420 *******************************************************************
422 *******************************************************************
424 static ssize_t
elan_sysfs_read_fw_checksum(struct device
*dev
,
425 struct device_attribute
*attr
,
428 struct i2c_client
*client
= to_i2c_client(dev
);
429 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
431 return sprintf(buf
, "0x%04x\n", data
->fw_checksum
);
434 static ssize_t
elan_sysfs_read_product_id(struct device
*dev
,
435 struct device_attribute
*attr
,
438 struct i2c_client
*client
= to_i2c_client(dev
);
439 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
441 return sprintf(buf
, ETP_PRODUCT_ID_FORMAT_STRING
"\n",
445 static ssize_t
elan_sysfs_read_fw_ver(struct device
*dev
,
446 struct device_attribute
*attr
,
449 struct i2c_client
*client
= to_i2c_client(dev
);
450 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
452 return sprintf(buf
, "%d.0\n", data
->fw_version
);
455 static ssize_t
elan_sysfs_read_sm_ver(struct device
*dev
,
456 struct device_attribute
*attr
,
459 struct i2c_client
*client
= to_i2c_client(dev
);
460 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
462 return sprintf(buf
, "%d.0\n", data
->sm_version
);
465 static ssize_t
elan_sysfs_read_iap_ver(struct device
*dev
,
466 struct device_attribute
*attr
,
469 struct i2c_client
*client
= to_i2c_client(dev
);
470 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
472 return sprintf(buf
, "%d.0\n", data
->iap_version
);
475 static ssize_t
elan_sysfs_update_fw(struct device
*dev
,
476 struct device_attribute
*attr
,
477 const char *buf
, size_t count
)
479 struct elan_tp_data
*data
= dev_get_drvdata(dev
);
480 const struct firmware
*fw
;
483 const u8
*fw_signature
;
484 static const u8 signature
[] = {0xAA, 0x55, 0xCC, 0x33, 0xFF, 0xFF};
486 /* Look for a firmware with the product id appended. */
487 fw_name
= kasprintf(GFP_KERNEL
, ETP_FW_NAME
, data
->product_id
);
489 dev_err(dev
, "failed to allocate memory for firmware name\n");
493 dev_info(dev
, "requesting fw '%s'\n", fw_name
);
494 error
= request_firmware(&fw
, fw_name
, dev
);
497 dev_err(dev
, "failed to request firmware: %d\n", error
);
501 /* Firmware file must match signature data */
502 fw_signature
= &fw
->data
[data
->fw_signature_address
];
503 if (memcmp(fw_signature
, signature
, sizeof(signature
)) != 0) {
504 dev_err(dev
, "signature mismatch (expected %*ph, got %*ph)\n",
505 (int)sizeof(signature
), signature
,
506 (int)sizeof(signature
), fw_signature
);
511 error
= mutex_lock_interruptible(&data
->sysfs_mutex
);
515 error
= elan_update_firmware(data
, fw
);
517 mutex_unlock(&data
->sysfs_mutex
);
520 release_firmware(fw
);
521 return error
?: count
;
524 static ssize_t
calibrate_store(struct device
*dev
,
525 struct device_attribute
*attr
,
526 const char *buf
, size_t count
)
528 struct i2c_client
*client
= to_i2c_client(dev
);
529 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
535 retval
= mutex_lock_interruptible(&data
->sysfs_mutex
);
539 disable_irq(client
->irq
);
541 data
->mode
|= ETP_ENABLE_CALIBRATE
;
542 retval
= data
->ops
->set_mode(client
, data
->mode
);
544 dev_err(dev
, "failed to enable calibration mode: %d\n",
549 retval
= data
->ops
->calibrate(client
);
551 dev_err(dev
, "failed to start calibration: %d\n",
553 goto out_disable_calibrate
;
558 /* Wait 250ms before checking if calibration has completed. */
561 retval
= data
->ops
->calibrate_result(client
, val
);
563 dev_err(dev
, "failed to check calibration result: %d\n",
565 else if (val
[0] == 0)
566 break; /* calibration done */
571 dev_err(dev
, "failed to calibrate. Timeout.\n");
575 out_disable_calibrate
:
576 data
->mode
&= ~ETP_ENABLE_CALIBRATE
;
577 error
= data
->ops
->set_mode(data
->client
, data
->mode
);
579 dev_err(dev
, "failed to disable calibration mode: %d\n",
585 enable_irq(client
->irq
);
586 mutex_unlock(&data
->sysfs_mutex
);
587 return retval
?: count
;
590 static ssize_t
elan_sysfs_read_mode(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
);
599 error
= mutex_lock_interruptible(&data
->sysfs_mutex
);
603 error
= data
->ops
->iap_get_mode(data
->client
, &mode
);
605 mutex_unlock(&data
->sysfs_mutex
);
610 return sprintf(buf
, "%d\n", (int)mode
);
613 static DEVICE_ATTR(product_id
, S_IRUGO
, elan_sysfs_read_product_id
, NULL
);
614 static DEVICE_ATTR(firmware_version
, S_IRUGO
, elan_sysfs_read_fw_ver
, NULL
);
615 static DEVICE_ATTR(sample_version
, S_IRUGO
, elan_sysfs_read_sm_ver
, NULL
);
616 static DEVICE_ATTR(iap_version
, S_IRUGO
, elan_sysfs_read_iap_ver
, NULL
);
617 static DEVICE_ATTR(fw_checksum
, S_IRUGO
, elan_sysfs_read_fw_checksum
, NULL
);
618 static DEVICE_ATTR(mode
, S_IRUGO
, elan_sysfs_read_mode
, NULL
);
619 static DEVICE_ATTR(update_fw
, S_IWUSR
, NULL
, elan_sysfs_update_fw
);
621 static DEVICE_ATTR_WO(calibrate
);
623 static struct attribute
*elan_sysfs_entries
[] = {
624 &dev_attr_product_id
.attr
,
625 &dev_attr_firmware_version
.attr
,
626 &dev_attr_sample_version
.attr
,
627 &dev_attr_iap_version
.attr
,
628 &dev_attr_fw_checksum
.attr
,
629 &dev_attr_calibrate
.attr
,
631 &dev_attr_update_fw
.attr
,
635 static const struct attribute_group elan_sysfs_group
= {
636 .attrs
= elan_sysfs_entries
,
639 static ssize_t
acquire_store(struct device
*dev
, struct device_attribute
*attr
,
640 const char *buf
, size_t count
)
642 struct i2c_client
*client
= to_i2c_client(dev
);
643 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
647 retval
= mutex_lock_interruptible(&data
->sysfs_mutex
);
651 disable_irq(client
->irq
);
653 data
->baseline_ready
= false;
655 data
->mode
|= ETP_ENABLE_CALIBRATE
;
656 retval
= data
->ops
->set_mode(data
->client
, data
->mode
);
658 dev_err(dev
, "Failed to enable calibration mode to get baseline: %d\n",
665 retval
= data
->ops
->get_baseline_data(data
->client
, true,
666 &data
->max_baseline
);
668 dev_err(dev
, "Failed to read max baseline form device: %d\n",
670 goto out_disable_calibrate
;
673 retval
= data
->ops
->get_baseline_data(data
->client
, false,
674 &data
->min_baseline
);
676 dev_err(dev
, "Failed to read min baseline form device: %d\n",
678 goto out_disable_calibrate
;
681 data
->baseline_ready
= true;
683 out_disable_calibrate
:
684 data
->mode
&= ~ETP_ENABLE_CALIBRATE
;
685 error
= data
->ops
->set_mode(data
->client
, data
->mode
);
687 dev_err(dev
, "Failed to disable calibration mode after acquiring baseline: %d\n",
693 enable_irq(client
->irq
);
694 mutex_unlock(&data
->sysfs_mutex
);
695 return retval
?: count
;
698 static ssize_t
min_show(struct device
*dev
,
699 struct device_attribute
*attr
, char *buf
)
701 struct i2c_client
*client
= to_i2c_client(dev
);
702 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
705 retval
= mutex_lock_interruptible(&data
->sysfs_mutex
);
709 if (!data
->baseline_ready
) {
714 retval
= snprintf(buf
, PAGE_SIZE
, "%d", data
->min_baseline
);
717 mutex_unlock(&data
->sysfs_mutex
);
721 static ssize_t
max_show(struct device
*dev
,
722 struct device_attribute
*attr
, char *buf
)
724 struct i2c_client
*client
= to_i2c_client(dev
);
725 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
728 retval
= mutex_lock_interruptible(&data
->sysfs_mutex
);
732 if (!data
->baseline_ready
) {
737 retval
= snprintf(buf
, PAGE_SIZE
, "%d", data
->max_baseline
);
740 mutex_unlock(&data
->sysfs_mutex
);
745 static DEVICE_ATTR_WO(acquire
);
746 static DEVICE_ATTR_RO(min
);
747 static DEVICE_ATTR_RO(max
);
749 static struct attribute
*elan_baseline_sysfs_entries
[] = {
750 &dev_attr_acquire
.attr
,
756 static const struct attribute_group elan_baseline_sysfs_group
= {
758 .attrs
= elan_baseline_sysfs_entries
,
761 static const struct attribute_group
*elan_sysfs_groups
[] = {
763 &elan_baseline_sysfs_group
,
768 ******************************************************************
770 ******************************************************************
772 static void elan_report_contact(struct elan_tp_data
*data
,
773 int contact_num
, bool contact_valid
,
776 struct input_dev
*input
= data
->input
;
777 unsigned int pos_x
, pos_y
;
778 unsigned int pressure
, mk_x
, mk_y
;
779 unsigned int area_x
, area_y
, major
, minor
;
780 unsigned int scaled_pressure
;
783 pos_x
= ((finger_data
[0] & 0xf0) << 4) |
785 pos_y
= ((finger_data
[0] & 0x0f) << 8) |
787 mk_x
= (finger_data
[3] & 0x0f);
788 mk_y
= (finger_data
[3] >> 4);
789 pressure
= finger_data
[4];
791 if (pos_x
> data
->max_x
|| pos_y
> data
->max_y
) {
792 dev_dbg(input
->dev
.parent
,
793 "[%d] x=%d y=%d over max (%d, %d)",
794 contact_num
, pos_x
, pos_y
,
795 data
->max_x
, data
->max_y
);
800 * To avoid treating large finger as palm, let's reduce the
801 * width x and y per trace.
803 area_x
= mk_x
* (data
->width_x
- ETP_FWIDTH_REDUCE
);
804 area_y
= mk_y
* (data
->width_y
- ETP_FWIDTH_REDUCE
);
806 major
= max(area_x
, area_y
);
807 minor
= min(area_x
, area_y
);
809 scaled_pressure
= pressure
+ data
->pressure_adjustment
;
811 if (scaled_pressure
> ETP_MAX_PRESSURE
)
812 scaled_pressure
= ETP_MAX_PRESSURE
;
814 input_mt_slot(input
, contact_num
);
815 input_mt_report_slot_state(input
, MT_TOOL_FINGER
, true);
816 input_report_abs(input
, ABS_MT_POSITION_X
, pos_x
);
817 input_report_abs(input
, ABS_MT_POSITION_Y
, data
->max_y
- pos_y
);
818 input_report_abs(input
, ABS_MT_PRESSURE
, scaled_pressure
);
819 input_report_abs(input
, ABS_TOOL_WIDTH
, mk_x
);
820 input_report_abs(input
, ABS_MT_TOUCH_MAJOR
, major
);
821 input_report_abs(input
, ABS_MT_TOUCH_MINOR
, minor
);
823 input_mt_slot(input
, contact_num
);
824 input_mt_report_slot_state(input
, MT_TOOL_FINGER
, false);
828 static void elan_report_absolute(struct elan_tp_data
*data
, u8
*packet
)
830 struct input_dev
*input
= data
->input
;
831 u8
*finger_data
= &packet
[ETP_FINGER_DATA_OFFSET
];
833 u8 tp_info
= packet
[ETP_TOUCH_INFO_OFFSET
];
834 u8 hover_info
= packet
[ETP_HOVER_INFO_OFFSET
];
835 bool contact_valid
, hover_event
;
837 hover_event
= hover_info
& 0x40;
838 for (i
= 0; i
< ETP_MAX_FINGERS
; i
++) {
839 contact_valid
= tp_info
& (1U << (3 + i
));
840 elan_report_contact(data
, i
, contact_valid
, finger_data
);
843 finger_data
+= ETP_FINGER_DATA_LEN
;
846 input_report_key(input
, BTN_LEFT
, tp_info
& 0x01);
847 input_report_abs(input
, ABS_DISTANCE
, hover_event
!= 0);
848 input_mt_report_pointer_emulation(input
, true);
852 static irqreturn_t
elan_isr(int irq
, void *dev_id
)
854 struct elan_tp_data
*data
= dev_id
;
855 struct device
*dev
= &data
->client
->dev
;
857 u8 report
[ETP_MAX_REPORT_LEN
];
860 * When device is connected to i2c bus, when all IAP page writes
861 * complete, the driver will receive interrupt and must read
862 * 0000 to confirm that IAP is finished.
864 if (data
->in_fw_update
) {
865 complete(&data
->fw_completion
);
869 error
= data
->ops
->get_report(data
->client
, report
);
873 if (report
[ETP_REPORT_ID_OFFSET
] != ETP_REPORT_ID
)
874 dev_err(dev
, "invalid report id data (%x)\n",
875 report
[ETP_REPORT_ID_OFFSET
]);
877 elan_report_absolute(data
, report
);
884 ******************************************************************
885 * Elan initialization functions
886 ******************************************************************
888 static int elan_setup_input_device(struct elan_tp_data
*data
)
890 struct device
*dev
= &data
->client
->dev
;
891 struct input_dev
*input
;
892 unsigned int max_width
= max(data
->width_x
, data
->width_y
);
893 unsigned int min_width
= min(data
->width_x
, data
->width_y
);
896 input
= devm_input_allocate_device(dev
);
900 input
->name
= "Elan Touchpad";
901 input
->id
.bustype
= BUS_I2C
;
902 input_set_drvdata(input
, data
);
904 error
= input_mt_init_slots(input
, ETP_MAX_FINGERS
,
905 INPUT_MT_POINTER
| INPUT_MT_DROP_UNUSED
);
907 dev_err(dev
, "failed to initialize MT slots: %d\n", error
);
911 __set_bit(EV_ABS
, input
->evbit
);
912 __set_bit(INPUT_PROP_POINTER
, input
->propbit
);
913 __set_bit(INPUT_PROP_BUTTONPAD
, input
->propbit
);
914 __set_bit(BTN_LEFT
, input
->keybit
);
916 /* Set up ST parameters */
917 input_set_abs_params(input
, ABS_X
, 0, data
->max_x
, 0, 0);
918 input_set_abs_params(input
, ABS_Y
, 0, data
->max_y
, 0, 0);
919 input_abs_set_res(input
, ABS_X
, data
->x_res
);
920 input_abs_set_res(input
, ABS_Y
, data
->y_res
);
921 input_set_abs_params(input
, ABS_PRESSURE
, 0, ETP_MAX_PRESSURE
, 0, 0);
922 input_set_abs_params(input
, ABS_TOOL_WIDTH
, 0, ETP_FINGER_WIDTH
, 0, 0);
923 input_set_abs_params(input
, ABS_DISTANCE
, 0, 1, 0, 0);
925 /* And MT parameters */
926 input_set_abs_params(input
, ABS_MT_POSITION_X
, 0, data
->max_x
, 0, 0);
927 input_set_abs_params(input
, ABS_MT_POSITION_Y
, 0, data
->max_y
, 0, 0);
928 input_abs_set_res(input
, ABS_MT_POSITION_X
, data
->x_res
);
929 input_abs_set_res(input
, ABS_MT_POSITION_Y
, data
->y_res
);
930 input_set_abs_params(input
, ABS_MT_PRESSURE
, 0,
931 ETP_MAX_PRESSURE
, 0, 0);
932 input_set_abs_params(input
, ABS_MT_TOUCH_MAJOR
, 0,
933 ETP_FINGER_WIDTH
* max_width
, 0, 0);
934 input_set_abs_params(input
, ABS_MT_TOUCH_MINOR
, 0,
935 ETP_FINGER_WIDTH
* min_width
, 0, 0);
942 static void elan_disable_regulator(void *_data
)
944 struct elan_tp_data
*data
= _data
;
946 regulator_disable(data
->vcc
);
949 static void elan_remove_sysfs_groups(void *_data
)
951 struct elan_tp_data
*data
= _data
;
953 sysfs_remove_groups(&data
->client
->dev
.kobj
, elan_sysfs_groups
);
956 static int elan_probe(struct i2c_client
*client
,
957 const struct i2c_device_id
*dev_id
)
959 const struct elan_transport_ops
*transport_ops
;
960 struct device
*dev
= &client
->dev
;
961 struct elan_tp_data
*data
;
962 unsigned long irqflags
;
965 if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_I2C
) &&
966 i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
)) {
967 transport_ops
= &elan_i2c_ops
;
968 } else if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_SMBUS
) &&
969 i2c_check_functionality(client
->adapter
,
970 I2C_FUNC_SMBUS_BYTE_DATA
|
971 I2C_FUNC_SMBUS_BLOCK_DATA
|
972 I2C_FUNC_SMBUS_I2C_BLOCK
)) {
973 transport_ops
= &elan_smbus_ops
;
975 dev_err(dev
, "not a supported I2C/SMBus adapter\n");
979 data
= devm_kzalloc(&client
->dev
, sizeof(struct elan_tp_data
),
984 i2c_set_clientdata(client
, data
);
986 data
->ops
= transport_ops
;
987 data
->client
= client
;
988 init_completion(&data
->fw_completion
);
989 mutex_init(&data
->sysfs_mutex
);
991 data
->vcc
= devm_regulator_get(&client
->dev
, "vcc");
992 if (IS_ERR(data
->vcc
)) {
993 error
= PTR_ERR(data
->vcc
);
994 if (error
!= -EPROBE_DEFER
)
995 dev_err(&client
->dev
,
996 "Failed to get 'vcc' regulator: %d\n",
1001 error
= regulator_enable(data
->vcc
);
1003 dev_err(&client
->dev
,
1004 "Failed to enable regulator: %d\n", error
);
1008 error
= devm_add_action(&client
->dev
,
1009 elan_disable_regulator
, data
);
1011 regulator_disable(data
->vcc
);
1012 dev_err(&client
->dev
,
1013 "Failed to add disable regulator action: %d\n",
1018 /* Initialize the touchpad. */
1019 error
= elan_initialize(data
);
1023 error
= elan_query_device_info(data
);
1027 error
= elan_query_device_parameters(data
);
1031 dev_dbg(&client
->dev
,
1032 "Elan Touchpad Information:\n"
1033 " Module product ID: 0x%04x\n"
1034 " Firmware Version: 0x%04x\n"
1035 " Sample Version: 0x%04x\n"
1036 " IAP Version: 0x%04x\n"
1037 " Max ABS X,Y: %d,%d\n"
1038 " Width X,Y: %d,%d\n"
1039 " Resolution X,Y: %d,%d (dots/mm)\n",
1044 data
->max_x
, data
->max_y
,
1045 data
->width_x
, data
->width_y
,
1046 data
->x_res
, data
->y_res
);
1048 /* Set up input device properties based on queried parameters. */
1049 error
= elan_setup_input_device(data
);
1054 * Systems using device tree should set up interrupt via DTS,
1055 * the rest will use the default falling edge interrupts.
1057 irqflags
= client
->dev
.of_node
? 0 : IRQF_TRIGGER_FALLING
;
1059 error
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
1061 irqflags
| IRQF_ONESHOT
,
1062 client
->name
, data
);
1064 dev_err(&client
->dev
, "cannot register irq=%d\n", client
->irq
);
1068 error
= sysfs_create_groups(&client
->dev
.kobj
, elan_sysfs_groups
);
1070 dev_err(&client
->dev
, "failed to create sysfs attributes: %d\n",
1075 error
= devm_add_action(&client
->dev
,
1076 elan_remove_sysfs_groups
, data
);
1078 elan_remove_sysfs_groups(data
);
1079 dev_err(&client
->dev
,
1080 "Failed to add sysfs cleanup action: %d\n",
1085 error
= input_register_device(data
->input
);
1087 dev_err(&client
->dev
, "failed to register input device: %d\n",
1093 * Systems using device tree should set up wakeup via DTS,
1094 * the rest will configure device as wakeup source by default.
1096 if (!client
->dev
.of_node
)
1097 device_init_wakeup(&client
->dev
, true);
1102 static int __maybe_unused
elan_suspend(struct device
*dev
)
1104 struct i2c_client
*client
= to_i2c_client(dev
);
1105 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
1109 * We are taking the mutex to make sure sysfs operations are
1110 * complete before we attempt to bring the device into low[er]
1113 ret
= mutex_lock_interruptible(&data
->sysfs_mutex
);
1117 disable_irq(client
->irq
);
1119 if (device_may_wakeup(dev
)) {
1120 ret
= elan_sleep(data
);
1121 /* Enable wake from IRQ */
1122 data
->irq_wake
= (enable_irq_wake(client
->irq
) == 0);
1124 ret
= elan_disable_power(data
);
1127 mutex_unlock(&data
->sysfs_mutex
);
1131 static int __maybe_unused
elan_resume(struct device
*dev
)
1133 struct i2c_client
*client
= to_i2c_client(dev
);
1134 struct elan_tp_data
*data
= i2c_get_clientdata(client
);
1137 if (device_may_wakeup(dev
) && data
->irq_wake
) {
1138 disable_irq_wake(client
->irq
);
1139 data
->irq_wake
= false;
1142 error
= elan_enable_power(data
);
1144 dev_err(dev
, "power up when resuming failed: %d\n", error
);
1148 error
= elan_initialize(data
);
1150 dev_err(dev
, "initialize when resuming failed: %d\n", error
);
1153 enable_irq(data
->client
->irq
);
1157 static SIMPLE_DEV_PM_OPS(elan_pm_ops
, elan_suspend
, elan_resume
);
1159 static const struct i2c_device_id elan_id
[] = {
1163 MODULE_DEVICE_TABLE(i2c
, elan_id
);
1166 static const struct acpi_device_id elan_acpi_id
[] = {
1170 MODULE_DEVICE_TABLE(acpi
, elan_acpi_id
);
1174 static const struct of_device_id elan_of_match
[] = {
1175 { .compatible
= "elan,ekth3000" },
1178 MODULE_DEVICE_TABLE(of
, elan_of_match
);
1181 static struct i2c_driver elan_driver
= {
1183 .name
= DRIVER_NAME
,
1184 .owner
= THIS_MODULE
,
1186 .acpi_match_table
= ACPI_PTR(elan_acpi_id
),
1187 .of_match_table
= of_match_ptr(elan_of_match
),
1189 .probe
= elan_probe
,
1190 .id_table
= elan_id
,
1193 module_i2c_driver(elan_driver
);
1195 MODULE_AUTHOR("Duson Lin <dusonlin@emc.com.tw>");
1196 MODULE_DESCRIPTION("Elan I2C/SMBus Touchpad driver");
1197 MODULE_LICENSE("GPL");
1198 MODULE_VERSION(ELAN_DRIVER_VERSION
);