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