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