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