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