drivers/input/mouse/psmouse-base.c

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