2 * Written for linux by Johan Myreen as a translation from
3 * the assembly version by Linus (with diacriticals added)
5 * Some additional features added by Christoph Niemann (ChN), March 1993
7 * Loadable keymaps by Risto Kankkunen, May 1993
9 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
10 * Added decr/incr_console, dynamic keymaps, Unicode support,
11 * dynamic function/string keys, led setting, Sept 1994
12 * `Sticky' modifier keys, 951006.
14 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
16 * Modified to provide 'generic' keyboard support by Hamish Macdonald
17 * Merge with the m68k keyboard driver and split-off of the PC low-level
18 * parts by Geert Uytterhoeven, May 1997
20 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
21 * 30-07-98: Dead keys redone, aeb@cwi.nl.
22 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
33 #include <linux/string.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
37 #include <linux/kbd_kern.h>
38 #include <linux/kbd_diacr.h>
39 #include <linux/vt_kern.h>
40 #include <linux/input.h>
41 #include <linux/reboot.h>
42 #include <linux/notifier.h>
43 #include <linux/jiffies.h>
45 #include <asm/irq_regs.h>
47 extern void ctrl_alt_del(void);
50 * Exported functions/variables
53 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
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.
62 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
63 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
70 void compute_shiftstate(void);
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
82 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
84 static k_handler_fn K_HANDLERS;
85 static k_handler_fn *k_handler[16] = { K_HANDLERS };
88 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
89 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
90 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
91 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
92 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
94 typedef void (fn_handler_fn)(struct vc_data *vc);
95 static fn_handler_fn FN_HANDLERS;
96 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
99 * Variables exported for vt_ioctl.c
102 /* maximum values each key_handler can handle */
103 const int max_vals[] = {
104 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
105 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
106 255, NR_LOCK - 1, 255, NR_BRL - 1
109 const int NR_TYPES = ARRAY_SIZE(max_vals);
111 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
112 EXPORT_SYMBOL_GPL(kbd_table);
113 static struct kbd_struct *kbd = kbd_table;
115 struct vt_spawn_console vt_spawn_con = {
116 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
122 * Variables exported for vt.c
131 static struct input_handler kbd_handler;
132 static DEFINE_SPINLOCK(kbd_event_lock);
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 bool 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 */
140 static unsigned char ledstate = 0xff; /* undefined */
141 static unsigned char ledioctl;
143 static struct ledptr {
146 unsigned char valid:1;
150 * Notifier list for console keyboard events
152 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
154 int register_keyboard_notifier(struct notifier_block *nb)
156 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
158 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
160 int unregister_keyboard_notifier(struct notifier_block *nb)
162 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
164 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
167 * Translation of scancodes to keycodes. We set them on only the first
168 * keyboard in the list that accepts the scancode and keycode.
169 * Explanation for not choosing the first attached keyboard anymore:
170 * USB keyboards for example have two event devices: one for all "normal"
171 * keys and one for extra function keys (like "volume up", "make coffee",
172 * etc.). So this means that scancodes for the extra function keys won't
173 * be valid for the first event device, but will be for the second.
176 struct getset_keycode_data {
177 struct input_keymap_entry ke;
181 static int getkeycode_helper(struct input_handle *handle, void *data)
183 struct getset_keycode_data *d = data;
185 d->error = input_get_keycode(handle->dev, &d->ke);
187 return d->error == 0; /* stop as soon as we successfully get one */
190 int getkeycode(unsigned int scancode)
192 struct getset_keycode_data d = {
195 .len = sizeof(scancode),
201 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
203 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
205 return d.error ?: d.ke.keycode;
208 static int setkeycode_helper(struct input_handle *handle, void *data)
210 struct getset_keycode_data *d = data;
212 d->error = input_set_keycode(handle->dev, &d->ke);
214 return d->error == 0; /* stop as soon as we successfully set one */
217 int setkeycode(unsigned int scancode, unsigned int keycode)
219 struct getset_keycode_data d = {
222 .len = sizeof(scancode),
228 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
230 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
236 * Making beeps and bells. Note that we prefer beeps to bells, but when
237 * shutting the sound off we do both.
240 static int kd_sound_helper(struct input_handle *handle, void *data)
242 unsigned int *hz = data;
243 struct input_dev *dev = handle->dev;
245 if (test_bit(EV_SND, dev->evbit)) {
246 if (test_bit(SND_TONE, dev->sndbit)) {
247 input_inject_event(handle, EV_SND, SND_TONE, *hz);
251 if (test_bit(SND_BELL, dev->sndbit))
252 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
258 static void kd_nosound(unsigned long ignored)
260 static unsigned int zero;
262 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
265 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
267 void kd_mksound(unsigned int hz, unsigned int ticks)
269 del_timer_sync(&kd_mksound_timer);
271 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
274 mod_timer(&kd_mksound_timer, jiffies + ticks);
276 EXPORT_SYMBOL(kd_mksound);
279 * Setting the keyboard rate.
282 static int kbd_rate_helper(struct input_handle *handle, void *data)
284 struct input_dev *dev = handle->dev;
285 struct kbd_repeat *rep = data;
287 if (test_bit(EV_REP, dev->evbit)) {
289 if (rep[0].delay > 0)
290 input_inject_event(handle,
291 EV_REP, REP_DELAY, rep[0].delay);
292 if (rep[0].period > 0)
293 input_inject_event(handle,
294 EV_REP, REP_PERIOD, rep[0].period);
296 rep[1].delay = dev->rep[REP_DELAY];
297 rep[1].period = dev->rep[REP_PERIOD];
303 int kbd_rate(struct kbd_repeat *rep)
305 struct kbd_repeat data[2] = { *rep };
307 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
308 *rep = data[1]; /* Copy currently used settings */
316 static void put_queue(struct vc_data *vc, int ch)
318 struct tty_struct *tty = vc->port.tty;
321 tty_insert_flip_char(tty, ch, 0);
322 con_schedule_flip(tty);
326 static void puts_queue(struct vc_data *vc, char *cp)
328 struct tty_struct *tty = vc->port.tty;
334 tty_insert_flip_char(tty, *cp, 0);
337 con_schedule_flip(tty);
340 static void applkey(struct vc_data *vc, int key, char mode)
342 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
344 buf[1] = (mode ? 'O' : '[');
350 * Many other routines do put_queue, but I think either
351 * they produce ASCII, or they produce some user-assigned
352 * string, and in both cases we might assume that it is
355 static void to_utf8(struct vc_data *vc, uint c)
360 else if (c < 0x800) {
361 /* 110***** 10****** */
362 put_queue(vc, 0xc0 | (c >> 6));
363 put_queue(vc, 0x80 | (c & 0x3f));
364 } else if (c < 0x10000) {
365 if (c >= 0xD800 && c < 0xE000)
369 /* 1110**** 10****** 10****** */
370 put_queue(vc, 0xe0 | (c >> 12));
371 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
372 put_queue(vc, 0x80 | (c & 0x3f));
373 } else if (c < 0x110000) {
374 /* 11110*** 10****** 10****** 10****** */
375 put_queue(vc, 0xf0 | (c >> 18));
376 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
377 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
378 put_queue(vc, 0x80 | (c & 0x3f));
383 * Called after returning from RAW mode or when changing consoles - recompute
384 * shift_down[] and shift_state from key_down[] maybe called when keymap is
385 * undefined, so that shiftkey release is seen
387 void compute_shiftstate(void)
389 unsigned int k, sym, val;
392 memset(shift_down, 0, sizeof(shift_down));
394 for_each_set_bit(k, key_down, min(NR_KEYS, KEY_CNT)) {
395 sym = U(key_maps[0][k]);
396 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
400 if (val == KVAL(K_CAPSSHIFT))
404 shift_state |= BIT(val);
409 * We have a combining character DIACR here, followed by the character CH.
410 * If the combination occurs in the table, return the corresponding value.
411 * Otherwise, if CH is a space or equals DIACR, return DIACR.
412 * Otherwise, conclude that DIACR was not combining after all,
413 * queue it and return CH.
415 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
417 unsigned int d = diacr;
422 if ((d & ~0xff) == BRL_UC_ROW) {
423 if ((ch & ~0xff) == BRL_UC_ROW)
426 for (i = 0; i < accent_table_size; i++)
427 if (accent_table[i].diacr == d && accent_table[i].base == ch)
428 return accent_table[i].result;
431 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
434 if (kbd->kbdmode == VC_UNICODE)
437 int c = conv_uni_to_8bit(d);
446 * Special function handlers
448 static void fn_enter(struct vc_data *vc)
451 if (kbd->kbdmode == VC_UNICODE)
454 int c = conv_uni_to_8bit(diacr);
462 if (vc_kbd_mode(kbd, VC_CRLF))
466 static void fn_caps_toggle(struct vc_data *vc)
471 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
474 static void fn_caps_on(struct vc_data *vc)
479 set_vc_kbd_led(kbd, VC_CAPSLOCK);
482 static void fn_show_ptregs(struct vc_data *vc)
484 struct pt_regs *regs = get_irq_regs();
490 static void fn_hold(struct vc_data *vc)
492 struct tty_struct *tty = vc->port.tty;
498 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
499 * these routines are also activated by ^S/^Q.
500 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
508 static void fn_num(struct vc_data *vc)
510 if (vc_kbd_mode(kbd, VC_APPLIC))
517 * Bind this to Shift-NumLock if you work in application keypad mode
518 * but want to be able to change the NumLock flag.
519 * Bind this to NumLock if you prefer that the NumLock key always
520 * changes the NumLock flag.
522 static void fn_bare_num(struct vc_data *vc)
525 chg_vc_kbd_led(kbd, VC_NUMLOCK);
528 static void fn_lastcons(struct vc_data *vc)
530 /* switch to the last used console, ChN */
531 set_console(last_console);
534 static void fn_dec_console(struct vc_data *vc)
536 int i, cur = fg_console;
538 /* Currently switching? Queue this next switch relative to that. */
539 if (want_console != -1)
542 for (i = cur - 1; i != cur; i--) {
544 i = MAX_NR_CONSOLES - 1;
545 if (vc_cons_allocated(i))
551 static void fn_inc_console(struct vc_data *vc)
553 int i, cur = fg_console;
555 /* Currently switching? Queue this next switch relative to that. */
556 if (want_console != -1)
559 for (i = cur+1; i != cur; i++) {
560 if (i == MAX_NR_CONSOLES)
562 if (vc_cons_allocated(i))
568 static void fn_send_intr(struct vc_data *vc)
570 struct tty_struct *tty = vc->port.tty;
574 tty_insert_flip_char(tty, 0, TTY_BREAK);
575 con_schedule_flip(tty);
578 static void fn_scroll_forw(struct vc_data *vc)
583 static void fn_scroll_back(struct vc_data *vc)
588 static void fn_show_mem(struct vc_data *vc)
593 static void fn_show_state(struct vc_data *vc)
598 static void fn_boot_it(struct vc_data *vc)
603 static void fn_compose(struct vc_data *vc)
605 dead_key_next = true;
608 static void fn_spawn_con(struct vc_data *vc)
610 spin_lock(&vt_spawn_con.lock);
611 if (vt_spawn_con.pid)
612 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
613 put_pid(vt_spawn_con.pid);
614 vt_spawn_con.pid = NULL;
616 spin_unlock(&vt_spawn_con.lock);
619 static void fn_SAK(struct vc_data *vc)
621 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
622 schedule_work(SAK_work);
625 static void fn_null(struct vc_data *vc)
627 compute_shiftstate();
631 * Special key handlers
633 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
637 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
641 if (value >= ARRAY_SIZE(fn_handler))
643 if ((kbd->kbdmode == VC_RAW ||
644 kbd->kbdmode == VC_MEDIUMRAW ||
645 kbd->kbdmode == VC_OFF) &&
646 value != KVAL(K_SAK))
647 return; /* SAK is allowed even in raw mode */
648 fn_handler[value](vc);
651 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
653 pr_err("k_lowercase was called - impossible\n");
656 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
659 return; /* no action, if this is a key release */
662 value = handle_diacr(vc, value);
665 dead_key_next = false;
669 if (kbd->kbdmode == VC_UNICODE)
672 int c = conv_uni_to_8bit(value);
679 * Handle dead key. Note that we now may have several
680 * dead keys modifying the same character. Very useful
683 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
688 diacr = (diacr ? handle_diacr(vc, value) : value);
691 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
693 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
696 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
698 k_deadunicode(vc, value, up_flag);
702 * Obsolete - for backwards compatibility only
704 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
706 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
708 k_deadunicode(vc, ret_diacr[value], up_flag);
711 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
719 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
724 if ((unsigned)value < ARRAY_SIZE(func_table)) {
725 if (func_table[value])
726 puts_queue(vc, func_table[value]);
728 pr_err("k_fn called with value=%d\n", value);
731 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
733 static const char cur_chars[] = "BDCA";
738 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
741 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
743 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
744 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
747 return; /* no action, if this is a key release */
749 /* kludge... shift forces cursor/number keys */
750 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
751 applkey(vc, app_map[value], 1);
755 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
760 k_fn(vc, KVAL(K_REMOVE), 0);
763 k_fn(vc, KVAL(K_INSERT), 0);
766 k_fn(vc, KVAL(K_SELECT), 0);
769 k_cur(vc, KVAL(K_DOWN), 0);
772 k_fn(vc, KVAL(K_PGDN), 0);
775 k_cur(vc, KVAL(K_LEFT), 0);
778 k_cur(vc, KVAL(K_RIGHT), 0);
781 k_fn(vc, KVAL(K_FIND), 0);
784 k_cur(vc, KVAL(K_UP), 0);
787 k_fn(vc, KVAL(K_PGUP), 0);
790 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
795 put_queue(vc, pad_chars[value]);
796 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
800 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
802 int old_state = shift_state;
808 * a CapsShift key acts like Shift but undoes CapsLock
810 if (value == KVAL(K_CAPSSHIFT)) {
811 value = KVAL(K_SHIFT);
813 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
818 * handle the case that two shift or control
819 * keys are depressed simultaneously
821 if (shift_down[value])
826 if (shift_down[value])
827 shift_state |= (1 << value);
829 shift_state &= ~(1 << value);
832 if (up_flag && shift_state != old_state && npadch != -1) {
833 if (kbd->kbdmode == VC_UNICODE)
836 put_queue(vc, npadch & 0xff);
841 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
846 if (vc_kbd_mode(kbd, VC_META)) {
847 put_queue(vc, '\033');
848 put_queue(vc, value);
850 put_queue(vc, value | 0x80);
853 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
861 /* decimal input of code, while Alt depressed */
864 /* hexadecimal input of code, while AltGr depressed */
872 npadch = npadch * base + value;
875 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
880 chg_vc_kbd_lock(kbd, value);
883 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
885 k_shift(vc, value, up_flag);
889 chg_vc_kbd_slock(kbd, value);
890 /* try to make Alt, oops, AltGr and such work */
891 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
893 chg_vc_kbd_slock(kbd, value);
897 /* by default, 300ms interval for combination release */
898 static unsigned brl_timeout = 300;
899 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
900 module_param(brl_timeout, uint, 0644);
902 static unsigned brl_nbchords = 1;
903 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
904 module_param(brl_nbchords, uint, 0644);
906 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
908 static unsigned long chords;
909 static unsigned committed;
912 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
914 committed |= pattern;
916 if (chords == brl_nbchords) {
917 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
924 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
926 static unsigned pressed, committing;
927 static unsigned long releasestart;
929 if (kbd->kbdmode != VC_UNICODE) {
931 pr_warning("keyboard mode must be unicode for braille patterns\n");
936 k_unicode(vc, BRL_UC_ROW, up_flag);
944 pressed |= 1 << (value - 1);
946 committing = pressed;
947 } else if (brl_timeout) {
950 releasestart + msecs_to_jiffies(brl_timeout))) {
951 committing = pressed;
952 releasestart = jiffies;
954 pressed &= ~(1 << (value - 1));
955 if (!pressed && committing) {
956 k_brlcommit(vc, committing, 0);
961 k_brlcommit(vc, committing, 0);
964 pressed &= ~(1 << (value - 1));
969 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
970 * or (ii) whatever pattern of lights people want to show using KDSETLED,
971 * or (iii) specified bits of specified words in kernel memory.
973 unsigned char getledstate(void)
978 void setledstate(struct kbd_struct *kbd, unsigned int led)
982 kbd->ledmode = LED_SHOW_IOCTL;
984 kbd->ledmode = LED_SHOW_FLAGS;
989 static inline unsigned char getleds(void)
991 struct kbd_struct *kbd = kbd_table + fg_console;
995 if (kbd->ledmode == LED_SHOW_IOCTL)
998 leds = kbd->ledflagstate;
1000 if (kbd->ledmode == LED_SHOW_MEM) {
1001 for (i = 0; i < 3; i++)
1002 if (ledptrs[i].valid) {
1003 if (*ledptrs[i].addr & ledptrs[i].mask)
1012 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1014 unsigned char leds = *(unsigned char *)data;
1016 if (test_bit(EV_LED, handle->dev->evbit)) {
1017 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1018 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1019 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1020 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1027 * This is the tasklet that updates LED state on all keyboards
1028 * attached to the box. The reason we use tasklet is that we
1029 * need to handle the scenario when keyboard handler is not
1030 * registered yet but we already getting updates form VT to
1033 static void kbd_bh(unsigned long dummy)
1035 unsigned char leds = getleds();
1037 if (leds != ledstate) {
1038 input_handler_for_each_handle(&kbd_handler, &leds,
1039 kbd_update_leds_helper);
1044 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1046 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1047 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1048 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1049 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1050 defined(CONFIG_AVR32)
1052 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1053 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1055 static const unsigned short x86_keycodes[256] =
1056 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1057 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1058 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1059 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1060 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1061 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1062 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1063 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1064 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1065 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1066 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1067 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1068 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1069 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1070 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1073 static int sparc_l1_a_state;
1074 extern void sun_do_break(void);
1077 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1078 unsigned char up_flag)
1085 put_queue(vc, 0xe1);
1086 put_queue(vc, 0x1d | up_flag);
1087 put_queue(vc, 0x45 | up_flag);
1092 put_queue(vc, 0xf2);
1097 put_queue(vc, 0xf1);
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.
1107 if (test_bit(KEY_LEFTALT, key_down) ||
1108 test_bit(KEY_RIGHTALT, key_down)) {
1109 put_queue(vc, 0x54 | up_flag);
1111 put_queue(vc, 0xe0);
1112 put_queue(vc, 0x2a | up_flag);
1113 put_queue(vc, 0xe0);
1114 put_queue(vc, 0x37 | up_flag);
1122 code = x86_keycodes[keycode];
1127 put_queue(vc, 0xe0);
1128 put_queue(vc, (code & 0x7f) | up_flag);
1138 #define HW_RAW(dev) 0
1140 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1145 put_queue(vc, keycode | up_flag);
1150 static void kbd_rawcode(unsigned char data)
1152 struct vc_data *vc = vc_cons[fg_console].d;
1154 kbd = kbd_table + vc->vc_num;
1155 if (kbd->kbdmode == VC_RAW)
1156 put_queue(vc, data);
1159 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1161 struct vc_data *vc = vc_cons[fg_console].d;
1162 unsigned short keysym, *key_map;
1165 struct tty_struct *tty;
1167 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1172 if (tty && (!tty->driver_data)) {
1173 /* No driver data? Strange. Okay we fix it then. */
1174 tty->driver_data = vc;
1177 kbd = kbd_table + vc->vc_num;
1180 if (keycode == KEY_STOP)
1181 sparc_l1_a_state = down;
1186 raw_mode = (kbd->kbdmode == VC_RAW);
1187 if (raw_mode && !hw_raw)
1188 if (emulate_raw(vc, keycode, !down << 7))
1189 /*if (keycode < BTN_MISC && printk_ratelimit())
1190 pr_warning("can't emulate rawmode for keycode %d\n",
1194 if (keycode == KEY_A && sparc_l1_a_state) {
1195 sparc_l1_a_state = false;
1200 if (kbd->kbdmode == VC_MEDIUMRAW) {
1202 * This is extended medium raw mode, with keys above 127
1203 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1204 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1205 * interfere with anything else. The two bytes after 0 will
1206 * always have the up flag set not to interfere with older
1207 * applications. This allows for 16384 different keycodes,
1208 * which should be enough.
1210 if (keycode < 128) {
1211 put_queue(vc, keycode | (!down << 7));
1213 put_queue(vc, !down << 7);
1214 put_queue(vc, (keycode >> 7) | 0x80);
1215 put_queue(vc, keycode | 0x80);
1221 set_bit(keycode, key_down);
1223 clear_bit(keycode, key_down);
1226 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1227 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1229 * Don't repeat a key if the input buffers are not empty and the
1230 * characters get aren't echoed locally. This makes key repeat
1231 * usable with slow applications and under heavy loads.
1236 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1237 param.ledstate = kbd->ledflagstate;
1238 key_map = key_maps[shift_final];
1240 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1241 KBD_KEYCODE, ¶m);
1242 if (rc == NOTIFY_STOP || !key_map) {
1243 atomic_notifier_call_chain(&keyboard_notifier_list,
1244 KBD_UNBOUND_KEYCODE, ¶m);
1245 compute_shiftstate();
1246 kbd->slockstate = 0;
1250 if (keycode < NR_KEYS)
1251 keysym = key_map[keycode];
1252 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1253 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1257 type = KTYP(keysym);
1260 param.value = keysym;
1261 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1262 KBD_UNICODE, ¶m);
1263 if (rc != NOTIFY_STOP)
1264 if (down && !raw_mode)
1265 to_utf8(vc, keysym);
1271 if (type == KT_LETTER) {
1273 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1274 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1276 keysym = key_map[keycode];
1280 param.value = keysym;
1281 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1282 KBD_KEYSYM, ¶m);
1283 if (rc == NOTIFY_STOP)
1286 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1289 (*k_handler[type])(vc, keysym & 0xff, !down);
1291 param.ledstate = kbd->ledflagstate;
1292 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1294 if (type != KT_SLOCK)
1295 kbd->slockstate = 0;
1298 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1299 unsigned int event_code, int value)
1301 /* We are called with interrupts disabled, just take the lock */
1302 spin_lock(&kbd_event_lock);
1304 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1306 if (event_type == EV_KEY)
1307 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1309 spin_unlock(&kbd_event_lock);
1311 tasklet_schedule(&keyboard_tasklet);
1312 do_poke_blanked_console = 1;
1313 schedule_console_callback();
1316 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1320 if (test_bit(EV_SND, dev->evbit))
1323 if (test_bit(EV_KEY, dev->evbit)) {
1324 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1325 if (test_bit(i, dev->keybit))
1327 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1328 if (test_bit(i, dev->keybit))
1336 * When a keyboard (or other input device) is found, the kbd_connect
1337 * function is called. The function then looks at the device, and if it
1338 * likes it, it can open it and get events from it. In this (kbd_connect)
1339 * function, we should decide which VT to bind that keyboard to initially.
1341 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1342 const struct input_device_id *id)
1344 struct input_handle *handle;
1347 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1352 handle->handler = handler;
1353 handle->name = "kbd";
1355 error = input_register_handle(handle);
1357 goto err_free_handle;
1359 error = input_open_device(handle);
1361 goto err_unregister_handle;
1365 err_unregister_handle:
1366 input_unregister_handle(handle);
1372 static void kbd_disconnect(struct input_handle *handle)
1374 input_close_device(handle);
1375 input_unregister_handle(handle);
1380 * Start keyboard handler on the new keyboard by refreshing LED state to
1381 * match the rest of the system.
1383 static void kbd_start(struct input_handle *handle)
1385 tasklet_disable(&keyboard_tasklet);
1387 if (ledstate != 0xff)
1388 kbd_update_leds_helper(handle, &ledstate);
1390 tasklet_enable(&keyboard_tasklet);
1393 static const struct input_device_id kbd_ids[] = {
1395 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1396 .evbit = { BIT_MASK(EV_KEY) },
1400 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1401 .evbit = { BIT_MASK(EV_SND) },
1404 { }, /* Terminating entry */
1407 MODULE_DEVICE_TABLE(input, kbd_ids);
1409 static struct input_handler kbd_handler = {
1412 .connect = kbd_connect,
1413 .disconnect = kbd_disconnect,
1416 .id_table = kbd_ids,
1419 int __init kbd_init(void)
1424 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1425 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1426 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1427 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1428 kbd_table[i].lockstate = KBD_DEFLOCK;
1429 kbd_table[i].slockstate = 0;
1430 kbd_table[i].modeflags = KBD_DEFMODE;
1431 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1434 error = input_register_handler(&kbd_handler);
1438 tasklet_enable(&keyboard_tasklet);
1439 tasklet_schedule(&keyboard_tasklet);