drivers/input/mouse/psmouse-base.c

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