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