v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / drivers / char / pc_keyb.c
1 /*
2  * linux/drivers/char/pc_keyb.c
3  *
4  * Separation of the PC low-level part by Geert Uytterhoeven, May 1997
5  * See keyboard.c for the whole history.
6  *
7  * Major cleanup by Martin Mares, May 1997
8  *
9  * Combined the keyboard and PS/2 mouse handling into one file,
10  * because they share the same hardware.
11  * Johan Myreen <jem@iki.fi> 1998-10-08.
12  *
13  * Code fixes to handle mouse ACKs properly.
14  * C. Scott Ananian <cananian@alumni.princeton.edu> 1999-01-29.
15  *
16  */
17
18 #include <linux/config.h>
19
20 #include <linux/spinlock.h>
21 #include <linux/sched.h>
22 #include <linux/interrupt.h>
23 #include <linux/tty.h>
24 #include <linux/mm.h>
25 #include <linux/signal.h>
26 #include <linux/init.h>
27 #include <linux/kbd_ll.h>
28 #include <linux/delay.h>
29 #include <linux/random.h>
30 #include <linux/poll.h>
31 #include <linux/miscdevice.h>
32 #include <linux/slab.h>
33 #include <linux/kbd_kern.h>
34 #include <linux/smp_lock.h>
35
36 #include <asm/keyboard.h>
37 #include <asm/bitops.h>
38 #include <asm/uaccess.h>
39 #include <asm/irq.h>
40 #include <asm/system.h>
41
42 #include <asm/io.h>
43
44 /* Some configuration switches are present in the include file... */
45
46 #include <linux/pc_keyb.h>
47
48 /* Simple translation table for the SysRq keys */
49
50 #ifdef CONFIG_MAGIC_SYSRQ
51 unsigned char pckbd_sysrq_xlate[128] =
52         "\000\0331234567890-=\177\t"                    /* 0x00 - 0x0f */
53         "qwertyuiop[]\r\000as"                          /* 0x10 - 0x1f */
54         "dfghjkl;'`\000\\zxcv"                          /* 0x20 - 0x2f */
55         "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
56         "\206\207\210\211\212\000\000789-456+1"         /* 0x40 - 0x4f */
57         "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
58         "\r\000/";                                      /* 0x60 - 0x6f */
59 #endif
60
61 static void kbd_write_command_w(int data);
62 static void kbd_write_output_w(int data);
63 #ifdef CONFIG_PSMOUSE
64 static void aux_write_ack(int val);
65 static void __aux_write_ack(int val);
66 #endif
67
68 static spinlock_t kbd_controller_lock = SPIN_LOCK_UNLOCKED;
69 static unsigned char handle_kbd_event(void);
70
71 /* used only by send_data - set by keyboard_interrupt */
72 static volatile unsigned char reply_expected;
73 static volatile unsigned char acknowledge;
74 static volatile unsigned char resend;
75
76
77 #if defined CONFIG_PSMOUSE
78 /*
79  *      PS/2 Auxiliary Device
80  */
81
82 static int __init psaux_init(void);
83
84 #define AUX_RECONNECT 170 /* scancode when ps2 device is plugged (back) in */
85  
86 static struct aux_queue *queue; /* Mouse data buffer. */
87 static int aux_count;
88 /* used when we send commands to the mouse that expect an ACK. */
89 static unsigned char mouse_reply_expected;
90
91 #define AUX_INTS_OFF (KBD_MODE_KCC | KBD_MODE_DISABLE_MOUSE | KBD_MODE_SYS | KBD_MODE_KBD_INT)
92 #define AUX_INTS_ON  (KBD_MODE_KCC | KBD_MODE_SYS | KBD_MODE_MOUSE_INT | KBD_MODE_KBD_INT)
93
94 #define MAX_RETRIES     60              /* some aux operations take long time*/
95 #endif /* CONFIG_PSMOUSE */
96
97 /*
98  * Wait for keyboard controller input buffer to drain.
99  *
100  * Don't use 'jiffies' so that we don't depend on
101  * interrupts..
102  *
103  * Quote from PS/2 System Reference Manual:
104  *
105  * "Address hex 0060 and address hex 0064 should be written only when
106  * the input-buffer-full bit and output-buffer-full bit in the
107  * Controller Status register are set 0."
108  */
109
110 static void kb_wait(void)
111 {
112         unsigned long timeout = KBC_TIMEOUT;
113
114         do {
115                 /*
116                  * "handle_kbd_event()" will handle any incoming events
117                  * while we wait - keypresses or mouse movement.
118                  */
119                 unsigned char status = handle_kbd_event();
120
121                 if (! (status & KBD_STAT_IBF))
122                         return;
123                 mdelay(1);
124                 timeout--;
125         } while (timeout);
126 #ifdef KBD_REPORT_TIMEOUTS
127         printk(KERN_WARNING "Keyboard timed out[1]\n");
128 #endif
129 }
130
131 /*
132  * Translation of escaped scancodes to keycodes.
133  * This is now user-settable.
134  * The keycodes 1-88,96-111,119 are fairly standard, and
135  * should probably not be changed - changing might confuse X.
136  * X also interprets scancode 0x5d (KEY_Begin).
137  *
138  * For 1-88 keycode equals scancode.
139  */
140
141 #define E0_KPENTER 96
142 #define E0_RCTRL   97
143 #define E0_KPSLASH 98
144 #define E0_PRSCR   99
145 #define E0_RALT    100
146 #define E0_BREAK   101  /* (control-pause) */
147 #define E0_HOME    102
148 #define E0_UP      103
149 #define E0_PGUP    104
150 #define E0_LEFT    105
151 #define E0_RIGHT   106
152 #define E0_END     107
153 #define E0_DOWN    108
154 #define E0_PGDN    109
155 #define E0_INS     110
156 #define E0_DEL     111
157
158 #define E1_PAUSE   119
159
160 /*
161  * The keycodes below are randomly located in 89-95,112-118,120-127.
162  * They could be thrown away (and all occurrences below replaced by 0),
163  * but that would force many users to use the `setkeycodes' utility, where
164  * they needed not before. It does not matter that there are duplicates, as
165  * long as no duplication occurs for any single keyboard.
166  */
167 #define SC_LIM 89
168
169 #define FOCUS_PF1 85           /* actual code! */
170 #define FOCUS_PF2 89
171 #define FOCUS_PF3 90
172 #define FOCUS_PF4 91
173 #define FOCUS_PF5 92
174 #define FOCUS_PF6 93
175 #define FOCUS_PF7 94
176 #define FOCUS_PF8 95
177 #define FOCUS_PF9 120
178 #define FOCUS_PF10 121
179 #define FOCUS_PF11 122
180 #define FOCUS_PF12 123
181
182 #define JAP_86     124
183 /* tfj@olivia.ping.dk:
184  * The four keys are located over the numeric keypad, and are
185  * labelled A1-A4. It's an rc930 keyboard, from
186  * Regnecentralen/RC International, Now ICL.
187  * Scancodes: 59, 5a, 5b, 5c.
188  */
189 #define RGN1 124
190 #define RGN2 125
191 #define RGN3 126
192 #define RGN4 127
193
194 static unsigned char high_keys[128 - SC_LIM] = {
195   RGN1, RGN2, RGN3, RGN4, 0, 0, 0,                   /* 0x59-0x5f */
196   0, 0, 0, 0, 0, 0, 0, 0,                            /* 0x60-0x67 */
197   0, 0, 0, 0, 0, FOCUS_PF11, 0, FOCUS_PF12,          /* 0x68-0x6f */
198   0, 0, 0, FOCUS_PF2, FOCUS_PF9, 0, 0, FOCUS_PF3,    /* 0x70-0x77 */
199   FOCUS_PF4, FOCUS_PF5, FOCUS_PF6, FOCUS_PF7,        /* 0x78-0x7b */
200   FOCUS_PF8, JAP_86, FOCUS_PF10, 0                   /* 0x7c-0x7f */
201 };
202
203 /* BTC */
204 #define E0_MACRO   112
205 /* LK450 */
206 #define E0_F13     113
207 #define E0_F14     114
208 #define E0_HELP    115
209 #define E0_DO      116
210 #define E0_F17     117
211 #define E0_KPMINPLUS 118
212 /*
213  * My OmniKey generates e0 4c for  the "OMNI" key and the
214  * right alt key does nada. [kkoller@nyx10.cs.du.edu]
215  */
216 #define E0_OK   124
217 /*
218  * New microsoft keyboard is rumoured to have
219  * e0 5b (left window button), e0 5c (right window button),
220  * e0 5d (menu button). [or: LBANNER, RBANNER, RMENU]
221  * [or: Windows_L, Windows_R, TaskMan]
222  */
223 #define E0_MSLW 125
224 #define E0_MSRW 126
225 #define E0_MSTM 127
226
227 static unsigned char e0_keys[128] = {
228   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x00-0x07 */
229   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x08-0x0f */
230   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x10-0x17 */
231   0, 0, 0, 0, E0_KPENTER, E0_RCTRL, 0, 0,             /* 0x18-0x1f */
232   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x20-0x27 */
233   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x28-0x2f */
234   0, 0, 0, 0, 0, E0_KPSLASH, 0, E0_PRSCR,             /* 0x30-0x37 */
235   E0_RALT, 0, 0, 0, 0, E0_F13, E0_F14, E0_HELP,       /* 0x38-0x3f */
236   E0_DO, E0_F17, 0, 0, 0, 0, E0_BREAK, E0_HOME,       /* 0x40-0x47 */
237   E0_UP, E0_PGUP, 0, E0_LEFT, E0_OK, E0_RIGHT, E0_KPMINPLUS, E0_END,/* 0x48-0x4f */
238   E0_DOWN, E0_PGDN, E0_INS, E0_DEL, 0, 0, 0, 0,       /* 0x50-0x57 */
239   0, 0, 0, E0_MSLW, E0_MSRW, E0_MSTM, 0, 0,           /* 0x58-0x5f */
240   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x60-0x67 */
241   0, 0, 0, 0, 0, 0, 0, E0_MACRO,                      /* 0x68-0x6f */
242   0, 0, 0, 0, 0, 0, 0, 0,                             /* 0x70-0x77 */
243   0, 0, 0, 0, 0, 0, 0, 0                              /* 0x78-0x7f */
244 };
245
246 int pckbd_setkeycode(unsigned int scancode, unsigned int keycode)
247 {
248         if (scancode < SC_LIM || scancode > 255 || keycode > 127)
249           return -EINVAL;
250         if (scancode < 128)
251           high_keys[scancode - SC_LIM] = keycode;
252         else
253           e0_keys[scancode - 128] = keycode;
254         return 0;
255 }
256
257 int pckbd_getkeycode(unsigned int scancode)
258 {
259         return
260           (scancode < SC_LIM || scancode > 255) ? -EINVAL :
261           (scancode < 128) ? high_keys[scancode - SC_LIM] :
262             e0_keys[scancode - 128];
263 }
264
265 static int do_acknowledge(unsigned char scancode)
266 {
267         if (reply_expected) {
268           /* Unfortunately, we must recognise these codes only if we know they
269            * are known to be valid (i.e., after sending a command), because there
270            * are some brain-damaged keyboards (yes, FOCUS 9000 again) which have
271            * keys with such codes :(
272            */
273                 if (scancode == KBD_REPLY_ACK) {
274                         acknowledge = 1;
275                         reply_expected = 0;
276                         return 0;
277                 } else if (scancode == KBD_REPLY_RESEND) {
278                         resend = 1;
279                         reply_expected = 0;
280                         return 0;
281                 }
282                 /* Should not happen... */
283 #if 0
284                 printk(KERN_DEBUG "keyboard reply expected - got %02x\n",
285                        scancode);
286 #endif
287         }
288         return 1;
289 }
290
291 int pckbd_translate(unsigned char scancode, unsigned char *keycode,
292                     char raw_mode)
293 {
294         static int prev_scancode;
295
296         /* special prefix scancodes.. */
297         if (scancode == 0xe0 || scancode == 0xe1) {
298                 prev_scancode = scancode;
299                 return 0;
300         }
301
302         /* 0xFF is sent by a few keyboards, ignore it. 0x00 is error */
303         if (scancode == 0x00 || scancode == 0xff) {
304                 prev_scancode = 0;
305                 return 0;
306         }
307
308         scancode &= 0x7f;
309
310         if (prev_scancode) {
311           /*
312            * usually it will be 0xe0, but a Pause key generates
313            * e1 1d 45 e1 9d c5 when pressed, and nothing when released
314            */
315           if (prev_scancode != 0xe0) {
316               if (prev_scancode == 0xe1 && scancode == 0x1d) {
317                   prev_scancode = 0x100;
318                   return 0;
319               } else if (prev_scancode == 0x100 && scancode == 0x45) {
320                   *keycode = E1_PAUSE;
321                   prev_scancode = 0;
322               } else {
323 #ifdef KBD_REPORT_UNKN
324                   if (!raw_mode)
325                     printk(KERN_INFO "keyboard: unknown e1 escape sequence\n");
326 #endif
327                   prev_scancode = 0;
328                   return 0;
329               }
330           } else {
331               prev_scancode = 0;
332               /*
333                *  The keyboard maintains its own internal caps lock and
334                *  num lock statuses. In caps lock mode E0 AA precedes make
335                *  code and E0 2A follows break code. In num lock mode,
336                *  E0 2A precedes make code and E0 AA follows break code.
337                *  We do our own book-keeping, so we will just ignore these.
338                */
339               /*
340                *  For my keyboard there is no caps lock mode, but there are
341                *  both Shift-L and Shift-R modes. The former mode generates
342                *  E0 2A / E0 AA pairs, the latter E0 B6 / E0 36 pairs.
343                *  So, we should also ignore the latter. - aeb@cwi.nl
344                */
345               if (scancode == 0x2a || scancode == 0x36)
346                 return 0;
347
348               if (e0_keys[scancode])
349                 *keycode = e0_keys[scancode];
350               else {
351 #ifdef KBD_REPORT_UNKN
352                   if (!raw_mode)
353                     printk(KERN_INFO "keyboard: unknown scancode e0 %02x\n",
354                            scancode);
355 #endif
356                   return 0;
357               }
358           }
359         } else if (scancode >= SC_LIM) {
360             /* This happens with the FOCUS 9000 keyboard
361                Its keys PF1..PF12 are reported to generate
362                55 73 77 78 79 7a 7b 7c 74 7e 6d 6f
363                Moreover, unless repeated, they do not generate
364                key-down events, so we have to zero up_flag below */
365             /* Also, Japanese 86/106 keyboards are reported to
366                generate 0x73 and 0x7d for \ - and \ | respectively. */
367             /* Also, some Brazilian keyboard is reported to produce
368                0x73 and 0x7e for \ ? and KP-dot, respectively. */
369
370           *keycode = high_keys[scancode - SC_LIM];
371
372           if (!*keycode) {
373               if (!raw_mode) {
374 #ifdef KBD_REPORT_UNKN
375                   printk(KERN_INFO "keyboard: unrecognized scancode (%02x)"
376                          " - ignored\n", scancode);
377 #endif
378               }
379               return 0;
380           }
381         } else
382           *keycode = scancode;
383         return 1;
384 }
385
386 char pckbd_unexpected_up(unsigned char keycode)
387 {
388         /* unexpected, but this can happen: maybe this was a key release for a
389            FOCUS 9000 PF key; if we want to see it, we have to clear up_flag */
390         if (keycode >= SC_LIM || keycode == 85)
391             return 0;
392         else
393             return 0200;
394 }
395
396 static inline void handle_mouse_event(unsigned char scancode)
397 {
398 #ifdef CONFIG_PSMOUSE
399         if (mouse_reply_expected) {
400                 if (scancode == AUX_ACK) {
401                         mouse_reply_expected--;
402                         return;
403                 }
404                 mouse_reply_expected = 0;
405         }
406         else if(scancode == AUX_RECONNECT){
407                 queue->head = queue->tail = 0;  /* Flush input queue */
408                 __aux_write_ack(AUX_ENABLE_DEV);  /* ping the mouse :) */
409                 return;
410         }
411
412         add_mouse_randomness(scancode);
413         if (aux_count) {
414                 int head = queue->head;
415
416                 queue->buf[head] = scancode;
417                 head = (head + 1) & (AUX_BUF_SIZE-1);
418                 if (head != queue->tail) {
419                         queue->head = head;
420                         kill_fasync(&queue->fasync, SIGIO, POLL_IN);
421                         wake_up_interruptible(&queue->proc_list);
422                 }
423         }
424 #endif
425 }
426
427 static unsigned char kbd_exists = 1;
428
429 static inline void handle_keyboard_event(unsigned char scancode)
430 {
431 #ifdef CONFIG_VT
432         kbd_exists = 1;
433         if (do_acknowledge(scancode))
434                 handle_scancode(scancode, !(scancode & 0x80));
435 #endif                          
436         tasklet_schedule(&keyboard_tasklet);
437 }       
438
439 /*
440  * This reads the keyboard status port, and does the
441  * appropriate action.
442  *
443  * It requires that we hold the keyboard controller
444  * spinlock.
445  */
446 static unsigned char handle_kbd_event(void)
447 {
448         unsigned char status = kbd_read_status();
449         unsigned int work = 10000;
450
451         while ((--work > 0) && (status & KBD_STAT_OBF)) {
452                 unsigned char scancode;
453
454                 scancode = kbd_read_input();
455
456                 /* Error bytes must be ignored to make the 
457                    Synaptics touchpads compaq use work */
458 #if 1
459                 /* Ignore error bytes */
460                 if (!(status & (KBD_STAT_GTO | KBD_STAT_PERR)))
461 #endif
462                 {
463                         if (status & KBD_STAT_MOUSE_OBF)
464                                 handle_mouse_event(scancode);
465                         else
466                                 handle_keyboard_event(scancode);
467                 }
468
469                 status = kbd_read_status();
470         }
471                 
472         if (!work)
473                 printk(KERN_ERR "pc_keyb: controller jammed (0x%02X).\n", status);
474
475         return status;
476 }
477
478
479 static void keyboard_interrupt(int irq, void *dev_id, struct pt_regs *regs)
480 {
481 #ifdef CONFIG_VT
482         kbd_pt_regs = regs;
483 #endif
484
485         spin_lock_irq(&kbd_controller_lock);
486         handle_kbd_event();
487         spin_unlock_irq(&kbd_controller_lock);
488 }
489
490 /*
491  * send_data sends a character to the keyboard and waits
492  * for an acknowledge, possibly retrying if asked to. Returns
493  * the success status.
494  *
495  * Don't use 'jiffies', so that we don't depend on interrupts
496  */
497 static int send_data(unsigned char data)
498 {
499         int retries = 3;
500
501         do {
502                 unsigned long timeout = KBD_TIMEOUT;
503
504                 acknowledge = 0; /* Set by interrupt routine on receipt of ACK. */
505                 resend = 0;
506                 reply_expected = 1;
507                 kbd_write_output_w(data);
508                 for (;;) {
509                         if (acknowledge)
510                                 return 1;
511                         if (resend)
512                                 break;
513                         mdelay(1);
514                         if (!--timeout) {
515 #ifdef KBD_REPORT_TIMEOUTS
516                                 printk(KERN_WARNING "keyboard: Timeout - AT keyboard not present?\n");
517 #endif
518                                 return 0;
519                         }
520                 }
521         } while (retries-- > 0);
522 #ifdef KBD_REPORT_TIMEOUTS
523         printk(KERN_WARNING "keyboard: Too many NACKs -- noisy kbd cable?\n");
524 #endif
525         return 0;
526 }
527
528 void pckbd_leds(unsigned char leds)
529 {
530         if (kbd_exists && (!send_data(KBD_CMD_SET_LEDS) || !send_data(leds))) {
531                 send_data(KBD_CMD_ENABLE);      /* re-enable kbd if any errors */
532                 kbd_exists = 0;
533         }
534 }
535
536 #define DEFAULT_KEYB_REP_DELAY  250
537 #define DEFAULT_KEYB_REP_RATE   30      /* cps */
538
539 static struct kbd_repeat kbdrate={
540         DEFAULT_KEYB_REP_DELAY,
541         DEFAULT_KEYB_REP_RATE
542 };
543
544 static unsigned char parse_kbd_rate(struct kbd_repeat *r)
545 {
546         static struct r2v{
547                 int rate;
548                 unsigned char val;
549         } kbd_rates[]={ {5,0x14},
550                         {7,0x10},
551                         {10,0x0c},
552                         {15,0x08},
553                         {20,0x04},
554                         {25,0x02},
555                         {30,0x00}
556         };
557         static struct d2v{
558                 int delay;
559                 unsigned char val;
560         } kbd_delays[]={{250,0},
561                         {500,1},
562                         {750,2},
563                         {1000,3}
564         };
565         int rate=0,delay=0;
566         if (r != NULL){
567                 int i,new_rate=30,new_delay=250;
568                 if (r->rate <= 0)
569                         r->rate=kbdrate.rate;
570                 if (r->delay <= 0)
571                         r->delay=kbdrate.delay;
572                 for (i=0; i < sizeof(kbd_rates)/sizeof(struct r2v); i++)
573                         if (kbd_rates[i].rate == r->rate){
574                                 new_rate=kbd_rates[i].rate;
575                                 rate=kbd_rates[i].val;
576                                 break;
577                         }
578                 for (i=0; i < sizeof(kbd_delays)/sizeof(struct d2v); i++)
579                         if (kbd_delays[i].delay == r->delay){
580                                 new_delay=kbd_delays[i].delay;
581                                 delay=kbd_delays[i].val;
582                                 break;
583                         }
584                 r->rate=new_rate;
585                 r->delay=new_delay;
586         }
587         return (delay << 5) | rate;
588 }
589
590 static int write_kbd_rate(unsigned char r)
591 {
592         if (!send_data(KBD_CMD_SET_RATE) || !send_data(r)){
593                 send_data(KBD_CMD_ENABLE);      /* re-enable kbd if any errors */
594                 return 0;
595         }else
596                 return 1;
597 }
598
599 int pckbd_rate(struct kbd_repeat *rep)
600 {
601         if (rep == NULL)
602                 return -EINVAL;
603         else{
604                 unsigned char r=parse_kbd_rate(rep);
605                 struct kbd_repeat old_rep;
606                 memcpy(&old_rep,&kbdrate,sizeof(struct kbd_repeat));
607                 if (write_kbd_rate(r)){
608                         memcpy(&kbdrate,rep,sizeof(struct kbd_repeat));
609                         memcpy(rep,&old_rep,sizeof(struct kbd_repeat));
610                         return 0;
611                 }
612         }
613         return -EIO;
614 }
615
616 /*
617  * In case we run on a non-x86 hardware we need to initialize both the
618  * keyboard controller and the keyboard.  On a x86, the BIOS will
619  * already have initialized them.
620  *
621  * Some x86 BIOSes do not correctly initialize the keyboard, so the
622  * "kbd-reset" command line options can be given to force a reset.
623  * [Ranger]
624  */
625 #ifdef __i386__
626  int kbd_startup_reset __initdata = 0;
627 #else
628  int kbd_startup_reset __initdata = 1;
629 #endif
630
631 /* for "kbd-reset" cmdline param */
632 static int __init kbd_reset_setup(char *str)
633 {
634         kbd_startup_reset = 1;
635         return 1;
636 }
637
638 __setup("kbd-reset", kbd_reset_setup);
639
640 #define KBD_NO_DATA     (-1)    /* No data */
641 #define KBD_BAD_DATA    (-2)    /* Parity or other error */
642
643 static int __init kbd_read_data(void)
644 {
645         int retval = KBD_NO_DATA;
646         unsigned char status;
647
648         status = kbd_read_status();
649         if (status & KBD_STAT_OBF) {
650                 unsigned char data = kbd_read_input();
651
652                 retval = data;
653                 if (status & (KBD_STAT_GTO | KBD_STAT_PERR))
654                         retval = KBD_BAD_DATA;
655         }
656         return retval;
657 }
658
659 static void __init kbd_clear_input(void)
660 {
661         int maxread = 100;      /* Random number */
662
663         do {
664                 if (kbd_read_data() == KBD_NO_DATA)
665                         break;
666         } while (--maxread);
667 }
668
669 static int __init kbd_wait_for_input(void)
670 {
671         long timeout = KBD_INIT_TIMEOUT;
672
673         do {
674                 int retval = kbd_read_data();
675                 if (retval >= 0)
676                         return retval;
677                 mdelay(1);
678         } while (--timeout);
679         return -1;
680 }
681
682 static void kbd_write_command_w(int data)
683 {
684         unsigned long flags;
685
686         spin_lock_irqsave(&kbd_controller_lock, flags);
687         kb_wait();
688         kbd_write_command(data);
689         spin_unlock_irqrestore(&kbd_controller_lock, flags);
690 }
691
692 static void kbd_write_output_w(int data)
693 {
694         unsigned long flags;
695
696         spin_lock_irqsave(&kbd_controller_lock, flags);
697         kb_wait();
698         kbd_write_output(data);
699         spin_unlock_irqrestore(&kbd_controller_lock, flags);
700 }
701
702 #if defined CONFIG_PSMOUSE
703 static void kbd_write_cmd(int cmd)
704 {
705         unsigned long flags;
706
707         spin_lock_irqsave(&kbd_controller_lock, flags);
708         kb_wait();
709         kbd_write_command(KBD_CCMD_WRITE_MODE);
710         kb_wait();
711         kbd_write_output(cmd);
712         spin_unlock_irqrestore(&kbd_controller_lock, flags);
713 }
714 #endif /* CONFIG_PSMOUSE */
715
716 static char * __init initialize_kbd(void)
717 {
718         int status;
719
720         /*
721          * Test the keyboard interface.
722          * This seems to be the only way to get it going.
723          * If the test is successful a x55 is placed in the input buffer.
724          */
725         kbd_write_command_w(KBD_CCMD_SELF_TEST);
726         if (kbd_wait_for_input() != 0x55)
727                 return "Keyboard failed self test";
728
729         /*
730          * Perform a keyboard interface test.  This causes the controller
731          * to test the keyboard clock and data lines.  The results of the
732          * test are placed in the input buffer.
733          */
734         kbd_write_command_w(KBD_CCMD_KBD_TEST);
735         if (kbd_wait_for_input() != 0x00)
736                 return "Keyboard interface failed self test";
737
738         /*
739          * Enable the keyboard by allowing the keyboard clock to run.
740          */
741         kbd_write_command_w(KBD_CCMD_KBD_ENABLE);
742
743         /*
744          * Reset keyboard. If the read times out
745          * then the assumption is that no keyboard is
746          * plugged into the machine.
747          * This defaults the keyboard to scan-code set 2.
748          *
749          * Set up to try again if the keyboard asks for RESEND.
750          */
751         do {
752                 kbd_write_output_w(KBD_CMD_RESET);
753                 status = kbd_wait_for_input();
754                 if (status == KBD_REPLY_ACK)
755                         break;
756                 if (status != KBD_REPLY_RESEND)
757                         return "Keyboard reset failed, no ACK";
758         } while (1);
759
760         if (kbd_wait_for_input() != KBD_REPLY_POR)
761                 return "Keyboard reset failed, no POR";
762
763         /*
764          * Set keyboard controller mode. During this, the keyboard should be
765          * in the disabled state.
766          *
767          * Set up to try again if the keyboard asks for RESEND.
768          */
769         do {
770                 kbd_write_output_w(KBD_CMD_DISABLE);
771                 status = kbd_wait_for_input();
772                 if (status == KBD_REPLY_ACK)
773                         break;
774                 if (status != KBD_REPLY_RESEND)
775                         return "Disable keyboard: no ACK";
776         } while (1);
777
778         kbd_write_command_w(KBD_CCMD_WRITE_MODE);
779         kbd_write_output_w(KBD_MODE_KBD_INT
780                               | KBD_MODE_SYS
781                               | KBD_MODE_DISABLE_MOUSE
782                               | KBD_MODE_KCC);
783
784         /* ibm powerpc portables need this to use scan-code set 1 -- Cort */
785         kbd_write_command_w(KBD_CCMD_READ_MODE);
786         if (!(kbd_wait_for_input() & KBD_MODE_KCC)) {
787                 /*
788                  * If the controller does not support conversion,
789                  * Set the keyboard to scan-code set 1.
790                  */
791                 kbd_write_output_w(0xF0);
792                 kbd_wait_for_input();
793                 kbd_write_output_w(0x01);
794                 kbd_wait_for_input();
795         }
796
797         
798         kbd_write_output_w(KBD_CMD_ENABLE);
799         if (kbd_wait_for_input() != KBD_REPLY_ACK)
800                 return "Enable keyboard: no ACK";
801
802         /*
803          * Finally, set the typematic rate to maximum.
804          */
805         kbd_write_output_w(KBD_CMD_SET_RATE);
806         if (kbd_wait_for_input() != KBD_REPLY_ACK)
807                 return "Set rate: no ACK";
808         kbd_write_output_w(0x00);
809         if (kbd_wait_for_input() != KBD_REPLY_ACK)
810                 return "Set rate: no ACK";
811
812         return NULL;
813 }
814
815 void __init pckbd_init_hw(void)
816 {
817         kbd_request_region();
818
819         /* Flush any pending input. */
820         kbd_clear_input();
821
822         if (kbd_startup_reset) {
823                 char *msg = initialize_kbd();
824                 if (msg)
825                         printk(KERN_WARNING "initialize_kbd: %s\n", msg);
826         }
827
828 #if defined CONFIG_PSMOUSE
829         psaux_init();
830 #endif
831
832         /* Ok, finally allocate the IRQ, and off we go.. */
833         kbd_request_irq(keyboard_interrupt);
834 }
835
836 #if defined CONFIG_PSMOUSE
837
838 /*
839  * Check if this is a dual port controller.
840  */
841 static int __init detect_auxiliary_port(void)
842 {
843         unsigned long flags;
844         int loops = 10;
845         int retval = 0;
846
847         /* Check if the BIOS detected a device on the auxiliary port. */
848         if (aux_device_present == 0xaa)
849                 return 1;
850
851         spin_lock_irqsave(&kbd_controller_lock, flags);
852
853         /* Put the value 0x5A in the output buffer using the "Write
854          * Auxiliary Device Output Buffer" command (0xD3). Poll the
855          * Status Register for a while to see if the value really
856          * turns up in the Data Register. If the KBD_STAT_MOUSE_OBF
857          * bit is also set to 1 in the Status Register, we assume this
858          * controller has an Auxiliary Port (a.k.a. Mouse Port).
859          */
860         kb_wait();
861         kbd_write_command(KBD_CCMD_WRITE_AUX_OBUF);
862
863         kb_wait();
864         kbd_write_output(0x5a); /* 0x5a is a random dummy value. */
865
866         do {
867                 unsigned char status = kbd_read_status();
868
869                 if (status & KBD_STAT_OBF) {
870                         (void) kbd_read_input();
871                         if (status & KBD_STAT_MOUSE_OBF) {
872                                 printk(KERN_INFO "Detected PS/2 Mouse Port.\n");
873                                 retval = 1;
874                         }
875                         break;
876                 }
877                 mdelay(1);
878         } while (--loops);
879         spin_unlock_irqrestore(&kbd_controller_lock, flags);
880
881         return retval;
882 }
883
884 /*
885  * Send a byte to the mouse.
886  */
887 static void aux_write_dev(int val)
888 {
889         unsigned long flags;
890
891         spin_lock_irqsave(&kbd_controller_lock, flags);
892         kb_wait();
893         kbd_write_command(KBD_CCMD_WRITE_MOUSE);
894         kb_wait();
895         kbd_write_output(val);
896         spin_unlock_irqrestore(&kbd_controller_lock, flags);
897 }
898
899 /*
900  * Send a byte to the mouse & handle returned ack
901  */
902 static void __aux_write_ack(int val)
903 {
904         kb_wait();
905         kbd_write_command(KBD_CCMD_WRITE_MOUSE);
906         kb_wait();
907         kbd_write_output(val);
908         /* we expect an ACK in response. */
909         mouse_reply_expected++;
910         kb_wait();
911 }
912
913 static void aux_write_ack(int val)
914 {
915         unsigned long flags;
916
917         spin_lock_irqsave(&kbd_controller_lock, flags);
918         __aux_write_ack(val);
919         spin_unlock_irqrestore(&kbd_controller_lock, flags);
920 }
921
922 static unsigned char get_from_queue(void)
923 {
924         unsigned char result;
925         unsigned long flags;
926
927         spin_lock_irqsave(&kbd_controller_lock, flags);
928         result = queue->buf[queue->tail];
929         queue->tail = (queue->tail + 1) & (AUX_BUF_SIZE-1);
930         spin_unlock_irqrestore(&kbd_controller_lock, flags);
931         return result;
932 }
933
934
935 static inline int queue_empty(void)
936 {
937         return queue->head == queue->tail;
938 }
939
940 static int fasync_aux(int fd, struct file *filp, int on)
941 {
942         int retval;
943
944         retval = fasync_helper(fd, filp, on, &queue->fasync);
945         if (retval < 0)
946                 return retval;
947         return 0;
948 }
949
950
951 /*
952  * Random magic cookie for the aux device
953  */
954 #define AUX_DEV ((void *)queue)
955
956 static int release_aux(struct inode * inode, struct file * file)
957 {
958         lock_kernel();
959         fasync_aux(-1, file, 0);
960         if (--aux_count) {
961                 unlock_kernel();
962                 return 0;
963         }
964         kbd_write_cmd(AUX_INTS_OFF);                        /* Disable controller ints */
965         kbd_write_command_w(KBD_CCMD_MOUSE_DISABLE);
966         aux_free_irq(AUX_DEV);
967         unlock_kernel();
968         return 0;
969 }
970
971 /*
972  * Install interrupt handler.
973  * Enable auxiliary device.
974  */
975
976 static int open_aux(struct inode * inode, struct file * file)
977 {
978         if (aux_count++) {
979                 return 0;
980         }
981         queue->head = queue->tail = 0;          /* Flush input queue */
982         if (aux_request_irq(keyboard_interrupt, AUX_DEV)) {
983                 aux_count--;
984                 return -EBUSY;
985         }
986         kbd_write_command_w(KBD_CCMD_MOUSE_ENABLE);     /* Enable the
987                                                            auxiliary port on
988                                                            controller. */
989         aux_write_ack(AUX_ENABLE_DEV); /* Enable aux device */
990         kbd_write_cmd(AUX_INTS_ON); /* Enable controller ints */
991         
992         mdelay(2);                      /* Ensure we follow the kbc access delay rules.. */
993
994         send_data(KBD_CMD_ENABLE);      /* try to workaround toshiba4030cdt problem */
995
996         return 0;
997 }
998
999 /*
1000  * Put bytes from input queue to buffer.
1001  */
1002
1003 static ssize_t read_aux(struct file * file, char * buffer,
1004                         size_t count, loff_t *ppos)
1005 {
1006         DECLARE_WAITQUEUE(wait, current);
1007         ssize_t i = count;
1008         unsigned char c;
1009
1010         if (queue_empty()) {
1011                 if (file->f_flags & O_NONBLOCK)
1012                         return -EAGAIN;
1013                 add_wait_queue(&queue->proc_list, &wait);
1014 repeat:
1015                 set_current_state(TASK_INTERRUPTIBLE);
1016                 if (queue_empty() && !signal_pending(current)) {
1017                         schedule();
1018                         goto repeat;
1019                 }
1020                 current->state = TASK_RUNNING;
1021                 remove_wait_queue(&queue->proc_list, &wait);
1022         }
1023         while (i > 0 && !queue_empty()) {
1024                 c = get_from_queue();
1025                 put_user(c, buffer++);
1026                 i--;
1027         }
1028         if (count-i) {
1029                 file->f_dentry->d_inode->i_atime = CURRENT_TIME;
1030                 return count-i;
1031         }
1032         if (signal_pending(current))
1033                 return -ERESTARTSYS;
1034         return 0;
1035 }
1036
1037 /*
1038  * Write to the aux device.
1039  */
1040
1041 static ssize_t write_aux(struct file * file, const char * buffer,
1042                          size_t count, loff_t *ppos)
1043 {
1044         ssize_t retval = 0;
1045
1046         if (count) {
1047                 ssize_t written = 0;
1048
1049                 if (count > 32)
1050                         count = 32; /* Limit to 32 bytes. */
1051                 do {
1052                         char c;
1053                         get_user(c, buffer++);
1054                         aux_write_dev(c);
1055                         written++;
1056                 } while (--count);
1057                 retval = -EIO;
1058                 if (written) {
1059                         retval = written;
1060                         file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
1061                 }
1062         }
1063
1064         return retval;
1065 }
1066
1067 /* No kernel lock held - fine */
1068 static unsigned int aux_poll(struct file *file, poll_table * wait)
1069 {
1070         poll_wait(file, &queue->proc_list, wait);
1071         if (!queue_empty())
1072                 return POLLIN | POLLRDNORM;
1073         return 0;
1074 }
1075
1076 struct file_operations psaux_fops = {
1077         read:           read_aux,
1078         write:          write_aux,
1079         poll:           aux_poll,
1080         open:           open_aux,
1081         release:        release_aux,
1082         fasync:         fasync_aux,
1083 };
1084
1085 /*
1086  * Initialize driver.
1087  */
1088 static struct miscdevice psaux_mouse = {
1089         PSMOUSE_MINOR, "psaux", &psaux_fops
1090 };
1091
1092 static int __init psaux_init(void)
1093 {
1094         if (!detect_auxiliary_port())
1095                 return -EIO;
1096
1097         misc_register(&psaux_mouse);
1098         queue = (struct aux_queue *) kmalloc(sizeof(*queue), GFP_KERNEL);
1099         if (queue == NULL)
1100                 panic("psaux_init(): out of memory");
1101         memset(queue, 0, sizeof(*queue));
1102         queue->head = queue->tail = 0;
1103         init_waitqueue_head(&queue->proc_list);
1104
1105 #ifdef INITIALIZE_MOUSE
1106         kbd_write_command_w(KBD_CCMD_MOUSE_ENABLE); /* Enable Aux. */
1107         aux_write_ack(AUX_SET_SAMPLE);
1108         aux_write_ack(100);                     /* 100 samples/sec */
1109         aux_write_ack(AUX_SET_RES);
1110         aux_write_ack(3);                       /* 8 counts per mm */
1111         aux_write_ack(AUX_SET_SCALE21);         /* 2:1 scaling */
1112 #endif /* INITIALIZE_MOUSE */
1113         kbd_write_command(KBD_CCMD_MOUSE_DISABLE); /* Disable aux device. */
1114         kbd_write_cmd(AUX_INTS_OFF); /* Disable controller ints. */
1115
1116         return 0;
1117 }
1118
1119 #endif /* CONFIG_PSMOUSE */