?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/i915: Move non-phys cursors into the GTT
[linux/fpc-iii.git] / drivers / input / mouse / elantech.c
blobb18862b2a70e142a1e73bc306244ed3e377b438a
1 /*
2 * Elantech Touchpad driver (v6)
3 *
4 * Copyright (C) 2007-2009 Arjan Opmeer <arjan@opmeer.net>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published
8 * by the Free Software Foundation.
9 *
10 * Trademarks are the property of their respective owners.
11 */
12
13 #define pr_fmt(fmt) KBUILD_BASENAME ": " fmt
14
15 #include <linux/delay.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
18 #include <linux/input.h>
19 #include <linux/serio.h>
20 #include <linux/libps2.h>
21 #include "psmouse.h"
22 #include "elantech.h"
23
24 #define elantech_debug(fmt, ...) \
25 do { \
26 if (etd->debug) \
27 printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); \
28 } while (0)
29
30 static bool force_elantech;
31 module_param_named(force_elantech, force_elantech, bool, 0644);
32 MODULE_PARM_DESC(force_elantech, "Force the Elantech PS/2 protocol extension to be used, 1 = enabled, 0 = disabled (default).");
33
34 /*
35 * Send a Synaptics style sliced query command
36 */
37 static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c,
38 unsigned char *param)
39 {
40 if (psmouse_sliced_command(psmouse, c) ||
41 ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
42 pr_err("synaptics_send_cmd query 0x%02x failed.\n", c);
43 return -1;
44 }
45
46 return 0;
47 }
48
49 /*
50 * A retrying version of ps2_command
51 */
52 static int elantech_ps2_command(struct psmouse *psmouse,
53 unsigned char *param, int command)
54 {
55 struct ps2dev *ps2dev = &psmouse->ps2dev;
56 struct elantech_data *etd = psmouse->private;
57 int rc;
58 int tries = ETP_PS2_COMMAND_TRIES;
59
60 do {
61 rc = ps2_command(ps2dev, param, command);
62 if (rc == 0)
63 break;
64 tries--;
65 elantech_debug("retrying ps2 command 0x%02x (%d).\n",
66 command, tries);
67 msleep(ETP_PS2_COMMAND_DELAY);
68 } while (tries > 0);
69
70 if (rc)
71 pr_err("ps2 command 0x%02x failed.\n", command);
72
73 return rc;
74 }
75
76 /*
77 * Send an Elantech style special command to read a value from a register
78 */
79 static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg,
80 unsigned char *val)
81 {
82 struct elantech_data *etd = psmouse->private;
83 unsigned char param[3];
84 int rc = 0;
85
86 if (reg < 0x10 || reg > 0x26)
87 return -1;
88
89 if (reg > 0x11 && reg < 0x20)
90 return -1;
91
92 switch (etd->hw_version) {
93 case 1:
94 if (psmouse_sliced_command(psmouse, ETP_REGISTER_READ) ||
95 psmouse_sliced_command(psmouse, reg) ||
96 ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
97 rc = -1;
98 }
99 break;
100
101 case 2:
102 if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
103 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READ) ||
104 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
105 elantech_ps2_command(psmouse, NULL, reg) ||
106 elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
107 rc = -1;
108 }
109 break;
110 }
111
112 if (rc)
113 pr_err("failed to read register 0x%02x.\n", reg);
114 else
115 *val = param[0];
116
117 return rc;
118 }
119
120 /*
121 * Send an Elantech style special command to write a register with a value
122 */
123 static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg,
124 unsigned char val)
125 {
126 struct elantech_data *etd = psmouse->private;
127 int rc = 0;
128
129 if (reg < 0x10 || reg > 0x26)
130 return -1;
131
132 if (reg > 0x11 && reg < 0x20)
133 return -1;
134
135 switch (etd->hw_version) {
136 case 1:
137 if (psmouse_sliced_command(psmouse, ETP_REGISTER_WRITE) ||
138 psmouse_sliced_command(psmouse, reg) ||
139 psmouse_sliced_command(psmouse, val) ||
140 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) {
141 rc = -1;
142 }
143 break;
144
145 case 2:
146 if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
147 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_WRITE) ||
148 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
149 elantech_ps2_command(psmouse, NULL, reg) ||
150 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
151 elantech_ps2_command(psmouse, NULL, val) ||
152 elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
153 rc = -1;
154 }
155 break;
156 }
157
158 if (rc)
159 pr_err("failed to write register 0x%02x with value 0x%02x.\n",
160 reg, val);
161
162 return rc;
163 }
164
165 /*
166 * Dump a complete mouse movement packet to the syslog
167 */
168 static void elantech_packet_dump(unsigned char *packet, int size)
169 {
170 int i;
171
172 printk(KERN_DEBUG pr_fmt("PS/2 packet ["));
173 for (i = 0; i < size; i++)
174 printk("%s0x%02x ", (i) ? ", " : " ", packet[i]);
175 printk("]\n");
176 }
177
178 /*
179 * Interpret complete data packets and report absolute mode input events for
180 * hardware version 1. (4 byte packets)
181 */
182 static void elantech_report_absolute_v1(struct psmouse *psmouse)
183 {
184 struct input_dev *dev = psmouse->dev;
185 struct elantech_data *etd = psmouse->private;
186 unsigned char *packet = psmouse->packet;
187 int fingers;
188 static int old_fingers;
189
190 if (etd->fw_version < 0x020000) {
191 /*
192 * byte 0: D U p1 p2 1 p3 R L
193 * byte 1: f 0 th tw x9 x8 y9 y8
194 */
195 fingers = ((packet[1] & 0x80) >> 7) +
196 ((packet[1] & 0x30) >> 4);
197 } else {
198 /*
199 * byte 0: n1 n0 p2 p1 1 p3 R L
200 * byte 1: 0 0 0 0 x9 x8 y9 y8
201 */
202 fingers = (packet[0] & 0xc0) >> 6;
203 }
204
205 if (etd->jumpy_cursor) {
206 /* Discard packets that are likely to have bogus coordinates */
207 if (fingers > old_fingers) {
208 elantech_debug("discarding packet\n");
209 goto discard_packet_v1;
210 }
211 }
212
213 input_report_key(dev, BTN_TOUCH, fingers != 0);
214
215 /*
216 * byte 2: x7 x6 x5 x4 x3 x2 x1 x0
217 * byte 3: y7 y6 y5 y4 y3 y2 y1 y0
218 */
219 if (fingers) {
220 input_report_abs(dev, ABS_X,
221 ((packet[1] & 0x0c) << 6) | packet[2]);
222 input_report_abs(dev, ABS_Y,
223 ETP_YMAX_V1 - (((packet[1] & 0x03) << 8) | packet[3]));
224 }
225
226 input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
227 input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
228 input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
229 input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
230 input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
231
232 if (etd->fw_version < 0x020000 &&
233 (etd->capabilities & ETP_CAP_HAS_ROCKER)) {
234 /* rocker up */
235 input_report_key(dev, BTN_FORWARD, packet[0] & 0x40);
236 /* rocker down */
237 input_report_key(dev, BTN_BACK, packet[0] & 0x80);
238 }
239
240 input_sync(dev);
241
242 discard_packet_v1:
243 old_fingers = fingers;
244 }
245
246 /*
247 * Interpret complete data packets and report absolute mode input events for
248 * hardware version 2. (6 byte packets)
249 */
250 static void elantech_report_absolute_v2(struct psmouse *psmouse)
251 {
252 struct input_dev *dev = psmouse->dev;
253 unsigned char *packet = psmouse->packet;
254 int fingers, x1, y1, x2, y2;
255
256 /* byte 0: n1 n0 . . . . R L */
257 fingers = (packet[0] & 0xc0) >> 6;
258 input_report_key(dev, BTN_TOUCH, fingers != 0);
259
260 switch (fingers) {
261 case 1:
262 /*
263 * byte 1: . . . . . x10 x9 x8
264 * byte 2: x7 x6 x5 x4 x4 x2 x1 x0
265 */
266 input_report_abs(dev, ABS_X,
267 ((packet[1] & 0x07) << 8) | packet[2]);
268 /*
269 * byte 4: . . . . . . y9 y8
270 * byte 5: y7 y6 y5 y4 y3 y2 y1 y0
271 */
272 input_report_abs(dev, ABS_Y,
273 ETP_YMAX_V2 - (((packet[4] & 0x03) << 8) | packet[5]));
274 break;
275
276 case 2:
277 /*
278 * The coordinate of each finger is reported separately
279 * with a lower resolution for two finger touches:
280 * byte 0: . . ay8 ax8 . . . .
281 * byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0
282 */
283 x1 = ((packet[0] & 0x10) << 4) | packet[1];
284 /* byte 2: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 */
285 y1 = ETP_2FT_YMAX - (((packet[0] & 0x20) << 3) | packet[2]);
286 /*
287 * byte 3: . . by8 bx8 . . . .
288 * byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0
289 */
290 x2 = ((packet[3] & 0x10) << 4) | packet[4];
291 /* byte 5: by7 by8 by5 by4 by3 by2 by1 by0 */
292 y2 = ETP_2FT_YMAX - (((packet[3] & 0x20) << 3) | packet[5]);
293 /*
294 * For compatibility with the X Synaptics driver scale up
295 * one coordinate and report as ordinary mouse movent
296 */
297 input_report_abs(dev, ABS_X, x1 << 2);
298 input_report_abs(dev, ABS_Y, y1 << 2);
299 /*
300 * For compatibility with the proprietary X Elantech driver
301 * report both coordinates as hat coordinates
302 */
303 input_report_abs(dev, ABS_HAT0X, x1);
304 input_report_abs(dev, ABS_HAT0Y, y1);
305 input_report_abs(dev, ABS_HAT1X, x2);
306 input_report_abs(dev, ABS_HAT1Y, y2);
307 break;
308 }
309
310 input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
311 input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
312 input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
313 input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
314 input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
315
316 input_sync(dev);
317 }
318
319 static int elantech_check_parity_v1(struct psmouse *psmouse)
320 {
321 struct elantech_data *etd = psmouse->private;
322 unsigned char *packet = psmouse->packet;
323 unsigned char p1, p2, p3;
324
325 /* Parity bits are placed differently */
326 if (etd->fw_version < 0x020000) {
327 /* byte 0: D U p1 p2 1 p3 R L */
328 p1 = (packet[0] & 0x20) >> 5;
329 p2 = (packet[0] & 0x10) >> 4;
330 } else {
331 /* byte 0: n1 n0 p2 p1 1 p3 R L */
332 p1 = (packet[0] & 0x10) >> 4;
333 p2 = (packet[0] & 0x20) >> 5;
334 }
335
336 p3 = (packet[0] & 0x04) >> 2;
337
338 return etd->parity[packet[1]] == p1 &&
339 etd->parity[packet[2]] == p2 &&
340 etd->parity[packet[3]] == p3;
341 }
342
343 /*
344 * Process byte stream from mouse and handle complete packets
345 */
346 static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse)
347 {
348 struct elantech_data *etd = psmouse->private;
349
350 if (psmouse->pktcnt < psmouse->pktsize)
351 return PSMOUSE_GOOD_DATA;
352
353 if (etd->debug > 1)
354 elantech_packet_dump(psmouse->packet, psmouse->pktsize);
355
356 switch (etd->hw_version) {
357 case 1:
358 if (etd->paritycheck && !elantech_check_parity_v1(psmouse))
359 return PSMOUSE_BAD_DATA;
360
361 elantech_report_absolute_v1(psmouse);
362 break;
363
364 case 2:
365 /* We don't know how to check parity in protocol v2 */
366 elantech_report_absolute_v2(psmouse);
367 break;
368 }
369
370 return PSMOUSE_FULL_PACKET;
371 }
372
373 /*
374 * Put the touchpad into absolute mode
375 */
376 static int elantech_set_absolute_mode(struct psmouse *psmouse)
377 {
378 struct elantech_data *etd = psmouse->private;
379 unsigned char val;
380 int tries = ETP_READ_BACK_TRIES;
381 int rc = 0;
382
383 switch (etd->hw_version) {
384 case 1:
385 etd->reg_10 = 0x16;
386 etd->reg_11 = 0x8f;
387 if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
388 elantech_write_reg(psmouse, 0x11, etd->reg_11)) {
389 rc = -1;
390 }
391 break;
392
393 case 2:
394 /* Windows driver values */
395 etd->reg_10 = 0x54;
396 etd->reg_11 = 0x88; /* 0x8a */
397 etd->reg_21 = 0x60; /* 0x00 */
398 if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
399 elantech_write_reg(psmouse, 0x11, etd->reg_11) ||
400 elantech_write_reg(psmouse, 0x21, etd->reg_21)) {
401 rc = -1;
402 break;
403 }
404 }
405
406 if (rc == 0) {
407 /*
408 * Read back reg 0x10. For hardware version 1 we must make
409 * sure the absolute mode bit is set. For hardware version 2
410 * the touchpad is probably initalising and not ready until
411 * we read back the value we just wrote.
412 */
413 do {
414 rc = elantech_read_reg(psmouse, 0x10, &val);
415 if (rc == 0)
416 break;
417 tries--;
418 elantech_debug("retrying read (%d).\n", tries);
419 msleep(ETP_READ_BACK_DELAY);
420 } while (tries > 0);
421
422 if (rc) {
423 pr_err("failed to read back register 0x10.\n");
424 } else if (etd->hw_version == 1 &&
425 !(val & ETP_R10_ABSOLUTE_MODE)) {
426 pr_err("touchpad refuses to switch to absolute mode.\n");
427 rc = -1;
428 }
429 }
430
431 if (rc)
432 pr_err("failed to initialise registers.\n");
433
434 return rc;
435 }
436
437 /*
438 * Set the appropriate event bits for the input subsystem
439 */
440 static void elantech_set_input_params(struct psmouse *psmouse)
441 {
442 struct input_dev *dev = psmouse->dev;
443 struct elantech_data *etd = psmouse->private;
444
445 __set_bit(EV_KEY, dev->evbit);
446 __set_bit(EV_ABS, dev->evbit);
447 __clear_bit(EV_REL, dev->evbit);
448
449 __set_bit(BTN_LEFT, dev->keybit);
450 __set_bit(BTN_RIGHT, dev->keybit);
451
452 __set_bit(BTN_TOUCH, dev->keybit);
453 __set_bit(BTN_TOOL_FINGER, dev->keybit);
454 __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
455 __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
456
457 switch (etd->hw_version) {
458 case 1:
459 /* Rocker button */
460 if (etd->fw_version < 0x020000 &&
461 (etd->capabilities & ETP_CAP_HAS_ROCKER)) {
462 __set_bit(BTN_FORWARD, dev->keybit);
463 __set_bit(BTN_BACK, dev->keybit);
464 }
465 input_set_abs_params(dev, ABS_X, ETP_XMIN_V1, ETP_XMAX_V1, 0, 0);
466 input_set_abs_params(dev, ABS_Y, ETP_YMIN_V1, ETP_YMAX_V1, 0, 0);
467 break;
468
469 case 2:
470 input_set_abs_params(dev, ABS_X, ETP_XMIN_V2, ETP_XMAX_V2, 0, 0);
471 input_set_abs_params(dev, ABS_Y, ETP_YMIN_V2, ETP_YMAX_V2, 0, 0);
472 input_set_abs_params(dev, ABS_HAT0X, ETP_2FT_XMIN, ETP_2FT_XMAX, 0, 0);
473 input_set_abs_params(dev, ABS_HAT0Y, ETP_2FT_YMIN, ETP_2FT_YMAX, 0, 0);
474 input_set_abs_params(dev, ABS_HAT1X, ETP_2FT_XMIN, ETP_2FT_XMAX, 0, 0);
475 input_set_abs_params(dev, ABS_HAT1Y, ETP_2FT_YMIN, ETP_2FT_YMAX, 0, 0);
476 break;
477 }
478 }
479
480 struct elantech_attr_data {
481 size_t field_offset;
482 unsigned char reg;
483 };
484
485 /*
486 * Display a register value by reading a sysfs entry
487 */
488 static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data,
489 char *buf)
490 {
491 struct elantech_data *etd = psmouse->private;
492 struct elantech_attr_data *attr = data;
493 unsigned char *reg = (unsigned char *) etd + attr->field_offset;
494 int rc = 0;
495
496 if (attr->reg)
497 rc = elantech_read_reg(psmouse, attr->reg, reg);
498
499 return sprintf(buf, "0x%02x\n", (attr->reg && rc) ? -1 : *reg);
500 }
501
502 /*
503 * Write a register value by writing a sysfs entry
504 */
505 static ssize_t elantech_set_int_attr(struct psmouse *psmouse,
506 void *data, const char *buf, size_t count)
507 {
508 struct elantech_data *etd = psmouse->private;
509 struct elantech_attr_data *attr = data;
510 unsigned char *reg = (unsigned char *) etd + attr->field_offset;
511 unsigned long value;
512 int err;
513
514 err = strict_strtoul(buf, 16, &value);
515 if (err)
516 return err;
517
518 if (value > 0xff)
519 return -EINVAL;
520
521 /* Do we need to preserve some bits for version 2 hardware too? */
522 if (etd->hw_version == 1) {
523 if (attr->reg == 0x10)
524 /* Force absolute mode always on */
525 value |= ETP_R10_ABSOLUTE_MODE;
526 else if (attr->reg == 0x11)
527 /* Force 4 byte mode always on */
528 value |= ETP_R11_4_BYTE_MODE;
529 }
530
531 if (!attr->reg || elantech_write_reg(psmouse, attr->reg, value) == 0)
532 *reg = value;
533
534 return count;
535 }
536
537 #define ELANTECH_INT_ATTR(_name, _register) \
538 static struct elantech_attr_data elantech_attr_##_name = { \
539 .field_offset = offsetof(struct elantech_data, _name), \
540 .reg = _register, \
541 }; \
542 PSMOUSE_DEFINE_ATTR(_name, S_IWUSR | S_IRUGO, \
543 &elantech_attr_##_name, \
544 elantech_show_int_attr, \
545 elantech_set_int_attr)
546
547 ELANTECH_INT_ATTR(reg_10, 0x10);
548 ELANTECH_INT_ATTR(reg_11, 0x11);
549 ELANTECH_INT_ATTR(reg_20, 0x20);
550 ELANTECH_INT_ATTR(reg_21, 0x21);
551 ELANTECH_INT_ATTR(reg_22, 0x22);
552 ELANTECH_INT_ATTR(reg_23, 0x23);
553 ELANTECH_INT_ATTR(reg_24, 0x24);
554 ELANTECH_INT_ATTR(reg_25, 0x25);
555 ELANTECH_INT_ATTR(reg_26, 0x26);
556 ELANTECH_INT_ATTR(debug, 0);
557 ELANTECH_INT_ATTR(paritycheck, 0);
558
559 static struct attribute *elantech_attrs[] = {
560 &psmouse_attr_reg_10.dattr.attr,
561 &psmouse_attr_reg_11.dattr.attr,
562 &psmouse_attr_reg_20.dattr.attr,
563 &psmouse_attr_reg_21.dattr.attr,
564 &psmouse_attr_reg_22.dattr.attr,
565 &psmouse_attr_reg_23.dattr.attr,
566 &psmouse_attr_reg_24.dattr.attr,
567 &psmouse_attr_reg_25.dattr.attr,
568 &psmouse_attr_reg_26.dattr.attr,
569 &psmouse_attr_debug.dattr.attr,
570 &psmouse_attr_paritycheck.dattr.attr,
571 NULL
572 };
573
574 static struct attribute_group elantech_attr_group = {
575 .attrs = elantech_attrs,
576 };
577
578 static bool elantech_is_signature_valid(const unsigned char *param)
579 {
580 static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10 };
581 int i;
582
583 if (param[0] == 0)
584 return false;
585
586 if (param[1] == 0)
587 return true;
588
589 for (i = 0; i < ARRAY_SIZE(rates); i++)
590 if (param[2] == rates[i])
591 return false;
592
593 return true;
594 }
595
596 /*
597 * Use magic knock to detect Elantech touchpad
598 */
599 int elantech_detect(struct psmouse *psmouse, bool set_properties)
600 {
601 struct ps2dev *ps2dev = &psmouse->ps2dev;
602 unsigned char param[3];
603
604 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
605
606 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
607 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
608 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
609 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
610 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
611 pr_debug("sending Elantech magic knock failed.\n");
612 return -1;
613 }
614
615 /*
616 * Report this in case there are Elantech models that use a different
617 * set of magic numbers
618 */
619 if (param[0] != 0x3c || param[1] != 0x03 || param[2] != 0xc8) {
620 pr_debug("unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
621 param[0], param[1], param[2]);
622 return -1;
623 }
624
625 /*
626 * Query touchpad's firmware version and see if it reports known
627 * value to avoid mis-detection. Logitech mice are known to respond
628 * to Elantech magic knock and there might be more.
629 */
630 if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
631 pr_debug("failed to query firmware version.\n");
632 return -1;
633 }
634
635 pr_debug("Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
636 param[0], param[1], param[2]);
637
638 if (!elantech_is_signature_valid(param)) {
639 if (!force_elantech) {
640 pr_debug("Probably not a real Elantech touchpad. Aborting.\n");
641 return -1;
642 }
643
644 pr_debug("Probably not a real Elantech touchpad. Enabling anyway due to force_elantech.\n");
645 }
646
647 if (set_properties) {
648 psmouse->vendor = "Elantech";
649 psmouse->name = "Touchpad";
650 }
651
652 return 0;
653 }
654
655 /*
656 * Clean up sysfs entries when disconnecting
657 */
658 static void elantech_disconnect(struct psmouse *psmouse)
659 {
660 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
661 &elantech_attr_group);
662 kfree(psmouse->private);
663 psmouse->private = NULL;
664 }
665
666 /*
667 * Put the touchpad back into absolute mode when reconnecting
668 */
669 static int elantech_reconnect(struct psmouse *psmouse)
670 {
671 if (elantech_detect(psmouse, 0))
672 return -1;
673
674 if (elantech_set_absolute_mode(psmouse)) {
675 pr_err("failed to put touchpad back into absolute mode.\n");
676 return -1;
677 }
678
679 return 0;
680 }
681
682 /*
683 * Initialize the touchpad and create sysfs entries
684 */
685 int elantech_init(struct psmouse *psmouse)
686 {
687 struct elantech_data *etd;
688 int i, error;
689 unsigned char param[3];
690
691 psmouse->private = etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL);
692 if (!etd)
693 return -1;
694
695 etd->parity[0] = 1;
696 for (i = 1; i < 256; i++)
697 etd->parity[i] = etd->parity[i & (i - 1)] ^ 1;
698
699 /*
700 * Do the version query again so we can store the result
701 */
702 if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
703 pr_err("failed to query firmware version.\n");
704 goto init_fail;
705 }
706
707 etd->fw_version = (param[0] << 16) | (param[1] << 8) | param[2];
708
709 /*
710 * Assume every version greater than this is new EeePC style
711 * hardware with 6 byte packets
712 */
713 if (etd->fw_version >= 0x020030) {
714 etd->hw_version = 2;
715 /* For now show extra debug information */
716 etd->debug = 1;
717 /* Don't know how to do parity checking for version 2 */
718 etd->paritycheck = 0;
719 } else {
720 etd->hw_version = 1;
721 etd->paritycheck = 1;
722 }
723
724 pr_info("assuming hardware version %d, firmware version %d.%d.%d\n",
725 etd->hw_version, param[0], param[1], param[2]);
726
727 if (synaptics_send_cmd(psmouse, ETP_CAPABILITIES_QUERY, param)) {
728 pr_err("failed to query capabilities.\n");
729 goto init_fail;
730 }
731 pr_info("Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
732 param[0], param[1], param[2]);
733 etd->capabilities = param[0];
734
735 /*
736 * This firmware seems to suffer from misreporting coordinates when
737 * a touch action starts causing the mouse cursor or scrolled page
738 * to jump. Enable a workaround.
739 */
740 if (etd->fw_version == 0x020022) {
741 pr_info("firmware version 2.0.34 detected, enabling jumpy cursor workaround\n");
742 etd->jumpy_cursor = 1;
743 }
744
745 if (elantech_set_absolute_mode(psmouse)) {
746 pr_err("failed to put touchpad into absolute mode.\n");
747 goto init_fail;
748 }
749
750 elantech_set_input_params(psmouse);
751
752 error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
753 &elantech_attr_group);
754 if (error) {
755 pr_err("failed to create sysfs attributes, error: %d.\n", error);
756 goto init_fail;
757 }
758
759 psmouse->protocol_handler = elantech_process_byte;
760 psmouse->disconnect = elantech_disconnect;
761 psmouse->reconnect = elantech_reconnect;
762 psmouse->pktsize = etd->hw_version == 2 ? 6 : 4;
763
764 return 0;
765
766 init_fail:
767 kfree(etd);
768 return -1;
769 }
Linux with added FPC-III support