Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us