SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 #include <linux/delay.h>
  15 #include <linux/module.h>
  16 #include <linux/moduleparam.h>
  17 #include <linux/slab.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/input.h>
  20 #include <linux/serio.h>
  21 #include <linux/init.h>
  22 #include <linux/libps2.h>
  23 #include "psmouse.h"
  24 #include "synaptics.h"
  25 #include "logips2pp.h"
  26 #include "alps.h"
  27 #include "lifebook.h"
  28 #include "trackpoint.h"
  29
  30 #define DRIVER_DESC     "PS/2 mouse driver"
  31
  32 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  33 MODULE_DESCRIPTION(DRIVER_DESC);
  34 MODULE_LICENSE("GPL");
  35
  36 static unsigned int psmouse_max_proto = PSMOUSE_AUTO;
  37 static int psmouse_set_maxproto(const char *val, struct kernel_param *kp);
  38 static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp);
  39 #define param_check_proto_abbrev(name, p)       __param_check(name, p, unsigned int)
  40 #define param_set_proto_abbrev                  psmouse_set_maxproto
  41 #define param_get_proto_abbrev                  psmouse_get_maxproto
  42 module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644);
  43 MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches.");
  44
  45 static unsigned int psmouse_resolution = 200;
  46 module_param_named(resolution, psmouse_resolution, uint, 0644);
  47 MODULE_PARM_DESC(resolution, "Resolution, in dpi.");
  48
  49 static unsigned int psmouse_rate = 100;
  50 module_param_named(rate, psmouse_rate, uint, 0644);
  51 MODULE_PARM_DESC(rate, "Report rate, in reports per second.");
  52
  53 static unsigned int psmouse_smartscroll = 1;
  54 module_param_named(smartscroll, psmouse_smartscroll, bool, 0644);
  55 MODULE_PARM_DESC(smartscroll, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled.");
  56
  57 static unsigned int psmouse_resetafter;
  58 module_param_named(resetafter, psmouse_resetafter, uint, 0644);
  59 MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never).");
  60
  61 PSMOUSE_DEFINE_ATTR(protocol);
  62 PSMOUSE_DEFINE_ATTR(rate);
  63 PSMOUSE_DEFINE_ATTR(resolution);
  64 PSMOUSE_DEFINE_ATTR(resetafter);
  65
  66 __obsolete_setup("psmouse_noext");
  67 __obsolete_setup("psmouse_resolution=");
  68 __obsolete_setup("psmouse_smartscroll=");
  69 __obsolete_setup("psmouse_resetafter=");
  70 __obsolete_setup("psmouse_rate=");
  71
  72 /*
  73  * psmouse_sem protects all operations changing state of mouse
  74  * (connecting, disconnecting, changing rate or resolution via
  75  * sysfs). We could use a per-device semaphore but since there
  76  * rarely more than one PS/2 mouse connected and since semaphore
  77  * is taken in "slow" paths it is not worth it.
  78  */
  79 static DECLARE_MUTEX(psmouse_sem);
  80
  81 struct psmouse_protocol {
  82         enum psmouse_type type;
  83         char *name;
  84         char *alias;
  85         int maxproto;
  86         int (*detect)(struct psmouse *, int);
  87         int (*init)(struct psmouse *);
  88 };
  89
  90 /*
  91  * psmouse_process_byte() analyzes the PS/2 data stream and reports
  92  * relevant events to the input module once full packet has arrived.
  93  */
  94
  95 static psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse, struct pt_regs *regs)
  96 {
  97         struct input_dev *dev = &psmouse->dev;
  98         unsigned char *packet = psmouse->packet;
  99
 100         if (psmouse->pktcnt < psmouse->pktsize)
 101                 return PSMOUSE_GOOD_DATA;
 102
 103 /*
 104  * Full packet accumulated, process it
 105  */
 106
 107         input_regs(dev, regs);
 108
 109 /*
 110  * Scroll wheel on IntelliMice, scroll buttons on NetMice
 111  */
 112
 113         if (psmouse->type == PSMOUSE_IMPS || psmouse->type == PSMOUSE_GENPS)
 114                 input_report_rel(dev, REL_WHEEL, -(signed char) packet[3]);
 115
 116 /*
 117  * Scroll wheel and buttons on IntelliMouse Explorer
 118  */
 119
 120         if (psmouse->type == PSMOUSE_IMEX) {
 121                 input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 8) - (int) (packet[3] & 7));
 122                 input_report_key(dev, BTN_SIDE, (packet[3] >> 4) & 1);
 123                 input_report_key(dev, BTN_EXTRA, (packet[3] >> 5) & 1);
 124         }
 125
 126 /*
 127  * Extra buttons on Genius NewNet 3D
 128  */
 129
 130         if (psmouse->type == PSMOUSE_GENPS) {
 131                 input_report_key(dev, BTN_SIDE, (packet[0] >> 6) & 1);
 132                 input_report_key(dev, BTN_EXTRA, (packet[0] >> 7) & 1);
 133         }
 134
 135 /*
 136  * Extra button on ThinkingMouse
 137  */
 138         if (psmouse->type == PSMOUSE_THINKPS) {
 139                 input_report_key(dev, BTN_EXTRA, (packet[0] >> 3) & 1);
 140                 /* Without this bit of weirdness moving up gives wildly high Y changes. */
 141                 packet[1] |= (packet[0] & 0x40) << 1;
 142         }
 143
 144 /*
 145  * Generic PS/2 Mouse
 146  */
 147
 148         input_report_key(dev, BTN_LEFT,    packet[0]       & 1);
 149         input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1);
 150         input_report_key(dev, BTN_RIGHT,  (packet[0] >> 1) & 1);
 151
 152         input_report_rel(dev, REL_X, packet[1] ? (int) packet[1] - (int) ((packet[0] << 4) & 0x100) : 0);
 153         input_report_rel(dev, REL_Y, packet[2] ? (int) ((packet[0] << 3) & 0x100) - (int) packet[2] : 0);
 154
 155         input_sync(dev);
 156
 157         return PSMOUSE_FULL_PACKET;
 158 }
 159
 160 /*
 161  * psmouse_interrupt() handles incoming characters, either gathering them into
 162  * packets or passing them to the command routine as command output.
 163  */
 164
 165 static irqreturn_t psmouse_interrupt(struct serio *serio,
 166                 unsigned char data, unsigned int flags, struct pt_regs *regs)
 167 {
 168         struct psmouse *psmouse = serio_get_drvdata(serio);
 169         psmouse_ret_t rc;
 170
 171         if (psmouse->state == PSMOUSE_IGNORE)
 172                 goto out;
 173
 174         if (flags & (SERIO_PARITY|SERIO_TIMEOUT)) {
 175                 if (psmouse->state == PSMOUSE_ACTIVATED)
 176                         printk(KERN_WARNING "psmouse.c: bad data from KBC -%s%s\n",
 177                                 flags & SERIO_TIMEOUT ? " timeout" : "",
 178                                 flags & SERIO_PARITY ? " bad parity" : "");
 179                 ps2_cmd_aborted(&psmouse->ps2dev);
 180                 goto out;
 181         }
 182
 183         if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_ACK))
 184                 if  (ps2_handle_ack(&psmouse->ps2dev, data))
 185                         goto out;
 186
 187         if (unlikely(psmouse->ps2dev.flags & PS2_FLAG_CMD))
 188                 if  (ps2_handle_response(&psmouse->ps2dev, data))
 189                         goto out;
 190
 191         if (psmouse->state == PSMOUSE_INITIALIZING)
 192                 goto out;
 193
 194         if (psmouse->state == PSMOUSE_ACTIVATED &&
 195             psmouse->pktcnt && time_after(jiffies, psmouse->last + HZ/2)) {
 196                 printk(KERN_WARNING "psmouse.c: %s at %s lost synchronization, throwing %d bytes away.\n",
 197                        psmouse->name, psmouse->phys, psmouse->pktcnt);
 198                 psmouse->pktcnt = 0;
 199         }
 200
 201         psmouse->last = jiffies;
 202         psmouse->packet[psmouse->pktcnt++] = data;
 203
 204         if (psmouse->packet[0] == PSMOUSE_RET_BAT) {
 205                 if (psmouse->pktcnt == 1)
 206                         goto out;
 207
 208                 if (psmouse->pktcnt == 2) {
 209                         if (psmouse->packet[1] == PSMOUSE_RET_ID) {
 210                                 psmouse->state = PSMOUSE_IGNORE;
 211                                 serio_reconnect(serio);
 212                                 goto out;
 213                         }
 214                         if (psmouse->type == PSMOUSE_SYNAPTICS) {
 215                                 /* neither 0xAA nor 0x00 are valid first bytes
 216                                  * for a packet in absolute mode
 217                                  */
 218                                 psmouse->pktcnt = 0;
 219                                 goto out;
 220                         }
 221                 }
 222         }
 223
 224         rc = psmouse->protocol_handler(psmouse, regs);
 225
 226         switch (rc) {
 227                 case PSMOUSE_BAD_DATA:
 228                         printk(KERN_WARNING "psmouse.c: %s at %s lost sync at byte %d\n",
 229                                 psmouse->name, psmouse->phys, psmouse->pktcnt);
 230                         psmouse->pktcnt = 0;
 231
 232                         if (++psmouse->out_of_sync == psmouse->resetafter) {
 233                                 psmouse->state = PSMOUSE_IGNORE;
 234                                 printk(KERN_NOTICE "psmouse.c: issuing reconnect request\n");
 235                                 serio_reconnect(psmouse->ps2dev.serio);
 236                         }
 237                         break;
 238
 239                 case PSMOUSE_FULL_PACKET:
 240                         psmouse->pktcnt = 0;
 241                         if (psmouse->out_of_sync) {
 242                                 psmouse->out_of_sync = 0;
 243                                 printk(KERN_NOTICE "psmouse.c: %s at %s - driver resynched.\n",
 244                                         psmouse->name, psmouse->phys);
 245                         }
 246                         break;
 247
 248                 case PSMOUSE_GOOD_DATA:
 249                         break;
 250         }
 251 out:
 252         return IRQ_HANDLED;
 253 }
 254
 255
 256 /*
 257  * psmouse_sliced_command() sends an extended PS/2 command to the mouse
 258  * using sliced syntax, understood by advanced devices, such as Logitech
 259  * or Synaptics touchpads. The command is encoded as:
 260  * 0xE6 0xE8 rr 0xE8 ss 0xE8 tt 0xE8 uu where (rr*64)+(ss*16)+(tt*4)+uu
 261  * is the command.
 262  */
 263 int psmouse_sliced_command(struct psmouse *psmouse, unsigned char command)
 264 {
 265         int i;
 266
 267         if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11))
 268                 return -1;
 269
 270         for (i = 6; i >= 0; i -= 2) {
 271                 unsigned char d = (command >> i) & 3;
 272                 if (ps2_command(&psmouse->ps2dev, &d, PSMOUSE_CMD_SETRES))
 273                         return -1;
 274         }
 275
 276         return 0;
 277 }
 278
 279
 280 /*
 281  * psmouse_reset() resets the mouse into power-on state.
 282  */
 283 int psmouse_reset(struct psmouse *psmouse)
 284 {
 285         unsigned char param[2];
 286
 287         if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_RESET_BAT))
 288                 return -1;
 289
 290         if (param[0] != PSMOUSE_RET_BAT && param[1] != PSMOUSE_RET_ID)
 291                 return -1;
 292
 293         return 0;
 294 }
 295
 296
 297 /*
 298  * Genius NetMouse magic init.
 299  */
 300 static int genius_detect(struct psmouse *psmouse, int set_properties)
 301 {
 302         struct ps2dev *ps2dev = &psmouse->ps2dev;
 303         unsigned char param[4];
 304
 305         param[0] = 3;
 306         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
 307         ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
 308         ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
 309         ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11);
 310         ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);
 311
 312         if (param[0] != 0x00 || param[1] != 0x33 || param[2] != 0x55)
 313                 return -1;
 314
 315         if (set_properties) {
 316                 set_bit(BTN_EXTRA, psmouse->dev.keybit);
 317                 set_bit(BTN_SIDE, psmouse->dev.keybit);
 318                 set_bit(REL_WHEEL, psmouse->dev.relbit);
 319
 320                 psmouse->vendor = "Genius";
 321                 psmouse->name = "Wheel Mouse";
 322                 psmouse->pktsize = 4;
 323         }
 324
 325         return 0;
 326 }
 327
 328 /*
 329  * IntelliMouse magic init.
 330  */
 331 static int intellimouse_detect(struct psmouse *psmouse, int set_properties)
 332 {
 333         struct ps2dev *ps2dev = &psmouse->ps2dev;
 334         unsigned char param[2];
 335
 336         param[0] = 200;
 337         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 338         param[0] = 100;
 339         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 340         param[0] =  80;
 341         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 342         ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
 343
 344         if (param[0] != 3)
 345                 return -1;
 346
 347         if (set_properties) {
 348                 set_bit(BTN_MIDDLE, psmouse->dev.keybit);
 349                 set_bit(REL_WHEEL, psmouse->dev.relbit);
 350
 351                 if (!psmouse->vendor) psmouse->vendor = "Generic";
 352                 if (!psmouse->name) psmouse->name = "Wheel Mouse";
 353                 psmouse->pktsize = 4;
 354         }
 355
 356         return 0;
 357 }
 358
 359 /*
 360  * Try IntelliMouse/Explorer magic init.
 361  */
 362 static int im_explorer_detect(struct psmouse *psmouse, int set_properties)
 363 {
 364         struct ps2dev *ps2dev = &psmouse->ps2dev;
 365         unsigned char param[2];
 366
 367         intellimouse_detect(psmouse, 0);
 368
 369         param[0] = 200;
 370         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 371         param[0] = 200;
 372         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 373         param[0] =  80;
 374         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 375         ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
 376
 377         if (param[0] != 4)
 378                 return -1;
 379
 380         if (set_properties) {
 381                 set_bit(BTN_MIDDLE, psmouse->dev.keybit);
 382                 set_bit(REL_WHEEL, psmouse->dev.relbit);
 383                 set_bit(BTN_SIDE, psmouse->dev.keybit);
 384                 set_bit(BTN_EXTRA, psmouse->dev.keybit);
 385
 386                 if (!psmouse->vendor) psmouse->vendor = "Generic";
 387                 if (!psmouse->name) psmouse->name = "Explorer Mouse";
 388                 psmouse->pktsize = 4;
 389         }
 390
 391         return 0;
 392 }
 393
 394 /*
 395  * Kensington ThinkingMouse / ExpertMouse magic init.
 396  */
 397 static int thinking_detect(struct psmouse *psmouse, int set_properties)
 398 {
 399         struct ps2dev *ps2dev = &psmouse->ps2dev;
 400         unsigned char param[2];
 401         unsigned char seq[] = { 20, 60, 40, 20, 20, 60, 40, 20, 20, 0 };
 402         int i;
 403
 404         param[0] = 10;
 405         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
 406         param[0] = 0;
 407         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
 408         for (i = 0; seq[i]; i++)
 409                 ps2_command(ps2dev, seq + i, PSMOUSE_CMD_SETRATE);
 410         ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
 411
 412         if (param[0] != 2)
 413                 return -1;
 414
 415         if (set_properties) {
 416                 set_bit(BTN_EXTRA, psmouse->dev.keybit);
 417
 418                 psmouse->vendor = "Kensington";
 419                 psmouse->name = "ThinkingMouse";
 420         }
 421
 422         return 0;
 423 }
 424
 425 /*
 426  * Bare PS/2 protocol "detection". Always succeeds.
 427  */
 428 static int ps2bare_detect(struct psmouse *psmouse, int set_properties)
 429 {
 430         if (set_properties) {
 431                 if (!psmouse->vendor) psmouse->vendor = "Generic";
 432                 if (!psmouse->name) psmouse->name = "Mouse";
 433         }
 434
 435         return 0;
 436 }
 437
 438
 439 /*
 440  * psmouse_extensions() probes for any extensions to the basic PS/2 protocol
 441  * the mouse may have.
 442  */
 443
 444 static int psmouse_extensions(struct psmouse *psmouse,
 445                               unsigned int max_proto, int set_properties)
 446 {
 447         int synaptics_hardware = 0;
 448
 449 /*
 450  * We always check for lifebook because it does not disturb mouse
 451  * (it only checks DMI information).
 452  */
 453         if (lifebook_detect(psmouse, set_properties) == 0) {
 454                 if (max_proto > PSMOUSE_IMEX) {
 455                         if (!set_properties || lifebook_init(psmouse) == 0)
 456                                 return PSMOUSE_LIFEBOOK;
 457                 }
 458         }
 459
 460 /*
 461  * Try Kensington ThinkingMouse (we try first, because synaptics probe
 462  * upsets the thinkingmouse).
 463  */
 464
 465         if (max_proto > PSMOUSE_IMEX && thinking_detect(psmouse, set_properties) == 0)
 466                 return PSMOUSE_THINKPS;
 467
 468 /*
 469  * Try Synaptics TouchPad
 470  */
 471         if (max_proto > PSMOUSE_PS2 && synaptics_detect(psmouse, set_properties) == 0) {
 472                 synaptics_hardware = 1;
 473
 474                 if (max_proto > PSMOUSE_IMEX) {
 475                         if (!set_properties || synaptics_init(psmouse) == 0)
 476                                 return PSMOUSE_SYNAPTICS;
 477 /*
 478  * Some Synaptics touchpads can emulate extended protocols (like IMPS/2).
 479  * Unfortunately Logitech/Genius probes confuse some firmware versions so
 480  * we'll have to skip them.
 481  */
 482                         max_proto = PSMOUSE_IMEX;
 483                 }
 484 /*
 485  * Make sure that touchpad is in relative mode, gestures (taps) are enabled
 486  */
 487                 synaptics_reset(psmouse);
 488         }
 489
 490 /*
 491  * Try ALPS TouchPad
 492  */
 493         if (max_proto > PSMOUSE_IMEX) {
 494                 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
 495                 if (alps_detect(psmouse, set_properties) == 0) {
 496                         if (!set_properties || alps_init(psmouse) == 0)
 497                                 return PSMOUSE_ALPS;
 498 /*
 499  * Init failed, try basic relative protocols
 500  */
 501                         max_proto = PSMOUSE_IMEX;
 502                 }
 503         }
 504
 505         if (max_proto > PSMOUSE_IMEX && genius_detect(psmouse, set_properties) == 0)
 506                 return PSMOUSE_GENPS;
 507
 508         if (max_proto > PSMOUSE_IMEX && ps2pp_init(psmouse, set_properties) == 0)
 509                 return PSMOUSE_PS2PP;
 510
 511 /*
 512  * Reset to defaults in case the device got confused by extended
 513  * protocol probes.
 514  */
 515         ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
 516
 517         if (max_proto >= PSMOUSE_IMEX && im_explorer_detect(psmouse, set_properties) == 0)
 518                 return PSMOUSE_IMEX;
 519
 520         if (max_proto >= PSMOUSE_IMPS && intellimouse_detect(psmouse, set_properties) == 0)
 521                 return PSMOUSE_IMPS;
 522
 523 /*
 524  * Try to initialize the IBM TrackPoint
 525  */
 526         if (max_proto > PSMOUSE_IMEX && trackpoint_detect(psmouse, set_properties) == 0)
 527                 return PSMOUSE_TRACKPOINT;
 528
 529 /*
 530  * Okay, all failed, we have a standard mouse here. The number of the buttons
 531  * is still a question, though. We assume 3.
 532  */
 533         ps2bare_detect(psmouse, set_properties);
 534
 535         if (synaptics_hardware) {
 536 /*
 537  * We detected Synaptics hardware but it did not respond to IMPS/2 probes.
 538  * We need to reset the touchpad because if there is a track point on the
 539  * pass through port it could get disabled while probing for protocol
 540  * extensions.
 541  */
 542                 psmouse_reset(psmouse);
 543                 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
 544         }
 545
 546         return PSMOUSE_PS2;
 547 }
 548
 549 static struct psmouse_protocol psmouse_protocols[] = {
 550         {
 551                 .type           = PSMOUSE_PS2,
 552                 .name           = "PS/2",
 553                 .alias          = "bare",
 554                 .maxproto       = 1,
 555                 .detect         = ps2bare_detect,
 556         },
 557         {
 558                 .type           = PSMOUSE_PS2PP,
 559                 .name           = "PS2++",
 560                 .alias          = "logitech",
 561                 .detect         = ps2pp_init,
 562         },
 563         {
 564                 .type           = PSMOUSE_THINKPS,
 565                 .name           = "ThinkPS/2",
 566                 .alias          = "thinkps",
 567                 .detect         = thinking_detect,
 568         },
 569         {
 570                 .type           = PSMOUSE_GENPS,
 571                 .name           = "GenPS/2",
 572                 .alias          = "genius",
 573                 .detect         = genius_detect,
 574         },
 575         {
 576                 .type           = PSMOUSE_IMPS,
 577                 .name           = "ImPS/2",
 578                 .alias          = "imps",
 579                 .maxproto       = 1,
 580                 .detect         = intellimouse_detect,
 581         },
 582         {
 583                 .type           = PSMOUSE_IMEX,
 584                 .name           = "ImExPS/2",
 585                 .alias          = "exps",
 586                 .maxproto       = 1,
 587                 .detect         = im_explorer_detect,
 588         },
 589         {
 590                 .type           = PSMOUSE_SYNAPTICS,
 591                 .name           = "SynPS/2",
 592                 .alias          = "synaptics",
 593                 .detect         = synaptics_detect,
 594                 .init           = synaptics_init,
 595         },
 596         {
 597                 .type           = PSMOUSE_ALPS,
 598                 .name           = "AlpsPS/2",
 599                 .alias          = "alps",
 600                 .detect         = alps_detect,
 601                 .init           = alps_init,
 602         },
 603         {
 604                 .type           = PSMOUSE_LIFEBOOK,
 605                 .name           = "LBPS/2",
 606                 .alias          = "lifebook",
 607                 .init           = lifebook_init,
 608         },
 609         {
 610                 .type           = PSMOUSE_TRACKPOINT,
 611                 .name           = "TPPS/2",
 612                 .alias          = "trackpoint",
 613                 .detect         = trackpoint_detect,
 614         },
 615         {
 616                 .type           = PSMOUSE_AUTO,
 617                 .name           = "auto",
 618                 .alias          = "any",
 619                 .maxproto       = 1,
 620         },
 621 };
 622
 623 static struct psmouse_protocol *psmouse_protocol_by_type(enum psmouse_type type)
 624 {
 625         int i;
 626
 627         for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++)
 628                 if (psmouse_protocols[i].type == type)
 629                         return &psmouse_protocols[i];
 630
 631         WARN_ON(1);
 632         return &psmouse_protocols[0];
 633 }
 634
 635 static struct psmouse_protocol *psmouse_protocol_by_name(const char *name, size_t len)
 636 {
 637         struct psmouse_protocol *p;
 638         int i;
 639
 640         for (i = 0; i < ARRAY_SIZE(psmouse_protocols); i++) {
 641                 p = &psmouse_protocols[i];
 642
 643                 if ((strlen(p->name) == len && !strncmp(p->name, name, len)) ||
 644                     (strlen(p->alias) == len && !strncmp(p->alias, name, len)))
 645                         return &psmouse_protocols[i];
 646         }
 647
 648         return NULL;
 649 }
 650
 651
 652 /*
 653  * psmouse_probe() probes for a PS/2 mouse.
 654  */
 655
 656 static int psmouse_probe(struct psmouse *psmouse)
 657 {
 658         struct ps2dev *ps2dev = &psmouse->ps2dev;
 659         unsigned char param[2];
 660
 661 /*
 662  * First, we check if it's a mouse. It should send 0x00 or 0x03
 663  * in case of an IntelliMouse in 4-byte mode or 0x04 for IM Explorer.
 664  * Sunrex K8561 IR Keyboard/Mouse reports 0xff on second and subsequent
 665  * ID queries, probably due to a firmware bug.
 666  */
 667
 668         param[0] = 0xa5;
 669         if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETID))
 670                 return -1;
 671
 672         if (param[0] != 0x00 && param[0] != 0x03 &&
 673             param[0] != 0x04 && param[0] != 0xff)
 674                 return -1;
 675
 676 /*
 677  * Then we reset and disable the mouse so that it doesn't generate events.
 678  */
 679
 680         if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_DIS))
 681                 printk(KERN_WARNING "psmouse.c: Failed to reset mouse on %s\n", ps2dev->serio->phys);
 682
 683         return 0;
 684 }
 685
 686 /*
 687  * Here we set the mouse resolution.
 688  */
 689
 690 void psmouse_set_resolution(struct psmouse *psmouse, unsigned int resolution)
 691 {
 692         unsigned char params[] = { 0, 1, 2, 2, 3 };
 693
 694         if (resolution == 0 || resolution > 200)
 695                 resolution = 200;
 696
 697         ps2_command(&psmouse->ps2dev, &params[resolution / 50], PSMOUSE_CMD_SETRES);
 698         psmouse->resolution = 25 << params[resolution / 50];
 699 }
 700
 701 /*
 702  * Here we set the mouse report rate.
 703  */
 704
 705 static void psmouse_set_rate(struct psmouse *psmouse, unsigned int rate)
 706 {
 707         unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10, 0 };
 708         int i = 0;
 709
 710         while (rates[i] > rate) i++;
 711         ps2_command(&psmouse->ps2dev, &rates[i], PSMOUSE_CMD_SETRATE);
 712         psmouse->rate = rates[i];
 713 }
 714
 715 /*
 716  * psmouse_initialize() initializes the mouse to a sane state.
 717  */
 718
 719 static void psmouse_initialize(struct psmouse *psmouse)
 720 {
 721 /*
 722  * We set the mouse into streaming mode.
 723  */
 724
 725         ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSTREAM);
 726
 727 /*
 728  * We set the mouse report rate, resolution and scaling.
 729  */
 730
 731         if (psmouse_max_proto != PSMOUSE_PS2) {
 732                 psmouse->set_rate(psmouse, psmouse->rate);
 733                 psmouse->set_resolution(psmouse, psmouse->resolution);
 734                 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11);
 735         }
 736 }
 737
 738 /*
 739  * psmouse_set_state() sets new psmouse state and resets all flags and
 740  * counters while holding serio lock so fighting with interrupt handler
 741  * is not a concern.
 742  */
 743
 744 static void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
 745 {
 746         serio_pause_rx(psmouse->ps2dev.serio);
 747         psmouse->state = new_state;
 748         psmouse->pktcnt = psmouse->out_of_sync = 0;
 749         psmouse->ps2dev.flags = 0;
 750         serio_continue_rx(psmouse->ps2dev.serio);
 751 }
 752
 753 /*
 754  * psmouse_activate() enables the mouse so that we get motion reports from it.
 755  */
 756
 757 static void psmouse_activate(struct psmouse *psmouse)
 758 {
 759         if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE))
 760                 printk(KERN_WARNING "psmouse.c: Failed to enable mouse on %s\n",
 761                         psmouse->ps2dev.serio->phys);
 762
 763         psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
 764 }
 765
 766
 767 /*
 768  * psmouse_deactivate() puts the mouse into poll mode so that we don't get motion
 769  * reports from it unless we explicitely request it.
 770  */
 771
 772 static void psmouse_deactivate(struct psmouse *psmouse)
 773 {
 774         if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE))
 775                 printk(KERN_WARNING "psmouse.c: Failed to deactivate mouse on %s\n",
 776                         psmouse->ps2dev.serio->phys);
 777
 778         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
 779 }
 780
 781
 782 /*
 783  * psmouse_cleanup() resets the mouse into power-on state.
 784  */
 785
 786 static void psmouse_cleanup(struct serio *serio)
 787 {
 788         struct psmouse *psmouse = serio_get_drvdata(serio);
 789
 790         psmouse_reset(psmouse);
 791 }
 792
 793 /*
 794  * psmouse_disconnect() closes and frees.
 795  */
 796
 797 static void psmouse_disconnect(struct serio *serio)
 798 {
 799         struct psmouse *psmouse, *parent = NULL;
 800
 801         psmouse = serio_get_drvdata(serio);
 802
 803         device_remove_file(&serio->dev, &psmouse_attr_protocol);
 804         device_remove_file(&serio->dev, &psmouse_attr_rate);
 805         device_remove_file(&serio->dev, &psmouse_attr_resolution);
 806         device_remove_file(&serio->dev, &psmouse_attr_resetafter);
 807
 808         down(&psmouse_sem);
 809
 810         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
 811
 812         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
 813                 parent = serio_get_drvdata(serio->parent);
 814                 psmouse_deactivate(parent);
 815         }
 816
 817         if (psmouse->disconnect)
 818                 psmouse->disconnect(psmouse);
 819
 820         if (parent && parent->pt_deactivate)
 821                 parent->pt_deactivate(parent);
 822
 823         psmouse_set_state(psmouse, PSMOUSE_IGNORE);
 824
 825         input_unregister_device(&psmouse->dev);
 826         serio_close(serio);
 827         serio_set_drvdata(serio, NULL);
 828         kfree(psmouse);
 829
 830         if (parent)
 831                 psmouse_activate(parent);
 832
 833         up(&psmouse_sem);
 834 }
 835
 836 static int psmouse_switch_protocol(struct psmouse *psmouse, struct psmouse_protocol *proto)
 837 {
 838         memset(&psmouse->dev, 0, sizeof(struct input_dev));
 839
 840         init_input_dev(&psmouse->dev);
 841
 842         psmouse->dev.private = psmouse;
 843         psmouse->dev.dev = &psmouse->ps2dev.serio->dev;
 844
 845         psmouse->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
 846         psmouse->dev.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_MIDDLE) | BIT(BTN_RIGHT);
 847         psmouse->dev.relbit[0] = BIT(REL_X) | BIT(REL_Y);
 848
 849         psmouse->set_rate = psmouse_set_rate;
 850         psmouse->set_resolution = psmouse_set_resolution;
 851         psmouse->protocol_handler = psmouse_process_byte;
 852         psmouse->pktsize = 3;
 853
 854         if (proto && (proto->detect || proto->init)) {
 855                 if (proto->detect && proto->detect(psmouse, 1) < 0)
 856                         return -1;
 857
 858                 if (proto->init && proto->init(psmouse) < 0)
 859                         return -1;
 860
 861                 psmouse->type = proto->type;
 862         }
 863         else
 864                 psmouse->type = psmouse_extensions(psmouse, psmouse_max_proto, 1);
 865
 866         sprintf(psmouse->devname, "%s %s %s",
 867                 psmouse_protocol_by_type(psmouse->type)->name, psmouse->vendor, psmouse->name);
 868
 869         psmouse->dev.name = psmouse->devname;
 870         psmouse->dev.phys = psmouse->phys;
 871         psmouse->dev.id.bustype = BUS_I8042;
 872         psmouse->dev.id.vendor = 0x0002;
 873         psmouse->dev.id.product = psmouse->type;
 874         psmouse->dev.id.version = psmouse->model;
 875
 876         return 0;
 877 }
 878
 879 /*
 880  * psmouse_connect() is a callback from the serio module when
 881  * an unhandled serio port is found.
 882  */
 883 static int psmouse_connect(struct serio *serio, struct serio_driver *drv)
 884 {
 885         struct psmouse *psmouse, *parent = NULL;
 886         int retval;
 887
 888         down(&psmouse_sem);
 889
 890         /*
 891          * If this is a pass-through port deactivate parent so the device
 892          * connected to this port can be successfully identified
 893          */
 894         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
 895                 parent = serio_get_drvdata(serio->parent);
 896                 psmouse_deactivate(parent);
 897         }
 898
 899         if (!(psmouse = kcalloc(1, sizeof(struct psmouse), GFP_KERNEL))) {
 900                 retval = -ENOMEM;
 901                 goto out;
 902         }
 903
 904         ps2_init(&psmouse->ps2dev, serio);
 905         sprintf(psmouse->phys, "%s/input0", serio->phys);
 906
 907         psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
 908
 909         serio_set_drvdata(serio, psmouse);
 910
 911         retval = serio_open(serio, drv);
 912         if (retval) {
 913                 serio_set_drvdata(serio, NULL);
 914                 kfree(psmouse);
 915                 goto out;
 916         }
 917
 918         if (psmouse_probe(psmouse) < 0) {
 919                 serio_close(serio);
 920                 serio_set_drvdata(serio, NULL);
 921                 kfree(psmouse);
 922                 retval = -ENODEV;
 923                 goto out;
 924         }
 925
 926         psmouse->rate = psmouse_rate;
 927         psmouse->resolution = psmouse_resolution;
 928         psmouse->resetafter = psmouse_resetafter;
 929         psmouse->smartscroll = psmouse_smartscroll;
 930
 931         psmouse_switch_protocol(psmouse, NULL);
 932
 933         input_register_device(&psmouse->dev);
 934         printk(KERN_INFO "input: %s on %s\n", psmouse->devname, serio->phys);
 935
 936         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
 937
 938         psmouse_initialize(psmouse);
 939
 940         if (parent && parent->pt_activate)
 941                 parent->pt_activate(parent);
 942
 943         device_create_file(&serio->dev, &psmouse_attr_protocol);
 944         device_create_file(&serio->dev, &psmouse_attr_rate);
 945         device_create_file(&serio->dev, &psmouse_attr_resolution);
 946         device_create_file(&serio->dev, &psmouse_attr_resetafter);
 947
 948         psmouse_activate(psmouse);
 949
 950         retval = 0;
 951
 952 out:
 953         /* If this is a pass-through port the parent needs to be re-activated */
 954         if (parent)
 955                 psmouse_activate(parent);
 956
 957         up(&psmouse_sem);
 958         return retval;
 959 }
 960
 961
 962 static int psmouse_reconnect(struct serio *serio)
 963 {
 964         struct psmouse *psmouse = serio_get_drvdata(serio);
 965         struct psmouse *parent = NULL;
 966         struct serio_driver *drv = serio->drv;
 967         int rc = -1;
 968
 969         if (!drv || !psmouse) {
 970                 printk(KERN_DEBUG "psmouse: reconnect request, but serio is disconnected, ignoring...\n");
 971                 return -1;
 972         }
 973
 974         down(&psmouse_sem);
 975
 976         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
 977                 parent = serio_get_drvdata(serio->parent);
 978                 psmouse_deactivate(parent);
 979         }
 980
 981         psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
 982
 983         if (psmouse->reconnect) {
 984                 if (psmouse->reconnect(psmouse))
 985                         goto out;
 986         } else if (psmouse_probe(psmouse) < 0 ||
 987                    psmouse->type != psmouse_extensions(psmouse, psmouse_max_proto, 0))
 988                 goto out;
 989
 990         /* ok, the device type (and capabilities) match the old one,
 991          * we can continue using it, complete intialization
 992          */
 993         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
 994
 995         psmouse_initialize(psmouse);
 996
 997         if (parent && parent->pt_activate)
 998                 parent->pt_activate(parent);
 999
