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