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