drivers/input/mouse/psmouse-base.c

   1 /*
   2  * PS/2 mouse driver
   3  *
   4  * Copyright (c) 1999-2002 Vojtech Pavlik
   5  */
   6
   7 /*
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License version 2 as published by
  10  * the Free Software Foundation.
  11  */
  12
  13 #include <linux/delay.h>
  14 #include <linux/module.h>
  15 #include <linux/moduleparam.h>
  16 #include <linux/slab.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/input.h>
  19 #include <linux/serio.h>
  20 #include <linux/init.h>
  21 #include "psmouse.h"
  22 #include "synaptics.h"
  23 #include "logips2pp.h"
  24
  25 #define DRIVER_DESC     "PS/2 mouse driver"
  26
  27 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  28 MODULE_DESCRIPTION(DRIVER_DESC);
  29 MODULE_LICENSE("GPL");
  30
  31 static char *psmouse_proto;
  32 static unsigned int psmouse_max_proto = -1U;
  33 module_param_named(proto, psmouse_proto, charp, 0);
  34 MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps). Useful for KVM switches.");
  35
  36 int psmouse_resolution = 200;
  37 module_param_named(resolution, psmouse_resolution, uint, 0);
  38 MODULE_PARM_DESC(resolution, "Resolution, in dpi.");
  39
  40 unsigned int psmouse_rate = 100;
  41 module_param_named(rate, psmouse_rate, uint, 0);
  42 MODULE_PARM_DESC(rate, "Report rate, in reports per second.");
  43
  44 int psmouse_smartscroll = 1;
  45 module_param_named(smartscroll, psmouse_smartscroll, bool, 0);
  46 MODULE_PARM_DESC(smartscroll, "Logitech Smartscroll autorepeat, 1 = enabled (default), 0 = disabled.");
  47
  48 static unsigned int psmouse_resetafter;
  49 module_param_named(resetafter, psmouse_resetafter, uint, 0);
  50 MODULE_PARM_DESC(resetafter, "Reset device after so many bad packets (0 = never).");
  51
  52 __obsolete_setup("psmouse_noext");
  53 __obsolete_setup("psmouse_resolution=");
  54 __obsolete_setup("psmouse_smartscroll=");
  55 __obsolete_setup("psmouse_resetafter=");
  56 __obsolete_setup("psmouse_rate=");
  57
  58 static char *psmouse_protocols[] = { "None", "PS/2", "PS2++", "PS2T++", "GenPS/2", "ImPS/2", "ImExPS/2", "SynPS/2"};
  59
  60 /*
  61  * psmouse_process_byte() analyzes the PS/2 data stream and reports
  62  * relevant events to the input module once full packet has arrived.
  63  */
  64
  65 static psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse, struct pt_regs *regs)
  66 {
  67         struct input_dev *dev = &psmouse->dev;
  68         unsigned char *packet = psmouse->packet;
  69
  70         if (psmouse->pktcnt < 3 + (psmouse->type >= PSMOUSE_GENPS))
  71                 return PSMOUSE_GOOD_DATA;
  72
  73 /*
  74  * Full packet accumulated, process it
  75  */
  76
  77         input_regs(dev, regs);
  78
  79 /*
  80  * The PS2++ protocol is a little bit complex
  81  */
  82
  83         if (psmouse->type == PSMOUSE_PS2PP || psmouse->type == PSMOUSE_PS2TPP)
  84                 ps2pp_process_packet(psmouse);
  85
  86 /*
  87  * Scroll wheel on IntelliMice, scroll buttons on NetMice
  88  */
  89
  90         if (psmouse->type == PSMOUSE_IMPS || psmouse->type == PSMOUSE_GENPS)
  91                 input_report_rel(dev, REL_WHEEL, -(signed char) packet[3]);
  92
  93 /*
  94  * Scroll wheel and buttons on IntelliMouse Explorer
  95  */
  96
  97         if (psmouse->type == PSMOUSE_IMEX) {
  98                 input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 8) - (int) (packet[3] & 7));
  99                 input_report_key(dev, BTN_SIDE, (packet[3] >> 4) & 1);
 100                 input_report_key(dev, BTN_EXTRA, (packet[3] >> 5) & 1);
 101         }
 102
 103 /*
 104  * Extra buttons on Genius NewNet 3D
 105  */
 106
 107         if (psmouse->type == PSMOUSE_GENPS) {
 108                 input_report_key(dev, BTN_SIDE, (packet[0] >> 6) & 1);
 109                 input_report_key(dev, BTN_EXTRA, (packet[0] >> 7) & 1);
 110         }
 111
 112 /*
 113  * Generic PS/2 Mouse
 114  */
 115
 116         input_report_key(dev, BTN_LEFT,    packet[0]       & 1);
 117         input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1);
 118         input_report_key(dev, BTN_RIGHT,  (packet[0] >> 1) & 1);
 119
 120         input_report_rel(dev, REL_X, packet[1] ? (int) packet[1] - (int) ((packet[0] << 4) & 0x100) : 0);
 121         input_report_rel(dev, REL_Y, packet[2] ? (int) ((packet[0] << 3) & 0x100) - (int) packet[2] : 0);
 122
 123         input_sync(dev);
 124
 125         return PSMOUSE_FULL_PACKET;
 126 }
 127
 128 /*
 129  * psmouse_interrupt() handles incoming characters, either gathering them into
 130  * packets or passing them to the command routine as command output.
 131  */
 132
 133 static irqreturn_t psmouse_interrupt(struct serio *serio,
 134                 unsigned char data, unsigned int flags, struct pt_regs *regs)
 135 {
 136         struct psmouse *psmouse = serio->private;
 137         psmouse_ret_t rc;
 138
 139         if (psmouse->state == PSMOUSE_IGNORE)
 140                 goto out;
 141
 142         if (flags & (SERIO_PARITY|SERIO_TIMEOUT)) {
 143                 if (psmouse->state == PSMOUSE_ACTIVATED)
 144                         printk(KERN_WARNING "psmouse.c: bad data from KBC -%s%s\n",
 145                                 flags & SERIO_TIMEOUT ? " timeout" : "",
 146                                 flags & SERIO_PARITY ? " bad parity" : "");
 147                 psmouse->nak = 1;
 148                 clear_bit(PSMOUSE_FLAG_ACK, &psmouse->flags);
 149                 clear_bit(PSMOUSE_FLAG_CMD,  &psmouse->flags);
 150                 wake_up_interruptible(&psmouse->wait);
 151                 goto out;
 152         }
 153
 154         if (test_bit(PSMOUSE_FLAG_ACK, &psmouse->flags)) {
 155                 switch (data) {
 156                         case PSMOUSE_RET_ACK:
 157                                 psmouse->nak = 0;
 158                                 break;
 159
 160                         case PSMOUSE_RET_NAK:
 161                                 psmouse->nak = 1;
 162                                 break;
 163
 164                         /*
 165                          * Workaround for mice which don't ACK the Get ID command.
 166                          * These are valid mouse IDs that we recognize.
 167                          */
 168                         case 0x00:
 169                         case 0x03:
 170                         case 0x04:
 171                                 if (test_bit(PSMOUSE_FLAG_WAITID, &psmouse->flags)) {
 172                                         psmouse->nak = 0;
 173                                         break;
 174                                 }
 175                                 /* Fall through */
 176                         default:
 177                                 goto out;
 178                 }
 179
 180                 if (!psmouse->nak && psmouse->cmdcnt) {
 181                         set_bit(PSMOUSE_FLAG_CMD, &psmouse->flags);
 182                         set_bit(PSMOUSE_FLAG_CMD1, &psmouse->flags);
 183                 }
 184                 clear_bit(PSMOUSE_FLAG_ACK, &psmouse->flags);
 185                 wake_up_interruptible(&psmouse->wait);
 186
 187                 if (data == PSMOUSE_RET_ACK || data == PSMOUSE_RET_NAK)
 188                         goto out;
 189         }
 190
 191         if (test_bit(PSMOUSE_FLAG_CMD, &psmouse->flags)) {
 192                 if (psmouse->cmdcnt)
 193                         psmouse->cmdbuf[--psmouse->cmdcnt] = data;
 194
 195                 if (test_and_clear_bit(PSMOUSE_FLAG_CMD1, &psmouse->flags) && psmouse->cmdcnt)
 196                         wake_up_interruptible(&psmouse->wait);
 197
 198                 if (!psmouse->cmdcnt) {
 199                         clear_bit(PSMOUSE_FLAG_CMD, &psmouse->flags);
 200                         wake_up_interruptible(&psmouse->wait);
 201                 }
 202                 goto out;
 203         }
 204
 205         if (psmouse->state == PSMOUSE_INITIALIZING)
 206                 goto out;
 207
 208         if (psmouse->state == PSMOUSE_ACTIVATED &&
 209             psmouse->pktcnt && time_after(jiffies, psmouse->last + HZ/2)) {
 210                 printk(KERN_WARNING "psmouse.c: %s at %s lost synchronization, throwing %d bytes away.\n",
 211                        psmouse->name, psmouse->phys, psmouse->pktcnt);
 212                 psmouse->pktcnt = 0;
 213         }
 214
 215         psmouse->last = jiffies;
 216         psmouse->packet[psmouse->pktcnt++] = data;
 217
 218         if (psmouse->packet[0] == PSMOUSE_RET_BAT) {
 219                 if (psmouse->pktcnt == 1)
 220                         goto out;
 221
 222                 if (psmouse->pktcnt == 2) {
 223                         if (psmouse->packet[1] == PSMOUSE_RET_ID) {
 224                                 psmouse->state = PSMOUSE_IGNORE;
 225                                 serio_reconnect(serio);
 226                                 goto out;
 227                         }
 228                         if (psmouse->type == PSMOUSE_SYNAPTICS) {
 229                                 /* neither 0xAA nor 0x00 are valid first bytes
 230                                  * for a packet in absolute mode
 231                                  */
 232                                 psmouse->pktcnt = 0;
 233                                 goto out;
 234                         }
 235                 }
 236         }
 237
 238         rc = psmouse->protocol_handler(psmouse, regs);
 239
 240         switch (rc) {
 241                 case PSMOUSE_BAD_DATA:
 242                         printk(KERN_WARNING "psmouse.c: %s at %s lost sync at byte %d\n",
 243                                 psmouse->name, psmouse->phys, psmouse->pktcnt);
 244                         psmouse->pktcnt = 0;
 245
 246                         if (++psmouse->out_of_sync == psmouse_resetafter) {
 247                                 psmouse->state = PSMOUSE_IGNORE;
 248                                 printk(KERN_NOTICE "psmouse.c: issuing reconnect request\n");
 249                                 serio_reconnect(psmouse->serio);
 250                         }
 251                         break;
 252
 253                 case PSMOUSE_FULL_PACKET:
 254                         psmouse->pktcnt = 0;
 255                         if (psmouse->out_of_sync) {
 256                                 psmouse->out_of_sync = 0;
 257                                 printk(KERN_NOTICE "psmouse.c: %s at %s - driver resynched.\n",
 258                                         psmouse->name, psmouse->phys);
 259                         }
 260                         break;
 261
 262                 case PSMOUSE_GOOD_DATA:
 263                         break;
 264         }
 265 out:
 266         return IRQ_HANDLED;
 267 }
 268
 269 /*
 270  * psmouse_sendbyte() sends a byte to the mouse, and waits for acknowledge.
 271  * It doesn't handle retransmission, though it could - because when there would
 272  * be need for retransmissions, the mouse has to be replaced anyway.
 273  *
 274  * psmouse_sendbyte() can only be called from a process context
 275  */
 276
 277 static int psmouse_sendbyte(struct psmouse *psmouse, unsigned char byte)
 278 {
 279         psmouse->nak = 1;
 280         set_bit(PSMOUSE_FLAG_ACK, &psmouse->flags);
 281
 282         if (serio_write(psmouse->serio, byte) == 0)
 283                 wait_event_interruptible_timeout(psmouse->wait,
 284                                 !test_bit(PSMOUSE_FLAG_ACK, &psmouse->flags),
 285                                 msecs_to_jiffies(200));
 286
 287         clear_bit(PSMOUSE_FLAG_ACK, &psmouse->flags);
 288         return -psmouse->nak;
 289 }
 290
 291 /*
 292  * psmouse_command() sends a command and its parameters to the mouse,
 293  * then waits for the response and puts it in the param array.
 294  *
 295  * psmouse_command() can only be called from a process context
 296  */
 297
 298 int psmouse_command(struct psmouse *psmouse, unsigned char *param, int command)
 299 {
 300         int timeout;
 301         int send = (command >> 12) & 0xf;
 302         int receive = (command >> 8) & 0xf;
 303         int rc = -1;
 304         int i;
 305
 306         timeout = msecs_to_jiffies(command == PSMOUSE_CMD_RESET_BAT ? 4000 : 500);
 307
 308         clear_bit(PSMOUSE_FLAG_CMD, &psmouse->flags);
 309         if (command == PSMOUSE_CMD_GETID)
 310                 set_bit(PSMOUSE_FLAG_WAITID, &psmouse->flags);
 311
 312         if (receive && param)
 313                 for (i = 0; i < receive; i++)
 314                         psmouse->cmdbuf[(receive - 1) - i] = param[i];
 315
 316         psmouse->cmdcnt = receive;
 317
 318         if (command & 0xff)
 319                 if (psmouse_sendbyte(psmouse, command & 0xff))
 320                         goto out;
 321
 322         for (i = 0; i < send; i++)
 323                 if (psmouse_sendbyte(psmouse, param[i]))
 324                         goto out;
 325
 326         timeout = wait_event_interruptible_timeout(psmouse->wait,
 327                                 !test_bit(PSMOUSE_FLAG_CMD1, &psmouse->flags), timeout);
 328
 329         if (psmouse->cmdcnt && timeout > 0) {
 330                 if (command == PSMOUSE_CMD_RESET_BAT && jiffies_to_msecs(timeout) > 100)
 331                         timeout = msecs_to_jiffies(100);
 332
 333                 if (command == PSMOUSE_CMD_GETID &&
 334                     psmouse->cmdbuf[receive - 1] != 0xab && psmouse->cmdbuf[receive - 1] != 0xac) {
 335                         /*
 336                          * Device behind the port is not a keyboard
 337                          * so we don't need to wait for the 2nd byte
 338                          * of ID response.
 339                          */
 340                         clear_bit(PSMOUSE_FLAG_CMD, &psmouse->flags);
 341                         psmouse->cmdcnt = 0;
 342                 }
 343
 344                 wait_event_interruptible_timeout(psmouse->wait,
 345                                 !test_bit(PSMOUSE_FLAG_CMD, &psmouse->flags), timeout);
 346         }
 347
 348         if (param)
 349                 for (i = 0; i < receive; i++)
 350                         param[i] = psmouse->cmdbuf[(receive - 1) - i];
 351
 352         if (psmouse->cmdcnt && (command != PSMOUSE_CMD_RESET_BAT || psmouse->cmdcnt != 1))
 353                 goto out;
 354
 355         rc = 0;
 356
 357 out:
 358         clear_bit(PSMOUSE_FLAG_CMD, &psmouse->flags);
 359         clear_bit(PSMOUSE_FLAG_CMD1, &psmouse->flags);
 360         clear_bit(PSMOUSE_FLAG_WAITID, &psmouse->flags);
 361         return rc;
 362 }
 363
 364 /*
 365  * psmouse_sliced_command() sends an extended PS/2 command to the mouse
 366  * using sliced syntax, understood by advanced devices, such as Logitech
 367  * or Synaptics touchpads. The command is encoded as:
 368  * 0xE6 0xE8 rr 0xE8 ss 0xE8 tt 0xE8 uu where (rr*64)+(ss*16)+(tt*4)+uu
 369  * is the command.
 370  */
 371 int psmouse_sliced_command(struct psmouse *psmouse, unsigned char command)
 372 {
 373         int i;
 374
 375         if (psmouse_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11))
 376                 return -1;
 377
 378         for (i = 6; i >= 0; i -= 2) {
 379                 unsigned char d = (command >> i) & 3;
 380                 if (psmouse_command(psmouse, &d, PSMOUSE_CMD_SETRES))
 381                         return -1;
 382         }
 383
 384         return 0;
 385 }
 386
 387
 388 /*
 389  * psmouse_reset() resets the mouse into power-on state.
 390  */
 391 int psmouse_reset(struct psmouse *psmouse)
 392 {
 393         unsigned char param[2];
 394
 395         if (psmouse_command(psmouse, param, PSMOUSE_CMD_RESET_BAT))
 396                 return -1;
 397
 398         if (param[0] != PSMOUSE_RET_BAT && param[1] != PSMOUSE_RET_ID)
 399                 return -1;
 400
 401         return 0;
 402 }
 403
 404
 405 /*
 406  * Genius NetMouse magic init.
 407  */
 408 static int genius_detect(struct psmouse *psmouse)
 409 {
 410         unsigned char param[4];
 411
 412         param[0] = 3;
 413         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRES);
 414         psmouse_command(psmouse,  NULL, PSMOUSE_CMD_SETSCALE11);
 415         psmouse_command(psmouse,  NULL, PSMOUSE_CMD_SETSCALE11);
 416         psmouse_command(psmouse,  NULL, PSMOUSE_CMD_SETSCALE11);
 417         psmouse_command(psmouse, param, PSMOUSE_CMD_GETINFO);
 418
 419         return param[0] == 0x00 && param[1] == 0x33 && param[2] == 0x55;
 420 }
 421
 422 /*
 423  * IntelliMouse magic init.
 424  */
 425 static int intellimouse_detect(struct psmouse *psmouse)
 426 {
 427         unsigned char param[2];
 428
 429         param[0] = 200;
 430         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRATE);
 431         param[0] = 100;
 432         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRATE);
 433         param[0] =  80;
 434         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRATE);
 435         psmouse_command(psmouse, param, PSMOUSE_CMD_GETID);
 436
 437         return param[0] == 3;
 438 }
 439
 440 /*
 441  * Try IntelliMouse/Explorer magic init.
 442  */
 443 static int im_explorer_detect(struct psmouse *psmouse)
 444 {
 445         unsigned char param[2];
 446
 447         intellimouse_detect(psmouse);
 448
 449         param[0] = 200;
 450         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRATE);
 451         param[0] = 200;
 452         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRATE);
 453         param[0] =  80;
 454         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRATE);
 455         psmouse_command(psmouse, param, PSMOUSE_CMD_GETID);
 456
 457         return param[0] == 4;
 458 }
 459
 460 /*
 461  * psmouse_extensions() probes for any extensions to the basic PS/2 protocol
 462  * the mouse may have.
 463  */
 464
 465 static int psmouse_extensions(struct psmouse *psmouse,
 466                               unsigned int max_proto, int set_properties)
 467 {
 468         int synaptics_hardware = 0;
 469
 470 /*
 471  * Try Synaptics TouchPad
 472  */
 473         if (max_proto > PSMOUSE_PS2 && synaptics_detect(psmouse)) {
 474                 synaptics_hardware = 1;
 475
 476                 if (set_properties) {
 477                         psmouse->vendor = "Synaptics";
 478                         psmouse->name = "TouchPad";
 479                 }
 480
 481                 if (max_proto > PSMOUSE_IMEX) {
 482                         if (!set_properties || synaptics_init(psmouse) == 0)
 483                                 return PSMOUSE_SYNAPTICS;
 484 /*
 485  * Some Synaptics touchpads can emulate extended protocols (like IMPS/2).
 486  * Unfortunately Logitech/Genius probes confuse some firmware versions so
 487  * we'll have to skip them.
 488  */
 489                         max_proto = PSMOUSE_IMEX;
 490                 }
 491 /*
 492  * Make sure that touchpad is in relative mode, gestures (taps) are enabled
 493  */
 494                 synaptics_reset(psmouse);
 495         }
 496
 497         if (max_proto > PSMOUSE_IMEX && genius_detect(psmouse)) {
 498
 499                 if (set_properties) {
 500                         set_bit(BTN_EXTRA, psmouse->dev.keybit);
 501                         set_bit(BTN_SIDE, psmouse->dev.keybit);
 502                         set_bit(REL_WHEEL, psmouse->dev.relbit);
 503                         psmouse->vendor = "Genius";
 504                         psmouse->name = "Wheel Mouse";
 505                 }
 506
 507                 return PSMOUSE_GENPS;
 508         }
 509
 510         if (max_proto > PSMOUSE_IMEX) {
 511                 int type = ps2pp_init(psmouse, set_properties);
 512                 if (type > PSMOUSE_PS2)
 513                         return type;
 514         }
 515
 516         if (max_proto >= PSMOUSE_IMEX && im_explorer_detect(psmouse)) {
 517
 518                 if (set_properties) {
 519                         set_bit(REL_WHEEL, psmouse->dev.relbit);
 520                         set_bit(BTN_SIDE, psmouse->dev.keybit);
 521                         set_bit(BTN_EXTRA, psmouse->dev.keybit);
 522                         if (!psmouse->name)
 523                                 psmouse->name = "Explorer Mouse";
 524                 }
 525
 526                 return PSMOUSE_IMEX;
 527         }
 528
 529         if (max_proto >= PSMOUSE_IMPS && intellimouse_detect(psmouse)) {
 530
 531                 if (set_properties) {
 532                         set_bit(REL_WHEEL, psmouse->dev.relbit);
 533                         if (!psmouse->name)
 534                                 psmouse->name = "Wheel Mouse";
 535                 }
 536
 537                 return PSMOUSE_IMPS;
 538         }
 539
 540 /*
 541  * Okay, all failed, we have a standard mouse here. The number of the buttons
 542  * is still a question, though. We assume 3.
 543  */
 544         if (synaptics_hardware) {
 545 /*
 546  * We detected Synaptics hardware but it did not respond to IMPS/2 probes.
 547  * We need to reset the touchpad because if there is a track point on the
 548  * pass through port it could get disabled while probing for protocol
 549  * extensions.
 550  */
 551                 psmouse_reset(psmouse);
 552                 psmouse_command(psmouse, NULL, PSMOUSE_CMD_RESET_DIS);
 553         }
 554
 555         return PSMOUSE_PS2;
 556 }
 557
 558 /*
 559  * psmouse_probe() probes for a PS/2 mouse.
 560  */
 561
 562 static int psmouse_probe(struct psmouse *psmouse)
 563 {
 564         unsigned char param[2];
 565
 566 /*
 567  * First, we check if it's a mouse. It should send 0x00 or 0x03
 568  * in case of an IntelliMouse in 4-byte mode or 0x04 for IM Explorer.
 569  */
 570
 571         param[0] = 0xa5;
 572
 573         if (psmouse_command(psmouse, param, PSMOUSE_CMD_GETID))
 574                 return -1;
 575
 576         if (param[0] != 0x00 && param[0] != 0x03 && param[0] != 0x04)
 577                 return -1;
 578
 579 /*
 580  * Then we reset and disable the mouse so that it doesn't generate events.
 581  */
 582
 583         if (psmouse_command(psmouse, NULL, PSMOUSE_CMD_RESET_DIS))
 584                 printk(KERN_WARNING "psmouse.c: Failed to reset mouse on %s\n", psmouse->serio->phys);
 585
 586         return 0;
 587 }
 588
 589 /*
 590  * Here we set the mouse resolution.
 591  */
 592
 593 static void psmouse_set_resolution(struct psmouse *psmouse)
 594 {
 595         unsigned char param[1];
 596
 597         if (psmouse->type == PSMOUSE_PS2PP && psmouse_resolution > 400) {
 598                 ps2pp_set_800dpi(psmouse);
 599                 return;
 600         }
 601
 602         if (!psmouse_resolution || psmouse_resolution >= 200)
 603                 param[0] = 3;
 604         else if (psmouse_resolution >= 100)
 605                 param[0] = 2;
 606         else if (psmouse_resolution >= 50)
 607                 param[0] = 1;
 608         else if (psmouse_resolution)
 609                 param[0] = 0;
 610
 611         psmouse_command(psmouse, param, PSMOUSE_CMD_SETRES);
 612 }
 613
 614 /*
 615  * Here we set the mouse report rate.
 616  */
 617
 618 static void psmouse_set_rate(struct psmouse *psmouse)
 619 {
 620         unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10, 0 };
 621         int i = 0;
 622
 623         while (rates[i] > psmouse_rate) i++;
 624         psmouse_command(psmouse, rates + i, PSMOUSE_CMD_SETRATE);
 625 }
 626
 627 /*
 628  * psmouse_initialize() initializes the mouse to a sane state.
 629  */
 630
 631 static void psmouse_initialize(struct psmouse *psmouse)
 632 {
 633         unsigned char param[2];
 634
 635 /*
 636  * We set the mouse report rate, resolution and scaling.
 637  */
 638
 639         if (psmouse_max_proto != PSMOUSE_PS2) {
 640                 psmouse_set_rate(psmouse);
 641                 psmouse_set_resolution(psmouse);
 642                 psmouse_command(psmouse,  NULL, PSMOUSE_CMD_SETSCALE11);
 643         }
 644
 645 /*
 646  * We set the mouse into streaming mode.
 647  */
 648
 649         psmouse_command(psmouse, param, PSMOUSE_CMD_SETSTREAM);
 650 }
 651
 652 /*
 653  * psmouse_set_state() sets new psmouse state and resets all flags and
 654  * counters while holding serio lock so fighting with interrupt handler
 655  * is not a concern.
 656  */
 657
 658 static void psmouse_set_state(struct psmouse *psmouse, enum psmouse_state new_state)
 659 {
 660         serio_pause_rx(psmouse->serio);
 661         psmouse->state = new_state;
 662         psmouse->pktcnt = psmouse->cmdcnt = psmouse->out_of_sync = 0;
 663         psmouse->flags = 0;
 664         serio_continue_rx(psmouse->serio);
 665 }
 666
 667 /*
 668  * psmouse_activate() enables the mouse so that we get motion reports from it.
 669  */
 670
 671 static void psmouse_activate(struct psmouse *psmouse)
 672 {
 673         if (psmouse_command(psmouse, NULL, PSMOUSE_CMD_ENABLE))
 674                 printk(KERN_WARNING "psmouse.c: Failed to enable mouse on %s\n", psmouse->serio->phys);
 675
 676         psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
 677 }
 678
 679
 680 /*
 681  * psmouse_deactivate() puts the mouse into poll mode so that we don't get motion
 682  * reports from it unless we explicitely request it.
 683  */
 684
 685 static void psmouse_deactivate(struct psmouse *psmouse)
 686 {
 687         if (psmouse_command(psmouse, NULL, PSMOUSE_CMD_DISABLE))
 688                 printk(KERN_WARNING "psmouse.c: Failed to deactivate mouse on %s\n", psmouse->serio->phys);
 689
 690         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
 691 }
 692
 693
 694 /*
 695  * psmouse_cleanup() resets the mouse into power-on state.
 696  */
 697
 698 static void psmouse_cleanup(struct serio *serio)
 699 {
 700         struct psmouse *psmouse = serio->private;
 701
 702         psmouse_reset(psmouse);
 703 }
 704
 705 /*
 706  * psmouse_disconnect() closes and frees.
 707  */
 708
 709 static void psmouse_disconnect(struct serio *serio)
 710 {
 711         struct psmouse *psmouse, *parent;
 712
 713         psmouse = serio->private;
 714         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
 715
 716         if (serio->parent && (serio->type & SERIO_TYPE) == SERIO_PS_PSTHRU) {
 717                 parent = serio->parent->private;
 718                 if (parent->pt_deactivate)
 719                         parent->pt_deactivate(parent);
 720         }
 721
 722         if (psmouse->disconnect)
 723                 psmouse->disconnect(psmouse);
 724
 725         psmouse_set_state(psmouse, PSMOUSE_IGNORE);
 726
 727         input_unregister_device(&psmouse->dev);
 728         serio_close(serio);
 729         kfree(psmouse);
 730 }
 731
 732 /*
 733  * psmouse_connect() is a callback from the serio module when
 734  * an unhandled serio port is found.
 735  */
 736 static void psmouse_connect(struct serio *serio, struct serio_driver *drv)
 737 {
 738         struct psmouse *psmouse, *parent = NULL;
 739
 740         if ((serio->type & SERIO_TYPE) != SERIO_8042 &&
 741             (serio->type & SERIO_TYPE) != SERIO_PS_PSTHRU)
 742                 return;
 743
 744         /*
 745          * If this is a pass-through port deactivate parent so the device
 746          * connected to this port can be successfully identified
 747          */
 748         if (serio->parent && (serio->type & SERIO_TYPE) == SERIO_PS_PSTHRU) {
 749                 parent = serio->parent->private;
 750                 psmouse_deactivate(parent);
 751         }
 752
 753         if (!(psmouse = kmalloc(sizeof(struct psmouse), GFP_KERNEL)))
 754                 goto out;
 755
 756         memset(psmouse, 0, sizeof(struct psmouse));
 757
 758         init_waitqueue_head(&psmouse->wait);
 759         init_input_dev(&psmouse->dev);
 760         psmouse->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
 761         psmouse->dev.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_MIDDLE) | BIT(BTN_RIGHT);
 762         psmouse->dev.relbit[0] = BIT(REL_X) | BIT(REL_Y);
 763         psmouse->serio = serio;
 764         psmouse->dev.private = psmouse;
 765         psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
 766
 767         serio->private = psmouse;
 768         if (serio_open(serio, drv)) {
 769                 kfree(psmouse);
 770                 serio->private = NULL;
 771                 goto out;
 772         }
 773
 774         if (psmouse_probe(psmouse) < 0) {
 775                 serio_close(serio);
 776                 kfree(psmouse);
 777                 serio->private = NULL;
 778                 goto out;
 779         }
 780
 781         psmouse->type = psmouse_extensions(psmouse, psmouse_max_proto, 1);
 782         if (!psmouse->vendor)
 783                 psmouse->vendor = "Generic";
 784         if (!psmouse->name)
 785                 psmouse->name = "Mouse";
 786         if (!psmouse->protocol_handler)
 787                 psmouse->protocol_handler = psmouse_process_byte;
 788
 789         sprintf(psmouse->devname, "%s %s %s",
 790                 psmouse_protocols[psmouse->type], psmouse->vendor, psmouse->name);
 791         sprintf(psmouse->phys, "%s/input0",
 792                 serio->phys);
 793
 794         psmouse->dev.name = psmouse->devname;
 795         psmouse->dev.phys = psmouse->phys;
 796         psmouse->dev.id.bustype = BUS_I8042;
 797         psmouse->dev.id.vendor = 0x0002;
 798         psmouse->dev.id.product = psmouse->type;
 799         psmouse->dev.id.version = psmouse->model;
 800
 801         input_register_device(&psmouse->dev);
 802
 803         printk(KERN_INFO "input: %s on %s\n", psmouse->devname, serio->phys);
 804
 805         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
 806
 807         psmouse_initialize(psmouse);
 808
 809         if (parent && parent->pt_activate)
 810                 parent->pt_activate(parent);
 811
 812         if (serio->child) {
 813                 /*
 814                  * Nothing to be done here, serio core will detect that
 815                  * the driver set serio->child and will register it for us.
 816                  */
 817                 printk(KERN_INFO "serio: %s port at %s\n", serio->child->name, psmouse->phys);
 818         }
 819
 820         psmouse_activate(psmouse);
 821
 822 out:
 823         /* If this is a pass-through port the parent awaits to be activated */
 824         if (parent)
 825                 psmouse_activate(parent);
 826 }
 827
 828
 829 static int psmouse_reconnect(struct serio *serio)
 830 {
 831         struct psmouse *psmouse = serio->private;
 832         struct psmouse *parent = NULL;
 833         struct serio_driver *drv = serio->drv;
 834         int rc = -1;
 835
 836         if (!drv || !psmouse) {
 837                 printk(KERN_DEBUG "psmouse: reconnect request, but serio is disconnected, ignoring...\n");
 838                 return -1;
 839         }
 840
 841         if (serio->parent && (serio->type & SERIO_TYPE) == SERIO_PS_PSTHRU) {
 842                 parent = serio->parent->private;
 843                 psmouse_deactivate(parent);
 844         }
 845
 846         psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
 847
 848         if (psmouse->reconnect) {
 849                if (psmouse->reconnect(psmouse))
 850                         goto out;
 851         } else if (psmouse_probe(psmouse) < 0 ||
 852                    psmouse->type != psmouse_extensions(psmouse, psmouse_max_proto, 0))
 853                 goto out;
 854
 855         /* ok, the device type (and capabilities) match the old one,
 856          * we can continue using it, complete intialization
 857          */
 858         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
 859
 860         psmouse_initialize(psmouse);
 861
 862         if (parent && parent->pt_activate)
 863                 parent->pt_activate(parent);
 864
 865         psmouse_activate(psmouse);
 866         rc = 0;
 867
 868 out:
 869         /* If this is a pass-through port the parent waits to be activated */
 870         if (parent)
 871                 psmouse_activate(parent);
 872
 873         return rc;
 874 }
 875
 876
 877 static struct serio_driver psmouse_drv = {
 878         .driver         = {
 879                 .name   = "psmouse",
 880         },
 881         .description    = DRIVER_DESC,
 882         .interrupt      = psmouse_interrupt,
 883         .connect        = psmouse_connect,
 884         .reconnect      = psmouse_reconnect,
 885         .disconnect     = psmouse_disconnect,
 886         .cleanup        = psmouse_cleanup,
 887 };
 888
 889 static inline void psmouse_parse_proto(void)
 890 {
 891         if (psmouse_proto) {
 892                 if (!strcmp(psmouse_proto, "bare"))
 893                         psmouse_max_proto = PSMOUSE_PS2;
 894                 else if (!strcmp(psmouse_proto, "imps"))
 895                         psmouse_max_proto = PSMOUSE_IMPS;
 896                 else if (!strcmp(psmouse_proto, "exps"))
 897                         psmouse_max_proto = PSMOUSE_IMEX;
 898                 else
 899                         printk(KERN_ERR "psmouse: unknown protocol type '%s'\n", psmouse_proto);
 900         }
 901 }
 902
 903 int __init psmouse_init(void)
 904 {
 905         psmouse_parse_proto();
 906         serio_register_driver(&psmouse_drv);
 907         return 0;
 908 }
 909
 910 void __exit psmouse_exit(void)
 911 {
 912         serio_unregister_driver(&psmouse_drv);
 913 }
 914
 915 module_init(psmouse_init);
 916 module_exit(psmouse_exit);