2 * linux/drivers/char/keyboard.c
4 * Written for linux by Johan Myreen as a translation from
5 * the assembly version by Linus (with diacriticals added)
7 * Some additional features added by Christoph Niemann (ChN), March 1993
9 * Loadable keymaps by Risto Kankkunen, May 1993
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.
16 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
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
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)
27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29 #include <linux/consolemap.h>
30 #include <linux/module.h>
31 #include <linux/sched.h>
32 #include <linux/tty.h>
33 #include <linux/tty_flip.h>
35 #include <linux/string.h>
36 #include <linux/init.h>
37 #include <linux/slab.h>
38 #include <linux/irq.h>
40 #include <linux/kbd_kern.h>
41 #include <linux/kbd_diacr.h>
42 #include <linux/vt_kern.h>
43 #include <linux/input.h>
44 #include <linux/reboot.h>
45 #include <linux/notifier.h>
46 #include <linux/jiffies.h>
48 extern void ctrl_alt_del(void);
51 * Exported functions/variables
54 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
57 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
58 * This seems a good reason to start with NumLock off. On HIL keyboards
59 * of PARISC machines however there is no NumLock key and everyone expects the keypad
60 * to be used for numbers.
63 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
64 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
71 void compute_shiftstate(void);
78 k_self, k_fn, k_spec, k_pad,\
79 k_dead, k_cons, k_cur, k_shift,\
80 k_meta, k_ascii, k_lock, k_lowercase,\
81 k_slock, k_dead2, k_brl, k_ignore
83 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
85 static k_handler_fn K_HANDLERS;
86 static k_handler_fn *k_handler[16] = { K_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
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 };
100 * Variables exported for vt_ioctl.c
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
110 const int NR_TYPES = ARRAY_SIZE(max_vals);
112 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
113 EXPORT_SYMBOL_GPL(kbd_table);
114 static struct kbd_struct *kbd = kbd_table;
116 struct vt_spawn_console vt_spawn_con = {
117 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
123 * Variables exported for vt.c
132 static struct input_handler kbd_handler;
133 static DEFINE_SPINLOCK(kbd_event_lock);
134 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
135 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
136 static bool dead_key_next;
137 static int npadch = -1; /* -1 or number assembled on pad */
138 static unsigned int diacr;
139 static char rep; /* flag telling character repeat */
141 static unsigned char ledstate = 0xff; /* undefined */
142 static unsigned char ledioctl;
144 static struct ledptr {
147 unsigned char valid:1;
151 * Notifier list for console keyboard events
153 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
155 int register_keyboard_notifier(struct notifier_block *nb)
157 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
159 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
161 int unregister_keyboard_notifier(struct notifier_block *nb)
163 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
165 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
168 * Translation of scancodes to keycodes. We set them on only the first
169 * keyboard in the list that accepts the scancode and keycode.
170 * Explanation for not choosing the first attached keyboard anymore:
171 * USB keyboards for example have two event devices: one for all "normal"
172 * keys and one for extra function keys (like "volume up", "make coffee",
173 * etc.). So this means that scancodes for the extra function keys won't
174 * be valid for the first event device, but will be for the second.
177 struct getset_keycode_data {
178 struct input_keymap_entry ke;
182 static int getkeycode_helper(struct input_handle *handle, void *data)
184 struct getset_keycode_data *d = data;
186 d->error = input_get_keycode(handle->dev, &d->ke);
188 return d->error == 0; /* stop as soon as we successfully get one */
191 int getkeycode(unsigned int scancode)
193 struct getset_keycode_data d = {
196 .len = sizeof(scancode),
202 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
204 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
206 return d.error ?: d.ke.keycode;
209 static int setkeycode_helper(struct input_handle *handle, void *data)
211 struct getset_keycode_data *d = data;
213 d->error = input_set_keycode(handle->dev, &d->ke);
215 return d->error == 0; /* stop as soon as we successfully set one */
218 int setkeycode(unsigned int scancode, unsigned int keycode)
220 struct getset_keycode_data d = {
223 .len = sizeof(scancode),
229 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
231 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
237 * Making beeps and bells. Note that we prefer beeps to bells, but when
238 * shutting the sound off we do both.
241 static int kd_sound_helper(struct input_handle *handle, void *data)
243 unsigned int *hz = data;
244 struct input_dev *dev = handle->dev;
246 if (test_bit(EV_SND, dev->evbit)) {
247 if (test_bit(SND_TONE, dev->sndbit)) {
248 input_inject_event(handle, EV_SND, SND_TONE, *hz);
252 if (test_bit(SND_BELL, dev->sndbit))
253 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
259 static void kd_nosound(unsigned long ignored)
261 static unsigned int zero;
263 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
266 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
268 void kd_mksound(unsigned int hz, unsigned int ticks)
270 del_timer_sync(&kd_mksound_timer);
272 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
275 mod_timer(&kd_mksound_timer, jiffies + ticks);
277 EXPORT_SYMBOL(kd_mksound);
280 * Setting the keyboard rate.
283 static int kbd_rate_helper(struct input_handle *handle, void *data)
285 struct input_dev *dev = handle->dev;
286 struct kbd_repeat *rep = data;
288 if (test_bit(EV_REP, dev->evbit)) {
290 if (rep[0].delay > 0)
291 input_inject_event(handle,
292 EV_REP, REP_DELAY, rep[0].delay);
293 if (rep[0].period > 0)
294 input_inject_event(handle,
295 EV_REP, REP_PERIOD, rep[0].period);
297 rep[1].delay = dev->rep[REP_DELAY];
298 rep[1].period = dev->rep[REP_PERIOD];
304 int kbd_rate(struct kbd_repeat *rep)
306 struct kbd_repeat data[2] = { *rep };
308 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
309 *rep = data[1]; /* Copy currently used settings */
317 static void put_queue(struct vc_data *vc, int ch)
319 struct tty_struct *tty = vc->port.tty;
322 tty_insert_flip_char(tty, ch, 0);
323 con_schedule_flip(tty);
327 static void puts_queue(struct vc_data *vc, char *cp)
329 struct tty_struct *tty = vc->port.tty;
335 tty_insert_flip_char(tty, *cp, 0);
338 con_schedule_flip(tty);
341 static void applkey(struct vc_data *vc, int key, char mode)
343 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
345 buf[1] = (mode ? 'O' : '[');
351 * Many other routines do put_queue, but I think either
352 * they produce ASCII, or they produce some user-assigned
353 * string, and in both cases we might assume that it is
356 static void to_utf8(struct vc_data *vc, uint c)
361 else if (c < 0x800) {
362 /* 110***** 10****** */
363 put_queue(vc, 0xc0 | (c >> 6));
364 put_queue(vc, 0x80 | (c & 0x3f));
365 } else if (c < 0x10000) {
366 if (c >= 0xD800 && c < 0xE000)
370 /* 1110**** 10****** 10****** */
371 put_queue(vc, 0xe0 | (c >> 12));
372 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
373 put_queue(vc, 0x80 | (c & 0x3f));
374 } else if (c < 0x110000) {
375 /* 11110*** 10****** 10****** 10****** */
376 put_queue(vc, 0xf0 | (c >> 18));
377 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
378 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
379 put_queue(vc, 0x80 | (c & 0x3f));
384 * Called after returning from RAW mode or when changing consoles - recompute
385 * shift_down[] and shift_state from key_down[] maybe called when keymap is
386 * undefined, so that shiftkey release is seen
388 void compute_shiftstate(void)
390 unsigned int i, j, k, sym, val;
393 memset(shift_down, 0, sizeof(shift_down));
395 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
400 k = i * BITS_PER_LONG;
402 for (j = 0; j < BITS_PER_LONG; j++, k++) {
404 if (!test_bit(k, key_down))
407 sym = U(key_maps[0][k]);
408 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
412 if (val == KVAL(K_CAPSSHIFT))
416 shift_state |= (1 << val);
422 * We have a combining character DIACR here, followed by the character CH.
423 * If the combination occurs in the table, return the corresponding value.
424 * Otherwise, if CH is a space or equals DIACR, return DIACR.
425 * Otherwise, conclude that DIACR was not combining after all,
426 * queue it and return CH.
428 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
430 unsigned int d = diacr;
435 if ((d & ~0xff) == BRL_UC_ROW) {
436 if ((ch & ~0xff) == BRL_UC_ROW)
439 for (i = 0; i < accent_table_size; i++)
440 if (accent_table[i].diacr == d && accent_table[i].base == ch)
441 return accent_table[i].result;
444 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
447 if (kbd->kbdmode == VC_UNICODE)
450 int c = conv_uni_to_8bit(d);
459 * Special function handlers
461 static void fn_enter(struct vc_data *vc)
464 if (kbd->kbdmode == VC_UNICODE)
467 int c = conv_uni_to_8bit(diacr);
475 if (vc_kbd_mode(kbd, VC_CRLF))
479 static void fn_caps_toggle(struct vc_data *vc)
484 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
487 static void fn_caps_on(struct vc_data *vc)
492 set_vc_kbd_led(kbd, VC_CAPSLOCK);
495 static void fn_show_ptregs(struct vc_data *vc)
497 struct pt_regs *regs = get_irq_regs();
503 static void fn_hold(struct vc_data *vc)
505 struct tty_struct *tty = vc->port.tty;
511 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
512 * these routines are also activated by ^S/^Q.
513 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
521 static void fn_num(struct vc_data *vc)
523 if (vc_kbd_mode(kbd, VC_APPLIC))
530 * Bind this to Shift-NumLock if you work in application keypad mode
531 * but want to be able to change the NumLock flag.
532 * Bind this to NumLock if you prefer that the NumLock key always
533 * changes the NumLock flag.
535 static void fn_bare_num(struct vc_data *vc)
538 chg_vc_kbd_led(kbd, VC_NUMLOCK);
541 static void fn_lastcons(struct vc_data *vc)
543 /* switch to the last used console, ChN */
544 set_console(last_console);
547 static void fn_dec_console(struct vc_data *vc)
549 int i, cur = fg_console;
551 /* Currently switching? Queue this next switch relative to that. */
552 if (want_console != -1)
555 for (i = cur - 1; i != cur; i--) {
557 i = MAX_NR_CONSOLES - 1;
558 if (vc_cons_allocated(i))
564 static void fn_inc_console(struct vc_data *vc)
566 int i, cur = fg_console;
568 /* Currently switching? Queue this next switch relative to that. */
569 if (want_console != -1)
572 for (i = cur+1; i != cur; i++) {
573 if (i == MAX_NR_CONSOLES)
575 if (vc_cons_allocated(i))
581 static void fn_send_intr(struct vc_data *vc)
583 struct tty_struct *tty = vc->port.tty;
587 tty_insert_flip_char(tty, 0, TTY_BREAK);
588 con_schedule_flip(tty);
591 static void fn_scroll_forw(struct vc_data *vc)
596 static void fn_scroll_back(struct vc_data *vc)
601 static void fn_show_mem(struct vc_data *vc)
606 static void fn_show_state(struct vc_data *vc)
611 static void fn_boot_it(struct vc_data *vc)
616 static void fn_compose(struct vc_data *vc)
618 dead_key_next = true;
621 static void fn_spawn_con(struct vc_data *vc)
623 spin_lock(&vt_spawn_con.lock);
624 if (vt_spawn_con.pid)
625 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
626 put_pid(vt_spawn_con.pid);
627 vt_spawn_con.pid = NULL;
629 spin_unlock(&vt_spawn_con.lock);
632 static void fn_SAK(struct vc_data *vc)
634 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
635 schedule_work(SAK_work);
638 static void fn_null(struct vc_data *vc)
640 compute_shiftstate();
644 * Special key handlers
646 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
650 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
654 if (value >= ARRAY_SIZE(fn_handler))
656 if ((kbd->kbdmode == VC_RAW ||
657 kbd->kbdmode == VC_MEDIUMRAW ||
658 kbd->kbdmode == VC_OFF) &&
659 value != KVAL(K_SAK))
660 return; /* SAK is allowed even in raw mode */
661 fn_handler[value](vc);
664 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
666 pr_err("k_lowercase was called - impossible\n");
669 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
672 return; /* no action, if this is a key release */
675 value = handle_diacr(vc, value);
678 dead_key_next = false;
682 if (kbd->kbdmode == VC_UNICODE)
685 int c = conv_uni_to_8bit(value);
692 * Handle dead key. Note that we now may have several
693 * dead keys modifying the same character. Very useful
696 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
701 diacr = (diacr ? handle_diacr(vc, value) : value);
704 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
706 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
709 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
711 k_deadunicode(vc, value, up_flag);
715 * Obsolete - for backwards compatibility only
717 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
719 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
721 k_deadunicode(vc, ret_diacr[value], up_flag);
724 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
732 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
737 if ((unsigned)value < ARRAY_SIZE(func_table)) {
738 if (func_table[value])
739 puts_queue(vc, func_table[value]);
741 pr_err("k_fn called with value=%d\n", value);
744 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
746 static const char cur_chars[] = "BDCA";
751 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
754 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
756 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
757 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
760 return; /* no action, if this is a key release */
762 /* kludge... shift forces cursor/number keys */
763 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
764 applkey(vc, app_map[value], 1);
768 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
773 k_fn(vc, KVAL(K_REMOVE), 0);
776 k_fn(vc, KVAL(K_INSERT), 0);
779 k_fn(vc, KVAL(K_SELECT), 0);
782 k_cur(vc, KVAL(K_DOWN), 0);
785 k_fn(vc, KVAL(K_PGDN), 0);
788 k_cur(vc, KVAL(K_LEFT), 0);
791 k_cur(vc, KVAL(K_RIGHT), 0);
794 k_fn(vc, KVAL(K_FIND), 0);
797 k_cur(vc, KVAL(K_UP), 0);
800 k_fn(vc, KVAL(K_PGUP), 0);
803 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
808 put_queue(vc, pad_chars[value]);
809 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
813 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
815 int old_state = shift_state;
821 * a CapsShift key acts like Shift but undoes CapsLock
823 if (value == KVAL(K_CAPSSHIFT)) {
824 value = KVAL(K_SHIFT);
826 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
831 * handle the case that two shift or control
832 * keys are depressed simultaneously
834 if (shift_down[value])
839 if (shift_down[value])
840 shift_state |= (1 << value);
842 shift_state &= ~(1 << value);
845 if (up_flag && shift_state != old_state && npadch != -1) {
846 if (kbd->kbdmode == VC_UNICODE)
849 put_queue(vc, npadch & 0xff);
854 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
859 if (vc_kbd_mode(kbd, VC_META)) {
860 put_queue(vc, '\033');
861 put_queue(vc, value);
863 put_queue(vc, value | 0x80);
866 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
874 /* decimal input of code, while Alt depressed */
877 /* hexadecimal input of code, while AltGr depressed */
885 npadch = npadch * base + value;
888 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
893 chg_vc_kbd_lock(kbd, value);
896 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
898 k_shift(vc, value, up_flag);
902 chg_vc_kbd_slock(kbd, value);
903 /* try to make Alt, oops, AltGr and such work */
904 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
906 chg_vc_kbd_slock(kbd, value);
910 /* by default, 300ms interval for combination release */
911 static unsigned brl_timeout = 300;
912 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
913 module_param(brl_timeout, uint, 0644);
915 static unsigned brl_nbchords = 1;
916 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
917 module_param(brl_nbchords, uint, 0644);
919 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
921 static unsigned long chords;
922 static unsigned committed;
925 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
927 committed |= pattern;
929 if (chords == brl_nbchords) {
930 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
937 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
939 static unsigned pressed, committing;
940 static unsigned long releasestart;
942 if (kbd->kbdmode != VC_UNICODE) {
944 pr_warning("keyboard mode must be unicode for braille patterns\n");
949 k_unicode(vc, BRL_UC_ROW, up_flag);
957 pressed |= 1 << (value - 1);
959 committing = pressed;
960 } else if (brl_timeout) {
963 releasestart + msecs_to_jiffies(brl_timeout))) {
964 committing = pressed;
965 releasestart = jiffies;
967 pressed &= ~(1 << (value - 1));
968 if (!pressed && committing) {
969 k_brlcommit(vc, committing, 0);
974 k_brlcommit(vc, committing, 0);
977 pressed &= ~(1 << (value - 1));
982 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
983 * or (ii) whatever pattern of lights people want to show using KDSETLED,
984 * or (iii) specified bits of specified words in kernel memory.
986 unsigned char getledstate(void)
991 void setledstate(struct kbd_struct *kbd, unsigned int led)
995 kbd->ledmode = LED_SHOW_IOCTL;
997 kbd->ledmode = LED_SHOW_FLAGS;
1002 static inline unsigned char getleds(void)
1004 struct kbd_struct *kbd = kbd_table + fg_console;
1008 if (kbd->ledmode == LED_SHOW_IOCTL)
1011 leds = kbd->ledflagstate;
1013 if (kbd->ledmode == LED_SHOW_MEM) {
1014 for (i = 0; i < 3; i++)
1015 if (ledptrs[i].valid) {
1016 if (*ledptrs[i].addr & ledptrs[i].mask)
1025 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1027 unsigned char leds = *(unsigned char *)data;
1029 if (test_bit(EV_LED, handle->dev->evbit)) {
1030 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1031 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1032 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1033 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1040 * This is the tasklet that updates LED state on all keyboards
1041 * attached to the box. The reason we use tasklet is that we
1042 * need to handle the scenario when keyboard handler is not
1043 * registered yet but we already getting updates form VT to
1046 static void kbd_bh(unsigned long dummy)
1048 unsigned char leds = getleds();
1050 if (leds != ledstate) {
1051 input_handler_for_each_handle(&kbd_handler, &leds,
1052 kbd_update_leds_helper);
1057 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1059 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1060 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1061 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1062 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1063 defined(CONFIG_AVR32)
1065 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1066 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1068 static const unsigned short x86_keycodes[256] =
1069 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1070 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1071 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1072 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1073 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1074 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1075 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1076 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1077 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1078 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1079 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1080 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1081 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1082 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1083 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1086 static int sparc_l1_a_state;
1087 extern void sun_do_break(void);
1090 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1091 unsigned char up_flag)
1098 put_queue(vc, 0xe1);
1099 put_queue(vc, 0x1d | up_flag);
1100 put_queue(vc, 0x45 | up_flag);
1105 put_queue(vc, 0xf2);
1110 put_queue(vc, 0xf1);
1115 * Real AT keyboards (that's what we're trying
1116 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1117 * pressing PrtSc/SysRq alone, but simply 0x54
1118 * when pressing Alt+PrtSc/SysRq.
1120 if (test_bit(KEY_LEFTALT, key_down) ||
1121 test_bit(KEY_RIGHTALT, key_down)) {
1122 put_queue(vc, 0x54 | up_flag);
1124 put_queue(vc, 0xe0);
1125 put_queue(vc, 0x2a | up_flag);
1126 put_queue(vc, 0xe0);
1127 put_queue(vc, 0x37 | up_flag);
1135 code = x86_keycodes[keycode];
1140 put_queue(vc, 0xe0);
1141 put_queue(vc, (code & 0x7f) | up_flag);
1151 #define HW_RAW(dev) 0
1153 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1158 put_queue(vc, keycode | up_flag);
1163 static void kbd_rawcode(unsigned char data)
1165 struct vc_data *vc = vc_cons[fg_console].d;
1167 kbd = kbd_table + vc->vc_num;
1168 if (kbd->kbdmode == VC_RAW)
1169 put_queue(vc, data);
1172 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1174 struct vc_data *vc = vc_cons[fg_console].d;
1175 unsigned short keysym, *key_map;
1178 struct tty_struct *tty;
1180 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1185 if (tty && (!tty->driver_data)) {
1186 /* No driver data? Strange. Okay we fix it then. */
1187 tty->driver_data = vc;
1190 kbd = kbd_table + vc->vc_num;
1193 if (keycode == KEY_STOP)
1194 sparc_l1_a_state = down;
1199 raw_mode = (kbd->kbdmode == VC_RAW);
1200 if (raw_mode && !hw_raw)
1201 if (emulate_raw(vc, keycode, !down << 7))
1202 if (keycode < BTN_MISC && printk_ratelimit())
1203 pr_warning("can't emulate rawmode for keycode %d\n",
1207 if (keycode == KEY_A && sparc_l1_a_state) {
1208 sparc_l1_a_state = false;
1213 if (kbd->kbdmode == VC_MEDIUMRAW) {
1215 * This is extended medium raw mode, with keys above 127
1216 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1217 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1218 * interfere with anything else. The two bytes after 0 will
1219 * always have the up flag set not to interfere with older
1220 * applications. This allows for 16384 different keycodes,
1221 * which should be enough.
1223 if (keycode < 128) {
1224 put_queue(vc, keycode | (!down << 7));
1226 put_queue(vc, !down << 7);
1227 put_queue(vc, (keycode >> 7) | 0x80);
1228 put_queue(vc, keycode | 0x80);
1234 set_bit(keycode, key_down);
1236 clear_bit(keycode, key_down);
1239 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1240 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1242 * Don't repeat a key if the input buffers are not empty and the
1243 * characters get aren't echoed locally. This makes key repeat
1244 * usable with slow applications and under heavy loads.
1249 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1250 param.ledstate = kbd->ledflagstate;
1251 key_map = key_maps[shift_final];
1253 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1254 KBD_KEYCODE, ¶m);
1255 if (rc == NOTIFY_STOP || !key_map) {
1256 atomic_notifier_call_chain(&keyboard_notifier_list,
1257 KBD_UNBOUND_KEYCODE, ¶m);
1258 compute_shiftstate();
1259 kbd->slockstate = 0;
1263 if (keycode < NR_KEYS)
1264 keysym = key_map[keycode];
1265 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1266 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1270 type = KTYP(keysym);
1273 param.value = keysym;
1274 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1275 KBD_UNICODE, ¶m);
1276 if (rc != NOTIFY_STOP)
1277 if (down && !raw_mode)
1278 to_utf8(vc, keysym);
1284 if (type == KT_LETTER) {
1286 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1287 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1289 keysym = key_map[keycode];
1293 param.value = keysym;
1294 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1295 KBD_KEYSYM, ¶m);
1296 if (rc == NOTIFY_STOP)
1299 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1302 (*k_handler[type])(vc, keysym & 0xff, !down);
1304 param.ledstate = kbd->ledflagstate;
1305 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1307 if (type != KT_SLOCK)
1308 kbd->slockstate = 0;
1311 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1312 unsigned int event_code, int value)
1314 /* We are called with interrupts disabled, just take the lock */
1315 spin_lock(&kbd_event_lock);
1317 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1319 if (event_type == EV_KEY)
1320 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1322 spin_unlock(&kbd_event_lock);
1324 tasklet_schedule(&keyboard_tasklet);
1325 do_poke_blanked_console = 1;
1326 schedule_console_callback();
1329 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1333 if (test_bit(EV_SND, dev->evbit))
1336 if (test_bit(EV_KEY, dev->evbit)) {
1337 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1338 if (test_bit(i, dev->keybit))
1340 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1341 if (test_bit(i, dev->keybit))
1349 * When a keyboard (or other input device) is found, the kbd_connect
1350 * function is called. The function then looks at the device, and if it
1351 * likes it, it can open it and get events from it. In this (kbd_connect)
1352 * function, we should decide which VT to bind that keyboard to initially.
1354 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1355 const struct input_device_id *id)
1357 struct input_handle *handle;
1360 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1365 handle->handler = handler;
1366 handle->name = "kbd";
1368 error = input_register_handle(handle);
1370 goto err_free_handle;
1372 error = input_open_device(handle);
1374 goto err_unregister_handle;
1378 err_unregister_handle:
1379 input_unregister_handle(handle);
1385 static void kbd_disconnect(struct input_handle *handle)
1387 input_close_device(handle);
1388 input_unregister_handle(handle);
1393 * Start keyboard handler on the new keyboard by refreshing LED state to
1394 * match the rest of the system.
1396 static void kbd_start(struct input_handle *handle)
1398 tasklet_disable(&keyboard_tasklet);
1400 if (ledstate != 0xff)
1401 kbd_update_leds_helper(handle, &ledstate);
1403 tasklet_enable(&keyboard_tasklet);
1406 static const struct input_device_id kbd_ids[] = {
1408 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1409 .evbit = { BIT_MASK(EV_KEY) },
1413 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1414 .evbit = { BIT_MASK(EV_SND) },
1417 { }, /* Terminating entry */
1420 MODULE_DEVICE_TABLE(input, kbd_ids);
1422 static struct input_handler kbd_handler = {
1425 .connect = kbd_connect,
1426 .disconnect = kbd_disconnect,
1429 .id_table = kbd_ids,
1432 int __init kbd_init(void)
1437 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1438 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1439 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1440 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1441 kbd_table[i].lockstate = KBD_DEFLOCK;
1442 kbd_table[i].slockstate = 0;
1443 kbd_table[i].modeflags = KBD_DEFMODE;
1444 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1447 error = input_register_handler(&kbd_handler);
1451 tasklet_enable(&keyboard_tasklet);
1452 tasklet_schedule(&keyboard_tasklet);