Manual merge with Linus
[linux-2.6.git] / drivers / char / keyboard.c
1 /*
2  * linux/drivers/char/keyboard.c
3  *
4  * Written for linux by Johan Myreen as a translation from
5  * the assembly version by Linus (with diacriticals added)
6  *
7  * Some additional features added by Christoph Niemann (ChN), March 1993
8  *
9  * Loadable keymaps by Risto Kankkunen, May 1993
10  *
11  * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
12  * Added decr/incr_console, dynamic keymaps, Unicode support,
13  * dynamic function/string keys, led setting,  Sept 1994
14  * `Sticky' modifier keys, 951006.
15  *
16  * 11-11-96: SAK should now work in the raw mode (Martin Mares)
17  * 
18  * Modified to provide 'generic' keyboard support by Hamish Macdonald
19  * Merge with the m68k keyboard driver and split-off of the PC low-level
20  * parts by Geert Uytterhoeven, May 1997
21  *
22  * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
23  * 30-07-98: Dead keys redone, aeb@cwi.nl.
24  * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
25  */
26
27 #include <linux/config.h>
28 #include <linux/module.h>
29 #include <linux/sched.h>
30 #include <linux/tty.h>
31 #include <linux/tty_flip.h>
32 #include <linux/mm.h>
33 #include <linux/string.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
36
37 #include <linux/kbd_kern.h>
38 #include <linux/kbd_diacr.h>
39 #include <linux/vt_kern.h>
40 #include <linux/sysrq.h>
41 #include <linux/input.h>
42
43 static void kbd_disconnect(struct input_handle *handle);
44 extern void ctrl_alt_del(void);
45
46 /*
47  * Exported functions/variables
48  */
49
50 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
51
52 /*
53  * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
54  * This seems a good reason to start with NumLock off. On HIL keyboards
55  * of PARISC machines however there is no NumLock key and everyone expects the keypad 
56  * to be used for numbers.
57  */
58
59 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
60 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
61 #else
62 #define KBD_DEFLEDS 0
63 #endif
64
65 #define KBD_DEFLOCK 0
66
67 void compute_shiftstate(void);
68
69 /*
70  * Handler Tables.
71  */
72
73 #define K_HANDLERS\
74         k_self,         k_fn,           k_spec,         k_pad,\
75         k_dead,         k_cons,         k_cur,          k_shift,\
76         k_meta,         k_ascii,        k_lock,         k_lowercase,\
77         k_slock,        k_dead2,        k_ignore,       k_ignore
78
79 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value, 
80                             char up_flag, struct pt_regs *regs);
81 static k_handler_fn K_HANDLERS;
82 static k_handler_fn *k_handler[16] = { K_HANDLERS };
83
84 #define FN_HANDLERS\
85         fn_null,        fn_enter,       fn_show_ptregs, fn_show_mem,\
86         fn_show_state,  fn_send_intr,   fn_lastcons,    fn_caps_toggle,\
87         fn_num,         fn_hold,        fn_scroll_forw, fn_scroll_back,\
88         fn_boot_it,     fn_caps_on,     fn_compose,     fn_SAK,\
89         fn_dec_console, fn_inc_console, fn_spawn_con,   fn_bare_num
90
91 typedef void (fn_handler_fn)(struct vc_data *vc, struct pt_regs *regs);
92 static fn_handler_fn FN_HANDLERS;
93 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
94
95 /*
96  * Variables exported for vt_ioctl.c
97  */
98
99 /* maximum values each key_handler can handle */
100 const int max_vals[] = {
101         255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
102         NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
103         255, NR_LOCK - 1, 255
104 };
105
106 const int NR_TYPES = ARRAY_SIZE(max_vals);
107
108 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
109 static struct kbd_struct *kbd = kbd_table;
110 static struct kbd_struct kbd0;
111
112 int spawnpid, spawnsig;
113
114 /*
115  * Variables exported for vt.c
116  */
117
118 int shift_state = 0;
119
120 /*
121  * Internal Data.
122  */
123
124 static struct input_handler kbd_handler;
125 static unsigned long key_down[NBITS(KEY_MAX)];          /* keyboard key bitmap */
126 static unsigned char shift_down[NR_SHIFT];              /* shift state counters.. */
127 static int dead_key_next;
128 static int npadch = -1;                                 /* -1 or number assembled on pad */
129 static unsigned char diacr;
130 static char rep;                                        /* flag telling character repeat */
131
132 static unsigned char ledstate = 0xff;                   /* undefined */
133 static unsigned char ledioctl;
134
135 static struct ledptr {
136         unsigned int *addr;
137         unsigned int mask;
138         unsigned char valid:1;
139 } ledptrs[3];
140
141 /* Simple translation table for the SysRq keys */
142
143 #ifdef CONFIG_MAGIC_SYSRQ
144 unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
145         "\000\0331234567890-=\177\t"                    /* 0x00 - 0x0f */
146         "qwertyuiop[]\r\000as"                          /* 0x10 - 0x1f */
147         "dfghjkl;'`\000\\zxcv"                          /* 0x20 - 0x2f */
148         "bnm,./\000*\000 \000\201\202\203\204\205"      /* 0x30 - 0x3f */
149         "\206\207\210\211\212\000\000789-456+1"         /* 0x40 - 0x4f */
150         "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
151         "\r\000/";                                      /* 0x60 - 0x6f */
152 static int sysrq_down;
153 #endif
154 static int sysrq_alt;
155
156 /*
157  * Translation of scancodes to keycodes. We set them on only the first attached
158  * keyboard - for per-keyboard setting, /dev/input/event is more useful.
159  */
160 int getkeycode(unsigned int scancode)
161 {
162         struct list_head * node;
163         struct input_dev *dev = NULL;
164
165         list_for_each(node,&kbd_handler.h_list) {
166                 struct input_handle * handle = to_handle_h(node);
167                 if (handle->dev->keycodesize) { 
168                         dev = handle->dev; 
169                         break;
170                 }
171         }
172
173         if (!dev)
174                 return -ENODEV;
175
176         if (scancode >= dev->keycodemax)
177                 return -EINVAL;
178
179         return INPUT_KEYCODE(dev, scancode);
180 }
181
182 int setkeycode(unsigned int scancode, unsigned int keycode)
183 {
184         struct list_head * node;
185         struct input_dev *dev = NULL;
186         unsigned int i, oldkey;
187
188         list_for_each(node,&kbd_handler.h_list) {
189                 struct input_handle *handle = to_handle_h(node);
190                 if (handle->dev->keycodesize) { 
191                         dev = handle->dev; 
192                         break; 
193                 }
194         }
195
196         if (!dev)
197                 return -ENODEV;
198
199         if (scancode >= dev->keycodemax)
200                 return -EINVAL;
201         if (keycode < 0 || keycode > KEY_MAX)
202                 return -EINVAL;
203         if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
204                 return -EINVAL;
205
206         oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
207
208         clear_bit(oldkey, dev->keybit);
209         set_bit(keycode, dev->keybit);
210
211         for (i = 0; i < dev->keycodemax; i++)
212                 if (INPUT_KEYCODE(dev,i) == oldkey)
213                         set_bit(oldkey, dev->keybit);
214
215         return 0;
216 }
217
218 /*
219  * Making beeps and bells. 
220  */
221 static void kd_nosound(unsigned long ignored)
222 {
223         struct list_head * node;
224
225         list_for_each(node,&kbd_handler.h_list) {
226                 struct input_handle *handle = to_handle_h(node);
227                 if (test_bit(EV_SND, handle->dev->evbit)) {
228                         if (test_bit(SND_TONE, handle->dev->sndbit))
229                                 input_event(handle->dev, EV_SND, SND_TONE, 0);
230                         if (test_bit(SND_BELL, handle->dev->sndbit))
231                                 input_event(handle->dev, EV_SND, SND_BELL, 0);
232                 }
233         }
234 }
235
236 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
237
238 void kd_mksound(unsigned int hz, unsigned int ticks)
239 {
240         struct list_head * node;
241
242         del_timer(&kd_mksound_timer);
243
244         if (hz) {
245                 list_for_each_prev(node,&kbd_handler.h_list) {
246                         struct input_handle *handle = to_handle_h(node);
247                         if (test_bit(EV_SND, handle->dev->evbit)) {
248                                 if (test_bit(SND_TONE, handle->dev->sndbit)) {
249                                         input_event(handle->dev, EV_SND, SND_TONE, hz);
250                                         break;
251                                 }
252                                 if (test_bit(SND_BELL, handle->dev->sndbit)) {
253                                         input_event(handle->dev, EV_SND, SND_BELL, 1);
254                                         break;
255                                 }
256                         }
257                 }
258                 if (ticks)
259                         mod_timer(&kd_mksound_timer, jiffies + ticks);
260         } else
261                 kd_nosound(0);
262 }
263
264 /*
265  * Setting the keyboard rate.
266  */
267
268 int kbd_rate(struct kbd_repeat *rep)
269 {
270         struct list_head *node;
271         unsigned int d = 0;
272         unsigned int p = 0;
273
274         list_for_each(node,&kbd_handler.h_list) {
275                 struct input_handle *handle = to_handle_h(node);
276                 struct input_dev *dev = handle->dev;
277
278                 if (test_bit(EV_REP, dev->evbit)) {
279                         if (rep->delay > 0)
280                                 input_event(dev, EV_REP, REP_DELAY, rep->delay);
281                         if (rep->period > 0)
282                                 input_event(dev, EV_REP, REP_PERIOD, rep->period);
283                         d = dev->rep[REP_DELAY];
284                         p = dev->rep[REP_PERIOD];
285                 }
286         }
287         rep->delay  = d;
288         rep->period = p;
289         return 0;
290 }
291
292 /*
293  * Helper Functions.
294  */
295 static void put_queue(struct vc_data *vc, int ch)
296 {
297         struct tty_struct *tty = vc->vc_tty;
298
299         if (tty) {
300                 tty_insert_flip_char(tty, ch, 0);
301                 con_schedule_flip(tty);
302         }
303 }
304
305 static void puts_queue(struct vc_data *vc, char *cp)
306 {
307         struct tty_struct *tty = vc->vc_tty;
308
309         if (!tty)
310                 return;
311
312         while (*cp) {
313                 tty_insert_flip_char(tty, *cp, 0);
314                 cp++;
315         }
316         con_schedule_flip(tty);
317 }
318
319 static void applkey(struct vc_data *vc, int key, char mode)
320 {
321         static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
322
323         buf[1] = (mode ? 'O' : '[');
324         buf[2] = key;
325         puts_queue(vc, buf);
326 }
327
328 /*
329  * Many other routines do put_queue, but I think either
330  * they produce ASCII, or they produce some user-assigned
331  * string, and in both cases we might assume that it is
332  * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
333  * but we need only 16 bits here
334  */
335 static void to_utf8(struct vc_data *vc, ushort c)
336 {
337         if (c < 0x80)
338                 /*  0******* */
339                 put_queue(vc, c);
340         else if (c < 0x800) {
341                 /* 110***** 10****** */
342                 put_queue(vc, 0xc0 | (c >> 6)); 
343                 put_queue(vc, 0x80 | (c & 0x3f));
344         } else {
345                 /* 1110**** 10****** 10****** */
346                 put_queue(vc, 0xe0 | (c >> 12));
347                 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
348                 put_queue(vc, 0x80 | (c & 0x3f));
349         }
350 }
351
352 /* 
353  * Called after returning from RAW mode or when changing consoles - recompute
354  * shift_down[] and shift_state from key_down[] maybe called when keymap is
355  * undefined, so that shiftkey release is seen
356  */
357 void compute_shiftstate(void)
358 {
359         unsigned int i, j, k, sym, val;
360
361         shift_state = 0;
362         memset(shift_down, 0, sizeof(shift_down));
363         
364         for (i = 0; i < ARRAY_SIZE(key_down); i++) {
365
366                 if (!key_down[i])
367                         continue;
368
369                 k = i * BITS_PER_LONG;
370
371                 for (j = 0; j < BITS_PER_LONG; j++, k++) {
372
373                         if (!test_bit(k, key_down))
374                                 continue;
375
376                         sym = U(key_maps[0][k]);
377                         if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
378                                 continue;
379
380                         val = KVAL(sym);
381                         if (val == KVAL(K_CAPSSHIFT))
382                                 val = KVAL(K_SHIFT);
383
384                         shift_down[val]++;
385                         shift_state |= (1 << val);
386                 }
387         }
388 }
389
390 /*
391  * We have a combining character DIACR here, followed by the character CH.
392  * If the combination occurs in the table, return the corresponding value.
393  * Otherwise, if CH is a space or equals DIACR, return DIACR.
394  * Otherwise, conclude that DIACR was not combining after all,
395  * queue it and return CH.
396  */
397 static unsigned char handle_diacr(struct vc_data *vc, unsigned char ch)
398 {
399         int d = diacr;
400         unsigned int i;
401
402         diacr = 0;
403
404         for (i = 0; i < accent_table_size; i++) {
405                 if (accent_table[i].diacr == d && accent_table[i].base == ch)
406                         return accent_table[i].result;
407         }
408
409         if (ch == ' ' || ch == d)
410                 return d;
411
412         put_queue(vc, d);
413         return ch;
414 }
415
416 /*
417  * Special function handlers
418  */
419 static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
420 {
421         if (diacr) {
422                 put_queue(vc, diacr);
423                 diacr = 0;
424         }
425         put_queue(vc, 13);
426         if (vc_kbd_mode(kbd, VC_CRLF))
427                 put_queue(vc, 10);
428 }
429
430 static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
431 {
432         if (rep)
433                 return;
434         chg_vc_kbd_led(kbd, VC_CAPSLOCK);
435 }
436
437 static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
438 {
439         if (rep)
440                 return;
441         set_vc_kbd_led(kbd, VC_CAPSLOCK);
442 }
443
444 static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
445 {
446         if (regs)
447                 show_regs(regs);
448 }
449
450 static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
451 {
452         struct tty_struct *tty = vc->vc_tty;
453
454         if (rep || !tty)
455                 return;
456
457         /*
458          * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
459          * these routines are also activated by ^S/^Q.
460          * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
461          */
462         if (tty->stopped)
463                 start_tty(tty);
464         else
465                 stop_tty(tty);
466 }
467
468 static void fn_num(struct vc_data *vc, struct pt_regs *regs)
469 {
470         if (vc_kbd_mode(kbd,VC_APPLIC))
471                 applkey(vc, 'P', 1);
472         else
473                 fn_bare_num(vc, regs);
474 }
475
476 /*
477  * Bind this to Shift-NumLock if you work in application keypad mode
478  * but want to be able to change the NumLock flag.
479  * Bind this to NumLock if you prefer that the NumLock key always
480  * changes the NumLock flag.
481  */
482 static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
483 {
484         if (!rep)
485                 chg_vc_kbd_led(kbd, VC_NUMLOCK);
486 }
487
488 static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
489 {
490         /* switch to the last used console, ChN */
491         set_console(last_console);
492 }
493
494 static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
495 {
496         int i, cur = fg_console;
497
498         /* Currently switching?  Queue this next switch relative to that. */
499         if (want_console != -1)
500                 cur = want_console;
501
502         for (i = cur-1; i != cur; i--) {
503                 if (i == -1)
504                         i = MAX_NR_CONSOLES-1;
505                 if (vc_cons_allocated(i))
506                         break;
507         }
508         set_console(i);
509 }
510
511 static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
512 {
513         int i, cur = fg_console;
514
515         /* Currently switching?  Queue this next switch relative to that. */
516         if (want_console != -1)
517                 cur = want_console;
518
519         for (i = cur+1; i != cur; i++) {
520                 if (i == MAX_NR_CONSOLES)
521                         i = 0;
522                 if (vc_cons_allocated(i))
523                         break;
524         }
525         set_console(i);
526 }
527
528 static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
529 {
530         struct tty_struct *tty = vc->vc_tty;
531
532         if (!tty)
533                 return;
534         tty_insert_flip_char(tty, 0, TTY_BREAK);
535         con_schedule_flip(tty);
536 }
537
538 static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
539 {
540         scrollfront(vc, 0);
541 }
542
543 static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
544 {
545         scrollback(vc, 0);
546 }
547
548 static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
549 {
550         show_mem();
551 }
552
553 static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
554 {
555         show_state();
556 }
557
558 static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
559 {
560         ctrl_alt_del();
561 }
562
563 static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
564 {
565         dead_key_next = 1;
566 }
567
568 static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
569 {
570         if (spawnpid)
571            if(kill_proc(spawnpid, spawnsig, 1))
572              spawnpid = 0;
573 }
574
575 static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
576 {
577         struct tty_struct *tty = vc->vc_tty;
578
579         /*
580          * SAK should also work in all raw modes and reset
581          * them properly.
582          */
583         if (tty)
584                 do_SAK(tty);
585         reset_vc(vc);
586 }
587
588 static void fn_null(struct vc_data *vc, struct pt_regs *regs)
589 {
590         compute_shiftstate();
591 }
592
593 /*
594  * Special key handlers
595  */
596 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
597 {
598 }
599
600 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
601 {
602         if (up_flag)
603                 return;
604         if (value >= ARRAY_SIZE(fn_handler))
605                 return;
606         if ((kbd->kbdmode == VC_RAW || 
607              kbd->kbdmode == VC_MEDIUMRAW) && 
608              value != KVAL(K_SAK))
609                 return;         /* SAK is allowed even in raw mode */
610         fn_handler[value](vc, regs);
611 }
612
613 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
614 {
615         printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
616 }
617
618 static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
619 {
620         if (up_flag)
621                 return;         /* no action, if this is a key release */
622
623         if (diacr)
624                 value = handle_diacr(vc, value);
625
626         if (dead_key_next) {
627                 dead_key_next = 0;
628                 diacr = value;
629                 return;
630         }
631         put_queue(vc, value);
632 }
633
634 /*
635  * Handle dead key. Note that we now may have several
636  * dead keys modifying the same character. Very useful
637  * for Vietnamese.
638  */
639 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
640 {
641         if (up_flag)
642                 return;
643         diacr = (diacr ? handle_diacr(vc, value) : value);
644 }
645
646 /*
647  * Obsolete - for backwards compatibility only
648  */
649 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
650 {
651         static unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
652         value = ret_diacr[value];
653         k_dead2(vc, value, up_flag, regs);
654 }
655
656 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
657 {
658         if (up_flag)
659                 return;
660         set_console(value);
661 }
662
663 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
664 {
665         unsigned v;
666
667         if (up_flag)
668                 return;
669         v = value;
670         if (v < ARRAY_SIZE(func_table)) {
671                 if (func_table[value])
672                         puts_queue(vc, func_table[value]);
673         } else
674                 printk(KERN_ERR "k_fn called with value=%d\n", value);
675 }
676
677 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
678 {
679         static const char *cur_chars = "BDCA";
680
681         if (up_flag)
682                 return;
683         applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
684 }
685
686 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
687 {
688         static const char *pad_chars = "0123456789+-*/\015,.?()#";
689         static const char *app_map = "pqrstuvwxylSRQMnnmPQS";
690
691         if (up_flag)
692                 return;         /* no action, if this is a key release */
693
694         /* kludge... shift forces cursor/number keys */
695         if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
696                 applkey(vc, app_map[value], 1);
697                 return;
698         }
699
700         if (!vc_kbd_led(kbd, VC_NUMLOCK))
701                 switch (value) {
702                         case KVAL(K_PCOMMA):
703                         case KVAL(K_PDOT):
704                                 k_fn(vc, KVAL(K_REMOVE), 0, regs);
705                                 return;
706                         case KVAL(K_P0):
707                                 k_fn(vc, KVAL(K_INSERT), 0, regs);
708                                 return;
709                         case KVAL(K_P1):
710                                 k_fn(vc, KVAL(K_SELECT), 0, regs);
711                                 return;
712                         case KVAL(K_P2):
713                                 k_cur(vc, KVAL(K_DOWN), 0, regs);
714                                 return;
715                         case KVAL(K_P3):
716                                 k_fn(vc, KVAL(K_PGDN), 0, regs);
717                                 return;
718                         case KVAL(K_P4):
719                                 k_cur(vc, KVAL(K_LEFT), 0, regs);
720                                 return;
721                         case KVAL(K_P6):
722                                 k_cur(vc, KVAL(K_RIGHT), 0, regs);
723                                 return;
724                         case KVAL(K_P7):
725                                 k_fn(vc, KVAL(K_FIND), 0, regs);
726                                 return;
727                         case KVAL(K_P8):
728                                 k_cur(vc, KVAL(K_UP), 0, regs);
729                                 return;
730                         case KVAL(K_P9):
731                                 k_fn(vc, KVAL(K_PGUP), 0, regs);
732                                 return;
733                         case KVAL(K_P5):
734                                 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
735                                 return;
736                 }
737
738         put_queue(vc, pad_chars[value]);
739         if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
740                 put_queue(vc, 10);
741 }
742
743 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
744 {
745         int old_state = shift_state;
746
747         if (rep)
748                 return;
749         /*
750          * Mimic typewriter:
751          * a CapsShift key acts like Shift but undoes CapsLock
752          */
753         if (value == KVAL(K_CAPSSHIFT)) {
754                 value = KVAL(K_SHIFT);
755                 if (!up_flag)
756                         clr_vc_kbd_led(kbd, VC_CAPSLOCK);
757         }
758
759         if (up_flag) {
760                 /*
761                  * handle the case that two shift or control
762                  * keys are depressed simultaneously
763                  */
764                 if (shift_down[value])
765                         shift_down[value]--;
766         } else
767                 shift_down[value]++;
768
769         if (shift_down[value])
770                 shift_state |= (1 << value);
771         else
772                 shift_state &= ~(1 << value);
773
774         /* kludge */
775         if (up_flag && shift_state != old_state && npadch != -1) {
776                 if (kbd->kbdmode == VC_UNICODE)
777                         to_utf8(vc, npadch & 0xffff);
778                 else
779                         put_queue(vc, npadch & 0xff);
780                 npadch = -1;
781         }
782 }
783
784 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
785 {
786         if (up_flag)
787                 return;
788
789         if (vc_kbd_mode(kbd, VC_META)) {
790                 put_queue(vc, '\033');
791                 put_queue(vc, value);
792         } else
793                 put_queue(vc, value | 0x80);
794 }
795
796 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
797 {
798         int base;
799
800         if (up_flag)
801                 return;
802
803         if (value < 10) {
804                 /* decimal input of code, while Alt depressed */
805                 base = 10;
806         } else {
807                 /* hexadecimal input of code, while AltGr depressed */
808                 value -= 10;
809                 base = 16;
810         }
811
812         if (npadch == -1)
813                 npadch = value;
814         else
815                 npadch = npadch * base + value;
816 }
817
818 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
819 {
820         if (up_flag || rep)
821                 return;
822         chg_vc_kbd_lock(kbd, value);
823 }
824
825 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
826 {
827         k_shift(vc, value, up_flag, regs);
828         if (up_flag || rep)
829                 return;
830         chg_vc_kbd_slock(kbd, value);
831         /* try to make Alt, oops, AltGr and such work */
832         if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
833                 kbd->slockstate = 0;
834                 chg_vc_kbd_slock(kbd, value);
835         }
836 }
837
838 /*
839  * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
840  * or (ii) whatever pattern of lights people want to show using KDSETLED,
841  * or (iii) specified bits of specified words in kernel memory.
842  */
843 unsigned char getledstate(void)
844 {
845         return ledstate;
846 }
847
848 void setledstate(struct kbd_struct *kbd, unsigned int led)
849 {
850         if (!(led & ~7)) {
851                 ledioctl = led;
852                 kbd->ledmode = LED_SHOW_IOCTL;
853         } else
854                 kbd->ledmode = LED_SHOW_FLAGS;
855         set_leds();
856 }
857
858 static inline unsigned char getleds(void)
859 {
860         struct kbd_struct *kbd = kbd_table + fg_console;
861         unsigned char leds;
862         int i;
863
864         if (kbd->ledmode == LED_SHOW_IOCTL)
865                 return ledioctl;
866
867         leds = kbd->ledflagstate;
868
869         if (kbd->ledmode == LED_SHOW_MEM) {
870                 for (i = 0; i < 3; i++)
871                         if (ledptrs[i].valid) {
872                                 if (*ledptrs[i].addr & ledptrs[i].mask)
873                                         leds |= (1 << i);
874                                 else
875                                         leds &= ~(1 << i);
876                         }
877         }
878         return leds;
879 }
880
881 /*
882  * This routine is the bottom half of the keyboard interrupt
883  * routine, and runs with all interrupts enabled. It does
884  * console changing, led setting and copy_to_cooked, which can
885  * take a reasonably long time.
886  *
887  * Aside from timing (which isn't really that important for
888  * keyboard interrupts as they happen often), using the software
889  * interrupt routines for this thing allows us to easily mask
890  * this when we don't want any of the above to happen.
891  * This allows for easy and efficient race-condition prevention
892  * for kbd_refresh_leds => input_event(dev, EV_LED, ...) => ...
893  */
894
895 static void kbd_bh(unsigned long dummy)
896 {
897         struct list_head * node;
898         unsigned char leds = getleds();
899
900         if (leds != ledstate) {
901                 list_for_each(node,&kbd_handler.h_list) {
902                         struct input_handle * handle = to_handle_h(node);
903                         input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
904                         input_event(handle->dev, EV_LED, LED_NUML,    !!(leds & 0x02));
905                         input_event(handle->dev, EV_LED, LED_CAPSL,   !!(leds & 0x04));
906                         input_sync(handle->dev);
907                 }
908         }
909
910         ledstate = leds;
911 }
912
913 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
914
915 /*
916  * This allows a newly plugged keyboard to pick the LED state.
917  */
918 static void kbd_refresh_leds(struct input_handle *handle)
919 {
920         unsigned char leds = ledstate;
921
922         tasklet_disable(&keyboard_tasklet);
923         if (leds != 0xff) {
924                 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
925                 input_event(handle->dev, EV_LED, LED_NUML,    !!(leds & 0x02));
926                 input_event(handle->dev, EV_LED, LED_CAPSL,   !!(leds & 0x04));
927                 input_sync(handle->dev);
928         }
929         tasklet_enable(&keyboard_tasklet);
930 }
931
932 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
933     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC32) ||\
934     defined(CONFIG_SPARC64) || defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
935     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
936
937 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
938                         ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
939
940 static unsigned short x86_keycodes[256] =
941         { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
942          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
943          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
944          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
945          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
946          80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
947         284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
948         367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
949         360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
950         103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
951         291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
952         264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
953         377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
954         308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
955         332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
956
957 #ifdef CONFIG_MAC_EMUMOUSEBTN
958 extern int mac_hid_mouse_emulate_buttons(int, int, int);
959 #endif /* CONFIG_MAC_EMUMOUSEBTN */
960
961 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
962 static int sparc_l1_a_state = 0;
963 extern void sun_do_break(void);
964 #endif
965
966 static int emulate_raw(struct vc_data *vc, unsigned int keycode, 
967                        unsigned char up_flag)
968 {
969         if (keycode > 255 || !x86_keycodes[keycode])
970                 return -1; 
971
972         switch (keycode) {
973                 case KEY_PAUSE:
974                         put_queue(vc, 0xe1);
975                         put_queue(vc, 0x1d | up_flag);
976                         put_queue(vc, 0x45 | up_flag);
977                         return 0;
978                 case KEY_HANGUEL:
979                         if (!up_flag) put_queue(vc, 0xf1);
980                         return 0;
981                 case KEY_HANJA:
982                         if (!up_flag) put_queue(vc, 0xf2);
983                         return 0;
984         } 
985
986         if (keycode == KEY_SYSRQ && sysrq_alt) {
987                 put_queue(vc, 0x54 | up_flag);
988                 return 0;
989         }
990
991         if (x86_keycodes[keycode] & 0x100)
992                 put_queue(vc, 0xe0);
993
994         put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
995
996         if (keycode == KEY_SYSRQ) {
997                 put_queue(vc, 0xe0);
998                 put_queue(vc, 0x37 | up_flag);
999         }
1000
1001         return 0;
1002 }
1003
1004 #else
1005
1006 #define HW_RAW(dev)     0
1007
1008 #warning "Cannot generate rawmode keyboard for your architecture yet."
1009
1010 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1011 {
1012         if (keycode > 127)
1013                 return -1;
1014
1015         put_queue(vc, keycode | up_flag);
1016         return 0;
1017 }
1018 #endif
1019
1020 static void kbd_rawcode(unsigned char data)
1021 {
1022         struct vc_data *vc = vc_cons[fg_console].d;
1023         kbd = kbd_table + fg_console;
1024         if (kbd->kbdmode == VC_RAW)
1025                 put_queue(vc, data);
1026 }
1027
1028 static void kbd_keycode(unsigned int keycode, int down,
1029                         int hw_raw, struct pt_regs *regs)
1030 {
1031         struct vc_data *vc = vc_cons[fg_console].d;
1032         unsigned short keysym, *key_map;
1033         unsigned char type, raw_mode;
1034         struct tty_struct *tty;
1035         int shift_final;
1036
1037         tty = vc->vc_tty;
1038
1039         if (tty && (!tty->driver_data)) {
1040                 /* No driver data? Strange. Okay we fix it then. */
1041                 tty->driver_data = vc;
1042         }
1043
1044         kbd = kbd_table + fg_console;
1045
1046         if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1047                 sysrq_alt = down;
1048 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1049         if (keycode == KEY_STOP)
1050                 sparc_l1_a_state = down;
1051 #endif
1052
1053         rep = (down == 2);
1054
1055 #ifdef CONFIG_MAC_EMUMOUSEBTN
1056         if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1057                 return;
1058 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1059
1060         if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1061                 if (emulate_raw(vc, keycode, !down << 7))
1062                         if (keycode < BTN_MISC)
1063                                 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1064
1065 #ifdef CONFIG_MAGIC_SYSRQ              /* Handle the SysRq Hack */
1066         if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1067                 sysrq_down = down;
1068                 return;
1069         }
1070         if (sysrq_down && down && !rep) {
1071                 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1072                 return;
1073         }
1074 #endif
1075 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1076         if (keycode == KEY_A && sparc_l1_a_state) {
1077                 sparc_l1_a_state = 0;
1078                 sun_do_break();
1079         }
1080 #endif
1081
1082         if (kbd->kbdmode == VC_MEDIUMRAW) {
1083                 /*
1084                  * This is extended medium raw mode, with keys above 127
1085                  * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1086                  * the 'up' flag if needed. 0 is reserved, so this shouldn't
1087                  * interfere with anything else. The two bytes after 0 will
1088                  * always have the up flag set not to interfere with older
1089                  * applications. This allows for 16384 different keycodes,
1090                  * which should be enough.
1091                  */
1092                 if (keycode < 128) {
1093                         put_queue(vc, keycode | (!down << 7));
1094                 } else {
1095                         put_queue(vc, !down << 7);
1096                         put_queue(vc, (keycode >> 7) | 0x80);
1097                         put_queue(vc, keycode | 0x80);
1098                 }
1099                 raw_mode = 1;
1100         }
1101
1102         if (down)
1103                 set_bit(keycode, key_down);
1104         else
1105                 clear_bit(keycode, key_down);
1106
1107         if (rep && (!vc_kbd_mode(kbd, VC_REPEAT) || (tty && 
1108                 (!L_ECHO(tty) && tty->driver->chars_in_buffer(tty))))) {
1109                 /*
1110                  * Don't repeat a key if the input buffers are not empty and the
1111                  * characters get aren't echoed locally. This makes key repeat 
1112                  * usable with slow applications and under heavy loads.
1113                  */
1114                 return;
1115         }
1116
1117         shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1118         key_map = key_maps[shift_final];
1119
1120         if (!key_map) {
1121                 compute_shiftstate();
1122                 kbd->slockstate = 0;
1123                 return;
1124         }
1125
1126         if (keycode > NR_KEYS)
1127                 return;
1128
1129         keysym = key_map[keycode];
1130         type = KTYP(keysym);
1131
1132         if (type < 0xf0) {
1133                 if (down && !raw_mode) to_utf8(vc, keysym);
1134                 return;
1135         }
1136
1137         type -= 0xf0;
1138
1139         if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1140                 return;
1141
1142         if (type == KT_LETTER) {
1143                 type = KT_LATIN;
1144                 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1145                         key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1146                         if (key_map)
1147                                 keysym = key_map[keycode];
1148                 }
1149         }
1150
1151         (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1152
1153         if (type != KT_SLOCK)
1154                 kbd->slockstate = 0;
1155 }
1156
1157 static void kbd_event(struct input_handle *handle, unsigned int event_type, 
1158                       unsigned int event_code, int value)
1159 {
1160         if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1161                 kbd_rawcode(value);
1162         if (event_type == EV_KEY)
1163                 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1164         tasklet_schedule(&keyboard_tasklet);
1165         do_poke_blanked_console = 1;
1166         schedule_console_callback();
1167 }
1168
1169 static char kbd_name[] = "kbd";
1170
1171 /*
1172  * When a keyboard (or other input device) is found, the kbd_connect
1173  * function is called. The function then looks at the device, and if it
1174  * likes it, it can open it and get events from it. In this (kbd_connect)
1175  * function, we should decide which VT to bind that keyboard to initially.
1176  */
1177 static struct input_handle *kbd_connect(struct input_handler *handler, 
1178                                         struct input_dev *dev,
1179                                         struct input_device_id *id)
1180 {
1181         struct input_handle *handle;
1182         int i;
1183
1184         for (i = KEY_RESERVED; i < BTN_MISC; i++)
1185                 if (test_bit(i, dev->keybit)) break;
1186
1187         if ((i == BTN_MISC) && !test_bit(EV_SND, dev->evbit)) 
1188                 return NULL;
1189
1190         if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL))) 
1191                 return NULL;
1192         memset(handle, 0, sizeof(struct input_handle));
1193
1194         handle->dev = dev;
1195         handle->handler = handler;
1196         handle->name = kbd_name;
1197
1198         input_open_device(handle);
1199         kbd_refresh_leds(handle);
1200
1201         return handle;
1202 }
1203
1204 static void kbd_disconnect(struct input_handle *handle)
1205 {
1206         input_close_device(handle);
1207         kfree(handle);
1208 }
1209
1210 static struct input_device_id kbd_ids[] = {
1211         {
1212                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1213                 .evbit = { BIT(EV_KEY) },
1214         },
1215         
1216         {
1217                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1218                 .evbit = { BIT(EV_SND) },
1219         },      
1220
1221         { },    /* Terminating entry */
1222 };
1223
1224 MODULE_DEVICE_TABLE(input, kbd_ids);
1225
1226 static struct input_handler kbd_handler = {
1227         .event          = kbd_event,
1228         .connect        = kbd_connect,
1229         .disconnect     = kbd_disconnect,
1230         .name           = "kbd",
1231         .id_table       = kbd_ids,
1232 };
1233
1234 int __init kbd_init(void)
1235 {
1236         int i;
1237
1238         kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1239         kbd0.ledmode = LED_SHOW_FLAGS;
1240         kbd0.lockstate = KBD_DEFLOCK;
1241         kbd0.slockstate = 0;
1242         kbd0.modeflags = KBD_DEFMODE;
1243         kbd0.kbdmode = VC_XLATE;
1244
1245         for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1246                 kbd_table[i] = kbd0;
1247
1248         input_register_handler(&kbd_handler);
1249
1250         tasklet_enable(&keyboard_tasklet);
1251         tasklet_schedule(&keyboard_tasklet);
1252
1253         return 0;
1254 }