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