I updated my driver for the Elantech touchpad. Changes include: - Fixed an issue on some models where using the physical buttons did not work and only tapping the touchpad produced mouse clicks. - Absolute mode reporting also has an "older" and "newer" packet format where the finger tap and parity bits are placed differently. The driver makes an educated guess based on the Synaptics Capabilities query which layout to expect. - Implemented a reconnect handler to make suspend and resume work without the touchpad and the driver getting out of sync.
Testers are still very much wanted and encouraged to give feedback. For people that are reading the mailing list via a web interface: I've made the patches available for download and provided some extra information at http://arjan.opmeer.net/elantech Arjan --- diff -purN -X linux-2.6.24.vanilla/Documentation/dontdiff linux-2.6.24.vanilla/Documentation/input/elantech.txt linux-2.6.24.elantech/Documentation/input/elantech.txt --- linux-2.6.24.vanilla/Documentation/input/elantech.txt 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.24.elantech/Documentation/input/elantech.txt 2008-01-26 01:38:58.000000000 +0100 @@ -0,0 +1,221 @@ +Elantech Touchpad Driver +======================== + Copyright (C) 2007-2008 Arjan Opmeer <[EMAIL PROTECTED]> + + Extra information found and provided by Steve Havelka + + +Introduction +~~~~~~~~~~~~ + +Like most touchpads the Elantech touchpad can be in two modes. One is called +relative mode in which the touchpad uses its internal controller to +translate touching the pad and moving your finger into mouse movement +updates. In this mode the touchpad acts just like a normal wired mouse. + +The other is called absolute mode in which the touchpad merely acts as an XY +grid and as long as there is a finger on the pad continuously sends the +coordinates of the finger to the driver. Think of it like a tablet where +your finger is the stylus. + +In relative mode the operation of the touchpad can be influenced by +adjusting the contents of some registers. These registers are represented by +the driver as sysfs entries under /sys/bus/serio/drivers/psmouse/serio? that +can be read from and written to. + +E.g. to disable tapping while leaving the other settings to the default +Windows driver value one would do: + + echo -n 0x32 > reg_10 + +and to switch the touchpad to absolute mode one would do: + + echo -n 0x16 > reg_10 + +In absolute mode the touchpad is not using the internal controller, so +adjusting the registers no longer has the desired effect. However, the +driver makes sure that in this mode the touchpad can be used with the Xorg +synaptics driver so any one of the Synaptics configuration utilities should +also work for adjusting the operation of the Elantech touchpad. + + +Registers +~~~~~~~~~ + +* reg_10 (Windows driver default value 0x12) + + bit 7 6 5 4 3 2 1 0 + B C T D L A S E + + E: 1 = enable smart edges unconditionally + S: 1 = enable smart edges only when dragging + A: 1 = absolute mode (needs 4 byte packets, see reg_11) + L: 1 = enable drag lock (see reg_22) + D: 1 = disable dynamic resolution + T: 1 = disable tapping + C: 1 = enable corner tap + B: 1 = swap left and right button + +* reg_11 (Windows driver default value 0x8f) + + bit 7 6 5 4 3 2 1 0 + 1 0 0 H V 1 F P + + P: 1 = enable parity checking for relative mode + F: 1 = enable native 4 byte packet mode + V: 1 = enable vertical scroll area + H: 1 = enable horizontal scroll area + + +* reg_20 (Windows driver default value 0x0a) + + single finger width? + +* reg_21 (Windows driver default value 0x60) + + scroll area width (small: 0x40 ... wide: 0xff) + +* reg_22 (Windows driver default value 0xff) + + drag lock time out (short: 0x14 ... long: 0xfe; 0xff =never) + +* reg_23 (Windows driver default value 0x10) + + tap make timeout? + + Note: the Windows driver does not write this register + +* reg_24 (Windows driver default value 0x10) + + tap release timeout? + + Note: the Windows driver does not write this register + +* reg_25 (Windows driver default value 0x03) + + smart edge cursor speed (0x02 = slow, 0x03 = medium, 0x04 = fast) + +* reg_26 (Windows driver default value 0x00 ?? ) + + smart edge activation area width? + + Note: the Windows driver does not write this register + Note: the Windows driver default value of 0x00 disables smart edges + when it would get written + Note: the Windows driver sets bit 0 of the registry value to disable + tapping when typing, but never actually writes the register. + Only used as an internal driver flag? + + + +Initially the Elantech touchpad is in emulation mode and reports 3 byte +standard PS/2 packets and hence works with a standard mouse driver. +However, it can be configured to talk its native 4 byte relative mode and 4 +byte absolute mode both for which a dedicated driver is needed. + + +Native 4 byte relative mode packet format +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +byte 0: + bit 7 6 5 4 3 2 1 0 + c c p2 p1 1 M R L + + L, R, M = 1 when Left, Right, Middle mouse button pressed + some models have M as byte 3 odd parity bit + when parity checking is enabled (P = 1): + p1..p2 = byte 1 and 2 odd parity bit + c = 1 when corner tap detected + +byte 1: + bit 7 6 5 4 3 2 1 0 + dx7 dx6 dx5 dx4 dx3 dx2 dx1 dx0 + + dx7..dx0 = x movement; positive = right, negative = left + byte 1 = 0xf0 when corner tap detected + +byte 2: + bit 7 6 5 4 3 2 1 0 + dy7 dy6 dy5 dy4 dy3 dy2 dy1 dy0 + + dy7..dy0 = y movement; positive = up, negative = down + +byte 3: + parity checking enabled (reg_11, P = 1): + + bit 7 6 5 4 3 2 1 0 + w h n1 n0 ds3 ds2 ds1 ds0 + + normally: + ds3..ds0 = scroll wheel amount and direction + positive = down or left + negative = up or right + when corner tap detected: + ds0 = 1 when top right corner tapped + ds1 = 1 when bottom right corner tapped + ds2 = 1 when bottom left corner tapped + ds3 = 1 when top left corner tapped + n1..n0 = number of fingers on touchpad + not all models report this but map one, two and three + finger taps directly to L, M and R mouse buttons + h = 1 when horizontal scroll action + w = 1 when wide finger touch? + + otherwise (reg_11, P = 0): + + bit 7 6 5 4 3 2 1 0 + ds7 ds6 ds5 ds4 ds3 ds2 ds1 ds0 + + ds7..ds0 = vertical scroll amount and direction + negative = up + positive = down + + +Native 4 byte absolute mode packet format +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +byte 0: + older models: + + bit 7 6 5 4 3 2 1 0 + D U p1 p2 1 p3 R L + + L, R = 1 when Left, Right mouse button pressed + p1..p3 = byte 1..3 odd parity bit + D, U = 1 when rocker switch pressed Up, Down + + newer models: + + bit 7 6 5 4 3 2 1 0 + n1 n0 p2 p1 1 p3 R L + + L, R = 1 when Left, Right mouse button pressed + p1..p3 = byte 1..3 odd parity bit + n1..n0 = number of fingers on touchpad + +byte 1: + older models: + + bit 7 6 5 4 3 2 1 0 + f 0 th tw x9 x8 y9 y8 + + tw = 1 when two finger touch + th = 1 when three finger touch + f = 1 when finger touch + + newer models: + + bit 7 6 5 4 3 2 1 0 + 0 0 0 0 x9 x8 y9 y8 + +byte 2: + bit 7 6 5 4 3 2 1 0 + x7 x6 x5 x4 x3 x2 x1 x0 + + x9..x0 = absolute x value (horizontal) + +byte 3: + bit 7 6 5 4 3 2 1 0 + y7 y6 y5 y4 y3 y2 y1 y0 + + y9..y0 = absolute y value (vertical) diff -purN -X linux-2.6.24.vanilla/Documentation/dontdiff linux-2.6.24.vanilla/drivers/input/mouse/Kconfig linux-2.6.24.elantech/drivers/input/mouse/Kconfig --- linux-2.6.24.vanilla/drivers/input/mouse/Kconfig 2008-01-24 23:58:37.000000000 +0100 +++ linux-2.6.24.elantech/drivers/input/mouse/Kconfig 2008-01-26 01:38:58.000000000 +0100 @@ -96,6 +96,21 @@ config MOUSE_PS2_TOUCHKIT If unsure, say N. +config MOUSE_PS2_ELANTECH + bool "Elantech PS/2 protocol extension" + depends on MOUSE_PS2 + help + Say Y here if you have an Elantech PS/2 touchpad connected + to your system. + + If unsure, say N. + + This driver exposes some configuration registers via sysfs + entries. + + For further information, see + <file:Documentation/input/elantech.txt>. + config MOUSE_SERIAL tristate "Serial mouse" select SERIO diff -purN -X linux-2.6.24.vanilla/Documentation/dontdiff linux-2.6.24.vanilla/drivers/input/mouse/Makefile linux-2.6.24.elantech/drivers/input/mouse/Makefile --- linux-2.6.24.vanilla/drivers/input/mouse/Makefile 2008-01-24 23:58:37.000000000 +0100 +++ linux-2.6.24.elantech/drivers/input/mouse/Makefile 2008-01-26 01:38:58.000000000 +0100 @@ -24,3 +24,4 @@ psmouse-$(CONFIG_MOUSE_PS2_LOGIPS2PP) += psmouse-$(CONFIG_MOUSE_PS2_LIFEBOOK) += lifebook.o psmouse-$(CONFIG_MOUSE_PS2_TRACKPOINT) += trackpoint.o psmouse-$(CONFIG_MOUSE_PS2_TOUCHKIT) += touchkit_ps2.o +psmouse-$(CONFIG_MOUSE_PS2_ELANTECH) += elantech.o diff -purN -X linux-2.6.24.vanilla/Documentation/dontdiff linux-2.6.24.vanilla/drivers/input/mouse/elantech.c linux-2.6.24.elantech/drivers/input/mouse/elantech.c --- linux-2.6.24.vanilla/drivers/input/mouse/elantech.c 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.24.elantech/drivers/input/mouse/elantech.c 2008-01-26 01:38:58.000000000 +0100 @@ -0,0 +1,556 @@ +/* + * Elantech Touchpad driver (v3) + * + * Copyright (C) 2007-2008 Arjan Opmeer <[EMAIL PROTECTED]> + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 as published + * by the Free Software Foundation. + * + * Trademarks are the property of their respective owners. + */ + +#include <linux/module.h> +#include <linux/input.h> +#include <linux/serio.h> +#include <linux/libps2.h> +#include "psmouse.h" +#include "synaptics.h" +#include "elantech.h" + +/* + * Native absolute mode reporting has odd parity check on the last 3 bytes. + * Native relative mode can have odd parity checking on second and third byte, + * or last 3 bytes depending on model. + */ +static unsigned char parity[256]; + +/* + * Send a synaptics style special commands + */ +static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c, unsigned char *param) +{ + if (psmouse_sliced_command(psmouse, c)) + return -1; + if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) + return -1; + return 0; +} + +/* + * Send an Elantech style special command to write a register with a value + */ +static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg, unsigned char val) +{ + if ((reg < 0x10) || (reg > 0x26)) + return -1; + if ((reg > 0x11) && (reg < 0x20)) + return -1; + + if (psmouse_sliced_command(psmouse, ELANTECH_COMMAND_START) || + psmouse_sliced_command(psmouse, reg) || + psmouse_sliced_command(psmouse, val) || + ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) { + return -1; + } + + return 0; +} + +/* + * Dump a complete mouse movement packet to the syslog + */ +static void elantech_packet_dump(unsigned char *packet, int size) +{ + int i; + + printk(KERN_DEBUG "elantech.c: PS/2 packet ["); + for (i = 0; i < size; i++) + printk("%s0x%02x ", (i) ? ", " : " ", packet[i]); + printk("]\n"); +} + +/* + * Report absolute mode input events + */ +static void elantech_report_absolute(struct psmouse *psmouse) +{ + struct elantech_data *etd = psmouse->private; + struct input_dev *dev = psmouse->dev; + unsigned char *packet = psmouse->packet; + int fingers; + + if (etd->capabilities & ETP_CAP_ALTERNATE_TAP_BITS) { + /* byte 0: n1 n0 p2 p1 1 p3 R L + * byte 1: 0 0 0 0 x9 x8 y9 y8 */ + fingers = (packet[0] & 0xc0) >> 6; + } else { + /* byte 0: D U p1 p2 1 p3 R L + * byte 1: f 0 th tw x9 x8 y9 y8 */ + fingers = ((packet[1] & 0x80) >> 7) + ((packet[1] & 0x30) >> 4); + } + input_report_key(dev, BTN_TOUCH, fingers != 0); + /* byte 2: x7 x6 x5 x4 x3 x2 x1 x0 + * byte 3: y7 y6 y5 y4 y3 y2 y1 y0 */ + if (fingers == 1) { + input_report_abs(dev, ABS_X, + ((packet[1] & 0x0c) << 6) | packet[2]); + input_report_abs(dev, ABS_Y, ETP_YMAX - + (((packet[1] & 0x03) << 8) | packet[3])); + } + input_report_abs(dev, ABS_PRESSURE, (fingers) ? ETP_DEF_PRESSURE : 0); + input_report_key(dev, BTN_TOOL_FINGER, fingers == 1); + input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2); + input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3); + input_report_key(dev, BTN_LEFT, packet[0] & 0x01); + input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); + if (!(etd->capabilities & ETP_CAP_ALTERNATE_TAP_BITS) && + (etd->capabilities & ETP_CAP_HAS_ROCKER)) { + input_report_key(dev, BTN_FORWARD, packet[0] & 0x40); /* rocker up */ + input_report_key(dev, BTN_BACK, packet[0] & 0x80); /* rocker down */ + } +} + +/* + * Report relative mode input events + */ +static void elantech_report_relative(struct psmouse *psmouse) +{ + struct elantech_data *etd = psmouse->private; + struct input_dev *dev = psmouse->dev; + unsigned char *packet = psmouse->packet; + int fingers, cornertap; + + /* byte 0: c c p2 p1 1 M R L + * byte 1: dx7 dx6 dx5 dx4 dx3 dx2 dx1 dx0 + * byte 2: dy7 dy6 dy5 dy4 dy3 dy2 dy1 dy0 + * byte 3: w h n1 n0 ds3 ds2 ds1 ds0 */ + input_report_key(dev, BTN_LEFT, packet[0] & 0x01); + input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); + + if (etd->capabilities & ETP_CAP_REPORTS_MIDDLE_BUTTON) + input_report_key(dev, BTN_MIDDLE, packet[0] & 0x04); + + if (etd->capabilities & ETP_CAP_ALTERNATE_TAP_BITS) { + fingers = (packet[3] & 0x30) >> 4; + if (fingers) { + input_report_key(dev, BTN_LEFT, fingers == 1); + input_report_key(dev, BTN_MIDDLE, fingers == 2); + input_report_key(dev, BTN_RIGHT, fingers == 3); + } + } + + cornertap = (((packet[0] & 0xc0) == 0xc0) && ((packet[1] & 0xf0) == 0xf0)); + if (!cornertap) { + input_report_rel(dev, REL_X, (int) (packet[1] & 0x7f) - + (int) (packet[1] & 0x80)); + input_report_rel(dev, REL_Y, (int) (packet[2] & 0x80) - + (int) (packet[2] & 0x7f)); + } + + /* No more information in 3 bytes */ + if (!(etd->reg_11 & ETP_R11_4_BYTE_MODE)) + return; + + if (cornertap) { + input_report_key(dev, BTN_0, packet[3] & 0x01); /* top right */ + input_report_key(dev, BTN_1, packet[3] & 0x02); /* bottom right */ + input_report_key(dev, BTN_2, packet[3] & 0x04); /* bottom left */ + input_report_key(dev, BTN_3, packet[3] & 0x08); /* top left */ + return; + } + + if (etd->reg_11 & ETP_R11_PARITY_CHECKING) { + if (packet[3] & 0x0f) { + if (packet[3] & 0x40) { + input_report_rel(dev, REL_HWHEEL, + (int) (packet[3] & 0x08) - + (int) (packet[3] & 0x07)); + } else { + input_report_rel(dev, REL_WHEEL, + (int) (packet[3] & 0x08) - + (int) (packet[3] & 0x07)); + } + } + } else { + if (packet[3]) + input_report_rel(dev, REL_WHEEL, + (int) (packet[3] & 0x80) - + (int) (packet[3] & 0x7f)); + } +} + +/* + * Process byte stream from mouse and interpret complete data packets + */ +static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse) +{ + struct elantech_data *etd = psmouse->private; + struct input_dev *dev = psmouse->dev; + unsigned char *packet = psmouse->packet; + unsigned char p1, p2, p3; + + if (psmouse->pktcnt < psmouse->pktsize) + return PSMOUSE_GOOD_DATA; + + if (etd->debug) + elantech_packet_dump(packet, psmouse->pktsize); + + if (etd->reg_10 & ETP_R10_ABSOLUTE_MODE) { + if (etd->capabilities & ETP_CAP_ALTERNATE_TAP_BITS) { + /* byte 0: n1 n0 p2 p1 1 p3 R L */ + p1 = (packet[0] & 0x10) >> 4; + p2 = (packet[0] & 0x20) >> 5; + } else { + /* byte 0: D U p1 p2 1 p3 R L */ + p1 = (packet[0] & 0x20) >> 5; + p2 = (packet[0] & 0x10) >> 4; + } + p3 = (packet[0] & 0x04) >> 2; + if ((parity[packet[1]] != p1) || (parity[packet[2]] != p2) || + (parity[packet[3]] != p3)) + return PSMOUSE_BAD_DATA; + } else if (etd->reg_11 & ETP_R11_PARITY_CHECKING) { + /* byte 0: c c p2 p1 1 M R L */ + p1 = (packet[0] & 0x10) >> 4; + p2 = (packet[0] & 0x20) >> 5; + if ((parity[packet[1]] != p1) || (parity[packet[2]] != p2)) + return PSMOUSE_BAD_DATA; + /* Parity bit has not been sacrificed as middle mouse button bit */ + if (!(etd->capabilities & ETP_CAP_REPORTS_MIDDLE_BUTTON)) { + p3 = (packet[0] & 0x04) >> 2; + if (parity[packet[3]] != p3) + return PSMOUSE_BAD_DATA; + } + } + + if (etd->reg_10 & ETP_R10_ABSOLUTE_MODE) { + elantech_report_absolute(psmouse); + } else { + elantech_report_relative(psmouse); + } + + input_sync(dev); + + return PSMOUSE_FULL_PACKET; +} + +/* + * Initialise the touchpad to a default state. Because we don't know (yet) + * how to read registers we need to write some default values so we can + * report their contents when asked to. + */ +static void elantech_set_register_defaults(struct psmouse *psmouse) +{ + struct elantech_data *etd = psmouse->private; + + /* + * For now, use the Elantech Windows driver default values + */ + etd->reg_10 = 0x12; + etd->reg_11 = 0x8f; + etd->reg_20 = 0x0a; + etd->reg_21 = 0x60; + etd->reg_22 = 0xff; + etd->reg_25 = 0x03; + + /* + * The Windows driver mentions registers 23, 24 and 26 + * but seems to never actually write them + * Set the defaults anyway + */ + etd->reg_23 = 0x10; + etd->reg_24 = 0x10; + /* + * The Windows driver default value of 0x00 seems wrong as it + * disables smart edge cursor movement + */ + etd->reg_26 = 0x00; +} + +/* + * Write the registers we care about to the touchpad + */ +static int elantech_write_registers(struct psmouse *psmouse) +{ + struct elantech_data *etd = psmouse->private; + + /* + * The Windows driver mentions registers 23, 24 and 26 + * but seems to never actually write them + */ + if (elantech_write_reg(psmouse, 0x10, etd->reg_10) || + elantech_write_reg(psmouse, 0x11, etd->reg_11) || + elantech_write_reg(psmouse, 0x20, etd->reg_20) || + elantech_write_reg(psmouse, 0x21, etd->reg_21) || + elantech_write_reg(psmouse, 0x22, etd->reg_22) || + elantech_write_reg(psmouse, 0x25, etd->reg_25)) { + return -1; + } + + return 0; +} + +/* + * Set the appropriate event bits for the input subsystem + */ +static void elantech_set_input_params(struct psmouse *psmouse) +{ + struct elantech_data *etd = psmouse->private; + struct input_dev *dev = psmouse->dev; + + set_bit(EV_KEY, dev->evbit); + set_bit(BTN_LEFT, dev->keybit); + set_bit(BTN_MIDDLE, dev->keybit); + set_bit(BTN_RIGHT, dev->keybit); + + set_bit(BTN_TOUCH, dev->keybit); + set_bit(BTN_TOOL_FINGER, dev->keybit); + set_bit(BTN_TOOL_DOUBLETAP, dev->keybit); + set_bit(BTN_TOOL_TRIPLETAP, dev->keybit); + + /* Rocker button */ + if (etd->capabilities & ETP_CAP_HAS_ROCKER) { + set_bit(BTN_FORWARD, dev->keybit); + set_bit(BTN_BACK, dev->keybit); + } + + /* Corner taps */ + set_bit(BTN_0, dev->keybit); + set_bit(BTN_1, dev->keybit); + set_bit(BTN_2, dev->keybit); + set_bit(BTN_3, dev->keybit); + + set_bit(EV_REL, dev->evbit); + set_bit(REL_X, dev->relbit); + set_bit(REL_Y, dev->relbit); + set_bit(REL_WHEEL, dev->relbit); + set_bit(REL_HWHEEL, dev->relbit); + + set_bit(EV_ABS, dev->evbit); + input_set_abs_params(dev, ABS_X, ETP_XMIN, ETP_XMAX, 0, 0); + input_set_abs_params(dev, ABS_Y, ETP_YMIN, ETP_YMAX, 0, 0); + input_set_abs_params(dev, ABS_PRESSURE, 0, ETP_MAX_PRESSURE, 0, 0); +} + +struct elantech_attr_data { + size_t field_offset; + unsigned char reg; +}; + +/* + * Display a register value by reading a sysfs entry + */ +static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data, char *buf) +{ + struct elantech_data *etd = psmouse->private; + struct elantech_attr_data *attr = data; + unsigned char *reg = (unsigned char *) + etd + attr->field_offset; + + return sprintf(buf, "0x%02x\n", *reg); +} + +/* + * Write a register value by writing a sysfs entry + */ +static ssize_t elantech_set_int_attr(struct psmouse *psmouse, void *data, + const char *buf, size_t count) +{ + struct elantech_data *etd = psmouse->private; + struct elantech_attr_data *attr = data; + unsigned char *reg = (unsigned char *) + etd + attr->field_offset; + unsigned long value; + char *rest; + + value = simple_strtoul(buf, &rest, 16); + if (*rest || value > 255) + return -EINVAL; + + if (attr->reg == 0x10) { + /* Force on 4 byte mode when absolute mode gets selected */ + if ((value & ETP_R10_ABSOLUTE_MODE) && + !(etd->reg_11 & ETP_R11_4_BYTE_MODE)) { + etd->reg_11 |= ETP_R11_4_BYTE_MODE; + elantech_write_reg(psmouse, 0x11, etd->reg_11); + psmouse->pktsize = 4; + } + } else if (attr->reg == 0x11) { + if (value & ETP_R11_4_BYTE_MODE) + psmouse->pktsize = 4; + else { + /* Force off absolute mode when 4 byte mode is + * no longer selected */ + if (etd->reg_10 & ETP_R10_ABSOLUTE_MODE) { + etd->reg_10 ^= ETP_R10_ABSOLUTE_MODE; + elantech_write_reg(psmouse, 0x10, etd->reg_10); + } + psmouse->pktsize = 3; + } + } + + *reg = value; + elantech_write_reg(psmouse, attr->reg, value); + + return count; +} + +#define ELANTECH_INT_ATTR(_name, _register) \ + static struct elantech_attr_data elantech_attr_##_name = { \ + .field_offset = offsetof(struct elantech_data, _name), \ + .reg = _register, \ + }; \ + PSMOUSE_DEFINE_ATTR(_name, S_IWUSR | S_IRUGO, \ + &elantech_attr_##_name, \ + elantech_show_int_attr, \ + elantech_set_int_attr) + +ELANTECH_INT_ATTR(reg_10, 0x10); +ELANTECH_INT_ATTR(reg_11, 0x11); +ELANTECH_INT_ATTR(reg_20, 0x20); +ELANTECH_INT_ATTR(reg_21, 0x21); +ELANTECH_INT_ATTR(reg_22, 0x22); +ELANTECH_INT_ATTR(reg_23, 0x23); +ELANTECH_INT_ATTR(reg_24, 0x24); +ELANTECH_INT_ATTR(reg_25, 0x25); +ELANTECH_INT_ATTR(reg_26, 0x26); +ELANTECH_INT_ATTR(debug, 0); + +static struct attribute *elantech_attrs[] = { + &psmouse_attr_reg_10.dattr.attr, + &psmouse_attr_reg_11.dattr.attr, + &psmouse_attr_reg_20.dattr.attr, + &psmouse_attr_reg_21.dattr.attr, + &psmouse_attr_reg_22.dattr.attr, + &psmouse_attr_reg_23.dattr.attr, + &psmouse_attr_reg_24.dattr.attr, + &psmouse_attr_reg_25.dattr.attr, + &psmouse_attr_reg_26.dattr.attr, + &psmouse_attr_debug.dattr.attr, + NULL +}; + +static struct attribute_group elantech_attr_group = { + .attrs = elantech_attrs, +}; + +/* + * Use magic knock to detect Elantech touchpad + */ +int elantech_detect(struct psmouse *psmouse, int set_properties) +{ + struct ps2dev *ps2dev = &psmouse->ps2dev; + unsigned char param[3]; + + ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE); + ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11); + ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11); + ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11); + ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO); + + /* + * Report this in case there are Elantech models that use a different + * set of magic numbers + */ + if ((param[0] != 0x3c) || (param[1] != 0x03) || (param[2] != 0xc8)) { + pr_info("elantech.c: unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n", + param[0], param[1], param[2]); + return -1; + } + + if (set_properties) { + psmouse->vendor = "Elantech"; + psmouse->name = "Touchpad"; + } + + return 0; +} + +/* + * Clean up sysfs entries when disconnecting + */ +static void elantech_disconnect(struct psmouse *psmouse) +{ + sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj, + &elantech_attr_group); + kfree(psmouse->private); + psmouse->private = NULL; +} + +/* + * Rewrite registers when reconnecting + */ +static int elantech_reconnect(struct psmouse *psmouse) +{ + if (elantech_detect(psmouse, 0)) + return -1; + + if (elantech_write_registers(psmouse)) { + printk(KERN_ERR "elantech.c: failed to rewrite registers.\n"); + return -1; + } + + return 0; +} + +/* + * Initialize the touchpad and create sysfs entries + */ +int elantech_init(struct psmouse *psmouse) +{ + struct elantech_data *etd; + int i, error; + unsigned char param[3]; + + etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL); + psmouse->private = etd; + if (!etd) + return -1; + + parity[0] = 1; + for (i = 1; i < 256; i++) + parity[i] = (parity[i & (i - 1)] ^ 1); + + /* + * Why does the Elantech Windows driver try this? + * For now just report it and see if it makes sense + * when more people use this driver + */ + if (!synaptics_send_cmd(psmouse, SYN_QUE_IDENTIFY, param)) + pr_info("elantech.c: Synaptics identify query result 0x%02x, 0x%02x, 0x%02x.\n", + param[0], param[1], param[2]); + if (!synaptics_send_cmd(psmouse, SYN_QUE_MODES, param)) + pr_info("elantech.c: Synaptics modes query result 0x%02x, 0x%02x, 0x%02x.\n", + param[0], param[1], param[2]); + if (!synaptics_send_cmd(psmouse, SYN_QUE_CAPABILITIES, param)) { + pr_info("elantech.c: Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n", + param[0], param[1], param[2]); + etd->capabilities = param[0]; + } + + elantech_set_register_defaults(psmouse); + if (elantech_write_registers(psmouse)) { + printk(KERN_ERR "elantech.c: failed to write registers to default state.\n"); + goto init_fail; + } + elantech_set_input_params(psmouse); + + psmouse->protocol_handler = elantech_process_byte; + psmouse->disconnect = elantech_disconnect; + psmouse->reconnect = elantech_reconnect; + psmouse->pktsize = 4; + + error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj, + &elantech_attr_group); + if (error) { + printk(KERN_ERR "elantech.c: failed to create sysfs attributes, error: %d.\n", error); + goto init_fail; + } + + return 0; + +init_fail: + kfree(etd); + return -1; +} diff -purN -X linux-2.6.24.vanilla/Documentation/dontdiff linux-2.6.24.vanilla/drivers/input/mouse/elantech.h linux-2.6.24.elantech/drivers/input/mouse/elantech.h --- linux-2.6.24.vanilla/drivers/input/mouse/elantech.h 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.24.elantech/drivers/input/mouse/elantech.h 2008-01-26 01:38:58.000000000 +0100 @@ -0,0 +1,82 @@ +/* + * Elantech Touchpad driver (v3) + * + * Copyright (C) 2007-2008 Arjan Opmeer <[EMAIL PROTECTED]> + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 as published + * by the Free Software Foundation. + * + * Trademarks are the property of their respective owners. + */ + +#ifndef _ELANTECH_H +#define _ELANTECH_H + +/* + * Commands start with this value + */ +#define ELANTECH_COMMAND_START 0x11 + +/* + * Register bitmasks + */ +#define ETP_R10_ABSOLUTE_MODE 0x04 +#define ETP_R11_PARITY_CHECKING 0x01 +#define ETP_R11_4_BYTE_MODE 0x02 + +/* + * Capability bitmasks + */ +#define ETP_CAP_REPORTS_MIDDLE_BUTTON 0x02 +#define ETP_CAP_HAS_ROCKER 0x04 +#define ETP_CAP_ALTERNATE_TAP_BITS 0x10 + +/* + * One hard to find application note states that X axis range is 0 to 576 + * and Y axis range is 0 to 384. + * Edge fuzz might be necessary because of bezel around the touchpad. + */ +#define ETP_EDGE_FUZZ 32 + +#define ETP_XMIN ( 0 + ETP_EDGE_FUZZ) +#define ETP_XMAX (576 - ETP_EDGE_FUZZ) +#define ETP_YMIN ( 0 + ETP_EDGE_FUZZ) +#define ETP_YMAX (384 - ETP_EDGE_FUZZ) + +/* + * It seems the touchpad does not report pressure. + * Just choose some values for compatibility with X Synaptics driver + */ +#define ETP_MAX_PRESSURE 255 +#define ETP_DEF_PRESSURE 128 + +struct elantech_data { + unsigned char reg_10; + unsigned char reg_11; + unsigned char reg_20; + unsigned char reg_21; + unsigned char reg_22; + unsigned char reg_23; + unsigned char reg_24; + unsigned char reg_25; + unsigned char reg_26; + unsigned char debug; + unsigned char capabilities; +}; + +#ifdef CONFIG_MOUSE_PS2_ELANTECH +int elantech_detect(struct psmouse *psmouse, int set_properties); +int elantech_init(struct psmouse *psmouse); +#else +static inline int elantech_detect(struct psmouse *psmouse, int set_properties) +{ + return -ENOSYS; +} +static inline int elantech_init(struct psmouse *psmouse) +{ + return -ENOSYS; +} +#endif /* CONFIG_MOUSE_PS2_ELANTECH */ + +#endif diff -purN -X linux-2.6.24.vanilla/Documentation/dontdiff linux-2.6.24.vanilla/drivers/input/mouse/psmouse-base.c linux-2.6.24.elantech/drivers/input/mouse/psmouse-base.c --- linux-2.6.24.vanilla/drivers/input/mouse/psmouse-base.c 2008-01-24 23:58:37.000000000 +0100 +++ linux-2.6.24.elantech/drivers/input/mouse/psmouse-base.c 2008-01-26 01:38:58.000000000 +0100 @@ -29,6 +29,7 @@ #include "lifebook.h" #include "trackpoint.h" #include "touchkit_ps2.h" +#include "elantech.h" #define DRIVER_DESC "PS/2 mouse driver" @@ -654,6 +655,13 @@ static int psmouse_extensions(struct psm ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS); psmouse_reset(psmouse); + if (elantech_detect(psmouse, set_properties) == 0) { + if (max_proto > PSMOUSE_IMEX) { + if (!set_properties || elantech_init(psmouse) == 0) + return PSMOUSE_ELANTECH; + } + } + if (max_proto >= PSMOUSE_IMEX && im_explorer_detect(psmouse, set_properties) == 0) return PSMOUSE_IMEX; @@ -769,6 +777,15 @@ static const struct psmouse_protocol psm .alias = "cortps", .detect = cortron_detect, }, +#ifdef CONFIG_MOUSE_PS2_ELANTECH + { + .type = PSMOUSE_ELANTECH, + .name = "ETPS/2", + .alias = "elantech", + .detect = elantech_detect, + .init = elantech_init, + }, +#endif { .type = PSMOUSE_AUTO, .name = "auto", diff -purN -X linux-2.6.24.vanilla/Documentation/dontdiff linux-2.6.24.vanilla/drivers/input/mouse/psmouse.h linux-2.6.24.elantech/drivers/input/mouse/psmouse.h --- linux-2.6.24.vanilla/drivers/input/mouse/psmouse.h 2008-01-24 23:58:37.000000000 +0100 +++ linux-2.6.24.elantech/drivers/input/mouse/psmouse.h 2008-01-26 01:38:58.000000000 +0100 @@ -89,6 +89,7 @@ enum psmouse_type { PSMOUSE_TRACKPOINT, PSMOUSE_TOUCHKIT_PS2, PSMOUSE_CORTRON, + PSMOUSE_ELANTECH, PSMOUSE_AUTO /* This one should always be last */ };
