Version:  2.0.40 2.2.26 2.4.37 3.9 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

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

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