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