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