kernel/drivers/tty/vt/keyboard.c

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