1 // SPDX-License-Identifier: GPL-2.0
3 * Written for linux by Johan Myreen as a translation from
4 * the assembly version by Linus (with diacriticals added)
6 * Some additional features added by Christoph Niemann (ChN), March 1993
8 * Loadable keymaps by Risto Kankkunen, May 1993
10 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
11 * Added decr/incr_console, dynamic keymaps, Unicode support,
12 * dynamic function/string keys, led setting, Sept 1994
13 * `Sticky' modifier keys, 951006.
15 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
17 * Modified to provide 'generic' keyboard support by Hamish Macdonald
18 * Merge with the m68k keyboard driver and split-off of the PC low-level
19 * parts by Geert Uytterhoeven, May 1997
21 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
22 * 30-07-98: Dead keys redone, aeb@cwi.nl.
23 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28 #include <linux/consolemap.h>
29 #include <linux/module.h>
30 #include <linux/sched/signal.h>
31 #include <linux/sched/debug.h>
32 #include <linux/tty.h>
33 #include <linux/tty_flip.h>
35 #include <linux/string.h>
36 #include <linux/init.h>
37 #include <linux/slab.h>
38 #include <linux/leds.h>
40 #include <linux/kbd_kern.h>
41 #include <linux/kbd_diacr.h>
42 #include <linux/vt_kern.h>
43 #include <linux/input.h>
44 #include <linux/reboot.h>
45 #include <linux/notifier.h>
46 #include <linux/jiffies.h>
47 #include <linux/uaccess.h>
49 #include <asm/irq_regs.h>
51 extern void ctrl_alt_del(void);
54 * Exported functions/variables
57 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
59 #if defined(CONFIG_X86) || defined(CONFIG_PARISC)
60 #include <asm/kbdleds.h>
62 static inline int kbd_defleds(void)
75 k_self, k_fn, k_spec, k_pad,\
76 k_dead, k_cons, k_cur, k_shift,\
77 k_meta, k_ascii, k_lock, k_lowercase,\
78 k_slock, k_dead2, k_brl, k_ignore
80 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
82 static k_handler_fn K_HANDLERS;
83 static k_handler_fn *k_handler[16] = { K_HANDLERS };
86 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
87 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
88 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
89 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
90 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
92 typedef void (fn_handler_fn)(struct vc_data *vc);
93 static fn_handler_fn FN_HANDLERS;
94 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
97 * Variables exported for vt_ioctl.c
100 struct vt_spawn_console vt_spawn_con = {
101 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
111 static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
112 static struct kbd_struct *kbd = kbd_table;
114 /* maximum values each key_handler can handle */
115 static const int max_vals[] = {
116 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
117 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
118 255, NR_LOCK - 1, 255, NR_BRL - 1
121 static const int NR_TYPES = ARRAY_SIZE(max_vals);
123 static struct input_handler kbd_handler;
124 static DEFINE_SPINLOCK(kbd_event_lock);
125 static DEFINE_SPINLOCK(led_lock);
126 static DEFINE_SPINLOCK(func_buf_lock); /* guard 'func_buf' and friends */
127 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
128 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
129 static bool dead_key_next;
131 /* Handles a number being assembled on the number pad */
132 static bool npadch_active;
133 static unsigned int npadch_value;
135 static unsigned int diacr;
136 static char rep; /* flag telling character repeat */
138 static int shift_state = 0;
140 static unsigned int ledstate = -1U; /* undefined */
141 static unsigned char ledioctl;
144 * Notifier list for console keyboard events
146 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
148 int register_keyboard_notifier(struct notifier_block *nb)
150 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
152 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
154 int unregister_keyboard_notifier(struct notifier_block *nb)
156 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
158 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
161 * Translation of scancodes to keycodes. We set them on only the first
162 * keyboard in the list that accepts the scancode and keycode.
163 * Explanation for not choosing the first attached keyboard anymore:
164 * USB keyboards for example have two event devices: one for all "normal"
165 * keys and one for extra function keys (like "volume up", "make coffee",
166 * etc.). So this means that scancodes for the extra function keys won't
167 * be valid for the first event device, but will be for the second.
170 struct getset_keycode_data {
171 struct input_keymap_entry ke;
175 static int getkeycode_helper(struct input_handle *handle, void *data)
177 struct getset_keycode_data *d = data;
179 d->error = input_get_keycode(handle->dev, &d->ke);
181 return d->error == 0; /* stop as soon as we successfully get one */
184 static int getkeycode(unsigned int scancode)
186 struct getset_keycode_data d = {
189 .len = sizeof(scancode),
195 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
197 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
199 return d.error ?: d.ke.keycode;
202 static int setkeycode_helper(struct input_handle *handle, void *data)
204 struct getset_keycode_data *d = data;
206 d->error = input_set_keycode(handle->dev, &d->ke);
208 return d->error == 0; /* stop as soon as we successfully set one */
211 static int setkeycode(unsigned int scancode, unsigned int keycode)
213 struct getset_keycode_data d = {
216 .len = sizeof(scancode),
222 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
224 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
230 * Making beeps and bells. Note that we prefer beeps to bells, but when
231 * shutting the sound off we do both.
234 static int kd_sound_helper(struct input_handle *handle, void *data)
236 unsigned int *hz = data;
237 struct input_dev *dev = handle->dev;
239 if (test_bit(EV_SND, dev->evbit)) {
240 if (test_bit(SND_TONE, dev->sndbit)) {
241 input_inject_event(handle, EV_SND, SND_TONE, *hz);
245 if (test_bit(SND_BELL, dev->sndbit))
246 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
252 static void kd_nosound(struct timer_list *unused)
254 static unsigned int zero;
256 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
259 static DEFINE_TIMER(kd_mksound_timer, kd_nosound);
261 void kd_mksound(unsigned int hz, unsigned int ticks)
263 del_timer_sync(&kd_mksound_timer);
265 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
268 mod_timer(&kd_mksound_timer, jiffies + ticks);
270 EXPORT_SYMBOL(kd_mksound);
273 * Setting the keyboard rate.
276 static int kbd_rate_helper(struct input_handle *handle, void *data)
278 struct input_dev *dev = handle->dev;
279 struct kbd_repeat *rpt = data;
281 if (test_bit(EV_REP, dev->evbit)) {
283 if (rpt[0].delay > 0)
284 input_inject_event(handle,
285 EV_REP, REP_DELAY, rpt[0].delay);
286 if (rpt[0].period > 0)
287 input_inject_event(handle,
288 EV_REP, REP_PERIOD, rpt[0].period);
290 rpt[1].delay = dev->rep[REP_DELAY];
291 rpt[1].period = dev->rep[REP_PERIOD];
297 int kbd_rate(struct kbd_repeat *rpt)
299 struct kbd_repeat data[2] = { *rpt };
301 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
302 *rpt = data[1]; /* Copy currently used settings */
310 static void put_queue(struct vc_data *vc, int ch)
312 tty_insert_flip_char(&vc->port, ch, 0);
313 tty_flip_buffer_push(&vc->port);
316 static void puts_queue(struct vc_data *vc, char *cp)
319 tty_insert_flip_char(&vc->port, *cp, 0);
322 tty_flip_buffer_push(&vc->port);
325 static void applkey(struct vc_data *vc, int key, char mode)
327 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
329 buf[1] = (mode ? 'O' : '[');
335 * Many other routines do put_queue, but I think either
336 * they produce ASCII, or they produce some user-assigned
337 * string, and in both cases we might assume that it is
340 static void to_utf8(struct vc_data *vc, uint c)
345 else if (c < 0x800) {
346 /* 110***** 10****** */
347 put_queue(vc, 0xc0 | (c >> 6));
348 put_queue(vc, 0x80 | (c & 0x3f));
349 } else if (c < 0x10000) {
350 if (c >= 0xD800 && c < 0xE000)
354 /* 1110**** 10****** 10****** */
355 put_queue(vc, 0xe0 | (c >> 12));
356 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
357 put_queue(vc, 0x80 | (c & 0x3f));
358 } else if (c < 0x110000) {
359 /* 11110*** 10****** 10****** 10****** */
360 put_queue(vc, 0xf0 | (c >> 18));
361 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
362 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
363 put_queue(vc, 0x80 | (c & 0x3f));
368 * Called after returning from RAW mode or when changing consoles - recompute
369 * shift_down[] and shift_state from key_down[] maybe called when keymap is
370 * undefined, so that shiftkey release is seen. The caller must hold the
374 static void do_compute_shiftstate(void)
376 unsigned int k, sym, val;
379 memset(shift_down, 0, sizeof(shift_down));
381 for_each_set_bit(k, key_down, min(NR_KEYS, KEY_CNT)) {
382 sym = U(key_maps[0][k]);
383 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
387 if (val == KVAL(K_CAPSSHIFT))
391 shift_state |= BIT(val);
395 /* We still have to export this method to vt.c */
396 void compute_shiftstate(void)
399 spin_lock_irqsave(&kbd_event_lock, flags);
400 do_compute_shiftstate();
401 spin_unlock_irqrestore(&kbd_event_lock, flags);
405 * We have a combining character DIACR here, followed by the character CH.
406 * If the combination occurs in the table, return the corresponding value.
407 * Otherwise, if CH is a space or equals DIACR, return DIACR.
408 * Otherwise, conclude that DIACR was not combining after all,
409 * queue it and return CH.
411 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
413 unsigned int d = diacr;
418 if ((d & ~0xff) == BRL_UC_ROW) {
419 if ((ch & ~0xff) == BRL_UC_ROW)
422 for (i = 0; i < accent_table_size; i++)
423 if (accent_table[i].diacr == d && accent_table[i].base == ch)
424 return accent_table[i].result;
427 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
430 if (kbd->kbdmode == VC_UNICODE)
433 int c = conv_uni_to_8bit(d);
442 * Special function handlers
444 static void fn_enter(struct vc_data *vc)
447 if (kbd->kbdmode == VC_UNICODE)
450 int c = conv_uni_to_8bit(diacr);
458 if (vc_kbd_mode(kbd, VC_CRLF))
462 static void fn_caps_toggle(struct vc_data *vc)
467 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
470 static void fn_caps_on(struct vc_data *vc)
475 set_vc_kbd_led(kbd, VC_CAPSLOCK);
478 static void fn_show_ptregs(struct vc_data *vc)
480 struct pt_regs *regs = get_irq_regs();
486 static void fn_hold(struct vc_data *vc)
488 struct tty_struct *tty = vc->port.tty;
494 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
495 * these routines are also activated by ^S/^Q.
496 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
504 static void fn_num(struct vc_data *vc)
506 if (vc_kbd_mode(kbd, VC_APPLIC))
513 * Bind this to Shift-NumLock if you work in application keypad mode
514 * but want to be able to change the NumLock flag.
515 * Bind this to NumLock if you prefer that the NumLock key always
516 * changes the NumLock flag.
518 static void fn_bare_num(struct vc_data *vc)
521 chg_vc_kbd_led(kbd, VC_NUMLOCK);
524 static void fn_lastcons(struct vc_data *vc)
526 /* switch to the last used console, ChN */
527 set_console(last_console);
530 static void fn_dec_console(struct vc_data *vc)
532 int i, cur = fg_console;
534 /* Currently switching? Queue this next switch relative to that. */
535 if (want_console != -1)
538 for (i = cur - 1; i != cur; i--) {
540 i = MAX_NR_CONSOLES - 1;
541 if (vc_cons_allocated(i))
547 static void fn_inc_console(struct vc_data *vc)
549 int i, cur = fg_console;
551 /* Currently switching? Queue this next switch relative to that. */
552 if (want_console != -1)
555 for (i = cur+1; i != cur; i++) {
556 if (i == MAX_NR_CONSOLES)
558 if (vc_cons_allocated(i))
564 static void fn_send_intr(struct vc_data *vc)
566 tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
567 tty_flip_buffer_push(&vc->port);
570 static void fn_scroll_forw(struct vc_data *vc)
575 static void fn_scroll_back(struct vc_data *vc)
580 static void fn_show_mem(struct vc_data *vc)
585 static void fn_show_state(struct vc_data *vc)
590 static void fn_boot_it(struct vc_data *vc)
595 static void fn_compose(struct vc_data *vc)
597 dead_key_next = true;
600 static void fn_spawn_con(struct vc_data *vc)
602 spin_lock(&vt_spawn_con.lock);
603 if (vt_spawn_con.pid)
604 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
605 put_pid(vt_spawn_con.pid);
606 vt_spawn_con.pid = NULL;
608 spin_unlock(&vt_spawn_con.lock);
611 static void fn_SAK(struct vc_data *vc)
613 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
614 schedule_work(SAK_work);
617 static void fn_null(struct vc_data *vc)
619 do_compute_shiftstate();
623 * Special key handlers
625 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
629 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
633 if (value >= ARRAY_SIZE(fn_handler))
635 if ((kbd->kbdmode == VC_RAW ||
636 kbd->kbdmode == VC_MEDIUMRAW ||
637 kbd->kbdmode == VC_OFF) &&
638 value != KVAL(K_SAK))
639 return; /* SAK is allowed even in raw mode */
640 fn_handler[value](vc);
643 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
645 pr_err("k_lowercase was called - impossible\n");
648 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
651 return; /* no action, if this is a key release */
654 value = handle_diacr(vc, value);
657 dead_key_next = false;
661 if (kbd->kbdmode == VC_UNICODE)
664 int c = conv_uni_to_8bit(value);
671 * Handle dead key. Note that we now may have several
672 * dead keys modifying the same character. Very useful
675 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
680 diacr = (diacr ? handle_diacr(vc, value) : value);
683 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
685 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
688 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
690 k_deadunicode(vc, value, up_flag);
694 * Obsolete - for backwards compatibility only
696 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
698 static const unsigned char ret_diacr[NR_DEAD] = {
699 '`', /* dead_grave */
700 '\'', /* dead_acute */
701 '^', /* dead_circumflex */
702 '~', /* dead_tilda */
703 '"', /* dead_diaeresis */
704 ',', /* dead_cedilla */
705 '_', /* dead_macron */
706 'U', /* dead_breve */
707 '.', /* dead_abovedot */
708 '*', /* dead_abovering */
709 '=', /* dead_doubleacute */
710 'c', /* dead_caron */
711 'k', /* dead_ogonek */
713 '#', /* dead_voiced_sound */
714 'o', /* dead_semivoiced_sound */
715 '!', /* dead_belowdot */
718 '-', /* dead_stroke */
719 ')', /* dead_abovecomma */
720 '(', /* dead_abovereversedcomma */
721 ':', /* dead_doublegrave */
722 'n', /* dead_invertedbreve */
723 ';', /* dead_belowcomma */
724 '$', /* dead_currency */
725 '@', /* dead_greek */
728 k_deadunicode(vc, ret_diacr[value], up_flag);
731 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
739 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
744 if ((unsigned)value < ARRAY_SIZE(func_table)) {
747 spin_lock_irqsave(&func_buf_lock, flags);
748 if (func_table[value])
749 puts_queue(vc, func_table[value]);
750 spin_unlock_irqrestore(&func_buf_lock, flags);
753 pr_err("k_fn called with value=%d\n", value);
756 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
758 static const char cur_chars[] = "BDCA";
763 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
766 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
768 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
769 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
772 return; /* no action, if this is a key release */
774 /* kludge... shift forces cursor/number keys */
775 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
776 applkey(vc, app_map[value], 1);
780 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
785 k_fn(vc, KVAL(K_REMOVE), 0);
788 k_fn(vc, KVAL(K_INSERT), 0);
791 k_fn(vc, KVAL(K_SELECT), 0);
794 k_cur(vc, KVAL(K_DOWN), 0);
797 k_fn(vc, KVAL(K_PGDN), 0);
800 k_cur(vc, KVAL(K_LEFT), 0);
803 k_cur(vc, KVAL(K_RIGHT), 0);
806 k_fn(vc, KVAL(K_FIND), 0);
809 k_cur(vc, KVAL(K_UP), 0);
812 k_fn(vc, KVAL(K_PGUP), 0);
815 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
820 put_queue(vc, pad_chars[value]);
821 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
825 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
827 int old_state = shift_state;
833 * a CapsShift key acts like Shift but undoes CapsLock
835 if (value == KVAL(K_CAPSSHIFT)) {
836 value = KVAL(K_SHIFT);
838 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
843 * handle the case that two shift or control
844 * keys are depressed simultaneously
846 if (shift_down[value])
851 if (shift_down[value])
852 shift_state |= (1 << value);
854 shift_state &= ~(1 << value);
857 if (up_flag && shift_state != old_state && npadch_active) {
858 if (kbd->kbdmode == VC_UNICODE)
859 to_utf8(vc, npadch_value);
861 put_queue(vc, npadch_value & 0xff);
862 npadch_active = false;
866 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
871 if (vc_kbd_mode(kbd, VC_META)) {
872 put_queue(vc, '\033');
873 put_queue(vc, value);
875 put_queue(vc, value | 0x80);
878 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
886 /* decimal input of code, while Alt depressed */
889 /* hexadecimal input of code, while AltGr depressed */
894 if (!npadch_active) {
896 npadch_active = true;
899 npadch_value = npadch_value * base + value;
902 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
907 chg_vc_kbd_lock(kbd, value);
910 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
912 k_shift(vc, value, up_flag);
916 chg_vc_kbd_slock(kbd, value);
917 /* try to make Alt, oops, AltGr and such work */
918 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
920 chg_vc_kbd_slock(kbd, value);
924 /* by default, 300ms interval for combination release */
925 static unsigned brl_timeout = 300;
926 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
927 module_param(brl_timeout, uint, 0644);
929 static unsigned brl_nbchords = 1;
930 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
931 module_param(brl_nbchords, uint, 0644);
933 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
935 static unsigned long chords;
936 static unsigned committed;
939 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
941 committed |= pattern;
943 if (chords == brl_nbchords) {
944 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
951 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
953 static unsigned pressed, committing;
954 static unsigned long releasestart;
956 if (kbd->kbdmode != VC_UNICODE) {
958 pr_warn("keyboard mode must be unicode for braille patterns\n");
963 k_unicode(vc, BRL_UC_ROW, up_flag);
971 pressed |= 1 << (value - 1);
973 committing = pressed;
974 } else if (brl_timeout) {
977 releasestart + msecs_to_jiffies(brl_timeout))) {
978 committing = pressed;
979 releasestart = jiffies;
981 pressed &= ~(1 << (value - 1));
982 if (!pressed && committing) {
983 k_brlcommit(vc, committing, 0);
988 k_brlcommit(vc, committing, 0);
991 pressed &= ~(1 << (value - 1));
995 #if IS_ENABLED(CONFIG_INPUT_LEDS) && IS_ENABLED(CONFIG_LEDS_TRIGGERS)
997 struct kbd_led_trigger {
998 struct led_trigger trigger;
1002 static int kbd_led_trigger_activate(struct led_classdev *cdev)
1004 struct kbd_led_trigger *trigger =
1005 container_of(cdev->trigger, struct kbd_led_trigger, trigger);
1007 tasklet_disable(&keyboard_tasklet);
1008 if (ledstate != -1U)
1009 led_trigger_event(&trigger->trigger,
1010 ledstate & trigger->mask ?
1011 LED_FULL : LED_OFF);
1012 tasklet_enable(&keyboard_tasklet);
1017 #define KBD_LED_TRIGGER(_led_bit, _name) { \
1020 .activate = kbd_led_trigger_activate, \
1022 .mask = BIT(_led_bit), \
1025 #define KBD_LOCKSTATE_TRIGGER(_led_bit, _name) \
1026 KBD_LED_TRIGGER((_led_bit) + 8, _name)
1028 static struct kbd_led_trigger kbd_led_triggers[] = {
1029 KBD_LED_TRIGGER(VC_SCROLLOCK, "kbd-scrolllock"),
1030 KBD_LED_TRIGGER(VC_NUMLOCK, "kbd-numlock"),
1031 KBD_LED_TRIGGER(VC_CAPSLOCK, "kbd-capslock"),
1032 KBD_LED_TRIGGER(VC_KANALOCK, "kbd-kanalock"),
1034 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLOCK, "kbd-shiftlock"),
1035 KBD_LOCKSTATE_TRIGGER(VC_ALTGRLOCK, "kbd-altgrlock"),
1036 KBD_LOCKSTATE_TRIGGER(VC_CTRLLOCK, "kbd-ctrllock"),
1037 KBD_LOCKSTATE_TRIGGER(VC_ALTLOCK, "kbd-altlock"),
1038 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLLOCK, "kbd-shiftllock"),
1039 KBD_LOCKSTATE_TRIGGER(VC_SHIFTRLOCK, "kbd-shiftrlock"),
1040 KBD_LOCKSTATE_TRIGGER(VC_CTRLLLOCK, "kbd-ctrlllock"),
1041 KBD_LOCKSTATE_TRIGGER(VC_CTRLRLOCK, "kbd-ctrlrlock"),
1044 static void kbd_propagate_led_state(unsigned int old_state,
1045 unsigned int new_state)
1047 struct kbd_led_trigger *trigger;
1048 unsigned int changed = old_state ^ new_state;
1051 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1052 trigger = &kbd_led_triggers[i];
1054 if (changed & trigger->mask)
1055 led_trigger_event(&trigger->trigger,
1056 new_state & trigger->mask ?
1057 LED_FULL : LED_OFF);
1061 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1063 unsigned int led_state = *(unsigned int *)data;
1065 if (test_bit(EV_LED, handle->dev->evbit))
1066 kbd_propagate_led_state(~led_state, led_state);
1071 static void kbd_init_leds(void)
1076 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1077 error = led_trigger_register(&kbd_led_triggers[i].trigger);
1079 pr_err("error %d while registering trigger %s\n",
1080 error, kbd_led_triggers[i].trigger.name);
1086 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1088 unsigned int leds = *(unsigned int *)data;
1090 if (test_bit(EV_LED, handle->dev->evbit)) {
1091 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1092 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1093 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1094 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1100 static void kbd_propagate_led_state(unsigned int old_state,
1101 unsigned int new_state)
1103 input_handler_for_each_handle(&kbd_handler, &new_state,
1104 kbd_update_leds_helper);
1107 static void kbd_init_leds(void)
1114 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
1115 * or (ii) whatever pattern of lights people want to show using KDSETLED,
1116 * or (iii) specified bits of specified words in kernel memory.
1118 static unsigned char getledstate(void)
1120 return ledstate & 0xff;
1123 void setledstate(struct kbd_struct *kb, unsigned int led)
1125 unsigned long flags;
1126 spin_lock_irqsave(&led_lock, flags);
1129 kb->ledmode = LED_SHOW_IOCTL;
1131 kb->ledmode = LED_SHOW_FLAGS;
1134 spin_unlock_irqrestore(&led_lock, flags);
1137 static inline unsigned char getleds(void)
1139 struct kbd_struct *kb = kbd_table + fg_console;
1141 if (kb->ledmode == LED_SHOW_IOCTL)
1144 return kb->ledflagstate;
1148 * vt_get_leds - helper for braille console
1149 * @console: console to read
1150 * @flag: flag we want to check
1152 * Check the status of a keyboard led flag and report it back
1154 int vt_get_leds(int console, int flag)
1156 struct kbd_struct *kb = kbd_table + console;
1158 unsigned long flags;
1160 spin_lock_irqsave(&led_lock, flags);
1161 ret = vc_kbd_led(kb, flag);
1162 spin_unlock_irqrestore(&led_lock, flags);
1166 EXPORT_SYMBOL_GPL(vt_get_leds);
1169 * vt_set_led_state - set LED state of a console
1170 * @console: console to set
1173 * Set the LEDs on a console. This is a wrapper for the VT layer
1174 * so that we can keep kbd knowledge internal
1176 void vt_set_led_state(int console, int leds)
1178 struct kbd_struct *kb = kbd_table + console;
1179 setledstate(kb, leds);
1183 * vt_kbd_con_start - Keyboard side of console start
1186 * Handle console start. This is a wrapper for the VT layer
1187 * so that we can keep kbd knowledge internal
1189 * FIXME: We eventually need to hold the kbd lock here to protect
1190 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1191 * and start_tty under the kbd_event_lock, while normal tty paths
1192 * don't hold the lock. We probably need to split out an LED lock
1193 * but not during an -rc release!
1195 void vt_kbd_con_start(int console)
1197 struct kbd_struct *kb = kbd_table + console;
1198 unsigned long flags;
1199 spin_lock_irqsave(&led_lock, flags);
1200 clr_vc_kbd_led(kb, VC_SCROLLOCK);
1202 spin_unlock_irqrestore(&led_lock, flags);
1206 * vt_kbd_con_stop - Keyboard side of console stop
1209 * Handle console stop. This is a wrapper for the VT layer
1210 * so that we can keep kbd knowledge internal
1212 void vt_kbd_con_stop(int console)
1214 struct kbd_struct *kb = kbd_table + console;
1215 unsigned long flags;
1216 spin_lock_irqsave(&led_lock, flags);
1217 set_vc_kbd_led(kb, VC_SCROLLOCK);
1219 spin_unlock_irqrestore(&led_lock, flags);
1223 * This is the tasklet that updates LED state of LEDs using standard
1224 * keyboard triggers. The reason we use tasklet is that we need to
1225 * handle the scenario when keyboard handler is not registered yet
1226 * but we already getting updates from the VT to update led state.
1228 static void kbd_bh(unsigned long dummy)
1231 unsigned long flags;
1233 spin_lock_irqsave(&led_lock, flags);
1235 leds |= (unsigned int)kbd->lockstate << 8;
1236 spin_unlock_irqrestore(&led_lock, flags);
1238 if (leds != ledstate) {
1239 kbd_propagate_led_state(ledstate, leds);
1244 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1246 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1247 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1248 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1249 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1251 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1252 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1254 static const unsigned short x86_keycodes[256] =
1255 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1256 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1257 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1258 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1259 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1260 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1261 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1262 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1263 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1264 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1265 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1266 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1267 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1268 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1269 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1272 static int sparc_l1_a_state;
1273 extern void sun_do_break(void);
1276 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1277 unsigned char up_flag)
1284 put_queue(vc, 0xe1);
1285 put_queue(vc, 0x1d | up_flag);
1286 put_queue(vc, 0x45 | up_flag);
1291 put_queue(vc, 0xf2);
1296 put_queue(vc, 0xf1);
1301 * Real AT keyboards (that's what we're trying
1302 * to emulate here) emit 0xe0 0x2a 0xe0 0x37 when
1303 * pressing PrtSc/SysRq alone, but simply 0x54
1304 * when pressing Alt+PrtSc/SysRq.
1306 if (test_bit(KEY_LEFTALT, key_down) ||
1307 test_bit(KEY_RIGHTALT, key_down)) {
1308 put_queue(vc, 0x54 | up_flag);
1310 put_queue(vc, 0xe0);
1311 put_queue(vc, 0x2a | up_flag);
1312 put_queue(vc, 0xe0);
1313 put_queue(vc, 0x37 | up_flag);
1321 code = x86_keycodes[keycode];
1326 put_queue(vc, 0xe0);
1327 put_queue(vc, (code & 0x7f) | up_flag);
1337 #define HW_RAW(dev) 0
1339 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1344 put_queue(vc, keycode | up_flag);
1349 static void kbd_rawcode(unsigned char data)
1351 struct vc_data *vc = vc_cons[fg_console].d;
1353 kbd = kbd_table + vc->vc_num;
1354 if (kbd->kbdmode == VC_RAW)
1355 put_queue(vc, data);
1358 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1360 struct vc_data *vc = vc_cons[fg_console].d;
1361 unsigned short keysym, *key_map;
1364 struct tty_struct *tty;
1366 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1371 if (tty && (!tty->driver_data)) {
1372 /* No driver data? Strange. Okay we fix it then. */
1373 tty->driver_data = vc;
1376 kbd = kbd_table + vc->vc_num;
1379 if (keycode == KEY_STOP)
1380 sparc_l1_a_state = down;
1385 raw_mode = (kbd->kbdmode == VC_RAW);
1386 if (raw_mode && !hw_raw)
1387 if (emulate_raw(vc, keycode, !down << 7))
1388 if (keycode < BTN_MISC && printk_ratelimit())
1389 pr_warn("can't emulate rawmode for keycode %d\n",
1393 if (keycode == KEY_A && sparc_l1_a_state) {
1394 sparc_l1_a_state = false;
1399 if (kbd->kbdmode == VC_MEDIUMRAW) {
1401 * This is extended medium raw mode, with keys above 127
1402 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1403 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1404 * interfere with anything else. The two bytes after 0 will
1405 * always have the up flag set not to interfere with older
1406 * applications. This allows for 16384 different keycodes,
1407 * which should be enough.
1409 if (keycode < 128) {
1410 put_queue(vc, keycode | (!down << 7));
1412 put_queue(vc, !down << 7);
1413 put_queue(vc, (keycode >> 7) | 0x80);
1414 put_queue(vc, keycode | 0x80);
1420 set_bit(keycode, key_down);
1422 clear_bit(keycode, key_down);
1425 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1426 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1428 * Don't repeat a key if the input buffers are not empty and the
1429 * characters get aren't echoed locally. This makes key repeat
1430 * usable with slow applications and under heavy loads.
1435 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1436 param.ledstate = kbd->ledflagstate;
1437 key_map = key_maps[shift_final];
1439 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1440 KBD_KEYCODE, ¶m);
1441 if (rc == NOTIFY_STOP || !key_map) {
1442 atomic_notifier_call_chain(&keyboard_notifier_list,
1443 KBD_UNBOUND_KEYCODE, ¶m);
1444 do_compute_shiftstate();
1445 kbd->slockstate = 0;
1449 if (keycode < NR_KEYS)
1450 keysym = key_map[keycode];
1451 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1452 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1456 type = KTYP(keysym);
1459 param.value = keysym;
1460 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1461 KBD_UNICODE, ¶m);
1462 if (rc != NOTIFY_STOP)
1463 if (down && !raw_mode)
1464 to_utf8(vc, keysym);
1470 if (type == KT_LETTER) {
1472 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1473 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1475 keysym = key_map[keycode];
1479 param.value = keysym;
1480 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1481 KBD_KEYSYM, ¶m);
1482 if (rc == NOTIFY_STOP)
1485 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1488 (*k_handler[type])(vc, keysym & 0xff, !down);
1490 param.ledstate = kbd->ledflagstate;
1491 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1493 if (type != KT_SLOCK)
1494 kbd->slockstate = 0;
1497 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1498 unsigned int event_code, int value)
1500 /* We are called with interrupts disabled, just take the lock */
1501 spin_lock(&kbd_event_lock);
1503 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1505 if (event_type == EV_KEY && event_code <= KEY_MAX)
1506 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1508 spin_unlock(&kbd_event_lock);
1510 tasklet_schedule(&keyboard_tasklet);
1511 do_poke_blanked_console = 1;
1512 schedule_console_callback();
1515 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1519 if (test_bit(EV_SND, dev->evbit))
1522 if (test_bit(EV_KEY, dev->evbit)) {
1523 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1524 if (test_bit(i, dev->keybit))
1526 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1527 if (test_bit(i, dev->keybit))
1535 * When a keyboard (or other input device) is found, the kbd_connect
1536 * function is called. The function then looks at the device, and if it
1537 * likes it, it can open it and get events from it. In this (kbd_connect)
1538 * function, we should decide which VT to bind that keyboard to initially.
1540 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1541 const struct input_device_id *id)
1543 struct input_handle *handle;
1546 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1551 handle->handler = handler;
1552 handle->name = "kbd";
1554 error = input_register_handle(handle);
1556 goto err_free_handle;
1558 error = input_open_device(handle);
1560 goto err_unregister_handle;
1564 err_unregister_handle:
1565 input_unregister_handle(handle);
1571 static void kbd_disconnect(struct input_handle *handle)
1573 input_close_device(handle);
1574 input_unregister_handle(handle);
1579 * Start keyboard handler on the new keyboard by refreshing LED state to
1580 * match the rest of the system.
1582 static void kbd_start(struct input_handle *handle)
1584 tasklet_disable(&keyboard_tasklet);
1586 if (ledstate != -1U)
1587 kbd_update_leds_helper(handle, &ledstate);
1589 tasklet_enable(&keyboard_tasklet);
1592 static const struct input_device_id kbd_ids[] = {
1594 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1595 .evbit = { BIT_MASK(EV_KEY) },
1599 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1600 .evbit = { BIT_MASK(EV_SND) },
1603 { }, /* Terminating entry */
1606 MODULE_DEVICE_TABLE(input, kbd_ids);
1608 static struct input_handler kbd_handler = {
1611 .connect = kbd_connect,
1612 .disconnect = kbd_disconnect,
1615 .id_table = kbd_ids,
1618 int __init kbd_init(void)
1623 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1624 kbd_table[i].ledflagstate = kbd_defleds();
1625 kbd_table[i].default_ledflagstate = kbd_defleds();
1626 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1627 kbd_table[i].lockstate = KBD_DEFLOCK;
1628 kbd_table[i].slockstate = 0;
1629 kbd_table[i].modeflags = KBD_DEFMODE;
1630 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1635 error = input_register_handler(&kbd_handler);
1639 tasklet_enable(&keyboard_tasklet);
1640 tasklet_schedule(&keyboard_tasklet);
1645 /* Ioctl support code */
1648 * vt_do_diacrit - diacritical table updates
1649 * @cmd: ioctl request
1650 * @udp: pointer to user data for ioctl
1651 * @perm: permissions check computed by caller
1653 * Update the diacritical tables atomically and safely. Lock them
1654 * against simultaneous keypresses
1656 int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
1658 unsigned long flags;
1665 struct kbdiacrs __user *a = udp;
1666 struct kbdiacr *dia;
1669 dia = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacr),
1674 /* Lock the diacriticals table, make a copy and then
1675 copy it after we unlock */
1676 spin_lock_irqsave(&kbd_event_lock, flags);
1678 asize = accent_table_size;
1679 for (i = 0; i < asize; i++) {
1680 dia[i].diacr = conv_uni_to_8bit(
1681 accent_table[i].diacr);
1682 dia[i].base = conv_uni_to_8bit(
1683 accent_table[i].base);
1684 dia[i].result = conv_uni_to_8bit(
1685 accent_table[i].result);
1687 spin_unlock_irqrestore(&kbd_event_lock, flags);
1689 if (put_user(asize, &a->kb_cnt))
1691 else if (copy_to_user(a->kbdiacr, dia,
1692 asize * sizeof(struct kbdiacr)))
1699 struct kbdiacrsuc __user *a = udp;
1702 buf = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacruc),
1707 /* Lock the diacriticals table, make a copy and then
1708 copy it after we unlock */
1709 spin_lock_irqsave(&kbd_event_lock, flags);
1711 asize = accent_table_size;
1712 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1714 spin_unlock_irqrestore(&kbd_event_lock, flags);
1716 if (put_user(asize, &a->kb_cnt))
1718 else if (copy_to_user(a->kbdiacruc, buf,
1719 asize*sizeof(struct kbdiacruc)))
1727 struct kbdiacrs __user *a = udp;
1728 struct kbdiacr *dia = NULL;
1734 if (get_user(ct, &a->kb_cnt))
1736 if (ct >= MAX_DIACR)
1741 dia = memdup_user(a->kbdiacr,
1742 sizeof(struct kbdiacr) * ct);
1744 return PTR_ERR(dia);
1748 spin_lock_irqsave(&kbd_event_lock, flags);
1749 accent_table_size = ct;
1750 for (i = 0; i < ct; i++) {
1751 accent_table[i].diacr =
1752 conv_8bit_to_uni(dia[i].diacr);
1753 accent_table[i].base =
1754 conv_8bit_to_uni(dia[i].base);
1755 accent_table[i].result =
1756 conv_8bit_to_uni(dia[i].result);
1758 spin_unlock_irqrestore(&kbd_event_lock, flags);
1765 struct kbdiacrsuc __user *a = udp;
1772 if (get_user(ct, &a->kb_cnt))
1775 if (ct >= MAX_DIACR)
1779 buf = memdup_user(a->kbdiacruc,
1780 ct * sizeof(struct kbdiacruc));
1782 return PTR_ERR(buf);
1784 spin_lock_irqsave(&kbd_event_lock, flags);
1786 memcpy(accent_table, buf,
1787 ct * sizeof(struct kbdiacruc));
1788 accent_table_size = ct;
1789 spin_unlock_irqrestore(&kbd_event_lock, flags);
1798 * vt_do_kdskbmode - set keyboard mode ioctl
1799 * @console: the console to use
1800 * @arg: the requested mode
1802 * Update the keyboard mode bits while holding the correct locks.
1803 * Return 0 for success or an error code.
1805 int vt_do_kdskbmode(int console, unsigned int arg)
1807 struct kbd_struct *kb = kbd_table + console;
1809 unsigned long flags;
1811 spin_lock_irqsave(&kbd_event_lock, flags);
1814 kb->kbdmode = VC_RAW;
1817 kb->kbdmode = VC_MEDIUMRAW;
1820 kb->kbdmode = VC_XLATE;
1821 do_compute_shiftstate();
1824 kb->kbdmode = VC_UNICODE;
1825 do_compute_shiftstate();
1828 kb->kbdmode = VC_OFF;
1833 spin_unlock_irqrestore(&kbd_event_lock, flags);
1838 * vt_do_kdskbmeta - set keyboard meta state
1839 * @console: the console to use
1840 * @arg: the requested meta state
1842 * Update the keyboard meta bits while holding the correct locks.
1843 * Return 0 for success or an error code.
1845 int vt_do_kdskbmeta(int console, unsigned int arg)
1847 struct kbd_struct *kb = kbd_table + console;
1849 unsigned long flags;
1851 spin_lock_irqsave(&kbd_event_lock, flags);
1854 clr_vc_kbd_mode(kb, VC_META);
1857 set_vc_kbd_mode(kb, VC_META);
1862 spin_unlock_irqrestore(&kbd_event_lock, flags);
1866 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1869 struct kbkeycode tmp;
1872 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1876 kc = getkeycode(tmp.scancode);
1878 kc = put_user(kc, &user_kbkc->keycode);
1883 kc = setkeycode(tmp.scancode, tmp.keycode);
1889 #define i (tmp.kb_index)
1890 #define s (tmp.kb_table)
1891 #define v (tmp.kb_value)
1893 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1896 struct kbd_struct *kb = kbd_table + console;
1898 ushort *key_map, *new_map, val, ov;
1899 unsigned long flags;
1901 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1904 if (!capable(CAP_SYS_TTY_CONFIG))
1909 /* Ensure another thread doesn't free it under us */
1910 spin_lock_irqsave(&kbd_event_lock, flags);
1911 key_map = key_maps[s];
1913 val = U(key_map[i]);
1914 if (kb->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1917 val = (i ? K_HOLE : K_NOSUCHMAP);
1918 spin_unlock_irqrestore(&kbd_event_lock, flags);
1919 return put_user(val, &user_kbe->kb_value);
1923 if (!i && v == K_NOSUCHMAP) {
1924 spin_lock_irqsave(&kbd_event_lock, flags);
1925 /* deallocate map */
1926 key_map = key_maps[s];
1929 if (key_map[0] == U(K_ALLOCATED)) {
1934 spin_unlock_irqrestore(&kbd_event_lock, flags);
1938 if (KTYP(v) < NR_TYPES) {
1939 if (KVAL(v) > max_vals[KTYP(v)])
1942 if (kb->kbdmode != VC_UNICODE)
1945 /* ++Geert: non-PC keyboards may generate keycode zero */
1946 #if !defined(__mc68000__) && !defined(__powerpc__)
1947 /* assignment to entry 0 only tests validity of args */
1952 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1955 spin_lock_irqsave(&kbd_event_lock, flags);
1956 key_map = key_maps[s];
1957 if (key_map == NULL) {
1960 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1961 !capable(CAP_SYS_RESOURCE)) {
1962 spin_unlock_irqrestore(&kbd_event_lock, flags);
1966 key_maps[s] = new_map;
1968 key_map[0] = U(K_ALLOCATED);
1969 for (j = 1; j < NR_KEYS; j++)
1970 key_map[j] = U(K_HOLE);
1981 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1982 spin_unlock_irqrestore(&kbd_event_lock, flags);
1986 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1987 do_compute_shiftstate();
1989 spin_unlock_irqrestore(&kbd_event_lock, flags);
1998 /* FIXME: This one needs untangling */
1999 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
2001 struct kbsentry *kbs;
2005 char *first_free, *fj, *fnw;
2008 unsigned long flags;
2010 if (!capable(CAP_SYS_TTY_CONFIG))
2013 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
2019 /* we mostly copy too much here (512bytes), but who cares ;) */
2020 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
2024 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
2029 /* size should have been a struct member */
2030 ssize_t len = sizeof(user_kdgkb->kb_string);
2032 spin_lock_irqsave(&func_buf_lock, flags);
2033 len = strlcpy(kbs->kb_string, func_table[i] ? : "", len);
2034 spin_unlock_irqrestore(&func_buf_lock, flags);
2036 ret = copy_to_user(user_kdgkb->kb_string, kbs->kb_string,
2037 len + 1) ? -EFAULT : 0;
2049 /* race aginst other writers */
2051 spin_lock_irqsave(&func_buf_lock, flags);
2054 /* fj pointer to next entry after 'q' */
2055 first_free = funcbufptr + (funcbufsize - funcbufleft);
2056 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
2058 if (j < MAX_NR_FUNC)
2062 /* buffer usage increase by new entry */
2063 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
2065 if (delta <= funcbufleft) { /* it fits in current buf */
2066 if (j < MAX_NR_FUNC) {
2067 /* make enough space for new entry at 'fj' */
2068 memmove(fj + delta, fj, first_free - fj);
2069 for (k = j; k < MAX_NR_FUNC; k++)
2071 func_table[k] += delta;
2075 funcbufleft -= delta;
2076 } else { /* allocate a larger buffer */
2078 while (sz < funcbufsize - funcbufleft + delta)
2081 spin_unlock_irqrestore(&func_buf_lock, flags);
2083 fnw = kmalloc(sz, GFP_KERNEL);
2094 /* copy data before insertion point to new location */
2095 if (fj > funcbufptr)
2096 memmove(fnw, funcbufptr, fj - funcbufptr);
2097 for (k = 0; k < j; k++)
2099 func_table[k] = fnw + (func_table[k] - funcbufptr);
2101 /* copy data after insertion point to new location */
2102 if (first_free > fj) {
2103 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
2104 for (k = j; k < MAX_NR_FUNC; k++)
2106 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
2108 if (funcbufptr != func_buf)
2111 funcbufleft = funcbufleft - delta + sz - funcbufsize;
2114 /* finally insert item itself */
2115 strcpy(func_table[i], kbs->kb_string);
2116 spin_unlock_irqrestore(&func_buf_lock, flags);
2125 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2127 struct kbd_struct *kb = kbd_table + console;
2128 unsigned long flags;
2129 unsigned char ucval;
2132 /* the ioctls below read/set the flags usually shown in the leds */
2133 /* don't use them - they will go away without warning */
2135 spin_lock_irqsave(&kbd_event_lock, flags);
2136 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2137 spin_unlock_irqrestore(&kbd_event_lock, flags);
2138 return put_user(ucval, (char __user *)arg);
2145 spin_lock_irqsave(&led_lock, flags);
2146 kb->ledflagstate = (arg & 7);
2147 kb->default_ledflagstate = ((arg >> 4) & 7);
2149 spin_unlock_irqrestore(&led_lock, flags);
2152 /* the ioctls below only set the lights, not the functions */
2153 /* for those, see KDGKBLED and KDSKBLED above */
2155 ucval = getledstate();
2156 return put_user(ucval, (char __user *)arg);
2161 setledstate(kb, arg);
2164 return -ENOIOCTLCMD;
2167 int vt_do_kdgkbmode(int console)
2169 struct kbd_struct *kb = kbd_table + console;
2170 /* This is a spot read so needs no locking */
2171 switch (kb->kbdmode) {
2186 * vt_do_kdgkbmeta - report meta status
2187 * @console: console to report
2189 * Report the meta flag status of this console
2191 int vt_do_kdgkbmeta(int console)
2193 struct kbd_struct *kb = kbd_table + console;
2194 /* Again a spot read so no locking */
2195 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2199 * vt_reset_unicode - reset the unicode status
2200 * @console: console being reset
2202 * Restore the unicode console state to its default
2204 void vt_reset_unicode(int console)
2206 unsigned long flags;
2208 spin_lock_irqsave(&kbd_event_lock, flags);
2209 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2210 spin_unlock_irqrestore(&kbd_event_lock, flags);
2214 * vt_get_shiftstate - shift bit state
2216 * Report the shift bits from the keyboard state. We have to export
2217 * this to support some oddities in the vt layer.
2219 int vt_get_shift_state(void)
2221 /* Don't lock as this is a transient report */
2226 * vt_reset_keyboard - reset keyboard state
2227 * @console: console to reset
2229 * Reset the keyboard bits for a console as part of a general console
2232 void vt_reset_keyboard(int console)
2234 struct kbd_struct *kb = kbd_table + console;
2235 unsigned long flags;
2237 spin_lock_irqsave(&kbd_event_lock, flags);
2238 set_vc_kbd_mode(kb, VC_REPEAT);
2239 clr_vc_kbd_mode(kb, VC_CKMODE);
2240 clr_vc_kbd_mode(kb, VC_APPLIC);
2241 clr_vc_kbd_mode(kb, VC_CRLF);
2244 spin_lock(&led_lock);
2245 kb->ledmode = LED_SHOW_FLAGS;
2246 kb->ledflagstate = kb->default_ledflagstate;
2247 spin_unlock(&led_lock);
2248 /* do not do set_leds here because this causes an endless tasklet loop
2249 when the keyboard hasn't been initialized yet */
2250 spin_unlock_irqrestore(&kbd_event_lock, flags);
2254 * vt_get_kbd_mode_bit - read keyboard status bits
2255 * @console: console to read from
2256 * @bit: mode bit to read
2258 * Report back a vt mode bit. We do this without locking so the
2259 * caller must be sure that there are no synchronization needs
2262 int vt_get_kbd_mode_bit(int console, int bit)
2264 struct kbd_struct *kb = kbd_table + console;
2265 return vc_kbd_mode(kb, bit);
2269 * vt_set_kbd_mode_bit - read keyboard status bits
2270 * @console: console to read from
2271 * @bit: mode bit to read
2273 * Set a vt mode bit. We do this without locking so the
2274 * caller must be sure that there are no synchronization needs
2277 void vt_set_kbd_mode_bit(int console, int bit)
2279 struct kbd_struct *kb = kbd_table + console;
2280 unsigned long flags;
2282 spin_lock_irqsave(&kbd_event_lock, flags);
2283 set_vc_kbd_mode(kb, bit);
2284 spin_unlock_irqrestore(&kbd_event_lock, flags);
2288 * vt_clr_kbd_mode_bit - read keyboard status bits
2289 * @console: console to read from
2290 * @bit: mode bit to read
2292 * Report back a vt mode bit. We do this without locking so the
2293 * caller must be sure that there are no synchronization needs
2296 void vt_clr_kbd_mode_bit(int console, int bit)
2298 struct kbd_struct *kb = kbd_table + console;
2299 unsigned long flags;
2301 spin_lock_irqsave(&kbd_event_lock, flags);
2302 clr_vc_kbd_mode(kb, bit);
2303 spin_unlock_irqrestore(&kbd_event_lock, flags);