1 /* 2 * ALPS touchpad PS/2 mouse driver 3 * 4 * Copyright (c) 2003 Neil Brown <neilb@cse.unsw.edu.au> 5 * Copyright (c) 2003-2005 Peter Osterlund <petero2@telia.com> 6 * Copyright (c) 2004 Dmitry Torokhov <dtor@mail.ru> 7 * Copyright (c) 2005 Vojtech Pavlik <vojtech@suse.cz> 8 * 9 * ALPS detection, tap switching and status querying info is taken from 10 * tpconfig utility (by C. Scott Ananian and Bruce Kall). 11 * 12 * This program is free software; you can redistribute it and/or modify it 13 * under the terms of the GNU General Public License version 2 as published by 14 * the Free Software Foundation. 15 */ 16 17 #include <linux/input.h> 18 #include <linux/serio.h> 19 #include <linux/libps2.h> 20 21 #include "psmouse.h" 22 #include "alps.h" 23 24 #undef DEBUG 25 #ifdef DEBUG 26 #define dbg(format, arg...) printk(KERN_INFO "alps.c: " format "\n", ## arg) 27 #else 28 #define dbg(format, arg...) do {} while (0) 29 #endif 30 31 #define ALPS_DUALPOINT 0x01 32 #define ALPS_WHEEL 0x02 33 #define ALPS_FW_BK_1 0x04 34 #define ALPS_4BTN 0x08 35 #define ALPS_OLDPROTO 0x10 36 #define ALPS_PASS 0x20 37 #define ALPS_FW_BK_2 0x40 38 39 static const struct alps_model_info alps_model_data[] = { 40 { { 0x32, 0x02, 0x14 }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* Toshiba Salellite Pro M10 */ 41 { { 0x33, 0x02, 0x0a }, 0x88, 0xf8, ALPS_OLDPROTO }, /* UMAX-530T */ 42 { { 0x53, 0x02, 0x0a }, 0xf8, 0xf8, 0 }, 43 { { 0x53, 0x02, 0x14 }, 0xf8, 0xf8, 0 }, 44 { { 0x60, 0x03, 0xc8 }, 0xf8, 0xf8, 0 }, /* HP ze1115 */ 45 { { 0x63, 0x02, 0x0a }, 0xf8, 0xf8, 0 }, 46 { { 0x63, 0x02, 0x14 }, 0xf8, 0xf8, 0 }, 47 { { 0x63, 0x02, 0x28 }, 0xf8, 0xf8, ALPS_FW_BK_2 }, /* Fujitsu Siemens S6010 */ 48 { { 0x63, 0x02, 0x3c }, 0x8f, 0x8f, ALPS_WHEEL }, /* Toshiba Satellite S2400-103 */ 49 { { 0x63, 0x02, 0x50 }, 0xef, 0xef, ALPS_FW_BK_1 }, /* NEC Versa L320 */ 50 { { 0x63, 0x02, 0x64 }, 0xf8, 0xf8, 0 }, 51 { { 0x63, 0x03, 0xc8 }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* Dell Latitude D800 */ 52 { { 0x73, 0x00, 0x0a }, 0xf8, 0xf8, ALPS_DUALPOINT }, /* ThinkPad R61 8918-5QG */ 53 { { 0x73, 0x02, 0x0a }, 0xf8, 0xf8, 0 }, 54 { { 0x73, 0x02, 0x14 }, 0xf8, 0xf8, ALPS_FW_BK_2 }, /* Ahtec Laptop */ 55 { { 0x20, 0x02, 0x0e }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* XXX */ 56 { { 0x22, 0x02, 0x0a }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, 57 { { 0x22, 0x02, 0x14 }, 0xff, 0xff, ALPS_PASS | ALPS_DUALPOINT }, /* Dell Latitude D600 */ 58 { { 0x62, 0x02, 0x14 }, 0xcf, 0xcf, ALPS_PASS | ALPS_DUALPOINT }, /* Dell Latitude E6500 */ 59 { { 0x73, 0x02, 0x50 }, 0xcf, 0xcf, ALPS_FW_BK_1 }, /* Dell Vostro 1400 */ 60 }; 61 62 /* 63 * XXX - this entry is suspicious. First byte has zero lower nibble, 64 * which is what a normal mouse would report. Also, the value 0x0e 65 * isn't valid per PS/2 spec. 66 */ 67 68 /* 69 * ALPS abolute Mode - new format 70 * 71 * byte 0: 1 ? ? ? 1 ? ? ? 72 * byte 1: 0 x6 x5 x4 x3 x2 x1 x0 73 * byte 2: 0 x10 x9 x8 x7 ? fin ges 74 * byte 3: 0 y9 y8 y7 1 M R L 75 * byte 4: 0 y6 y5 y4 y3 y2 y1 y0 76 * byte 5: 0 z6 z5 z4 z3 z2 z1 z0 77 * 78 * ?'s can have different meanings on different models, 79 * such as wheel rotation, extra buttons, stick buttons 80 * on a dualpoint, etc. 81 */ 82 83 static void alps_process_packet(struct psmouse *psmouse) 84 { 85 struct alps_data *priv = psmouse->private; 86 unsigned char *packet = psmouse->packet; 87 struct input_dev *dev = psmouse->dev; 88 struct input_dev *dev2 = priv->dev2; 89 int x, y, z, ges, fin, left, right, middle; 90 int back = 0, forward = 0; 91 92 if ((packet[0] & 0xc8) == 0x08) { /* 3-byte PS/2 packet */ 93 input_report_key(dev2, BTN_LEFT, packet[0] & 1); 94 input_report_key(dev2, BTN_RIGHT, packet[0] & 2); 95 input_report_key(dev2, BTN_MIDDLE, packet[0] & 4); 96 input_report_rel(dev2, REL_X, 97 packet[1] ? packet[1] - ((packet[0] << 4) & 0x100) : 0); 98 input_report_rel(dev2, REL_Y, 99 packet[2] ? ((packet[0] << 3) & 0x100) - packet[2] : 0); 100 input_sync(dev2); 101 return; 102 } 103 104 if (priv->i->flags & ALPS_OLDPROTO) { 105 left = packet[2] & 0x10; 106 right = packet[2] & 0x08; 107 middle = 0; 108 x = packet[1] | ((packet[0] & 0x07) << 7); 109 y = packet[4] | ((packet[3] & 0x07) << 7); 110 z = packet[5]; 111 } else { 112 left = packet[3] & 1; 113 right = packet[3] & 2; 114 middle = packet[3] & 4; 115 x = packet[1] | ((packet[2] & 0x78) << (7 - 3)); 116 y = packet[4] | ((packet[3] & 0x70) << (7 - 4)); 117 z = packet[5]; 118 } 119 120 if (priv->i->flags & ALPS_FW_BK_1) { 121 back = packet[0] & 0x10; 122 forward = packet[2] & 4; 123 } 124 125 if (priv->i->flags & ALPS_FW_BK_2) { 126 back = packet[3] & 4; 127 forward = packet[2] & 4; 128 if ((middle = forward && back)) 129 forward = back = 0; 130 } 131 132 ges = packet[2] & 1; 133 fin = packet[2] & 2; 134 135 if ((priv->i->flags & ALPS_DUALPOINT) && z == 127) { 136 input_report_rel(dev2, REL_X, (x > 383 ? (x - 768) : x)); 137 input_report_rel(dev2, REL_Y, -(y > 255 ? (y - 512) : y)); 138 139 input_report_key(dev2, BTN_LEFT, left); 140 input_report_key(dev2, BTN_RIGHT, right); 141 input_report_key(dev2, BTN_MIDDLE, middle); 142 143 input_sync(dev); 144 input_sync(dev2); 145 return; 146 } 147 148 input_report_key(dev, BTN_LEFT, left); 149 input_report_key(dev, BTN_RIGHT, right); 150 input_report_key(dev, BTN_MIDDLE, middle); 151 152 /* Convert hardware tap to a reasonable Z value */ 153 if (ges && !fin) z = 40; 154 155 /* 156 * A "tap and drag" operation is reported by the hardware as a transition 157 * from (!fin && ges) to (fin && ges). This should be translated to the 158 * sequence Z>0, Z==0, Z>0, so the Z==0 event has to be generated manually. 159 */ 160 if (ges && fin && !priv->prev_fin) { 161 input_report_abs(dev, ABS_X, x); 162 input_report_abs(dev, ABS_Y, y); 163 input_report_abs(dev, ABS_PRESSURE, 0); 164 input_report_key(dev, BTN_TOOL_FINGER, 0); 165 input_sync(dev); 166 } 167 priv->prev_fin = fin; 168 169 if (z > 30) input_report_key(dev, BTN_TOUCH, 1); 170 if (z < 25) input_report_key(dev, BTN_TOUCH, 0); 171 172 if (z > 0) { 173 input_report_abs(dev, ABS_X, x); 174 input_report_abs(dev, ABS_Y, y); 175 } 176 177 input_report_abs(dev, ABS_PRESSURE, z); 178 input_report_key(dev, BTN_TOOL_FINGER, z > 0); 179 180 if (priv->i->flags & ALPS_WHEEL) 181 input_report_rel(dev, REL_WHEEL, ((packet[2] << 1) & 0x08) - ((packet[0] >> 4) & 0x07)); 182 183 if (priv->i->flags & (ALPS_FW_BK_1 | ALPS_FW_BK_2)) { 184 input_report_key(dev, BTN_FORWARD, forward); 185 input_report_key(dev, BTN_BACK, back); 186 } 187 188 input_sync(dev); 189 } 190 191 static psmouse_ret_t alps_process_byte(struct psmouse *psmouse) 192 { 193 struct alps_data *priv = psmouse->private; 194 195 if ((psmouse->packet[0] & 0xc8) == 0x08) { /* PS/2 packet */ 196 if (psmouse->pktcnt == 3) { 197 alps_process_packet(psmouse); 198 return PSMOUSE_FULL_PACKET; 199 } 200 return PSMOUSE_GOOD_DATA; 201 } 202 203 if ((psmouse->packet[0] & priv->i->mask0) != priv->i->byte0) 204 return PSMOUSE_BAD_DATA; 205 206 /* Bytes 2 - 6 should have 0 in the highest bit */ 207 if (psmouse->pktcnt >= 2 && psmouse->pktcnt <= 6 && 208 (psmouse->packet[psmouse->pktcnt - 1] & 0x80)) 209 return PSMOUSE_BAD_DATA; 210 211 if (psmouse->pktcnt == 6) { 212 alps_process_packet(psmouse); 213 return PSMOUSE_FULL_PACKET; 214 } 215 216 return PSMOUSE_GOOD_DATA; 217 } 218 219 static const struct alps_model_info *alps_get_model(struct psmouse *psmouse, int *version) 220 { 221 struct ps2dev *ps2dev = &psmouse->ps2dev; 222 static const unsigned char rates[] = { 0, 10, 20, 40, 60, 80, 100, 200 }; 223 unsigned char param[4]; 224 int i; 225 226 /* 227 * First try "E6 report". 228 * ALPS should return 0,0,10 or 0,0,100 229 */ 230 param[0] = 0; 231 if (ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES) || 232 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || 233 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || 234 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) 235 return NULL; 236 237 param[0] = param[1] = param[2] = 0xff; 238 if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) 239 return NULL; 240 241 dbg("E6 report: %2.2x %2.2x %2.2x", param[0], param[1], param[2]); 242 243 if (param[0] != 0 || param[1] != 0 || (param[2] != 10 && param[2] != 100)) 244 return NULL; 245 246 /* 247 * Now try "E7 report". Allowed responses are in 248 * alps_model_data[].signature 249 */ 250 param[0] = 0; 251 if (ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES) || 252 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) || 253 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) || 254 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21)) 255 return NULL; 256 257 param[0] = param[1] = param[2] = 0xff; 258 if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) 259 return NULL; 260 261 dbg("E7 report: %2.2x %2.2x %2.2x", param[0], param[1], param[2]); 262 263 if (version) { 264 for (i = 0; i < ARRAY_SIZE(rates) && param[2] != rates[i]; i++) 265 /* empty */; 266 *version = (param[0] << 8) | (param[1] << 4) | i; 267 } 268 269 for (i = 0; i < ARRAY_SIZE(alps_model_data); i++) 270 if (!memcmp(param, alps_model_data[i].signature, 271 sizeof(alps_model_data[i].signature))) 272 return alps_model_data + i; 273 274 return NULL; 275 } 276 277 /* 278 * For DualPoint devices select the device that should respond to 279 * subsequent commands. It looks like glidepad is behind stickpointer, 280 * I'd thought it would be other way around... 281 */ 282 static int alps_passthrough_mode(struct psmouse *psmouse, bool enable) 283 { 284 struct ps2dev *ps2dev = &psmouse->ps2dev; 285 int cmd = enable ? PSMOUSE_CMD_SETSCALE21 : PSMOUSE_CMD_SETSCALE11; 286 287 if (ps2_command(ps2dev, NULL, cmd) || 288 ps2_command(ps2dev, NULL, cmd) || 289 ps2_command(ps2dev, NULL, cmd) || 290 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE)) 291 return -1; 292 293 /* we may get 3 more bytes, just ignore them */ 294 ps2_drain(ps2dev, 3, 100); 295 296 return 0; 297 } 298 299 static int alps_absolute_mode(struct psmouse *psmouse) 300 { 301 struct ps2dev *ps2dev = &psmouse->ps2dev; 302 303 /* Try ALPS magic knock - 4 disable before enable */ 304 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 305 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 306 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 307 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 308 ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE)) 309 return -1; 310 311 /* 312 * Switch mouse to poll (remote) mode so motion data will not 313 * get in our way 314 */ 315 return ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETPOLL); 316 } 317 318 static int alps_get_status(struct psmouse *psmouse, char *param) 319 { 320 struct ps2dev *ps2dev = &psmouse->ps2dev; 321 322 /* Get status: 0xF5 0xF5 0xF5 0xE9 */ 323 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 324 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 325 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 326 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) 327 return -1; 328 329 dbg("Status: %2.2x %2.2x %2.2x", param[0], param[1], param[2]); 330 331 return 0; 332 } 333 334 /* 335 * Turn touchpad tapping on or off. The sequences are: 336 * 0xE9 0xF5 0xF5 0xF3 0x0A to enable, 337 * 0xE9 0xF5 0xF5 0xE8 0x00 to disable. 338 * My guess that 0xE9 (GetInfo) is here as a sync point. 339 * For models that also have stickpointer (DualPoints) its tapping 340 * is controlled separately (0xE6 0xE6 0xE6 0xF3 0x14|0x0A) but 341 * we don't fiddle with it. 342 */ 343 static int alps_tap_mode(struct psmouse *psmouse, int enable) 344 { 345 struct ps2dev *ps2dev = &psmouse->ps2dev; 346 int cmd = enable ? PSMOUSE_CMD_SETRATE : PSMOUSE_CMD_SETRES; 347 unsigned char tap_arg = enable ? 0x0A : 0x00; 348 unsigned char param[4]; 349 350 if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) || 351 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 352 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 353 ps2_command(ps2dev, &tap_arg, cmd)) 354 return -1; 355 356 if (alps_get_status(psmouse, param)) 357 return -1; 358 359 return 0; 360 } 361 362 /* 363 * alps_poll() - poll the touchpad for current motion packet. 364 * Used in resync. 365 */ 366 static int alps_poll(struct psmouse *psmouse) 367 { 368 struct alps_data *priv = psmouse->private; 369 unsigned char buf[6]; 370 bool poll_failed; 371 372 if (priv->i->flags & ALPS_PASS) 373 alps_passthrough_mode(psmouse, true); 374 375 poll_failed = ps2_command(&psmouse->ps2dev, buf, 376 PSMOUSE_CMD_POLL | (psmouse->pktsize << 8)) < 0; 377 378 if (priv->i->flags & ALPS_PASS) 379 alps_passthrough_mode(psmouse, false); 380 381 if (poll_failed || (buf[0] & priv->i->mask0) != priv->i->byte0) 382 return -1; 383 384 if ((psmouse->badbyte & 0xc8) == 0x08) { 385 /* 386 * Poll the track stick ... 387 */ 388 if (ps2_command(&psmouse->ps2dev, buf, PSMOUSE_CMD_POLL | (3 << 8))) 389 return -1; 390 } 391 392 memcpy(psmouse->packet, buf, sizeof(buf)); 393 return 0; 394 } 395 396 static int alps_hw_init(struct psmouse *psmouse, int *version) 397 { 398 struct alps_data *priv = psmouse->private; 399 400 priv->i = alps_get_model(psmouse, version); 401 if (!priv->i) 402 return -1; 403 404 if ((priv->i->flags & ALPS_PASS) && 405 alps_passthrough_mode(psmouse, true)) { 406 return -1; 407 } 408 409 if (alps_tap_mode(psmouse, true)) { 410 printk(KERN_WARNING "alps.c: Failed to enable hardware tapping\n"); 411 return -1; 412 } 413 414 if (alps_absolute_mode(psmouse)) { 415 printk(KERN_ERR "alps.c: Failed to enable absolute mode\n"); 416 return -1; 417 } 418 419 if ((priv->i->flags & ALPS_PASS) && 420 alps_passthrough_mode(psmouse, false)) { 421 return -1; 422 } 423 424 /* ALPS needs stream mode, otherwise it won't report any data */ 425 if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSTREAM)) { 426 printk(KERN_ERR "alps.c: Failed to enable stream mode\n"); 427 return -1; 428 } 429 430 return 0; 431 } 432 433 static int alps_reconnect(struct psmouse *psmouse) 434 { 435 psmouse_reset(psmouse); 436 437 if (alps_hw_init(psmouse, NULL)) 438 return -1; 439 440 return 0; 441 } 442 443 static void alps_disconnect(struct psmouse *psmouse) 444 { 445 struct alps_data *priv = psmouse->private; 446 447 psmouse_reset(psmouse); 448 input_unregister_device(priv->dev2); 449 kfree(priv); 450 } 451 452 int alps_init(struct psmouse *psmouse) 453 { 454 struct alps_data *priv; 455 struct input_dev *dev1 = psmouse->dev, *dev2; 456 int version; 457 458 priv = kzalloc(sizeof(struct alps_data), GFP_KERNEL); 459 dev2 = input_allocate_device(); 460 if (!priv || !dev2) 461 goto init_fail; 462 463 priv->dev2 = dev2; 464 psmouse->private = priv; 465 466 if (alps_hw_init(psmouse, &version)) 467 goto init_fail; 468 469 dev1->evbit[BIT_WORD(EV_KEY)] |= BIT_MASK(EV_KEY); 470 dev1->keybit[BIT_WORD(BTN_TOUCH)] |= BIT_MASK(BTN_TOUCH); 471 dev1->keybit[BIT_WORD(BTN_TOOL_FINGER)] |= BIT_MASK(BTN_TOOL_FINGER); 472 dev1->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_LEFT) | 473 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT); 474 475 dev1->evbit[BIT_WORD(EV_ABS)] |= BIT_MASK(EV_ABS); 476 input_set_abs_params(dev1, ABS_X, 0, 1023, 0, 0); 477 input_set_abs_params(dev1, ABS_Y, 0, 767, 0, 0); 478 input_set_abs_params(dev1, ABS_PRESSURE, 0, 127, 0, 0); 479 480 if (priv->i->flags & ALPS_WHEEL) { 481 dev1->evbit[BIT_WORD(EV_REL)] |= BIT_MASK(EV_REL); 482 dev1->relbit[BIT_WORD(REL_WHEEL)] |= BIT_MASK(REL_WHEEL); 483 } 484 485 if (priv->i->flags & (ALPS_FW_BK_1 | ALPS_FW_BK_2)) { 486 dev1->keybit[BIT_WORD(BTN_FORWARD)] |= BIT_MASK(BTN_FORWARD); 487 dev1->keybit[BIT_WORD(BTN_BACK)] |= BIT_MASK(BTN_BACK); 488 } 489 490 snprintf(priv->phys, sizeof(priv->phys), "%s/input1", psmouse->ps2dev.serio->phys); 491 dev2->phys = priv->phys; 492 dev2->name = (priv->i->flags & ALPS_DUALPOINT) ? "DualPoint Stick" : "PS/2 Mouse"; 493 dev2->id.bustype = BUS_I8042; 494 dev2->id.vendor = 0x0002; 495 dev2->id.product = PSMOUSE_ALPS; 496 dev2->id.version = 0x0000; 497 dev2->dev.parent = &psmouse->ps2dev.serio->dev; 498 499 dev2->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL); 500 dev2->relbit[BIT_WORD(REL_X)] |= BIT_MASK(REL_X) | BIT_MASK(REL_Y); 501 dev2->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_LEFT) | 502 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT); 503 504 if (input_register_device(priv->dev2)) 505 goto init_fail; 506 507 psmouse->protocol_handler = alps_process_byte; 508 psmouse->poll = alps_poll; 509 psmouse->disconnect = alps_disconnect; 510 psmouse->reconnect = alps_reconnect; 511 psmouse->pktsize = 6; 512 513 /* We are having trouble resyncing ALPS touchpads so disable it for now */ 514 psmouse->resync_time = 0; 515 516 return 0; 517 518 init_fail: 519 psmouse_reset(psmouse); 520 input_free_device(dev2); 521 kfree(priv); 522 psmouse->private = NULL; 523 return -1; 524 } 525 526 int alps_detect(struct psmouse *psmouse, bool set_properties) 527 { 528 int version; 529 const struct alps_model_info *model; 530 531 model = alps_get_model(psmouse, &version); 532 if (!model) 533 return -1; 534 535 if (set_properties) { 536 psmouse->vendor = "ALPS"; 537 psmouse->name = model->flags & ALPS_DUALPOINT ? 538 "DualPoint TouchPad" : "GlidePoint"; 539 psmouse->model = version; 540 } 541 return 0; 542 } 543 544