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