drivers/tty/vt/keyboard.c

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