Linux 4.1.16
[linux/fpc-iii.git] / drivers / tty / vt / keyboard.c
blob8a89f6e7715db19debaea61781dedc40d05597fc
1 /*
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>
32 #include <linux/mm.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))
56 #if defined(CONFIG_X86) || defined(CONFIG_PARISC)
57 #include <asm/kbdleds.h>
58 #else
59 static inline int kbd_defleds(void)
61 return 0;
63 #endif
65 #define KBD_DEFLOCK 0
68 * Handler Tables.
71 #define K_HANDLERS\
72 k_self, k_fn, k_spec, k_pad,\
73 k_dead, k_cons, k_cur, k_shift,\
74 k_meta, k_ascii, k_lock, k_lowercase,\
75 k_slock, k_dead2, k_brl, k_ignore
77 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
78 char up_flag);
79 static k_handler_fn K_HANDLERS;
80 static k_handler_fn *k_handler[16] = { K_HANDLERS };
82 #define FN_HANDLERS\
83 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
84 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
85 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
86 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
87 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
89 typedef void (fn_handler_fn)(struct vc_data *vc);
90 static fn_handler_fn FN_HANDLERS;
91 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
94 * Variables exported for vt_ioctl.c
97 struct vt_spawn_console vt_spawn_con = {
98 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
99 .pid = NULL,
100 .sig = 0,
105 * Internal Data.
108 static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
109 static struct kbd_struct *kbd = kbd_table;
111 /* maximum values each key_handler can handle */
112 static const int max_vals[] = {
113 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
114 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
115 255, NR_LOCK - 1, 255, NR_BRL - 1
118 static const int NR_TYPES = ARRAY_SIZE(max_vals);
120 static struct input_handler kbd_handler;
121 static DEFINE_SPINLOCK(kbd_event_lock);
122 static DEFINE_SPINLOCK(led_lock);
123 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
124 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
125 static bool dead_key_next;
126 static int npadch = -1; /* -1 or number assembled on pad */
127 static unsigned int diacr;
128 static char rep; /* flag telling character repeat */
130 static int shift_state = 0;
132 static unsigned char ledstate = 0xff; /* undefined */
133 static unsigned char ledioctl;
136 * Notifier list for console keyboard events
138 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
140 int register_keyboard_notifier(struct notifier_block *nb)
142 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
144 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
146 int unregister_keyboard_notifier(struct notifier_block *nb)
148 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
150 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
153 * Translation of scancodes to keycodes. We set them on only the first
154 * keyboard in the list that accepts the scancode and keycode.
155 * Explanation for not choosing the first attached keyboard anymore:
156 * USB keyboards for example have two event devices: one for all "normal"
157 * keys and one for extra function keys (like "volume up", "make coffee",
158 * etc.). So this means that scancodes for the extra function keys won't
159 * be valid for the first event device, but will be for the second.
162 struct getset_keycode_data {
163 struct input_keymap_entry ke;
164 int error;
167 static int getkeycode_helper(struct input_handle *handle, void *data)
169 struct getset_keycode_data *d = data;
171 d->error = input_get_keycode(handle->dev, &d->ke);
173 return d->error == 0; /* stop as soon as we successfully get one */
176 static int getkeycode(unsigned int scancode)
178 struct getset_keycode_data d = {
179 .ke = {
180 .flags = 0,
181 .len = sizeof(scancode),
182 .keycode = 0,
184 .error = -ENODEV,
187 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
189 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
191 return d.error ?: d.ke.keycode;
194 static int setkeycode_helper(struct input_handle *handle, void *data)
196 struct getset_keycode_data *d = data;
198 d->error = input_set_keycode(handle->dev, &d->ke);
200 return d->error == 0; /* stop as soon as we successfully set one */
203 static int setkeycode(unsigned int scancode, unsigned int keycode)
205 struct getset_keycode_data d = {
206 .ke = {
207 .flags = 0,
208 .len = sizeof(scancode),
209 .keycode = keycode,
211 .error = -ENODEV,
214 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
216 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
218 return d.error;
222 * Making beeps and bells. Note that we prefer beeps to bells, but when
223 * shutting the sound off we do both.
226 static int kd_sound_helper(struct input_handle *handle, void *data)
228 unsigned int *hz = data;
229 struct input_dev *dev = handle->dev;
231 if (test_bit(EV_SND, dev->evbit)) {
232 if (test_bit(SND_TONE, dev->sndbit)) {
233 input_inject_event(handle, EV_SND, SND_TONE, *hz);
234 if (*hz)
235 return 0;
237 if (test_bit(SND_BELL, dev->sndbit))
238 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
241 return 0;
244 static void kd_nosound(unsigned long ignored)
246 static unsigned int zero;
248 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
251 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
253 void kd_mksound(unsigned int hz, unsigned int ticks)
255 del_timer_sync(&kd_mksound_timer);
257 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
259 if (hz && ticks)
260 mod_timer(&kd_mksound_timer, jiffies + ticks);
262 EXPORT_SYMBOL(kd_mksound);
265 * Setting the keyboard rate.
268 static int kbd_rate_helper(struct input_handle *handle, void *data)
270 struct input_dev *dev = handle->dev;
271 struct kbd_repeat *rpt = data;
273 if (test_bit(EV_REP, dev->evbit)) {
275 if (rpt[0].delay > 0)
276 input_inject_event(handle,
277 EV_REP, REP_DELAY, rpt[0].delay);
278 if (rpt[0].period > 0)
279 input_inject_event(handle,
280 EV_REP, REP_PERIOD, rpt[0].period);
282 rpt[1].delay = dev->rep[REP_DELAY];
283 rpt[1].period = dev->rep[REP_PERIOD];
286 return 0;
289 int kbd_rate(struct kbd_repeat *rpt)
291 struct kbd_repeat data[2] = { *rpt };
293 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
294 *rpt = data[1]; /* Copy currently used settings */
296 return 0;
300 * Helper Functions.
302 static void put_queue(struct vc_data *vc, int ch)
304 tty_insert_flip_char(&vc->port, ch, 0);
305 tty_schedule_flip(&vc->port);
308 static void puts_queue(struct vc_data *vc, char *cp)
310 while (*cp) {
311 tty_insert_flip_char(&vc->port, *cp, 0);
312 cp++;
314 tty_schedule_flip(&vc->port);
317 static void applkey(struct vc_data *vc, int key, char mode)
319 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
321 buf[1] = (mode ? 'O' : '[');
322 buf[2] = key;
323 puts_queue(vc, buf);
327 * Many other routines do put_queue, but I think either
328 * they produce ASCII, or they produce some user-assigned
329 * string, and in both cases we might assume that it is
330 * in utf-8 already.
332 static void to_utf8(struct vc_data *vc, uint c)
334 if (c < 0x80)
335 /* 0******* */
336 put_queue(vc, c);
337 else if (c < 0x800) {
338 /* 110***** 10****** */
339 put_queue(vc, 0xc0 | (c >> 6));
340 put_queue(vc, 0x80 | (c & 0x3f));
341 } else if (c < 0x10000) {
342 if (c >= 0xD800 && c < 0xE000)
343 return;
344 if (c == 0xFFFF)
345 return;
346 /* 1110**** 10****** 10****** */
347 put_queue(vc, 0xe0 | (c >> 12));
348 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
349 put_queue(vc, 0x80 | (c & 0x3f));
350 } else if (c < 0x110000) {
351 /* 11110*** 10****** 10****** 10****** */
352 put_queue(vc, 0xf0 | (c >> 18));
353 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
354 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
355 put_queue(vc, 0x80 | (c & 0x3f));
360 * Called after returning from RAW mode or when changing consoles - recompute
361 * shift_down[] and shift_state from key_down[] maybe called when keymap is
362 * undefined, so that shiftkey release is seen. The caller must hold the
363 * kbd_event_lock.
366 static void do_compute_shiftstate(void)
368 unsigned int i, j, k, sym, val;
370 shift_state = 0;
371 memset(shift_down, 0, sizeof(shift_down));
373 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
375 if (!key_down[i])
376 continue;
378 k = i * BITS_PER_LONG;
380 for (j = 0; j < BITS_PER_LONG; j++, k++) {
382 if (!test_bit(k, key_down))
383 continue;
385 sym = U(key_maps[0][k]);
386 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
387 continue;
389 val = KVAL(sym);
390 if (val == KVAL(K_CAPSSHIFT))
391 val = KVAL(K_SHIFT);
393 shift_down[val]++;
394 shift_state |= (1 << val);
399 /* We still have to export this method to vt.c */
400 void compute_shiftstate(void)
402 unsigned long flags;
403 spin_lock_irqsave(&kbd_event_lock, flags);
404 do_compute_shiftstate();
405 spin_unlock_irqrestore(&kbd_event_lock, flags);
409 * We have a combining character DIACR here, followed by the character CH.
410 * If the combination occurs in the table, return the corresponding value.
411 * Otherwise, if CH is a space or equals DIACR, return DIACR.
412 * Otherwise, conclude that DIACR was not combining after all,
413 * queue it and return CH.
415 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
417 unsigned int d = diacr;
418 unsigned int i;
420 diacr = 0;
422 if ((d & ~0xff) == BRL_UC_ROW) {
423 if ((ch & ~0xff) == BRL_UC_ROW)
424 return d | ch;
425 } else {
426 for (i = 0; i < accent_table_size; i++)
427 if (accent_table[i].diacr == d && accent_table[i].base == ch)
428 return accent_table[i].result;
431 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
432 return d;
434 if (kbd->kbdmode == VC_UNICODE)
435 to_utf8(vc, d);
436 else {
437 int c = conv_uni_to_8bit(d);
438 if (c != -1)
439 put_queue(vc, c);
442 return ch;
446 * Special function handlers
448 static void fn_enter(struct vc_data *vc)
450 if (diacr) {
451 if (kbd->kbdmode == VC_UNICODE)
452 to_utf8(vc, diacr);
453 else {
454 int c = conv_uni_to_8bit(diacr);
455 if (c != -1)
456 put_queue(vc, c);
458 diacr = 0;
461 put_queue(vc, 13);
462 if (vc_kbd_mode(kbd, VC_CRLF))
463 put_queue(vc, 10);
466 static void fn_caps_toggle(struct vc_data *vc)
468 if (rep)
469 return;
471 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
474 static void fn_caps_on(struct vc_data *vc)
476 if (rep)
477 return;
479 set_vc_kbd_led(kbd, VC_CAPSLOCK);
482 static void fn_show_ptregs(struct vc_data *vc)
484 struct pt_regs *regs = get_irq_regs();
486 if (regs)
487 show_regs(regs);
490 static void fn_hold(struct vc_data *vc)
492 struct tty_struct *tty = vc->port.tty;
494 if (rep || !tty)
495 return;
498 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
499 * these routines are also activated by ^S/^Q.
500 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
502 if (tty->stopped)
503 start_tty(tty);
504 else
505 stop_tty(tty);
508 static void fn_num(struct vc_data *vc)
510 if (vc_kbd_mode(kbd, VC_APPLIC))
511 applkey(vc, 'P', 1);
512 else
513 fn_bare_num(vc);
517 * Bind this to Shift-NumLock if you work in application keypad mode
518 * but want to be able to change the NumLock flag.
519 * Bind this to NumLock if you prefer that the NumLock key always
520 * changes the NumLock flag.
522 static void fn_bare_num(struct vc_data *vc)
524 if (!rep)
525 chg_vc_kbd_led(kbd, VC_NUMLOCK);
528 static void fn_lastcons(struct vc_data *vc)
530 /* switch to the last used console, ChN */
531 set_console(last_console);
534 static void fn_dec_console(struct vc_data *vc)
536 int i, cur = fg_console;
538 /* Currently switching? Queue this next switch relative to that. */
539 if (want_console != -1)
540 cur = want_console;
542 for (i = cur - 1; i != cur; i--) {
543 if (i == -1)
544 i = MAX_NR_CONSOLES - 1;
545 if (vc_cons_allocated(i))
546 break;
548 set_console(i);
551 static void fn_inc_console(struct vc_data *vc)
553 int i, cur = fg_console;
555 /* Currently switching? Queue this next switch relative to that. */
556 if (want_console != -1)
557 cur = want_console;
559 for (i = cur+1; i != cur; i++) {
560 if (i == MAX_NR_CONSOLES)
561 i = 0;
562 if (vc_cons_allocated(i))
563 break;
565 set_console(i);
568 static void fn_send_intr(struct vc_data *vc)
570 tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
571 tty_schedule_flip(&vc->port);
574 static void fn_scroll_forw(struct vc_data *vc)
576 scrollfront(vc, 0);
579 static void fn_scroll_back(struct vc_data *vc)
581 scrollback(vc, 0);
584 static void fn_show_mem(struct vc_data *vc)
586 show_mem(0);
589 static void fn_show_state(struct vc_data *vc)
591 show_state();
594 static void fn_boot_it(struct vc_data *vc)
596 ctrl_alt_del();
599 static void fn_compose(struct vc_data *vc)
601 dead_key_next = true;
604 static void fn_spawn_con(struct vc_data *vc)
606 spin_lock(&vt_spawn_con.lock);
607 if (vt_spawn_con.pid)
608 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
609 put_pid(vt_spawn_con.pid);
610 vt_spawn_con.pid = NULL;
612 spin_unlock(&vt_spawn_con.lock);
615 static void fn_SAK(struct vc_data *vc)
617 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
618 schedule_work(SAK_work);
621 static void fn_null(struct vc_data *vc)
623 do_compute_shiftstate();
627 * Special key handlers
629 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
633 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
635 if (up_flag)
636 return;
637 if (value >= ARRAY_SIZE(fn_handler))
638 return;
639 if ((kbd->kbdmode == VC_RAW ||
640 kbd->kbdmode == VC_MEDIUMRAW ||
641 kbd->kbdmode == VC_OFF) &&
642 value != KVAL(K_SAK))
643 return; /* SAK is allowed even in raw mode */
644 fn_handler[value](vc);
647 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
649 pr_err("k_lowercase was called - impossible\n");
652 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
654 if (up_flag)
655 return; /* no action, if this is a key release */
657 if (diacr)
658 value = handle_diacr(vc, value);
660 if (dead_key_next) {
661 dead_key_next = false;
662 diacr = value;
663 return;
665 if (kbd->kbdmode == VC_UNICODE)
666 to_utf8(vc, value);
667 else {
668 int c = conv_uni_to_8bit(value);
669 if (c != -1)
670 put_queue(vc, c);
675 * Handle dead key. Note that we now may have several
676 * dead keys modifying the same character. Very useful
677 * for Vietnamese.
679 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
681 if (up_flag)
682 return;
684 diacr = (diacr ? handle_diacr(vc, value) : value);
687 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
689 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
692 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
694 k_deadunicode(vc, value, up_flag);
698 * Obsolete - for backwards compatibility only
700 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
702 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
704 k_deadunicode(vc, ret_diacr[value], up_flag);
707 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
709 if (up_flag)
710 return;
712 set_console(value);
715 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
717 if (up_flag)
718 return;
720 if ((unsigned)value < ARRAY_SIZE(func_table)) {
721 if (func_table[value])
722 puts_queue(vc, func_table[value]);
723 } else
724 pr_err("k_fn called with value=%d\n", value);
727 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
729 static const char cur_chars[] = "BDCA";
731 if (up_flag)
732 return;
734 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
737 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
739 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
740 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
742 if (up_flag)
743 return; /* no action, if this is a key release */
745 /* kludge... shift forces cursor/number keys */
746 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
747 applkey(vc, app_map[value], 1);
748 return;
751 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
753 switch (value) {
754 case KVAL(K_PCOMMA):
755 case KVAL(K_PDOT):
756 k_fn(vc, KVAL(K_REMOVE), 0);
757 return;
758 case KVAL(K_P0):
759 k_fn(vc, KVAL(K_INSERT), 0);
760 return;
761 case KVAL(K_P1):
762 k_fn(vc, KVAL(K_SELECT), 0);
763 return;
764 case KVAL(K_P2):
765 k_cur(vc, KVAL(K_DOWN), 0);
766 return;
767 case KVAL(K_P3):
768 k_fn(vc, KVAL(K_PGDN), 0);
769 return;
770 case KVAL(K_P4):
771 k_cur(vc, KVAL(K_LEFT), 0);
772 return;
773 case KVAL(K_P6):
774 k_cur(vc, KVAL(K_RIGHT), 0);
775 return;
776 case KVAL(K_P7):
777 k_fn(vc, KVAL(K_FIND), 0);
778 return;
779 case KVAL(K_P8):
780 k_cur(vc, KVAL(K_UP), 0);
781 return;
782 case KVAL(K_P9):
783 k_fn(vc, KVAL(K_PGUP), 0);
784 return;
785 case KVAL(K_P5):
786 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
787 return;
791 put_queue(vc, pad_chars[value]);
792 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
793 put_queue(vc, 10);
796 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
798 int old_state = shift_state;
800 if (rep)
801 return;
803 * Mimic typewriter:
804 * a CapsShift key acts like Shift but undoes CapsLock
806 if (value == KVAL(K_CAPSSHIFT)) {
807 value = KVAL(K_SHIFT);
808 if (!up_flag)
809 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
812 if (up_flag) {
814 * handle the case that two shift or control
815 * keys are depressed simultaneously
817 if (shift_down[value])
818 shift_down[value]--;
819 } else
820 shift_down[value]++;
822 if (shift_down[value])
823 shift_state |= (1 << value);
824 else
825 shift_state &= ~(1 << value);
827 /* kludge */
828 if (up_flag && shift_state != old_state && npadch != -1) {
829 if (kbd->kbdmode == VC_UNICODE)
830 to_utf8(vc, npadch);
831 else
832 put_queue(vc, npadch & 0xff);
833 npadch = -1;
837 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
839 if (up_flag)
840 return;
842 if (vc_kbd_mode(kbd, VC_META)) {
843 put_queue(vc, '\033');
844 put_queue(vc, value);
845 } else
846 put_queue(vc, value | 0x80);
849 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
851 int base;
853 if (up_flag)
854 return;
856 if (value < 10) {
857 /* decimal input of code, while Alt depressed */
858 base = 10;
859 } else {
860 /* hexadecimal input of code, while AltGr depressed */
861 value -= 10;
862 base = 16;
865 if (npadch == -1)
866 npadch = value;
867 else
868 npadch = npadch * base + value;
871 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
873 if (up_flag || rep)
874 return;
876 chg_vc_kbd_lock(kbd, value);
879 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
881 k_shift(vc, value, up_flag);
882 if (up_flag || rep)
883 return;
885 chg_vc_kbd_slock(kbd, value);
886 /* try to make Alt, oops, AltGr and such work */
887 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
888 kbd->slockstate = 0;
889 chg_vc_kbd_slock(kbd, value);
893 /* by default, 300ms interval for combination release */
894 static unsigned brl_timeout = 300;
895 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
896 module_param(brl_timeout, uint, 0644);
898 static unsigned brl_nbchords = 1;
899 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
900 module_param(brl_nbchords, uint, 0644);
902 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
904 static unsigned long chords;
905 static unsigned committed;
907 if (!brl_nbchords)
908 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
909 else {
910 committed |= pattern;
911 chords++;
912 if (chords == brl_nbchords) {
913 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
914 chords = 0;
915 committed = 0;
920 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
922 static unsigned pressed, committing;
923 static unsigned long releasestart;
925 if (kbd->kbdmode != VC_UNICODE) {
926 if (!up_flag)
927 pr_warn("keyboard mode must be unicode for braille patterns\n");
928 return;
931 if (!value) {
932 k_unicode(vc, BRL_UC_ROW, up_flag);
933 return;
936 if (value > 8)
937 return;
939 if (!up_flag) {
940 pressed |= 1 << (value - 1);
941 if (!brl_timeout)
942 committing = pressed;
943 } else if (brl_timeout) {
944 if (!committing ||
945 time_after(jiffies,
946 releasestart + msecs_to_jiffies(brl_timeout))) {
947 committing = pressed;
948 releasestart = jiffies;
950 pressed &= ~(1 << (value - 1));
951 if (!pressed && committing) {
952 k_brlcommit(vc, committing, 0);
953 committing = 0;
955 } else {
956 if (committing) {
957 k_brlcommit(vc, committing, 0);
958 committing = 0;
960 pressed &= ~(1 << (value - 1));
965 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
966 * or (ii) whatever pattern of lights people want to show using KDSETLED,
967 * or (iii) specified bits of specified words in kernel memory.
969 static unsigned char getledstate(void)
971 return ledstate;
974 void setledstate(struct kbd_struct *kb, unsigned int led)
976 unsigned long flags;
977 spin_lock_irqsave(&led_lock, flags);
978 if (!(led & ~7)) {
979 ledioctl = led;
980 kb->ledmode = LED_SHOW_IOCTL;
981 } else
982 kb->ledmode = LED_SHOW_FLAGS;
984 set_leds();
985 spin_unlock_irqrestore(&led_lock, flags);
988 static inline unsigned char getleds(void)
990 struct kbd_struct *kb = kbd_table + fg_console;
992 if (kb->ledmode == LED_SHOW_IOCTL)
993 return ledioctl;
995 return kb->ledflagstate;
998 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1000 unsigned char leds = *(unsigned char *)data;
1002 if (test_bit(EV_LED, handle->dev->evbit)) {
1003 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1004 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1005 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1006 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1009 return 0;
1013 * vt_get_leds - helper for braille console
1014 * @console: console to read
1015 * @flag: flag we want to check
1017 * Check the status of a keyboard led flag and report it back
1019 int vt_get_leds(int console, int flag)
1021 struct kbd_struct *kb = kbd_table + console;
1022 int ret;
1023 unsigned long flags;
1025 spin_lock_irqsave(&led_lock, flags);
1026 ret = vc_kbd_led(kb, flag);
1027 spin_unlock_irqrestore(&led_lock, flags);
1029 return ret;
1031 EXPORT_SYMBOL_GPL(vt_get_leds);
1034 * vt_set_led_state - set LED state of a console
1035 * @console: console to set
1036 * @leds: LED bits
1038 * Set the LEDs on a console. This is a wrapper for the VT layer
1039 * so that we can keep kbd knowledge internal
1041 void vt_set_led_state(int console, int leds)
1043 struct kbd_struct *kb = kbd_table + console;
1044 setledstate(kb, leds);
1048 * vt_kbd_con_start - Keyboard side of console start
1049 * @console: console
1051 * Handle console start. This is a wrapper for the VT layer
1052 * so that we can keep kbd knowledge internal
1054 * FIXME: We eventually need to hold the kbd lock here to protect
1055 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1056 * and start_tty under the kbd_event_lock, while normal tty paths
1057 * don't hold the lock. We probably need to split out an LED lock
1058 * but not during an -rc release!
1060 void vt_kbd_con_start(int console)
1062 struct kbd_struct *kb = kbd_table + console;
1063 unsigned long flags;
1064 spin_lock_irqsave(&led_lock, flags);
1065 clr_vc_kbd_led(kb, VC_SCROLLOCK);
1066 set_leds();
1067 spin_unlock_irqrestore(&led_lock, flags);
1071 * vt_kbd_con_stop - Keyboard side of console stop
1072 * @console: console
1074 * Handle console stop. This is a wrapper for the VT layer
1075 * so that we can keep kbd knowledge internal
1077 void vt_kbd_con_stop(int console)
1079 struct kbd_struct *kb = kbd_table + console;
1080 unsigned long flags;
1081 spin_lock_irqsave(&led_lock, flags);
1082 set_vc_kbd_led(kb, VC_SCROLLOCK);
1083 set_leds();
1084 spin_unlock_irqrestore(&led_lock, flags);
1088 * This is the tasklet that updates LED state on all keyboards
1089 * attached to the box. The reason we use tasklet is that we
1090 * need to handle the scenario when keyboard handler is not
1091 * registered yet but we already getting updates from the VT to
1092 * update led state.
1094 static void kbd_bh(unsigned long dummy)
1096 unsigned char leds;
1097 unsigned long flags;
1099 spin_lock_irqsave(&led_lock, flags);
1100 leds = getleds();
1101 spin_unlock_irqrestore(&led_lock, flags);
1103 if (leds != ledstate) {
1104 input_handler_for_each_handle(&kbd_handler, &leds,
1105 kbd_update_leds_helper);
1106 ledstate = leds;
1110 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1112 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1113 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1114 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1115 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1116 defined(CONFIG_AVR32)
1118 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1119 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1121 static const unsigned short x86_keycodes[256] =
1122 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1123 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1124 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1125 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1126 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1127 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1128 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1129 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1130 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1131 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1132 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1133 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1134 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1135 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1136 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1138 #ifdef CONFIG_SPARC
1139 static int sparc_l1_a_state;
1140 extern void sun_do_break(void);
1141 #endif
1143 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1144 unsigned char up_flag)
1146 int code;
1148 switch (keycode) {
1150 case KEY_PAUSE:
1151 put_queue(vc, 0xe1);
1152 put_queue(vc, 0x1d | up_flag);
1153 put_queue(vc, 0x45 | up_flag);
1154 break;
1156 case KEY_HANGEUL:
1157 if (!up_flag)
1158 put_queue(vc, 0xf2);
1159 break;
1161 case KEY_HANJA:
1162 if (!up_flag)
1163 put_queue(vc, 0xf1);
1164 break;
1166 case KEY_SYSRQ:
1168 * Real AT keyboards (that's what we're trying
1169 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1170 * pressing PrtSc/SysRq alone, but simply 0x54
1171 * when pressing Alt+PrtSc/SysRq.
1173 if (test_bit(KEY_LEFTALT, key_down) ||
1174 test_bit(KEY_RIGHTALT, key_down)) {
1175 put_queue(vc, 0x54 | up_flag);
1176 } else {
1177 put_queue(vc, 0xe0);
1178 put_queue(vc, 0x2a | up_flag);
1179 put_queue(vc, 0xe0);
1180 put_queue(vc, 0x37 | up_flag);
1182 break;
1184 default:
1185 if (keycode > 255)
1186 return -1;
1188 code = x86_keycodes[keycode];
1189 if (!code)
1190 return -1;
1192 if (code & 0x100)
1193 put_queue(vc, 0xe0);
1194 put_queue(vc, (code & 0x7f) | up_flag);
1196 break;
1199 return 0;
1202 #else
1204 #define HW_RAW(dev) 0
1206 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1208 if (keycode > 127)
1209 return -1;
1211 put_queue(vc, keycode | up_flag);
1212 return 0;
1214 #endif
1216 static void kbd_rawcode(unsigned char data)
1218 struct vc_data *vc = vc_cons[fg_console].d;
1220 kbd = kbd_table + vc->vc_num;
1221 if (kbd->kbdmode == VC_RAW)
1222 put_queue(vc, data);
1225 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1227 struct vc_data *vc = vc_cons[fg_console].d;
1228 unsigned short keysym, *key_map;
1229 unsigned char type;
1230 bool raw_mode;
1231 struct tty_struct *tty;
1232 int shift_final;
1233 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1234 int rc;
1236 tty = vc->port.tty;
1238 if (tty && (!tty->driver_data)) {
1239 /* No driver data? Strange. Okay we fix it then. */
1240 tty->driver_data = vc;
1243 kbd = kbd_table + vc->vc_num;
1245 #ifdef CONFIG_SPARC
1246 if (keycode == KEY_STOP)
1247 sparc_l1_a_state = down;
1248 #endif
1250 rep = (down == 2);
1252 raw_mode = (kbd->kbdmode == VC_RAW);
1253 if (raw_mode && !hw_raw)
1254 if (emulate_raw(vc, keycode, !down << 7))
1255 if (keycode < BTN_MISC && printk_ratelimit())
1256 pr_warn("can't emulate rawmode for keycode %d\n",
1257 keycode);
1259 #ifdef CONFIG_SPARC
1260 if (keycode == KEY_A && sparc_l1_a_state) {
1261 sparc_l1_a_state = false;
1262 sun_do_break();
1264 #endif
1266 if (kbd->kbdmode == VC_MEDIUMRAW) {
1268 * This is extended medium raw mode, with keys above 127
1269 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1270 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1271 * interfere with anything else. The two bytes after 0 will
1272 * always have the up flag set not to interfere with older
1273 * applications. This allows for 16384 different keycodes,
1274 * which should be enough.
1276 if (keycode < 128) {
1277 put_queue(vc, keycode | (!down << 7));
1278 } else {
1279 put_queue(vc, !down << 7);
1280 put_queue(vc, (keycode >> 7) | 0x80);
1281 put_queue(vc, keycode | 0x80);
1283 raw_mode = true;
1286 if (down)
1287 set_bit(keycode, key_down);
1288 else
1289 clear_bit(keycode, key_down);
1291 if (rep &&
1292 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1293 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1295 * Don't repeat a key if the input buffers are not empty and the
1296 * characters get aren't echoed locally. This makes key repeat
1297 * usable with slow applications and under heavy loads.
1299 return;
1302 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1303 param.ledstate = kbd->ledflagstate;
1304 key_map = key_maps[shift_final];
1306 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1307 KBD_KEYCODE, &param);
1308 if (rc == NOTIFY_STOP || !key_map) {
1309 atomic_notifier_call_chain(&keyboard_notifier_list,
1310 KBD_UNBOUND_KEYCODE, &param);
1311 do_compute_shiftstate();
1312 kbd->slockstate = 0;
1313 return;
1316 if (keycode < NR_KEYS)
1317 keysym = key_map[keycode];
1318 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1319 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1320 else
1321 return;
1323 type = KTYP(keysym);
1325 if (type < 0xf0) {
1326 param.value = keysym;
1327 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1328 KBD_UNICODE, &param);
1329 if (rc != NOTIFY_STOP)
1330 if (down && !raw_mode)
1331 to_utf8(vc, keysym);
1332 return;
1335 type -= 0xf0;
1337 if (type == KT_LETTER) {
1338 type = KT_LATIN;
1339 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1340 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1341 if (key_map)
1342 keysym = key_map[keycode];
1346 param.value = keysym;
1347 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1348 KBD_KEYSYM, &param);
1349 if (rc == NOTIFY_STOP)
1350 return;
1352 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1353 return;
1355 (*k_handler[type])(vc, keysym & 0xff, !down);
1357 param.ledstate = kbd->ledflagstate;
1358 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1360 if (type != KT_SLOCK)
1361 kbd->slockstate = 0;
1364 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1365 unsigned int event_code, int value)
1367 /* We are called with interrupts disabled, just take the lock */
1368 spin_lock(&kbd_event_lock);
1370 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1371 kbd_rawcode(value);
1372 if (event_type == EV_KEY)
1373 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1375 spin_unlock(&kbd_event_lock);
1377 tasklet_schedule(&keyboard_tasklet);
1378 do_poke_blanked_console = 1;
1379 schedule_console_callback();
1382 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1384 int i;
1386 if (test_bit(EV_SND, dev->evbit))
1387 return true;
1389 if (test_bit(EV_KEY, dev->evbit)) {
1390 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1391 if (test_bit(i, dev->keybit))
1392 return true;
1393 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1394 if (test_bit(i, dev->keybit))
1395 return true;
1398 return false;
1402 * When a keyboard (or other input device) is found, the kbd_connect
1403 * function is called. The function then looks at the device, and if it
1404 * likes it, it can open it and get events from it. In this (kbd_connect)
1405 * function, we should decide which VT to bind that keyboard to initially.
1407 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1408 const struct input_device_id *id)
1410 struct input_handle *handle;
1411 int error;
1413 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1414 if (!handle)
1415 return -ENOMEM;
1417 handle->dev = dev;
1418 handle->handler = handler;
1419 handle->name = "kbd";
1421 error = input_register_handle(handle);
1422 if (error)
1423 goto err_free_handle;
1425 error = input_open_device(handle);
1426 if (error)
1427 goto err_unregister_handle;
1429 return 0;
1431 err_unregister_handle:
1432 input_unregister_handle(handle);
1433 err_free_handle:
1434 kfree(handle);
1435 return error;
1438 static void kbd_disconnect(struct input_handle *handle)
1440 input_close_device(handle);
1441 input_unregister_handle(handle);
1442 kfree(handle);
1446 * Start keyboard handler on the new keyboard by refreshing LED state to
1447 * match the rest of the system.
1449 static void kbd_start(struct input_handle *handle)
1451 tasklet_disable(&keyboard_tasklet);
1453 if (ledstate != 0xff)
1454 kbd_update_leds_helper(handle, &ledstate);
1456 tasklet_enable(&keyboard_tasklet);
1459 static const struct input_device_id kbd_ids[] = {
1461 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1462 .evbit = { BIT_MASK(EV_KEY) },
1466 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1467 .evbit = { BIT_MASK(EV_SND) },
1470 { }, /* Terminating entry */
1473 MODULE_DEVICE_TABLE(input, kbd_ids);
1475 static struct input_handler kbd_handler = {
1476 .event = kbd_event,
1477 .match = kbd_match,
1478 .connect = kbd_connect,
1479 .disconnect = kbd_disconnect,
1480 .start = kbd_start,
1481 .name = "kbd",
1482 .id_table = kbd_ids,
1485 int __init kbd_init(void)
1487 int i;
1488 int error;
1490 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1491 kbd_table[i].ledflagstate = kbd_defleds();
1492 kbd_table[i].default_ledflagstate = kbd_defleds();
1493 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1494 kbd_table[i].lockstate = KBD_DEFLOCK;
1495 kbd_table[i].slockstate = 0;
1496 kbd_table[i].modeflags = KBD_DEFMODE;
1497 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1500 error = input_register_handler(&kbd_handler);
1501 if (error)
1502 return error;
1504 tasklet_enable(&keyboard_tasklet);
1505 tasklet_schedule(&keyboard_tasklet);
1507 return 0;
1510 /* Ioctl support code */
1513 * vt_do_diacrit - diacritical table updates
1514 * @cmd: ioctl request
1515 * @udp: pointer to user data for ioctl
1516 * @perm: permissions check computed by caller
1518 * Update the diacritical tables atomically and safely. Lock them
1519 * against simultaneous keypresses
1521 int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
1523 unsigned long flags;
1524 int asize;
1525 int ret = 0;
1527 switch (cmd) {
1528 case KDGKBDIACR:
1530 struct kbdiacrs __user *a = udp;
1531 struct kbdiacr *dia;
1532 int i;
1534 dia = kmalloc(MAX_DIACR * sizeof(struct kbdiacr),
1535 GFP_KERNEL);
1536 if (!dia)
1537 return -ENOMEM;
1539 /* Lock the diacriticals table, make a copy and then
1540 copy it after we unlock */
1541 spin_lock_irqsave(&kbd_event_lock, flags);
1543 asize = accent_table_size;
1544 for (i = 0; i < asize; i++) {
1545 dia[i].diacr = conv_uni_to_8bit(
1546 accent_table[i].diacr);
1547 dia[i].base = conv_uni_to_8bit(
1548 accent_table[i].base);
1549 dia[i].result = conv_uni_to_8bit(
1550 accent_table[i].result);
1552 spin_unlock_irqrestore(&kbd_event_lock, flags);
1554 if (put_user(asize, &a->kb_cnt))
1555 ret = -EFAULT;
1556 else if (copy_to_user(a->kbdiacr, dia,
1557 asize * sizeof(struct kbdiacr)))
1558 ret = -EFAULT;
1559 kfree(dia);
1560 return ret;
1562 case KDGKBDIACRUC:
1564 struct kbdiacrsuc __user *a = udp;
1565 void *buf;
1567 buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc),
1568 GFP_KERNEL);
1569 if (buf == NULL)
1570 return -ENOMEM;
1572 /* Lock the diacriticals table, make a copy and then
1573 copy it after we unlock */
1574 spin_lock_irqsave(&kbd_event_lock, flags);
1576 asize = accent_table_size;
1577 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1579 spin_unlock_irqrestore(&kbd_event_lock, flags);
1581 if (put_user(asize, &a->kb_cnt))
1582 ret = -EFAULT;
1583 else if (copy_to_user(a->kbdiacruc, buf,
1584 asize*sizeof(struct kbdiacruc)))
1585 ret = -EFAULT;
1586 kfree(buf);
1587 return ret;
1590 case KDSKBDIACR:
1592 struct kbdiacrs __user *a = udp;
1593 struct kbdiacr *dia = NULL;
1594 unsigned int ct;
1595 int i;
1597 if (!perm)
1598 return -EPERM;
1599 if (get_user(ct, &a->kb_cnt))
1600 return -EFAULT;
1601 if (ct >= MAX_DIACR)
1602 return -EINVAL;
1604 if (ct) {
1605 dia = kmalloc(sizeof(struct kbdiacr) * ct,
1606 GFP_KERNEL);
1607 if (!dia)
1608 return -ENOMEM;
1610 if (copy_from_user(dia, a->kbdiacr,
1611 sizeof(struct kbdiacr) * ct)) {
1612 kfree(dia);
1613 return -EFAULT;
1617 spin_lock_irqsave(&kbd_event_lock, flags);
1618 accent_table_size = ct;
1619 for (i = 0; i < ct; i++) {
1620 accent_table[i].diacr =
1621 conv_8bit_to_uni(dia[i].diacr);
1622 accent_table[i].base =
1623 conv_8bit_to_uni(dia[i].base);
1624 accent_table[i].result =
1625 conv_8bit_to_uni(dia[i].result);
1627 spin_unlock_irqrestore(&kbd_event_lock, flags);
1628 kfree(dia);
1629 return 0;
1632 case KDSKBDIACRUC:
1634 struct kbdiacrsuc __user *a = udp;
1635 unsigned int ct;
1636 void *buf = NULL;
1638 if (!perm)
1639 return -EPERM;
1641 if (get_user(ct, &a->kb_cnt))
1642 return -EFAULT;
1644 if (ct >= MAX_DIACR)
1645 return -EINVAL;
1647 if (ct) {
1648 buf = kmalloc(ct * sizeof(struct kbdiacruc),
1649 GFP_KERNEL);
1650 if (buf == NULL)
1651 return -ENOMEM;
1653 if (copy_from_user(buf, a->kbdiacruc,
1654 ct * sizeof(struct kbdiacruc))) {
1655 kfree(buf);
1656 return -EFAULT;
1659 spin_lock_irqsave(&kbd_event_lock, flags);
1660 if (ct)
1661 memcpy(accent_table, buf,
1662 ct * sizeof(struct kbdiacruc));
1663 accent_table_size = ct;
1664 spin_unlock_irqrestore(&kbd_event_lock, flags);
1665 kfree(buf);
1666 return 0;
1669 return ret;
1673 * vt_do_kdskbmode - set keyboard mode ioctl
1674 * @console: the console to use
1675 * @arg: the requested mode
1677 * Update the keyboard mode bits while holding the correct locks.
1678 * Return 0 for success or an error code.
1680 int vt_do_kdskbmode(int console, unsigned int arg)
1682 struct kbd_struct *kb = kbd_table + console;
1683 int ret = 0;
1684 unsigned long flags;
1686 spin_lock_irqsave(&kbd_event_lock, flags);
1687 switch(arg) {
1688 case K_RAW:
1689 kb->kbdmode = VC_RAW;
1690 break;
1691 case K_MEDIUMRAW:
1692 kb->kbdmode = VC_MEDIUMRAW;
1693 break;
1694 case K_XLATE:
1695 kb->kbdmode = VC_XLATE;
1696 do_compute_shiftstate();
1697 break;
1698 case K_UNICODE:
1699 kb->kbdmode = VC_UNICODE;
1700 do_compute_shiftstate();
1701 break;
1702 case K_OFF:
1703 kb->kbdmode = VC_OFF;
1704 break;
1705 default:
1706 ret = -EINVAL;
1708 spin_unlock_irqrestore(&kbd_event_lock, flags);
1709 return ret;
1713 * vt_do_kdskbmeta - set keyboard meta state
1714 * @console: the console to use
1715 * @arg: the requested meta state
1717 * Update the keyboard meta bits while holding the correct locks.
1718 * Return 0 for success or an error code.
1720 int vt_do_kdskbmeta(int console, unsigned int arg)
1722 struct kbd_struct *kb = kbd_table + console;
1723 int ret = 0;
1724 unsigned long flags;
1726 spin_lock_irqsave(&kbd_event_lock, flags);
1727 switch(arg) {
1728 case K_METABIT:
1729 clr_vc_kbd_mode(kb, VC_META);
1730 break;
1731 case K_ESCPREFIX:
1732 set_vc_kbd_mode(kb, VC_META);
1733 break;
1734 default:
1735 ret = -EINVAL;
1737 spin_unlock_irqrestore(&kbd_event_lock, flags);
1738 return ret;
1741 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1742 int perm)
1744 struct kbkeycode tmp;
1745 int kc = 0;
1747 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1748 return -EFAULT;
1749 switch (cmd) {
1750 case KDGETKEYCODE:
1751 kc = getkeycode(tmp.scancode);
1752 if (kc >= 0)
1753 kc = put_user(kc, &user_kbkc->keycode);
1754 break;
1755 case KDSETKEYCODE:
1756 if (!perm)
1757 return -EPERM;
1758 kc = setkeycode(tmp.scancode, tmp.keycode);
1759 break;
1761 return kc;
1764 #define i (tmp.kb_index)
1765 #define s (tmp.kb_table)
1766 #define v (tmp.kb_value)
1768 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1769 int console)
1771 struct kbd_struct *kb = kbd_table + console;
1772 struct kbentry tmp;
1773 ushort *key_map, *new_map, val, ov;
1774 unsigned long flags;
1776 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1777 return -EFAULT;
1779 if (!capable(CAP_SYS_TTY_CONFIG))
1780 perm = 0;
1782 switch (cmd) {
1783 case KDGKBENT:
1784 /* Ensure another thread doesn't free it under us */
1785 spin_lock_irqsave(&kbd_event_lock, flags);
1786 key_map = key_maps[s];
1787 if (key_map) {
1788 val = U(key_map[i]);
1789 if (kb->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1790 val = K_HOLE;
1791 } else
1792 val = (i ? K_HOLE : K_NOSUCHMAP);
1793 spin_unlock_irqrestore(&kbd_event_lock, flags);
1794 return put_user(val, &user_kbe->kb_value);
1795 case KDSKBENT:
1796 if (!perm)
1797 return -EPERM;
1798 if (!i && v == K_NOSUCHMAP) {
1799 spin_lock_irqsave(&kbd_event_lock, flags);
1800 /* deallocate map */
1801 key_map = key_maps[s];
1802 if (s && key_map) {
1803 key_maps[s] = NULL;
1804 if (key_map[0] == U(K_ALLOCATED)) {
1805 kfree(key_map);
1806 keymap_count--;
1809 spin_unlock_irqrestore(&kbd_event_lock, flags);
1810 break;
1813 if (KTYP(v) < NR_TYPES) {
1814 if (KVAL(v) > max_vals[KTYP(v)])
1815 return -EINVAL;
1816 } else
1817 if (kb->kbdmode != VC_UNICODE)
1818 return -EINVAL;
1820 /* ++Geert: non-PC keyboards may generate keycode zero */
1821 #if !defined(__mc68000__) && !defined(__powerpc__)
1822 /* assignment to entry 0 only tests validity of args */
1823 if (!i)
1824 break;
1825 #endif
1827 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1828 if (!new_map)
1829 return -ENOMEM;
1830 spin_lock_irqsave(&kbd_event_lock, flags);
1831 key_map = key_maps[s];
1832 if (key_map == NULL) {
1833 int j;
1835 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1836 !capable(CAP_SYS_RESOURCE)) {
1837 spin_unlock_irqrestore(&kbd_event_lock, flags);
1838 kfree(new_map);
1839 return -EPERM;
1841 key_maps[s] = new_map;
1842 key_map = new_map;
1843 key_map[0] = U(K_ALLOCATED);
1844 for (j = 1; j < NR_KEYS; j++)
1845 key_map[j] = U(K_HOLE);
1846 keymap_count++;
1847 } else
1848 kfree(new_map);
1850 ov = U(key_map[i]);
1851 if (v == ov)
1852 goto out;
1854 * Attention Key.
1856 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1857 spin_unlock_irqrestore(&kbd_event_lock, flags);
1858 return -EPERM;
1860 key_map[i] = U(v);
1861 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1862 do_compute_shiftstate();
1863 out:
1864 spin_unlock_irqrestore(&kbd_event_lock, flags);
1865 break;
1867 return 0;
1869 #undef i
1870 #undef s
1871 #undef v
1873 /* FIXME: This one needs untangling and locking */
1874 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1876 struct kbsentry *kbs;
1877 char *p;
1878 u_char *q;
1879 u_char __user *up;
1880 int sz;
1881 int delta;
1882 char *first_free, *fj, *fnw;
1883 int i, j, k;
1884 int ret;
1886 if (!capable(CAP_SYS_TTY_CONFIG))
1887 perm = 0;
1889 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
1890 if (!kbs) {
1891 ret = -ENOMEM;
1892 goto reterr;
1895 /* we mostly copy too much here (512bytes), but who cares ;) */
1896 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
1897 ret = -EFAULT;
1898 goto reterr;
1900 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
1901 i = kbs->kb_func;
1903 switch (cmd) {
1904 case KDGKBSENT:
1905 sz = sizeof(kbs->kb_string) - 1; /* sz should have been
1906 a struct member */
1907 up = user_kdgkb->kb_string;
1908 p = func_table[i];
1909 if(p)
1910 for ( ; *p && sz; p++, sz--)
1911 if (put_user(*p, up++)) {
1912 ret = -EFAULT;
1913 goto reterr;
1915 if (put_user('\0', up)) {
1916 ret = -EFAULT;
1917 goto reterr;
1919 kfree(kbs);
1920 return ((p && *p) ? -EOVERFLOW : 0);
1921 case KDSKBSENT:
1922 if (!perm) {
1923 ret = -EPERM;
1924 goto reterr;
1927 q = func_table[i];
1928 first_free = funcbufptr + (funcbufsize - funcbufleft);
1929 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
1931 if (j < MAX_NR_FUNC)
1932 fj = func_table[j];
1933 else
1934 fj = first_free;
1936 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
1937 if (delta <= funcbufleft) { /* it fits in current buf */
1938 if (j < MAX_NR_FUNC) {
1939 memmove(fj + delta, fj, first_free - fj);
1940 for (k = j; k < MAX_NR_FUNC; k++)
1941 if (func_table[k])
1942 func_table[k] += delta;
1944 if (!q)
1945 func_table[i] = fj;
1946 funcbufleft -= delta;
1947 } else { /* allocate a larger buffer */
1948 sz = 256;
1949 while (sz < funcbufsize - funcbufleft + delta)
1950 sz <<= 1;
1951 fnw = kmalloc(sz, GFP_KERNEL);
1952 if(!fnw) {
1953 ret = -ENOMEM;
1954 goto reterr;
1957 if (!q)
1958 func_table[i] = fj;
1959 if (fj > funcbufptr)
1960 memmove(fnw, funcbufptr, fj - funcbufptr);
1961 for (k = 0; k < j; k++)
1962 if (func_table[k])
1963 func_table[k] = fnw + (func_table[k] - funcbufptr);
1965 if (first_free > fj) {
1966 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
1967 for (k = j; k < MAX_NR_FUNC; k++)
1968 if (func_table[k])
1969 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
1971 if (funcbufptr != func_buf)
1972 kfree(funcbufptr);
1973 funcbufptr = fnw;
1974 funcbufleft = funcbufleft - delta + sz - funcbufsize;
1975 funcbufsize = sz;
1977 strcpy(func_table[i], kbs->kb_string);
1978 break;
1980 ret = 0;
1981 reterr:
1982 kfree(kbs);
1983 return ret;
1986 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
1988 struct kbd_struct *kb = kbd_table + console;
1989 unsigned long flags;
1990 unsigned char ucval;
1992 switch(cmd) {
1993 /* the ioctls below read/set the flags usually shown in the leds */
1994 /* don't use them - they will go away without warning */
1995 case KDGKBLED:
1996 spin_lock_irqsave(&kbd_event_lock, flags);
1997 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
1998 spin_unlock_irqrestore(&kbd_event_lock, flags);
1999 return put_user(ucval, (char __user *)arg);
2001 case KDSKBLED:
2002 if (!perm)
2003 return -EPERM;
2004 if (arg & ~0x77)
2005 return -EINVAL;
2006 spin_lock_irqsave(&led_lock, flags);
2007 kb->ledflagstate = (arg & 7);
2008 kb->default_ledflagstate = ((arg >> 4) & 7);
2009 set_leds();
2010 spin_unlock_irqrestore(&led_lock, flags);
2011 return 0;
2013 /* the ioctls below only set the lights, not the functions */
2014 /* for those, see KDGKBLED and KDSKBLED above */
2015 case KDGETLED:
2016 ucval = getledstate();
2017 return put_user(ucval, (char __user *)arg);
2019 case KDSETLED:
2020 if (!perm)
2021 return -EPERM;
2022 setledstate(kb, arg);
2023 return 0;
2025 return -ENOIOCTLCMD;
2028 int vt_do_kdgkbmode(int console)
2030 struct kbd_struct *kb = kbd_table + console;
2031 /* This is a spot read so needs no locking */
2032 switch (kb->kbdmode) {
2033 case VC_RAW:
2034 return K_RAW;
2035 case VC_MEDIUMRAW:
2036 return K_MEDIUMRAW;
2037 case VC_UNICODE:
2038 return K_UNICODE;
2039 case VC_OFF:
2040 return K_OFF;
2041 default:
2042 return K_XLATE;
2047 * vt_do_kdgkbmeta - report meta status
2048 * @console: console to report
2050 * Report the meta flag status of this console
2052 int vt_do_kdgkbmeta(int console)
2054 struct kbd_struct *kb = kbd_table + console;
2055 /* Again a spot read so no locking */
2056 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2060 * vt_reset_unicode - reset the unicode status
2061 * @console: console being reset
2063 * Restore the unicode console state to its default
2065 void vt_reset_unicode(int console)
2067 unsigned long flags;
2069 spin_lock_irqsave(&kbd_event_lock, flags);
2070 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2071 spin_unlock_irqrestore(&kbd_event_lock, flags);
2075 * vt_get_shiftstate - shift bit state
2077 * Report the shift bits from the keyboard state. We have to export
2078 * this to support some oddities in the vt layer.
2080 int vt_get_shift_state(void)
2082 /* Don't lock as this is a transient report */
2083 return shift_state;
2087 * vt_reset_keyboard - reset keyboard state
2088 * @console: console to reset
2090 * Reset the keyboard bits for a console as part of a general console
2091 * reset event
2093 void vt_reset_keyboard(int console)
2095 struct kbd_struct *kb = kbd_table + console;
2096 unsigned long flags;
2098 spin_lock_irqsave(&kbd_event_lock, flags);
2099 set_vc_kbd_mode(kb, VC_REPEAT);
2100 clr_vc_kbd_mode(kb, VC_CKMODE);
2101 clr_vc_kbd_mode(kb, VC_APPLIC);
2102 clr_vc_kbd_mode(kb, VC_CRLF);
2103 kb->lockstate = 0;
2104 kb->slockstate = 0;
2105 spin_lock(&led_lock);
2106 kb->ledmode = LED_SHOW_FLAGS;
2107 kb->ledflagstate = kb->default_ledflagstate;
2108 spin_unlock(&led_lock);
2109 /* do not do set_leds here because this causes an endless tasklet loop
2110 when the keyboard hasn't been initialized yet */
2111 spin_unlock_irqrestore(&kbd_event_lock, flags);
2115 * vt_get_kbd_mode_bit - read keyboard status bits
2116 * @console: console to read from
2117 * @bit: mode bit to read
2119 * Report back a vt mode bit. We do this without locking so the
2120 * caller must be sure that there are no synchronization needs
2123 int vt_get_kbd_mode_bit(int console, int bit)
2125 struct kbd_struct *kb = kbd_table + console;
2126 return vc_kbd_mode(kb, bit);
2130 * vt_set_kbd_mode_bit - read keyboard status bits
2131 * @console: console to read from
2132 * @bit: mode bit to read
2134 * Set a vt mode bit. We do this without locking so the
2135 * caller must be sure that there are no synchronization needs
2138 void vt_set_kbd_mode_bit(int console, int bit)
2140 struct kbd_struct *kb = kbd_table + console;
2141 unsigned long flags;
2143 spin_lock_irqsave(&kbd_event_lock, flags);
2144 set_vc_kbd_mode(kb, bit);
2145 spin_unlock_irqrestore(&kbd_event_lock, flags);
2149 * vt_clr_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 void vt_clr_kbd_mode_bit(int console, int bit)
2159 struct kbd_struct *kb = kbd_table + console;
2160 unsigned long flags;
2162 spin_lock_irqsave(&kbd_event_lock, flags);
2163 clr_vc_kbd_mode(kb, bit);
2164 spin_unlock_irqrestore(&kbd_event_lock, flags);