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