git.oblomov.eu Git - linux-2.6/blob - drivers/input/serio/i8042.c

   1 /*
   2  *  i8042 keyboard and mouse controller driver for Linux
   3  *
   4  *  Copyright (c) 1999-2004 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/init.h>
  20 #include <linux/serio.h>
  21 #include <linux/err.h>
  22 #include <linux/rcupdate.h>
  23 #include <linux/platform_device.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_nokbd;
  32 module_param_named(nokbd, i8042_nokbd, bool, 0);
  33 MODULE_PARM_DESC(nokbd, "Do not probe or use KBD port.");
  34
  35 static unsigned int i8042_noaux;
  36 module_param_named(noaux, i8042_noaux, bool, 0);
  37 MODULE_PARM_DESC(noaux, "Do not probe or use AUX (mouse) port.");
  38
  39 static unsigned int i8042_nomux;
  40 module_param_named(nomux, i8042_nomux, bool, 0);
  41 MODULE_PARM_DESC(nomux, "Do not check whether an active multiplexing conrtoller is present.");
  42
  43 static unsigned int i8042_unlock;
  44 module_param_named(unlock, i8042_unlock, bool, 0);
  45 MODULE_PARM_DESC(unlock, "Ignore keyboard lock.");
  46
  47 static unsigned int i8042_reset;
  48 module_param_named(reset, i8042_reset, bool, 0);
  49 MODULE_PARM_DESC(reset, "Reset controller during init and cleanup.");
  50
  51 static unsigned int i8042_direct;
  52 module_param_named(direct, i8042_direct, bool, 0);
  53 MODULE_PARM_DESC(direct, "Put keyboard port into non-translated mode.");
  54
  55 static unsigned int i8042_dumbkbd;
  56 module_param_named(dumbkbd, i8042_dumbkbd, bool, 0);
  57 MODULE_PARM_DESC(dumbkbd, "Pretend that controller can only read data from keyboard");
  58
  59 static unsigned int i8042_noloop;
  60 module_param_named(noloop, i8042_noloop, bool, 0);
  61 MODULE_PARM_DESC(noloop, "Disable the AUX Loopback command while probing for the AUX port");
  62
  63 static unsigned int i8042_blink_frequency = 500;
  64 module_param_named(panicblink, i8042_blink_frequency, uint, 0600);
  65 MODULE_PARM_DESC(panicblink, "Frequency with which keyboard LEDs should blink when kernel panics");
  66
  67 #ifdef CONFIG_PNP
  68 static int i8042_nopnp;
  69 module_param_named(nopnp, i8042_nopnp, bool, 0);
  70 MODULE_PARM_DESC(nopnp, "Do not use PNP to detect controller settings");
  71 #endif
  72
  73 #define DEBUG
  74 #ifdef DEBUG
  75 static int i8042_debug;
  76 module_param_named(debug, i8042_debug, bool, 0600);
  77 MODULE_PARM_DESC(debug, "Turn i8042 debugging mode on and off");
  78 #endif
  79
  80 __obsolete_setup("i8042_noaux");
  81 __obsolete_setup("i8042_nomux");
  82 __obsolete_setup("i8042_unlock");
  83 __obsolete_setup("i8042_reset");
  84 __obsolete_setup("i8042_direct");
  85 __obsolete_setup("i8042_dumbkbd");
  86
  87 #include "i8042.h"
  88
  89 static DEFINE_SPINLOCK(i8042_lock);
  90
  91 struct i8042_port {
  92         struct serio *serio;
  93         int irq;
  94         unsigned char disable;
  95         unsigned char irqen;
  96         unsigned char exists;
  97         signed char mux;
  98         char name[8];
  99 };
 100
 101 #define I8042_KBD_PORT_NO       0
 102 #define I8042_AUX_PORT_NO       1
 103 #define I8042_MUX_PORT_NO       2
 104 #define I8042_NUM_PORTS         (I8042_NUM_MUX_PORTS + 2)
 105 static struct i8042_port i8042_ports[I8042_NUM_PORTS] = {
 106         {
 107                 .disable        = I8042_CTR_KBDDIS,
 108                 .irqen          = I8042_CTR_KBDINT,
 109                 .mux            = -1,
 110                 .name           = "KBD",
 111         },
 112         {
 113                 .disable        = I8042_CTR_AUXDIS,
 114                 .irqen          = I8042_CTR_AUXINT,
 115                 .mux            = -1,
 116                 .name           = "AUX",
 117         }
 118 };
 119
 120 static unsigned char i8042_initial_ctr;
 121 static unsigned char i8042_ctr;
 122 static unsigned char i8042_mux_open;
 123 static unsigned char i8042_mux_present;
 124 static struct timer_list i8042_timer;
 125 static struct platform_device *i8042_platform_device;
 126
 127
 128 /*
 129  * Shared IRQ's require a device pointer, but this driver doesn't support
 130  * multiple devices
 131  */
 132 #define i8042_request_irq_cookie (&i8042_timer)
 133
 134 static irqreturn_t i8042_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 135
 136 /*
 137  * The i8042_wait_read() and i8042_wait_write functions wait for the i8042 to
 138  * be ready for reading values from it / writing values to it.
 139  * Called always with i8042_lock held.
 140  */
 141
 142 static int i8042_wait_read(void)
 143 {
 144         int i = 0;
 145         while ((~i8042_read_status() & I8042_STR_OBF) && (i < I8042_CTL_TIMEOUT)) {
 146                 udelay(50);
 147                 i++;
 148         }
 149         return -(i == I8042_CTL_TIMEOUT);
 150 }
 151
 152 static int i8042_wait_write(void)
 153 {
 154         int i = 0;
 155         while ((i8042_read_status() & I8042_STR_IBF) && (i < I8042_CTL_TIMEOUT)) {
 156                 udelay(50);
 157                 i++;
 158         }
 159         return -(i == I8042_CTL_TIMEOUT);
 160 }
 161
 162 /*
 163  * i8042_flush() flushes all data that may be in the keyboard and mouse buffers
 164  * of the i8042 down the toilet.
 165  */
 166
 167 static int i8042_flush(void)
 168 {
 169         unsigned long flags;
 170         unsigned char data, str;
 171         int i = 0;
 172
 173         spin_lock_irqsave(&i8042_lock, flags);
 174
 175         while (((str = i8042_read_status()) & I8042_STR_OBF) && (i < I8042_BUFFER_SIZE)) {
 176                 udelay(50);
 177                 data = i8042_read_data();
 178                 i++;
 179                 dbg("%02x <- i8042 (flush, %s)", data,
 180                         str & I8042_STR_AUXDATA ? "aux" : "kbd");
 181         }
 182
 183         spin_unlock_irqrestore(&i8042_lock, flags);
 184
 185         return i;
 186 }
 187
 188 /*
 189  * i8042_command() executes a command on the i8042. It also sends the input
 190  * parameter(s) of the commands to it, and receives the output value(s). The
 191  * parameters are to be stored in the param array, and the output is placed
 192  * into the same array. The number of the parameters and output values is
 193  * encoded in bits 8-11 of the command number.
 194  */
 195
 196 static int i8042_command(unsigned char *param, int command)
 197 {
 198         unsigned long flags;
 199         int i, retval, auxerr = 0;
 200
 201         if (i8042_noloop && command == I8042_CMD_AUX_LOOP)
 202                 return -1;
 203
 204         spin_lock_irqsave(&i8042_lock, flags);
 205
 206         if ((retval = i8042_wait_write()))
 207                 goto out;
 208
 209         dbg("%02x -> i8042 (command)", command & 0xff);
 210         i8042_write_command(command & 0xff);
 211
 212         for (i = 0; i < ((command >> 12) & 0xf); i++) {
 213                 if ((retval = i8042_wait_write()))
 214                         goto out;
 215                 dbg("%02x -> i8042 (parameter)", param[i]);
 216                 i8042_write_data(param[i]);
 217         }
 218
 219         for (i = 0; i < ((command >> 8) & 0xf); i++) {
 220                 if ((retval = i8042_wait_read()))
 221                         goto out;
 222
 223                 if (command == I8042_CMD_AUX_LOOP &&
 224                     !(i8042_read_status() & I8042_STR_AUXDATA)) {
 225                         retval = auxerr = -1;
 226                         goto out;
 227                 }
 228
 229                 param[i] = i8042_read_data();
 230                 dbg("%02x <- i8042 (return)", param[i]);
 231         }
 232
 233         if (retval)
 234                 dbg("     -- i8042 (%s)", auxerr ? "auxerr" : "timeout");
 235
 236  out:
 237         spin_unlock_irqrestore(&i8042_lock, flags);
 238         return retval;
 239 }
 240
 241 /*
 242  * i8042_kbd_write() sends a byte out through the keyboard interface.
 243  */
 244
 245 static int i8042_kbd_write(struct serio *port, unsigned char c)
 246 {
 247         unsigned long flags;
 248         int retval = 0;
 249
 250         spin_lock_irqsave(&i8042_lock, flags);
 251
 252         if(!(retval = i8042_wait_write())) {
 253                 dbg("%02x -> i8042 (kbd-data)", c);
 254                 i8042_write_data(c);
 255         }
 256
 257         spin_unlock_irqrestore(&i8042_lock, flags);
 258
 259         return retval;
 260 }
 261
 262 /*
 263  * i8042_aux_write() sends a byte out through the aux interface.
 264  */
 265
 266 static int i8042_aux_write(struct serio *serio, unsigned char c)
 267 {
 268         struct i8042_port *port = serio->port_data;
 269         int retval;
 270
 271 /*
 272  * Send the byte out.
 273  */
 274
 275         if (port->mux == -1)
 276                 retval = i8042_command(&c, I8042_CMD_AUX_SEND);
 277         else
 278                 retval = i8042_command(&c, I8042_CMD_MUX_SEND + port->mux);
 279
 280 /*
 281  * Make sure the interrupt happens and the character is received even
 282  * in the case the IRQ isn't wired, so that we can receive further
 283  * characters later.
 284  */
 285
 286         i8042_interrupt(0, NULL, NULL);
 287         return retval;
 288 }
 289
 290 /*
 291  * i8042_activate_port() enables port on a chip.
 292  */
 293
 294 static int i8042_activate_port(struct i8042_port *port)
 295 {
 296         if (!port->serio)
 297                 return -1;
 298
 299         i8042_flush();
 300
 301         /*
 302          * Enable port again here because it is disabled if we are
 303          * resuming (normally it is enabled already).
 304          */
 305         i8042_ctr &= ~port->disable;
 306
 307         i8042_ctr |= port->irqen;
 308
 309         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
 310                 i8042_ctr &= ~port->irqen;
 311                 return -1;
 312         }
 313
 314         return 0;
 315 }
 316
 317
 318 /*
 319  * i8042_open() is called when a port is open by the higher layer.
 320  * It allocates the interrupt and calls i8042_enable_port.
 321  */
 322
 323 static int i8042_open(struct serio *serio)
 324 {
 325         struct i8042_port *port = serio->port_data;
 326
 327         if (port->mux != -1)
 328                 if (i8042_mux_open++)
 329                         return 0;
 330
 331         if (request_irq(port->irq, i8042_interrupt,
 332                         SA_SHIRQ, "i8042", i8042_request_irq_cookie)) {
 333                 printk(KERN_ERR "i8042.c: Can't get irq %d for %s, unregistering the port.\n", port->irq, port->name);
 334                 goto irq_fail;
 335         }
 336
 337         if (i8042_activate_port(port)) {
 338                 printk(KERN_ERR "i8042.c: Can't activate %s, unregistering the port\n", port->name);
 339                 goto activate_fail;
 340         }
 341
 342         i8042_interrupt(0, NULL, NULL);
 343
 344         return 0;
 345
 346  activate_fail:
 347         free_irq(port->irq, i8042_request_irq_cookie);
 348
 349  irq_fail:
 350         serio_unregister_port_delayed(serio);
 351
 352         return -1;
 353 }
 354
 355 /*
 356  * i8042_close() frees the interrupt, so that it can possibly be used
 357  * by another driver. We never know - if the user doesn't have a mouse,
 358  * the BIOS could have used the AUX interrupt for PCI.
 359  */
 360
 361 static void i8042_close(struct serio *serio)
 362 {
 363         struct i8042_port *port = serio->port_data;
 364
 365         if (port->mux != -1)
 366                 if (--i8042_mux_open)
 367                         return;
 368
 369         i8042_ctr &= ~port->irqen;
 370
 371         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
 372                 printk(KERN_WARNING "i8042.c: Can't write CTR while closing %s.\n", port->name);
 373 /*
 374  * We still want to continue and free IRQ so if more data keeps coming in
 375  * kernel will just ignore the irq.
 376  */
 377         }
 378
 379         free_irq(port->irq, i8042_request_irq_cookie);
 380
 381         i8042_flush();
 382 }
 383
 384 /*
 385  * i8042_start() is called by serio core when port is about to finish
 386  * registering. It will mark port as existing so i8042_interrupt can
 387  * start sending data through it.
 388  */
 389 static int i8042_start(struct serio *serio)
 390 {
 391         struct i8042_port *port = serio->port_data;
 392
 393         port->exists = 1;
 394         mb();
 395         return 0;
 396 }
 397
 398 /*
 399  * i8042_stop() marks serio port as non-existing so i8042_interrupt
 400  * will not try to send data to the port that is about to go away.
 401  * The function is called by serio core as part of unregister procedure.
 402  */
 403 static void i8042_stop(struct serio *serio)
 404 {
 405         struct i8042_port *port = serio->port_data;
 406
 407         port->exists = 0;
 408         synchronize_sched();
 409         port->serio = NULL;
 410 }
 411
 412 /*
 413  * i8042_interrupt() is the most important function in this driver -
 414  * it handles the interrupts from the i8042, and sends incoming bytes
 415  * to the upper layers.
 416  */
 417
 418 static irqreturn_t i8042_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 419 {
 420         struct i8042_port *port;
 421         unsigned long flags;
 422         unsigned char str, data;
 423         unsigned int dfl;
 424         unsigned int port_no;
 425         int ret;
 426
 427         mod_timer(&i8042_timer, jiffies + I8042_POLL_PERIOD);
 428
 429         spin_lock_irqsave(&i8042_lock, flags);
 430         str = i8042_read_status();
 431         if (unlikely(~str & I8042_STR_OBF)) {
 432                 spin_unlock_irqrestore(&i8042_lock, flags);
 433                 if (irq) dbg("Interrupt %d, without any data", irq);
 434                 ret = 0;
 435                 goto out;
 436         }
 437         data = i8042_read_data();
 438         spin_unlock_irqrestore(&i8042_lock, flags);
 439
 440         if (i8042_mux_present && (str & I8042_STR_AUXDATA)) {
 441                 static unsigned long last_transmit;
 442                 static unsigned char last_str;
 443
 444                 dfl = 0;
 445                 if (str & I8042_STR_MUXERR) {
 446                         dbg("MUX error, status is %02x, data is %02x", str, data);
 447                         switch (data) {
 448                                 default:
 449 /*
 450  * When MUXERR condition is signalled the data register can only contain
 451  * 0xfd, 0xfe or 0xff if implementation follows the spec. Unfortunately
 452  * it is not always the case. Some KBC just get confused which port the
 453  * data came from and signal error leaving the data intact. They _do not_
 454  * revert to legacy mode (actually I've never seen KBC reverting to legacy
 455  * mode yet, when we see one we'll add proper handling).
 456  * Anyway, we will assume that the data came from the same serio last byte
 457  * was transmitted (if transmission happened not too long ago).
 458  */
 459                                         if (time_before(jiffies, last_transmit + HZ/10)) {
 460                                                 str = last_str;
 461                                                 break;
 462                                         }
 463                                         /* fall through - report timeout */
 464                                 case 0xfd:
 465                                 case 0xfe: dfl = SERIO_TIMEOUT; data = 0xfe; break;
 466                                 case 0xff: dfl = SERIO_PARITY;  data = 0xfe; break;
 467                         }
 468                 }
 469
 470                 port_no = I8042_MUX_PORT_NO + ((str >> 6) & 3);
 471                 last_str = str;
 472                 last_transmit = jiffies;
 473         } else {
 474
 475                 dfl = ((str & I8042_STR_PARITY) ? SERIO_PARITY : 0) |
 476                       ((str & I8042_STR_TIMEOUT) ? SERIO_TIMEOUT : 0);
 477
 478                 port_no = (str & I8042_STR_AUXDATA) ?
 479                                 I8042_AUX_PORT_NO : I8042_KBD_PORT_NO;
 480         }
 481
 482         port = &i8042_ports[port_no];
 483
 484         dbg("%02x <- i8042 (interrupt, %s, %d%s%s)",
 485             data, port->name, irq,
 486             dfl & SERIO_PARITY ? ", bad parity" : "",
 487             dfl & SERIO_TIMEOUT ? ", timeout" : "");
 488
 489         if (likely(port->exists))
 490                 serio_interrupt(port->serio, data, dfl, regs);
 491
 492         ret = 1;
 493  out:
 494         return IRQ_RETVAL(ret);
 495 }
 496
 497 /*
 498  * i8042_set_mux_mode checks whether the controller has an active
 499  * multiplexor and puts the chip into Multiplexed (1) or Legacy (0) mode.
 500  */
 501
 502 static int i8042_set_mux_mode(unsigned int mode, unsigned char *mux_version)
 503 {
 504
 505         unsigned char param;
 506 /*
 507  * Get rid of bytes in the queue.
 508  */
 509
 510         i8042_flush();
 511
 512 /*
 513  * Internal loopback test - send three bytes, they should come back from the
 514  * mouse interface, the last should be version. Note that we negate mouseport
 515  * command responses for the i8042_check_aux() routine.
 516  */
 517
 518         param = 0xf0;
 519         if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0xf0)
 520                 return -1;
 521         param = mode ? 0x56 : 0xf6;
 522         if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != (mode ? 0x56 : 0xf6))
 523                 return -1;
 524         param = mode ? 0xa4 : 0xa5;
 525         if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param == (mode ? 0xa4 : 0xa5))
 526                 return -1;
 527
 528         if (mux_version)
 529                 *mux_version = param;
 530
 531         return 0;
 532 }
 533
 534
 535 /*
 536  * i8042_enable_mux_ports enables 4 individual AUX ports after
 537  * the controller has been switched into Multiplexed mode
 538  */
 539
 540 static int i8042_enable_mux_ports(void)
 541 {
 542         unsigned char param;
 543         int i;
 544 /*
 545  * Disable all muxed ports by disabling AUX.
 546  */
 547
 548         i8042_ctr |= I8042_CTR_AUXDIS;
 549         i8042_ctr &= ~I8042_CTR_AUXINT;
 550
 551         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
 552                 printk(KERN_ERR "i8042.c: Failed to disable AUX port, can't use MUX.\n");
 553                 return -1;
 554         }
 555
 556 /*
 557  * Enable all muxed ports.
 558  */
 559
 560         for (i = 0; i < I8042_NUM_MUX_PORTS; i++) {
 561                 i8042_command(&param, I8042_CMD_MUX_PFX + i);
 562                 i8042_command(&param, I8042_CMD_AUX_ENABLE);
 563         }
 564
 565         return 0;
 566 }
 567
 568
 569 /*
 570  * i8042_check_mux() checks whether the controller supports the PS/2 Active
 571  * Multiplexing specification by Synaptics, Phoenix, Insyde and
 572  * LCS/Telegraphics.
 573  */
 574
 575 static int __devinit i8042_check_mux(void)
 576 {
 577         unsigned char mux_version;
 578
 579         if (i8042_set_mux_mode(1, &mux_version))
 580                 return -1;
 581
 582         /* Workaround for interference with USB Legacy emulation */
 583         /* that causes a v10.12 MUX to be found. */
 584         if (mux_version == 0xAC)
 585                 return -1;
 586
 587         printk(KERN_INFO "i8042.c: Detected active multiplexing controller, rev %d.%d.\n",
 588                 (mux_version >> 4) & 0xf, mux_version & 0xf);
 589
 590         if (i8042_enable_mux_ports())
 591                 return -1;
 592
 593         i8042_mux_present = 1;
 594         return 0;
 595 }
 596
 597
 598 /*
 599  * i8042_check_aux() applies as much paranoia as it can at detecting
 600  * the presence of an AUX interface.
 601  */
 602
 603 static int __devinit i8042_check_aux(void)
 604 {
 605         unsigned char param;
 606         static int i8042_check_aux_cookie;
 607
 608 /*
 609  * Check if AUX irq is available. If it isn't, then there is no point
 610  * in trying to detect AUX presence.
 611  */
 612
 613         if (request_irq(i8042_ports[I8042_AUX_PORT_NO].irq, i8042_interrupt,
 614                         SA_SHIRQ, "i8042", &i8042_check_aux_cookie))
 615                 return -1;
 616         free_irq(i8042_ports[I8042_AUX_PORT_NO].irq, &i8042_check_aux_cookie);
 617
 618 /*
 619  * Get rid of bytes in the queue.
 620  */
 621
 622         i8042_flush();
 623
 624 /*
 625  * Internal loopback test - filters out AT-type i8042's. Unfortunately
 626  * SiS screwed up and their 5597 doesn't support the LOOP command even
 627  * though it has an AUX port.
 628  */
 629
 630         param = 0x5a;
 631         if (i8042_command(&param, I8042_CMD_AUX_LOOP) || param != 0x5a) {
 632
 633 /*
 634  * External connection test - filters out AT-soldered PS/2 i8042's
 635  * 0x00 - no error, 0x01-0x03 - clock/data stuck, 0xff - general error
 636  * 0xfa - no error on some notebooks which ignore the spec
 637  * Because it's common for chipsets to return error on perfectly functioning
 638  * AUX ports, we test for this only when the LOOP command failed.
 639  */
 640
 641                 if (i8042_command(&param, I8042_CMD_AUX_TEST)
 642                         || (param && param != 0xfa && param != 0xff))
 643                                 return -1;
 644         }
 645
 646 /*
 647  * Bit assignment test - filters out PS/2 i8042's in AT mode
 648  */
 649
 650         if (i8042_command(&param, I8042_CMD_AUX_DISABLE))
 651                 return -1;
 652         if (i8042_command(&param, I8042_CMD_CTL_RCTR) || (~param & I8042_CTR_AUXDIS)) {
 653                 printk(KERN_WARNING "Failed to disable AUX port, but continuing anyway... Is this a SiS?\n");
 654                 printk(KERN_WARNING "If AUX port is really absent please use the 'i8042.noaux' option.\n");
 655         }
 656
 657         if (i8042_command(&param, I8042_CMD_AUX_ENABLE))
 658                 return -1;
 659         if (i8042_command(&param, I8042_CMD_CTL_RCTR) || (param & I8042_CTR_AUXDIS))
 660                 return -1;
 661
 662 /*
 663  * Disable the interface.
 664  */
 665
 666         i8042_ctr |= I8042_CTR_AUXDIS;
 667         i8042_ctr &= ~I8042_CTR_AUXINT;
 668
 669         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
 670                 return -1;
 671
 672         return 0;
 673 }
 674
 675
 676 /*
 677  * i8042_port_register() marks the device as existing,
 678  * registers it, and reports to the user.
 679  */
 680
 681 static int __devinit i8042_port_register(struct i8042_port *port)
 682 {
 683         i8042_ctr &= ~port->disable;
 684
 685         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
 686                 printk(KERN_WARNING "i8042.c: Can't write CTR while registering.\n");
 687                 kfree(port->serio);
 688                 port->serio = NULL;
 689                 i8042_ctr |= port->disable;
 690                 return -EIO;
 691         }
 692
 693         printk(KERN_INFO "serio: i8042 %s port at %#lx,%#lx irq %d\n",
 694                port->name,
 695                (unsigned long) I8042_DATA_REG,
 696                (unsigned long) I8042_COMMAND_REG,
 697                port->irq);
 698
 699         serio_register_port(port->serio);
 700
 701         return 0;
 702 }
 703
 704
 705 static void i8042_timer_func(unsigned long data)
 706 {
 707         i8042_interrupt(0, NULL, NULL);
 708 }
 709
 710 static int i8042_ctl_test(void)
 711 {
 712         unsigned char param;
 713
 714         if (!i8042_reset)
 715                 return 0;
 716
 717         if (i8042_command(&param, I8042_CMD_CTL_TEST)) {
 718                 printk(KERN_ERR "i8042.c: i8042 controller self test timeout.\n");
 719                 return -1;
 720         }
 721
 722         if (param != I8042_RET_CTL_TEST) {
 723                 printk(KERN_ERR "i8042.c: i8042 controller selftest failed. (%#x != %#x)\n",
 724                          param, I8042_RET_CTL_TEST);
 725                 return -1;
 726         }
 727
 728         return 0;
 729 }
 730
 731 /*
 732  * i8042_controller init initializes the i8042 controller, and,
 733  * most importantly, sets it into non-xlated mode if that's
 734  * desired.
 735  */
 736
 737 static int i8042_controller_init(void)
 738 {
 739         unsigned long flags;
 740
 741 /*
 742  * Test the i8042. We need to know if it thinks it's working correctly
 743  * before doing anything else.
 744  */
 745
 746         if (i8042_flush() == I8042_BUFFER_SIZE) {
 747                 printk(KERN_ERR "i8042.c: No controller found.\n");
 748                 return -1;
 749         }
 750
 751         if (i8042_ctl_test())
 752                 return -1;
 753
 754 /*
 755  * Save the CTR for restoral on unload / reboot.
 756  */
 757
 758         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_RCTR)) {
 759                 printk(KERN_ERR "i8042.c: Can't read CTR while initializing i8042.\n");
 760                 return -1;
 761         }
 762
 763         i8042_initial_ctr = i8042_ctr;
 764
 765 /*
 766  * Disable the keyboard interface and interrupt.
 767  */
 768
 769         i8042_ctr |= I8042_CTR_KBDDIS;
 770         i8042_ctr &= ~I8042_CTR_KBDINT;
 771
 772 /*
 773  * Handle keylock.
 774  */
 775
 776         spin_lock_irqsave(&i8042_lock, flags);
 777         if (~i8042_read_status() & I8042_STR_KEYLOCK) {
 778                 if (i8042_unlock)
 779                         i8042_ctr |= I8042_CTR_IGNKEYLOCK;
 780                  else
 781                         printk(KERN_WARNING "i8042.c: Warning: Keylock active.\n");
 782         }
 783         spin_unlock_irqrestore(&i8042_lock, flags);
 784
 785 /*
 786  * If the chip is configured into nontranslated mode by the BIOS, don't
 787  * bother enabling translating and be happy.
 788  */
 789
 790         if (~i8042_ctr & I8042_CTR_XLATE)
 791                 i8042_direct = 1;
 792
 793 /*
 794  * Set nontranslated mode for the kbd interface if requested by an option.
 795  * After this the kbd interface becomes a simple serial in/out, like the aux
 796  * interface is. We don't do this by default, since it can confuse notebook
 797  * BIOSes.
 798  */
 799
 800         if (i8042_direct)
 801                 i8042_ctr &= ~I8042_CTR_XLATE;
 802
 803 /*
 804  * Write CTR back.
 805  */
 806
 807         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
 808                 printk(KERN_ERR "i8042.c: Can't write CTR while initializing i8042.\n");
 809                 return -1;
 810         }
 811
 812         return 0;
 813 }
 814
 815
 816 /*
 817  * Reset the controller.
 818  */
 819 static void i8042_controller_reset(void)
 820 {
 821 /*
 822  * Reset the controller if requested.
 823  */
 824
 825         i8042_ctl_test();
 826
 827 /*
 828  * Disable MUX mode if present.
 829  */
 830
 831         if (i8042_mux_present)
 832                 i8042_set_mux_mode(0, NULL);
 833
 834 /*
 835  * Restore the original control register setting.
 836  */
 837
 838         i8042_ctr = i8042_initial_ctr;
 839
 840         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
 841                 printk(KERN_WARNING "i8042.c: Can't restore CTR.\n");
 842 }
 843
 844
 845 /*
 846  * Here we try to reset everything back to a state in which the BIOS will be
 847  * able to talk to the hardware when rebooting.
 848  */
 849
 850 static void i8042_controller_cleanup(void)
 851 {
 852         int i;
 853
 854         i8042_flush();
 855
 856 /*
 857  * Reset anything that is connected to the ports.
 858  */
 859
 860         for (i = 0; i < I8042_NUM_PORTS; i++)
 861                 if (i8042_ports[i].exists)
 862                         serio_cleanup(i8042_ports[i].serio);
 863
 864         i8042_controller_reset();
 865 }
 866
 867
 868 /*
 869  * i8042_panic_blink() will flash the keyboard LEDs and is called when
 870  * kernel panics. Flashing LEDs is useful for users running X who may
 871  * not see the console and will help distingushing panics from "real"
 872  * lockups.
 873  *
 874  * Note that DELAY has a limit of 10ms so we will not get stuck here
 875  * waiting for KBC to free up even if KBD interrupt is off
 876  */
 877
 878 #define DELAY do { mdelay(1); if (++delay > 10) return delay; } while(0)
 879
 880 static long i8042_panic_blink(long count)
 881 {
 882         long delay = 0;
 883         static long last_blink;
 884         static char led;
 885
 886         /*
 887          * We expect frequency to be about 1/2s. KDB uses about 1s.
 888          * Make sure they are different.
 889          */
 890         if (!i8042_blink_frequency)
 891                 return 0;
 892         if (count - last_blink < i8042_blink_frequency)
 893                 return 0;
 894
 895         led ^= 0x01 | 0x04;
 896         while (i8042_read_status() & I8042_STR_IBF)
 897                 DELAY;
 898         i8042_write_data(0xed); /* set leds */
 899         DELAY;
 900         while (i8042_read_status() & I8042_STR_IBF)
 901                 DELAY;
 902         DELAY;
 903         i8042_write_data(led);
 904         DELAY;
 905         last_blink = count;
 906         return delay;
 907 }
 908
 909 #undef DELAY
 910
 911 /*
 912  * Here we try to restore the original BIOS settings
 913  */
 914
 915 static int i8042_suspend(struct platform_device *dev, pm_message_t state)
 916 {
 917         del_timer_sync(&i8042_timer);
 918         i8042_controller_reset();
 919
 920         return 0;
 921 }
 922
 923
 924 /*
 925  * Here we try to reset everything back to a state in which suspended
 926  */
 927
 928 static int i8042_resume(struct platform_device *dev)
 929 {
 930         int i;
 931
 932         if (i8042_ctl_test())
 933                 return -1;
 934
 935         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
 936                 printk(KERN_ERR "i8042: Can't write CTR\n");
 937                 return -1;
 938         }
 939
 940         if (i8042_mux_present)
 941                 if (i8042_set_mux_mode(1, NULL) || i8042_enable_mux_ports())
 942                         printk(KERN_WARNING "i8042: failed to resume active multiplexor, mouse won't work.\n");
 943
 944 /*
 945  * Activate all ports.
 946  */
 947
 948         for (i = 0; i < I8042_NUM_PORTS; i++)
 949                 i8042_activate_port(&i8042_ports[i]);
 950
 951 /*
 952  * Restart timer (for polling "stuck" data)
 953  */
 954         mod_timer(&i8042_timer, jiffies + I8042_POLL_PERIOD);
 955
 956         panic_blink = i8042_panic_blink;
 957
 958         return 0;
 959 }
 960
 961 /*
 962  * We need to reset the 8042 back to original mode on system shutdown,
 963  * because otherwise BIOSes will be confused.
 964  */
 965
 966 static void i8042_shutdown(struct platform_device *dev)
 967 {
 968         i8042_controller_cleanup();
 969 }
 970
 971 static int __devinit i8042_create_kbd_port(void)
 972 {
 973         struct serio *serio;
 974         struct i8042_port *port = &i8042_ports[I8042_KBD_PORT_NO];
 975
 976         serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
 977         if (!serio)
 978                 return -ENOMEM;
 979
 980         serio->id.type          = i8042_direct ? SERIO_8042 : SERIO_8042_XL;
 981         serio->write            = i8042_dumbkbd ? NULL : i8042_kbd_write;
 982         serio->open             = i8042_open;
 983         serio->close            = i8042_close;
 984         serio->start            = i8042_start;
 985         serio->stop             = i8042_stop;
 986         serio->port_data        = port;
 987         serio->dev.parent       = &i8042_platform_device->dev;
 988         strlcpy(serio->name, "i8042 Kbd Port", sizeof(serio->name));
 989         strlcpy(serio->phys, I8042_KBD_PHYS_DESC, sizeof(serio->phys));
 990
 991         port->serio = serio;
 992
 993         return i8042_port_register(port);
 994 }
 995
 996 static int __devinit i8042_create_aux_port(void)
 997 {
 998         struct serio *serio;
 999         struct i8042_port *port = &i8042_ports[I8042_AUX_PORT_NO];
1000
1001         serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
1002         if (!serio)
1003                 return -ENOMEM;
1004
1005         serio->id.type          = SERIO_8042;
1006         serio->write            = i8042_aux_write;
1007         serio->open             = i8042_open;
1008         serio->close            = i8042_close;
1009         serio->start            = i8042_start;
1010         serio->stop             = i8042_stop;
1011         serio->port_data        = port;
1012         serio->dev.parent       = &i8042_platform_device->dev;
1013         strlcpy(serio->name, "i8042 Aux Port", sizeof(serio->name));
1014         strlcpy(serio->phys, I8042_AUX_PHYS_DESC, sizeof(serio->phys));
1015
1016         port->serio = serio;
1017
1018         return i8042_port_register(port);
1019 }
1020
1021 static int __devinit i8042_create_mux_port(int index)
1022 {
1023         struct serio *serio;
1024         struct i8042_port *port = &i8042_ports[I8042_MUX_PORT_NO + index];
1025
1026         serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
1027         if (!serio)
1028                 return -ENOMEM;
1029
1030         serio->id.type          = SERIO_8042;
1031         serio->write            = i8042_aux_write;
1032         serio->open             = i8042_open;
1033         serio->close            = i8042_close;
1034         serio->start            = i8042_start;
1035         serio->stop             = i8042_stop;
1036         serio->port_data        = port;
1037         serio->dev.parent       = &i8042_platform_device->dev;
1038         snprintf(serio->name, sizeof(serio->name), "i8042 Aux-%d Port", index);
1039         snprintf(serio->phys, sizeof(serio->phys), I8042_MUX_PHYS_DESC, index + 1);
1040
1041         *port = i8042_ports[I8042_AUX_PORT_NO];
1042         port->exists = 0;
1043         snprintf(port->name, sizeof(port->name), "AUX%d", index);
1044         port->mux = index;
1045         port->serio = serio;
1046
1047         return i8042_port_register(port);
1048 }
1049
1050 static int __devinit i8042_probe(struct platform_device *dev)
1051 {
1052         int i, have_ports = 0;
1053         int err;
1054
1055         init_timer(&i8042_timer);
1056         i8042_timer.function = i8042_timer_func;
1057
1058         if (i8042_controller_init())
1059                 return -ENODEV;
1060
1061         if (!i8042_noaux && !i8042_check_aux()) {
1062                 if (!i8042_nomux && !i8042_check_mux()) {
1063                         for (i = 0; i < I8042_NUM_MUX_PORTS; i++) {
1064                                 err = i8042_create_mux_port(i);
1065                                 if (err)
1066                                         goto err_unregister_ports;
1067                         }
1068                 } else {
1069                         err = i8042_create_aux_port();
1070                         if (err)
1071                                 goto err_unregister_ports;
1072                 }
1073                 have_ports = 1;
1074         }
1075
1076         if (!i8042_nokbd) {
1077                 err = i8042_create_kbd_port();
1078                 if (err)
1079                         goto err_unregister_ports;
1080                 have_ports = 1;
1081         }
1082
1083         if (!have_ports) {
1084                 err = -ENODEV;
1085                 goto err_controller_cleanup;
1086         }
1087
1088         mod_timer(&i8042_timer, jiffies + I8042_POLL_PERIOD);
1089         return 0;
1090
1091  err_unregister_ports:
1092         for (i = 0; i < I8042_NUM_PORTS; i++)
1093                 if (i8042_ports[i].serio)
1094                         serio_unregister_port(i8042_ports[i].serio);
1095  err_controller_cleanup:
1096         i8042_controller_cleanup();
1097
1098         return err;
1099 }
1100
1101 static int __devexit i8042_remove(struct platform_device *dev)
1102 {
1103         int i;
1104
1105         i8042_controller_cleanup();
1106
1107         for (i = 0; i < I8042_NUM_PORTS; i++)
1108                 if (i8042_ports[i].exists)
1109                         serio_unregister_port(i8042_ports[i].serio);
1110
1111         del_timer_sync(&i8042_timer);
1112
1113         return 0;
1114 }
1115
1116 static struct platform_driver i8042_driver = {
1117         .driver         = {
1118                 .name   = "i8042",
1119                 .owner  = THIS_MODULE,
1120         },
1121         .probe          = i8042_probe,
1122         .remove         = __devexit_p(i8042_remove),
1123         .suspend        = i8042_suspend,
1124         .resume         = i8042_resume,
1125         .shutdown       = i8042_shutdown,
1126 };
1127
1128 static int __init i8042_init(void)
1129 {
1130         int err;
1131
1132         dbg_init();
1133
1134         err = i8042_platform_init();
1135         if (err)
1136                 return err;
1137
1138         i8042_ports[I8042_AUX_PORT_NO].irq = I8042_AUX_IRQ;
1139         i8042_ports[I8042_KBD_PORT_NO].irq = I8042_KBD_IRQ;
1140
1141         err = platform_driver_register(&i8042_driver);
1142         if (err)
1143                 goto err_platform_exit;
1144
1145         i8042_platform_device = platform_device_alloc("i8042", -1);
1146         if (!i8042_platform_device) {
1147                 err = -ENOMEM;
1148                 goto err_unregister_driver;
1149         }
1150
1151         err = platform_device_add(i8042_platform_device);
1152         if (err)
1153                 goto err_free_device;
1154
1155         return 0;
1156
1157  err_free_device:
1158         platform_device_put(i8042_platform_device);
1159  err_unregister_driver:
1160         platform_driver_unregister(&i8042_driver);
1161  err_platform_exit:
1162         i8042_platform_exit();
1163
1164         return err;
1165 }
1166
1167 static void __exit i8042_exit(void)
1168 {
1169         platform_device_unregister(i8042_platform_device);
1170         platform_driver_unregister(&i8042_driver);
1171
1172         i8042_platform_exit();
1173
1174         panic_blink = NULL;
1175 }
1176
1177 module_init(i8042_init);
1178 module_exit(i8042_exit);