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