drivers/tty/vt/keyboard.c

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