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