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