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