1 /* 2 * PS/2 mouse driver 3 * 4 * Copyright (c) 1999-2002 Vojtech Pavlik 5 * Copyright (c) 2003-2004 Dmitry Torokhov 6 */ 7 8 /* 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License version 2 as published by 11 * the Free Software Foundation. 12 */ 13 14 #include <linux/delay.h> 15 #include <linux/module.h> 16 #include <linux/moduleparam.h> 17 #include <linux/slab.h> 18 #include <linux/interrupt.h> 19 #include <linux/input.h> 20 #include <linux/serio.h> 21 #include <linux/init.h> 22 #include <linux/libps2.h> 23 #include "psmouse.h" 24 #include "synaptics.h" 25 #include "logips2pp.h" 26 #include "alps.h" 27 #include "lifebook.h" 28 #include "trackpoint.h" 29 30 #define DRIVER_DESC "PS/2 mouse driver" 31 32 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>"); 33 MODULE_DESCRIPTION(DRIVER_DESC); 34 MODULE_LICENSE("GPL"); 35 36 static unsigned int psmouse_max_proto = PSMOUSE_AUTO; 37 static int psmouse_set_maxproto(const char *val, struct kernel_param *kp); 38 static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp); 39 #define param_check_proto_abbrev(name, p) __param_check(name, p, unsigned int) 40 #define param_set_proto_abbrev psmouse_set_maxproto 41 #define param_get_proto_abbrev psmouse_get_maxproto 42 module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644); 43 MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches."); 44 45 static unsigned int psmouse_resolution = 200; 46 module_param_named(resolution, psmouse_resolution, uint, 0644); 47 MODULE_PARM_DESC(resolution, "Resolution, in dpi."); 48 49 static unsigned int psmouse_rate = 100; 50 module_param_named(rate, psmouse_rate, uint, 0644); 51 MODULE_PARM_DESC(rate, "Report rate, in reports per second."); 52 53 static unsigned int psmouse_smartscroll = 1; 54 module_param_named(smartscroll, psmouse_smartscroll, bool, 0644); 55 MODULE_PARM_DESC(smartscroll, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled."); 56 57 static unsigned int psmouse_resetafter; 58 module_param_named(resetafter, psmouse_resetafter, uint, 0644); 59 MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never)."); 60 61 PSMOUSE_DEFINE_ATTR(protocol, S_IWUSR | S_IRUGO, 62 NULL, 63 psmouse_attr_show_protocol, psmouse_attr_set_protocol); 64 PSMOUSE_DEFINE_ATTR(rate, S_IWUSR | S_IRUGO, 65 (void *) offsetof(struct psmouse, rate), 66 psmouse_show_int_attr, psmouse_attr_set_rate); 67 PSMOUSE_DEFINE_ATTR(resolution, S_IWUSR | S_IRUGO, 68 (void *) offsetof(struct psmouse, resolution), 69 psmouse_show_int_attr, psmouse_attr_set_resolution); 70 PSMOUSE_DEFINE_ATTR(resetafter, S_IWUSR | S_IRUGO, 71 (void *) offsetof(struct psmouse, resetafter), 72 psmouse_show_int_attr, psmouse_set_int_attr); 73 74 static struct attribute *psmouse_attributes[] = { 75 &psmouse_attr_protocol.dattr.attr, 76 &psmouse_attr_rate.dattr.attr, 77 &psmouse_attr_resolution.dattr.attr, 78 &psmouse_attr_resetafter.dattr.attr, 79 NULL 80 }; 81 82 static struct attribute_group psmouse_attribute_group = { 83 .attrs = psmouse_attributes, 84 }; 85 86 __obsolete_setup("psmouse_noext"); 87 __obsolete_setup("psmouse_resolution="); 88 __obsolete_setup("psmouse_smartscroll="); 89 __obsolete_setup("psmouse_resetafter="); 90 __obsolete_setup("psmouse_rate="); 91 92 /* 93 * psmouse_sem protects all operations changing state of mouse 94 * (connecting, disconnecting, changing rate or resolution via 95 * sysfs). We could use a per-device semaphore but since there 96 * rarely more than one PS/2 mouse connected and since semaphore 97 * is taken in "slow" paths it is not worth it. 98 */ 99 static DECLARE_MUTEX(psmouse_sem); 100 101 struct psmouse_protocol { 102 enum psmouse_type type; 103 char *name; 104 char *alias; 105 int maxproto; 106 int (*detect)(struct psmouse *, int); 107 int (*init)(struct psmouse *); 108 }; 109 110 /* 111 * psmouse_process_byte() analyzes the PS/2 data stream and reports 112 * relevant events to the input module once full packet has arrived. 113 */ 114 115 static psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse, struct pt_regs *regs) 116 { 117 struct input_dev *dev = &psmouse->dev; 118 unsigned char *packet = psmouse->packet; 119 120 if (psmouse->pktcnt < psmouse->pktsize) 121 return PSMOUSE_GOOD_DATA; 122 123 /* 124 * Full packet accumulated, process it 125 */ 126 127 input_regs(dev, regs); 128 129 /* 130 * Scroll wheel on IntelliMice, scroll buttons on NetMice 131 */ 132 133 if (psmouse->type == PSMOUSE_IMPS || psmouse->type == PSMOUSE_GENPS) 134 input_report_rel(dev, REL_WHEEL, -(signed char) packet[3]); 135 136 /* 137 * Scroll wheel and buttons on IntelliMouse Explorer 138 */ 139 140 if (psmouse->type == PSMOUSE_IMEX) { 141 input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 8) - (int) (packet[3] & 7)); 142 input_report_key(dev, BTN_SIDE, (packet[3] >> 4) & 1); 143 input_report_key(dev, BTN_EXTRA, (packet[3] >> 5) & 1); 144 } 145 146 /* 147 * Extra buttons on Genius NewNet 3D 148 */ 149 150 if (psmouse->type == PSMOUSE_GENPS) { 151 input_report_key(dev, BTN_SIDE, (packet[0] >> 6) & 1); 152 input_report_key(dev, BTN_EXTRA, (packet[0] >> 7) & 1); 153 } 154 155 /* 156 * Extra button on ThinkingMouse 157 */ 158 if (psmouse->type == PSMOUSE_THINKPS) { 159 input_report_key(dev, BTN_EXTRA, (packet[0] >> 3) & 1); 160 /* Without this bit of weirdness moving up gives wildly high Y changes. */ 161 packet[1] |= (packet[0] & 0x40) << 1; 162 } 163 164 /* 165 * Generic PS/2 Mouse 166 */ 167 168 input_report_key(dev, BTN_LEFT, packet[0] & 1); 169 input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1); 170 input_report_key(dev, BTN_RIGHT, (packet[0] >> 1) & 1); 171 172 input_report_rel(dev, REL_X, packet[1] ? (int) packet[1] - (int) ((packet[0] << 4) & 0x100) : 0); 173 input_report_rel(dev, REL_Y, packet[2] ? (int) ((packet[0] << 3) & 0x100) - (int) packet[2] : 0); 174 175 input_sync(dev); 176 177 return PSMOUSE_FULL_PACKET; 178 } 179 180 /* 181 * psmouse_interrupt() handles incoming characters, either gathering them into 182 * packets or passing them to the command routine as command output. 183 */ 184 185 static irqreturn_t psmouse_interrupt(struct serio *serio, 186 unsigned char data, unsigned int flags, struct pt_regs *regs) 187 { 188 struct psmouse *psmouse = serio_get_drvdata(serio); 189 psmouse_ret_t rc; 190 191 if (psmouse->state == PSMOUSE_IGNORE) 192 goto out; 193 194 if (flags & (SERIO_PARITY|SERIO_TIMEOUT)) { 195 if (psmouse->state == PSMOUSE_ACTIVATED) 196 printk(KERN_WARNING "psmouse.c: bad data from KBC -%s%s\n", 197 flags & SERIO_TIMEOUT ? " timeout" : "", 198 flags & SERIO_PARITY ? " bad parity" : ""); 199 ps2_cmd_aborted(&psmouse->ps2dev); 200 goto out; 201 } 202 203 if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_ACK)) 204 if (ps2_handle_ack(&psmouse->ps2dev, data)) 205 goto out; 206 207 if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_CMD)) 208 if (ps2_handle_response(&psmouse->ps2dev, data)) 209 goto out; 210 211 if (psmouse->state == PSMOUSE_INITIALIZING) 212 goto out; 213 214 if (psmouse->state == PSMOUSE_ACTIVATED && 215 psmouse->pktcnt && time_after(jiffies, psmouse->last + HZ/2)) { 216 printk(KERN_WARNING "psmouse.c: %s at %s lost synchronization, throwing %d bytes away.\n", 217 psmouse->name, psmouse->phys, psmouse->pktcnt); 218 psmouse->pktcnt = 0; 219 } 220 221 psmouse->last = jiffies; 222 psmouse->packet[psmouse->pktcnt++] = data; 223 224 if (psmouse->packet[0] == PSMOUSE_RET_BAT) { 225 if (psmouse->pktcnt == 1) 226 goto out; 227 228 if (psmouse->pktcnt == 2) { 229 if (psmouse->packet[1] == PSMOUSE_RET_ID) { 230 psmouse->state = PSMOUSE_IGNORE; 231 serio_reconnect(serio); 232 goto out; 233 } 234 if (psmouse->type == PSMOUSE_SYNAPTICS) { 235 /* neither 0xAA nor 0x00 are valid first bytes 236 * for a packet in absolute mode 237 */ 238 psmouse->pktcnt = 0; 239 goto out; 240 } 241 } 242 } 243 244 rc = psmouse->protocol_handler(psmouse, regs); 245 246 switch (rc) { 247 case PSMOUSE_BAD_DATA: 248 printk(KERN_WARNING "psmouse.c: %s at %s lost sync at byte %d\n", 249 psmouse->name, psmouse->phys, psmouse->pktcnt); 250 psmouse->pktcnt = 0; 251 252 if (++psmouse->out_of_sync == psmouse->resetafter) { 253 psmouse->state = PSMOUSE_IGNORE; 254 printk(KERN_NOTICE "psmouse.c: issuing reconnect request\n"); 255 serio_reconnect(psmouse->ps2dev.serio); 256 } 257 break; 258 259 case PSMOUSE_FULL_PACKET: 260 psmouse->pktcnt = 0; 261 if (psmouse->out_of_sync) { 262 psmouse->out_of_sync = 0; 263 printk(KERN_NOTICE "psmouse.c: %s at %s - driver resynched.\n", 264 psmouse->name, psmouse->phys); 265 } 266 break; 267 268 case PSMOUSE_GOOD_DATA: 269 break; 270 } 271 out: 272 return IRQ_HANDLED; 273 } 274 275 276 /* 277 * psmouse_sliced_command() sends an extended PS/2 command to the mouse 278 * using sliced syntax, understood by advanced devices, such as Logitech 279 * or Synaptics touchpads. The command is encoded as: 280 * 0xE6 0xE8 rr 0xE8 ss 0xE8 tt 0xE8 uu where (rr*64)+(ss*16)+(tt*4)+uu 281 * is the command. 282 */ 283 int psmouse_sliced_command(struct psmouse *psmouse, unsigned char command) 284 { 285 int i; 286 287 if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) 288 return -1; 289 290 for (i = 6; i >= 0; i -= 2) { 291 unsigned char d = (command >> i) & 3; 292 if (ps2_command(&psmouse->ps2dev, &d, PSMOUSE_CMD_SETRES)) 293 return -1; 294 } 295 296 return 0; 297 } 298 299 300 /* 301 * psmouse_reset() resets the mouse into power-on state. 302 */ 303 int psmouse_reset(struct psmouse *psmouse) 304 { 305 unsigned char param[2]; 306 307 if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_RESET_BAT)) 308 return -1; 309 310 if (param[0] != PSMOUSE_RET_BAT && param[1] != PSMOUSE_RET_ID) 311 return -1; 312 313 return 0; 314 } 315 316 317 /* 318 * Genius NetMouse magic init. 319 */ 320 static int genius_detect(struct psmouse *psmouse, int set_properties) 321 { 322 struct ps2dev *ps2dev = &psmouse->ps2dev; 323 unsigned char param[4]; 324 325 param[0] = 3; 326 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES); 327 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11); 328 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11); 329 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11); 330 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO); 331 332 if (param[0] != 0x00 || param[1] != 0x33 || param[2] != 0x55) 333 return -1; 334 335 if (set_properties) { 336 set_bit(BTN_EXTRA, psmouse->dev.keybit); 337 set_bit(BTN_SIDE, psmouse->dev.keybit); 338 set_bit(REL_WHEEL, psmouse->dev.relbit); 339 340 psmouse->vendor = "Genius"; 341 psmouse->name = "Wheel Mouse"; 342 psmouse->pktsize = 4; 343 } 344 345 return 0; 346 } 347 348 /* 349 * IntelliMouse magic init. 350 */ 351 static int intellimouse_detect(struct psmouse *psmouse, int set_properties) 352 { 353 struct ps2dev *ps2dev = &psmouse->ps2dev; 354 unsigned char param[2]; 355 356 param[0] = 200; 357 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 358 param[0] = 100; 359 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 360 param[0] = 80; 361 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 362 ps2_command(ps2dev, param, PSMOUSE_CMD_GETID); 363 364 if (param[0] != 3) 365 return -1; 366 367 if (set_properties) { 368 set_bit(BTN_MIDDLE, psmouse->dev.keybit); 369 set_bit(REL_WHEEL, psmouse->dev.relbit); 370 371 if (!psmouse->vendor) psmouse->vendor = "Generic"; 372 if (!psmouse->name) psmouse->name = "Wheel Mouse"; 373 psmouse->pktsize = 4; 374 } 375 376 return 0; 377 } 378 379 /* 380 * Try IntelliMouse/Explorer magic init. 381 */ 382 static int im_explorer_detect(struct psmouse *psmouse, int set_properties) 383 { 384 struct ps2dev *ps2dev = &psmouse->ps2dev; 385 unsigned char param[2]; 386 387 intellimouse_detect(psmouse, 0); 388 389 param[0] = 200; 390 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 391 param[0] = 200; 392 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 393 param[0] = 80; 394 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 395 ps2_command(ps2dev, param, PSMOUSE_CMD_GETID); 396 397 if (param[0] != 4) 398 return -1; 399 400 if (set_properties) { 401 set_bit(BTN_MIDDLE, psmouse->dev.keybit); 402 set_bit(REL_WHEEL, psmouse->dev.relbit); 403 set_bit(BTN_SIDE, psmouse->dev.keybit); 404 set_bit(BTN_EXTRA, psmouse->dev.keybit); 405 406 if (!psmouse->vendor) psmouse->vendor = "Generic"; 407 if (!psmouse->name) psmouse->name = "Explorer Mouse"; 408 psmouse->pktsize = 4; 409 } 410 411 return 0; 412 } 413 414 /* 415 * Kensington ThinkingMouse / ExpertMouse magic init. 416 */ 417 static int thinking_detect(struct psmouse *psmouse, int set_properties) 418 { 419 struct ps2dev *ps2dev = &psmouse->ps2dev; 420 unsigned char param[2]; 421 unsigned char seq[] = { 20, 60, 40, 20, 20, 60, 40, 20, 20, 0 }; 422 int i; 423 424 param[0] = 10; 425 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 426 param[0] = 0; 427 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES); 428 for (i = 0; seq[i]; i++) 429 ps2_command(ps2dev, seq + i, PSMOUSE_CMD_SETRATE); 430 ps2_command(ps2dev, param, PSMOUSE_CMD_GETID); 431 432 if (param[0] != 2) 433 return -1; 434 435 if (set_properties) { 436 set_bit(BTN_EXTRA, psmouse->dev.keybit); 437 438 psmouse->vendor = "Kensington"; 439 psmouse->name = "ThinkingMouse"; 440 } 441 442 return 0; 443 } 444 445 /* 446 * Bare PS/2 protocol "detection". Always succeeds. 447 */ 448 static int ps2bare_detect(struct psmouse *psmouse, int set_properties) 449 { 450 if (set_properties) { 451 if (!psmouse->vendor) psmouse->vendor = "Generic"; 452 if (!psmouse->name) psmouse->name = "Mouse"; 453 } 454 455 return 0; 456 } 457 458 459 /* 460 * psmouse_extensions() probes for any extensions to the basic PS/2 protocol 461 * the mouse may have. 462 */ 463 464 static int psmouse_extensions(struct psmouse *psmouse, 465 unsigned int max_proto, int set_properties) 466 { 467 int synaptics_hardware = 0; 468 469 /* 470 * We always check for lifebook because it does not disturb mouse 471 * (it only checks DMI information). 472 */ 473 if (lifebook_detect(psmouse, set_properties) == 0) { 474 if (max_proto > PSMOUSE_IMEX) { 475 if (!set_properties || lifebook_init(psmouse) == 0) 476 return PSMOUSE_LIFEBOOK; 477 } 478 } 479 480 /* 481 * Try Kensington ThinkingMouse (we try first, because synaptics probe 482 * upsets the thinkingmouse). 483 */ 484 485 if (max_proto > PSMOUSE_IMEX && thinking_detect(psmouse, set_properties) == 0) 486 return PSMOUSE_THINKPS; 487 488 /* 489 * Try Synaptics TouchPad 490 */ 491 if (max_proto > PSMOUSE_PS2 && synaptics_detect(psmouse, set_properties) == 0) { 492 synaptics_hardware = 1; 493 494 if (max_proto > PSMOUSE_IMEX) { 495 if (!set_properties || synaptics_init(psmouse) == 0) 496 return PSMOUSE_SYNAPTICS; 497 /* 498 * Some Synaptics touchpads can emulate extended protocols (like IMPS/2). 499 * Unfortunately Logitech/Genius probes confuse some firmware versions so 500 * we'll have to skip them. 501 */ 502 max_proto = PSMOUSE_IMEX; 503 } 504 /* 505 * Make sure that touchpad is in relative mode, gestures (taps) are enabled 506 */ 507 synaptics_reset(psmouse); 508 } 509 510 /* 511 * Try ALPS TouchPad 512 */ 513 if (max_proto > PSMOUSE_IMEX) { 514 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS); 515 if (alps_detect(psmouse, set_properties) == 0) { 516 if (!set_properties || alps_init(psmouse) == 0) 517 return PSMOUSE_ALPS; 518 /* 519 * Init failed, try basic relative protocols 520 */ 521 max_proto = PSMOUSE_IMEX; 522 } 523 } 524 525 if (max_proto > PSMOUSE_IMEX && genius_detect(psmouse, set_properties) == 0) 526 return PSMOUSE_GENPS; 527 528 if (max_proto > PSMOUSE_IMEX && ps2pp_init(psmouse, set_properties) == 0) 529 return PSMOUSE_PS2PP; 530 531 /* 532 * Reset to defaults in case the device got confused by extended 533 * protocol probes. 534 */ 535 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS); 536 537 if (max_proto >= PSMOUSE_IMEX && im_explorer_detect(psmouse, set_properties) == 0) 538 return PSMOUSE_IMEX; 539 540 if (max_proto >= PSMOUSE_IMPS && intellimouse_detect(psmouse, set_properties) == 0) 541 return PSMOUSE_IMPS; 542 543 /* 544 * Try to initialize the IBM TrackPoint 545 */ 546 if (max_proto > PSMOUSE_IMEX && trackpoint_detect(psmouse, set_properties) == 0) 547 return PSMOUSE_TRACKPOINT; 548 549 /* 550 * Okay, all failed, we have a standard mouse here. The number of the buttons 551 * is still a question, though. We assume 3. 552 */ 553 ps2bare_detect(psmouse, set_properties); 554 555 if (synaptics_hardware) { 556 /* 557 * We detected Synaptics hardware but it did not respond to IMPS/2 probes. 558 * We need to reset the touchpad because if there is a track point on the 559 * pass through port it could get disabled while probing for protocol 560 * extensions. 561 */ 562 psmouse_reset(psmouse); 563 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS); 564 } 565 566 return PSMOUSE_PS2; 567 } 568 569 static struct psmouse_protocol psmouse_protocols[] = { 570 { 571 .type = PSMOUSE_PS2, 572 .name = "PS/2", 573 .alias = "bare", 574 .maxproto = 1, 575 .detect = ps2bare_detect, 576 }, 577 { 578 .type = PSMOUSE_PS2PP, 579 .name = "PS2++", 580 .alias = "logitech", 581 .detect = ps2pp_init, 582 }, 583 { 584 .type = PSMOUSE_THINKPS, 585 .name = "ThinkPS/2", 586 .alias = "thinkps", 587 .detect = thinking_detect, 588 }, 589 { 590 .type = PSMOUSE_GENPS, 591 .name = "GenPS/2", 592 .alias = "genius", 593 .detect = genius_detect, 594 }, 595 { 596 .type = PSMOUSE_IMPS, 597 .name = "ImPS/2", 598 .alias = "imps", 599 .maxproto = 1, 600 .detect = intellimouse_detect, 601 }, 602 { 603 .type = PSMOUSE_IMEX, 604 .name = "ImExPS/2", 605 .alias = "exps", 606 .maxproto = 1, 607 .detect = im_explorer_detect, 608 }, 609 { 610 .type = PSMOUSE_SYNAPTICS, 611 .name = "SynPS/2", 612 .alias = "synaptics", 613 .detect = synaptics_detect, 614 .init = synaptics_init, 615 }, 616 { 617 .type = PSMOUSE_ALPS, 618 .name = "AlpsPS/2", 619 .alias = "alps", 620 .detect = alps_detect, 621 .init = alps_init, 622 }, 623 { 624 .type = PSMOUSE_LIFEBOOK, 625 .name = "LBPS/2", 626 .alias = "lifebook", 627 .init = lifebook_init, 628 }, 629 { 630 .type = PSMOUSE_TRACKPOINT, 631 .name = "TPPS/2", 632 .alias = "trackpoint", 633 .detect = trackpoint_detect, 634 }, 635 { 636 .type = PSMOUSE_AUTO, 637 .name = "auto", 638 .alias = "any", 639 .maxproto = 1, 640 }, 641 }; 642 643 static struct psmouse_protocol *psmouse_protocol_by_type(enum psmouse_type type) 644 { 645 int i; 646 647 for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++) 648 if (psmouse_protocols[i].type == type) 649 return &psmouse_protocols[i]; 650 651 WARN_ON(1); 652 return &psmouse_protocols[0]; 653 } 654 655 static struct psmouse_protocol *psmouse_protocol_by_name(const char *name, size_t len) 656 { 657 struct psmouse_protocol *p; 658 int i; 659 660 for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++) { 661 p = &psmouse_protocols[i]; 662 663 if ((strlen(p->name) == len && !strncmp(p->name, name, len)) || 664 (strlen(p->alias) == len && !strncmp(p->alias, name, len))) 665 return &psmouse_protocols[i]; 666 } 667 668 return NULL; 669 } 670 671 672 /* 673 * psmouse_probe() probes for a PS/2 mouse. 674 */ 675 676 static int psmouse_probe(struct psmouse *psmouse) 677 { 678 struct ps2dev *ps2dev = &psmouse->ps2dev; 679 unsigned char param[2]; 680 681 /* 682 * First, we check if it's a mouse. It should send 0x00 or 0x03 683 * in case of an IntelliMouse in 4-byte mode or 0x04 for IM Explorer. 684 * Sunrex K8561 IR Keyboard/Mouse reports 0xff on second and subsequent 685 * ID queries, probably due to a firmware bug. 686 */ 687 688 param[0] = 0xa5; 689 if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETID)) 690 return -1; 691 692 if (param[0] != 0x00 && param[0] != 0x03 && 693 param[0] != 0x04 && param[0] != 0xff) 694 return -1; 695 696 /* 697 * Then we reset and disable the mouse so that it doesn't generate events. 698 */ 699 700 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_DIS)) 701 printk(KERN_WARNING "psmouse.c: Failed to reset mouse on %s\n", ps2dev->serio->phys); 702 703 return 0; 704 } 705 706 /* 707 * Here we set the mouse resolution. 708 */ 709 710 void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution) 711 { 712 unsigned char params[] = { 0, 1, 2, 2, 3 }; 713 714 if (resolution == 0 || resolution > 200) 715 resolution = 200; 716 717 ps2_command(&psmouse->ps2dev, ¶ms[resolution / 50], PSMOUSE_CMD_SETRES); 718 psmouse->resolution = 25 << params[resolution / 50]; 719 } 720 721 /* 722 * Here we set the mouse report rate. 723 */ 724 725 static void psmouse_set_rate(struct psmouse *psmouse, unsigned int rate) 726 { 727 unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10, 0 }; 728 int i = 0; 729 730 while (rates[i] > rate) i++; 731 ps2_command(&psmouse->ps2dev, &rates[i], PSMOUSE_CMD_SETRATE); 732 psmouse->rate = rates[i]; 733 } 734 735 /* 736 * psmouse_initialize() initializes the mouse to a sane state. 737 */ 738 739 static void psmouse_initialize(struct psmouse *psmouse) 740 { 741 /* 742 * We set the mouse into streaming mode. 743 */ 744 745 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSTREAM); 746 747 /* 748 * We set the mouse report rate, resolution and scaling. 749 */ 750 751 if (psmouse_max_proto != PSMOUSE_PS2) { 752 psmouse->set_rate(psmouse, psmouse->rate); 753 psmouse->set_resolution(psmouse, psmouse->resolution); 754 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11); 755 } 756 } 757 758 /* 759 * psmouse_set_state() sets new psmouse state and resets all flags and 760 * counters while holding serio lock so fighting with interrupt handler 761 * is not a concern. 762 */ 763 764 static void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state) 765 { 766 serio_pause_rx(psmouse->ps2dev.serio); 767 psmouse->state = new_state; 768 psmouse->pktcnt = psmouse->out_of_sync = 0; 769 psmouse->ps2dev.flags = 0; 770 serio_continue_rx(psmouse->ps2dev.serio); 771 } 772 773 /* 774 * psmouse_activate() enables the mouse so that we get motion reports from it. 775 */ 776 777 static void psmouse_activate(struct psmouse *psmouse) 778 { 779 if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) 780 printk(KERN_WARNING "psmouse.c: Failed to enable mouse on %s\n", 781 psmouse->ps2dev.serio->phys); 782 783 psmouse_set_state(psmouse, PSMOUSE_ACTIVATED); 784 } 785 786 787 /* 788 * psmouse_deactivate() puts the mouse into poll mode so that we don't get motion 789 * reports from it unless we explicitely request it. 790 */ 791 792 static void psmouse_deactivate(struct psmouse *psmouse) 793 { 794 if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE)) 795 printk(KERN_WARNING "psmouse.c: Failed to deactivate mouse on %s\n", 796 psmouse->ps2dev.serio->phys); 797 798 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 799 } 800 801 802 /* 803 * psmouse_cleanup() resets the mouse into power-on state. 804 */ 805 806 static void psmouse_cleanup(struct serio *serio) 807 { 808 struct psmouse *psmouse = serio_get_drvdata(serio); 809 810 psmouse_reset(psmouse); 811 } 812 813 /* 814 * psmouse_disconnect() closes and frees. 815 */ 816 817 static void psmouse_disconnect(struct serio *serio) 818 { 819 struct psmouse *psmouse, *parent = NULL; 820 821 psmouse = serio_get_drvdata(serio); 822 823 sysfs_remove_group(&serio->dev.kobj, &psmouse_attribute_group); 824 825 down(&psmouse_sem); 826 827 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 828 829 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 830 parent = serio_get_drvdata(serio->parent); 831 psmouse_deactivate(parent); 832 } 833 834 if (psmouse->disconnect) 835 psmouse->disconnect(psmouse); 836 837 if (parent && parent->pt_deactivate) 838 parent->pt_deactivate(parent); 839 840 psmouse_set_state(psmouse, PSMOUSE_IGNORE); 841 842 input_unregister_device(&psmouse->dev); 843 serio_close(serio); 844 serio_set_drvdata(serio, NULL); 845 kfree(psmouse); 846 847 if (parent) 848 psmouse_activate(parent); 849 850 up(&psmouse_sem); 851 } 852 853 static int psmouse_switch_protocol(struct psmouse *psmouse, struct psmouse_protocol *proto) 854 { 855 memset(&psmouse->dev, 0, sizeof(struct input_dev)); 856 857 init_input_dev(&psmouse->dev); 858 859 psmouse->dev.private = psmouse; 860 psmouse->dev.dev = &psmouse->ps2dev.serio->dev; 861 862 psmouse->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REL); 863 psmouse->dev.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_MIDDLE) | BIT(BTN_RIGHT); 864 psmouse->dev.relbit[0] = BIT(REL_X) | BIT(REL_Y); 865 866 psmouse->set_rate = psmouse_set_rate; 867 psmouse->set_resolution = psmouse_set_resolution; 868 psmouse->protocol_handler = psmouse_process_byte; 869 psmouse->pktsize = 3; 870 871 if (proto && (proto->detect || proto->init)) { 872 if (proto->detect && proto->detect(psmouse, 1) < 0) 873 return -1; 874 875 if (proto->init && proto->init(psmouse) < 0) 876 return -1; 877 878 psmouse->type = proto->type; 879 } 880 else 881 psmouse->type = psmouse_extensions(psmouse, psmouse_max_proto, 1); 882 883 sprintf(psmouse->devname, "%s %s %s", 884 psmouse_protocol_by_type(psmouse->type)->name, psmouse->vendor, psmouse->name); 885 886 psmouse->dev.name = psmouse->devname; 887 psmouse->dev.phys = psmouse->phys; 888 psmouse->dev.id.bustype = BUS_I8042; 889 psmouse->dev.id.vendor = 0x0002; 890 psmouse->dev.id.product = psmouse->type; 891 psmouse->dev.id.version = psmouse->model; 892 893 return 0; 894 } 895 896 /* 897 * psmouse_connect() is a callback from the serio module when 898 * an unhandled serio port is found. 899 */ 900 static int psmouse_connect(struct serio *serio, struct serio_driver *drv) 901 { 902 struct psmouse *psmouse, *parent = NULL; 903 int retval; 904 905 down(&psmouse_sem); 906 907 /* 908 * If this is a pass-through port deactivate parent so the device 909 * connected to this port can be successfully identified 910 */ 911 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 912 parent = serio_get_drvdata(serio->parent); 913 psmouse_deactivate(parent); 914 } 915 916 if (!(psmouse = kzalloc(sizeof(struct psmouse), GFP_KERNEL))) { 917 retval = -ENOMEM; 918 goto out; 919 } 920 921 ps2_init(&psmouse->ps2dev, serio); 922 sprintf(psmouse->phys, "%s/input0", serio->phys); 923 924 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING); 925 926 serio_set_drvdata(serio, psmouse); 927 928 retval = serio_open(serio, drv); 929 if (retval) { 930 serio_set_drvdata(serio, NULL); 931 kfree(psmouse); 932 goto out; 933 } 934 935 if (psmouse_probe(psmouse) < 0) { 936 serio_close(serio); 937 serio_set_drvdata(serio, NULL); 938 kfree(psmouse); 939 retval = -ENODEV; 940 goto out; 941 } 942 943 psmouse->rate = psmouse_rate; 944 psmouse->resolution = psmouse_resolution; 945 psmouse->resetafter = psmouse_resetafter; 946 psmouse->smartscroll = psmouse_smartscroll; 947 948 psmouse_switch_protocol(psmouse, NULL); 949 950 input_register_device(&psmouse->dev); 951 printk(KERN_INFO "input: %s on %s\n", psmouse->devname, serio->phys); 952 953 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 954 955 psmouse_initialize(psmouse); 956 957 if (parent && parent->pt_activate) 958 parent->pt_activate(parent); 959 960 sysfs_create_group(&serio->dev.kobj, &psmouse_attribute_group); 961 962 psmouse_activate(psmouse); 963 964 retval = 0; 965 966 out: 967 /* If this is a pass-through port the parent needs to be re-activated */ 968 if (parent) 969 psmouse_activate(parent); 970 971 up(&psmouse_sem); 972 return retval; 973 } 974 975 976 static int psmouse_reconnect(struct serio *serio) 977 { 978 struct psmouse *psmouse = serio_get_drvdata(serio); 979 struct psmouse *parent = NULL; 980 struct serio_driver *drv = serio->drv; 981 int rc = -1; 982 983 if (!drv || !psmouse) { 984 printk(KERN_DEBUG "psmouse: reconnect request, but serio is disconnected, ignoring...\n"); 985 return -1; 986 } 987 988 down(&psmouse_sem); 989 990 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 991 parent = serio_get_drvdata(serio->parent); 992 psmouse_deactivate(parent); 993 } 994 995 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING); 996 997 if (psmouse->reconnect) { 998 if (psmouse->reconnect(psmouse)) 999 goto out; 1000 } else if (psmouse_probe(psmouse) < 0 || 1001 psmouse->type != psmouse_extensions(psmouse, psmouse_max_proto, 0)) 1002 goto out; 1003 1004 /* ok, the device type (and capabilities) match the old one, 1005 * we can continue using it, complete intialization 1006 */ 1007 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 1008 1009 psmouse_initialize(psmouse); 1010 1011 if (parent && parent->pt_activate) 1012 parent->pt_activate(parent); 1013 1014 psmouse_activate(psmouse); 1015 rc = 0; 1016 1017 out: 1018 /* If this is a pass-through port the parent waits to be activated */ 1019 if (parent) 1020 psmouse_activate(parent); 1021 1022 up(&psmouse_sem); 1023 return rc; 1024 } 1025 1026 static struct serio_device_id psmouse_serio_ids[] = { 1027 { 1028 .type = SERIO_8042, 1029 .proto = SERIO_ANY, 1030 .id = SERIO_ANY, 1031 .extra = SERIO_ANY, 1032 }, 1033 { 1034 .type = SERIO_PS_PSTHRU, 1035 .proto = SERIO_ANY, 1036 .id = SERIO_ANY, 1037 .extra = SERIO_ANY, 1038 }, 1039 { 0 } 1040 }; 1041 1042 MODULE_DEVICE_TABLE(serio, psmouse_serio_ids); 1043 1044 static struct serio_driver psmouse_drv = { 1045 .driver = { 1046 .name = "psmouse", 1047 }, 1048 .description = DRIVER_DESC, 1049 .id_table = psmouse_serio_ids, 1050 .interrupt = psmouse_interrupt, 1051 .connect = psmouse_connect, 1052 .reconnect = psmouse_reconnect, 1053 .disconnect = psmouse_disconnect, 1054 .cleanup = psmouse_cleanup, 1055 }; 1056 1057 ssize_t psmouse_attr_show_helper(struct device *dev, struct device_attribute *devattr, 1058 char *buf) 1059 { 1060 struct serio *serio = to_serio_port(dev); 1061 struct psmouse_attribute *attr = to_psmouse_attr(devattr); 1062 struct psmouse *psmouse; 1063 int retval; 1064 1065 retval = serio_pin_driver(serio); 1066 if (retval) 1067 return retval; 1068 1069 if (serio->drv != &psmouse_drv) { 1070 retval = -ENODEV; 1071 goto out; 1072 } 1073 1074 psmouse = serio_get_drvdata(serio); 1075 1076 retval = attr->show(psmouse, attr->data, buf); 1077 1078 out: 1079 serio_unpin_driver(serio); 1080 return retval; 1081 } 1082 1083 ssize_t psmouse_attr_set_helper(struct device *dev, struct device_attribute *devattr, 1084 const char *buf, size_t count) 1085 { 1086 struct serio *serio = to_serio_port(dev); 1087 struct psmouse_attribute *attr = to_psmouse_attr(devattr); 1088 struct psmouse *psmouse, *parent = NULL; 1089 int retval; 1090 1091 retval = serio_pin_driver(serio); 1092 if (retval) 1093 return retval; 1094 1095 if (serio->drv != &psmouse_drv) { 1096 retval = -ENODEV; 1097 goto out_unpin; 1098 } 1099 1100 retval = down_interruptible(&psmouse_sem); 1101 if (retval) 1102 goto out_unpin; 1103 1104 psmouse = serio_get_drvdata(serio); 1105 1106 if (psmouse->state == PSMOUSE_IGNORE) { 1107 retval = -ENODEV; 1108 goto out_up; 1109 } 1110 1111 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 1112 parent = serio_get_drvdata(serio->parent); 1113 psmouse_deactivate(parent); 1114 } 1115 1116 psmouse_deactivate(psmouse); 1117 1118 retval = attr->set(psmouse, attr->data, buf, count); 1119 1120 if (retval != -ENODEV) 1121 psmouse_activate(psmouse); 1122 1123 if (parent) 1124 psmouse_activate(parent); 1125 1126 out_up: 1127 up(&psmouse_sem); 1128 out_unpin: 1129 serio_unpin_driver(serio); 1130 return retval; 1131 } 1132 1133 static ssize_t psmouse_show_int_attr(struct psmouse *psmouse, void *offset, char *buf) 1134 { 1135 unsigned long *field = (unsigned long *)((char *)psmouse + (size_t)offset); 1136 1137 return sprintf(buf, "%lu\n", *field); 1138 } 1139 1140 static ssize_t psmouse_set_int_attr(struct psmouse *psmouse, void *offset, const char *buf, size_t count) 1141 { 1142 unsigned long *field = (unsigned long *)((char *)psmouse + (size_t)offset); 1143 unsigned long value; 1144 char *rest; 1145 1146 value = simple_strtoul(buf, &rest, 10); 1147 if (*rest) 1148 return -EINVAL; 1149 1150 *field = value; 1151 1152 return count; 1153 } 1154 1155 static ssize_t psmouse_attr_show_protocol(struct psmouse *psmouse, void *data, char *buf) 1156 { 1157 return sprintf(buf, "%s\n", psmouse_protocol_by_type(psmouse->type)->name); 1158 } 1159 1160 static ssize_t psmouse_attr_set_protocol(struct psmouse *psmouse, void *data, const char *buf, size_t count) 1161 { 1162 struct serio *serio = psmouse->ps2dev.serio; 1163 struct psmouse *parent = NULL; 1164 struct psmouse_protocol *proto; 1165 int retry = 0; 1166 1167 if (!(proto = psmouse_protocol_by_name(buf, count))) 1168 return -EINVAL; 1169 1170 if (psmouse->type == proto->type) 1171 return count; 1172 1173 while (serio->child) { 1174 if (++retry > 3) { 1175 printk(KERN_WARNING "psmouse: failed to destroy child port, protocol change aborted.\n"); 1176 return -EIO; 1177 } 1178 1179 up(&psmouse_sem); 1180 serio_unpin_driver(serio); 1181 serio_unregister_child_port(serio); 1182 serio_pin_driver_uninterruptible(serio); 1183 down(&psmouse_sem); 1184 1185 if (serio->drv != &psmouse_drv) 1186 return -ENODEV; 1187 1188 if (psmouse->type == proto->type) 1189 return count; /* switched by other thread */ 1190 } 1191 1192 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 1193 parent = serio_get_drvdata(serio->parent); 1194 if (parent->pt_deactivate) 1195 parent->pt_deactivate(parent); 1196 } 1197 1198 if (psmouse->disconnect) 1199 psmouse->disconnect(psmouse); 1200 1201 psmouse_set_state(psmouse, PSMOUSE_IGNORE); 1202 input_unregister_device(&psmouse->dev); 1203 1204 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING); 1205 1206 if (psmouse_switch_protocol(psmouse, proto) < 0) { 1207 psmouse_reset(psmouse); 1208 /* default to PSMOUSE_PS2 */ 1209 psmouse_switch_protocol(psmouse, &psmouse_protocols[0]); 1210 } 1211 1212 psmouse_initialize(psmouse); 1213 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 1214 1215 input_register_device(&psmouse->dev); 1216 printk(KERN_INFO "input: %s on %s\n", psmouse->devname, serio->phys); 1217 1218 if (parent && parent->pt_activate) 1219 parent->pt_activate(parent); 1220 1221 return count; 1222 } 1223 1224 static ssize_t psmouse_attr_set_rate(struct psmouse *psmouse, void *data, const char *buf, size_t count) 1225 { 1226 unsigned long value; 1227 char *rest; 1228 1229 value = simple_strtoul(buf, &rest, 10); 1230 if (*rest) 1231 return -EINVAL; 1232 1233 psmouse->set_rate(psmouse, value); 1234 return count; 1235 } 1236 1237 static ssize_t psmouse_attr_set_resolution(struct psmouse *psmouse, void *data, const char *buf, size_t count) 1238 { 1239 unsigned long value; 1240 char *rest; 1241 1242 value = simple_strtoul(buf, &rest, 10); 1243 if (*rest) 1244 return -EINVAL; 1245 1246 psmouse->set_resolution(psmouse, value); 1247 return count; 1248 } 1249 1250 1251 static int psmouse_set_maxproto(const char *val, struct kernel_param *kp) 1252 { 1253 struct psmouse_protocol *proto; 1254 1255 if (!val) 1256 return -EINVAL; 1257 1258 proto = psmouse_protocol_by_name(val, strlen(val)); 1259 1260 if (!proto || !proto->maxproto) 1261 return -EINVAL; 1262 1263 *((unsigned int *)kp->arg) = proto->type; 1264 1265 return 0; 1266 } 1267 1268 static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp) 1269 { 1270 int type = *((unsigned int *)kp->arg); 1271 1272 return sprintf(buffer, "%s\n", psmouse_protocol_by_type(type)->name); 1273 } 1274 1275 static int __init psmouse_init(void) 1276 { 1277 serio_register_driver(&psmouse_drv); 1278 return 0; 1279 } 1280 1281 static void __exit psmouse_exit(void) 1282 { 1283 serio_unregister_driver(&psmouse_drv); 1284 } 1285 1286 module_init(psmouse_init); 1287 module_exit(psmouse_exit); 1288