drivers/input/serio/i8042.c

   1 /*
   2  *  i8042 keyboard and mouse controller driver for Linux
   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/interrupt.h>
  17 #include <linux/ioport.h>
  18 #include <linux/config.h>
  19 #include <linux/reboot.h>
  20 #include <linux/init.h>
  21 #include <linux/sysdev.h>
  22 #include <linux/pm.h>
  23 #include <linux/serio.h>
  24
  25 #include <asm/io.h>
  26
  27 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
  28 MODULE_DESCRIPTION("i8042 keyboard and mouse controller driver");
  29 MODULE_LICENSE("GPL");
  30
  31 static unsigned int i8042_noaux;
  32 module_param_named(noaux, i8042_noaux, bool, 0);
  33 MODULE_PARM_DESC(noaux, "Do not probe or use AUX (mouse) port.");
  34
  35 static unsigned int i8042_nomux;
  36 module_param_named(nomux, i8042_nomux, bool, 0);
  37 MODULE_PARM_DESC(nomux, "Do not check whether an active multiplexing conrtoller is present.");
  38
  39 static unsigned int i8042_unlock;
  40 module_param_named(unlock, i8042_unlock, bool, 0);
  41 MODULE_PARM_DESC(unlock, "Ignore keyboard lock.");
  42
  43 static unsigned int i8042_reset;
  44 module_param_named(reset, i8042_reset, bool, 0);
  45 MODULE_PARM_DESC(reset, "Reset controller during init and cleanup.");
  46
  47 static unsigned int i8042_direct;
  48 module_param_named(direct, i8042_direct, bool, 0);
  49 MODULE_PARM_DESC(direct, "Put keyboard port into non-translated mode.");
  50
  51 static unsigned int i8042_dumbkbd;
  52 module_param_named(dumbkbd, i8042_dumbkbd, bool, 0);
  53 MODULE_PARM_DESC(dumbkbd, "Pretend that controller can only read data from keyboard");
  54
  55 __obsolete_setup("i8042_noaux");
  56 __obsolete_setup("i8042_nomux");
  57 __obsolete_setup("i8042_unlock");
  58 __obsolete_setup("i8042_reset");
  59 __obsolete_setup("i8042_direct");
  60 __obsolete_setup("i8042_dumbkbd");
  61
  62 #undef DEBUG
  63 #include "i8042.h"
  64
  65 spinlock_t i8042_lock = SPIN_LOCK_UNLOCKED;
  66
  67 struct i8042_values {
  68         int irq;
  69         unsigned char disable;
  70         unsigned char irqen;
  71         unsigned char exists;
  72         signed char mux;
  73         unsigned char *name;
  74         unsigned char *phys;
  75 };
  76
  77 static struct serio i8042_kbd_port;
  78 static struct serio i8042_aux_port;
  79 static unsigned char i8042_initial_ctr;
  80 static unsigned char i8042_ctr;
  81 static unsigned char i8042_mux_open;
  82 static unsigned char i8042_mux_present;
  83 static unsigned char i8042_sysdev_initialized;
  84 static struct pm_dev *i8042_pm_dev;
  85 struct timer_list i8042_timer;
  86
  87 /*
  88  * Shared IRQ's require a device pointer, but this driver doesn't support
  89  * multiple devices
  90  */
  91 #define i8042_request_irq_cookie (&i8042_timer)
  92
  93 static irqreturn_t i8042_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  94
  95 /*
  96  * The i8042_wait_read() and i8042_wait_write functions wait for the i8042 to
  97  * be ready for reading values from it / writing values to it.
  98  */
  99
 100 static int i8042_wait_read(void)
 101 {
 102         int i = 0;
 103         while ((~i8042_read_status() & I8042_STR_OBF) && (i < I8042_CTL_TIMEOUT)) {
 104                 udelay(50);
 105                 i++;
 106         }
 107         return -(i == I8042_CTL_TIMEOUT);
 108 }
 109
 110 static int i8042_wait_write(void)
 111 {
 112         int i = 0;
 113         while ((i8042_read_status() & I8042_STR_IBF) && (i < I8042_CTL_TIMEOUT)) {
 114                 udelay(50);
 115                 i++;
 116         }
 117         return -(i == I8042_CTL_TIMEOUT);
 118 }
 119
 120 /*
 121  * i8042_flush() flushes all data that may be in the keyboard and mouse buffers
 122  * of the i8042 down the toilet.
 123  */
 124
 125 static int i8042_flush(void)
 126 {
 127         unsigned long flags;
 128         unsigned char data;
 129         int i = 0;
 130
 131         spin_lock_irqsave(&i8042_lock, flags);
 132
 133         while ((i8042_read_status() & I8042_STR_OBF) && (i++ < I8042_BUFFER_SIZE)) {
 134                 data = i8042_read_data();
 135                 dbg("%02x <- i8042 (flush, %s)", data,
 136                         i8042_read_status() & I8042_STR_AUXDATA ? "aux" : "kbd");
 137         }
 138
 139         spin_unlock_irqrestore(&i8042_lock, flags);
 140
 141         return i;
 142 }
 143
 144 /*
 145  * i8042_command() executes a command on the i8042. It also sends the input
 146  * parameter(s) of the commands to it, and receives the output value(s). The
 147  * parameters are to be stored in the param array, and the output is placed
 148  * into the same array. The number of the parameters and output values is
 149  * encoded in bits 8-11 of the command number.
 150  */
 151
 152 static int i8042_command(unsigned char *param, int command)
 153 {
 154         unsigned long flags;
 155         int retval = 0, i = 0;
 156
 157         spin_lock_irqsave(&i8042_lock, flags);
 158
 159         retval = i8042_wait_write();
 160         if (!retval) {
 161                 dbg("%02x -> i8042 (command)", command & 0xff);
 162                 i8042_write_command(command & 0xff);
 163         }
 164
 165         if (!retval)
 166                 for (i = 0; i < ((command >> 12) & 0xf); i++) {
 167                         if ((retval = i8042_wait_write())) break;
 168                         dbg("%02x -> i8042 (parameter)", param[i]);
 169                         i8042_write_data(param[i]);
 170                 }
 171
 172         if (!retval)
 173                 for (i = 0; i < ((command >> 8) & 0xf); i++) {
 174                         if ((retval = i8042_wait_read())) break;
 175                         if (i8042_read_status() & I8042_STR_AUXDATA)
 176                                 param[i] = ~i8042_read_data();
 177                         else
 178                                 param[i] = i8042_read_data();
 179                         dbg("%02x <- i8042 (return)", param[i]);
 180                 }
 181
 182         spin_unlock_irqrestore(&i8042_lock, flags);
 183
 184         if (retval)
 185                 dbg("     -- i8042 (timeout)");
 186
 187         return retval;
 188 }
 189
 190 /*
 191  * i8042_kbd_write() sends a byte out through the keyboard interface.
 192  */
 193
 194 static int i8042_kbd_write(struct serio *port, unsigned char c)
 195 {
 196         unsigned long flags;
 197         int retval = 0;
 198
 199         spin_lock_irqsave(&i8042_lock, flags);
 200
 201         if(!(retval = i8042_wait_write())) {
 202                 dbg("%02x -> i8042 (kbd-data)", c);
 203                 i8042_write_data(c);
 204         }
 205
 206         spin_unlock_irqrestore(&i8042_lock, flags);
 207
 208         return retval;
 209 }
 210
 211 /*
 212  * i8042_aux_write() sends a byte out through the aux interface.
 213  */
 214
 215 static int i8042_aux_write(struct serio *port, unsigned char c)
 216 {
 217         struct i8042_values *values = port->driver;
 218         int retval;
 219
 220 /*
 221  * Send the byte out.
 222  */
 223
 224         if (values->mux == -1)
 225                 retval = i8042_command(&c, I8042_CMD_AUX_SEND);
 226         else
 227                 retval = i8042_command(&c, I8042_CMD_MUX_SEND + values->mux);
 228
 229 /*
 230  * Make sure the interrupt happens and the character is received even
 231  * in the case the IRQ isn't wired, so that we can receive further
 232  * characters later.
 233  */
 234
 235         i8042_interrupt(0, NULL, NULL);
 236         return retval;
 237 }
 238
 239 /*
 240  * i8042_activate_port() enables port on a chip.
 241  */
 242
 243 static int i8042_activate_port(struct serio *port)
 244 {
 245         struct i8042_values *values = port->driver;
 246
 247         i8042_flush();
 248
 249         /*
 250          * Enable port again here because it is disabled if we are
 251          * resuming (normally it is enabled already).
 252          */
 253         i8042_ctr &= ~values->disable;
 254
 255         i8042_ctr |= values->irqen;
 256
 257         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
 258                 i8042_ctr &= ~values->irqen;
 259                 return -1;
 260         }
 261
 262         return 0;
 263 }
 264
 265
 266 /*
 267  * i8042_open() is called when a port is open by the higher layer.
 268  * It allocates the interrupt and calls i8042_enable_port.
 269  */
 270
 271 static int i8042_open(struct serio *port)
 272 {
 273         struct i8042_values *values = port->driver;
 274
 275         if (values->mux != -1)
 276                 if (i8042_mux_open++)
 277                         return 0;
 278
 279         if (request_irq(values->irq, i8042_interrupt,
 280                         SA_SHIRQ, "i8042", i8042_request_irq_cookie)) {
 281                 printk(KERN_ERR "i8042.c: Can't get irq %d for %s, unregistering the port.\n", values->irq, values->name);
 282                 goto irq_fail;
 283         }
 284
 285         if (i8042_activate_port(port)) {
 286                 printk(KERN_ERR "i8042.c: Can't activate %s, unregistering the port\n", values->name);
 287                 goto activate_fail;
 288         }
 289
 290         i8042_interrupt(0, NULL, NULL);
 291
 292         return 0;
 293
 294 activate_fail:
 295         free_irq(values->irq, i8042_request_irq_cookie);
 296
 297 irq_fail:
 298         values->exists = 0;
 299         serio_unregister_port_delayed(port);
 300
 301         return -1;
 302 }
 303
 304 /*
 305  * i8042_close() frees the interrupt, so that it can possibly be used
 306  * by another driver. We never know - if the user doesn't have a mouse,
 307  * the BIOS could have used the AUX interrupt for PCI.
 308  */
 309
 310 static void i8042_close(struct serio *port)
 311 {
 312         struct i8042_values *values = port->driver;
 313
 314         if (values->mux != -1)
 315                 if (--i8042_mux_open)
 316                         return;
 317
 318         i8042_ctr &= ~values->irqen;
 319
 320         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
 321                 printk(KERN_ERR "i8042.c: Can't write CTR while closing %s.\n", values->name);
 322                 return;
 323         }
 324
 325         free_irq(values->irq, i8042_request_irq_cookie);
 326
 327         i8042_flush();
 328 }
 329
 330 /*
 331  * Structures for registering the devices in the serio.c module.
 332  */
 333
 334 static struct i8042_values i8042_kbd_values = {
 335         .irqen =        I8042_CTR_KBDINT,
 336         .disable =      I8042_CTR_KBDDIS,
 337         .name =         "KBD",
 338         .mux =          -1,
 339 };
 340
 341 static struct serio i8042_kbd_port =
 342 {
 343         .type =         SERIO_8042_XL,
 344         .write =        i8042_kbd_write,
 345         .open =         i8042_open,
 346         .close =        i8042_close,
 347         .driver =       &i8042_kbd_values,
 348         .name =         "i8042 Kbd Port",
 349         .phys =         I8042_KBD_PHYS_DESC,
 350 };
 351
 352 static struct i8042_values i8042_aux_values = {
 353         .irqen =        I8042_CTR_AUXINT,
 354         .disable =      I8042_CTR_AUXDIS,
 355         .name =         "AUX",
 356         .mux =          -1,
 357 };
 358
 359 static struct serio i8042_aux_port =
 360 {
 361         .type =         SERIO_8042,
 362         .write =        i8042_aux_write,
 363         .open =         i8042_open,
 364         .close =        i8042_close,
 365         .driver =       &i8042_aux_values,
 366         .name =         "i8042 Aux Port",
 367         .phys =         I8042_AUX_PHYS_DESC,
 368 };
 369
 370 static struct i8042_values i8042_mux_values[4];
 371 static struct serio i8042_mux_port[4];
 372 static char i8042_mux_names[4][32];
 373 static char i8042_mux_short[4][16];
 374 static char i8042_mux_phys[4][32];
 375
 376 /*
 377  * i8042_interrupt() is the most important function in this driver -
 378  * it handles the interrupts from the i8042, and sends incoming bytes
 379  * to the upper layers.
 380  */
 381
 382 static irqreturn_t i8042_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 383 {
 384         unsigned long flags;
 385         unsigned char str, data = 0;
 386         unsigned int dfl;
 387         int ret;
 388
 389         mod_timer(&i8042_timer, jiffies + I8042_POLL_PERIOD);
 390
 391         spin_lock_irqsave(&i8042_lock, flags);
 392         str = i8042_read_status();
 393         if (str & I8042_STR_OBF)
 394                 data = i8042_read_data();
 395         spin_unlock_irqrestore(&i8042_lock, flags);
 396
 397         if (~str & I8042_STR_OBF) {
 398                 if (irq) dbg("Interrupt %d, without any data", irq);
 399                 ret = 0;
 400                 goto out;
 401         }
 402
 403         dfl = ((str & I8042_STR_PARITY) ? SERIO_PARITY : 0) |
 404               ((str & I8042_STR_TIMEOUT) ? SERIO_TIMEOUT : 0);
 405
 406         if (i8042_mux_values[0].exists && (str & I8042_STR_AUXDATA)) {
 407
 408                 if (str & I8042_STR_MUXERR) {
 409                         switch (data) {
 410                                 case 0xfd:
 411                                 case 0xfe: dfl = SERIO_TIMEOUT; break;
 412                                 case 0xff: dfl = SERIO_PARITY; break;
 413                         }
 414                         data = 0xfe;
 415                 } else dfl = 0;
 416
 417                 dbg("%02x <- i8042 (interrupt, aux%d, %d%s%s)",
 418                         data, (str >> 6), irq,
 419                         dfl & SERIO_PARITY ? ", bad parity" : "",
 420                         dfl & SERIO_TIMEOUT ? ", timeout" : "");
 421
 422                 serio_interrupt(i8042_mux_port + ((str >> 6) & 3), data, dfl, regs);
 423
 424                 goto irq_ret;
 425         }
 426
 427         dbg("%02x <- i8042 (interrupt, %s, %d%s%s)",
 428                 data, (str & I8042_STR_AUXDATA) ? "aux" : "kbd", irq,
 429                 dfl & SERIO_PARITY ? ", bad parity" : "",
 430                 dfl & SERIO_TIMEOUT ? ", timeout" : "");
 431
 432         if (i8042_aux_values.exists && (str & I8042_STR_AUXDATA)) {
 433                 serio_interrupt(&i8042_aux_port, data, dfl, regs);
 434                 goto irq_ret;
 435         }
 436
 437         if (!i8042_kbd_values.exists)
 438                 goto irq_ret;
 439
 440         serio_interrupt(&i8042_kbd_port, data, dfl, regs);
 441
 442 irq_ret:
 443         ret = 1;
 444 out:
 445         return IRQ_RETVAL(ret);
 446 }
 447
 448 /*
 449  * i8042_enable_mux_mode checks whether the controller has an active
 450  * multiplexor and puts the chip into Multiplexed (as opposed to
 451  * Legacy) mode.
 452  */
 453
 454 static int i8042_enable_mux_mode(struct i8042_values *values, unsigned char *mux_version)
 455 {
 456
 457         unsigned char param;
 458 /*
 459  * Get rid of bytes in the queue.
 460  */
 461
 462         i8042_flush();
 463
 464 /*
 465  * Internal loopback test - send three bytes, they should come back from the
 466  * mouse interface, the last should be version. Note that we negate mouseport
 467  * command responses for the i8042_check_aux() routine.
 468  */
 469
 470         param = 0xf0;
 471         if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0x0f)
 472                 return -1;
 473         param = 0x56;
 474         if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0xa9)
 475                 return -1;
 476         param = 0xa4;
 477         if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param == 0x5b)
 478                 return -1;
 479
 480         if (mux_version)
 481                 *mux_version = ~param;
 482
 483         return 0;
 484 }
 485
 486
 487 /*
 488  * i8042_enable_mux_ports enables 4 individual AUX ports after
 489  * the controller has been switched into Multiplexed mode
 490  */
 491
 492 static int i8042_enable_mux_ports(struct i8042_values *values)
 493 {
 494         unsigned char param;
 495         int i;
 496 /*
 497  * Disable all muxed ports by disabling AUX.
 498  */
 499
 500         i8042_ctr |= I8042_CTR_AUXDIS;
 501         i8042_ctr &= ~I8042_CTR_AUXINT;
 502
 503         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
 504                 printk(KERN_ERR "i8042.c: Failed to disable AUX port, can't use MUX.\n");
 505                 return -1;
 506         }
 507
 508 /*
 509  * Enable all muxed ports.
 510  */
 511
 512         for (i = 0; i < 4; i++) {
 513                 i8042_command(&param, I8042_CMD_MUX_PFX + i);
 514                 i8042_command(&param, I8042_CMD_AUX_ENABLE);
 515         }
 516
 517         return 0;
 518 }
 519
 520
 521 /*
 522  * i8042_check_mux() checks whether the controller supports the PS/2 Active
 523  * Multiplexing specification by Synaptics, Phoenix, Insyde and
 524  * LCS/Telegraphics.
 525  */
 526
 527 static int __init i8042_check_mux(struct i8042_values *values)
 528 {
 529         unsigned char mux_version;
 530
 531         if (i8042_enable_mux_mode(values, &mux_version))
 532                 return -1;
 533
 534         /* Workaround for broken chips which seem to support MUX, but in reality don't. */
 535         /* They all report version 12.10 */
 536         if (mux_version == 0xCA)
 537                 return -1;
 538
 539         printk(KERN_INFO "i8042.c: Detected active multiplexing controller, rev %d.%d.\n",
 540                 (mux_version >> 4) & 0xf, mux_version & 0xf);
 541
 542         if (i8042_enable_mux_ports(values))
 543                 return -1;
 544
 545         i8042_mux_present = 1;
 546         return 0;
 547 }
 548
 549
 550 /*
 551  * i8042_check_aux() applies as much paranoia as it can at detecting
 552  * the presence of an AUX interface.
 553  */
 554
 555 static int __init i8042_check_aux(struct i8042_values *values)
 556 {
 557         unsigned char param;
 558         static int i8042_check_aux_cookie;
 559
 560 /*
 561  * Check if AUX irq is available. If it isn't, then there is no point
 562  * in trying to detect AUX presence.
 563  */
 564
 565         if (request_irq(values->irq, i8042_interrupt, SA_SHIRQ,
 566                                 "i8042", &i8042_check_aux_cookie))
 567                 return -1;
 568         free_irq(values->irq, &i8042_check_aux_cookie);
 569
 570 /*
 571  * Get rid of bytes in the queue.
 572  */
 573
 574         i8042_flush();
 575
 576 /*
 577  * Internal loopback test - filters out AT-type i8042's. Unfortunately
 578  * SiS screwed up and their 5597 doesn't support the LOOP command even
 579  * though it has an AUX port.
 580  */
 581
 582         param = 0x5a;
 583         if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0xa5) {
 584
 585 /*
 586  * External connection test - filters out AT-soldered PS/2 i8042's
 587  * 0x00 - no error, 0x01-0x03 - clock/data stuck, 0xff - general error
 588  * 0xfa - no error on some notebooks which ignore the spec
 589  * Because it's common for chipsets to return error on perfectly functioning
 590  * AUX ports, we test for this only when the LOOP command failed.
 591  */
 592
 593                 if (i8042_command(&param, I8042_CMD_AUX_TEST)
 594                         || (param && param != 0xfa && param != 0xff))
 595                                 return -1;
 596         }
 597
 598 /*
 599  * Bit assignment test - filters out PS/2 i8042's in AT mode
 600  */
 601
 602         if (i8042_command(&param, I8042_CMD_AUX_DISABLE))
 603                 return -1;
 604         if (i8042_command(&param, I8042_CMD_CTL_RCTR) || (~param & I8042_CTR_AUXDIS)) {
 605                 printk(KERN_WARNING "Failed to disable AUX port, but continuing anyway... Is this a SiS?\n");
 606                 printk(KERN_WARNING "If AUX port is really absent please use the 'i8042.noaux' option.\n");
 607         }
 608
 609         if (i8042_command(&param, I8042_CMD_AUX_ENABLE))
 610                 return -1;
 611         if (i8042_command(&param, I8042_CMD_CTL_RCTR) || (param & I8042_CTR_AUXDIS))
 612                 return -1;
 613
 614 /*
 615  * Disable the interface.
 616  */
 617
 618         i8042_ctr |= I8042_CTR_AUXDIS;
 619         i8042_ctr &= ~I8042_CTR_AUXINT;
 620
 621         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
 622                 return -1;
 623
 624         return 0;
 625 }
 626
 627
 628 /*
 629  * i8042_port_register() marks the device as existing,
 630  * registers it, and reports to the user.
 631  */
 632
 633 static int __init i8042_port_register(struct i8042_values *values, struct serio *port)
 634 {
 635         values->exists = 1;
 636
 637         i8042_ctr &= ~values->disable;
 638
 639         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
 640                 printk(KERN_WARNING "i8042.c: Can't write CTR while registering.\n");
 641                 values->exists = 0;
 642                 return -1;
 643         }
 644
 645         printk(KERN_INFO "serio: i8042 %s port at %#lx,%#lx irq %d\n",
 646                values->name,
 647                (unsigned long) I8042_DATA_REG,
 648                (unsigned long) I8042_COMMAND_REG,
 649                values->irq);
 650
 651         serio_register_port(port);
 652
 653         return 0;
 654 }
 655
 656
 657 static void i8042_timer_func(unsigned long data)
 658 {
 659         i8042_interrupt(0, NULL, NULL);
 660 }
 661
 662
 663 /*
 664  * i8042_controller init initializes the i8042 controller, and,
 665  * most importantly, sets it into non-xlated mode if that's
 666  * desired.
 667  */
 668
 669 static int i8042_controller_init(void)
 670 {
 671
 672 /*
 673  * Test the i8042. We need to know if it thinks it's working correctly
 674  * before doing anything else.
 675  */
 676
 677         i8042_flush();
 678
 679         if (i8042_reset) {
 680
 681                 unsigned char param;
 682
 683                 if (i8042_command(&param, I8042_CMD_CTL_TEST)) {
 684                         printk(KERN_ERR "i8042.c: i8042 controller self test timeout.\n");
 685                         return -1;
 686                 }
 687
 688                 if (param != I8042_RET_CTL_TEST) {
 689                         printk(KERN_ERR "i8042.c: i8042 controller selftest failed. (%#x != %#x)\n",
 690                                  param, I8042_RET_CTL_TEST);
 691                         return -1;
 692                 }
 693         }
 694
 695 /*
 696  * Save the CTR for restoral on unload / reboot.
 697  */
 698
 699         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_RCTR)) {
 700                 printk(KERN_ERR "i8042.c: Can't read CTR while initializing i8042.\n");
 701                 return -1;
 702         }
 703
 704         i8042_initial_ctr = i8042_ctr;
 705
 706 /*
 707  * Disable the keyboard interface and interrupt.
 708  */
 709
 710         i8042_ctr |= I8042_CTR_KBDDIS;
 711         i8042_ctr &= ~I8042_CTR_KBDINT;
 712
 713 /*
 714  * Handle keylock.
 715  */
 716
 717         if (~i8042_read_status() & I8042_STR_KEYLOCK) {
 718                 if (i8042_unlock)
 719                         i8042_ctr |= I8042_CTR_IGNKEYLOCK;
 720                  else
 721                         printk(KERN_WARNING "i8042.c: Warning: Keylock active.\n");
 722         }
 723
 724 /*
 725  * If the chip is configured into nontranslated mode by the BIOS, don't
 726  * bother enabling translating and be happy.
 727  */
 728
 729         if (~i8042_ctr & I8042_CTR_XLATE)
 730                 i8042_direct = 1;
 731
 732 /*
 733  * Set nontranslated mode for the kbd interface if requested by an option.
 734  * After this the kbd interface becomes a simple serial in/out, like the aux
 735  * interface is. We don't do this by default, since it can confuse notebook
 736  * BIOSes.
 737  */
 738
 739         if (i8042_direct) {
 740                 i8042_ctr &= ~I8042_CTR_XLATE;
 741                 i8042_kbd_port.type = SERIO_8042;
 742         }
 743
 744 /*
 745  * Write CTR back.
 746  */
 747
 748         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
 749                 printk(KERN_ERR "i8042.c: Can't write CTR while initializing i8042.\n");
 750                 return -1;
 751         }
 752
 753         return 0;
 754 }
 755
 756
 757 /*
 758  * Reset the controller.
 759  */
 760 void i8042_controller_reset(void)
 761 {
 762         if (i8042_reset) {
 763                 unsigned char param;
 764
 765                 if (i8042_command(&param, I8042_CMD_CTL_TEST))
 766                         printk(KERN_ERR "i8042.c: i8042 controller reset timeout.\n");
 767         }
 768
 769 /*
 770  * Restore the original control register setting.
 771  */
 772
 773         i8042_ctr = i8042_initial_ctr;
 774
 775         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
 776                 printk(KERN_WARNING "i8042.c: Can't restore CTR.\n");
 777 }
 778
 779
 780 /*
 781  * Here we try to reset everything back to a state in which the BIOS will be
 782  * able to talk to the hardware when rebooting.
 783  */
 784
 785 void i8042_controller_cleanup(void)
 786 {
 787         int i;
 788
 789         i8042_flush();
 790
 791 /*
 792  * Reset anything that is connected to the ports.
 793  */
 794
 795         if (i8042_kbd_values.exists)
 796                 serio_cleanup(&i8042_kbd_port);
 797
 798         if (i8042_aux_values.exists)
 799                 serio_cleanup(&i8042_aux_port);
 800
 801         for (i = 0; i < 4; i++)
 802                 if (i8042_mux_values[i].exists)
 803                         serio_cleanup(i8042_mux_port + i);
 804
 805         i8042_controller_reset();
 806 }
 807
 808
 809 /*
 810  * Here we try to restore the original BIOS settings
 811  */
 812
 813 static int i8042_controller_suspend(void)
 814 {
 815         del_timer_sync(&i8042_timer);
 816         i8042_controller_reset();
 817
 818         return 0;
 819 }
 820
 821
 822 /*
 823  * Here we try to reset everything back to a state in which suspended
 824  */
 825
 826 static int i8042_controller_resume(void)
 827 {
 828         int i;
 829
 830         if (i8042_controller_init()) {
 831                 printk(KERN_ERR "i8042: resume failed\n");
 832                 return -1;
 833         }
 834
 835         if (i8042_mux_present)
 836                 if (i8042_enable_mux_mode(&i8042_aux_values, NULL) ||
 837                     i8042_enable_mux_ports(&i8042_aux_values)) {
 838                         printk(KERN_WARNING "i8042: failed to resume active multiplexor, mouse won't work.\n");
 839                 }
 840
 841 /*
 842  * Reconnect anything that was connected to the ports.
 843  */
 844
 845         if (i8042_kbd_values.exists && i8042_activate_port(&i8042_kbd_port) == 0)
 846                 serio_reconnect(&i8042_kbd_port);
 847
 848         if (i8042_aux_values.exists && i8042_activate_port(&i8042_aux_port) == 0)
 849                 serio_reconnect(&i8042_aux_port);
 850
 851         for (i = 0; i < 4; i++)
 852                 if (i8042_mux_values[i].exists && i8042_activate_port(i8042_mux_port + i) == 0)
 853                         serio_reconnect(i8042_mux_port + i);
 854 /*
 855  * Restart timer (for polling "stuck" data)
 856  */
 857         mod_timer(&i8042_timer, jiffies + I8042_POLL_PERIOD);
 858
 859         return 0;
 860 }
 861
 862
 863 /*
 864  * We need to reset the 8042 back to original mode on system shutdown,
 865  * because otherwise BIOSes will be confused.
 866  */
 867
 868 static int i8042_notify_sys(struct notifier_block *this, unsigned long code,
 869                             void *unused)
 870 {
 871         if (code==SYS_DOWN || code==SYS_HALT)
 872                 i8042_controller_cleanup();
 873         return NOTIFY_DONE;
 874 }
 875
 876 static struct notifier_block i8042_notifier=
 877 {
 878         i8042_notify_sys,
 879         NULL,
 880         0
 881 };
 882
 883 /*
 884  * Suspend/resume handlers for the new PM scheme (driver model)
 885  */
 886 static int i8042_suspend(struct sys_device *dev, u32 state)
 887 {
 888         return i8042_controller_suspend();
 889 }
 890
 891 static int i8042_resume(struct sys_device *dev)
 892 {
 893         return i8042_controller_resume();
 894 }
 895
 896 static struct sysdev_class kbc_sysclass = {
 897         set_kset_name("i8042"),
 898         .suspend = i8042_suspend,
 899         .resume = i8042_resume,
 900 };
 901
 902 static struct sys_device device_i8042 = {
 903        .id     = 0,
 904        .cls    = &kbc_sysclass,
 905 };
 906
 907 /*
 908  * Suspend/resume handler for the old PM scheme (APM)
 909  */
 910 static int i8042_pm_callback(struct pm_dev *dev, pm_request_t request, void *dummy)
 911 {
 912         switch (request) {
 913                 case PM_SUSPEND:
 914                         return i8042_controller_suspend();
 915
 916                 case PM_RESUME:
 917                         return i8042_controller_resume();
 918         }
 919
 920         return 0;
 921 }
 922
 923 static void __init i8042_init_mux_values(struct i8042_values *values, struct serio *port, int index)
 924 {
 925         memcpy(port, &i8042_aux_port, sizeof(struct serio));
 926         memcpy(values, &i8042_aux_values, sizeof(struct i8042_values));
 927         sprintf(i8042_mux_names[index], "i8042 Aux-%d Port", index);
 928         sprintf(i8042_mux_phys[index], I8042_MUX_PHYS_DESC, index + 1);
 929         sprintf(i8042_mux_short[index], "AUX%d", index);
 930         port->name = i8042_mux_names[index];
 931         port->phys = i8042_mux_phys[index];
 932         port->driver = values;
 933         values->name = i8042_mux_short[index];
 934         values->mux = index;
 935 }
 936
 937 int __init i8042_init(void)
 938 {
 939         int i;
 940
 941         dbg_init();
 942
 943         init_timer(&i8042_timer);
 944         i8042_timer.function = i8042_timer_func;
 945
 946         if (i8042_platform_init())
 947                 return -EBUSY;
 948
 949         i8042_aux_values.irq = I8042_AUX_IRQ;
 950         i8042_kbd_values.irq = I8042_KBD_IRQ;
 951
 952         if (i8042_controller_init())
 953                 return -ENODEV;
 954
 955         if (i8042_dumbkbd)
 956                 i8042_kbd_port.write = NULL;
 957
 958         if (!i8042_noaux && !i8042_check_aux(&i8042_aux_values)) {
 959                 if (!i8042_nomux && !i8042_check_mux(&i8042_aux_values))
 960                         for (i = 0; i < 4; i++) {
 961                                 i8042_init_mux_values(i8042_mux_values + i, i8042_mux_port + i, i);
 962                                 i8042_port_register(i8042_mux_values + i, i8042_mux_port + i);
 963                         }
 964                 else
 965                         i8042_port_register(&i8042_aux_values, &i8042_aux_port);
 966         }
 967
 968         i8042_port_register(&i8042_kbd_values, &i8042_kbd_port);
 969
 970         mod_timer(&i8042_timer, jiffies + I8042_POLL_PERIOD);
 971
 972         if (sysdev_class_register(&kbc_sysclass) == 0) {
 973                 if (sysdev_register(&device_i8042) == 0)
 974                         i8042_sysdev_initialized = 1;
 975                 else
 976                         sysdev_class_unregister(&kbc_sysclass);
 977         }
 978
 979         i8042_pm_dev = pm_register(PM_SYS_DEV, PM_SYS_UNKNOWN, i8042_pm_callback);
 980
 981         register_reboot_notifier(&i8042_notifier);
 982
 983         return 0;
 984 }
 985
 986 void __exit i8042_exit(void)
 987 {
 988         int i;
 989
 990         unregister_reboot_notifier(&i8042_notifier);
 991
 992         if (i8042_pm_dev)
 993                 pm_unregister(i8042_pm_dev);
 994
 995         if (i8042_sysdev_initialized) {
 996                 sysdev_unregister(&device_i8042);
 997                 sysdev_class_unregister(&kbc_sysclass);
 998         }
 999
1000         del_timer_sync(&i8042_timer);
1001
1002         i8042_controller_cleanup();
1003
1004         if (i8042_kbd_values.exists)
1005                 serio_unregister_port(&i8042_kbd_port);
1006
1007         if (i8042_aux_values.exists)
1008                 serio_unregister_port(&i8042_aux_port);
1009
1010         for (i = 0; i < 4; i++)
1011                 if (i8042_mux_values[i].exists)
1012                         serio_unregister_port(i8042_mux_port + i);
1013
1014         i8042_platform_exit();
1015 }
1016
1017 module_init(i8042_init);
1018 module_exit(i8042_exit);