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  *      FIXME: We eventually need to hold the kbd lock here to protect
1090  *      the LED updating. We can't do it yet because fn_hold calls stop_tty
1091  *      and start_tty under the kbd_event_lock, while normal tty paths
1092  *      don't hold the lock. We probably need to split out an LED lock
1093  *      but not during an -rc release!
1094  */
1095 void vt_kbd_con_start(int console)
1096 {
1097         struct kbd_struct * kbd = kbd_table + console;
1098 /*      unsigned long flags; */
1099 /*      spin_lock_irqsave(&kbd_event_lock, flags); */
1100         clr_vc_kbd_led(kbd, VC_SCROLLOCK);
1101         set_leds();
1102 /*      spin_unlock_irqrestore(&kbd_event_lock, flags); */
1103 }
1104
1105 /**
1106  *      vt_kbd_con_stop         -       Keyboard side of console stop
1107  *      @console: console
1108  *
1109  *      Handle console stop. This is a wrapper for the VT layer
1110  *      so that we can keep kbd knowledge internal
1111  *
1112  *      FIXME: We eventually need to hold the kbd lock here to protect
1113  *      the LED updating. We can't do it yet because fn_hold calls stop_tty
1114  *      and start_tty under the kbd_event_lock, while normal tty paths
1115  *      don't hold the lock. We probably need to split out an LED lock
1116  *      but not during an -rc release!
1117  */
1118 void vt_kbd_con_stop(int console)
1119 {
1120         struct kbd_struct * kbd = kbd_table + console;
1121 /*      unsigned long flags; */
1122 /*      spin_lock_irqsave(&kbd_event_lock, flags); */
1123         set_vc_kbd_led(kbd, VC_SCROLLOCK);
1124         set_leds();
1125 /*      spin_unlock_irqrestore(&kbd_event_lock, flags); */
1126 }
1127
1128 /*
1129  * This is the tasklet that updates LED state on all keyboards
1130  * attached to the box. The reason we use tasklet is that we
1131  * need to handle the scenario when keyboard handler is not
1132  * registered yet but we already getting updates from the VT to
1133  * update led state.
1134  */
1135 static void kbd_bh(unsigned long dummy)
1136 {
1137         unsigned char leds = getleds();
1138
1139         if (leds != ledstate) {
1140                 input_handler_for_each_handle(&kbd_handler, &leds,
1141                                               kbd_update_leds_helper);
1142                 ledstate = leds;
1143         }
1144 }
1145
1146 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1147
1148 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1149     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1150     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1151     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1152     defined(CONFIG_AVR32)
1153
1154 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1155                         ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1156
1157 static const unsigned short x86_keycodes[256] =
1158         { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1159          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1160          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1161          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1162          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1163          80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1164         284,285,309,  0,312, 91,327,328,329,331,333,335,336,337,338,339,
1165         367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1166         360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1167         103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1168         291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1169         264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1170         377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1171         308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1172         332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1173
1174 #ifdef CONFIG_SPARC
1175 static int sparc_l1_a_state;
1176 extern void sun_do_break(void);
1177 #endif
1178
1179 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1180                        unsigned char up_flag)
1181 {
1182         int code;
1183
1184         switch (keycode) {
1185
1186         case KEY_PAUSE:
1187                 put_queue(vc, 0xe1);
1188                 put_queue(vc, 0x1d | up_flag);
1189                 put_queue(vc, 0x45 | up_flag);
1190                 break;
1191
1192         case KEY_HANGEUL:
1193                 if (!up_flag)
1194                         put_queue(vc, 0xf2);
1195                 break;
1196
1197         case KEY_HANJA:
1198                 if (!up_flag)
1199                         put_queue(vc, 0xf1);
1200                 break;
1201
1202         case KEY_SYSRQ:
1203                 /*
1204                  * Real AT keyboards (that's what we're trying
1205                  * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1206                  * pressing PrtSc/SysRq alone, but simply 0x54
1207                  * when pressing Alt+PrtSc/SysRq.
1208                  */
1209                 if (test_bit(KEY_LEFTALT, key_down) ||
1210                     test_bit(KEY_RIGHTALT, key_down)) {
1211                         put_queue(vc, 0x54 | up_flag);
1212                 } else {
1213                         put_queue(vc, 0xe0);
1214                         put_queue(vc, 0x2a | up_flag);
1215                         put_queue(vc, 0xe0);
1216                         put_queue(vc, 0x37 | up_flag);
1217                 }
1218                 break;
1219
1220         default:
1221                 if (keycode > 255)
1222                         return -1;
1223
1224                 code = x86_keycodes[keycode];
1225                 if (!code)
1226                         return -1;
1227
1228                 if (code & 0x100)
1229                         put_queue(vc, 0xe0);
1230                 put_queue(vc, (code & 0x7f) | up_flag);
1231
1232                 break;
1233         }
1234
1235         return 0;
1236 }
1237
1238 #else
1239
1240 #define HW_RAW(dev)     0
1241
1242 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1243 {
1244         if (keycode > 127)
1245                 return -1;
1246
1247         put_queue(vc, keycode | up_flag);
1248         return 0;
1249 }
1250 #endif
1251
1252 static void kbd_rawcode(unsigned char data)
1253 {
1254         struct vc_data *vc = vc_cons[fg_console].d;
1255
1256         kbd = kbd_table + vc->vc_num;
1257         if (kbd->kbdmode == VC_RAW)
1258                 put_queue(vc, data);
1259 }
1260
1261 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1262 {
1263         struct vc_data *vc = vc_cons[fg_console].d;
1264         unsigned short keysym, *key_map;
1265         unsigned char type;
1266         bool raw_mode;
1267         struct tty_struct *tty;
1268         int shift_final;
1269         struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1270         int rc;
1271
1272         tty = vc->port.tty;
1273
1274         if (tty && (!tty->driver_data)) {
1275                 /* No driver data? Strange. Okay we fix it then. */
1276                 tty->driver_data = vc;
1277         }
1278
1279         kbd = kbd_table + vc->vc_num;
1280
1281 #ifdef CONFIG_SPARC
1282         if (keycode == KEY_STOP)
1283                 sparc_l1_a_state = down;
1284 #endif
1285
1286         rep = (down == 2);
1287
1288         raw_mode = (kbd->kbdmode == VC_RAW);
1289         if (raw_mode && !hw_raw)
1290                 if (emulate_raw(vc, keycode, !down << 7))
1291                         if (keycode < BTN_MISC && printk_ratelimit())
1292                                 pr_warning("can't emulate rawmode for keycode %d\n",
1293                                            keycode);
1294
1295 #ifdef CONFIG_SPARC
1296         if (keycode == KEY_A && sparc_l1_a_state) {
1297                 sparc_l1_a_state = false;
1298                 sun_do_break();
1299         }
1300 #endif
1301
1302         if (kbd->kbdmode == VC_MEDIUMRAW) {
1303                 /*
1304                  * This is extended medium raw mode, with keys above 127
1305                  * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1306                  * the 'up' flag if needed. 0 is reserved, so this shouldn't
1307                  * interfere with anything else. The two bytes after 0 will
1308                  * always have the up flag set not to interfere with older
1309                  * applications. This allows for 16384 different keycodes,
1310                  * which should be enough.
1311                  */
1312                 if (keycode < 128) {
1313                         put_queue(vc, keycode | (!down << 7));
1314                 } else {
1315                         put_queue(vc, !down << 7);
1316                         put_queue(vc, (keycode >> 7) | 0x80);
1317                         put_queue(vc, keycode | 0x80);
1318                 }
1319                 raw_mode = true;
1320         }
1321
1322         if (down)
1323                 set_bit(keycode, key_down);
1324         else
1325                 clear_bit(keycode, key_down);
1326
1327         if (rep &&
1328             (!vc_kbd_mode(kbd, VC_REPEAT) ||
1329              (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1330                 /*
1331                  * Don't repeat a key if the input buffers are not empty and the
1332                  * characters get aren't echoed locally. This makes key repeat
1333                  * usable with slow applications and under heavy loads.
1334                  */
1335                 return;
1336         }
1337
1338         param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1339         param.ledstate = kbd->ledflagstate;
1340         key_map = key_maps[shift_final];
1341
1342         rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1343                                         KBD_KEYCODE, &param);
1344         if (rc == NOTIFY_STOP || !key_map) {
1345                 atomic_notifier_call_chain(&keyboard_notifier_list,
1346                                            KBD_UNBOUND_KEYCODE, &param);
1347                 do_compute_shiftstate();
1348                 kbd->slockstate = 0;
1349                 return;
1350         }
1351
1352         if (keycode < NR_KEYS)
1353                 keysym = key_map[keycode];
1354         else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1355                 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1356         else
1357                 return;
1358
1359         type = KTYP(keysym);
1360
1361         if (type < 0xf0) {
1362                 param.value = keysym;
1363                 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1364                                                 KBD_UNICODE, &param);
1365                 if (rc != NOTIFY_STOP)
1366                         if (down && !raw_mode)
1367                                 to_utf8(vc, keysym);
1368                 return;
1369         }
1370
1371         type -= 0xf0;
1372
1373         if (type == KT_LETTER) {
1374                 type = KT_LATIN;
1375                 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1376                         key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1377                         if (key_map)
1378                                 keysym = key_map[keycode];
1379                 }
1380         }
1381
1382         param.value = keysym;
1383         rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1384                                         KBD_KEYSYM, &param);
1385         if (rc == NOTIFY_STOP)
1386                 return;
1387
1388         if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1389                 return;
1390
1391         (*k_handler[type])(vc, keysym & 0xff, !down);
1392
1393         param.ledstate = kbd->ledflagstate;
1394         atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1395
1396         if (type != KT_SLOCK)
1397                 kbd->slockstate = 0;
1398 }
1399
1400 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1401                       unsigned int event_code, int value)
1402 {
1403         /* We are called with interrupts disabled, just take the lock */
1404         spin_lock(&kbd_event_lock);
1405
1406         if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1407                 kbd_rawcode(value);
1408         if (event_type == EV_KEY)
1409                 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1410
1411         spin_unlock(&kbd_event_lock);
1412
1413         tasklet_schedule(&keyboard_tasklet);
1414         do_poke_blanked_console = 1;
1415         schedule_console_callback();
1416 }
1417
1418 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1419 {
1420         int i;
1421
1422         if (test_bit(EV_SND, dev->evbit))
1423                 return true;
1424
1425         if (test_bit(EV_KEY, dev->evbit)) {
1426                 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1427                         if (test_bit(i, dev->keybit))
1428                                 return true;
1429                 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1430                         if (test_bit(i, dev->keybit))
1431                                 return true;
1432         }
1433
1434         return false;
1435 }
1436
1437 /*
1438  * When a keyboard (or other input device) is found, the kbd_connect
1439  * function is called. The function then looks at the device, and if it
1440  * likes it, it can open it and get events from it. In this (kbd_connect)
1441  * function, we should decide which VT to bind that keyboard to initially.
1442  */
1443 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1444                         const struct input_device_id *id)
1445 {
1446         struct input_handle *handle;
1447         int error;
1448
1449         handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1450         if (!handle)
1451                 return -ENOMEM;
1452
1453         handle->dev = dev;
1454         handle->handler = handler;
1455         handle->name = "kbd";
1456
1457         error = input_register_handle(handle);
1458         if (error)
1459                 goto err_free_handle;
1460
1461         error = input_open_device(handle);
1462         if (error)
1463                 goto err_unregister_handle;
1464
1465         return 0;
1466
1467  err_unregister_handle:
1468         input_unregister_handle(handle);
1469  err_free_handle:
1470         kfree(handle);
1471         return error;
1472 }
1473
1474 static void kbd_disconnect(struct input_handle *handle)
1475 {
1476         input_close_device(handle);
1477         input_unregister_handle(handle);
1478         kfree(handle);
1479 }
1480
1481 /*
1482  * Start keyboard handler on the new keyboard by refreshing LED state to
1483  * match the rest of the system.
1484  */
1485 static void kbd_start(struct input_handle *handle)
1486 {
1487         tasklet_disable(&keyboard_tasklet);
1488
1489         if (ledstate != 0xff)
1490                 kbd_update_leds_helper(handle, &ledstate);
1491
1492         tasklet_enable(&keyboard_tasklet);
1493 }
1494
1495 static const struct input_device_id kbd_ids[] = {
1496         {
1497                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1498                 .evbit = { BIT_MASK(EV_KEY) },
1499         },
1500
1501         {
1502                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1503                 .evbit = { BIT_MASK(EV_SND) },
1504         },
1505
1506         { },    /* Terminating entry */
1507 };
1508
1509 MODULE_DEVICE_TABLE(input, kbd_ids);
1510
1511 static struct input_handler kbd_handler = {
1512         .event          = kbd_event,
1513         .match          = kbd_match,
1514         .connect        = kbd_connect,
1515         .disconnect     = kbd_disconnect,
1516         .start          = kbd_start,
1517         .name           = "kbd",
1518         .id_table       = kbd_ids,
1519 };
1520
1521 int __init kbd_init(void)
1522 {
1523         int i;
1524         int error;
1525
1526         for (i = 0; i < MAX_NR_CONSOLES; i++) {
1527                 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1528                 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1529                 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1530                 kbd_table[i].lockstate = KBD_DEFLOCK;
1531                 kbd_table[i].slockstate = 0;
1532                 kbd_table[i].modeflags = KBD_DEFMODE;
1533                 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1534         }
1535
1536         error = input_register_handler(&kbd_handler);
1537         if (error)
1538                 return error;
1539
1540         tasklet_enable(&keyboard_tasklet);
1541         tasklet_schedule(&keyboard_tasklet);
1542
1543         return 0;
1544 }
1545
1546 /* Ioctl support code */
1547
1548 /**
1549  *      vt_do_diacrit           -       diacritical table updates
1550  *      @cmd: ioctl request
1551  *      @up: pointer to user data for ioctl
1552  *      @perm: permissions check computed by caller
1553  *
1554  *      Update the diacritical tables atomically and safely. Lock them
1555  *      against simultaneous keypresses
1556  */
1557 int vt_do_diacrit(unsigned int cmd, void __user *up, int perm)
1558 {
1559         struct kbdiacrs __user *a = up;
1560         unsigned long flags;
1561         int asize;
1562         int ret = 0;
1563
1564         switch (cmd) {
1565         case KDGKBDIACR:
1566         {
1567                 struct kbdiacr *diacr;
1568                 int i;
1569
1570                 diacr = kmalloc(MAX_DIACR * sizeof(struct kbdiacr),
1571                                                                 GFP_KERNEL);
1572                 if (diacr == NULL)
1573                         return -ENOMEM;
1574
1575                 /* Lock the diacriticals table, make a copy and then
1576                    copy it after we unlock */
1577                 spin_lock_irqsave(&kbd_event_lock, flags);
1578
1579                 asize = accent_table_size;
1580                 for (i = 0; i < asize; i++) {
1581                         diacr[i].diacr = conv_uni_to_8bit(
1582                                                 accent_table[i].diacr);
1583                         diacr[i].base = conv_uni_to_8bit(
1584                                                 accent_table[i].base);
1585                         diacr[i].result = conv_uni_to_8bit(
1586                                                 accent_table[i].result);
1587                 }
1588                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1589
1590                 if (put_user(asize, &a->kb_cnt))
1591                         ret = -EFAULT;
1592                 else  if (copy_to_user(a->kbdiacr, diacr,
1593                                 asize * sizeof(struct kbdiacr)))
1594                         ret = -EFAULT;
1595                 kfree(diacr);
1596                 return ret;
1597         }
1598         case KDGKBDIACRUC:
1599         {
1600                 struct kbdiacrsuc __user *a = up;
1601                 void *buf;
1602
1603                 buf = kmalloc(MAX_DIACR * sizeof(struct kbdiacruc),
1604                                                                 GFP_KERNEL);
1605                 if (buf == NULL)
1606                         return -ENOMEM;
1607
1608                 /* Lock the diacriticals table, make a copy and then
1609                    copy it after we unlock */
1610                 spin_lock_irqsave(&kbd_event_lock, flags);
1611
1612                 asize = accent_table_size;
1613                 memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc));
1614
1615                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1616
1617                 if (put_user(asize, &a->kb_cnt))
1618                         ret = -EFAULT;
1619                 else if (copy_to_user(a->kbdiacruc, buf,
1620                                 asize*sizeof(struct kbdiacruc)))
1621                         ret = -EFAULT;
1622                 kfree(buf);
1623                 return ret;
1624         }
1625
1626         case KDSKBDIACR:
1627         {
1628                 struct kbdiacrs __user *a = up;
1629                 struct kbdiacr *diacr = NULL;
1630                 unsigned int ct;
1631                 int i;
1632
1633                 if (!perm)
1634                         return -EPERM;
1635                 if (get_user(ct, &a->kb_cnt))
1636                         return -EFAULT;
1637                 if (ct >= MAX_DIACR)
1638                         return -EINVAL;
1639
1640                 if (ct) {
1641                         diacr = kmalloc(sizeof(struct kbdiacr) * ct,
1642                                                                 GFP_KERNEL);
1643                         if (diacr == NULL)
1644                                 return -ENOMEM;
1645
1646                         if (copy_from_user(diacr, a->kbdiacr,
1647                                         sizeof(struct kbdiacr) * ct)) {
1648                                 kfree(diacr);
1649                                 return -EFAULT;
1650                         }
1651                 }
1652
1653                 spin_lock_irqsave(&kbd_event_lock, flags);
1654                 accent_table_size = ct;
1655                 for (i = 0; i < ct; i++) {
1656                         accent_table[i].diacr =
1657                                         conv_8bit_to_uni(diacr[i].diacr);
1658                         accent_table[i].base =
1659                                         conv_8bit_to_uni(diacr[i].base);
1660                         accent_table[i].result =
1661                                         conv_8bit_to_uni(diacr[i].result);
1662                 }
1663                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1664                 kfree(diacr);
1665                 return 0;
1666         }
1667
1668         case KDSKBDIACRUC:
1669         {
1670                 struct kbdiacrsuc __user *a = up;
1671                 unsigned int ct;
1672                 void *buf = NULL;
1673
1674                 if (!perm)
1675                         return -EPERM;
1676
1677                 if (get_user(ct, &a->kb_cnt))
1678                         return -EFAULT;
1679
1680                 if (ct >= MAX_DIACR)
1681                         return -EINVAL;
1682
1683                 if (ct) {
1684                         buf = kmalloc(ct * sizeof(struct kbdiacruc),
1685                                                                 GFP_KERNEL);
1686                         if (buf == NULL)
1687                                 return -ENOMEM;
1688
1689                         if (copy_from_user(buf, a->kbdiacruc,
1690                                         ct * sizeof(struct kbdiacruc))) {
1691                                 kfree(buf);
1692                                 return -EFAULT;
1693                         }
1694                 }
1695                 spin_lock_irqsave(&kbd_event_lock, flags);
1696                 if (ct)
1697                         memcpy(accent_table, buf,
1698                                         ct * sizeof(struct kbdiacruc));
1699                 accent_table_size = ct;
1700                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1701                 kfree(buf);
1702                 return 0;
1703         }
1704         }
1705         return ret;
1706 }
1707
1708 /**
1709  *      vt_do_kdskbmode         -       set keyboard mode ioctl
1710  *      @console: the console to use
1711  *      @arg: the requested mode
1712  *
1713  *      Update the keyboard mode bits while holding the correct locks.
1714  *      Return 0 for success or an error code.
1715  */
1716 int vt_do_kdskbmode(int console, unsigned int arg)
1717 {
1718         struct kbd_struct * kbd = kbd_table + console;
1719         int ret = 0;
1720         unsigned long flags;
1721
1722         spin_lock_irqsave(&kbd_event_lock, flags);
1723         switch(arg) {
1724         case K_RAW:
1725                 kbd->kbdmode = VC_RAW;
1726                 break;
1727         case K_MEDIUMRAW:
1728                 kbd->kbdmode = VC_MEDIUMRAW;
1729                 break;
1730         case K_XLATE:
1731                 kbd->kbdmode = VC_XLATE;
1732                 do_compute_shiftstate();
1733                 break;
1734         case K_UNICODE:
1735                 kbd->kbdmode = VC_UNICODE;
1736                 do_compute_shiftstate();
1737                 break;
1738         case K_OFF:
1739                 kbd->kbdmode = VC_OFF;
1740                 break;
1741         default:
1742                 ret = -EINVAL;
1743         }
1744         spin_unlock_irqrestore(&kbd_event_lock, flags);
1745         return ret;
1746 }
1747
1748 /**
1749  *      vt_do_kdskbmeta         -       set keyboard meta state
1750  *      @console: the console to use
1751  *      @arg: the requested meta state
1752  *
1753  *      Update the keyboard meta bits while holding the correct locks.
1754  *      Return 0 for success or an error code.
1755  */
1756 int vt_do_kdskbmeta(int console, unsigned int arg)
1757 {
1758         struct kbd_struct * kbd = kbd_table + console;
1759         int ret = 0;
1760         unsigned long flags;
1761
1762         spin_lock_irqsave(&kbd_event_lock, flags);
1763         switch(arg) {
1764         case K_METABIT:
1765                 clr_vc_kbd_mode(kbd, VC_META);
1766                 break;
1767         case K_ESCPREFIX:
1768                 set_vc_kbd_mode(kbd, VC_META);
1769                 break;
1770         default:
1771                 ret = -EINVAL;
1772         }
1773         spin_unlock_irqrestore(&kbd_event_lock, flags);
1774         return ret;
1775 }
1776
1777 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
1778                                                                 int perm)
1779 {
1780         struct kbkeycode tmp;
1781         int kc = 0;
1782
1783         if (copy_from_user(&tmp, user_kbkc, sizeof(struct kbkeycode)))
1784                 return -EFAULT;
1785         switch (cmd) {
1786         case KDGETKEYCODE:
1787                 kc = getkeycode(tmp.scancode);
1788                 if (kc >= 0)
1789                         kc = put_user(kc, &user_kbkc->keycode);
1790                 break;
1791         case KDSETKEYCODE:
1792                 if (!perm)
1793                         return -EPERM;
1794                 kc = setkeycode(tmp.scancode, tmp.keycode);
1795                 break;
1796         }
1797         return kc;
1798 }
1799
1800 #define i (tmp.kb_index)
1801 #define s (tmp.kb_table)
1802 #define v (tmp.kb_value)
1803
1804 int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe, int perm,
1805                                                 int console)
1806 {
1807         struct kbd_struct * kbd = kbd_table + console;
1808         struct kbentry tmp;
1809         ushort *key_map, *new_map, val, ov;
1810         unsigned long flags;
1811
1812         if (copy_from_user(&tmp, user_kbe, sizeof(struct kbentry)))
1813                 return -EFAULT;
1814
1815         if (!capable(CAP_SYS_TTY_CONFIG))
1816                 perm = 0;
1817
1818         switch (cmd) {
1819         case KDGKBENT:
1820                 /* Ensure another thread doesn't free it under us */
1821                 spin_lock_irqsave(&kbd_event_lock, flags);
1822                 key_map = key_maps[s];
1823                 if (key_map) {
1824                     val = U(key_map[i]);
1825                     if (kbd->kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES)
1826                         val = K_HOLE;
1827                 } else
1828                     val = (i ? K_HOLE : K_NOSUCHMAP);
1829                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1830                 return put_user(val, &user_kbe->kb_value);
1831         case KDSKBENT:
1832                 if (!perm)
1833                         return -EPERM;
1834                 if (!i && v == K_NOSUCHMAP) {
1835                         spin_lock_irqsave(&kbd_event_lock, flags);
1836                         /* deallocate map */
1837                         key_map = key_maps[s];
1838                         if (s && key_map) {
1839                             key_maps[s] = NULL;
1840                             if (key_map[0] == U(K_ALLOCATED)) {
1841                                         kfree(key_map);
1842                                         keymap_count--;
1843                             }
1844                         }
1845                         spin_unlock_irqrestore(&kbd_event_lock, flags);
1846                         break;
1847                 }
1848
1849                 if (KTYP(v) < NR_TYPES) {
1850                     if (KVAL(v) > max_vals[KTYP(v)])
1851                                 return -EINVAL;
1852                 } else
1853                     if (kbd->kbdmode != VC_UNICODE)
1854                                 return -EINVAL;
1855
1856                 /* ++Geert: non-PC keyboards may generate keycode zero */
1857 #if !defined(__mc68000__) && !defined(__powerpc__)
1858                 /* assignment to entry 0 only tests validity of args */
1859                 if (!i)
1860                         break;
1861 #endif
1862
1863                 new_map = kmalloc(sizeof(plain_map), GFP_KERNEL);
1864                 if (!new_map)
1865                         return -ENOMEM;
1866                 spin_lock_irqsave(&kbd_event_lock, flags);
1867                 key_map = key_maps[s];
1868                 if (key_map == NULL) {
1869                         int j;
1870
1871                         if (keymap_count >= MAX_NR_OF_USER_KEYMAPS &&
1872                             !capable(CAP_SYS_RESOURCE)) {
1873                                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1874                                 kfree(new_map);
1875                                 return -EPERM;
1876                         }
1877                         key_maps[s] = new_map;
1878                         key_map = new_map;
1879                         key_map[0] = U(K_ALLOCATED);
1880                         for (j = 1; j < NR_KEYS; j++)
1881                                 key_map[j] = U(K_HOLE);
1882                         keymap_count++;
1883                 } else
1884                         kfree(new_map);
1885
1886                 ov = U(key_map[i]);
1887                 if (v == ov)
1888                         goto out;
1889                 /*
1890                  * Attention Key.
1891                  */
1892                 if (((ov == K_SAK) || (v == K_SAK)) && !capable(CAP_SYS_ADMIN)) {
1893                         spin_unlock_irqrestore(&kbd_event_lock, flags);
1894                         return -EPERM;
1895                 }
1896                 key_map[i] = U(v);
1897                 if (!s && (KTYP(ov) == KT_SHIFT || KTYP(v) == KT_SHIFT))
1898                         do_compute_shiftstate();
1899 out:
1900                 spin_unlock_irqrestore(&kbd_event_lock, flags);
1901                 break;
1902         }
1903         return 0;
1904 }
1905 #undef i
1906 #undef s
1907 #undef v
1908
1909 /* FIXME: This one needs untangling and locking */
1910 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm)
1911 {
1912         struct kbsentry *kbs;
1913         char *p;
1914         u_char *q;
1915         u_char __user *up;
1916         int sz;
1917         int delta;
1918         char *first_free, *fj, *fnw;
1919         int i, j, k;
1920         int ret;
1921
1922         if (!capable(CAP_SYS_TTY_CONFIG))
1923                 perm = 0;
1924
1925         kbs = kmalloc(sizeof(*kbs), GFP_KERNEL);
1926         if (!kbs) {
1927                 ret = -ENOMEM;
1928                 goto reterr;
1929         }
1930
1931         /* we mostly copy too much here (512bytes), but who cares ;) */
1932         if (copy_from_user(kbs, user_kdgkb, sizeof(struct kbsentry))) {
1933                 ret = -EFAULT;
1934                 goto reterr;
1935         }
1936         kbs->kb_string[sizeof(kbs->kb_string)-1] = '\0';
1937         i = kbs->kb_func;
1938
1939         switch (cmd) {
1940         case KDGKBSENT:
1941                 sz = sizeof(kbs->kb_string) - 1; /* sz should have been
1942                                                   a struct member */
1943                 up = user_kdgkb->kb_string;
1944                 p = func_table[i];
1945                 if(p)
1946                         for ( ; *p && sz; p++, sz--)
1947                                 if (put_user(*p, up++)) {
1948                                         ret = -EFAULT;
1949                                         goto reterr;
1950                                 }
1951                 if (put_user('\0', up)) {
1952                         ret = -EFAULT;
1953                         goto reterr;
1954                 }
1955                 kfree(kbs);
1956                 return ((p && *p) ? -EOVERFLOW : 0);
1957         case KDSKBSENT:
1958                 if (!perm) {
1959                         ret = -EPERM;
1960                         goto reterr;
1961                 }
1962
1963                 q = func_table[i];
1964                 first_free = funcbufptr + (funcbufsize - funcbufleft);
1965                 for (j = i+1; j < MAX_NR_FUNC && !func_table[j]; j++)
1966                         ;
1967                 if (j < MAX_NR_FUNC)
1968                         fj = func_table[j];
1969                 else
1970                         fj = first_free;
1971
1972                 delta = (q ? -strlen(q) : 1) + strlen(kbs->kb_string);
1973                 if (delta <= funcbufleft) {     /* it fits in current buf */
1974                     if (j < MAX_NR_FUNC) {
1975                         memmove(fj + delta, fj, first_free - fj);
1976                         for (k = j; k < MAX_NR_FUNC; k++)
1977                             if (func_table[k])
1978                                 func_table[k] += delta;
1979                     }
1980                     if (!q)
1981                       func_table[i] = fj;
1982                     funcbufleft -= delta;
1983                 } else {                        /* allocate a larger buffer */
1984                     sz = 256;
1985                     while (sz < funcbufsize - funcbufleft + delta)
1986                       sz <<= 1;
1987                     fnw = kmalloc(sz, GFP_KERNEL);
1988                     if(!fnw) {
1989                       ret = -ENOMEM;
1990                       goto reterr;
1991                     }
1992
1993                     if (!q)
1994                       func_table[i] = fj;
1995                     if (fj > funcbufptr)
1996                         memmove(fnw, funcbufptr, fj - funcbufptr);
1997                     for (k = 0; k < j; k++)
1998                       if (func_table[k])
1999                         func_table[k] = fnw + (func_table[k] - funcbufptr);
2000
2001                     if (first_free > fj) {
2002                         memmove(fnw + (fj - funcbufptr) + delta, fj, first_free - fj);
2003                         for (k = j; k < MAX_NR_FUNC; k++)
2004                           if (func_table[k])
2005                             func_table[k] = fnw + (func_table[k] - funcbufptr) + delta;
2006                     }
2007                     if (funcbufptr != func_buf)
2008                       kfree(funcbufptr);
2009                     funcbufptr = fnw;
2010                     funcbufleft = funcbufleft - delta + sz - funcbufsize;
2011                     funcbufsize = sz;
2012                 }
2013                 strcpy(func_table[i], kbs->kb_string);
2014                 break;
2015         }
2016         ret = 0;
2017 reterr:
2018         kfree(kbs);
2019         return ret;
2020 }
2021
2022 int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm)
2023 {
2024         struct kbd_struct * kbd = kbd_table + console;
2025         unsigned long flags;
2026         unsigned char ucval;
2027
2028         switch(cmd) {
2029         /* the ioctls below read/set the flags usually shown in the leds */
2030         /* don't use them - they will go away without warning */
2031         case KDGKBLED:
2032                 spin_lock_irqsave(&kbd_event_lock, flags);
2033                 ucval = kbd->ledflagstate | (kbd->default_ledflagstate << 4);
2034                 spin_unlock_irqrestore(&kbd_event_lock, flags);
2035                 return put_user(ucval, (char __user *)arg);
2036
2037         case KDSKBLED:
2038                 if (!perm)
2039                         return -EPERM;
2040                 if (arg & ~0x77)
2041                         return -EINVAL;
2042                 spin_lock_irqsave(&kbd_event_lock, flags);
2043                 kbd->ledflagstate = (arg & 7);
2044                 kbd->default_ledflagstate = ((arg >> 4) & 7);
2045                 set_leds();
2046                 spin_unlock_irqrestore(&kbd_event_lock, flags);
2047                 return 0;
2048
2049         /* the ioctls below only set the lights, not the functions */
2050         /* for those, see KDGKBLED and KDSKBLED above */
2051         case KDGETLED:
2052                 ucval = getledstate();
2053                 return put_user(ucval, (char __user *)arg);
2054
2055         case KDSETLED:
2056                 if (!perm)
2057                         return -EPERM;
2058                 setledstate(kbd, arg);
2059                 return 0;
2060         }
2061         return -ENOIOCTLCMD;
2062 }
2063
2064 int vt_do_kdgkbmode(int console)
2065 {
2066         struct kbd_struct * kbd = kbd_table + console;
2067         /* This is a spot read so needs no locking */
2068         switch (kbd->kbdmode) {
2069         case VC_RAW:
2070                 return K_RAW;
2071         case VC_MEDIUMRAW:
2072                 return K_MEDIUMRAW;
2073         case VC_UNICODE:
2074                 return K_UNICODE;
2075         case VC_OFF:
2076                 return K_OFF;
2077         default:
2078                 return K_XLATE;
2079         }
2080 }
2081
2082 /**
2083  *      vt_do_kdgkbmeta         -       report meta status
2084  *      @console: console to report
2085  *
2086  *      Report the meta flag status of this console
2087  */
2088 int vt_do_kdgkbmeta(int console)
2089 {
2090         struct kbd_struct * kbd = kbd_table + console;
2091         /* Again a spot read so no locking */
2092         return vc_kbd_mode(kbd, VC_META) ? K_ESCPREFIX : K_METABIT;
2093 }
2094
2095 /**
2096  *      vt_reset_unicode        -       reset the unicode status
2097  *      @console: console being reset
2098  *
2099  *      Restore the unicode console state to its default
2100  */
2101 void vt_reset_unicode(int console)
2102 {
2103         unsigned long flags;
2104
2105         spin_lock_irqsave(&kbd_event_lock, flags);
2106         kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
2107         spin_unlock_irqrestore(&kbd_event_lock, flags);
2108 }
2109
2110 /**
2111  *      vt_get_shiftstate       -       shift bit state
2112  *
2113  *      Report the shift bits from the keyboard state. We have to export
2114  *      this to support some oddities in the vt layer.
2115  */
2116 int vt_get_shift_state(void)
2117 {
2118         /* Don't lock as this is a transient report */
2119         return shift_state;
2120 }
2121
2122 /**
2123  *      vt_reset_keyboard       -       reset keyboard state
2124  *      @console: console to reset
2125  *
2126  *      Reset the keyboard bits for a console as part of a general console
2127  *      reset event
2128  */
2129 void vt_reset_keyboard(int console)
2130 {
2131         struct kbd_struct * kbd = kbd_table + console;
2132         unsigned long flags;
2133
2134         spin_lock_irqsave(&kbd_event_lock, flags);
2135         set_vc_kbd_mode(kbd, VC_REPEAT);
2136         clr_vc_kbd_mode(kbd, VC_CKMODE);
2137         clr_vc_kbd_mode(kbd, VC_APPLIC);
2138         clr_vc_kbd_mode(kbd, VC_CRLF);
2139         kbd->lockstate = 0;
2140         kbd->slockstate = 0;
2141         kbd->ledmode = LED_SHOW_FLAGS;
2142         kbd->ledflagstate = kbd->default_ledflagstate;
2143         /* do not do set_leds here because this causes an endless tasklet loop
2144            when the keyboard hasn't been initialized yet */
2145         spin_unlock_irqrestore(&kbd_event_lock, flags);
2146 }
2147
2148 /**
2149  *      vt_get_kbd_mode_bit     -       read keyboard status bits
2150  *      @console: console to read from
2151  *      @bit: mode bit to read
2152  *
2153  *      Report back a vt mode bit. We do this without locking so the
2154  *      caller must be sure that there are no synchronization needs
2155  */
2156
2157 int vt_get_kbd_mode_bit(int console, int bit)
2158 {
2159         struct kbd_struct * kbd = kbd_table + console;
2160         return vc_kbd_mode(kbd, bit);
2161 }
2162
2163 /**
2164  *      vt_set_kbd_mode_bit     -       read keyboard status bits
2165  *      @console: console to read from
2166  *      @bit: mode bit to read
2167  *
2168  *      Set a vt mode bit. We do this without locking so the
2169  *      caller must be sure that there are no synchronization needs
2170  */
2171
2172 void vt_set_kbd_mode_bit(int console, int bit)
2173 {
2174         struct kbd_struct * kbd = kbd_table + console;
2175         unsigned long flags;
2176
2177         spin_lock_irqsave(&kbd_event_lock, flags);
2178         set_vc_kbd_mode(kbd, bit);
2179         spin_unlock_irqrestore(&kbd_event_lock, flags);
2180 }
2181
2182 /**
2183  *      vt_clr_kbd_mode_bit     -       read keyboard status bits
2184  *      @console: console to read from
2185  *      @bit: mode bit to read
2186  *
2187  *      Report back a vt mode bit. We do this without locking so the
2188  *      caller must be sure that there are no synchronization needs
2189  */
2190
2191 void vt_clr_kbd_mode_bit(int console, int bit)
2192 {
2193         struct kbd_struct * kbd = kbd_table + console;
2194         unsigned long flags;
2195
2196         spin_lock_irqsave(&kbd_event_lock, flags);
2197         clr_vc_kbd_mode(kbd, bit);
2198         spin_unlock_irqrestore(&kbd_event_lock, flags);
2199 }