]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/tty/vt/keyboard.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


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