drivers/tty/vt/keyboard.c

   1 /*
   2  * Written for linux by Johan Myreen as a translation from
   3  * the assembly version by Linus (with diacriticals added)
   4  *
   5  * Some additional features added by Christoph Niemann (ChN), March 1993
   6  *
   7  * Loadable keymaps by Risto Kankkunen, May 1993
   8  *
   9  * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
  10  * Added decr/incr_console, dynamic keymaps, Unicode support,
  11  * dynamic function/string keys, led setting,  Sept 1994
  12  * `Sticky' modifier keys, 951006.
  13  *
  14  * 11-11-96: SAK should now work in the raw mode (Martin Mares)
  15  *
  16  * Modified to provide 'generic' keyboard support by Hamish Macdonald
  17  * Merge with the m68k keyboard driver and split-off of the PC low-level
  18  * parts by Geert Uytterhoeven, May 1997
  19  *
  20  * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
  21  * 30-07-98: Dead keys redone, aeb@cwi.nl.
  22  * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
  23  */
  24
  25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  26
  27 #include <linux/consolemap.h>
  28 #include <linux/module.h>
  29 #include <linux/sched.h>
  30 #include <linux/tty.h>
  31 #include <linux/tty_flip.h>
  32 #include <linux/mm.h>
  33 #include <linux/string.h>
  34 #include <linux/init.h>
  35 #include <linux/slab.h>
  36
  37 #include <linux/kbd_kern.h>
  38 #include <linux/kbd_diacr.h>
  39 #include <linux/vt_kern.h>
  40 #include <linux/input.h>
  41 #include <linux/reboot.h>
  42 #include <linux/notifier.h>
  43 #include <linux/jiffies.h>
  44
  45 #include <asm/irq_regs.h>
  46
  47 extern void ctrl_alt_del(void);
  48
  49 /*
  50  * Exported functions/variables
  51  */
  52
  53 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
  54
  55 /*
  56  * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
  57  * This seems a good reason to start with NumLock off. On HIL keyboards
  58  * of PARISC machines however there is no NumLock key and everyone expects the keypad
  59  * to be used for numbers.
  60  */
  61
  62 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
  63 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
  64 #else
  65 #define KBD_DEFLEDS 0
  66 #endif
  67
  68 #define KBD_DEFLOCK 0
  69
  70 void compute_shiftstate(void);
  71
  72 /*
  73  * Handler Tables.
  74  */
  75
  76 #define K_HANDLERS\
  77         k_self,         k_fn,           k_spec,         k_pad,\
  78         k_dead,         k_cons,         k_cur,          k_shift,\
  79         k_meta,         k_ascii,        k_lock,         k_lowercase,\
  80         k_slock,        k_dead2,        k_brl,          k_ignore
  81
  82 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
  83                             char up_flag);
  84 static k_handler_fn K_HANDLERS;
  85 static k_handler_fn *k_handler[16] = { K_HANDLERS };
  86
  87 #define FN_HANDLERS\
  88         fn_null,        fn_enter,       fn_show_ptregs, fn_show_mem,\
  89         fn_show_state,  fn_send_intr,   fn_lastcons,    fn_caps_toggle,\
  90         fn_num,         fn_hold,        fn_scroll_forw, fn_scroll_back,\
  91         fn_boot_it,     fn_caps_on,     fn_compose,     fn_SAK,\
  92         fn_dec_console, fn_inc_console, fn_spawn_con,   fn_bare_num
  93
  94 typedef void (fn_handler_fn)(struct vc_data *vc);
  95 static fn_handler_fn FN_HANDLERS;
  96 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
  97
  98 /*
  99  * Variables exported for vt_ioctl.c
 100  */
 101
 102 /* maximum values each key_handler can handle */
 103 const int max_vals[] = {
 104         255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
 105         NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
 106         255, NR_LOCK - 1, 255, NR_BRL - 1
 107 };
 108
 109 const int NR_TYPES = ARRAY_SIZE(max_vals);
 110
 111 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
 112 EXPORT_SYMBOL_GPL(kbd_table);
 113 static struct kbd_struct *kbd = kbd_table;
 114
 115 struct vt_spawn_console vt_spawn_con = {
 116         .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
 117         .pid  = NULL,
 118         .sig  = 0,
 119 };
 120
 121 /*
 122  * Variables exported for vt.c
 123  */
 124
 125 int shift_state = 0;
 126
 127 /*
 128  * Internal Data.
 129  */
 130
 131 static struct input_handler kbd_handler;
 132 static DEFINE_SPINLOCK(kbd_event_lock);
 133 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)];  /* keyboard key bitmap */
 134 static unsigned char shift_down[NR_SHIFT];              /* shift state counters.. */
 135 static bool dead_key_next;
 136 static int npadch = -1;                                 /* -1 or number assembled on pad */
 137 static unsigned int diacr;
 138 static char rep;                                        /* flag telling character repeat */
 139
 140 static unsigned char ledstate = 0xff;                   /* undefined */
 141 static unsigned char ledioctl;
 142
 143 static struct ledptr {
 144         unsigned int *addr;
 145         unsigned int mask;
 146         unsigned char valid:1;
 147 } ledptrs[3];
 148
 149 /*
 150  * Notifier list for console keyboard events
 151  */
 152 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
 153
 154 int register_keyboard_notifier(struct notifier_block *nb)
 155 {
 156         return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
 157 }
 158 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
 159
 160 int unregister_keyboard_notifier(struct notifier_block *nb)
 161 {
 162         return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
 163 }
 164 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
 165
 166 /*
 167  * Translation of scancodes to keycodes. We set them on only the first
 168  * keyboard in the list that accepts the scancode and keycode.
 169  * Explanation for not choosing the first attached keyboard anymore:
 170  *  USB keyboards for example have two event devices: one for all "normal"
 171  *  keys and one for extra function keys (like "volume up", "make coffee",
 172  *  etc.). So this means that scancodes for the extra function keys won't
 173  *  be valid for the first event device, but will be for the second.
 174  */
 175
 176 struct getset_keycode_data {
 177         struct input_keymap_entry ke;
 178         int error;
 179 };
 180
 181 static int getkeycode_helper(struct input_handle *handle, void *data)
 182 {
 183         struct getset_keycode_data *d = data;
 184
 185         d->error = input_get_keycode(handle->dev, &d->ke);
 186
 187         return d->error == 0; /* stop as soon as we successfully get one */
 188 }
 189
 190 int getkeycode(unsigned int scancode)
 191 {
 192         struct getset_keycode_data d = {
 193                 .ke     = {
 194                         .flags          = 0,
 195                         .len            = sizeof(scancode),
 196                         .keycode        = 0,
 197                 },
 198                 .error  = -ENODEV,
 199         };
 200
 201         memcpy(d.ke.scancode, &scancode, sizeof(scancode));
 202
 203         input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
 204
 205         return d.error ?: d.ke.keycode;
 206 }
 207
 208 static int setkeycode_helper(struct input_handle *handle, void *data)
 209 {
 210         struct getset_keycode_data *d = data;
 211
 212         d->error = input_set_keycode(handle->dev, &d->ke);
 213
 214         return d->error == 0; /* stop as soon as we successfully set one */
 215 }
 216
 217 int setkeycode(unsigned int scancode, unsigned int keycode)
 218 {
 219         struct getset_keycode_data d = {
 220                 .ke     = {
 221                         .flags          = 0,
 222                         .len            = sizeof(scancode),
 223                         .keycode        = keycode,
 224                 },
 225                 .error  = -ENODEV,
 226         };
 227
 228         memcpy(d.ke.scancode, &scancode, sizeof(scancode));
 229
 230         input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
 231
 232         return d.error;
 233 }
 234
 235 /*
 236  * Making beeps and bells. Note that we prefer beeps to bells, but when
 237  * shutting the sound off we do both.
 238  */
 239
 240 static int kd_sound_helper(struct input_handle *handle, void *data)
 241 {
 242         unsigned int *hz = data;
 243         struct input_dev *dev = handle->dev;
 244
 245         if (test_bit(EV_SND, dev->evbit)) {
 246                 if (test_bit(SND_TONE, dev->sndbit)) {
 247                         input_inject_event(handle, EV_SND, SND_TONE, *hz);
 248                         if (*hz)
 249                                 return 0;
 250                 }
 251                 if (test_bit(SND_BELL, dev->sndbit))
 252                         input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
 253         }
 254
 255         return 0;
 256 }
 257
 258 static void kd_nosound(unsigned long ignored)
 259 {
 260         static unsigned int zero;
 261
 262         input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
 263 }
 264
 265 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
 266
 267 void kd_mksound(unsigned int hz, unsigned int ticks)
 268 {
 269         del_timer_sync(&kd_mksound_timer);
 270
 271         input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
 272
 273         if (hz && ticks)
 274                 mod_timer(&kd_mksound_timer, jiffies + ticks);
 275 }
 276 EXPORT_SYMBOL(kd_mksound);
 277
 278 /*
 279  * Setting the keyboard rate.
 280  */
 281
 282 static int kbd_rate_helper(struct input_handle *handle, void *data)
 283 {
 284         struct input_dev *dev = handle->dev;
 285         struct kbd_repeat *rep = data;
 286
 287         if (test_bit(EV_REP, dev->evbit)) {
 288
 289                 if (rep[0].delay > 0)
 290                         input_inject_event(handle,
 291                                            EV_REP, REP_DELAY, rep[0].delay);
 292                 if (rep[0].period > 0)
 293                         input_inject_event(handle,
 294                                            EV_REP, REP_PERIOD, rep[0].period);
 295
 296                 rep[1].delay = dev->rep[REP_DELAY];
 297                 rep[1].period = dev->rep[REP_PERIOD];
 298         }
 299
 300         return 0;
 301 }
 302
 303 int kbd_rate(struct kbd_repeat *rep)
 304 {
 305         struct kbd_repeat data[2] = { *rep };
 306
 307         input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
 308         *rep = data[1]; /* Copy currently used settings */
 309
 310         return 0;
 311 }
 312
 313 /*
 314  * Helper Functions.
 315  */
 316 static void put_queue(struct vc_data *vc, int ch)
 317 {
 318         struct tty_struct *tty = vc->port.tty;
 319
 320         if (tty) {
 321                 tty_insert_flip_char(tty, ch, 0);
 322                 con_schedule_flip(tty);
 323         }
 324 }
 325
 326 static void puts_queue(struct vc_data *vc, char *cp)
 327 {
 328         struct tty_struct *tty = vc->port.tty;
 329
 330         if (!tty)
 331                 return;
 332
 333         while (*cp) {
 334                 tty_insert_flip_char(tty, *cp, 0);
 335                 cp++;
 336         }
 337         con_schedule_flip(tty);
 338 }
 339
 340 static void applkey(struct vc_data *vc, int key, char mode)
 341 {
 342         static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
 343
 344         buf[1] = (mode ? 'O' : '[');
 345         buf[2] = key;
 346         puts_queue(vc, buf);
 347 }
 348
 349 /*
 350  * Many other routines do put_queue, but I think either
 351  * they produce ASCII, or they produce some user-assigned
 352  * string, and in both cases we might assume that it is
 353  * in utf-8 already.
 354  */
 355 static void to_utf8(struct vc_data *vc, uint c)
 356 {
 357         if (c < 0x80)
 358                 /*  0******* */
 359                 put_queue(vc, c);
 360         else if (c < 0x800) {
 361                 /* 110***** 10****** */
 362                 put_queue(vc, 0xc0 | (c >> 6));
 363                 put_queue(vc, 0x80 | (c & 0x3f));
 364         } else if (c < 0x10000) {
 365                 if (c >= 0xD800 && c < 0xE000)
 366                         return;
 367                 if (c == 0xFFFF)
 368                         return;
 369                 /* 1110**** 10****** 10****** */
 370                 put_queue(vc, 0xe0 | (c >> 12));
 371                 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
 372                 put_queue(vc, 0x80 | (c & 0x3f));
 373         } else if (c < 0x110000) {
 374                 /* 11110*** 10****** 10****** 10****** */
 375                 put_queue(vc, 0xf0 | (c >> 18));
 376                 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
 377                 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
 378                 put_queue(vc, 0x80 | (c & 0x3f));
 379         }
 380 }
 381
 382 /*
 383  * Called after returning from RAW mode or when changing consoles - recompute
 384  * shift_down[] and shift_state from key_down[] maybe called when keymap is
 385  * undefined, so that shiftkey release is seen
 386  */
 387 void compute_shiftstate(void)
 388 {
 389         unsigned int k, sym, val;
 390
 391         shift_state = 0;
 392         memset(shift_down, 0, sizeof(shift_down));
 393
 394         for_each_set_bit(k, key_down, min(NR_KEYS, KEY_CNT)) {
 395                 sym = U(key_maps[0][k]);
 396                 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
 397                         continue;
 398
 399                 val = KVAL(sym);
 400                 if (val == KVAL(K_CAPSSHIFT))
 401                         val = KVAL(K_SHIFT);
 402
 403                 shift_down[val]++;
 404                 shift_state |= BIT(val);
 405         }
 406 }
 407
 408 /*
 409  * We have a combining character DIACR here, followed by the character CH.
 410  * If the combination occurs in the table, return the corresponding value.
 411  * Otherwise, if CH is a space or equals DIACR, return DIACR.
 412  * Otherwise, conclude that DIACR was not combining after all,
 413  * queue it and return CH.
 414  */
 415 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
 416 {
 417         unsigned int d = diacr;
 418         unsigned int i;
 419
 420         diacr = 0;
 421
 422         if ((d & ~0xff) == BRL_UC_ROW) {
 423                 if ((ch & ~0xff) == BRL_UC_ROW)
 424                         return d | ch;
 425         } else {
 426                 for (i = 0; i < accent_table_size; i++)
 427                         if (accent_table[i].diacr == d && accent_table[i].base == ch)
 428                                 return accent_table[i].result;
 429         }
 430
 431         if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
 432                 return d;
 433
 434         if (kbd->kbdmode == VC_UNICODE)
 435                 to_utf8(vc, d);
 436         else {
 437                 int c = conv_uni_to_8bit(d);
 438                 if (c != -1)
 439                         put_queue(vc, c);
 440         }
 441
 442         return ch;
 443 }
 444
 445 /*
 446  * Special function handlers
 447  */
 448 static void fn_enter(struct vc_data *vc)
 449 {
 450         if (diacr) {
 451                 if (kbd->kbdmode == VC_UNICODE)
 452                         to_utf8(vc, diacr);
 453                 else {
 454                         int c = conv_uni_to_8bit(diacr);
 455                         if (c != -1)
 456                                 put_queue(vc, c);
 457                 }
 458                 diacr = 0;
 459         }
 460
 461         put_queue(vc, 13);
 462         if (vc_kbd_mode(kbd, VC_CRLF))
 463                 put_queue(vc, 10);
 464 }
 465
 466 static void fn_caps_toggle(struct vc_data *vc)
 467 {
 468         if (rep)
 469                 return;
 470
 471         chg_vc_kbd_led(kbd, VC_CAPSLOCK);
 472 }
 473
 474 static void fn_caps_on(struct vc_data *vc)
 475 {
 476         if (rep)
 477                 return;
 478
 479         set_vc_kbd_led(kbd, VC_CAPSLOCK);
 480 }
 481
 482 static void fn_show_ptregs(struct vc_data *vc)
 483 {
 484         struct pt_regs *regs = get_irq_regs();
 485
 486         if (regs)
 487                 show_regs(regs);
 488 }
 489
 490 static void fn_hold(struct vc_data *vc)
 491 {
 492         struct tty_struct *tty = vc->port.tty;
 493
 494         if (rep || !tty)
 495                 return;
 496
 497         /*
 498          * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
 499          * these routines are also activated by ^S/^Q.
 500          * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
 501          */
 502         if (tty->stopped)
 503                 start_tty(tty);
 504         else
 505                 stop_tty(tty);
 506 }
 507
 508 static void fn_num(struct vc_data *vc)
 509 {
 510         if (vc_kbd_mode(kbd, VC_APPLIC))
 511                 applkey(vc, 'P', 1);
 512         else
 513                 fn_bare_num(vc);
 514 }
 515
 516 /*
 517  * Bind this to Shift-NumLock if you work in application keypad mode
 518  * but want to be able to change the NumLock flag.
 519  * Bind this to NumLock if you prefer that the NumLock key always
 520  * changes the NumLock flag.
 521  */
 522 static void fn_bare_num(struct vc_data *vc)
 523 {
 524         if (!rep)
 525                 chg_vc_kbd_led(kbd, VC_NUMLOCK);
 526 }
 527
 528 static void fn_lastcons(struct vc_data *vc)
 529 {
 530         /* switch to the last used console, ChN */
 531         set_console(last_console);
 532 }
 533
 534 static void fn_dec_console(struct vc_data *vc)
 535 {
 536         int i, cur = fg_console;
 537
 538         /* Currently switching?  Queue this next switch relative to that. */
 539         if (want_console != -1)
 540                 cur = want_console;
 541
 542         for (i = cur - 1; i != cur; i--) {
 543                 if (i == -1)
 544                         i = MAX_NR_CONSOLES - 1;
 545                 if (vc_cons_allocated(i))
 546                         break;
 547         }
 548         set_console(i);
 549 }
 550
 551 static void fn_inc_console(struct vc_data *vc)
 552 {
 553         int i, cur = fg_console;
 554
 555         /* Currently switching?  Queue this next switch relative to that. */
 556         if (want_console != -1)
 557                 cur = want_console;
 558
 559         for (i = cur+1; i != cur; i++) {
 560                 if (i == MAX_NR_CONSOLES)
 561                         i = 0;
 562                 if (vc_cons_allocated(i))
 563                         break;
 564         }
 565         set_console(i);
 566 }
 567
 568 static void fn_send_intr(struct vc_data *vc)
 569 {
 570         struct tty_struct *tty = vc->port.tty;
 571
 572         if (!tty)
 573                 return;
 574         tty_insert_flip_char(tty, 0, TTY_BREAK);
 575         con_schedule_flip(tty);
 576 }
 577
 578 static void fn_scroll_forw(struct vc_data *vc)
 579 {
 580         scrollfront(vc, 0);
 581 }
 582
 583 static void fn_scroll_back(struct vc_data *vc)
 584 {
 585         scrollback(vc, 0);
 586 }
 587
 588 static void fn_show_mem(struct vc_data *vc)
 589 {
 590         show_mem(0);
 591 }
 592
 593 static void fn_show_state(struct vc_data *vc)
 594 {
 595         show_state();
 596 }
 597
 598 static void fn_boot_it(struct vc_data *vc)
 599 {
 600         ctrl_alt_del();
 601 }
 602
 603 static void fn_compose(struct vc_data *vc)
 604 {
 605         dead_key_next = true;
 606 }
 607
 608 static void fn_spawn_con(struct vc_data *vc)
 609 {
 610         spin_lock(&vt_spawn_con.lock);
 611         if (vt_spawn_con.pid)
 612                 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
 613                         put_pid(vt_spawn_con.pid);
 614                         vt_spawn_con.pid = NULL;
 615                 }
 616         spin_unlock(&vt_spawn_con.lock);
 617 }
 618
 619 static void fn_SAK(struct vc_data *vc)
 620 {
 621         struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
 622         schedule_work(SAK_work);
 623 }
 624
 625 static void fn_null(struct vc_data *vc)
 626 {
 627         compute_shiftstate();
 628 }
 629
 630 /*
 631  * Special key handlers
 632  */
 633 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
 634 {
 635 }
 636
 637 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
 638 {
 639         if (up_flag)
 640                 return;
 641         if (value >= ARRAY_SIZE(fn_handler))
 642                 return;
 643         if ((kbd->kbdmode == VC_RAW ||
 644              kbd->kbdmode == VC_MEDIUMRAW ||
 645              kbd->kbdmode == VC_OFF) &&
 646              value != KVAL(K_SAK))
 647                 return;         /* SAK is allowed even in raw mode */
 648         fn_handler[value](vc);
 649 }
 650
 651 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
 652 {
 653         pr_err("k_lowercase was called - impossible\n");
 654 }
 655
 656 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
 657 {
 658         if (up_flag)
 659                 return;         /* no action, if this is a key release */
 660
 661         if (diacr)
 662                 value = handle_diacr(vc, value);
 663
 664         if (dead_key_next) {
 665                 dead_key_next = false;
 666                 diacr = value;
 667                 return;
 668         }
 669         if (kbd->kbdmode == VC_UNICODE)
 670                 to_utf8(vc, value);
 671         else {
 672                 int c = conv_uni_to_8bit(value);
 673                 if (c != -1)
 674                         put_queue(vc, c);
 675         }
 676 }
 677
 678 /*
 679  * Handle dead key. Note that we now may have several
 680  * dead keys modifying the same character. Very useful
 681  * for Vietnamese.
 682  */
 683 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
 684 {
 685         if (up_flag)
 686                 return;
 687
 688         diacr = (diacr ? handle_diacr(vc, value) : value);
 689 }
 690
 691 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
 692 {
 693         k_unicode(vc, conv_8bit_to_uni(value), up_flag);
 694 }
 695
 696 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
 697 {
 698         k_deadunicode(vc, value, up_flag);
 699 }
 700
 701 /*
 702  * Obsolete - for backwards compatibility only
 703  */
 704 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
 705 {
 706         static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
 707
 708         k_deadunicode(vc, ret_diacr[value], up_flag);
 709 }
 710
 711 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
 712 {
 713         if (up_flag)
 714                 return;
 715
 716         set_console(value);
 717 }
 718
 719 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
 720 {
 721         if (up_flag)
 722                 return;
 723
 724         if ((unsigned)value < ARRAY_SIZE(func_table)) {
 725                 if (func_table[value])
 726                         puts_queue(vc, func_table[value]);
 727         } else
 728                 pr_err("k_fn called with value=%d\n", value);
 729 }
 730
 731 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
 732 {
 733         static const char cur_chars[] = "BDCA";
 734
 735         if (up_flag)
 736                 return;
 737
 738         applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
 739 }
 740
 741 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
 742 {
 743         static const char pad_chars[] = "0123456789+-*/\015,.?()#";
 744         static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
 745
 746         if (up_flag)
 747                 return;         /* no action, if this is a key release */
 748
 749         /* kludge... shift forces cursor/number keys */
 750         if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
 751                 applkey(vc, app_map[value], 1);
 752                 return;
 753         }
 754
 755         if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
 756
 757                 switch (value) {
 758                 case KVAL(K_PCOMMA):
 759                 case KVAL(K_PDOT):
 760                         k_fn(vc, KVAL(K_REMOVE), 0);
 761                         return;
 762                 case KVAL(K_P0):
 763                         k_fn(vc, KVAL(K_INSERT), 0);
 764                         return;
 765                 case KVAL(K_P1):
 766                         k_fn(vc, KVAL(K_SELECT), 0);
 767                         return;
 768                 case KVAL(K_P2):
 769                         k_cur(vc, KVAL(K_DOWN), 0);
 770                         return;
 771                 case KVAL(K_P3):
 772                         k_fn(vc, KVAL(K_PGDN), 0);
 773                         return;
 774                 case KVAL(K_P4):
 775                         k_cur(vc, KVAL(K_LEFT), 0);
 776                         return;
 777                 case KVAL(K_P6):
 778                         k_cur(vc, KVAL(K_RIGHT), 0);
 779                         return;
 780                 case KVAL(K_P7):
 781                         k_fn(vc, KVAL(K_FIND), 0);
 782                         return;
 783                 case KVAL(K_P8):
 784                         k_cur(vc, KVAL(K_UP), 0);
 785                         return;
 786                 case KVAL(K_P9):
 787                         k_fn(vc, KVAL(K_PGUP), 0);
 788                         return;
 789                 case KVAL(K_P5):
 790                         applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
 791                         return;
 792                 }
 793         }
 794
 795         put_queue(vc, pad_chars[value]);
 796         if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
 797                 put_queue(vc, 10);
 798 }
 799
 800 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
 801 {
 802         int old_state = shift_state;
 803
 804         if (rep)
 805                 return;
 806         /*
 807          * Mimic typewriter:
 808          * a CapsShift key acts like Shift but undoes CapsLock
 809          */
 810         if (value == KVAL(K_CAPSSHIFT)) {
 811                 value = KVAL(K_SHIFT);
 812                 if (!up_flag)
 813                         clr_vc_kbd_led(kbd, VC_CAPSLOCK);
 814         }
 815
 816         if (up_flag) {
 817                 /*
 818                  * handle the case that two shift or control
 819                  * keys are depressed simultaneously
 820                  */
 821                 if (shift_down[value])
 822                         shift_down[value]--;
 823         } else
 824                 shift_down[value]++;
 825
 826         if (shift_down[value])
 827                 shift_state |= (1 << value);
 828         else
 829                 shift_state &= ~(1 << value);
 830
 831         /* kludge */
 832         if (up_flag && shift_state != old_state && npadch != -1) {
 833                 if (kbd->kbdmode == VC_UNICODE)
 834                         to_utf8(vc, npadch);
 835                 else
 836                         put_queue(vc, npadch & 0xff);
 837                 npadch = -1;
 838         }
 839 }
 840
 841 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
 842 {
 843         if (up_flag)
 844                 return;
 845
 846         if (vc_kbd_mode(kbd, VC_META)) {
 847                 put_queue(vc, '\033');
 848                 put_queue(vc, value);
 849         } else
 850                 put_queue(vc, value | 0x80);
 851 }
 852
 853 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
 854 {
 855         int base;
 856
 857         if (up_flag)
 858                 return;
 859
 860         if (value < 10) {
 861                 /* decimal input of code, while Alt depressed */
 862                 base = 10;
 863         } else {
 864                 /* hexadecimal input of code, while AltGr depressed */
 865                 value -= 10;
 866                 base = 16;
 867         }
 868
 869         if (npadch == -1)
 870                 npadch = value;
 871         else
 872                 npadch = npadch * base + value;
 873 }
 874
 875 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
 876 {
 877         if (up_flag || rep)
 878                 return;
 879
 880         chg_vc_kbd_lock(kbd, value);
 881 }
 882
 883 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
 884 {
 885         k_shift(vc, value, up_flag);
 886         if (up_flag || rep)
 887                 return;
 888
 889         chg_vc_kbd_slock(kbd, value);
 890         /* try to make Alt, oops, AltGr and such work */
 891         if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
 892                 kbd->slockstate = 0;
 893                 chg_vc_kbd_slock(kbd, value);
 894         }
 895 }
 896
 897 /* by default, 300ms interval for combination release */
 898 static unsigned brl_timeout = 300;
 899 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
 900 module_param(brl_timeout, uint, 0644);
 901
 902 static unsigned brl_nbchords = 1;
 903 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
 904 module_param(brl_nbchords, uint, 0644);
 905
 906 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
 907 {
 908         static unsigned long chords;
 909         static unsigned committed;
 910
 911         if (!brl_nbchords)
 912                 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
 913         else {
 914                 committed |= pattern;
 915                 chords++;
 916                 if (chords == brl_nbchords) {
 917                         k_unicode(vc, BRL_UC_ROW | committed, up_flag);
 918                         chords = 0;
 919                         committed = 0;
 920                 }
 921         }
 922 }
 923
 924 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
 925 {
 926         static unsigned pressed, committing;
 927         static unsigned long releasestart;
 928
 929         if (kbd->kbdmode != VC_UNICODE) {
 930                 if (!up_flag)
 931                         pr_warning("keyboard mode must be unicode for braille patterns\n");
 932                 return;
 933         }
 934
 935         if (!value) {
 936                 k_unicode(vc, BRL_UC_ROW, up_flag);
 937                 return;
 938         }
 939
 940         if (value > 8)
 941                 return;
 942
 943         if (!up_flag) {
 944                 pressed |= 1 << (value - 1);
 945                 if (!brl_timeout)
 946                         committing = pressed;
 947         } else if (brl_timeout) {
 948                 if (!committing ||
 949                     time_after(jiffies,
 950                                releasestart + msecs_to_jiffies(brl_timeout))) {
 951                         committing = pressed;
 952                         releasestart = jiffies;
 953                 }
 954                 pressed &= ~(1 << (value - 1));
 955                 if (!pressed && committing) {
 956                         k_brlcommit(vc, committing, 0);
 957                         committing = 0;
 958                 }
 959         } else {
 960                 if (committing) {
 961                         k_brlcommit(vc, committing, 0);
 962                         committing = 0;
 963                 }
 964                 pressed &= ~(1 << (value - 1));
 965         }
 966 }
 967
 968 /*
 969  * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
 970  * or (ii) whatever pattern of lights people want to show using KDSETLED,
 971  * or (iii) specified bits of specified words in kernel memory.
 972  */
 973 unsigned char getledstate(void)
 974 {
 975         return ledstate;
 976 }
 977
 978 void setledstate(struct kbd_struct *kbd, unsigned int led)
 979 {
 980         if (!(led & ~7)) {
 981                 ledioctl = led;
 982                 kbd->ledmode = LED_SHOW_IOCTL;
 983         } else
 984                 kbd->ledmode = LED_SHOW_FLAGS;
 985
 986         set_leds();
 987 }
 988
 989 static inline unsigned char getleds(void)
 990 {
 991         struct kbd_struct *kbd = kbd_table + fg_console;
 992         unsigned char leds;
 993         int i;
 994
 995         if (kbd->ledmode == LED_SHOW_IOCTL)
 996                 return ledioctl;
 997
 998         leds = kbd->ledflagstate;
 999
1000         if (kbd->ledmode == LED_SHOW_MEM) {
1001                 for (i = 0; i < 3; i++)
1002                         if (ledptrs[i].valid) {
1003                                 if (*ledptrs[i].addr & ledptrs[i].mask)
1004                                         leds |= (1 << i);
1005                                 else
1006                                         leds &= ~(1 << i);
1007                         }
1008         }
1009         return leds;
1010 }
1011
1012 static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1013 {
1014         unsigned char leds = *(unsigned char *)data;
1015
1016         if (test_bit(EV_LED, handle->dev->evbit)) {
1017                 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1018                 input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & 0x02));
1019                 input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1020                 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1021         }
1022
1023         return 0;
1024 }
1025
1026 /*
1027  * This is the tasklet that updates LED state on all keyboards
1028  * attached to the box. The reason we use tasklet is that we
1029  * need to handle the scenario when keyboard handler is not
1030  * registered yet but we already getting updates form VT to
1031  * update led state.
1032  */
1033 static void kbd_bh(unsigned long dummy)
1034 {
1035         unsigned char leds = getleds();
1036
1037         if (leds != ledstate) {
1038                 input_handler_for_each_handle(&kbd_handler, &leds,
1039                                               kbd_update_leds_helper);
1040                 ledstate = leds;
1041         }
1042 }
1043
1044 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1045
1046 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1047     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1048     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1049     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1050     defined(CONFIG_AVR32)
1051
1052 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1053                         ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1054
1055 static const unsigned short x86_keycodes[256] =
1056         { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1057          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1058          32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1059          48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1060          64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1061          80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1062         284,285,309,  0,312, 91,327,328,329,331,333,335,336,337,338,339,
1063         367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1064         360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1065         103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1066         291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1067         264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1068         377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1069         308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1070         332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1071
1072 #ifdef CONFIG_SPARC
1073 static int sparc_l1_a_state;
1074 extern void sun_do_break(void);
1075 #endif
1076
1077 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1078                        unsigned char up_flag)
1079 {
1080         int code;
1081
1082         switch (keycode) {
1083
1084         case KEY_PAUSE:
1085                 put_queue(vc, 0xe1);
1086                 put_queue(vc, 0x1d | up_flag);
1087                 put_queue(vc, 0x45 | up_flag);
1088                 break;
1089
1090         case KEY_HANGEUL:
1091                 if (!up_flag)
1092                         put_queue(vc, 0xf2);
1093                 break;
1094
1095         case KEY_HANJA:
1096                 if (!up_flag)
1097                         put_queue(vc, 0xf1);
1098                 break;
1099
1100         case KEY_SYSRQ:
1101                 /*
1102                  * Real AT keyboards (that's what we're trying
1103                  * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1104                  * pressing PrtSc/SysRq alone, but simply 0x54
1105                  * when pressing Alt+PrtSc/SysRq.
1106                  */
1107                 if (test_bit(KEY_LEFTALT, key_down) ||
1108                     test_bit(KEY_RIGHTALT, key_down)) {
1109                         put_queue(vc, 0x54 | up_flag);
1110                 } else {
1111                         put_queue(vc, 0xe0);
1112                         put_queue(vc, 0x2a | up_flag);
1113                         put_queue(vc, 0xe0);
1114                         put_queue(vc, 0x37 | up_flag);
1115                 }
1116                 break;
1117
1118         default:
1119                 if (keycode > 255)
1120                         return -1;
1121
1122                 code = x86_keycodes[keycode];
1123                 if (!code)
1124                         return -1;
1125
1126                 if (code & 0x100)
1127                         put_queue(vc, 0xe0);
1128                 put_queue(vc, (code & 0x7f) | up_flag);
1129
1130                 break;
1131         }
1132
1133         return 0;
1134 }
1135
1136 #else
1137
1138 #define HW_RAW(dev)     0
1139
1140 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1141 {
1142         if (keycode > 127)
1143                 return -1;
1144
1145         put_queue(vc, keycode | up_flag);
1146         return 0;
1147 }
1148 #endif
1149
1150 static void kbd_rawcode(unsigned char data)
1151 {
1152         struct vc_data *vc = vc_cons[fg_console].d;
1153
1154         kbd = kbd_table + vc->vc_num;
1155         if (kbd->kbdmode == VC_RAW)
1156                 put_queue(vc, data);
1157 }
1158
1159 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1160 {
1161         struct vc_data *vc = vc_cons[fg_console].d;
1162         unsigned short keysym, *key_map;
1163         unsigned char type;
1164         bool raw_mode;
1165         struct tty_struct *tty;
1166         int shift_final;
1167         struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1168         int rc;
1169
1170         tty = vc->port.tty;
1171
1172         if (tty && (!tty->driver_data)) {
1173                 /* No driver data? Strange. Okay we fix it then. */
1174                 tty->driver_data = vc;
1175         }
1176
1177         kbd = kbd_table + vc->vc_num;
1178
1179 #ifdef CONFIG_SPARC
1180         if (keycode == KEY_STOP)
1181                 sparc_l1_a_state = down;
1182 #endif
1183
1184         rep = (down == 2);
1185
1186         raw_mode = (kbd->kbdmode == VC_RAW);
1187         if (raw_mode && !hw_raw)
1188                 if (emulate_raw(vc, keycode, !down << 7))
1189                         if (keycode < BTN_MISC && printk_ratelimit())
1190                                 pr_warning("can't emulate rawmode for keycode %d\n",
1191                                            keycode);
1192
1193 #ifdef CONFIG_SPARC
1194         if (keycode == KEY_A && sparc_l1_a_state) {
1195                 sparc_l1_a_state = false;
1196                 sun_do_break();
1197         }
1198 #endif
1199
1200         if (kbd->kbdmode == VC_MEDIUMRAW) {
1201                 /*
1202                  * This is extended medium raw mode, with keys above 127
1203                  * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1204                  * the 'up' flag if needed. 0 is reserved, so this shouldn't
1205                  * interfere with anything else. The two bytes after 0 will
1206                  * always have the up flag set not to interfere with older
1207                  * applications. This allows for 16384 different keycodes,
1208                  * which should be enough.
1209                  */
1210                 if (keycode < 128) {
1211                         put_queue(vc, keycode | (!down << 7));
1212                 } else {
1213                         put_queue(vc, !down << 7);
1214                         put_queue(vc, (keycode >> 7) | 0x80);
1215                         put_queue(vc, keycode | 0x80);
1216                 }
1217                 raw_mode = true;
1218         }
1219
1220         if (down)
1221                 set_bit(keycode, key_down);
1222         else
1223                 clear_bit(keycode, key_down);
1224
1225         if (rep &&
1226             (!vc_kbd_mode(kbd, VC_REPEAT) ||
1227              (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1228                 /*
1229                  * Don't repeat a key if the input buffers are not empty and the
1230                  * characters get aren't echoed locally. This makes key repeat
1231                  * usable with slow applications and under heavy loads.
1232                  */
1233                 return;
1234         }
1235
1236         param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1237         param.ledstate = kbd->ledflagstate;
1238         key_map = key_maps[shift_final];
1239
1240         rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1241                                         KBD_KEYCODE, &param);
1242         if (rc == NOTIFY_STOP || !key_map) {
1243                 atomic_notifier_call_chain(&keyboard_notifier_list,
1244                                            KBD_UNBOUND_KEYCODE, &param);
1245                 compute_shiftstate();
1246                 kbd->slockstate = 0;
1247                 return;
1248         }
1249
1250         if (keycode < NR_KEYS)
1251                 keysym = key_map[keycode];
1252         else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1253                 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1254         else
1255                 return;
1256
1257         type = KTYP(keysym);
1258
1259         if (type < 0xf0) {
1260                 param.value = keysym;
1261                 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1262                                                 KBD_UNICODE, &param);
1263                 if (rc != NOTIFY_STOP)
1264                         if (down && !raw_mode)
1265                                 to_utf8(vc, keysym);
1266                 return;
1267         }
1268
1269         type -= 0xf0;
1270
1271         if (type == KT_LETTER) {
1272                 type = KT_LATIN;
1273                 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1274                         key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1275                         if (key_map)
1276                                 keysym = key_map[keycode];
1277                 }
1278         }
1279
1280         param.value = keysym;
1281         rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1282                                         KBD_KEYSYM, &param);
1283         if (rc == NOTIFY_STOP)
1284                 return;
1285
1286         if ((raw_mode || kbd->kbdmode == VC_OFF) && type != KT_SPEC && type != KT_SHIFT)
1287                 return;
1288
1289         (*k_handler[type])(vc, keysym & 0xff, !down);
1290
1291         param.ledstate = kbd->ledflagstate;
1292         atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1293
1294         if (type != KT_SLOCK)
1295                 kbd->slockstate = 0;
1296 }
1297
1298 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1299                       unsigned int event_code, int value)
1300 {
1301         /* We are called with interrupts disabled, just take the lock */
1302         spin_lock(&kbd_event_lock);
1303
1304         if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1305                 kbd_rawcode(value);
1306         if (event_type == EV_KEY)
1307                 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1308
1309         spin_unlock(&kbd_event_lock);
1310
1311         tasklet_schedule(&keyboard_tasklet);
1312         do_poke_blanked_console = 1;
1313         schedule_console_callback();
1314 }
1315
1316 static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1317 {
1318         int i;
1319
1320         if (test_bit(EV_SND, dev->evbit))
1321                 return true;
1322
1323         if (test_bit(EV_KEY, dev->evbit)) {
1324                 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1325                         if (test_bit(i, dev->keybit))
1326                                 return true;
1327                 for (i = KEY_BRL_DOT1; i <= KEY_BRL_DOT10; i++)
1328                         if (test_bit(i, dev->keybit))
1329                                 return true;
1330         }
1331
1332         return false;
1333 }
1334
1335 /*
1336  * When a keyboard (or other input device) is found, the kbd_connect
1337  * function is called. The function then looks at the device, and if it
1338  * likes it, it can open it and get events from it. In this (kbd_connect)
1339  * function, we should decide which VT to bind that keyboard to initially.
1340  */
1341 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1342                         const struct input_device_id *id)
1343 {
1344         struct input_handle *handle;
1345         int error;
1346
1347         handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1348         if (!handle)
1349                 return -ENOMEM;
1350
1351         handle->dev = dev;
1352         handle->handler = handler;
1353         handle->name = "kbd";
1354
1355         error = input_register_handle(handle);
1356         if (error)
1357                 goto err_free_handle;
1358
1359         error = input_open_device(handle);
1360         if (error)
1361                 goto err_unregister_handle;
1362
1363         return 0;
1364
1365  err_unregister_handle:
1366         input_unregister_handle(handle);
1367  err_free_handle:
1368         kfree(handle);
1369         return error;
1370 }
1371
1372 static void kbd_disconnect(struct input_handle *handle)
1373 {
1374         input_close_device(handle);
1375         input_unregister_handle(handle);
1376         kfree(handle);
1377 }
1378
1379 /*
1380  * Start keyboard handler on the new keyboard by refreshing LED state to
1381  * match the rest of the system.
1382  */
1383 static void kbd_start(struct input_handle *handle)
1384 {
1385         tasklet_disable(&keyboard_tasklet);
1386
1387         if (ledstate != 0xff)
1388                 kbd_update_leds_helper(handle, &ledstate);
1389
1390         tasklet_enable(&keyboard_tasklet);
1391 }
1392
1393 static const struct input_device_id kbd_ids[] = {
1394         {
1395                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1396                 .evbit = { BIT_MASK(EV_KEY) },
1397         },
1398
1399         {
1400                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1401                 .evbit = { BIT_MASK(EV_SND) },
1402         },
1403
1404         { },    /* Terminating entry */
1405 };
1406
1407 MODULE_DEVICE_TABLE(input, kbd_ids);
1408
1409 static struct input_handler kbd_handler = {
1410         .event          = kbd_event,
1411         .match          = kbd_match,
1412         .connect        = kbd_connect,
1413         .disconnect     = kbd_disconnect,
1414         .start          = kbd_start,
1415         .name           = "kbd",
1416         .id_table       = kbd_ids,
1417 };
1418
1419 int __init kbd_init(void)
1420 {
1421         int i;
1422         int error;
1423
1424         for (i = 0; i < MAX_NR_CONSOLES; i++) {
1425                 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1426                 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1427                 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1428                 kbd_table[i].lockstate = KBD_DEFLOCK;
1429                 kbd_table[i].slockstate = 0;
1430                 kbd_table[i].modeflags = KBD_DEFMODE;
1431                 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1432         }
1433
1434         error = input_register_handler(&kbd_handler);
1435         if (error)
1436                 return error;
1437
1438         tasklet_enable(&keyboard_tasklet);
1439         tasklet_schedule(&keyboard_tasklet);
1440
1441         return 0;
1442 }