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>
36 #include <linux/leds.h>
38 #include <linux/kbd_kern.h>
39 #include <linux/kbd_diacr.h>
40 #include <linux/vt_kern.h>
41 #include <linux/input.h>
42 #include <linux/reboot.h>
43 #include <linux/notifier.h>
44 #include <linux/jiffies.h>
45 #include <linux/uaccess.h>
47 #include <asm/irq_regs.h>
49 extern void ctrl_alt_del(void);
52 * Exported functions/variables
55 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
57 #if defined(CONFIG_X86) || defined(CONFIG_PARISC)
58 #include <asm/kbdleds.h>
60 static inline int kbd_defleds(void)
73 k_self, k_fn, k_spec, k_pad,\
74 k_dead, k_cons, k_cur, k_shift,\
75 k_meta, k_ascii, k_lock, k_lowercase,\
76 k_slock, k_dead2, k_brl, k_ignore
78 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
80 static k_handler_fn K_HANDLERS;
81 static k_handler_fn *k_handler[16] = { K_HANDLERS };
84 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
85 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
86 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
87 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
88 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
90 typedef void (fn_handler_fn)(struct vc_data *vc);
91 static fn_handler_fn FN_HANDLERS;
92 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
95 * Variables exported for vt_ioctl.c
98 struct vt_spawn_console vt_spawn_con = {
99 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
109 static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
110 static struct kbd_struct *kbd = kbd_table;
112 /* maximum values each key_handler can handle */
113 static const int max_vals[] = {
114 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
115 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
116 255, NR_LOCK - 1, 255, NR_BRL - 1
119 static const int NR_TYPES = ARRAY_SIZE(max_vals);
121 static struct input_handler kbd_handler;
122 static DEFINE_SPINLOCK(kbd_event_lock);
123 static DEFINE_SPINLOCK(led_lock);
124 static DEFINE_SPINLOCK(func_buf_lock); /* guard 'func_buf' and friends */
125 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
126 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
127 static bool dead_key_next;
129 /* Handles a number being assembled on the number pad */
130 static bool npadch_active;
131 static unsigned int npadch_value;
133 static unsigned int diacr;
134 static char rep; /* flag telling character repeat */
136 static int shift_state = 0;
138 static unsigned int ledstate = -1U; /* undefined */
139 static unsigned char ledioctl;
142 * Notifier list for console keyboard events
144 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
146 int register_keyboard_notifier(struct notifier_block *nb)
148 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
150 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
152 int unregister_keyboard_notifier(struct notifier_block *nb)
154 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
156 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
159 * Translation of scancodes to keycodes. We set them on only the first
160 * keyboard in the list that accepts the scancode and keycode.
161 * Explanation for not choosing the first attached keyboard anymore:
162 * USB keyboards for example have two event devices: one for all "normal"
163 * keys and one for extra function keys (like "volume up", "make coffee",
164 * etc.). So this means that scancodes for the extra function keys won't
165 * be valid for the first event device, but will be for the second.
168 struct getset_keycode_data {
169 struct input_keymap_entry ke;
173 static int getkeycode_helper(struct input_handle *handle, void *data)
175 struct getset_keycode_data *d = data;
177 d->error = input_get_keycode(handle->dev, &d->ke);
179 return d->error == 0; /* stop as soon as we successfully get one */
182 static int getkeycode(unsigned int scancode)
184 struct getset_keycode_data d = {
187 .len = sizeof(scancode),
193 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
195 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
197 return d.error ?: d.ke.keycode;
200 static int setkeycode_helper(struct input_handle *handle, void *data)
202 struct getset_keycode_data *d = data;
204 d->error = input_set_keycode(handle->dev, &d->ke);
206 return d->error == 0; /* stop as soon as we successfully set one */
209 static int setkeycode(unsigned int scancode, unsigned int keycode)
211 struct getset_keycode_data d = {
214 .len = sizeof(scancode),
220 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
222 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
228 * Making beeps and bells. Note that we prefer beeps to bells, but when
229 * shutting the sound off we do both.
232 static int kd_sound_helper(struct input_handle *handle, void *data)
234 unsigned int *hz = data;
235 struct input_dev *dev = handle->dev;
237 if (test_bit(EV_SND, dev->evbit)) {
238 if (test_bit(SND_TONE, dev->sndbit)) {
239 input_inject_event(handle, EV_SND, SND_TONE, *hz);
243 if (test_bit(SND_BELL, dev->sndbit))
244 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
250 static void kd_nosound(unsigned long ignored)
252 static unsigned int zero;
254 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
257 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
259 void kd_mksound(unsigned int hz, unsigned int ticks)
261 del_timer_sync(&kd_mksound_timer);
263 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
266 mod_timer(&kd_mksound_timer, jiffies + ticks);
268 EXPORT_SYMBOL(kd_mksound);
271 * Setting the keyboard rate.
274 static int kbd_rate_helper(struct input_handle *handle, void *data)
276 struct input_dev *dev = handle->dev;
277 struct kbd_repeat *rpt = data;
279 if (test_bit(EV_REP, dev->evbit)) {
281 if (rpt[0].delay > 0)
282 input_inject_event(handle,
283 EV_REP, REP_DELAY, rpt[0].delay);
284 if (rpt[0].period > 0)
285 input_inject_event(handle,
286 EV_REP, REP_PERIOD, rpt[0].period);
288 rpt[1].delay = dev->rep[REP_DELAY];
289 rpt[1].period = dev->rep[REP_PERIOD];
295 int kbd_rate(struct kbd_repeat *rpt)
297 struct kbd_repeat data[2] = { *rpt };
299 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
300 *rpt = data[1]; /* Copy currently used settings */
308 static void put_queue(struct vc_data *vc, int ch)
310 tty_insert_flip_char(&vc->port, ch, 0);
311 tty_schedule_flip(&vc->port);
314 static void puts_queue(struct vc_data *vc, char *cp)
317 tty_insert_flip_char(&vc->port, *cp, 0);
320 tty_schedule_flip(&vc->port);
323 static void applkey(struct vc_data *vc, int key, char mode)
325 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
327 buf[1] = (mode ? 'O' : '[');
333 * Many other routines do put_queue, but I think either
334 * they produce ASCII, or they produce some user-assigned
335 * string, and in both cases we might assume that it is
338 static void to_utf8(struct vc_data *vc, uint c)
343 else if (c < 0x800) {
344 /* 110***** 10****** */
345 put_queue(vc, 0xc0 | (c >> 6));
346 put_queue(vc, 0x80 | (c & 0x3f));
347 } else if (c < 0x10000) {
348 if (c >= 0xD800 && c < 0xE000)
352 /* 1110**** 10****** 10****** */
353 put_queue(vc, 0xe0 | (c >> 12));
354 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
355 put_queue(vc, 0x80 | (c & 0x3f));
356 } else if (c < 0x110000) {
357 /* 11110*** 10****** 10****** 10****** */
358 put_queue(vc, 0xf0 | (c >> 18));
359 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
360 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
361 put_queue(vc, 0x80 | (c & 0x3f));
366 * Called after returning from RAW mode or when changing consoles - recompute
367 * shift_down[] and shift_state from key_down[] maybe called when keymap is
368 * undefined, so that shiftkey release is seen. The caller must hold the
372 static void do_compute_shiftstate(void)
374 unsigned int k, sym, val;
377 memset(shift_down, 0, sizeof(shift_down));
379 for_each_set_bit(k, key_down, min(NR_KEYS, KEY_CNT)) {
380 sym = U(key_maps[0][k]);
381 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
385 if (val == KVAL(K_CAPSSHIFT))
389 shift_state |= BIT(val);
393 /* We still have to export this method to vt.c */
394 void compute_shiftstate(void)
397 spin_lock_irqsave(&kbd_event_lock, flags);
398 do_compute_shiftstate();
399 spin_unlock_irqrestore(&kbd_event_lock, flags);
403 * We have a combining character DIACR here, followed by the character CH.
404 * If the combination occurs in the table, return the corresponding value.
405 * Otherwise, if CH is a space or equals DIACR, return DIACR.
406 * Otherwise, conclude that DIACR was not combining after all,
407 * queue it and return CH.
409 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
411 unsigned int d = diacr;
416 if ((d & ~0xff) == BRL_UC_ROW) {
417 if ((ch & ~0xff) == BRL_UC_ROW)
420 for (i = 0; i < accent_table_size; i++)
421 if (accent_table[i].diacr == d && accent_table[i].base == ch)
422 return accent_table[i].result;
425 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
428 if (kbd->kbdmode == VC_UNICODE)
431 int c = conv_uni_to_8bit(d);
440 * Special function handlers
442 static void fn_enter(struct vc_data *vc)
445 if (kbd->kbdmode == VC_UNICODE)
448 int c = conv_uni_to_8bit(diacr);
456 if (vc_kbd_mode(kbd, VC_CRLF))
460 static void fn_caps_toggle(struct vc_data *vc)
465 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
468 static void fn_caps_on(struct vc_data *vc)
473 set_vc_kbd_led(kbd, VC_CAPSLOCK);
476 static void fn_show_ptregs(struct vc_data *vc)
478 struct pt_regs *regs = get_irq_regs();
484 static void fn_hold(struct vc_data *vc)
486 struct tty_struct *tty = vc->port.tty;
492 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
493 * these routines are also activated by ^S/^Q.
494 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
502 static void fn_num(struct vc_data *vc)
504 if (vc_kbd_mode(kbd, VC_APPLIC))
511 * Bind this to Shift-NumLock if you work in application keypad mode
512 * but want to be able to change the NumLock flag.
513 * Bind this to NumLock if you prefer that the NumLock key always
514 * changes the NumLock flag.
516 static void fn_bare_num(struct vc_data *vc)
519 chg_vc_kbd_led(kbd, VC_NUMLOCK);
522 static void fn_lastcons(struct vc_data *vc)
524 /* switch to the last used console, ChN */
525 set_console(last_console);
528 static void fn_dec_console(struct vc_data *vc)
530 int i, cur = fg_console;
532 /* Currently switching? Queue this next switch relative to that. */
533 if (want_console != -1)
536 for (i = cur - 1; i != cur; i--) {
538 i = MAX_NR_CONSOLES - 1;
539 if (vc_cons_allocated(i))
545 static void fn_inc_console(struct vc_data *vc)
547 int i, cur = fg_console;
549 /* Currently switching? Queue this next switch relative to that. */
550 if (want_console != -1)
553 for (i = cur+1; i != cur; i++) {
554 if (i == MAX_NR_CONSOLES)
556 if (vc_cons_allocated(i))
562 static void fn_send_intr(struct vc_data *vc)
564 tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
565 tty_schedule_flip(&vc->port);
568 static void fn_scroll_forw(struct vc_data *vc)
573 static void fn_scroll_back(struct vc_data *vc)
578 static void fn_show_mem(struct vc_data *vc)
583 static void fn_show_state(struct vc_data *vc)
588 static void fn_boot_it(struct vc_data *vc)
593 static void fn_compose(struct vc_data *vc)
595 dead_key_next = true;
598 static void fn_spawn_con(struct vc_data *vc)
600 spin_lock(&vt_spawn_con.lock);
601 if (vt_spawn_con.pid)
602 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
603 put_pid(vt_spawn_con.pid);
604 vt_spawn_con.pid = NULL;
606 spin_unlock(&vt_spawn_con.lock);
609 static void fn_SAK(struct vc_data *vc)
611 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
612 schedule_work(SAK_work);
615 static void fn_null(struct vc_data *vc)
617 do_compute_shiftstate();
621 * Special key handlers
623 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
627 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
631 if (value >= ARRAY_SIZE(fn_handler))
633 if ((kbd->kbdmode == VC_RAW ||
634 kbd->kbdmode == VC_MEDIUMRAW ||
635 kbd->kbdmode == VC_OFF) &&
636 value != KVAL(K_SAK))
637 return; /* SAK is allowed even in raw mode */
638 fn_handler[value](vc);
641 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
643 pr_err("k_lowercase was called - impossible\n");
646 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
649 return; /* no action, if this is a key release */
652 value = handle_diacr(vc, value);
655 dead_key_next = false;
659 if (kbd->kbdmode == VC_UNICODE)
662 int c = conv_uni_to_8bit(value);
669 * Handle dead key. Note that we now may have several
670 * dead keys modifying the same character. Very useful
673 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
678 diacr = (diacr ? handle_diacr(vc, value) : value);
681 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
683 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
686 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
688 k_deadunicode(vc, value, up_flag);
692 * Obsolete - for backwards compatibility only
694 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
696 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
698 k_deadunicode(vc, ret_diacr[value], up_flag);
701 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
709 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
714 if ((unsigned)value < ARRAY_SIZE(func_table)) {
717 spin_lock_irqsave(&func_buf_lock, flags);
718 if (func_table[value])
719 puts_queue(vc, func_table[value]);
720 spin_unlock_irqrestore(&func_buf_lock, flags);
723 pr_err("k_fn called with value=%d\n", value);
726 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
728 static const char cur_chars[] = "BDCA";
733 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
736 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
738 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
739 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
742 return; /* no action, if this is a key release */
744 /* kludge... shift forces cursor/number keys */
745 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
746 applkey(vc, app_map[value], 1);
750 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
755 k_fn(vc, KVAL(K_REMOVE), 0);
758 k_fn(vc, KVAL(K_INSERT), 0);
761 k_fn(vc, KVAL(K_SELECT), 0);
764 k_cur(vc, KVAL(K_DOWN), 0);
767 k_fn(vc, KVAL(K_PGDN), 0);
770 k_cur(vc, KVAL(K_LEFT), 0);
773 k_cur(vc, KVAL(K_RIGHT), 0);
776 k_fn(vc, KVAL(K_FIND), 0);
779 k_cur(vc, KVAL(K_UP), 0);
782 k_fn(vc, KVAL(K_PGUP), 0);
785 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
790 put_queue(vc, pad_chars[value]);
791 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
795 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
797 int old_state = shift_state;
803 * a CapsShift key acts like Shift but undoes CapsLock
805 if (value == KVAL(K_CAPSSHIFT)) {
806 value = KVAL(K_SHIFT);
808 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
813 * handle the case that two shift or control
814 * keys are depressed simultaneously
816 if (shift_down[value])
821 if (shift_down[value])
822 shift_state |= (1 << value);
824 shift_state &= ~(1 << value);
827 if (up_flag && shift_state != old_state && npadch_active) {
828 if (kbd->kbdmode == VC_UNICODE)
829 to_utf8(vc, npadch_value);
831 put_queue(vc, npadch_value & 0xff);
832 npadch_active = false;
836 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
841 if (vc_kbd_mode(kbd, VC_META)) {
842 put_queue(vc, '\033');
843 put_queue(vc, value);
845 put_queue(vc, value | 0x80);
848 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
856 /* decimal input of code, while Alt depressed */
859 /* hexadecimal input of code, while AltGr depressed */
864 if (!npadch_active) {
866 npadch_active = true;
869 npadch_value = npadch_value * base + value;
872 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
877 chg_vc_kbd_lock(kbd, value);
880 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
882 k_shift(vc, value, up_flag);
886 chg_vc_kbd_slock(kbd, value);
887 /* try to make Alt, oops, AltGr and such work */
888 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
890 chg_vc_kbd_slock(kbd, value);
894 /* by default, 300ms interval for combination release */
895 static unsigned brl_timeout = 300;
896 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
897 module_param(brl_timeout, uint, 0644);
899 static unsigned brl_nbchords = 1;
900 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
901 module_param(brl_nbchords, uint, 0644);
903 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
905 static unsigned long chords;
906 static unsigned committed;
909 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
911 committed |= pattern;
913 if (chords == brl_nbchords) {
914 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
921 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
923 static unsigned pressed, committing;
924 static unsigned long releasestart;
926 if (kbd->kbdmode != VC_UNICODE) {
928 pr_warn("keyboard mode must be unicode for braille patterns\n");
933 k_unicode(vc, BRL_UC_ROW, up_flag);
941 pressed |= 1 << (value - 1);
943 committing = pressed;
944 } else if (brl_timeout) {
947 releasestart + msecs_to_jiffies(brl_timeout))) {
948 committing = pressed;
949 releasestart = jiffies;
951 pressed &= ~(1 << (value - 1));
952 if (!pressed && committing) {
953 k_brlcommit(vc, committing, 0);
958 k_brlcommit(vc, committing, 0);
961 pressed &= ~(1 << (value - 1));
965 #if IS_ENABLED(CONFIG_INPUT_LEDS) && IS_ENABLED(CONFIG_LEDS_TRIGGERS)
967 struct kbd_led_trigger {
968 struct led_trigger trigger;
972 static void kbd_led_trigger_activate(struct led_classdev *cdev)
974 struct kbd_led_trigger *trigger =
975 container_of(cdev->trigger, struct kbd_led_trigger, trigger);
977 tasklet_disable(&keyboard_tasklet);
979 led_trigger_event(&trigger->trigger,
980 ledstate & trigger->mask ?
982 tasklet_enable(&keyboard_tasklet);
985 #define KBD_LED_TRIGGER(_led_bit, _name) { \
988 .activate = kbd_led_trigger_activate, \
990 .mask = BIT(_led_bit), \
993 #define KBD_LOCKSTATE_TRIGGER(_led_bit, _name) \
994 KBD_LED_TRIGGER((_led_bit) + 8, _name)
996 static struct kbd_led_trigger kbd_led_triggers[] = {
997 KBD_LED_TRIGGER(VC_SCROLLOCK, "kbd-scrolllock"),
998 KBD_LED_TRIGGER(VC_NUMLOCK, "kbd-numlock"),
999 KBD_LED_TRIGGER(VC_CAPSLOCK, "kbd-capslock"),
1000 KBD_LED_TRIGGER(VC_KANALOCK, "kbd-kanalock"),
1002 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLOCK, "kbd-shiftlock"),
1003 KBD_LOCKSTATE_TRIGGER(VC_ALTGRLOCK, "kbd-altgrlock"),
1004 KBD_LOCKSTATE_TRIGGER(VC_CTRLLOCK, "kbd-ctrllock"),
1005 KBD_LOCKSTATE_TRIGGER(VC_ALTLOCK, "kbd-altlock"),
1006 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLLOCK, "kbd-shiftllock"),
1007 KBD_LOCKSTATE_TRIGGER(VC_SHIFTRLOCK, "kbd-shiftrlock"),
1008 KBD_LOCKSTATE_TRIGGER(VC_CTRLLLOCK, "kbd-ctrlllock"),
1009 KBD_LOCKSTATE_TRIGGER(VC_CTRLRLOCK, "kbd-ctrlrlock"),
1012 static void kbd_propagate_led_state(unsigned int old_state,
1013 unsigned int new_state)
1015 struct kbd_led_trigger *trigger;
1016 unsigned int changed = old_state ^ new_state;
1019 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1020 trigger = &kbd_led_triggers[i];
1022 if (changed & trigger->mask)
1023 led_trigger_event(&trigger->trigger,
1024 new_state & trigger->mask ?
1025 LED_FULL : LED_OFF);
1029 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1031 unsigned int led_state = *(unsigned int *)data;
1033 if (test_bit(EV_LED, handle->dev->evbit))
1034 kbd_propagate_led_state(~led_state, led_state);
1039 static void kbd_init_leds(void)
1044 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1045 error = led_trigger_register(&kbd_led_triggers[i].trigger);
1047 pr_err("error %d while registering trigger %s\n",
1048 error, kbd_led_triggers[i].trigger.name);
1054 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1056 unsigned int leds = *(unsigned int *)data;
1058 if (test_bit(EV_LED, handle->dev->evbit)) {
1059 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1060 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1061 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1062 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1068 static void kbd_propagate_led_state(unsigned int old_state,
1069 unsigned int new_state)
1071 input_handler_for_each_handle(&kbd_handler, &new_state,
1072 kbd_update_leds_helper);
1075 static void kbd_init_leds(void)
1082 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
1083 * or (ii) whatever pattern of lights people want to show using KDSETLED,
1084 * or (iii) specified bits of specified words in kernel memory.
1086 static unsigned char getledstate(void)
1088 return ledstate & 0xff;
1091 void setledstate(struct kbd_struct *kb, unsigned int led)
1093 unsigned long flags;
1094 spin_lock_irqsave(&led_lock, flags);
1097 kb->ledmode = LED_SHOW_IOCTL;
1099 kb->ledmode = LED_SHOW_FLAGS;
1102 spin_unlock_irqrestore(&led_lock, flags);
1105 static inline unsigned char getleds(void)
1107 struct kbd_struct *kb = kbd_table + fg_console;
1109 if (kb->ledmode == LED_SHOW_IOCTL)
1112 return kb->ledflagstate;
1116 * vt_get_leds - helper for braille console
1117 * @console: console to read
1118 * @flag: flag we want to check
1120 * Check the status of a keyboard led flag and report it back
1122 int vt_get_leds(int console, int flag)
1124 struct kbd_struct *kb = kbd_table + console;
1126 unsigned long flags;
1128 spin_lock_irqsave(&led_lock, flags);
1129 ret = vc_kbd_led(kb, flag);
1130 spin_unlock_irqrestore(&led_lock, flags);
1134 EXPORT_SYMBOL_GPL(vt_get_leds);
1137 * vt_set_led_state - set LED state of a console
1138 * @console: console to set
1141 * Set the LEDs on a console. This is a wrapper for the VT layer
1142 * so that we can keep kbd knowledge internal
1144 void vt_set_led_state(int console, int leds)
1146 struct kbd_struct *kb = kbd_table + console;
1147 setledstate(kb, leds);
1151 * vt_kbd_con_start - Keyboard side of console start
1154 * Handle console start. This is a wrapper for the VT layer
1155 * so that we can keep kbd knowledge internal
1157 * FIXME: We eventually need to hold the kbd lock here to protect
1158 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1159 * and start_tty under the kbd_event_lock, while normal tty paths
1160 * don't hold the lock. We probably need to split out an LED lock
1161 * but not during an -rc release!
1163 void vt_kbd_con_start(int console)
1165 struct kbd_struct *kb = kbd_table + console;
1166 unsigned long flags;
1167 spin_lock_irqsave(&led_lock, flags);
1168 clr_vc_kbd_led(kb, VC_SCROLLOCK);
1170 spin_unlock_irqrestore(&led_lock, flags);
1174 * vt_kbd_con_stop - Keyboard side of console stop
1177 * Handle console stop. This is a wrapper for the VT layer
1178 * so that we can keep kbd knowledge internal
1180 void vt_kbd_con_stop(int console)
1182 struct kbd_struct *kb = kbd_table + console;
1183 unsigned long flags;
1184 spin_lock_irqsave(&led_lock, flags);
1185 set_vc_kbd_led(kb, VC_SCROLLOCK);
1187 spin_unlock_irqrestore(&led_lock, flags);
1191 * This is the tasklet that updates LED state of LEDs using standard
1192 * keyboard triggers. The reason we use tasklet is that we need to
1193 * handle the scenario when keyboard handler is not registered yet
1194 * but we already getting updates from the VT to update led state.
1196 static void kbd_bh(unsigned long dummy)
1199 unsigned long flags;
1201 spin_lock_irqsave(&led_lock, flags);
1203 leds |= (unsigned int)kbd->lockstate << 8;
1204 spin_unlock_irqrestore(&led_lock, flags);
1206 if (leds != ledstate) {
1207 kbd_propagate_led_state(ledstate, leds);
1212 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1214 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1215 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1216 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1217 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1218 defined(CONFIG_AVR32)
1220 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1221 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1223 static const unsigned short x86_keycodes[256] =
1224 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1225 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1226 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1227 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1228 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1229 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1230 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1231 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1232 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1233 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1234 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1235 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1236 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1237 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1238 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1241 static int sparc_l1_a_state;
1242 extern void sun_do_break(void);
1245 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1246 unsigned char up_flag)
1253 put_queue(vc, 0xe1);
1254 put_queue(vc, 0x1d | up_flag);
1255 put_queue(vc, 0x45 | up_flag);
1260 put_queue(vc, 0xf2);
1265 put_queue(vc, 0xf1);
1270 * Real AT keyboards (that's what we're trying
1271 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1272 * pressing PrtSc/SysRq alone, but simply 0x54
1273 * when pressing Alt+PrtSc/SysRq.
1275 if (test_bit(KEY_LEFTALT, key_down) ||
1276 test_bit(KEY_RIGHTALT, key_down)) {
1277 put_queue(vc, 0x54 | up_flag);
1279 put_queue(vc, 0xe0);
1280 put_queue(vc, 0x2a | up_flag);
1281 put_queue(vc, 0xe0);
1282 put_queue(vc, 0x37 | up_flag);
1290 code = x86_keycodes[keycode];
1295 put_queue(vc, 0xe0);
1296 put_queue(vc, (code & 0x7f) | up_flag);
1306 #define HW_RAW(dev) 0
1308 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1313 put_queue(vc, keycode | up_flag);
1318 static void kbd_rawcode(unsigned char data)
1320 struct vc_data *vc = vc_cons[fg_console].d;
1322 kbd = kbd_table + vc->vc_num;
1323 if (kbd->kbdmode == VC_RAW)
1324 put_queue(vc, data);
1327 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1329 struct vc_data *vc = vc_cons[fg_console].d;
1330 unsigned short keysym, *key_map;
1333 struct tty_struct *tty;
1335 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1340 if (tty && (!tty->driver_data)) {
1341 /* No driver data? Strange. Okay we fix it then. */
1342 tty->driver_data = vc;
1345 kbd = kbd_table + vc->vc_num;
1348 if (keycode == KEY_STOP)
1349 sparc_l1_a_state = down;
1354 raw_mode = (kbd->kbdmode == VC_RAW);
1355 if (raw_mode && !hw_raw)
1356 if (emulate_raw(vc, keycode, !down << 7))
1357 if (keycode < BTN_MISC && printk_ratelimit())
1358 pr_warn("can't emulate rawmode for keycode %d\n",
1362 if (keycode == KEY_A && sparc_l1_a_state) {
1363 sparc_l1_a_state = false;
1368 if (kbd->kbdmode == VC_MEDIUMRAW) {
1370 * This is extended medium raw mode, with keys above 127
1371 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1372 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1373 * interfere with anything else. The two bytes after 0 will
1374 * always have the up flag set not to interfere with older
1375 * applications. This allows for 16384 different keycodes,
1376 * which should be enough.
1378 if (keycode < 128) {
1379 put_queue(vc, keycode | (!down << 7));
1381 put_queue(vc, !down << 7);
1382 put_queue(vc, (keycode >> 7) | 0x80);
1383 put_queue(vc, keycode | 0x80);
1389 set_bit(keycode, key_down);
1391 clear_bit(keycode, key_down);
1394 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1395 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1397 * Don't repeat a key if the input buffers are not empty and the
1398 * characters get aren't echoed locally. This makes key repeat
1399 * usable with slow applications and under heavy loads.
1404 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1405 param.ledstate = kbd->ledflagstate;
1406 key_map = key_maps[shift_final];
1408 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1409 KBD_KEYCODE, ¶m);
1410 if (rc == NOTIFY_STOP || !key_map) {
1411 atomic_notifier_call_chain(&keyboard_notifier_list,
1412 KBD_UNBOUND_KEYCODE, ¶m);
1413 do_compute_shiftstate();
1414 kbd->slockstate = 0;
1418 if (keycode < NR_KEYS)
1419 keysym = key_map[keycode];
1420 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1421 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1425 type = KTYP(keysym);
1428 param.value = keysym;
1429 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1430 KBD_UNICODE, ¶m);
1431 if (rc != NOTIFY_STOP)
1432 if (down && !raw_mode)
1433 to_utf8(vc, keysym);
1439 if (type == KT_LETTER) {
1441 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1442 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1444 keysym = key_map[keycode];
1448 param.value = keysym;
1449 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1450 KBD_KEYSYM, ¶m);
1451 if (rc == NOTIFY_STOP)
1454 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1457 (*k_handler[type])(vc, keysym & 0xff, !down);
1459 param.ledstate = kbd->ledflagstate;
1460 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1462 if (type != KT_SLOCK)
1463 kbd->slockstate = 0;
1466 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1467 unsigned int event_code, int value)
1469 /* We are called with interrupts disabled, just take the lock */
1470 spin_lock(&kbd_event_lock);
1472 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1474 if (event_type == EV_KEY && event_code <= KEY_MAX)
1475 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1477 spin_unlock(&kbd_event_lock);
1479 tasklet_schedule(&keyboard_tasklet);
1480 do_poke_blanked_console = 1;
1481 schedule_console_callback();
1484 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1488 if (test_bit(EV_SND, dev->evbit))
1491 if (test_bit(EV_KEY, dev->evbit)) {
1492 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1493 if (test_bit(i, dev->keybit))
1495 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1496 if (test_bit(i, dev->keybit))
1504 * When a keyboard (or other input device) is found, the kbd_connect
1505 * function is called. The function then looks at the device, and if it
1506 * likes it, it can open it and get events from it. In this (kbd_connect)
1507 * function, we should decide which VT to bind that keyboard to initially.
1509 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1510 const struct input_device_id *id)
1512 struct input_handle *handle;
1515 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1520 handle->handler = handler;
1521 handle->name = "kbd";
1523 error = input_register_handle(handle);
1525 goto err_free_handle;
1527 error = input_open_device(handle);
1529 goto err_unregister_handle;
1533 err_unregister_handle:
1534 input_unregister_handle(handle);
1540 static void kbd_disconnect(struct input_handle *handle)
1542 input_close_device(handle);
1543 input_unregister_handle(handle);
1548 * Start keyboard handler on the new keyboard by refreshing LED state to
1549 * match the rest of the system.
1551 static void kbd_start(struct input_handle *handle)
1553 tasklet_disable(&keyboard_tasklet);
1555 if (ledstate != -1U)
1556 kbd_update_leds_helper(handle, &ledstate);
1558 tasklet_enable(&keyboard_tasklet);
1561 static const struct input_device_id kbd_ids[] = {
1563 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1564 .evbit = { BIT_MASK(EV_KEY) },
1568 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1569 .evbit = { BIT_MASK(EV_SND) },
1572 { }, /* Terminating entry */
1575 MODULE_DEVICE_TABLE(input, kbd_ids);
1577 static struct input_handler kbd_handler = {
1580 .connect = kbd_connect,
1581 .disconnect = kbd_disconnect,
1584 .id_table = kbd_ids,
1587 int __init kbd_init(void)
1592 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1593 kbd_table[i].ledflagstate = kbd_defleds();
1594 kbd_table[i].default_ledflagstate = kbd_defleds();
1595 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1596 kbd_table[i].lockstate = KBD_DEFLOCK;
1597 kbd_table[i].slockstate = 0;
1598 kbd_table[i].modeflags = KBD_DEFMODE;
1599 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1604 error = input_register_handler(&kbd_handler);
1608 tasklet_enable(&keyboard_tasklet);
1609 tasklet_schedule(&keyboard_tasklet);
1614 /* Ioctl support code */
1617 * vt_do_diacrit - diacritical table updates
1618 * @cmd: ioctl request
1619 * @udp: pointer to user data for ioctl
1620 * @perm: permissions check computed by caller
1622 * Update the diacritical tables atomically and safely. Lock them
1623 * against simultaneous keypresses
1625 int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
1627 unsigned long flags;
1634 struct kbdiacrs __user *a = udp;
1635 struct kbdiacr *dia;
1638 dia = kmalloc(MAX_DIACR * sizeof(struct kbdiacr),
1643 /* Lock the diacriticals table, make a copy and then
1644 copy it after we unlock */
1645 spin_lock_irqsave(&kbd_event_lock, flags);
1647 asize = accent_table_size;
1648 for (i = 0; i < asize; i++) {
1649 dia[i].diacr = conv_uni_to_8bit(
1650 accent_table[i].diacr);
1651 dia[i].base = conv_uni_to_8bit(
1652 accent_table[i].base);
1653 dia[i].result = conv_uni_to_8bit(
1654 accent_table[i].result);
1656 spin_unlock_irqrestore(&kbd_event_lock, flags);
1658 if (put_user(asize, &a->kb_cnt))
1660 else if (copy_to_user(a->kbdiacr, dia,
1661 asize * sizeof(struct kbdiacr)))
1668 struct kbdiacrsuc __user *a = udp;
1671 buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc),
1676 /* Lock the diacriticals table, make a copy and then
1677 copy it after we unlock */
1678 spin_lock_irqsave(&kbd_event_lock, flags);
1680 asize = accent_table_size;
1681 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1683 spin_unlock_irqrestore(&kbd_event_lock, flags);
1685 if (put_user(asize, &a->kb_cnt))
1687 else if (copy_to_user(a->kbdiacruc, buf,
1688 asize*sizeof(struct kbdiacruc)))
1696 struct kbdiacrs __user *a = udp;
1697 struct kbdiacr *dia = NULL;
1703 if (get_user(ct, &a->kb_cnt))
1705 if (ct >= MAX_DIACR)
1709 dia = kmalloc(sizeof(struct kbdiacr) * ct,
1714 if (copy_from_user(dia, a->kbdiacr,
1715 sizeof(struct kbdiacr) * ct)) {
1721 spin_lock_irqsave(&kbd_event_lock, flags);
1722 accent_table_size = ct;
1723 for (i = 0; i < ct; i++) {
1724 accent_table[i].diacr =
1725 conv_8bit_to_uni(dia[i].diacr);
1726 accent_table[i].base =
1727 conv_8bit_to_uni(dia[i].base);
1728 accent_table[i].result =
1729 conv_8bit_to_uni(dia[i].result);
1731 spin_unlock_irqrestore(&kbd_event_lock, flags);
1738 struct kbdiacrsuc __user *a = udp;
1745 if (get_user(ct, &a->kb_cnt))
1748 if (ct >= MAX_DIACR)
1752 buf = kmalloc(ct * sizeof(struct kbdiacruc),
1757 if (copy_from_user(buf, a->kbdiacruc,
1758 ct * sizeof(struct kbdiacruc))) {
1763 spin_lock_irqsave(&kbd_event_lock, flags);
1765 memcpy(accent_table, buf,
1766 ct * sizeof(struct kbdiacruc));
1767 accent_table_size = ct;
1768 spin_unlock_irqrestore(&kbd_event_lock, flags);
1777 * vt_do_kdskbmode - set keyboard mode ioctl
1778 * @console: the console to use
1779 * @arg: the requested mode
1781 * Update the keyboard mode bits while holding the correct locks.
1782 * Return 0 for success or an error code.
1784 int vt_do_kdskbmode(int console, unsigned int arg)
1786 struct kbd_struct *kb = kbd_table + console;
1788 unsigned long flags;
1790 spin_lock_irqsave(&kbd_event_lock, flags);
1793 kb->kbdmode = VC_RAW;
1796 kb->kbdmode = VC_MEDIUMRAW;
1799 kb->kbdmode = VC_XLATE;
1800 do_compute_shiftstate();
1803 kb->kbdmode = VC_UNICODE;
1804 do_compute_shiftstate();
1807 kb->kbdmode = VC_OFF;
1812 spin_unlock_irqrestore(&kbd_event_lock, flags);
1817 * vt_do_kdskbmeta - set keyboard meta state
1818 * @console: the console to use
1819 * @arg: the requested meta state
1821 * Update the keyboard meta bits while holding the correct locks.
1822 * Return 0 for success or an error code.
1824 int vt_do_kdskbmeta(int console, unsigned int arg)
1826 struct kbd_struct *kb = kbd_table + console;
1828 unsigned long flags;
1830 spin_lock_irqsave(&kbd_event_lock, flags);
1833 clr_vc_kbd_mode(kb, VC_META);
1836 set_vc_kbd_mode(kb, VC_META);
1841 spin_unlock_irqrestore(&kbd_event_lock, flags);
1845 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1848 struct kbkeycode tmp;
1851 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1855 kc = getkeycode(tmp.scancode);
1857 kc = put_user(kc, &user_kbkc->keycode);
1862 kc = setkeycode(tmp.scancode, tmp.keycode);
1868 #define i (tmp.kb_index)
1869 #define s (tmp.kb_table)
1870 #define v (tmp.kb_value)
1872 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1875 struct kbd_struct *kb = kbd_table + console;
1877 ushort *key_map, *new_map, val, ov;
1878 unsigned long flags;
1880 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1883 if (!capable(CAP_SYS_TTY_CONFIG))
1888 /* Ensure another thread doesn't free it under us */
1889 spin_lock_irqsave(&kbd_event_lock, flags);
1890 key_map = key_maps[s];
1892 val = U(key_map[i]);
1893 if (kb->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1896 val = (i ? K_HOLE : K_NOSUCHMAP);
1897 spin_unlock_irqrestore(&kbd_event_lock, flags);
1898 return put_user(val, &user_kbe->kb_value);
1902 if (!i && v == K_NOSUCHMAP) {
1903 spin_lock_irqsave(&kbd_event_lock, flags);
1904 /* deallocate map */
1905 key_map = key_maps[s];
1908 if (key_map[0] == U(K_ALLOCATED)) {
1913 spin_unlock_irqrestore(&kbd_event_lock, flags);
1917 if (KTYP(v) < NR_TYPES) {
1918 if (KVAL(v) > max_vals[KTYP(v)])
1921 if (kb->kbdmode != VC_UNICODE)
1924 /* ++Geert: non-PC keyboards may generate keycode zero */
1925 #if !defined(__mc68000__) && !defined(__powerpc__)
1926 /* assignment to entry 0 only tests validity of args */
1931 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1934 spin_lock_irqsave(&kbd_event_lock, flags);
1935 key_map = key_maps[s];
1936 if (key_map == NULL) {
1939 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1940 !capable(CAP_SYS_RESOURCE)) {
1941 spin_unlock_irqrestore(&kbd_event_lock, flags);
1945 key_maps[s] = new_map;
1947 key_map[0] = U(K_ALLOCATED);
1948 for (j = 1; j < NR_KEYS; j++)
1949 key_map[j] = U(K_HOLE);
1960 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1961 spin_unlock_irqrestore(&kbd_event_lock, flags);
1965 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1966 do_compute_shiftstate();
1968 spin_unlock_irqrestore(&kbd_event_lock, flags);
1977 /* FIXME: This one needs untangling */
1978 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1980 struct kbsentry *kbs;
1984 char *first_free, *fj, *fnw;
1987 unsigned long flags;
1989 if (!capable(CAP_SYS_TTY_CONFIG))
1992 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
1998 /* we mostly copy too much here (512bytes), but who cares ;) */
1999 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
2003 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
2008 /* size should have been a struct member */
2009 ssize_t len = sizeof(user_kdgkb->kb_string);
2011 spin_lock_irqsave(&func_buf_lock, flags);
2012 len = strlcpy(kbs->kb_string, func_table[i] ? : "", len);
2013 spin_unlock_irqrestore(&func_buf_lock, flags);
2015 ret = copy_to_user(user_kdgkb->kb_string, kbs->kb_string,
2016 len + 1) ? -EFAULT : 0;
2028 /* race aginst other writers */
2030 spin_lock_irqsave(&func_buf_lock, flags);
2033 /* fj pointer to next entry after 'q' */
2034 first_free = funcbufptr + (funcbufsize - funcbufleft);
2035 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
2037 if (j < MAX_NR_FUNC)
2041 /* buffer usage increase by new entry */
2042 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
2044 if (delta <= funcbufleft) { /* it fits in current buf */
2045 if (j < MAX_NR_FUNC) {
2046 /* make enough space for new entry at 'fj' */
2047 memmove(fj + delta, fj, first_free - fj);
2048 for (k = j; k < MAX_NR_FUNC; k++)
2050 func_table[k] += delta;
2054 funcbufleft -= delta;
2055 } else { /* allocate a larger buffer */
2057 while (sz < funcbufsize - funcbufleft + delta)
2060 spin_unlock_irqrestore(&func_buf_lock, flags);
2062 fnw = kmalloc(sz, GFP_KERNEL);
2073 /* copy data before insertion point to new location */
2074 if (fj > funcbufptr)
2075 memmove(fnw, funcbufptr, fj - funcbufptr);
2076 for (k = 0; k < j; k++)
2078 func_table[k] = fnw + (func_table[k] - funcbufptr);
2080 /* copy data after insertion point to new location */
2081 if (first_free > fj) {
2082 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
2083 for (k = j; k < MAX_NR_FUNC; k++)
2085 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
2087 if (funcbufptr != func_buf)
2090 funcbufleft = funcbufleft - delta + sz - funcbufsize;
2093 /* finally insert item itself */
2094 strcpy(func_table[i], kbs->kb_string);
2095 spin_unlock_irqrestore(&func_buf_lock, flags);
2104 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2106 struct kbd_struct *kb = kbd_table + console;
2107 unsigned long flags;
2108 unsigned char ucval;
2111 /* the ioctls below read/set the flags usually shown in the leds */
2112 /* don't use them - they will go away without warning */
2114 spin_lock_irqsave(&kbd_event_lock, flags);
2115 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2116 spin_unlock_irqrestore(&kbd_event_lock, flags);
2117 return put_user(ucval, (char __user *)arg);
2124 spin_lock_irqsave(&led_lock, flags);
2125 kb->ledflagstate = (arg & 7);
2126 kb->default_ledflagstate = ((arg >> 4) & 7);
2128 spin_unlock_irqrestore(&led_lock, flags);
2131 /* the ioctls below only set the lights, not the functions */
2132 /* for those, see KDGKBLED and KDSKBLED above */
2134 ucval = getledstate();
2135 return put_user(ucval, (char __user *)arg);
2140 setledstate(kb, arg);
2143 return -ENOIOCTLCMD;
2146 int vt_do_kdgkbmode(int console)
2148 struct kbd_struct *kb = kbd_table + console;
2149 /* This is a spot read so needs no locking */
2150 switch (kb->kbdmode) {
2165 * vt_do_kdgkbmeta - report meta status
2166 * @console: console to report
2168 * Report the meta flag status of this console
2170 int vt_do_kdgkbmeta(int console)
2172 struct kbd_struct *kb = kbd_table + console;
2173 /* Again a spot read so no locking */
2174 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2178 * vt_reset_unicode - reset the unicode status
2179 * @console: console being reset
2181 * Restore the unicode console state to its default
2183 void vt_reset_unicode(int console)
2185 unsigned long flags;
2187 spin_lock_irqsave(&kbd_event_lock, flags);
2188 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2189 spin_unlock_irqrestore(&kbd_event_lock, flags);
2193 * vt_get_shiftstate - shift bit state
2195 * Report the shift bits from the keyboard state. We have to export
2196 * this to support some oddities in the vt layer.
2198 int vt_get_shift_state(void)
2200 /* Don't lock as this is a transient report */
2205 * vt_reset_keyboard - reset keyboard state
2206 * @console: console to reset
2208 * Reset the keyboard bits for a console as part of a general console
2211 void vt_reset_keyboard(int console)
2213 struct kbd_struct *kb = kbd_table + console;
2214 unsigned long flags;
2216 spin_lock_irqsave(&kbd_event_lock, flags);
2217 set_vc_kbd_mode(kb, VC_REPEAT);
2218 clr_vc_kbd_mode(kb, VC_CKMODE);
2219 clr_vc_kbd_mode(kb, VC_APPLIC);
2220 clr_vc_kbd_mode(kb, VC_CRLF);
2223 spin_lock(&led_lock);
2224 kb->ledmode = LED_SHOW_FLAGS;
2225 kb->ledflagstate = kb->default_ledflagstate;
2226 spin_unlock(&led_lock);
2227 /* do not do set_leds here because this causes an endless tasklet loop
2228 when the keyboard hasn't been initialized yet */
2229 spin_unlock_irqrestore(&kbd_event_lock, flags);
2233 * vt_get_kbd_mode_bit - read keyboard status bits
2234 * @console: console to read from
2235 * @bit: mode bit to read
2237 * Report back a vt mode bit. We do this without locking so the
2238 * caller must be sure that there are no synchronization needs
2241 int vt_get_kbd_mode_bit(int console, int bit)
2243 struct kbd_struct *kb = kbd_table + console;
2244 return vc_kbd_mode(kb, bit);
2248 * vt_set_kbd_mode_bit - read keyboard status bits
2249 * @console: console to read from
2250 * @bit: mode bit to read
2252 * Set a vt mode bit. We do this without locking so the
2253 * caller must be sure that there are no synchronization needs
2256 void vt_set_kbd_mode_bit(int console, int bit)
2258 struct kbd_struct *kb = kbd_table + console;
2259 unsigned long flags;
2261 spin_lock_irqsave(&kbd_event_lock, flags);
2262 set_vc_kbd_mode(kb, bit);
2263 spin_unlock_irqrestore(&kbd_event_lock, flags);
2267 * vt_clr_kbd_mode_bit - read keyboard status bits
2268 * @console: console to read from
2269 * @bit: mode bit to read
2271 * Report back a vt mode bit. We do this without locking so the
2272 * caller must be sure that there are no synchronization needs
2275 void vt_clr_kbd_mode_bit(int console, int bit)
2277 struct kbd_struct *kb = kbd_table + console;
2278 unsigned long flags;
2280 spin_lock_irqsave(&kbd_event_lock, flags);
2281 clr_vc_kbd_mode(kb, bit);
2282 spin_unlock_irqrestore(&kbd_event_lock, flags);