tty: keyboard.c: add uaccess.h to fix a build problem on sparc32
[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 void compute_shiftstate(void);
72
73 /*
74  * Handler Tables.
75  */
76
77 #define K_HANDLERS\
78         k_self,         k_fn,           k_spec,         k_pad,\
79         k_dead,         k_cons,         k_cur,          k_shift,\
80         k_meta,         k_ascii,        k_lock,         k_lowercase,\
81         k_slock,        k_dead2,        k_brl,          k_ignore
82
83 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
84                             char up_flag);
85 static k_handler_fn K_HANDLERS;
86 static k_handler_fn *k_handler[16] = { K_HANDLERS };
87
88 #define FN_HANDLERS\
89         fn_null,        fn_enter,       fn_show_ptregs, fn_show_mem,\
90         fn_show_state,  fn_send_intr,   fn_lastcons,    fn_caps_toggle,\
91         fn_num,         fn_hold,        fn_scroll_forw, fn_scroll_back,\
92         fn_boot_it,     fn_caps_on,     fn_compose,     fn_SAK,\
93         fn_dec_console, fn_inc_console, fn_spawn_con,   fn_bare_num
94
95 typedef void (fn_handler_fn)(struct vc_data *vc);
96 static fn_handler_fn FN_HANDLERS;
97 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
98
99 /*
100  * Variables exported for vt_ioctl.c
101  */
102
103 /* maximum values each key_handler can handle */
104 const int max_vals[] = {
105         255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
106         NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
107         255, NR_LOCK - 1, 255, NR_BRL - 1
108 };
109
110 const int NR_TYPES = ARRAY_SIZE(max_vals);
111
112 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
113 EXPORT_SYMBOL_GPL(kbd_table);
114 static struct kbd_struct *kbd = kbd_table;
115
116 struct vt_spawn_console vt_spawn_con = {
117         .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
118         .pid  = NULL,
119         .sig  = 0,
120 };
121
122 /*
123  * Variables exported for vt.c
124  */
125
126 int shift_state = 0;
127
128 /*
129  * Internal Data.
130  */
131
132 static struct input_handler kbd_handler;
133 static DEFINE_SPINLOCK(kbd_event_lock);
134 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)];  /* keyboard key bitmap */
135 static unsigned char shift_down[NR_SHIFT];              /* shift state counters.. */
136 static bool dead_key_next;
137 static int npadch = -1;                                 /* -1 or number assembled on pad */
138 static unsigned int diacr;
139 static char rep;                                        /* flag telling character repeat */
140
141 static unsigned char ledstate = 0xff;                   /* undefined */
142 static unsigned char ledioctl;
143
144 static struct ledptr {
145         unsigned int *addr;
146         unsigned int mask;
147         unsigned char valid:1;
148 } ledptrs[3];
149
150 /*
151  * Notifier list for console keyboard events
152  */
153 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
154
155 int register_keyboard_notifier(struct notifier_block *nb)
156 {
157         return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
158 }
159 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
160
161 int unregister_keyboard_notifier(struct notifier_block *nb)
162 {
163         return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
164 }
165 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
166
167 /*
168  * Translation of scancodes to keycodes. We set them on only the first
169  * keyboard in the list that accepts the scancode and keycode.
170  * Explanation for not choosing the first attached keyboard anymore:
171  *  USB keyboards for example have two event devices: one for all "normal"
172  *  keys and one for extra function keys (like "volume up", "make coffee",
173  *  etc.). So this means that scancodes for the extra function keys won't
174  *  be valid for the first event device, but will be for the second.
175  */
176
177 struct getset_keycode_data {
178         struct input_keymap_entry ke;
179         int error;
180 };
181
182 static int getkeycode_helper(struct input_handle *handle, void *data)
183 {
184         struct getset_keycode_data *d = data;
185
186         d->error = input_get_keycode(handle->dev, &d->ke);
187
188         return d->error == 0; /* stop as soon as we successfully get one */
189 }
190
191 int getkeycode(unsigned int scancode)
192 {
193         struct getset_keycode_data d = {
194                 .ke     = {
195                         .flags          = 0,
196                         .len            = sizeof(scancode),
197                         .keycode        = 0,
198                 },
199                 .error  = -ENODEV,
200         };
201
202         memcpy(d.ke.scancode, &scancode, sizeof(scancode));
203
204         input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
205
206         return d.error ?: d.ke.keycode;
207 }
208
209 static int setkeycode_helper(struct input_handle *handle, void *data)
210 {
211         struct getset_keycode_data *d = data;
212
213         d->error = input_set_keycode(handle->dev, &d->ke);
214
215         return d->error == 0; /* stop as soon as we successfully set one */
216 }
217
218 int setkeycode(unsigned int scancode, unsigned int keycode)
219 {
220         struct getset_keycode_data d = {
221                 .ke     = {
222                         .flags          = 0,
223                         .len            = sizeof(scancode),
224                         .keycode        = keycode,
225                 },
226                 .error  = -ENODEV,
227         };
228
229         memcpy(d.ke.scancode, &scancode, sizeof(scancode));
230
231         input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
232
233         return d.error;
234 }
235
236 /*
237  * Making beeps and bells. Note that we prefer beeps to bells, but when
238  * shutting the sound off we do both.
239  */
240
241 static int kd_sound_helper(struct input_handle *handle, void *data)
242 {
243         unsigned int *hz = data;
244         struct input_dev *dev = handle->dev;
245
246         if (test_bit(EV_SND, dev->evbit)) {
247                 if (test_bit(SND_TONE, dev->sndbit)) {
248                         input_inject_event(handle, EV_SND, SND_TONE, *hz);
249                         if (*hz)
250                                 return 0;
251                 }
252                 if (test_bit(SND_BELL, dev->sndbit))
253                         input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
254         }
255
256         return 0;
257 }
258
259 static void kd_nosound(unsigned long ignored)
260 {
261         static unsigned int zero;
262
263         input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
264 }
265
266 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
267
268 void kd_mksound(unsigned int hz, unsigned int ticks)
269 {
270         del_timer_sync(&kd_mksound_timer);
271
272         input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
273
274         if (hz && ticks)
275                 mod_timer(&kd_mksound_timer, jiffies + ticks);
276 }
277 EXPORT_SYMBOL(kd_mksound);
278
279 /*
280  * Setting the keyboard rate.
281  */
282
283 static int kbd_rate_helper(struct input_handle *handle, void *data)
284 {
285         struct input_dev *dev = handle->dev;
286         struct kbd_repeat *rep = data;
287
288         if (test_bit(EV_REP, dev->evbit)) {
289
290                 if (rep[0].delay > 0)
291                         input_inject_event(handle,
292                                            EV_REP, REP_DELAY, rep[0].delay);
293                 if (rep[0].period > 0)
294                         input_inject_event(handle,
295                                            EV_REP, REP_PERIOD, rep[0].period);
296
297                 rep[1].delay = dev->rep[REP_DELAY];
298                 rep[1].period = dev->rep[REP_PERIOD];
299         }
300
301         return 0;
302 }
303
304 int kbd_rate(struct kbd_repeat *rep)
305 {
306         struct kbd_repeat data[2] = { *rep };
307
308         input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
309         *rep = data[1]; /* Copy currently used settings */
310
311         return 0;
312 }
313
314 /*
315  * Helper Functions.
316  */
317 static void put_queue(struct vc_data *vc, int ch)
318 {
319         struct tty_struct *tty = vc->port.tty;
320
321         if (tty) {
322                 tty_insert_flip_char(tty, ch, 0);
323                 con_schedule_flip(tty);
324         }
325 }
326
327 static void puts_queue(struct vc_data *vc, char *cp)
328 {
329         struct tty_struct *tty = vc->port.tty;
330
331         if (!tty)
332                 return;
333
334         while (*cp) {
335                 tty_insert_flip_char(tty, *cp, 0);
336                 cp++;
337         }
338         con_schedule_flip(tty);
339 }
340
341 static void applkey(struct vc_data *vc, int key, char mode)
342 {
343         static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
344
345         buf[1] = (mode ? 'O' : '[');
346         buf[2] = key;
347         puts_queue(vc, buf);
348 }
349
350 /*
351  * Many other routines do put_queue, but I think either
352  * they produce ASCII, or they produce some user-assigned
353  * string, and in both cases we might assume that it is
354  * in utf-8 already.
355  */
356 static void to_utf8(struct vc_data *vc, uint c)
357 {
358         if (c < 0x80)
359                 /*  0******* */
360                 put_queue(vc, c);
361         else if (c < 0x800) {
362                 /* 110***** 10****** */
363                 put_queue(vc, 0xc0 | (c >> 6));
364                 put_queue(vc, 0x80 | (c & 0x3f));
365         } else if (c < 0x10000) {
366                 if (c >= 0xD800 && c < 0xE000)
367                         return;
368                 if (c == 0xFFFF)
369                         return;
370                 /* 1110**** 10****** 10****** */
371                 put_queue(vc, 0xe0 | (c >> 12));
372                 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
373                 put_queue(vc, 0x80 | (c & 0x3f));
374         } else if (c < 0x110000) {
375                 /* 11110*** 10****** 10****** 10****** */
376                 put_queue(vc, 0xf0 | (c >> 18));
377                 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
378                 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
379                 put_queue(vc, 0x80 | (c & 0x3f));
380         }
381 }
382
383 /*
384  * Called after returning from RAW mode or when changing consoles - recompute
385  * shift_down[] and shift_state from key_down[] maybe called when keymap is
386  * undefined, so that shiftkey release is seen
387  */
388 void compute_shiftstate(void)
389 {
390         unsigned int i, j, k, sym, val;
391
392         shift_state = 0;
393         memset(shift_down, 0, sizeof(shift_down));
394
395         for (i = 0; i < ARRAY_SIZE(key_down); i++) {
396
397                 if (!key_down[i])
398                         continue;
399
400                 k = i * BITS_PER_LONG;
401
402                 for (j = 0; j < BITS_PER_LONG; j++, k++) {
403
404                         if (!test_bit(k, key_down))
405                                 continue;
406
407                         sym = U(key_maps[0][k]);
408                         if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
409                                 continue;
410
411                         val = KVAL(sym);
412                         if (val == KVAL(K_CAPSSHIFT))
413                                 val = KVAL(K_SHIFT);
414
415                         shift_down[val]++;
416                         shift_state |= (1 << val);
417                 }
418         }
419 }
420
421 /*
422  * We have a combining character DIACR here, followed by the character CH.
423  * If the combination occurs in the table, return the corresponding value.
424  * Otherwise, if CH is a space or equals DIACR, return DIACR.
425  * Otherwise, conclude that DIACR was not combining after all,
426  * queue it and return CH.
427  */
428 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
429 {
430         unsigned int d = diacr;
431         unsigned int i;
432
433         diacr = 0;
434
435         if ((d & ~0xff) == BRL_UC_ROW) {
436                 if ((ch & ~0xff) == BRL_UC_ROW)
437                         return d | ch;
438         } else {
439                 for (i = 0; i < accent_table_size; i++)
440                         if (accent_table[i].diacr == d && accent_table[i].base == ch)
441                                 return accent_table[i].result;
442         }
443
444         if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
445                 return d;
446
447         if (kbd->kbdmode == VC_UNICODE)
448                 to_utf8(vc, d);
449         else {
450                 int c = conv_uni_to_8bit(d);
451                 if (c != -1)
452                         put_queue(vc, c);
453         }
454
455         return ch;
456 }
457
458 /*
459  * Special function handlers
460  */
461 static void fn_enter(struct vc_data *vc)
462 {
463         if (diacr) {
464                 if (kbd->kbdmode == VC_UNICODE)
465                         to_utf8(vc, diacr);
466                 else {
467                         int c = conv_uni_to_8bit(diacr);
468                         if (c != -1)
469                                 put_queue(vc, c);
470                 }
471                 diacr = 0;
472         }
473
474         put_queue(vc, 13);
475         if (vc_kbd_mode(kbd, VC_CRLF))
476                 put_queue(vc, 10);
477 }
478
479 static void fn_caps_toggle(struct vc_data *vc)
480 {
481         if (rep)
482                 return;
483
484         chg_vc_kbd_led(kbd, VC_CAPSLOCK);
485 }
486
487 static void fn_caps_on(struct vc_data *vc)
488 {
489         if (rep)
490                 return;
491
492         set_vc_kbd_led(kbd, VC_CAPSLOCK);
493 }
494
495 static void fn_show_ptregs(struct vc_data *vc)
496 {
497         struct pt_regs *regs = get_irq_regs();
498
499         if (regs)
500                 show_regs(regs);
501 }
502
503 static void fn_hold(struct vc_data *vc)
504 {
505         struct tty_struct *tty = vc->port.tty;
506
507         if (rep || !tty)
508                 return;
509
510         /*
511          * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
512          * these routines are also activated by ^S/^Q.
513          * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
514          */
515         if (tty->stopped)
516                 start_tty(tty);
517         else
518                 stop_tty(tty);
519 }
520
521 static void fn_num(struct vc_data *vc)
522 {
523         if (vc_kbd_mode(kbd, VC_APPLIC))
524                 applkey(vc, 'P', 1);
525         else
526                 fn_bare_num(vc);
527 }
528
529 /*
530  * Bind this to Shift-NumLock if you work in application keypad mode
531  * but want to be able to change the NumLock flag.
532  * Bind this to NumLock if you prefer that the NumLock key always
533  * changes the NumLock flag.
534  */
535 static void fn_bare_num(struct vc_data *vc)
536 {
537         if (!rep)
538                 chg_vc_kbd_led(kbd, VC_NUMLOCK);
539 }
540
541 static void fn_lastcons(struct vc_data *vc)
542 {
543         /* switch to the last used console, ChN */
544         set_console(last_console);
545 }
546
547 static void fn_dec_console(struct vc_data *vc)
548 {
549         int i, cur = fg_console;
550
551         /* Currently switching?  Queue this next switch relative to that. */
552         if (want_console != -1)
553                 cur = want_console;
554
555         for (i = cur - 1; i != cur; i--) {
556                 if (i == -1)
557                         i = MAX_NR_CONSOLES - 1;
558                 if (vc_cons_allocated(i))
559                         break;
560         }
561         set_console(i);
562 }
563
564 static void fn_inc_console(struct vc_data *vc)
565 {
566         int i, cur = fg_console;
567
568         /* Currently switching?  Queue this next switch relative to that. */
569         if (want_console != -1)
570                 cur = want_console;
571
572         for (i = cur+1; i != cur; i++) {
573                 if (i == MAX_NR_CONSOLES)
574                         i = 0;
575                 if (vc_cons_allocated(i))
576                         break;
577         }
578         set_console(i);
579 }
580
581 static void fn_send_intr(struct vc_data *vc)
582 {
583         struct tty_struct *tty = vc->port.tty;
584
585         if (!tty)
586                 return;
587         tty_insert_flip_char(tty, 0, TTY_BREAK);
588         con_schedule_flip(tty);
589 }
590
591 static void fn_scroll_forw(struct vc_data *vc)
592 {
593         scrollfront(vc, 0);
594 }
595
596 static void fn_scroll_back(struct vc_data *vc)
597 {
598         scrollback(vc, 0);
599 }
600
601 static void fn_show_mem(struct vc_data *vc)
602 {
603         show_mem(0);
604 }
605
606 static void fn_show_state(struct vc_data *vc)
607 {
608         show_state();
609 }
610
611 static void fn_boot_it(struct vc_data *vc)
612 {
613         ctrl_alt_del();
614 }
615
616 static void fn_compose(struct vc_data *vc)
617 {
618         dead_key_next = true;
619 }
620
621 static void fn_spawn_con(struct vc_data *vc)
622 {
623         spin_lock(&vt_spawn_con.lock);
624         if (vt_spawn_con.pid)
625                 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
626                         put_pid(vt_spawn_con.pid);
627                         vt_spawn_con.pid = NULL;
628                 }
629         spin_unlock(&vt_spawn_con.lock);
630 }
631
632 static void fn_SAK(struct vc_data *vc)
633 {
634         struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
635         schedule_work(SAK_work);
636 }
637
638 static void fn_null(struct vc_data *vc)
639 {
640         compute_shiftstate();
641 }
642
643 /*
644  * Special key handlers
645  */
646 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
647 {
648 }
649
650 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
651 {
652         if (up_flag)
653                 return;
654         if (value >= ARRAY_SIZE(fn_handler))
655                 return;
656         if ((kbd->kbdmode == VC_RAW ||
657              kbd->kbdmode == VC_MEDIUMRAW ||
658              kbd->kbdmode == VC_OFF) &&
659              value != KVAL(K_SAK))
660                 return;         /* SAK is allowed even in raw mode */
661         fn_handler[value](vc);
662 }
663
664 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
665 {
666         pr_err("k_lowercase was called - impossible\n");
667 }
668
669 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
670 {
671         if (up_flag)
672                 return;         /* no action, if this is a key release */
673
674         if (diacr)
675                 value = handle_diacr(vc, value);
676
677         if (dead_key_next) {
678                 dead_key_next = false;
679                 diacr = value;
680                 return;
681         }
682         if (kbd->kbdmode == VC_UNICODE)
683                 to_utf8(vc, value);
684         else {
685                 int c = conv_uni_to_8bit(value);
686                 if (c != -1)
687                         put_queue(vc, c);
688         }
689 }
690
691 /*
692  * Handle dead key. Note that we now may have several
693  * dead keys modifying the same character. Very useful
694  * for Vietnamese.
695  */
696 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
697 {
698         if (up_flag)
699                 return;
700
701         diacr = (diacr ? handle_diacr(vc, value) : value);
702 }
703
704 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
705 {
706         k_unicode(vc, conv_8bit_to_uni(value), up_flag);
707 }
708
709 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
710 {
711         k_deadunicode(vc, value, up_flag);
712 }
713
714 /*
715  * Obsolete - for backwards compatibility only
716  */
717 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
718 {
719         static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
720
721         k_deadunicode(vc, ret_diacr[value], up_flag);
722 }
723
724 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
725 {
726         if (up_flag)
727                 return;
728
729         set_console(value);
730 }
731
732 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
733 {
734         if (up_flag)
735                 return;
736
737         if ((unsigned)value < ARRAY_SIZE(func_table)) {
738                 if (func_table[value])
739                         puts_queue(vc, func_table[value]);
740         } else
741                 pr_err("k_fn called with value=%d\n", value);
742 }
743
744 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
745 {
746         static const char cur_chars[] = "BDCA";
747
748         if (up_flag)
749                 return;
750
751         applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
752 }
753
754 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
755 {
756         static const char pad_chars[] = "0123456789+-*/\015,.?()#";
757         static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
758
759         if (up_flag)
760                 return;         /* no action, if this is a key release */
761
762         /* kludge... shift forces cursor/number keys */
763         if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
764                 applkey(vc, app_map[value], 1);
765                 return;
766         }
767
768         if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
769
770                 switch (value) {
771                 case KVAL(K_PCOMMA):
772                 case KVAL(K_PDOT):
773                         k_fn(vc, KVAL(K_REMOVE), 0);
774                         return;
775                 case KVAL(K_P0):
776                         k_fn(vc, KVAL(K_INSERT), 0);
777                         return;
778                 case KVAL(K_P1):
779                         k_fn(vc, KVAL(K_SELECT), 0);
780                         return;
781                 case KVAL(K_P2):
782                         k_cur(vc, KVAL(K_DOWN), 0);
783                         return;
784                 case KVAL(K_P3):
785                         k_fn(vc, KVAL(K_PGDN), 0);
786                         return;
787                 case KVAL(K_P4):
788                         k_cur(vc, KVAL(K_LEFT), 0);
789                         return;
790                 case KVAL(K_P6):
791                         k_cur(vc, KVAL(K_RIGHT), 0);
792                         return;
793                 case KVAL(K_P7):
794                         k_fn(vc, KVAL(K_FIND), 0);
795                         return;
796                 case KVAL(K_P8):
797                         k_cur(vc, KVAL(K_UP), 0);
798                         return;
799                 case KVAL(K_P9):
800                         k_fn(vc, KVAL(K_PGUP), 0);
801                         return;
802                 case KVAL(K_P5):
803                         applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
804                         return;
805                 }
806         }
807
808         put_queue(vc, pad_chars[value]);
809         if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
810                 put_queue(vc, 10);
811 }
812
813 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
814 {
815         int old_state = shift_state;
816
817         if (rep)
818                 return;
819         /*
820          * Mimic typewriter:
821          * a CapsShift key acts like Shift but undoes CapsLock
822          */
823         if (value == KVAL(K_CAPSSHIFT)) {
824                 value = KVAL(K_SHIFT);
825                 if (!up_flag)
826                         clr_vc_kbd_led(kbd, VC_CAPSLOCK);
827         }
828
829         if (up_flag) {
830                 /*
831                  * handle the case that two shift or control
832                  * keys are depressed simultaneously
833                  */
834                 if (shift_down[value])
835                         shift_down[value]--;
836         } else
837                 shift_down[value]++;
838
839         if (shift_down[value])
840                 shift_state |= (1 << value);
841         else
842                 shift_state &= ~(1 << value);
843
844         /* kludge */
845         if (up_flag && shift_state != old_state && npadch != -1) {
846                 if (kbd->kbdmode == VC_UNICODE)
847                         to_utf8(vc, npadch);
848                 else
849                         put_queue(vc, npadch & 0xff);
850                 npadch = -1;
851         }
852 }
853
854 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
855 {
856         if (up_flag)
857                 return;
858
859         if (vc_kbd_mode(kbd, VC_META)) {
860                 put_queue(vc, '\033');
861                 put_queue(vc, value);
862         } else
863                 put_queue(vc, value | 0x80);
864 }
865
866 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
867 {
868         int base;
869
870         if (up_flag)
871                 return;
872
873         if (value < 10) {
874                 /* decimal input of code, while Alt depressed */
875                 base = 10;
876         } else {
877                 /* hexadecimal input of code, while AltGr depressed */
878                 value -= 10;
879                 base = 16;
880         }
881
882         if (npadch == -1)
883                 npadch = value;
884         else
885                 npadch = npadch * base + value;
886 }
887
888 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
889 {
890         if (up_flag || rep)
891                 return;
892
893         chg_vc_kbd_lock(kbd, value);
894 }
895
896 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
897 {
898         k_shift(vc, value, up_flag);
899         if (up_flag || rep)
900                 return;
901
902         chg_vc_kbd_slock(kbd, value);
903         /* try to make Alt, oops, AltGr and such work */
904         if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
905                 kbd->slockstate = 0;
906                 chg_vc_kbd_slock(kbd, value);
907         }
908 }
909
910 /* by default, 300ms interval for combination release */
911 static unsigned brl_timeout = 300;
912 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
913 module_param(brl_timeout, uint, 0644);
914
915 static unsigned brl_nbchords = 1;
916 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
917 module_param(brl_nbchords, uint, 0644);
918
919 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
920 {
921         static unsigned long chords;
922         static unsigned committed;
923
924         if (!brl_nbchords)
925                 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
926         else {
927                 committed |= pattern;
928                 chords++;
929                 if (chords == brl_nbchords) {
930                         k_unicode(vc, BRL_UC_ROW | committed, up_flag);
931                         chords = 0;
932                         committed = 0;
933                 }
934         }
935 }
936
937 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
938 {
939         static unsigned pressed, committing;
940         static unsigned long releasestart;
941
942         if (kbd->kbdmode != VC_UNICODE) {
943                 if (!up_flag)
944                         pr_warning("keyboard mode must be unicode for braille patterns\n");
945                 return;
946         }
947
948         if (!value) {
949                 k_unicode(vc, BRL_UC_ROW, up_flag);
950                 return;
951         }
952
953         if (value > 8)
954                 return;
955
956         if (!up_flag) {
957                 pressed |= 1 << (value - 1);
958                 if (!brl_timeout)
959                         committing = pressed;
960         } else if (brl_timeout) {
961                 if (!committing ||
962                     time_after(jiffies,
963                                releasestart + msecs_to_jiffies(brl_timeout))) {
964                         committing = pressed;
965                         releasestart = jiffies;
966                 }
967                 pressed &= ~(1 << (value - 1));
968                 if (!pressed && committing) {
969                         k_brlcommit(vc, committing, 0);
970                         committing = 0;
971                 }
972         } else {
973                 if (committing) {
974                         k_brlcommit(vc, committing, 0);
975                         committing = 0;
976                 }
977                 pressed &= ~(1 << (value - 1));
978         }
979 }
980
981 /*
982  * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
983  * or (ii) whatever pattern of lights people want to show using KDSETLED,
984  * or (iii) specified bits of specified words in kernel memory.
985  */
986 unsigned char getledstate(void)
987 {
988         return ledstate;
989 }
990
991 void setledstate(struct kbd_struct *kbd, unsigned int led)
992 {
993         if (!(led & ~7)) {
994                 ledioctl = led;
995                 kbd->ledmode = LED_SHOW_IOCTL;
996         } else
997                 kbd->ledmode = LED_SHOW_FLAGS;
998
999         set_leds();
1000 }
1001
1002 static inline unsigned char getleds(void)
1003 {
1004         struct kbd_struct *kbd = kbd_table + fg_console;
1005         unsigned char leds;
1006         int i;
1007
1008         if (kbd->ledmode == LED_SHOW_IOCTL)
1009                 return ledioctl;
1010
1011         leds = kbd->ledflagstate;
1012
1013         if (kbd->ledmode == LED_SHOW_MEM) {
1014                 for (i = 0; i < 3; i++)
1015                         if (ledptrs[i].valid) {
1016                                 if (*ledptrs[i].addr & ledptrs[i].mask)
1017                                         leds |= (1 << i);
1018                                 else
1019                                         leds &= ~(1 << i);
1020                         }
1021         }
1022         return leds;
1023 }
1024
1025 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1026 {
1027         unsigned char leds = *(unsigned char *)data;
1028
1029         if (test_bit(EV_LED, handle->dev->evbit)) {
1030                 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1031                 input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & 0x02));
1032                 input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1033                 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1034         }
1035
1036         return 0;
1037 }
1038
1039 /*
1040  * This is the tasklet that updates LED state on all keyboards
1041  * attached to the box. The reason we use tasklet is that we
1042  * need to handle the scenario when keyboard handler is not
1043  * registered yet but we already getting updates form VT to
1044  * update led state.
1045  */
1046 static void kbd_bh(unsigned long dummy)
1047 {
1048         unsigned char leds = getleds();
1049
1050         if (leds != ledstate) {
1051                 input_handler_for_each_handle(&kbd_handler, &leds,
1052                                               kbd_update_leds_helper);
1053                 ledstate = leds;
1054         }
1055 }
1056
1057 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1058
1059 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1060     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1061     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1062     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1063     defined(CONFIG_AVR32)
1064
1065 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1066                         ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1067
1068 static const unsigned short x86_keycodes[256] =
1069         { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1070          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1071          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1072          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1073          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1074          80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1075         284,285,309,  0,312, 91,327,328,329,331,333,335,336,337,338,339,
1076         367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1077         360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1078         103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1079         291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1080         264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1081         377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1082         308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1083         332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1084
1085 #ifdef CONFIG_SPARC
1086 static int sparc_l1_a_state;
1087 extern void sun_do_break(void);
1088 #endif
1089
1090 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1091                        unsigned char up_flag)
1092 {
1093         int code;
1094
1095         switch (keycode) {
1096
1097         case KEY_PAUSE:
1098                 put_queue(vc, 0xe1);
1099                 put_queue(vc, 0x1d | up_flag);
1100                 put_queue(vc, 0x45 | up_flag);
1101                 break;
1102
1103         case KEY_HANGEUL:
1104                 if (!up_flag)
1105                         put_queue(vc, 0xf2);
1106                 break;
1107
1108         case KEY_HANJA:
1109                 if (!up_flag)
1110                         put_queue(vc, 0xf1);
1111                 break;
1112
1113         case KEY_SYSRQ:
1114                 /*
1115                  * Real AT keyboards (that's what we're trying
1116                  * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1117                  * pressing PrtSc/SysRq alone, but simply 0x54
1118                  * when pressing Alt+PrtSc/SysRq.
1119                  */
1120                 if (test_bit(KEY_LEFTALT, key_down) ||
1121                     test_bit(KEY_RIGHTALT, key_down)) {
1122                         put_queue(vc, 0x54 | up_flag);
1123                 } else {
1124                         put_queue(vc, 0xe0);
1125                         put_queue(vc, 0x2a | up_flag);
1126                         put_queue(vc, 0xe0);
1127                         put_queue(vc, 0x37 | up_flag);
1128                 }
1129                 break;
1130
1131         default:
1132                 if (keycode > 255)
1133                         return -1;
1134
1135                 code = x86_keycodes[keycode];
1136                 if (!code)
1137                         return -1;
1138
1139                 if (code & 0x100)
1140                         put_queue(vc, 0xe0);
1141                 put_queue(vc, (code & 0x7f) | up_flag);
1142
1143                 break;
1144         }
1145
1146         return 0;
1147 }
1148
1149 #else
1150
1151 #define HW_RAW(dev)     0
1152
1153 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1154 {
1155         if (keycode > 127)
1156                 return -1;
1157
1158         put_queue(vc, keycode | up_flag);
1159         return 0;
1160 }
1161 #endif
1162
1163 static void kbd_rawcode(unsigned char data)
1164 {
1165         struct vc_data *vc = vc_cons[fg_console].d;
1166
1167         kbd = kbd_table + vc->vc_num;
1168         if (kbd->kbdmode == VC_RAW)
1169                 put_queue(vc, data);
1170 }
1171
1172 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1173 {
1174         struct vc_data *vc = vc_cons[fg_console].d;
1175         unsigned short keysym, *key_map;
1176         unsigned char type;
1177         bool raw_mode;
1178         struct tty_struct *tty;
1179         int shift_final;
1180         struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1181         int rc;
1182
1183         tty = vc->port.tty;
1184
1185         if (tty && (!tty->driver_data)) {
1186                 /* No driver data? Strange. Okay we fix it then. */
1187                 tty->driver_data = vc;
1188         }
1189
1190         kbd = kbd_table + vc->vc_num;
1191
1192 #ifdef CONFIG_SPARC
1193         if (keycode == KEY_STOP)
1194                 sparc_l1_a_state = down;
1195 #endif
1196
1197         rep = (down == 2);
1198
1199         raw_mode = (kbd->kbdmode == VC_RAW);
1200         if (raw_mode && !hw_raw)
1201                 if (emulate_raw(vc, keycode, !down << 7))
1202                         if (keycode < BTN_MISC && printk_ratelimit())
1203                                 pr_warning("can't emulate rawmode for keycode %d\n",
1204                                            keycode);
1205
1206 #ifdef CONFIG_SPARC
1207         if (keycode == KEY_A && sparc_l1_a_state) {
1208                 sparc_l1_a_state = false;
1209                 sun_do_break();
1210         }
1211 #endif
1212
1213         if (kbd->kbdmode == VC_MEDIUMRAW) {
1214                 /*
1215                  * This is extended medium raw mode, with keys above 127
1216                  * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1217                  * the 'up' flag if needed. 0 is reserved, so this shouldn't
1218                  * interfere with anything else. The two bytes after 0 will
1219                  * always have the up flag set not to interfere with older
1220                  * applications. This allows for 16384 different keycodes,
1221                  * which should be enough.
1222                  */
1223                 if (keycode < 128) {
1224                         put_queue(vc, keycode | (!down << 7));
1225                 } else {
1226                         put_queue(vc, !down << 7);
1227                         put_queue(vc, (keycode >> 7) | 0x80);
1228                         put_queue(vc, keycode | 0x80);
1229                 }
1230                 raw_mode = true;
1231         }
1232
1233         if (down)
1234                 set_bit(keycode, key_down);
1235         else
1236                 clear_bit(keycode, key_down);
1237
1238         if (rep &&
1239             (!vc_kbd_mode(kbd, VC_REPEAT) ||
1240              (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1241                 /*
1242                  * Don't repeat a key if the input buffers are not empty and the
1243                  * characters get aren't echoed locally. This makes key repeat
1244                  * usable with slow applications and under heavy loads.
1245                  */
1246                 return;
1247         }
1248
1249         param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1250         param.ledstate = kbd->ledflagstate;
1251         key_map = key_maps[shift_final];
1252
1253         rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1254                                         KBD_KEYCODE, &param);
1255         if (rc == NOTIFY_STOP || !key_map) {
1256                 atomic_notifier_call_chain(&keyboard_notifier_list,
1257                                            KBD_UNBOUND_KEYCODE, &param);
1258                 compute_shiftstate();
1259                 kbd->slockstate = 0;
1260                 return;
1261         }
1262
1263         if (keycode < NR_KEYS)
1264                 keysym = key_map[keycode];
1265         else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1266                 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1267         else
1268                 return;
1269
1270         type = KTYP(keysym);
1271
1272         if (type < 0xf0) {
1273                 param.value = keysym;
1274                 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1275                                                 KBD_UNICODE, &param);
1276                 if (rc != NOTIFY_STOP)
1277                         if (down && !raw_mode)
1278                                 to_utf8(vc, keysym);
1279                 return;
1280         }
1281
1282         type -= 0xf0;
1283
1284         if (type == KT_LETTER) {
1285                 type = KT_LATIN;
1286                 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1287                         key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1288                         if (key_map)
1289                                 keysym = key_map[keycode];
1290                 }
1291         }
1292
1293         param.value = keysym;
1294         rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1295                                         KBD_KEYSYM, &param);
1296         if (rc == NOTIFY_STOP)
1297                 return;
1298
1299         if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1300                 return;
1301
1302         (*k_handler[type])(vc, keysym & 0xff, !down);
1303
1304         param.ledstate = kbd->ledflagstate;
1305         atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1306
1307         if (type != KT_SLOCK)
1308                 kbd->slockstate = 0;
1309 }
1310
1311 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1312                       unsigned int event_code, int value)
1313 {
1314         /* We are called with interrupts disabled, just take the lock */
1315         spin_lock(&kbd_event_lock);
1316
1317         if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1318                 kbd_rawcode(value);
1319         if (event_type == EV_KEY)
1320                 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1321
1322         spin_unlock(&kbd_event_lock);
1323
1324         tasklet_schedule(&keyboard_tasklet);
1325         do_poke_blanked_console = 1;
1326         schedule_console_callback();
1327 }
1328
1329 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1330 {
1331         int i;
1332
1333         if (test_bit(EV_SND, dev->evbit))
1334                 return true;
1335
1336         if (test_bit(EV_KEY, dev->evbit)) {
1337                 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1338                         if (test_bit(i, dev->keybit))
1339                                 return true;
1340                 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1341                         if (test_bit(i, dev->keybit))
1342                                 return true;
1343         }
1344
1345         return false;
1346 }
1347
1348 /*
1349  * When a keyboard (or other input device) is found, the kbd_connect
1350  * function is called. The function then looks at the device, and if it
1351  * likes it, it can open it and get events from it. In this (kbd_connect)
1352  * function, we should decide which VT to bind that keyboard to initially.
1353  */
1354 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1355                         const struct input_device_id *id)
1356 {
1357         struct input_handle *handle;
1358         int error;
1359
1360         handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1361         if (!handle)
1362                 return -ENOMEM;
1363
1364         handle->dev = dev;
1365         handle->handler = handler;
1366         handle->name = "kbd";
1367
1368         error = input_register_handle(handle);
1369         if (error)
1370                 goto err_free_handle;
1371
1372         error = input_open_device(handle);
1373         if (error)
1374                 goto err_unregister_handle;
1375
1376         return 0;
1377
1378  err_unregister_handle:
1379         input_unregister_handle(handle);
1380  err_free_handle:
1381         kfree(handle);
1382         return error;
1383 }
1384
1385 static void kbd_disconnect(struct input_handle *handle)
1386 {
1387         input_close_device(handle);
1388         input_unregister_handle(handle);
1389         kfree(handle);
1390 }
1391
1392 /*
1393  * Start keyboard handler on the new keyboard by refreshing LED state to
1394  * match the rest of the system.
1395  */
1396 static void kbd_start(struct input_handle *handle)
1397 {
1398         tasklet_disable(&keyboard_tasklet);
1399
1400         if (ledstate != 0xff)
1401                 kbd_update_leds_helper(handle, &ledstate);
1402
1403         tasklet_enable(&keyboard_tasklet);
1404 }
1405
1406 static const struct input_device_id kbd_ids[] = {
1407         {
1408                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1409                 .evbit = { BIT_MASK(EV_KEY) },
1410         },
1411
1412         {
1413                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1414                 .evbit = { BIT_MASK(EV_SND) },
1415         },
1416
1417         { },    /* Terminating entry */
1418 };
1419
1420 MODULE_DEVICE_TABLE(input, kbd_ids);
1421
1422 static struct input_handler kbd_handler = {
1423         .event          = kbd_event,
1424         .match          = kbd_match,
1425         .connect        = kbd_connect,
1426         .disconnect     = kbd_disconnect,
1427         .start          = kbd_start,
1428         .name           = "kbd",
1429         .id_table       = kbd_ids,
1430 };
1431
1432 int __init kbd_init(void)
1433 {
1434         int i;
1435         int error;
1436
1437         for (i = 0; i < MAX_NR_CONSOLES; i++) {
1438                 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1439                 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1440                 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1441                 kbd_table[i].lockstate = KBD_DEFLOCK;
1442                 kbd_table[i].slockstate = 0;
1443                 kbd_table[i].modeflags = KBD_DEFMODE;
1444                 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1445         }
1446
1447         error = input_register_handler(&kbd_handler);
1448         if (error)
1449                 return error;
1450
1451         tasklet_enable(&keyboard_tasklet);
1452         tasklet_schedule(&keyboard_tasklet);
1453
1454         return 0;
1455 }
1456
1457 /* Ioctl support code */
1458
1459 /**
1460  *      vt_do_diacrit           -       diacritical table updates
1461  *      @cmd: ioctl request
1462  *      @up: pointer to user data for ioctl
1463  *      @perm: permissions check computed by caller
1464  *
1465  *      Update the diacritical tables atomically and safely. Lock them
1466  *      against simultaneous keypresses
1467  */
1468 int vt_do_diacrit(unsigned int cmd, void __user *up, int perm)
1469 {
1470         struct kbdiacrs __user *a = up;
1471         unsigned long flags;
1472         int asize;
1473         int ret = 0;
1474
1475         switch (cmd) {
1476         case KDGKBDIACR:
1477         {
1478                 struct kbdiacr *diacr;
1479                 int i;
1480
1481                 diacr = kmalloc(MAX_DIACR * sizeof(struct kbdiacr),
1482                                                                 GFP_KERNEL);
1483                 if (diacr == NULL)
1484                         return -ENOMEM;
1485
1486                 /* Lock the diacriticals table, make a copy and then
1487                    copy it after we unlock */
1488                 spin_lock_irqsave(&kbd_event_lock, flags);
1489
1490                 asize = accent_table_size;
1491                 for (i = 0; i < asize; i++) {
1492                         diacr[i].diacr = conv_uni_to_8bit(
1493                                                 accent_table[i].diacr);
1494                         diacr[i].base = conv_uni_to_8bit(
1495                                                 accent_table[i].base);
1496                         diacr[i].result = conv_uni_to_8bit(
1497                                                 accent_table[i].result);
1498                 }
1499                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1500
1501                 if (put_user(asize, &a->kb_cnt))
1502                         ret = -EFAULT;
1503                 else  if (copy_to_user(a->kbdiacr, diacr,
1504                                 asize * sizeof(struct kbdiacr)))
1505                         ret = -EFAULT;
1506                 kfree(diacr);
1507                 return ret;
1508         }
1509         case KDGKBDIACRUC:
1510         {
1511                 struct kbdiacrsuc __user *a = up;
1512                 void *buf;
1513
1514                 buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc),
1515                                                                 GFP_KERNEL);
1516                 if (buf == NULL)
1517                         return -ENOMEM;
1518
1519                 /* Lock the diacriticals table, make a copy and then
1520                    copy it after we unlock */
1521                 spin_lock_irqsave(&kbd_event_lock, flags);
1522
1523                 asize = accent_table_size;
1524                 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1525
1526                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1527
1528                 if (put_user(asize, &a->kb_cnt))
1529                         ret = -EFAULT;
1530                 else if (copy_to_user(a->kbdiacruc, buf,
1531                                 asize*sizeof(struct kbdiacruc)))
1532                         ret = -EFAULT;
1533                 kfree(buf);
1534                 return ret;
1535         }
1536
1537         case KDSKBDIACR:
1538         {
1539                 struct kbdiacrs __user *a = up;
1540                 struct kbdiacr *diacr = NULL;
1541                 unsigned int ct;
1542                 int i;
1543
1544                 if (!perm)
1545                         return -EPERM;
1546                 if (get_user(ct, &a->kb_cnt))
1547                         return -EFAULT;
1548                 if (ct >= MAX_DIACR)
1549                         return -EINVAL;
1550
1551                 if (ct) {
1552                         diacr = kmalloc(sizeof(struct kbdiacr) * ct,
1553                                                                 GFP_KERNEL);
1554                         if (diacr == NULL)
1555                                 return -ENOMEM;
1556
1557                         if (copy_from_user(diacr, a->kbdiacr,
1558                                         sizeof(struct kbdiacr) * ct)) {
1559                                 kfree(diacr);
1560                                 return -EFAULT;
1561                         }
1562                 }
1563
1564                 spin_lock_irqsave(&kbd_event_lock, flags);
1565                 accent_table_size = ct;
1566                 for (i = 0; i < ct; i++) {
1567                         accent_table[i].diacr =
1568                                         conv_8bit_to_uni(diacr[i].diacr);
1569                         accent_table[i].base =
1570                                         conv_8bit_to_uni(diacr[i].base);
1571                         accent_table[i].result =
1572                                         conv_8bit_to_uni(diacr[i].result);
1573                 }
1574                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1575                 kfree(diacr);
1576                 return 0;
1577         }
1578
1579         case KDSKBDIACRUC:
1580         {
1581                 struct kbdiacrsuc __user *a = up;
1582                 unsigned int ct;
1583                 void *buf = NULL;
1584
1585                 if (!perm)
1586                         return -EPERM;
1587
1588                 if (get_user(ct, &a->kb_cnt))
1589                         return -EFAULT;
1590
1591                 if (ct >= MAX_DIACR)
1592                         return -EINVAL;
1593
1594                 if (ct) {
1595                         buf = kmalloc(ct * sizeof(struct kbdiacruc),
1596                                                                 GFP_KERNEL);
1597                         if (buf == NULL)
1598                                 return -ENOMEM;
1599
1600                         if (copy_from_user(buf, a->kbdiacruc,
1601                                         ct * sizeof(struct kbdiacruc))) {
1602                                 kfree(buf);
1603                                 return -EFAULT;
1604                         }
1605                 } 
1606                 spin_lock_irqsave(&kbd_event_lock, flags);
1607                 if (ct)
1608                         memcpy(accent_table, buf,
1609                                         ct * sizeof(struct kbdiacruc));
1610                 accent_table_size = ct;
1611                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1612                 kfree(buf);
1613                 return 0;
1614         }
1615         }
1616         return ret;
1617 }