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