projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'linus' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[deliverable/linux.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
1710 dia = memdup_user(a->kbdiacr,
1711 sizeof(struct kbdiacr) * ct);
1712 if (IS_ERR(dia))
1713 return PTR_ERR(dia);
1714
1715 }
1716
1717 spin_lock_irqsave(&kbd_event_lock, flags);
1718 accent_table_size = ct;
1719 for (i = 0; i < ct; i++) {
1720 accent_table[i].diacr =
1721 conv_8bit_to_uni(dia[i].diacr);
1722 accent_table[i].base =
1723 conv_8bit_to_uni(dia[i].base);
1724 accent_table[i].result =
1725 conv_8bit_to_uni(dia[i].result);
1726 }
1727 spin_unlock_irqrestore(&kbd_event_lock, flags);
1728 kfree(dia);
1729 return 0;
1730 }
1731
1732 case KDSKBDIACRUC:
1733 {
1734 struct kbdiacrsuc __user *a = udp;
1735 unsigned int ct;
1736 void *buf = NULL;
1737
1738 if (!perm)
1739 return -EPERM;
1740
1741 if (get_user(ct, &a->kb_cnt))
1742 return -EFAULT;
1743
1744 if (ct >= MAX_DIACR)
1745 return -EINVAL;
1746
1747 if (ct) {
1748 buf = kmalloc(ct * sizeof(struct kbdiacruc),
1749 GFP_KERNEL);
1750 if (buf == NULL)
1751 return -ENOMEM;
1752
1753 if (copy_from_user(buf, a->kbdiacruc,
1754 ct * sizeof(struct kbdiacruc))) {
1755 kfree(buf);
1756 return -EFAULT;
1757 }
1758 }
1759 spin_lock_irqsave(&kbd_event_lock, flags);
1760 if (ct)
1761 memcpy(accent_table, buf,
1762 ct * sizeof(struct kbdiacruc));
1763 accent_table_size = ct;
1764 spin_unlock_irqrestore(&kbd_event_lock, flags);
1765 kfree(buf);
1766 return 0;
1767 }
1768 }
1769 return ret;
1770 }
1771
1772 /**
1773 * vt_do_kdskbmode - set keyboard mode ioctl
1774 * @console: the console to use
1775 * @arg: the requested mode
1776 *
1777 * Update the keyboard mode bits while holding the correct locks.
1778 * Return 0 for success or an error code.
1779 */
1780 int vt_do_kdskbmode(int console, unsigned int arg)
1781 {
1782 struct kbd_struct *kb = kbd_table + console;
1783 int ret = 0;
1784 unsigned long flags;
1785
1786 spin_lock_irqsave(&kbd_event_lock, flags);
1787 switch(arg) {
1788 case K_RAW:
1789 kb->kbdmode = VC_RAW;
1790 break;
1791 case K_MEDIUMRAW:
1792 kb->kbdmode = VC_MEDIUMRAW;
1793 break;
1794 case K_XLATE:
1795 kb->kbdmode = VC_XLATE;
1796 do_compute_shiftstate();
1797 break;
1798 case K_UNICODE:
1799 kb->kbdmode = VC_UNICODE;
1800 do_compute_shiftstate();
1801 break;
1802 case K_OFF:
1803 kb->kbdmode = VC_OFF;
1804 break;
1805 default:
1806 ret = -EINVAL;
1807 }
1808 spin_unlock_irqrestore(&kbd_event_lock, flags);
1809 return ret;
1810 }
1811
1812 /**
1813 * vt_do_kdskbmeta - set keyboard meta state
1814 * @console: the console to use
1815 * @arg: the requested meta state
1816 *
1817 * Update the keyboard meta bits while holding the correct locks.
1818 * Return 0 for success or an error code.
1819 */
1820 int vt_do_kdskbmeta(int console, unsigned int arg)
1821 {
1822 struct kbd_struct *kb = kbd_table + console;
1823 int ret = 0;
1824 unsigned long flags;
1825
1826 spin_lock_irqsave(&kbd_event_lock, flags);
1827 switch(arg) {
1828 case K_METABIT:
1829 clr_vc_kbd_mode(kb, VC_META);
1830 break;
1831 case K_ESCPREFIX:
1832 set_vc_kbd_mode(kb, VC_META);
1833 break;
1834 default:
1835 ret = -EINVAL;
1836 }
1837 spin_unlock_irqrestore(&kbd_event_lock, flags);
1838 return ret;
1839 }
1840
1841 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1842 int perm)
1843 {
1844 struct kbkeycode tmp;
1845 int kc = 0;
1846
1847 if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1848 return -EFAULT;
1849 switch (cmd) {
1850 case KDGETKEYCODE:
1851 kc = getkeycode(tmp.scancode);
1852 if (kc >= 0)
1853 kc = put_user(kc, &user_kbkc->keycode);
1854 break;
1855 case KDSETKEYCODE:
1856 if (!perm)
1857 return -EPERM;
1858 kc = setkeycode(tmp.scancode, tmp.keycode);
1859 break;
1860 }
1861 return kc;
1862 }
1863
1864 #define i (tmp.kb_index)
1865 #define s (tmp.kb_table)
1866 #define v (tmp.kb_value)
1867
1868 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1869 int console)
1870 {
1871 struct kbd_struct *kb = kbd_table + console;
1872 struct kbentry tmp;
1873 ushort *key_map, *new_map, val, ov;
1874 unsigned long flags;
1875
1876 if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1877 return -EFAULT;
1878
1879 if (!capable(CAP_SYS_TTY_CONFIG))
1880 perm = 0;
1881
1882 switch (cmd) {
1883 case KDGKBENT:
1884 /* Ensure another thread doesn't free it under us */
1885 spin_lock_irqsave(&kbd_event_lock, flags);
1886 key_map = key_maps[s];
1887 if (key_map) {
1888 val = U(key_map[i]);
1889 if (kb->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1890 val = K_HOLE;
1891 } else
1892 val = (i ? K_HOLE : K_NOSUCHMAP);
1893 spin_unlock_irqrestore(&kbd_event_lock, flags);
1894 return put_user(val, &user_kbe->kb_value);
1895 case KDSKBENT:
1896 if (!perm)
1897 return -EPERM;
1898 if (!i && v == K_NOSUCHMAP) {
1899 spin_lock_irqsave(&kbd_event_lock, flags);
1900 /* deallocate map */
1901 key_map = key_maps[s];
1902 if (s && key_map) {
1903 key_maps[s] = NULL;
1904 if (key_map[0] == U(K_ALLOCATED)) {
1905 kfree(key_map);
1906 keymap_count--;
1907 }
1908 }
1909 spin_unlock_irqrestore(&kbd_event_lock, flags);
1910 break;
1911 }
1912
1913 if (KTYP(v) < NR_TYPES) {
1914 if (KVAL(v) > max_vals[KTYP(v)])
1915 return -EINVAL;
1916 } else
1917 if (kb->kbdmode != VC_UNICODE)
1918 return -EINVAL;
1919
1920 /* ++Geert: non-PC keyboards may generate keycode zero */
1921 #if !defined(__mc68000__) && !defined(__powerpc__)
1922 /* assignment to entry 0 only tests validity of args */
1923 if (!i)
1924 break;
1925 #endif
1926
1927 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1928 if (!new_map)
1929 return -ENOMEM;
1930 spin_lock_irqsave(&kbd_event_lock, flags);
1931 key_map = key_maps[s];
1932 if (key_map == NULL) {
1933 int j;
1934
1935 if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1936 !capable(CAP_SYS_RESOURCE)) {
1937 spin_unlock_irqrestore(&kbd_event_lock, flags);
1938 kfree(new_map);
1939 return -EPERM;
1940 }
1941 key_maps[s] = new_map;
1942 key_map = new_map;
1943 key_map[0] = U(K_ALLOCATED);
1944 for (j = 1; j < NR_KEYS; j++)
1945 key_map[j] = U(K_HOLE);
1946 keymap_count++;
1947 } else
1948 kfree(new_map);
1949
1950 ov = U(key_map[i]);
1951 if (v == ov)
1952 goto out;
1953 /*
1954 * Attention Key.
1955 */
1956 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1957 spin_unlock_irqrestore(&kbd_event_lock, flags);
1958 return -EPERM;
1959 }
1960 key_map[i] = U(v);
1961 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1962 do_compute_shiftstate();
1963 out:
1964 spin_unlock_irqrestore(&kbd_event_lock, flags);
1965 break;
1966 }
1967 return 0;
1968 }
1969 #undef i
1970 #undef s
1971 #undef v
1972
1973 /* FIXME: This one needs untangling and locking */
1974 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1975 {
1976 struct kbsentry *kbs;
1977 char *p;
1978 u_char *q;
1979 u_char __user *up;
1980 int sz;
1981 int delta;
1982 char *first_free, *fj, *fnw;
1983 int i, j, k;
1984 int ret;
1985
1986 if (!capable(CAP_SYS_TTY_CONFIG))
1987 perm = 0;
1988
1989 kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
1990 if (!kbs) {
1991 ret = -ENOMEM;
1992 goto reterr;
1993 }
1994
1995 /* we mostly copy too much here (512bytes), but who cares ;) */
1996 if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
1997 ret = -EFAULT;
1998 goto reterr;
1999 }
2000 kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
2001 i = kbs->kb_func;
2002
2003 switch (cmd) {
2004 case KDGKBSENT:
2005 sz = sizeof(kbs->kb_string) - 1; /* sz should have been
2006 a struct member */
2007 up = user_kdgkb->kb_string;
2008 p = func_table[i];
2009 if(p)
2010 for ( ; *p && sz; p++, sz--)
2011 if (put_user(*p, up++)) {
2012 ret = -EFAULT;
2013 goto reterr;
2014 }
2015 if (put_user('\0', up)) {
2016 ret = -EFAULT;
2017 goto reterr;
2018 }
2019 kfree(kbs);
2020 return ((p && *p) ? -EOVERFLOW : 0);
2021 case KDSKBSENT:
2022 if (!perm) {
2023 ret = -EPERM;
2024 goto reterr;
2025 }
2026
2027 q = func_table[i];
2028 first_free = funcbufptr + (funcbufsize - funcbufleft);
2029 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
2030 ;
2031 if (j < MAX_NR_FUNC)
2032 fj = func_table[j];
2033 else
2034 fj = first_free;
2035
2036 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
2037 if (delta <= funcbufleft) { /* it fits in current buf */
2038 if (j < MAX_NR_FUNC) {
2039 memmove(fj + delta, fj, first_free - fj);
2040 for (k = j; k < MAX_NR_FUNC; k++)
2041 if (func_table[k])
2042 func_table[k] += delta;
2043 }
2044 if (!q)
2045 func_table[i] = fj;
2046 funcbufleft -= delta;
2047 } else { /* allocate a larger buffer */
2048 sz = 256;
2049 while (sz < funcbufsize - funcbufleft + delta)
2050 sz <<= 1;
2051 fnw = kmalloc(sz, GFP_KERNEL);
2052 if(!fnw) {
2053 ret = -ENOMEM;
2054 goto reterr;
2055 }
2056
2057 if (!q)
2058 func_table[i] = fj;
2059 if (fj > funcbufptr)
2060 memmove(fnw, funcbufptr, fj - funcbufptr);
2061 for (k = 0; k < j; k++)
2062 if (func_table[k])
2063 func_table[k] = fnw + (func_table[k] - funcbufptr);
2064
2065 if (first_free > fj) {
2066 memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
2067 for (k = j; k < MAX_NR_FUNC; k++)
2068 if (func_table[k])
2069 func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
2070 }
2071 if (funcbufptr != func_buf)
2072 kfree(funcbufptr);
2073 funcbufptr = fnw;
2074 funcbufleft = funcbufleft - delta + sz - funcbufsize;
2075 funcbufsize = sz;
2076 }
2077 strcpy(func_table[i], kbs->kb_string);
2078 break;
2079 }
2080 ret = 0;
2081 reterr:
2082 kfree(kbs);
2083 return ret;
2084 }
2085
2086 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2087 {
2088 struct kbd_struct *kb = kbd_table + console;
2089 unsigned long flags;
2090 unsigned char ucval;
2091
2092 switch(cmd) {
2093 /* the ioctls below read/set the flags usually shown in the leds */
2094 /* don't use them - they will go away without warning */
2095 case KDGKBLED:
2096 spin_lock_irqsave(&kbd_event_lock, flags);
2097 ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2098 spin_unlock_irqrestore(&kbd_event_lock, flags);
2099 return put_user(ucval, (char __user *)arg);
2100
2101 case KDSKBLED:
2102 if (!perm)
2103 return -EPERM;
2104 if (arg & ~0x77)
2105 return -EINVAL;
2106 spin_lock_irqsave(&led_lock, flags);
2107 kb->ledflagstate = (arg & 7);
2108 kb->default_ledflagstate = ((arg >> 4) & 7);
2109 set_leds();
2110 spin_unlock_irqrestore(&led_lock, flags);
2111 return 0;
2112
2113 /* the ioctls below only set the lights, not the functions */
2114 /* for those, see KDGKBLED and KDSKBLED above */
2115 case KDGETLED:
2116 ucval = getledstate();
2117 return put_user(ucval, (char __user *)arg);
2118
2119 case KDSETLED:
2120 if (!perm)
2121 return -EPERM;
2122 setledstate(kb, arg);
2123 return 0;
2124 }
2125 return -ENOIOCTLCMD;
2126 }
2127
2128 int vt_do_kdgkbmode(int console)
2129 {
2130 struct kbd_struct *kb = kbd_table + console;
2131 /* This is a spot read so needs no locking */
2132 switch (kb->kbdmode) {
2133 case VC_RAW:
2134 return K_RAW;
2135 case VC_MEDIUMRAW:
2136 return K_MEDIUMRAW;
2137 case VC_UNICODE:
2138 return K_UNICODE;
2139 case VC_OFF:
2140 return K_OFF;
2141 default:
2142 return K_XLATE;
2143 }
2144 }
2145
2146 /**
2147 * vt_do_kdgkbmeta - report meta status
2148 * @console: console to report
2149 *
2150 * Report the meta flag status of this console
2151 */
2152 int vt_do_kdgkbmeta(int console)
2153 {
2154 struct kbd_struct *kb = kbd_table + console;
2155 /* Again a spot read so no locking */
2156 return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2157 }
2158
2159 /**
2160 * vt_reset_unicode - reset the unicode status
2161 * @console: console being reset
2162 *
2163 * Restore the unicode console state to its default
2164 */
2165 void vt_reset_unicode(int console)
2166 {
2167 unsigned long flags;
2168
2169 spin_lock_irqsave(&kbd_event_lock, flags);
2170 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2171 spin_unlock_irqrestore(&kbd_event_lock, flags);
2172 }
2173
2174 /**
2175 * vt_get_shiftstate - shift bit state
2176 *
2177 * Report the shift bits from the keyboard state. We have to export
2178 * this to support some oddities in the vt layer.
2179 */
2180 int vt_get_shift_state(void)
2181 {
2182 /* Don't lock as this is a transient report */
2183 return shift_state;
2184 }
2185
2186 /**
2187 * vt_reset_keyboard - reset keyboard state
2188 * @console: console to reset
2189 *
2190 * Reset the keyboard bits for a console as part of a general console
2191 * reset event
2192 */
2193 void vt_reset_keyboard(int console)
2194 {
2195 struct kbd_struct *kb = kbd_table + console;
2196 unsigned long flags;
2197
2198 spin_lock_irqsave(&kbd_event_lock, flags);
2199 set_vc_kbd_mode(kb, VC_REPEAT);
2200 clr_vc_kbd_mode(kb, VC_CKMODE);
2201 clr_vc_kbd_mode(kb, VC_APPLIC);
2202 clr_vc_kbd_mode(kb, VC_CRLF);
2203 kb->lockstate = 0;
2204 kb->slockstate = 0;
2205 spin_lock(&led_lock);
2206 kb->ledmode = LED_SHOW_FLAGS;
2207 kb->ledflagstate = kb->default_ledflagstate;
2208 spin_unlock(&led_lock);
2209 /* do not do set_leds here because this causes an endless tasklet loop
2210 when the keyboard hasn't been initialized yet */
2211 spin_unlock_irqrestore(&kbd_event_lock, flags);
2212 }
2213
2214 /**
2215 * vt_get_kbd_mode_bit - read keyboard status bits
2216 * @console: console to read from
2217 * @bit: mode bit to read
2218 *
2219 * Report back a vt mode bit. We do this without locking so the
2220 * caller must be sure that there are no synchronization needs
2221 */
2222
2223 int vt_get_kbd_mode_bit(int console, int bit)
2224 {
2225 struct kbd_struct *kb = kbd_table + console;
2226 return vc_kbd_mode(kb, bit);
2227 }
2228
2229 /**
2230 * vt_set_kbd_mode_bit - read keyboard status bits
2231 * @console: console to read from
2232 * @bit: mode bit to read
2233 *
2234 * Set a vt mode bit. We do this without locking so the
2235 * caller must be sure that there are no synchronization needs
2236 */
2237
2238 void vt_set_kbd_mode_bit(int console, int bit)
2239 {
2240 struct kbd_struct *kb = kbd_table + console;
2241 unsigned long flags;
2242
2243 spin_lock_irqsave(&kbd_event_lock, flags);
2244 set_vc_kbd_mode(kb, bit);
2245 spin_unlock_irqrestore(&kbd_event_lock, flags);
2246 }
2247
2248 /**
2249 * vt_clr_kbd_mode_bit - read keyboard status bits
2250 * @console: console to read from
2251 * @bit: mode bit to read
2252 *
2253 * Report back a vt mode bit. We do this without locking so the
2254 * caller must be sure that there are no synchronization needs
2255 */
2256
2257 void vt_clr_kbd_mode_bit(int console, int bit)
2258 {
2259 struct kbd_struct *kb = kbd_table + console;
2260 unsigned long flags;
2261
2262 spin_lock_irqsave(&kbd_event_lock, flags);
2263 clr_vc_kbd_mode(kb, bit);
2264 spin_unlock_irqrestore(&kbd_event_lock, flags);
2265 }
Linux kernel - Deliverables
This page took 0.08084 seconds and 5 git commands to generate.