aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorDuson Lin <dusonlin@emc.com.tw>2014-10-03 16:24:27 -0400
committerDmitry Torokhov <dmitry.torokhov@gmail.com>2014-10-24 16:54:24 -0400
commit6696777c6506fa52b2a0282121195843ed855be6 (patch)
tree884054a61197a1a5cafaf06002e2ba38619ab1b3
parentdae7aa8d849615134a11704cbd37fb45a22bd316 (diff)
Input: add driver for Elan I2C/SMbus touchpad
This driver supports Elan I2C/SMbus touchpads found in some laptops and also in many Chromebooks. Signed-off-by: Duson Lin <dusonlin@emc.com.tw> Reviewed-by: Benson Leung <bleung@chromium.org> Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
Diffstat
-rw-r--r--Documentation/devicetree/bindings/input/elan_i2c.txt34
-rw-r--r--Documentation/devicetree/bindings/vendor-prefixes.txt1
-rw-r--r--drivers/input/mouse/Kconfig30
-rw-r--r--drivers/input/mouse/Makefile5
-rw-r--r--drivers/input/mouse/elan_i2c.h86
-rw-r--r--drivers/input/mouse/elan_i2c_core.c1137
-rw-r--r--drivers/input/mouse/elan_i2c_i2c.c611
-rw-r--r--drivers/input/mouse/elan_i2c_smbus.c514
8 files changed, 2418 insertions, 0 deletions
diff --git a/Documentation/devicetree/bindings/input/elan_i2c.txt b/Documentation/devicetree/bindings/input/elan_i2c.txt
new file mode 100644
index 000000000000..ee3242c4ba67
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/elan_i2c.txt
@@ -0,0 +1,34 @@
1Elantech I2C Touchpad
2
3Required properties:
4- compatible: must be "elan,ekth3000".
5- reg: I2C address of the chip.
6- interrupt-parent: a phandle for the interrupt controller (see interrupt
7 binding[0]).
8- interrupts: interrupt to which the chip is connected (see interrupt
9 binding[0]).
10
11Optional properties:
12- wakeup-source: touchpad can be used as a wakeup source.
13- pinctrl-names: should be "default" (see pinctrl binding [1]).
14- pinctrl-0: a phandle pointing to the pin settings for the device (see
15 pinctrl binding [1]).
16- vcc-supply: a phandle for the regulator supplying 3.3V power.
17
18[0]: Documentation/devicetree/bindings/interrupt-controller/interrupts.txt
19[1]: Documentation/devicetree/bindings/pinctrl/pinctrl-bindings.txt
20
21Example:
22 &i2c1 {
23 /* ... */
24
25 touchpad@15 {
26 compatible = "elan,ekth3000";
27 reg = <0x15>;
28 interrupt-parent = <&gpio4>;
29 interrupts = <0x0 IRQ_TYPE_EDGE_FALLING>;
30 wakeup-source;
31 };
32
33 /* ... */
34 };
diff --git a/Documentation/devicetree/bindings/vendor-prefixes.txt b/Documentation/devicetree/bindings/vendor-prefixes.txt
index ac7269f90764..e6469ec7a90e 100644
--- a/Documentation/devicetree/bindings/vendor-prefixes.txt
+++ b/Documentation/devicetree/bindings/vendor-prefixes.txt
@@ -42,6 +42,7 @@ dlink D-Link Corporation
42dmo Data Modul AG 42dmo Data Modul AG
43ebv EBV Elektronik 43ebv EBV Elektronik
44edt Emerging Display Technologies 44edt Emerging Display Technologies
45elan Elan Microelectronic Corp.
45emmicro EM Microelectronic 46emmicro EM Microelectronic
46epcos EPCOS AG 47epcos EPCOS AG
47epfl Ecole Polytechnique Fédérale de Lausanne 48epfl Ecole Polytechnique Fédérale de Lausanne
diff --git a/drivers/input/mouse/Kconfig b/drivers/input/mouse/Kconfig
index 366fc7ad5eb6..d8b46b0f2dbe 100644
--- a/drivers/input/mouse/Kconfig
+++ b/drivers/input/mouse/Kconfig
@@ -215,6 +215,36 @@ config MOUSE_CYAPA
215 To compile this driver as a module, choose M here: the module will be 215 To compile this driver as a module, choose M here: the module will be
216 called cyapa. 216 called cyapa.
217 217
218config MOUSE_ELAN_I2C
219 tristate "ELAN I2C Touchpad support"
220 depends on I2C
221 help
222 This driver adds support for Elan I2C/SMbus Trackpads.
223
224 Say Y here if you have a ELAN I2C/SMbus Touchpad.
225
226 To compile this driver as a module, choose M here: the module will be
227 called elan_i2c.
228
229config MOUSE_ELAN_I2C_I2C
230 bool "Enable I2C support"
231 depends on MOUSE_ELAN_I2C
232 default y
233 help
234 Say Y here if Elan Touchpad in your system is connected to
235 a standard I2C controller.
236
237 If unsure, say Y.
238
239config MOUSE_ELAN_I2C_SMBUS
240 bool "Enable SMbus support"
241 depends on MOUSE_ELAN_I2C
242 help
243 Say Y here if Elan Touchpad in your system is connected to
244 a SMbus adapter.
245
246 If unsure, say Y.
247
218config MOUSE_INPORT 248config MOUSE_INPORT
219 tristate "InPort/MS/ATIXL busmouse" 249 tristate "InPort/MS/ATIXL busmouse"
220 depends on ISA 250 depends on ISA
diff --git a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile
index dda507f8b3a2..560003dcac37 100644
--- a/drivers/input/mouse/Makefile
+++ b/drivers/input/mouse/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_MOUSE_APPLETOUCH) += appletouch.o
9obj-$(CONFIG_MOUSE_ATARI) += atarimouse.o 9obj-$(CONFIG_MOUSE_ATARI) += atarimouse.o
10obj-$(CONFIG_MOUSE_BCM5974) += bcm5974.o 10obj-$(CONFIG_MOUSE_BCM5974) += bcm5974.o
11obj-$(CONFIG_MOUSE_CYAPA) += cyapa.o 11obj-$(CONFIG_MOUSE_CYAPA) += cyapa.o
12obj-$(CONFIG_MOUSE_ELAN_I2C) += elan_i2c.o
12obj-$(CONFIG_MOUSE_GPIO) += gpio_mouse.o 13obj-$(CONFIG_MOUSE_GPIO) += gpio_mouse.o
13obj-$(CONFIG_MOUSE_INPORT) += inport.o 14obj-$(CONFIG_MOUSE_INPORT) += inport.o
14obj-$(CONFIG_MOUSE_LOGIBM) += logibm.o 15obj-$(CONFIG_MOUSE_LOGIBM) += logibm.o
@@ -34,3 +35,7 @@ psmouse-$(CONFIG_MOUSE_PS2_SENTELIC) += sentelic.o
34psmouse-$(CONFIG_MOUSE_PS2_TRACKPOINT) += trackpoint.o 35psmouse-$(CONFIG_MOUSE_PS2_TRACKPOINT) += trackpoint.o
35psmouse-$(CONFIG_MOUSE_PS2_TOUCHKIT) += touchkit_ps2.o 36psmouse-$(CONFIG_MOUSE_PS2_TOUCHKIT) += touchkit_ps2.o
36psmouse-$(CONFIG_MOUSE_PS2_CYPRESS) += cypress_ps2.o 37psmouse-$(CONFIG_MOUSE_PS2_CYPRESS) += cypress_ps2.o
38
39elan_i2c-objs := elan_i2c_core.o
40elan_i2c-$(CONFIG_MOUSE_ELAN_I2C_I2C) += elan_i2c_i2c.o
41elan_i2c-$(CONFIG_MOUSE_ELAN_I2C_SMBUS) += elan_i2c_smbus.o
diff --git a/drivers/input/mouse/elan_i2c.h b/drivers/input/mouse/elan_i2c.h
new file mode 100644
index 000000000000..2e838626205f
--- /dev/null
+++ b/drivers/input/mouse/elan_i2c.h
@@ -0,0 +1,86 @@
1/*
2 * Elan I2C/SMBus Touchpad driver
3 *
4 * Copyright (c) 2013 ELAN Microelectronics Corp.
5 *
6 * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw>
7 * Version: 1.5.5
8 *
9 * Based on cyapa driver:
10 * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
11 * copyright (c) 2011-2012 Google, Inc.
12 *
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.
16 *
17 * Trademarks are the property of their respective owners.
18 */
19
20#ifndef _ELAN_I2C_H
21#define _ELAN_i2C_H
22
23#include <linux/types.h>
24
25#define ETP_ENABLE_ABS 0x0001
26#define ETP_ENABLE_CALIBRATE 0x0002
27#define ETP_DISABLE_CALIBRATE 0x0000
28#define ETP_DISABLE_POWER 0x0001
29
30/* IAP Firmware handling */
31#define ETP_FW_NAME "elan_i2c.bin"
32#define ETP_IAP_START_ADDR 0x0083
33#define ETP_FW_IAP_PAGE_ERR (1 << 5)
34#define ETP_FW_IAP_INTF_ERR (1 << 4)
35#define ETP_FW_PAGE_SIZE 64
36#define ETP_FW_PAGE_COUNT 768
37#define ETP_FW_SIZE (ETP_FW_PAGE_SIZE * ETP_FW_PAGE_COUNT)
38
39struct i2c_client;
40struct completion;
41
42enum tp_mode {
43 IAP_MODE = 1,
44 MAIN_MODE
45};
46
47struct elan_transport_ops {
48 int (*initialize)(struct i2c_client *client);
49 int (*sleep_control)(struct i2c_client *, bool sleep);
50 int (*power_control)(struct i2c_client *, bool enable);
51 int (*set_mode)(struct i2c_client *client, u8 mode);
52
53 int (*calibrate)(struct i2c_client *client);
54 int (*calibrate_result)(struct i2c_client *client, u8 *val);
55
56 int (*get_baseline_data)(struct i2c_client *client,
57 bool max_baseliune, u8 *value);
58
59 int (*get_version)(struct i2c_client *client, bool iap, u8 *version);
60 int (*get_sm_version)(struct i2c_client *client, u8 *version);
61 int (*get_checksum)(struct i2c_client *client, bool iap, u16 *csum);
62 int (*get_product_id)(struct i2c_client *client, u8 *id);
63
64 int (*get_max)(struct i2c_client *client,
65 unsigned int *max_x, unsigned int *max_y);
66 int (*get_resolution)(struct i2c_client *client,
67 u8 *hw_res_x, u8 *hw_res_y);
68 int (*get_num_traces)(struct i2c_client *client,
69 unsigned int *x_tracenum,
70 unsigned int *y_tracenum);
71
72 int (*iap_get_mode)(struct i2c_client *client, enum tp_mode *mode);
73 int (*iap_reset)(struct i2c_client *client);
74
75 int (*prepare_fw_update)(struct i2c_client *client);
76 int (*write_fw_block)(struct i2c_client *client,
77 const u8 *page, u16 checksum, int idx);
78 int (*finish_fw_update)(struct i2c_client *client,
79 struct completion *reset_done);
80
81 int (*get_report)(struct i2c_client *client, u8 *report);
82};
83
84extern const struct elan_transport_ops elan_smbus_ops, elan_i2c_ops;
85
86#endif /* _ELAN_I2C_H */
diff --git a/drivers/input/mouse/elan_i2c_core.c b/drivers/input/mouse/elan_i2c_core.c
new file mode 100644
index 000000000000..0cb2be48d537
--- /dev/null
+++ b/drivers/input/mouse/elan_i2c_core.c
@@ -0,0 +1,1137 @@
1/*
2 * Elan I2C/SMBus Touchpad driver
3 *
4 * Copyright (c) 2013 ELAN Microelectronics Corp.
5 *
6 * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw>
7 * Version: 1.5.5
8 *
9 * Based on cyapa driver:
10 * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
11 * copyright (c) 2011-2012 Google, Inc.
12 *
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.
16 *
17 * Trademarks are the property of their respective owners.
18 */
19
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>
36#include <linux/of.h>
37#include <linux/regulator/consumer.h>
38#include <asm/unaligned.h>
39
40#include "elan_i2c.h"
41
42#define DRIVER_NAME "elan_i2c"
43#define ELAN_DRIVER_VERSION "1.5.5"
44#define ETP_PRESSURE_OFFSET 25
45#define ETP_MAX_PRESSURE 255
46#define ETP_FWIDTH_REDUCE 90
47#define ETP_FINGER_WIDTH 15
48#define ETP_RETRY_COUNT 3
49
50#define ETP_MAX_FINGERS 5
51#define ETP_FINGER_DATA_LEN 5
52#define ETP_REPORT_ID 0x5D
53#define ETP_REPORT_ID_OFFSET 2
54#define ETP_TOUCH_INFO_OFFSET 3
55#define ETP_FINGER_DATA_OFFSET 4
56#define ETP_MAX_REPORT_LEN 34
57
58/* The main device structure */
59struct elan_tp_data {
60 struct i2c_client *client;
61 struct input_dev *input;
62 struct regulator *vcc;
63
64 const struct elan_transport_ops *ops;
65
66 /* for fw update */
67 struct completion fw_completion;
68 bool in_fw_update;
69
70 struct mutex sysfs_mutex;
71
72 unsigned int max_x;
73 unsigned int max_y;
74 unsigned int width_x;
75 unsigned int width_y;
76 unsigned int x_res;
77 unsigned int y_res;
78
79 u8 product_id;
80 u8 fw_version;
81 u8 sm_version;
82 u8 iap_version;
83 u16 fw_checksum;
84
85 u8 mode;
86
87 bool irq_wake;
88
89 u8 min_baseline;
90 u8 max_baseline;
91 bool baseline_ready;
92};
93
94static int elan_enable_power(struct elan_tp_data *data)
95{
96 int repeat = ETP_RETRY_COUNT;
97 int error;
98
99 error = regulator_enable(data->vcc);
100 if (error) {
101 dev_err(&data->client->dev,
102 "Failed to enable regulator: %d\n", error);
103 return error;
104 }
105
106 do {
107 error = data->ops->power_control(data->client, true);
108 if (error >= 0)
109 return 0;
110
111 msleep(30);
112 } while (--repeat > 0);
113
114 return error;
115}
116
117static int elan_disable_power(struct elan_tp_data *data)
118{
119 int repeat = ETP_RETRY_COUNT;
120 int error;
121
122 do {
123 error = data->ops->power_control(data->client, false);
124 if (!error) {
125 error = regulator_disable(data->vcc);
126 if (error) {
127 dev_err(&data->client->dev,
128 "Failed to disable regulator: %d\n",
129 error);
130 /* Attempt to power the chip back up */
131 data->ops->power_control(data->client, true);
132 break;
133 }
134
135 return 0;
136 }
137
138 msleep(30);
139 } while (--repeat > 0);
140
141 return error;
142}
143
144static int elan_sleep(struct elan_tp_data *data)
145{
146 int repeat = ETP_RETRY_COUNT;
147 int error;
148
149 do {
150 error = data->ops->sleep_control(data->client, true);
151 if (!error)
152 return 0;
153
154 msleep(30);
155 } while (--repeat > 0);
156
157 return error;
158}
159
160static int __elan_initialize(struct elan_tp_data *data)
161{
162 struct i2c_client *client = data->client;
163 int error;
164
165 error = data->ops->initialize(client);
166 if (error) {
167 dev_err(&client->dev, "device initialize failed: %d\n", error);
168 return error;
169 }
170
171 data->mode |= ETP_ENABLE_ABS;
172 error = data->ops->set_mode(client, data->mode);
173 if (error) {
174 dev_err(&client->dev,
175 "failed to switch to absolute mode: %d\n", error);
176 return error;
177 }
178
179 error = data->ops->sleep_control(client, false);
180 if (error) {
181 dev_err(&client->dev,
182 "failed to wake device up: %d\n", error);
183 return error;
184 }
185
186 return 0;
187}
188
189static int elan_initialize(struct elan_tp_data *data)
190{
191 int repeat = ETP_RETRY_COUNT;
192 int error;
193
194 do {
195 error = __elan_initialize(data);
196 if (!error)
197 return 0;
198
199 repeat--;
200 msleep(30);
201 } while (--repeat > 0);
202
203 return error;
204}
205
206static int elan_query_device_info(struct elan_tp_data *data)
207{
208 int error;
209
210 error = data->ops->get_product_id(data->client, &data->product_id);
211 if (error)
212 return error;
213
214 error = data->ops->get_version(data->client, false, &data->fw_version);
215 if (error)
216 return error;
217
218 error = data->ops->get_checksum(data->client, false,
219 &data->fw_checksum);
220 if (error)
221 return error;
222
223 error = data->ops->get_sm_version(data->client, &data->sm_version);
224 if (error)
225 return error;
226
227 error = data->ops->get_version(data->client, true, &data->iap_version);
228 if (error)
229 return error;
230
231 return 0;
232}
233
234static unsigned int elan_convert_resolution(u8 val)
235{
236 /*
237 * (value from firmware) * 10 + 790 = dpi
238 *
239 * We also have to convert dpi to dots/mm (*10/254 to avoid floating
240 * point).
241 */
242
243 return ((int)(char)val * 10 + 790) * 10 / 254;
244}
245
246static int elan_query_device_parameters(struct elan_tp_data *data)
247{
248 unsigned int x_traces, y_traces;
249 u8 hw_x_res, hw_y_res;
250 int error;
251
252 error = data->ops->get_max(data->client, &data->max_x, &data->max_y);
253 if (error)
254 return error;
255
256 error = data->ops->get_num_traces(data->client, &x_traces, &y_traces);
257 if (error)
258 return error;
259
260 data->width_x = data->max_x / x_traces;
261 data->width_y = data->max_y / y_traces;
262
263 error = data->ops->get_resolution(data->client, &hw_x_res, &hw_y_res);
264 if (error)
265 return error;
266
267 data->x_res = elan_convert_resolution(hw_x_res);
268 data->y_res = elan_convert_resolution(hw_y_res);
269
270 return 0;
271}
272
273/*
274 **********************************************************
275 * IAP firmware updater related routines
276 **********************************************************
277 */
278static int elan_write_fw_block(struct elan_tp_data *data,
279 const u8 *page, u16 checksum, int idx)
280{
281 int retry = ETP_RETRY_COUNT;
282 int error;
283
284 do {
285 error = data->ops->write_fw_block(data->client,
286 page, checksum, idx);
287 if (!error)
288 return 0;
289
290 dev_dbg(&data->client->dev,
291 "IAP retrying page %d (error: %d)\n", idx, error);
292 } while (--retry > 0);
293
294 return error;
295}
296
297static int __elan_update_firmware(struct elan_tp_data *data,
298 const struct firmware *fw)
299{
300 struct i2c_client *client = data->client;
301 struct device *dev = &client->dev;
302 int i, j;
303 int error;
304 u16 iap_start_addr;
305 u16 boot_page_count;
306 u16 sw_checksum = 0, fw_checksum = 0;
307
308 error = data->ops->prepare_fw_update(client);
309 if (error)
310 return error;
311
312 iap_start_addr = get_unaligned_le16(&fw->data[ETP_IAP_START_ADDR * 2]);
313
314 boot_page_count = (iap_start_addr * 2) / ETP_FW_PAGE_SIZE;
315 for (i = boot_page_count; i < ETP_FW_PAGE_COUNT; i++) {
316 u16 checksum = 0;
317 const u8 *page = &fw->data[i * ETP_FW_PAGE_SIZE];
318
319 for (j = 0; j < ETP_FW_PAGE_SIZE; j += 2)
320 checksum += ((page[j + 1] << 8) | page[j]);
321
322 error = elan_write_fw_block(data, page, checksum, i);
323 if (error) {
324 dev_err(dev, "write page %d fail: %d\n", i, error);
325 return error;
326 }
327
328 sw_checksum += checksum;
329 }
330
331 /* Wait WDT reset and power on reset */
332 msleep(600);
333
334 error = data->ops->finish_fw_update(client, &data->fw_completion);
335 if (error)
336 return error;
337
338 error = data->ops->get_checksum(client, true, &fw_checksum);
339 if (error)
340 return error;
341
342 if (sw_checksum != fw_checksum) {
343 dev_err(dev, "checksum diff sw=[%04X], fw=[%04X]\n",
344 sw_checksum, fw_checksum);
345 return -EIO;
346 }
347
348 return 0;
349}
350
351static int elan_update_firmware(struct elan_tp_data *data,
352 const struct firmware *fw)
353{
354 struct i2c_client *client = data->client;
355 int retval;
356
357 dev_dbg(&client->dev, "Starting firmware update....\n");
358
359 disable_irq(client->irq);
360 data->in_fw_update = true;
361
362 retval = __elan_update_firmware(data, fw);
363 if (retval) {
364 dev_err(&client->dev, "firmware update failed: %d\n", retval);
365 data->ops->iap_reset(client);
366 } else {
367 /* Reinitialize TP after fw is updated */
368 elan_initialize(data);
369 elan_query_device_info(data);
370 }
371
372 data->in_fw_update = false;
373 enable_irq(client->irq);
374
375 return retval;
376}
377
378/*
379 *******************************************************************
380 * SYSFS attributes
381 *******************************************************************
382 */
383static ssize_t elan_sysfs_read_fw_checksum(struct device *dev,
384 struct device_attribute *attr,
385 char *buf)
386{
387 struct i2c_client *client = to_i2c_client(dev);
388 struct elan_tp_data *data = i2c_get_clientdata(client);
389
390 return sprintf(buf, "0x%04x\n", data->fw_checksum);
391}
392
393static ssize_t elan_sysfs_read_product_id(struct device *dev,
394 struct device_attribute *attr,
395 char *buf)
396{
397 struct i2c_client *client = to_i2c_client(dev);
398 struct elan_tp_data *data = i2c_get_clientdata(client);
399
400 return sprintf(buf, "%d.0\n", data->product_id);
401}
402
403static ssize_t elan_sysfs_read_fw_ver(struct device *dev,
404 struct device_attribute *attr,
405 char *buf)
406{
407 struct i2c_client *client = to_i2c_client(dev);
408 struct elan_tp_data *data = i2c_get_clientdata(client);
409
410 return sprintf(buf, "%d.0\n", data->fw_version);
411}
412
413static ssize_t elan_sysfs_read_sm_ver(struct device *dev,
414 struct device_attribute *attr,
415 char *buf)
416{
417 struct i2c_client *client = to_i2c_client(dev);
418 struct elan_tp_data *data = i2c_get_clientdata(client);
419
420 return sprintf(buf, "%d.0\n", data->sm_version);
421}
422
423static ssize_t elan_sysfs_read_iap_ver(struct device *dev,
424 struct device_attribute *attr,
425 char *buf)
426{
427 struct i2c_client *client = to_i2c_client(dev);
428 struct elan_tp_data *data = i2c_get_clientdata(client);
429
430 return sprintf(buf, "%d.0\n", data->iap_version);
431}
432
433static ssize_t elan_sysfs_update_fw(struct device *dev,
434 struct device_attribute *attr,
435 const char *buf, size_t count)
436{
437 struct i2c_client *client = to_i2c_client(dev);
438 struct elan_tp_data *data = i2c_get_clientdata(client);
439 const struct firmware *fw;
440 int error;
441
442 error = request_firmware(&fw, ETP_FW_NAME, dev);
443 if (error) {
444 dev_err(dev, "cannot load firmware %s: %d\n",
445 ETP_FW_NAME, error);
446 return error;
447 }
448
449 /* Firmware must be exactly PAGE_NUM * PAGE_SIZE bytes */
450 if (fw->size != ETP_FW_SIZE) {
451 dev_err(dev, "invalid firmware size = %zu, expected %d.\n",
452 fw->size, ETP_FW_SIZE);
453 error = -EBADF;
454 goto out_release_fw;
455 }
456
457 error = mutex_lock_interruptible(&data->sysfs_mutex);
458 if (error)
459 goto out_release_fw;
460
461 error = elan_update_firmware(data, fw);
462
463 mutex_unlock(&data->sysfs_mutex);
464
465out_release_fw:
466 release_firmware(fw);
467 return error ?: count;
468}
469
470static ssize_t calibrate_store(struct device *dev,
471 struct device_attribute *attr,
472 const char *buf, size_t count)
473{
474 struct i2c_client *client = to_i2c_client(dev);
475 struct elan_tp_data *data = i2c_get_clientdata(client);
476 int tries = 20;
477 int retval;
478 int error;
479 u8 val[3];
480
481 retval = mutex_lock_interruptible(&data->sysfs_mutex);
482 if (retval)
483 return retval;
484
485 disable_irq(client->irq);
486
487 data->mode |= ETP_ENABLE_CALIBRATE;
488 retval = data->ops->set_mode(client, data->mode);
489 if (retval) {
490 dev_err(dev, "failed to enable calibration mode: %d\n",
491 retval);
492 goto out;
493 }
494
495 retval = data->ops->calibrate(client);
496 if (retval) {
497 dev_err(dev, "failed to start calibration: %d\n",
498 retval);
499 goto out_disable_calibrate;
500 }
501
502 val[0] = 0xff;
503 do {
504 /* Wait 250ms before checking if calibration has completed. */
505 msleep(250);
506
507 retval = data->ops->calibrate_result(client, val);
508 if (retval)
509 dev_err(dev, "failed to check calibration result: %d\n",
510 retval);
511 else if (val[0] == 0)
512 break; /* calibration done */
513
514 } while (--tries);
515
516 if (tries == 0) {
517 dev_err(dev, "failed to calibrate. Timeout.\n");
518 retval = -ETIMEDOUT;
519 }
520
521out_disable_calibrate:
522 data->mode &= ~ETP_ENABLE_CALIBRATE;
523 error = data->ops->set_mode(data->client, data->mode);
524 if (error) {
525 dev_err(dev, "failed to disable calibration mode: %d\n",
526 error);
527 if (!retval)
528 retval = error;
529 }
530out:
531 enable_irq(client->irq);
532 mutex_unlock(&data->sysfs_mutex);
533 return retval ?: count;
534}
535
536static ssize_t elan_sysfs_read_mode(struct device *dev,
537 struct device_attribute *attr,
538 char *buf)
539{
540 struct i2c_client *client = to_i2c_client(dev);
541 struct elan_tp_data *data = i2c_get_clientdata(client);
542 int error;
543 enum tp_mode mode;
544
545 error = mutex_lock_interruptible(&data->sysfs_mutex);
546 if (error)
547 return error;
548
549 error = data->ops->iap_get_mode(data->client, &mode);
550
551 mutex_unlock(&data->sysfs_mutex);
552
553 if (error)
554 return error;
555
556 return sprintf(buf, "%d\n", (int)mode);
557}
558
559static DEVICE_ATTR(product_id, S_IRUGO, elan_sysfs_read_product_id, NULL);
560static DEVICE_ATTR(firmware_version, S_IRUGO, elan_sysfs_read_fw_ver, NULL);
561static DEVICE_ATTR(sample_version, S_IRUGO, elan_sysfs_read_sm_ver, NULL);
562static DEVICE_ATTR(iap_version, S_IRUGO, elan_sysfs_read_iap_ver, NULL);
563static DEVICE_ATTR(fw_checksum, S_IRUGO, elan_sysfs_read_fw_checksum, NULL);
564static DEVICE_ATTR(mode, S_IRUGO, elan_sysfs_read_mode, NULL);
565static DEVICE_ATTR(update_fw, S_IWUSR, NULL, elan_sysfs_update_fw);
566
567static DEVICE_ATTR_WO(calibrate);
568
569static struct attribute *elan_sysfs_entries[] = {
570 &dev_attr_product_id.attr,
571 &dev_attr_firmware_version.attr,
572 &dev_attr_sample_version.attr,
573 &dev_attr_iap_version.attr,
574 &dev_attr_fw_checksum.attr,
575 &dev_attr_calibrate.attr,
576 &dev_attr_mode.attr,
577 &dev_attr_update_fw.attr,
578 NULL,
579};
580
581static const struct attribute_group elan_sysfs_group = {
582 .attrs = elan_sysfs_entries,
583};
584
585static ssize_t acquire_store(struct device *dev, struct device_attribute *attr,
586 const char *buf, size_t count)
587{
588 struct i2c_client *client = to_i2c_client(dev);
589 struct elan_tp_data *data = i2c_get_clientdata(client);
590 int error;
591 int retval;
592
593 retval = mutex_lock_interruptible(&data->sysfs_mutex);
594 if (retval)
595 return retval;
596
597 disable_irq(client->irq);
598
599 data->baseline_ready = false;
600
601 data->mode |= ETP_ENABLE_CALIBRATE;
602 retval = data->ops->set_mode(data->client, data->mode);
603 if (retval) {
604 dev_err(dev, "Failed to enable calibration mode to get baseline: %d\n",
605 retval);
606 goto out;
607 }
608
609 msleep(250);
610
611 retval = data->ops->get_baseline_data(data->client, true,
612 &data->max_baseline);
613 if (retval) {
614 dev_err(dev, "Failed to read max baseline form device: %d\n",
615 retval);
616 goto out_disable_calibrate;
617 }
618
619 retval = data->ops->get_baseline_data(data->client, false,
620 &data->min_baseline);
621 if (retval) {
622 dev_err(dev, "Failed to read min baseline form device: %d\n",
623 retval);
624 goto out_disable_calibrate;
625 }
626
627 data->baseline_ready = true;
628
629out_disable_calibrate:
630 data->mode &= ~ETP_ENABLE_CALIBRATE;
631 error = data->ops->set_mode(data->client, data->mode);
632 if (error) {
633 dev_err(dev, "Failed to disable calibration mode after acquiring baseline: %d\n",
634 error);
635 if (!retval)
636 retval = error;
637 }
638out:
639 enable_irq(client->irq);
640 mutex_unlock(&data->sysfs_mutex);
641 return retval ?: count;
642}
643
644static ssize_t min_show(struct device *dev,
645 struct device_attribute *attr, char *buf)
646{
647 struct i2c_client *client = to_i2c_client(dev);
648 struct elan_tp_data *data = i2c_get_clientdata(client);
649 int retval;
650
651 retval = mutex_lock_interruptible(&data->sysfs_mutex);
652 if (retval)
653 return retval;
654
655 if (!data->baseline_ready) {
656 retval = -ENODATA;
657 goto out;
658 }
659
660 retval = snprintf(buf, PAGE_SIZE, "%d", data->min_baseline);
661
662out:
663 mutex_unlock(&data->sysfs_mutex);
664 return retval;
665}
666
667static ssize_t max_show(struct device *dev,
668 struct device_attribute *attr, char *buf)
669{
670 struct i2c_client *client = to_i2c_client(dev);
671 struct elan_tp_data *data = i2c_get_clientdata(client);
672 int retval;
673
674 retval = mutex_lock_interruptible(&data->sysfs_mutex);
675 if (retval)
676 return retval;
677
678 if (!data->baseline_ready) {
679 retval = -ENODATA;
680 goto out;
681 }
682
683 retval = snprintf(buf, PAGE_SIZE, "%d", data->max_baseline);
684
685out:
686 mutex_unlock(&data->sysfs_mutex);
687 return retval;
688}
689
690
691static DEVICE_ATTR_WO(acquire);
692static DEVICE_ATTR_RO(min);
693static DEVICE_ATTR_RO(max);
694
695static struct attribute *elan_baseline_sysfs_entries[] = {
696 &dev_attr_acquire.attr,
697 &dev_attr_min.attr,
698 &dev_attr_max.attr,
699 NULL,
700};
701
702static const struct attribute_group elan_baseline_sysfs_group = {
703 .name = "baseline",
704 .attrs = elan_baseline_sysfs_entries,
705};
706
707static const struct attribute_group *elan_sysfs_groups[] = {
708 &elan_sysfs_group,
709 &elan_baseline_sysfs_group,
710 NULL
711};
712
713/*
714 ******************************************************************
715 * Elan isr functions
716 ******************************************************************
717 */
718static void elan_report_contact(struct elan_tp_data *data,
719 int contact_num, bool contact_valid,
720 u8 *finger_data)
721{
722 struct input_dev *input = data->input;
723 unsigned int pos_x, pos_y;
724 unsigned int pressure, mk_x, mk_y;
725 unsigned int area_x, area_y, major, minor, new_pressure;
726
727
728 if (contact_valid) {
729 pos_x = ((finger_data[0] & 0xf0) << 4) |
730 finger_data[1];
731 pos_y = ((finger_data[0] & 0x0f) << 8) |
732 finger_data[2];
733 mk_x = (finger_data[3] & 0x0f);
734 mk_y = (finger_data[3] >> 4);
735 pressure = finger_data[4];
736
737 if (pos_x > data->max_x || pos_y > data->max_y) {
738 dev_dbg(input->dev.parent,
739 "[%d] x=%d y=%d over max (%d, %d)",
740 contact_num, pos_x, pos_y,
741 data->max_x, data->max_y);
742 return;
743 }
744
745 /*
746 * To avoid treating large finger as palm, let's reduce the
747 * width x and y per trace.
748 */
749 area_x = mk_x * (data->width_x - ETP_FWIDTH_REDUCE);
750 area_y = mk_y * (data->width_y - ETP_FWIDTH_REDUCE);
751
752 major = max(area_x, area_y);
753 minor = min(area_x, area_y);
754
755 new_pressure = pressure + ETP_PRESSURE_OFFSET;
756 if (new_pressure > ETP_MAX_PRESSURE)
757 new_pressure = ETP_MAX_PRESSURE;
758
759 input_mt_slot(input, contact_num);
760 input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
761 input_report_abs(input, ABS_MT_POSITION_X, pos_x);
762 input_report_abs(input, ABS_MT_POSITION_Y, data->max_y - pos_y);
763 input_report_abs(input, ABS_MT_PRESSURE, new_pressure);
764 input_report_abs(input, ABS_TOOL_WIDTH, mk_x);
765 input_report_abs(input, ABS_MT_TOUCH_MAJOR, major);
766 input_report_abs(input, ABS_MT_TOUCH_MINOR, minor);
767 } else {
768 input_mt_slot(input, contact_num);
769 input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
770 }
771}
772
773static void elan_report_absolute(struct elan_tp_data *data, u8 *packet)
774{
775 struct input_dev *input = data->input;
776 u8 *finger_data = &packet[ETP_FINGER_DATA_OFFSET];
777 int i;
778 u8 tp_info = packet[ETP_TOUCH_INFO_OFFSET];
779 bool contact_valid;
780
781 for (i = 0; i < ETP_MAX_FINGERS; i++) {
782 contact_valid = tp_info & (1U << (3 + i));
783 elan_report_contact(data, i, contact_valid, finger_data);
784
785 if (contact_valid)
786 finger_data += ETP_FINGER_DATA_LEN;
787 }
788
789 input_report_key(input, BTN_LEFT, tp_info & 0x01);
790 input_mt_report_pointer_emulation(input, true);
791 input_sync(input);
792}
793
794static irqreturn_t elan_isr(int irq, void *dev_id)
795{
796 struct elan_tp_data *data = dev_id;
797 struct device *dev = &data->client->dev;
798 int error;
799 u8 report[ETP_MAX_REPORT_LEN];
800
801 /*
802 * When device is connected to i2c bus, when all IAP page writes
803 * complete, the driver will receive interrupt and must read
804 * 0000 to confirm that IAP is finished.
805 */
806 if (data->in_fw_update) {
807 complete(&data->fw_completion);
808 goto out;
809 }
810
811 error = data->ops->get_report(data->client, report);
812 if (error)
813 goto out;
814
815 if (report[ETP_REPORT_ID_OFFSET] != ETP_REPORT_ID)
816 dev_err(dev, "invalid report id data (%x)\n",
817 report[ETP_REPORT_ID_OFFSET]);
818 else
819 elan_report_absolute(data, report);
820
821out:
822 return IRQ_HANDLED;
823}
824
825/*
826 ******************************************************************
827 * Elan initialization functions
828 ******************************************************************
829 */
830static int elan_setup_input_device(struct elan_tp_data *data)
831{
832 struct device *dev = &data->client->dev;
833 struct input_dev *input;
834 unsigned int max_width = max(data->width_x, data->width_y);
835 unsigned int min_width = min(data->width_x, data->width_y);
836 int error;
837
838 input = devm_input_allocate_device(dev);
839 if (!input)
840 return -ENOMEM;
841
842 input->name = "Elan Touchpad";
843 input->id.bustype = BUS_I2C;
844 input_set_drvdata(input, data);
845
846 error = input_mt_init_slots(input, ETP_MAX_FINGERS,
847 INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED);
848 if (error) {
849 dev_err(dev, "failed to initialize MT slots: %d\n", error);
850 return error;
851 }
852
853 __set_bit(EV_ABS, input->evbit);
854 __set_bit(INPUT_PROP_POINTER, input->propbit);
855 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
856 __set_bit(BTN_LEFT, input->keybit);
857
858 /* Set up ST parameters */
859 input_set_abs_params(input, ABS_X, 0, data->max_x, 0, 0);
860 input_set_abs_params(input, ABS_Y, 0, data->max_y, 0, 0);
861 input_abs_set_res(input, ABS_X, data->x_res);
862 input_abs_set_res(input, ABS_Y, data->y_res);
863 input_set_abs_params(input, ABS_PRESSURE, 0, ETP_MAX_PRESSURE, 0, 0);
864 input_set_abs_params(input, ABS_TOOL_WIDTH, 0, ETP_FINGER_WIDTH, 0, 0);
865
866 /* And MT parameters */
867 input_set_abs_params(input, ABS_MT_POSITION_X, 0, data->max_x, 0, 0);
868 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, data->max_y, 0, 0);
869 input_abs_set_res(input, ABS_MT_POSITION_X, data->x_res);
870 input_abs_set_res(input, ABS_MT_POSITION_Y, data->y_res);
871 input_set_abs_params(input, ABS_MT_PRESSURE, 0,
872 ETP_MAX_PRESSURE, 0, 0);
873 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0,
874 ETP_FINGER_WIDTH * max_width, 0, 0);
875 input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0,
876 ETP_FINGER_WIDTH * min_width, 0, 0);
877
878 data->input = input;
879
880 return 0;
881}
882
883static void elan_disable_regulator(void *_data)
884{
885 struct elan_tp_data *data = _data;
886
887 regulator_disable(data->vcc);
888}
889
890static void elan_remove_sysfs_groups(void *_data)
891{
892 struct elan_tp_data *data = _data;
893
894 sysfs_remove_groups(&data->client->dev.kobj, elan_sysfs_groups);
895}
896
897static int elan_probe(struct i2c_client *client,
898 const struct i2c_device_id *dev_id)
899{
900 const struct elan_transport_ops *transport_ops;
901 struct device *dev = &client->dev;
902 struct elan_tp_data *data;
903 unsigned long irqflags;
904 int error;
905
906 if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_I2C) &&
907 i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
908 transport_ops = &elan_i2c_ops;
909 } else if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_SMBUS) &&
910 i2c_check_functionality(client->adapter,
911 I2C_FUNC_SMBUS_BYTE_DATA |
912 I2C_FUNC_SMBUS_BLOCK_DATA |
913 I2C_FUNC_SMBUS_I2C_BLOCK)) {
914 transport_ops = &elan_smbus_ops;
915 } else {
916 dev_err(dev, "not a supported I2C/SMBus adapter\n");
917 return -EIO;
918 }
919
920 data = devm_kzalloc(&client->dev, sizeof(struct elan_tp_data),
921 GFP_KERNEL);
922 if (!data)
923 return -ENOMEM;
924
925 i2c_set_clientdata(client, data);
926
927 data->ops = transport_ops;
928 data->client = client;
929 init_completion(&data->fw_completion);
930 mutex_init(&data->sysfs_mutex);
931
932 data->vcc = devm_regulator_get(&client->dev, "vcc");
933 if (IS_ERR(data->vcc)) {
934 error = PTR_ERR(data->vcc);
935 if (error != -EPROBE_DEFER)
936 dev_err(&client->dev,
937 "Failed to get 'vcc' regulator: %d\n",
938 error);
939 return error;
940 }
941
942 error = regulator_enable(data->vcc);
943 if (error) {
944 dev_err(&client->dev,
945 "Failed to enable regulator: %d\n", error);
946 return error;
947 }
948
949 error = devm_add_action(&client->dev,
950 elan_disable_regulator, data);
951 if (error) {
952 regulator_disable(data->vcc);
953 dev_err(&client->dev,
954 "Failed to add disable regulator action: %d\n",
955 error);
956 return error;
957 }
958
959 /* Initialize the touchpad. */
960 error = elan_initialize(data);
961 if (error)
962 return error;
963
964 error = elan_query_device_info(data);
965 if (error)
966 return error;
967
968 error = elan_query_device_parameters(data);
969 if (error)
970 return error;
971
972 dev_dbg(&client->dev,
973 "Elan Touchpad Information:\n"
974 " Module product ID: 0x%04x\n"
975 " Firmware Version: 0x%04x\n"
976 " Sample Version: 0x%04x\n"
977 " IAP Version: 0x%04x\n"
978 " Max ABS X,Y: %d,%d\n"
979 " Width X,Y: %d,%d\n"
980 " Resolution X,Y: %d,%d (dots/mm)\n",
981 data->product_id,
982 data->fw_version,
983 data->sm_version,
984 data->iap_version,
985 data->max_x, data->max_y,
986 data->width_x, data->width_y,
987 data->x_res, data->y_res);
988
989 /* Set up input device properties based on queried parameters. */
990 error = elan_setup_input_device(data);
991 if (error)
992 return error;
993
994 /*
995 * Systems using device tree should set up interrupt via DTS,
996 * the rest will use the default falling edge interrupts.
997 */
998 irqflags = client->dev.of_node ? 0 : IRQF_TRIGGER_FALLING;
999
1000 error = devm_request_threaded_irq(&client->dev, client->irq,
1001 NULL, elan_isr,
1002 irqflags | IRQF_ONESHOT,
1003 client->name, data);
1004 if (error) {
1005 dev_err(&client->dev, "cannot register irq=%d\n", client->irq);
1006 return error;
1007 }
1008
1009 error = sysfs_create_groups(&client->dev.kobj, elan_sysfs_groups);
1010 if (error) {
1011 dev_err(&client->dev, "failed to create sysfs attributes: %d\n",
1012 error);
1013 return error;
1014 }
1015
1016 error = devm_add_action(&client->dev,
1017 elan_remove_sysfs_groups, data);
1018 if (error) {
1019 elan_remove_sysfs_groups(data);
1020 dev_err(&client->dev,
1021 "Failed to add sysfs cleanup action: %d\n",
1022 error);
1023 return error;
1024 }
1025
1026 error = input_register_device(data->input);
1027 if (error) {
1028 dev_err(&client->dev, "failed to register input device: %d\n",
1029 error);
1030 return error;
1031 }
1032
1033 /*
1034 * Systems using device tree should set up wakeup via DTS,
1035 * the rest will configure device as wakeup source by default.
1036 */
1037 if (!client->dev.of_node)
1038 device_init_wakeup(&client->dev, true);
1039
1040 return 0;
1041}
1042
1043static int __maybe_unused elan_suspend(struct device *dev)
1044{
1045 struct i2c_client *client = to_i2c_client(dev);
1046 struct elan_tp_data *data = i2c_get_clientdata(client);
1047 int ret;
1048
1049 /*
1050 * We are taking the mutex to make sure sysfs operations are
1051 * complete before we attempt to bring the device into low[er]
1052 * power mode.
1053 */
1054 ret = mutex_lock_interruptible(&data->sysfs_mutex);
1055 if (ret)
1056 return ret;
1057
1058 disable_irq(client->irq);
1059
1060 if (device_may_wakeup(dev)) {
1061 ret = elan_sleep(data);
1062 /* Enable wake from IRQ */
1063 data->irq_wake = (enable_irq_wake(client->irq) == 0);
1064 } else {
1065 ret = elan_disable_power(data);
1066 }
1067
1068 mutex_unlock(&data->sysfs_mutex);
1069 return ret;
1070}
1071
1072static int __maybe_unused elan_resume(struct device *dev)
1073{
1074 struct i2c_client *client = to_i2c_client(dev);
1075 struct elan_tp_data *data = i2c_get_clientdata(client);
1076 int error;
1077
1078 if (device_may_wakeup(dev) && data->irq_wake) {
1079 disable_irq_wake(client->irq);
1080 data->irq_wake = false;
1081 }
1082
1083 error = elan_enable_power(data);
1084 if (error)
1085 dev_err(dev, "power up when resuming failed: %d\n", error);
1086
1087 error = elan_initialize(data);
1088 if (error)
1089 dev_err(dev, "initialize when resuming failed: %d\n", error);
1090
1091 enable_irq(data->client->irq);
1092
1093 return 0;
1094}
1095
1096static SIMPLE_DEV_PM_OPS(elan_pm_ops, elan_suspend, elan_resume);
1097
1098static const struct i2c_device_id elan_id[] = {
1099 { DRIVER_NAME, 0 },
1100 { },
1101};
1102MODULE_DEVICE_TABLE(i2c, elan_id);
1103
1104#ifdef CONFIG_ACPI
1105static const struct acpi_device_id elan_acpi_id[] = {
1106 { "ELAN0000", 0 },
1107 { }
1108};
1109MODULE_DEVICE_TABLE(acpi, elan_acpi_id);
1110#endif
1111
1112#ifdef CONFIG_OF
1113static const struct of_device_id elan_of_match[] = {
1114 { .compatible = "elan,ekth3000" },
1115 { /* sentinel */ }
1116};
1117MODULE_DEVICE_TABLE(of, elan_of_match);
1118#endif
1119
1120static struct i2c_driver elan_driver = {
1121 .driver = {
1122 .name = DRIVER_NAME,
1123 .owner = THIS_MODULE,
1124 .pm = &elan_pm_ops,
1125 .acpi_match_table = ACPI_PTR(elan_acpi_id),
1126 .of_match_table = of_match_ptr(elan_of_match),
1127 },
1128 .probe = elan_probe,
1129 .id_table = elan_id,
1130};
1131
1132module_i2c_driver(elan_driver);
1133
1134MODULE_AUTHOR("Duson Lin <dusonlin@emc.com.tw>");
1135MODULE_DESCRIPTION("Elan I2C/SMBus Touchpad driver");
1136MODULE_LICENSE("GPL");
1137MODULE_VERSION(ELAN_DRIVER_VERSION);
diff --git a/drivers/input/mouse/elan_i2c_i2c.c b/drivers/input/mouse/elan_i2c_i2c.c
new file mode 100644
index 000000000000..97d4937fc244
--- /dev/null
+++ b/drivers/input/mouse/elan_i2c_i2c.c
@@ -0,0 +1,611 @@
1/*
2 * Elan I2C/SMBus Touchpad driver - I2C interface
3 *
4 * Copyright (c) 2013 ELAN Microelectronics Corp.
5 *
6 * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw>
7 * Version: 1.5.5
8 *
9 * Based on cyapa driver:
10 * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
11 * copyright (c) 2011-2012 Google, Inc.
12 *
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.
16 *
17 * Trademarks are the property of their respective owners.
18 */
19
20#include <linux/completion.h>
21#include <linux/delay.h>
22#include <linux/i2c.h>
23#include <linux/interrupt.h>
24#include <linux/jiffies.h>
25#include <linux/kernel.h>
26#include <linux/sched.h>
27#include <asm/unaligned.h>
28
29#include "elan_i2c.h"
30
31/* Elan i2c commands */
32#define ETP_I2C_RESET 0x0100
33#define ETP_I2C_WAKE_UP 0x0800
34#define ETP_I2C_SLEEP 0x0801
35#define ETP_I2C_DESC_CMD 0x0001
36#define ETP_I2C_REPORT_DESC_CMD 0x0002
37#define ETP_I2C_STAND_CMD 0x0005
38#define ETP_I2C_UNIQUEID_CMD 0x0101
39#define ETP_I2C_FW_VERSION_CMD 0x0102
40#define ETP_I2C_SM_VERSION_CMD 0x0103
41#define ETP_I2C_XY_TRACENUM_CMD 0x0105
42#define ETP_I2C_MAX_X_AXIS_CMD 0x0106
43#define ETP_I2C_MAX_Y_AXIS_CMD 0x0107
44#define ETP_I2C_RESOLUTION_CMD 0x0108
45#define ETP_I2C_IAP_VERSION_CMD 0x0110
46#define ETP_I2C_SET_CMD 0x0300
47#define ETP_I2C_POWER_CMD 0x0307
48#define ETP_I2C_FW_CHECKSUM_CMD 0x030F
49#define ETP_I2C_IAP_CTRL_CMD 0x0310
50#define ETP_I2C_IAP_CMD 0x0311
51#define ETP_I2C_IAP_RESET_CMD 0x0314
52#define ETP_I2C_IAP_CHECKSUM_CMD 0x0315
53#define ETP_I2C_CALIBRATE_CMD 0x0316
54#define ETP_I2C_MAX_BASELINE_CMD 0x0317
55#define ETP_I2C_MIN_BASELINE_CMD 0x0318
56
57#define ETP_I2C_REPORT_LEN 34
58#define ETP_I2C_DESC_LENGTH 30
59#define ETP_I2C_REPORT_DESC_LENGTH 158
60#define ETP_I2C_INF_LENGTH 2
61#define ETP_I2C_IAP_PASSWORD 0x1EA5
62#define ETP_I2C_IAP_RESET 0xF0F0
63#define ETP_I2C_MAIN_MODE_ON (1 << 9)
64#define ETP_I2C_IAP_REG_L 0x01
65#define ETP_I2C_IAP_REG_H 0x06
66
67static int elan_i2c_read_block(struct i2c_client *client,
68 u16 reg, u8 *val, u16 len)
69{
70 __le16 buf[] = {
71 cpu_to_le16(reg),
72 };
73 struct i2c_msg msgs[] = {
74 {
75 .addr = client->addr,
76 .flags = client->flags & I2C_M_TEN,
77 .len = sizeof(buf),
78 .buf = (u8 *)buf,
79 },
80 {
81 .addr = client->addr,
82 .flags = (client->flags & I2C_M_TEN) | I2C_M_RD,
83 .len = len,
84 .buf = val,
85 }
86 };
87 int ret;
88
89 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
90 return ret == ARRAY_SIZE(msgs) ? 0 : (ret < 0 ? ret : -EIO);
91}
92
93static int elan_i2c_read_cmd(struct i2c_client *client, u16 reg, u8 *val)
94{
95 int retval;
96
97 retval = elan_i2c_read_block(client, reg, val, ETP_I2C_INF_LENGTH);
98 if (retval < 0) {
99 dev_err(&client->dev, "reading cmd (0x%04x) fail.\n", reg);
100 return retval;
101 }
102
103 return 0;
104}
105
106static int elan_i2c_write_cmd(struct i2c_client *client, u16 reg, u16 cmd)
107{
108 __le16 buf[] = {
109 cpu_to_le16(reg),
110 cpu_to_le16(cmd),
111 };
112 struct i2c_msg msg = {
113 .addr = client->addr,
114 .flags = client->flags & I2C_M_TEN,
115 .len = sizeof(buf),
116 .buf = (u8 *)buf,
117 };
118 int ret;
119
120 ret = i2c_transfer(client->adapter, &msg, 1);
121 return ret == 1 ? 0 : (ret < 0 ? ret : -EIO);
122}
123
124static int elan_i2c_initialize(struct i2c_client *client)
125{
126 struct device *dev = &client->dev;
127 int error;
128 u8 val[256];
129
130 error = elan_i2c_write_cmd(client, ETP_I2C_STAND_CMD, ETP_I2C_RESET);
131 if (error) {
132 dev_err(dev, "device reset failed: %d\n", error);
133 return error;
134 }
135
136 /* Wait for the device to reset */
137 msleep(100);
138
139 /* get reset acknowledgement 0000 */
140 error = i2c_master_recv(client, val, ETP_I2C_INF_LENGTH);
141 if (error < 0) {
142 dev_err(dev, "failed to read reset response: %d\n", error);
143 return error;
144 }
145
146 error = elan_i2c_read_block(client, ETP_I2C_DESC_CMD,
147 val, ETP_I2C_DESC_LENGTH);
148 if (error) {
149 dev_err(dev, "cannot get device descriptor: %d\n", error);
150 return error;
151 }
152
153 error = elan_i2c_read_block(client, ETP_I2C_REPORT_DESC_CMD,
154 val, ETP_I2C_REPORT_DESC_LENGTH);
155 if (error) {
156 dev_err(dev, "fetching report descriptor failed.: %d\n", error);
157 return error;
158 }
159
160 return 0;
161}
162
163static int elan_i2c_sleep_control(struct i2c_client *client, bool sleep)
164{
165 return elan_i2c_write_cmd(client, ETP_I2C_STAND_CMD,
166 sleep ? ETP_I2C_SLEEP : ETP_I2C_WAKE_UP);
167}
168
169static int elan_i2c_power_control(struct i2c_client *client, bool enable)
170{
171 u8 val[2];
172 u16 reg;
173 int error;
174
175 error = elan_i2c_read_cmd(client, ETP_I2C_POWER_CMD, val);
176 if (error) {
177 dev_err(&client->dev,
178 "failed to read current power state: %d\n",
179 error);
180 return error;
181 }
182
183 reg = le16_to_cpup((__le16 *)val);
184 if (enable)
185 reg &= ~ETP_DISABLE_POWER;
186 else
187 reg |= ETP_DISABLE_POWER;
188
189 error = elan_i2c_write_cmd(client, ETP_I2C_POWER_CMD, reg);
190 if (error) {
191 dev_err(&client->dev,
192 "failed to write current power state: %d\n",
193 error);
194 return error;
195 }
196
197 return 0;
198}
199
200static int elan_i2c_set_mode(struct i2c_client *client, u8 mode)
201{
202 return elan_i2c_write_cmd(client, ETP_I2C_SET_CMD, mode);
203}
204
205
206static int elan_i2c_calibrate(struct i2c_client *client)
207{
208 return elan_i2c_write_cmd(client, ETP_I2C_CALIBRATE_CMD, 1);
209}
210
211static int elan_i2c_calibrate_result(struct i2c_client *client, u8 *val)
212{
213 return elan_i2c_read_block(client, ETP_I2C_CALIBRATE_CMD, val, 1);
214}
215
216static int elan_i2c_get_baseline_data(struct i2c_client *client,
217 bool max_baseline, u8 *value)
218{
219 int error;
220 u8 val[3];
221
222 error = elan_i2c_read_cmd(client,
223 max_baseline ? ETP_I2C_MAX_BASELINE_CMD :
224 ETP_I2C_MIN_BASELINE_CMD,
225 val);
226 if (error)
227 return error;
228
229 *value = le16_to_cpup((__le16 *)val);
230
231 return 0;
232}
233
234static int elan_i2c_get_version(struct i2c_client *client,
235 bool iap, u8 *version)
236{
237 int error;
238 u8 val[3];
239
240 error = elan_i2c_read_cmd(client,
241 iap ? ETP_I2C_IAP_VERSION_CMD :
242 ETP_I2C_FW_VERSION_CMD,
243 val);
244 if (error) {
245 dev_err(&client->dev, "failed to get %s version: %d\n",
246 iap ? "IAP" : "FW", error);
247 return error;
248 }
249
250 *version = val[0];
251 return 0;
252}
253
254static int elan_i2c_get_sm_version(struct i2c_client *client, u8 *version)
255{
256 int error;
257 u8 val[3];
258
259 error = elan_i2c_read_cmd(client, ETP_I2C_SM_VERSION_CMD, val);
260 if (error) {
261 dev_err(&client->dev, "failed to get SM version: %d\n", error);
262 return error;
263 }
264
265 *version = val[0];
266 return 0;
267}
268
269static int elan_i2c_get_product_id(struct i2c_client *client, u8 *id)
270{
271 int error;
272 u8 val[3];
273
274 error = elan_i2c_read_cmd(client, ETP_I2C_UNIQUEID_CMD, val);
275 if (error) {
276 dev_err(&client->dev, "failed to get product ID: %d\n", error);
277 return error;
278 }
279
280 *id = val[0];
281 return 0;
282}
283
284static int elan_i2c_get_checksum(struct i2c_client *client,
285 bool iap, u16 *csum)
286{
287 int error;
288 u8 val[3];
289
290 error = elan_i2c_read_cmd(client,
291 iap ? ETP_I2C_IAP_CHECKSUM_CMD :
292 ETP_I2C_FW_CHECKSUM_CMD,
293 val);
294 if (error) {
295 dev_err(&client->dev, "failed to get %s checksum: %d\n",
296 iap ? "IAP" : "FW", error);
297 return error;
298 }
299
300 *csum = le16_to_cpup((__le16 *)val);
301 return 0;
302}
303
304static int elan_i2c_get_max(struct i2c_client *client,
305 unsigned int *max_x, unsigned int *max_y)
306{
307 int error;
308 u8 val[3];
309
310 error = elan_i2c_read_cmd(client, ETP_I2C_MAX_X_AXIS_CMD, val);
311 if (error) {
312 dev_err(&client->dev, "failed to get X dimension: %d\n", error);
313 return error;
314 }
315
316 *max_x = le16_to_cpup((__le16 *)val) & 0x0fff;
317
318 error = elan_i2c_read_cmd(client, ETP_I2C_MAX_Y_AXIS_CMD, val);
319 if (error) {
320 dev_err(&client->dev, "failed to get Y dimension: %d\n", error);
321 return error;
322 }
323
324 *max_y = le16_to_cpup((__le16 *)val) & 0x0fff;
325
326 return 0;
327}
328
329static int elan_i2c_get_resolution(struct i2c_client *client,
330 u8 *hw_res_x, u8 *hw_res_y)
331{
332 int error;
333 u8 val[3];
334
335 error = elan_i2c_read_cmd(client, ETP_I2C_RESOLUTION_CMD, val);
336 if (error) {
337 dev_err(&client->dev, "failed to get resolution: %d\n", error);
338 return error;
339 }
340
341 *hw_res_x = val[0];
342 *hw_res_y = val[1];
343
344 return 0;
345}
346
347static int elan_i2c_get_num_traces(struct i2c_client *client,
348 unsigned int *x_traces,
349 unsigned int *y_traces)
350{
351 int error;
352 u8 val[3];
353
354 error = elan_i2c_read_cmd(client, ETP_I2C_XY_TRACENUM_CMD, val);
355 if (error) {
356 dev_err(&client->dev, "failed to get trace info: %d\n", error);
357 return error;
358 }
359
360 *x_traces = val[0] - 1;
361 *y_traces = val[1] - 1;
362
363 return 0;
364}
365
366static int elan_i2c_iap_get_mode(struct i2c_client *client, enum tp_mode *mode)
367{
368 int error;
369 u16 constant;
370 u8 val[3];
371
372 error = elan_i2c_read_cmd(client, ETP_I2C_IAP_CTRL_CMD, val);
373 if (error) {
374 dev_err(&client->dev,
375 "failed to read iap control register: %d\n",
376 error);
377 return error;
378 }
379
380 constant = le16_to_cpup((__le16 *)val);
381 dev_dbg(&client->dev, "iap control reg: 0x%04x.\n", constant);
382
383 *mode = (constant & ETP_I2C_MAIN_MODE_ON) ? MAIN_MODE : IAP_MODE;
384
385 return 0;
386}
387
388static int elan_i2c_iap_reset(struct i2c_client *client)
389{
390 int error;
391
392 error = elan_i2c_write_cmd(client, ETP_I2C_IAP_RESET_CMD,
393 ETP_I2C_IAP_RESET);
394 if (error) {
395 dev_err(&client->dev, "cannot reset IC: %d\n", error);
396 return error;
397 }
398
399 return 0;
400}
401
402static int elan_i2c_set_flash_key(struct i2c_client *client)
403{
404 int error;
405
406 error = elan_i2c_write_cmd(client, ETP_I2C_IAP_CMD,
407 ETP_I2C_IAP_PASSWORD);
408 if (error) {
409 dev_err(&client->dev, "cannot set flash key: %d\n", error);
410 return error;
411 }
412
413 return 0;
414}
415
416static int elan_i2c_prepare_fw_update(struct i2c_client *client)
417{
418 struct device *dev = &client->dev;
419 int error;
420 enum tp_mode mode;
421 u8 val[3];
422 u16 password;
423
424 /* Get FW in which mode (IAP_MODE/MAIN_MODE) */
425 error = elan_i2c_iap_get_mode(client, &mode);
426 if (error)
427 return error;
428
429 if (mode == IAP_MODE) {
430 /* Reset IC */
431 error = elan_i2c_iap_reset(client);
432 if (error)
433 return error;
434
435 msleep(30);
436 }
437
438 /* Set flash key*/
439 error = elan_i2c_set_flash_key(client);
440 if (error)
441 return error;
442
443 /* Wait for F/W IAP initialization */
444 msleep(mode == MAIN_MODE ? 100 : 30);
445
446 /* Check if we are in IAP mode or not */
447 error = elan_i2c_iap_get_mode(client, &mode);
448 if (error)
449 return error;
450
451 if (mode == MAIN_MODE) {
452 dev_err(dev, "wrong mode: %d\n", mode);
453 return -EIO;
454 }
455
456 /* Set flash key again */
457 error = elan_i2c_set_flash_key(client);
458 if (error)
459 return error;
460
461 /* Wait for F/W IAP initialization */
462 msleep(30);
463
464 /* read back to check we actually enabled successfully. */
465 error = elan_i2c_read_cmd(client, ETP_I2C_IAP_CMD, val);
466 if (error) {
467 dev_err(dev, "cannot read iap password: %d\n",
468 error);
469 return error;
470 }
471
472 password = le16_to_cpup((__le16 *)val);
473 if (password != ETP_I2C_IAP_PASSWORD) {
474 dev_err(dev, "wrong iap password: 0x%X\n", password);
475 return -EIO;
476 }
477
478 return 0;
479}
480
481static int elan_i2c_write_fw_block(struct i2c_client *client,
482 const u8 *page, u16 checksum, int idx)
483{
484 struct device *dev = &client->dev;
485 u8 page_store[ETP_FW_PAGE_SIZE + 4];
486 u8 val[3];
487 u16 result;
488 int ret, error;
489
490 page_store[0] = ETP_I2C_IAP_REG_L;
491 page_store[1] = ETP_I2C_IAP_REG_H;
492 memcpy(&page_store[2], page, ETP_FW_PAGE_SIZE);
493 /* recode checksum at last two bytes */
494 put_unaligned_le16(checksum, &page_store[ETP_FW_PAGE_SIZE + 2]);
495
496 ret = i2c_master_send(client, page_store, sizeof(page_store));
497 if (ret != sizeof(page_store)) {
498 error = ret < 0 ? ret : -EIO;
499 dev_err(dev, "Failed to write page %d: %d\n", idx, error);
500 return error;
501 }
502
503 /* Wait for F/W to update one page ROM data. */
504 msleep(20);
505
506 error = elan_i2c_read_cmd(client, ETP_I2C_IAP_CTRL_CMD, val);
507 if (error) {
508 dev_err(dev, "Failed to read IAP write result: %d\n", error);
509 return error;
510 }
511
512 result = le16_to_cpup((__le16 *)val);
513 if (result & (ETP_FW_IAP_PAGE_ERR | ETP_FW_IAP_INTF_ERR)) {
514 dev_err(dev, "IAP reports failed write: %04hx\n",
515 result);
516 return -EIO;
517 }
518
519 return 0;
520}
521
522static int elan_i2c_finish_fw_update(struct i2c_client *client,
523 struct completion *completion)
524{
525 struct device *dev = &client->dev;
526 long ret;
527 int error;
528 int len;
529 u8 buffer[ETP_I2C_INF_LENGTH];
530
531 reinit_completion(completion);
532 enable_irq(client->irq);
533
534 error = elan_i2c_write_cmd(client, ETP_I2C_STAND_CMD, ETP_I2C_RESET);
535 if (!error)
536 ret = wait_for_completion_interruptible_timeout(completion,
537 msecs_to_jiffies(300));
538 disable_irq(client->irq);
539
540 if (error) {
541 dev_err(dev, "device reset failed: %d\n", error);
542 return error;
543 } else if (ret == 0) {
544 dev_err(dev, "timeout waiting for device reset\n");
545 return -ETIMEDOUT;
546 } else if (ret < 0) {
547 error = ret;
548 dev_err(dev, "error waiting for device reset: %d\n", error);
549 return error;
550 }
551
552 len = i2c_master_recv(client, buffer, ETP_I2C_INF_LENGTH);
553 if (len != ETP_I2C_INF_LENGTH) {
554 error = len < 0 ? len : -EIO;
555 dev_err(dev, "failed to read INT signal: %d (%d)\n",
556 error, len);
557 return error;
558 }
559
560 return 0;
561}
562
563static int elan_i2c_get_report(struct i2c_client *client, u8 *report)
564{
565 int len;
566
567 len = i2c_master_recv(client, report, ETP_I2C_REPORT_LEN);
568 if (len < 0) {
569 dev_err(&client->dev, "failed to read report data: %d\n", len);
570 return len;
571 }
572
573 if (len != ETP_I2C_REPORT_LEN) {
574 dev_err(&client->dev,
575 "wrong report length (%d vs %d expected)\n",
576 len, ETP_I2C_REPORT_LEN);
577 return -EIO;
578 }
579
580 return 0;
581}
582
583const struct elan_transport_ops elan_i2c_ops = {
584 .initialize = elan_i2c_initialize,
585 .sleep_control = elan_i2c_sleep_control,
586 .power_control = elan_i2c_power_control,
587 .set_mode = elan_i2c_set_mode,
588
589 .calibrate = elan_i2c_calibrate,
590 .calibrate_result = elan_i2c_calibrate_result,
591
592 .get_baseline_data = elan_i2c_get_baseline_data,
593
594 .get_version = elan_i2c_get_version,
595 .get_sm_version = elan_i2c_get_sm_version,
596 .get_product_id = elan_i2c_get_product_id,
597 .get_checksum = elan_i2c_get_checksum,
598
599 .get_max = elan_i2c_get_max,
600 .get_resolution = elan_i2c_get_resolution,
601 .get_num_traces = elan_i2c_get_num_traces,
602
603 .iap_get_mode = elan_i2c_iap_get_mode,
604 .iap_reset = elan_i2c_iap_reset,
605
606 .prepare_fw_update = elan_i2c_prepare_fw_update,
607 .write_fw_block = elan_i2c_write_fw_block,
608 .finish_fw_update = elan_i2c_finish_fw_update,
609
610 .get_report = elan_i2c_get_report,
611};
diff --git a/drivers/input/mouse/elan_i2c_smbus.c b/drivers/input/mouse/elan_i2c_smbus.c
new file mode 100644
index 000000000000..359bf8583d54
--- /dev/null
+++ b/drivers/input/mouse/elan_i2c_smbus.c
@@ -0,0 +1,514 @@
1/*
2 * Elan I2C/SMBus Touchpad driver - SMBus interface
3 *
4 * Copyright (c) 2013 ELAN Microelectronics Corp.
5 *
6 * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw>
7 * Version: 1.5.5
8 *
9 * Based on cyapa driver:
10 * copyright (c) 2011-2012 Cypress Semiconductor, Inc.
11 * copyright (c) 2011-2012 Google, Inc.
12 *
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.
16 *
17 * Trademarks are the property of their respective owners.
18 */
19
20#include <linux/delay.h>
21#include <linux/i2c.h>
22#include <linux/init.h>
23#include <linux/kernel.h>
24
25#include "elan_i2c.h"
26
27/* Elan SMbus commands */
28#define ETP_SMBUS_IAP_CMD 0x00
29#define ETP_SMBUS_ENABLE_TP 0x20
30#define ETP_SMBUS_SLEEP_CMD 0x21
31#define ETP_SMBUS_IAP_PASSWORD_WRITE 0x29
32#define ETP_SMBUS_IAP_PASSWORD_READ 0x80
33#define ETP_SMBUS_WRITE_FW_BLOCK 0x2A
34#define ETP_SMBUS_IAP_RESET_CMD 0x2B
35#define ETP_SMBUS_RANGE_CMD 0xA0
36#define ETP_SMBUS_FW_VERSION_CMD 0xA1
37#define ETP_SMBUS_XY_TRACENUM_CMD 0xA2
38#define ETP_SMBUS_SM_VERSION_CMD 0xA3
39#define ETP_SMBUS_UNIQUEID_CMD 0xA3
40#define ETP_SMBUS_RESOLUTION_CMD 0xA4
41#define ETP_SMBUS_HELLOPACKET_CMD 0xA7
42#define ETP_SMBUS_PACKET_QUERY 0xA8
43#define ETP_SMBUS_IAP_VERSION_CMD 0xAC
44#define ETP_SMBUS_IAP_CTRL_CMD 0xAD
45#define ETP_SMBUS_IAP_CHECKSUM_CMD 0xAE
46#define ETP_SMBUS_FW_CHECKSUM_CMD 0xAF
47#define ETP_SMBUS_MAX_BASELINE_CMD 0xC3
48#define ETP_SMBUS_MIN_BASELINE_CMD 0xC4
49#define ETP_SMBUS_CALIBRATE_QUERY 0xC5
50
51#define ETP_SMBUS_REPORT_LEN 32
52#define ETP_SMBUS_REPORT_OFFSET 2
53#define ETP_SMBUS_HELLOPACKET_LEN 5
54#define ETP_SMBUS_IAP_PASSWORD 0x1234
55#define ETP_SMBUS_IAP_MODE_ON (1 << 6)
56
57static int elan_smbus_initialize(struct i2c_client *client)
58{
59 u8 check[ETP_SMBUS_HELLOPACKET_LEN] = { 0x55, 0x55, 0x55, 0x55, 0x55 };
60 u8 values[ETP_SMBUS_HELLOPACKET_LEN] = { 0, 0, 0, 0, 0 };
61 int len, error;
62
63 /* Get hello packet */
64 len = i2c_smbus_read_block_data(client,
65 ETP_SMBUS_HELLOPACKET_CMD, values);
66 if (len != ETP_SMBUS_HELLOPACKET_LEN) {
67 dev_err(&client->dev, "hello packet length fail: %d\n", len);
68 error = len < 0 ? len : -EIO;
69 return error;
70 }
71
72 /* compare hello packet */
73 if (memcmp(values, check, ETP_SMBUS_HELLOPACKET_LEN)) {
74 dev_err(&client->dev, "hello packet fail [%*px]\n",
75 ETP_SMBUS_HELLOPACKET_LEN, values);
76 return -ENXIO;
77 }
78
79 /* enable tp */
80 error = i2c_smbus_write_byte(client, ETP_SMBUS_ENABLE_TP);
81 if (error) {
82 dev_err(&client->dev, "failed to enable touchpad: %d\n", error);
83 return error;
84 }
85
86 return 0;
87}
88
89static int elan_smbus_set_mode(struct i2c_client *client, u8 mode)
90{
91 u8 cmd[4] = { 0x00, 0x07, 0x00, mode };
92
93 return i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
94 sizeof(cmd), cmd);
95}
96
97static int elan_smbus_sleep_control(struct i2c_client *client, bool sleep)
98{
99 if (sleep)
100 return i2c_smbus_write_byte(client, ETP_SMBUS_SLEEP_CMD);
101 else
102 return 0; /* XXX should we send ETP_SMBUS_ENABLE_TP here? */
103}
104
105static int elan_smbus_power_control(struct i2c_client *client, bool enable)
106{
107 return 0; /* A no-op */
108}
109
110static int elan_smbus_calibrate(struct i2c_client *client)
111{
112 u8 cmd[4] = { 0x00, 0x08, 0x00, 0x01 };
113
114 return i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
115 sizeof(cmd), cmd);
116}
117
118static int elan_smbus_calibrate_result(struct i2c_client *client, u8 *val)
119{
120 int error;
121
122 error = i2c_smbus_read_block_data(client,
123 ETP_SMBUS_CALIBRATE_QUERY, val);
124 if (error < 0)
125 return error;
126
127 return 0;
128}
129
130static int elan_smbus_get_baseline_data(struct i2c_client *client,
131 bool max_baseline, u8 *value)
132{
133 int error;
134 u8 val[3];
135
136 error = i2c_smbus_read_block_data(client,
137 max_baseline ?
138 ETP_SMBUS_MAX_BASELINE_CMD :
139 ETP_SMBUS_MIN_BASELINE_CMD,
140 val);
141 if (error < 0)
142 return error;
143
144 *value = be16_to_cpup((__be16 *)val);
145
146 return 0;
147}
148
149static int elan_smbus_get_version(struct i2c_client *client,
150 bool iap, u8 *version)
151{
152 int error;
153 u8 val[3];
154
155 error = i2c_smbus_read_block_data(client,
156 iap ? ETP_SMBUS_IAP_VERSION_CMD :
157 ETP_SMBUS_FW_VERSION_CMD,
158 val);
159 if (error < 0) {
160 dev_err(&client->dev, "failed to get %s version: %d\n",
161 iap ? "IAP" : "FW", error);
162 return error;
163 }
164
165 *version = val[2];
166 return 0;
167}
168
169static int elan_smbus_get_sm_version(struct i2c_client *client, u8 *version)
170{
171 int error;
172 u8 val[3];
173
174 error = i2c_smbus_read_block_data(client,
175 ETP_SMBUS_SM_VERSION_CMD, val);
176 if (error < 0) {
177 dev_err(&client->dev, "failed to get SM version: %d\n", error);
178 return error;
179 }
180
181 *version = val[0]; /* XXX Why 0 and not 2 as in IAP/FW versions? */
182 return 0;
183}
184
185static int elan_smbus_get_product_id(struct i2c_client *client, u8 *id)
186{
187 int error;
188 u8 val[3];
189
190 error = i2c_smbus_read_block_data(client,
191 ETP_SMBUS_UNIQUEID_CMD, val);
192 if (error < 0) {
193 dev_err(&client->dev, "failed to get product ID: %d\n", error);
194 return error;
195 }
196
197 *id = val[1];
198 return 0;
199}
200
201static int elan_smbus_get_checksum(struct i2c_client *client,
202 bool iap, u16 *csum)
203{
204 int error;
205 u8 val[3];
206
207 error = i2c_smbus_read_block_data(client,
208 iap ? ETP_SMBUS_FW_CHECKSUM_CMD :
209 ETP_SMBUS_IAP_CHECKSUM_CMD,
210 val);
211 if (error < 0) {
212 dev_err(&client->dev, "failed to get %s checksum: %d\n",
213 iap ? "IAP" : "FW", error);
214 return error;
215 }
216
217 *csum = be16_to_cpup((__be16 *)val);
218 return 0;
219}
220
221static int elan_smbus_get_max(struct i2c_client *client,
222 unsigned int *max_x, unsigned int *max_y)
223{
224 int error;
225 u8 val[3];
226
227 error = i2c_smbus_read_block_data(client, ETP_SMBUS_RANGE_CMD, val);
228 if (error) {
229 dev_err(&client->dev, "failed to get dimensions: %d\n", error);
230 return error;
231 }
232
233 *max_x = (0x0f & val[0]) << 8 | val[1];
234 *max_y = (0xf0 & val[0]) << 4 | val[2];
235
236 return 0;
237}
238
239static int elan_smbus_get_resolution(struct i2c_client *client,
240 u8 *hw_res_x, u8 *hw_res_y)
241{
242 int error;
243 u8 val[3];
244
245 error = i2c_smbus_read_block_data(client,
246 ETP_SMBUS_RESOLUTION_CMD, val);
247 if (error) {
248 dev_err(&client->dev, "failed to get resolution: %d\n", error);
249 return error;
250 }
251
252 *hw_res_x = val[1] & 0x0F;
253 *hw_res_y = (val[1] & 0xF0) >> 4;
254
255 return 0;
256}
257
258static int elan_smbus_get_num_traces(struct i2c_client *client,
259 unsigned int *x_traces,
260 unsigned int *y_traces)
261{
262 int error;
263 u8 val[3];
264
265 error = i2c_smbus_read_block_data(client,
266 ETP_SMBUS_XY_TRACENUM_CMD, val);
267 if (error) {
268 dev_err(&client->dev, "failed to get trace info: %d\n", error);
269 return error;
270 }
271
272 *x_traces = val[1] - 1;
273 *y_traces = val[2] - 1;
274
275 return 0;
276}
277
278static int elan_smbus_iap_get_mode(struct i2c_client *client,
279 enum tp_mode *mode)
280{
281 int error;
282 u16 constant;
283 u8 val[3];
284
285 error = i2c_smbus_read_block_data(client, ETP_SMBUS_IAP_CTRL_CMD, val);
286 if (error < 0) {
287 dev_err(&client->dev, "failed to read iap ctrol register: %d\n",
288 error);
289 return error;
290 }
291
292 constant = be16_to_cpup((__be16 *)val);
293 dev_dbg(&client->dev, "iap control reg: 0x%04x.\n", constant);
294
295 *mode = (constant & ETP_SMBUS_IAP_MODE_ON) ? IAP_MODE : MAIN_MODE;
296
297 return 0;
298}
299
300static int elan_smbus_iap_reset(struct i2c_client *client)
301{
302 int error;
303
304 error = i2c_smbus_write_byte(client, ETP_SMBUS_IAP_RESET_CMD);
305 if (error) {
306 dev_err(&client->dev, "cannot reset IC: %d\n", error);
307 return error;
308 }
309
310 return 0;
311}
312
313static int elan_smbus_set_flash_key(struct i2c_client *client)
314{
315 int error;
316 u8 cmd[4] = { 0x00, 0x0B, 0x00, 0x5A };
317
318 error = i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
319 sizeof(cmd), cmd);
320 if (error) {
321 dev_err(&client->dev, "cannot set flash key: %d\n", error);
322 return error;
323 }
324
325 return 0;
326}
327
328static int elan_smbus_prepare_fw_update(struct i2c_client *client)
329{
330 struct device *dev = &client->dev;
331 int len;
332 int error;
333 enum tp_mode mode;
334 u8 val[3];
335 u8 cmd[4] = {0x0F, 0x78, 0x00, 0x06};
336 u16 password;
337
338 /* Get FW in which mode (IAP_MODE/MAIN_MODE) */
339 error = elan_smbus_iap_get_mode(client, &mode);
340 if (error)
341 return error;
342
343 if (mode == MAIN_MODE) {
344
345 /* set flash key */
346 error = elan_smbus_set_flash_key(client);
347 if (error)
348 return error;
349
350 /* write iap password */
351 if (i2c_smbus_write_byte(client,
352 ETP_SMBUS_IAP_PASSWORD_WRITE) < 0) {
353 dev_err(dev, "cannot write iap password\n");
354 return -EIO;
355 }
356
357 error = i2c_smbus_write_block_data(client, ETP_SMBUS_IAP_CMD,
358 sizeof(cmd), cmd);
359 if (error) {
360 dev_err(dev, "failed to write iap password: %d\n",
361 error);
362 return error;
363 }
364
365 /*
366 * Read back password to make sure we enabled flash
367 * successfully.
368 */
369 len = i2c_smbus_read_block_data(client,
370 ETP_SMBUS_IAP_PASSWORD_READ,
371 val);
372 if (len < sizeof(u16)) {
373 error = len < 0 ? len : -EIO;
374 dev_err(dev, "failed to read iap password: %d\n",
375 error);
376 return error;
377 }
378
379 password = be16_to_cpup((__be16 *)val);
380 if (password != ETP_SMBUS_IAP_PASSWORD) {
381 dev_err(dev, "wrong iap password = 0x%X\n", password);
382 return -EIO;
383 }
384
385 /* Wait 30ms for MAIN_MODE change to IAP_MODE */
386 msleep(30);
387 }
388
389 error = elan_smbus_set_flash_key(client);
390 if (error)
391 return error;
392
393 /* Reset IC */
394 error = elan_smbus_iap_reset(client);
395 if (error)
396 return error;
397
398 return 0;
399}
400
401
402static int elan_smbus_write_fw_block(struct i2c_client *client,
403 const u8 *page, u16 checksum, int idx)
404{
405 struct device *dev = &client->dev;
406 int error;
407 u16 result;
408 u8 val[3];
409
410 /*
411 * Due to the limitation of smbus protocol limiting
412 * transfer to 32 bytes at a time, we must split block
413 * in 2 transfers.
414 */
415 error = i2c_smbus_write_block_data(client,
416 ETP_SMBUS_WRITE_FW_BLOCK,
417 ETP_FW_PAGE_SIZE / 2,
418 page);
419 if (error) {
420 dev_err(dev, "Failed to write page %d (part %d): %d\n",
421 idx, 1, error);
422 return error;
423 }
424
425 error = i2c_smbus_write_block_data(client,
426 ETP_SMBUS_WRITE_FW_BLOCK,
427 ETP_FW_PAGE_SIZE / 2,
428 page + ETP_FW_PAGE_SIZE / 2);
429 if (error) {
430 dev_err(dev, "Failed to write page %d (part %d): %d\n",
431 idx, 2, error);
432 return error;
433 }
434
435
436 /* Wait for F/W to update one page ROM data. */
437 usleep_range(8000, 10000);
438
439 error = i2c_smbus_read_block_data(client,
440 ETP_SMBUS_IAP_CTRL_CMD, val);
441 if (error < 0) {
442 dev_err(dev, "Failed to read IAP write result: %d\n",
443 error);
444 return error;
445 }
446
447 result = be16_to_cpup((__be16 *)val);
448 if (result & (ETP_FW_IAP_PAGE_ERR | ETP_FW_IAP_INTF_ERR)) {
449 dev_err(dev, "IAP reports failed write: %04hx\n",
450 result);
451 return -EIO;
452 }
453
454 return 0;
455}
456
457static int elan_smbus_get_report(struct i2c_client *client, u8 *report)
458{
459 int len;
460
461 len = i2c_smbus_read_block_data(client,
462 ETP_SMBUS_PACKET_QUERY,
463 &report[ETP_SMBUS_REPORT_OFFSET]);
464 if (len < 0) {
465 dev_err(&client->dev, "failed to read report data: %d\n", len);
466 return len;
467 }
468
469 if (len != ETP_SMBUS_REPORT_LEN) {
470 dev_err(&client->dev,
471 "wrong report length (%d vs %d expected)\n",
472 len, ETP_SMBUS_REPORT_LEN);
473 return -EIO;
474 }
475
476 return 0;
477}
478
479static int elan_smbus_finish_fw_update(struct i2c_client *client,
480 struct completion *fw_completion)
481{
482 /* No special handling unlike I2C transport */
483 return 0;
484}
485
486const struct elan_transport_ops elan_smbus_ops = {
487 .initialize = elan_smbus_initialize,
488 .sleep_control = elan_smbus_sleep_control,
489 .power_control = elan_smbus_power_control,
490 .set_mode = elan_smbus_set_mode,
491
492 .calibrate = elan_smbus_calibrate,
493 .calibrate_result = elan_smbus_calibrate_result,
494
495 .get_baseline_data = elan_smbus_get_baseline_data,
496
497 .get_version = elan_smbus_get_version,
498 .get_sm_version = elan_smbus_get_sm_version,
499 .get_product_id = elan_smbus_get_product_id,
500 .get_checksum = elan_smbus_get_checksum,
501
502 .get_max = elan_smbus_get_max,
503 .get_resolution = elan_smbus_get_resolution,
504 .get_num_traces = elan_smbus_get_num_traces,
505
506 .iap_get_mode = elan_smbus_iap_get_mode,
507 .iap_reset = elan_smbus_iap_reset,
508
509 .prepare_fw_update = elan_smbus_prepare_fw_update,
510 .write_fw_block = elan_smbus_write_fw_block,
511 .finish_fw_update = elan_smbus_finish_fw_update,
512
513 .get_report = elan_smbus_get_report,
514};
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-10 01:23:26 -0400