tty/vt/keyboard.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Written for linux by Johan Myreen as a translation from
0004  * the assembly version by Linus (with diacriticals added)
0005  *
0006  * Some additional features added by Christoph Niemann (ChN), March 1993
0007  *
0008  * Loadable keymaps by Risto Kankkunen, May 1993
0009  *
0010  * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
0011  * Added decr/incr_console, dynamic keymaps, Unicode support,
0012  * dynamic function/string keys, led setting,  Sept 1994
0013  * `Sticky' modifier keys, 951006.
0014  *
0015  * 11-11-96: SAK should now work in the raw mode (Martin Mares)
0016  *
0017  * Modified to provide 'generic' keyboard support by Hamish Macdonald
0018  * Merge with the m68k keyboard driver and split-off of the PC low-level
0019  * parts by Geert Uytterhoeven, May 1997
0020  *
0021  * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
0022  * 30-07-98: Dead keys redone, aeb@cwi.nl.
0023  * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
0024  */
0025
0026 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0027
0028 #include <linux/consolemap.h>
0029 #include <linux/init.h>
0030 #include <linux/input.h>
0031 #include <linux/jiffies.h>
0032 #include <linux/kbd_diacr.h>
0033 #include <linux/kbd_kern.h>
0034 #include <linux/leds.h>
0035 #include <linux/mm.h>
0036 #include <linux/module.h>
0037 #include <linux/nospec.h>
0038 #include <linux/notifier.h>
0039 #include <linux/reboot.h>
0040 #include <linux/sched/debug.h>
0041 #include <linux/sched/signal.h>
0042 #include <linux/slab.h>
0043 #include <linux/spinlock.h>
0044 #include <linux/string.h>
0045 #include <linux/tty_flip.h>
0046 #include <linux/tty.h>
0047 #include <linux/uaccess.h>
0048 #include <linux/vt_kern.h>
0049
0050 #include <asm/irq_regs.h>
0051
0052 /*
0053  * Exported functions/variables
0054  */
0055
0056 #define KBD_DEFMODE (BIT(VC_REPEAT) | BIT(VC_META))
0057
0058 #if defined(CONFIG_X86) || defined(CONFIG_PARISC)
0059 #include <asm/kbdleds.h>
0060 #else
0061 static inline int kbd_defleds(void)
0062 {
0063     return 0;
0064 }
0065 #endif
0066
0067 #define KBD_DEFLOCK 0
0068
0069 /*
0070  * Handler Tables.
0071  */
0072
0073 #define K_HANDLERS\
0074     k_self,     k_fn,       k_spec,     k_pad,\
0075     k_dead,     k_cons,     k_cur,      k_shift,\
0076     k_meta,     k_ascii,    k_lock,     k_lowercase,\
0077     k_slock,    k_dead2,    k_brl,      k_ignore
0078
0079 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
0080                 char up_flag);
0081 static k_handler_fn K_HANDLERS;
0082 static k_handler_fn *k_handler[16] = { K_HANDLERS };
0083
0084 #define FN_HANDLERS\
0085     fn_null,    fn_enter,   fn_show_ptregs, fn_show_mem,\
0086     fn_show_state,  fn_send_intr,   fn_lastcons,    fn_caps_toggle,\
0087     fn_num,     fn_hold,    fn_scroll_forw, fn_scroll_back,\
0088     fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
0089     fn_dec_console, fn_inc_console, fn_spawn_con,   fn_bare_num
0090
0091 typedef void (fn_handler_fn)(struct vc_data *vc);
0092 static fn_handler_fn FN_HANDLERS;
0093 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
0094
0095 /*
0096  * Variables exported for vt_ioctl.c
0097  */
0098
0099 struct vt_spawn_console vt_spawn_con = {
0100     .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
0101     .pid  = NULL,
0102     .sig  = 0,
0103 };
0104
0105
0106 /*
0107  * Internal Data.
0108  */
0109
0110 static struct kbd_struct kbd_table[MAX_NR_CONSOLES];
0111 static struct kbd_struct *kbd = kbd_table;
0112
0113 /* maximum values each key_handler can handle */
0114 static const unsigned char max_vals[] = {
0115     [ KT_LATIN  ] = 255,
0116     [ KT_FN     ] = ARRAY_SIZE(func_table) - 1,
0117     [ KT_SPEC   ] = ARRAY_SIZE(fn_handler) - 1,
0118     [ KT_PAD    ] = NR_PAD - 1,
0119     [ KT_DEAD   ] = NR_DEAD - 1,
0120     [ KT_CONS   ] = 255,
0121     [ KT_CUR    ] = 3,
0122     [ KT_SHIFT  ] = NR_SHIFT - 1,
0123     [ KT_META   ] = 255,
0124     [ KT_ASCII  ] = NR_ASCII - 1,
0125     [ KT_LOCK   ] = NR_LOCK - 1,
0126     [ KT_LETTER ] = 255,
0127     [ KT_SLOCK  ] = NR_LOCK - 1,
0128     [ KT_DEAD2  ] = 255,
0129     [ KT_BRL    ] = NR_BRL - 1,
0130 };
0131
0132 static const int NR_TYPES = ARRAY_SIZE(max_vals);
0133
0134 static void kbd_bh(struct tasklet_struct *unused);
0135 static DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh);
0136
0137 static struct input_handler kbd_handler;
0138 static DEFINE_SPINLOCK(kbd_event_lock);
0139 static DEFINE_SPINLOCK(led_lock);
0140 static DEFINE_SPINLOCK(func_buf_lock); /* guard 'func_buf'  and friends */
0141 static DECLARE_BITMAP(key_down, KEY_CNT);   /* keyboard key bitmap */
0142 static unsigned char shift_down[NR_SHIFT];      /* shift state counters.. */
0143 static bool dead_key_next;
0144
0145 /* Handles a number being assembled on the number pad */
0146 static bool npadch_active;
0147 static unsigned int npadch_value;
0148
0149 static unsigned int diacr;
0150 static bool rep;            /* flag telling character repeat */
0151
0152 static int shift_state = 0;
0153
0154 static unsigned int ledstate = -1U;         /* undefined */
0155 static unsigned char ledioctl;
0156 static bool vt_switch;
0157
0158 /*
0159  * Notifier list for console keyboard events
0160  */
0161 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
0162
0163 int register_keyboard_notifier(struct notifier_block *nb)
0164 {
0165     return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
0166 }
0167 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
0168
0169 int unregister_keyboard_notifier(struct notifier_block *nb)
0170 {
0171     return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
0172 }
0173 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
0174
0175 /*
0176  * Translation of scancodes to keycodes. We set them on only the first
0177  * keyboard in the list that accepts the scancode and keycode.
0178  * Explanation for not choosing the first attached keyboard anymore:
0179  *  USB keyboards for example have two event devices: one for all "normal"
0180  *  keys and one for extra function keys (like "volume up", "make coffee",
0181  *  etc.). So this means that scancodes for the extra function keys won't
0182  *  be valid for the first event device, but will be for the second.
0183  */
0184
0185 struct getset_keycode_data {
0186     struct input_keymap_entry ke;
0187     int error;
0188 };
0189
0190 static int getkeycode_helper(struct input_handle *handle, void *data)
0191 {
0192     struct getset_keycode_data *d = data;
0193
0194     d->error = input_get_keycode(handle->dev, &d->ke);
0195
0196     return d->error == 0; /* stop as soon as we successfully get one */
0197 }
0198
0199 static int getkeycode(unsigned int scancode)
0200 {
0201     struct getset_keycode_data d = {
0202         .ke = {
0203             .flags      = 0,
0204             .len        = sizeof(scancode),
0205             .keycode    = 0,
0206         },
0207         .error  = -ENODEV,
0208     };
0209
0210     memcpy(d.ke.scancode, &scancode, sizeof(scancode));
0211
0212     input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
0213
0214     return d.error ?: d.ke.keycode;
0215 }
0216
0217 static int setkeycode_helper(struct input_handle *handle, void *data)
0218 {
0219     struct getset_keycode_data *d = data;
0220
0221     d->error = input_set_keycode(handle->dev, &d->ke);
0222
0223     return d->error == 0; /* stop as soon as we successfully set one */
0224 }
0225
0226 static int setkeycode(unsigned int scancode, unsigned int keycode)
0227 {
0228     struct getset_keycode_data d = {
0229         .ke = {
0230             .flags      = 0,
0231             .len        = sizeof(scancode),
0232             .keycode    = keycode,
0233         },
0234         .error  = -ENODEV,
0235     };
0236
0237     memcpy(d.ke.scancode, &scancode, sizeof(scancode));
0238
0239     input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
0240
0241     return d.error;
0242 }
0243
0244 /*
0245  * Making beeps and bells. Note that we prefer beeps to bells, but when
0246  * shutting the sound off we do both.
0247  */
0248
0249 static int kd_sound_helper(struct input_handle *handle, void *data)
0250 {
0251     unsigned int *hz = data;
0252     struct input_dev *dev = handle->dev;
0253
0254     if (test_bit(EV_SND, dev->evbit)) {
0255         if (test_bit(SND_TONE, dev->sndbit)) {
0256             input_inject_event(handle, EV_SND, SND_TONE, *hz);
0257             if (*hz)
0258                 return 0;
0259         }
0260         if (test_bit(SND_BELL, dev->sndbit))
0261             input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
0262     }
0263
0264     return 0;
0265 }
0266
0267 static void kd_nosound(struct timer_list *unused)
0268 {
0269     static unsigned int zero;
0270
0271     input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
0272 }
0273
0274 static DEFINE_TIMER(kd_mksound_timer, kd_nosound);
0275
0276 void kd_mksound(unsigned int hz, unsigned int ticks)
0277 {
0278     del_timer_sync(&kd_mksound_timer);
0279
0280     input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
0281
0282     if (hz && ticks)
0283         mod_timer(&kd_mksound_timer, jiffies + ticks);
0284 }
0285 EXPORT_SYMBOL(kd_mksound);
0286
0287 /*
0288  * Setting the keyboard rate.
0289  */
0290
0291 static int kbd_rate_helper(struct input_handle *handle, void *data)
0292 {
0293     struct input_dev *dev = handle->dev;
0294     struct kbd_repeat *rpt = data;
0295
0296     if (test_bit(EV_REP, dev->evbit)) {
0297
0298         if (rpt[0].delay > 0)
0299             input_inject_event(handle,
0300                        EV_REP, REP_DELAY, rpt[0].delay);
0301         if (rpt[0].period > 0)
0302             input_inject_event(handle,
0303                        EV_REP, REP_PERIOD, rpt[0].period);
0304
0305         rpt[1].delay = dev->rep[REP_DELAY];
0306         rpt[1].period = dev->rep[REP_PERIOD];
0307     }
0308
0309     return 0;
0310 }
0311
0312 int kbd_rate(struct kbd_repeat *rpt)
0313 {
0314     struct kbd_repeat data[2] = { *rpt };
0315
0316     input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
0317     *rpt = data[1]; /* Copy currently used settings */
0318
0319     return 0;
0320 }
0321
0322 /*
0323  * Helper Functions.
0324  */
0325 static void put_queue(struct vc_data *vc, int ch)
0326 {
0327     tty_insert_flip_char(&vc->port, ch, 0);
0328     tty_flip_buffer_push(&vc->port);
0329 }
0330
0331 static void puts_queue(struct vc_data *vc, const char *cp)
0332 {
0333     tty_insert_flip_string(&vc->port, cp, strlen(cp));
0334     tty_flip_buffer_push(&vc->port);
0335 }
0336
0337 static void applkey(struct vc_data *vc, int key, char mode)
0338 {
0339     static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
0340
0341     buf[1] = (mode ? 'O' : '[');
0342     buf[2] = key;
0343     puts_queue(vc, buf);
0344 }
0345
0346 /*
0347  * Many other routines do put_queue, but I think either
0348  * they produce ASCII, or they produce some user-assigned
0349  * string, and in both cases we might assume that it is
0350  * in utf-8 already.
0351  */
0352 static void to_utf8(struct vc_data *vc, uint c)
0353 {
0354     if (c < 0x80)
0355         /*  0******* */
0356         put_queue(vc, c);
0357     else if (c < 0x800) {
0358         /* 110***** 10****** */
0359         put_queue(vc, 0xc0 | (c >> 6));
0360         put_queue(vc, 0x80 | (c & 0x3f));
0361     } else if (c < 0x10000) {
0362         if (c >= 0xD800 && c < 0xE000)
0363             return;
0364         if (c == 0xFFFF)
0365             return;
0366         /* 1110**** 10****** 10****** */
0367         put_queue(vc, 0xe0 | (c >> 12));
0368         put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
0369         put_queue(vc, 0x80 | (c & 0x3f));
0370     } else if (c < 0x110000) {
0371         /* 11110*** 10****** 10****** 10****** */
0372         put_queue(vc, 0xf0 | (c >> 18));
0373         put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
0374         put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
0375         put_queue(vc, 0x80 | (c & 0x3f));
0376     }
0377 }
0378
0379 /* FIXME: review locking for vt.c callers */
0380 static void set_leds(void)
0381 {
0382     tasklet_schedule(&keyboard_tasklet);
0383 }
0384
0385 /*
0386  * Called after returning from RAW mode or when changing consoles - recompute
0387  * shift_down[] and shift_state from key_down[] maybe called when keymap is
0388  * undefined, so that shiftkey release is seen. The caller must hold the
0389  * kbd_event_lock.
0390  */
0391
0392 static void do_compute_shiftstate(void)
0393 {
0394     unsigned int k, sym, val;
0395
0396     shift_state = 0;
0397     memset(shift_down, 0, sizeof(shift_down));
0398
0399     for_each_set_bit(k, key_down, min(NR_KEYS, KEY_CNT)) {
0400         sym = U(key_maps[0][k]);
0401         if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
0402             continue;
0403
0404         val = KVAL(sym);
0405         if (val == KVAL(K_CAPSSHIFT))
0406             val = KVAL(K_SHIFT);
0407
0408         shift_down[val]++;
0409         shift_state |= BIT(val);
0410     }
0411 }
0412
0413 /* We still have to export this method to vt.c */
0414 void vt_set_leds_compute_shiftstate(void)
0415 {
0416     unsigned long flags;
0417
0418     /*
0419      * When VT is switched, the keyboard led needs to be set once.
0420      * Ensure that after the switch is completed, the state of the
0421      * keyboard LED is consistent with the state of the keyboard lock.
0422      */
0423     vt_switch = true;
0424     set_leds();
0425
0426     spin_lock_irqsave(&kbd_event_lock, flags);
0427     do_compute_shiftstate();
0428     spin_unlock_irqrestore(&kbd_event_lock, flags);
0429 }
0430
0431 /*
0432  * We have a combining character DIACR here, followed by the character CH.
0433  * If the combination occurs in the table, return the corresponding value.
0434  * Otherwise, if CH is a space or equals DIACR, return DIACR.
0435  * Otherwise, conclude that DIACR was not combining after all,
0436  * queue it and return CH.
0437  */
0438 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
0439 {
0440     unsigned int d = diacr;
0441     unsigned int i;
0442
0443     diacr = 0;
0444
0445     if ((d & ~0xff) == BRL_UC_ROW) {
0446         if ((ch & ~0xff) == BRL_UC_ROW)
0447             return d | ch;
0448     } else {
0449         for (i = 0; i < accent_table_size; i++)
0450             if (accent_table[i].diacr == d && accent_table[i].base == ch)
0451                 return accent_table[i].result;
0452     }
0453
0454     if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
0455         return d;
0456
0457     if (kbd->kbdmode == VC_UNICODE)
0458         to_utf8(vc, d);
0459     else {
0460         int c = conv_uni_to_8bit(d);
0461         if (c != -1)
0462             put_queue(vc, c);
0463     }
0464
0465     return ch;
0466 }
0467
0468 /*
0469  * Special function handlers
0470  */
0471 static void fn_enter(struct vc_data *vc)
0472 {
0473     if (diacr) {
0474         if (kbd->kbdmode == VC_UNICODE)
0475             to_utf8(vc, diacr);
0476         else {
0477             int c = conv_uni_to_8bit(diacr);
0478             if (c != -1)
0479                 put_queue(vc, c);
0480         }
0481         diacr = 0;
0482     }
0483
0484     put_queue(vc, '\r');
0485     if (vc_kbd_mode(kbd, VC_CRLF))
0486         put_queue(vc, '\n');
0487 }
0488
0489 static void fn_caps_toggle(struct vc_data *vc)
0490 {
0491     if (rep)
0492         return;
0493
0494     chg_vc_kbd_led(kbd, VC_CAPSLOCK);
0495 }
0496
0497 static void fn_caps_on(struct vc_data *vc)
0498 {
0499     if (rep)
0500         return;
0501
0502     set_vc_kbd_led(kbd, VC_CAPSLOCK);
0503 }
0504
0505 static void fn_show_ptregs(struct vc_data *vc)
0506 {
0507     struct pt_regs *regs = get_irq_regs();
0508
0509     if (regs)
0510         show_regs(regs);
0511 }
0512
0513 static void fn_hold(struct vc_data *vc)
0514 {
0515     struct tty_struct *tty = vc->port.tty;
0516
0517     if (rep || !tty)
0518         return;
0519
0520     /*
0521      * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
0522      * these routines are also activated by ^S/^Q.
0523      * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
0524      */
0525     if (tty->flow.stopped)
0526         start_tty(tty);
0527     else
0528         stop_tty(tty);
0529 }
0530
0531 static void fn_num(struct vc_data *vc)
0532 {
0533     if (vc_kbd_mode(kbd, VC_APPLIC))
0534         applkey(vc, 'P', 1);
0535     else
0536         fn_bare_num(vc);
0537 }
0538
0539 /*
0540  * Bind this to Shift-NumLock if you work in application keypad mode
0541  * but want to be able to change the NumLock flag.
0542  * Bind this to NumLock if you prefer that the NumLock key always
0543  * changes the NumLock flag.
0544  */
0545 static void fn_bare_num(struct vc_data *vc)
0546 {
0547     if (!rep)
0548         chg_vc_kbd_led(kbd, VC_NUMLOCK);
0549 }
0550
0551 static void fn_lastcons(struct vc_data *vc)
0552 {
0553     /* switch to the last used console, ChN */
0554     set_console(last_console);
0555 }
0556
0557 static void fn_dec_console(struct vc_data *vc)
0558 {
0559     int i, cur = fg_console;
0560
0561     /* Currently switching?  Queue this next switch relative to that. */
0562     if (want_console != -1)
0563         cur = want_console;
0564
0565     for (i = cur - 1; i != cur; i--) {
0566         if (i == -1)
0567             i = MAX_NR_CONSOLES - 1;
0568         if (vc_cons_allocated(i))
0569             break;
0570     }
0571     set_console(i);
0572 }
0573
0574 static void fn_inc_console(struct vc_data *vc)
0575 {
0576     int i, cur = fg_console;
0577
0578     /* Currently switching?  Queue this next switch relative to that. */
0579     if (want_console != -1)
0580         cur = want_console;
0581
0582     for (i = cur+1; i != cur; i++) {
0583         if (i == MAX_NR_CONSOLES)
0584             i = 0;
0585         if (vc_cons_allocated(i))
0586             break;
0587     }
0588     set_console(i);
0589 }
0590
0591 static void fn_send_intr(struct vc_data *vc)
0592 {
0593     tty_insert_flip_char(&vc->port, 0, TTY_BREAK);
0594     tty_flip_buffer_push(&vc->port);
0595 }
0596
0597 static void fn_scroll_forw(struct vc_data *vc)
0598 {
0599     scrollfront(vc, 0);
0600 }
0601
0602 static void fn_scroll_back(struct vc_data *vc)
0603 {
0604     scrollback(vc);
0605 }
0606
0607 static void fn_show_mem(struct vc_data *vc)
0608 {
0609     show_mem(0, NULL);
0610 }
0611
0612 static void fn_show_state(struct vc_data *vc)
0613 {
0614     show_state();
0615 }
0616
0617 static void fn_boot_it(struct vc_data *vc)
0618 {
0619     ctrl_alt_del();
0620 }
0621
0622 static void fn_compose(struct vc_data *vc)
0623 {
0624     dead_key_next = true;
0625 }
0626
0627 static void fn_spawn_con(struct vc_data *vc)
0628 {
0629     spin_lock(&vt_spawn_con.lock);
0630     if (vt_spawn_con.pid)
0631         if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
0632             put_pid(vt_spawn_con.pid);
0633             vt_spawn_con.pid = NULL;
0634         }
0635     spin_unlock(&vt_spawn_con.lock);
0636 }
0637
0638 static void fn_SAK(struct vc_data *vc)
0639 {
0640     struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
0641     schedule_work(SAK_work);
0642 }
0643
0644 static void fn_null(struct vc_data *vc)
0645 {
0646     do_compute_shiftstate();
0647 }
0648
0649 /*
0650  * Special key handlers
0651  */
0652 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
0653 {
0654 }
0655
0656 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
0657 {
0658     if (up_flag)
0659         return;
0660     if (value >= ARRAY_SIZE(fn_handler))
0661         return;
0662     if ((kbd->kbdmode == VC_RAW ||
0663          kbd->kbdmode == VC_MEDIUMRAW ||
0664          kbd->kbdmode == VC_OFF) &&
0665          value != KVAL(K_SAK))
0666         return;     /* SAK is allowed even in raw mode */
0667     fn_handler[value](vc);
0668 }
0669
0670 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
0671 {
0672     pr_err("k_lowercase was called - impossible\n");
0673 }
0674
0675 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
0676 {
0677     if (up_flag)
0678         return;     /* no action, if this is a key release */
0679
0680     if (diacr)
0681         value = handle_diacr(vc, value);
0682
0683     if (dead_key_next) {
0684         dead_key_next = false;
0685         diacr = value;
0686         return;
0687     }
0688     if (kbd->kbdmode == VC_UNICODE)
0689         to_utf8(vc, value);
0690     else {
0691         int c = conv_uni_to_8bit(value);
0692         if (c != -1)
0693             put_queue(vc, c);
0694     }
0695 }
0696
0697 /*
0698  * Handle dead key. Note that we now may have several
0699  * dead keys modifying the same character. Very useful
0700  * for Vietnamese.
0701  */
0702 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
0703 {
0704     if (up_flag)
0705         return;
0706
0707     diacr = (diacr ? handle_diacr(vc, value) : value);
0708 }
0709
0710 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
0711 {
0712     k_unicode(vc, conv_8bit_to_uni(value), up_flag);
0713 }
0714
0715 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
0716 {
0717     k_deadunicode(vc, value, up_flag);
0718 }
0719
0720 /*
0721  * Obsolete - for backwards compatibility only
0722  */
0723 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
0724 {
0725     static const unsigned char ret_diacr[NR_DEAD] = {
0726         '`',    /* dead_grave */
0727         '\'',   /* dead_acute */
0728         '^',    /* dead_circumflex */
0729         '~',    /* dead_tilda */
0730         '"',    /* dead_diaeresis */
0731         ',',    /* dead_cedilla */
0732         '_',    /* dead_macron */
0733         'U',    /* dead_breve */
0734         '.',    /* dead_abovedot */
0735         '*',    /* dead_abovering */
0736         '=',    /* dead_doubleacute */
0737         'c',    /* dead_caron */
0738         'k',    /* dead_ogonek */
0739         'i',    /* dead_iota */
0740         '#',    /* dead_voiced_sound */
0741         'o',    /* dead_semivoiced_sound */
0742         '!',    /* dead_belowdot */
0743         '?',    /* dead_hook */
0744         '+',    /* dead_horn */
0745         '-',    /* dead_stroke */
0746         ')',    /* dead_abovecomma */
0747         '(',    /* dead_abovereversedcomma */
0748         ':',    /* dead_doublegrave */
0749         'n',    /* dead_invertedbreve */
0750         ';',    /* dead_belowcomma */
0751         '$',    /* dead_currency */
0752         '@',    /* dead_greek */
0753     };
0754
0755     k_deadunicode(vc, ret_diacr[value], up_flag);
0756 }
0757
0758 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
0759 {
0760     if (up_flag)
0761         return;
0762
0763     set_console(value);
0764 }
0765
0766 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
0767 {
0768     if (up_flag)
0769         return;
0770
0771     if ((unsigned)value < ARRAY_SIZE(func_table)) {
0772         unsigned long flags;
0773
0774         spin_lock_irqsave(&func_buf_lock, flags);
0775         if (func_table[value])
0776             puts_queue(vc, func_table[value]);
0777         spin_unlock_irqrestore(&func_buf_lock, flags);
0778
0779     } else
0780         pr_err("k_fn called with value=%d\n", value);
0781 }
0782
0783 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
0784 {
0785     static const char cur_chars[] = "BDCA";
0786
0787     if (up_flag)
0788         return;
0789
0790     applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
0791 }
0792
0793 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
0794 {
0795     static const char pad_chars[] = "0123456789+-*/\015,.?()#";
0796     static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
0797
0798     if (up_flag)
0799         return;     /* no action, if this is a key release */
0800
0801     /* kludge... shift forces cursor/number keys */
0802     if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
0803         applkey(vc, app_map[value], 1);
0804         return;
0805     }
0806
0807     if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
0808
0809         switch (value) {
0810         case KVAL(K_PCOMMA):
0811         case KVAL(K_PDOT):
0812             k_fn(vc, KVAL(K_REMOVE), 0);
0813             return;
0814         case KVAL(K_P0):
0815             k_fn(vc, KVAL(K_INSERT), 0);
0816             return;
0817         case KVAL(K_P1):
0818             k_fn(vc, KVAL(K_SELECT), 0);
0819             return;
0820         case KVAL(K_P2):
0821             k_cur(vc, KVAL(K_DOWN), 0);
0822             return;
0823         case KVAL(K_P3):
0824             k_fn(vc, KVAL(K_PGDN), 0);
0825             return;
0826         case KVAL(K_P4):
0827             k_cur(vc, KVAL(K_LEFT), 0);
0828             return;
0829         case KVAL(K_P6):
0830             k_cur(vc, KVAL(K_RIGHT), 0);
0831             return;
0832         case KVAL(K_P7):
0833             k_fn(vc, KVAL(K_FIND), 0);
0834             return;
0835         case KVAL(K_P8):
0836             k_cur(vc, KVAL(K_UP), 0);
0837             return;
0838         case KVAL(K_P9):
0839             k_fn(vc, KVAL(K_PGUP), 0);
0840             return;
0841         case KVAL(K_P5):
0842             applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
0843             return;
0844         }
0845     }
0846
0847     put_queue(vc, pad_chars[value]);
0848     if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
0849         put_queue(vc, '\n');
0850 }
0851
0852 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
0853 {
0854     int old_state = shift_state;
0855
0856     if (rep)
0857         return;
0858     /*
0859      * Mimic typewriter:
0860      * a CapsShift key acts like Shift but undoes CapsLock
0861      */
0862     if (value == KVAL(K_CAPSSHIFT)) {
0863         value = KVAL(K_SHIFT);
0864         if (!up_flag)
0865             clr_vc_kbd_led(kbd, VC_CAPSLOCK);
0866     }
0867
0868     if (up_flag) {
0869         /*
0870          * handle the case that two shift or control
0871          * keys are depressed simultaneously
0872          */
0873         if (shift_down[value])
0874             shift_down[value]--;
0875     } else
0876         shift_down[value]++;
0877
0878     if (shift_down[value])
0879         shift_state |= BIT(value);
0880     else
0881         shift_state &= ~BIT(value);
0882
0883     /* kludge */
0884     if (up_flag && shift_state != old_state && npadch_active) {
0885         if (kbd->kbdmode == VC_UNICODE)
0886             to_utf8(vc, npadch_value);
0887         else
0888             put_queue(vc, npadch_value & 0xff);
0889         npadch_active = false;
0890     }
0891 }
0892
0893 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
0894 {
0895     if (up_flag)
0896         return;
0897
0898     if (vc_kbd_mode(kbd, VC_META)) {
0899         put_queue(vc, '\033');
0900         put_queue(vc, value);
0901     } else
0902         put_queue(vc, value | BIT(7));
0903 }
0904
0905 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
0906 {
0907     unsigned int base;
0908
0909     if (up_flag)
0910         return;
0911
0912     if (value < 10) {
0913         /* decimal input of code, while Alt depressed */
0914         base = 10;
0915     } else {
0916         /* hexadecimal input of code, while AltGr depressed */
0917         value -= 10;
0918         base = 16;
0919     }
0920
0921     if (!npadch_active) {
0922         npadch_value = 0;
0923         npadch_active = true;
0924     }
0925
0926     npadch_value = npadch_value * base + value;
0927 }
0928
0929 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
0930 {
0931     if (up_flag || rep)
0932         return;
0933
0934     chg_vc_kbd_lock(kbd, value);
0935 }
0936
0937 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
0938 {
0939     k_shift(vc, value, up_flag);
0940     if (up_flag || rep)
0941         return;
0942
0943     chg_vc_kbd_slock(kbd, value);
0944     /* try to make Alt, oops, AltGr and such work */
0945     if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
0946         kbd->slockstate = 0;
0947         chg_vc_kbd_slock(kbd, value);
0948     }
0949 }
0950
0951 /* by default, 300ms interval for combination release */
0952 static unsigned brl_timeout = 300;
0953 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
0954 module_param(brl_timeout, uint, 0644);
0955
0956 static unsigned brl_nbchords = 1;
0957 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
0958 module_param(brl_nbchords, uint, 0644);
0959
0960 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
0961 {
0962     static unsigned long chords;
0963     static unsigned committed;
0964
0965     if (!brl_nbchords)
0966         k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
0967     else {
0968         committed |= pattern;
0969         chords++;
0970         if (chords == brl_nbchords) {
0971             k_unicode(vc, BRL_UC_ROW | committed, up_flag);
0972             chords = 0;
0973             committed = 0;
0974         }
0975     }
0976 }
0977
0978 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
0979 {
0980     static unsigned pressed, committing;
0981     static unsigned long releasestart;
0982
0983     if (kbd->kbdmode != VC_UNICODE) {
0984         if (!up_flag)
0985             pr_warn("keyboard mode must be unicode for braille patterns\n");
0986         return;
0987     }
0988
0989     if (!value) {
0990         k_unicode(vc, BRL_UC_ROW, up_flag);
0991         return;
0992     }
0993
0994     if (value > 8)
0995         return;
0996
0997     if (!up_flag) {
0998         pressed |= BIT(value - 1);
0999         if (!brl_timeout)
1000             committing = pressed;
1001     } else if (brl_timeout) {
1002         if (!committing ||
1003             time_after(jiffies,
1004                    releasestart + msecs_to_jiffies(brl_timeout))) {
1005             committing = pressed;
1006             releasestart = jiffies;
1007         }
1008         pressed &= ~BIT(value - 1);
1009         if (!pressed && committing) {
1010             k_brlcommit(vc, committing, 0);
1011             committing = 0;
1012         }
1013     } else {
1014         if (committing) {
1015             k_brlcommit(vc, committing, 0);
1016             committing = 0;
1017         }
1018         pressed &= ~BIT(value - 1);
1019     }
1020 }
1021
1022 #if IS_ENABLED(CONFIG_INPUT_LEDS) && IS_ENABLED(CONFIG_LEDS_TRIGGERS)
1023
1024 struct kbd_led_trigger {
1025     struct led_trigger trigger;
1026     unsigned int mask;
1027 };
1028
1029 static int kbd_led_trigger_activate(struct led_classdev *cdev)
1030 {
1031     struct kbd_led_trigger *trigger =
1032         container_of(cdev->trigger, struct kbd_led_trigger, trigger);
1033
1034     tasklet_disable(&keyboard_tasklet);
1035     if (ledstate != -1U)
1036         led_trigger_event(&trigger->trigger,
1037                   ledstate & trigger->mask ?
1038                     LED_FULL : LED_OFF);
1039     tasklet_enable(&keyboard_tasklet);
1040
1041     return 0;
1042 }
1043
1044 #define KBD_LED_TRIGGER(_led_bit, _name) {          \
1045         .trigger = {                    \
1046             .name = _name,              \
1047             .activate = kbd_led_trigger_activate,   \
1048         },                      \
1049         .mask   = BIT(_led_bit),            \
1050     }
1051
1052 #define KBD_LOCKSTATE_TRIGGER(_led_bit, _name)      \
1053     KBD_LED_TRIGGER((_led_bit) + 8, _name)
1054
1055 static struct kbd_led_trigger kbd_led_triggers[] = {
1056     KBD_LED_TRIGGER(VC_SCROLLOCK, "kbd-scrolllock"),
1057     KBD_LED_TRIGGER(VC_NUMLOCK,   "kbd-numlock"),
1058     KBD_LED_TRIGGER(VC_CAPSLOCK,  "kbd-capslock"),
1059     KBD_LED_TRIGGER(VC_KANALOCK,  "kbd-kanalock"),
1060
1061     KBD_LOCKSTATE_TRIGGER(VC_SHIFTLOCK,  "kbd-shiftlock"),
1062     KBD_LOCKSTATE_TRIGGER(VC_ALTGRLOCK,  "kbd-altgrlock"),
1063     KBD_LOCKSTATE_TRIGGER(VC_CTRLLOCK,   "kbd-ctrllock"),
1064     KBD_LOCKSTATE_TRIGGER(VC_ALTLOCK,    "kbd-altlock"),
1065     KBD_LOCKSTATE_TRIGGER(VC_SHIFTLLOCK, "kbd-shiftllock"),
1066     KBD_LOCKSTATE_TRIGGER(VC_SHIFTRLOCK, "kbd-shiftrlock"),
1067     KBD_LOCKSTATE_TRIGGER(VC_CTRLLLOCK,  "kbd-ctrlllock"),
1068     KBD_LOCKSTATE_TRIGGER(VC_CTRLRLOCK,  "kbd-ctrlrlock"),
1069 };
1070
1071 static void kbd_propagate_led_state(unsigned int old_state,
1072                     unsigned int new_state)
1073 {
1074     struct kbd_led_trigger *trigger;
1075     unsigned int changed = old_state ^ new_state;
1076     int i;
1077
1078     for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1079         trigger = &kbd_led_triggers[i];
1080
1081         if (changed & trigger->mask)
1082             led_trigger_event(&trigger->trigger,
1083                       new_state & trigger->mask ?
1084                         LED_FULL : LED_OFF);
1085     }
1086 }
1087
1088 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1089 {
1090     unsigned int led_state = *(unsigned int *)data;
1091
1092     if (test_bit(EV_LED, handle->dev->evbit))
1093         kbd_propagate_led_state(~led_state, led_state);
1094
1095     return 0;
1096 }
1097
1098 static void kbd_init_leds(void)
1099 {
1100     int error;
1101     int i;
1102
1103     for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); i++) {
1104         error = led_trigger_register(&kbd_led_triggers[i].trigger);
1105         if (error)
1106             pr_err("error %d while registering trigger %s\n",
1107                    error, kbd_led_triggers[i].trigger.name);
1108     }
1109 }
1110
1111 #else
1112
1113 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1114 {
1115     unsigned int leds = *(unsigned int *)data;
1116
1117     if (test_bit(EV_LED, handle->dev->evbit)) {
1118         input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & BIT(0)));
1119         input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & BIT(1)));
1120         input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & BIT(2)));
1121         input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1122     }
1123
1124     return 0;
1125 }
1126
1127 static void kbd_propagate_led_state(unsigned int old_state,
1128                     unsigned int new_state)
1129 {
1130     input_handler_for_each_handle(&kbd_handler, &new_state,
1131                       kbd_update_leds_helper);
1132 }
1133
1134 static void kbd_init_leds(void)
1135 {
1136 }
1137
1138 #endif
1139
1140 /*
1141  * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
1142  * or (ii) whatever pattern of lights people want to show using KDSETLED,
1143  * or (iii) specified bits of specified words in kernel memory.
1144  */
1145 static unsigned char getledstate(void)
1146 {
1147     return ledstate & 0xff;
1148 }
1149
1150 void setledstate(struct kbd_struct *kb, unsigned int led)
1151 {
1152         unsigned long flags;
1153         spin_lock_irqsave(&led_lock, flags);
1154     if (!(led & ~7)) {
1155         ledioctl = led;
1156         kb->ledmode = LED_SHOW_IOCTL;
1157     } else
1158         kb->ledmode = LED_SHOW_FLAGS;
1159
1160     set_leds();
1161     spin_unlock_irqrestore(&led_lock, flags);
1162 }
1163
1164 static inline unsigned char getleds(void)
1165 {
1166     struct kbd_struct *kb = kbd_table + fg_console;
1167
1168     if (kb->ledmode == LED_SHOW_IOCTL)
1169         return ledioctl;
1170
1171     return kb->ledflagstate;
1172 }
1173
1174 /**
1175  *  vt_get_leds -   helper for braille console
1176  *  @console: console to read
1177  *  @flag: flag we want to check
1178  *
1179  *  Check the status of a keyboard led flag and report it back
1180  */
1181 int vt_get_leds(unsigned int console, int flag)
1182 {
1183     struct kbd_struct *kb = &kbd_table[console];
1184     int ret;
1185     unsigned long flags;
1186
1187     spin_lock_irqsave(&led_lock, flags);
1188     ret = vc_kbd_led(kb, flag);
1189     spin_unlock_irqrestore(&led_lock, flags);
1190
1191     return ret;
1192 }
1193 EXPORT_SYMBOL_GPL(vt_get_leds);
1194
1195 /**
1196  *  vt_set_led_state    -   set LED state of a console
1197  *  @console: console to set
1198  *  @leds: LED bits
1199  *
1200  *  Set the LEDs on a console. This is a wrapper for the VT layer
1201  *  so that we can keep kbd knowledge internal
1202  */
1203 void vt_set_led_state(unsigned int console, int leds)
1204 {
1205     struct kbd_struct *kb = &kbd_table[console];
1206     setledstate(kb, leds);
1207 }
1208
1209 /**
1210  *  vt_kbd_con_start    -   Keyboard side of console start
1211  *  @console: console
1212  *
1213  *  Handle console start. This is a wrapper for the VT layer
1214  *  so that we can keep kbd knowledge internal
1215  *
1216  *  FIXME: We eventually need to hold the kbd lock here to protect
1217  *  the LED updating. We can't do it yet because fn_hold calls stop_tty
1218  *  and start_tty under the kbd_event_lock, while normal tty paths
1219  *  don't hold the lock. We probably need to split out an LED lock
1220  *  but not during an -rc release!
1221  */
1222 void vt_kbd_con_start(unsigned int console)
1223 {
1224     struct kbd_struct *kb = &kbd_table[console];
1225     unsigned long flags;
1226     spin_lock_irqsave(&led_lock, flags);
1227     clr_vc_kbd_led(kb, VC_SCROLLOCK);
1228     set_leds();
1229     spin_unlock_irqrestore(&led_lock, flags);
1230 }
1231
1232 /**
1233  *  vt_kbd_con_stop     -   Keyboard side of console stop
1234  *  @console: console
1235  *
1236  *  Handle console stop. This is a wrapper for the VT layer
1237  *  so that we can keep kbd knowledge internal
1238  */
1239 void vt_kbd_con_stop(unsigned int console)
1240 {
1241     struct kbd_struct *kb = &kbd_table[console];
1242     unsigned long flags;
1243     spin_lock_irqsave(&led_lock, flags);
1244     set_vc_kbd_led(kb, VC_SCROLLOCK);
1245     set_leds();
1246     spin_unlock_irqrestore(&led_lock, flags);
1247 }
1248
1249 /*
1250  * This is the tasklet that updates LED state of LEDs using standard
1251  * keyboard triggers. The reason we use tasklet is that we need to
1252  * handle the scenario when keyboard handler is not registered yet
1253  * but we already getting updates from the VT to update led state.
1254  */
1255 static void kbd_bh(struct tasklet_struct *unused)
1256 {
1257     unsigned int leds;
1258     unsigned long flags;
1259
1260     spin_lock_irqsave(&led_lock, flags);
1261     leds = getleds();
1262     leds |= (unsigned int)kbd->lockstate << 8;
1263     spin_unlock_irqrestore(&led_lock, flags);
1264
1265     if (vt_switch) {
1266         ledstate = ~leds;
1267         vt_switch = false;
1268     }
1269
1270     if (leds != ledstate) {
1271         kbd_propagate_led_state(ledstate, leds);
1272         ledstate = leds;
1273     }
1274 }
1275
1276 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1277     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1278     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1279     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1280
1281 static inline bool kbd_is_hw_raw(const struct input_dev *dev)
1282 {
1283     if (!test_bit(EV_MSC, dev->evbit) || !test_bit(MSC_RAW, dev->mscbit))
1284         return false;
1285
1286     return dev->id.bustype == BUS_I8042 &&
1287         dev->id.vendor == 0x0001 && dev->id.product == 0x0001;
1288 }
1289
1290 static const unsigned short x86_keycodes[256] =
1291     { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1292      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1293      32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1294      48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1295      64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1296      80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1297     284,285,309,  0,312, 91,327,328,329,331,333,335,336,337,338,339,
1298     367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1299     360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1300     103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1301     291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1302     264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1303     377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1304     308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1305     332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1306
1307 #ifdef CONFIG_SPARC
1308 static int sparc_l1_a_state;
1309 extern void sun_do_break(void);
1310 #endif
1311
1312 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1313                unsigned char up_flag)
1314 {
1315     int code;
1316
1317     switch (keycode) {
1318
1319     case KEY_PAUSE:
1320         put_queue(vc, 0xe1);
1321         put_queue(vc, 0x1d | up_flag);
1322         put_queue(vc, 0x45 | up_flag);
1323         break;
1324
1325     case KEY_HANGEUL:
1326         if (!up_flag)
1327             put_queue(vc, 0xf2);
1328         break;
1329
1330     case KEY_HANJA:
1331         if (!up_flag)
1332             put_queue(vc, 0xf1);
1333         break;
1334
1335     case KEY_SYSRQ:
1336         /*
1337          * Real AT keyboards (that's what we're trying
1338          * to emulate here) emit 0xe0 0x2a 0xe0 0x37 when
1339          * pressing PrtSc/SysRq alone, but simply 0x54
1340          * when pressing Alt+PrtSc/SysRq.
1341          */
1342         if (test_bit(KEY_LEFTALT, key_down) ||
1343             test_bit(KEY_RIGHTALT, key_down)) {
1344             put_queue(vc, 0x54 | up_flag);
1345         } else {
1346             put_queue(vc, 0xe0);
1347             put_queue(vc, 0x2a | up_flag);
1348             put_queue(vc, 0xe0);
1349             put_queue(vc, 0x37 | up_flag);
1350         }
1351         break;
1352
1353     default:
1354         if (keycode > 255)
1355             return -1;
1356
1357         code = x86_keycodes[keycode];
1358         if (!code)
1359             return -1;
1360
1361         if (code & 0x100)
1362             put_queue(vc, 0xe0);
1363         put_queue(vc, (code & 0x7f) | up_flag);
1364
1365         break;
1366     }
1367
1368     return 0;
1369 }
1370
1371 #else
1372
1373 static inline bool kbd_is_hw_raw(const struct input_dev *dev)
1374 {
1375     return false;
1376 }
1377
1378 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1379 {
1380     if (keycode > 127)
1381         return -1;
1382
1383     put_queue(vc, keycode | up_flag);
1384     return 0;
1385 }
1386 #endif
1387
1388 static void kbd_rawcode(unsigned char data)
1389 {
1390     struct vc_data *vc = vc_cons[fg_console].d;
1391
1392     kbd = &kbd_table[vc->vc_num];
1393     if (kbd->kbdmode == VC_RAW)
1394         put_queue(vc, data);
1395 }
1396
1397 static void kbd_keycode(unsigned int keycode, int down, bool hw_raw)
1398 {
1399     struct vc_data *vc = vc_cons[fg_console].d;
1400     unsigned short keysym, *key_map;
1401     unsigned char type;
1402     bool raw_mode;
1403     struct tty_struct *tty;
1404     int shift_final;
1405     struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1406     int rc;
1407
1408     tty = vc->port.tty;
1409
1410     if (tty && (!tty->driver_data)) {
1411         /* No driver data? Strange. Okay we fix it then. */
1412         tty->driver_data = vc;
1413     }
1414
1415     kbd = &kbd_table[vc->vc_num];
1416
1417 #ifdef CONFIG_SPARC
1418     if (keycode == KEY_STOP)
1419         sparc_l1_a_state = down;
1420 #endif
1421
1422     rep = (down == 2);
1423
1424     raw_mode = (kbd->kbdmode == VC_RAW);
1425     if (raw_mode && !hw_raw)
1426         if (emulate_raw(vc, keycode, !down << 7))
1427             if (keycode < BTN_MISC && printk_ratelimit())
1428                 pr_warn("can't emulate rawmode for keycode %d\n",
1429                     keycode);
1430
1431 #ifdef CONFIG_SPARC
1432     if (keycode == KEY_A && sparc_l1_a_state) {
1433         sparc_l1_a_state = false;
1434         sun_do_break();
1435     }
1436 #endif
1437
1438     if (kbd->kbdmode == VC_MEDIUMRAW) {
1439         /*
1440          * This is extended medium raw mode, with keys above 127
1441          * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1442          * the 'up' flag if needed. 0 is reserved, so this shouldn't
1443          * interfere with anything else. The two bytes after 0 will
1444          * always have the up flag set not to interfere with older
1445          * applications. This allows for 16384 different keycodes,
1446          * which should be enough.
1447          */
1448         if (keycode < 128) {
1449             put_queue(vc, keycode | (!down << 7));
1450         } else {
1451             put_queue(vc, !down << 7);
1452             put_queue(vc, (keycode >> 7) | BIT(7));
1453             put_queue(vc, keycode | BIT(7));
1454         }
1455         raw_mode = true;
1456     }
1457
1458     assign_bit(keycode, key_down, down);
1459
1460     if (rep &&
1461         (!vc_kbd_mode(kbd, VC_REPEAT) ||
1462          (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1463         /*
1464          * Don't repeat a key if the input buffers are not empty and the
1465          * characters get aren't echoed locally. This makes key repeat
1466          * usable with slow applications and under heavy loads.
1467          */
1468         return;
1469     }
1470
1471     param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1472     param.ledstate = kbd->ledflagstate;
1473     key_map = key_maps[shift_final];
1474
1475     rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1476                     KBD_KEYCODE, &param);
1477     if (rc == NOTIFY_STOP || !key_map) {
1478         atomic_notifier_call_chain(&keyboard_notifier_list,
1479                        KBD_UNBOUND_KEYCODE, &param);
1480         do_compute_shiftstate();
1481         kbd->slockstate = 0;
1482         return;
1483     }
1484
1485     if (keycode < NR_KEYS)
1486         keysym = key_map[keycode];
1487     else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1488         keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1489     else
1490         return;
1491
1492     type = KTYP(keysym);
1493
1494     if (type < 0xf0) {
1495         param.value = keysym;
1496         rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1497                         KBD_UNICODE, &param);
1498         if (rc != NOTIFY_STOP)
1499             if (down && !raw_mode)
1500                 k_unicode(vc, keysym, !down);
1501         return;
1502     }
1503
1504     type -= 0xf0;
1505
1506     if (type == KT_LETTER) {
1507         type = KT_LATIN;
1508         if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1509             key_map = key_maps[shift_final ^ BIT(KG_SHIFT)];
1510             if (key_map)
1511                 keysym = key_map[keycode];
1512         }
1513     }
1514
1515     param.value = keysym;
1516     rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1517                     KBD_KEYSYM, &param);
1518     if (rc == NOTIFY_STOP)
1519         return;
1520
1521     if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1522         return;
1523
1524     (*k_handler[type])(vc, keysym & 0xff, !down);
1525
1526     param.ledstate = kbd->ledflagstate;
1527     atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1528
1529     if (type != KT_SLOCK)
1530         kbd->slockstate = 0;
1531 }
1532
1533 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1534               unsigned int event_code, int value)
1535 {
1536     /* We are called with interrupts disabled, just take the lock */
1537     spin_lock(&kbd_event_lock);
1538
1539     if (event_type == EV_MSC && event_code == MSC_RAW &&
1540             kbd_is_hw_raw(handle->dev))
1541         kbd_rawcode(value);
1542     if (event_type == EV_KEY && event_code <= KEY_MAX)
1543         kbd_keycode(event_code, value, kbd_is_hw_raw(handle->dev));
1544
1545     spin_unlock(&kbd_event_lock);
1546
1547     tasklet_schedule(&keyboard_tasklet);
1548     do_poke_blanked_console = 1;
1549     schedule_console_callback();
1550 }
1551
1552 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1553 {
1554     if (test_bit(EV_SND, dev->evbit))
1555         return true;
1556
1557     if (test_bit(EV_KEY, dev->evbit)) {
1558         if (find_next_bit(dev->keybit, BTN_MISC, KEY_RESERVED) <
1559                 BTN_MISC)
1560             return true;
1561         if (find_next_bit(dev->keybit, KEY_BRL_DOT10 + 1,
1562                     KEY_BRL_DOT1) <= KEY_BRL_DOT10)
1563             return true;
1564     }
1565
1566     return false;
1567 }
1568
1569 /*
1570  * When a keyboard (or other input device) is found, the kbd_connect
1571  * function is called. The function then looks at the device, and if it
1572  * likes it, it can open it and get events from it. In this (kbd_connect)
1573  * function, we should decide which VT to bind that keyboard to initially.
1574  */
1575 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1576             const struct input_device_id *id)
1577 {
1578     struct input_handle *handle;
1579     int error;
1580
1581     handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1582     if (!handle)
1583         return -ENOMEM;
1584
1585     handle->dev = dev;
1586     handle->handler = handler;
1587     handle->name = "kbd";
1588
1589     error = input_register_handle(handle);
1590     if (error)
1591         goto err_free_handle;
1592
1593     error = input_open_device(handle);
1594     if (error)
1595         goto err_unregister_handle;
1596
1597     return 0;
1598
1599  err_unregister_handle:
1600     input_unregister_handle(handle);
1601  err_free_handle:
1602     kfree(handle);
1603     return error;
1604 }
1605
1606 static void kbd_disconnect(struct input_handle *handle)
1607 {
1608     input_close_device(handle);
1609     input_unregister_handle(handle);
1610     kfree(handle);
1611 }
1612
1613 /*
1614  * Start keyboard handler on the new keyboard by refreshing LED state to
1615  * match the rest of the system.
1616  */
1617 static void kbd_start(struct input_handle *handle)
1618 {
1619     tasklet_disable(&keyboard_tasklet);
1620
1621     if (ledstate != -1U)
1622         kbd_update_leds_helper(handle, &ledstate);
1623
1624     tasklet_enable(&keyboard_tasklet);
1625 }
1626
1627 static const struct input_device_id kbd_ids[] = {
1628     {
1629         .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1630         .evbit = { BIT_MASK(EV_KEY) },
1631     },
1632
1633     {
1634         .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1635         .evbit = { BIT_MASK(EV_SND) },
1636     },
1637
1638     { },    /* Terminating entry */
1639 };
1640
1641 MODULE_DEVICE_TABLE(input, kbd_ids);
1642
1643 static struct input_handler kbd_handler = {
1644     .event      = kbd_event,
1645     .match      = kbd_match,
1646     .connect    = kbd_connect,
1647     .disconnect = kbd_disconnect,
1648     .start      = kbd_start,
1649     .name       = "kbd",
1650     .id_table   = kbd_ids,
1651 };
1652
1653 int __init kbd_init(void)
1654 {
1655     int i;
1656     int error;
1657
1658     for (i = 0; i < MAX_NR_CONSOLES; i++) {
1659         kbd_table[i].ledflagstate = kbd_defleds();
1660         kbd_table[i].default_ledflagstate = kbd_defleds();
1661         kbd_table[i].ledmode = LED_SHOW_FLAGS;
1662         kbd_table[i].lockstate = KBD_DEFLOCK;
1663         kbd_table[i].slockstate = 0;
1664         kbd_table[i].modeflags = KBD_DEFMODE;
1665         kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1666     }
1667
1668     kbd_init_leds();
1669
1670     error = input_register_handler(&kbd_handler);
1671     if (error)
1672         return error;
1673
1674     tasklet_enable(&keyboard_tasklet);
1675     tasklet_schedule(&keyboard_tasklet);
1676
1677     return 0;
1678 }
1679
1680 /* Ioctl support code */
1681
1682 /**
1683  *  vt_do_diacrit       -   diacritical table updates
1684  *  @cmd: ioctl request
1685  *  @udp: pointer to user data for ioctl
1686  *  @perm: permissions check computed by caller
1687  *
1688  *  Update the diacritical tables atomically and safely. Lock them
1689  *  against simultaneous keypresses
1690  */
1691 int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm)
1692 {
1693     unsigned long flags;
1694     int asize;
1695     int ret = 0;
1696
1697     switch (cmd) {
1698     case KDGKBDIACR:
1699     {
1700         struct kbdiacrs __user *a = udp;
1701         struct kbdiacr *dia;
1702         int i;
1703
1704         dia = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacr),
1705                                 GFP_KERNEL);
1706         if (!dia)
1707             return -ENOMEM;
1708
1709         /* Lock the diacriticals table, make a copy and then
1710            copy it after we unlock */
1711         spin_lock_irqsave(&kbd_event_lock, flags);
1712
1713         asize = accent_table_size;
1714         for (i = 0; i < asize; i++) {
1715             dia[i].diacr = conv_uni_to_8bit(
1716                         accent_table[i].diacr);
1717             dia[i].base = conv_uni_to_8bit(
1718                         accent_table[i].base);
1719             dia[i].result = conv_uni_to_8bit(
1720                         accent_table[i].result);
1721         }
1722         spin_unlock_irqrestore(&kbd_event_lock, flags);
1723
1724         if (put_user(asize, &a->kb_cnt))
1725             ret = -EFAULT;
1726         else  if (copy_to_user(a->kbdiacr, dia,
1727                 asize * sizeof(struct kbdiacr)))
1728             ret = -EFAULT;
1729         kfree(dia);
1730         return ret;
1731     }
1732     case KDGKBDIACRUC:
1733     {
1734         struct kbdiacrsuc __user *a = udp;
1735         void *buf;
1736
1737         buf = kmalloc_array(MAX_DIACR, sizeof(struct kbdiacruc),
1738                                 GFP_KERNEL);
1739         if (buf == NULL)
1740             return -ENOMEM;
1741
1742         /* Lock the diacriticals table, make a copy and then
1743            copy it after we unlock */
1744         spin_lock_irqsave(&kbd_event_lock, flags);
1745
1746         asize = accent_table_size;
1747         memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1748
1749         spin_unlock_irqrestore(&kbd_event_lock, flags);
1750
1751         if (put_user(asize, &a->kb_cnt))
1752             ret = -EFAULT;
1753         else if (copy_to_user(a->kbdiacruc, buf,
1754                 asize*sizeof(struct kbdiacruc)))
1755             ret = -EFAULT;
1756         kfree(buf);
1757         return ret;
1758     }
1759
1760     case KDSKBDIACR:
1761     {
1762         struct kbdiacrs __user *a = udp;
1763         struct kbdiacr *dia = NULL;
1764         unsigned int ct;
1765         int i;
1766
1767         if (!perm)
1768             return -EPERM;
1769         if (get_user(ct, &a->kb_cnt))
1770             return -EFAULT;
1771         if (ct >= MAX_DIACR)
1772             return -EINVAL;
1773
1774         if (ct) {
1775
1776             dia = memdup_user(a->kbdiacr,
1777                     sizeof(struct kbdiacr) * ct);
1778             if (IS_ERR(dia))
1779                 return PTR_ERR(dia);
1780
1781         }
1782
1783         spin_lock_irqsave(&kbd_event_lock, flags);
1784         accent_table_size = ct;
1785         for (i = 0; i < ct; i++) {
1786             accent_table[i].diacr =
1787                     conv_8bit_to_uni(dia[i].diacr);
1788             accent_table[i].base =
1789                     conv_8bit_to_uni(dia[i].base);
1790             accent_table[i].result =
1791                     conv_8bit_to_uni(dia[i].result);
1792         }
1793         spin_unlock_irqrestore(&kbd_event_lock, flags);
1794         kfree(dia);
1795         return 0;
1796     }
1797
1798     case KDSKBDIACRUC:
1799     {
1800         struct kbdiacrsuc __user *a = udp;
1801         unsigned int ct;
1802         void *buf = NULL;
1803
1804         if (!perm)
1805             return -EPERM;
1806
1807         if (get_user(ct, &a->kb_cnt))
1808             return -EFAULT;
1809
1810         if (ct >= MAX_DIACR)
1811             return -EINVAL;
1812
1813         if (ct) {
1814             buf = memdup_user(a->kbdiacruc,
1815                       ct * sizeof(struct kbdiacruc));
1816             if (IS_ERR(buf))
1817                 return PTR_ERR(buf);
1818         }
1819         spin_lock_irqsave(&kbd_event_lock, flags);
1820         if (ct)
1821             memcpy(accent_table, buf,
1822                     ct * sizeof(struct kbdiacruc));
1823         accent_table_size = ct;
1824         spin_unlock_irqrestore(&kbd_event_lock, flags);
1825         kfree(buf);
1826         return 0;
1827     }
1828     }
1829     return ret;
1830 }
1831
1832 /**
1833  *  vt_do_kdskbmode     -   set keyboard mode ioctl
1834  *  @console: the console to use
1835  *  @arg: the requested mode
1836  *
1837  *  Update the keyboard mode bits while holding the correct locks.
1838  *  Return 0 for success or an error code.
1839  */
1840 int vt_do_kdskbmode(unsigned int console, unsigned int arg)
1841 {
1842     struct kbd_struct *kb = &kbd_table[console];
1843     int ret = 0;
1844     unsigned long flags;
1845
1846     spin_lock_irqsave(&kbd_event_lock, flags);
1847     switch(arg) {
1848     case K_RAW:
1849         kb->kbdmode = VC_RAW;
1850         break;
1851     case K_MEDIUMRAW:
1852         kb->kbdmode = VC_MEDIUMRAW;
1853         break;
1854     case K_XLATE:
1855         kb->kbdmode = VC_XLATE;
1856         do_compute_shiftstate();
1857         break;
1858     case K_UNICODE:
1859         kb->kbdmode = VC_UNICODE;
1860         do_compute_shiftstate();
1861         break;
1862     case K_OFF:
1863         kb->kbdmode = VC_OFF;
1864         break;
1865     default:
1866         ret = -EINVAL;
1867     }
1868     spin_unlock_irqrestore(&kbd_event_lock, flags);
1869     return ret;
1870 }
1871
1872 /**
1873  *  vt_do_kdskbmeta     -   set keyboard meta state
1874  *  @console: the console to use
1875  *  @arg: the requested meta state
1876  *
1877  *  Update the keyboard meta bits while holding the correct locks.
1878  *  Return 0 for success or an error code.
1879  */
1880 int vt_do_kdskbmeta(unsigned int console, unsigned int arg)
1881 {
1882     struct kbd_struct *kb = &kbd_table[console];
1883     int ret = 0;
1884     unsigned long flags;
1885
1886     spin_lock_irqsave(&kbd_event_lock, flags);
1887     switch(arg) {
1888     case K_METABIT:
1889         clr_vc_kbd_mode(kb, VC_META);
1890         break;
1891     case K_ESCPREFIX:
1892         set_vc_kbd_mode(kb, VC_META);
1893         break;
1894     default:
1895         ret = -EINVAL;
1896     }
1897     spin_unlock_irqrestore(&kbd_event_lock, flags);
1898     return ret;
1899 }
1900
1901 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1902                                 int perm)
1903 {
1904     struct kbkeycode tmp;
1905     int kc = 0;
1906
1907     if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1908         return -EFAULT;
1909     switch (cmd) {
1910     case KDGETKEYCODE:
1911         kc = getkeycode(tmp.scancode);
1912         if (kc >= 0)
1913             kc = put_user(kc, &user_kbkc->keycode);
1914         break;
1915     case KDSETKEYCODE:
1916         if (!perm)
1917             return -EPERM;
1918         kc = setkeycode(tmp.scancode, tmp.keycode);
1919         break;
1920     }
1921     return kc;
1922 }
1923
1924 static unsigned short vt_kdgkbent(unsigned char kbdmode, unsigned char idx,
1925         unsigned char map)
1926 {
1927     unsigned short *key_map, val;
1928     unsigned long flags;
1929
1930     /* Ensure another thread doesn't free it under us */
1931     spin_lock_irqsave(&kbd_event_lock, flags);
1932     key_map = key_maps[map];
1933     if (key_map) {
1934         val = U(key_map[idx]);
1935         if (kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1936             val = K_HOLE;
1937     } else
1938         val = idx ? K_HOLE : K_NOSUCHMAP;
1939     spin_unlock_irqrestore(&kbd_event_lock, flags);
1940
1941     return val;
1942 }
1943
1944 static int vt_kdskbent(unsigned char kbdmode, unsigned char idx,
1945         unsigned char map, unsigned short val)
1946 {
1947     unsigned long flags;
1948     unsigned short *key_map, *new_map, oldval;
1949
1950     if (!idx && val == K_NOSUCHMAP) {
1951         spin_lock_irqsave(&kbd_event_lock, flags);
1952         /* deallocate map */
1953         key_map = key_maps[map];
1954         if (map && key_map) {
1955             key_maps[map] = NULL;
1956             if (key_map[0] == U(K_ALLOCATED)) {
1957                 kfree(key_map);
1958                 keymap_count--;
1959             }
1960         }
1961         spin_unlock_irqrestore(&kbd_event_lock, flags);
1962
1963         return 0;
1964     }
1965
1966     if (KTYP(val) < NR_TYPES) {
1967         if (KVAL(val) > max_vals[KTYP(val)])
1968             return -EINVAL;
1969     } else if (kbdmode != VC_UNICODE)
1970         return -EINVAL;
1971
1972     /* ++Geert: non-PC keyboards may generate keycode zero */
1973 #if !defined(__mc68000__) && !defined(__powerpc__)
1974     /* assignment to entry 0 only tests validity of args */
1975     if (!idx)
1976         return 0;
1977 #endif
1978
1979     new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1980     if (!new_map)
1981         return -ENOMEM;
1982
1983     spin_lock_irqsave(&kbd_event_lock, flags);
1984     key_map = key_maps[map];
1985     if (key_map == NULL) {
1986         int j;
1987
1988         if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1989             !capable(CAP_SYS_RESOURCE)) {
1990             spin_unlock_irqrestore(&kbd_event_lock, flags);
1991             kfree(new_map);
1992             return -EPERM;
1993         }
1994         key_maps[map] = new_map;
1995         key_map = new_map;
1996         key_map[0] = U(K_ALLOCATED);
1997         for (j = 1; j < NR_KEYS; j++)
1998             key_map[j] = U(K_HOLE);
1999         keymap_count++;
2000     } else
2001         kfree(new_map);
2002
2003     oldval = U(key_map[idx]);
2004     if (val == oldval)
2005         goto out;
2006
2007     /* Attention Key */
2008     if ((oldval == K_SAK || val == K_SAK) && !capable(CAP_SYS_ADMIN)) {
2009         spin_unlock_irqrestore(&kbd_event_lock, flags);
2010         return -EPERM;
2011     }
2012
2013     key_map[idx] = U(val);
2014     if (!map && (KTYP(oldval) == KT_SHIFT || KTYP(val) == KT_SHIFT))
2015         do_compute_shiftstate();
2016 out:
2017     spin_unlock_irqrestore(&kbd_event_lock, flags);
2018
2019     return 0;
2020 }
2021
2022 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
2023                         unsigned int console)
2024 {
2025     struct kbd_struct *kb = &kbd_table[console];
2026     struct kbentry kbe;
2027
2028     if (copy_from_user(&kbe, user_kbe, sizeof(struct kbentry)))
2029         return -EFAULT;
2030
2031     switch (cmd) {
2032     case KDGKBENT:
2033         return put_user(vt_kdgkbent(kb->kbdmode, kbe.kb_index,
2034                     kbe.kb_table),
2035                 &user_kbe->kb_value);
2036     case KDSKBENT:
2037         if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2038             return -EPERM;
2039         return vt_kdskbent(kb->kbdmode, kbe.kb_index, kbe.kb_table,
2040                 kbe.kb_value);
2041     }
2042     return 0;
2043 }
2044
2045 static char *vt_kdskbsent(char *kbs, unsigned char cur)
2046 {
2047     static DECLARE_BITMAP(is_kmalloc, MAX_NR_FUNC);
2048     char *cur_f = func_table[cur];
2049
2050     if (cur_f && strlen(cur_f) >= strlen(kbs)) {
2051         strcpy(cur_f, kbs);
2052         return kbs;
2053     }
2054
2055     func_table[cur] = kbs;
2056
2057     return __test_and_set_bit(cur, is_kmalloc) ? cur_f : NULL;
2058 }
2059
2060 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
2061 {
2062     unsigned char kb_func;
2063     unsigned long flags;
2064     char *kbs;
2065     int ret;
2066
2067     if (get_user(kb_func, &user_kdgkb->kb_func))
2068         return -EFAULT;
2069
2070     kb_func = array_index_nospec(kb_func, MAX_NR_FUNC);
2071
2072     switch (cmd) {
2073     case KDGKBSENT: {
2074         /* size should have been a struct member */
2075         ssize_t len = sizeof(user_kdgkb->kb_string);
2076
2077         kbs = kmalloc(len, GFP_KERNEL);
2078         if (!kbs)
2079             return -ENOMEM;
2080
2081         spin_lock_irqsave(&func_buf_lock, flags);
2082         len = strlcpy(kbs, func_table[kb_func] ? : "", len);
2083         spin_unlock_irqrestore(&func_buf_lock, flags);
2084
2085         ret = copy_to_user(user_kdgkb->kb_string, kbs, len + 1) ?
2086             -EFAULT : 0;
2087
2088         break;
2089     }
2090     case KDSKBSENT:
2091         if (!perm || !capable(CAP_SYS_TTY_CONFIG))
2092             return -EPERM;
2093
2094         kbs = strndup_user(user_kdgkb->kb_string,
2095                 sizeof(user_kdgkb->kb_string));
2096         if (IS_ERR(kbs))
2097             return PTR_ERR(kbs);
2098
2099         spin_lock_irqsave(&func_buf_lock, flags);
2100         kbs = vt_kdskbsent(kbs, kb_func);
2101         spin_unlock_irqrestore(&func_buf_lock, flags);
2102
2103         ret = 0;
2104         break;
2105     }
2106
2107     kfree(kbs);
2108
2109     return ret;
2110 }
2111
2112 int vt_do_kdskled(unsigned int console, int cmd, unsigned long arg, int perm)
2113 {
2114     struct kbd_struct *kb = &kbd_table[console];
2115         unsigned long flags;
2116     unsigned char ucval;
2117
2118         switch(cmd) {
2119     /* the ioctls below read/set the flags usually shown in the leds */
2120     /* don't use them - they will go away without warning */
2121     case KDGKBLED:
2122                 spin_lock_irqsave(&kbd_event_lock, flags);
2123         ucval = kb->ledflagstate | (kb->default_ledflagstate << 4);
2124                 spin_unlock_irqrestore(&kbd_event_lock, flags);
2125         return put_user(ucval, (char __user *)arg);
2126
2127     case KDSKBLED:
2128         if (!perm)
2129             return -EPERM;
2130         if (arg & ~0x77)
2131             return -EINVAL;
2132                 spin_lock_irqsave(&led_lock, flags);
2133         kb->ledflagstate = (arg & 7);
2134         kb->default_ledflagstate = ((arg >> 4) & 7);
2135         set_leds();
2136                 spin_unlock_irqrestore(&led_lock, flags);
2137         return 0;
2138
2139     /* the ioctls below only set the lights, not the functions */
2140     /* for those, see KDGKBLED and KDSKBLED above */
2141     case KDGETLED:
2142         ucval = getledstate();
2143         return put_user(ucval, (char __user *)arg);
2144
2145     case KDSETLED:
2146         if (!perm)
2147             return -EPERM;
2148         setledstate(kb, arg);
2149         return 0;
2150         }
2151         return -ENOIOCTLCMD;
2152 }
2153
2154 int vt_do_kdgkbmode(unsigned int console)
2155 {
2156     struct kbd_struct *kb = &kbd_table[console];
2157     /* This is a spot read so needs no locking */
2158     switch (kb->kbdmode) {
2159     case VC_RAW:
2160         return K_RAW;
2161     case VC_MEDIUMRAW:
2162         return K_MEDIUMRAW;
2163     case VC_UNICODE:
2164         return K_UNICODE;
2165     case VC_OFF:
2166         return K_OFF;
2167     default:
2168         return K_XLATE;
2169     }
2170 }
2171
2172 /**
2173  *  vt_do_kdgkbmeta     -   report meta status
2174  *  @console: console to report
2175  *
2176  *  Report the meta flag status of this console
2177  */
2178 int vt_do_kdgkbmeta(unsigned int console)
2179 {
2180     struct kbd_struct *kb = &kbd_table[console];
2181         /* Again a spot read so no locking */
2182     return vc_kbd_mode(kb, VC_META) ? K_ESCPREFIX : K_METABIT;
2183 }
2184
2185 /**
2186  *  vt_reset_unicode    -   reset the unicode status
2187  *  @console: console being reset
2188  *
2189  *  Restore the unicode console state to its default
2190  */
2191 void vt_reset_unicode(unsigned int console)
2192 {
2193     unsigned long flags;
2194
2195     spin_lock_irqsave(&kbd_event_lock, flags);
2196     kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2197     spin_unlock_irqrestore(&kbd_event_lock, flags);
2198 }
2199
2200 /**
2201  *  vt_get_shift_state  -   shift bit state
2202  *
2203  *  Report the shift bits from the keyboard state. We have to export
2204  *  this to support some oddities in the vt layer.
2205  */
2206 int vt_get_shift_state(void)
2207 {
2208         /* Don't lock as this is a transient report */
2209         return shift_state;
2210 }
2211
2212 /**
2213  *  vt_reset_keyboard   -   reset keyboard state
2214  *  @console: console to reset
2215  *
2216  *  Reset the keyboard bits for a console as part of a general console
2217  *  reset event
2218  */
2219 void vt_reset_keyboard(unsigned int console)
2220 {
2221     struct kbd_struct *kb = &kbd_table[console];
2222     unsigned long flags;
2223
2224     spin_lock_irqsave(&kbd_event_lock, flags);
2225     set_vc_kbd_mode(kb, VC_REPEAT);
2226     clr_vc_kbd_mode(kb, VC_CKMODE);
2227     clr_vc_kbd_mode(kb, VC_APPLIC);
2228     clr_vc_kbd_mode(kb, VC_CRLF);
2229     kb->lockstate = 0;
2230     kb->slockstate = 0;
2231     spin_lock(&led_lock);
2232     kb->ledmode = LED_SHOW_FLAGS;
2233     kb->ledflagstate = kb->default_ledflagstate;
2234     spin_unlock(&led_lock);
2235     /* do not do set_leds here because this causes an endless tasklet loop
2236        when the keyboard hasn't been initialized yet */
2237     spin_unlock_irqrestore(&kbd_event_lock, flags);
2238 }
2239
2240 /**
2241  *  vt_get_kbd_mode_bit -   read keyboard status bits
2242  *  @console: console to read from
2243  *  @bit: mode bit to read
2244  *
2245  *  Report back a vt mode bit. We do this without locking so the
2246  *  caller must be sure that there are no synchronization needs
2247  */
2248
2249 int vt_get_kbd_mode_bit(unsigned int console, int bit)
2250 {
2251     struct kbd_struct *kb = &kbd_table[console];
2252     return vc_kbd_mode(kb, bit);
2253 }
2254
2255 /**
2256  *  vt_set_kbd_mode_bit -   read keyboard status bits
2257  *  @console: console to read from
2258  *  @bit: mode bit to read
2259  *
2260  *  Set a vt mode bit. We do this without locking so the
2261  *  caller must be sure that there are no synchronization needs
2262  */
2263
2264 void vt_set_kbd_mode_bit(unsigned int console, int bit)
2265 {
2266     struct kbd_struct *kb = &kbd_table[console];
2267     unsigned long flags;
2268
2269     spin_lock_irqsave(&kbd_event_lock, flags);
2270     set_vc_kbd_mode(kb, bit);
2271     spin_unlock_irqrestore(&kbd_event_lock, flags);
2272 }
2273
2274 /**
2275  *  vt_clr_kbd_mode_bit -   read keyboard status bits
2276  *  @console: console to read from
2277  *  @bit: mode bit to read
2278  *
2279  *  Report back a vt mode bit. We do this without locking so the
2280  *  caller must be sure that there are no synchronization needs
2281  */
2282
2283 void vt_clr_kbd_mode_bit(unsigned int console, int bit)
2284 {
2285     struct kbd_struct *kb = &kbd_table[console];
2286     unsigned long flags;
2287
2288     spin_lock_irqsave(&kbd_event_lock, flags);
2289     clr_vc_kbd_mode(kb, bit);
2290     spin_unlock_irqrestore(&kbd_event_lock, flags);
2291 }