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