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/signal.h>
30 #include <linux/sched/debug.h>
31 #include <linux/tty.h>
32 #include <linux/tty_flip.h>
34 #include <linux/string.h>
35 #include <linux/init.h>
36 #include <linux/slab.h>
37 #include <linux/leds.h>
39 #include <linux/kbd_kern.h>
40 #include <linux/kbd_diacr.h>
41 #include <linux/vt_kern.h>
42 #include <linux/input.h>
43 #include <linux/reboot.h>
44 #include <linux/notifier.h>
45 #include <linux/jiffies.h>
46 #include <linux/uaccess.h>
48 #include <asm/irq_regs.h>
50 extern void ctrl_alt_del(void);
53 * Exported functions/variables
56 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
58 #if defined(CONFIG_X86) || defined(CONFIG_PARISC)
59 #include <asm/kbdleds.h>
61 static inline int kbd_defleds(void)
74 k_self, k_fn, k_spec, k_pad,\
75 k_dead, k_cons, k_cur, k_shift,\
76 k_meta, k_ascii, k_lock, k_lowercase,\
77 k_slock, k_dead2, k_brl, k_ignore
79 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
81 static k_handler_fn K_HANDLERS;
82 static k_handler_fn *k_handler[16] = { K_HANDLERS };
85 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
86 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
87 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
88 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
89 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
91 typedef void (fn_handler_fn)(struct vc_data *vc);
92 static fn_handler_fn FN_HANDLERS;
93 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
96 * Variables exported for vt_ioctl.c
99 struct vt_spawn_console vt_spawn_con = {
100 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
110 static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
111 static struct kbd_struct *kbd = kbd_table;
113 /* maximum values each key_handler can handle */
114 static const int max_vals[] = {
115 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
116 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
117 255, NR_LOCK - 1, 255, NR_BRL - 1
120 static const int NR_TYPES = ARRAY_SIZE(max_vals);
122 static struct input_handler kbd_handler;
123 static DEFINE_SPINLOCK(kbd_event_lock);
124 static DEFINE_SPINLOCK(led_lock);
125 static DEFINE_SPINLOCK(func_buf_lock); /* guard 'func_buf' and friends */
126 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
127 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
128 static bool dead_key_next;
130 /* Handles a number being assembled on the number pad */
131 static bool npadch_active;
132 static unsigned int npadch_value;
134 static unsigned int diacr;
135 static char rep; /* flag telling character repeat */
137 static int shift_state = 0;
139 static unsigned int ledstate = -1U; /* undefined */
140 static unsigned char ledioctl;
143 * Notifier list for console keyboard events
145 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
147 int register_keyboard_notifier(struct notifier_block *nb)
149 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
151 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
153 int unregister_keyboard_notifier(struct notifier_block *nb)
155 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
157 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
160 * Translation of scancodes to keycodes. We set them on only the first
161 * keyboard in the list that accepts the scancode and keycode.
162 * Explanation for not choosing the first attached keyboard anymore:
163 * USB keyboards for example have two event devices: one for all "normal"
164 * keys and one for extra function keys (like "volume up", "make coffee",
165 * etc.). So this means that scancodes for the extra function keys won't
166 * be valid for the first event device, but will be for the second.
169 struct getset_keycode_data {
170 struct input_keymap_entry ke;
174 static int getkeycode_helper(struct input_handle *handle, void *data)
176 struct getset_keycode_data *d = data;
178 d->error = input_get_keycode(handle->dev, &d->ke);
180 return d->error == 0; /* stop as soon as we successfully get one */
183 static int getkeycode(unsigned int scancode)
185 struct getset_keycode_data d = {
188 .len = sizeof(scancode),
194 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
196 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
198 return d.error ?: d.ke.keycode;
201 static int setkeycode_helper(struct input_handle *handle, void *data)
203 struct getset_keycode_data *d = data;
205 d->error = input_set_keycode(handle->dev, &d->ke);
207 return d->error == 0; /* stop as soon as we successfully set one */
210 static int setkeycode(unsigned int scancode, unsigned int keycode)
212 struct getset_keycode_data d = {
215 .len = sizeof(scancode),
221 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
223 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
229 * Making beeps and bells. Note that we prefer beeps to bells, but when
230 * shutting the sound off we do both.
233 static int kd_sound_helper(struct input_handle *handle, void *data)
235 unsigned int *hz = data;
236 struct input_dev *dev = handle->dev;
238 if (test_bit(EV_SND, dev->evbit)) {
239 if (test_bit(SND_TONE, dev->sndbit)) {
240 input_inject_event(handle, EV_SND, SND_TONE, *hz);
244 if (test_bit(SND_BELL, dev->sndbit))
245 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
251 static void kd_nosound(unsigned long ignored)
253 static unsigned int zero;
255 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
258 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
260 void kd_mksound(unsigned int hz, unsigned int ticks)
262 del_timer_sync(&kd_mksound_timer);
264 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
267 mod_timer(&kd_mksound_timer, jiffies + ticks);
269 EXPORT_SYMBOL(kd_mksound);
272 * Setting the keyboard rate.
275 static int kbd_rate_helper(struct input_handle *handle, void *data)
277 struct input_dev *dev = handle->dev;
278 struct kbd_repeat *rpt = data;
280 if (test_bit(EV_REP, dev->evbit)) {
282 if (rpt[0].delay > 0)
283 input_inject_event(handle,
284 EV_REP, REP_DELAY, rpt[0].delay);
285 if (rpt[0].period > 0)
286 input_inject_event(handle,
287 EV_REP, REP_PERIOD, rpt[0].period);
289 rpt[1].delay = dev->rep[REP_DELAY];
290 rpt[1].period = dev->rep[REP_PERIOD];
296 int kbd_rate(struct kbd_repeat *rpt)
298 struct kbd_repeat data[2] = { *rpt };
300 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
301 *rpt = data[1]; /* Copy currently used settings */
309 static void put_queue(struct vc_data *vc, int ch)
311 tty_insert_flip_char(&vc->port, ch, 0);
312 tty_schedule_flip(&vc->port);
315 static void puts_queue(struct vc_data *vc, char *cp)
318 tty_insert_flip_char(&vc->port, *cp, 0);
321 tty_schedule_flip(&vc->port);
324 static void applkey(struct vc_data *vc, int key, char mode)
326 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
328 buf[1] = (mode ? 'O' : '[');
334 * Many other routines do put_queue, but I think either
335 * they produce ASCII, or they produce some user-assigned
336 * string, and in both cases we might assume that it is
339 static void to_utf8(struct vc_data *vc, uint c)
344 else if (c < 0x800) {
345 /* 110***** 10****** */
346 put_queue(vc, 0xc0 | (c >> 6));
347 put_queue(vc, 0x80 | (c & 0x3f));
348 } else if (c < 0x10000) {
349 if (c >= 0xD800 && c < 0xE000)
353 /* 1110**** 10****** 10****** */
354 put_queue(vc, 0xe0 | (c >> 12));
355 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
356 put_queue(vc, 0x80 | (c & 0x3f));
357 } else if (c < 0x110000) {
358 /* 11110*** 10****** 10****** 10****** */
359 put_queue(vc, 0xf0 | (c >> 18));
360 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
361 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
362 put_queue(vc, 0x80 | (c & 0x3f));
367 * Called after returning from RAW mode or when changing consoles - recompute
368 * shift_down[] and shift_state from key_down[] maybe called when keymap is
369 * undefined, so that shiftkey release is seen. The caller must hold the
373 static void do_compute_shiftstate(void)
375 unsigned int k, sym, val;
378 memset(shift_down, 0, sizeof(shift_down));
380 for_each_set_bit(k, key_down, min(NR_KEYS, KEY_CNT)) {
381 sym = U(key_maps[0][k]);
382 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
386 if (val == KVAL(K_CAPSSHIFT))
390 shift_state |= BIT(val);
394 /* We still have to export this method to vt.c */
395 void compute_shiftstate(void)
398 spin_lock_irqsave(&kbd_event_lock, flags);
399 do_compute_shiftstate();
400 spin_unlock_irqrestore(&kbd_event_lock, flags);
404 * We have a combining character DIACR here, followed by the character CH.
405 * If the combination occurs in the table, return the corresponding value.
406 * Otherwise, if CH is a space or equals DIACR, return DIACR.
407 * Otherwise, conclude that DIACR was not combining after all,
408 * queue it and return CH.
410 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
412 unsigned int d = diacr;
417 if ((d & ~0xff) == BRL_UC_ROW) {
418 if ((ch & ~0xff) == BRL_UC_ROW)
421 for (i = 0; i < accent_table_size; i++)
422 if (accent_table[i].diacr == d && accent_table[i].base == ch)
423 return accent_table[i].result;
426 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
429 if (kbd->kbdmode == VC_UNICODE)
432 int c = conv_uni_to_8bit(d);
441 * Special function handlers
443 static void fn_enter(struct vc_data *vc)
446 if (kbd->kbdmode == VC_UNICODE)
449 int c = conv_uni_to_8bit(diacr);
457 if (vc_kbd_mode(kbd, VC_CRLF))
461 static void fn_caps_toggle(struct vc_data *vc)
466 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
469 static void fn_caps_on(struct vc_data *vc)
474 set_vc_kbd_led(kbd, VC_CAPSLOCK);
477 static void fn_show_ptregs(struct vc_data *vc)
479 struct pt_regs *regs = get_irq_regs();
485 static void fn_hold(struct vc_data *vc)
487 struct tty_struct *tty = vc->port.tty;
493 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
494 * these routines are also activated by ^S/^Q.
495 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
503 static void fn_num(struct vc_data *vc)
505 if (vc_kbd_mode(kbd, VC_APPLIC))
512 * Bind this to Shift-NumLock if you work in application keypad mode
513 * but want to be able to change the NumLock flag.
514 * Bind this to NumLock if you prefer that the NumLock key always
515 * changes the NumLock flag.
517 static void fn_bare_num(struct vc_data *vc)
520 chg_vc_kbd_led(kbd, VC_NUMLOCK);
523 static void fn_lastcons(struct vc_data *vc)
525 /* switch to the last used console, ChN */
526 set_console(last_console);
529 static void fn_dec_console(struct vc_data *vc)
531 int i, cur = fg_console;
533 /* Currently switching? Queue this next switch relative to that. */
534 if (want_console != -1)
537 for (i = cur - 1; i != cur; i--) {
539 i = MAX_NR_CONSOLES - 1;
540 if (vc_cons_allocated(i))
546 static void fn_inc_console(struct vc_data *vc)
548 int i, cur = fg_console;
550 /* Currently switching? Queue this next switch relative to that. */
551 if (want_console != -1)
554 for (i = cur+1; i != cur; i++) {
555 if (i == MAX_NR_CONSOLES)
557 if (vc_cons_allocated(i))
563 static void fn_send_intr(struct vc_data *vc)
565 tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
566 tty_schedule_flip(&vc->port);
569 static void fn_scroll_forw(struct vc_data *vc)
574 static void fn_scroll_back(struct vc_data *vc)
579 static void fn_show_mem(struct vc_data *vc)
584 static void fn_show_state(struct vc_data *vc)
589 static void fn_boot_it(struct vc_data *vc)
594 static void fn_compose(struct vc_data *vc)
596 dead_key_next = true;
599 static void fn_spawn_con(struct vc_data *vc)
601 spin_lock(&vt_spawn_con.lock);
602 if (vt_spawn_con.pid)
603 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
604 put_pid(vt_spawn_con.pid);
605 vt_spawn_con.pid = NULL;
607 spin_unlock(&vt_spawn_con.lock);
610 static void fn_SAK(struct vc_data *vc)
612 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
613 schedule_work(SAK_work);
616 static void fn_null(struct vc_data *vc)
618 do_compute_shiftstate();
622 * Special key handlers
624 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
628 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
632 if (value >= ARRAY_SIZE(fn_handler))
634 if ((kbd->kbdmode == VC_RAW ||
635 kbd->kbdmode == VC_MEDIUMRAW ||
636 kbd->kbdmode == VC_OFF) &&
637 value != KVAL(K_SAK))
638 return; /* SAK is allowed even in raw mode */
639 fn_handler[value](vc);
642 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
644 pr_err("k_lowercase was called - impossible\n");
647 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
650 return; /* no action, if this is a key release */
653 value = handle_diacr(vc, value);
656 dead_key_next = false;
660 if (kbd->kbdmode == VC_UNICODE)
663 int c = conv_uni_to_8bit(value);
670 * Handle dead key. Note that we now may have several
671 * dead keys modifying the same character. Very useful
674 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
679 diacr = (diacr ? handle_diacr(vc, value) : value);
682 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
684 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
687 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
689 k_deadunicode(vc, value, up_flag);
693 * Obsolete - for backwards compatibility only
695 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
697 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
699 k_deadunicode(vc, ret_diacr[value], up_flag);
702 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
710 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
715 if ((unsigned)value < ARRAY_SIZE(func_table)) {
718 spin_lock_irqsave(&func_buf_lock, flags);
719 if (func_table[value])
720 puts_queue(vc, func_table[value]);
721 spin_unlock_irqrestore(&func_buf_lock, flags);
724 pr_err("k_fn called with value=%d\n", value);
727 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
729 static const char cur_chars[] = "BDCA";
734 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
737 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
739 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
740 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
743 return; /* no action, if this is a key release */
745 /* kludge... shift forces cursor/number keys */
746 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
747 applkey(vc, app_map[value], 1);
751 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
756 k_fn(vc, KVAL(K_REMOVE), 0);
759 k_fn(vc, KVAL(K_INSERT), 0);
762 k_fn(vc, KVAL(K_SELECT), 0);
765 k_cur(vc, KVAL(K_DOWN), 0);
768 k_fn(vc, KVAL(K_PGDN), 0);
771 k_cur(vc, KVAL(K_LEFT), 0);
774 k_cur(vc, KVAL(K_RIGHT), 0);
777 k_fn(vc, KVAL(K_FIND), 0);
780 k_cur(vc, KVAL(K_UP), 0);
783 k_fn(vc, KVAL(K_PGUP), 0);
786 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
791 put_queue(vc, pad_chars[value]);
792 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
796 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
798 int old_state = shift_state;
804 * a CapsShift key acts like Shift but undoes CapsLock
806 if (value == KVAL(K_CAPSSHIFT)) {
807 value = KVAL(K_SHIFT);
809 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
814 * handle the case that two shift or control
815 * keys are depressed simultaneously
817 if (shift_down[value])
822 if (shift_down[value])
823 shift_state |= (1 << value);
825 shift_state &= ~(1 << value);
828 if (up_flag && shift_state != old_state && npadch_active) {
829 if (kbd->kbdmode == VC_UNICODE)
830 to_utf8(vc, npadch_value);
832 put_queue(vc, npadch_value & 0xff);
833 npadch_active = false;
837 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
842 if (vc_kbd_mode(kbd, VC_META)) {
843 put_queue(vc, '\033');
844 put_queue(vc, value);
846 put_queue(vc, value | 0x80);
849 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
857 /* decimal input of code, while Alt depressed */
860 /* hexadecimal input of code, while AltGr depressed */
865 if (!npadch_active) {
867 npadch_active = true;
870 npadch_value = npadch_value * base + value;
873 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
878 chg_vc_kbd_lock(kbd, value);
881 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
883 k_shift(vc, value, up_flag);
887 chg_vc_kbd_slock(kbd, value);
888 /* try to make Alt, oops, AltGr and such work */
889 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
891 chg_vc_kbd_slock(kbd, value);
895 /* by default, 300ms interval for combination release */
896 static unsigned brl_timeout = 300;
897 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
898 module_param(brl_timeout, uint, 0644);
900 static unsigned brl_nbchords = 1;
901 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
902 module_param(brl_nbchords, uint, 0644);
904 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
906 static unsigned long chords;
907 static unsigned committed;
910 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
912 committed |= pattern;
914 if (chords == brl_nbchords) {
915 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
922 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
924 static unsigned pressed, committing;
925 static unsigned long releasestart;
927 if (kbd->kbdmode != VC_UNICODE) {
929 pr_warn("keyboard mode must be unicode for braille patterns\n");
934 k_unicode(vc, BRL_UC_ROW, up_flag);
942 pressed |= 1 << (value - 1);
944 committing = pressed;
945 } else if (brl_timeout) {
948 releasestart + msecs_to_jiffies(brl_timeout))) {
949 committing = pressed;
950 releasestart = jiffies;
952 pressed &= ~(1 << (value - 1));
953 if (!pressed && committing) {
954 k_brlcommit(vc, committing, 0);
959 k_brlcommit(vc, committing, 0);
962 pressed &= ~(1 << (value - 1));
966 #if IS_ENABLED(CONFIG_INPUT_LEDS) && IS_ENABLED(CONFIG_LEDS_TRIGGERS)
968 struct kbd_led_trigger {
969 struct led_trigger trigger;
973 static void kbd_led_trigger_activate(struct led_classdev *cdev)
975 struct kbd_led_trigger *trigger =
976 container_of(cdev->trigger, struct kbd_led_trigger, trigger);
978 tasklet_disable(&keyboard_tasklet);
980 led_trigger_event(&trigger->trigger,
981 ledstate & trigger->mask ?
983 tasklet_enable(&keyboard_tasklet);
986 #define KBD_LED_TRIGGER(_led_bit, _name) { \
989 .activate = kbd_led_trigger_activate, \
991 .mask = BIT(_led_bit), \
994 #define KBD_LOCKSTATE_TRIGGER(_led_bit, _name) \
995 KBD_LED_TRIGGER((_led_bit) + 8, _name)
997 static struct kbd_led_trigger kbd_led_triggers[] = {
998 KBD_LED_TRIGGER(VC_SCROLLOCK, "kbd-scrolllock"),
999 KBD_LED_TRIGGER(VC_NUMLOCK, "kbd-numlock"),
1000 KBD_LED_TRIGGER(VC_CAPSLOCK, "kbd-capslock"),
1001 KBD_LED_TRIGGER(VC_KANALOCK, "kbd-kanalock"),
1003 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLOCK, "kbd-shiftlock"),
1004 KBD_LOCKSTATE_TRIGGER(VC_ALTGRLOCK, "kbd-altgrlock"),
1005 KBD_LOCKSTATE_TRIGGER(VC_CTRLLOCK, "kbd-ctrllock"),
1006 KBD_LOCKSTATE_TRIGGER(VC_ALTLOCK, "kbd-altlock"),
1007 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLLOCK, "kbd-shiftllock"),
1008 KBD_LOCKSTATE_TRIGGER(VC_SHIFTRLOCK, "kbd-shiftrlock"),
1009 KBD_LOCKSTATE_TRIGGER(VC_CTRLLLOCK, "kbd-ctrlllock"),
1010 KBD_LOCKSTATE_TRIGGER(VC_CTRLRLOCK, "kbd-ctrlrlock"),
1013 static void kbd_propagate_led_state(unsigned int old_state,
1014 unsigned int new_state)
1016 struct kbd_led_trigger *trigger;
1017 unsigned int changed = old_state ^ new_state;
1020 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1021 trigger = &kbd_led_triggers[i];
1023 if (changed & trigger->mask)
1024 led_trigger_event(&trigger->trigger,
1025 new_state & trigger->mask ?
1026 LED_FULL : LED_OFF);
1030 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1032 unsigned int led_state = *(unsigned int *)data;
1034 if (test_bit(EV_LED, handle->dev->evbit))
1035 kbd_propagate_led_state(~led_state, led_state);
1040 static void kbd_init_leds(void)
1045 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1046 error = led_trigger_register(&kbd_led_triggers[i].trigger);
1048 pr_err("error %d while registering trigger %s\n",
1049 error, kbd_led_triggers[i].trigger.name);
1055 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1057 unsigned int leds = *(unsigned int *)data;
1059 if (test_bit(EV_LED, handle->dev->evbit)) {
1060 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1061 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1062 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1063 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1069 static void kbd_propagate_led_state(unsigned int old_state,
1070 unsigned int new_state)
1072 input_handler_for_each_handle(&kbd_handler, &new_state,
1073 kbd_update_leds_helper);
1076 static void kbd_init_leds(void)
1083 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
1084 * or (ii) whatever pattern of lights people want to show using KDSETLED,
1085 * or (iii) specified bits of specified words in kernel memory.
1087 static unsigned char getledstate(void)
1089 return ledstate & 0xff;
1092 void setledstate(struct kbd_struct *kb, unsigned int led)
1094 unsigned long flags;
1095 spin_lock_irqsave(&led_lock, flags);
1098 kb->ledmode = LED_SHOW_IOCTL;
1100 kb->ledmode = LED_SHOW_FLAGS;
1103 spin_unlock_irqrestore(&led_lock, flags);
1106 static inline unsigned char getleds(void)
1108 struct kbd_struct *kb = kbd_table + fg_console;
1110 if (kb->ledmode == LED_SHOW_IOCTL)
1113 return kb->ledflagstate;
1117 * vt_get_leds - helper for braille console
1118 * @console: console to read
1119 * @flag: flag we want to check
1121 * Check the status of a keyboard led flag and report it back
1123 int vt_get_leds(int console, int flag)
1125 struct kbd_struct *kb = kbd_table + console;
1127 unsigned long flags;
1129 spin_lock_irqsave(&led_lock, flags);
1130 ret = vc_kbd_led(kb, flag);
1131 spin_unlock_irqrestore(&led_lock, flags);
1135 EXPORT_SYMBOL_GPL(vt_get_leds);
1138 * vt_set_led_state - set LED state of a console
1139 * @console: console to set
1142 * Set the LEDs on a console. This is a wrapper for the VT layer
1143 * so that we can keep kbd knowledge internal
1145 void vt_set_led_state(int console, int leds)
1147 struct kbd_struct *kb = kbd_table + console;
1148 setledstate(kb, leds);
1152 * vt_kbd_con_start - Keyboard side of console start
1155 * Handle console start. This is a wrapper for the VT layer
1156 * so that we can keep kbd knowledge internal
1158 * FIXME: We eventually need to hold the kbd lock here to protect
1159 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1160 * and start_tty under the kbd_event_lock, while normal tty paths
1161 * don't hold the lock. We probably need to split out an LED lock
1162 * but not during an -rc release!
1164 void vt_kbd_con_start(int console)
1166 struct kbd_struct *kb = kbd_table + console;
1167 unsigned long flags;
1168 spin_lock_irqsave(&led_lock, flags);
1169 clr_vc_kbd_led(kb, VC_SCROLLOCK);
1171 spin_unlock_irqrestore(&led_lock, flags);
1175 * vt_kbd_con_stop - Keyboard side of console stop
1178 * Handle console stop. This is a wrapper for the VT layer
1179 * so that we can keep kbd knowledge internal
1181 void vt_kbd_con_stop(int console)
1183 struct kbd_struct *kb = kbd_table + console;
1184 unsigned long flags;
1185 spin_lock_irqsave(&led_lock, flags);
1186 set_vc_kbd_led(kb, VC_SCROLLOCK);
1188 spin_unlock_irqrestore(&led_lock, flags);
1192 * This is the tasklet that updates LED state of LEDs using standard
1193 * keyboard triggers. The reason we use tasklet is that we need to
1194 * handle the scenario when keyboard handler is not registered yet
1195 * but we already getting updates from the VT to update led state.
1197 static void kbd_bh(unsigned long dummy)
1200 unsigned long flags;
1202 spin_lock_irqsave(&led_lock, flags);
1204 leds |= (unsigned int)kbd->lockstate << 8;
1205 spin_unlock_irqrestore(&led_lock, flags);
1207 if (leds != ledstate) {
1208 kbd_propagate_led_state(ledstate, leds);
1213 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1215 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1216 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1217 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1218 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
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)
1710 dia = memdup_user(a->kbdiacr,
1711 sizeof(struct kbdiacr) * ct);
1713 return PTR_ERR(dia);
1717 spin_lock_irqsave(&kbd_event_lock, flags);
1718 accent_table_size = ct;
1719 for (i = 0; i < ct; i++) {
1720 accent_table[i].diacr =
1721 conv_8bit_to_uni(dia[i].diacr);
1722 accent_table[i].base =
1723 conv_8bit_to_uni(dia[i].base);
1724 accent_table[i].result =
1725 conv_8bit_to_uni(dia[i].result);
1727 spin_unlock_irqrestore(&kbd_event_lock, flags);
1734 struct kbdiacrsuc __user *a = udp;
1741 if (get_user(ct, &a->kb_cnt))
1744 if (ct >= MAX_DIACR)
1748 buf = memdup_user(a->kbdiacruc,
1749 ct * sizeof(struct kbdiacruc));
1751 return PTR_ERR(buf);
1753 spin_lock_irqsave(&kbd_event_lock, flags);
1755 memcpy(accent_table, buf,
1756 ct * sizeof(struct kbdiacruc));
1757 accent_table_size = ct;
1758 spin_unlock_irqrestore(&kbd_event_lock, flags);
1767 * vt_do_kdskbmode - set keyboard mode ioctl
1768 * @console: the console to use
1769 * @arg: the requested mode
1771 * Update the keyboard mode bits while holding the correct locks.
1772 * Return 0 for success or an error code.
1774 int vt_do_kdskbmode(int console, unsigned int arg)
1776 struct kbd_struct *kb = kbd_table + console;
1778 unsigned long flags;
1780 spin_lock_irqsave(&kbd_event_lock, flags);
1783 kb->kbdmode = VC_RAW;
1786 kb->kbdmode = VC_MEDIUMRAW;
1789 kb->kbdmode = VC_XLATE;
1790 do_compute_shiftstate();
1793 kb->kbdmode = VC_UNICODE;
1794 do_compute_shiftstate();
1797 kb->kbdmode = VC_OFF;
1802 spin_unlock_irqrestore(&kbd_event_lock, flags);
1807 * vt_do_kdskbmeta - set keyboard meta state
1808 * @console: the console to use
1809 * @arg: the requested meta state
1811 * Update the keyboard meta bits while holding the correct locks.
1812 * Return 0 for success or an error code.
1814 int vt_do_kdskbmeta(int console, unsigned int arg)
1816 struct kbd_struct *kb = kbd_table + console;
1818 unsigned long flags;
1820 spin_lock_irqsave(&kbd_event_lock, flags);
1823 clr_vc_kbd_mode(kb, VC_META);
1826 set_vc_kbd_mode(kb, VC_META);
1831 spin_unlock_irqrestore(&kbd_event_lock, flags);
1835 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1838 struct kbkeycode tmp;
1841 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1845 kc = getkeycode(tmp.scancode);
1847 kc = put_user(kc, &user_kbkc->keycode);
1852 kc = setkeycode(tmp.scancode, tmp.keycode);
1858 #define i (tmp.kb_index)
1859 #define s (tmp.kb_table)
1860 #define v (tmp.kb_value)
1862 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1865 struct kbd_struct *kb = kbd_table + console;
1867 ushort *key_map, *new_map, val, ov;
1868 unsigned long flags;
1870 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1873 if (!capable(CAP_SYS_TTY_CONFIG))
1878 /* Ensure another thread doesn't free it under us */
1879 spin_lock_irqsave(&kbd_event_lock, flags);
1880 key_map = key_maps[s];
1882 val = U(key_map[i]);
1883 if (kb->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1886 val = (i ? K_HOLE : K_NOSUCHMAP);
1887 spin_unlock_irqrestore(&kbd_event_lock, flags);
1888 return put_user(val, &user_kbe->kb_value);
1892 if (!i && v == K_NOSUCHMAP) {
1893 spin_lock_irqsave(&kbd_event_lock, flags);
1894 /* deallocate map */
1895 key_map = key_maps[s];
1898 if (key_map[0] == U(K_ALLOCATED)) {
1903 spin_unlock_irqrestore(&kbd_event_lock, flags);
1907 if (KTYP(v) < NR_TYPES) {
1908 if (KVAL(v) > max_vals[KTYP(v)])
1911 if (kb->kbdmode != VC_UNICODE)
1914 /* ++Geert: non-PC keyboards may generate keycode zero */
1915 #if !defined(__mc68000__) && !defined(__powerpc__)
1916 /* assignment to entry 0 only tests validity of args */
1921 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1924 spin_lock_irqsave(&kbd_event_lock, flags);
1925 key_map = key_maps[s];
1926 if (key_map == NULL) {
1929 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1930 !capable(CAP_SYS_RESOURCE)) {
1931 spin_unlock_irqrestore(&kbd_event_lock, flags);
1935 key_maps[s] = new_map;
1937 key_map[0] = U(K_ALLOCATED);
1938 for (j = 1; j < NR_KEYS; j++)
1939 key_map[j] = U(K_HOLE);
1950 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1951 spin_unlock_irqrestore(&kbd_event_lock, flags);
1955 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1956 do_compute_shiftstate();
1958 spin_unlock_irqrestore(&kbd_event_lock, flags);
1967 /* FIXME: This one needs untangling */
1968 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1970 struct kbsentry *kbs;
1974 char *first_free, *fj, *fnw;
1977 unsigned long flags;
1979 if (!capable(CAP_SYS_TTY_CONFIG))
1982 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
1988 /* we mostly copy too much here (512bytes), but who cares ;) */
1989 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
1993 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
1998 /* size should have been a struct member */
1999 ssize_t len = sizeof(user_kdgkb->kb_string);
2001 spin_lock_irqsave(&func_buf_lock, flags);
2002 len = strlcpy(kbs->kb_string, func_table[i] ? : "", len);
2003 spin_unlock_irqrestore(&func_buf_lock, flags);
2005 ret = copy_to_user(user_kdgkb->kb_string, kbs->kb_string,
2006 len + 1) ? -EFAULT : 0;
2018 /* race aginst other writers */
2020 spin_lock_irqsave(&func_buf_lock, flags);
2023 /* fj pointer to next entry after 'q' */
2024 first_free = funcbufptr + (funcbufsize - funcbufleft);
2025 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
2027 if (j < MAX_NR_FUNC)
2031 /* buffer usage increase by new entry */
2032 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
2034 if (delta <= funcbufleft) { /* it fits in current buf */
2035 if (j < MAX_NR_FUNC) {
2036 /* make enough space for new entry at 'fj' */
2037 memmove(fj + delta, fj, first_free - fj);
2038 for (k = j; k < MAX_NR_FUNC; k++)
2040 func_table[k] += delta;
2044 funcbufleft -= delta;
2045 } else { /* allocate a larger buffer */
2047 while (sz < funcbufsize - funcbufleft + delta)
2050 spin_unlock_irqrestore(&func_buf_lock, flags);
2052 fnw = kmalloc(sz, GFP_KERNEL);
2063 /* copy data before insertion point to new location */
2064 if (fj > funcbufptr)
2065 memmove(fnw, funcbufptr, fj - funcbufptr);
2066 for (k = 0; k < j; k++)
2068 func_table[k] = fnw + (func_table[k] - funcbufptr);
2070 /* copy data after insertion point to new location */
2071 if (first_free > fj) {
2072 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
2073 for (k = j; k < MAX_NR_FUNC; k++)
2075 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
2077 if (funcbufptr != func_buf)
2080 funcbufleft = funcbufleft - delta + sz - funcbufsize;
2083 /* finally insert item itself */
2084 strcpy(func_table[i], kbs->kb_string);
2085 spin_unlock_irqrestore(&func_buf_lock, flags);
2094 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2096 struct kbd_struct *kb = kbd_table + console;
2097 unsigned long flags;
2098 unsigned char ucval;
2101 /* the ioctls below read/set the flags usually shown in the leds */
2102 /* don't use them - they will go away without warning */
2104 spin_lock_irqsave(&kbd_event_lock, flags);
2105 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2106 spin_unlock_irqrestore(&kbd_event_lock, flags);
2107 return put_user(ucval, (char __user *)arg);
2114 spin_lock_irqsave(&led_lock, flags);
2115 kb->ledflagstate = (arg & 7);
2116 kb->default_ledflagstate = ((arg >> 4) & 7);
2118 spin_unlock_irqrestore(&led_lock, flags);
2121 /* the ioctls below only set the lights, not the functions */
2122 /* for those, see KDGKBLED and KDSKBLED above */
2124 ucval = getledstate();
2125 return put_user(ucval, (char __user *)arg);
2130 setledstate(kb, arg);
2133 return -ENOIOCTLCMD;
2136 int vt_do_kdgkbmode(int console)
2138 struct kbd_struct *kb = kbd_table + console;
2139 /* This is a spot read so needs no locking */
2140 switch (kb->kbdmode) {
2155 * vt_do_kdgkbmeta - report meta status
2156 * @console: console to report
2158 * Report the meta flag status of this console
2160 int vt_do_kdgkbmeta(int console)
2162 struct kbd_struct *kb = kbd_table + console;
2163 /* Again a spot read so no locking */
2164 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2168 * vt_reset_unicode - reset the unicode status
2169 * @console: console being reset
2171 * Restore the unicode console state to its default
2173 void vt_reset_unicode(int console)
2175 unsigned long flags;
2177 spin_lock_irqsave(&kbd_event_lock, flags);
2178 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2179 spin_unlock_irqrestore(&kbd_event_lock, flags);
2183 * vt_get_shiftstate - shift bit state
2185 * Report the shift bits from the keyboard state. We have to export
2186 * this to support some oddities in the vt layer.
2188 int vt_get_shift_state(void)
2190 /* Don't lock as this is a transient report */
2195 * vt_reset_keyboard - reset keyboard state
2196 * @console: console to reset
2198 * Reset the keyboard bits for a console as part of a general console
2201 void vt_reset_keyboard(int console)
2203 struct kbd_struct *kb = kbd_table + console;
2204 unsigned long flags;
2206 spin_lock_irqsave(&kbd_event_lock, flags);
2207 set_vc_kbd_mode(kb, VC_REPEAT);
2208 clr_vc_kbd_mode(kb, VC_CKMODE);
2209 clr_vc_kbd_mode(kb, VC_APPLIC);
2210 clr_vc_kbd_mode(kb, VC_CRLF);
2213 spin_lock(&led_lock);
2214 kb->ledmode = LED_SHOW_FLAGS;
2215 kb->ledflagstate = kb->default_ledflagstate;
2216 spin_unlock(&led_lock);
2217 /* do not do set_leds here because this causes an endless tasklet loop
2218 when the keyboard hasn't been initialized yet */
2219 spin_unlock_irqrestore(&kbd_event_lock, flags);
2223 * vt_get_kbd_mode_bit - read keyboard status bits
2224 * @console: console to read from
2225 * @bit: mode bit to read
2227 * Report back a vt mode bit. We do this without locking so the
2228 * caller must be sure that there are no synchronization needs
2231 int vt_get_kbd_mode_bit(int console, int bit)
2233 struct kbd_struct *kb = kbd_table + console;
2234 return vc_kbd_mode(kb, bit);
2238 * vt_set_kbd_mode_bit - read keyboard status bits
2239 * @console: console to read from
2240 * @bit: mode bit to read
2242 * Set a vt mode bit. We do this without locking so the
2243 * caller must be sure that there are no synchronization needs
2246 void vt_set_kbd_mode_bit(int console, int bit)
2248 struct kbd_struct *kb = kbd_table + console;
2249 unsigned long flags;
2251 spin_lock_irqsave(&kbd_event_lock, flags);
2252 set_vc_kbd_mode(kb, bit);
2253 spin_unlock_irqrestore(&kbd_event_lock, flags);
2257 * vt_clr_kbd_mode_bit - read keyboard status bits
2258 * @console: console to read from
2259 * @bit: mode bit to read
2261 * Report back a vt mode bit. We do this without locking so the
2262 * caller must be sure that there are no synchronization needs
2265 void vt_clr_kbd_mode_bit(int console, int bit)
2267 struct kbd_struct *kb = kbd_table + console;
2268 unsigned long flags;
2270 spin_lock_irqsave(&kbd_event_lock, flags);
2271 clr_vc_kbd_mode(kb, bit);
2272 spin_unlock_irqrestore(&kbd_event_lock, flags);