1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * PS/2 mouse driver 4 * 5 * Copyright (c) 1999-2002 Vojtech Pavlik 6 * Copyright (c) 2003-2004 Dmitry Torokhov 7 */ 8 9 10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 11 #define psmouse_fmt(fmt) fmt 12 13 #include <linux/bitops.h> 14 #include <linux/delay.h> 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 #include <linux/interrupt.h> 18 #include <linux/input.h> 19 #include <linux/serio.h> 20 #include <linux/init.h> 21 #include <linux/libps2.h> 22 #include <linux/mutex.h> 23 #include <linux/types.h> 24 25 #include "psmouse.h" 26 #include "synaptics.h" 27 #include "logips2pp.h" 28 #include "alps.h" 29 #include "lifebook.h" 30 #include "trackpoint.h" 31 #include "touchkit_ps2.h" 32 #include "elantech.h" 33 #include "sentelic.h" 34 #include "cypress_ps2.h" 35 #include "focaltech.h" 36 #include "vmmouse.h" 37 #include "byd.h" 38 39 #define DRIVER_DESC "PS/2 mouse driver" 40 41 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>"); 42 MODULE_DESCRIPTION(DRIVER_DESC); 43 MODULE_LICENSE("GPL"); 44 45 static unsigned int psmouse_max_proto = PSMOUSE_AUTO; 46 static int psmouse_set_maxproto(const char *val, const struct kernel_param *); 47 static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp); 48 static const struct kernel_param_ops param_ops_proto_abbrev = { 49 .set = psmouse_set_maxproto, 50 .get = psmouse_get_maxproto, 51 }; 52 #define param_check_proto_abbrev(name, p) __param_check(name, p, unsigned int) 53 module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644); 54 MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches."); 55 56 static unsigned int psmouse_resolution = 200; 57 module_param_named(resolution, psmouse_resolution, uint, 0644); 58 MODULE_PARM_DESC(resolution, "Resolution, in dpi."); 59 60 static unsigned int psmouse_rate = 100; 61 module_param_named(rate, psmouse_rate, uint, 0644); 62 MODULE_PARM_DESC(rate, "Report rate, in reports per second."); 63 64 static bool psmouse_smartscroll = true; 65 module_param_named(smartscroll, psmouse_smartscroll, bool, 0644); 66 MODULE_PARM_DESC(smartscroll, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled."); 67 68 static bool psmouse_a4tech_2wheels; 69 module_param_named(a4tech_workaround, psmouse_a4tech_2wheels, bool, 0644); 70 MODULE_PARM_DESC(a4tech_workaround, "A4Tech second scroll wheel workaround, 1 = enabled, 0 = disabled (default)."); 71 72 static unsigned int psmouse_resetafter = 5; 73 module_param_named(resetafter, psmouse_resetafter, uint, 0644); 74 MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never)."); 75 76 static unsigned int psmouse_resync_time; 77 module_param_named(resync_time, psmouse_resync_time, uint, 0644); 78 MODULE_PARM_DESC(resync_time, "How long can mouse stay idle before forcing resync (in seconds, 0 = never)."); 79 80 PSMOUSE_DEFINE_ATTR(protocol, S_IWUSR | S_IRUGO, 81 NULL, 82 psmouse_attr_show_protocol, psmouse_attr_set_protocol); 83 PSMOUSE_DEFINE_ATTR(rate, S_IWUSR | S_IRUGO, 84 (void *) offsetof(struct psmouse, rate), 85 psmouse_show_int_attr, psmouse_attr_set_rate); 86 PSMOUSE_DEFINE_ATTR(resolution, S_IWUSR | S_IRUGO, 87 (void *) offsetof(struct psmouse, resolution), 88 psmouse_show_int_attr, psmouse_attr_set_resolution); 89 PSMOUSE_DEFINE_ATTR(resetafter, S_IWUSR | S_IRUGO, 90 (void *) offsetof(struct psmouse, resetafter), 91 psmouse_show_int_attr, psmouse_set_int_attr); 92 PSMOUSE_DEFINE_ATTR(resync_time, S_IWUSR | S_IRUGO, 93 (void *) offsetof(struct psmouse, resync_time), 94 psmouse_show_int_attr, psmouse_set_int_attr); 95 96 static struct attribute *psmouse_dev_attrs[] = { 97 &psmouse_attr_protocol.dattr.attr, 98 &psmouse_attr_rate.dattr.attr, 99 &psmouse_attr_resolution.dattr.attr, 100 &psmouse_attr_resetafter.dattr.attr, 101 &psmouse_attr_resync_time.dattr.attr, 102 NULL 103 }; 104 105 ATTRIBUTE_GROUPS(psmouse_dev); 106 107 /* 108 * psmouse_mutex protects all operations changing state of mouse 109 * (connecting, disconnecting, changing rate or resolution via 110 * sysfs). We could use a per-device semaphore but since there 111 * rarely more than one PS/2 mouse connected and since semaphore 112 * is taken in "slow" paths it is not worth it. 113 */ 114 static DEFINE_MUTEX(psmouse_mutex); 115 116 struct psmouse *psmouse_from_serio(struct serio *serio) 117 { 118 struct ps2dev *ps2dev = serio_get_drvdata(serio); 119 120 return container_of(ps2dev, struct psmouse, ps2dev); 121 } 122 123 void psmouse_report_standard_buttons(struct input_dev *dev, u8 buttons) 124 { 125 input_report_key(dev, BTN_LEFT, buttons & BIT(0)); 126 input_report_key(dev, BTN_MIDDLE, buttons & BIT(2)); 127 input_report_key(dev, BTN_RIGHT, buttons & BIT(1)); 128 } 129 130 void psmouse_report_standard_motion(struct input_dev *dev, u8 *packet) 131 { 132 int x, y; 133 134 x = packet[1] ? packet[1] - ((packet[0] << 4) & 0x100) : 0; 135 y = packet[2] ? packet[2] - ((packet[0] << 3) & 0x100) : 0; 136 137 input_report_rel(dev, REL_X, x); 138 input_report_rel(dev, REL_Y, -y); 139 } 140 141 void psmouse_report_standard_packet(struct input_dev *dev, u8 *packet) 142 { 143 psmouse_report_standard_buttons(dev, packet[0]); 144 psmouse_report_standard_motion(dev, packet); 145 } 146 147 /* 148 * psmouse_process_byte() analyzes the PS/2 data stream and reports 149 * relevant events to the input module once full packet has arrived. 150 */ 151 psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse) 152 { 153 struct input_dev *dev = psmouse->dev; 154 u8 *packet = psmouse->packet; 155 int wheel; 156 157 if (psmouse->pktcnt < psmouse->pktsize) 158 return PSMOUSE_GOOD_DATA; 159 160 /* Full packet accumulated, process it */ 161 162 switch (psmouse->protocol->type) { 163 case PSMOUSE_IMPS: 164 /* IntelliMouse has scroll wheel */ 165 input_report_rel(dev, REL_WHEEL, -(s8) packet[3]); 166 break; 167 168 case PSMOUSE_IMEX: 169 /* Scroll wheel and buttons on IntelliMouse Explorer */ 170 switch (packet[3] & 0xC0) { 171 case 0x80: /* vertical scroll on IntelliMouse Explorer 4.0 */ 172 input_report_rel(dev, REL_WHEEL, 173 -sign_extend32(packet[3], 5)); 174 break; 175 case 0x40: /* horizontal scroll on IntelliMouse Explorer 4.0 */ 176 input_report_rel(dev, REL_HWHEEL, 177 -sign_extend32(packet[3], 5)); 178 break; 179 case 0x00: 180 case 0xC0: 181 wheel = sign_extend32(packet[3], 3); 182 183 /* 184 * Some A4Tech mice have two scroll wheels, with first 185 * one reporting +/-1 in the lower nibble, and second 186 * one reporting +/-2. 187 */ 188 if (psmouse_a4tech_2wheels && abs(wheel) > 1) 189 input_report_rel(dev, REL_HWHEEL, wheel / 2); 190 else 191 input_report_rel(dev, REL_WHEEL, -wheel); 192 193 input_report_key(dev, BTN_SIDE, packet[3] & BIT(4)); 194 input_report_key(dev, BTN_EXTRA, packet[3] & BIT(5)); 195 break; 196 } 197 break; 198 199 case PSMOUSE_GENPS: 200 /* Report scroll buttons on NetMice */ 201 input_report_rel(dev, REL_WHEEL, -(s8) packet[3]); 202 203 /* Extra buttons on Genius NewNet 3D */ 204 input_report_key(dev, BTN_SIDE, packet[0] & BIT(6)); 205 input_report_key(dev, BTN_EXTRA, packet[0] & BIT(7)); 206 break; 207 208 case PSMOUSE_THINKPS: 209 /* Extra button on ThinkingMouse */ 210 input_report_key(dev, BTN_EXTRA, packet[0] & BIT(3)); 211 212 /* 213 * Without this bit of weirdness moving up gives wildly 214 * high Y changes. 215 */ 216 packet[1] |= (packet[0] & 0x40) << 1; 217 break; 218 219 case PSMOUSE_CORTRON: 220 /* 221 * Cortron PS2 Trackball reports SIDE button in the 222 * 4th bit of the first byte. 223 */ 224 input_report_key(dev, BTN_SIDE, packet[0] & BIT(3)); 225 packet[0] |= BIT(3); 226 break; 227 228 default: 229 break; 230 } 231 232 /* Generic PS/2 Mouse */ 233 packet[0] |= psmouse->extra_buttons; 234 psmouse_report_standard_packet(dev, packet); 235 236 input_sync(dev); 237 238 return PSMOUSE_FULL_PACKET; 239 } 240 241 /* 242 * __psmouse_set_state() sets new psmouse state and resets all flags. 243 */ 244 static inline void __psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state) 245 { 246 psmouse->state = new_state; 247 psmouse->pktcnt = psmouse->out_of_sync_cnt = 0; 248 psmouse->ps2dev.flags = 0; 249 psmouse->last = jiffies; 250 } 251 252 /* 253 * psmouse_set_state() sets new psmouse state and resets all flags and 254 * counters while holding serio lock so fighting with interrupt handler 255 * is not a concern. 256 */ 257 void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state) 258 { 259 serio_pause_rx(psmouse->ps2dev.serio); 260 __psmouse_set_state(psmouse, new_state); 261 serio_continue_rx(psmouse->ps2dev.serio); 262 } 263 264 /* 265 * psmouse_handle_byte() processes one byte of the input data stream 266 * by calling corresponding protocol handler. 267 */ 268 static int psmouse_handle_byte(struct psmouse *psmouse) 269 { 270 psmouse_ret_t rc = psmouse->protocol_handler(psmouse); 271 272 switch (rc) { 273 case PSMOUSE_BAD_DATA: 274 if (psmouse->state == PSMOUSE_ACTIVATED) { 275 psmouse_warn(psmouse, 276 "%s at %s lost sync at byte %d\n", 277 psmouse->name, psmouse->phys, 278 psmouse->pktcnt); 279 if (++psmouse->out_of_sync_cnt == psmouse->resetafter) { 280 __psmouse_set_state(psmouse, PSMOUSE_IGNORE); 281 psmouse_notice(psmouse, 282 "issuing reconnect request\n"); 283 serio_reconnect(psmouse->ps2dev.serio); 284 return -EIO; 285 } 286 } 287 psmouse->pktcnt = 0; 288 break; 289 290 case PSMOUSE_FULL_PACKET: 291 psmouse->pktcnt = 0; 292 if (psmouse->out_of_sync_cnt) { 293 psmouse->out_of_sync_cnt = 0; 294 psmouse_notice(psmouse, 295 "%s at %s - driver resynced.\n", 296 psmouse->name, psmouse->phys); 297 } 298 break; 299 300 case PSMOUSE_GOOD_DATA: 301 break; 302 } 303 return 0; 304 } 305 306 static void psmouse_handle_oob_data(struct psmouse *psmouse, u8 data) 307 { 308 switch (psmouse->oob_data_type) { 309 case PSMOUSE_OOB_NONE: 310 psmouse->oob_data_type = data; 311 break; 312 313 case PSMOUSE_OOB_EXTRA_BTNS: 314 psmouse_report_standard_buttons(psmouse->dev, data); 315 input_sync(psmouse->dev); 316 317 psmouse->extra_buttons = data; 318 psmouse->oob_data_type = PSMOUSE_OOB_NONE; 319 break; 320 321 default: 322 psmouse_warn(psmouse, 323 "unknown OOB_DATA type: 0x%02x\n", 324 psmouse->oob_data_type); 325 psmouse->oob_data_type = PSMOUSE_OOB_NONE; 326 break; 327 } 328 } 329 330 static enum ps2_disposition psmouse_pre_receive_byte(struct ps2dev *ps2dev, 331 u8 data, 332 unsigned int flags) 333 { 334 struct psmouse *psmouse = container_of(ps2dev, struct psmouse, ps2dev); 335 336 if (psmouse->state == PSMOUSE_IGNORE) 337 return PS2_IGNORE; 338 339 if (unlikely((flags & SERIO_TIMEOUT) || 340 ((flags & SERIO_PARITY) && 341 !psmouse->protocol->ignore_parity))) { 342 343 if (psmouse->state == PSMOUSE_ACTIVATED) 344 psmouse_warn(psmouse, 345 "bad data from KBC -%s%s\n", 346 flags & SERIO_TIMEOUT ? " timeout" : "", 347 flags & SERIO_PARITY ? " bad parity" : ""); 348 return PS2_ERROR; 349 } 350 351 if (flags & SERIO_OOB_DATA) { 352 psmouse_handle_oob_data(psmouse, data); 353 return PS2_IGNORE; 354 } 355 356 return PS2_PROCESS; 357 } 358 359 static void psmouse_receive_byte(struct ps2dev *ps2dev, u8 data) 360 { 361 struct psmouse *psmouse = container_of(ps2dev, struct psmouse, ps2dev); 362 363 pm_wakeup_event(&ps2dev->serio->dev, 0); 364 365 if (psmouse->state <= PSMOUSE_RESYNCING) 366 return; 367 368 if (psmouse->state == PSMOUSE_ACTIVATED && 369 psmouse->pktcnt && time_after(jiffies, psmouse->last + HZ/2)) { 370 psmouse_info(psmouse, "%s at %s lost synchronization, throwing %d bytes away.\n", 371 psmouse->name, psmouse->phys, psmouse->pktcnt); 372 psmouse->badbyte = psmouse->packet[0]; 373 __psmouse_set_state(psmouse, PSMOUSE_RESYNCING); 374 schedule_work(&psmouse->resync_work); 375 return; 376 } 377 378 psmouse->packet[psmouse->pktcnt++] = data; 379 380 /* Check if this is a new device announcement (0xAA 0x00) */ 381 if (unlikely(psmouse->packet[0] == PSMOUSE_RET_BAT && psmouse->pktcnt <= 2)) { 382 if (psmouse->pktcnt == 1) { 383 psmouse->last = jiffies; 384 return; 385 } 386 387 if (psmouse->packet[1] == PSMOUSE_RET_ID) { 388 __psmouse_set_state(psmouse, PSMOUSE_IGNORE); 389 serio_reconnect(ps2dev->serio); 390 return; 391 } 392 393 /* Not a new device, try processing first byte normally */ 394 psmouse->pktcnt = 1; 395 if (psmouse_handle_byte(psmouse)) 396 return; 397 398 psmouse->packet[psmouse->pktcnt++] = data; 399 } 400 401 /* 402 * See if we need to force resync because mouse was idle for 403 * too long. 404 */ 405 if (psmouse->state == PSMOUSE_ACTIVATED && 406 psmouse->pktcnt == 1 && psmouse->resync_time && 407 time_after(jiffies, psmouse->last + psmouse->resync_time * HZ)) { 408 psmouse->badbyte = psmouse->packet[0]; 409 __psmouse_set_state(psmouse, PSMOUSE_RESYNCING); 410 schedule_work(&psmouse->resync_work); 411 return; 412 } 413 414 psmouse->last = jiffies; 415 psmouse_handle_byte(psmouse); 416 } 417 418 /* 419 * psmouse_reset() resets the mouse into power-on state. 420 */ 421 int psmouse_reset(struct psmouse *psmouse) 422 { 423 u8 param[2]; 424 int error; 425 426 error = ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_RESET_BAT); 427 if (error) 428 return error; 429 430 if (param[0] != PSMOUSE_RET_BAT && param[1] != PSMOUSE_RET_ID) 431 return -EIO; 432 433 return 0; 434 } 435 436 /* 437 * Here we set the mouse resolution. 438 */ 439 void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution) 440 { 441 static const u8 params[] = { 0, 1, 2, 2, 3 }; 442 u8 p; 443 444 if (resolution == 0 || resolution > 200) 445 resolution = 200; 446 447 p = params[resolution / 50]; 448 ps2_command(&psmouse->ps2dev, &p, PSMOUSE_CMD_SETRES); 449 psmouse->resolution = 25 << p; 450 } 451 452 /* 453 * Here we set the mouse report rate. 454 */ 455 static void psmouse_set_rate(struct psmouse *psmouse, unsigned int rate) 456 { 457 static const u8 rates[] = { 200, 100, 80, 60, 40, 20, 10, 0 }; 458 u8 r; 459 int i = 0; 460 461 while (rates[i] > rate) 462 i++; 463 r = rates[i]; 464 ps2_command(&psmouse->ps2dev, &r, PSMOUSE_CMD_SETRATE); 465 psmouse->rate = r; 466 } 467 468 /* 469 * Here we set the mouse scaling. 470 */ 471 static void psmouse_set_scale(struct psmouse *psmouse, enum psmouse_scale scale) 472 { 473 ps2_command(&psmouse->ps2dev, NULL, 474 scale == PSMOUSE_SCALE21 ? PSMOUSE_CMD_SETSCALE21 : 475 PSMOUSE_CMD_SETSCALE11); 476 } 477 478 /* 479 * psmouse_poll() - default poll handler. Everyone except for ALPS uses it. 480 */ 481 static int psmouse_poll(struct psmouse *psmouse) 482 { 483 return ps2_command(&psmouse->ps2dev, psmouse->packet, 484 PSMOUSE_CMD_POLL | (psmouse->pktsize << 8)); 485 } 486 487 static bool psmouse_check_pnp_id(const char *id, const char * const ids[]) 488 { 489 int i; 490 491 for (i = 0; ids[i]; i++) 492 if (!strcasecmp(id, ids[i])) 493 return true; 494 495 return false; 496 } 497 498 /* 499 * psmouse_matches_pnp_id - check if psmouse matches one of the passed in ids. 500 */ 501 bool psmouse_matches_pnp_id(struct psmouse *psmouse, const char * const ids[]) 502 { 503 struct serio *serio = psmouse->ps2dev.serio; 504 char *p, *fw_id_copy, *save_ptr; 505 bool found = false; 506 507 if (strncmp(serio->firmware_id, "PNP: ", 5)) 508 return false; 509 510 fw_id_copy = kstrndup(&serio->firmware_id[5], 511 sizeof(serio->firmware_id) - 5, 512 GFP_KERNEL); 513 if (!fw_id_copy) 514 return false; 515 516 save_ptr = fw_id_copy; 517 while ((p = strsep(&fw_id_copy, " ")) != NULL) { 518 if (psmouse_check_pnp_id(p, ids)) { 519 found = true; 520 break; 521 } 522 } 523 524 kfree(save_ptr); 525 return found; 526 } 527 528 /* 529 * Genius NetMouse magic init. 530 */ 531 static int genius_detect(struct psmouse *psmouse, bool set_properties) 532 { 533 struct ps2dev *ps2dev = &psmouse->ps2dev; 534 u8 param[4]; 535 536 param[0] = 3; 537 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES); 538 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11); 539 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11); 540 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11); 541 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO); 542 543 if (param[0] != 0x00 || param[1] != 0x33 || param[2] != 0x55) 544 return -ENODEV; 545 546 if (set_properties) { 547 __set_bit(BTN_MIDDLE, psmouse->dev->keybit); 548 __set_bit(BTN_EXTRA, psmouse->dev->keybit); 549 __set_bit(BTN_SIDE, psmouse->dev->keybit); 550 __set_bit(REL_WHEEL, psmouse->dev->relbit); 551 552 psmouse->vendor = "Genius"; 553 psmouse->name = "Mouse"; 554 psmouse->pktsize = 4; 555 } 556 557 return 0; 558 } 559 560 /* 561 * IntelliMouse magic init. 562 */ 563 static int intellimouse_detect(struct psmouse *psmouse, bool set_properties) 564 { 565 struct ps2dev *ps2dev = &psmouse->ps2dev; 566 u8 param[2]; 567 568 param[0] = 200; 569 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 570 param[0] = 100; 571 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 572 param[0] = 80; 573 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 574 ps2_command(ps2dev, param, PSMOUSE_CMD_GETID); 575 576 if (param[0] != 3) 577 return -ENODEV; 578 579 if (set_properties) { 580 __set_bit(BTN_MIDDLE, psmouse->dev->keybit); 581 __set_bit(REL_WHEEL, psmouse->dev->relbit); 582 583 if (!psmouse->vendor) 584 psmouse->vendor = "Generic"; 585 if (!psmouse->name) 586 psmouse->name = "Wheel Mouse"; 587 psmouse->pktsize = 4; 588 } 589 590 return 0; 591 } 592 593 /* 594 * Try IntelliMouse/Explorer magic init. 595 */ 596 static int im_explorer_detect(struct psmouse *psmouse, bool set_properties) 597 { 598 struct ps2dev *ps2dev = &psmouse->ps2dev; 599 u8 param[2]; 600 601 intellimouse_detect(psmouse, 0); 602 603 param[0] = 200; 604 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 605 param[0] = 200; 606 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 607 param[0] = 80; 608 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 609 ps2_command(ps2dev, param, PSMOUSE_CMD_GETID); 610 611 if (param[0] != 4) 612 return -ENODEV; 613 614 /* Magic to enable horizontal scrolling on IntelliMouse 4.0 */ 615 param[0] = 200; 616 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 617 param[0] = 80; 618 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 619 param[0] = 40; 620 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 621 622 if (set_properties) { 623 __set_bit(BTN_MIDDLE, psmouse->dev->keybit); 624 __set_bit(REL_WHEEL, psmouse->dev->relbit); 625 __set_bit(REL_HWHEEL, psmouse->dev->relbit); 626 __set_bit(BTN_SIDE, psmouse->dev->keybit); 627 __set_bit(BTN_EXTRA, psmouse->dev->keybit); 628 629 if (!psmouse->vendor) 630 psmouse->vendor = "Generic"; 631 if (!psmouse->name) 632 psmouse->name = "Explorer Mouse"; 633 psmouse->pktsize = 4; 634 } 635 636 return 0; 637 } 638 639 /* 640 * Kensington ThinkingMouse / ExpertMouse magic init. 641 */ 642 static int thinking_detect(struct psmouse *psmouse, bool set_properties) 643 { 644 struct ps2dev *ps2dev = &psmouse->ps2dev; 645 u8 param[2]; 646 static const u8 seq[] = { 20, 60, 40, 20, 20, 60, 40, 20, 20 }; 647 int i; 648 649 param[0] = 10; 650 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 651 param[0] = 0; 652 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES); 653 for (i = 0; i < ARRAY_SIZE(seq); i++) { 654 param[0] = seq[i]; 655 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE); 656 } 657 ps2_command(ps2dev, param, PSMOUSE_CMD_GETID); 658 659 if (param[0] != 2) 660 return -ENODEV; 661 662 if (set_properties) { 663 __set_bit(BTN_MIDDLE, psmouse->dev->keybit); 664 __set_bit(BTN_EXTRA, psmouse->dev->keybit); 665 666 psmouse->vendor = "Kensington"; 667 psmouse->name = "ThinkingMouse"; 668 } 669 670 return 0; 671 } 672 673 /* 674 * Bare PS/2 protocol "detection". Always succeeds. 675 */ 676 static int ps2bare_detect(struct psmouse *psmouse, bool set_properties) 677 { 678 if (set_properties) { 679 if (!psmouse->vendor) 680 psmouse->vendor = "Generic"; 681 if (!psmouse->name) 682 psmouse->name = "Mouse"; 683 684 /* 685 * We have no way of figuring true number of buttons so let's 686 * assume that the device has 3. 687 */ 688 input_set_capability(psmouse->dev, EV_KEY, BTN_MIDDLE); 689 } 690 691 return 0; 692 } 693 694 /* 695 * Cortron PS/2 protocol detection. There's no special way to detect it, so it 696 * must be forced by sysfs protocol writing. 697 */ 698 static int cortron_detect(struct psmouse *psmouse, bool set_properties) 699 { 700 if (set_properties) { 701 psmouse->vendor = "Cortron"; 702 psmouse->name = "PS/2 Trackball"; 703 704 __set_bit(BTN_MIDDLE, psmouse->dev->keybit); 705 __set_bit(BTN_SIDE, psmouse->dev->keybit); 706 } 707 708 return 0; 709 } 710 711 static const struct psmouse_protocol psmouse_protocols[] = { 712 { 713 .type = PSMOUSE_PS2, 714 .name = "PS/2", 715 .alias = "bare", 716 .maxproto = true, 717 .ignore_parity = true, 718 .detect = ps2bare_detect, 719 .try_passthru = true, 720 }, 721 #ifdef CONFIG_MOUSE_PS2_LOGIPS2PP 722 { 723 .type = PSMOUSE_PS2PP, 724 .name = "PS2++", 725 .alias = "logitech", 726 .detect = ps2pp_detect, 727 }, 728 #endif 729 { 730 .type = PSMOUSE_THINKPS, 731 .name = "ThinkPS/2", 732 .alias = "thinkps", 733 .detect = thinking_detect, 734 }, 735 #ifdef CONFIG_MOUSE_PS2_CYPRESS 736 { 737 .type = PSMOUSE_CYPRESS, 738 .name = "CyPS/2", 739 .alias = "cypress", 740 .detect = cypress_detect, 741 .init = cypress_init, 742 }, 743 #endif 744 { 745 .type = PSMOUSE_GENPS, 746 .name = "GenPS/2", 747 .alias = "genius", 748 .detect = genius_detect, 749 }, 750 { 751 .type = PSMOUSE_IMPS, 752 .name = "ImPS/2", 753 .alias = "imps", 754 .maxproto = true, 755 .ignore_parity = true, 756 .detect = intellimouse_detect, 757 .try_passthru = true, 758 }, 759 { 760 .type = PSMOUSE_IMEX, 761 .name = "ImExPS/2", 762 .alias = "exps", 763 .maxproto = true, 764 .ignore_parity = true, 765 .detect = im_explorer_detect, 766 .try_passthru = true, 767 }, 768 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS 769 { 770 .type = PSMOUSE_SYNAPTICS, 771 .name = "SynPS/2", 772 .alias = "synaptics", 773 .detect = synaptics_detect, 774 .init = synaptics_init_absolute, 775 }, 776 { 777 .type = PSMOUSE_SYNAPTICS_RELATIVE, 778 .name = "SynRelPS/2", 779 .alias = "synaptics-relative", 780 .detect = synaptics_detect, 781 .init = synaptics_init_relative, 782 }, 783 #endif 784 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS 785 { 786 .type = PSMOUSE_SYNAPTICS_SMBUS, 787 .name = "SynSMBus", 788 .alias = "synaptics-smbus", 789 .detect = synaptics_detect, 790 .init = synaptics_init_smbus, 791 .smbus_companion = true, 792 }, 793 #endif 794 #ifdef CONFIG_MOUSE_PS2_ALPS 795 { 796 .type = PSMOUSE_ALPS, 797 .name = "AlpsPS/2", 798 .alias = "alps", 799 .detect = alps_detect, 800 .init = alps_init, 801 }, 802 #endif 803 #ifdef CONFIG_MOUSE_PS2_LIFEBOOK 804 { 805 .type = PSMOUSE_LIFEBOOK, 806 .name = "LBPS/2", 807 .alias = "lifebook", 808 .detect = lifebook_detect, 809 .init = lifebook_init, 810 }, 811 #endif 812 #ifdef CONFIG_MOUSE_PS2_TRACKPOINT 813 { 814 .type = PSMOUSE_TRACKPOINT, 815 .name = "TPPS/2", 816 .alias = "trackpoint", 817 .detect = trackpoint_detect, 818 .try_passthru = true, 819 }, 820 #endif 821 #ifdef CONFIG_MOUSE_PS2_TOUCHKIT 822 { 823 .type = PSMOUSE_TOUCHKIT_PS2, 824 .name = "touchkitPS/2", 825 .alias = "touchkit", 826 .detect = touchkit_ps2_detect, 827 }, 828 #endif 829 #ifdef CONFIG_MOUSE_PS2_ELANTECH 830 { 831 .type = PSMOUSE_ELANTECH, 832 .name = "ETPS/2", 833 .alias = "elantech", 834 .detect = elantech_detect, 835 .init = elantech_init_ps2, 836 }, 837 #endif 838 #ifdef CONFIG_MOUSE_PS2_ELANTECH_SMBUS 839 { 840 .type = PSMOUSE_ELANTECH_SMBUS, 841 .name = "ETSMBus", 842 .alias = "elantech-smbus", 843 .detect = elantech_detect, 844 .init = elantech_init_smbus, 845 .smbus_companion = true, 846 }, 847 #endif 848 #ifdef CONFIG_MOUSE_PS2_SENTELIC 849 { 850 .type = PSMOUSE_FSP, 851 .name = "FSPPS/2", 852 .alias = "fsp", 853 .detect = fsp_detect, 854 .init = fsp_init, 855 }, 856 #endif 857 { 858 .type = PSMOUSE_CORTRON, 859 .name = "CortronPS/2", 860 .alias = "cortps", 861 .detect = cortron_detect, 862 }, 863 #ifdef CONFIG_MOUSE_PS2_FOCALTECH 864 { 865 .type = PSMOUSE_FOCALTECH, 866 .name = "FocalTechPS/2", 867 .alias = "focaltech", 868 .detect = focaltech_detect, 869 .init = focaltech_init, 870 }, 871 #endif 872 #ifdef CONFIG_MOUSE_PS2_VMMOUSE 873 { 874 .type = PSMOUSE_VMMOUSE, 875 .name = VMMOUSE_PSNAME, 876 .alias = "vmmouse", 877 .detect = vmmouse_detect, 878 .init = vmmouse_init, 879 }, 880 #endif 881 #ifdef CONFIG_MOUSE_PS2_BYD 882 { 883 .type = PSMOUSE_BYD, 884 .name = "BYDPS/2", 885 .alias = "byd", 886 .detect = byd_detect, 887 .init = byd_init, 888 }, 889 #endif 890 { 891 .type = PSMOUSE_AUTO, 892 .name = "auto", 893 .alias = "any", 894 .maxproto = true, 895 }, 896 }; 897 898 static const struct psmouse_protocol *__psmouse_protocol_by_type(enum psmouse_type type) 899 { 900 int i; 901 902 for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++) 903 if (psmouse_protocols[i].type == type) 904 return &psmouse_protocols[i]; 905 906 return NULL; 907 } 908 909 static const struct psmouse_protocol *psmouse_protocol_by_type(enum psmouse_type type) 910 { 911 const struct psmouse_protocol *proto; 912 913 proto = __psmouse_protocol_by_type(type); 914 if (proto) 915 return proto; 916 917 WARN_ON(1); 918 return &psmouse_protocols[0]; 919 } 920 921 static const struct psmouse_protocol *psmouse_protocol_by_name(const char *name, size_t len) 922 { 923 const struct psmouse_protocol *p; 924 int i; 925 926 for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++) { 927 p = &psmouse_protocols[i]; 928 929 if ((strlen(p->name) == len && !strncmp(p->name, name, len)) || 930 (strlen(p->alias) == len && !strncmp(p->alias, name, len))) 931 return &psmouse_protocols[i]; 932 } 933 934 return NULL; 935 } 936 937 /* 938 * Apply default settings to the psmouse structure. Most of them will 939 * be overridden by individual protocol initialization routines. 940 */ 941 static void psmouse_apply_defaults(struct psmouse *psmouse) 942 { 943 struct input_dev *input_dev = psmouse->dev; 944 945 bitmap_zero(input_dev->evbit, EV_CNT); 946 bitmap_zero(input_dev->keybit, KEY_CNT); 947 bitmap_zero(input_dev->relbit, REL_CNT); 948 bitmap_zero(input_dev->absbit, ABS_CNT); 949 bitmap_zero(input_dev->mscbit, MSC_CNT); 950 951 input_set_capability(input_dev, EV_KEY, BTN_LEFT); 952 input_set_capability(input_dev, EV_KEY, BTN_RIGHT); 953 954 input_set_capability(input_dev, EV_REL, REL_X); 955 input_set_capability(input_dev, EV_REL, REL_Y); 956 957 __set_bit(INPUT_PROP_POINTER, input_dev->propbit); 958 959 psmouse->protocol = &psmouse_protocols[0]; 960 961 psmouse->set_rate = psmouse_set_rate; 962 psmouse->set_resolution = psmouse_set_resolution; 963 psmouse->set_scale = psmouse_set_scale; 964 psmouse->poll = psmouse_poll; 965 psmouse->protocol_handler = psmouse_process_byte; 966 psmouse->pktsize = 3; 967 psmouse->reconnect = NULL; 968 psmouse->fast_reconnect = NULL; 969 psmouse->disconnect = NULL; 970 psmouse->cleanup = NULL; 971 psmouse->pt_activate = NULL; 972 psmouse->pt_deactivate = NULL; 973 } 974 975 static bool psmouse_do_detect(int (*detect)(struct psmouse *, bool), 976 struct psmouse *psmouse, bool allow_passthrough, 977 bool set_properties) 978 { 979 if (psmouse->ps2dev.serio->id.type == SERIO_PS_PSTHRU && 980 !allow_passthrough) { 981 return false; 982 } 983 984 if (set_properties) 985 psmouse_apply_defaults(psmouse); 986 987 return detect(psmouse, set_properties) == 0; 988 } 989 990 static bool psmouse_try_protocol(struct psmouse *psmouse, 991 enum psmouse_type type, 992 unsigned int *max_proto, 993 bool set_properties, bool init_allowed) 994 { 995 const struct psmouse_protocol *proto; 996 997 proto = __psmouse_protocol_by_type(type); 998 if (!proto) 999 return false; 1000 1001 if (!psmouse_do_detect(proto->detect, psmouse, proto->try_passthru, 1002 set_properties)) 1003 return false; 1004 1005 if (set_properties && proto->init && init_allowed) { 1006 if (proto->init(psmouse) != 0) { 1007 /* 1008 * We detected device, but init failed. Adjust 1009 * max_proto so we only try standard protocols. 1010 */ 1011 if (*max_proto > PSMOUSE_IMEX) 1012 *max_proto = PSMOUSE_IMEX; 1013 1014 return false; 1015 } 1016 } 1017 1018 return true; 1019 } 1020 1021 /* 1022 * psmouse_extensions() probes for any extensions to the basic PS/2 protocol 1023 * the mouse may have. 1024 */ 1025 static int psmouse_extensions(struct psmouse *psmouse, 1026 unsigned int max_proto, bool set_properties) 1027 { 1028 bool synaptics_hardware = false; 1029 int ret; 1030 1031 /* 1032 * Always check for focaltech, this is safe as it uses pnp-id 1033 * matching. 1034 */ 1035 if (psmouse_do_detect(focaltech_detect, 1036 psmouse, false, set_properties)) { 1037 if (max_proto > PSMOUSE_IMEX && 1038 IS_ENABLED(CONFIG_MOUSE_PS2_FOCALTECH) && 1039 (!set_properties || focaltech_init(psmouse) == 0)) { 1040 return PSMOUSE_FOCALTECH; 1041 } 1042 /* 1043 * Restrict psmouse_max_proto so that psmouse_initialize() 1044 * does not try to reset rate and resolution, because even 1045 * that upsets the device. 1046 * This also causes us to basically fall through to basic 1047 * protocol detection, where we fully reset the mouse, 1048 * and set it up as bare PS/2 protocol device. 1049 */ 1050 psmouse_max_proto = max_proto = PSMOUSE_PS2; 1051 } 1052 1053 /* 1054 * We always check for LifeBook because it does not disturb mouse 1055 * (it only checks DMI information). 1056 */ 1057 if (psmouse_try_protocol(psmouse, PSMOUSE_LIFEBOOK, &max_proto, 1058 set_properties, max_proto > PSMOUSE_IMEX)) 1059 return PSMOUSE_LIFEBOOK; 1060 1061 if (psmouse_try_protocol(psmouse, PSMOUSE_VMMOUSE, &max_proto, 1062 set_properties, max_proto > PSMOUSE_IMEX)) 1063 return PSMOUSE_VMMOUSE; 1064 1065 /* 1066 * Try Kensington ThinkingMouse (we try first, because Synaptics 1067 * probe upsets the ThinkingMouse). 1068 */ 1069 if (max_proto > PSMOUSE_IMEX && 1070 psmouse_try_protocol(psmouse, PSMOUSE_THINKPS, &max_proto, 1071 set_properties, true)) { 1072 return PSMOUSE_THINKPS; 1073 } 1074 1075 /* 1076 * Try Synaptics TouchPad. Note that probing is done even if 1077 * Synaptics protocol support is disabled in config - we need to 1078 * know if it is Synaptics so we can reset it properly after 1079 * probing for IntelliMouse. 1080 */ 1081 if (max_proto > PSMOUSE_PS2 && 1082 psmouse_do_detect(synaptics_detect, 1083 psmouse, false, set_properties)) { 1084 synaptics_hardware = true; 1085 1086 if (max_proto > PSMOUSE_IMEX) { 1087 /* 1088 * Try activating protocol, but check if support is 1089 * enabled first, since we try detecting Synaptics 1090 * even when protocol is disabled. 1091 */ 1092 if (IS_ENABLED(CONFIG_MOUSE_PS2_SYNAPTICS) || 1093 IS_ENABLED(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS)) { 1094 if (!set_properties) 1095 return PSMOUSE_SYNAPTICS; 1096 1097 ret = synaptics_init(psmouse); 1098 if (ret >= 0) 1099 return ret; 1100 } 1101 1102 /* 1103 * Some Synaptics touchpads can emulate extended 1104 * protocols (like IMPS/2). Unfortunately 1105 * Logitech/Genius probes confuse some firmware 1106 * versions so we'll have to skip them. 1107 */ 1108 max_proto = PSMOUSE_IMEX; 1109 } 1110 1111 /* 1112 * Make sure that touchpad is in relative mode, gestures 1113 * (taps) are enabled. 1114 */ 1115 synaptics_reset(psmouse); 1116 } 1117 1118 /* 1119 * Try Cypress Trackpad. We must try it before Finger Sensing Pad 1120 * because Finger Sensing Pad probe upsets some modules of Cypress 1121 * Trackpads. 1122 */ 1123 if (max_proto > PSMOUSE_IMEX && 1124 psmouse_try_protocol(psmouse, PSMOUSE_CYPRESS, &max_proto, 1125 set_properties, true)) { 1126 return PSMOUSE_CYPRESS; 1127 } 1128 1129 /* Try ALPS TouchPad */ 1130 if (max_proto > PSMOUSE_IMEX) { 1131 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS); 1132 if (psmouse_try_protocol(psmouse, PSMOUSE_ALPS, 1133 &max_proto, set_properties, true)) 1134 return PSMOUSE_ALPS; 1135 } 1136 1137 /* Try Elantech touchpad */ 1138 if (max_proto > PSMOUSE_IMEX && 1139 psmouse_try_protocol(psmouse, PSMOUSE_ELANTECH, 1140 &max_proto, set_properties, false)) { 1141 if (!set_properties) 1142 return PSMOUSE_ELANTECH; 1143 1144 ret = elantech_init(psmouse); 1145 if (ret >= 0) 1146 return ret; 1147 } 1148 1149 if (max_proto > PSMOUSE_IMEX) { 1150 if (psmouse_try_protocol(psmouse, PSMOUSE_GENPS, 1151 &max_proto, set_properties, true)) 1152 return PSMOUSE_GENPS; 1153 1154 if (psmouse_try_protocol(psmouse, PSMOUSE_PS2PP, 1155 &max_proto, set_properties, true)) 1156 return PSMOUSE_PS2PP; 1157 1158 if (psmouse_try_protocol(psmouse, PSMOUSE_TRACKPOINT, 1159 &max_proto, set_properties, true)) 1160 return PSMOUSE_TRACKPOINT; 1161 1162 if (psmouse_try_protocol(psmouse, PSMOUSE_TOUCHKIT_PS2, 1163 &max_proto, set_properties, true)) 1164 return PSMOUSE_TOUCHKIT_PS2; 1165 } 1166 1167 /* 1168 * Try Finger Sensing Pad. We do it here because its probe upsets 1169 * Trackpoint devices (causing TP_READ_ID command to time out). 1170 */ 1171 if (max_proto > PSMOUSE_IMEX && 1172 psmouse_try_protocol(psmouse, PSMOUSE_FSP, 1173 &max_proto, set_properties, true)) { 1174 return PSMOUSE_FSP; 1175 } 1176 1177 /* 1178 * Reset to defaults in case the device got confused by extended 1179 * protocol probes. Note that we follow up with full reset because 1180 * some mice put themselves to sleep when they see PSMOUSE_RESET_DIS. 1181 */ 1182 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS); 1183 psmouse_reset(psmouse); 1184 1185 if (max_proto >= PSMOUSE_IMEX && 1186 psmouse_try_protocol(psmouse, PSMOUSE_IMEX, 1187 &max_proto, set_properties, true)) { 1188 return PSMOUSE_IMEX; 1189 } 1190 1191 if (max_proto >= PSMOUSE_IMPS && 1192 psmouse_try_protocol(psmouse, PSMOUSE_IMPS, 1193 &max_proto, set_properties, true)) { 1194 return PSMOUSE_IMPS; 1195 } 1196 1197 /* 1198 * Okay, all failed, we have a standard mouse here. The number of 1199 * the buttons is still a question, though. We assume 3. 1200 */ 1201 psmouse_try_protocol(psmouse, PSMOUSE_PS2, 1202 &max_proto, set_properties, true); 1203 1204 if (synaptics_hardware) { 1205 /* 1206 * We detected Synaptics hardware but it did not respond to 1207 * IMPS/2 probes. We need to reset the touchpad because if 1208 * there is a track point on the pass through port it could 1209 * get disabled while probing for protocol extensions. 1210 */ 1211 psmouse_reset(psmouse); 1212 } 1213 1214 return PSMOUSE_PS2; 1215 } 1216 1217 /* 1218 * psmouse_probe() probes for a PS/2 mouse. 1219 */ 1220 static int psmouse_probe(struct psmouse *psmouse) 1221 { 1222 struct ps2dev *ps2dev = &psmouse->ps2dev; 1223 u8 param[2]; 1224 int error; 1225 1226 /* 1227 * First, we check if it's a mouse. It should send 0x00 or 0x03 in 1228 * case of an IntelliMouse in 4-byte mode or 0x04 for IM Explorer. 1229 * Sunrex K8561 IR Keyboard/Mouse reports 0xff on second and 1230 * subsequent ID queries, probably due to a firmware bug. 1231 */ 1232 param[0] = 0xa5; 1233 error = ps2_command(ps2dev, param, PSMOUSE_CMD_GETID); 1234 if (error) 1235 return error; 1236 1237 if (param[0] != 0x00 && param[0] != 0x03 && 1238 param[0] != 0x04 && param[0] != 0xff) 1239 return -ENODEV; 1240 1241 /* 1242 * Then we reset and disable the mouse so that it doesn't generate 1243 * events. 1244 */ 1245 error = ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_DIS); 1246 if (error) 1247 psmouse_warn(psmouse, "Failed to reset mouse on %s: %d\n", 1248 ps2dev->serio->phys, error); 1249 1250 return 0; 1251 } 1252 1253 /* 1254 * psmouse_initialize() initializes the mouse to a sane state. 1255 */ 1256 static void psmouse_initialize(struct psmouse *psmouse) 1257 { 1258 /* 1259 * We set the mouse report rate, resolution and scaling. 1260 */ 1261 if (psmouse_max_proto != PSMOUSE_PS2) { 1262 psmouse->set_rate(psmouse, psmouse->rate); 1263 psmouse->set_resolution(psmouse, psmouse->resolution); 1264 psmouse->set_scale(psmouse, PSMOUSE_SCALE11); 1265 } 1266 } 1267 1268 /* 1269 * psmouse_activate() enables the mouse so that we get motion reports from it. 1270 */ 1271 int psmouse_activate(struct psmouse *psmouse) 1272 { 1273 if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) { 1274 psmouse_warn(psmouse, "Failed to enable mouse on %s\n", 1275 psmouse->ps2dev.serio->phys); 1276 return -1; 1277 } 1278 1279 psmouse_set_state(psmouse, PSMOUSE_ACTIVATED); 1280 return 0; 1281 } 1282 1283 /* 1284 * psmouse_deactivate() puts the mouse into poll mode so that we don't get 1285 * motion reports from it unless we explicitly request it. 1286 */ 1287 int psmouse_deactivate(struct psmouse *psmouse) 1288 { 1289 int error; 1290 1291 error = ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE); 1292 if (error) { 1293 psmouse_warn(psmouse, "Failed to deactivate mouse on %s: %d\n", 1294 psmouse->ps2dev.serio->phys, error); 1295 return error; 1296 } 1297 1298 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 1299 return 0; 1300 } 1301 1302 /* 1303 * psmouse_resync() attempts to re-validate current protocol. 1304 */ 1305 static void psmouse_resync(struct work_struct *work) 1306 { 1307 struct psmouse *parent = NULL, *psmouse = 1308 container_of(work, struct psmouse, resync_work); 1309 struct serio *serio = psmouse->ps2dev.serio; 1310 psmouse_ret_t rc = PSMOUSE_GOOD_DATA; 1311 bool failed = false, enabled = false; 1312 int i; 1313 1314 mutex_lock(&psmouse_mutex); 1315 1316 if (psmouse->state != PSMOUSE_RESYNCING) 1317 goto out; 1318 1319 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 1320 parent = psmouse_from_serio(serio->parent); 1321 psmouse_deactivate(parent); 1322 } 1323 1324 /* 1325 * Some mice don't ACK commands sent while they are in the middle of 1326 * transmitting motion packet. To avoid delay we use ps2_sendbyte() 1327 * instead of ps2_command() which would wait for 200ms for an ACK 1328 * that may never come. 1329 * As an additional quirk ALPS touchpads may not only forget to ACK 1330 * disable command but will stop reporting taps, so if we see that 1331 * mouse at least once ACKs disable we will do full reconnect if ACK 1332 * is missing. 1333 */ 1334 psmouse->num_resyncs++; 1335 1336 if (ps2_sendbyte(&psmouse->ps2dev, PSMOUSE_CMD_DISABLE, 20)) { 1337 if (psmouse->num_resyncs < 3 || psmouse->acks_disable_command) 1338 failed = true; 1339 } else 1340 psmouse->acks_disable_command = true; 1341 1342 /* 1343 * Poll the mouse. If it was reset the packet will be shorter than 1344 * psmouse->pktsize and ps2_command will fail. We do not expect and 1345 * do not handle scenario when mouse "upgrades" its protocol while 1346 * disconnected since it would require additional delay. If we ever 1347 * see a mouse that does it we'll adjust the code. 1348 */ 1349 if (!failed) { 1350 if (psmouse->poll(psmouse)) 1351 failed = true; 1352 else { 1353 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 1354 for (i = 0; i < psmouse->pktsize; i++) { 1355 psmouse->pktcnt++; 1356 rc = psmouse->protocol_handler(psmouse); 1357 if (rc != PSMOUSE_GOOD_DATA) 1358 break; 1359 } 1360 if (rc != PSMOUSE_FULL_PACKET) 1361 failed = true; 1362 psmouse_set_state(psmouse, PSMOUSE_RESYNCING); 1363 } 1364 } 1365 1366 /* 1367 * Now try to enable mouse. We try to do that even if poll failed 1368 * and also repeat our attempts 5 times, otherwise we may be left 1369 * out with disabled mouse. 1370 */ 1371 for (i = 0; i < 5; i++) { 1372 if (!ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE)) { 1373 enabled = true; 1374 break; 1375 } 1376 msleep(200); 1377 } 1378 1379 if (!enabled) { 1380 psmouse_warn(psmouse, "failed to re-enable mouse on %s\n", 1381 psmouse->ps2dev.serio->phys); 1382 failed = true; 1383 } 1384 1385 if (failed) { 1386 psmouse_set_state(psmouse, PSMOUSE_IGNORE); 1387 psmouse_info(psmouse, 1388 "resync failed, issuing reconnect request\n"); 1389 serio_reconnect(serio); 1390 } else 1391 psmouse_set_state(psmouse, PSMOUSE_ACTIVATED); 1392 1393 if (parent) 1394 psmouse_activate(parent); 1395 out: 1396 mutex_unlock(&psmouse_mutex); 1397 } 1398 1399 /* 1400 * psmouse_cleanup() resets the mouse into power-on state. 1401 */ 1402 static void psmouse_cleanup(struct serio *serio) 1403 { 1404 struct psmouse *psmouse = psmouse_from_serio(serio); 1405 struct psmouse *parent = NULL; 1406 1407 mutex_lock(&psmouse_mutex); 1408 1409 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 1410 parent = psmouse_from_serio(serio->parent); 1411 psmouse_deactivate(parent); 1412 } 1413 1414 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING); 1415 1416 /* 1417 * Disable stream mode so cleanup routine can proceed undisturbed. 1418 */ 1419 if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE)) 1420 psmouse_warn(psmouse, "Failed to disable mouse on %s\n", 1421 psmouse->ps2dev.serio->phys); 1422 1423 if (psmouse->cleanup) 1424 psmouse->cleanup(psmouse); 1425 1426 /* 1427 * Reset the mouse to defaults (bare PS/2 protocol). 1428 */ 1429 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS); 1430 1431 /* 1432 * Some boxes, such as HP nx7400, get terribly confused if mouse 1433 * is not fully enabled before suspending/shutting down. 1434 */ 1435 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE); 1436 1437 if (parent) { 1438 if (parent->pt_deactivate) 1439 parent->pt_deactivate(parent); 1440 1441 psmouse_activate(parent); 1442 } 1443 1444 mutex_unlock(&psmouse_mutex); 1445 } 1446 1447 /* 1448 * psmouse_disconnect() closes and frees. 1449 */ 1450 static void psmouse_disconnect(struct serio *serio) 1451 { 1452 struct psmouse *psmouse = psmouse_from_serio(serio); 1453 struct psmouse *parent = NULL; 1454 1455 mutex_lock(&psmouse_mutex); 1456 1457 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 1458 1459 /* make sure we don't have a resync in progress */ 1460 mutex_unlock(&psmouse_mutex); 1461 disable_work_sync(&psmouse->resync_work); 1462 mutex_lock(&psmouse_mutex); 1463 1464 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 1465 parent = psmouse_from_serio(serio->parent); 1466 psmouse_deactivate(parent); 1467 } 1468 1469 if (psmouse->disconnect) 1470 psmouse->disconnect(psmouse); 1471 1472 if (parent && parent->pt_deactivate) 1473 parent->pt_deactivate(parent); 1474 1475 psmouse_set_state(psmouse, PSMOUSE_IGNORE); 1476 1477 serio_close(serio); 1478 serio_set_drvdata(serio, NULL); 1479 1480 if (psmouse->dev) 1481 input_unregister_device(psmouse->dev); 1482 1483 kfree(psmouse); 1484 1485 if (parent) 1486 psmouse_activate(parent); 1487 1488 mutex_unlock(&psmouse_mutex); 1489 } 1490 1491 static int psmouse_switch_protocol(struct psmouse *psmouse, 1492 const struct psmouse_protocol *proto) 1493 { 1494 const struct psmouse_protocol *selected_proto; 1495 struct input_dev *input_dev = psmouse->dev; 1496 enum psmouse_type type; 1497 1498 input_dev->dev.parent = &psmouse->ps2dev.serio->dev; 1499 1500 if (proto && (proto->detect || proto->init)) { 1501 psmouse_apply_defaults(psmouse); 1502 1503 if (proto->detect && proto->detect(psmouse, true) < 0) 1504 return -1; 1505 1506 if (proto->init && proto->init(psmouse) < 0) 1507 return -1; 1508 1509 selected_proto = proto; 1510 } else { 1511 type = psmouse_extensions(psmouse, psmouse_max_proto, true); 1512 selected_proto = psmouse_protocol_by_type(type); 1513 } 1514 1515 psmouse->protocol = selected_proto; 1516 1517 /* 1518 * If mouse's packet size is 3 there is no point in polling the 1519 * device in hopes to detect protocol reset - we won't get less 1520 * than 3 bytes response anyhow. 1521 */ 1522 if (psmouse->pktsize == 3) 1523 psmouse->resync_time = 0; 1524 1525 /* 1526 * Some smart KVMs fake response to POLL command returning just 1527 * 3 bytes and messing up our resync logic, so if initial poll 1528 * fails we won't try polling the device anymore. Hopefully 1529 * such KVM will maintain initially selected protocol. 1530 */ 1531 if (psmouse->resync_time && psmouse->poll(psmouse)) 1532 psmouse->resync_time = 0; 1533 1534 snprintf(psmouse->devname, sizeof(psmouse->devname), "%s %s %s", 1535 selected_proto->name, psmouse->vendor, psmouse->name); 1536 1537 input_dev->name = psmouse->devname; 1538 input_dev->phys = psmouse->phys; 1539 input_dev->id.bustype = BUS_I8042; 1540 input_dev->id.vendor = 0x0002; 1541 input_dev->id.product = psmouse->protocol->type; 1542 input_dev->id.version = psmouse->model; 1543 1544 return 0; 1545 } 1546 1547 /* 1548 * psmouse_connect() is a callback from the serio module when 1549 * an unhandled serio port is found. 1550 */ 1551 static int psmouse_connect(struct serio *serio, struct serio_driver *drv) 1552 { 1553 struct psmouse *psmouse, *parent = NULL; 1554 struct input_dev *input_dev; 1555 int retval = 0, error = -ENOMEM; 1556 1557 mutex_lock(&psmouse_mutex); 1558 1559 /* 1560 * If this is a pass-through port deactivate parent so the device 1561 * connected to this port can be successfully identified 1562 */ 1563 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 1564 parent = psmouse_from_serio(serio->parent); 1565 psmouse_deactivate(parent); 1566 } 1567 1568 psmouse = kzalloc_obj(*psmouse); 1569 input_dev = input_allocate_device(); 1570 if (!psmouse || !input_dev) 1571 goto err_free; 1572 1573 ps2_init(&psmouse->ps2dev, serio, 1574 psmouse_pre_receive_byte, psmouse_receive_byte); 1575 INIT_WORK(&psmouse->resync_work, psmouse_resync); 1576 psmouse->dev = input_dev; 1577 scnprintf(psmouse->phys, sizeof(psmouse->phys), "%s/input0", serio->phys); 1578 1579 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING); 1580 1581 error = serio_open(serio, drv); 1582 if (error) 1583 goto err_clear_drvdata; 1584 1585 /* give PT device some time to settle down before probing */ 1586 if (serio->id.type == SERIO_PS_PSTHRU) 1587 usleep_range(10000, 15000); 1588 1589 if (psmouse_probe(psmouse) < 0) { 1590 error = -ENODEV; 1591 goto err_close_serio; 1592 } 1593 1594 psmouse->rate = psmouse_rate; 1595 psmouse->resolution = psmouse_resolution; 1596 psmouse->resetafter = psmouse_resetafter; 1597 psmouse->resync_time = parent ? 0 : psmouse_resync_time; 1598 psmouse->smartscroll = psmouse_smartscroll; 1599 1600 psmouse_switch_protocol(psmouse, NULL); 1601 1602 if (!psmouse->protocol->smbus_companion) { 1603 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 1604 psmouse_initialize(psmouse); 1605 1606 error = input_register_device(input_dev); 1607 if (error) 1608 goto err_protocol_disconnect; 1609 } else { 1610 /* Smbus companion will be reporting events, not us. */ 1611 input_free_device(input_dev); 1612 psmouse->dev = input_dev = NULL; 1613 } 1614 1615 if (parent && parent->pt_activate) 1616 parent->pt_activate(parent); 1617 1618 /* 1619 * PS/2 devices having SMBus companions should stay disabled 1620 * on PS/2 side, in order to have SMBus part operable. 1621 */ 1622 if (!psmouse->protocol->smbus_companion) 1623 psmouse_activate(psmouse); 1624 1625 out: 1626 /* If this is a pass-through port the parent needs to be re-activated */ 1627 if (parent) 1628 psmouse_activate(parent); 1629 1630 mutex_unlock(&psmouse_mutex); 1631 return retval; 1632 1633 err_protocol_disconnect: 1634 if (psmouse->disconnect) 1635 psmouse->disconnect(psmouse); 1636 psmouse_set_state(psmouse, PSMOUSE_IGNORE); 1637 err_close_serio: 1638 serio_close(serio); 1639 err_clear_drvdata: 1640 serio_set_drvdata(serio, NULL); 1641 err_free: 1642 input_free_device(input_dev); 1643 kfree(psmouse); 1644 1645 retval = error; 1646 goto out; 1647 } 1648 1649 static int __psmouse_reconnect(struct serio *serio, bool fast_reconnect) 1650 { 1651 struct psmouse *psmouse = psmouse_from_serio(serio); 1652 struct psmouse *parent = NULL; 1653 int (*reconnect_handler)(struct psmouse *); 1654 enum psmouse_type type; 1655 int rc = -1; 1656 1657 mutex_lock(&psmouse_mutex); 1658 1659 if (fast_reconnect) { 1660 reconnect_handler = psmouse->fast_reconnect; 1661 if (!reconnect_handler) { 1662 rc = -ENOENT; 1663 goto out_unlock; 1664 } 1665 } else { 1666 reconnect_handler = psmouse->reconnect; 1667 } 1668 1669 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 1670 parent = psmouse_from_serio(serio->parent); 1671 psmouse_deactivate(parent); 1672 } 1673 1674 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING); 1675 1676 if (reconnect_handler) { 1677 if (reconnect_handler(psmouse)) 1678 goto out; 1679 } else { 1680 psmouse_reset(psmouse); 1681 1682 if (psmouse_probe(psmouse) < 0) 1683 goto out; 1684 1685 type = psmouse_extensions(psmouse, psmouse_max_proto, false); 1686 if (psmouse->protocol->type != type) 1687 goto out; 1688 } 1689 1690 /* 1691 * OK, the device type (and capabilities) match the old one, 1692 * we can continue using it, complete initialization 1693 */ 1694 if (!psmouse->protocol->smbus_companion) { 1695 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 1696 psmouse_initialize(psmouse); 1697 } 1698 1699 if (parent && parent->pt_activate) 1700 parent->pt_activate(parent); 1701 1702 /* 1703 * PS/2 devices having SMBus companions should stay disabled 1704 * on PS/2 side, in order to have SMBus part operable. 1705 */ 1706 if (!psmouse->protocol->smbus_companion) 1707 psmouse_activate(psmouse); 1708 1709 rc = 0; 1710 1711 out: 1712 /* If this is a pass-through port the parent waits to be activated */ 1713 if (parent) 1714 psmouse_activate(parent); 1715 1716 out_unlock: 1717 mutex_unlock(&psmouse_mutex); 1718 return rc; 1719 } 1720 1721 static int psmouse_reconnect(struct serio *serio) 1722 { 1723 return __psmouse_reconnect(serio, false); 1724 } 1725 1726 static int psmouse_fast_reconnect(struct serio *serio) 1727 { 1728 return __psmouse_reconnect(serio, true); 1729 } 1730 1731 static struct serio_device_id psmouse_serio_ids[] = { 1732 { 1733 .type = SERIO_8042, 1734 .proto = SERIO_ANY, 1735 .id = SERIO_ANY, 1736 .extra = SERIO_ANY, 1737 }, 1738 { 1739 .type = SERIO_PS_PSTHRU, 1740 .proto = SERIO_ANY, 1741 .id = SERIO_ANY, 1742 .extra = SERIO_ANY, 1743 }, 1744 { 0 } 1745 }; 1746 1747 MODULE_DEVICE_TABLE(serio, psmouse_serio_ids); 1748 1749 static struct serio_driver psmouse_drv = { 1750 .driver = { 1751 .name = "psmouse", 1752 .dev_groups = psmouse_dev_groups, 1753 }, 1754 .description = DRIVER_DESC, 1755 .id_table = psmouse_serio_ids, 1756 .interrupt = ps2_interrupt, 1757 .connect = psmouse_connect, 1758 .reconnect = psmouse_reconnect, 1759 .fast_reconnect = psmouse_fast_reconnect, 1760 .disconnect = psmouse_disconnect, 1761 .cleanup = psmouse_cleanup, 1762 }; 1763 1764 ssize_t psmouse_attr_show_helper(struct device *dev, struct device_attribute *devattr, 1765 char *buf) 1766 { 1767 struct serio *serio = to_serio_port(dev); 1768 struct psmouse_attribute *attr = to_psmouse_attr(devattr); 1769 struct psmouse *psmouse = psmouse_from_serio(serio); 1770 1771 if (psmouse->protocol->smbus_companion && 1772 devattr != &psmouse_attr_protocol.dattr) 1773 return -ENOENT; 1774 1775 return attr->show(psmouse, attr->data, buf); 1776 } 1777 1778 ssize_t psmouse_attr_set_helper(struct device *dev, struct device_attribute *devattr, 1779 const char *buf, size_t count) 1780 { 1781 struct serio *serio = to_serio_port(dev); 1782 struct psmouse_attribute *attr = to_psmouse_attr(devattr); 1783 struct psmouse *psmouse, *parent = NULL; 1784 int retval; 1785 1786 retval = mutex_lock_interruptible(&psmouse_mutex); 1787 if (retval) 1788 goto out; 1789 1790 psmouse = psmouse_from_serio(serio); 1791 1792 if (psmouse->protocol->smbus_companion && 1793 devattr != &psmouse_attr_protocol.dattr) { 1794 retval = -ENOENT; 1795 goto out_unlock; 1796 } 1797 1798 if (attr->protect) { 1799 if (psmouse->state == PSMOUSE_IGNORE) { 1800 retval = -ENODEV; 1801 goto out_unlock; 1802 } 1803 1804 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 1805 parent = psmouse_from_serio(serio->parent); 1806 psmouse_deactivate(parent); 1807 } 1808 1809 if (!psmouse->protocol->smbus_companion) 1810 psmouse_deactivate(psmouse); 1811 } 1812 1813 retval = attr->set(psmouse, attr->data, buf, count); 1814 1815 if (attr->protect) { 1816 if (retval != -ENODEV && !psmouse->protocol->smbus_companion) 1817 psmouse_activate(psmouse); 1818 1819 if (parent) 1820 psmouse_activate(parent); 1821 } 1822 1823 out_unlock: 1824 mutex_unlock(&psmouse_mutex); 1825 out: 1826 return retval; 1827 } 1828 1829 static ssize_t psmouse_show_int_attr(struct psmouse *psmouse, void *offset, char *buf) 1830 { 1831 unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset); 1832 1833 return sprintf(buf, "%u\n", *field); 1834 } 1835 1836 static ssize_t psmouse_set_int_attr(struct psmouse *psmouse, void *offset, const char *buf, size_t count) 1837 { 1838 unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset); 1839 unsigned int value; 1840 int err; 1841 1842 err = kstrtouint(buf, 10, &value); 1843 if (err) 1844 return err; 1845 1846 *field = value; 1847 1848 return count; 1849 } 1850 1851 static ssize_t psmouse_attr_show_protocol(struct psmouse *psmouse, void *data, char *buf) 1852 { 1853 return sprintf(buf, "%s\n", psmouse->protocol->name); 1854 } 1855 1856 static ssize_t psmouse_attr_set_protocol(struct psmouse *psmouse, void *data, const char *buf, size_t count) 1857 { 1858 struct serio *serio = psmouse->ps2dev.serio; 1859 struct psmouse *parent = NULL; 1860 struct input_dev *old_dev, *new_dev; 1861 const struct psmouse_protocol *proto, *old_proto; 1862 int error; 1863 int retry = 0; 1864 1865 proto = psmouse_protocol_by_name(buf, count); 1866 if (!proto) 1867 return -EINVAL; 1868 1869 if (psmouse->protocol == proto) 1870 return count; 1871 1872 new_dev = input_allocate_device(); 1873 if (!new_dev) 1874 return -ENOMEM; 1875 1876 while (!list_empty(&serio->children)) { 1877 if (++retry > 3) { 1878 psmouse_warn(psmouse, 1879 "failed to destroy children ports, protocol change aborted.\n"); 1880 input_free_device(new_dev); 1881 return -EIO; 1882 } 1883 1884 mutex_unlock(&psmouse_mutex); 1885 serio_unregister_child_port(serio); 1886 mutex_lock(&psmouse_mutex); 1887 1888 if (serio->drv != &psmouse_drv) { 1889 input_free_device(new_dev); 1890 return -ENODEV; 1891 } 1892 1893 if (psmouse->protocol == proto) { 1894 input_free_device(new_dev); 1895 return count; /* switched by other thread */ 1896 } 1897 } 1898 1899 if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) { 1900 parent = psmouse_from_serio(serio->parent); 1901 if (parent->pt_deactivate) 1902 parent->pt_deactivate(parent); 1903 } 1904 1905 old_dev = psmouse->dev; 1906 old_proto = psmouse->protocol; 1907 1908 if (psmouse->disconnect) 1909 psmouse->disconnect(psmouse); 1910 1911 psmouse_set_state(psmouse, PSMOUSE_IGNORE); 1912 1913 psmouse->dev = new_dev; 1914 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING); 1915 1916 if (psmouse_switch_protocol(psmouse, proto) < 0) { 1917 psmouse_reset(psmouse); 1918 /* default to PSMOUSE_PS2 */ 1919 psmouse_switch_protocol(psmouse, &psmouse_protocols[0]); 1920 } 1921 1922 psmouse_initialize(psmouse); 1923 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 1924 1925 if (psmouse->protocol->smbus_companion) { 1926 input_free_device(psmouse->dev); 1927 psmouse->dev = NULL; 1928 } else { 1929 error = input_register_device(psmouse->dev); 1930 if (error) { 1931 if (psmouse->disconnect) 1932 psmouse->disconnect(psmouse); 1933 1934 psmouse_set_state(psmouse, PSMOUSE_IGNORE); 1935 input_free_device(new_dev); 1936 psmouse->dev = old_dev; 1937 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING); 1938 psmouse_switch_protocol(psmouse, old_proto); 1939 psmouse_initialize(psmouse); 1940 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE); 1941 1942 return error; 1943 } 1944 } 1945 1946 if (old_dev) 1947 input_unregister_device(old_dev); 1948 1949 if (parent && parent->pt_activate) 1950 parent->pt_activate(parent); 1951 1952 return count; 1953 } 1954 1955 static ssize_t psmouse_attr_set_rate(struct psmouse *psmouse, void *data, const char *buf, size_t count) 1956 { 1957 unsigned int value; 1958 int err; 1959 1960 err = kstrtouint(buf, 10, &value); 1961 if (err) 1962 return err; 1963 1964 psmouse->set_rate(psmouse, value); 1965 return count; 1966 } 1967 1968 static ssize_t psmouse_attr_set_resolution(struct psmouse *psmouse, void *data, const char *buf, size_t count) 1969 { 1970 unsigned int value; 1971 int err; 1972 1973 err = kstrtouint(buf, 10, &value); 1974 if (err) 1975 return err; 1976 1977 psmouse->set_resolution(psmouse, value); 1978 return count; 1979 } 1980 1981 1982 static int psmouse_set_maxproto(const char *val, const struct kernel_param *kp) 1983 { 1984 const struct psmouse_protocol *proto; 1985 1986 if (!val) 1987 return -EINVAL; 1988 1989 proto = psmouse_protocol_by_name(val, strlen(val)); 1990 1991 if (!proto || !proto->maxproto) 1992 return -EINVAL; 1993 1994 *((unsigned int *)kp->arg) = proto->type; 1995 1996 return 0; 1997 } 1998 1999 static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp) 2000 { 2001 int type = *((unsigned int *)kp->arg); 2002 2003 return sprintf(buffer, "%s\n", psmouse_protocol_by_type(type)->name); 2004 } 2005 2006 static int __init psmouse_init(void) 2007 { 2008 int err; 2009 2010 lifebook_module_init(); 2011 synaptics_module_init(); 2012 2013 err = psmouse_smbus_module_init(); 2014 if (err) 2015 return err; 2016 2017 err = serio_register_driver(&psmouse_drv); 2018 if (err) 2019 goto err_smbus_exit; 2020 2021 return 0; 2022 2023 err_smbus_exit: 2024 psmouse_smbus_module_exit(); 2025 return err; 2026 } 2027 2028 static void __exit psmouse_exit(void) 2029 { 2030 serio_unregister_driver(&psmouse_drv); 2031 psmouse_smbus_module_exit(); 2032 } 2033 2034 module_init(psmouse_init); 2035 module_exit(psmouse_exit); 2036