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