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> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 14 | #include <linux/slab.h> |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 15 | #include <linux/module.h> |
| 16 | #include <linux/input.h> |
Éric Piel | 89eec4d | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 17 | #include <linux/input/mt.h> |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 18 | #include <linux/serio.h> |
| 19 | #include <linux/libps2.h> |
| 20 | #include "psmouse.h" |
| 21 | #include "elantech.h" |
| 22 | |
Dmitry Torokhov | d4ae84a8 | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 23 | #define elantech_debug(fmt, ...) \ |
| 24 | do { \ |
| 25 | if (etd->debug) \ |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 26 | psmouse_printk(KERN_DEBUG, psmouse, \ |
| 27 | fmt, ##__VA_ARGS__); \ |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 28 | } while (0) |
| 29 | |
| 30 | /* |
| 31 | * Send a Synaptics style sliced query command |
| 32 | */ |
| 33 | static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c, |
| 34 | unsigned char *param) |
| 35 | { |
| 36 | if (psmouse_sliced_command(psmouse, c) || |
| 37 | ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 38 | psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 39 | return -1; |
| 40 | } |
| 41 | |
| 42 | return 0; |
| 43 | } |
| 44 | |
| 45 | /* |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 46 | * V3 and later support this fast command |
| 47 | */ |
| 48 | static int elantech_send_cmd(struct psmouse *psmouse, unsigned char c, |
| 49 | unsigned char *param) |
| 50 | { |
| 51 | struct ps2dev *ps2dev = &psmouse->ps2dev; |
| 52 | |
| 53 | if (ps2_command(ps2dev, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 54 | ps2_command(ps2dev, NULL, c) || |
| 55 | ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) { |
| 56 | psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c); |
| 57 | return -1; |
| 58 | } |
| 59 | |
| 60 | return 0; |
| 61 | } |
| 62 | |
| 63 | /* |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 64 | * A retrying version of ps2_command |
| 65 | */ |
| 66 | static int elantech_ps2_command(struct psmouse *psmouse, |
| 67 | unsigned char *param, int command) |
| 68 | { |
| 69 | struct ps2dev *ps2dev = &psmouse->ps2dev; |
| 70 | struct elantech_data *etd = psmouse->private; |
| 71 | int rc; |
| 72 | int tries = ETP_PS2_COMMAND_TRIES; |
| 73 | |
| 74 | do { |
| 75 | rc = ps2_command(ps2dev, param, command); |
| 76 | if (rc == 0) |
| 77 | break; |
| 78 | tries--; |
Dmitry Torokhov | d4ae84a8 | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 79 | elantech_debug("retrying ps2 command 0x%02x (%d).\n", |
| 80 | command, tries); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 81 | msleep(ETP_PS2_COMMAND_DELAY); |
| 82 | } while (tries > 0); |
| 83 | |
| 84 | if (rc) |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 85 | psmouse_err(psmouse, "ps2 command 0x%02x failed.\n", command); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 86 | |
| 87 | return rc; |
| 88 | } |
| 89 | |
| 90 | /* |
| 91 | * Send an Elantech style special command to read a value from a register |
| 92 | */ |
| 93 | static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg, |
| 94 | unsigned char *val) |
| 95 | { |
| 96 | struct elantech_data *etd = psmouse->private; |
| 97 | unsigned char param[3]; |
| 98 | int rc = 0; |
| 99 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 100 | if (reg < 0x07 || reg > 0x26) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 101 | return -1; |
| 102 | |
| 103 | if (reg > 0x11 && reg < 0x20) |
| 104 | return -1; |
| 105 | |
| 106 | switch (etd->hw_version) { |
| 107 | case 1: |
| 108 | if (psmouse_sliced_command(psmouse, ETP_REGISTER_READ) || |
| 109 | psmouse_sliced_command(psmouse, reg) || |
| 110 | ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) { |
| 111 | rc = -1; |
| 112 | } |
| 113 | break; |
| 114 | |
| 115 | case 2: |
| 116 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 117 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READ) || |
| 118 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 119 | elantech_ps2_command(psmouse, NULL, reg) || |
| 120 | elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) { |
| 121 | rc = -1; |
| 122 | } |
| 123 | break; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 124 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 125 | case 3 ... 4: |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 126 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 127 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) || |
| 128 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 129 | elantech_ps2_command(psmouse, NULL, reg) || |
| 130 | elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) { |
| 131 | rc = -1; |
| 132 | } |
| 133 | break; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | if (rc) |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 137 | psmouse_err(psmouse, "failed to read register 0x%02x.\n", reg); |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 138 | else if (etd->hw_version != 4) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 139 | *val = param[0]; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 140 | else |
| 141 | *val = param[1]; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 142 | |
| 143 | return rc; |
| 144 | } |
| 145 | |
| 146 | /* |
| 147 | * Send an Elantech style special command to write a register with a value |
| 148 | */ |
| 149 | static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg, |
| 150 | unsigned char val) |
| 151 | { |
| 152 | struct elantech_data *etd = psmouse->private; |
| 153 | int rc = 0; |
| 154 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 155 | if (reg < 0x07 || reg > 0x26) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 156 | return -1; |
| 157 | |
| 158 | if (reg > 0x11 && reg < 0x20) |
| 159 | return -1; |
| 160 | |
| 161 | switch (etd->hw_version) { |
| 162 | case 1: |
| 163 | if (psmouse_sliced_command(psmouse, ETP_REGISTER_WRITE) || |
| 164 | psmouse_sliced_command(psmouse, reg) || |
| 165 | psmouse_sliced_command(psmouse, val) || |
| 166 | ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) { |
| 167 | rc = -1; |
| 168 | } |
| 169 | break; |
| 170 | |
| 171 | case 2: |
| 172 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 173 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_WRITE) || |
| 174 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 175 | elantech_ps2_command(psmouse, NULL, reg) || |
| 176 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 177 | elantech_ps2_command(psmouse, NULL, val) || |
| 178 | elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) { |
| 179 | rc = -1; |
| 180 | } |
| 181 | break; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 182 | |
| 183 | case 3: |
| 184 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 185 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) || |
| 186 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 187 | elantech_ps2_command(psmouse, NULL, reg) || |
| 188 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 189 | elantech_ps2_command(psmouse, NULL, val) || |
| 190 | elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) { |
| 191 | rc = -1; |
| 192 | } |
| 193 | break; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 194 | |
| 195 | case 4: |
| 196 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 197 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) || |
| 198 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 199 | elantech_ps2_command(psmouse, NULL, reg) || |
| 200 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 201 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) || |
| 202 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || |
| 203 | elantech_ps2_command(psmouse, NULL, val) || |
| 204 | elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) { |
| 205 | rc = -1; |
| 206 | } |
| 207 | break; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 208 | } |
| 209 | |
| 210 | if (rc) |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 211 | psmouse_err(psmouse, |
| 212 | "failed to write register 0x%02x with value 0x%02x.\n", |
| 213 | reg, val); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 214 | |
| 215 | return rc; |
| 216 | } |
| 217 | |
| 218 | /* |
| 219 | * Dump a complete mouse movement packet to the syslog |
| 220 | */ |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 221 | static void elantech_packet_dump(struct psmouse *psmouse) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 222 | { |
| 223 | int i; |
| 224 | |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 225 | psmouse_printk(KERN_DEBUG, psmouse, "PS/2 packet ["); |
| 226 | for (i = 0; i < psmouse->pktsize; i++) |
| 227 | printk("%s0x%02x ", i ? ", " : " ", psmouse->packet[i]); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 228 | printk("]\n"); |
| 229 | } |
| 230 | |
| 231 | /* |
| 232 | * Interpret complete data packets and report absolute mode input events for |
| 233 | * hardware version 1. (4 byte packets) |
| 234 | */ |
| 235 | static void elantech_report_absolute_v1(struct psmouse *psmouse) |
| 236 | { |
| 237 | struct input_dev *dev = psmouse->dev; |
| 238 | struct elantech_data *etd = psmouse->private; |
| 239 | unsigned char *packet = psmouse->packet; |
| 240 | int fingers; |
| 241 | |
Dmitry Torokhov | 504e8be | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 242 | if (etd->fw_version < 0x020000) { |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 243 | /* |
| 244 | * byte 0: D U p1 p2 1 p3 R L |
| 245 | * byte 1: f 0 th tw x9 x8 y9 y8 |
| 246 | */ |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 247 | fingers = ((packet[1] & 0x80) >> 7) + |
| 248 | ((packet[1] & 0x30) >> 4); |
| 249 | } else { |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 250 | /* |
| 251 | * byte 0: n1 n0 p2 p1 1 p3 R L |
| 252 | * byte 1: 0 0 0 0 x9 x8 y9 y8 |
| 253 | */ |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 254 | fingers = (packet[0] & 0xc0) >> 6; |
| 255 | } |
| 256 | |
Arjan Opmeer | 3f8c0df | 2009-04-18 19:05:40 -0700 | [diff] [blame] | 257 | if (etd->jumpy_cursor) { |
Éric Piel | 7f29f17 | 2010-08-05 23:51:49 -0700 | [diff] [blame] | 258 | if (fingers != 1) { |
| 259 | etd->single_finger_reports = 0; |
| 260 | } else if (etd->single_finger_reports < 2) { |
| 261 | /* Discard first 2 reports of one finger, bogus */ |
| 262 | etd->single_finger_reports++; |
Dmitry Torokhov | d4ae84a8 | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 263 | elantech_debug("discarding packet\n"); |
Éric Piel | 7f29f17 | 2010-08-05 23:51:49 -0700 | [diff] [blame] | 264 | return; |
Arjan Opmeer | 3f8c0df | 2009-04-18 19:05:40 -0700 | [diff] [blame] | 265 | } |
| 266 | } |
| 267 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 268 | input_report_key(dev, BTN_TOUCH, fingers != 0); |
| 269 | |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 270 | /* |
| 271 | * byte 2: x7 x6 x5 x4 x3 x2 x1 x0 |
| 272 | * byte 3: y7 y6 y5 y4 y3 y2 y1 y0 |
| 273 | */ |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 274 | if (fingers) { |
| 275 | input_report_abs(dev, ABS_X, |
| 276 | ((packet[1] & 0x0c) << 6) | packet[2]); |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 277 | input_report_abs(dev, ABS_Y, |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 278 | etd->y_max - (((packet[1] & 0x03) << 8) | packet[3])); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 279 | } |
| 280 | |
| 281 | input_report_key(dev, BTN_TOOL_FINGER, fingers == 1); |
| 282 | input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2); |
| 283 | input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3); |
| 284 | input_report_key(dev, BTN_LEFT, packet[0] & 0x01); |
| 285 | input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); |
| 286 | |
Dmitry Torokhov | 504e8be | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 287 | if (etd->fw_version < 0x020000 && |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 288 | (etd->capabilities[0] & ETP_CAP_HAS_ROCKER)) { |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 289 | /* rocker up */ |
| 290 | input_report_key(dev, BTN_FORWARD, packet[0] & 0x40); |
| 291 | /* rocker down */ |
| 292 | input_report_key(dev, BTN_BACK, packet[0] & 0x80); |
| 293 | } |
| 294 | |
| 295 | input_sync(dev); |
| 296 | } |
| 297 | |
Éric Piel | 89eec4d | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 298 | static void elantech_set_slot(struct input_dev *dev, int slot, bool active, |
| 299 | unsigned int x, unsigned int y) |
| 300 | { |
| 301 | input_mt_slot(dev, slot); |
| 302 | input_mt_report_slot_state(dev, MT_TOOL_FINGER, active); |
| 303 | if (active) { |
| 304 | input_report_abs(dev, ABS_MT_POSITION_X, x); |
| 305 | input_report_abs(dev, ABS_MT_POSITION_Y, y); |
| 306 | } |
| 307 | } |
| 308 | |
| 309 | /* x1 < x2 and y1 < y2 when two fingers, x = y = 0 when not pressed */ |
| 310 | static void elantech_report_semi_mt_data(struct input_dev *dev, |
| 311 | unsigned int num_fingers, |
| 312 | unsigned int x1, unsigned int y1, |
| 313 | unsigned int x2, unsigned int y2) |
| 314 | { |
| 315 | elantech_set_slot(dev, 0, num_fingers != 0, x1, y1); |
| 316 | elantech_set_slot(dev, 1, num_fingers == 2, x2, y2); |
| 317 | } |
| 318 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 319 | /* |
| 320 | * Interpret complete data packets and report absolute mode input events for |
| 321 | * hardware version 2. (6 byte packets) |
| 322 | */ |
| 323 | static void elantech_report_absolute_v2(struct psmouse *psmouse) |
| 324 | { |
Éric Piel | f941c70 | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 325 | struct elantech_data *etd = psmouse->private; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 326 | struct input_dev *dev = psmouse->dev; |
| 327 | unsigned char *packet = psmouse->packet; |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 328 | unsigned int fingers, x1 = 0, y1 = 0, x2 = 0, y2 = 0; |
| 329 | unsigned int width = 0, pres = 0; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 330 | |
| 331 | /* byte 0: n1 n0 . . . . R L */ |
| 332 | fingers = (packet[0] & 0xc0) >> 6; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 333 | |
| 334 | switch (fingers) { |
Éric Piel | 22462d9f | 2010-08-05 23:51:49 -0700 | [diff] [blame] | 335 | case 3: |
| 336 | /* |
| 337 | * Same as one finger, except report of more than 3 fingers: |
| 338 | * byte 3: n4 . w1 w0 . . . . |
| 339 | */ |
| 340 | if (packet[3] & 0x80) |
| 341 | fingers = 4; |
| 342 | /* pass through... */ |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 343 | case 1: |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 344 | /* |
JJ Ding | 1155961 | 2011-09-09 10:22:19 -0700 | [diff] [blame] | 345 | * byte 1: . . . . x11 x10 x9 x8 |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 346 | * byte 2: x7 x6 x5 x4 x4 x2 x1 x0 |
| 347 | */ |
JJ Ding | 1155961 | 2011-09-09 10:22:19 -0700 | [diff] [blame] | 348 | x1 = ((packet[1] & 0x0f) << 8) | packet[2]; |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 349 | /* |
JJ Ding | 1155961 | 2011-09-09 10:22:19 -0700 | [diff] [blame] | 350 | * byte 4: . . . . y11 y10 y9 y8 |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 351 | * byte 5: y7 y6 y5 y4 y3 y2 y1 y0 |
| 352 | */ |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 353 | y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]); |
Éric Piel | 89eec4d | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 354 | |
Éric Piel | f941c70 | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 355 | pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4); |
| 356 | width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 357 | break; |
| 358 | |
| 359 | case 2: |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 360 | /* |
| 361 | * The coordinate of each finger is reported separately |
| 362 | * with a lower resolution for two finger touches: |
| 363 | * byte 0: . . ay8 ax8 . . . . |
| 364 | * byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0 |
| 365 | */ |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 366 | x1 = (((packet[0] & 0x10) << 4) | packet[1]) << 2; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 367 | /* byte 2: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 */ |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 368 | y1 = etd->y_max - |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 369 | ((((packet[0] & 0x20) << 3) | packet[2]) << 2); |
Florian Ragwitz | e938fbf | 2010-05-03 23:29:37 -0700 | [diff] [blame] | 370 | /* |
| 371 | * byte 3: . . by8 bx8 . . . . |
| 372 | * byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0 |
| 373 | */ |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 374 | x2 = (((packet[3] & 0x10) << 4) | packet[4]) << 2; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 375 | /* byte 5: by7 by8 by5 by4 by3 by2 by1 by0 */ |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 376 | y2 = etd->y_max - |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 377 | ((((packet[3] & 0x20) << 3) | packet[5]) << 2); |
Éric Piel | f941c70 | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 378 | |
| 379 | /* Unknown so just report sensible values */ |
| 380 | pres = 127; |
| 381 | width = 7; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 382 | break; |
| 383 | } |
| 384 | |
JJ Ding | 461a791 | 2011-09-09 10:22:58 -0700 | [diff] [blame] | 385 | input_report_key(dev, BTN_TOUCH, fingers != 0); |
| 386 | if (fingers != 0) { |
| 387 | input_report_abs(dev, ABS_X, x1); |
| 388 | input_report_abs(dev, ABS_Y, y1); |
| 389 | } |
Éric Piel | 89eec4d | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 390 | elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 391 | input_report_key(dev, BTN_TOOL_FINGER, fingers == 1); |
| 392 | input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2); |
| 393 | input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3); |
Éric Piel | 22462d9f | 2010-08-05 23:51:49 -0700 | [diff] [blame] | 394 | input_report_key(dev, BTN_TOOL_QUADTAP, fingers == 4); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 395 | input_report_key(dev, BTN_LEFT, packet[0] & 0x01); |
| 396 | input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); |
Éric Piel | f941c70 | 2011-05-16 22:45:54 -0700 | [diff] [blame] | 397 | if (etd->reports_pressure) { |
| 398 | input_report_abs(dev, ABS_PRESSURE, pres); |
| 399 | input_report_abs(dev, ABS_TOOL_WIDTH, width); |
| 400 | } |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 401 | |
| 402 | input_sync(dev); |
| 403 | } |
| 404 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 405 | /* |
| 406 | * Interpret complete data packets and report absolute mode input events for |
| 407 | * hardware version 3. (12 byte packets for two fingers) |
| 408 | */ |
| 409 | static void elantech_report_absolute_v3(struct psmouse *psmouse, |
| 410 | int packet_type) |
| 411 | { |
| 412 | struct input_dev *dev = psmouse->dev; |
| 413 | struct elantech_data *etd = psmouse->private; |
| 414 | unsigned char *packet = psmouse->packet; |
| 415 | unsigned int fingers = 0, x1 = 0, y1 = 0, x2 = 0, y2 = 0; |
| 416 | unsigned int width = 0, pres = 0; |
| 417 | |
| 418 | /* byte 0: n1 n0 . . . . R L */ |
| 419 | fingers = (packet[0] & 0xc0) >> 6; |
| 420 | |
| 421 | switch (fingers) { |
| 422 | case 3: |
| 423 | case 1: |
| 424 | /* |
| 425 | * byte 1: . . . . x11 x10 x9 x8 |
| 426 | * byte 2: x7 x6 x5 x4 x4 x2 x1 x0 |
| 427 | */ |
| 428 | x1 = ((packet[1] & 0x0f) << 8) | packet[2]; |
| 429 | /* |
| 430 | * byte 4: . . . . y11 y10 y9 y8 |
| 431 | * byte 5: y7 y6 y5 y4 y3 y2 y1 y0 |
| 432 | */ |
| 433 | y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]); |
| 434 | break; |
| 435 | |
| 436 | case 2: |
| 437 | if (packet_type == PACKET_V3_HEAD) { |
| 438 | /* |
| 439 | * byte 1: . . . . ax11 ax10 ax9 ax8 |
| 440 | * byte 2: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0 |
| 441 | */ |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 442 | etd->mt[0].x = ((packet[1] & 0x0f) << 8) | packet[2]; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 443 | /* |
| 444 | * byte 4: . . . . ay11 ay10 ay9 ay8 |
| 445 | * byte 5: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 |
| 446 | */ |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 447 | etd->mt[0].y = etd->y_max - |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 448 | (((packet[4] & 0x0f) << 8) | packet[5]); |
| 449 | /* |
| 450 | * wait for next packet |
| 451 | */ |
| 452 | return; |
| 453 | } |
| 454 | |
| 455 | /* packet_type == PACKET_V3_TAIL */ |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 456 | x1 = etd->mt[0].x; |
| 457 | y1 = etd->mt[0].y; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 458 | x2 = ((packet[1] & 0x0f) << 8) | packet[2]; |
| 459 | y2 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]); |
| 460 | break; |
| 461 | } |
| 462 | |
| 463 | pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4); |
| 464 | width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4); |
| 465 | |
| 466 | input_report_key(dev, BTN_TOUCH, fingers != 0); |
| 467 | if (fingers != 0) { |
| 468 | input_report_abs(dev, ABS_X, x1); |
| 469 | input_report_abs(dev, ABS_Y, y1); |
| 470 | } |
| 471 | elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2); |
| 472 | input_report_key(dev, BTN_TOOL_FINGER, fingers == 1); |
| 473 | input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2); |
| 474 | input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3); |
| 475 | input_report_key(dev, BTN_LEFT, packet[0] & 0x01); |
| 476 | input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); |
| 477 | input_report_abs(dev, ABS_PRESSURE, pres); |
| 478 | input_report_abs(dev, ABS_TOOL_WIDTH, width); |
| 479 | |
| 480 | input_sync(dev); |
| 481 | } |
| 482 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 483 | static void elantech_input_sync_v4(struct psmouse *psmouse) |
| 484 | { |
| 485 | struct input_dev *dev = psmouse->dev; |
| 486 | unsigned char *packet = psmouse->packet; |
| 487 | |
| 488 | input_report_key(dev, BTN_LEFT, packet[0] & 0x01); |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 489 | input_mt_report_pointer_emulation(dev, true); |
| 490 | input_sync(dev); |
| 491 | } |
| 492 | |
| 493 | static void process_packet_status_v4(struct psmouse *psmouse) |
| 494 | { |
| 495 | struct input_dev *dev = psmouse->dev; |
| 496 | unsigned char *packet = psmouse->packet; |
| 497 | unsigned fingers; |
| 498 | int i; |
| 499 | |
| 500 | /* notify finger state change */ |
| 501 | fingers = packet[1] & 0x1f; |
| 502 | for (i = 0; i < ETP_MAX_FINGERS; i++) { |
| 503 | if ((fingers & (1 << i)) == 0) { |
| 504 | input_mt_slot(dev, i); |
| 505 | input_mt_report_slot_state(dev, MT_TOOL_FINGER, false); |
| 506 | } |
| 507 | } |
| 508 | |
| 509 | elantech_input_sync_v4(psmouse); |
| 510 | } |
| 511 | |
| 512 | static void process_packet_head_v4(struct psmouse *psmouse) |
| 513 | { |
| 514 | struct input_dev *dev = psmouse->dev; |
| 515 | struct elantech_data *etd = psmouse->private; |
| 516 | unsigned char *packet = psmouse->packet; |
| 517 | int id = ((packet[3] & 0xe0) >> 5) - 1; |
| 518 | int pres, traces; |
| 519 | |
| 520 | if (id < 0) |
| 521 | return; |
| 522 | |
| 523 | etd->mt[id].x = ((packet[1] & 0x0f) << 8) | packet[2]; |
| 524 | etd->mt[id].y = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]); |
| 525 | pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4); |
| 526 | traces = (packet[0] & 0xf0) >> 4; |
| 527 | |
| 528 | input_mt_slot(dev, id); |
| 529 | input_mt_report_slot_state(dev, MT_TOOL_FINGER, true); |
| 530 | |
| 531 | input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x); |
| 532 | input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y); |
| 533 | input_report_abs(dev, ABS_MT_PRESSURE, pres); |
| 534 | input_report_abs(dev, ABS_MT_TOUCH_MAJOR, traces * etd->width); |
| 535 | /* report this for backwards compatibility */ |
| 536 | input_report_abs(dev, ABS_TOOL_WIDTH, traces); |
| 537 | |
| 538 | elantech_input_sync_v4(psmouse); |
| 539 | } |
| 540 | |
| 541 | static void process_packet_motion_v4(struct psmouse *psmouse) |
| 542 | { |
| 543 | struct input_dev *dev = psmouse->dev; |
| 544 | struct elantech_data *etd = psmouse->private; |
| 545 | unsigned char *packet = psmouse->packet; |
| 546 | int weight, delta_x1 = 0, delta_y1 = 0, delta_x2 = 0, delta_y2 = 0; |
| 547 | int id, sid; |
| 548 | |
| 549 | id = ((packet[0] & 0xe0) >> 5) - 1; |
| 550 | if (id < 0) |
| 551 | return; |
| 552 | |
| 553 | sid = ((packet[3] & 0xe0) >> 5) - 1; |
| 554 | weight = (packet[0] & 0x10) ? ETP_WEIGHT_VALUE : 1; |
| 555 | /* |
| 556 | * Motion packets give us the delta of x, y values of specific fingers, |
| 557 | * but in two's complement. Let the compiler do the conversion for us. |
| 558 | * Also _enlarge_ the numbers to int, in case of overflow. |
| 559 | */ |
| 560 | delta_x1 = (signed char)packet[1]; |
| 561 | delta_y1 = (signed char)packet[2]; |
| 562 | delta_x2 = (signed char)packet[4]; |
| 563 | delta_y2 = (signed char)packet[5]; |
| 564 | |
| 565 | etd->mt[id].x += delta_x1 * weight; |
| 566 | etd->mt[id].y -= delta_y1 * weight; |
| 567 | input_mt_slot(dev, id); |
| 568 | input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x); |
| 569 | input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y); |
| 570 | |
| 571 | if (sid >= 0) { |
| 572 | etd->mt[sid].x += delta_x2 * weight; |
| 573 | etd->mt[sid].y -= delta_y2 * weight; |
| 574 | input_mt_slot(dev, sid); |
| 575 | input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[sid].x); |
| 576 | input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[sid].y); |
| 577 | } |
| 578 | |
| 579 | elantech_input_sync_v4(psmouse); |
| 580 | } |
| 581 | |
| 582 | static void elantech_report_absolute_v4(struct psmouse *psmouse, |
| 583 | int packet_type) |
| 584 | { |
| 585 | switch (packet_type) { |
| 586 | case PACKET_V4_STATUS: |
| 587 | process_packet_status_v4(psmouse); |
| 588 | break; |
| 589 | |
| 590 | case PACKET_V4_HEAD: |
| 591 | process_packet_head_v4(psmouse); |
| 592 | break; |
| 593 | |
| 594 | case PACKET_V4_MOTION: |
| 595 | process_packet_motion_v4(psmouse); |
| 596 | break; |
| 597 | |
| 598 | case PACKET_UNKNOWN: |
| 599 | default: |
| 600 | /* impossible to get here */ |
| 601 | break; |
| 602 | } |
| 603 | } |
| 604 | |
JJ Ding | 7894f21 | 2011-09-09 10:28:04 -0700 | [diff] [blame] | 605 | static int elantech_packet_check_v1(struct psmouse *psmouse) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 606 | { |
| 607 | struct elantech_data *etd = psmouse->private; |
| 608 | unsigned char *packet = psmouse->packet; |
| 609 | unsigned char p1, p2, p3; |
| 610 | |
| 611 | /* Parity bits are placed differently */ |
Dmitry Torokhov | 504e8be | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 612 | if (etd->fw_version < 0x020000) { |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 613 | /* byte 0: D U p1 p2 1 p3 R L */ |
| 614 | p1 = (packet[0] & 0x20) >> 5; |
| 615 | p2 = (packet[0] & 0x10) >> 4; |
| 616 | } else { |
| 617 | /* byte 0: n1 n0 p2 p1 1 p3 R L */ |
| 618 | p1 = (packet[0] & 0x10) >> 4; |
| 619 | p2 = (packet[0] & 0x20) >> 5; |
| 620 | } |
| 621 | |
| 622 | p3 = (packet[0] & 0x04) >> 2; |
| 623 | |
| 624 | return etd->parity[packet[1]] == p1 && |
| 625 | etd->parity[packet[2]] == p2 && |
| 626 | etd->parity[packet[3]] == p3; |
| 627 | } |
| 628 | |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 629 | static int elantech_debounce_check_v2(struct psmouse *psmouse) |
| 630 | { |
| 631 | /* |
| 632 | * When we encounter packet that matches this exactly, it means the |
| 633 | * hardware is in debounce status. Just ignore the whole packet. |
| 634 | */ |
| 635 | const u8 debounce_packet[] = { 0x84, 0xff, 0xff, 0x02, 0xff, 0xff }; |
| 636 | unsigned char *packet = psmouse->packet; |
| 637 | |
| 638 | return !memcmp(packet, debounce_packet, sizeof(debounce_packet)); |
| 639 | } |
| 640 | |
JJ Ding | 7894f21 | 2011-09-09 10:28:04 -0700 | [diff] [blame] | 641 | static int elantech_packet_check_v2(struct psmouse *psmouse) |
| 642 | { |
| 643 | struct elantech_data *etd = psmouse->private; |
| 644 | unsigned char *packet = psmouse->packet; |
| 645 | |
| 646 | /* |
| 647 | * V2 hardware has two flavors. Older ones that do not report pressure, |
| 648 | * and newer ones that reports pressure and width. With newer ones, all |
| 649 | * packets (1, 2, 3 finger touch) have the same constant bits. With |
| 650 | * older ones, 1/3 finger touch packets and 2 finger touch packets |
| 651 | * have different constant bits. |
| 652 | * With all three cases, if the constant bits are not exactly what I |
| 653 | * expected, I consider them invalid. |
| 654 | */ |
| 655 | if (etd->reports_pressure) |
| 656 | return (packet[0] & 0x0c) == 0x04 && |
| 657 | (packet[3] & 0x0f) == 0x02; |
| 658 | |
| 659 | if ((packet[0] & 0xc0) == 0x80) |
| 660 | return (packet[0] & 0x0c) == 0x0c && |
| 661 | (packet[3] & 0x0e) == 0x08; |
| 662 | |
| 663 | return (packet[0] & 0x3c) == 0x3c && |
| 664 | (packet[1] & 0xf0) == 0x00 && |
| 665 | (packet[3] & 0x3e) == 0x38 && |
| 666 | (packet[4] & 0xf0) == 0x00; |
| 667 | } |
| 668 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 669 | /* |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 670 | * We check the constant bits to determine what packet type we get, |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 671 | * so packet checking is mandatory for v3 and later hardware. |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 672 | */ |
| 673 | static int elantech_packet_check_v3(struct psmouse *psmouse) |
| 674 | { |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 675 | struct elantech_data *etd = psmouse->private; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 676 | const u8 debounce_packet[] = { 0xc4, 0xff, 0xff, 0x02, 0xff, 0xff }; |
| 677 | unsigned char *packet = psmouse->packet; |
| 678 | |
| 679 | /* |
| 680 | * check debounce first, it has the same signature in byte 0 |
| 681 | * and byte 3 as PACKET_V3_HEAD. |
| 682 | */ |
| 683 | if (!memcmp(packet, debounce_packet, sizeof(debounce_packet))) |
| 684 | return PACKET_DEBOUNCE; |
| 685 | |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 686 | /* |
| 687 | * If the hardware flag 'crc_enabled' is set the packets have |
| 688 | * different signatures. |
| 689 | */ |
| 690 | if (etd->crc_enabled) { |
| 691 | if ((packet[3] & 0x09) == 0x08) |
| 692 | return PACKET_V3_HEAD; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 693 | |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 694 | if ((packet[3] & 0x09) == 0x09) |
| 695 | return PACKET_V3_TAIL; |
| 696 | } else { |
| 697 | if ((packet[0] & 0x0c) == 0x04 && (packet[3] & 0xcf) == 0x02) |
| 698 | return PACKET_V3_HEAD; |
| 699 | |
| 700 | if ((packet[0] & 0x0c) == 0x0c && (packet[3] & 0xce) == 0x0c) |
| 701 | return PACKET_V3_TAIL; |
| 702 | } |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 703 | |
| 704 | return PACKET_UNKNOWN; |
| 705 | } |
| 706 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 707 | static int elantech_packet_check_v4(struct psmouse *psmouse) |
| 708 | { |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 709 | struct elantech_data *etd = psmouse->private; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 710 | unsigned char *packet = psmouse->packet; |
Matteo Delfino | 9eebed7 | 2013-07-06 21:52:26 -0700 | [diff] [blame] | 711 | unsigned char packet_type = packet[3] & 0x03; |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 712 | bool sanity_check; |
| 713 | |
| 714 | /* |
| 715 | * Sanity check based on the constant bits of a packet. |
| 716 | * The constant bits change depending on the value of |
| 717 | * the hardware flag 'crc_enabled' but are the same for |
| 718 | * every packet, regardless of the type. |
| 719 | */ |
| 720 | if (etd->crc_enabled) |
| 721 | sanity_check = ((packet[3] & 0x08) == 0x00); |
| 722 | else |
| 723 | sanity_check = ((packet[0] & 0x0c) == 0x04 && |
| 724 | (packet[3] & 0x1c) == 0x10); |
| 725 | |
| 726 | if (!sanity_check) |
| 727 | return PACKET_UNKNOWN; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 728 | |
Matteo Delfino | 9eebed7 | 2013-07-06 21:52:26 -0700 | [diff] [blame] | 729 | switch (packet_type) { |
| 730 | case 0: |
| 731 | return PACKET_V4_STATUS; |
| 732 | |
| 733 | case 1: |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 734 | return PACKET_V4_HEAD; |
| 735 | |
Matteo Delfino | 9eebed7 | 2013-07-06 21:52:26 -0700 | [diff] [blame] | 736 | case 2: |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 737 | return PACKET_V4_MOTION; |
Matteo Delfino | 9eebed7 | 2013-07-06 21:52:26 -0700 | [diff] [blame] | 738 | } |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 739 | |
| 740 | return PACKET_UNKNOWN; |
| 741 | } |
| 742 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 743 | /* |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 744 | * Process byte stream from mouse and handle complete packets |
| 745 | */ |
| 746 | static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse) |
| 747 | { |
| 748 | struct elantech_data *etd = psmouse->private; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 749 | int packet_type; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 750 | |
| 751 | if (psmouse->pktcnt < psmouse->pktsize) |
| 752 | return PSMOUSE_GOOD_DATA; |
| 753 | |
| 754 | if (etd->debug > 1) |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 755 | elantech_packet_dump(psmouse); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 756 | |
| 757 | switch (etd->hw_version) { |
| 758 | case 1: |
JJ Ding | 7894f21 | 2011-09-09 10:28:04 -0700 | [diff] [blame] | 759 | if (etd->paritycheck && !elantech_packet_check_v1(psmouse)) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 760 | return PSMOUSE_BAD_DATA; |
| 761 | |
| 762 | elantech_report_absolute_v1(psmouse); |
| 763 | break; |
| 764 | |
| 765 | case 2: |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 766 | /* ignore debounce */ |
| 767 | if (elantech_debounce_check_v2(psmouse)) |
| 768 | return PSMOUSE_FULL_PACKET; |
| 769 | |
JJ Ding | 7894f21 | 2011-09-09 10:28:04 -0700 | [diff] [blame] | 770 | if (etd->paritycheck && !elantech_packet_check_v2(psmouse)) |
| 771 | return PSMOUSE_BAD_DATA; |
| 772 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 773 | elantech_report_absolute_v2(psmouse); |
| 774 | break; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 775 | |
| 776 | case 3: |
| 777 | packet_type = elantech_packet_check_v3(psmouse); |
| 778 | /* ignore debounce */ |
| 779 | if (packet_type == PACKET_DEBOUNCE) |
| 780 | return PSMOUSE_FULL_PACKET; |
| 781 | |
| 782 | if (packet_type == PACKET_UNKNOWN) |
| 783 | return PSMOUSE_BAD_DATA; |
| 784 | |
| 785 | elantech_report_absolute_v3(psmouse, packet_type); |
| 786 | break; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 787 | |
| 788 | case 4: |
| 789 | packet_type = elantech_packet_check_v4(psmouse); |
| 790 | if (packet_type == PACKET_UNKNOWN) |
| 791 | return PSMOUSE_BAD_DATA; |
| 792 | |
| 793 | elantech_report_absolute_v4(psmouse, packet_type); |
| 794 | break; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 795 | } |
| 796 | |
| 797 | return PSMOUSE_FULL_PACKET; |
| 798 | } |
| 799 | |
| 800 | /* |
| 801 | * Put the touchpad into absolute mode |
| 802 | */ |
| 803 | static int elantech_set_absolute_mode(struct psmouse *psmouse) |
| 804 | { |
| 805 | struct elantech_data *etd = psmouse->private; |
| 806 | unsigned char val; |
| 807 | int tries = ETP_READ_BACK_TRIES; |
| 808 | int rc = 0; |
| 809 | |
| 810 | switch (etd->hw_version) { |
| 811 | case 1: |
| 812 | etd->reg_10 = 0x16; |
| 813 | etd->reg_11 = 0x8f; |
| 814 | if (elantech_write_reg(psmouse, 0x10, etd->reg_10) || |
| 815 | elantech_write_reg(psmouse, 0x11, etd->reg_11)) { |
| 816 | rc = -1; |
| 817 | } |
| 818 | break; |
| 819 | |
| 820 | case 2: |
| 821 | /* Windows driver values */ |
| 822 | etd->reg_10 = 0x54; |
| 823 | etd->reg_11 = 0x88; /* 0x8a */ |
| 824 | etd->reg_21 = 0x60; /* 0x00 */ |
| 825 | if (elantech_write_reg(psmouse, 0x10, etd->reg_10) || |
| 826 | elantech_write_reg(psmouse, 0x11, etd->reg_11) || |
| 827 | elantech_write_reg(psmouse, 0x21, etd->reg_21)) { |
| 828 | rc = -1; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 829 | } |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 830 | break; |
| 831 | |
| 832 | case 3: |
| 833 | etd->reg_10 = 0x0b; |
| 834 | if (elantech_write_reg(psmouse, 0x10, etd->reg_10)) |
| 835 | rc = -1; |
| 836 | |
| 837 | break; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 838 | |
| 839 | case 4: |
| 840 | etd->reg_07 = 0x01; |
| 841 | if (elantech_write_reg(psmouse, 0x07, etd->reg_07)) |
| 842 | rc = -1; |
| 843 | |
| 844 | goto skip_readback_reg_10; /* v4 has no reg 0x10 to read */ |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 845 | } |
| 846 | |
| 847 | if (rc == 0) { |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 848 | /* |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 849 | * Read back reg 0x10. For hardware version 1 we must make |
| 850 | * sure the absolute mode bit is set. For hardware version 2 |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 851 | * the touchpad is probably initializing and not ready until |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 852 | * we read back the value we just wrote. |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 853 | */ |
| 854 | do { |
| 855 | rc = elantech_read_reg(psmouse, 0x10, &val); |
| 856 | if (rc == 0) |
| 857 | break; |
| 858 | tries--; |
Dmitry Torokhov | d4ae84a8 | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 859 | elantech_debug("retrying read (%d).\n", tries); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 860 | msleep(ETP_READ_BACK_DELAY); |
| 861 | } while (tries > 0); |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 862 | |
| 863 | if (rc) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 864 | psmouse_err(psmouse, |
| 865 | "failed to read back register 0x10.\n"); |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 866 | } else if (etd->hw_version == 1 && |
| 867 | !(val & ETP_R10_ABSOLUTE_MODE)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 868 | psmouse_err(psmouse, |
| 869 | "touchpad refuses to switch to absolute mode.\n"); |
Arjan Opmeer | b2546df | 2009-04-18 19:10:17 -0700 | [diff] [blame] | 870 | rc = -1; |
| 871 | } |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 872 | } |
| 873 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 874 | skip_readback_reg_10: |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 875 | if (rc) |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 876 | psmouse_err(psmouse, "failed to initialise registers.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 877 | |
| 878 | return rc; |
| 879 | } |
| 880 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 881 | static int elantech_set_range(struct psmouse *psmouse, |
| 882 | unsigned int *x_min, unsigned int *y_min, |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 883 | unsigned int *x_max, unsigned int *y_max, |
| 884 | unsigned int *width) |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 885 | { |
| 886 | struct elantech_data *etd = psmouse->private; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 887 | unsigned char param[3]; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 888 | unsigned char traces; |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 889 | |
| 890 | switch (etd->hw_version) { |
| 891 | case 1: |
| 892 | *x_min = ETP_XMIN_V1; |
| 893 | *y_min = ETP_YMIN_V1; |
| 894 | *x_max = ETP_XMAX_V1; |
| 895 | *y_max = ETP_YMAX_V1; |
| 896 | break; |
| 897 | |
| 898 | case 2: |
| 899 | if (etd->fw_version == 0x020800 || |
| 900 | etd->fw_version == 0x020b00 || |
| 901 | etd->fw_version == 0x020030) { |
| 902 | *x_min = ETP_XMIN_V2; |
| 903 | *y_min = ETP_YMIN_V2; |
| 904 | *x_max = ETP_XMAX_V2; |
| 905 | *y_max = ETP_YMAX_V2; |
| 906 | } else { |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 907 | int i; |
| 908 | int fixed_dpi; |
| 909 | |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 910 | i = (etd->fw_version > 0x020800 && |
| 911 | etd->fw_version < 0x020900) ? 1 : 2; |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 912 | |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 913 | if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param)) |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 914 | return -1; |
| 915 | |
| 916 | fixed_dpi = param[1] & 0x10; |
| 917 | |
| 918 | if (((etd->fw_version >> 16) == 0x14) && fixed_dpi) { |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 919 | if (etd->send_cmd(psmouse, ETP_SAMPLE_QUERY, param)) |
JJ Ding | 84a90b6 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 920 | return -1; |
| 921 | |
| 922 | *x_max = (etd->capabilities[1] - i) * param[1] / 2; |
| 923 | *y_max = (etd->capabilities[2] - i) * param[2] / 2; |
| 924 | } else if (etd->fw_version == 0x040216) { |
| 925 | *x_max = 819; |
| 926 | *y_max = 405; |
| 927 | } else if (etd->fw_version == 0x040219 || etd->fw_version == 0x040215) { |
| 928 | *x_max = 900; |
| 929 | *y_max = 500; |
| 930 | } else { |
| 931 | *x_max = (etd->capabilities[1] - i) * 64; |
| 932 | *y_max = (etd->capabilities[2] - i) * 64; |
| 933 | } |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 934 | } |
| 935 | break; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 936 | |
| 937 | case 3: |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 938 | if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param)) |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 939 | return -1; |
| 940 | |
| 941 | *x_max = (0x0f & param[0]) << 8 | param[1]; |
| 942 | *y_max = (0xf0 & param[0]) << 4 | param[2]; |
| 943 | break; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 944 | |
| 945 | case 4: |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 946 | if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param)) |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 947 | return -1; |
| 948 | |
| 949 | *x_max = (0x0f & param[0]) << 8 | param[1]; |
| 950 | *y_max = (0xf0 & param[0]) << 4 | param[2]; |
| 951 | traces = etd->capabilities[1]; |
| 952 | if ((traces < 2) || (traces > *x_max)) |
| 953 | return -1; |
| 954 | |
| 955 | *width = *x_max / (traces - 1); |
| 956 | break; |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 957 | } |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 958 | |
| 959 | return 0; |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 960 | } |
| 961 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 962 | /* |
JJ Ding | 3d95fd6 | 2011-11-20 22:26:56 -0800 | [diff] [blame] | 963 | * (value from firmware) * 10 + 790 = dpi |
| 964 | * we also have to convert dpi to dots/mm (*10/254 to avoid floating point) |
| 965 | */ |
| 966 | static unsigned int elantech_convert_res(unsigned int val) |
| 967 | { |
| 968 | return (val * 10 + 790) * 10 / 254; |
| 969 | } |
| 970 | |
| 971 | static int elantech_get_resolution_v4(struct psmouse *psmouse, |
| 972 | unsigned int *x_res, |
| 973 | unsigned int *y_res) |
| 974 | { |
| 975 | unsigned char param[3]; |
| 976 | |
| 977 | if (elantech_send_cmd(psmouse, ETP_RESOLUTION_QUERY, param)) |
| 978 | return -1; |
| 979 | |
| 980 | *x_res = elantech_convert_res(param[1] & 0x0f); |
| 981 | *y_res = elantech_convert_res((param[1] & 0xf0) >> 4); |
| 982 | |
| 983 | return 0; |
| 984 | } |
| 985 | |
| 986 | /* |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 987 | * Set the appropriate event bits for the input subsystem |
| 988 | */ |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 989 | static int elantech_set_input_params(struct psmouse *psmouse) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 990 | { |
| 991 | struct input_dev *dev = psmouse->dev; |
| 992 | struct elantech_data *etd = psmouse->private; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 993 | unsigned int x_min = 0, y_min = 0, x_max = 0, y_max = 0, width = 0; |
JJ Ding | 3d95fd6 | 2011-11-20 22:26:56 -0800 | [diff] [blame] | 994 | unsigned int x_res = 0, y_res = 0; |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 995 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 996 | 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] | 997 | return -1; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 998 | |
JJ Ding | e3dde4f | 2012-04-10 00:30:12 -0700 | [diff] [blame] | 999 | __set_bit(INPUT_PROP_POINTER, dev->propbit); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1000 | __set_bit(EV_KEY, dev->evbit); |
| 1001 | __set_bit(EV_ABS, dev->evbit); |
Dmitry Torokhov | c7a1f3c | 2009-11-16 22:12:21 -0800 | [diff] [blame] | 1002 | __clear_bit(EV_REL, dev->evbit); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1003 | |
| 1004 | __set_bit(BTN_LEFT, dev->keybit); |
| 1005 | __set_bit(BTN_RIGHT, dev->keybit); |
| 1006 | |
| 1007 | __set_bit(BTN_TOUCH, dev->keybit); |
| 1008 | __set_bit(BTN_TOOL_FINGER, dev->keybit); |
| 1009 | __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit); |
| 1010 | __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit); |
| 1011 | |
| 1012 | switch (etd->hw_version) { |
| 1013 | case 1: |
| 1014 | /* Rocker button */ |
Dmitry Torokhov | 504e8be | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 1015 | if (etd->fw_version < 0x020000 && |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1016 | (etd->capabilities[0] & ETP_CAP_HAS_ROCKER)) { |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1017 | __set_bit(BTN_FORWARD, dev->keybit); |
| 1018 | __set_bit(BTN_BACK, dev->keybit); |
| 1019 | } |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1020 | input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0); |
| 1021 | 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] | 1022 | break; |
| 1023 | |
| 1024 | case 2: |
Éric Piel | 22462d9f | 2010-08-05 23:51:49 -0700 | [diff] [blame] | 1025 | __set_bit(BTN_TOOL_QUADTAP, dev->keybit); |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1026 | __set_bit(INPUT_PROP_SEMI_MT, dev->propbit); |
| 1027 | /* fall through */ |
| 1028 | case 3: |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1029 | input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0); |
| 1030 | 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] | 1031 | if (etd->reports_pressure) { |
| 1032 | input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2, |
| 1033 | ETP_PMAX_V2, 0, 0); |
| 1034 | input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2, |
| 1035 | ETP_WMAX_V2, 0, 0); |
| 1036 | } |
Henrik Rydberg | b4adbbe | 2012-08-11 22:07:55 +0200 | [diff] [blame] | 1037 | input_mt_init_slots(dev, 2, 0); |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1038 | input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0); |
| 1039 | 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] | 1040 | break; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1041 | |
| 1042 | case 4: |
JJ Ding | 3d95fd6 | 2011-11-20 22:26:56 -0800 | [diff] [blame] | 1043 | if (elantech_get_resolution_v4(psmouse, &x_res, &y_res)) { |
| 1044 | /* |
| 1045 | * if query failed, print a warning and leave the values |
| 1046 | * zero to resemble synaptics.c behavior. |
| 1047 | */ |
| 1048 | psmouse_warn(psmouse, "couldn't query resolution data.\n"); |
| 1049 | } |
JJ Ding | e3dde4f | 2012-04-10 00:30:12 -0700 | [diff] [blame] | 1050 | /* v4 is clickpad, with only one button. */ |
| 1051 | __set_bit(INPUT_PROP_BUTTONPAD, dev->propbit); |
| 1052 | __clear_bit(BTN_RIGHT, dev->keybit); |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1053 | __set_bit(BTN_TOOL_QUADTAP, dev->keybit); |
| 1054 | /* For X to recognize me as touchpad. */ |
| 1055 | input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0); |
| 1056 | input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0); |
JJ Ding | 3d95fd6 | 2011-11-20 22:26:56 -0800 | [diff] [blame] | 1057 | input_abs_set_res(dev, ABS_X, x_res); |
| 1058 | input_abs_set_res(dev, ABS_Y, y_res); |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1059 | /* |
| 1060 | * range of pressure and width is the same as v2, |
| 1061 | * report ABS_PRESSURE, ABS_TOOL_WIDTH for compatibility. |
| 1062 | */ |
| 1063 | input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2, |
| 1064 | ETP_PMAX_V2, 0, 0); |
| 1065 | input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2, |
| 1066 | ETP_WMAX_V2, 0, 0); |
| 1067 | /* Multitouch capable pad, up to 5 fingers. */ |
Henrik Rydberg | b4adbbe | 2012-08-11 22:07:55 +0200 | [diff] [blame] | 1068 | input_mt_init_slots(dev, ETP_MAX_FINGERS, 0); |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1069 | input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0); |
| 1070 | input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0); |
JJ Ding | 3d95fd6 | 2011-11-20 22:26:56 -0800 | [diff] [blame] | 1071 | input_abs_set_res(dev, ABS_MT_POSITION_X, x_res); |
| 1072 | input_abs_set_res(dev, ABS_MT_POSITION_Y, y_res); |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1073 | input_set_abs_params(dev, ABS_MT_PRESSURE, ETP_PMIN_V2, |
| 1074 | ETP_PMAX_V2, 0, 0); |
| 1075 | /* |
| 1076 | * The firmware reports how many trace lines the finger spans, |
| 1077 | * convert to surface unit as Protocol-B requires. |
| 1078 | */ |
| 1079 | input_set_abs_params(dev, ABS_MT_TOUCH_MAJOR, 0, |
| 1080 | ETP_WMAX_V2 * width, 0, 0); |
| 1081 | break; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1082 | } |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1083 | |
| 1084 | etd->y_max = y_max; |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1085 | etd->width = width; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1086 | |
| 1087 | return 0; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1088 | } |
| 1089 | |
| 1090 | struct elantech_attr_data { |
| 1091 | size_t field_offset; |
| 1092 | unsigned char reg; |
| 1093 | }; |
| 1094 | |
| 1095 | /* |
| 1096 | * Display a register value by reading a sysfs entry |
| 1097 | */ |
| 1098 | static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data, |
| 1099 | char *buf) |
| 1100 | { |
| 1101 | struct elantech_data *etd = psmouse->private; |
| 1102 | struct elantech_attr_data *attr = data; |
| 1103 | unsigned char *reg = (unsigned char *) etd + attr->field_offset; |
| 1104 | int rc = 0; |
| 1105 | |
| 1106 | if (attr->reg) |
| 1107 | rc = elantech_read_reg(psmouse, attr->reg, reg); |
| 1108 | |
| 1109 | return sprintf(buf, "0x%02x\n", (attr->reg && rc) ? -1 : *reg); |
| 1110 | } |
| 1111 | |
| 1112 | /* |
| 1113 | * Write a register value by writing a sysfs entry |
| 1114 | */ |
| 1115 | static ssize_t elantech_set_int_attr(struct psmouse *psmouse, |
| 1116 | void *data, const char *buf, size_t count) |
| 1117 | { |
| 1118 | struct elantech_data *etd = psmouse->private; |
| 1119 | struct elantech_attr_data *attr = data; |
| 1120 | unsigned char *reg = (unsigned char *) etd + attr->field_offset; |
JJ Ding | 76496e7 | 2011-11-09 10:20:14 -0800 | [diff] [blame] | 1121 | unsigned char value; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1122 | int err; |
| 1123 | |
JJ Ding | 76496e7 | 2011-11-09 10:20:14 -0800 | [diff] [blame] | 1124 | err = kstrtou8(buf, 16, &value); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1125 | if (err) |
| 1126 | return err; |
| 1127 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1128 | /* Do we need to preserve some bits for version 2 hardware too? */ |
| 1129 | if (etd->hw_version == 1) { |
| 1130 | if (attr->reg == 0x10) |
| 1131 | /* Force absolute mode always on */ |
| 1132 | value |= ETP_R10_ABSOLUTE_MODE; |
| 1133 | else if (attr->reg == 0x11) |
| 1134 | /* Force 4 byte mode always on */ |
| 1135 | value |= ETP_R11_4_BYTE_MODE; |
| 1136 | } |
| 1137 | |
| 1138 | if (!attr->reg || elantech_write_reg(psmouse, attr->reg, value) == 0) |
| 1139 | *reg = value; |
| 1140 | |
| 1141 | return count; |
| 1142 | } |
| 1143 | |
| 1144 | #define ELANTECH_INT_ATTR(_name, _register) \ |
| 1145 | static struct elantech_attr_data elantech_attr_##_name = { \ |
| 1146 | .field_offset = offsetof(struct elantech_data, _name), \ |
| 1147 | .reg = _register, \ |
| 1148 | }; \ |
| 1149 | PSMOUSE_DEFINE_ATTR(_name, S_IWUSR | S_IRUGO, \ |
| 1150 | &elantech_attr_##_name, \ |
| 1151 | elantech_show_int_attr, \ |
| 1152 | elantech_set_int_attr) |
| 1153 | |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1154 | ELANTECH_INT_ATTR(reg_07, 0x07); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1155 | ELANTECH_INT_ATTR(reg_10, 0x10); |
| 1156 | ELANTECH_INT_ATTR(reg_11, 0x11); |
| 1157 | ELANTECH_INT_ATTR(reg_20, 0x20); |
| 1158 | ELANTECH_INT_ATTR(reg_21, 0x21); |
| 1159 | ELANTECH_INT_ATTR(reg_22, 0x22); |
| 1160 | ELANTECH_INT_ATTR(reg_23, 0x23); |
| 1161 | ELANTECH_INT_ATTR(reg_24, 0x24); |
| 1162 | ELANTECH_INT_ATTR(reg_25, 0x25); |
| 1163 | ELANTECH_INT_ATTR(reg_26, 0x26); |
| 1164 | ELANTECH_INT_ATTR(debug, 0); |
| 1165 | ELANTECH_INT_ATTR(paritycheck, 0); |
| 1166 | |
| 1167 | static struct attribute *elantech_attrs[] = { |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1168 | &psmouse_attr_reg_07.dattr.attr, |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1169 | &psmouse_attr_reg_10.dattr.attr, |
| 1170 | &psmouse_attr_reg_11.dattr.attr, |
| 1171 | &psmouse_attr_reg_20.dattr.attr, |
| 1172 | &psmouse_attr_reg_21.dattr.attr, |
| 1173 | &psmouse_attr_reg_22.dattr.attr, |
| 1174 | &psmouse_attr_reg_23.dattr.attr, |
| 1175 | &psmouse_attr_reg_24.dattr.attr, |
| 1176 | &psmouse_attr_reg_25.dattr.attr, |
| 1177 | &psmouse_attr_reg_26.dattr.attr, |
| 1178 | &psmouse_attr_debug.dattr.attr, |
| 1179 | &psmouse_attr_paritycheck.dattr.attr, |
| 1180 | NULL |
| 1181 | }; |
| 1182 | |
| 1183 | static struct attribute_group elantech_attr_group = { |
| 1184 | .attrs = elantech_attrs, |
| 1185 | }; |
| 1186 | |
Dmitry Torokhov | a083632 | 2010-05-19 10:11:13 -0700 | [diff] [blame] | 1187 | static bool elantech_is_signature_valid(const unsigned char *param) |
| 1188 | { |
| 1189 | static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10 }; |
| 1190 | int i; |
| 1191 | |
| 1192 | if (param[0] == 0) |
| 1193 | return false; |
| 1194 | |
| 1195 | if (param[1] == 0) |
| 1196 | return true; |
| 1197 | |
| 1198 | for (i = 0; i < ARRAY_SIZE(rates); i++) |
| 1199 | if (param[2] == rates[i]) |
| 1200 | return false; |
| 1201 | |
| 1202 | return true; |
| 1203 | } |
| 1204 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1205 | /* |
| 1206 | * Use magic knock to detect Elantech touchpad |
| 1207 | */ |
Dmitry Torokhov | b7802c5 | 2009-09-09 19:13:20 -0700 | [diff] [blame] | 1208 | int elantech_detect(struct psmouse *psmouse, bool set_properties) |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1209 | { |
| 1210 | struct ps2dev *ps2dev = &psmouse->ps2dev; |
| 1211 | unsigned char param[3]; |
| 1212 | |
| 1213 | ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS); |
| 1214 | |
| 1215 | if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || |
| 1216 | ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || |
| 1217 | ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || |
| 1218 | ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || |
| 1219 | ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1220 | psmouse_dbg(psmouse, "sending Elantech magic knock failed.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1221 | return -1; |
| 1222 | } |
| 1223 | |
| 1224 | /* |
| 1225 | * Report this in case there are Elantech models that use a different |
| 1226 | * set of magic numbers |
| 1227 | */ |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1228 | if (param[0] != 0x3c || param[1] != 0x03 || |
| 1229 | (param[2] != 0xc8 && param[2] != 0x00)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1230 | psmouse_dbg(psmouse, |
| 1231 | "unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n", |
| 1232 | param[0], param[1], param[2]); |
Arjan Opmeer | 9ab7b25 | 2009-02-28 13:52:40 -0800 | [diff] [blame] | 1233 | return -1; |
| 1234 | } |
| 1235 | |
| 1236 | /* |
| 1237 | * Query touchpad's firmware version and see if it reports known |
| 1238 | * value to avoid mis-detection. Logitech mice are known to respond |
| 1239 | * to Elantech magic knock and there might be more. |
| 1240 | */ |
| 1241 | if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1242 | psmouse_dbg(psmouse, "failed to query firmware version.\n"); |
Arjan Opmeer | 9ab7b25 | 2009-02-28 13:52:40 -0800 | [diff] [blame] | 1243 | return -1; |
| 1244 | } |
| 1245 | |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1246 | psmouse_dbg(psmouse, |
| 1247 | "Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n", |
| 1248 | param[0], param[1], param[2]); |
Arjan Opmeer | 9ab7b25 | 2009-02-28 13:52:40 -0800 | [diff] [blame] | 1249 | |
Dmitry Torokhov | a083632 | 2010-05-19 10:11:13 -0700 | [diff] [blame] | 1250 | if (!elantech_is_signature_valid(param)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1251 | psmouse_dbg(psmouse, |
| 1252 | "Probably not a real Elantech touchpad. Aborting.\n"); |
JJ Ding | 4af61e9 | 2011-09-20 22:42:51 -0700 | [diff] [blame] | 1253 | return -1; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1254 | } |
| 1255 | |
| 1256 | if (set_properties) { |
| 1257 | psmouse->vendor = "Elantech"; |
| 1258 | psmouse->name = "Touchpad"; |
| 1259 | } |
| 1260 | |
| 1261 | return 0; |
| 1262 | } |
| 1263 | |
| 1264 | /* |
| 1265 | * Clean up sysfs entries when disconnecting |
| 1266 | */ |
| 1267 | static void elantech_disconnect(struct psmouse *psmouse) |
| 1268 | { |
| 1269 | sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj, |
| 1270 | &elantech_attr_group); |
| 1271 | kfree(psmouse->private); |
| 1272 | psmouse->private = NULL; |
| 1273 | } |
| 1274 | |
| 1275 | /* |
| 1276 | * Put the touchpad back into absolute mode when reconnecting |
| 1277 | */ |
| 1278 | static int elantech_reconnect(struct psmouse *psmouse) |
| 1279 | { |
JJ Ding | a67ada7 | 2012-04-10 00:29:12 -0700 | [diff] [blame] | 1280 | psmouse_reset(psmouse); |
| 1281 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1282 | if (elantech_detect(psmouse, 0)) |
| 1283 | return -1; |
| 1284 | |
| 1285 | if (elantech_set_absolute_mode(psmouse)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1286 | psmouse_err(psmouse, |
| 1287 | "failed to put touchpad back into absolute mode.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1288 | return -1; |
| 1289 | } |
| 1290 | |
| 1291 | return 0; |
| 1292 | } |
| 1293 | |
| 1294 | /* |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1295 | * determine hardware version and set some properties according to it. |
| 1296 | */ |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1297 | static int elantech_set_properties(struct elantech_data *etd) |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1298 | { |
JJ Ding | 3940d61 | 2011-11-08 22:13:14 -0800 | [diff] [blame] | 1299 | /* This represents the version of IC body. */ |
JJ Ding | 1dc6ede | 2011-09-09 10:31:58 -0700 | [diff] [blame] | 1300 | int ver = (etd->fw_version & 0x0f0000) >> 16; |
| 1301 | |
JJ Ding | 3940d61 | 2011-11-08 22:13:14 -0800 | [diff] [blame] | 1302 | /* Early version of Elan touchpads doesn't obey the rule. */ |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1303 | if (etd->fw_version < 0x020030 || etd->fw_version == 0x020600) |
| 1304 | etd->hw_version = 1; |
JJ Ding | 3940d61 | 2011-11-08 22:13:14 -0800 | [diff] [blame] | 1305 | else { |
| 1306 | switch (ver) { |
| 1307 | case 2: |
| 1308 | case 4: |
| 1309 | etd->hw_version = 2; |
| 1310 | break; |
| 1311 | case 5: |
| 1312 | etd->hw_version = 3; |
| 1313 | break; |
| 1314 | case 6: |
Matteo Delfino | 9eebed7 | 2013-07-06 21:52:26 -0700 | [diff] [blame] | 1315 | case 7: |
JJ Ding | 3940d61 | 2011-11-08 22:13:14 -0800 | [diff] [blame] | 1316 | etd->hw_version = 4; |
| 1317 | break; |
| 1318 | default: |
| 1319 | return -1; |
| 1320 | } |
| 1321 | } |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1322 | |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 1323 | /* decide which send_cmd we're gonna use early */ |
| 1324 | etd->send_cmd = etd->hw_version >= 3 ? elantech_send_cmd : |
| 1325 | synaptics_send_cmd; |
| 1326 | |
| 1327 | /* Turn on packet checking by default */ |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1328 | etd->paritycheck = 1; |
| 1329 | |
| 1330 | /* |
| 1331 | * This firmware suffers from misreporting coordinates when |
| 1332 | * a touch action starts causing the mouse cursor or scrolled page |
| 1333 | * to jump. Enable a workaround. |
| 1334 | */ |
| 1335 | etd->jumpy_cursor = |
| 1336 | (etd->fw_version == 0x020022 || etd->fw_version == 0x020600); |
| 1337 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1338 | if (etd->hw_version > 1) { |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1339 | /* For now show extra debug information */ |
| 1340 | etd->debug = 1; |
| 1341 | |
| 1342 | if (etd->fw_version >= 0x020800) |
| 1343 | etd->reports_pressure = true; |
| 1344 | } |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1345 | |
Matteo Delfino | acc0444 | 2013-08-15 00:09:41 -0700 | [diff] [blame] | 1346 | /* |
| 1347 | * The signatures of v3 and v4 packets change depending on the |
| 1348 | * value of this hardware flag. |
| 1349 | */ |
| 1350 | etd->crc_enabled = ((etd->fw_version & 0x4000) == 0x4000); |
| 1351 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1352 | return 0; |
JJ Ding | 3c8bbb9 | 2011-09-09 10:28:19 -0700 | [diff] [blame] | 1353 | } |
| 1354 | |
| 1355 | /* |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1356 | * Initialize the touchpad and create sysfs entries |
| 1357 | */ |
| 1358 | int elantech_init(struct psmouse *psmouse) |
| 1359 | { |
| 1360 | struct elantech_data *etd; |
| 1361 | int i, error; |
| 1362 | unsigned char param[3]; |
| 1363 | |
Arjan Opmeer | 9ab7b25 | 2009-02-28 13:52:40 -0800 | [diff] [blame] | 1364 | psmouse->private = etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1365 | if (!etd) |
Davidlohr Bueso | 6792cbb | 2010-09-29 18:53:35 -0700 | [diff] [blame] | 1366 | return -ENOMEM; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1367 | |
JJ Ding | a67ada7 | 2012-04-10 00:29:12 -0700 | [diff] [blame] | 1368 | psmouse_reset(psmouse); |
| 1369 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1370 | etd->parity[0] = 1; |
| 1371 | for (i = 1; i < 256; i++) |
| 1372 | etd->parity[i] = etd->parity[i & (i - 1)] ^ 1; |
| 1373 | |
| 1374 | /* |
Arjan Opmeer | 9ab7b25 | 2009-02-28 13:52:40 -0800 | [diff] [blame] | 1375 | * Do the version query again so we can store the result |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1376 | */ |
| 1377 | if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1378 | psmouse_err(psmouse, "failed to query firmware version.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1379 | goto init_fail; |
| 1380 | } |
Dmitry Torokhov | 504e8be | 2010-05-13 00:41:15 -0700 | [diff] [blame] | 1381 | etd->fw_version = (param[0] << 16) | (param[1] << 8) | param[2]; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1382 | |
| 1383 | if (elantech_set_properties(etd)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1384 | psmouse_err(psmouse, "unknown hardware version, aborting...\n"); |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1385 | goto init_fail; |
| 1386 | } |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1387 | psmouse_info(psmouse, |
| 1388 | "assuming hardware version %d (with firmware version 0x%02x%02x%02x)\n", |
| 1389 | etd->hw_version, param[0], param[1], param[2]); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1390 | |
JJ Ding | b56b92a | 2011-11-20 22:21:45 -0800 | [diff] [blame] | 1391 | if (etd->send_cmd(psmouse, ETP_CAPABILITIES_QUERY, |
JJ Ding | 230282a | 2011-09-09 10:26:16 -0700 | [diff] [blame] | 1392 | etd->capabilities)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1393 | psmouse_err(psmouse, "failed to query capabilities.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1394 | goto init_fail; |
| 1395 | } |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1396 | psmouse_info(psmouse, |
| 1397 | "Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n", |
| 1398 | etd->capabilities[0], etd->capabilities[1], |
| 1399 | etd->capabilities[2]); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1400 | |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1401 | if (elantech_set_absolute_mode(psmouse)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1402 | psmouse_err(psmouse, |
| 1403 | "failed to put touchpad into absolute mode.\n"); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1404 | goto init_fail; |
| 1405 | } |
| 1406 | |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1407 | if (elantech_set_input_params(psmouse)) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1408 | psmouse_err(psmouse, "failed to query touchpad range.\n"); |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1409 | goto init_fail; |
| 1410 | } |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1411 | |
| 1412 | error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj, |
| 1413 | &elantech_attr_group); |
| 1414 | if (error) { |
Dmitry Torokhov | b5d2170 | 2011-10-10 18:27:03 -0700 | [diff] [blame] | 1415 | psmouse_err(psmouse, |
| 1416 | "failed to create sysfs attributes, error: %d.\n", |
| 1417 | error); |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1418 | goto init_fail; |
| 1419 | } |
| 1420 | |
| 1421 | psmouse->protocol_handler = elantech_process_byte; |
| 1422 | psmouse->disconnect = elantech_disconnect; |
| 1423 | psmouse->reconnect = elantech_reconnect; |
JJ Ding | 28f4961 | 2011-09-09 10:30:31 -0700 | [diff] [blame] | 1424 | psmouse->pktsize = etd->hw_version > 1 ? 6 : 4; |
Arjan Opmeer | 2a0bd75 | 2008-10-16 22:10:19 -0400 | [diff] [blame] | 1425 | |
| 1426 | return 0; |
| 1427 | |
| 1428 | init_fail: |
| 1429 | kfree(etd); |
| 1430 | return -1; |
| 1431 | } |