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