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