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