projects/linux·blob master · refs

2291 lines · 53.1 KiB

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