Loading...
1/*
2 * Written for linux by Johan Myreen as a translation from
3 * the assembly version by Linus (with diacriticals added)
4 *
5 * Some additional features added by Christoph Niemann (ChN), March 1993
6 *
7 * Loadable keymaps by Risto Kankkunen, May 1993
8 *
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.
13 *
14 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
15 *
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
19 *
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)
23 */
24
25#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
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>
36#include <linux/irq.h>
37
38#include <linux/kbd_kern.h>
39#include <linux/kbd_diacr.h>
40#include <linux/vt_kern.h>
41#include <linux/input.h>
42#include <linux/reboot.h>
43#include <linux/notifier.h>
44#include <linux/jiffies.h>
45
46extern void ctrl_alt_del(void);
47
48/*
49 * Exported functions/variables
50 */
51
52#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
53
54/*
55 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
56 * This seems a good reason to start with NumLock off. On HIL keyboards
57 * of PARISC machines however there is no NumLock key and everyone expects the keypad
58 * to be used for numbers.
59 */
60
61#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
62#define KBD_DEFLEDS (1 << VC_NUMLOCK)
63#else
64#define KBD_DEFLEDS 0
65#endif
66
67#define KBD_DEFLOCK 0
68
69void compute_shiftstate(void);
70
71/*
72 * Handler Tables.
73 */
74
75#define K_HANDLERS\
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
80
81typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
82 char up_flag);
83static k_handler_fn K_HANDLERS;
84static k_handler_fn *k_handler[16] = { K_HANDLERS };
85
86#define FN_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
92
93typedef void (fn_handler_fn)(struct vc_data *vc);
94static fn_handler_fn FN_HANDLERS;
95static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
96
97/*
98 * Variables exported for vt_ioctl.c
99 */
100
101/* maximum values each key_handler can handle */
102const int max_vals[] = {
103 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
104 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
105 255, NR_LOCK - 1, 255, NR_BRL - 1
106};
107
108const int NR_TYPES = ARRAY_SIZE(max_vals);
109
110struct kbd_struct kbd_table[MAX_NR_CONSOLES];
111EXPORT_SYMBOL_GPL(kbd_table);
112static struct kbd_struct *kbd = kbd_table;
113
114struct vt_spawn_console vt_spawn_con = {
115 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
116 .pid = NULL,
117 .sig = 0,
118};
119
120/*
121 * Variables exported for vt.c
122 */
123
124int shift_state = 0;
125
126/*
127 * Internal Data.
128 */
129
130static struct input_handler kbd_handler;
131static DEFINE_SPINLOCK(kbd_event_lock);
132static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
133static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
134static bool dead_key_next;
135static int npadch = -1; /* -1 or number assembled on pad */
136static unsigned int diacr;
137static char rep; /* flag telling character repeat */
138
139static unsigned char ledstate = 0xff; /* undefined */
140static unsigned char ledioctl;
141
142static struct ledptr {
143 unsigned int *addr;
144 unsigned int mask;
145 unsigned char valid:1;
146} ledptrs[3];
147
148/*
149 * Notifier list for console keyboard events
150 */
151static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
152
153int register_keyboard_notifier(struct notifier_block *nb)
154{
155 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
156}
157EXPORT_SYMBOL_GPL(register_keyboard_notifier);
158
159int unregister_keyboard_notifier(struct notifier_block *nb)
160{
161 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
162}
163EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
164
165/*
166 * Translation of scancodes to keycodes. We set them on only the first
167 * keyboard in the list that accepts the scancode and keycode.
168 * Explanation for not choosing the first attached keyboard anymore:
169 * USB keyboards for example have two event devices: one for all "normal"
170 * keys and one for extra function keys (like "volume up", "make coffee",
171 * etc.). So this means that scancodes for the extra function keys won't
172 * be valid for the first event device, but will be for the second.
173 */
174
175struct getset_keycode_data {
176 struct input_keymap_entry ke;
177 int error;
178};
179
180static int getkeycode_helper(struct input_handle *handle, void *data)
181{
182 struct getset_keycode_data *d = data;
183
184 d->error = input_get_keycode(handle->dev, &d->ke);
185
186 return d->error == 0; /* stop as soon as we successfully get one */
187}
188
189int getkeycode(unsigned int scancode)
190{
191 struct getset_keycode_data d = {
192 .ke = {
193 .flags = 0,
194 .len = sizeof(scancode),
195 .keycode = 0,
196 },
197 .error = -ENODEV,
198 };
199
200 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
201
202 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
203
204 return d.error ?: d.ke.keycode;
205}
206
207static int setkeycode_helper(struct input_handle *handle, void *data)
208{
209 struct getset_keycode_data *d = data;
210
211 d->error = input_set_keycode(handle->dev, &d->ke);
212
213 return d->error == 0; /* stop as soon as we successfully set one */
214}
215
216int setkeycode(unsigned int scancode, unsigned int keycode)
217{
218 struct getset_keycode_data d = {
219 .ke = {
220 .flags = 0,
221 .len = sizeof(scancode),
222 .keycode = keycode,
223 },
224 .error = -ENODEV,
225 };
226
227 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
228
229 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
230
231 return d.error;
232}
233
234/*
235 * Making beeps and bells. Note that we prefer beeps to bells, but when
236 * shutting the sound off we do both.
237 */
238
239static int kd_sound_helper(struct input_handle *handle, void *data)
240{
241 unsigned int *hz = data;
242 struct input_dev *dev = handle->dev;
243
244 if (test_bit(EV_SND, dev->evbit)) {
245 if (test_bit(SND_TONE, dev->sndbit)) {
246 input_inject_event(handle, EV_SND, SND_TONE, *hz);
247 if (*hz)
248 return 0;
249 }
250 if (test_bit(SND_BELL, dev->sndbit))
251 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
252 }
253
254 return 0;
255}
256
257static void kd_nosound(unsigned long ignored)
258{
259 static unsigned int zero;
260
261 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
262}
263
264static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
265
266void kd_mksound(unsigned int hz, unsigned int ticks)
267{
268 del_timer_sync(&kd_mksound_timer);
269
270 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
271
272 if (hz && ticks)
273 mod_timer(&kd_mksound_timer, jiffies + ticks);
274}
275EXPORT_SYMBOL(kd_mksound);
276
277/*
278 * Setting the keyboard rate.
279 */
280
281static int kbd_rate_helper(struct input_handle *handle, void *data)
282{
283 struct input_dev *dev = handle->dev;
284 struct kbd_repeat *rep = data;
285
286 if (test_bit(EV_REP, dev->evbit)) {
287
288 if (rep[0].delay > 0)
289 input_inject_event(handle,
290 EV_REP, REP_DELAY, rep[0].delay);
291 if (rep[0].period > 0)
292 input_inject_event(handle,
293 EV_REP, REP_PERIOD, rep[0].period);
294
295 rep[1].delay = dev->rep[REP_DELAY];
296 rep[1].period = dev->rep[REP_PERIOD];
297 }
298
299 return 0;
300}
301
302int kbd_rate(struct kbd_repeat *rep)
303{
304 struct kbd_repeat data[2] = { *rep };
305
306 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
307 *rep = data[1]; /* Copy currently used settings */
308
309 return 0;
310}
311
312/*
313 * Helper Functions.
314 */
315static void put_queue(struct vc_data *vc, int ch)
316{
317 struct tty_struct *tty = vc->port.tty;
318
319 if (tty) {
320 tty_insert_flip_char(tty, ch, 0);
321 con_schedule_flip(tty);
322 }
323}
324
325static void puts_queue(struct vc_data *vc, char *cp)
326{
327 struct tty_struct *tty = vc->port.tty;
328
329 if (!tty)
330 return;
331
332 while (*cp) {
333 tty_insert_flip_char(tty, *cp, 0);
334 cp++;
335 }
336 con_schedule_flip(tty);
337}
338
339static void applkey(struct vc_data *vc, int key, char mode)
340{
341 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
342
343 buf[1] = (mode ? 'O' : '[');
344 buf[2] = key;
345 puts_queue(vc, buf);
346}
347
348/*
349 * Many other routines do put_queue, but I think either
350 * they produce ASCII, or they produce some user-assigned
351 * string, and in both cases we might assume that it is
352 * in utf-8 already.
353 */
354static void to_utf8(struct vc_data *vc, uint c)
355{
356 if (c < 0x80)
357 /* 0******* */
358 put_queue(vc, c);
359 else if (c < 0x800) {
360 /* 110***** 10****** */
361 put_queue(vc, 0xc0 | (c >> 6));
362 put_queue(vc, 0x80 | (c & 0x3f));
363 } else if (c < 0x10000) {
364 if (c >= 0xD800 && c < 0xE000)
365 return;
366 if (c == 0xFFFF)
367 return;
368 /* 1110**** 10****** 10****** */
369 put_queue(vc, 0xe0 | (c >> 12));
370 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
371 put_queue(vc, 0x80 | (c & 0x3f));
372 } else if (c < 0x110000) {
373 /* 11110*** 10****** 10****** 10****** */
374 put_queue(vc, 0xf0 | (c >> 18));
375 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
376 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
377 put_queue(vc, 0x80 | (c & 0x3f));
378 }
379}
380
381/*
382 * Called after returning from RAW mode or when changing consoles - recompute
383 * shift_down[] and shift_state from key_down[] maybe called when keymap is
384 * undefined, so that shiftkey release is seen
385 */
386void compute_shiftstate(void)
387{
388 unsigned int i, j, k, sym, val;
389
390 shift_state = 0;
391 memset(shift_down, 0, sizeof(shift_down));
392
393 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
394
395 if (!key_down[i])
396 continue;
397
398 k = i * BITS_PER_LONG;
399
400 for (j = 0; j < BITS_PER_LONG; j++, k++) {
401
402 if (!test_bit(k, key_down))
403 continue;
404
405 sym = U(key_maps[0][k]);
406 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
407 continue;
408
409 val = KVAL(sym);
410 if (val == KVAL(K_CAPSSHIFT))
411 val = KVAL(K_SHIFT);
412
413 shift_down[val]++;
414 shift_state |= (1 << val);
415 }
416 }
417}
418
419/*
420 * We have a combining character DIACR here, followed by the character CH.
421 * If the combination occurs in the table, return the corresponding value.
422 * Otherwise, if CH is a space or equals DIACR, return DIACR.
423 * Otherwise, conclude that DIACR was not combining after all,
424 * queue it and return CH.
425 */
426static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
427{
428 unsigned int d = diacr;
429 unsigned int i;
430
431 diacr = 0;
432
433 if ((d & ~0xff) == BRL_UC_ROW) {
434 if ((ch & ~0xff) == BRL_UC_ROW)
435 return d | ch;
436 } else {
437 for (i = 0; i < accent_table_size; i++)
438 if (accent_table[i].diacr == d && accent_table[i].base == ch)
439 return accent_table[i].result;
440 }
441
442 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
443 return d;
444
445 if (kbd->kbdmode == VC_UNICODE)
446 to_utf8(vc, d);
447 else {
448 int c = conv_uni_to_8bit(d);
449 if (c != -1)
450 put_queue(vc, c);
451 }
452
453 return ch;
454}
455
456/*
457 * Special function handlers
458 */
459static void fn_enter(struct vc_data *vc)
460{
461 if (diacr) {
462 if (kbd->kbdmode == VC_UNICODE)
463 to_utf8(vc, diacr);
464 else {
465 int c = conv_uni_to_8bit(diacr);
466 if (c != -1)
467 put_queue(vc, c);
468 }
469 diacr = 0;
470 }
471
472 put_queue(vc, 13);
473 if (vc_kbd_mode(kbd, VC_CRLF))
474 put_queue(vc, 10);
475}
476
477static void fn_caps_toggle(struct vc_data *vc)
478{
479 if (rep)
480 return;
481
482 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
483}
484
485static void fn_caps_on(struct vc_data *vc)
486{
487 if (rep)
488 return;
489
490 set_vc_kbd_led(kbd, VC_CAPSLOCK);
491}
492
493static void fn_show_ptregs(struct vc_data *vc)
494{
495 struct pt_regs *regs = get_irq_regs();
496
497 if (regs)
498 show_regs(regs);
499}
500
501static void fn_hold(struct vc_data *vc)
502{
503 struct tty_struct *tty = vc->port.tty;
504
505 if (rep || !tty)
506 return;
507
508 /*
509 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
510 * these routines are also activated by ^S/^Q.
511 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
512 */
513 if (tty->stopped)
514 start_tty(tty);
515 else
516 stop_tty(tty);
517}
518
519static void fn_num(struct vc_data *vc)
520{
521 if (vc_kbd_mode(kbd, VC_APPLIC))
522 applkey(vc, 'P', 1);
523 else
524 fn_bare_num(vc);
525}
526
527/*
528 * Bind this to Shift-NumLock if you work in application keypad mode
529 * but want to be able to change the NumLock flag.
530 * Bind this to NumLock if you prefer that the NumLock key always
531 * changes the NumLock flag.
532 */
533static void fn_bare_num(struct vc_data *vc)
534{
535 if (!rep)
536 chg_vc_kbd_led(kbd, VC_NUMLOCK);
537}
538
539static void fn_lastcons(struct vc_data *vc)
540{
541 /* switch to the last used console, ChN */
542 set_console(last_console);
543}
544
545static void fn_dec_console(struct vc_data *vc)
546{
547 int i, cur = fg_console;
548
549 /* Currently switching? Queue this next switch relative to that. */
550 if (want_console != -1)
551 cur = want_console;
552
553 for (i = cur - 1; i != cur; i--) {
554 if (i == -1)
555 i = MAX_NR_CONSOLES - 1;
556 if (vc_cons_allocated(i))
557 break;
558 }
559 set_console(i);
560}
561
562static void fn_inc_console(struct vc_data *vc)
563{
564 int i, cur = fg_console;
565
566 /* Currently switching? Queue this next switch relative to that. */
567 if (want_console != -1)
568 cur = want_console;
569
570 for (i = cur+1; i != cur; i++) {
571 if (i == MAX_NR_CONSOLES)
572 i = 0;
573 if (vc_cons_allocated(i))
574 break;
575 }
576 set_console(i);
577}
578
579static void fn_send_intr(struct vc_data *vc)
580{
581 struct tty_struct *tty = vc->port.tty;
582
583 if (!tty)
584 return;
585 tty_insert_flip_char(tty, 0, TTY_BREAK);
586 con_schedule_flip(tty);
587}
588
589static void fn_scroll_forw(struct vc_data *vc)
590{
591 scrollfront(vc, 0);
592}
593
594static void fn_scroll_back(struct vc_data *vc)
595{
596 scrollback(vc, 0);
597}
598
599static void fn_show_mem(struct vc_data *vc)
600{
601 show_mem(0);
602}
603
604static void fn_show_state(struct vc_data *vc)
605{
606 show_state();
607}
608
609static void fn_boot_it(struct vc_data *vc)
610{
611 ctrl_alt_del();
612}
613
614static void fn_compose(struct vc_data *vc)
615{
616 dead_key_next = true;
617}
618
619static void fn_spawn_con(struct vc_data *vc)
620{
621 spin_lock(&vt_spawn_con.lock);
622 if (vt_spawn_con.pid)
623 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
624 put_pid(vt_spawn_con.pid);
625 vt_spawn_con.pid = NULL;
626 }
627 spin_unlock(&vt_spawn_con.lock);
628}
629
630static void fn_SAK(struct vc_data *vc)
631{
632 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
633 schedule_work(SAK_work);
634}
635
636static void fn_null(struct vc_data *vc)
637{
638 compute_shiftstate();
639}
640
641/*
642 * Special key handlers
643 */
644static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
645{
646}
647
648static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
649{
650 if (up_flag)
651 return;
652 if (value >= ARRAY_SIZE(fn_handler))
653 return;
654 if ((kbd->kbdmode == VC_RAW ||
655 kbd->kbdmode == VC_MEDIUMRAW ||
656 kbd->kbdmode == VC_OFF) &&
657 value != KVAL(K_SAK))
658 return; /* SAK is allowed even in raw mode */
659 fn_handler[value](vc);
660}
661
662static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
663{
664 pr_err("k_lowercase was called - impossible\n");
665}
666
667static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
668{
669 if (up_flag)
670 return; /* no action, if this is a key release */
671
672 if (diacr)
673 value = handle_diacr(vc, value);
674
675 if (dead_key_next) {
676 dead_key_next = false;
677 diacr = value;
678 return;
679 }
680 if (kbd->kbdmode == VC_UNICODE)
681 to_utf8(vc, value);
682 else {
683 int c = conv_uni_to_8bit(value);
684 if (c != -1)
685 put_queue(vc, c);
686 }
687}
688
689/*
690 * Handle dead key. Note that we now may have several
691 * dead keys modifying the same character. Very useful
692 * for Vietnamese.
693 */
694static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
695{
696 if (up_flag)
697 return;
698
699 diacr = (diacr ? handle_diacr(vc, value) : value);
700}
701
702static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
703{
704 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
705}
706
707static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
708{
709 k_deadunicode(vc, value, up_flag);
710}
711
712/*
713 * Obsolete - for backwards compatibility only
714 */
715static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
716{
717 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
718
719 k_deadunicode(vc, ret_diacr[value], up_flag);
720}
721
722static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
723{
724 if (up_flag)
725 return;
726
727 set_console(value);
728}
729
730static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
731{
732 if (up_flag)
733 return;
734
735 if ((unsigned)value < ARRAY_SIZE(func_table)) {
736 if (func_table[value])
737 puts_queue(vc, func_table[value]);
738 } else
739 pr_err("k_fn called with value=%d\n", value);
740}
741
742static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
743{
744 static const char cur_chars[] = "BDCA";
745
746 if (up_flag)
747 return;
748
749 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
750}
751
752static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
753{
754 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
755 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
756
757 if (up_flag)
758 return; /* no action, if this is a key release */
759
760 /* kludge... shift forces cursor/number keys */
761 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
762 applkey(vc, app_map[value], 1);
763 return;
764 }
765
766 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
767
768 switch (value) {
769 case KVAL(K_PCOMMA):
770 case KVAL(K_PDOT):
771 k_fn(vc, KVAL(K_REMOVE), 0);
772 return;
773 case KVAL(K_P0):
774 k_fn(vc, KVAL(K_INSERT), 0);
775 return;
776 case KVAL(K_P1):
777 k_fn(vc, KVAL(K_SELECT), 0);
778 return;
779 case KVAL(K_P2):
780 k_cur(vc, KVAL(K_DOWN), 0);
781 return;
782 case KVAL(K_P3):
783 k_fn(vc, KVAL(K_PGDN), 0);
784 return;
785 case KVAL(K_P4):
786 k_cur(vc, KVAL(K_LEFT), 0);
787 return;
788 case KVAL(K_P6):
789 k_cur(vc, KVAL(K_RIGHT), 0);
790 return;
791 case KVAL(K_P7):
792 k_fn(vc, KVAL(K_FIND), 0);
793 return;
794 case KVAL(K_P8):
795 k_cur(vc, KVAL(K_UP), 0);
796 return;
797 case KVAL(K_P9):
798 k_fn(vc, KVAL(K_PGUP), 0);
799 return;
800 case KVAL(K_P5):
801 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
802 return;
803 }
804 }
805
806 put_queue(vc, pad_chars[value]);
807 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
808 put_queue(vc, 10);
809}
810
811static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
812{
813 int old_state = shift_state;
814
815 if (rep)
816 return;
817 /*
818 * Mimic typewriter:
819 * a CapsShift key acts like Shift but undoes CapsLock
820 */
821 if (value == KVAL(K_CAPSSHIFT)) {
822 value = KVAL(K_SHIFT);
823 if (!up_flag)
824 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
825 }
826
827 if (up_flag) {
828 /*
829 * handle the case that two shift or control
830 * keys are depressed simultaneously
831 */
832 if (shift_down[value])
833 shift_down[value]--;
834 } else
835 shift_down[value]++;
836
837 if (shift_down[value])
838 shift_state |= (1 << value);
839 else
840 shift_state &= ~(1 << value);
841
842 /* kludge */
843 if (up_flag && shift_state != old_state && npadch != -1) {
844 if (kbd->kbdmode == VC_UNICODE)
845 to_utf8(vc, npadch);
846 else
847 put_queue(vc, npadch & 0xff);
848 npadch = -1;
849 }
850}
851
852static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
853{
854 if (up_flag)
855 return;
856
857 if (vc_kbd_mode(kbd, VC_META)) {
858 put_queue(vc, '\033');
859 put_queue(vc, value);
860 } else
861 put_queue(vc, value | 0x80);
862}
863
864static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
865{
866 int base;
867
868 if (up_flag)
869 return;
870
871 if (value < 10) {
872 /* decimal input of code, while Alt depressed */
873 base = 10;
874 } else {
875 /* hexadecimal input of code, while AltGr depressed */
876 value -= 10;
877 base = 16;
878 }
879
880 if (npadch == -1)
881 npadch = value;
882 else
883 npadch = npadch * base + value;
884}
885
886static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
887{
888 if (up_flag || rep)
889 return;
890
891 chg_vc_kbd_lock(kbd, value);
892}
893
894static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
895{
896 k_shift(vc, value, up_flag);
897 if (up_flag || rep)
898 return;
899
900 chg_vc_kbd_slock(kbd, value);
901 /* try to make Alt, oops, AltGr and such work */
902 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
903 kbd->slockstate = 0;
904 chg_vc_kbd_slock(kbd, value);
905 }
906}
907
908/* by default, 300ms interval for combination release */
909static unsigned brl_timeout = 300;
910MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
911module_param(brl_timeout, uint, 0644);
912
913static unsigned brl_nbchords = 1;
914MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
915module_param(brl_nbchords, uint, 0644);
916
917static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
918{
919 static unsigned long chords;
920 static unsigned committed;
921
922 if (!brl_nbchords)
923 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
924 else {
925 committed |= pattern;
926 chords++;
927 if (chords == brl_nbchords) {
928 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
929 chords = 0;
930 committed = 0;
931 }
932 }
933}
934
935static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
936{
937 static unsigned pressed, committing;
938 static unsigned long releasestart;
939
940 if (kbd->kbdmode != VC_UNICODE) {
941 if (!up_flag)
942 pr_warning("keyboard mode must be unicode for braille patterns\n");
943 return;
944 }
945
946 if (!value) {
947 k_unicode(vc, BRL_UC_ROW, up_flag);
948 return;
949 }
950
951 if (value > 8)
952 return;
953
954 if (!up_flag) {
955 pressed |= 1 << (value - 1);
956 if (!brl_timeout)
957 committing = pressed;
958 } else if (brl_timeout) {
959 if (!committing ||
960 time_after(jiffies,
961 releasestart + msecs_to_jiffies(brl_timeout))) {
962 committing = pressed;
963 releasestart = jiffies;
964 }
965 pressed &= ~(1 << (value - 1));
966 if (!pressed && committing) {
967 k_brlcommit(vc, committing, 0);
968 committing = 0;
969 }
970 } else {
971 if (committing) {
972 k_brlcommit(vc, committing, 0);
973 committing = 0;
974 }
975 pressed &= ~(1 << (value - 1));
976 }
977}
978
979/*
980 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
981 * or (ii) whatever pattern of lights people want to show using KDSETLED,
982 * or (iii) specified bits of specified words in kernel memory.
983 */
984unsigned char getledstate(void)
985{
986 return ledstate;
987}
988
989void setledstate(struct kbd_struct *kbd, unsigned int led)
990{
991 if (!(led & ~7)) {
992 ledioctl = led;
993 kbd->ledmode = LED_SHOW_IOCTL;
994 } else
995 kbd->ledmode = LED_SHOW_FLAGS;
996
997 set_leds();
998}
999
1000static inline unsigned char getleds(void)
1001{
1002 struct kbd_struct *kbd = kbd_table + fg_console;
1003 unsigned char leds;
1004 int i;
1005
1006 if (kbd->ledmode == LED_SHOW_IOCTL)
1007 return ledioctl;
1008
1009 leds = kbd->ledflagstate;
1010
1011 if (kbd->ledmode == LED_SHOW_MEM) {
1012 for (i = 0; i < 3; i++)
1013 if (ledptrs[i].valid) {
1014 if (*ledptrs[i].addr & ledptrs[i].mask)
1015 leds |= (1 << i);
1016 else
1017 leds &= ~(1 << i);
1018 }
1019 }
1020 return leds;
1021}
1022
1023static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1024{
1025 unsigned char leds = *(unsigned char *)data;
1026
1027 if (test_bit(EV_LED, handle->dev->evbit)) {
1028 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1029 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1030 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1031 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1032 }
1033
1034 return 0;
1035}
1036
1037/*
1038 * This is the tasklet that updates LED state on all keyboards
1039 * attached to the box. The reason we use tasklet is that we
1040 * need to handle the scenario when keyboard handler is not
1041 * registered yet but we already getting updates form VT to
1042 * update led state.
1043 */
1044static void kbd_bh(unsigned long dummy)
1045{
1046 unsigned char leds = getleds();
1047
1048 if (leds != ledstate) {
1049 input_handler_for_each_handle(&kbd_handler, &leds,
1050 kbd_update_leds_helper);
1051 ledstate = leds;
1052 }
1053}
1054
1055DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1056
1057#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1058 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1059 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1060 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1061 defined(CONFIG_AVR32)
1062
1063#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1064 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1065
1066static const unsigned short x86_keycodes[256] =
1067 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1068 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1069 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1070 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1071 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1072 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1073 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1074 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1075 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1076 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1077 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1078 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1079 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1080 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1081 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1082
1083#ifdef CONFIG_SPARC
1084static int sparc_l1_a_state;
1085extern void sun_do_break(void);
1086#endif
1087
1088static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1089 unsigned char up_flag)
1090{
1091 int code;
1092
1093 switch (keycode) {
1094
1095 case KEY_PAUSE:
1096 put_queue(vc, 0xe1);
1097 put_queue(vc, 0x1d | up_flag);
1098 put_queue(vc, 0x45 | up_flag);
1099 break;
1100
1101 case KEY_HANGEUL:
1102 if (!up_flag)
1103 put_queue(vc, 0xf2);
1104 break;
1105
1106 case KEY_HANJA:
1107 if (!up_flag)
1108 put_queue(vc, 0xf1);
1109 break;
1110
1111 case KEY_SYSRQ:
1112 /*
1113 * Real AT keyboards (that's what we're trying
1114 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1115 * pressing PrtSc/SysRq alone, but simply 0x54
1116 * when pressing Alt+PrtSc/SysRq.
1117 */
1118 if (test_bit(KEY_LEFTALT, key_down) ||
1119 test_bit(KEY_RIGHTALT, key_down)) {
1120 put_queue(vc, 0x54 | up_flag);
1121 } else {
1122 put_queue(vc, 0xe0);
1123 put_queue(vc, 0x2a | up_flag);
1124 put_queue(vc, 0xe0);
1125 put_queue(vc, 0x37 | up_flag);
1126 }
1127 break;
1128
1129 default:
1130 if (keycode > 255)
1131 return -1;
1132
1133 code = x86_keycodes[keycode];
1134 if (!code)
1135 return -1;
1136
1137 if (code & 0x100)
1138 put_queue(vc, 0xe0);
1139 put_queue(vc, (code & 0x7f) | up_flag);
1140
1141 break;
1142 }
1143
1144 return 0;
1145}
1146
1147#else
1148
1149#define HW_RAW(dev) 0
1150
1151static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1152{
1153 if (keycode > 127)
1154 return -1;
1155
1156 put_queue(vc, keycode | up_flag);
1157 return 0;
1158}
1159#endif
1160
1161static void kbd_rawcode(unsigned char data)
1162{
1163 struct vc_data *vc = vc_cons[fg_console].d;
1164
1165 kbd = kbd_table + vc->vc_num;
1166 if (kbd->kbdmode == VC_RAW)
1167 put_queue(vc, data);
1168}
1169
1170static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1171{
1172 struct vc_data *vc = vc_cons[fg_console].d;
1173 unsigned short keysym, *key_map;
1174 unsigned char type;
1175 bool raw_mode;
1176 struct tty_struct *tty;
1177 int shift_final;
1178 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1179 int rc;
1180
1181 tty = vc->port.tty;
1182
1183 if (tty && (!tty->driver_data)) {
1184 /* No driver data? Strange. Okay we fix it then. */
1185 tty->driver_data = vc;
1186 }
1187
1188 kbd = kbd_table + vc->vc_num;
1189
1190#ifdef CONFIG_SPARC
1191 if (keycode == KEY_STOP)
1192 sparc_l1_a_state = down;
1193#endif
1194
1195 rep = (down == 2);
1196
1197 raw_mode = (kbd->kbdmode == VC_RAW);
1198 if (raw_mode && !hw_raw)
1199 if (emulate_raw(vc, keycode, !down << 7))
1200 if (keycode < BTN_MISC && printk_ratelimit())
1201 pr_warning("can't emulate rawmode for keycode %d\n",
1202 keycode);
1203
1204#ifdef CONFIG_SPARC
1205 if (keycode == KEY_A && sparc_l1_a_state) {
1206 sparc_l1_a_state = false;
1207 sun_do_break();
1208 }
1209#endif
1210
1211 if (kbd->kbdmode == VC_MEDIUMRAW) {
1212 /*
1213 * This is extended medium raw mode, with keys above 127
1214 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1215 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1216 * interfere with anything else. The two bytes after 0 will
1217 * always have the up flag set not to interfere with older
1218 * applications. This allows for 16384 different keycodes,
1219 * which should be enough.
1220 */
1221 if (keycode < 128) {
1222 put_queue(vc, keycode | (!down << 7));
1223 } else {
1224 put_queue(vc, !down << 7);
1225 put_queue(vc, (keycode >> 7) | 0x80);
1226 put_queue(vc, keycode | 0x80);
1227 }
1228 raw_mode = true;
1229 }
1230
1231 if (down)
1232 set_bit(keycode, key_down);
1233 else
1234 clear_bit(keycode, key_down);
1235
1236 if (rep &&
1237 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1238 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1239 /*
1240 * Don't repeat a key if the input buffers are not empty and the
1241 * characters get aren't echoed locally. This makes key repeat
1242 * usable with slow applications and under heavy loads.
1243 */
1244 return;
1245 }
1246
1247 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1248 param.ledstate = kbd->ledflagstate;
1249 key_map = key_maps[shift_final];
1250
1251 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1252 KBD_KEYCODE, ¶m);
1253 if (rc == NOTIFY_STOP || !key_map) {
1254 atomic_notifier_call_chain(&keyboard_notifier_list,
1255 KBD_UNBOUND_KEYCODE, ¶m);
1256 compute_shiftstate();
1257 kbd->slockstate = 0;
1258 return;
1259 }
1260
1261 if (keycode < NR_KEYS)
1262 keysym = key_map[keycode];
1263 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1264 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1265 else
1266 return;
1267
1268 type = KTYP(keysym);
1269
1270 if (type < 0xf0) {
1271 param.value = keysym;
1272 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1273 KBD_UNICODE, ¶m);
1274 if (rc != NOTIFY_STOP)
1275 if (down && !raw_mode)
1276 to_utf8(vc, keysym);
1277 return;
1278 }
1279
1280 type -= 0xf0;
1281
1282 if (type == KT_LETTER) {
1283 type = KT_LATIN;
1284 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1285 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1286 if (key_map)
1287 keysym = key_map[keycode];
1288 }
1289 }
1290
1291 param.value = keysym;
1292 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1293 KBD_KEYSYM, ¶m);
1294 if (rc == NOTIFY_STOP)
1295 return;
1296
1297 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1298 return;
1299
1300 (*k_handler[type])(vc, keysym & 0xff, !down);
1301
1302 param.ledstate = kbd->ledflagstate;
1303 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1304
1305 if (type != KT_SLOCK)
1306 kbd->slockstate = 0;
1307}
1308
1309static void kbd_event(struct input_handle *handle, unsigned int event_type,
1310 unsigned int event_code, int value)
1311{
1312 /* We are called with interrupts disabled, just take the lock */
1313 spin_lock(&kbd_event_lock);
1314
1315 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1316 kbd_rawcode(value);
1317 if (event_type == EV_KEY)
1318 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1319
1320 spin_unlock(&kbd_event_lock);
1321
1322 tasklet_schedule(&keyboard_tasklet);
1323 do_poke_blanked_console = 1;
1324 schedule_console_callback();
1325}
1326
1327static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1328{
1329 int i;
1330
1331 if (test_bit(EV_SND, dev->evbit))
1332 return true;
1333
1334 if (test_bit(EV_KEY, dev->evbit)) {
1335 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1336 if (test_bit(i, dev->keybit))
1337 return true;
1338 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1339 if (test_bit(i, dev->keybit))
1340 return true;
1341 }
1342
1343 return false;
1344}
1345
1346/*
1347 * When a keyboard (or other input device) is found, the kbd_connect
1348 * function is called. The function then looks at the device, and if it
1349 * likes it, it can open it and get events from it. In this (kbd_connect)
1350 * function, we should decide which VT to bind that keyboard to initially.
1351 */
1352static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1353 const struct input_device_id *id)
1354{
1355 struct input_handle *handle;
1356 int error;
1357
1358 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1359 if (!handle)
1360 return -ENOMEM;
1361
1362 handle->dev = dev;
1363 handle->handler = handler;
1364 handle->name = "kbd";
1365
1366 error = input_register_handle(handle);
1367 if (error)
1368 goto err_free_handle;
1369
1370 error = input_open_device(handle);
1371 if (error)
1372 goto err_unregister_handle;
1373
1374 return 0;
1375
1376 err_unregister_handle:
1377 input_unregister_handle(handle);
1378 err_free_handle:
1379 kfree(handle);
1380 return error;
1381}
1382
1383static void kbd_disconnect(struct input_handle *handle)
1384{
1385 input_close_device(handle);
1386 input_unregister_handle(handle);
1387 kfree(handle);
1388}
1389
1390/*
1391 * Start keyboard handler on the new keyboard by refreshing LED state to
1392 * match the rest of the system.
1393 */
1394static void kbd_start(struct input_handle *handle)
1395{
1396 tasklet_disable(&keyboard_tasklet);
1397
1398 if (ledstate != 0xff)
1399 kbd_update_leds_helper(handle, &ledstate);
1400
1401 tasklet_enable(&keyboard_tasklet);
1402}
1403
1404static const struct input_device_id kbd_ids[] = {
1405 {
1406 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1407 .evbit = { BIT_MASK(EV_KEY) },
1408 },
1409
1410 {
1411 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1412 .evbit = { BIT_MASK(EV_SND) },
1413 },
1414
1415 { }, /* Terminating entry */
1416};
1417
1418MODULE_DEVICE_TABLE(input, kbd_ids);
1419
1420static struct input_handler kbd_handler = {
1421 .event = kbd_event,
1422 .match = kbd_match,
1423 .connect = kbd_connect,
1424 .disconnect = kbd_disconnect,
1425 .start = kbd_start,
1426 .name = "kbd",
1427 .id_table = kbd_ids,
1428};
1429
1430int __init kbd_init(void)
1431{
1432 int i;
1433 int error;
1434
1435 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1436 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1437 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1438 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1439 kbd_table[i].lockstate = KBD_DEFLOCK;
1440 kbd_table[i].slockstate = 0;
1441 kbd_table[i].modeflags = KBD_DEFMODE;
1442 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1443 }
1444
1445 error = input_register_handler(&kbd_handler);
1446 if (error)
1447 return error;
1448
1449 tasklet_enable(&keyboard_tasklet);
1450 tasklet_schedule(&keyboard_tasklet);
1451
1452 return 0;
1453}
1/*
2 * Written for linux by Johan Myreen as a translation from
3 * the assembly version by Linus (with diacriticals added)
4 *
5 * Some additional features added by Christoph Niemann (ChN), March 1993
6 *
7 * Loadable keymaps by Risto Kankkunen, May 1993
8 *
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.
13 *
14 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
15 *
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
19 *
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)
23 */
24
25#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
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>
36#include <linux/leds.h>
37
38#include <linux/kbd_kern.h>
39#include <linux/kbd_diacr.h>
40#include <linux/vt_kern.h>
41#include <linux/input.h>
42#include <linux/reboot.h>
43#include <linux/notifier.h>
44#include <linux/jiffies.h>
45#include <linux/uaccess.h>
46
47#include <asm/irq_regs.h>
48
49extern void ctrl_alt_del(void);
50
51/*
52 * Exported functions/variables
53 */
54
55#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
56
57#if defined(CONFIG_X86) || defined(CONFIG_PARISC)
58#include <asm/kbdleds.h>
59#else
60static inline int kbd_defleds(void)
61{
62 return 0;
63}
64#endif
65
66#define KBD_DEFLOCK 0
67
68/*
69 * Handler Tables.
70 */
71
72#define K_HANDLERS\
73 k_self, k_fn, k_spec, k_pad,\
74 k_dead, k_cons, k_cur, k_shift,\
75 k_meta, k_ascii, k_lock, k_lowercase,\
76 k_slock, k_dead2, k_brl, k_ignore
77
78typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
79 char up_flag);
80static k_handler_fn K_HANDLERS;
81static k_handler_fn *k_handler[16] = { K_HANDLERS };
82
83#define FN_HANDLERS\
84 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
85 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
86 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
87 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
88 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
89
90typedef void (fn_handler_fn)(struct vc_data *vc);
91static fn_handler_fn FN_HANDLERS;
92static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
93
94/*
95 * Variables exported for vt_ioctl.c
96 */
97
98struct vt_spawn_console vt_spawn_con = {
99 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
100 .pid = NULL,
101 .sig = 0,
102};
103
104
105/*
106 * Internal Data.
107 */
108
109static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
110static struct kbd_struct *kbd = kbd_table;
111
112/* maximum values each key_handler can handle */
113static const int max_vals[] = {
114 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
115 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
116 255, NR_LOCK - 1, 255, NR_BRL - 1
117};
118
119static const int NR_TYPES = ARRAY_SIZE(max_vals);
120
121static struct input_handler kbd_handler;
122static DEFINE_SPINLOCK(kbd_event_lock);
123static DEFINE_SPINLOCK(led_lock);
124static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
125static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
126static bool dead_key_next;
127static int npadch = -1; /* -1 or number assembled on pad */
128static unsigned int diacr;
129static char rep; /* flag telling character repeat */
130
131static int shift_state = 0;
132
133static unsigned int ledstate = -1U; /* undefined */
134static unsigned char ledioctl;
135
136/*
137 * Notifier list for console keyboard events
138 */
139static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
140
141int register_keyboard_notifier(struct notifier_block *nb)
142{
143 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
144}
145EXPORT_SYMBOL_GPL(register_keyboard_notifier);
146
147int unregister_keyboard_notifier(struct notifier_block *nb)
148{
149 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
150}
151EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
152
153/*
154 * Translation of scancodes to keycodes. We set them on only the first
155 * keyboard in the list that accepts the scancode and keycode.
156 * Explanation for not choosing the first attached keyboard anymore:
157 * USB keyboards for example have two event devices: one for all "normal"
158 * keys and one for extra function keys (like "volume up", "make coffee",
159 * etc.). So this means that scancodes for the extra function keys won't
160 * be valid for the first event device, but will be for the second.
161 */
162
163struct getset_keycode_data {
164 struct input_keymap_entry ke;
165 int error;
166};
167
168static int getkeycode_helper(struct input_handle *handle, void *data)
169{
170 struct getset_keycode_data *d = data;
171
172 d->error = input_get_keycode(handle->dev, &d->ke);
173
174 return d->error == 0; /* stop as soon as we successfully get one */
175}
176
177static int getkeycode(unsigned int scancode)
178{
179 struct getset_keycode_data d = {
180 .ke = {
181 .flags = 0,
182 .len = sizeof(scancode),
183 .keycode = 0,
184 },
185 .error = -ENODEV,
186 };
187
188 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
189
190 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
191
192 return d.error ?: d.ke.keycode;
193}
194
195static int setkeycode_helper(struct input_handle *handle, void *data)
196{
197 struct getset_keycode_data *d = data;
198
199 d->error = input_set_keycode(handle->dev, &d->ke);
200
201 return d->error == 0; /* stop as soon as we successfully set one */
202}
203
204static int setkeycode(unsigned int scancode, unsigned int keycode)
205{
206 struct getset_keycode_data d = {
207 .ke = {
208 .flags = 0,
209 .len = sizeof(scancode),
210 .keycode = keycode,
211 },
212 .error = -ENODEV,
213 };
214
215 memcpy(d.ke.scancode, &scancode, sizeof(scancode));
216
217 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
218
219 return d.error;
220}
221
222/*
223 * Making beeps and bells. Note that we prefer beeps to bells, but when
224 * shutting the sound off we do both.
225 */
226
227static int kd_sound_helper(struct input_handle *handle, void *data)
228{
229 unsigned int *hz = data;
230 struct input_dev *dev = handle->dev;
231
232 if (test_bit(EV_SND, dev->evbit)) {
233 if (test_bit(SND_TONE, dev->sndbit)) {
234 input_inject_event(handle, EV_SND, SND_TONE, *hz);
235 if (*hz)
236 return 0;
237 }
238 if (test_bit(SND_BELL, dev->sndbit))
239 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
240 }
241
242 return 0;
243}
244
245static void kd_nosound(unsigned long ignored)
246{
247 static unsigned int zero;
248
249 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
250}
251
252static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
253
254void kd_mksound(unsigned int hz, unsigned int ticks)
255{
256 del_timer_sync(&kd_mksound_timer);
257
258 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
259
260 if (hz && ticks)
261 mod_timer(&kd_mksound_timer, jiffies + ticks);
262}
263EXPORT_SYMBOL(kd_mksound);
264
265/*
266 * Setting the keyboard rate.
267 */
268
269static int kbd_rate_helper(struct input_handle *handle, void *data)
270{
271 struct input_dev *dev = handle->dev;
272 struct kbd_repeat *rpt = data;
273
274 if (test_bit(EV_REP, dev->evbit)) {
275
276 if (rpt[0].delay > 0)
277 input_inject_event(handle,
278 EV_REP, REP_DELAY, rpt[0].delay);
279 if (rpt[0].period > 0)
280 input_inject_event(handle,
281 EV_REP, REP_PERIOD, rpt[0].period);
282
283 rpt[1].delay = dev->rep[REP_DELAY];
284 rpt[1].period = dev->rep[REP_PERIOD];
285 }
286
287 return 0;
288}
289
290int kbd_rate(struct kbd_repeat *rpt)
291{
292 struct kbd_repeat data[2] = { *rpt };
293
294 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
295 *rpt = data[1]; /* Copy currently used settings */
296
297 return 0;
298}
299
300/*
301 * Helper Functions.
302 */
303static void put_queue(struct vc_data *vc, int ch)
304{
305 tty_insert_flip_char(&vc->port, ch, 0);
306 tty_schedule_flip(&vc->port);
307}
308
309static void puts_queue(struct vc_data *vc, char *cp)
310{
311 while (*cp) {
312 tty_insert_flip_char(&vc->port, *cp, 0);
313 cp++;
314 }
315 tty_schedule_flip(&vc->port);
316}
317
318static void applkey(struct vc_data *vc, int key, char mode)
319{
320 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
321
322 buf[1] = (mode ? 'O' : '[');
323 buf[2] = key;
324 puts_queue(vc, buf);
325}
326
327/*
328 * Many other routines do put_queue, but I think either
329 * they produce ASCII, or they produce some user-assigned
330 * string, and in both cases we might assume that it is
331 * in utf-8 already.
332 */
333static void to_utf8(struct vc_data *vc, uint c)
334{
335 if (c < 0x80)
336 /* 0******* */
337 put_queue(vc, c);
338 else if (c < 0x800) {
339 /* 110***** 10****** */
340 put_queue(vc, 0xc0 | (c >> 6));
341 put_queue(vc, 0x80 | (c & 0x3f));
342 } else if (c < 0x10000) {
343 if (c >= 0xD800 && c < 0xE000)
344 return;
345 if (c == 0xFFFF)
346 return;
347 /* 1110**** 10****** 10****** */
348 put_queue(vc, 0xe0 | (c >> 12));
349 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
350 put_queue(vc, 0x80 | (c & 0x3f));
351 } else if (c < 0x110000) {
352 /* 11110*** 10****** 10****** 10****** */
353 put_queue(vc, 0xf0 | (c >> 18));
354 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
355 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
356 put_queue(vc, 0x80 | (c & 0x3f));
357 }
358}
359
360/*
361 * Called after returning from RAW mode or when changing consoles - recompute
362 * shift_down[] and shift_state from key_down[] maybe called when keymap is
363 * undefined, so that shiftkey release is seen. The caller must hold the
364 * kbd_event_lock.
365 */
366
367static void do_compute_shiftstate(void)
368{
369 unsigned int k, sym, val;
370
371 shift_state = 0;
372 memset(shift_down, 0, sizeof(shift_down));
373
374 for_each_set_bit(k, key_down, min(NR_KEYS, KEY_CNT)) {
375 sym = U(key_maps[0][k]);
376 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
377 continue;
378
379 val = KVAL(sym);
380 if (val == KVAL(K_CAPSSHIFT))
381 val = KVAL(K_SHIFT);
382
383 shift_down[val]++;
384 shift_state |= BIT(val);
385 }
386}
387
388/* We still have to export this method to vt.c */
389void compute_shiftstate(void)
390{
391 unsigned long flags;
392 spin_lock_irqsave(&kbd_event_lock, flags);
393 do_compute_shiftstate();
394 spin_unlock_irqrestore(&kbd_event_lock, flags);
395}
396
397/*
398 * We have a combining character DIACR here, followed by the character CH.
399 * If the combination occurs in the table, return the corresponding value.
400 * Otherwise, if CH is a space or equals DIACR, return DIACR.
401 * Otherwise, conclude that DIACR was not combining after all,
402 * queue it and return CH.
403 */
404static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
405{
406 unsigned int d = diacr;
407 unsigned int i;
408
409 diacr = 0;
410
411 if ((d & ~0xff) == BRL_UC_ROW) {
412 if ((ch & ~0xff) == BRL_UC_ROW)
413 return d | ch;
414 } else {
415 for (i = 0; i < accent_table_size; i++)
416 if (accent_table[i].diacr == d && accent_table[i].base == ch)
417 return accent_table[i].result;
418 }
419
420 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
421 return d;
422
423 if (kbd->kbdmode == VC_UNICODE)
424 to_utf8(vc, d);
425 else {
426 int c = conv_uni_to_8bit(d);
427 if (c != -1)
428 put_queue(vc, c);
429 }
430
431 return ch;
432}
433
434/*
435 * Special function handlers
436 */
437static void fn_enter(struct vc_data *vc)
438{
439 if (diacr) {
440 if (kbd->kbdmode == VC_UNICODE)
441 to_utf8(vc, diacr);
442 else {
443 int c = conv_uni_to_8bit(diacr);
444 if (c != -1)
445 put_queue(vc, c);
446 }
447 diacr = 0;
448 }
449
450 put_queue(vc, 13);
451 if (vc_kbd_mode(kbd, VC_CRLF))
452 put_queue(vc, 10);
453}
454
455static void fn_caps_toggle(struct vc_data *vc)
456{
457 if (rep)
458 return;
459
460 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
461}
462
463static void fn_caps_on(struct vc_data *vc)
464{
465 if (rep)
466 return;
467
468 set_vc_kbd_led(kbd, VC_CAPSLOCK);
469}
470
471static void fn_show_ptregs(struct vc_data *vc)
472{
473 struct pt_regs *regs = get_irq_regs();
474
475 if (regs)
476 show_regs(regs);
477}
478
479static void fn_hold(struct vc_data *vc)
480{
481 struct tty_struct *tty = vc->port.tty;
482
483 if (rep || !tty)
484 return;
485
486 /*
487 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
488 * these routines are also activated by ^S/^Q.
489 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
490 */
491 if (tty->stopped)
492 start_tty(tty);
493 else
494 stop_tty(tty);
495}
496
497static void fn_num(struct vc_data *vc)
498{
499 if (vc_kbd_mode(kbd, VC_APPLIC))
500 applkey(vc, 'P', 1);
501 else
502 fn_bare_num(vc);
503}
504
505/*
506 * Bind this to Shift-NumLock if you work in application keypad mode
507 * but want to be able to change the NumLock flag.
508 * Bind this to NumLock if you prefer that the NumLock key always
509 * changes the NumLock flag.
510 */
511static void fn_bare_num(struct vc_data *vc)
512{
513 if (!rep)
514 chg_vc_kbd_led(kbd, VC_NUMLOCK);
515}
516
517static void fn_lastcons(struct vc_data *vc)
518{
519 /* switch to the last used console, ChN */
520 set_console(last_console);
521}
522
523static void fn_dec_console(struct vc_data *vc)
524{
525 int i, cur = fg_console;
526
527 /* Currently switching? Queue this next switch relative to that. */
528 if (want_console != -1)
529 cur = want_console;
530
531 for (i = cur - 1; i != cur; i--) {
532 if (i == -1)
533 i = MAX_NR_CONSOLES - 1;
534 if (vc_cons_allocated(i))
535 break;
536 }
537 set_console(i);
538}
539
540static void fn_inc_console(struct vc_data *vc)
541{
542 int i, cur = fg_console;
543
544 /* Currently switching? Queue this next switch relative to that. */
545 if (want_console != -1)
546 cur = want_console;
547
548 for (i = cur+1; i != cur; i++) {
549 if (i == MAX_NR_CONSOLES)
550 i = 0;
551 if (vc_cons_allocated(i))
552 break;
553 }
554 set_console(i);
555}
556
557static void fn_send_intr(struct vc_data *vc)
558{
559 tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
560 tty_schedule_flip(&vc->port);
561}
562
563static void fn_scroll_forw(struct vc_data *vc)
564{
565 scrollfront(vc, 0);
566}
567
568static void fn_scroll_back(struct vc_data *vc)
569{
570 scrollback(vc);
571}
572
573static void fn_show_mem(struct vc_data *vc)
574{
575 show_mem(0);
576}
577
578static void fn_show_state(struct vc_data *vc)
579{
580 show_state();
581}
582
583static void fn_boot_it(struct vc_data *vc)
584{
585 ctrl_alt_del();
586}
587
588static void fn_compose(struct vc_data *vc)
589{
590 dead_key_next = true;
591}
592
593static void fn_spawn_con(struct vc_data *vc)
594{
595 spin_lock(&vt_spawn_con.lock);
596 if (vt_spawn_con.pid)
597 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
598 put_pid(vt_spawn_con.pid);
599 vt_spawn_con.pid = NULL;
600 }
601 spin_unlock(&vt_spawn_con.lock);
602}
603
604static void fn_SAK(struct vc_data *vc)
605{
606 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
607 schedule_work(SAK_work);
608}
609
610static void fn_null(struct vc_data *vc)
611{
612 do_compute_shiftstate();
613}
614
615/*
616 * Special key handlers
617 */
618static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
619{
620}
621
622static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
623{
624 if (up_flag)
625 return;
626 if (value >= ARRAY_SIZE(fn_handler))
627 return;
628 if ((kbd->kbdmode == VC_RAW ||
629 kbd->kbdmode == VC_MEDIUMRAW ||
630 kbd->kbdmode == VC_OFF) &&
631 value != KVAL(K_SAK))
632 return; /* SAK is allowed even in raw mode */
633 fn_handler[value](vc);
634}
635
636static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
637{
638 pr_err("k_lowercase was called - impossible\n");
639}
640
641static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
642{
643 if (up_flag)
644 return; /* no action, if this is a key release */
645
646 if (diacr)
647 value = handle_diacr(vc, value);
648
649 if (dead_key_next) {
650 dead_key_next = false;
651 diacr = value;
652 return;
653 }
654 if (kbd->kbdmode == VC_UNICODE)
655 to_utf8(vc, value);
656 else {
657 int c = conv_uni_to_8bit(value);
658 if (c != -1)
659 put_queue(vc, c);
660 }
661}
662
663/*
664 * Handle dead key. Note that we now may have several
665 * dead keys modifying the same character. Very useful
666 * for Vietnamese.
667 */
668static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
669{
670 if (up_flag)
671 return;
672
673 diacr = (diacr ? handle_diacr(vc, value) : value);
674}
675
676static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
677{
678 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
679}
680
681static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
682{
683 k_deadunicode(vc, value, up_flag);
684}
685
686/*
687 * Obsolete - for backwards compatibility only
688 */
689static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
690{
691 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
692
693 k_deadunicode(vc, ret_diacr[value], up_flag);
694}
695
696static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
697{
698 if (up_flag)
699 return;
700
701 set_console(value);
702}
703
704static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
705{
706 if (up_flag)
707 return;
708
709 if ((unsigned)value < ARRAY_SIZE(func_table)) {
710 if (func_table[value])
711 puts_queue(vc, func_table[value]);
712 } else
713 pr_err("k_fn called with value=%d\n", value);
714}
715
716static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
717{
718 static const char cur_chars[] = "BDCA";
719
720 if (up_flag)
721 return;
722
723 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
724}
725
726static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
727{
728 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
729 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
730
731 if (up_flag)
732 return; /* no action, if this is a key release */
733
734 /* kludge... shift forces cursor/number keys */
735 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
736 applkey(vc, app_map[value], 1);
737 return;
738 }
739
740 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
741
742 switch (value) {
743 case KVAL(K_PCOMMA):
744 case KVAL(K_PDOT):
745 k_fn(vc, KVAL(K_REMOVE), 0);
746 return;
747 case KVAL(K_P0):
748 k_fn(vc, KVAL(K_INSERT), 0);
749 return;
750 case KVAL(K_P1):
751 k_fn(vc, KVAL(K_SELECT), 0);
752 return;
753 case KVAL(K_P2):
754 k_cur(vc, KVAL(K_DOWN), 0);
755 return;
756 case KVAL(K_P3):
757 k_fn(vc, KVAL(K_PGDN), 0);
758 return;
759 case KVAL(K_P4):
760 k_cur(vc, KVAL(K_LEFT), 0);
761 return;
762 case KVAL(K_P6):
763 k_cur(vc, KVAL(K_RIGHT), 0);
764 return;
765 case KVAL(K_P7):
766 k_fn(vc, KVAL(K_FIND), 0);
767 return;
768 case KVAL(K_P8):
769 k_cur(vc, KVAL(K_UP), 0);
770 return;
771 case KVAL(K_P9):
772 k_fn(vc, KVAL(K_PGUP), 0);
773 return;
774 case KVAL(K_P5):
775 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
776 return;
777 }
778 }
779
780 put_queue(vc, pad_chars[value]);
781 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
782 put_queue(vc, 10);
783}
784
785static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
786{
787 int old_state = shift_state;
788
789 if (rep)
790 return;
791 /*
792 * Mimic typewriter:
793 * a CapsShift key acts like Shift but undoes CapsLock
794 */
795 if (value == KVAL(K_CAPSSHIFT)) {
796 value = KVAL(K_SHIFT);
797 if (!up_flag)
798 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
799 }
800
801 if (up_flag) {
802 /*
803 * handle the case that two shift or control
804 * keys are depressed simultaneously
805 */
806 if (shift_down[value])
807 shift_down[value]--;
808 } else
809 shift_down[value]++;
810
811 if (shift_down[value])
812 shift_state |= (1 << value);
813 else
814 shift_state &= ~(1 << value);
815
816 /* kludge */
817 if (up_flag && shift_state != old_state && npadch != -1) {
818 if (kbd->kbdmode == VC_UNICODE)
819 to_utf8(vc, npadch);
820 else
821 put_queue(vc, npadch & 0xff);
822 npadch = -1;
823 }
824}
825
826static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
827{
828 if (up_flag)
829 return;
830
831 if (vc_kbd_mode(kbd, VC_META)) {
832 put_queue(vc, '\033');
833 put_queue(vc, value);
834 } else
835 put_queue(vc, value | 0x80);
836}
837
838static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
839{
840 int base;
841
842 if (up_flag)
843 return;
844
845 if (value < 10) {
846 /* decimal input of code, while Alt depressed */
847 base = 10;
848 } else {
849 /* hexadecimal input of code, while AltGr depressed */
850 value -= 10;
851 base = 16;
852 }
853
854 if (npadch == -1)
855 npadch = value;
856 else
857 npadch = npadch * base + value;
858}
859
860static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
861{
862 if (up_flag || rep)
863 return;
864
865 chg_vc_kbd_lock(kbd, value);
866}
867
868static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
869{
870 k_shift(vc, value, up_flag);
871 if (up_flag || rep)
872 return;
873
874 chg_vc_kbd_slock(kbd, value);
875 /* try to make Alt, oops, AltGr and such work */
876 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
877 kbd->slockstate = 0;
878 chg_vc_kbd_slock(kbd, value);
879 }
880}
881
882/* by default, 300ms interval for combination release */
883static unsigned brl_timeout = 300;
884MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
885module_param(brl_timeout, uint, 0644);
886
887static unsigned brl_nbchords = 1;
888MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
889module_param(brl_nbchords, uint, 0644);
890
891static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
892{
893 static unsigned long chords;
894 static unsigned committed;
895
896 if (!brl_nbchords)
897 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
898 else {
899 committed |= pattern;
900 chords++;
901 if (chords == brl_nbchords) {
902 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
903 chords = 0;
904 committed = 0;
905 }
906 }
907}
908
909static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
910{
911 static unsigned pressed, committing;
912 static unsigned long releasestart;
913
914 if (kbd->kbdmode != VC_UNICODE) {
915 if (!up_flag)
916 pr_warn("keyboard mode must be unicode for braille patterns\n");
917 return;
918 }
919
920 if (!value) {
921 k_unicode(vc, BRL_UC_ROW, up_flag);
922 return;
923 }
924
925 if (value > 8)
926 return;
927
928 if (!up_flag) {
929 pressed |= 1 << (value - 1);
930 if (!brl_timeout)
931 committing = pressed;
932 } else if (brl_timeout) {
933 if (!committing ||
934 time_after(jiffies,
935 releasestart + msecs_to_jiffies(brl_timeout))) {
936 committing = pressed;
937 releasestart = jiffies;
938 }
939 pressed &= ~(1 << (value - 1));
940 if (!pressed && committing) {
941 k_brlcommit(vc, committing, 0);
942 committing = 0;
943 }
944 } else {
945 if (committing) {
946 k_brlcommit(vc, committing, 0);
947 committing = 0;
948 }
949 pressed &= ~(1 << (value - 1));
950 }
951}
952
953#if IS_ENABLED(CONFIG_INPUT_LEDS) && IS_ENABLED(CONFIG_LEDS_TRIGGERS)
954
955struct kbd_led_trigger {
956 struct led_trigger trigger;
957 unsigned int mask;
958};
959
960static void kbd_led_trigger_activate(struct led_classdev *cdev)
961{
962 struct kbd_led_trigger *trigger =
963 container_of(cdev->trigger, struct kbd_led_trigger, trigger);
964
965 tasklet_disable(&keyboard_tasklet);
966 if (ledstate != -1U)
967 led_trigger_event(&trigger->trigger,
968 ledstate & trigger->mask ?
969 LED_FULL : LED_OFF);
970 tasklet_enable(&keyboard_tasklet);
971}
972
973#define KBD_LED_TRIGGER(_led_bit, _name) { \
974 .trigger = { \
975 .name = _name, \
976 .activate = kbd_led_trigger_activate, \
977 }, \
978 .mask = BIT(_led_bit), \
979 }
980
981#define KBD_LOCKSTATE_TRIGGER(_led_bit, _name) \
982 KBD_LED_TRIGGER((_led_bit) + 8, _name)
983
984static struct kbd_led_trigger kbd_led_triggers[] = {
985 KBD_LED_TRIGGER(VC_SCROLLOCK, "kbd-scrolllock"),
986 KBD_LED_TRIGGER(VC_NUMLOCK, "kbd-numlock"),
987 KBD_LED_TRIGGER(VC_CAPSLOCK, "kbd-capslock"),
988 KBD_LED_TRIGGER(VC_KANALOCK, "kbd-kanalock"),
989
990 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLOCK, "kbd-shiftlock"),
991 KBD_LOCKSTATE_TRIGGER(VC_ALTGRLOCK, "kbd-altgrlock"),
992 KBD_LOCKSTATE_TRIGGER(VC_CTRLLOCK, "kbd-ctrllock"),
993 KBD_LOCKSTATE_TRIGGER(VC_ALTLOCK, "kbd-altlock"),
994 KBD_LOCKSTATE_TRIGGER(VC_SHIFTLLOCK, "kbd-shiftllock"),
995 KBD_LOCKSTATE_TRIGGER(VC_SHIFTRLOCK, "kbd-shiftrlock"),
996 KBD_LOCKSTATE_TRIGGER(VC_CTRLLLOCK, "kbd-ctrlllock"),
997 KBD_LOCKSTATE_TRIGGER(VC_CTRLRLOCK, "kbd-ctrlrlock"),
998};
999
1000static void kbd_propagate_led_state(unsigned int old_state,
1001 unsigned int new_state)
1002{
1003 struct kbd_led_trigger *trigger;
1004 unsigned int changed = old_state ^ new_state;
1005 int i;
1006
1007 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1008 trigger = &kbd_led_triggers[i];
1009
1010 if (changed & trigger->mask)
1011 led_trigger_event(&trigger->trigger,
1012 new_state & trigger->mask ?
1013 LED_FULL : LED_OFF);
1014 }
1015}
1016
1017static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1018{
1019 unsigned int led_state = *(unsigned int *)data;
1020
1021 if (test_bit(EV_LED, handle->dev->evbit))
1022 kbd_propagate_led_state(~led_state, led_state);
1023
1024 return 0;
1025}
1026
1027static void kbd_init_leds(void)
1028{
1029 int error;
1030 int i;
1031
1032 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1033 error = led_trigger_register(&kbd_led_triggers[i].trigger);
1034 if (error)
1035 pr_err("error %d while registering trigger %s\n",
1036 error, kbd_led_triggers[i].trigger.name);
1037 }
1038}
1039
1040#else
1041
1042static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1043{
1044 unsigned int leds = *(unsigned int *)data;
1045
1046 if (test_bit(EV_LED, handle->dev->evbit)) {
1047 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1048 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1049 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1050 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1051 }
1052
1053 return 0;
1054}
1055
1056static void kbd_propagate_led_state(unsigned int old_state,
1057 unsigned int new_state)
1058{
1059 input_handler_for_each_handle(&kbd_handler, &new_state,
1060 kbd_update_leds_helper);
1061}
1062
1063static void kbd_init_leds(void)
1064{
1065}
1066
1067#endif
1068
1069/*
1070 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
1071 * or (ii) whatever pattern of lights people want to show using KDSETLED,
1072 * or (iii) specified bits of specified words in kernel memory.
1073 */
1074static unsigned char getledstate(void)
1075{
1076 return ledstate & 0xff;
1077}
1078
1079void setledstate(struct kbd_struct *kb, unsigned int led)
1080{
1081 unsigned long flags;
1082 spin_lock_irqsave(&led_lock, flags);
1083 if (!(led & ~7)) {
1084 ledioctl = led;
1085 kb->ledmode = LED_SHOW_IOCTL;
1086 } else
1087 kb->ledmode = LED_SHOW_FLAGS;
1088
1089 set_leds();
1090 spin_unlock_irqrestore(&led_lock, flags);
1091}
1092
1093static inline unsigned char getleds(void)
1094{
1095 struct kbd_struct *kb = kbd_table + fg_console;
1096
1097 if (kb->ledmode == LED_SHOW_IOCTL)
1098 return ledioctl;
1099
1100 return kb->ledflagstate;
1101}
1102
1103/**
1104 * vt_get_leds - helper for braille console
1105 * @console: console to read
1106 * @flag: flag we want to check
1107 *
1108 * Check the status of a keyboard led flag and report it back
1109 */
1110int vt_get_leds(int console, int flag)
1111{
1112 struct kbd_struct *kb = kbd_table + console;
1113 int ret;
1114 unsigned long flags;
1115
1116 spin_lock_irqsave(&led_lock, flags);
1117 ret = vc_kbd_led(kb, flag);
1118 spin_unlock_irqrestore(&led_lock, flags);
1119
1120 return ret;
1121}
1122EXPORT_SYMBOL_GPL(vt_get_leds);
1123
1124/**
1125 * vt_set_led_state - set LED state of a console
1126 * @console: console to set
1127 * @leds: LED bits
1128 *
1129 * Set the LEDs on a console. This is a wrapper for the VT layer
1130 * so that we can keep kbd knowledge internal
1131 */
1132void vt_set_led_state(int console, int leds)
1133{
1134 struct kbd_struct *kb = kbd_table + console;
1135 setledstate(kb, leds);
1136}
1137
1138/**
1139 * vt_kbd_con_start - Keyboard side of console start
1140 * @console: console
1141 *
1142 * Handle console start. This is a wrapper for the VT layer
1143 * so that we can keep kbd knowledge internal
1144 *
1145 * FIXME: We eventually need to hold the kbd lock here to protect
1146 * the LED updating. We can't do it yet because fn_hold calls stop_tty
1147 * and start_tty under the kbd_event_lock, while normal tty paths
1148 * don't hold the lock. We probably need to split out an LED lock
1149 * but not during an -rc release!
1150 */
1151void vt_kbd_con_start(int console)
1152{
1153 struct kbd_struct *kb = kbd_table + console;
1154 unsigned long flags;
1155 spin_lock_irqsave(&led_lock, flags);
1156 clr_vc_kbd_led(kb, VC_SCROLLOCK);
1157 set_leds();
1158 spin_unlock_irqrestore(&led_lock, flags);
1159}
1160
1161/**
1162 * vt_kbd_con_stop - Keyboard side of console stop
1163 * @console: console
1164 *
1165 * Handle console stop. This is a wrapper for the VT layer
1166 * so that we can keep kbd knowledge internal
1167 */
1168void vt_kbd_con_stop(int console)
1169{
1170 struct kbd_struct *kb = kbd_table + console;
1171 unsigned long flags;
1172 spin_lock_irqsave(&led_lock, flags);
1173 set_vc_kbd_led(kb, VC_SCROLLOCK);
1174 set_leds();
1175 spin_unlock_irqrestore(&led_lock, flags);
1176}
1177
1178/*
1179 * This is the tasklet that updates LED state of LEDs using standard
1180 * keyboard triggers. The reason we use tasklet is that we need to
1181 * handle the scenario when keyboard handler is not registered yet
1182 * but we already getting updates from the VT to update led state.
1183 */
1184static void kbd_bh(unsigned long dummy)
1185{
1186 unsigned int leds;
1187 unsigned long flags;
1188
1189 spin_lock_irqsave(&led_lock, flags);
1190 leds = getleds();
1191 leds |= (unsigned int)kbd->lockstate << 8;
1192 spin_unlock_irqrestore(&led_lock, flags);
1193
1194 if (leds != ledstate) {
1195 kbd_propagate_led_state(ledstate, leds);
1196 ledstate = leds;
1197 }
1198}
1199
1200DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1201
1202#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1203 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1204 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1205 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1206 defined(CONFIG_AVR32)
1207
1208#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1209 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1210
1211static const unsigned short x86_keycodes[256] =
1212 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1213 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1214 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1215 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1216 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1217 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1218 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1219 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1220 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1221 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1222 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1223 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1224 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1225 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1226 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1227
1228#ifdef CONFIG_SPARC
1229static int sparc_l1_a_state;
1230extern void sun_do_break(void);
1231#endif
1232
1233static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1234 unsigned char up_flag)
1235{
1236 int code;
1237
1238 switch (keycode) {
1239
1240 case KEY_PAUSE:
1241 put_queue(vc, 0xe1);
1242 put_queue(vc, 0x1d | up_flag);
1243 put_queue(vc, 0x45 | up_flag);
1244 break;
1245
1246 case KEY_HANGEUL:
1247 if (!up_flag)
1248 put_queue(vc, 0xf2);
1249 break;
1250
1251 case KEY_HANJA:
1252 if (!up_flag)
1253 put_queue(vc, 0xf1);
1254 break;
1255
1256 case KEY_SYSRQ:
1257 /*
1258 * Real AT keyboards (that's what we're trying
1259 * to emulate here) emit 0xe0 0x2a 0xe0 0x37 when
1260 * pressing PrtSc/SysRq alone, but simply 0x54
1261 * when pressing Alt+PrtSc/SysRq.
1262 */
1263 if (test_bit(KEY_LEFTALT, key_down) ||
1264 test_bit(KEY_RIGHTALT, key_down)) {
1265 put_queue(vc, 0x54 | up_flag);
1266 } else {
1267 put_queue(vc, 0xe0);
1268 put_queue(vc, 0x2a | up_flag);
1269 put_queue(vc, 0xe0);
1270 put_queue(vc, 0x37 | up_flag);
1271 }
1272 break;
1273
1274 default:
1275 if (keycode > 255)
1276 return -1;
1277
1278 code = x86_keycodes[keycode];
1279 if (!code)
1280 return -1;
1281
1282 if (code & 0x100)
1283 put_queue(vc, 0xe0);
1284 put_queue(vc, (code & 0x7f) | up_flag);
1285
1286 break;
1287 }
1288
1289 return 0;
1290}
1291
1292#else
1293
1294#define HW_RAW(dev) 0
1295
1296static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1297{
1298 if (keycode > 127)
1299 return -1;
1300
1301 put_queue(vc, keycode | up_flag);
1302 return 0;
1303}
1304#endif
1305
1306static void kbd_rawcode(unsigned char data)
1307{
1308 struct vc_data *vc = vc_cons[fg_console].d;
1309
1310 kbd = kbd_table + vc->vc_num;
1311 if (kbd->kbdmode == VC_RAW)
1312 put_queue(vc, data);
1313}
1314
1315static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1316{
1317 struct vc_data *vc = vc_cons[fg_console].d;
1318 unsigned short keysym, *key_map;
1319 unsigned char type;
1320 bool raw_mode;
1321 struct tty_struct *tty;
1322 int shift_final;
1323 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1324 int rc;
1325
1326 tty = vc->port.tty;
1327
1328 if (tty && (!tty->driver_data)) {
1329 /* No driver data? Strange. Okay we fix it then. */
1330 tty->driver_data = vc;
1331 }
1332
1333 kbd = kbd_table + vc->vc_num;
1334
1335#ifdef CONFIG_SPARC
1336 if (keycode == KEY_STOP)
1337 sparc_l1_a_state = down;
1338#endif
1339
1340 rep = (down == 2);
1341
1342 raw_mode = (kbd->kbdmode == VC_RAW);
1343 if (raw_mode && !hw_raw)
1344 if (emulate_raw(vc, keycode, !down << 7))
1345 if (keycode < BTN_MISC && printk_ratelimit())
1346 pr_warn("can't emulate rawmode for keycode %d\n",
1347 keycode);
1348
1349#ifdef CONFIG_SPARC
1350 if (keycode == KEY_A && sparc_l1_a_state) {
1351 sparc_l1_a_state = false;
1352 sun_do_break();
1353 }
1354#endif
1355
1356 if (kbd->kbdmode == VC_MEDIUMRAW) {
1357 /*
1358 * This is extended medium raw mode, with keys above 127
1359 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1360 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1361 * interfere with anything else. The two bytes after 0 will
1362 * always have the up flag set not to interfere with older
1363 * applications. This allows for 16384 different keycodes,
1364 * which should be enough.
1365 */
1366 if (keycode < 128) {
1367 put_queue(vc, keycode | (!down << 7));
1368 } else {
1369 put_queue(vc, !down << 7);
1370 put_queue(vc, (keycode >> 7) | 0x80);
1371 put_queue(vc, keycode | 0x80);
1372 }
1373 raw_mode = true;
1374 }
1375
1376 if (down)
1377 set_bit(keycode, key_down);
1378 else
1379 clear_bit(keycode, key_down);
1380
1381 if (rep &&
1382 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1383 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1384 /*
1385 * Don't repeat a key if the input buffers are not empty and the
1386 * characters get aren't echoed locally. This makes key repeat
1387 * usable with slow applications and under heavy loads.
1388 */
1389 return;
1390 }
1391
1392 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1393 param.ledstate = kbd->ledflagstate;
1394 key_map = key_maps[shift_final];
1395
1396 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1397 KBD_KEYCODE, ¶m);
1398 if (rc == NOTIFY_STOP || !key_map) {
1399 atomic_notifier_call_chain(&keyboard_notifier_list,
1400 KBD_UNBOUND_KEYCODE, ¶m);
1401 do_compute_shiftstate();
1402 kbd->slockstate = 0;
1403 return;
1404 }
1405
1406 if (keycode < NR_KEYS)
1407 keysym = key_map[keycode];
1408 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1409 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1410 else
1411 return;
1412
1413 type = KTYP(keysym);
1414
1415 if (type < 0xf0) {
1416 param.value = keysym;
1417 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1418 KBD_UNICODE, ¶m);
1419 if (rc != NOTIFY_STOP)
1420 if (down && !raw_mode)
1421 to_utf8(vc, keysym);
1422 return;
1423 }
1424
1425 type -= 0xf0;
1426
1427 if (type == KT_LETTER) {
1428 type = KT_LATIN;
1429 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1430 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1431 if (key_map)
1432 keysym = key_map[keycode];
1433 }
1434 }
1435
1436 param.value = keysym;
1437 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1438 KBD_KEYSYM, ¶m);
1439 if (rc == NOTIFY_STOP)
1440 return;
1441
1442 if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1443 return;
1444
1445 (*k_handler[type])(vc, keysym & 0xff, !down);
1446
1447 param.ledstate = kbd->ledflagstate;
1448 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1449
1450 if (type != KT_SLOCK)
1451 kbd->slockstate = 0;
1452}
1453
1454static void kbd_event(struct input_handle *handle, unsigned int event_type,
1455 unsigned int event_code, int value)
1456{
1457 /* We are called with interrupts disabled, just take the lock */
1458 spin_lock(&kbd_event_lock);
1459
1460 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1461 kbd_rawcode(value);
1462 if (event_type == EV_KEY)
1463 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1464
1465 spin_unlock(&kbd_event_lock);
1466
1467 tasklet_schedule(&keyboard_tasklet);
1468 do_poke_blanked_console = 1;
1469 schedule_console_callback();
1470}
1471
1472static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1473{
1474 int i;
1475
1476 if (test_bit(EV_SND, dev->evbit))
1477 return true;
1478
1479 if (test_bit(EV_KEY, dev->evbit)) {
1480 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1481 if (test_bit(i, dev->keybit))
1482 return true;
1483 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1484 if (test_bit(i, dev->keybit))
1485 return true;
1486 }
1487
1488 return false;
1489}
1490
1491/*
1492 * When a keyboard (or other input device) is found, the kbd_connect
1493 * function is called. The function then looks at the device, and if it
1494 * likes it, it can open it and get events from it. In this (kbd_connect)
1495 * function, we should decide which VT to bind that keyboard to initially.
1496 */
1497static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1498 const struct input_device_id *id)
1499{
1500 struct input_handle *handle;
1501 int error;
1502
1503 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1504 if (!handle)
1505 return -ENOMEM;
1506
1507 handle->dev = dev;
1508 handle->handler = handler;
1509 handle->name = "kbd";
1510
1511 error = input_register_handle(handle);
1512 if (error)
1513 goto err_free_handle;
1514
1515 error = input_open_device(handle);
1516 if (error)
1517 goto err_unregister_handle;
1518
1519 return 0;
1520
1521 err_unregister_handle:
1522 input_unregister_handle(handle);
1523 err_free_handle:
1524 kfree(handle);
1525 return error;
1526}
1527
1528static void kbd_disconnect(struct input_handle *handle)
1529{
1530 input_close_device(handle);
1531 input_unregister_handle(handle);
1532 kfree(handle);
1533}
1534
1535/*
1536 * Start keyboard handler on the new keyboard by refreshing LED state to
1537 * match the rest of the system.
1538 */
1539static void kbd_start(struct input_handle *handle)
1540{
1541 tasklet_disable(&keyboard_tasklet);
1542
1543 if (ledstate != -1U)
1544 kbd_update_leds_helper(handle, &ledstate);
1545
1546 tasklet_enable(&keyboard_tasklet);
1547}
1548
1549static const struct input_device_id kbd_ids[] = {
1550 {
1551 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1552 .evbit = { BIT_MASK(EV_KEY) },
1553 },
1554
1555 {
1556 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1557 .evbit = { BIT_MASK(EV_SND) },
1558 },
1559
1560 { }, /* Terminating entry */
1561};
1562
1563MODULE_DEVICE_TABLE(input, kbd_ids);
1564
1565static struct input_handler kbd_handler = {
1566 .event = kbd_event,
1567 .match = kbd_match,
1568 .connect = kbd_connect,
1569 .disconnect = kbd_disconnect,
1570 .start = kbd_start,
1571 .name = "kbd",
1572 .id_table = kbd_ids,
1573};
1574
1575int __init kbd_init(void)
1576{
1577 int i;
1578 int error;
1579
1580 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1581 kbd_table[i].ledflagstate = kbd_defleds();
1582 kbd_table[i].default_ledflagstate = kbd_defleds();
1583 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1584 kbd_table[i].lockstate = KBD_DEFLOCK;
1585 kbd_table[i].slockstate = 0;
1586 kbd_table[i].modeflags = KBD_DEFMODE;
1587 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1588 }
1589
1590 kbd_init_leds();
1591
1592 error = input_register_handler(&kbd_handler);
1593 if (error)
1594 return error;
1595
1596 tasklet_enable(&keyboard_tasklet);
1597 tasklet_schedule(&keyboard_tasklet);
1598
1599 return 0;
1600}
1601
1602/* Ioctl support code */
1603
1604/**
1605 * vt_do_diacrit - diacritical table updates
1606 * @cmd: ioctl request
1607 * @udp: pointer to user data for ioctl
1608 * @perm: permissions check computed by caller
1609 *
1610 * Update the diacritical tables atomically and safely. Lock them
1611 * against simultaneous keypresses
1612 */
1613int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
1614{
1615 unsigned long flags;
1616 int asize;
1617 int ret = 0;
1618
1619 switch (cmd) {
1620 case KDGKBDIACR:
1621 {
1622 struct kbdiacrs __user *a = udp;
1623 struct kbdiacr *dia;
1624 int i;
1625
1626 dia = kmalloc(MAX_DIACR * sizeof(struct kbdiacr),
1627 GFP_KERNEL);
1628 if (!dia)
1629 return -ENOMEM;
1630
1631 /* Lock the diacriticals table, make a copy and then
1632 copy it after we unlock */
1633 spin_lock_irqsave(&kbd_event_lock, flags);
1634
1635 asize = accent_table_size;
1636 for (i = 0; i < asize; i++) {
1637 dia[i].diacr = conv_uni_to_8bit(
1638 accent_table[i].diacr);
1639 dia[i].base = conv_uni_to_8bit(
1640 accent_table[i].base);
1641 dia[i].result = conv_uni_to_8bit(
1642 accent_table[i].result);
1643 }
1644 spin_unlock_irqrestore(&kbd_event_lock, flags);
1645
1646 if (put_user(asize, &a->kb_cnt))
1647 ret = -EFAULT;
1648 else if (copy_to_user(a->kbdiacr, dia,
1649 asize * sizeof(struct kbdiacr)))
1650 ret = -EFAULT;
1651 kfree(dia);
1652 return ret;
1653 }
1654 case KDGKBDIACRUC:
1655 {
1656 struct kbdiacrsuc __user *a = udp;
1657 void *buf;
1658
1659 buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc),
1660 GFP_KERNEL);
1661 if (buf == NULL)
1662 return -ENOMEM;
1663
1664 /* Lock the diacriticals table, make a copy and then
1665 copy it after we unlock */
1666 spin_lock_irqsave(&kbd_event_lock, flags);
1667
1668 asize = accent_table_size;
1669 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1670
1671 spin_unlock_irqrestore(&kbd_event_lock, flags);
1672
1673 if (put_user(asize, &a->kb_cnt))
1674 ret = -EFAULT;
1675 else if (copy_to_user(a->kbdiacruc, buf,
1676 asize*sizeof(struct kbdiacruc)))
1677 ret = -EFAULT;
1678 kfree(buf);
1679 return ret;
1680 }
1681
1682 case KDSKBDIACR:
1683 {
1684 struct kbdiacrs __user *a = udp;
1685 struct kbdiacr *dia = NULL;
1686 unsigned int ct;
1687 int i;
1688
1689 if (!perm)
1690 return -EPERM;
1691 if (get_user(ct, &a->kb_cnt))
1692 return -EFAULT;
1693 if (ct >= MAX_DIACR)
1694 return -EINVAL;
1695
1696 if (ct) {
1697
1698 dia = memdup_user(a->kbdiacr,
1699 sizeof(struct kbdiacr) * ct);
1700 if (IS_ERR(dia))
1701 return PTR_ERR(dia);
1702
1703 }
1704
1705 spin_lock_irqsave(&kbd_event_lock, flags);
1706 accent_table_size = ct;
1707 for (i = 0; i < ct; i++) {
1708 accent_table[i].diacr =
1709 conv_8bit_to_uni(dia[i].diacr);
1710 accent_table[i].base =
1711 conv_8bit_to_uni(dia[i].base);
1712 accent_table[i].result =
1713 conv_8bit_to_uni(dia[i].result);
1714 }
1715 spin_unlock_irqrestore(&kbd_event_lock, flags);
1716 kfree(dia);
1717 return 0;
1718 }
1719
1720 case KDSKBDIACRUC:
1721 {
1722 struct kbdiacrsuc __user *a = udp;
1723 unsigned int ct;
1724 void *buf = NULL;
1725
1726 if (!perm)
1727 return -EPERM;
1728
1729 if (get_user(ct, &a->kb_cnt))
1730 return -EFAULT;
1731
1732 if (ct >= MAX_DIACR)
1733 return -EINVAL;
1734
1735 if (ct) {
1736 buf = memdup_user(a->kbdiacruc,
1737 ct * sizeof(struct kbdiacruc));
1738 if (IS_ERR(buf))
1739 return PTR_ERR(buf);
1740 }
1741 spin_lock_irqsave(&kbd_event_lock, flags);
1742 if (ct)
1743 memcpy(accent_table, buf,
1744 ct * sizeof(struct kbdiacruc));
1745 accent_table_size = ct;
1746 spin_unlock_irqrestore(&kbd_event_lock, flags);
1747 kfree(buf);
1748 return 0;
1749 }
1750 }
1751 return ret;
1752}
1753
1754/**
1755 * vt_do_kdskbmode - set keyboard mode ioctl
1756 * @console: the console to use
1757 * @arg: the requested mode
1758 *
1759 * Update the keyboard mode bits while holding the correct locks.
1760 * Return 0 for success or an error code.
1761 */
1762int vt_do_kdskbmode(int console, unsigned int arg)
1763{
1764 struct kbd_struct *kb = kbd_table + console;
1765 int ret = 0;
1766 unsigned long flags;
1767
1768 spin_lock_irqsave(&kbd_event_lock, flags);
1769 switch(arg) {
1770 case K_RAW:
1771 kb->kbdmode = VC_RAW;
1772 break;
1773 case K_MEDIUMRAW:
1774 kb->kbdmode = VC_MEDIUMRAW;
1775 break;
1776 case K_XLATE:
1777 kb->kbdmode = VC_XLATE;
1778 do_compute_shiftstate();
1779 break;
1780 case K_UNICODE:
1781 kb->kbdmode = VC_UNICODE;
1782 do_compute_shiftstate();
1783 break;
1784 case K_OFF:
1785 kb->kbdmode = VC_OFF;
1786 break;
1787 default:
1788 ret = -EINVAL;
1789 }
1790 spin_unlock_irqrestore(&kbd_event_lock, flags);
1791 return ret;
1792}
1793
1794/**
1795 * vt_do_kdskbmeta - set keyboard meta state
1796 * @console: the console to use
1797 * @arg: the requested meta state
1798 *
1799 * Update the keyboard meta bits while holding the correct locks.
1800 * Return 0 for success or an error code.
1801 */
1802int vt_do_kdskbmeta(int console, unsigned int arg)
1803{
1804 struct kbd_struct *kb = kbd_table + console;
1805 int ret = 0;
1806 unsigned long flags;
1807
1808 spin_lock_irqsave(&kbd_event_lock, flags);
1809 switch(arg) {
1810 case K_METABIT:
1811 clr_vc_kbd_mode(kb, VC_META);
1812 break;
1813 case K_ESCPREFIX:
1814 set_vc_kbd_mode(kb, VC_META);
1815 break;
1816 default:
1817 ret = -EINVAL;
1818 }
1819 spin_unlock_irqrestore(&kbd_event_lock, flags);
1820 return ret;
1821}
1822
1823int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1824 int perm)
1825{
1826 struct kbkeycode tmp;
1827 int kc = 0;
1828
1829 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1830 return -EFAULT;
1831 switch (cmd) {
1832 case KDGETKEYCODE:
1833 kc = getkeycode(tmp.scancode);
1834 if (kc >= 0)
1835 kc = put_user(kc, &user_kbkc->keycode);
1836 break;
1837 case KDSETKEYCODE:
1838 if (!perm)
1839 return -EPERM;
1840 kc = setkeycode(tmp.scancode, tmp.keycode);
1841 break;
1842 }
1843 return kc;
1844}
1845
1846#define i (tmp.kb_index)
1847#define s (tmp.kb_table)
1848#define v (tmp.kb_value)
1849
1850int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1851 int console)
1852{
1853 struct kbd_struct *kb = kbd_table + console;
1854 struct kbentry tmp;
1855 ushort *key_map, *new_map, val, ov;
1856 unsigned long flags;
1857
1858 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1859 return -EFAULT;
1860
1861 if (!capable(CAP_SYS_TTY_CONFIG))
1862 perm = 0;
1863
1864 switch (cmd) {
1865 case KDGKBENT:
1866 /* Ensure another thread doesn't free it under us */
1867 spin_lock_irqsave(&kbd_event_lock, flags);
1868 key_map = key_maps[s];
1869 if (key_map) {
1870 val = U(key_map[i]);
1871 if (kb->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1872 val = K_HOLE;
1873 } else
1874 val = (i ? K_HOLE : K_NOSUCHMAP);
1875 spin_unlock_irqrestore(&kbd_event_lock, flags);
1876 return put_user(val, &user_kbe->kb_value);
1877 case KDSKBENT:
1878 if (!perm)
1879 return -EPERM;
1880 if (!i && v == K_NOSUCHMAP) {
1881 spin_lock_irqsave(&kbd_event_lock, flags);
1882 /* deallocate map */
1883 key_map = key_maps[s];
1884 if (s && key_map) {
1885 key_maps[s] = NULL;
1886 if (key_map[0] == U(K_ALLOCATED)) {
1887 kfree(key_map);
1888 keymap_count--;
1889 }
1890 }
1891 spin_unlock_irqrestore(&kbd_event_lock, flags);
1892 break;
1893 }
1894
1895 if (KTYP(v) < NR_TYPES) {
1896 if (KVAL(v) > max_vals[KTYP(v)])
1897 return -EINVAL;
1898 } else
1899 if (kb->kbdmode != VC_UNICODE)
1900 return -EINVAL;
1901
1902 /* ++Geert: non-PC keyboards may generate keycode zero */
1903#if !defined(__mc68000__) && !defined(__powerpc__)
1904 /* assignment to entry 0 only tests validity of args */
1905 if (!i)
1906 break;
1907#endif
1908
1909 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1910 if (!new_map)
1911 return -ENOMEM;
1912 spin_lock_irqsave(&kbd_event_lock, flags);
1913 key_map = key_maps[s];
1914 if (key_map == NULL) {
1915 int j;
1916
1917 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1918 !capable(CAP_SYS_RESOURCE)) {
1919 spin_unlock_irqrestore(&kbd_event_lock, flags);
1920 kfree(new_map);
1921 return -EPERM;
1922 }
1923 key_maps[s] = new_map;
1924 key_map = new_map;
1925 key_map[0] = U(K_ALLOCATED);
1926 for (j = 1; j < NR_KEYS; j++)
1927 key_map[j] = U(K_HOLE);
1928 keymap_count++;
1929 } else
1930 kfree(new_map);
1931
1932 ov = U(key_map[i]);
1933 if (v == ov)
1934 goto out;
1935 /*
1936 * Attention Key.
1937 */
1938 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1939 spin_unlock_irqrestore(&kbd_event_lock, flags);
1940 return -EPERM;
1941 }
1942 key_map[i] = U(v);
1943 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1944 do_compute_shiftstate();
1945out:
1946 spin_unlock_irqrestore(&kbd_event_lock, flags);
1947 break;
1948 }
1949 return 0;
1950}
1951#undef i
1952#undef s
1953#undef v
1954
1955/* FIXME: This one needs untangling and locking */
1956int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1957{
1958 struct kbsentry *kbs;
1959 char *p;
1960 u_char *q;
1961 u_char __user *up;
1962 int sz;
1963 int delta;
1964 char *first_free, *fj, *fnw;
1965 int i, j, k;
1966 int ret;
1967
1968 if (!capable(CAP_SYS_TTY_CONFIG))
1969 perm = 0;
1970
1971 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
1972 if (!kbs) {
1973 ret = -ENOMEM;
1974 goto reterr;
1975 }
1976
1977 /* we mostly copy too much here (512bytes), but who cares ;) */
1978 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
1979 ret = -EFAULT;
1980 goto reterr;
1981 }
1982 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
1983 i = kbs->kb_func;
1984
1985 switch (cmd) {
1986 case KDGKBSENT:
1987 sz = sizeof(kbs->kb_string) - 1; /* sz should have been
1988 a struct member */
1989 up = user_kdgkb->kb_string;
1990 p = func_table[i];
1991 if(p)
1992 for ( ; *p && sz; p++, sz--)
1993 if (put_user(*p, up++)) {
1994 ret = -EFAULT;
1995 goto reterr;
1996 }
1997 if (put_user('\0', up)) {
1998 ret = -EFAULT;
1999 goto reterr;
2000 }
2001 kfree(kbs);
2002 return ((p && *p) ? -EOVERFLOW : 0);
2003 case KDSKBSENT:
2004 if (!perm) {
2005 ret = -EPERM;
2006 goto reterr;
2007 }
2008
2009 q = func_table[i];
2010 first_free = funcbufptr + (funcbufsize - funcbufleft);
2011 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
2012 ;
2013 if (j < MAX_NR_FUNC)
2014 fj = func_table[j];
2015 else
2016 fj = first_free;
2017
2018 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
2019 if (delta <= funcbufleft) { /* it fits in current buf */
2020 if (j < MAX_NR_FUNC) {
2021 memmove(fj + delta, fj, first_free - fj);
2022 for (k = j; k < MAX_NR_FUNC; k++)
2023 if (func_table[k])
2024 func_table[k] += delta;
2025 }
2026 if (!q)
2027 func_table[i] = fj;
2028 funcbufleft -= delta;
2029 } else { /* allocate a larger buffer */
2030 sz = 256;
2031 while (sz < funcbufsize - funcbufleft + delta)
2032 sz <<= 1;
2033 fnw = kmalloc(sz, GFP_KERNEL);
2034 if(!fnw) {
2035 ret = -ENOMEM;
2036 goto reterr;
2037 }
2038
2039 if (!q)
2040 func_table[i] = fj;
2041 if (fj > funcbufptr)
2042 memmove(fnw, funcbufptr, fj - funcbufptr);
2043 for (k = 0; k < j; k++)
2044 if (func_table[k])
2045 func_table[k] = fnw + (func_table[k] - funcbufptr);
2046
2047 if (first_free > fj) {
2048 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
2049 for (k = j; k < MAX_NR_FUNC; k++)
2050 if (func_table[k])
2051 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
2052 }
2053 if (funcbufptr != func_buf)
2054 kfree(funcbufptr);
2055 funcbufptr = fnw;
2056 funcbufleft = funcbufleft - delta + sz - funcbufsize;
2057 funcbufsize = sz;
2058 }
2059 strcpy(func_table[i], kbs->kb_string);
2060 break;
2061 }
2062 ret = 0;
2063reterr:
2064 kfree(kbs);
2065 return ret;
2066}
2067
2068int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2069{
2070 struct kbd_struct *kb = kbd_table + console;
2071 unsigned long flags;
2072 unsigned char ucval;
2073
2074 switch(cmd) {
2075 /* the ioctls below read/set the flags usually shown in the leds */
2076 /* don't use them - they will go away without warning */
2077 case KDGKBLED:
2078 spin_lock_irqsave(&kbd_event_lock, flags);
2079 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2080 spin_unlock_irqrestore(&kbd_event_lock, flags);
2081 return put_user(ucval, (char __user *)arg);
2082
2083 case KDSKBLED:
2084 if (!perm)
2085 return -EPERM;
2086 if (arg & ~0x77)
2087 return -EINVAL;
2088 spin_lock_irqsave(&led_lock, flags);
2089 kb->ledflagstate = (arg & 7);
2090 kb->default_ledflagstate = ((arg >> 4) & 7);
2091 set_leds();
2092 spin_unlock_irqrestore(&led_lock, flags);
2093 return 0;
2094
2095 /* the ioctls below only set the lights, not the functions */
2096 /* for those, see KDGKBLED and KDSKBLED above */
2097 case KDGETLED:
2098 ucval = getledstate();
2099 return put_user(ucval, (char __user *)arg);
2100
2101 case KDSETLED:
2102 if (!perm)
2103 return -EPERM;
2104 setledstate(kb, arg);
2105 return 0;
2106 }
2107 return -ENOIOCTLCMD;
2108}
2109
2110int vt_do_kdgkbmode(int console)
2111{
2112 struct kbd_struct *kb = kbd_table + console;
2113 /* This is a spot read so needs no locking */
2114 switch (kb->kbdmode) {
2115 case VC_RAW:
2116 return K_RAW;
2117 case VC_MEDIUMRAW:
2118 return K_MEDIUMRAW;
2119 case VC_UNICODE:
2120 return K_UNICODE;
2121 case VC_OFF:
2122 return K_OFF;
2123 default:
2124 return K_XLATE;
2125 }
2126}
2127
2128/**
2129 * vt_do_kdgkbmeta - report meta status
2130 * @console: console to report
2131 *
2132 * Report the meta flag status of this console
2133 */
2134int vt_do_kdgkbmeta(int console)
2135{
2136 struct kbd_struct *kb = kbd_table + console;
2137 /* Again a spot read so no locking */
2138 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2139}
2140
2141/**
2142 * vt_reset_unicode - reset the unicode status
2143 * @console: console being reset
2144 *
2145 * Restore the unicode console state to its default
2146 */
2147void vt_reset_unicode(int console)
2148{
2149 unsigned long flags;
2150
2151 spin_lock_irqsave(&kbd_event_lock, flags);
2152 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2153 spin_unlock_irqrestore(&kbd_event_lock, flags);
2154}
2155
2156/**
2157 * vt_get_shiftstate - shift bit state
2158 *
2159 * Report the shift bits from the keyboard state. We have to export
2160 * this to support some oddities in the vt layer.
2161 */
2162int vt_get_shift_state(void)
2163{
2164 /* Don't lock as this is a transient report */
2165 return shift_state;
2166}
2167
2168/**
2169 * vt_reset_keyboard - reset keyboard state
2170 * @console: console to reset
2171 *
2172 * Reset the keyboard bits for a console as part of a general console
2173 * reset event
2174 */
2175void vt_reset_keyboard(int console)
2176{
2177 struct kbd_struct *kb = kbd_table + console;
2178 unsigned long flags;
2179
2180 spin_lock_irqsave(&kbd_event_lock, flags);
2181 set_vc_kbd_mode(kb, VC_REPEAT);
2182 clr_vc_kbd_mode(kb, VC_CKMODE);
2183 clr_vc_kbd_mode(kb, VC_APPLIC);
2184 clr_vc_kbd_mode(kb, VC_CRLF);
2185 kb->lockstate = 0;
2186 kb->slockstate = 0;
2187 spin_lock(&led_lock);
2188 kb->ledmode = LED_SHOW_FLAGS;
2189 kb->ledflagstate = kb->default_ledflagstate;
2190 spin_unlock(&led_lock);
2191 /* do not do set_leds here because this causes an endless tasklet loop
2192 when the keyboard hasn't been initialized yet */
2193 spin_unlock_irqrestore(&kbd_event_lock, flags);
2194}
2195
2196/**
2197 * vt_get_kbd_mode_bit - read keyboard status bits
2198 * @console: console to read from
2199 * @bit: mode bit to read
2200 *
2201 * Report back a vt mode bit. We do this without locking so the
2202 * caller must be sure that there are no synchronization needs
2203 */
2204
2205int vt_get_kbd_mode_bit(int console, int bit)
2206{
2207 struct kbd_struct *kb = kbd_table + console;
2208 return vc_kbd_mode(kb, bit);
2209}
2210
2211/**
2212 * vt_set_kbd_mode_bit - read keyboard status bits
2213 * @console: console to read from
2214 * @bit: mode bit to read
2215 *
2216 * Set a vt mode bit. We do this without locking so the
2217 * caller must be sure that there are no synchronization needs
2218 */
2219
2220void vt_set_kbd_mode_bit(int console, int bit)
2221{
2222 struct kbd_struct *kb = kbd_table + console;
2223 unsigned long flags;
2224
2225 spin_lock_irqsave(&kbd_event_lock, flags);
2226 set_vc_kbd_mode(kb, bit);
2227 spin_unlock_irqrestore(&kbd_event_lock, flags);
2228}
2229
2230/**
2231 * vt_clr_kbd_mode_bit - read keyboard status bits
2232 * @console: console to read from
2233 * @bit: mode bit to read
2234 *
2235 * Report back a vt mode bit. We do this without locking so the
2236 * caller must be sure that there are no synchronization needs
2237 */
2238
2239void vt_clr_kbd_mode_bit(int console, int bit)
2240{
2241 struct kbd_struct *kb = kbd_table + console;
2242 unsigned long flags;
2243
2244 spin_lock_irqsave(&kbd_event_lock, flags);
2245 clr_vc_kbd_mode(kb, bit);
2246 spin_unlock_irqrestore(&kbd_event_lock, flags);
2247}