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