Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1 | /* |
Arjan Opmeer | 3f8c0df | 2009-04-18 19:05:40 -0700 | [diff] [blame] | 2 | * Elantech Touchpad driver (v6) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 3 | * |
Arjan Opmeer | 3f8c0df | 2009-04-18 19:05:40 -0700 | [diff] [blame] | 4 | * Copyright (C) 2007-2009 Arjan Opmeer <arjan@opmeer.net> |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 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 | #include <linux/delay.h> |
Hans de Goede | 36189cc | 2014-05-05 09:36:43 -0700 | [diff] [blame] | 14 | #include <linux/dmi.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 15 | #include <linux/slab.h> |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 16 | #include <linux/module.h> |
| 17 | #include <linux/input.h> |
Éric Piel | 89eec4d | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 18 | #include <linux/input/mt.h> |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 19 | #include <linux/serio.h> |
| 20 | #include <linux/libps2.h> |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 21 | #include <asm/unaligned.h> |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 22 | #include "psmouse.h" |
| 23 | #include "elantech.h" |
| 24 | |
Dmitry Torokhov | d4ae84a8 | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 25 | #define elantech_debug(fmt, ...) \ |
| 26 | do { \ |
| 27 | if (etd->debug) \ |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 28 | psmouse_printk(KERN_DEBUG, psmouse, \ |
| 29 | fmt, ##__VA_ARGS__); \ |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 30 | } while (0) |
| 31 | |
| 32 | /* |
| 33 | * Send a Synaptics style sliced query command |
| 34 | */ |
| 35 | static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c, |
| 36 | unsigned char *param) |
| 37 | { |
| 38 | if (psmouse_sliced_command(psmouse, c) || |
| 39 | ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 40 | psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 41 | return -1; |
| 42 | } |
| 43 | |
| 44 | return 0; |
| 45 | } |
| 46 | |
| 47 | /* |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 48 | * V3 and later support this fast command |
| 49 | */ |
| 50 | static int elantech_send_cmd(struct psmouse *psmouse, unsigned char c, |
| 51 | unsigned char *param) |
| 52 | { |
| 53 | struct ps2dev *ps2dev = &psmouse->ps2dev; |
| 54 | |
| 55 | if (ps2_command(ps2dev, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 56 | ps2_command(ps2dev, NULL, c) || |
| 57 | ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) { |
| 58 | psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c); |
| 59 | return -1; |
| 60 | } |
| 61 | |
| 62 | return 0; |
| 63 | } |
| 64 | |
| 65 | /* |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 66 | * A retrying version of ps2_command |
| 67 | */ |
| 68 | static int elantech_ps2_command(struct psmouse *psmouse, |
| 69 | unsigned char *param, int command) |
| 70 | { |
| 71 | struct ps2dev *ps2dev = &psmouse->ps2dev; |
| 72 | struct elantech_data *etd = psmouse->private; |
| 73 | int rc; |
| 74 | int tries = ETP_PS2_COMMAND_TRIES; |
| 75 | |
| 76 | do { |
| 77 | rc = ps2_command(ps2dev, param, command); |
| 78 | if (rc == 0) |
| 79 | break; |
| 80 | tries--; |
Dmitry Torokhov | d4ae84a8 | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 81 | elantech_debug("retrying ps2 command 0x%02x (%d).\n", |
| 82 | command, tries); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 83 | msleep(ETP_PS2_COMMAND_DELAY); |
| 84 | } while (tries > 0); |
| 85 | |
| 86 | if (rc) |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 87 | psmouse_err(psmouse, "ps2 command 0x%02x failed.\n", command); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 88 | |
| 89 | return rc; |
| 90 | } |
| 91 | |
| 92 | /* |
| 93 | * Send an Elantech style special command to read a value from a register |
| 94 | */ |
| 95 | static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg, |
| 96 | unsigned char *val) |
| 97 | { |
| 98 | struct elantech_data *etd = psmouse->private; |
| 99 | unsigned char param[3]; |
| 100 | int rc = 0; |
| 101 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 102 | if (reg < 0x07 || reg > 0x26) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 103 | return -1; |
| 104 | |
| 105 | if (reg > 0x11 && reg < 0x20) |
| 106 | return -1; |
| 107 | |
| 108 | switch (etd->hw_version) { |
| 109 | case 1: |
| 110 | if (psmouse_sliced_command(psmouse, ETP_REGISTER_READ) || |
| 111 | psmouse_sliced_command(psmouse, reg) || |
| 112 | ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) { |
| 113 | rc = -1; |
| 114 | } |
| 115 | break; |
| 116 | |
| 117 | case 2: |
| 118 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 119 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READ) || |
| 120 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 121 | elantech_ps2_command(psmouse, NULL, reg) || |
| 122 | elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) { |
| 123 | rc = -1; |
| 124 | } |
| 125 | break; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 126 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 127 | case 3 ... 4: |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 128 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 129 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) || |
| 130 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 131 | elantech_ps2_command(psmouse, NULL, reg) || |
| 132 | elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) { |
| 133 | rc = -1; |
| 134 | } |
| 135 | break; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 136 | } |
| 137 | |
| 138 | if (rc) |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 139 | psmouse_err(psmouse, "failed to read register 0x%02x.\n", reg); |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 140 | else if (etd->hw_version != 4) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 141 | *val = param[0]; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 142 | else |
| 143 | *val = param[1]; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 144 | |
| 145 | return rc; |
| 146 | } |
| 147 | |
| 148 | /* |
| 149 | * Send an Elantech style special command to write a register with a value |
| 150 | */ |
| 151 | static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg, |
| 152 | unsigned char val) |
| 153 | { |
| 154 | struct elantech_data *etd = psmouse->private; |
| 155 | int rc = 0; |
| 156 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 157 | if (reg < 0x07 || reg > 0x26) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 158 | return -1; |
| 159 | |
| 160 | if (reg > 0x11 && reg < 0x20) |
| 161 | return -1; |
| 162 | |
| 163 | switch (etd->hw_version) { |
| 164 | case 1: |
| 165 | if (psmouse_sliced_command(psmouse, ETP_REGISTER_WRITE) || |
| 166 | psmouse_sliced_command(psmouse, reg) || |
| 167 | psmouse_sliced_command(psmouse, val) || |
| 168 | ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) { |
| 169 | rc = -1; |
| 170 | } |
| 171 | break; |
| 172 | |
| 173 | case 2: |
| 174 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 175 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_WRITE) || |
| 176 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 177 | elantech_ps2_command(psmouse, NULL, reg) || |
| 178 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 179 | elantech_ps2_command(psmouse, NULL, val) || |
| 180 | elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) { |
| 181 | rc = -1; |
| 182 | } |
| 183 | break; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 184 | |
| 185 | case 3: |
| 186 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 187 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) || |
| 188 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 189 | elantech_ps2_command(psmouse, NULL, reg) || |
| 190 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 191 | elantech_ps2_command(psmouse, NULL, val) || |
| 192 | elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) { |
| 193 | rc = -1; |
| 194 | } |
| 195 | break; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 196 | |
| 197 | case 4: |
| 198 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 199 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) || |
| 200 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 201 | elantech_ps2_command(psmouse, NULL, reg) || |
| 202 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 203 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) || |
| 204 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 205 | elantech_ps2_command(psmouse, NULL, val) || |
| 206 | elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) { |
| 207 | rc = -1; |
| 208 | } |
| 209 | break; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 210 | } |
| 211 | |
| 212 | if (rc) |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 213 | psmouse_err(psmouse, |
| 214 | "failed to write register 0x%02x with value 0x%02x.\n", |
| 215 | reg, val); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 216 | |
| 217 | return rc; |
| 218 | } |
| 219 | |
| 220 | /* |
| 221 | * Dump a complete mouse movement packet to the syslog |
| 222 | */ |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 223 | static void elantech_packet_dump(struct psmouse *psmouse) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 224 | { |
| 225 | int i; |
| 226 | |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 227 | psmouse_printk(KERN_DEBUG, psmouse, "PS/2 packet ["); |
| 228 | for (i = 0; i < psmouse->pktsize; i++) |
| 229 | printk("%s0x%02x ", i ? ", " : " ", psmouse->packet[i]); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 230 | printk("]\n"); |
| 231 | } |
| 232 | |
| 233 | /* |
| 234 | * Interpret complete data packets and report absolute mode input events for |
| 235 | * hardware version 1. (4 byte packets) |
| 236 | */ |
| 237 | static void elantech_report_absolute_v1(struct psmouse *psmouse) |
| 238 | { |
| 239 | struct input_dev *dev = psmouse->dev; |
| 240 | struct elantech_data *etd = psmouse->private; |
| 241 | unsigned char *packet = psmouse->packet; |
| 242 | int fingers; |
| 243 | |
Dmitry Torokhov | 504e8be | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 244 | if (etd->fw_version < 0x020000) { |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 245 | /* |
| 246 | * byte 0: D U p1 p2 1 p3 R L |
| 247 | * byte 1: f 0 th tw x9 x8 y9 y8 |
| 248 | */ |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 249 | fingers = ((packet[1] & 0x80) >> 7) + |
| 250 | ((packet[1] & 0x30) >> 4); |
| 251 | } else { |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 252 | /* |
| 253 | * byte 0: n1 n0 p2 p1 1 p3 R L |
| 254 | * byte 1: 0 0 0 0 x9 x8 y9 y8 |
| 255 | */ |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 256 | fingers = (packet[0] & 0xc0) >> 6; |
| 257 | } |
| 258 | |
Arjan Opmeer | 3f8c0df | 2009-04-18 19:05:40 -0700 | [diff] [blame] | 259 | if (etd->jumpy_cursor) { |
Éric Piel | 7f29f17 | 2010-08-05 23:51:49 -0700 | [diff] [blame] | 260 | if (fingers != 1) { |
| 261 | etd->single_finger_reports = 0; |
| 262 | } else if (etd->single_finger_reports < 2) { |
| 263 | /* Discard first 2 reports of one finger, bogus */ |
| 264 | etd->single_finger_reports++; |
Dmitry Torokhov | d4ae84a8 | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 265 | elantech_debug("discarding packet\n"); |
Éric Piel | 7f29f17 | 2010-08-05 23:51:49 -0700 | [diff] [blame] | 266 | return; |
Arjan Opmeer | 3f8c0df | 2009-04-18 19:05:40 -0700 | [diff] [blame] | 267 | } |
| 268 | } |
| 269 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 270 | input_report_key(dev, BTN_TOUCH, fingers != 0); |
| 271 | |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 272 | /* |
| 273 | * byte 2: x7 x6 x5 x4 x3 x2 x1 x0 |
| 274 | * byte 3: y7 y6 y5 y4 y3 y2 y1 y0 |
| 275 | */ |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 276 | if (fingers) { |
| 277 | input_report_abs(dev, ABS_X, |
| 278 | ((packet[1] & 0x0c) << 6) | packet[2]); |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 279 | input_report_abs(dev, ABS_Y, |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 280 | etd->y_max - (((packet[1] & 0x03) << 8) | packet[3])); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 281 | } |
| 282 | |
| 283 | input_report_key(dev, BTN_TOOL_FINGER, fingers == 1); |
| 284 | input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2); |
| 285 | input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3); |
| 286 | input_report_key(dev, BTN_LEFT, packet[0] & 0x01); |
| 287 | input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); |
| 288 | |
Dmitry Torokhov | 504e8be | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 289 | if (etd->fw_version < 0x020000 && |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 290 | (etd->capabilities[0] & ETP_CAP_HAS_ROCKER)) { |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 291 | /* rocker up */ |
| 292 | input_report_key(dev, BTN_FORWARD, packet[0] & 0x40); |
| 293 | /* rocker down */ |
| 294 | input_report_key(dev, BTN_BACK, packet[0] & 0x80); |
| 295 | } |
| 296 | |
| 297 | input_sync(dev); |
| 298 | } |
| 299 | |
Éric Piel | 89eec4d | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 300 | static void elantech_set_slot(struct input_dev *dev, int slot, bool active, |
| 301 | unsigned int x, unsigned int y) |
| 302 | { |
| 303 | input_mt_slot(dev, slot); |
| 304 | input_mt_report_slot_state(dev, MT_TOOL_FINGER, active); |
| 305 | if (active) { |
| 306 | input_report_abs(dev, ABS_MT_POSITION_X, x); |
| 307 | input_report_abs(dev, ABS_MT_POSITION_Y, y); |
| 308 | } |
| 309 | } |
| 310 | |
| 311 | /* x1 < x2 and y1 < y2 when two fingers, x = y = 0 when not pressed */ |
| 312 | static void elantech_report_semi_mt_data(struct input_dev *dev, |
| 313 | unsigned int num_fingers, |
| 314 | unsigned int x1, unsigned int y1, |
| 315 | unsigned int x2, unsigned int y2) |
| 316 | { |
| 317 | elantech_set_slot(dev, 0, num_fingers != 0, x1, y1); |
Benjamin Tissoires | 3c0213d | 2015-04-23 09:08:43 -0700 | [diff] [blame] | 318 | elantech_set_slot(dev, 1, num_fingers >= 2, x2, y2); |
Éric Piel | 89eec4d | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 319 | } |
| 320 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 321 | /* |
| 322 | * Interpret complete data packets and report absolute mode input events for |
| 323 | * hardware version 2. (6 byte packets) |
| 324 | */ |
| 325 | static void elantech_report_absolute_v2(struct psmouse *psmouse) |
| 326 | { |
Éric Piel | f941c70 | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 327 | struct elantech_data *etd = psmouse->private; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 328 | struct input_dev *dev = psmouse->dev; |
| 329 | unsigned char *packet = psmouse->packet; |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 330 | unsigned int fingers, x1 = 0, y1 = 0, x2 = 0, y2 = 0; |
| 331 | unsigned int width = 0, pres = 0; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 332 | |
| 333 | /* byte 0: n1 n0 . . . . R L */ |
| 334 | fingers = (packet[0] & 0xc0) >> 6; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 335 | |
| 336 | switch (fingers) { |
Éric Piel | 22462d9f | 2010-08-05 23:51:49 -0700 | [diff] [blame] | 337 | case 3: |
| 338 | /* |
| 339 | * Same as one finger, except report of more than 3 fingers: |
| 340 | * byte 3: n4 . w1 w0 . . . . |
| 341 | */ |
| 342 | if (packet[3] & 0x80) |
| 343 | fingers = 4; |
| 344 | /* pass through... */ |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 345 | case 1: |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 346 | /* |
JJ Ding | 1155961 | 2011-09-09 10:22:19 -0700 | [diff] [blame] | 347 | * byte 1: . . . . x11 x10 x9 x8 |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 348 | * byte 2: x7 x6 x5 x4 x4 x2 x1 x0 |
| 349 | */ |
JJ Ding | 1155961 | 2011-09-09 10:22:19 -0700 | [diff] [blame] | 350 | x1 = ((packet[1] & 0x0f) << 8) | packet[2]; |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 351 | /* |
JJ Ding | 1155961 | 2011-09-09 10:22:19 -0700 | [diff] [blame] | 352 | * byte 4: . . . . y11 y10 y9 y8 |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 353 | * byte 5: y7 y6 y5 y4 y3 y2 y1 y0 |
| 354 | */ |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 355 | y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]); |
Éric Piel | 89eec4d | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 356 | |
Éric Piel | f941c70 | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 357 | pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4); |
| 358 | width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 359 | break; |
| 360 | |
| 361 | case 2: |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 362 | /* |
| 363 | * The coordinate of each finger is reported separately |
| 364 | * with a lower resolution for two finger touches: |
| 365 | * byte 0: . . ay8 ax8 . . . . |
| 366 | * byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0 |
| 367 | */ |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 368 | x1 = (((packet[0] & 0x10) << 4) | packet[1]) << 2; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 369 | /* byte 2: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 */ |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 370 | y1 = etd->y_max - |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 371 | ((((packet[0] & 0x20) << 3) | packet[2]) << 2); |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 372 | /* |
| 373 | * byte 3: . . by8 bx8 . . . . |
| 374 | * byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0 |
| 375 | */ |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 376 | x2 = (((packet[3] & 0x10) << 4) | packet[4]) << 2; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 377 | /* byte 5: by7 by8 by5 by4 by3 by2 by1 by0 */ |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 378 | y2 = etd->y_max - |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 379 | ((((packet[3] & 0x20) << 3) | packet[5]) << 2); |
Éric Piel | f941c70 | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 380 | |
| 381 | /* Unknown so just report sensible values */ |
| 382 | pres = 127; |
| 383 | width = 7; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 384 | break; |
| 385 | } |
| 386 | |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 387 | input_report_key(dev, BTN_TOUCH, fingers != 0); |
| 388 | if (fingers != 0) { |
| 389 | input_report_abs(dev, ABS_X, x1); |
| 390 | input_report_abs(dev, ABS_Y, y1); |
| 391 | } |
Éric Piel | 89eec4d | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 392 | elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 393 | input_report_key(dev, BTN_TOOL_FINGER, fingers == 1); |
| 394 | input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2); |
| 395 | input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3); |
Éric Piel | 22462d9f | 2010-08-05 23:51:49 -0700 | [diff] [blame] | 396 | input_report_key(dev, BTN_TOOL_QUADTAP, fingers == 4); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 397 | input_report_key(dev, BTN_LEFT, packet[0] & 0x01); |
| 398 | input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); |
Éric Piel | f941c70 | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 399 | if (etd->reports_pressure) { |
| 400 | input_report_abs(dev, ABS_PRESSURE, pres); |
| 401 | input_report_abs(dev, ABS_TOOL_WIDTH, width); |
| 402 | } |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 403 | |
| 404 | input_sync(dev); |
| 405 | } |
| 406 | |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 407 | static void elantech_report_trackpoint(struct psmouse *psmouse, |
| 408 | int packet_type) |
| 409 | { |
| 410 | /* |
| 411 | * byte 0: 0 0 sx sy 0 M R L |
| 412 | * byte 1:~sx 0 0 0 0 0 0 0 |
| 413 | * byte 2:~sy 0 0 0 0 0 0 0 |
| 414 | * byte 3: 0 0 ~sy ~sx 0 1 1 0 |
| 415 | * byte 4: x7 x6 x5 x4 x3 x2 x1 x0 |
| 416 | * byte 5: y7 y6 y5 y4 y3 y2 y1 y0 |
| 417 | * |
| 418 | * x and y are written in two's complement spread |
| 419 | * over 9 bits with sx/sy the relative top bit and |
| 420 | * x7..x0 and y7..y0 the lower bits. |
| 421 | * The sign of y is opposite to what the input driver |
| 422 | * expects for a relative movement |
| 423 | */ |
| 424 | |
| 425 | struct elantech_data *etd = psmouse->private; |
| 426 | struct input_dev *tp_dev = etd->tp_dev; |
| 427 | unsigned char *packet = psmouse->packet; |
| 428 | int x, y; |
| 429 | u32 t; |
| 430 | |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 431 | t = get_unaligned_le32(&packet[0]); |
| 432 | |
| 433 | switch (t & ~7U) { |
| 434 | case 0x06000030U: |
| 435 | case 0x16008020U: |
| 436 | case 0x26800010U: |
| 437 | case 0x36808000U: |
| 438 | x = packet[4] - (int)((packet[1]^0x80) << 1); |
| 439 | y = (int)((packet[2]^0x80) << 1) - packet[5]; |
| 440 | |
| 441 | input_report_key(tp_dev, BTN_LEFT, packet[0] & 0x01); |
| 442 | input_report_key(tp_dev, BTN_RIGHT, packet[0] & 0x02); |
| 443 | input_report_key(tp_dev, BTN_MIDDLE, packet[0] & 0x04); |
| 444 | |
| 445 | input_report_rel(tp_dev, REL_X, x); |
| 446 | input_report_rel(tp_dev, REL_Y, y); |
| 447 | |
| 448 | input_sync(tp_dev); |
| 449 | |
| 450 | break; |
| 451 | |
| 452 | default: |
| 453 | /* Dump unexpected packet sequences if debug=1 (default) */ |
| 454 | if (etd->debug == 1) |
| 455 | elantech_packet_dump(psmouse); |
| 456 | |
| 457 | break; |
| 458 | } |
| 459 | } |
| 460 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 461 | /* |
| 462 | * Interpret complete data packets and report absolute mode input events for |
| 463 | * hardware version 3. (12 byte packets for two fingers) |
| 464 | */ |
| 465 | static void elantech_report_absolute_v3(struct psmouse *psmouse, |
| 466 | int packet_type) |
| 467 | { |
| 468 | struct input_dev *dev = psmouse->dev; |
| 469 | struct elantech_data *etd = psmouse->private; |
| 470 | unsigned char *packet = psmouse->packet; |
| 471 | unsigned int fingers = 0, x1 = 0, y1 = 0, x2 = 0, y2 = 0; |
| 472 | unsigned int width = 0, pres = 0; |
| 473 | |
| 474 | /* byte 0: n1 n0 . . . . R L */ |
| 475 | fingers = (packet[0] & 0xc0) >> 6; |
| 476 | |
| 477 | switch (fingers) { |
| 478 | case 3: |
| 479 | case 1: |
| 480 | /* |
| 481 | * byte 1: . . . . x11 x10 x9 x8 |
| 482 | * byte 2: x7 x6 x5 x4 x4 x2 x1 x0 |
| 483 | */ |
| 484 | x1 = ((packet[1] & 0x0f) << 8) | packet[2]; |
| 485 | /* |
| 486 | * byte 4: . . . . y11 y10 y9 y8 |
| 487 | * byte 5: y7 y6 y5 y4 y3 y2 y1 y0 |
| 488 | */ |
| 489 | y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]); |
| 490 | break; |
| 491 | |
| 492 | case 2: |
| 493 | if (packet_type == PACKET_V3_HEAD) { |
| 494 | /* |
| 495 | * byte 1: . . . . ax11 ax10 ax9 ax8 |
| 496 | * byte 2: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0 |
| 497 | */ |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 498 | etd->mt[0].x = ((packet[1] & 0x0f) << 8) | packet[2]; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 499 | /* |
| 500 | * byte 4: . . . . ay11 ay10 ay9 ay8 |
| 501 | * byte 5: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 |
| 502 | */ |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 503 | etd->mt[0].y = etd->y_max - |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 504 | (((packet[4] & 0x0f) << 8) | packet[5]); |
| 505 | /* |
| 506 | * wait for next packet |
| 507 | */ |
| 508 | return; |
| 509 | } |
| 510 | |
| 511 | /* packet_type == PACKET_V3_TAIL */ |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 512 | x1 = etd->mt[0].x; |
| 513 | y1 = etd->mt[0].y; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 514 | x2 = ((packet[1] & 0x0f) << 8) | packet[2]; |
| 515 | y2 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]); |
| 516 | break; |
| 517 | } |
| 518 | |
| 519 | pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4); |
| 520 | width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4); |
| 521 | |
| 522 | input_report_key(dev, BTN_TOUCH, fingers != 0); |
| 523 | if (fingers != 0) { |
| 524 | input_report_abs(dev, ABS_X, x1); |
| 525 | input_report_abs(dev, ABS_Y, y1); |
| 526 | } |
| 527 | elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2); |
| 528 | input_report_key(dev, BTN_TOOL_FINGER, fingers == 1); |
| 529 | input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2); |
| 530 | input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3); |
Hans de Goede | cd9e83e | 2014-06-07 22:35:07 -0700 | [diff] [blame] | 531 | |
| 532 | /* For clickpads map both buttons to BTN_LEFT */ |
| 533 | if (etd->fw_version & 0x001000) { |
| 534 | input_report_key(dev, BTN_LEFT, packet[0] & 0x03); |
| 535 | } else { |
| 536 | input_report_key(dev, BTN_LEFT, packet[0] & 0x01); |
| 537 | input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); |
| 538 | } |
| 539 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 540 | input_report_abs(dev, ABS_PRESSURE, pres); |
| 541 | input_report_abs(dev, ABS_TOOL_WIDTH, width); |
| 542 | |
| 543 | input_sync(dev); |
| 544 | } |
| 545 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 546 | static void elantech_input_sync_v4(struct psmouse *psmouse) |
| 547 | { |
| 548 | struct input_dev *dev = psmouse->dev; |
Hans de Goede | cd9e83e | 2014-06-07 22:35:07 -0700 | [diff] [blame] | 549 | struct elantech_data *etd = psmouse->private; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 550 | unsigned char *packet = psmouse->packet; |
| 551 | |
Hans de Goede | cd9e83e | 2014-06-07 22:35:07 -0700 | [diff] [blame] | 552 | /* For clickpads map both buttons to BTN_LEFT */ |
| 553 | if (etd->fw_version & 0x001000) { |
| 554 | input_report_key(dev, BTN_LEFT, packet[0] & 0x03); |
| 555 | } else { |
| 556 | input_report_key(dev, BTN_LEFT, packet[0] & 0x01); |
| 557 | input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); |
Ulrik De Bie | f386474 | 2014-11-13 17:45:12 -0800 | [diff] [blame] | 558 | input_report_key(dev, BTN_MIDDLE, packet[0] & 0x04); |
Hans de Goede | cd9e83e | 2014-06-07 22:35:07 -0700 | [diff] [blame] | 559 | } |
| 560 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 561 | input_mt_report_pointer_emulation(dev, true); |
| 562 | input_sync(dev); |
| 563 | } |
| 564 | |
| 565 | static void process_packet_status_v4(struct psmouse *psmouse) |
| 566 | { |
| 567 | struct input_dev *dev = psmouse->dev; |
| 568 | unsigned char *packet = psmouse->packet; |
| 569 | unsigned fingers; |
| 570 | int i; |
| 571 | |
| 572 | /* notify finger state change */ |
| 573 | fingers = packet[1] & 0x1f; |
| 574 | for (i = 0; i < ETP_MAX_FINGERS; i++) { |
| 575 | if ((fingers & (1 << i)) == 0) { |
| 576 | input_mt_slot(dev, i); |
| 577 | input_mt_report_slot_state(dev, MT_TOOL_FINGER, false); |
| 578 | } |
| 579 | } |
| 580 | |
| 581 | elantech_input_sync_v4(psmouse); |
| 582 | } |
| 583 | |
| 584 | static void process_packet_head_v4(struct psmouse *psmouse) |
| 585 | { |
| 586 | struct input_dev *dev = psmouse->dev; |
| 587 | struct elantech_data *etd = psmouse->private; |
| 588 | unsigned char *packet = psmouse->packet; |
| 589 | int id = ((packet[3] & 0xe0) >> 5) - 1; |
| 590 | int pres, traces; |
| 591 | |
| 592 | if (id < 0) |
| 593 | return; |
| 594 | |
| 595 | etd->mt[id].x = ((packet[1] & 0x0f) << 8) | packet[2]; |
| 596 | etd->mt[id].y = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]); |
| 597 | pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4); |
| 598 | traces = (packet[0] & 0xf0) >> 4; |
| 599 | |
| 600 | input_mt_slot(dev, id); |
| 601 | input_mt_report_slot_state(dev, MT_TOOL_FINGER, true); |
| 602 | |
| 603 | input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x); |
| 604 | input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y); |
| 605 | input_report_abs(dev, ABS_MT_PRESSURE, pres); |
| 606 | input_report_abs(dev, ABS_MT_TOUCH_MAJOR, traces * etd->width); |
| 607 | /* report this for backwards compatibility */ |
| 608 | input_report_abs(dev, ABS_TOOL_WIDTH, traces); |
| 609 | |
| 610 | elantech_input_sync_v4(psmouse); |
| 611 | } |
| 612 | |
| 613 | static void process_packet_motion_v4(struct psmouse *psmouse) |
| 614 | { |
| 615 | struct input_dev *dev = psmouse->dev; |
| 616 | struct elantech_data *etd = psmouse->private; |
| 617 | unsigned char *packet = psmouse->packet; |
| 618 | int weight, delta_x1 = 0, delta_y1 = 0, delta_x2 = 0, delta_y2 = 0; |
| 619 | int id, sid; |
| 620 | |
| 621 | id = ((packet[0] & 0xe0) >> 5) - 1; |
| 622 | if (id < 0) |
| 623 | return; |
| 624 | |
| 625 | sid = ((packet[3] & 0xe0) >> 5) - 1; |
| 626 | weight = (packet[0] & 0x10) ? ETP_WEIGHT_VALUE : 1; |
| 627 | /* |
| 628 | * Motion packets give us the delta of x, y values of specific fingers, |
| 629 | * but in two's complement. Let the compiler do the conversion for us. |
| 630 | * Also _enlarge_ the numbers to int, in case of overflow. |
| 631 | */ |
| 632 | delta_x1 = (signed char)packet[1]; |
| 633 | delta_y1 = (signed char)packet[2]; |
| 634 | delta_x2 = (signed char)packet[4]; |
| 635 | delta_y2 = (signed char)packet[5]; |
| 636 | |
| 637 | etd->mt[id].x += delta_x1 * weight; |
| 638 | etd->mt[id].y -= delta_y1 * weight; |
| 639 | input_mt_slot(dev, id); |
| 640 | input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x); |
| 641 | input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y); |
| 642 | |
| 643 | if (sid >= 0) { |
| 644 | etd->mt[sid].x += delta_x2 * weight; |
| 645 | etd->mt[sid].y -= delta_y2 * weight; |
| 646 | input_mt_slot(dev, sid); |
| 647 | input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[sid].x); |
| 648 | input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[sid].y); |
| 649 | } |
| 650 | |
| 651 | elantech_input_sync_v4(psmouse); |
| 652 | } |
| 653 | |
| 654 | static void elantech_report_absolute_v4(struct psmouse *psmouse, |
| 655 | int packet_type) |
| 656 | { |
| 657 | switch (packet_type) { |
| 658 | case PACKET_V4_STATUS: |
| 659 | process_packet_status_v4(psmouse); |
| 660 | break; |
| 661 | |
| 662 | case PACKET_V4_HEAD: |
| 663 | process_packet_head_v4(psmouse); |
| 664 | break; |
| 665 | |
| 666 | case PACKET_V4_MOTION: |
| 667 | process_packet_motion_v4(psmouse); |
| 668 | break; |
| 669 | |
| 670 | case PACKET_UNKNOWN: |
| 671 | default: |
| 672 | /* impossible to get here */ |
| 673 | break; |
| 674 | } |
| 675 | } |
| 676 | |
JJ Ding | 7894f21 | 2011-09-09 10:28:04 -0700 | [diff] [blame] | 677 | static int elantech_packet_check_v1(struct psmouse *psmouse) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 678 | { |
| 679 | struct elantech_data *etd = psmouse->private; |
| 680 | unsigned char *packet = psmouse->packet; |
| 681 | unsigned char p1, p2, p3; |
| 682 | |
| 683 | /* Parity bits are placed differently */ |
Dmitry Torokhov | 504e8be | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 684 | if (etd->fw_version < 0x020000) { |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 685 | /* byte 0: D U p1 p2 1 p3 R L */ |
| 686 | p1 = (packet[0] & 0x20) >> 5; |
| 687 | p2 = (packet[0] & 0x10) >> 4; |
| 688 | } else { |
| 689 | /* byte 0: n1 n0 p2 p1 1 p3 R L */ |
| 690 | p1 = (packet[0] & 0x10) >> 4; |
| 691 | p2 = (packet[0] & 0x20) >> 5; |
| 692 | } |
| 693 | |
| 694 | p3 = (packet[0] & 0x04) >> 2; |
| 695 | |
| 696 | return etd->parity[packet[1]] == p1 && |
| 697 | etd->parity[packet[2]] == p2 && |
| 698 | etd->parity[packet[3]] == p3; |
| 699 | } |
| 700 | |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 701 | static int elantech_debounce_check_v2(struct psmouse *psmouse) |
| 702 | { |
| 703 | /* |
| 704 | * When we encounter packet that matches this exactly, it means the |
| 705 | * hardware is in debounce status. Just ignore the whole packet. |
| 706 | */ |
| 707 | const u8 debounce_packet[] = { 0x84, 0xff, 0xff, 0x02, 0xff, 0xff }; |
| 708 | unsigned char *packet = psmouse->packet; |
| 709 | |
| 710 | return !memcmp(packet, debounce_packet, sizeof(debounce_packet)); |
| 711 | } |
| 712 | |
JJ Ding | 7894f21 | 2011-09-09 10:28:04 -0700 | [diff] [blame] | 713 | static int elantech_packet_check_v2(struct psmouse *psmouse) |
| 714 | { |
| 715 | struct elantech_data *etd = psmouse->private; |
| 716 | unsigned char *packet = psmouse->packet; |
| 717 | |
| 718 | /* |
| 719 | * V2 hardware has two flavors. Older ones that do not report pressure, |
| 720 | * and newer ones that reports pressure and width. With newer ones, all |
| 721 | * packets (1, 2, 3 finger touch) have the same constant bits. With |
| 722 | * older ones, 1/3 finger touch packets and 2 finger touch packets |
| 723 | * have different constant bits. |
| 724 | * With all three cases, if the constant bits are not exactly what I |
| 725 | * expected, I consider them invalid. |
| 726 | */ |
| 727 | if (etd->reports_pressure) |
| 728 | return (packet[0] & 0x0c) == 0x04 && |
| 729 | (packet[3] & 0x0f) == 0x02; |
| 730 | |
| 731 | if ((packet[0] & 0xc0) == 0x80) |
| 732 | return (packet[0] & 0x0c) == 0x0c && |
| 733 | (packet[3] & 0x0e) == 0x08; |
| 734 | |
| 735 | return (packet[0] & 0x3c) == 0x3c && |
| 736 | (packet[1] & 0xf0) == 0x00 && |
| 737 | (packet[3] & 0x3e) == 0x38 && |
| 738 | (packet[4] & 0xf0) == 0x00; |
| 739 | } |
| 740 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 741 | /* |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 742 | * We check the constant bits to determine what packet type we get, |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 743 | * so packet checking is mandatory for v3 and later hardware. |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 744 | */ |
| 745 | static int elantech_packet_check_v3(struct psmouse *psmouse) |
| 746 | { |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 747 | struct elantech_data *etd = psmouse->private; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 748 | const u8 debounce_packet[] = { 0xc4, 0xff, 0xff, 0x02, 0xff, 0xff }; |
| 749 | unsigned char *packet = psmouse->packet; |
| 750 | |
| 751 | /* |
| 752 | * check debounce first, it has the same signature in byte 0 |
| 753 | * and byte 3 as PACKET_V3_HEAD. |
| 754 | */ |
| 755 | if (!memcmp(packet, debounce_packet, sizeof(debounce_packet))) |
| 756 | return PACKET_DEBOUNCE; |
| 757 | |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 758 | /* |
| 759 | * If the hardware flag 'crc_enabled' is set the packets have |
| 760 | * different signatures. |
| 761 | */ |
| 762 | if (etd->crc_enabled) { |
| 763 | if ((packet[3] & 0x09) == 0x08) |
| 764 | return PACKET_V3_HEAD; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 765 | |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 766 | if ((packet[3] & 0x09) == 0x09) |
| 767 | return PACKET_V3_TAIL; |
| 768 | } else { |
| 769 | if ((packet[0] & 0x0c) == 0x04 && (packet[3] & 0xcf) == 0x02) |
| 770 | return PACKET_V3_HEAD; |
| 771 | |
| 772 | if ((packet[0] & 0x0c) == 0x0c && (packet[3] & 0xce) == 0x0c) |
| 773 | return PACKET_V3_TAIL; |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 774 | if ((packet[3] & 0x0f) == 0x06) |
| 775 | return PACKET_TRACKPOINT; |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 776 | } |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 777 | |
| 778 | return PACKET_UNKNOWN; |
| 779 | } |
| 780 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 781 | static int elantech_packet_check_v4(struct psmouse *psmouse) |
| 782 | { |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 783 | struct elantech_data *etd = psmouse->private; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 784 | unsigned char *packet = psmouse->packet; |
Matteo Delfino | 9eebed7 | 2013-07-06 21:52:26 -0700 | [diff] [blame] | 785 | unsigned char packet_type = packet[3] & 0x03; |
Duson Lin | 6b30c73 | 2015-08-07 14:37:24 -0700 | [diff] [blame] | 786 | unsigned int ic_version; |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 787 | bool sanity_check; |
| 788 | |
Dmitry Torokhov | d0ab547 | 2014-11-19 23:33:07 -0800 | [diff] [blame] | 789 | if (etd->tp_dev && (packet[3] & 0x0f) == 0x06) |
Ulrik De Bie | caeb0d3 | 2014-11-07 23:51:34 -0800 | [diff] [blame] | 790 | return PACKET_TRACKPOINT; |
| 791 | |
Duson Lin | 6b30c73 | 2015-08-07 14:37:24 -0700 | [diff] [blame] | 792 | /* This represents the version of IC body. */ |
| 793 | ic_version = (etd->fw_version & 0x0f0000) >> 16; |
| 794 | |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 795 | /* |
| 796 | * Sanity check based on the constant bits of a packet. |
| 797 | * The constant bits change depending on the value of |
Duson Lin | 6b30c73 | 2015-08-07 14:37:24 -0700 | [diff] [blame] | 798 | * the hardware flag 'crc_enabled' and the version of |
| 799 | * the IC body, but are the same for every packet, |
| 800 | * regardless of the type. |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 801 | */ |
| 802 | if (etd->crc_enabled) |
| 803 | sanity_check = ((packet[3] & 0x08) == 0x00); |
Duson Lin | 6b30c73 | 2015-08-07 14:37:24 -0700 | [diff] [blame] | 804 | else if (ic_version == 7 && etd->samples[1] == 0x2A) |
| 805 | sanity_check = ((packet[3] & 0x1c) == 0x10); |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 806 | else |
| 807 | sanity_check = ((packet[0] & 0x0c) == 0x04 && |
| 808 | (packet[3] & 0x1c) == 0x10); |
| 809 | |
| 810 | if (!sanity_check) |
| 811 | return PACKET_UNKNOWN; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 812 | |
Matteo Delfino | 9eebed7 | 2013-07-06 21:52:26 -0700 | [diff] [blame] | 813 | switch (packet_type) { |
| 814 | case 0: |
| 815 | return PACKET_V4_STATUS; |
| 816 | |
| 817 | case 1: |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 818 | return PACKET_V4_HEAD; |
| 819 | |
Matteo Delfino | 9eebed7 | 2013-07-06 21:52:26 -0700 | [diff] [blame] | 820 | case 2: |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 821 | return PACKET_V4_MOTION; |
Matteo Delfino | 9eebed7 | 2013-07-06 21:52:26 -0700 | [diff] [blame] | 822 | } |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 823 | |
| 824 | return PACKET_UNKNOWN; |
| 825 | } |
| 826 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 827 | /* |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 828 | * Process byte stream from mouse and handle complete packets |
| 829 | */ |
| 830 | static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse) |
| 831 | { |
| 832 | struct elantech_data *etd = psmouse->private; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 833 | int packet_type; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 834 | |
| 835 | if (psmouse->pktcnt < psmouse->pktsize) |
| 836 | return PSMOUSE_GOOD_DATA; |
| 837 | |
| 838 | if (etd->debug > 1) |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 839 | elantech_packet_dump(psmouse); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 840 | |
| 841 | switch (etd->hw_version) { |
| 842 | case 1: |
JJ Ding | 7894f21 | 2011-09-09 10:28:04 -0700 | [diff] [blame] | 843 | if (etd->paritycheck && !elantech_packet_check_v1(psmouse)) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 844 | return PSMOUSE_BAD_DATA; |
| 845 | |
| 846 | elantech_report_absolute_v1(psmouse); |
| 847 | break; |
| 848 | |
| 849 | case 2: |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 850 | /* ignore debounce */ |
| 851 | if (elantech_debounce_check_v2(psmouse)) |
| 852 | return PSMOUSE_FULL_PACKET; |
| 853 | |
JJ Ding | 7894f21 | 2011-09-09 10:28:04 -0700 | [diff] [blame] | 854 | if (etd->paritycheck && !elantech_packet_check_v2(psmouse)) |
| 855 | return PSMOUSE_BAD_DATA; |
| 856 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 857 | elantech_report_absolute_v2(psmouse); |
| 858 | break; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 859 | |
| 860 | case 3: |
| 861 | packet_type = elantech_packet_check_v3(psmouse); |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 862 | switch (packet_type) { |
| 863 | case PACKET_UNKNOWN: |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 864 | return PSMOUSE_BAD_DATA; |
| 865 | |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 866 | case PACKET_DEBOUNCE: |
| 867 | /* ignore debounce */ |
| 868 | break; |
| 869 | |
| 870 | case PACKET_TRACKPOINT: |
| 871 | elantech_report_trackpoint(psmouse, packet_type); |
| 872 | break; |
| 873 | |
| 874 | default: |
| 875 | elantech_report_absolute_v3(psmouse, packet_type); |
| 876 | break; |
| 877 | } |
| 878 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 879 | break; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 880 | |
| 881 | case 4: |
| 882 | packet_type = elantech_packet_check_v4(psmouse); |
Ulrik De Bie | caeb0d3 | 2014-11-07 23:51:34 -0800 | [diff] [blame] | 883 | switch (packet_type) { |
| 884 | case PACKET_UNKNOWN: |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 885 | return PSMOUSE_BAD_DATA; |
| 886 | |
Ulrik De Bie | caeb0d3 | 2014-11-07 23:51:34 -0800 | [diff] [blame] | 887 | case PACKET_TRACKPOINT: |
| 888 | elantech_report_trackpoint(psmouse, packet_type); |
| 889 | break; |
| 890 | |
| 891 | default: |
| 892 | elantech_report_absolute_v4(psmouse, packet_type); |
| 893 | break; |
| 894 | } |
| 895 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 896 | break; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 897 | } |
| 898 | |
| 899 | return PSMOUSE_FULL_PACKET; |
| 900 | } |
| 901 | |
| 902 | /* |
Ulrik De Bie | bd88414 | 2015-04-06 15:35:38 -0700 | [diff] [blame] | 903 | * This writes the reg_07 value again to the hardware at the end of every |
| 904 | * set_rate call because the register loses its value. reg_07 allows setting |
| 905 | * absolute mode on v4 hardware |
| 906 | */ |
| 907 | static void elantech_set_rate_restore_reg_07(struct psmouse *psmouse, |
| 908 | unsigned int rate) |
| 909 | { |
| 910 | struct elantech_data *etd = psmouse->private; |
| 911 | |
| 912 | etd->original_set_rate(psmouse, rate); |
| 913 | if (elantech_write_reg(psmouse, 0x07, etd->reg_07)) |
| 914 | psmouse_err(psmouse, "restoring reg_07 failed\n"); |
| 915 | } |
| 916 | |
| 917 | /* |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 918 | * Put the touchpad into absolute mode |
| 919 | */ |
| 920 | static int elantech_set_absolute_mode(struct psmouse *psmouse) |
| 921 | { |
| 922 | struct elantech_data *etd = psmouse->private; |
| 923 | unsigned char val; |
| 924 | int tries = ETP_READ_BACK_TRIES; |
| 925 | int rc = 0; |
| 926 | |
| 927 | switch (etd->hw_version) { |
| 928 | case 1: |
| 929 | etd->reg_10 = 0x16; |
| 930 | etd->reg_11 = 0x8f; |
| 931 | if (elantech_write_reg(psmouse, 0x10, etd->reg_10) || |
| 932 | elantech_write_reg(psmouse, 0x11, etd->reg_11)) { |
| 933 | rc = -1; |
| 934 | } |
| 935 | break; |
| 936 | |
| 937 | case 2: |
| 938 | /* Windows driver values */ |
| 939 | etd->reg_10 = 0x54; |
| 940 | etd->reg_11 = 0x88; /* 0x8a */ |
| 941 | etd->reg_21 = 0x60; /* 0x00 */ |
| 942 | if (elantech_write_reg(psmouse, 0x10, etd->reg_10) || |
| 943 | elantech_write_reg(psmouse, 0x11, etd->reg_11) || |
| 944 | elantech_write_reg(psmouse, 0x21, etd->reg_21)) { |
| 945 | rc = -1; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 946 | } |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 947 | break; |
| 948 | |
| 949 | case 3: |
Hans de Goede | 36189cc | 2014-05-05 09:36:43 -0700 | [diff] [blame] | 950 | if (etd->set_hw_resolution) |
| 951 | etd->reg_10 = 0x0b; |
| 952 | else |
Hans de Goede | fb4f8f5 | 2014-06-07 23:07:13 -0700 | [diff] [blame] | 953 | etd->reg_10 = 0x01; |
Hans de Goede | 36189cc | 2014-05-05 09:36:43 -0700 | [diff] [blame] | 954 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 955 | if (elantech_write_reg(psmouse, 0x10, etd->reg_10)) |
| 956 | rc = -1; |
| 957 | |
| 958 | break; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 959 | |
| 960 | case 4: |
| 961 | etd->reg_07 = 0x01; |
| 962 | if (elantech_write_reg(psmouse, 0x07, etd->reg_07)) |
| 963 | rc = -1; |
| 964 | |
| 965 | goto skip_readback_reg_10; /* v4 has no reg 0x10 to read */ |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 966 | } |
| 967 | |
| 968 | if (rc == 0) { |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 969 | /* |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 970 | * Read back reg 0x10. For hardware version 1 we must make |
| 971 | * sure the absolute mode bit is set. For hardware version 2 |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 972 | * the touchpad is probably initializing and not ready until |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 973 | * we read back the value we just wrote. |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 974 | */ |
| 975 | do { |
| 976 | rc = elantech_read_reg(psmouse, 0x10, &val); |
| 977 | if (rc == 0) |
| 978 | break; |
| 979 | tries--; |
Dmitry Torokhov | d4ae84a8 | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 980 | elantech_debug("retrying read (%d).\n", tries); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 981 | msleep(ETP_READ_BACK_DELAY); |
| 982 | } while (tries > 0); |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 983 | |
| 984 | if (rc) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 985 | psmouse_err(psmouse, |
| 986 | "failed to read back register 0x10.\n"); |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 987 | } else if (etd->hw_version == 1 && |
| 988 | !(val & ETP_R10_ABSOLUTE_MODE)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 989 | psmouse_err(psmouse, |
| 990 | "touchpad refuses to switch to absolute mode.\n"); |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 991 | rc = -1; |
| 992 | } |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 993 | } |
| 994 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 995 | skip_readback_reg_10: |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 996 | if (rc) |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 997 | psmouse_err(psmouse, "failed to initialise registers.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 998 | |
| 999 | return rc; |
| 1000 | } |
| 1001 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1002 | static int elantech_set_range(struct psmouse *psmouse, |
| 1003 | unsigned int *x_min, unsigned int *y_min, |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1004 | unsigned int *x_max, unsigned int *y_max, |
| 1005 | unsigned int *width) |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1006 | { |
| 1007 | struct elantech_data *etd = psmouse->private; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1008 | unsigned char param[3]; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1009 | unsigned char traces; |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1010 | |
| 1011 | switch (etd->hw_version) { |
| 1012 | case 1: |
| 1013 | *x_min = ETP_XMIN_V1; |
| 1014 | *y_min = ETP_YMIN_V1; |
| 1015 | *x_max = ETP_XMAX_V1; |
| 1016 | *y_max = ETP_YMAX_V1; |
| 1017 | break; |
| 1018 | |
| 1019 | case 2: |
| 1020 | if (etd->fw_version == 0x020800 || |
| 1021 | etd->fw_version == 0x020b00 || |
| 1022 | etd->fw_version == 0x020030) { |
| 1023 | *x_min = ETP_XMIN_V2; |
| 1024 | *y_min = ETP_YMIN_V2; |
| 1025 | *x_max = ETP_XMAX_V2; |
| 1026 | *y_max = ETP_YMAX_V2; |
| 1027 | } else { |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 1028 | int i; |
| 1029 | int fixed_dpi; |
| 1030 | |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1031 | i = (etd->fw_version > 0x020800 && |
| 1032 | etd->fw_version < 0x020900) ? 1 : 2; |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 1033 | |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 1034 | if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param)) |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 1035 | return -1; |
| 1036 | |
| 1037 | fixed_dpi = param[1] & 0x10; |
| 1038 | |
| 1039 | if (((etd->fw_version >> 16) == 0x14) && fixed_dpi) { |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 1040 | if (etd->send_cmd(psmouse, ETP_SAMPLE_QUERY, param)) |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 1041 | return -1; |
| 1042 | |
| 1043 | *x_max = (etd->capabilities[1] - i) * param[1] / 2; |
| 1044 | *y_max = (etd->capabilities[2] - i) * param[2] / 2; |
| 1045 | } else if (etd->fw_version == 0x040216) { |
| 1046 | *x_max = 819; |
| 1047 | *y_max = 405; |
| 1048 | } else if (etd->fw_version == 0x040219 || etd->fw_version == 0x040215) { |
| 1049 | *x_max = 900; |
| 1050 | *y_max = 500; |
| 1051 | } else { |
| 1052 | *x_max = (etd->capabilities[1] - i) * 64; |
| 1053 | *y_max = (etd->capabilities[2] - i) * 64; |
| 1054 | } |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1055 | } |
| 1056 | break; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1057 | |
| 1058 | case 3: |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 1059 | if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param)) |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1060 | return -1; |
| 1061 | |
| 1062 | *x_max = (0x0f & param[0]) << 8 | param[1]; |
| 1063 | *y_max = (0xf0 & param[0]) << 4 | param[2]; |
| 1064 | break; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1065 | |
| 1066 | case 4: |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 1067 | if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param)) |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1068 | return -1; |
| 1069 | |
| 1070 | *x_max = (0x0f & param[0]) << 8 | param[1]; |
| 1071 | *y_max = (0xf0 & param[0]) << 4 | param[2]; |
| 1072 | traces = etd->capabilities[1]; |
| 1073 | if ((traces < 2) || (traces > *x_max)) |
| 1074 | return -1; |
| 1075 | |
| 1076 | *width = *x_max / (traces - 1); |
| 1077 | break; |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1078 | } |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1079 | |
| 1080 | return 0; |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1081 | } |
| 1082 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1083 | /* |
JJ Ding | 3d95fd6 | 2011-11-20 22:26:56 -0800 | [diff] [blame] | 1084 | * (value from firmware) * 10 + 790 = dpi |
| 1085 | * we also have to convert dpi to dots/mm (*10/254 to avoid floating point) |
| 1086 | */ |
| 1087 | static unsigned int elantech_convert_res(unsigned int val) |
| 1088 | { |
| 1089 | return (val * 10 + 790) * 10 / 254; |
| 1090 | } |
| 1091 | |
| 1092 | static int elantech_get_resolution_v4(struct psmouse *psmouse, |
| 1093 | unsigned int *x_res, |
| 1094 | unsigned int *y_res) |
| 1095 | { |
| 1096 | unsigned char param[3]; |
| 1097 | |
| 1098 | if (elantech_send_cmd(psmouse, ETP_RESOLUTION_QUERY, param)) |
| 1099 | return -1; |
| 1100 | |
| 1101 | *x_res = elantech_convert_res(param[1] & 0x0f); |
| 1102 | *y_res = elantech_convert_res((param[1] & 0xf0) >> 4); |
| 1103 | |
| 1104 | return 0; |
| 1105 | } |
| 1106 | |
| 1107 | /* |
Hans de Goede | c15bdfd | 2013-12-16 07:09:25 -0800 | [diff] [blame] | 1108 | * Advertise INPUT_PROP_BUTTONPAD for clickpads. The testing of bit 12 in |
| 1109 | * fw_version for this is based on the following fw_version & caps table: |
| 1110 | * |
| 1111 | * Laptop-model: fw_version: caps: buttons: |
| 1112 | * Acer S3 0x461f00 10, 13, 0e clickpad |
| 1113 | * Acer S7-392 0x581f01 50, 17, 0d clickpad |
| 1114 | * Acer V5-131 0x461f02 01, 16, 0c clickpad |
| 1115 | * Acer V5-551 0x461f00 ? clickpad |
| 1116 | * Asus K53SV 0x450f01 78, 15, 0c 2 hw buttons |
| 1117 | * Asus G46VW 0x460f02 00, 18, 0c 2 hw buttons |
| 1118 | * Asus G750JX 0x360f00 00, 16, 0c 2 hw buttons |
Ulrik De Bie | bd88414 | 2015-04-06 15:35:38 -0700 | [diff] [blame] | 1119 | * Asus TP500LN 0x381f17 10, 14, 0e clickpad |
| 1120 | * Asus X750JN 0x381f17 10, 14, 0e clickpad |
Hans de Goede | c15bdfd | 2013-12-16 07:09:25 -0800 | [diff] [blame] | 1121 | * Asus UX31 0x361f00 20, 15, 0e clickpad |
| 1122 | * Asus UX32VD 0x361f02 00, 15, 0e clickpad |
| 1123 | * Avatar AVIU-145A2 0x361f00 ? clickpad |
Rainer Koenig | 47c1ffb | 2015-01-27 15:15:11 -0800 | [diff] [blame] | 1124 | * Fujitsu LIFEBOOK E544 0x470f00 d0, 12, 09 2 hw buttons |
| 1125 | * Fujitsu LIFEBOOK E554 0x570f01 40, 14, 0c 2 hw buttons |
Duson Lin | 6b30c73 | 2015-08-07 14:37:24 -0700 | [diff] [blame] | 1126 | * Fujitsu T725 0x470f01 05, 12, 09 2 hw buttons |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 1127 | * Fujitsu H730 0x570f00 c0, 14, 0c 3 hw buttons (**) |
Hans de Goede | c15bdfd | 2013-12-16 07:09:25 -0800 | [diff] [blame] | 1128 | * Gigabyte U2442 0x450f01 58, 17, 0c 2 hw buttons |
| 1129 | * Lenovo L430 0x350f02 b9, 15, 0c 2 hw buttons (*) |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 1130 | * Lenovo L530 0x350f02 b9, 15, 0c 2 hw buttons (*) |
Hans de Goede | c15bdfd | 2013-12-16 07:09:25 -0800 | [diff] [blame] | 1131 | * Samsung NF210 0x150b00 78, 14, 0a 2 hw buttons |
| 1132 | * Samsung NP770Z5E 0x575f01 10, 15, 0f clickpad |
| 1133 | * Samsung NP700Z5B 0x361f06 21, 15, 0f clickpad |
| 1134 | * Samsung NP900X3E-A02 0x575f03 ? clickpad |
| 1135 | * Samsung NP-QX410 0x851b00 19, 14, 0c clickpad |
| 1136 | * Samsung RC512 0x450f00 08, 15, 0c 2 hw buttons |
| 1137 | * Samsung RF710 0x450f00 ? 2 hw buttons |
| 1138 | * System76 Pangolin 0x250f01 ? 2 hw buttons |
| 1139 | * (*) + 3 trackpoint buttons |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 1140 | * (**) + 0 trackpoint buttons |
| 1141 | * Note: Lenovo L430 and Lenovo L430 have the same fw_version/caps |
Hans de Goede | c15bdfd | 2013-12-16 07:09:25 -0800 | [diff] [blame] | 1142 | */ |
| 1143 | static void elantech_set_buttonpad_prop(struct psmouse *psmouse) |
| 1144 | { |
| 1145 | struct input_dev *dev = psmouse->dev; |
| 1146 | struct elantech_data *etd = psmouse->private; |
| 1147 | |
| 1148 | if (etd->fw_version & 0x001000) { |
| 1149 | __set_bit(INPUT_PROP_BUTTONPAD, dev->propbit); |
| 1150 | __clear_bit(BTN_RIGHT, dev->keybit); |
| 1151 | } |
| 1152 | } |
| 1153 | |
| 1154 | /* |
Ulrik De Bie | f386474 | 2014-11-13 17:45:12 -0800 | [diff] [blame] | 1155 | * Some hw_version 4 models do have a middle button |
| 1156 | */ |
| 1157 | static const struct dmi_system_id elantech_dmi_has_middle_button[] = { |
| 1158 | #if defined(CONFIG_DMI) && defined(CONFIG_X86) |
| 1159 | { |
| 1160 | /* Fujitsu H730 has a middle button */ |
| 1161 | .matches = { |
| 1162 | DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), |
| 1163 | DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"), |
| 1164 | }, |
| 1165 | }, |
| 1166 | #endif |
| 1167 | { } |
| 1168 | }; |
| 1169 | |
| 1170 | /* |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1171 | * Set the appropriate event bits for the input subsystem |
| 1172 | */ |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1173 | static int elantech_set_input_params(struct psmouse *psmouse) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1174 | { |
| 1175 | struct input_dev *dev = psmouse->dev; |
| 1176 | struct elantech_data *etd = psmouse->private; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1177 | unsigned int x_min = 0, y_min = 0, x_max = 0, y_max = 0, width = 0; |
Peter Hutterer | d98399e | 2015-07-16 10:38:15 -0700 | [diff] [blame] | 1178 | unsigned int x_res = 31, y_res = 31; |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1179 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1180 | if (elantech_set_range(psmouse, &x_min, &y_min, &x_max, &y_max, &width)) |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1181 | return -1; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1182 | |
JJ Ding | e3dde4f | 2012-04-10 00:30:12 -0700 | [diff] [blame] | 1183 | __set_bit(INPUT_PROP_POINTER, dev->propbit); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1184 | __set_bit(EV_KEY, dev->evbit); |
| 1185 | __set_bit(EV_ABS, dev->evbit); |
Dmitry Torokhov | c7a1f3c | 2009-11-16 22:12:21 -0800 | [diff] [blame] | 1186 | __clear_bit(EV_REL, dev->evbit); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1187 | |
| 1188 | __set_bit(BTN_LEFT, dev->keybit); |
Ulrik De Bie | f386474 | 2014-11-13 17:45:12 -0800 | [diff] [blame] | 1189 | if (dmi_check_system(elantech_dmi_has_middle_button)) |
| 1190 | __set_bit(BTN_MIDDLE, dev->keybit); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1191 | __set_bit(BTN_RIGHT, dev->keybit); |
| 1192 | |
| 1193 | __set_bit(BTN_TOUCH, dev->keybit); |
| 1194 | __set_bit(BTN_TOOL_FINGER, dev->keybit); |
| 1195 | __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit); |
| 1196 | __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit); |
| 1197 | |
| 1198 | switch (etd->hw_version) { |
| 1199 | case 1: |
| 1200 | /* Rocker button */ |
Dmitry Torokhov | 504e8be | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 1201 | if (etd->fw_version < 0x020000 && |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1202 | (etd->capabilities[0] & ETP_CAP_HAS_ROCKER)) { |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1203 | __set_bit(BTN_FORWARD, dev->keybit); |
| 1204 | __set_bit(BTN_BACK, dev->keybit); |
| 1205 | } |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1206 | input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0); |
| 1207 | input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1208 | break; |
| 1209 | |
| 1210 | case 2: |
Éric Piel | 22462d9f | 2010-08-05 23:51:49 -0700 | [diff] [blame] | 1211 | __set_bit(BTN_TOOL_QUADTAP, dev->keybit); |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1212 | __set_bit(INPUT_PROP_SEMI_MT, dev->propbit); |
| 1213 | /* fall through */ |
| 1214 | case 3: |
Hans de Goede | c15bdfd | 2013-12-16 07:09:25 -0800 | [diff] [blame] | 1215 | if (etd->hw_version == 3) |
| 1216 | elantech_set_buttonpad_prop(psmouse); |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1217 | input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0); |
| 1218 | input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0); |
Éric Piel | f941c70 | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 1219 | if (etd->reports_pressure) { |
| 1220 | input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2, |
| 1221 | ETP_PMAX_V2, 0, 0); |
| 1222 | input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2, |
| 1223 | ETP_WMAX_V2, 0, 0); |
| 1224 | } |
Henrik Rydberg | b4adbbe | 2012-08-11 22:07:55 +0200 | [diff] [blame] | 1225 | input_mt_init_slots(dev, 2, 0); |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1226 | input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0); |
| 1227 | input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1228 | break; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1229 | |
| 1230 | case 4: |
JJ Ding | 3d95fd6 | 2011-11-20 22:26:56 -0800 | [diff] [blame] | 1231 | if (elantech_get_resolution_v4(psmouse, &x_res, &y_res)) { |
| 1232 | /* |
| 1233 | * if query failed, print a warning and leave the values |
| 1234 | * zero to resemble synaptics.c behavior. |
| 1235 | */ |
| 1236 | psmouse_warn(psmouse, "couldn't query resolution data.\n"); |
| 1237 | } |
Hans de Goede | c15bdfd | 2013-12-16 07:09:25 -0800 | [diff] [blame] | 1238 | elantech_set_buttonpad_prop(psmouse); |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1239 | __set_bit(BTN_TOOL_QUADTAP, dev->keybit); |
| 1240 | /* For X to recognize me as touchpad. */ |
| 1241 | input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0); |
| 1242 | input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0); |
| 1243 | /* |
| 1244 | * range of pressure and width is the same as v2, |
| 1245 | * report ABS_PRESSURE, ABS_TOOL_WIDTH for compatibility. |
| 1246 | */ |
| 1247 | input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2, |
| 1248 | ETP_PMAX_V2, 0, 0); |
| 1249 | input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2, |
| 1250 | ETP_WMAX_V2, 0, 0); |
| 1251 | /* Multitouch capable pad, up to 5 fingers. */ |
Henrik Rydberg | b4adbbe | 2012-08-11 22:07:55 +0200 | [diff] [blame] | 1252 | input_mt_init_slots(dev, ETP_MAX_FINGERS, 0); |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1253 | input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0); |
| 1254 | input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0); |
| 1255 | input_set_abs_params(dev, ABS_MT_PRESSURE, ETP_PMIN_V2, |
| 1256 | ETP_PMAX_V2, 0, 0); |
| 1257 | /* |
| 1258 | * The firmware reports how many trace lines the finger spans, |
| 1259 | * convert to surface unit as Protocol-B requires. |
| 1260 | */ |
| 1261 | input_set_abs_params(dev, ABS_MT_TOUCH_MAJOR, 0, |
| 1262 | ETP_WMAX_V2 * width, 0, 0); |
| 1263 | break; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1264 | } |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1265 | |
Peter Hutterer | d98399e | 2015-07-16 10:38:15 -0700 | [diff] [blame] | 1266 | input_abs_set_res(dev, ABS_X, x_res); |
| 1267 | input_abs_set_res(dev, ABS_Y, y_res); |
| 1268 | if (etd->hw_version > 1) { |
| 1269 | input_abs_set_res(dev, ABS_MT_POSITION_X, x_res); |
| 1270 | input_abs_set_res(dev, ABS_MT_POSITION_Y, y_res); |
| 1271 | } |
| 1272 | |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1273 | etd->y_max = y_max; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1274 | etd->width = width; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1275 | |
| 1276 | return 0; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1277 | } |
| 1278 | |
| 1279 | struct elantech_attr_data { |
| 1280 | size_t field_offset; |
| 1281 | unsigned char reg; |
| 1282 | }; |
| 1283 | |
| 1284 | /* |
| 1285 | * Display a register value by reading a sysfs entry |
| 1286 | */ |
| 1287 | static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data, |
| 1288 | char *buf) |
| 1289 | { |
| 1290 | struct elantech_data *etd = psmouse->private; |
| 1291 | struct elantech_attr_data *attr = data; |
| 1292 | unsigned char *reg = (unsigned char *) etd + attr->field_offset; |
| 1293 | int rc = 0; |
| 1294 | |
| 1295 | if (attr->reg) |
| 1296 | rc = elantech_read_reg(psmouse, attr->reg, reg); |
| 1297 | |
| 1298 | return sprintf(buf, "0x%02x\n", (attr->reg && rc) ? -1 : *reg); |
| 1299 | } |
| 1300 | |
| 1301 | /* |
| 1302 | * Write a register value by writing a sysfs entry |
| 1303 | */ |
| 1304 | static ssize_t elantech_set_int_attr(struct psmouse *psmouse, |
| 1305 | void *data, const char *buf, size_t count) |
| 1306 | { |
| 1307 | struct elantech_data *etd = psmouse->private; |
| 1308 | struct elantech_attr_data *attr = data; |
| 1309 | unsigned char *reg = (unsigned char *) etd + attr->field_offset; |
JJ Ding | 76496e7 | 2011-11-09 10:20:14 -0800 | [diff] [blame] | 1310 | unsigned char value; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1311 | int err; |
| 1312 | |
JJ Ding | 76496e7 | 2011-11-09 10:20:14 -0800 | [diff] [blame] | 1313 | err = kstrtou8(buf, 16, &value); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1314 | if (err) |
| 1315 | return err; |
| 1316 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1317 | /* Do we need to preserve some bits for version 2 hardware too? */ |
| 1318 | if (etd->hw_version == 1) { |
| 1319 | if (attr->reg == 0x10) |
| 1320 | /* Force absolute mode always on */ |
| 1321 | value |= ETP_R10_ABSOLUTE_MODE; |
| 1322 | else if (attr->reg == 0x11) |
| 1323 | /* Force 4 byte mode always on */ |
| 1324 | value |= ETP_R11_4_BYTE_MODE; |
| 1325 | } |
| 1326 | |
| 1327 | if (!attr->reg || elantech_write_reg(psmouse, attr->reg, value) == 0) |
| 1328 | *reg = value; |
| 1329 | |
| 1330 | return count; |
| 1331 | } |
| 1332 | |
| 1333 | #define ELANTECH_INT_ATTR(_name, _register) \ |
| 1334 | static struct elantech_attr_data elantech_attr_##_name = { \ |
| 1335 | .field_offset = offsetof(struct elantech_data, _name), \ |
| 1336 | .reg = _register, \ |
| 1337 | }; \ |
| 1338 | PSMOUSE_DEFINE_ATTR(_name, S_IWUSR | S_IRUGO, \ |
| 1339 | &elantech_attr_##_name, \ |
| 1340 | elantech_show_int_attr, \ |
| 1341 | elantech_set_int_attr) |
| 1342 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1343 | ELANTECH_INT_ATTR(reg_07, 0x07); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1344 | ELANTECH_INT_ATTR(reg_10, 0x10); |
| 1345 | ELANTECH_INT_ATTR(reg_11, 0x11); |
| 1346 | ELANTECH_INT_ATTR(reg_20, 0x20); |
| 1347 | ELANTECH_INT_ATTR(reg_21, 0x21); |
| 1348 | ELANTECH_INT_ATTR(reg_22, 0x22); |
| 1349 | ELANTECH_INT_ATTR(reg_23, 0x23); |
| 1350 | ELANTECH_INT_ATTR(reg_24, 0x24); |
| 1351 | ELANTECH_INT_ATTR(reg_25, 0x25); |
| 1352 | ELANTECH_INT_ATTR(reg_26, 0x26); |
| 1353 | ELANTECH_INT_ATTR(debug, 0); |
| 1354 | ELANTECH_INT_ATTR(paritycheck, 0); |
Ulrik De Bie | 2d9eb81 | 2014-11-13 17:47:04 -0800 | [diff] [blame] | 1355 | ELANTECH_INT_ATTR(crc_enabled, 0); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1356 | |
| 1357 | static struct attribute *elantech_attrs[] = { |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1358 | &psmouse_attr_reg_07.dattr.attr, |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1359 | &psmouse_attr_reg_10.dattr.attr, |
| 1360 | &psmouse_attr_reg_11.dattr.attr, |
| 1361 | &psmouse_attr_reg_20.dattr.attr, |
| 1362 | &psmouse_attr_reg_21.dattr.attr, |
| 1363 | &psmouse_attr_reg_22.dattr.attr, |
| 1364 | &psmouse_attr_reg_23.dattr.attr, |
| 1365 | &psmouse_attr_reg_24.dattr.attr, |
| 1366 | &psmouse_attr_reg_25.dattr.attr, |
| 1367 | &psmouse_attr_reg_26.dattr.attr, |
| 1368 | &psmouse_attr_debug.dattr.attr, |
| 1369 | &psmouse_attr_paritycheck.dattr.attr, |
Ulrik De Bie | 2d9eb81 | 2014-11-13 17:47:04 -0800 | [diff] [blame] | 1370 | &psmouse_attr_crc_enabled.dattr.attr, |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1371 | NULL |
| 1372 | }; |
| 1373 | |
| 1374 | static struct attribute_group elantech_attr_group = { |
| 1375 | .attrs = elantech_attrs, |
| 1376 | }; |
| 1377 | |
Dmitry Torokhov | a083632 | 2010-05-19 10:11:13 -0700 | [diff] [blame] | 1378 | static bool elantech_is_signature_valid(const unsigned char *param) |
| 1379 | { |
| 1380 | static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10 }; |
| 1381 | int i; |
| 1382 | |
| 1383 | if (param[0] == 0) |
| 1384 | return false; |
| 1385 | |
| 1386 | if (param[1] == 0) |
| 1387 | return true; |
| 1388 | |
Hans de Goede | 271329b | 2014-09-08 14:39:52 -0700 | [diff] [blame] | 1389 | /* |
Hans de Goede | 5f0ee9d | 2015-06-02 10:40:50 -0700 | [diff] [blame] | 1390 | * Some hw_version >= 4 models have a revision higher then 20. Meaning |
| 1391 | * that param[2] may be 10 or 20, skip the rates check for these. |
Hans de Goede | 271329b | 2014-09-08 14:39:52 -0700 | [diff] [blame] | 1392 | */ |
Hans de Goede | 5f0ee9d | 2015-06-02 10:40:50 -0700 | [diff] [blame] | 1393 | if ((param[0] & 0x0f) >= 0x06 && (param[1] & 0xaf) == 0x0f && |
| 1394 | param[2] < 40) |
Hans de Goede | 271329b | 2014-09-08 14:39:52 -0700 | [diff] [blame] | 1395 | return true; |
| 1396 | |
Dmitry Torokhov | a083632 | 2010-05-19 10:11:13 -0700 | [diff] [blame] | 1397 | for (i = 0; i < ARRAY_SIZE(rates); i++) |
| 1398 | if (param[2] == rates[i]) |
| 1399 | return false; |
| 1400 | |
| 1401 | return true; |
| 1402 | } |
| 1403 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1404 | /* |
| 1405 | * Use magic knock to detect Elantech touchpad |
| 1406 | */ |
Dmitry Torokhov | b7802c5 | 2009-09-09 19:13:20 -0700 | [diff] [blame] | 1407 | int elantech_detect(struct psmouse *psmouse, bool set_properties) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1408 | { |
| 1409 | struct ps2dev *ps2dev = &psmouse->ps2dev; |
| 1410 | unsigned char param[3]; |
| 1411 | |
| 1412 | ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS); |
| 1413 | |
| 1414 | if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || |
| 1415 | ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || |
| 1416 | ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || |
| 1417 | ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || |
| 1418 | ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1419 | psmouse_dbg(psmouse, "sending Elantech magic knock failed.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1420 | return -1; |
| 1421 | } |
| 1422 | |
| 1423 | /* |
| 1424 | * Report this in case there are Elantech models that use a different |
| 1425 | * set of magic numbers |
| 1426 | */ |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1427 | if (param[0] != 0x3c || param[1] != 0x03 || |
| 1428 | (param[2] != 0xc8 && param[2] != 0x00)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1429 | psmouse_dbg(psmouse, |
| 1430 | "unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n", |
| 1431 | param[0], param[1], param[2]); |
Arjan Opmeer | 9ab7b25 | 2009-02-28 13:52:40 -0800 | [diff] [blame] | 1432 | return -1; |
| 1433 | } |
| 1434 | |
| 1435 | /* |
| 1436 | * Query touchpad's firmware version and see if it reports known |
| 1437 | * value to avoid mis-detection. Logitech mice are known to respond |
| 1438 | * to Elantech magic knock and there might be more. |
| 1439 | */ |
| 1440 | if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1441 | psmouse_dbg(psmouse, "failed to query firmware version.\n"); |
Arjan Opmeer | 9ab7b25 | 2009-02-28 13:52:40 -0800 | [diff] [blame] | 1442 | return -1; |
| 1443 | } |
| 1444 | |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1445 | psmouse_dbg(psmouse, |
| 1446 | "Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n", |
| 1447 | param[0], param[1], param[2]); |
Arjan Opmeer | 9ab7b25 | 2009-02-28 13:52:40 -0800 | [diff] [blame] | 1448 | |
Dmitry Torokhov | a083632 | 2010-05-19 10:11:13 -0700 | [diff] [blame] | 1449 | if (!elantech_is_signature_valid(param)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1450 | psmouse_dbg(psmouse, |
| 1451 | "Probably not a real Elantech touchpad. Aborting.\n"); |
JJ Ding | 4af61e9 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 1452 | return -1; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1453 | } |
| 1454 | |
| 1455 | if (set_properties) { |
| 1456 | psmouse->vendor = "Elantech"; |
| 1457 | psmouse->name = "Touchpad"; |
| 1458 | } |
| 1459 | |
| 1460 | return 0; |
| 1461 | } |
| 1462 | |
| 1463 | /* |
| 1464 | * Clean up sysfs entries when disconnecting |
| 1465 | */ |
| 1466 | static void elantech_disconnect(struct psmouse *psmouse) |
| 1467 | { |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 1468 | struct elantech_data *etd = psmouse->private; |
| 1469 | |
| 1470 | if (etd->tp_dev) |
| 1471 | input_unregister_device(etd->tp_dev); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1472 | sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj, |
| 1473 | &elantech_attr_group); |
| 1474 | kfree(psmouse->private); |
| 1475 | psmouse->private = NULL; |
| 1476 | } |
| 1477 | |
| 1478 | /* |
| 1479 | * Put the touchpad back into absolute mode when reconnecting |
| 1480 | */ |
| 1481 | static int elantech_reconnect(struct psmouse *psmouse) |
| 1482 | { |
JJ Ding | a67ada7 | 2012-04-10 00:29:12 -0700 | [diff] [blame] | 1483 | psmouse_reset(psmouse); |
| 1484 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1485 | if (elantech_detect(psmouse, 0)) |
| 1486 | return -1; |
| 1487 | |
| 1488 | if (elantech_set_absolute_mode(psmouse)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1489 | psmouse_err(psmouse, |
| 1490 | "failed to put touchpad back into absolute mode.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1491 | return -1; |
| 1492 | } |
| 1493 | |
| 1494 | return 0; |
| 1495 | } |
| 1496 | |
| 1497 | /* |
Ulrik De Bie | 0dc1587 | 2014-11-07 23:57:34 -0800 | [diff] [blame] | 1498 | * Some hw_version 4 models do not work with crc_disabled |
| 1499 | */ |
| 1500 | static const struct dmi_system_id elantech_dmi_force_crc_enabled[] = { |
| 1501 | #if defined(CONFIG_DMI) && defined(CONFIG_X86) |
| 1502 | { |
| 1503 | /* Fujitsu H730 does not work with crc_enabled == 0 */ |
| 1504 | .matches = { |
| 1505 | DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), |
| 1506 | DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"), |
| 1507 | }, |
| 1508 | }, |
Rainer Koenig | 47c1ffb | 2015-01-27 15:15:11 -0800 | [diff] [blame] | 1509 | { |
| 1510 | /* Fujitsu LIFEBOOK E554 does not work with crc_enabled == 0 */ |
| 1511 | .matches = { |
| 1512 | DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), |
| 1513 | DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E554"), |
| 1514 | }, |
| 1515 | }, |
| 1516 | { |
| 1517 | /* Fujitsu LIFEBOOK E544 does not work with crc_enabled == 0 */ |
| 1518 | .matches = { |
| 1519 | DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), |
| 1520 | DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E544"), |
| 1521 | }, |
| 1522 | }, |
Takashi Iwai | 6060395 | 2015-11-06 11:26:01 -0800 | [diff] [blame^] | 1523 | { |
| 1524 | /* Fujitsu LIFEBOOK U745 does not work with crc_enabled == 0 */ |
| 1525 | .matches = { |
| 1526 | DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), |
| 1527 | DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK U745"), |
| 1528 | }, |
| 1529 | }, |
Ulrik De Bie | 0dc1587 | 2014-11-07 23:57:34 -0800 | [diff] [blame] | 1530 | #endif |
| 1531 | { } |
| 1532 | }; |
| 1533 | |
| 1534 | /* |
Hans de Goede | fb4f8f5 | 2014-06-07 23:07:13 -0700 | [diff] [blame] | 1535 | * Some hw_version 3 models go into error state when we try to set |
| 1536 | * bit 3 and/or bit 1 of r10. |
Hans de Goede | 36189cc | 2014-05-05 09:36:43 -0700 | [diff] [blame] | 1537 | */ |
| 1538 | static const struct dmi_system_id no_hw_res_dmi_table[] = { |
| 1539 | #if defined(CONFIG_DMI) && defined(CONFIG_X86) |
| 1540 | { |
| 1541 | /* Gigabyte U2442 */ |
| 1542 | .matches = { |
| 1543 | DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"), |
| 1544 | DMI_MATCH(DMI_PRODUCT_NAME, "U2442"), |
| 1545 | }, |
| 1546 | }, |
| 1547 | #endif |
| 1548 | { } |
| 1549 | }; |
| 1550 | |
| 1551 | /* |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1552 | * determine hardware version and set some properties according to it. |
| 1553 | */ |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1554 | static int elantech_set_properties(struct elantech_data *etd) |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1555 | { |
JJ Ding | 3940d61 | 2011-11-08 22:13:14 -0800 | [diff] [blame] | 1556 | /* This represents the version of IC body. */ |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1557 | int ver = (etd->fw_version & 0x0f0000) >> 16; |
| 1558 | |
JJ Ding | 3940d61 | 2011-11-08 22:13:14 -0800 | [diff] [blame] | 1559 | /* Early version of Elan touchpads doesn't obey the rule. */ |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1560 | if (etd->fw_version < 0x020030 || etd->fw_version == 0x020600) |
| 1561 | etd->hw_version = 1; |
JJ Ding | 3940d61 | 2011-11-08 22:13:14 -0800 | [diff] [blame] | 1562 | else { |
| 1563 | switch (ver) { |
| 1564 | case 2: |
| 1565 | case 4: |
| 1566 | etd->hw_version = 2; |
| 1567 | break; |
| 1568 | case 5: |
| 1569 | etd->hw_version = 3; |
| 1570 | break; |
| 1571 | case 6: |
Matteo Delfino | 9eebed7 | 2013-07-06 21:52:26 -0700 | [diff] [blame] | 1572 | case 7: |
Matt Walker | 9cb80b9 | 2013-12-05 12:39:02 -0800 | [diff] [blame] | 1573 | case 8: |
Jordan Rife | ae4bedf | 2014-04-22 17:44:51 -0700 | [diff] [blame] | 1574 | case 9: |
Sam hung | 810aa09 | 2015-01-08 13:22:43 -0800 | [diff] [blame] | 1575 | case 10: |
| 1576 | case 13: |
洪一竹 | 692dd19 | 2015-06-04 22:00:24 -0700 | [diff] [blame] | 1577 | case 14: |
JJ Ding | 3940d61 | 2011-11-08 22:13:14 -0800 | [diff] [blame] | 1578 | etd->hw_version = 4; |
| 1579 | break; |
| 1580 | default: |
| 1581 | return -1; |
| 1582 | } |
| 1583 | } |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1584 | |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 1585 | /* decide which send_cmd we're gonna use early */ |
| 1586 | etd->send_cmd = etd->hw_version >= 3 ? elantech_send_cmd : |
| 1587 | synaptics_send_cmd; |
| 1588 | |
| 1589 | /* Turn on packet checking by default */ |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1590 | etd->paritycheck = 1; |
| 1591 | |
| 1592 | /* |
| 1593 | * This firmware suffers from misreporting coordinates when |
| 1594 | * a touch action starts causing the mouse cursor or scrolled page |
| 1595 | * to jump. Enable a workaround. |
| 1596 | */ |
| 1597 | etd->jumpy_cursor = |
| 1598 | (etd->fw_version == 0x020022 || etd->fw_version == 0x020600); |
| 1599 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1600 | if (etd->hw_version > 1) { |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1601 | /* For now show extra debug information */ |
| 1602 | etd->debug = 1; |
| 1603 | |
| 1604 | if (etd->fw_version >= 0x020800) |
| 1605 | etd->reports_pressure = true; |
| 1606 | } |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1607 | |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 1608 | /* |
| 1609 | * The signatures of v3 and v4 packets change depending on the |
| 1610 | * value of this hardware flag. |
| 1611 | */ |
Ulrik De Bie | 0dc1587 | 2014-11-07 23:57:34 -0800 | [diff] [blame] | 1612 | etd->crc_enabled = (etd->fw_version & 0x4000) == 0x4000 || |
| 1613 | dmi_check_system(elantech_dmi_force_crc_enabled); |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 1614 | |
Hans de Goede | 36189cc | 2014-05-05 09:36:43 -0700 | [diff] [blame] | 1615 | /* Enable real hardware resolution on hw_version 3 ? */ |
| 1616 | etd->set_hw_resolution = !dmi_check_system(no_hw_res_dmi_table); |
| 1617 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1618 | return 0; |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1619 | } |
| 1620 | |
| 1621 | /* |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1622 | * Initialize the touchpad and create sysfs entries |
| 1623 | */ |
| 1624 | int elantech_init(struct psmouse *psmouse) |
| 1625 | { |
| 1626 | struct elantech_data *etd; |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 1627 | int i; |
| 1628 | int error = -EINVAL; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1629 | unsigned char param[3]; |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 1630 | struct input_dev *tp_dev; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1631 | |
Arjan Opmeer | 9ab7b25 | 2009-02-28 13:52:40 -0800 | [diff] [blame] | 1632 | psmouse->private = etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1633 | if (!etd) |
Davidlohr Bueso | 6792cbb | 2010-09-29 18:53:35 -0700 | [diff] [blame] | 1634 | return -ENOMEM; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1635 | |
JJ Ding | a67ada7 | 2012-04-10 00:29:12 -0700 | [diff] [blame] | 1636 | psmouse_reset(psmouse); |
| 1637 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1638 | etd->parity[0] = 1; |
| 1639 | for (i = 1; i < 256; i++) |
| 1640 | etd->parity[i] = etd->parity[i & (i - 1)] ^ 1; |
| 1641 | |
| 1642 | /* |
Arjan Opmeer | 9ab7b25 | 2009-02-28 13:52:40 -0800 | [diff] [blame] | 1643 | * Do the version query again so we can store the result |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1644 | */ |
| 1645 | if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1646 | psmouse_err(psmouse, "failed to query firmware version.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1647 | goto init_fail; |
| 1648 | } |
Dmitry Torokhov | 504e8be | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 1649 | etd->fw_version = (param[0] << 16) | (param[1] << 8) | param[2]; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1650 | |
| 1651 | if (elantech_set_properties(etd)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1652 | psmouse_err(psmouse, "unknown hardware version, aborting...\n"); |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1653 | goto init_fail; |
| 1654 | } |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1655 | psmouse_info(psmouse, |
| 1656 | "assuming hardware version %d (with firmware version 0x%02x%02x%02x)\n", |
| 1657 | etd->hw_version, param[0], param[1], param[2]); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1658 | |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 1659 | if (etd->send_cmd(psmouse, ETP_CAPABILITIES_QUERY, |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1660 | etd->capabilities)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1661 | psmouse_err(psmouse, "failed to query capabilities.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1662 | goto init_fail; |
| 1663 | } |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1664 | psmouse_info(psmouse, |
| 1665 | "Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n", |
| 1666 | etd->capabilities[0], etd->capabilities[1], |
| 1667 | etd->capabilities[2]); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1668 | |
Duson Lin | 6b30c73 | 2015-08-07 14:37:24 -0700 | [diff] [blame] | 1669 | if (etd->hw_version != 1) { |
| 1670 | if (etd->send_cmd(psmouse, ETP_SAMPLE_QUERY, etd->samples)) { |
| 1671 | psmouse_err(psmouse, "failed to query sample data\n"); |
| 1672 | goto init_fail; |
| 1673 | } |
| 1674 | psmouse_info(psmouse, |
| 1675 | "Elan sample query result %02x, %02x, %02x\n", |
| 1676 | etd->samples[0], etd->samples[1], etd->samples[2]); |
| 1677 | } |
| 1678 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1679 | if (elantech_set_absolute_mode(psmouse)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1680 | psmouse_err(psmouse, |
| 1681 | "failed to put touchpad into absolute mode.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1682 | goto init_fail; |
| 1683 | } |
| 1684 | |
Ulrik De Bie | bd88414 | 2015-04-06 15:35:38 -0700 | [diff] [blame] | 1685 | if (etd->fw_version == 0x381f17) { |
| 1686 | etd->original_set_rate = psmouse->set_rate; |
| 1687 | psmouse->set_rate = elantech_set_rate_restore_reg_07; |
| 1688 | } |
| 1689 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1690 | if (elantech_set_input_params(psmouse)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1691 | psmouse_err(psmouse, "failed to query touchpad range.\n"); |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1692 | goto init_fail; |
| 1693 | } |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1694 | |
| 1695 | error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj, |
| 1696 | &elantech_attr_group); |
| 1697 | if (error) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1698 | psmouse_err(psmouse, |
| 1699 | "failed to create sysfs attributes, error: %d.\n", |
| 1700 | error); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1701 | goto init_fail; |
| 1702 | } |
| 1703 | |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 1704 | /* The MSB indicates the presence of the trackpoint */ |
| 1705 | if ((etd->capabilities[0] & 0x80) == 0x80) { |
| 1706 | tp_dev = input_allocate_device(); |
| 1707 | |
| 1708 | if (!tp_dev) { |
| 1709 | error = -ENOMEM; |
| 1710 | goto init_fail_tp_alloc; |
| 1711 | } |
| 1712 | |
| 1713 | etd->tp_dev = tp_dev; |
| 1714 | snprintf(etd->tp_phys, sizeof(etd->tp_phys), "%s/input1", |
| 1715 | psmouse->ps2dev.serio->phys); |
| 1716 | tp_dev->phys = etd->tp_phys; |
| 1717 | tp_dev->name = "Elantech PS/2 TrackPoint"; |
| 1718 | tp_dev->id.bustype = BUS_I8042; |
| 1719 | tp_dev->id.vendor = 0x0002; |
| 1720 | tp_dev->id.product = PSMOUSE_ELANTECH; |
| 1721 | tp_dev->id.version = 0x0000; |
| 1722 | tp_dev->dev.parent = &psmouse->ps2dev.serio->dev; |
| 1723 | tp_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL); |
| 1724 | tp_dev->relbit[BIT_WORD(REL_X)] = |
| 1725 | BIT_MASK(REL_X) | BIT_MASK(REL_Y); |
| 1726 | tp_dev->keybit[BIT_WORD(BTN_LEFT)] = |
| 1727 | BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_MIDDLE) | |
| 1728 | BIT_MASK(BTN_RIGHT); |
Hans de Goede | 7611392 | 2014-09-08 14:42:12 -0700 | [diff] [blame] | 1729 | |
Hans de Goede | 01d4cd5 | 2014-09-08 14:44:05 -0700 | [diff] [blame] | 1730 | __set_bit(INPUT_PROP_POINTER, tp_dev->propbit); |
Hans de Goede | 7611392 | 2014-09-08 14:42:12 -0700 | [diff] [blame] | 1731 | __set_bit(INPUT_PROP_POINTING_STICK, tp_dev->propbit); |
| 1732 | |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 1733 | error = input_register_device(etd->tp_dev); |
| 1734 | if (error < 0) |
| 1735 | goto init_fail_tp_reg; |
| 1736 | } |
| 1737 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1738 | psmouse->protocol_handler = elantech_process_byte; |
| 1739 | psmouse->disconnect = elantech_disconnect; |
| 1740 | psmouse->reconnect = elantech_reconnect; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1741 | psmouse->pktsize = etd->hw_version > 1 ? 6 : 4; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1742 | |
| 1743 | return 0; |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 1744 | init_fail_tp_reg: |
| 1745 | input_free_device(tp_dev); |
| 1746 | init_fail_tp_alloc: |
| 1747 | sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj, |
| 1748 | &elantech_attr_group); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1749 | init_fail: |
Ulrik De Bie | ac84eba | 2014-08-22 17:08:21 -0700 | [diff] [blame] | 1750 | psmouse_reset(psmouse); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1751 | kfree(etd); |
Ulrik De Bie | a2418fc | 2014-08-22 17:06:00 -0700 | [diff] [blame] | 1752 | return error; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1753 | } |