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