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 }, /* 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 input_report_key(dev, BTN_LEFT, left); 136 input_report_key(dev, BTN_RIGHT, right); 137 input_report_key(dev, BTN_MIDDLE, middle); 138 139 if ((priv->i->flags & ALPS_DUALPOINT) && z == 127) { 140 input_report_rel(dev2, REL_X, (x > 383 ? (x - 768) : x)); 141 input_report_rel(dev2, REL_Y, -(y > 255 ? (y - 512) : y)); 142 input_sync(dev); 143 input_sync(dev2); 144 return; 145 } 146 147 /* Convert hardware tap to a reasonable Z value */ 148 if (ges && !fin) z = 40; 149 150 /* 151 * A "tap and drag" operation is reported by the hardware as a transition 152 * from (!fin && ges) to (fin && ges). This should be translated to the 153 * sequence Z>0, Z==0, Z>0, so the Z==0 event has to be generated manually. 154 */ 155 if (ges && fin && !priv->prev_fin) { 156 input_report_abs(dev, ABS_X, x); 157 input_report_abs(dev, ABS_Y, y); 158 input_report_abs(dev, ABS_PRESSURE, 0); 159 input_report_key(dev, BTN_TOOL_FINGER, 0); 160 input_sync(dev); 161 } 162 priv->prev_fin = fin; 163 164 if (z > 30) input_report_key(dev, BTN_TOUCH, 1); 165 if (z < 25) input_report_key(dev, BTN_TOUCH, 0); 166 167 if (z > 0) { 168 input_report_abs(dev, ABS_X, x); 169 input_report_abs(dev, ABS_Y, y); 170 } 171 172 input_report_abs(dev, ABS_PRESSURE, z); 173 input_report_key(dev, BTN_TOOL_FINGER, z > 0); 174 175 if (priv->i->flags & ALPS_WHEEL) 176 input_report_rel(dev, REL_WHEEL, ((packet[2] << 1) & 0x08) - ((packet[0] >> 4) & 0x07)); 177 178 if (priv->i->flags & (ALPS_FW_BK_1 | ALPS_FW_BK_2)) { 179 input_report_key(dev, BTN_FORWARD, forward); 180 input_report_key(dev, BTN_BACK, back); 181 } 182 183 input_sync(dev); 184 } 185 186 static psmouse_ret_t alps_process_byte(struct psmouse *psmouse) 187 { 188 struct alps_data *priv = psmouse->private; 189 190 if ((psmouse->packet[0] & 0xc8) == 0x08) { /* PS/2 packet */ 191 if (psmouse->pktcnt == 3) { 192 alps_process_packet(psmouse); 193 return PSMOUSE_FULL_PACKET; 194 } 195 return PSMOUSE_GOOD_DATA; 196 } 197 198 if ((psmouse->packet[0] & priv->i->mask0) != priv->i->byte0) 199 return PSMOUSE_BAD_DATA; 200 201 /* Bytes 2 - 6 should have 0 in the highest bit */ 202 if (psmouse->pktcnt >= 2 && psmouse->pktcnt <= 6 && 203 (psmouse->packet[psmouse->pktcnt - 1] & 0x80)) 204 return PSMOUSE_BAD_DATA; 205 206 if (psmouse->pktcnt == 6) { 207 alps_process_packet(psmouse); 208 return PSMOUSE_FULL_PACKET; 209 } 210 211 return PSMOUSE_GOOD_DATA; 212 } 213 214 static const struct alps_model_info *alps_get_model(struct psmouse *psmouse, int *version) 215 { 216 struct ps2dev *ps2dev = &psmouse->ps2dev; 217 static const unsigned char rates[] = { 0, 10, 20, 40, 60, 80, 100, 200 }; 218 unsigned char param[4]; 219 int i; 220 221 /* 222 * First try "E6 report". 223 * ALPS should return 0,0,10 or 0,0,100 224 */ 225 param[0] = 0; 226 if (ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES) || 227 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || 228 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || 229 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) 230 return NULL; 231 232 param[0] = param[1] = param[2] = 0xff; 233 if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) 234 return NULL; 235 236 dbg("E6 report: %2.2x %2.2x %2.2x", param[0], param[1], param[2]); 237 238 if (param[0] != 0 || param[1] != 0 || (param[2] != 10 && param[2] != 100)) 239 return NULL; 240 241 /* 242 * Now try "E7 report". Allowed responses are in 243 * alps_model_data[].signature 244 */ 245 param[0] = 0; 246 if (ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES) || 247 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) || 248 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) || 249 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21)) 250 return NULL; 251 252 param[0] = param[1] = param[2] = 0xff; 253 if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) 254 return NULL; 255 256 dbg("E7 report: %2.2x %2.2x %2.2x", param[0], param[1], param[2]); 257 258 if (version) { 259 for (i = 0; i < ARRAY_SIZE(rates) && param[2] != rates[i]; i++) 260 /* empty */; 261 *version = (param[0] << 8) | (param[1] << 4) | i; 262 } 263 264 for (i = 0; i < ARRAY_SIZE(alps_model_data); i++) 265 if (!memcmp(param, alps_model_data[i].signature, 266 sizeof(alps_model_data[i].signature))) 267 return alps_model_data + i; 268 269 return NULL; 270 } 271 272 /* 273 * For DualPoint devices select the device that should respond to 274 * subsequent commands. It looks like glidepad is behind stickpointer, 275 * I'd thought it would be other way around... 276 */ 277 static int alps_passthrough_mode(struct psmouse *psmouse, int enable) 278 { 279 struct ps2dev *ps2dev = &psmouse->ps2dev; 280 int cmd = enable ? PSMOUSE_CMD_SETSCALE21 : PSMOUSE_CMD_SETSCALE11; 281 282 if (ps2_command(ps2dev, NULL, cmd) || 283 ps2_command(ps2dev, NULL, cmd) || 284 ps2_command(ps2dev, NULL, cmd) || 285 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE)) 286 return -1; 287 288 /* we may get 3 more bytes, just ignore them */ 289 ps2_drain(ps2dev, 3, 100); 290 291 return 0; 292 } 293 294 static int alps_absolute_mode(struct psmouse *psmouse) 295 { 296 struct ps2dev *ps2dev = &psmouse->ps2dev; 297 298 /* Try ALPS magic knock - 4 disable before enable */ 299 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 300 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 301 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 302 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 303 ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE)) 304 return -1; 305 306 /* 307 * Switch mouse to poll (remote) mode so motion data will not 308 * get in our way 309 */ 310 return ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETPOLL); 311 } 312 313 static int alps_get_status(struct psmouse *psmouse, char *param) 314 { 315 struct ps2dev *ps2dev = &psmouse->ps2dev; 316 317 /* Get status: 0xF5 0xF5 0xF5 0xE9 */ 318 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 319 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 320 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 321 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) 322 return -1; 323 324 dbg("Status: %2.2x %2.2x %2.2x", param[0], param[1], param[2]); 325 326 return 0; 327 } 328 329 /* 330 * Turn touchpad tapping on or off. The sequences are: 331 * 0xE9 0xF5 0xF5 0xF3 0x0A to enable, 332 * 0xE9 0xF5 0xF5 0xE8 0x00 to disable. 333 * My guess that 0xE9 (GetInfo) is here as a sync point. 334 * For models that also have stickpointer (DualPoints) its tapping 335 * is controlled separately (0xE6 0xE6 0xE6 0xF3 0x14|0x0A) but 336 * we don't fiddle with it. 337 */ 338 static int alps_tap_mode(struct psmouse *psmouse, int enable) 339 { 340 struct ps2dev *ps2dev = &psmouse->ps2dev; 341 int cmd = enable ? PSMOUSE_CMD_SETRATE : PSMOUSE_CMD_SETRES; 342 unsigned char tap_arg = enable ? 0x0A : 0x00; 343 unsigned char param[4]; 344 345 if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) || 346 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 347 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || 348 ps2_command(ps2dev, &tap_arg, cmd)) 349 return -1; 350 351 if (alps_get_status(psmouse, param)) 352 return -1; 353 354 return 0; 355 } 356 357 /* 358 * alps_poll() - poll the touchpad for current motion packet. 359 * Used in resync. 360 */ 361 static int alps_poll(struct psmouse *psmouse) 362 { 363 struct alps_data *priv = psmouse->private; 364 unsigned char buf[6]; 365 int poll_failed; 366 367 if (priv->i->flags & ALPS_PASS) 368 alps_passthrough_mode(psmouse, 1); 369 370 poll_failed = ps2_command(&psmouse->ps2dev, buf, 371 PSMOUSE_CMD_POLL | (psmouse->pktsize << 8)) < 0; 372 373 if (priv->i->flags & ALPS_PASS) 374 alps_passthrough_mode(psmouse, 0); 375 376 if (poll_failed || (buf[0] & priv->i->mask0) != priv->i->byte0) 377 return -1; 378 379 if ((psmouse->badbyte & 0xc8) == 0x08) { 380 /* 381 * Poll the track stick ... 382 */ 383 if (ps2_command(&psmouse->ps2dev, buf, PSMOUSE_CMD_POLL | (3 << 8))) 384 return -1; 385 } 386 387 memcpy(psmouse->packet, buf, sizeof(buf)); 388 return 0; 389 } 390 391 static int alps_hw_init(struct psmouse *psmouse, int *version) 392 { 393 struct alps_data *priv = psmouse->private; 394 395 priv->i = alps_get_model(psmouse, version); 396 if (!priv->i) 397 return -1; 398 399 if ((priv->i->flags & ALPS_PASS) && alps_passthrough_mode(psmouse, 1)) 400 return -1; 401 402 if (alps_tap_mode(psmouse, 1)) { 403 printk(KERN_WARNING "alps.c: Failed to enable hardware tapping\n"); 404 return -1; 405 } 406 407 if (alps_absolute_mode(psmouse)) { 408 printk(KERN_ERR "alps.c: Failed to enable absolute mode\n"); 409 return -1; 410 } 411 412 if ((priv->i->flags & ALPS_PASS) && alps_passthrough_mode(psmouse, 0)) 413 return -1; 414 415 /* ALPS needs stream mode, otherwise it won't report any data */ 416 if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSTREAM)) { 417 printk(KERN_ERR "alps.c: Failed to enable stream mode\n"); 418 return -1; 419 } 420 421 return 0; 422 } 423 424 static int alps_reconnect(struct psmouse *psmouse) 425 { 426 psmouse_reset(psmouse); 427 428 if (alps_hw_init(psmouse, NULL)) 429 return -1; 430 431 return 0; 432 } 433 434 static void alps_disconnect(struct psmouse *psmouse) 435 { 436 struct alps_data *priv = psmouse->private; 437 438 psmouse_reset(psmouse); 439 input_unregister_device(priv->dev2); 440 kfree(priv); 441 } 442 443 int alps_init(struct psmouse *psmouse) 444 { 445 struct alps_data *priv; 446 struct input_dev *dev1 = psmouse->dev, *dev2; 447 int version; 448 449 priv = kzalloc(sizeof(struct alps_data), GFP_KERNEL); 450 dev2 = input_allocate_device(); 451 if (!priv || !dev2) 452 goto init_fail; 453 454 priv->dev2 = dev2; 455 psmouse->private = priv; 456 457 if (alps_hw_init(psmouse, &version)) 458 goto init_fail; 459 460 dev1->evbit[BIT_WORD(EV_KEY)] |= BIT_MASK(EV_KEY); 461 dev1->keybit[BIT_WORD(BTN_TOUCH)] |= BIT_MASK(BTN_TOUCH); 462 dev1->keybit[BIT_WORD(BTN_TOOL_FINGER)] |= BIT_MASK(BTN_TOOL_FINGER); 463 dev1->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_LEFT) | 464 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT); 465 466 dev1->evbit[BIT_WORD(EV_ABS)] |= BIT_MASK(EV_ABS); 467 input_set_abs_params(dev1, ABS_X, 0, 1023, 0, 0); 468 input_set_abs_params(dev1, ABS_Y, 0, 767, 0, 0); 469 input_set_abs_params(dev1, ABS_PRESSURE, 0, 127, 0, 0); 470 471 if (priv->i->flags & ALPS_WHEEL) { 472 dev1->evbit[BIT_WORD(EV_REL)] |= BIT_MASK(EV_REL); 473 dev1->relbit[BIT_WORD(REL_WHEEL)] |= BIT_MASK(REL_WHEEL); 474 } 475 476 if (priv->i->flags & (ALPS_FW_BK_1 | ALPS_FW_BK_2)) { 477 dev1->keybit[BIT_WORD(BTN_FORWARD)] |= BIT_MASK(BTN_FORWARD); 478 dev1->keybit[BIT_WORD(BTN_BACK)] |= BIT_MASK(BTN_BACK); 479 } 480 481 snprintf(priv->phys, sizeof(priv->phys), "%s/input1", psmouse->ps2dev.serio->phys); 482 dev2->phys = priv->phys; 483 dev2->name = (priv->i->flags & ALPS_DUALPOINT) ? "DualPoint Stick" : "PS/2 Mouse"; 484 dev2->id.bustype = BUS_I8042; 485 dev2->id.vendor = 0x0002; 486 dev2->id.product = PSMOUSE_ALPS; 487 dev2->id.version = 0x0000; 488 dev2->dev.parent = &psmouse->ps2dev.serio->dev; 489 490 dev2->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL); 491 dev2->relbit[BIT_WORD(REL_X)] |= BIT_MASK(REL_X) | BIT_MASK(REL_Y); 492 dev2->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_LEFT) | 493 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT); 494 495 if (input_register_device(priv->dev2)) 496 goto init_fail; 497 498 psmouse->protocol_handler = alps_process_byte; 499 psmouse->poll = alps_poll; 500 psmouse->disconnect = alps_disconnect; 501 psmouse->reconnect = alps_reconnect; 502 psmouse->pktsize = 6; 503 504 /* We are having trouble resyncing ALPS touchpads so disable it for now */ 505 psmouse->resync_time = 0; 506 507 return 0; 508 509 init_fail: 510 psmouse_reset(psmouse); 511 input_free_device(dev2); 512 kfree(priv); 513 psmouse->private = NULL; 514 return -1; 515 } 516 517 int alps_detect(struct psmouse *psmouse, int set_properties) 518 { 519 int version; 520 const struct alps_model_info *model; 521 522 model = alps_get_model(psmouse, &version); 523 if (!model) 524 return -1; 525 526 if (set_properties) { 527 psmouse->vendor = "ALPS"; 528 psmouse->name = model->flags & ALPS_DUALPOINT ? 529 "DualPoint TouchPad" : "GlidePoint"; 530 psmouse->model = version; 531 } 532 return 0; 533 } 534 535