drivers/tty/vt/keyboard.c

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