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