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