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