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