drivers/tty/vt/keyboard.c

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