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