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