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