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