Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

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

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