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