2 * Elantech Touchpad driver (v5)
4 * Copyright (C) 2007-2008 Arjan Opmeer <arjan@opmeer.net>
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.
10 * Trademarks are the property of their respective owners.
13 #include <linux/delay.h>
14 #include <linux/module.h>
15 #include <linux/input.h>
16 #include <linux/serio.h>
17 #include <linux/libps2.h>
21 #define elantech_debug(format, arg...) \
24 printk(KERN_DEBUG format, ##arg); \
28 * Send a Synaptics style sliced query command
30 static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c,
33 if (psmouse_sliced_command(psmouse, c) ||
34 ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
35 pr_err("elantech.c: synaptics_send_cmd query 0x%02x failed.\n", c);
43 * A retrying version of ps2_command
45 static int elantech_ps2_command(struct psmouse *psmouse,
46 unsigned char *param, int command)
48 struct ps2dev *ps2dev = &psmouse->ps2dev;
49 struct elantech_data *etd = psmouse->private;
51 int tries = ETP_PS2_COMMAND_TRIES;
54 rc = ps2_command(ps2dev, param, command);
58 elantech_debug("elantech.c: retrying ps2 command 0x%02x (%d).\n",
60 msleep(ETP_PS2_COMMAND_DELAY);
64 pr_err("elantech.c: ps2 command 0x%02x failed.\n", command);
70 * Send an Elantech style special command to read a value from a register
72 static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg,
75 struct elantech_data *etd = psmouse->private;
76 unsigned char param[3];
79 if (reg < 0x10 || reg > 0x26)
82 if (reg > 0x11 && reg < 0x20)
85 switch (etd->hw_version) {
87 if (psmouse_sliced_command(psmouse, ETP_REGISTER_READ) ||
88 psmouse_sliced_command(psmouse, reg) ||
89 ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
95 if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
96 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READ) ||
97 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
98 elantech_ps2_command(psmouse, NULL, reg) ||
99 elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
106 pr_err("elantech.c: failed to read register 0x%02x.\n", reg);
114 * Send an Elantech style special command to write a register with a value
116 static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg,
119 struct elantech_data *etd = psmouse->private;
122 if (reg < 0x10 || reg > 0x26)
125 if (reg > 0x11 && reg < 0x20)
128 switch (etd->hw_version) {
130 if (psmouse_sliced_command(psmouse, ETP_REGISTER_WRITE) ||
131 psmouse_sliced_command(psmouse, reg) ||
132 psmouse_sliced_command(psmouse, val) ||
133 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) {
139 if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
140 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_WRITE) ||
141 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
142 elantech_ps2_command(psmouse, NULL, reg) ||
143 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
144 elantech_ps2_command(psmouse, NULL, val) ||
145 elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
152 pr_err("elantech.c: failed to write register 0x%02x with value 0x%02x.\n",
159 * Dump a complete mouse movement packet to the syslog
161 static void elantech_packet_dump(unsigned char *packet, int size)
165 printk(KERN_DEBUG "elantech.c: PS/2 packet [");
166 for (i = 0; i < size; i++)
167 printk("%s0x%02x ", (i) ? ", " : " ", packet[i]);
172 * Interpret complete data packets and report absolute mode input events for
173 * hardware version 1. (4 byte packets)
175 static void elantech_report_absolute_v1(struct psmouse *psmouse)
177 struct input_dev *dev = psmouse->dev;
178 struct elantech_data *etd = psmouse->private;
179 unsigned char *packet = psmouse->packet;
182 if (etd->fw_version_maj == 0x01) {
183 /* byte 0: D U p1 p2 1 p3 R L
184 byte 1: f 0 th tw x9 x8 y9 y8 */
185 fingers = ((packet[1] & 0x80) >> 7) +
186 ((packet[1] & 0x30) >> 4);
188 /* byte 0: n1 n0 p2 p1 1 p3 R L
189 byte 1: 0 0 0 0 x9 x8 y9 y8 */
190 fingers = (packet[0] & 0xc0) >> 6;
193 input_report_key(dev, BTN_TOUCH, fingers != 0);
195 /* byte 2: x7 x6 x5 x4 x3 x2 x1 x0
196 byte 3: y7 y6 y5 y4 y3 y2 y1 y0 */
198 input_report_abs(dev, ABS_X,
199 ((packet[1] & 0x0c) << 6) | packet[2]);
200 input_report_abs(dev, ABS_Y, ETP_YMAX_V1 -
201 (((packet[1] & 0x03) << 8) | packet[3]));
204 input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
205 input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
206 input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
207 input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
208 input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
210 if ((etd->fw_version_maj == 0x01) &&
211 (etd->capabilities & ETP_CAP_HAS_ROCKER)) {
213 input_report_key(dev, BTN_FORWARD, packet[0] & 0x40);
215 input_report_key(dev, BTN_BACK, packet[0] & 0x80);
222 * Interpret complete data packets and report absolute mode input events for
223 * hardware version 2. (6 byte packets)
225 static void elantech_report_absolute_v2(struct psmouse *psmouse)
227 struct input_dev *dev = psmouse->dev;
228 unsigned char *packet = psmouse->packet;
229 int fingers, x1, y1, x2, y2;
231 /* byte 0: n1 n0 . . . . R L */
232 fingers = (packet[0] & 0xc0) >> 6;
233 input_report_key(dev, BTN_TOUCH, fingers != 0);
237 /* byte 1: x15 x14 x13 x12 x11 x10 x9 x8
238 byte 2: x7 x6 x5 x4 x4 x2 x1 x0 */
239 input_report_abs(dev, ABS_X, (packet[1] << 8) | packet[2]);
240 /* byte 4: y15 y14 y13 y12 y11 y10 y8 y8
241 byte 5: y7 y6 y5 y4 y3 y2 y1 y0 */
242 input_report_abs(dev, ABS_Y, ETP_YMAX_V2 -
243 ((packet[4] << 8) | packet[5]));
247 /* The coordinate of each finger is reported separately with
248 a lower resolution for two finger touches */
249 /* byte 0: . . ay8 ax8 . . . .
250 byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0 */
251 x1 = ((packet[0] & 0x10) << 4) | packet[1];
252 /* byte 2: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 */
253 y1 = ETP_2FT_YMAX - (((packet[0] & 0x20) << 3) | packet[2]);
254 /* byte 3: . . by8 bx8 . . . .
255 byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0 */
256 x2 = ((packet[3] & 0x10) << 4) | packet[4];
257 /* byte 5: by7 by8 by5 by4 by3 by2 by1 by0 */
258 y2 = ETP_2FT_YMAX - (((packet[3] & 0x20) << 3) | packet[5]);
259 /* For compatibility with the X Synaptics driver scale up one
260 coordinate and report as ordinary mouse movent */
261 input_report_abs(dev, ABS_X, x1 << 2);
262 input_report_abs(dev, ABS_Y, y1 << 2);
263 /* For compatibility with the proprietary X Elantech driver
264 report both coordinates as hat coordinates */
265 input_report_abs(dev, ABS_HAT0X, x1);
266 input_report_abs(dev, ABS_HAT0Y, y1);
267 input_report_abs(dev, ABS_HAT1X, x2);
268 input_report_abs(dev, ABS_HAT1Y, y2);
272 input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
273 input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
274 input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
275 input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
276 input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
281 static int elantech_check_parity_v1(struct psmouse *psmouse)
283 struct elantech_data *etd = psmouse->private;
284 unsigned char *packet = psmouse->packet;
285 unsigned char p1, p2, p3;
287 /* Parity bits are placed differently */
288 if (etd->fw_version_maj == 0x01) {
289 /* byte 0: D U p1 p2 1 p3 R L */
290 p1 = (packet[0] & 0x20) >> 5;
291 p2 = (packet[0] & 0x10) >> 4;
293 /* byte 0: n1 n0 p2 p1 1 p3 R L */
294 p1 = (packet[0] & 0x10) >> 4;
295 p2 = (packet[0] & 0x20) >> 5;
298 p3 = (packet[0] & 0x04) >> 2;
300 return etd->parity[packet[1]] == p1 &&
301 etd->parity[packet[2]] == p2 &&
302 etd->parity[packet[3]] == p3;
306 * Process byte stream from mouse and handle complete packets
308 static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse)
310 struct elantech_data *etd = psmouse->private;
312 if (psmouse->pktcnt < psmouse->pktsize)
313 return PSMOUSE_GOOD_DATA;
316 elantech_packet_dump(psmouse->packet, psmouse->pktsize);
318 switch (etd->hw_version) {
320 if (etd->paritycheck && !elantech_check_parity_v1(psmouse))
321 return PSMOUSE_BAD_DATA;
323 elantech_report_absolute_v1(psmouse);
327 /* We don't know how to check parity in protocol v2 */
328 elantech_report_absolute_v2(psmouse);
332 return PSMOUSE_FULL_PACKET;
336 * Put the touchpad into absolute mode
338 static int elantech_set_absolute_mode(struct psmouse *psmouse)
340 struct elantech_data *etd = psmouse->private;
342 int tries = ETP_READ_BACK_TRIES;
345 switch (etd->hw_version) {
349 if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
350 elantech_write_reg(psmouse, 0x11, etd->reg_11)) {
356 /* Windows driver values */
358 etd->reg_11 = 0x88; /* 0x8a */
359 etd->reg_21 = 0x60; /* 0x00 */
360 if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
361 elantech_write_reg(psmouse, 0x11, etd->reg_11) ||
362 elantech_write_reg(psmouse, 0x21, etd->reg_21)) {
367 * Read back reg 0x10. The touchpad is probably initalising
368 * and not ready until we read back the value we just wrote.
371 rc = elantech_read_reg(psmouse, 0x10, &val);
375 elantech_debug("elantech.c: retrying read (%d).\n",
377 msleep(ETP_READ_BACK_DELAY);
380 pr_err("elantech.c: failed to read back register 0x10.\n");
385 pr_err("elantech.c: failed to initialise registers.\n");
391 * Set the appropriate event bits for the input subsystem
393 static void elantech_set_input_params(struct psmouse *psmouse)
395 struct input_dev *dev = psmouse->dev;
396 struct elantech_data *etd = psmouse->private;
398 __set_bit(EV_KEY, dev->evbit);
399 __set_bit(EV_ABS, dev->evbit);
401 __set_bit(BTN_LEFT, dev->keybit);
402 __set_bit(BTN_RIGHT, dev->keybit);
404 __set_bit(BTN_TOUCH, dev->keybit);
405 __set_bit(BTN_TOOL_FINGER, dev->keybit);
406 __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
407 __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
409 switch (etd->hw_version) {
412 if ((etd->fw_version_maj == 0x01) &&
413 (etd->capabilities & ETP_CAP_HAS_ROCKER)) {
414 __set_bit(BTN_FORWARD, dev->keybit);
415 __set_bit(BTN_BACK, dev->keybit);
417 input_set_abs_params(dev, ABS_X, ETP_XMIN_V1, ETP_XMAX_V1, 0, 0);
418 input_set_abs_params(dev, ABS_Y, ETP_YMIN_V1, ETP_YMAX_V1, 0, 0);
422 input_set_abs_params(dev, ABS_X, ETP_XMIN_V2, ETP_XMAX_V2, 0, 0);
423 input_set_abs_params(dev, ABS_Y, ETP_YMIN_V2, ETP_YMAX_V2, 0, 0);
424 input_set_abs_params(dev, ABS_HAT0X, ETP_2FT_XMIN, ETP_2FT_XMAX, 0, 0);
425 input_set_abs_params(dev, ABS_HAT0Y, ETP_2FT_YMIN, ETP_2FT_YMAX, 0, 0);
426 input_set_abs_params(dev, ABS_HAT1X, ETP_2FT_XMIN, ETP_2FT_XMAX, 0, 0);
427 input_set_abs_params(dev, ABS_HAT1Y, ETP_2FT_YMIN, ETP_2FT_YMAX, 0, 0);
432 struct elantech_attr_data {
438 * Display a register value by reading a sysfs entry
440 static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data,
443 struct elantech_data *etd = psmouse->private;
444 struct elantech_attr_data *attr = data;
445 unsigned char *reg = (unsigned char *) etd + attr->field_offset;
449 rc = elantech_read_reg(psmouse, attr->reg, reg);
451 return sprintf(buf, "0x%02x\n", (attr->reg && rc) ? -1 : *reg);
455 * Write a register value by writing a sysfs entry
457 static ssize_t elantech_set_int_attr(struct psmouse *psmouse,
458 void *data, const char *buf, size_t count)
460 struct elantech_data *etd = psmouse->private;
461 struct elantech_attr_data *attr = data;
462 unsigned char *reg = (unsigned char *) etd + attr->field_offset;
466 err = strict_strtoul(buf, 16, &value);
473 /* Do we need to preserve some bits for version 2 hardware too? */
474 if (etd->hw_version == 1) {
475 if (attr->reg == 0x10)
476 /* Force absolute mode always on */
477 value |= ETP_R10_ABSOLUTE_MODE;
478 else if (attr->reg == 0x11)
479 /* Force 4 byte mode always on */
480 value |= ETP_R11_4_BYTE_MODE;
483 if (!attr->reg || elantech_write_reg(psmouse, attr->reg, value) == 0)
489 #define ELANTECH_INT_ATTR(_name, _register) \
490 static struct elantech_attr_data elantech_attr_##_name = { \
491 .field_offset = offsetof(struct elantech_data, _name), \
494 PSMOUSE_DEFINE_ATTR(_name, S_IWUSR | S_IRUGO, \
495 &elantech_attr_##_name, \
496 elantech_show_int_attr, \
497 elantech_set_int_attr)
499 ELANTECH_INT_ATTR(reg_10, 0x10);
500 ELANTECH_INT_ATTR(reg_11, 0x11);
501 ELANTECH_INT_ATTR(reg_20, 0x20);
502 ELANTECH_INT_ATTR(reg_21, 0x21);
503 ELANTECH_INT_ATTR(reg_22, 0x22);
504 ELANTECH_INT_ATTR(reg_23, 0x23);
505 ELANTECH_INT_ATTR(reg_24, 0x24);
506 ELANTECH_INT_ATTR(reg_25, 0x25);
507 ELANTECH_INT_ATTR(reg_26, 0x26);
508 ELANTECH_INT_ATTR(debug, 0);
509 ELANTECH_INT_ATTR(paritycheck, 0);
511 static struct attribute *elantech_attrs[] = {
512 &psmouse_attr_reg_10.dattr.attr,
513 &psmouse_attr_reg_11.dattr.attr,
514 &psmouse_attr_reg_20.dattr.attr,
515 &psmouse_attr_reg_21.dattr.attr,
516 &psmouse_attr_reg_22.dattr.attr,
517 &psmouse_attr_reg_23.dattr.attr,
518 &psmouse_attr_reg_24.dattr.attr,
519 &psmouse_attr_reg_25.dattr.attr,
520 &psmouse_attr_reg_26.dattr.attr,
521 &psmouse_attr_debug.dattr.attr,
522 &psmouse_attr_paritycheck.dattr.attr,
526 static struct attribute_group elantech_attr_group = {
527 .attrs = elantech_attrs,
531 * Use magic knock to detect Elantech touchpad
533 int elantech_detect(struct psmouse *psmouse, int set_properties)
535 struct ps2dev *ps2dev = &psmouse->ps2dev;
536 unsigned char param[3];
538 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
540 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
541 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
542 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
543 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
544 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
545 pr_debug("elantech.c: sending Elantech magic knock failed.\n");
550 * Report this in case there are Elantech models that use a different
551 * set of magic numbers
553 if (param[0] != 0x3c || param[1] != 0x03 || param[2] != 0xc8) {
554 pr_debug("elantech.c: "
555 "unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
556 param[0], param[1], param[2]);
561 * Query touchpad's firmware version and see if it reports known
562 * value to avoid mis-detection. Logitech mice are known to respond
563 * to Elantech magic knock and there might be more.
565 if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
566 pr_debug("elantech.c: failed to query firmware version.\n");
570 pr_debug("elantech.c: Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
571 param[0], param[1], param[2]);
573 if (param[0] == 0 || param[1] != 0) {
574 pr_debug("elantech.c: Probably not a real Elantech touchpad. Aborting.\n");
578 if (set_properties) {
579 psmouse->vendor = "Elantech";
580 psmouse->name = "Touchpad";
587 * Clean up sysfs entries when disconnecting
589 static void elantech_disconnect(struct psmouse *psmouse)
591 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
592 &elantech_attr_group);
593 kfree(psmouse->private);
594 psmouse->private = NULL;
598 * Put the touchpad back into absolute mode when reconnecting
600 static int elantech_reconnect(struct psmouse *psmouse)
602 if (elantech_detect(psmouse, 0))
605 if (elantech_set_absolute_mode(psmouse)) {
606 pr_err("elantech.c: failed to put touchpad back into absolute mode.\n");
614 * Initialize the touchpad and create sysfs entries
616 int elantech_init(struct psmouse *psmouse)
618 struct elantech_data *etd;
620 unsigned char param[3];
622 psmouse->private = etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL);
627 for (i = 1; i < 256; i++)
628 etd->parity[i] = etd->parity[i & (i - 1)] ^ 1;
631 * Do the version query again so we can store the result
633 if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
634 pr_err("elantech.c: failed to query firmware version.\n");
637 etd->fw_version_maj = param[0];
638 etd->fw_version_min = param[2];
641 * Assume every version greater than this is new EeePC style
642 * hardware with 6 byte packets
644 if (etd->fw_version_maj >= 0x02 && etd->fw_version_min >= 0x30) {
646 /* For now show extra debug information */
648 /* Don't know how to do parity checking for version 2 */
649 etd->paritycheck = 0;
652 etd->paritycheck = 1;
654 pr_info("elantech.c: assuming hardware version %d, firmware version %d.%d\n",
655 etd->hw_version, etd->fw_version_maj, etd->fw_version_min);
657 if (synaptics_send_cmd(psmouse, ETP_CAPABILITIES_QUERY, param)) {
658 pr_err("elantech.c: failed to query capabilities.\n");
661 pr_info("elantech.c: Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
662 param[0], param[1], param[2]);
663 etd->capabilities = param[0];
665 if (elantech_set_absolute_mode(psmouse)) {
666 pr_err("elantech.c: failed to put touchpad into absolute mode.\n");
670 elantech_set_input_params(psmouse);
672 error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
673 &elantech_attr_group);
675 pr_err("elantech.c: failed to create sysfs attributes, error: %d.\n",
680 psmouse->protocol_handler = elantech_process_byte;
681 psmouse->disconnect = elantech_disconnect;
682 psmouse->reconnect = elantech_reconnect;
683 psmouse->pktsize = etd->hw_version == 2 ? 6 : 4;
692 * Elantech Touchpad driver (v5)
694 * Copyright (C) 2007-2008 Arjan Opmeer <arjan@opmeer.net>
696 * This program is free software; you can redistribute it and/or modify it
697 * under the terms of the GNU General Public License version 2 as published
698 * by the Free Software Foundation.
700 * Trademarks are the property of their respective owners.
703 #include <linux/delay.h>
704 #include <linux/module.h>
705 #include <linux/input.h>
706 #include <linux/serio.h>
707 #include <linux/libps2.h>
709 #include "elantech.h"
711 #define elantech_debug(format, arg...) \
714 printk(KERN_DEBUG format, ##arg); \
718 * Send a Synaptics style sliced query command
720 static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c,
721 unsigned char *param)
723 if (psmouse_sliced_command(psmouse, c) ||
724 ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
725 pr_err("elantech.c: synaptics_send_cmd query 0x%02x failed.\n", c);
733 * A retrying version of ps2_command
735 static int elantech_ps2_command(struct psmouse *psmouse,
736 unsigned char *param, int command)
738 struct ps2dev *ps2dev = &psmouse->ps2dev;
739 struct elantech_data *etd = psmouse->private;
741 int tries = ETP_PS2_COMMAND_TRIES;
744 rc = ps2_command(ps2dev, param, command);
748 elantech_debug("elantech.c: retrying ps2 command 0x%02x (%d).\n",
750 msleep(ETP_PS2_COMMAND_DELAY);
754 pr_err("elantech.c: ps2 command 0x%02x failed.\n", command);
760 * Send an Elantech style special command to read a value from a register
762 static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg,
765 struct elantech_data *etd = psmouse->private;
766 unsigned char param[3];
769 if (reg < 0x10 || reg > 0x26)
772 if (reg > 0x11 && reg < 0x20)
775 switch (etd->hw_version) {
777 if (psmouse_sliced_command(psmouse, ETP_REGISTER_READ) ||
778 psmouse_sliced_command(psmouse, reg) ||
779 ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
785 if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
786 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READ) ||
787 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
788 elantech_ps2_command(psmouse, NULL, reg) ||
789 elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
796 pr_err("elantech.c: failed to read register 0x%02x.\n", reg);
804 * Send an Elantech style special command to write a register with a value
806 static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg,
809 struct elantech_data *etd = psmouse->private;
812 if (reg < 0x10 || reg > 0x26)
815 if (reg > 0x11 && reg < 0x20)
818 switch (etd->hw_version) {
820 if (psmouse_sliced_command(psmouse, ETP_REGISTER_WRITE) ||
821 psmouse_sliced_command(psmouse, reg) ||
822 psmouse_sliced_command(psmouse, val) ||
823 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) {
829 if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
830 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_WRITE) ||
831 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
832 elantech_ps2_command(psmouse, NULL, reg) ||
833 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
834 elantech_ps2_command(psmouse, NULL, val) ||
835 elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
842 pr_err("elantech.c: failed to write register 0x%02x with value 0x%02x.\n",
849 * Dump a complete mouse movement packet to the syslog
851 static void elantech_packet_dump(unsigned char *packet, int size)
855 printk(KERN_DEBUG "elantech.c: PS/2 packet [");
856 for (i = 0; i < size; i++)
857 printk("%s0x%02x ", (i) ? ", " : " ", packet[i]);
862 * Interpret complete data packets and report absolute mode input events for
863 * hardware version 1. (4 byte packets)
865 static void elantech_report_absolute_v1(struct psmouse *psmouse)
867 struct input_dev *dev = psmouse->dev;
868 struct elantech_data *etd = psmouse->private;
869 unsigned char *packet = psmouse->packet;
872 if (etd->fw_version_maj == 0x01) {
873 /* byte 0: D U p1 p2 1 p3 R L
874 byte 1: f 0 th tw x9 x8 y9 y8 */
875 fingers = ((packet[1] & 0x80) >> 7) +
876 ((packet[1] & 0x30) >> 4);
878 /* byte 0: n1 n0 p2 p1 1 p3 R L
879 byte 1: 0 0 0 0 x9 x8 y9 y8 */
880 fingers = (packet[0] & 0xc0) >> 6;
883 input_report_key(dev, BTN_TOUCH, fingers != 0);
885 /* byte 2: x7 x6 x5 x4 x3 x2 x1 x0
886 byte 3: y7 y6 y5 y4 y3 y2 y1 y0 */
888 input_report_abs(dev, ABS_X,
889 ((packet[1] & 0x0c) << 6) | packet[2]);
890 input_report_abs(dev, ABS_Y, ETP_YMAX_V1 -
891 (((packet[1] & 0x03) << 8) | packet[3]));
894 input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
895 input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
896 input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
897 input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
898 input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
900 if ((etd->fw_version_maj == 0x01) &&
901 (etd->capabilities & ETP_CAP_HAS_ROCKER)) {
903 input_report_key(dev, BTN_FORWARD, packet[0] & 0x40);
905 input_report_key(dev, BTN_BACK, packet[0] & 0x80);
912 * Interpret complete data packets and report absolute mode input events for
913 * hardware version 2. (6 byte packets)
915 static void elantech_report_absolute_v2(struct psmouse *psmouse)
917 struct input_dev *dev = psmouse->dev;
918 unsigned char *packet = psmouse->packet;
919 int fingers, x1, y1, x2, y2;
921 /* byte 0: n1 n0 . . . . R L */
922 fingers = (packet[0] & 0xc0) >> 6;
923 input_report_key(dev, BTN_TOUCH, fingers != 0);
927 /* byte 1: x15 x14 x13 x12 x11 x10 x9 x8
928 byte 2: x7 x6 x5 x4 x4 x2 x1 x0 */
929 input_report_abs(dev, ABS_X, (packet[1] << 8) | packet[2]);
930 /* byte 4: y15 y14 y13 y12 y11 y10 y8 y8
931 byte 5: y7 y6 y5 y4 y3 y2 y1 y0 */
932 input_report_abs(dev, ABS_Y, ETP_YMAX_V2 -
933 ((packet[4] << 8) | packet[5]));
937 /* The coordinate of each finger is reported separately with
938 a lower resolution for two finger touches */
939 /* byte 0: . . ay8 ax8 . . . .
940 byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0 */
941 x1 = ((packet[0] & 0x10) << 4) | packet[1];
942 /* byte 2: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 */
943 y1 = ETP_2FT_YMAX - (((packet[0] & 0x20) << 3) | packet[2]);
944 /* byte 3: . . by8 bx8 . . . .
945 byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0 */
946 x2 = ((packet[3] & 0x10) << 4) | packet[4];
947 /* byte 5: by7 by8 by5 by4 by3 by2 by1 by0 */
948 y2 = ETP_2FT_YMAX - (((packet[3] & 0x20) << 3) | packet[5]);
949 /* For compatibility with the X Synaptics driver scale up one
950 coordinate and report as ordinary mouse movent */
951 input_report_abs(dev, ABS_X, x1 << 2);
952 input_report_abs(dev, ABS_Y, y1 << 2);
953 /* For compatibility with the proprietary X Elantech driver
954 report both coordinates as hat coordinates */
955 input_report_abs(dev, ABS_HAT0X, x1);
956 input_report_abs(dev, ABS_HAT0Y, y1);
957 input_report_abs(dev, ABS_HAT1X, x2);
958 input_report_abs(dev, ABS_HAT1Y, y2);
962 input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
963 input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
964 input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
965 input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
966 input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
971 static int elantech_check_parity_v1(struct psmouse *psmouse)
973 struct elantech_data *etd = psmouse->private;
974 unsigned char *packet = psmouse->packet;
975 unsigned char p1, p2, p3;
977 /* Parity bits are placed differently */
978 if (etd->fw_version_maj == 0x01) {
979 /* byte 0: D U p1 p2 1 p3 R L */
980 p1 = (packet[0] & 0x20) >> 5;
981 p2 = (packet[0] & 0x10) >> 4;
983 /* byte 0: n1 n0 p2 p1 1 p3 R L */
984 p1 = (packet[0] & 0x10) >> 4;
985 p2 = (packet[0] & 0x20) >> 5;
988 p3 = (packet[0] & 0x04) >> 2;
990 return etd->parity[packet[1]] == p1 &&
991 etd->parity[packet[2]] == p2 &&
992 etd->parity[packet[3]] == p3;
996 * Process byte stream from mouse and handle complete packets
998 static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse)
1000 struct elantech_data *etd = psmouse->private;
1002 if (psmouse->pktcnt < psmouse->pktsize)
1003 return PSMOUSE_GOOD_DATA;
1006 elantech_packet_dump(psmouse->packet, psmouse->pktsize);
1008 switch (etd->hw_version) {
1010 if (etd->paritycheck && !elantech_check_parity_v1(psmouse))
1011 return PSMOUSE_BAD_DATA;
1013 elantech_report_absolute_v1(psmouse);
1017 /* We don't know how to check parity in protocol v2 */
1018 elantech_report_absolute_v2(psmouse);
1022 return PSMOUSE_FULL_PACKET;
1026 * Put the touchpad into absolute mode
1028 static int elantech_set_absolute_mode(struct psmouse *psmouse)
1030 struct elantech_data *etd = psmouse->private;
1032 int tries = ETP_READ_BACK_TRIES;
1035 switch (etd->hw_version) {
1039 if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
1040 elantech_write_reg(psmouse, 0x11, etd->reg_11)) {
1046 /* Windows driver values */
1048 etd->reg_11 = 0x88; /* 0x8a */
1049 etd->reg_21 = 0x60; /* 0x00 */
1050 if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
1051 elantech_write_reg(psmouse, 0x11, etd->reg_11) ||
1052 elantech_write_reg(psmouse, 0x21, etd->reg_21)) {
1057 * Read back reg 0x10. The touchpad is probably initalising
1058 * and not ready until we read back the value we just wrote.
1061 rc = elantech_read_reg(psmouse, 0x10, &val);
1065 elantech_debug("elantech.c: retrying read (%d).\n",
1067 msleep(ETP_READ_BACK_DELAY);
1068 } while (tries > 0);
1070 pr_err("elantech.c: failed to read back register 0x10.\n");
1075 pr_err("elantech.c: failed to initialise registers.\n");
1081 * Set the appropriate event bits for the input subsystem
1083 static void elantech_set_input_params(struct psmouse *psmouse)
1085 struct input_dev *dev = psmouse->dev;
1086 struct elantech_data *etd = psmouse->private;
1088 __set_bit(EV_KEY, dev->evbit);
1089 __set_bit(EV_ABS, dev->evbit);
1091 __set_bit(BTN_LEFT, dev->keybit);
1092 __set_bit(BTN_RIGHT, dev->keybit);
1094 __set_bit(BTN_TOUCH, dev->keybit);
1095 __set_bit(BTN_TOOL_FINGER, dev->keybit);
1096 __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
1097 __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
1099 switch (etd->hw_version) {
1102 if ((etd->fw_version_maj == 0x01) &&
1103 (etd->capabilities & ETP_CAP_HAS_ROCKER)) {
1104 __set_bit(BTN_FORWARD, dev->keybit);
1105 __set_bit(BTN_BACK, dev->keybit);
1107 input_set_abs_params(dev, ABS_X, ETP_XMIN_V1, ETP_XMAX_V1, 0, 0);
1108 input_set_abs_params(dev, ABS_Y, ETP_YMIN_V1, ETP_YMAX_V1, 0, 0);
1112 input_set_abs_params(dev, ABS_X, ETP_XMIN_V2, ETP_XMAX_V2, 0, 0);
1113 input_set_abs_params(dev, ABS_Y, ETP_YMIN_V2, ETP_YMAX_V2, 0, 0);
1114 input_set_abs_params(dev, ABS_HAT0X, ETP_2FT_XMIN, ETP_2FT_XMAX, 0, 0);
1115 input_set_abs_params(dev, ABS_HAT0Y, ETP_2FT_YMIN, ETP_2FT_YMAX, 0, 0);
1116 input_set_abs_params(dev, ABS_HAT1X, ETP_2FT_XMIN, ETP_2FT_XMAX, 0, 0);
1117 input_set_abs_params(dev, ABS_HAT1Y, ETP_2FT_YMIN, ETP_2FT_YMAX, 0, 0);
1122 struct elantech_attr_data {
1123 size_t field_offset;
1128 * Display a register value by reading a sysfs entry
1130 static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data,
1133 struct elantech_data *etd = psmouse->private;
1134 struct elantech_attr_data *attr = data;
1135 unsigned char *reg = (unsigned char *) etd + attr->field_offset;
1139 rc = elantech_read_reg(psmouse, attr->reg, reg);
1141 return sprintf(buf, "0x%02x\n", (attr->reg && rc) ? -1 : *reg);
1145 * Write a register value by writing a sysfs entry
1147 static ssize_t elantech_set_int_attr(struct psmouse *psmouse,
1148 void *data, const char *buf, size_t count)
1150 struct elantech_data *etd = psmouse->private;
1151 struct elantech_attr_data *attr = data;
1152 unsigned char *reg = (unsigned char *) etd + attr->field_offset;
1153 unsigned long value;
1156 err = strict_strtoul(buf, 16, &value);
1163 /* Do we need to preserve some bits for version 2 hardware too? */
1164 if (etd->hw_version == 1) {
1165 if (attr->reg == 0x10)
1166 /* Force absolute mode always on */
1167 value |= ETP_R10_ABSOLUTE_MODE;
1168 else if (attr->reg == 0x11)
1169 /* Force 4 byte mode always on */
1170 value |= ETP_R11_4_BYTE_MODE;
1173 if (!attr->reg || elantech_write_reg(psmouse, attr->reg, value) == 0)
1179 #define ELANTECH_INT_ATTR(_name, _register) \
1180 static struct elantech_attr_data elantech_attr_##_name = { \
1181 .field_offset = offsetof(struct elantech_data, _name), \
1184 PSMOUSE_DEFINE_ATTR(_name, S_IWUSR | S_IRUGO, \
1185 &elantech_attr_##_name, \
1186 elantech_show_int_attr, \
1187 elantech_set_int_attr)
1189 ELANTECH_INT_ATTR(reg_10, 0x10);
1190 ELANTECH_INT_ATTR(reg_11, 0x11);
1191 ELANTECH_INT_ATTR(reg_20, 0x20);
1192 ELANTECH_INT_ATTR(reg_21, 0x21);
1193 ELANTECH_INT_ATTR(reg_22, 0x22);
1194 ELANTECH_INT_ATTR(reg_23, 0x23);
1195 ELANTECH_INT_ATTR(reg_24, 0x24);
1196 ELANTECH_INT_ATTR(reg_25, 0x25);
1197 ELANTECH_INT_ATTR(reg_26, 0x26);
1198 ELANTECH_INT_ATTR(debug, 0);
1199 ELANTECH_INT_ATTR(paritycheck, 0);
1201 static struct attribute *elantech_attrs[] = {
1202 &psmouse_attr_reg_10.dattr.attr,
1203 &psmouse_attr_reg_11.dattr.attr,
1204 &psmouse_attr_reg_20.dattr.attr,
1205 &psmouse_attr_reg_21.dattr.attr,
1206 &psmouse_attr_reg_22.dattr.attr,
1207 &psmouse_attr_reg_23.dattr.attr,
1208 &psmouse_attr_reg_24.dattr.attr,
1209 &psmouse_attr_reg_25.dattr.attr,
1210 &psmouse_attr_reg_26.dattr.attr,
1211 &psmouse_attr_debug.dattr.attr,
1212 &psmouse_attr_paritycheck.dattr.attr,
1216 static struct attribute_group elantech_attr_group = {
1217 .attrs = elantech_attrs,
1221 * Use magic knock to detect Elantech touchpad
1223 int elantech_detect(struct psmouse *psmouse, int set_properties)
1225 struct ps2dev *ps2dev = &psmouse->ps2dev;
1226 unsigned char param[3];
1228 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1230 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
1231 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
1232 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
1233 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
1234 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
1235 pr_debug("elantech.c: sending Elantech magic knock failed.\n");
1240 * Report this in case there are Elantech models that use a different
1241 * set of magic numbers
1243 if (param[0] != 0x3c || param[1] != 0x03 || param[2] != 0xc8) {
1244 pr_debug("elantech.c: "
1245 "unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
1246 param[0], param[1], param[2]);
1251 * Query touchpad's firmware version and see if it reports known
1252 * value to avoid mis-detection. Logitech mice are known to respond
1253 * to Elantech magic knock and there might be more.
1255 if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
1256 pr_debug("elantech.c: failed to query firmware version.\n");
1260 pr_debug("elantech.c: Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
1261 param[0], param[1], param[2]);
1263 if (param[0] == 0 || param[1] != 0) {
1264 pr_debug("elantech.c: Probably not a real Elantech touchpad. Aborting.\n");
1268 if (set_properties) {
1269 psmouse->vendor = "Elantech";
1270 psmouse->name = "Touchpad";
1277 * Clean up sysfs entries when disconnecting
1279 static void elantech_disconnect(struct psmouse *psmouse)
1281 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
1282 &elantech_attr_group);
1283 kfree(psmouse->private);
1284 psmouse->private = NULL;
1288 * Put the touchpad back into absolute mode when reconnecting
1290 static int elantech_reconnect(struct psmouse *psmouse)
1292 if (elantech_detect(psmouse, 0))
1295 if (elantech_set_absolute_mode(psmouse)) {
1296 pr_err("elantech.c: failed to put touchpad back into absolute mode.\n");
1304 * Initialize the touchpad and create sysfs entries
1306 int elantech_init(struct psmouse *psmouse)
1308 struct elantech_data *etd;
1310 unsigned char param[3];
1312 psmouse->private = etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL);
1317 for (i = 1; i < 256; i++)
1318 etd->parity[i] = etd->parity[i & (i - 1)] ^ 1;
1321 * Do the version query again so we can store the result
1323 if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
1324 pr_err("elantech.c: failed to query firmware version.\n");
1327 etd->fw_version_maj = param[0];
1328 etd->fw_version_min = param[2];
1331 * Assume every version greater than this is new EeePC style
1332 * hardware with 6 byte packets
1334 if (etd->fw_version_maj >= 0x02 && etd->fw_version_min >= 0x30) {
1335 etd->hw_version = 2;
1336 /* For now show extra debug information */
1338 /* Don't know how to do parity checking for version 2 */
1339 etd->paritycheck = 0;
1341 etd->hw_version = 1;
1342 etd->paritycheck = 1;
1344 pr_info("elantech.c: assuming hardware version %d, firmware version %d.%d\n",
1345 etd->hw_version, etd->fw_version_maj, etd->fw_version_min);
1347 if (synaptics_send_cmd(psmouse, ETP_CAPABILITIES_QUERY, param)) {
1348 pr_err("elantech.c: failed to query capabilities.\n");
1351 pr_info("elantech.c: Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
1352 param[0], param[1], param[2]);
1353 etd->capabilities = param[0];
1355 if (elantech_set_absolute_mode(psmouse)) {
1356 pr_err("elantech.c: failed to put touchpad into absolute mode.\n");
1360 elantech_set_input_params(psmouse);
1362 error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
1363 &elantech_attr_group);
1365 pr_err("elantech.c: failed to create sysfs attributes, error: %d.\n",
1370 psmouse->protocol_handler = elantech_process_byte;
1371 psmouse->disconnect = elantech_disconnect;
1372 psmouse->reconnect = elantech_reconnect;
1373 psmouse->pktsize = etd->hw_version == 2 ? 6 : 4;