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