]>
Commit | Line | Data |
---|---|---|
6696777c DL |
1 | /* |
2 | * Elan I2C/SMBus Touchpad driver | |
3 | * | |
4 | * Copyright (c) 2013 ELAN Microelectronics Corp. | |
5 | * | |
6 | * Author: 林政維 (Duson Lin) <dusonlin@emc.com.tw> | |
2de4fcc6 | 7 | * Author: KT Liao <kt.liao@emc.com.tw> |
a2eaf299 | 8 | * Version: 1.6.3 |
6696777c DL |
9 | * |
10 | * Based on cyapa driver: | |
11 | * copyright (c) 2011-2012 Cypress Semiconductor, Inc. | |
12 | * copyright (c) 2011-2012 Google, Inc. | |
13 | * | |
14 | * This program is free software; you can redistribute it and/or modify it | |
15 | * under the terms of the GNU General Public License version 2 as published | |
16 | * by the Free Software Foundation. | |
17 | * | |
18 | * Trademarks are the property of their respective owners. | |
19 | */ | |
20 | ||
21 | #include <linux/acpi.h> | |
22 | #include <linux/delay.h> | |
23 | #include <linux/device.h> | |
24 | #include <linux/firmware.h> | |
25 | #include <linux/i2c.h> | |
26 | #include <linux/init.h> | |
27 | #include <linux/input/mt.h> | |
28 | #include <linux/interrupt.h> | |
a4b0a58b | 29 | #include <linux/irq.h> |
6696777c DL |
30 | #include <linux/module.h> |
31 | #include <linux/slab.h> | |
32 | #include <linux/kernel.h> | |
33 | #include <linux/sched.h> | |
34 | #include <linux/input.h> | |
35 | #include <linux/uaccess.h> | |
36 | #include <linux/jiffies.h> | |
37 | #include <linux/completion.h> | |
38 | #include <linux/of.h> | |
4c5b6d78 | 39 | #include <linux/input/elan-i2c-ids.h> |
6696777c DL |
40 | #include <linux/regulator/consumer.h> |
41 | #include <asm/unaligned.h> | |
42 | ||
43 | #include "elan_i2c.h" | |
44 | ||
45 | #define DRIVER_NAME "elan_i2c" | |
a2eaf299 | 46 | #define ELAN_DRIVER_VERSION "1.6.3" |
3eab4588 | 47 | #define ELAN_VENDOR_ID 0x04f3 |
6696777c DL |
48 | #define ETP_MAX_PRESSURE 255 |
49 | #define ETP_FWIDTH_REDUCE 90 | |
50 | #define ETP_FINGER_WIDTH 15 | |
51 | #define ETP_RETRY_COUNT 3 | |
52 | ||
53 | #define ETP_MAX_FINGERS 5 | |
54 | #define ETP_FINGER_DATA_LEN 5 | |
55 | #define ETP_REPORT_ID 0x5D | |
56 | #define ETP_REPORT_ID_OFFSET 2 | |
57 | #define ETP_TOUCH_INFO_OFFSET 3 | |
58 | #define ETP_FINGER_DATA_OFFSET 4 | |
090ad325 | 59 | #define ETP_HOVER_INFO_OFFSET 30 |
6696777c DL |
60 | #define ETP_MAX_REPORT_LEN 34 |
61 | ||
62 | /* The main device structure */ | |
63 | struct elan_tp_data { | |
64 | struct i2c_client *client; | |
65 | struct input_dev *input; | |
66 | struct regulator *vcc; | |
67 | ||
68 | const struct elan_transport_ops *ops; | |
69 | ||
70 | /* for fw update */ | |
71 | struct completion fw_completion; | |
72 | bool in_fw_update; | |
73 | ||
74 | struct mutex sysfs_mutex; | |
75 | ||
76 | unsigned int max_x; | |
77 | unsigned int max_y; | |
78 | unsigned int width_x; | |
79 | unsigned int width_y; | |
80 | unsigned int x_res; | |
81 | unsigned int y_res; | |
82 | ||
a2eaf299 | 83 | u8 pattern; |
ed75a14e | 84 | u16 product_id; |
6696777c DL |
85 | u8 fw_version; |
86 | u8 sm_version; | |
87 | u8 iap_version; | |
88 | u16 fw_checksum; | |
b9bced0e | 89 | int pressure_adjustment; |
6696777c | 90 | u8 mode; |
a2eaf299 | 91 | u16 ic_type; |
742f452b | 92 | u16 fw_validpage_count; |
12018ac3 | 93 | u16 fw_signature_address; |
6696777c DL |
94 | |
95 | bool irq_wake; | |
96 | ||
97 | u8 min_baseline; | |
98 | u8 max_baseline; | |
99 | bool baseline_ready; | |
99136881 | 100 | u8 clickpad; |
6696777c DL |
101 | }; |
102 | ||
a2eaf299 | 103 | static int elan_get_fwinfo(u16 ic_type, u16 *validpage_count, |
12018ac3 DL |
104 | u16 *signature_address) |
105 | { | |
a2eaf299 | 106 | switch (ic_type) { |
22ef28b4 | 107 | case 0x00: |
108 | case 0x06: | |
534fcb3b | 109 | case 0x08: |
742f452b | 110 | *validpage_count = 512; |
534fcb3b | 111 | break; |
c84333a1 | 112 | case 0x03: |
22ef28b4 | 113 | case 0x07: |
114 | case 0x09: | |
115 | case 0x0A: | |
116 | case 0x0B: | |
117 | case 0x0C: | |
742f452b | 118 | *validpage_count = 768; |
12018ac3 DL |
119 | break; |
120 | case 0x0D: | |
742f452b | 121 | *validpage_count = 896; |
12018ac3 | 122 | break; |
22ef28b4 | 123 | case 0x0E: |
124 | *validpage_count = 640; | |
125 | break; | |
a2eaf299 KL |
126 | case 0x10: |
127 | *validpage_count = 1024; | |
128 | break; | |
12018ac3 DL |
129 | default: |
130 | /* unknown ic type clear value */ | |
742f452b | 131 | *validpage_count = 0; |
12018ac3 DL |
132 | *signature_address = 0; |
133 | return -ENXIO; | |
134 | } | |
135 | ||
136 | *signature_address = | |
742f452b | 137 | (*validpage_count * ETP_FW_PAGE_SIZE) - ETP_FW_SIGNATURE_SIZE; |
12018ac3 DL |
138 | |
139 | return 0; | |
140 | } | |
141 | ||
6696777c DL |
142 | static int elan_enable_power(struct elan_tp_data *data) |
143 | { | |
144 | int repeat = ETP_RETRY_COUNT; | |
145 | int error; | |
146 | ||
147 | error = regulator_enable(data->vcc); | |
148 | if (error) { | |
149 | dev_err(&data->client->dev, | |
b3beed7f | 150 | "failed to enable regulator: %d\n", error); |
6696777c DL |
151 | return error; |
152 | } | |
153 | ||
154 | do { | |
155 | error = data->ops->power_control(data->client, true); | |
156 | if (error >= 0) | |
157 | return 0; | |
158 | ||
159 | msleep(30); | |
160 | } while (--repeat > 0); | |
161 | ||
b3beed7f | 162 | dev_err(&data->client->dev, "failed to enable power: %d\n", error); |
6696777c DL |
163 | return error; |
164 | } | |
165 | ||
166 | static int elan_disable_power(struct elan_tp_data *data) | |
167 | { | |
168 | int repeat = ETP_RETRY_COUNT; | |
169 | int error; | |
170 | ||
171 | do { | |
172 | error = data->ops->power_control(data->client, false); | |
173 | if (!error) { | |
174 | error = regulator_disable(data->vcc); | |
175 | if (error) { | |
176 | dev_err(&data->client->dev, | |
b3beed7f | 177 | "failed to disable regulator: %d\n", |
6696777c DL |
178 | error); |
179 | /* Attempt to power the chip back up */ | |
180 | data->ops->power_control(data->client, true); | |
181 | break; | |
182 | } | |
183 | ||
184 | return 0; | |
185 | } | |
186 | ||
187 | msleep(30); | |
188 | } while (--repeat > 0); | |
189 | ||
b3beed7f | 190 | dev_err(&data->client->dev, "failed to disable power: %d\n", error); |
6696777c DL |
191 | return error; |
192 | } | |
193 | ||
194 | static int elan_sleep(struct elan_tp_data *data) | |
195 | { | |
196 | int repeat = ETP_RETRY_COUNT; | |
197 | int error; | |
198 | ||
199 | do { | |
200 | error = data->ops->sleep_control(data->client, true); | |
201 | if (!error) | |
202 | return 0; | |
203 | ||
204 | msleep(30); | |
205 | } while (--repeat > 0); | |
206 | ||
207 | return error; | |
208 | } | |
209 | ||
2de4fcc6 KL |
210 | static int elan_query_product(struct elan_tp_data *data) |
211 | { | |
212 | int error; | |
213 | ||
214 | error = data->ops->get_product_id(data->client, &data->product_id); | |
215 | if (error) | |
216 | return error; | |
217 | ||
218 | error = data->ops->get_sm_version(data->client, &data->ic_type, | |
99136881 | 219 | &data->sm_version, &data->clickpad); |
2de4fcc6 KL |
220 | if (error) |
221 | return error; | |
222 | ||
223 | return 0; | |
224 | } | |
225 | ||
226 | static int elan_check_ASUS_special_fw(struct elan_tp_data *data) | |
227 | { | |
92ef6f97 MH |
228 | if (data->ic_type == 0x0E) { |
229 | switch (data->product_id) { | |
230 | case 0x05 ... 0x07: | |
231 | case 0x09: | |
232 | case 0x13: | |
233 | return true; | |
234 | } | |
235 | } else if (data->ic_type == 0x08 && data->product_id == 0x26) { | |
236 | /* ASUS EeeBook X205TA */ | |
2de4fcc6 | 237 | return true; |
2de4fcc6 | 238 | } |
92ef6f97 MH |
239 | |
240 | return false; | |
2de4fcc6 KL |
241 | } |
242 | ||
6696777c DL |
243 | static int __elan_initialize(struct elan_tp_data *data) |
244 | { | |
245 | struct i2c_client *client = data->client; | |
2de4fcc6 | 246 | bool woken_up = false; |
6696777c DL |
247 | int error; |
248 | ||
249 | error = data->ops->initialize(client); | |
250 | if (error) { | |
251 | dev_err(&client->dev, "device initialize failed: %d\n", error); | |
252 | return error; | |
253 | } | |
254 | ||
2de4fcc6 KL |
255 | error = elan_query_product(data); |
256 | if (error) | |
257 | return error; | |
258 | ||
259 | /* | |
260 | * Some ASUS devices were shipped with firmware that requires | |
261 | * touchpads to be woken up first, before attempting to switch | |
262 | * them into absolute reporting mode. | |
263 | */ | |
264 | if (elan_check_ASUS_special_fw(data)) { | |
265 | error = data->ops->sleep_control(client, false); | |
266 | if (error) { | |
267 | dev_err(&client->dev, | |
268 | "failed to wake device up: %d\n", error); | |
269 | return error; | |
270 | } | |
271 | ||
272 | msleep(200); | |
273 | woken_up = true; | |
274 | } | |
275 | ||
6696777c DL |
276 | data->mode |= ETP_ENABLE_ABS; |
277 | error = data->ops->set_mode(client, data->mode); | |
278 | if (error) { | |
279 | dev_err(&client->dev, | |
280 | "failed to switch to absolute mode: %d\n", error); | |
281 | return error; | |
282 | } | |
283 | ||
2de4fcc6 KL |
284 | if (!woken_up) { |
285 | error = data->ops->sleep_control(client, false); | |
286 | if (error) { | |
287 | dev_err(&client->dev, | |
288 | "failed to wake device up: %d\n", error); | |
289 | return error; | |
290 | } | |
6696777c DL |
291 | } |
292 | ||
293 | return 0; | |
294 | } | |
295 | ||
296 | static int elan_initialize(struct elan_tp_data *data) | |
297 | { | |
298 | int repeat = ETP_RETRY_COUNT; | |
299 | int error; | |
300 | ||
301 | do { | |
302 | error = __elan_initialize(data); | |
303 | if (!error) | |
304 | return 0; | |
305 | ||
6696777c DL |
306 | msleep(30); |
307 | } while (--repeat > 0); | |
308 | ||
309 | return error; | |
310 | } | |
311 | ||
312 | static int elan_query_device_info(struct elan_tp_data *data) | |
313 | { | |
314 | int error; | |
a2eaf299 | 315 | u16 ic_type; |
6696777c | 316 | |
6696777c DL |
317 | error = data->ops->get_version(data->client, false, &data->fw_version); |
318 | if (error) | |
319 | return error; | |
320 | ||
321 | error = data->ops->get_checksum(data->client, false, | |
322 | &data->fw_checksum); | |
323 | if (error) | |
324 | return error; | |
325 | ||
6696777c DL |
326 | error = data->ops->get_version(data->client, true, &data->iap_version); |
327 | if (error) | |
328 | return error; | |
329 | ||
b9bced0e | 330 | error = data->ops->get_pressure_adjustment(data->client, |
331 | &data->pressure_adjustment); | |
332 | if (error) | |
333 | return error; | |
334 | ||
a2eaf299 KL |
335 | error = data->ops->get_pattern(data->client, &data->pattern); |
336 | if (error) | |
337 | return error; | |
338 | ||
339 | if (data->pattern == 0x01) | |
340 | ic_type = data->ic_type; | |
341 | else | |
342 | ic_type = data->iap_version; | |
343 | ||
344 | error = elan_get_fwinfo(ic_type, &data->fw_validpage_count, | |
12018ac3 | 345 | &data->fw_signature_address); |
9d7b03f8 DD |
346 | if (error) |
347 | dev_warn(&data->client->dev, | |
348 | "unexpected iap version %#04x (ic type: %#04x), firmware update will not work\n", | |
349 | data->iap_version, data->ic_type); | |
12018ac3 | 350 | |
6696777c DL |
351 | return 0; |
352 | } | |
353 | ||
354 | static unsigned int elan_convert_resolution(u8 val) | |
355 | { | |
356 | /* | |
357 | * (value from firmware) * 10 + 790 = dpi | |
358 | * | |
359 | * We also have to convert dpi to dots/mm (*10/254 to avoid floating | |
360 | * point). | |
361 | */ | |
362 | ||
363 | return ((int)(char)val * 10 + 790) * 10 / 254; | |
364 | } | |
365 | ||
366 | static int elan_query_device_parameters(struct elan_tp_data *data) | |
367 | { | |
368 | unsigned int x_traces, y_traces; | |
369 | u8 hw_x_res, hw_y_res; | |
370 | int error; | |
371 | ||
372 | error = data->ops->get_max(data->client, &data->max_x, &data->max_y); | |
373 | if (error) | |
374 | return error; | |
375 | ||
376 | error = data->ops->get_num_traces(data->client, &x_traces, &y_traces); | |
377 | if (error) | |
378 | return error; | |
379 | ||
380 | data->width_x = data->max_x / x_traces; | |
381 | data->width_y = data->max_y / y_traces; | |
382 | ||
383 | error = data->ops->get_resolution(data->client, &hw_x_res, &hw_y_res); | |
384 | if (error) | |
385 | return error; | |
386 | ||
387 | data->x_res = elan_convert_resolution(hw_x_res); | |
388 | data->y_res = elan_convert_resolution(hw_y_res); | |
389 | ||
390 | return 0; | |
391 | } | |
392 | ||
393 | /* | |
394 | ********************************************************** | |
395 | * IAP firmware updater related routines | |
396 | ********************************************************** | |
397 | */ | |
398 | static int elan_write_fw_block(struct elan_tp_data *data, | |
399 | const u8 *page, u16 checksum, int idx) | |
400 | { | |
401 | int retry = ETP_RETRY_COUNT; | |
402 | int error; | |
403 | ||
404 | do { | |
405 | error = data->ops->write_fw_block(data->client, | |
406 | page, checksum, idx); | |
407 | if (!error) | |
408 | return 0; | |
409 | ||
410 | dev_dbg(&data->client->dev, | |
411 | "IAP retrying page %d (error: %d)\n", idx, error); | |
412 | } while (--retry > 0); | |
413 | ||
414 | return error; | |
415 | } | |
416 | ||
417 | static int __elan_update_firmware(struct elan_tp_data *data, | |
418 | const struct firmware *fw) | |
419 | { | |
420 | struct i2c_client *client = data->client; | |
421 | struct device *dev = &client->dev; | |
422 | int i, j; | |
423 | int error; | |
424 | u16 iap_start_addr; | |
425 | u16 boot_page_count; | |
426 | u16 sw_checksum = 0, fw_checksum = 0; | |
427 | ||
428 | error = data->ops->prepare_fw_update(client); | |
429 | if (error) | |
430 | return error; | |
431 | ||
432 | iap_start_addr = get_unaligned_le16(&fw->data[ETP_IAP_START_ADDR * 2]); | |
433 | ||
434 | boot_page_count = (iap_start_addr * 2) / ETP_FW_PAGE_SIZE; | |
742f452b | 435 | for (i = boot_page_count; i < data->fw_validpage_count; i++) { |
6696777c DL |
436 | u16 checksum = 0; |
437 | const u8 *page = &fw->data[i * ETP_FW_PAGE_SIZE]; | |
438 | ||
439 | for (j = 0; j < ETP_FW_PAGE_SIZE; j += 2) | |
440 | checksum += ((page[j + 1] << 8) | page[j]); | |
441 | ||
442 | error = elan_write_fw_block(data, page, checksum, i); | |
443 | if (error) { | |
444 | dev_err(dev, "write page %d fail: %d\n", i, error); | |
445 | return error; | |
446 | } | |
447 | ||
448 | sw_checksum += checksum; | |
449 | } | |
450 | ||
451 | /* Wait WDT reset and power on reset */ | |
452 | msleep(600); | |
453 | ||
454 | error = data->ops->finish_fw_update(client, &data->fw_completion); | |
455 | if (error) | |
456 | return error; | |
457 | ||
458 | error = data->ops->get_checksum(client, true, &fw_checksum); | |
459 | if (error) | |
460 | return error; | |
461 | ||
462 | if (sw_checksum != fw_checksum) { | |
463 | dev_err(dev, "checksum diff sw=[%04X], fw=[%04X]\n", | |
464 | sw_checksum, fw_checksum); | |
465 | return -EIO; | |
466 | } | |
467 | ||
468 | return 0; | |
469 | } | |
470 | ||
471 | static int elan_update_firmware(struct elan_tp_data *data, | |
472 | const struct firmware *fw) | |
473 | { | |
474 | struct i2c_client *client = data->client; | |
475 | int retval; | |
476 | ||
477 | dev_dbg(&client->dev, "Starting firmware update....\n"); | |
478 | ||
479 | disable_irq(client->irq); | |
480 | data->in_fw_update = true; | |
481 | ||
482 | retval = __elan_update_firmware(data, fw); | |
483 | if (retval) { | |
484 | dev_err(&client->dev, "firmware update failed: %d\n", retval); | |
485 | data->ops->iap_reset(client); | |
486 | } else { | |
487 | /* Reinitialize TP after fw is updated */ | |
488 | elan_initialize(data); | |
489 | elan_query_device_info(data); | |
490 | } | |
491 | ||
492 | data->in_fw_update = false; | |
493 | enable_irq(client->irq); | |
494 | ||
495 | return retval; | |
496 | } | |
497 | ||
498 | /* | |
499 | ******************************************************************* | |
500 | * SYSFS attributes | |
501 | ******************************************************************* | |
502 | */ | |
503 | static ssize_t elan_sysfs_read_fw_checksum(struct device *dev, | |
504 | struct device_attribute *attr, | |
505 | char *buf) | |
506 | { | |
507 | struct i2c_client *client = to_i2c_client(dev); | |
508 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
509 | ||
510 | return sprintf(buf, "0x%04x\n", data->fw_checksum); | |
511 | } | |
512 | ||
513 | static ssize_t elan_sysfs_read_product_id(struct device *dev, | |
514 | struct device_attribute *attr, | |
515 | char *buf) | |
516 | { | |
517 | struct i2c_client *client = to_i2c_client(dev); | |
518 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
519 | ||
7b9f1830 CM |
520 | return sprintf(buf, ETP_PRODUCT_ID_FORMAT_STRING "\n", |
521 | data->product_id); | |
6696777c DL |
522 | } |
523 | ||
524 | static ssize_t elan_sysfs_read_fw_ver(struct device *dev, | |
525 | struct device_attribute *attr, | |
526 | char *buf) | |
527 | { | |
528 | struct i2c_client *client = to_i2c_client(dev); | |
529 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
530 | ||
531 | return sprintf(buf, "%d.0\n", data->fw_version); | |
532 | } | |
533 | ||
534 | static ssize_t elan_sysfs_read_sm_ver(struct device *dev, | |
535 | struct device_attribute *attr, | |
536 | char *buf) | |
537 | { | |
538 | struct i2c_client *client = to_i2c_client(dev); | |
539 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
540 | ||
541 | return sprintf(buf, "%d.0\n", data->sm_version); | |
542 | } | |
543 | ||
544 | static ssize_t elan_sysfs_read_iap_ver(struct device *dev, | |
545 | struct device_attribute *attr, | |
546 | char *buf) | |
547 | { | |
548 | struct i2c_client *client = to_i2c_client(dev); | |
549 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
550 | ||
551 | return sprintf(buf, "%d.0\n", data->iap_version); | |
552 | } | |
553 | ||
554 | static ssize_t elan_sysfs_update_fw(struct device *dev, | |
555 | struct device_attribute *attr, | |
556 | const char *buf, size_t count) | |
557 | { | |
bb03bf3f | 558 | struct elan_tp_data *data = dev_get_drvdata(dev); |
6696777c | 559 | const struct firmware *fw; |
7b9f1830 | 560 | char *fw_name; |
6696777c | 561 | int error; |
bb03bf3f DL |
562 | const u8 *fw_signature; |
563 | static const u8 signature[] = {0xAA, 0x55, 0xCC, 0x33, 0xFF, 0xFF}; | |
6696777c | 564 | |
9d7b03f8 DD |
565 | if (data->fw_validpage_count == 0) |
566 | return -EINVAL; | |
567 | ||
7b9f1830 CM |
568 | /* Look for a firmware with the product id appended. */ |
569 | fw_name = kasprintf(GFP_KERNEL, ETP_FW_NAME, data->product_id); | |
570 | if (!fw_name) { | |
571 | dev_err(dev, "failed to allocate memory for firmware name\n"); | |
572 | return -ENOMEM; | |
573 | } | |
574 | ||
575 | dev_info(dev, "requesting fw '%s'\n", fw_name); | |
576 | error = request_firmware(&fw, fw_name, dev); | |
577 | kfree(fw_name); | |
6696777c | 578 | if (error) { |
7b9f1830 | 579 | dev_err(dev, "failed to request firmware: %d\n", error); |
6696777c DL |
580 | return error; |
581 | } | |
582 | ||
bb03bf3f | 583 | /* Firmware file must match signature data */ |
12018ac3 | 584 | fw_signature = &fw->data[data->fw_signature_address]; |
bb03bf3f DL |
585 | if (memcmp(fw_signature, signature, sizeof(signature)) != 0) { |
586 | dev_err(dev, "signature mismatch (expected %*ph, got %*ph)\n", | |
587 | (int)sizeof(signature), signature, | |
588 | (int)sizeof(signature), fw_signature); | |
6696777c DL |
589 | error = -EBADF; |
590 | goto out_release_fw; | |
591 | } | |
592 | ||
593 | error = mutex_lock_interruptible(&data->sysfs_mutex); | |
594 | if (error) | |
595 | goto out_release_fw; | |
596 | ||
597 | error = elan_update_firmware(data, fw); | |
598 | ||
599 | mutex_unlock(&data->sysfs_mutex); | |
600 | ||
601 | out_release_fw: | |
602 | release_firmware(fw); | |
603 | return error ?: count; | |
604 | } | |
605 | ||
606 | static ssize_t calibrate_store(struct device *dev, | |
607 | struct device_attribute *attr, | |
608 | const char *buf, size_t count) | |
609 | { | |
610 | struct i2c_client *client = to_i2c_client(dev); | |
611 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
612 | int tries = 20; | |
613 | int retval; | |
614 | int error; | |
51f13a3d | 615 | u8 val[ETP_CALIBRATE_MAX_LEN]; |
6696777c DL |
616 | |
617 | retval = mutex_lock_interruptible(&data->sysfs_mutex); | |
618 | if (retval) | |
619 | return retval; | |
620 | ||
621 | disable_irq(client->irq); | |
622 | ||
623 | data->mode |= ETP_ENABLE_CALIBRATE; | |
624 | retval = data->ops->set_mode(client, data->mode); | |
625 | if (retval) { | |
626 | dev_err(dev, "failed to enable calibration mode: %d\n", | |
627 | retval); | |
628 | goto out; | |
629 | } | |
630 | ||
631 | retval = data->ops->calibrate(client); | |
632 | if (retval) { | |
633 | dev_err(dev, "failed to start calibration: %d\n", | |
634 | retval); | |
635 | goto out_disable_calibrate; | |
636 | } | |
637 | ||
638 | val[0] = 0xff; | |
639 | do { | |
640 | /* Wait 250ms before checking if calibration has completed. */ | |
641 | msleep(250); | |
642 | ||
643 | retval = data->ops->calibrate_result(client, val); | |
644 | if (retval) | |
645 | dev_err(dev, "failed to check calibration result: %d\n", | |
646 | retval); | |
647 | else if (val[0] == 0) | |
648 | break; /* calibration done */ | |
649 | ||
650 | } while (--tries); | |
651 | ||
652 | if (tries == 0) { | |
653 | dev_err(dev, "failed to calibrate. Timeout.\n"); | |
654 | retval = -ETIMEDOUT; | |
655 | } | |
656 | ||
657 | out_disable_calibrate: | |
658 | data->mode &= ~ETP_ENABLE_CALIBRATE; | |
659 | error = data->ops->set_mode(data->client, data->mode); | |
660 | if (error) { | |
661 | dev_err(dev, "failed to disable calibration mode: %d\n", | |
662 | error); | |
663 | if (!retval) | |
664 | retval = error; | |
665 | } | |
666 | out: | |
667 | enable_irq(client->irq); | |
668 | mutex_unlock(&data->sysfs_mutex); | |
669 | return retval ?: count; | |
670 | } | |
671 | ||
672 | static ssize_t elan_sysfs_read_mode(struct device *dev, | |
673 | struct device_attribute *attr, | |
674 | char *buf) | |
675 | { | |
676 | struct i2c_client *client = to_i2c_client(dev); | |
677 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
678 | int error; | |
679 | enum tp_mode mode; | |
680 | ||
681 | error = mutex_lock_interruptible(&data->sysfs_mutex); | |
682 | if (error) | |
683 | return error; | |
684 | ||
685 | error = data->ops->iap_get_mode(data->client, &mode); | |
686 | ||
687 | mutex_unlock(&data->sysfs_mutex); | |
688 | ||
689 | if (error) | |
690 | return error; | |
691 | ||
692 | return sprintf(buf, "%d\n", (int)mode); | |
693 | } | |
694 | ||
695 | static DEVICE_ATTR(product_id, S_IRUGO, elan_sysfs_read_product_id, NULL); | |
696 | static DEVICE_ATTR(firmware_version, S_IRUGO, elan_sysfs_read_fw_ver, NULL); | |
697 | static DEVICE_ATTR(sample_version, S_IRUGO, elan_sysfs_read_sm_ver, NULL); | |
698 | static DEVICE_ATTR(iap_version, S_IRUGO, elan_sysfs_read_iap_ver, NULL); | |
699 | static DEVICE_ATTR(fw_checksum, S_IRUGO, elan_sysfs_read_fw_checksum, NULL); | |
700 | static DEVICE_ATTR(mode, S_IRUGO, elan_sysfs_read_mode, NULL); | |
701 | static DEVICE_ATTR(update_fw, S_IWUSR, NULL, elan_sysfs_update_fw); | |
702 | ||
703 | static DEVICE_ATTR_WO(calibrate); | |
704 | ||
705 | static struct attribute *elan_sysfs_entries[] = { | |
706 | &dev_attr_product_id.attr, | |
707 | &dev_attr_firmware_version.attr, | |
708 | &dev_attr_sample_version.attr, | |
709 | &dev_attr_iap_version.attr, | |
710 | &dev_attr_fw_checksum.attr, | |
711 | &dev_attr_calibrate.attr, | |
712 | &dev_attr_mode.attr, | |
713 | &dev_attr_update_fw.attr, | |
714 | NULL, | |
715 | }; | |
716 | ||
717 | static const struct attribute_group elan_sysfs_group = { | |
718 | .attrs = elan_sysfs_entries, | |
719 | }; | |
720 | ||
721 | static ssize_t acquire_store(struct device *dev, struct device_attribute *attr, | |
722 | const char *buf, size_t count) | |
723 | { | |
724 | struct i2c_client *client = to_i2c_client(dev); | |
725 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
726 | int error; | |
727 | int retval; | |
728 | ||
729 | retval = mutex_lock_interruptible(&data->sysfs_mutex); | |
730 | if (retval) | |
731 | return retval; | |
732 | ||
733 | disable_irq(client->irq); | |
734 | ||
735 | data->baseline_ready = false; | |
736 | ||
737 | data->mode |= ETP_ENABLE_CALIBRATE; | |
738 | retval = data->ops->set_mode(data->client, data->mode); | |
739 | if (retval) { | |
740 | dev_err(dev, "Failed to enable calibration mode to get baseline: %d\n", | |
741 | retval); | |
742 | goto out; | |
743 | } | |
744 | ||
745 | msleep(250); | |
746 | ||
747 | retval = data->ops->get_baseline_data(data->client, true, | |
748 | &data->max_baseline); | |
749 | if (retval) { | |
750 | dev_err(dev, "Failed to read max baseline form device: %d\n", | |
751 | retval); | |
752 | goto out_disable_calibrate; | |
753 | } | |
754 | ||
755 | retval = data->ops->get_baseline_data(data->client, false, | |
756 | &data->min_baseline); | |
757 | if (retval) { | |
758 | dev_err(dev, "Failed to read min baseline form device: %d\n", | |
759 | retval); | |
760 | goto out_disable_calibrate; | |
761 | } | |
762 | ||
763 | data->baseline_ready = true; | |
764 | ||
765 | out_disable_calibrate: | |
766 | data->mode &= ~ETP_ENABLE_CALIBRATE; | |
767 | error = data->ops->set_mode(data->client, data->mode); | |
768 | if (error) { | |
769 | dev_err(dev, "Failed to disable calibration mode after acquiring baseline: %d\n", | |
770 | error); | |
771 | if (!retval) | |
772 | retval = error; | |
773 | } | |
774 | out: | |
775 | enable_irq(client->irq); | |
776 | mutex_unlock(&data->sysfs_mutex); | |
777 | return retval ?: count; | |
778 | } | |
779 | ||
780 | static ssize_t min_show(struct device *dev, | |
781 | struct device_attribute *attr, char *buf) | |
782 | { | |
783 | struct i2c_client *client = to_i2c_client(dev); | |
784 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
785 | int retval; | |
786 | ||
787 | retval = mutex_lock_interruptible(&data->sysfs_mutex); | |
788 | if (retval) | |
789 | return retval; | |
790 | ||
791 | if (!data->baseline_ready) { | |
792 | retval = -ENODATA; | |
793 | goto out; | |
794 | } | |
795 | ||
796 | retval = snprintf(buf, PAGE_SIZE, "%d", data->min_baseline); | |
797 | ||
798 | out: | |
799 | mutex_unlock(&data->sysfs_mutex); | |
800 | return retval; | |
801 | } | |
802 | ||
803 | static ssize_t max_show(struct device *dev, | |
804 | struct device_attribute *attr, char *buf) | |
805 | { | |
806 | struct i2c_client *client = to_i2c_client(dev); | |
807 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
808 | int retval; | |
809 | ||
810 | retval = mutex_lock_interruptible(&data->sysfs_mutex); | |
811 | if (retval) | |
812 | return retval; | |
813 | ||
814 | if (!data->baseline_ready) { | |
815 | retval = -ENODATA; | |
816 | goto out; | |
817 | } | |
818 | ||
819 | retval = snprintf(buf, PAGE_SIZE, "%d", data->max_baseline); | |
820 | ||
821 | out: | |
822 | mutex_unlock(&data->sysfs_mutex); | |
823 | return retval; | |
824 | } | |
825 | ||
826 | ||
827 | static DEVICE_ATTR_WO(acquire); | |
828 | static DEVICE_ATTR_RO(min); | |
829 | static DEVICE_ATTR_RO(max); | |
830 | ||
831 | static struct attribute *elan_baseline_sysfs_entries[] = { | |
832 | &dev_attr_acquire.attr, | |
833 | &dev_attr_min.attr, | |
834 | &dev_attr_max.attr, | |
835 | NULL, | |
836 | }; | |
837 | ||
838 | static const struct attribute_group elan_baseline_sysfs_group = { | |
839 | .name = "baseline", | |
840 | .attrs = elan_baseline_sysfs_entries, | |
841 | }; | |
842 | ||
843 | static const struct attribute_group *elan_sysfs_groups[] = { | |
844 | &elan_sysfs_group, | |
845 | &elan_baseline_sysfs_group, | |
846 | NULL | |
847 | }; | |
848 | ||
849 | /* | |
850 | ****************************************************************** | |
851 | * Elan isr functions | |
852 | ****************************************************************** | |
853 | */ | |
854 | static void elan_report_contact(struct elan_tp_data *data, | |
855 | int contact_num, bool contact_valid, | |
539c4b88 | 856 | u8 *finger_data) |
6696777c DL |
857 | { |
858 | struct input_dev *input = data->input; | |
859 | unsigned int pos_x, pos_y; | |
860 | unsigned int pressure, mk_x, mk_y; | |
b9bced0e | 861 | unsigned int area_x, area_y, major, minor; |
862 | unsigned int scaled_pressure; | |
6696777c DL |
863 | |
864 | if (contact_valid) { | |
865 | pos_x = ((finger_data[0] & 0xf0) << 4) | | |
866 | finger_data[1]; | |
867 | pos_y = ((finger_data[0] & 0x0f) << 8) | | |
868 | finger_data[2]; | |
869 | mk_x = (finger_data[3] & 0x0f); | |
870 | mk_y = (finger_data[3] >> 4); | |
871 | pressure = finger_data[4]; | |
872 | ||
873 | if (pos_x > data->max_x || pos_y > data->max_y) { | |
874 | dev_dbg(input->dev.parent, | |
875 | "[%d] x=%d y=%d over max (%d, %d)", | |
876 | contact_num, pos_x, pos_y, | |
877 | data->max_x, data->max_y); | |
878 | return; | |
879 | } | |
880 | ||
881 | /* | |
882 | * To avoid treating large finger as palm, let's reduce the | |
883 | * width x and y per trace. | |
884 | */ | |
885 | area_x = mk_x * (data->width_x - ETP_FWIDTH_REDUCE); | |
886 | area_y = mk_y * (data->width_y - ETP_FWIDTH_REDUCE); | |
887 | ||
888 | major = max(area_x, area_y); | |
889 | minor = min(area_x, area_y); | |
890 | ||
b9bced0e | 891 | scaled_pressure = pressure + data->pressure_adjustment; |
892 | ||
893 | if (scaled_pressure > ETP_MAX_PRESSURE) | |
894 | scaled_pressure = ETP_MAX_PRESSURE; | |
6696777c DL |
895 | |
896 | input_mt_slot(input, contact_num); | |
897 | input_mt_report_slot_state(input, MT_TOOL_FINGER, true); | |
898 | input_report_abs(input, ABS_MT_POSITION_X, pos_x); | |
899 | input_report_abs(input, ABS_MT_POSITION_Y, data->max_y - pos_y); | |
539c4b88 | 900 | input_report_abs(input, ABS_MT_PRESSURE, scaled_pressure); |
6696777c DL |
901 | input_report_abs(input, ABS_TOOL_WIDTH, mk_x); |
902 | input_report_abs(input, ABS_MT_TOUCH_MAJOR, major); | |
903 | input_report_abs(input, ABS_MT_TOUCH_MINOR, minor); | |
904 | } else { | |
905 | input_mt_slot(input, contact_num); | |
906 | input_mt_report_slot_state(input, MT_TOOL_FINGER, false); | |
907 | } | |
908 | } | |
909 | ||
910 | static void elan_report_absolute(struct elan_tp_data *data, u8 *packet) | |
911 | { | |
912 | struct input_dev *input = data->input; | |
913 | u8 *finger_data = &packet[ETP_FINGER_DATA_OFFSET]; | |
914 | int i; | |
915 | u8 tp_info = packet[ETP_TOUCH_INFO_OFFSET]; | |
090ad325 DL |
916 | u8 hover_info = packet[ETP_HOVER_INFO_OFFSET]; |
917 | bool contact_valid, hover_event; | |
6696777c | 918 | |
090ad325 | 919 | hover_event = hover_info & 0x40; |
6696777c DL |
920 | for (i = 0; i < ETP_MAX_FINGERS; i++) { |
921 | contact_valid = tp_info & (1U << (3 + i)); | |
539c4b88 | 922 | elan_report_contact(data, i, contact_valid, finger_data); |
6696777c DL |
923 | |
924 | if (contact_valid) | |
925 | finger_data += ETP_FINGER_DATA_LEN; | |
926 | } | |
927 | ||
928 | input_report_key(input, BTN_LEFT, tp_info & 0x01); | |
99136881 | 929 | input_report_key(input, BTN_RIGHT, tp_info & 0x02); |
539c4b88 | 930 | input_report_abs(input, ABS_DISTANCE, hover_event != 0); |
6696777c DL |
931 | input_mt_report_pointer_emulation(input, true); |
932 | input_sync(input); | |
933 | } | |
934 | ||
935 | static irqreturn_t elan_isr(int irq, void *dev_id) | |
936 | { | |
937 | struct elan_tp_data *data = dev_id; | |
938 | struct device *dev = &data->client->dev; | |
939 | int error; | |
940 | u8 report[ETP_MAX_REPORT_LEN]; | |
941 | ||
942 | /* | |
943 | * When device is connected to i2c bus, when all IAP page writes | |
944 | * complete, the driver will receive interrupt and must read | |
945 | * 0000 to confirm that IAP is finished. | |
946 | */ | |
947 | if (data->in_fw_update) { | |
948 | complete(&data->fw_completion); | |
949 | goto out; | |
950 | } | |
951 | ||
952 | error = data->ops->get_report(data->client, report); | |
953 | if (error) | |
954 | goto out; | |
955 | ||
956 | if (report[ETP_REPORT_ID_OFFSET] != ETP_REPORT_ID) | |
957 | dev_err(dev, "invalid report id data (%x)\n", | |
958 | report[ETP_REPORT_ID_OFFSET]); | |
959 | else | |
960 | elan_report_absolute(data, report); | |
961 | ||
962 | out: | |
963 | return IRQ_HANDLED; | |
964 | } | |
965 | ||
966 | /* | |
967 | ****************************************************************** | |
968 | * Elan initialization functions | |
969 | ****************************************************************** | |
970 | */ | |
971 | static int elan_setup_input_device(struct elan_tp_data *data) | |
972 | { | |
973 | struct device *dev = &data->client->dev; | |
974 | struct input_dev *input; | |
975 | unsigned int max_width = max(data->width_x, data->width_y); | |
976 | unsigned int min_width = min(data->width_x, data->width_y); | |
977 | int error; | |
978 | ||
979 | input = devm_input_allocate_device(dev); | |
980 | if (!input) | |
981 | return -ENOMEM; | |
982 | ||
983 | input->name = "Elan Touchpad"; | |
984 | input->id.bustype = BUS_I2C; | |
3eab4588 CM |
985 | input->id.vendor = ELAN_VENDOR_ID; |
986 | input->id.product = data->product_id; | |
6696777c DL |
987 | input_set_drvdata(input, data); |
988 | ||
989 | error = input_mt_init_slots(input, ETP_MAX_FINGERS, | |
990 | INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED); | |
991 | if (error) { | |
992 | dev_err(dev, "failed to initialize MT slots: %d\n", error); | |
993 | return error; | |
994 | } | |
995 | ||
996 | __set_bit(EV_ABS, input->evbit); | |
997 | __set_bit(INPUT_PROP_POINTER, input->propbit); | |
99136881 KL |
998 | if (data->clickpad) |
999 | __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); | |
1000 | else | |
1001 | __set_bit(BTN_RIGHT, input->keybit); | |
6696777c DL |
1002 | __set_bit(BTN_LEFT, input->keybit); |
1003 | ||
1004 | /* Set up ST parameters */ | |
1005 | input_set_abs_params(input, ABS_X, 0, data->max_x, 0, 0); | |
1006 | input_set_abs_params(input, ABS_Y, 0, data->max_y, 0, 0); | |
1007 | input_abs_set_res(input, ABS_X, data->x_res); | |
1008 | input_abs_set_res(input, ABS_Y, data->y_res); | |
1009 | input_set_abs_params(input, ABS_PRESSURE, 0, ETP_MAX_PRESSURE, 0, 0); | |
1010 | input_set_abs_params(input, ABS_TOOL_WIDTH, 0, ETP_FINGER_WIDTH, 0, 0); | |
539c4b88 | 1011 | input_set_abs_params(input, ABS_DISTANCE, 0, 1, 0, 0); |
6696777c DL |
1012 | |
1013 | /* And MT parameters */ | |
1014 | input_set_abs_params(input, ABS_MT_POSITION_X, 0, data->max_x, 0, 0); | |
1015 | input_set_abs_params(input, ABS_MT_POSITION_Y, 0, data->max_y, 0, 0); | |
1016 | input_abs_set_res(input, ABS_MT_POSITION_X, data->x_res); | |
1017 | input_abs_set_res(input, ABS_MT_POSITION_Y, data->y_res); | |
1018 | input_set_abs_params(input, ABS_MT_PRESSURE, 0, | |
1019 | ETP_MAX_PRESSURE, 0, 0); | |
1020 | input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, | |
1021 | ETP_FINGER_WIDTH * max_width, 0, 0); | |
1022 | input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, | |
1023 | ETP_FINGER_WIDTH * min_width, 0, 0); | |
1024 | ||
1025 | data->input = input; | |
1026 | ||
1027 | return 0; | |
1028 | } | |
1029 | ||
1030 | static void elan_disable_regulator(void *_data) | |
1031 | { | |
1032 | struct elan_tp_data *data = _data; | |
1033 | ||
1034 | regulator_disable(data->vcc); | |
1035 | } | |
1036 | ||
1037 | static void elan_remove_sysfs_groups(void *_data) | |
1038 | { | |
1039 | struct elan_tp_data *data = _data; | |
1040 | ||
1041 | sysfs_remove_groups(&data->client->dev.kobj, elan_sysfs_groups); | |
1042 | } | |
1043 | ||
1044 | static int elan_probe(struct i2c_client *client, | |
1045 | const struct i2c_device_id *dev_id) | |
1046 | { | |
1047 | const struct elan_transport_ops *transport_ops; | |
1048 | struct device *dev = &client->dev; | |
1049 | struct elan_tp_data *data; | |
1050 | unsigned long irqflags; | |
1051 | int error; | |
1052 | ||
1053 | if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_I2C) && | |
1054 | i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { | |
1055 | transport_ops = &elan_i2c_ops; | |
1056 | } else if (IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_SMBUS) && | |
1057 | i2c_check_functionality(client->adapter, | |
1058 | I2C_FUNC_SMBUS_BYTE_DATA | | |
1059 | I2C_FUNC_SMBUS_BLOCK_DATA | | |
1060 | I2C_FUNC_SMBUS_I2C_BLOCK)) { | |
1061 | transport_ops = &elan_smbus_ops; | |
1062 | } else { | |
1063 | dev_err(dev, "not a supported I2C/SMBus adapter\n"); | |
1064 | return -EIO; | |
1065 | } | |
1066 | ||
ad56814f | 1067 | data = devm_kzalloc(dev, sizeof(struct elan_tp_data), GFP_KERNEL); |
6696777c DL |
1068 | if (!data) |
1069 | return -ENOMEM; | |
1070 | ||
1071 | i2c_set_clientdata(client, data); | |
1072 | ||
1073 | data->ops = transport_ops; | |
1074 | data->client = client; | |
1075 | init_completion(&data->fw_completion); | |
1076 | mutex_init(&data->sysfs_mutex); | |
1077 | ||
ad56814f | 1078 | data->vcc = devm_regulator_get(dev, "vcc"); |
6696777c DL |
1079 | if (IS_ERR(data->vcc)) { |
1080 | error = PTR_ERR(data->vcc); | |
1081 | if (error != -EPROBE_DEFER) | |
ad56814f | 1082 | dev_err(dev, "Failed to get 'vcc' regulator: %d\n", |
6696777c DL |
1083 | error); |
1084 | return error; | |
1085 | } | |
1086 | ||
1087 | error = regulator_enable(data->vcc); | |
1088 | if (error) { | |
ad56814f | 1089 | dev_err(dev, "Failed to enable regulator: %d\n", error); |
6696777c DL |
1090 | return error; |
1091 | } | |
1092 | ||
ad56814f | 1093 | error = devm_add_action(dev, elan_disable_regulator, data); |
6696777c DL |
1094 | if (error) { |
1095 | regulator_disable(data->vcc); | |
ad56814f | 1096 | dev_err(dev, "Failed to add disable regulator action: %d\n", |
6696777c DL |
1097 | error); |
1098 | return error; | |
1099 | } | |
1100 | ||
c5928551 DT |
1101 | /* Make sure there is something at this address */ |
1102 | error = i2c_smbus_read_byte(client); | |
1103 | if (error < 0) { | |
1104 | dev_dbg(&client->dev, "nothing at this address: %d\n", error); | |
1105 | return -ENXIO; | |
1106 | } | |
1107 | ||
6696777c DL |
1108 | /* Initialize the touchpad. */ |
1109 | error = elan_initialize(data); | |
1110 | if (error) | |
1111 | return error; | |
1112 | ||
1113 | error = elan_query_device_info(data); | |
1114 | if (error) | |
1115 | return error; | |
1116 | ||
1117 | error = elan_query_device_parameters(data); | |
1118 | if (error) | |
1119 | return error; | |
1120 | ||
ad56814f | 1121 | dev_info(dev, |
39a0d75a BT |
1122 | "Elan Touchpad: Module ID: 0x%04x, Firmware: 0x%04x, Sample: 0x%04x, IAP: 0x%04x\n", |
1123 | data->product_id, | |
1124 | data->fw_version, | |
1125 | data->sm_version, | |
1126 | data->iap_version); | |
1127 | ||
ad56814f | 1128 | dev_dbg(dev, |
39a0d75a | 1129 | "Elan Touchpad Extra Information:\n" |
6696777c DL |
1130 | " Max ABS X,Y: %d,%d\n" |
1131 | " Width X,Y: %d,%d\n" | |
a2eaf299 KL |
1132 | " Resolution X,Y: %d,%d (dots/mm)\n" |
1133 | " ic type: 0x%x\n" | |
1134 | " info pattern: 0x%x\n", | |
6696777c DL |
1135 | data->max_x, data->max_y, |
1136 | data->width_x, data->width_y, | |
a2eaf299 KL |
1137 | data->x_res, data->y_res, |
1138 | data->ic_type, data->pattern); | |
6696777c DL |
1139 | |
1140 | /* Set up input device properties based on queried parameters. */ | |
1141 | error = elan_setup_input_device(data); | |
1142 | if (error) | |
1143 | return error; | |
1144 | ||
1145 | /* | |
a4b0a58b DT |
1146 | * Platform code (ACPI, DTS) should normally set up interrupt |
1147 | * for us, but in case it did not let's fall back to using falling | |
1148 | * edge to be compatible with older Chromebooks. | |
6696777c | 1149 | */ |
a4b0a58b DT |
1150 | irqflags = irq_get_trigger_type(client->irq); |
1151 | if (!irqflags) | |
1152 | irqflags = IRQF_TRIGGER_FALLING; | |
6696777c | 1153 | |
ad56814f | 1154 | error = devm_request_threaded_irq(dev, client->irq, NULL, elan_isr, |
6696777c DL |
1155 | irqflags | IRQF_ONESHOT, |
1156 | client->name, data); | |
1157 | if (error) { | |
ad56814f | 1158 | dev_err(dev, "cannot register irq=%d\n", client->irq); |
6696777c DL |
1159 | return error; |
1160 | } | |
1161 | ||
ad56814f | 1162 | error = sysfs_create_groups(&dev->kobj, elan_sysfs_groups); |
6696777c | 1163 | if (error) { |
ad56814f | 1164 | dev_err(dev, "failed to create sysfs attributes: %d\n", error); |
6696777c DL |
1165 | return error; |
1166 | } | |
1167 | ||
ad56814f | 1168 | error = devm_add_action(dev, elan_remove_sysfs_groups, data); |
6696777c DL |
1169 | if (error) { |
1170 | elan_remove_sysfs_groups(data); | |
ad56814f | 1171 | dev_err(dev, "Failed to add sysfs cleanup action: %d\n", |
6696777c DL |
1172 | error); |
1173 | return error; | |
1174 | } | |
1175 | ||
1176 | error = input_register_device(data->input); | |
1177 | if (error) { | |
ad56814f | 1178 | dev_err(dev, "failed to register input device: %d\n", error); |
6696777c DL |
1179 | return error; |
1180 | } | |
1181 | ||
1182 | /* | |
1183 | * Systems using device tree should set up wakeup via DTS, | |
1184 | * the rest will configure device as wakeup source by default. | |
1185 | */ | |
ad56814f GR |
1186 | if (!dev->of_node) |
1187 | device_init_wakeup(dev, true); | |
6696777c DL |
1188 | |
1189 | return 0; | |
1190 | } | |
1191 | ||
1192 | static int __maybe_unused elan_suspend(struct device *dev) | |
1193 | { | |
1194 | struct i2c_client *client = to_i2c_client(dev); | |
1195 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
1196 | int ret; | |
1197 | ||
1198 | /* | |
1199 | * We are taking the mutex to make sure sysfs operations are | |
1200 | * complete before we attempt to bring the device into low[er] | |
1201 | * power mode. | |
1202 | */ | |
1203 | ret = mutex_lock_interruptible(&data->sysfs_mutex); | |
1204 | if (ret) | |
1205 | return ret; | |
1206 | ||
1207 | disable_irq(client->irq); | |
1208 | ||
1209 | if (device_may_wakeup(dev)) { | |
1210 | ret = elan_sleep(data); | |
1211 | /* Enable wake from IRQ */ | |
1212 | data->irq_wake = (enable_irq_wake(client->irq) == 0); | |
1213 | } else { | |
1214 | ret = elan_disable_power(data); | |
1215 | } | |
1216 | ||
1217 | mutex_unlock(&data->sysfs_mutex); | |
1218 | return ret; | |
1219 | } | |
1220 | ||
1221 | static int __maybe_unused elan_resume(struct device *dev) | |
1222 | { | |
1223 | struct i2c_client *client = to_i2c_client(dev); | |
1224 | struct elan_tp_data *data = i2c_get_clientdata(client); | |
1225 | int error; | |
1226 | ||
1227 | if (device_may_wakeup(dev) && data->irq_wake) { | |
1228 | disable_irq_wake(client->irq); | |
1229 | data->irq_wake = false; | |
1230 | } | |
1231 | ||
1232 | error = elan_enable_power(data); | |
b3beed7f | 1233 | if (error) { |
6696777c | 1234 | dev_err(dev, "power up when resuming failed: %d\n", error); |
b3beed7f DL |
1235 | goto err; |
1236 | } | |
6696777c DL |
1237 | |
1238 | error = elan_initialize(data); | |
1239 | if (error) | |
1240 | dev_err(dev, "initialize when resuming failed: %d\n", error); | |
1241 | ||
b3beed7f | 1242 | err: |
6696777c | 1243 | enable_irq(data->client->irq); |
b3beed7f | 1244 | return error; |
6696777c DL |
1245 | } |
1246 | ||
1247 | static SIMPLE_DEV_PM_OPS(elan_pm_ops, elan_suspend, elan_resume); | |
1248 | ||
1249 | static const struct i2c_device_id elan_id[] = { | |
1250 | { DRIVER_NAME, 0 }, | |
1251 | { }, | |
1252 | }; | |
1253 | MODULE_DEVICE_TABLE(i2c, elan_id); | |
1254 | ||
1255 | #ifdef CONFIG_ACPI | |
6696777c DL |
1256 | MODULE_DEVICE_TABLE(acpi, elan_acpi_id); |
1257 | #endif | |
1258 | ||
1259 | #ifdef CONFIG_OF | |
1260 | static const struct of_device_id elan_of_match[] = { | |
1261 | { .compatible = "elan,ekth3000" }, | |
1262 | { /* sentinel */ } | |
1263 | }; | |
1264 | MODULE_DEVICE_TABLE(of, elan_of_match); | |
1265 | #endif | |
1266 | ||
1267 | static struct i2c_driver elan_driver = { | |
1268 | .driver = { | |
1269 | .name = DRIVER_NAME, | |
6696777c DL |
1270 | .pm = &elan_pm_ops, |
1271 | .acpi_match_table = ACPI_PTR(elan_acpi_id), | |
1272 | .of_match_table = of_match_ptr(elan_of_match), | |
71d0f562 | 1273 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
6696777c DL |
1274 | }, |
1275 | .probe = elan_probe, | |
1276 | .id_table = elan_id, | |
1277 | }; | |
1278 | ||
1279 | module_i2c_driver(elan_driver); | |
1280 | ||
1281 | MODULE_AUTHOR("Duson Lin <dusonlin@emc.com.tw>"); | |
1282 | MODULE_DESCRIPTION("Elan I2C/SMBus Touchpad driver"); | |
1283 | MODULE_LICENSE("GPL"); | |
1284 | MODULE_VERSION(ELAN_DRIVER_VERSION); |