2 * Written for linux by Johan Myreen as a translation from
3 * the assembly version by Linus (with diacriticals added)
5 * Some additional features added by Christoph Niemann (ChN), March 1993
7 * Loadable keymaps by Risto Kankkunen, May 1993
9 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
10 * Added decr/incr_console, dynamic keymaps, Unicode support,
11 * dynamic function/string keys, led setting, Sept 1994
12 * `Sticky' modifier keys, 951006.
14 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
16 * Modified to provide 'generic' keyboard support by Hamish Macdonald
17 * Merge with the m68k keyboard driver and split-off of the PC low-level
18 * parts by Geert Uytterhoeven, May 1997
20 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
21 * 30-07-98: Dead keys redone, aeb@cwi.nl.
22 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27 #include <linux/consolemap.h>
28 #include <linux/module.h>
29 #include <linux/sched.h>
30 #include <linux/tty.h>
31 #include <linux/tty_flip.h>
33 #include <linux/string.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
37 #include <linux/kbd_kern.h>
38 #include <linux/kbd_diacr.h>
39 #include <linux/vt_kern.h>
40 #include <linux/input.h>
41 #include <linux/reboot.h>
42 #include <linux/notifier.h>
43 #include <linux/jiffies.h>
44 #include <linux/uaccess.h>
46 #include <asm/irq_regs.h>
48 extern void ctrl_alt_del(void);
51 * Exported functions/variables
54 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
57 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
58 * This seems a good reason to start with NumLock off. On HIL keyboards
59 * of PARISC machines however there is no NumLock key and everyone expects the
60 * keypad to be used for numbers.
63 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
64 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
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 unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
127 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
128 static bool dead_key_next;
129 static int npadch = -1; /* -1 or number assembled on pad */
130 static unsigned int diacr;
131 static char rep; /* flag telling character repeat */
133 static int shift_state = 0;
135 static unsigned char ledstate = 0xff; /* undefined */
136 static unsigned char ledioctl;
138 static struct ledptr {
141 unsigned char valid:1;
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(unsigned long ignored)
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, 0, 0);
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 *rep = data;
282 if (test_bit(EV_REP, dev->evbit)) {
284 if (rep[0].delay > 0)
285 input_inject_event(handle,
286 EV_REP, REP_DELAY, rep[0].delay);
287 if (rep[0].period > 0)
288 input_inject_event(handle,
289 EV_REP, REP_PERIOD, rep[0].period);
291 rep[1].delay = dev->rep[REP_DELAY];
292 rep[1].period = dev->rep[REP_PERIOD];
298 int kbd_rate(struct kbd_repeat *rep)
300 struct kbd_repeat data[2] = { *rep };
302 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
303 *rep = data[1]; /* Copy currently used settings */
311 static void put_queue(struct vc_data *vc, int ch)
313 struct tty_struct *tty = vc->port.tty;
316 tty_insert_flip_char(tty, ch, 0);
317 con_schedule_flip(tty);
321 static void puts_queue(struct vc_data *vc, char *cp)
323 struct tty_struct *tty = vc->port.tty;
329 tty_insert_flip_char(tty, *cp, 0);
332 con_schedule_flip(tty);
335 static void applkey(struct vc_data *vc, int key, char mode)
337 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
339 buf[1] = (mode ? 'O' : '[');
345 * Many other routines do put_queue, but I think either
346 * they produce ASCII, or they produce some user-assigned
347 * string, and in both cases we might assume that it is
350 static void to_utf8(struct vc_data *vc, uint c)
355 else if (c < 0x800) {
356 /* 110***** 10****** */
357 put_queue(vc, 0xc0 | (c >> 6));
358 put_queue(vc, 0x80 | (c & 0x3f));
359 } else if (c < 0x10000) {
360 if (c >= 0xD800 && c < 0xE000)
364 /* 1110**** 10****** 10****** */
365 put_queue(vc, 0xe0 | (c >> 12));
366 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
367 put_queue(vc, 0x80 | (c & 0x3f));
368 } else if (c < 0x110000) {
369 /* 11110*** 10****** 10****** 10****** */
370 put_queue(vc, 0xf0 | (c >> 18));
371 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
372 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
373 put_queue(vc, 0x80 | (c & 0x3f));
378 * Called after returning from RAW mode or when changing consoles - recompute
379 * shift_down[] and shift_state from key_down[] maybe called when keymap is
380 * undefined, so that shiftkey release is seen. The caller must hold the
384 static void do_compute_shiftstate(void)
386 unsigned int i, j, k, sym, val;
389 memset(shift_down, 0, sizeof(shift_down));
391 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
396 k = i * BITS_PER_LONG;
398 for (j = 0; j < BITS_PER_LONG; j++, k++) {
400 if (!test_bit(k, key_down))
403 sym = U(key_maps[0][k]);
404 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
408 if (val == KVAL(K_CAPSSHIFT))
412 shift_state |= (1 << val);
417 /* We still have to export this method to vt.c */
418 void compute_shiftstate(void)
421 spin_lock_irqsave(&kbd_event_lock, flags);
422 do_compute_shiftstate();
423 spin_unlock_irqrestore(&kbd_event_lock, flags);
427 * We have a combining character DIACR here, followed by the character CH.
428 * If the combination occurs in the table, return the corresponding value.
429 * Otherwise, if CH is a space or equals DIACR, return DIACR.
430 * Otherwise, conclude that DIACR was not combining after all,
431 * queue it and return CH.
433 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
435 unsigned int d = diacr;
440 if ((d & ~0xff) == BRL_UC_ROW) {
441 if ((ch & ~0xff) == BRL_UC_ROW)
444 for (i = 0; i < accent_table_size; i++)
445 if (accent_table[i].diacr == d && accent_table[i].base == ch)
446 return accent_table[i].result;
449 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
452 if (kbd->kbdmode == VC_UNICODE)
455 int c = conv_uni_to_8bit(d);
464 * Special function handlers
466 static void fn_enter(struct vc_data *vc)
469 if (kbd->kbdmode == VC_UNICODE)
472 int c = conv_uni_to_8bit(diacr);
480 if (vc_kbd_mode(kbd, VC_CRLF))
484 static void fn_caps_toggle(struct vc_data *vc)
489 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
492 static void fn_caps_on(struct vc_data *vc)
497 set_vc_kbd_led(kbd, VC_CAPSLOCK);
500 static void fn_show_ptregs(struct vc_data *vc)
502 struct pt_regs *regs = get_irq_regs();
508 static void fn_hold(struct vc_data *vc)
510 struct tty_struct *tty = vc->port.tty;
516 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
517 * these routines are also activated by ^S/^Q.
518 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
526 static void fn_num(struct vc_data *vc)
528 if (vc_kbd_mode(kbd, VC_APPLIC))
535 * Bind this to Shift-NumLock if you work in application keypad mode
536 * but want to be able to change the NumLock flag.
537 * Bind this to NumLock if you prefer that the NumLock key always
538 * changes the NumLock flag.
540 static void fn_bare_num(struct vc_data *vc)
543 chg_vc_kbd_led(kbd, VC_NUMLOCK);
546 static void fn_lastcons(struct vc_data *vc)
548 /* switch to the last used console, ChN */
549 set_console(last_console);
552 static void fn_dec_console(struct vc_data *vc)
554 int i, cur = fg_console;
556 /* Currently switching? Queue this next switch relative to that. */
557 if (want_console != -1)
560 for (i = cur - 1; i != cur; i--) {
562 i = MAX_NR_CONSOLES - 1;
563 if (vc_cons_allocated(i))
569 static void fn_inc_console(struct vc_data *vc)
571 int i, cur = fg_console;
573 /* Currently switching? Queue this next switch relative to that. */
574 if (want_console != -1)
577 for (i = cur+1; i != cur; i++) {
578 if (i == MAX_NR_CONSOLES)
580 if (vc_cons_allocated(i))
586 static void fn_send_intr(struct vc_data *vc)
588 struct tty_struct *tty = vc->port.tty;
592 tty_insert_flip_char(tty, 0, TTY_BREAK);
593 con_schedule_flip(tty);
596 static void fn_scroll_forw(struct vc_data *vc)
601 static void fn_scroll_back(struct vc_data *vc)
606 static void fn_show_mem(struct vc_data *vc)
611 static void fn_show_state(struct vc_data *vc)
616 static void fn_boot_it(struct vc_data *vc)
621 static void fn_compose(struct vc_data *vc)
623 dead_key_next = true;
626 static void fn_spawn_con(struct vc_data *vc)
628 spin_lock(&vt_spawn_con.lock);
629 if (vt_spawn_con.pid)
630 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
631 put_pid(vt_spawn_con.pid);
632 vt_spawn_con.pid = NULL;
634 spin_unlock(&vt_spawn_con.lock);
637 static void fn_SAK(struct vc_data *vc)
639 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
640 schedule_work(SAK_work);
643 static void fn_null(struct vc_data *vc)
645 do_compute_shiftstate();
649 * Special key handlers
651 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
655 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
659 if (value >= ARRAY_SIZE(fn_handler))
661 if ((kbd->kbdmode == VC_RAW ||
662 kbd->kbdmode == VC_MEDIUMRAW ||
663 kbd->kbdmode == VC_OFF) &&
664 value != KVAL(K_SAK))
665 return; /* SAK is allowed even in raw mode */
666 fn_handler[value](vc);
669 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
671 pr_err("k_lowercase was called - impossible\n");
674 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
677 return; /* no action, if this is a key release */
680 value = handle_diacr(vc, value);
683 dead_key_next = false;
687 if (kbd->kbdmode == VC_UNICODE)
690 int c = conv_uni_to_8bit(value);
697 * Handle dead key. Note that we now may have several
698 * dead keys modifying the same character. Very useful
701 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
706 diacr = (diacr ? handle_diacr(vc, value) : value);
709 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
711 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
714 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
716 k_deadunicode(vc, value, up_flag);
720 * Obsolete - for backwards compatibility only
722 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
724 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
726 k_deadunicode(vc, ret_diacr[value], up_flag);
729 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
737 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
742 if ((unsigned)value < ARRAY_SIZE(func_table)) {
743 if (func_table[value])
744 puts_queue(vc, func_table[value]);
746 pr_err("k_fn called with value=%d\n", value);
749 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
751 static const char cur_chars[] = "BDCA";
756 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
759 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
761 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
762 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
765 return; /* no action, if this is a key release */
767 /* kludge... shift forces cursor/number keys */
768 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
769 applkey(vc, app_map[value], 1);
773 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
778 k_fn(vc, KVAL(K_REMOVE), 0);
781 k_fn(vc, KVAL(K_INSERT), 0);
784 k_fn(vc, KVAL(K_SELECT), 0);
787 k_cur(vc, KVAL(K_DOWN), 0);
790 k_fn(vc, KVAL(K_PGDN), 0);
793 k_cur(vc, KVAL(K_LEFT), 0);
796 k_cur(vc, KVAL(K_RIGHT), 0);
799 k_fn(vc, KVAL(K_FIND), 0);
802 k_cur(vc, KVAL(K_UP), 0);
805 k_fn(vc, KVAL(K_PGUP), 0);
808 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
813 put_queue(vc, pad_chars[value]);
814 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
818 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
820 int old_state = shift_state;
826 * a CapsShift key acts like Shift but undoes CapsLock
828 if (value == KVAL(K_CAPSSHIFT)) {
829 value = KVAL(K_SHIFT);
831 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
836 * handle the case that two shift or control
837 * keys are depressed simultaneously
839 if (shift_down[value])
844 if (shift_down[value])
845 shift_state |= (1 << value);
847 shift_state &= ~(1 << value);
850 if (up_flag && shift_state != old_state && npadch != -1) {
851 if (kbd->kbdmode == VC_UNICODE)
854 put_queue(vc, npadch & 0xff);
859 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
864 if (vc_kbd_mode(kbd, VC_META)) {
865 put_queue(vc, '\033');
866 put_queue(vc, value);
868 put_queue(vc, value | 0x80);
871 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
879 /* decimal input of code, while Alt depressed */
882 /* hexadecimal input of code, while AltGr depressed */
890 npadch = npadch * base + value;
893 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
898 chg_vc_kbd_lock(kbd, value);
901 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
903 k_shift(vc, value, up_flag);
907 chg_vc_kbd_slock(kbd, value);
908 /* try to make Alt, oops, AltGr and such work */
909 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
911 chg_vc_kbd_slock(kbd, value);
915 /* by default, 300ms interval for combination release */
916 static unsigned brl_timeout = 300;
917 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
918 module_param(brl_timeout, uint, 0644);
920 static unsigned brl_nbchords = 1;
921 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
922 module_param(brl_nbchords, uint, 0644);
924 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
926 static unsigned long chords;
927 static unsigned committed;
930 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
932 committed |= pattern;
934 if (chords == brl_nbchords) {
935 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
942 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
944 static unsigned pressed, committing;
945 static unsigned long releasestart;
947 if (kbd->kbdmode != VC_UNICODE) {
949 pr_warning("keyboard mode must be unicode for braille patterns\n");
954 k_unicode(vc, BRL_UC_ROW, up_flag);
962 pressed |= 1 << (value - 1);
964 committing = pressed;
965 } else if (brl_timeout) {
968 releasestart + msecs_to_jiffies(brl_timeout))) {
969 committing = pressed;
970 releasestart = jiffies;
972 pressed &= ~(1 << (value - 1));
973 if (!pressed && committing) {
974 k_brlcommit(vc, committing, 0);
979 k_brlcommit(vc, committing, 0);
982 pressed &= ~(1 << (value - 1));
987 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
988 * or (ii) whatever pattern of lights people want to show using KDSETLED,
989 * or (iii) specified bits of specified words in kernel memory.
991 unsigned char getledstate(void)
996 void setledstate(struct kbd_struct *kbd, unsigned int led)
999 spin_lock_irqsave(&kbd_event_lock, flags);
1002 kbd->ledmode = LED_SHOW_IOCTL;
1004 kbd->ledmode = LED_SHOW_FLAGS;
1007 spin_unlock_irqrestore(&kbd_event_lock, flags);
1010 static inline unsigned char getleds(void)
1012 struct kbd_struct *kbd = kbd_table + fg_console;
1016 if (kbd->ledmode == LED_SHOW_IOCTL)
1019 leds = kbd->ledflagstate;
1021 if (kbd->ledmode == LED_SHOW_MEM) {
1022 for (i = 0; i < 3; i++)
1023 if (ledptrs[i].valid) {
1024 if (*ledptrs[i].addr & ledptrs[i].mask)
1033 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1035 unsigned char leds = *(unsigned char *)data;
1037 if (test_bit(EV_LED, handle->dev->evbit)) {
1038 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1039 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1040 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1041 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1048 * vt_get_leds - helper for braille console
1049 * @console: console to read
1050 * @flag: flag we want to check
1052 * Check the status of a keyboard led flag and report it back
1054 int vt_get_leds(int console, int flag)
1056 unsigned long flags;
1057 struct kbd_struct * kbd = kbd_table + console;
1060 spin_lock_irqsave(&kbd_event_lock, flags);
1061 ret = vc_kbd_led(kbd, flag);
1062 spin_unlock_irqrestore(&kbd_event_lock, flags);
1066 EXPORT_SYMBOL_GPL(vt_get_leds);
1069 * vt_set_led_state - set LED state of a console
1070 * @console: console to set
1073 * Set the LEDs on a console. This is a wrapper for the VT layer
1074 * so that we can keep kbd knowledge internal
1076 void vt_set_led_state(int console, int leds)
1078 struct kbd_struct * kbd = kbd_table + console;
1079 setledstate(kbd, leds);
1083 * vt_kbd_con_start - Keyboard side of console start
1086 * Handle console start. This is a wrapper for the VT layer
1087 * so that we can keep kbd knowledge internal
1089 * FIXME: We eventually need to hold the kbd lock here to protect
1090 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1091 * and start_tty under the kbd_event_lock, while normal tty paths
1092 * don't hold the lock. We probably need to split out an LED lock
1093 * but not during an -rc release!
1095 void vt_kbd_con_start(int console)
1097 struct kbd_struct * kbd = kbd_table + console;
1098 /* unsigned long flags; */
1099 /* spin_lock_irqsave(&kbd_event_lock, flags); */
1100 clr_vc_kbd_led(kbd, VC_SCROLLOCK);
1102 /* spin_unlock_irqrestore(&kbd_event_lock, flags); */
1106 * vt_kbd_con_stop - Keyboard side of console stop
1109 * Handle console stop. This is a wrapper for the VT layer
1110 * so that we can keep kbd knowledge internal
1112 * FIXME: We eventually need to hold the kbd lock here to protect
1113 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1114 * and start_tty under the kbd_event_lock, while normal tty paths
1115 * don't hold the lock. We probably need to split out an LED lock
1116 * but not during an -rc release!
1118 void vt_kbd_con_stop(int console)
1120 struct kbd_struct * kbd = kbd_table + console;
1121 /* unsigned long flags; */
1122 /* spin_lock_irqsave(&kbd_event_lock, flags); */
1123 set_vc_kbd_led(kbd, VC_SCROLLOCK);
1125 /* spin_unlock_irqrestore(&kbd_event_lock, flags); */
1129 * This is the tasklet that updates LED state on all keyboards
1130 * attached to the box. The reason we use tasklet is that we
1131 * need to handle the scenario when keyboard handler is not
1132 * registered yet but we already getting updates from the VT to
1135 static void kbd_bh(unsigned long dummy)
1137 unsigned char leds = getleds();
1139 if (leds != ledstate) {
1140 input_handler_for_each_handle(&kbd_handler, &leds,
1141 kbd_update_leds_helper);
1146 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1148 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1149 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1150 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1151 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1152 defined(CONFIG_AVR32)
1154 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1155 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1157 static const unsigned short x86_keycodes[256] =
1158 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1159 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1160 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1161 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1162 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1163 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1164 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1165 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1166 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1167 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1168 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1169 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1170 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1171 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1172 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1175 static int sparc_l1_a_state;
1176 extern void sun_do_break(void);
1179 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1180 unsigned char up_flag)
1187 put_queue(vc, 0xe1);
1188 put_queue(vc, 0x1d | up_flag);
1189 put_queue(vc, 0x45 | up_flag);
1194 put_queue(vc, 0xf2);
1199 put_queue(vc, 0xf1);
1204 * Real AT keyboards (that's what we're trying
1205 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1206 * pressing PrtSc/SysRq alone, but simply 0x54
1207 * when pressing Alt+PrtSc/SysRq.
1209 if (test_bit(KEY_LEFTALT, key_down) ||
1210 test_bit(KEY_RIGHTALT, key_down)) {
1211 put_queue(vc, 0x54 | up_flag);
1213 put_queue(vc, 0xe0);
1214 put_queue(vc, 0x2a | up_flag);
1215 put_queue(vc, 0xe0);
1216 put_queue(vc, 0x37 | up_flag);
1224 code = x86_keycodes[keycode];
1229 put_queue(vc, 0xe0);
1230 put_queue(vc, (code & 0x7f) | up_flag);
1240 #define HW_RAW(dev) 0
1242 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1247 put_queue(vc, keycode | up_flag);
1252 static void kbd_rawcode(unsigned char data)
1254 struct vc_data *vc = vc_cons[fg_console].d;
1256 kbd = kbd_table + vc->vc_num;
1257 if (kbd->kbdmode == VC_RAW)
1258 put_queue(vc, data);
1261 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1263 struct vc_data *vc = vc_cons[fg_console].d;
1264 unsigned short keysym, *key_map;
1267 struct tty_struct *tty;
1269 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1274 if (tty && (!tty->driver_data)) {
1275 /* No driver data? Strange. Okay we fix it then. */
1276 tty->driver_data = vc;
1279 kbd = kbd_table + vc->vc_num;
1282 if (keycode == KEY_STOP)
1283 sparc_l1_a_state = down;
1288 raw_mode = (kbd->kbdmode == VC_RAW);
1289 if (raw_mode && !hw_raw)
1290 if (emulate_raw(vc, keycode, !down << 7))
1291 if (keycode < BTN_MISC && printk_ratelimit())
1292 pr_warning("can't emulate rawmode for keycode %d\n",
1296 if (keycode == KEY_A && sparc_l1_a_state) {
1297 sparc_l1_a_state = false;
1302 if (kbd->kbdmode == VC_MEDIUMRAW) {
1304 * This is extended medium raw mode, with keys above 127
1305 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1306 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1307 * interfere with anything else. The two bytes after 0 will
1308 * always have the up flag set not to interfere with older
1309 * applications. This allows for 16384 different keycodes,
1310 * which should be enough.
1312 if (keycode < 128) {
1313 put_queue(vc, keycode | (!down << 7));
1315 put_queue(vc, !down << 7);
1316 put_queue(vc, (keycode >> 7) | 0x80);
1317 put_queue(vc, keycode | 0x80);
1323 set_bit(keycode, key_down);
1325 clear_bit(keycode, key_down);
1328 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1329 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1331 * Don't repeat a key if the input buffers are not empty and the
1332 * characters get aren't echoed locally. This makes key repeat
1333 * usable with slow applications and under heavy loads.
1338 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1339 param.ledstate = kbd->ledflagstate;
1340 key_map = key_maps[shift_final];
1342 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1343 KBD_KEYCODE, ¶m);
1344 if (rc == NOTIFY_STOP || !key_map) {
1345 atomic_notifier_call_chain(&keyboard_notifier_list,
1346 KBD_UNBOUND_KEYCODE, ¶m);
1347 do_compute_shiftstate();
1348 kbd->slockstate = 0;
1352 if (keycode < NR_KEYS)
1353 keysym = key_map[keycode];
1354 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1355 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1359 type = KTYP(keysym);
1362 param.value = keysym;
1363 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1364 KBD_UNICODE, ¶m);
1365 if (rc != NOTIFY_STOP)
1366 if (down && !raw_mode)
1367 to_utf8(vc, keysym);
1373 if (type == KT_LETTER) {
1375 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1376 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1378 keysym = key_map[keycode];
1382 param.value = keysym;
1383 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1384 KBD_KEYSYM, ¶m);
1385 if (rc == NOTIFY_STOP)
1388 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1391 (*k_handler[type])(vc, keysym & 0xff, !down);
1393 param.ledstate = kbd->ledflagstate;
1394 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1396 if (type != KT_SLOCK)
1397 kbd->slockstate = 0;
1400 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1401 unsigned int event_code, int value)
1403 /* We are called with interrupts disabled, just take the lock */
1404 spin_lock(&kbd_event_lock);
1406 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1408 if (event_type == EV_KEY)
1409 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1411 spin_unlock(&kbd_event_lock);
1413 tasklet_schedule(&keyboard_tasklet);
1414 do_poke_blanked_console = 1;
1415 schedule_console_callback();
1418 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1422 if (test_bit(EV_SND, dev->evbit))
1425 if (test_bit(EV_KEY, dev->evbit)) {
1426 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1427 if (test_bit(i, dev->keybit))
1429 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1430 if (test_bit(i, dev->keybit))
1438 * When a keyboard (or other input device) is found, the kbd_connect
1439 * function is called. The function then looks at the device, and if it
1440 * likes it, it can open it and get events from it. In this (kbd_connect)
1441 * function, we should decide which VT to bind that keyboard to initially.
1443 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1444 const struct input_device_id *id)
1446 struct input_handle *handle;
1449 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1454 handle->handler = handler;
1455 handle->name = "kbd";
1457 error = input_register_handle(handle);
1459 goto err_free_handle;
1461 error = input_open_device(handle);
1463 goto err_unregister_handle;
1467 err_unregister_handle:
1468 input_unregister_handle(handle);
1474 static void kbd_disconnect(struct input_handle *handle)
1476 input_close_device(handle);
1477 input_unregister_handle(handle);
1482 * Start keyboard handler on the new keyboard by refreshing LED state to
1483 * match the rest of the system.
1485 static void kbd_start(struct input_handle *handle)
1487 tasklet_disable(&keyboard_tasklet);
1489 if (ledstate != 0xff)
1490 kbd_update_leds_helper(handle, &ledstate);
1492 tasklet_enable(&keyboard_tasklet);
1495 static const struct input_device_id kbd_ids[] = {
1497 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1498 .evbit = { BIT_MASK(EV_KEY) },
1502 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1503 .evbit = { BIT_MASK(EV_SND) },
1506 { }, /* Terminating entry */
1509 MODULE_DEVICE_TABLE(input, kbd_ids);
1511 static struct input_handler kbd_handler = {
1514 .connect = kbd_connect,
1515 .disconnect = kbd_disconnect,
1518 .id_table = kbd_ids,
1521 int __init kbd_init(void)
1526 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1527 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1528 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1529 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1530 kbd_table[i].lockstate = KBD_DEFLOCK;
1531 kbd_table[i].slockstate = 0;
1532 kbd_table[i].modeflags = KBD_DEFMODE;
1533 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1536 error = input_register_handler(&kbd_handler);
1540 tasklet_enable(&keyboard_tasklet);
1541 tasklet_schedule(&keyboard_tasklet);
1546 /* Ioctl support code */
1549 * vt_do_diacrit - diacritical table updates
1550 * @cmd: ioctl request
1551 * @up: pointer to user data for ioctl
1552 * @perm: permissions check computed by caller
1554 * Update the diacritical tables atomically and safely. Lock them
1555 * against simultaneous keypresses
1557 int vt_do_diacrit(unsigned int cmd, void __user *up, int perm)
1559 struct kbdiacrs __user *a = up;
1560 unsigned long flags;
1567 struct kbdiacr *diacr;
1570 diacr = kmalloc(MAX_DIACR * sizeof(struct kbdiacr),
1575 /* Lock the diacriticals table, make a copy and then
1576 copy it after we unlock */
1577 spin_lock_irqsave(&kbd_event_lock, flags);
1579 asize = accent_table_size;
1580 for (i = 0; i < asize; i++) {
1581 diacr[i].diacr = conv_uni_to_8bit(
1582 accent_table[i].diacr);
1583 diacr[i].base = conv_uni_to_8bit(
1584 accent_table[i].base);
1585 diacr[i].result = conv_uni_to_8bit(
1586 accent_table[i].result);
1588 spin_unlock_irqrestore(&kbd_event_lock, flags);
1590 if (put_user(asize, &a->kb_cnt))
1592 else if (copy_to_user(a->kbdiacr, diacr,
1593 asize * sizeof(struct kbdiacr)))
1600 struct kbdiacrsuc __user *a = up;
1603 buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc),
1608 /* Lock the diacriticals table, make a copy and then
1609 copy it after we unlock */
1610 spin_lock_irqsave(&kbd_event_lock, flags);
1612 asize = accent_table_size;
1613 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1615 spin_unlock_irqrestore(&kbd_event_lock, flags);
1617 if (put_user(asize, &a->kb_cnt))
1619 else if (copy_to_user(a->kbdiacruc, buf,
1620 asize*sizeof(struct kbdiacruc)))
1628 struct kbdiacrs __user *a = up;
1629 struct kbdiacr *diacr = NULL;
1635 if (get_user(ct, &a->kb_cnt))
1637 if (ct >= MAX_DIACR)
1641 diacr = kmalloc(sizeof(struct kbdiacr) * ct,
1646 if (copy_from_user(diacr, a->kbdiacr,
1647 sizeof(struct kbdiacr) * ct)) {
1653 spin_lock_irqsave(&kbd_event_lock, flags);
1654 accent_table_size = ct;
1655 for (i = 0; i < ct; i++) {
1656 accent_table[i].diacr =
1657 conv_8bit_to_uni(diacr[i].diacr);
1658 accent_table[i].base =
1659 conv_8bit_to_uni(diacr[i].base);
1660 accent_table[i].result =
1661 conv_8bit_to_uni(diacr[i].result);
1663 spin_unlock_irqrestore(&kbd_event_lock, flags);
1670 struct kbdiacrsuc __user *a = up;
1677 if (get_user(ct, &a->kb_cnt))
1680 if (ct >= MAX_DIACR)
1684 buf = kmalloc(ct * sizeof(struct kbdiacruc),
1689 if (copy_from_user(buf, a->kbdiacruc,
1690 ct * sizeof(struct kbdiacruc))) {
1695 spin_lock_irqsave(&kbd_event_lock, flags);
1697 memcpy(accent_table, buf,
1698 ct * sizeof(struct kbdiacruc));
1699 accent_table_size = ct;
1700 spin_unlock_irqrestore(&kbd_event_lock, flags);
1709 * vt_do_kdskbmode - set keyboard mode ioctl
1710 * @console: the console to use
1711 * @arg: the requested mode
1713 * Update the keyboard mode bits while holding the correct locks.
1714 * Return 0 for success or an error code.
1716 int vt_do_kdskbmode(int console, unsigned int arg)
1718 struct kbd_struct * kbd = kbd_table + console;
1720 unsigned long flags;
1722 spin_lock_irqsave(&kbd_event_lock, flags);
1725 kbd->kbdmode = VC_RAW;
1728 kbd->kbdmode = VC_MEDIUMRAW;
1731 kbd->kbdmode = VC_XLATE;
1732 do_compute_shiftstate();
1735 kbd->kbdmode = VC_UNICODE;
1736 do_compute_shiftstate();
1739 kbd->kbdmode = VC_OFF;
1744 spin_unlock_irqrestore(&kbd_event_lock, flags);
1749 * vt_do_kdskbmeta - set keyboard meta state
1750 * @console: the console to use
1751 * @arg: the requested meta state
1753 * Update the keyboard meta bits while holding the correct locks.
1754 * Return 0 for success or an error code.
1756 int vt_do_kdskbmeta(int console, unsigned int arg)
1758 struct kbd_struct * kbd = kbd_table + console;
1760 unsigned long flags;
1762 spin_lock_irqsave(&kbd_event_lock, flags);
1765 clr_vc_kbd_mode(kbd, VC_META);
1768 set_vc_kbd_mode(kbd, VC_META);
1773 spin_unlock_irqrestore(&kbd_event_lock, flags);
1777 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1780 struct kbkeycode tmp;
1783 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1787 kc = getkeycode(tmp.scancode);
1789 kc = put_user(kc, &user_kbkc->keycode);
1794 kc = setkeycode(tmp.scancode, tmp.keycode);
1800 #define i (tmp.kb_index)
1801 #define s (tmp.kb_table)
1802 #define v (tmp.kb_value)
1804 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1807 struct kbd_struct * kbd = kbd_table + console;
1809 ushort *key_map, *new_map, val, ov;
1810 unsigned long flags;
1812 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1815 if (!capable(CAP_SYS_TTY_CONFIG))
1820 /* Ensure another thread doesn't free it under us */
1821 spin_lock_irqsave(&kbd_event_lock, flags);
1822 key_map = key_maps[s];
1824 val = U(key_map[i]);
1825 if (kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1828 val = (i ? K_HOLE : K_NOSUCHMAP);
1829 spin_unlock_irqrestore(&kbd_event_lock, flags);
1830 return put_user(val, &user_kbe->kb_value);
1834 if (!i && v == K_NOSUCHMAP) {
1835 spin_lock_irqsave(&kbd_event_lock, flags);
1836 /* deallocate map */
1837 key_map = key_maps[s];
1840 if (key_map[0] == U(K_ALLOCATED)) {
1845 spin_unlock_irqrestore(&kbd_event_lock, flags);
1849 if (KTYP(v) < NR_TYPES) {
1850 if (KVAL(v) > max_vals[KTYP(v)])
1853 if (kbd->kbdmode != VC_UNICODE)
1856 /* ++Geert: non-PC keyboards may generate keycode zero */
1857 #if !defined(__mc68000__) && !defined(__powerpc__)
1858 /* assignment to entry 0 only tests validity of args */
1863 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1866 spin_lock_irqsave(&kbd_event_lock, flags);
1867 key_map = key_maps[s];
1868 if (key_map == NULL) {
1871 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1872 !capable(CAP_SYS_RESOURCE)) {
1873 spin_unlock_irqrestore(&kbd_event_lock, flags);
1877 key_maps[s] = new_map;
1879 key_map[0] = U(K_ALLOCATED);
1880 for (j = 1; j < NR_KEYS; j++)
1881 key_map[j] = U(K_HOLE);
1892 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1893 spin_unlock_irqrestore(&kbd_event_lock, flags);
1897 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1898 do_compute_shiftstate();
1900 spin_unlock_irqrestore(&kbd_event_lock, flags);
1909 /* FIXME: This one needs untangling and locking */
1910 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1912 struct kbsentry *kbs;
1918 char *first_free, *fj, *fnw;
1922 if (!capable(CAP_SYS_TTY_CONFIG))
1925 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
1931 /* we mostly copy too much here (512bytes), but who cares ;) */
1932 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
1936 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
1941 sz = sizeof(kbs->kb_string) - 1; /* sz should have been
1943 up = user_kdgkb->kb_string;
1946 for ( ; *p && sz; p++, sz--)
1947 if (put_user(*p, up++)) {
1951 if (put_user('\0', up)) {
1956 return ((p && *p) ? -EOVERFLOW : 0);
1964 first_free = funcbufptr + (funcbufsize - funcbufleft);
1965 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
1967 if (j < MAX_NR_FUNC)
1972 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
1973 if (delta <= funcbufleft) { /* it fits in current buf */
1974 if (j < MAX_NR_FUNC) {
1975 memmove(fj + delta, fj, first_free - fj);
1976 for (k = j; k < MAX_NR_FUNC; k++)
1978 func_table[k] += delta;
1982 funcbufleft -= delta;
1983 } else { /* allocate a larger buffer */
1985 while (sz < funcbufsize - funcbufleft + delta)
1987 fnw = kmalloc(sz, GFP_KERNEL);
1995 if (fj > funcbufptr)
1996 memmove(fnw, funcbufptr, fj - funcbufptr);
1997 for (k = 0; k < j; k++)
1999 func_table[k] = fnw + (func_table[k] - funcbufptr);
2001 if (first_free > fj) {
2002 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
2003 for (k = j; k < MAX_NR_FUNC; k++)
2005 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
2007 if (funcbufptr != func_buf)
2010 funcbufleft = funcbufleft - delta + sz - funcbufsize;
2013 strcpy(func_table[i], kbs->kb_string);
2022 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2024 struct kbd_struct * kbd = kbd_table + console;
2025 unsigned long flags;
2026 unsigned char ucval;
2029 /* the ioctls below read/set the flags usually shown in the leds */
2030 /* don't use them - they will go away without warning */
2032 spin_lock_irqsave(&kbd_event_lock, flags);
2033 ucval = kbd->ledflagstate | (kbd->default_ledflagstate << 4);
2034 spin_unlock_irqrestore(&kbd_event_lock, flags);
2035 return put_user(ucval, (char __user *)arg);
2042 spin_lock_irqsave(&kbd_event_lock, flags);
2043 kbd->ledflagstate = (arg & 7);
2044 kbd->default_ledflagstate = ((arg >> 4) & 7);
2046 spin_unlock_irqrestore(&kbd_event_lock, flags);
2049 /* the ioctls below only set the lights, not the functions */
2050 /* for those, see KDGKBLED and KDSKBLED above */
2052 ucval = getledstate();
2053 return put_user(ucval, (char __user *)arg);
2058 setledstate(kbd, arg);
2061 return -ENOIOCTLCMD;
2064 int vt_do_kdgkbmode(int console)
2066 struct kbd_struct * kbd = kbd_table + console;
2067 /* This is a spot read so needs no locking */
2068 switch (kbd->kbdmode) {
2083 * vt_do_kdgkbmeta - report meta status
2084 * @console: console to report
2086 * Report the meta flag status of this console
2088 int vt_do_kdgkbmeta(int console)
2090 struct kbd_struct * kbd = kbd_table + console;
2091 /* Again a spot read so no locking */
2092 return vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX : K_METABIT;
2096 * vt_reset_unicode - reset the unicode status
2097 * @console: console being reset
2099 * Restore the unicode console state to its default
2101 void vt_reset_unicode(int console)
2103 unsigned long flags;
2105 spin_lock_irqsave(&kbd_event_lock, flags);
2106 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2107 spin_unlock_irqrestore(&kbd_event_lock, flags);
2111 * vt_get_shiftstate - shift bit state
2113 * Report the shift bits from the keyboard state. We have to export
2114 * this to support some oddities in the vt layer.
2116 int vt_get_shift_state(void)
2118 /* Don't lock as this is a transient report */
2123 * vt_reset_keyboard - reset keyboard state
2124 * @console: console to reset
2126 * Reset the keyboard bits for a console as part of a general console
2129 void vt_reset_keyboard(int console)
2131 struct kbd_struct * kbd = kbd_table + console;
2132 unsigned long flags;
2134 spin_lock_irqsave(&kbd_event_lock, flags);
2135 set_vc_kbd_mode(kbd, VC_REPEAT);
2136 clr_vc_kbd_mode(kbd, VC_CKMODE);
2137 clr_vc_kbd_mode(kbd, VC_APPLIC);
2138 clr_vc_kbd_mode(kbd, VC_CRLF);
2140 kbd->slockstate = 0;
2141 kbd->ledmode = LED_SHOW_FLAGS;
2142 kbd->ledflagstate = kbd->default_ledflagstate;
2143 /* do not do set_leds here because this causes an endless tasklet loop
2144 when the keyboard hasn't been initialized yet */
2145 spin_unlock_irqrestore(&kbd_event_lock, flags);
2149 * vt_get_kbd_mode_bit - read keyboard status bits
2150 * @console: console to read from
2151 * @bit: mode bit to read
2153 * Report back a vt mode bit. We do this without locking so the
2154 * caller must be sure that there are no synchronization needs
2157 int vt_get_kbd_mode_bit(int console, int bit)
2159 struct kbd_struct * kbd = kbd_table + console;
2160 return vc_kbd_mode(kbd, bit);
2164 * vt_set_kbd_mode_bit - read keyboard status bits
2165 * @console: console to read from
2166 * @bit: mode bit to read
2168 * Set a vt mode bit. We do this without locking so the
2169 * caller must be sure that there are no synchronization needs
2172 void vt_set_kbd_mode_bit(int console, int bit)
2174 struct kbd_struct * kbd = kbd_table + console;
2175 unsigned long flags;
2177 spin_lock_irqsave(&kbd_event_lock, flags);
2178 set_vc_kbd_mode(kbd, bit);
2179 spin_unlock_irqrestore(&kbd_event_lock, flags);
2183 * vt_clr_kbd_mode_bit - read keyboard status bits
2184 * @console: console to read from
2185 * @bit: mode bit to read
2187 * Report back a vt mode bit. We do this without locking so the
2188 * caller must be sure that there are no synchronization needs
2191 void vt_clr_kbd_mode_bit(int console, int bit)
2193 struct kbd_struct * kbd = kbd_table + console;
2194 unsigned long flags;
2196 spin_lock_irqsave(&kbd_event_lock, flags);
2197 clr_vc_kbd_mode(kbd, bit);
2198 spin_unlock_irqrestore(&kbd_event_lock, flags);