git.oblomov.eu Git - linux-2.6/blob - drivers/char/keyboard.c

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