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/nospec.h>
36 #include <linux/string.h>
37 #include <linux/init.h>
38 #include <linux/slab.h>
39 #include <linux/leds.h>
41 #include <linux/kbd_kern.h>
42 #include <linux/kbd_diacr.h>
43 #include <linux/vt_kern.h>
44 #include <linux/input.h>
45 #include <linux/reboot.h>
46 #include <linux/notifier.h>
47 #include <linux/jiffies.h>
48 #include <linux/uaccess.h>
50 #include <asm/irq_regs.h>
52 extern void ctrl_alt_del(void);
55 * Exported functions/variables
58 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
60 #if defined(CONFIG_X86) || defined(CONFIG_PARISC)
61 #include <asm/kbdleds.h>
63 static inline int kbd_defleds(void)
76 k_self, k_fn, k_spec, k_pad,\
77 k_dead, k_cons, k_cur, k_shift,\
78 k_meta, k_ascii, k_lock, k_lowercase,\
79 k_slock, k_dead2, k_brl, k_ignore
81 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
83 static k_handler_fn K_HANDLERS;
84 static k_handler_fn *k_handler[16] = { K_HANDLERS };
87 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
88 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
89 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
90 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
91 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
93 typedef void (fn_handler_fn)(struct vc_data *vc);
94 static fn_handler_fn FN_HANDLERS;
95 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
98 * Variables exported for vt_ioctl.c
101 struct vt_spawn_console vt_spawn_con = {
102 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
112 static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
113 static struct kbd_struct *kbd = kbd_table;
115 /* maximum values each key_handler can handle */
116 static const int max_vals[] = {
117 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
118 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
119 255, NR_LOCK - 1, 255, NR_BRL - 1
122 static const int NR_TYPES = ARRAY_SIZE(max_vals);
124 static struct input_handler kbd_handler;
125 static DEFINE_SPINLOCK(kbd_event_lock);
126 static DEFINE_SPINLOCK(led_lock);
127 static DEFINE_SPINLOCK(func_buf_lock); /* guard 'func_buf' and friends */
128 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
129 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
130 static bool dead_key_next;
132 /* Handles a number being assembled on the number pad */
133 static bool npadch_active;
134 static unsigned int npadch_value;
136 static unsigned int diacr;
137 static char rep; /* flag telling character repeat */
139 static int shift_state = 0;
141 static unsigned int ledstate = -1U; /* undefined */
142 static unsigned char ledioctl;
145 * Notifier list for console keyboard events
147 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
149 int register_keyboard_notifier(struct notifier_block *nb)
151 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
153 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
155 int unregister_keyboard_notifier(struct notifier_block *nb)
157 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
159 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
162 * Translation of scancodes to keycodes. We set them on only the first
163 * keyboard in the list that accepts the scancode and keycode.
164 * Explanation for not choosing the first attached keyboard anymore:
165 * USB keyboards for example have two event devices: one for all "normal"
166 * keys and one for extra function keys (like "volume up", "make coffee",
167 * etc.). So this means that scancodes for the extra function keys won't
168 * be valid for the first event device, but will be for the second.
171 struct getset_keycode_data {
172 struct input_keymap_entry ke;
176 static int getkeycode_helper(struct input_handle *handle, void *data)
178 struct getset_keycode_data *d = data;
180 d->error = input_get_keycode(handle->dev, &d->ke);
182 return d->error == 0; /* stop as soon as we successfully get one */
185 static int getkeycode(unsigned int scancode)
187 struct getset_keycode_data d = {
190 .len = sizeof(scancode),
196 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
198 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
200 return d.error ?: d.ke.keycode;
203 static int setkeycode_helper(struct input_handle *handle, void *data)
205 struct getset_keycode_data *d = data;
207 d->error = input_set_keycode(handle->dev, &d->ke);
209 return d->error == 0; /* stop as soon as we successfully set one */
212 static int setkeycode(unsigned int scancode, unsigned int keycode)
214 struct getset_keycode_data d = {
217 .len = sizeof(scancode),
223 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
225 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
231 * Making beeps and bells. Note that we prefer beeps to bells, but when
232 * shutting the sound off we do both.
235 static int kd_sound_helper(struct input_handle *handle, void *data)
237 unsigned int *hz = data;
238 struct input_dev *dev = handle->dev;
240 if (test_bit(EV_SND, dev->evbit)) {
241 if (test_bit(SND_TONE, dev->sndbit)) {
242 input_inject_event(handle, EV_SND, SND_TONE, *hz);
246 if (test_bit(SND_BELL, dev->sndbit))
247 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
253 static void kd_nosound(struct timer_list *unused)
255 static unsigned int zero;
257 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
260 static DEFINE_TIMER(kd_mksound_timer, kd_nosound);
262 void kd_mksound(unsigned int hz, unsigned int ticks)
264 del_timer_sync(&kd_mksound_timer);
266 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
269 mod_timer(&kd_mksound_timer, jiffies + ticks);
271 EXPORT_SYMBOL(kd_mksound);
274 * Setting the keyboard rate.
277 static int kbd_rate_helper(struct input_handle *handle, void *data)
279 struct input_dev *dev = handle->dev;
280 struct kbd_repeat *rpt = data;
282 if (test_bit(EV_REP, dev->evbit)) {
284 if (rpt[0].delay > 0)
285 input_inject_event(handle,
286 EV_REP, REP_DELAY, rpt[0].delay);
287 if (rpt[0].period > 0)
288 input_inject_event(handle,
289 EV_REP, REP_PERIOD, rpt[0].period);
291 rpt[1].delay = dev->rep[REP_DELAY];
292 rpt[1].period = dev->rep[REP_PERIOD];
298 int kbd_rate(struct kbd_repeat *rpt)
300 struct kbd_repeat data[2] = { *rpt };
302 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
303 *rpt = data[1]; /* Copy currently used settings */
311 static void put_queue(struct vc_data *vc, int ch)
313 tty_insert_flip_char(&vc->port, ch, 0);
314 tty_flip_buffer_push(&vc->port);
317 static void puts_queue(struct vc_data *vc, char *cp)
320 tty_insert_flip_char(&vc->port, *cp, 0);
323 tty_flip_buffer_push(&vc->port);
326 static void applkey(struct vc_data *vc, int key, char mode)
328 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
330 buf[1] = (mode ? 'O' : '[');
336 * Many other routines do put_queue, but I think either
337 * they produce ASCII, or they produce some user-assigned
338 * string, and in both cases we might assume that it is
341 static void to_utf8(struct vc_data *vc, uint c)
346 else if (c < 0x800) {
347 /* 110***** 10****** */
348 put_queue(vc, 0xc0 | (c >> 6));
349 put_queue(vc, 0x80 | (c & 0x3f));
350 } else if (c < 0x10000) {
351 if (c >= 0xD800 && c < 0xE000)
355 /* 1110**** 10****** 10****** */
356 put_queue(vc, 0xe0 | (c >> 12));
357 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
358 put_queue(vc, 0x80 | (c & 0x3f));
359 } else if (c < 0x110000) {
360 /* 11110*** 10****** 10****** 10****** */
361 put_queue(vc, 0xf0 | (c >> 18));
362 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
363 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
364 put_queue(vc, 0x80 | (c & 0x3f));
369 * Called after returning from RAW mode or when changing consoles - recompute
370 * shift_down[] and shift_state from key_down[] maybe called when keymap is
371 * undefined, so that shiftkey release is seen. The caller must hold the
375 static void do_compute_shiftstate(void)
377 unsigned int k, sym, val;
380 memset(shift_down, 0, sizeof(shift_down));
382 for_each_set_bit(k, key_down, min(NR_KEYS, KEY_CNT)) {
383 sym = U(key_maps[0][k]);
384 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
388 if (val == KVAL(K_CAPSSHIFT))
392 shift_state |= BIT(val);
396 /* We still have to export this method to vt.c */
397 void compute_shiftstate(void)
400 spin_lock_irqsave(&kbd_event_lock, flags);
401 do_compute_shiftstate();
402 spin_unlock_irqrestore(&kbd_event_lock, flags);
406 * We have a combining character DIACR here, followed by the character CH.
407 * If the combination occurs in the table, return the corresponding value.
408 * Otherwise, if CH is a space or equals DIACR, return DIACR.
409 * Otherwise, conclude that DIACR was not combining after all,
410 * queue it and return CH.
412 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
414 unsigned int d = diacr;
419 if ((d & ~0xff) == BRL_UC_ROW) {
420 if ((ch & ~0xff) == BRL_UC_ROW)
423 for (i = 0; i < accent_table_size; i++)
424 if (accent_table[i].diacr == d && accent_table[i].base == ch)
425 return accent_table[i].result;
428 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
431 if (kbd->kbdmode == VC_UNICODE)
434 int c = conv_uni_to_8bit(d);
443 * Special function handlers
445 static void fn_enter(struct vc_data *vc)
448 if (kbd->kbdmode == VC_UNICODE)
451 int c = conv_uni_to_8bit(diacr);
459 if (vc_kbd_mode(kbd, VC_CRLF))
463 static void fn_caps_toggle(struct vc_data *vc)
468 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
471 static void fn_caps_on(struct vc_data *vc)
476 set_vc_kbd_led(kbd, VC_CAPSLOCK);
479 static void fn_show_ptregs(struct vc_data *vc)
481 struct pt_regs *regs = get_irq_regs();
487 static void fn_hold(struct vc_data *vc)
489 struct tty_struct *tty = vc->port.tty;
495 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
496 * these routines are also activated by ^S/^Q.
497 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
505 static void fn_num(struct vc_data *vc)
507 if (vc_kbd_mode(kbd, VC_APPLIC))
514 * Bind this to Shift-NumLock if you work in application keypad mode
515 * but want to be able to change the NumLock flag.
516 * Bind this to NumLock if you prefer that the NumLock key always
517 * changes the NumLock flag.
519 static void fn_bare_num(struct vc_data *vc)
522 chg_vc_kbd_led(kbd, VC_NUMLOCK);
525 static void fn_lastcons(struct vc_data *vc)
527 /* switch to the last used console, ChN */
528 set_console(last_console);
531 static void fn_dec_console(struct vc_data *vc)
533 int i, cur = fg_console;
535 /* Currently switching? Queue this next switch relative to that. */
536 if (want_console != -1)
539 for (i = cur - 1; i != cur; i--) {
541 i = MAX_NR_CONSOLES - 1;
542 if (vc_cons_allocated(i))
548 static void fn_inc_console(struct vc_data *vc)
550 int i, cur = fg_console;
552 /* Currently switching? Queue this next switch relative to that. */
553 if (want_console != -1)
556 for (i = cur+1; i != cur; i++) {
557 if (i == MAX_NR_CONSOLES)
559 if (vc_cons_allocated(i))
565 static void fn_send_intr(struct vc_data *vc)
567 tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
568 tty_flip_buffer_push(&vc->port);
571 static void fn_scroll_forw(struct vc_data *vc)
576 static void fn_scroll_back(struct vc_data *vc)
581 static void fn_show_mem(struct vc_data *vc)
586 static void fn_show_state(struct vc_data *vc)
591 static void fn_boot_it(struct vc_data *vc)
596 static void fn_compose(struct vc_data *vc)
598 dead_key_next = true;
601 static void fn_spawn_con(struct vc_data *vc)
603 spin_lock(&vt_spawn_con.lock);
604 if (vt_spawn_con.pid)
605 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
606 put_pid(vt_spawn_con.pid);
607 vt_spawn_con.pid = NULL;
609 spin_unlock(&vt_spawn_con.lock);
612 static void fn_SAK(struct vc_data *vc)
614 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
615 schedule_work(SAK_work);
618 static void fn_null(struct vc_data *vc)
620 do_compute_shiftstate();
624 * Special key handlers
626 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
630 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
634 if (value >= ARRAY_SIZE(fn_handler))
636 if ((kbd->kbdmode == VC_RAW ||
637 kbd->kbdmode == VC_MEDIUMRAW ||
638 kbd->kbdmode == VC_OFF) &&
639 value != KVAL(K_SAK))
640 return; /* SAK is allowed even in raw mode */
641 fn_handler[value](vc);
644 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
646 pr_err("k_lowercase was called - impossible\n");
649 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
652 return; /* no action, if this is a key release */
655 value = handle_diacr(vc, value);
658 dead_key_next = false;
662 if (kbd->kbdmode == VC_UNICODE)
665 int c = conv_uni_to_8bit(value);
672 * Handle dead key. Note that we now may have several
673 * dead keys modifying the same character. Very useful
676 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
681 diacr = (diacr ? handle_diacr(vc, value) : value);
684 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
686 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
689 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
691 k_deadunicode(vc, value, up_flag);
695 * Obsolete - for backwards compatibility only
697 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
699 static const unsigned char ret_diacr[NR_DEAD] = {
700 '`', /* dead_grave */
701 '\'', /* dead_acute */
702 '^', /* dead_circumflex */
703 '~', /* dead_tilda */
704 '"', /* dead_diaeresis */
705 ',', /* dead_cedilla */
706 '_', /* dead_macron */
707 'U', /* dead_breve */
708 '.', /* dead_abovedot */
709 '*', /* dead_abovering */
710 '=', /* dead_doubleacute */
711 'c', /* dead_caron */
712 'k', /* dead_ogonek */
714 '#', /* dead_voiced_sound */
715 'o', /* dead_semivoiced_sound */
716 '!', /* dead_belowdot */
719 '-', /* dead_stroke */
720 ')', /* dead_abovecomma */
721 '(', /* dead_abovereversedcomma */
722 ':', /* dead_doublegrave */
723 'n', /* dead_invertedbreve */
724 ';', /* dead_belowcomma */
725 '$', /* dead_currency */
726 '@', /* dead_greek */
729 k_deadunicode(vc, ret_diacr[value], up_flag);
732 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
740 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
745 if ((unsigned)value < ARRAY_SIZE(func_table)) {
748 spin_lock_irqsave(&func_buf_lock, flags);
749 if (func_table[value])
750 puts_queue(vc, func_table[value]);
751 spin_unlock_irqrestore(&func_buf_lock, flags);
754 pr_err("k_fn called with value=%d\n", value);
757 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
759 static const char cur_chars[] = "BDCA";
764 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
767 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
769 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
770 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
773 return; /* no action, if this is a key release */
775 /* kludge... shift forces cursor/number keys */
776 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
777 applkey(vc, app_map[value], 1);
781 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
786 k_fn(vc, KVAL(K_REMOVE), 0);
789 k_fn(vc, KVAL(K_INSERT), 0);
792 k_fn(vc, KVAL(K_SELECT), 0);
795 k_cur(vc, KVAL(K_DOWN), 0);
798 k_fn(vc, KVAL(K_PGDN), 0);
801 k_cur(vc, KVAL(K_LEFT), 0);
804 k_cur(vc, KVAL(K_RIGHT), 0);
807 k_fn(vc, KVAL(K_FIND), 0);
810 k_cur(vc, KVAL(K_UP), 0);
813 k_fn(vc, KVAL(K_PGUP), 0);
816 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
821 put_queue(vc, pad_chars[value]);
822 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
826 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
828 int old_state = shift_state;
834 * a CapsShift key acts like Shift but undoes CapsLock
836 if (value == KVAL(K_CAPSSHIFT)) {
837 value = KVAL(K_SHIFT);
839 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
844 * handle the case that two shift or control
845 * keys are depressed simultaneously
847 if (shift_down[value])
852 if (shift_down[value])
853 shift_state |= (1 << value);
855 shift_state &= ~(1 << value);
858 if (up_flag && shift_state != old_state && npadch_active) {
859 if (kbd->kbdmode == VC_UNICODE)
860 to_utf8(vc, npadch_value);
862 put_queue(vc, npadch_value & 0xff);
863 npadch_active = false;
867 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
872 if (vc_kbd_mode(kbd, VC_META)) {
873 put_queue(vc, '\033');
874 put_queue(vc, value);
876 put_queue(vc, value | 0x80);
879 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
887 /* decimal input of code, while Alt depressed */
890 /* hexadecimal input of code, while AltGr depressed */
895 if (!npadch_active) {
897 npadch_active = true;
900 npadch_value = npadch_value * base + value;
903 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
908 chg_vc_kbd_lock(kbd, value);
911 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
913 k_shift(vc, value, up_flag);
917 chg_vc_kbd_slock(kbd, value);
918 /* try to make Alt, oops, AltGr and such work */
919 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
921 chg_vc_kbd_slock(kbd, value);
925 /* by default, 300ms interval for combination release */
926 static unsigned brl_timeout = 300;
927 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
928 module_param(brl_timeout, uint, 0644);
930 static unsigned brl_nbchords = 1;
931 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
932 module_param(brl_nbchords, uint, 0644);
934 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
936 static unsigned long chords;
937 static unsigned committed;
940 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
942 committed |= pattern;
944 if (chords == brl_nbchords) {
945 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
952 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
954 static unsigned pressed, committing;
955 static unsigned long releasestart;
957 if (kbd->kbdmode != VC_UNICODE) {
959 pr_warn("keyboard mode must be unicode for braille patterns\n");
964 k_unicode(vc, BRL_UC_ROW, up_flag);
972 pressed |= 1 << (value - 1);
974 committing = pressed;
975 } else if (brl_timeout) {
978 releasestart + msecs_to_jiffies(brl_timeout))) {
979 committing = pressed;
980 releasestart = jiffies;
982 pressed &= ~(1 << (value - 1));
983 if (!pressed && committing) {
984 k_brlcommit(vc, committing, 0);
989 k_brlcommit(vc, committing, 0);
992 pressed &= ~(1 << (value - 1));
996 #if IS_ENABLED(CONFIG_INPUT_LEDS) && IS_ENABLED(CONFIG_LEDS_TRIGGERS)
998 struct kbd_led_trigger {
999 struct led_trigger trigger;
1003 static int kbd_led_trigger_activate(struct led_classdev *cdev)
1005 struct kbd_led_trigger *trigger =
1006 container_of(cdev->trigger, struct kbd_led_trigger, trigger);
1008 tasklet_disable(&keyboard_tasklet);
1009 if (ledstate != -1U)
1010 led_trigger_event(&trigger->trigger,
1011 ledstate & trigger->mask ?
1012 LED_FULL : LED_OFF);
1013 tasklet_enable(&keyboard_tasklet);
1018 #define KBD_LED_TRIGGER(_led_bit, _name) { \
1021 .activate = kbd_led_trigger_activate, \
1023 .mask = BIT(_led_bit), \
1026 #define KBD_LOCKSTATE_TRIGGER(_led_bit, _name) \
1027 KBD_LED_TRIGGER((_led_bit) + 8, _name)
1029 static struct kbd_led_trigger kbd_led_triggers[] = {
1030 KBD_LED_TRIGGER(VC_SCROLLOCK, "kbd-scrolllock"),
1031 KBD_LED_TRIGGER(VC_NUMLOCK, "kbd-numlock"),
1032 KBD_LED_TRIGGER(VC_CAPSLOCK, "kbd-capslock"),
1033 KBD_LED_TRIGGER(VC_KANALOCK, "kbd-kanalock"),
1035 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLOCK, "kbd-shiftlock"),
1036 KBD_LOCKSTATE_TRIGGER(VC_ALTGRLOCK, "kbd-altgrlock"),
1037 KBD_LOCKSTATE_TRIGGER(VC_CTRLLOCK, "kbd-ctrllock"),
1038 KBD_LOCKSTATE_TRIGGER(VC_ALTLOCK, "kbd-altlock"),
1039 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLLOCK, "kbd-shiftllock"),
1040 KBD_LOCKSTATE_TRIGGER(VC_SHIFTRLOCK, "kbd-shiftrlock"),
1041 KBD_LOCKSTATE_TRIGGER(VC_CTRLLLOCK, "kbd-ctrlllock"),
1042 KBD_LOCKSTATE_TRIGGER(VC_CTRLRLOCK, "kbd-ctrlrlock"),
1045 static void kbd_propagate_led_state(unsigned int old_state,
1046 unsigned int new_state)
1048 struct kbd_led_trigger *trigger;
1049 unsigned int changed = old_state ^ new_state;
1052 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1053 trigger = &kbd_led_triggers[i];
1055 if (changed & trigger->mask)
1056 led_trigger_event(&trigger->trigger,
1057 new_state & trigger->mask ?
1058 LED_FULL : LED_OFF);
1062 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1064 unsigned int led_state = *(unsigned int *)data;
1066 if (test_bit(EV_LED, handle->dev->evbit))
1067 kbd_propagate_led_state(~led_state, led_state);
1072 static void kbd_init_leds(void)
1077 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1078 error = led_trigger_register(&kbd_led_triggers[i].trigger);
1080 pr_err("error %d while registering trigger %s\n",
1081 error, kbd_led_triggers[i].trigger.name);
1087 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1089 unsigned int leds = *(unsigned int *)data;
1091 if (test_bit(EV_LED, handle->dev->evbit)) {
1092 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1093 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1094 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1095 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1101 static void kbd_propagate_led_state(unsigned int old_state,
1102 unsigned int new_state)
1104 input_handler_for_each_handle(&kbd_handler, &new_state,
1105 kbd_update_leds_helper);
1108 static void kbd_init_leds(void)
1115 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
1116 * or (ii) whatever pattern of lights people want to show using KDSETLED,
1117 * or (iii) specified bits of specified words in kernel memory.
1119 static unsigned char getledstate(void)
1121 return ledstate & 0xff;
1124 void setledstate(struct kbd_struct *kb, unsigned int led)
1126 unsigned long flags;
1127 spin_lock_irqsave(&led_lock, flags);
1130 kb->ledmode = LED_SHOW_IOCTL;
1132 kb->ledmode = LED_SHOW_FLAGS;
1135 spin_unlock_irqrestore(&led_lock, flags);
1138 static inline unsigned char getleds(void)
1140 struct kbd_struct *kb = kbd_table + fg_console;
1142 if (kb->ledmode == LED_SHOW_IOCTL)
1145 return kb->ledflagstate;
1149 * vt_get_leds - helper for braille console
1150 * @console: console to read
1151 * @flag: flag we want to check
1153 * Check the status of a keyboard led flag and report it back
1155 int vt_get_leds(int console, int flag)
1157 struct kbd_struct *kb = kbd_table + console;
1159 unsigned long flags;
1161 spin_lock_irqsave(&led_lock, flags);
1162 ret = vc_kbd_led(kb, flag);
1163 spin_unlock_irqrestore(&led_lock, flags);
1167 EXPORT_SYMBOL_GPL(vt_get_leds);
1170 * vt_set_led_state - set LED state of a console
1171 * @console: console to set
1174 * Set the LEDs on a console. This is a wrapper for the VT layer
1175 * so that we can keep kbd knowledge internal
1177 void vt_set_led_state(int console, int leds)
1179 struct kbd_struct *kb = kbd_table + console;
1180 setledstate(kb, leds);
1184 * vt_kbd_con_start - Keyboard side of console start
1187 * Handle console start. This is a wrapper for the VT layer
1188 * so that we can keep kbd knowledge internal
1190 * FIXME: We eventually need to hold the kbd lock here to protect
1191 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1192 * and start_tty under the kbd_event_lock, while normal tty paths
1193 * don't hold the lock. We probably need to split out an LED lock
1194 * but not during an -rc release!
1196 void vt_kbd_con_start(int console)
1198 struct kbd_struct *kb = kbd_table + console;
1199 unsigned long flags;
1200 spin_lock_irqsave(&led_lock, flags);
1201 clr_vc_kbd_led(kb, VC_SCROLLOCK);
1203 spin_unlock_irqrestore(&led_lock, flags);
1207 * vt_kbd_con_stop - Keyboard side of console stop
1210 * Handle console stop. This is a wrapper for the VT layer
1211 * so that we can keep kbd knowledge internal
1213 void vt_kbd_con_stop(int console)
1215 struct kbd_struct *kb = kbd_table + console;
1216 unsigned long flags;
1217 spin_lock_irqsave(&led_lock, flags);
1218 set_vc_kbd_led(kb, VC_SCROLLOCK);
1220 spin_unlock_irqrestore(&led_lock, flags);
1224 * This is the tasklet that updates LED state of LEDs using standard
1225 * keyboard triggers. The reason we use tasklet is that we need to
1226 * handle the scenario when keyboard handler is not registered yet
1227 * but we already getting updates from the VT to update led state.
1229 static void kbd_bh(unsigned long dummy)
1232 unsigned long flags;
1234 spin_lock_irqsave(&led_lock, flags);
1236 leds |= (unsigned int)kbd->lockstate << 8;
1237 spin_unlock_irqrestore(&led_lock, flags);
1239 if (leds != ledstate) {
1240 kbd_propagate_led_state(ledstate, leds);
1245 DECLARE_TASKLET_DISABLED_OLD(keyboard_tasklet, kbd_bh);
1247 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1248 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1249 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1250 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1252 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1253 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1255 static const unsigned short x86_keycodes[256] =
1256 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1257 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1258 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1259 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1260 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1261 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1262 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1263 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1264 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1265 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1266 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1267 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1268 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1269 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1270 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1273 static int sparc_l1_a_state;
1274 extern void sun_do_break(void);
1277 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1278 unsigned char up_flag)
1285 put_queue(vc, 0xe1);
1286 put_queue(vc, 0x1d | up_flag);
1287 put_queue(vc, 0x45 | up_flag);
1292 put_queue(vc, 0xf2);
1297 put_queue(vc, 0xf1);
1302 * Real AT keyboards (that's what we're trying
1303 * to emulate here) emit 0xe0 0x2a 0xe0 0x37 when
1304 * pressing PrtSc/SysRq alone, but simply 0x54
1305 * when pressing Alt+PrtSc/SysRq.
1307 if (test_bit(KEY_LEFTALT, key_down) ||
1308 test_bit(KEY_RIGHTALT, key_down)) {
1309 put_queue(vc, 0x54 | up_flag);
1311 put_queue(vc, 0xe0);
1312 put_queue(vc, 0x2a | up_flag);
1313 put_queue(vc, 0xe0);
1314 put_queue(vc, 0x37 | up_flag);
1322 code = x86_keycodes[keycode];
1327 put_queue(vc, 0xe0);
1328 put_queue(vc, (code & 0x7f) | up_flag);
1338 #define HW_RAW(dev) 0
1340 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1345 put_queue(vc, keycode | up_flag);
1350 static void kbd_rawcode(unsigned char data)
1352 struct vc_data *vc = vc_cons[fg_console].d;
1354 kbd = kbd_table + vc->vc_num;
1355 if (kbd->kbdmode == VC_RAW)
1356 put_queue(vc, data);
1359 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1361 struct vc_data *vc = vc_cons[fg_console].d;
1362 unsigned short keysym, *key_map;
1365 struct tty_struct *tty;
1367 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1372 if (tty && (!tty->driver_data)) {
1373 /* No driver data? Strange. Okay we fix it then. */
1374 tty->driver_data = vc;
1377 kbd = kbd_table + vc->vc_num;
1380 if (keycode == KEY_STOP)
1381 sparc_l1_a_state = down;
1386 raw_mode = (kbd->kbdmode == VC_RAW);
1387 if (raw_mode && !hw_raw)
1388 if (emulate_raw(vc, keycode, !down << 7))
1389 if (keycode < BTN_MISC && printk_ratelimit())
1390 pr_warn("can't emulate rawmode for keycode %d\n",
1394 if (keycode == KEY_A && sparc_l1_a_state) {
1395 sparc_l1_a_state = false;
1400 if (kbd->kbdmode == VC_MEDIUMRAW) {
1402 * This is extended medium raw mode, with keys above 127
1403 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1404 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1405 * interfere with anything else. The two bytes after 0 will
1406 * always have the up flag set not to interfere with older
1407 * applications. This allows for 16384 different keycodes,
1408 * which should be enough.
1410 if (keycode < 128) {
1411 put_queue(vc, keycode | (!down << 7));
1413 put_queue(vc, !down << 7);
1414 put_queue(vc, (keycode >> 7) | 0x80);
1415 put_queue(vc, keycode | 0x80);
1421 set_bit(keycode, key_down);
1423 clear_bit(keycode, key_down);
1426 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1427 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1429 * Don't repeat a key if the input buffers are not empty and the
1430 * characters get aren't echoed locally. This makes key repeat
1431 * usable with slow applications and under heavy loads.
1436 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1437 param.ledstate = kbd->ledflagstate;
1438 key_map = key_maps[shift_final];
1440 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1441 KBD_KEYCODE, ¶m);
1442 if (rc == NOTIFY_STOP || !key_map) {
1443 atomic_notifier_call_chain(&keyboard_notifier_list,
1444 KBD_UNBOUND_KEYCODE, ¶m);
1445 do_compute_shiftstate();
1446 kbd->slockstate = 0;
1450 if (keycode < NR_KEYS)
1451 keysym = key_map[keycode];
1452 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1453 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1457 type = KTYP(keysym);
1460 param.value = keysym;
1461 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1462 KBD_UNICODE, ¶m);
1463 if (rc != NOTIFY_STOP)
1464 if (down && !raw_mode)
1465 k_unicode(vc, keysym, !down);
1471 if (type == KT_LETTER) {
1473 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1474 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1476 keysym = key_map[keycode];
1480 param.value = keysym;
1481 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1482 KBD_KEYSYM, ¶m);
1483 if (rc == NOTIFY_STOP)
1486 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1489 (*k_handler[type])(vc, keysym & 0xff, !down);
1491 param.ledstate = kbd->ledflagstate;
1492 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1494 if (type != KT_SLOCK)
1495 kbd->slockstate = 0;
1498 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1499 unsigned int event_code, int value)
1501 /* We are called with interrupts disabled, just take the lock */
1502 spin_lock(&kbd_event_lock);
1504 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1506 if (event_type == EV_KEY && event_code <= KEY_MAX)
1507 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1509 spin_unlock(&kbd_event_lock);
1511 tasklet_schedule(&keyboard_tasklet);
1512 do_poke_blanked_console = 1;
1513 schedule_console_callback();
1516 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1520 if (test_bit(EV_SND, dev->evbit))
1523 if (test_bit(EV_KEY, dev->evbit)) {
1524 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1525 if (test_bit(i, dev->keybit))
1527 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1528 if (test_bit(i, dev->keybit))
1536 * When a keyboard (or other input device) is found, the kbd_connect
1537 * function is called. The function then looks at the device, and if it
1538 * likes it, it can open it and get events from it. In this (kbd_connect)
1539 * function, we should decide which VT to bind that keyboard to initially.
1541 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1542 const struct input_device_id *id)
1544 struct input_handle *handle;
1547 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1552 handle->handler = handler;
1553 handle->name = "kbd";
1555 error = input_register_handle(handle);
1557 goto err_free_handle;
1559 error = input_open_device(handle);
1561 goto err_unregister_handle;
1565 err_unregister_handle:
1566 input_unregister_handle(handle);
1572 static void kbd_disconnect(struct input_handle *handle)
1574 input_close_device(handle);
1575 input_unregister_handle(handle);
1580 * Start keyboard handler on the new keyboard by refreshing LED state to
1581 * match the rest of the system.
1583 static void kbd_start(struct input_handle *handle)
1585 tasklet_disable(&keyboard_tasklet);
1587 if (ledstate != -1U)
1588 kbd_update_leds_helper(handle, &ledstate);
1590 tasklet_enable(&keyboard_tasklet);
1593 static const struct input_device_id kbd_ids[] = {
1595 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1596 .evbit = { BIT_MASK(EV_KEY) },
1600 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1601 .evbit = { BIT_MASK(EV_SND) },
1604 { }, /* Terminating entry */
1607 MODULE_DEVICE_TABLE(input, kbd_ids);
1609 static struct input_handler kbd_handler = {
1612 .connect = kbd_connect,
1613 .disconnect = kbd_disconnect,
1616 .id_table = kbd_ids,
1619 int __init kbd_init(void)
1624 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1625 kbd_table[i].ledflagstate = kbd_defleds();
1626 kbd_table[i].default_ledflagstate = kbd_defleds();
1627 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1628 kbd_table[i].lockstate = KBD_DEFLOCK;
1629 kbd_table[i].slockstate = 0;
1630 kbd_table[i].modeflags = KBD_DEFMODE;
1631 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1636 error = input_register_handler(&kbd_handler);
1640 tasklet_enable(&keyboard_tasklet);
1641 tasklet_schedule(&keyboard_tasklet);
1646 /* Ioctl support code */
1649 * vt_do_diacrit - diacritical table updates
1650 * @cmd: ioctl request
1651 * @udp: pointer to user data for ioctl
1652 * @perm: permissions check computed by caller
1654 * Update the diacritical tables atomically and safely. Lock them
1655 * against simultaneous keypresses
1657 int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
1659 unsigned long flags;
1666 struct kbdiacrs __user *a = udp;
1667 struct kbdiacr *dia;
1670 dia = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacr),
1675 /* Lock the diacriticals table, make a copy and then
1676 copy it after we unlock */
1677 spin_lock_irqsave(&kbd_event_lock, flags);
1679 asize = accent_table_size;
1680 for (i = 0; i < asize; i++) {
1681 dia[i].diacr = conv_uni_to_8bit(
1682 accent_table[i].diacr);
1683 dia[i].base = conv_uni_to_8bit(
1684 accent_table[i].base);
1685 dia[i].result = conv_uni_to_8bit(
1686 accent_table[i].result);
1688 spin_unlock_irqrestore(&kbd_event_lock, flags);
1690 if (put_user(asize, &a->kb_cnt))
1692 else if (copy_to_user(a->kbdiacr, dia,
1693 asize * sizeof(struct kbdiacr)))
1700 struct kbdiacrsuc __user *a = udp;
1703 buf = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacruc),
1708 /* Lock the diacriticals table, make a copy and then
1709 copy it after we unlock */
1710 spin_lock_irqsave(&kbd_event_lock, flags);
1712 asize = accent_table_size;
1713 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1715 spin_unlock_irqrestore(&kbd_event_lock, flags);
1717 if (put_user(asize, &a->kb_cnt))
1719 else if (copy_to_user(a->kbdiacruc, buf,
1720 asize*sizeof(struct kbdiacruc)))
1728 struct kbdiacrs __user *a = udp;
1729 struct kbdiacr *dia = NULL;
1735 if (get_user(ct, &a->kb_cnt))
1737 if (ct >= MAX_DIACR)
1742 dia = memdup_user(a->kbdiacr,
1743 sizeof(struct kbdiacr) * ct);
1745 return PTR_ERR(dia);
1749 spin_lock_irqsave(&kbd_event_lock, flags);
1750 accent_table_size = ct;
1751 for (i = 0; i < ct; i++) {
1752 accent_table[i].diacr =
1753 conv_8bit_to_uni(dia[i].diacr);
1754 accent_table[i].base =
1755 conv_8bit_to_uni(dia[i].base);
1756 accent_table[i].result =
1757 conv_8bit_to_uni(dia[i].result);
1759 spin_unlock_irqrestore(&kbd_event_lock, flags);
1766 struct kbdiacrsuc __user *a = udp;
1773 if (get_user(ct, &a->kb_cnt))
1776 if (ct >= MAX_DIACR)
1780 buf = memdup_user(a->kbdiacruc,
1781 ct * sizeof(struct kbdiacruc));
1783 return PTR_ERR(buf);
1785 spin_lock_irqsave(&kbd_event_lock, flags);
1787 memcpy(accent_table, buf,
1788 ct * sizeof(struct kbdiacruc));
1789 accent_table_size = ct;
1790 spin_unlock_irqrestore(&kbd_event_lock, flags);
1799 * vt_do_kdskbmode - set keyboard mode ioctl
1800 * @console: the console to use
1801 * @arg: the requested mode
1803 * Update the keyboard mode bits while holding the correct locks.
1804 * Return 0 for success or an error code.
1806 int vt_do_kdskbmode(int console, unsigned int arg)
1808 struct kbd_struct *kb = kbd_table + console;
1810 unsigned long flags;
1812 spin_lock_irqsave(&kbd_event_lock, flags);
1815 kb->kbdmode = VC_RAW;
1818 kb->kbdmode = VC_MEDIUMRAW;
1821 kb->kbdmode = VC_XLATE;
1822 do_compute_shiftstate();
1825 kb->kbdmode = VC_UNICODE;
1826 do_compute_shiftstate();
1829 kb->kbdmode = VC_OFF;
1834 spin_unlock_irqrestore(&kbd_event_lock, flags);
1839 * vt_do_kdskbmeta - set keyboard meta state
1840 * @console: the console to use
1841 * @arg: the requested meta state
1843 * Update the keyboard meta bits while holding the correct locks.
1844 * Return 0 for success or an error code.
1846 int vt_do_kdskbmeta(int console, unsigned int arg)
1848 struct kbd_struct *kb = kbd_table + console;
1850 unsigned long flags;
1852 spin_lock_irqsave(&kbd_event_lock, flags);
1855 clr_vc_kbd_mode(kb, VC_META);
1858 set_vc_kbd_mode(kb, VC_META);
1863 spin_unlock_irqrestore(&kbd_event_lock, flags);
1867 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1870 struct kbkeycode tmp;
1873 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1877 kc = getkeycode(tmp.scancode);
1879 kc = put_user(kc, &user_kbkc->keycode);
1884 kc = setkeycode(tmp.scancode, tmp.keycode);
1890 #define i (tmp.kb_index)
1891 #define s (tmp.kb_table)
1892 #define v (tmp.kb_value)
1894 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1897 struct kbd_struct *kb = kbd_table + console;
1899 ushort *key_map, *new_map, val, ov;
1900 unsigned long flags;
1902 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1905 if (!capable(CAP_SYS_TTY_CONFIG))
1910 /* Ensure another thread doesn't free it under us */
1911 spin_lock_irqsave(&kbd_event_lock, flags);
1912 key_map = key_maps[s];
1914 val = U(key_map[i]);
1915 if (kb->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1918 val = (i ? K_HOLE : K_NOSUCHMAP);
1919 spin_unlock_irqrestore(&kbd_event_lock, flags);
1920 return put_user(val, &user_kbe->kb_value);
1924 if (!i && v == K_NOSUCHMAP) {
1925 spin_lock_irqsave(&kbd_event_lock, flags);
1926 /* deallocate map */
1927 key_map = key_maps[s];
1930 if (key_map[0] == U(K_ALLOCATED)) {
1935 spin_unlock_irqrestore(&kbd_event_lock, flags);
1939 if (KTYP(v) < NR_TYPES) {
1940 if (KVAL(v) > max_vals[KTYP(v)])
1943 if (kb->kbdmode != VC_UNICODE)
1946 /* ++Geert: non-PC keyboards may generate keycode zero */
1947 #if !defined(__mc68000__) && !defined(__powerpc__)
1948 /* assignment to entry 0 only tests validity of args */
1953 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1956 spin_lock_irqsave(&kbd_event_lock, flags);
1957 key_map = key_maps[s];
1958 if (key_map == NULL) {
1961 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1962 !capable(CAP_SYS_RESOURCE)) {
1963 spin_unlock_irqrestore(&kbd_event_lock, flags);
1967 key_maps[s] = new_map;
1969 key_map[0] = U(K_ALLOCATED);
1970 for (j = 1; j < NR_KEYS; j++)
1971 key_map[j] = U(K_HOLE);
1982 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1983 spin_unlock_irqrestore(&kbd_event_lock, flags);
1987 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1988 do_compute_shiftstate();
1990 spin_unlock_irqrestore(&kbd_event_lock, flags);
1999 /* FIXME: This one needs untangling */
2000 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
2002 struct kbsentry *kbs;
2006 char *first_free, *fj, *fnw;
2009 unsigned long flags;
2011 if (!capable(CAP_SYS_TTY_CONFIG))
2014 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
2020 /* we mostly copy too much here (512bytes), but who cares ;) */
2021 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
2025 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
2026 i = array_index_nospec(kbs->kb_func, MAX_NR_FUNC);
2030 /* size should have been a struct member */
2031 ssize_t len = sizeof(user_kdgkb->kb_string);
2033 spin_lock_irqsave(&func_buf_lock, flags);
2034 len = strlcpy(kbs->kb_string, func_table[i] ? : "", len);
2035 spin_unlock_irqrestore(&func_buf_lock, flags);
2037 ret = copy_to_user(user_kdgkb->kb_string, kbs->kb_string,
2038 len + 1) ? -EFAULT : 0;
2050 /* race aginst other writers */
2052 spin_lock_irqsave(&func_buf_lock, flags);
2055 /* fj pointer to next entry after 'q' */
2056 first_free = funcbufptr + (funcbufsize - funcbufleft);
2057 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
2059 if (j < MAX_NR_FUNC)
2063 /* buffer usage increase by new entry */
2064 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
2066 if (delta <= funcbufleft) { /* it fits in current buf */
2067 if (j < MAX_NR_FUNC) {
2068 /* make enough space for new entry at 'fj' */
2069 memmove(fj + delta, fj, first_free - fj);
2070 for (k = j; k < MAX_NR_FUNC; k++)
2072 func_table[k] += delta;
2076 funcbufleft -= delta;
2077 } else { /* allocate a larger buffer */
2079 while (sz < funcbufsize - funcbufleft + delta)
2082 spin_unlock_irqrestore(&func_buf_lock, flags);
2084 fnw = kmalloc(sz, GFP_KERNEL);
2095 /* copy data before insertion point to new location */
2096 if (fj > funcbufptr)
2097 memmove(fnw, funcbufptr, fj - funcbufptr);
2098 for (k = 0; k < j; k++)
2100 func_table[k] = fnw + (func_table[k] - funcbufptr);
2102 /* copy data after insertion point to new location */
2103 if (first_free > fj) {
2104 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
2105 for (k = j; k < MAX_NR_FUNC; k++)
2107 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
2109 if (funcbufptr != func_buf)
2112 funcbufleft = funcbufleft - delta + sz - funcbufsize;
2115 /* finally insert item itself */
2116 strcpy(func_table[i], kbs->kb_string);
2117 spin_unlock_irqrestore(&func_buf_lock, flags);
2126 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2128 struct kbd_struct *kb = kbd_table + console;
2129 unsigned long flags;
2130 unsigned char ucval;
2133 /* the ioctls below read/set the flags usually shown in the leds */
2134 /* don't use them - they will go away without warning */
2136 spin_lock_irqsave(&kbd_event_lock, flags);
2137 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2138 spin_unlock_irqrestore(&kbd_event_lock, flags);
2139 return put_user(ucval, (char __user *)arg);
2146 spin_lock_irqsave(&led_lock, flags);
2147 kb->ledflagstate = (arg & 7);
2148 kb->default_ledflagstate = ((arg >> 4) & 7);
2150 spin_unlock_irqrestore(&led_lock, flags);
2153 /* the ioctls below only set the lights, not the functions */
2154 /* for those, see KDGKBLED and KDSKBLED above */
2156 ucval = getledstate();
2157 return put_user(ucval, (char __user *)arg);
2162 setledstate(kb, arg);
2165 return -ENOIOCTLCMD;
2168 int vt_do_kdgkbmode(int console)
2170 struct kbd_struct *kb = kbd_table + console;
2171 /* This is a spot read so needs no locking */
2172 switch (kb->kbdmode) {
2187 * vt_do_kdgkbmeta - report meta status
2188 * @console: console to report
2190 * Report the meta flag status of this console
2192 int vt_do_kdgkbmeta(int console)
2194 struct kbd_struct *kb = kbd_table + console;
2195 /* Again a spot read so no locking */
2196 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2200 * vt_reset_unicode - reset the unicode status
2201 * @console: console being reset
2203 * Restore the unicode console state to its default
2205 void vt_reset_unicode(int console)
2207 unsigned long flags;
2209 spin_lock_irqsave(&kbd_event_lock, flags);
2210 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2211 spin_unlock_irqrestore(&kbd_event_lock, flags);
2215 * vt_get_shiftstate - shift bit state
2217 * Report the shift bits from the keyboard state. We have to export
2218 * this to support some oddities in the vt layer.
2220 int vt_get_shift_state(void)
2222 /* Don't lock as this is a transient report */
2227 * vt_reset_keyboard - reset keyboard state
2228 * @console: console to reset
2230 * Reset the keyboard bits for a console as part of a general console
2233 void vt_reset_keyboard(int console)
2235 struct kbd_struct *kb = kbd_table + console;
2236 unsigned long flags;
2238 spin_lock_irqsave(&kbd_event_lock, flags);
2239 set_vc_kbd_mode(kb, VC_REPEAT);
2240 clr_vc_kbd_mode(kb, VC_CKMODE);
2241 clr_vc_kbd_mode(kb, VC_APPLIC);
2242 clr_vc_kbd_mode(kb, VC_CRLF);
2245 spin_lock(&led_lock);
2246 kb->ledmode = LED_SHOW_FLAGS;
2247 kb->ledflagstate = kb->default_ledflagstate;
2248 spin_unlock(&led_lock);
2249 /* do not do set_leds here because this causes an endless tasklet loop
2250 when the keyboard hasn't been initialized yet */
2251 spin_unlock_irqrestore(&kbd_event_lock, flags);
2255 * vt_get_kbd_mode_bit - read keyboard status bits
2256 * @console: console to read from
2257 * @bit: mode bit to read
2259 * Report back a vt mode bit. We do this without locking so the
2260 * caller must be sure that there are no synchronization needs
2263 int vt_get_kbd_mode_bit(int console, int bit)
2265 struct kbd_struct *kb = kbd_table + console;
2266 return vc_kbd_mode(kb, bit);
2270 * vt_set_kbd_mode_bit - read keyboard status bits
2271 * @console: console to read from
2272 * @bit: mode bit to read
2274 * Set a vt mode bit. We do this without locking so the
2275 * caller must be sure that there are no synchronization needs
2278 void vt_set_kbd_mode_bit(int console, int bit)
2280 struct kbd_struct *kb = kbd_table + console;
2281 unsigned long flags;
2283 spin_lock_irqsave(&kbd_event_lock, flags);
2284 set_vc_kbd_mode(kb, bit);
2285 spin_unlock_irqrestore(&kbd_event_lock, flags);
2289 * vt_clr_kbd_mode_bit - read keyboard status bits
2290 * @console: console to read from
2291 * @bit: mode bit to read
2293 * Report back a vt mode bit. We do this without locking so the
2294 * caller must be sure that there are no synchronization needs
2297 void vt_clr_kbd_mode_bit(int console, int bit)
2299 struct kbd_struct *kb = kbd_table + console;
2300 unsigned long flags;
2302 spin_lock_irqsave(&kbd_event_lock, flags);
2303 clr_vc_kbd_mode(kb, bit);
2304 spin_unlock_irqrestore(&kbd_event_lock, flags);