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