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