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