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