1000         psmouse_activate(psmouse);
1001         rc = 0;
1002
1003 out:
1004         /* If this is a pass-through port the parent waits to be activated */
1005         if (parent)
1006                 psmouse_activate(parent);
1007
1008         up(&psmouse_sem);
1009         return rc;
1010 }
1011
1012 static struct serio_device_id psmouse_serio_ids[] = {
1013         {
1014                 .type   = SERIO_8042,
1015                 .proto  = SERIO_ANY,
1016                 .id     = SERIO_ANY,
1017                 .extra  = SERIO_ANY,
1018         },
1019         {
1020                 .type   = SERIO_PS_PSTHRU,
1021                 .proto  = SERIO_ANY,
1022                 .id     = SERIO_ANY,
1023                 .extra  = SERIO_ANY,
1024         },
1025         { 0 }
1026 };
1027
1028 MODULE_DEVICE_TABLE(serio, psmouse_serio_ids);
1029
1030 static struct serio_driver psmouse_drv = {
1031         .driver         = {
1032                 .name   = "psmouse",
1033         },
1034         .description    = DRIVER_DESC,
1035         .id_table       = psmouse_serio_ids,
1036         .interrupt      = psmouse_interrupt,
1037         .connect        = psmouse_connect,
1038         .reconnect      = psmouse_reconnect,
1039         .disconnect     = psmouse_disconnect,
1040         .cleanup        = psmouse_cleanup,
1041 };
1042
1043 ssize_t psmouse_attr_show_helper(struct device *dev, char *buf,
1044                                  ssize_t (*handler)(struct psmouse *, char *))
1045 {
1046         struct serio *serio = to_serio_port(dev);
1047         int retval;
1048
1049         retval = serio_pin_driver(serio);
1050         if (retval)
1051                 return retval;
1052
1053         if (serio->drv != &psmouse_drv) {
1054                 retval = -ENODEV;
1055                 goto out;
1056         }
1057
1058         retval = handler(serio_get_drvdata(serio), buf);
1059
1060 out:
1061         serio_unpin_driver(serio);
1062         return retval;
1063 }
1064
1065 ssize_t psmouse_attr_set_helper(struct device *dev, const char *buf, size_t count,
1066                                 ssize_t (*handler)(struct psmouse *, const char *, size_t))
1067 {
1068         struct serio *serio = to_serio_port(dev);
1069         struct psmouse *psmouse = serio_get_drvdata(serio);
1070         struct psmouse *parent = NULL;
1071         int retval;
1072
1073         retval = serio_pin_driver(serio);
1074         if (retval)
1075                 return retval;
1076
1077         if (serio->drv != &psmouse_drv) {
1078                 retval = -ENODEV;
1079                 goto out_unpin;
1080         }
1081
1082         retval = down_interruptible(&psmouse_sem);
1083         if (retval)
1084                 goto out_unpin;
1085
1086         if (psmouse->state == PSMOUSE_IGNORE) {
1087                 retval = -ENODEV;
1088                 goto out_up;
1089         }
1090
1091         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1092                 parent = serio_get_drvdata(serio->parent);
1093                 psmouse_deactivate(parent);
1094         }
1095
1096         psmouse_deactivate(psmouse);
1097
1098         retval = handler(psmouse, buf, count);
1099
1100         if (retval != -ENODEV)
1101                 psmouse_activate(psmouse);
1102
1103         if (parent)
1104                 psmouse_activate(parent);
1105
1106  out_up:
1107         up(&psmouse_sem);
1108  out_unpin:
1109         serio_unpin_driver(serio);
1110         return retval;
1111 }
1112
1113 static ssize_t psmouse_attr_show_protocol(struct psmouse *psmouse, char *buf)
1114 {
1115         return sprintf(buf, "%s\n", psmouse_protocol_by_type(psmouse->type)->name);
1116 }
1117
1118 static ssize_t psmouse_attr_set_protocol(struct psmouse *psmouse, const char *buf, size_t count)
1119 {
1120         struct serio *serio = psmouse->ps2dev.serio;
1121         struct psmouse *parent = NULL;
1122         struct psmouse_protocol *proto;
1123         int retry = 0;
1124
1125         if (!(proto = psmouse_protocol_by_name(buf, count)))
1126                 return -EINVAL;
1127
1128         if (psmouse->type == proto->type)
1129                 return count;
1130
1131         while (serio->child) {
1132                 if (++retry > 3) {
1133                         printk(KERN_WARNING "psmouse: failed to destroy child port, protocol change aborted.\n");
1134                         return -EIO;
1135                 }
1136
1137                 up(&psmouse_sem);
1138                 serio_unpin_driver(serio);
1139                 serio_unregister_child_port(serio);
1140                 serio_pin_driver_uninterruptible(serio);
1141                 down(&psmouse_sem);
1142
1143                 if (serio->drv != &psmouse_drv)
1144                         return -ENODEV;
1145
1146                 if (psmouse->type == proto->type)
1147                         return count; /* switched by other thread */
1148         }
1149
1150         if (serio->parent && serio->id.type == SERIO_PS_PSTHRU) {
1151                 parent = serio_get_drvdata(serio->parent);
1152                 if (parent->pt_deactivate)
1153                         parent->pt_deactivate(parent);
1154         }
1155
1156         if (psmouse->disconnect)
1157                 psmouse->disconnect(psmouse);
1158
1159         psmouse_set_state(psmouse, PSMOUSE_IGNORE);
1160         input_unregister_device(&psmouse->dev);
1161
1162         psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
1163
1164         if (psmouse_switch_protocol(psmouse, proto) < 0) {
1165                 psmouse_reset(psmouse);
1166                 /* default to PSMOUSE_PS2 */
1167                 psmouse_switch_protocol(psmouse, &psmouse_protocols[0]);
1168         }
1169
1170         psmouse_initialize(psmouse);
1171         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
1172
1173         input_register_device(&psmouse->dev);
1174         printk(KERN_INFO "input: %s on %s\n", psmouse->devname, serio->phys);
1175
1176         if (parent && parent->pt_activate)
1177                 parent->pt_activate(parent);
1178
1179         return count;
1180 }
1181
1182 static ssize_t psmouse_attr_show_rate(struct psmouse *psmouse, char *buf)
1183 {
1184         return sprintf(buf, "%d\n", psmouse->rate);
1185 }
1186
1187 static ssize_t psmouse_attr_set_rate(struct psmouse *psmouse, const char *buf, size_t count)
1188 {
1189         unsigned long value;
1190         char *rest;
1191
1192         value = simple_strtoul(buf, &rest, 10);
1193         if (*rest)
1194                 return -EINVAL;
1195
1196         psmouse->set_rate(psmouse, value);
1197         return count;
1198 }
1199
1200 static ssize_t psmouse_attr_show_resolution(struct psmouse *psmouse, char *buf)
1201 {
1202         return sprintf(buf, "%d\n", psmouse->resolution);
1203 }
1204
1205 static ssize_t psmouse_attr_set_resolution(struct psmouse *psmouse, const char *buf, size_t count)
1206 {
1207         unsigned long value;
1208         char *rest;
1209
1210         value = simple_strtoul(buf, &rest, 10);
1211         if (*rest)
1212                 return -EINVAL;
1213
1214         psmouse->set_resolution(psmouse, value);
1215         return count;
1216 }
1217
1218 static ssize_t psmouse_attr_show_resetafter(struct psmouse *psmouse, char *buf)
1219 {
1220         return sprintf(buf, "%d\n", psmouse->resetafter);
1221 }
1222
1223 static ssize_t psmouse_attr_set_resetafter(struct psmouse *psmouse, const char *buf, size_t count)
1224 {
1225         unsigned long value;
1226         char *rest;
1227
1228         value = simple_strtoul(buf, &rest, 10);
1229         if (*rest)
1230                 return -EINVAL;
1231
1232         psmouse->resetafter = value;
1233         return count;
1234 }
1235
1236 static int psmouse_set_maxproto(const char *val, struct kernel_param *kp)
1237 {
1238         struct psmouse_protocol *proto;
1239
1240         if (!val)
1241                 return -EINVAL;
1242
1243         proto = psmouse_protocol_by_name(val, strlen(val));
1244
1245         if (!proto || !proto->maxproto)
1246                 return -EINVAL;
1247
1248         *((unsigned int *)kp->arg) = proto->type;
1249
1250         return 0;
1251 }
1252
1253 static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp)
1254 {
1255         int type = *((unsigned int *)kp->arg);
1256
1257         return sprintf(buffer, "%s\n", psmouse_protocol_by_type(type)->name);
1258 }
1259
1260 static int __init psmouse_init(void)
1261 {
1262         serio_register_driver(&psmouse_drv);
1263         return 0;
1264 }
1265
1266 static void __exit psmouse_exit(void)
1267 {
1268         serio_unregister_driver(&psmouse_drv);
1269 }
1270
1271 module_init(psmouse_init);
1272 module_exit(psmouse_exit);