ia64/linux-2.6.18-xen.hg

view drivers/char/keyboard.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
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 */
27 #include <linux/module.h>
28 #include <linux/sched.h>
29 #include <linux/tty.h>
30 #include <linux/tty_flip.h>
31 #include <linux/mm.h>
32 #include <linux/string.h>
33 #include <linux/init.h>
34 #include <linux/slab.h>
36 #include <linux/kbd_kern.h>
37 #include <linux/kbd_diacr.h>
38 #include <linux/vt_kern.h>
39 #include <linux/sysrq.h>
40 #include <linux/input.h>
41 #include <linux/reboot.h>
43 static void kbd_disconnect(struct input_handle *handle);
44 extern void ctrl_alt_del(void);
46 /*
47 * Exported functions/variables
48 */
50 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
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 */
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
65 #define KBD_DEFLOCK 0
67 void compute_shiftstate(void);
69 /*
70 * Handler Tables.
71 */
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_brl, k_ignore
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 };
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
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 };
95 /*
96 * Variables exported for vt_ioctl.c
97 */
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, NR_BRL - 1
104 };
106 const int NR_TYPES = ARRAY_SIZE(max_vals);
108 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
109 static struct kbd_struct *kbd = kbd_table;
111 int spawnpid, spawnsig;
113 /*
114 * Variables exported for vt.c
115 */
117 int shift_state = 0;
119 /*
120 * Internal Data.
121 */
123 static struct input_handler kbd_handler;
124 static unsigned long key_down[NBITS(KEY_MAX)]; /* keyboard key bitmap */
125 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
126 static int dead_key_next;
127 static int npadch = -1; /* -1 or number assembled on pad */
128 static unsigned int diacr;
129 static char rep; /* flag telling character repeat */
131 static unsigned char ledstate = 0xff; /* undefined */
132 static unsigned char ledioctl;
134 static struct ledptr {
135 unsigned int *addr;
136 unsigned int mask;
137 unsigned char valid:1;
138 } ledptrs[3];
140 /* Simple translation table for the SysRq keys */
142 #ifdef CONFIG_MAGIC_SYSRQ
143 unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
144 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
145 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
146 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
147 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
148 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
149 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
150 "\r\000/"; /* 0x60 - 0x6f */
151 static int sysrq_down;
152 static int sysrq_alt_use;
153 #endif
154 static int sysrq_alt;
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;
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 }
173 if (!dev)
174 return -ENODEV;
176 if (scancode >= dev->keycodemax)
177 return -EINVAL;
179 return INPUT_KEYCODE(dev, scancode);
180 }
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;
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 }
196 if (!dev)
197 return -ENODEV;
199 if (scancode >= dev->keycodemax)
200 return -EINVAL;
201 if (keycode < 0 || keycode > KEY_MAX)
202 return -EINVAL;
203 if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
204 return -EINVAL;
206 oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
208 clear_bit(oldkey, dev->keybit);
209 set_bit(keycode, dev->keybit);
211 for (i = 0; i < dev->keycodemax; i++)
212 if (INPUT_KEYCODE(dev,i) == oldkey)
213 set_bit(oldkey, dev->keybit);
215 return 0;
216 }
218 /*
219 * Making beeps and bells.
220 */
221 static void kd_nosound(unsigned long ignored)
222 {
223 struct list_head *node;
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_inject_event(handle, EV_SND, SND_TONE, 0);
230 if (test_bit(SND_BELL, handle->dev->sndbit))
231 input_inject_event(handle, EV_SND, SND_BELL, 0);
232 }
233 }
234 }
236 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
238 void kd_mksound(unsigned int hz, unsigned int ticks)
239 {
240 struct list_head *node;
242 del_timer(&kd_mksound_timer);
244 if (hz) {
245 list_for_each_prev(node, &kbd_handler.h_list) {
246 struct input_handle *handle = to_handle_h(node);
247 if (test_bit(EV_SND, handle->dev->evbit)) {
248 if (test_bit(SND_TONE, handle->dev->sndbit)) {
249 input_inject_event(handle, EV_SND, SND_TONE, hz);
250 break;
251 }
252 if (test_bit(SND_BELL, handle->dev->sndbit)) {
253 input_inject_event(handle, EV_SND, SND_BELL, 1);
254 break;
255 }
256 }
257 }
258 if (ticks)
259 mod_timer(&kd_mksound_timer, jiffies + ticks);
260 } else
261 kd_nosound(0);
262 }
264 /*
265 * Setting the keyboard rate.
266 */
268 int kbd_rate(struct kbd_repeat *rep)
269 {
270 struct list_head *node;
271 unsigned int d = 0;
272 unsigned int p = 0;
274 list_for_each(node, &kbd_handler.h_list) {
275 struct input_handle *handle = to_handle_h(node);
276 struct input_dev *dev = handle->dev;
278 if (test_bit(EV_REP, dev->evbit)) {
279 if (rep->delay > 0)
280 input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
281 if (rep->period > 0)
282 input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
283 d = dev->rep[REP_DELAY];
284 p = dev->rep[REP_PERIOD];
285 }
286 }
287 rep->delay = d;
288 rep->period = p;
289 return 0;
290 }
292 /*
293 * Helper Functions.
294 */
295 static void put_queue(struct vc_data *vc, int ch)
296 {
297 struct tty_struct *tty = vc->vc_tty;
299 if (tty) {
300 tty_insert_flip_char(tty, ch, 0);
301 con_schedule_flip(tty);
302 }
303 }
305 static void puts_queue(struct vc_data *vc, char *cp)
306 {
307 struct tty_struct *tty = vc->vc_tty;
309 if (!tty)
310 return;
312 while (*cp) {
313 tty_insert_flip_char(tty, *cp, 0);
314 cp++;
315 }
316 con_schedule_flip(tty);
317 }
319 static void applkey(struct vc_data *vc, int key, char mode)
320 {
321 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
323 buf[1] = (mode ? 'O' : '[');
324 buf[2] = key;
325 puts_queue(vc, buf);
326 }
328 /*
329 * Many other routines do put_queue, but I think either
330 * they produce ASCII, or they produce some user-assigned
331 * string, and in both cases we might assume that it is
332 * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
333 * but we need only 16 bits here
334 */
335 static void to_utf8(struct vc_data *vc, ushort c)
336 {
337 if (c < 0x80)
338 /* 0******* */
339 put_queue(vc, c);
340 else if (c < 0x800) {
341 /* 110***** 10****** */
342 put_queue(vc, 0xc0 | (c >> 6));
343 put_queue(vc, 0x80 | (c & 0x3f));
344 } else {
345 /* 1110**** 10****** 10****** */
346 put_queue(vc, 0xe0 | (c >> 12));
347 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
348 put_queue(vc, 0x80 | (c & 0x3f));
349 }
350 }
352 /*
353 * Called after returning from RAW mode or when changing consoles - recompute
354 * shift_down[] and shift_state from key_down[] maybe called when keymap is
355 * undefined, so that shiftkey release is seen
356 */
357 void compute_shiftstate(void)
358 {
359 unsigned int i, j, k, sym, val;
361 shift_state = 0;
362 memset(shift_down, 0, sizeof(shift_down));
364 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
366 if (!key_down[i])
367 continue;
369 k = i * BITS_PER_LONG;
371 for (j = 0; j < BITS_PER_LONG; j++, k++) {
373 if (!test_bit(k, key_down))
374 continue;
376 sym = U(key_maps[0][k]);
377 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
378 continue;
380 val = KVAL(sym);
381 if (val == KVAL(K_CAPSSHIFT))
382 val = KVAL(K_SHIFT);
384 shift_down[val]++;
385 shift_state |= (1 << val);
386 }
387 }
388 }
390 /*
391 * We have a combining character DIACR here, followed by the character CH.
392 * If the combination occurs in the table, return the corresponding value.
393 * Otherwise, if CH is a space or equals DIACR, return DIACR.
394 * Otherwise, conclude that DIACR was not combining after all,
395 * queue it and return CH.
396 */
397 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
398 {
399 unsigned int d = diacr;
400 unsigned int i;
402 diacr = 0;
404 if ((d & ~0xff) == BRL_UC_ROW) {
405 if ((ch & ~0xff) == BRL_UC_ROW)
406 return d | ch;
407 } else {
408 for (i = 0; i < accent_table_size; i++)
409 if (accent_table[i].diacr == d && accent_table[i].base == ch)
410 return accent_table[i].result;
411 }
413 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
414 return d;
416 if (kbd->kbdmode == VC_UNICODE)
417 to_utf8(vc, d);
418 else if (d < 0x100)
419 put_queue(vc, d);
421 return ch;
422 }
424 /*
425 * Special function handlers
426 */
427 static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
428 {
429 if (diacr) {
430 if (kbd->kbdmode == VC_UNICODE)
431 to_utf8(vc, diacr);
432 else if (diacr < 0x100)
433 put_queue(vc, diacr);
434 diacr = 0;
435 }
436 put_queue(vc, 13);
437 if (vc_kbd_mode(kbd, VC_CRLF))
438 put_queue(vc, 10);
439 }
441 static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
442 {
443 if (rep)
444 return;
445 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
446 }
448 static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
449 {
450 if (rep)
451 return;
452 set_vc_kbd_led(kbd, VC_CAPSLOCK);
453 }
455 static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
456 {
457 if (regs)
458 show_regs(regs);
459 }
461 static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
462 {
463 struct tty_struct *tty = vc->vc_tty;
465 if (rep || !tty)
466 return;
468 /*
469 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
470 * these routines are also activated by ^S/^Q.
471 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
472 */
473 if (tty->stopped)
474 start_tty(tty);
475 else
476 stop_tty(tty);
477 }
479 static void fn_num(struct vc_data *vc, struct pt_regs *regs)
480 {
481 if (vc_kbd_mode(kbd,VC_APPLIC))
482 applkey(vc, 'P', 1);
483 else
484 fn_bare_num(vc, regs);
485 }
487 /*
488 * Bind this to Shift-NumLock if you work in application keypad mode
489 * but want to be able to change the NumLock flag.
490 * Bind this to NumLock if you prefer that the NumLock key always
491 * changes the NumLock flag.
492 */
493 static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
494 {
495 if (!rep)
496 chg_vc_kbd_led(kbd, VC_NUMLOCK);
497 }
499 static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
500 {
501 /* switch to the last used console, ChN */
502 set_console(last_console);
503 }
505 static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
506 {
507 int i, cur = fg_console;
509 /* Currently switching? Queue this next switch relative to that. */
510 if (want_console != -1)
511 cur = want_console;
513 for (i = cur - 1; i != cur; i--) {
514 if (i == -1)
515 i = MAX_NR_CONSOLES - 1;
516 if (vc_cons_allocated(i))
517 break;
518 }
519 set_console(i);
520 }
522 static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
523 {
524 int i, cur = fg_console;
526 /* Currently switching? Queue this next switch relative to that. */
527 if (want_console != -1)
528 cur = want_console;
530 for (i = cur+1; i != cur; i++) {
531 if (i == MAX_NR_CONSOLES)
532 i = 0;
533 if (vc_cons_allocated(i))
534 break;
535 }
536 set_console(i);
537 }
539 static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
540 {
541 struct tty_struct *tty = vc->vc_tty;
543 if (!tty)
544 return;
545 tty_insert_flip_char(tty, 0, TTY_BREAK);
546 con_schedule_flip(tty);
547 }
549 static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
550 {
551 scrollfront(vc, 0);
552 }
554 static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
555 {
556 scrollback(vc, 0);
557 }
559 static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
560 {
561 show_mem();
562 }
564 static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
565 {
566 show_state();
567 }
569 static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
570 {
571 ctrl_alt_del();
572 }
574 static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
575 {
576 dead_key_next = 1;
577 }
579 static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
580 {
581 if (spawnpid)
582 if (kill_proc(spawnpid, spawnsig, 1))
583 spawnpid = 0;
584 }
586 static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
587 {
588 struct tty_struct *tty = vc->vc_tty;
590 /*
591 * SAK should also work in all raw modes and reset
592 * them properly.
593 */
594 if (tty)
595 do_SAK(tty);
596 reset_vc(vc);
597 }
599 static void fn_null(struct vc_data *vc, struct pt_regs *regs)
600 {
601 compute_shiftstate();
602 }
604 /*
605 * Special key handlers
606 */
607 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
608 {
609 }
611 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
612 {
613 if (up_flag)
614 return;
615 if (value >= ARRAY_SIZE(fn_handler))
616 return;
617 if ((kbd->kbdmode == VC_RAW ||
618 kbd->kbdmode == VC_MEDIUMRAW) &&
619 value != KVAL(K_SAK))
620 return; /* SAK is allowed even in raw mode */
621 fn_handler[value](vc, regs);
622 }
624 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
625 {
626 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
627 }
629 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
630 {
631 if (up_flag)
632 return; /* no action, if this is a key release */
634 if (diacr)
635 value = handle_diacr(vc, value);
637 if (dead_key_next) {
638 dead_key_next = 0;
639 diacr = value;
640 return;
641 }
642 if (kbd->kbdmode == VC_UNICODE)
643 to_utf8(vc, value);
644 else if (value < 0x100)
645 put_queue(vc, value);
646 }
648 /*
649 * Handle dead key. Note that we now may have several
650 * dead keys modifying the same character. Very useful
651 * for Vietnamese.
652 */
653 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
654 {
655 if (up_flag)
656 return;
657 diacr = (diacr ? handle_diacr(vc, value) : value);
658 }
660 static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
661 {
662 k_unicode(vc, value, up_flag, regs);
663 }
665 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
666 {
667 k_deadunicode(vc, value, up_flag, regs);
668 }
670 /*
671 * Obsolete - for backwards compatibility only
672 */
673 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
674 {
675 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
676 value = ret_diacr[value];
677 k_deadunicode(vc, value, up_flag, regs);
678 }
680 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
681 {
682 if (up_flag)
683 return;
684 set_console(value);
685 }
687 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
688 {
689 unsigned v;
691 if (up_flag)
692 return;
693 v = value;
694 if (v < ARRAY_SIZE(func_table)) {
695 if (func_table[value])
696 puts_queue(vc, func_table[value]);
697 } else
698 printk(KERN_ERR "k_fn called with value=%d\n", value);
699 }
701 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
702 {
703 static const char *cur_chars = "BDCA";
705 if (up_flag)
706 return;
707 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
708 }
710 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
711 {
712 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
713 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
715 if (up_flag)
716 return; /* no action, if this is a key release */
718 /* kludge... shift forces cursor/number keys */
719 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
720 applkey(vc, app_map[value], 1);
721 return;
722 }
724 if (!vc_kbd_led(kbd, VC_NUMLOCK))
725 switch (value) {
726 case KVAL(K_PCOMMA):
727 case KVAL(K_PDOT):
728 k_fn(vc, KVAL(K_REMOVE), 0, regs);
729 return;
730 case KVAL(K_P0):
731 k_fn(vc, KVAL(K_INSERT), 0, regs);
732 return;
733 case KVAL(K_P1):
734 k_fn(vc, KVAL(K_SELECT), 0, regs);
735 return;
736 case KVAL(K_P2):
737 k_cur(vc, KVAL(K_DOWN), 0, regs);
738 return;
739 case KVAL(K_P3):
740 k_fn(vc, KVAL(K_PGDN), 0, regs);
741 return;
742 case KVAL(K_P4):
743 k_cur(vc, KVAL(K_LEFT), 0, regs);
744 return;
745 case KVAL(K_P6):
746 k_cur(vc, KVAL(K_RIGHT), 0, regs);
747 return;
748 case KVAL(K_P7):
749 k_fn(vc, KVAL(K_FIND), 0, regs);
750 return;
751 case KVAL(K_P8):
752 k_cur(vc, KVAL(K_UP), 0, regs);
753 return;
754 case KVAL(K_P9):
755 k_fn(vc, KVAL(K_PGUP), 0, regs);
756 return;
757 case KVAL(K_P5):
758 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
759 return;
760 }
762 put_queue(vc, pad_chars[value]);
763 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
764 put_queue(vc, 10);
765 }
767 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
768 {
769 int old_state = shift_state;
771 if (rep)
772 return;
773 /*
774 * Mimic typewriter:
775 * a CapsShift key acts like Shift but undoes CapsLock
776 */
777 if (value == KVAL(K_CAPSSHIFT)) {
778 value = KVAL(K_SHIFT);
779 if (!up_flag)
780 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
781 }
783 if (up_flag) {
784 /*
785 * handle the case that two shift or control
786 * keys are depressed simultaneously
787 */
788 if (shift_down[value])
789 shift_down[value]--;
790 } else
791 shift_down[value]++;
793 if (shift_down[value])
794 shift_state |= (1 << value);
795 else
796 shift_state &= ~(1 << value);
798 /* kludge */
799 if (up_flag && shift_state != old_state && npadch != -1) {
800 if (kbd->kbdmode == VC_UNICODE)
801 to_utf8(vc, npadch & 0xffff);
802 else
803 put_queue(vc, npadch & 0xff);
804 npadch = -1;
805 }
806 }
808 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
809 {
810 if (up_flag)
811 return;
813 if (vc_kbd_mode(kbd, VC_META)) {
814 put_queue(vc, '\033');
815 put_queue(vc, value);
816 } else
817 put_queue(vc, value | 0x80);
818 }
820 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
821 {
822 int base;
824 if (up_flag)
825 return;
827 if (value < 10) {
828 /* decimal input of code, while Alt depressed */
829 base = 10;
830 } else {
831 /* hexadecimal input of code, while AltGr depressed */
832 value -= 10;
833 base = 16;
834 }
836 if (npadch == -1)
837 npadch = value;
838 else
839 npadch = npadch * base + value;
840 }
842 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
843 {
844 if (up_flag || rep)
845 return;
846 chg_vc_kbd_lock(kbd, value);
847 }
849 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
850 {
851 k_shift(vc, value, up_flag, regs);
852 if (up_flag || rep)
853 return;
854 chg_vc_kbd_slock(kbd, value);
855 /* try to make Alt, oops, AltGr and such work */
856 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
857 kbd->slockstate = 0;
858 chg_vc_kbd_slock(kbd, value);
859 }
860 }
862 /* by default, 300ms interval for combination release */
863 static unsigned brl_timeout = 300;
864 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
865 module_param(brl_timeout, uint, 0644);
867 static unsigned brl_nbchords = 1;
868 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
869 module_param(brl_nbchords, uint, 0644);
871 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag, struct pt_regs *regs)
872 {
873 static unsigned long chords;
874 static unsigned committed;
876 if (!brl_nbchords)
877 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag, regs);
878 else {
879 committed |= pattern;
880 chords++;
881 if (chords == brl_nbchords) {
882 k_unicode(vc, BRL_UC_ROW | committed, up_flag, regs);
883 chords = 0;
884 committed = 0;
885 }
886 }
887 }
889 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
890 {
891 static unsigned pressed,committing;
892 static unsigned long releasestart;
894 if (kbd->kbdmode != VC_UNICODE) {
895 if (!up_flag)
896 printk("keyboard mode must be unicode for braille patterns\n");
897 return;
898 }
900 if (!value) {
901 k_unicode(vc, BRL_UC_ROW, up_flag, regs);
902 return;
903 }
905 if (value > 8)
906 return;
908 if (up_flag) {
909 if (brl_timeout) {
910 if (!committing ||
911 jiffies - releasestart > (brl_timeout * HZ) / 1000) {
912 committing = pressed;
913 releasestart = jiffies;
914 }
915 pressed &= ~(1 << (value - 1));
916 if (!pressed) {
917 if (committing) {
918 k_brlcommit(vc, committing, 0, regs);
919 committing = 0;
920 }
921 }
922 } else {
923 if (committing) {
924 k_brlcommit(vc, committing, 0, regs);
925 committing = 0;
926 }
927 pressed &= ~(1 << (value - 1));
928 }
929 } else {
930 pressed |= 1 << (value - 1);
931 if (!brl_timeout)
932 committing = pressed;
933 }
934 }
936 /*
937 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
938 * or (ii) whatever pattern of lights people want to show using KDSETLED,
939 * or (iii) specified bits of specified words in kernel memory.
940 */
941 unsigned char getledstate(void)
942 {
943 return ledstate;
944 }
946 void setledstate(struct kbd_struct *kbd, unsigned int led)
947 {
948 if (!(led & ~7)) {
949 ledioctl = led;
950 kbd->ledmode = LED_SHOW_IOCTL;
951 } else
952 kbd->ledmode = LED_SHOW_FLAGS;
953 set_leds();
954 }
956 static inline unsigned char getleds(void)
957 {
958 struct kbd_struct *kbd = kbd_table + fg_console;
959 unsigned char leds;
960 int i;
962 if (kbd->ledmode == LED_SHOW_IOCTL)
963 return ledioctl;
965 leds = kbd->ledflagstate;
967 if (kbd->ledmode == LED_SHOW_MEM) {
968 for (i = 0; i < 3; i++)
969 if (ledptrs[i].valid) {
970 if (*ledptrs[i].addr & ledptrs[i].mask)
971 leds |= (1 << i);
972 else
973 leds &= ~(1 << i);
974 }
975 }
976 return leds;
977 }
979 /*
980 * This routine is the bottom half of the keyboard interrupt
981 * routine, and runs with all interrupts enabled. It does
982 * console changing, led setting and copy_to_cooked, which can
983 * take a reasonably long time.
984 *
985 * Aside from timing (which isn't really that important for
986 * keyboard interrupts as they happen often), using the software
987 * interrupt routines for this thing allows us to easily mask
988 * this when we don't want any of the above to happen.
989 * This allows for easy and efficient race-condition prevention
990 * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
991 */
993 static void kbd_bh(unsigned long dummy)
994 {
995 struct list_head *node;
996 unsigned char leds = getleds();
998 if (leds != ledstate) {
999 list_for_each(node, &kbd_handler.h_list) {
1000 struct input_handle *handle = to_handle_h(node);
1001 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1002 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1003 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1004 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1008 ledstate = leds;
1011 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1013 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1014 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1015 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1016 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1018 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1019 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1021 static const unsigned short x86_keycodes[256] =
1022 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1023 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1024 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1025 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1026 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1027 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1028 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1029 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1030 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1031 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1032 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1033 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1034 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1035 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1036 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1038 #ifdef CONFIG_MAC_EMUMOUSEBTN
1039 extern int mac_hid_mouse_emulate_buttons(int, int, int);
1040 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1042 #ifdef CONFIG_SPARC
1043 static int sparc_l1_a_state = 0;
1044 extern void sun_do_break(void);
1045 #endif
1047 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1048 unsigned char up_flag)
1050 int code;
1052 switch (keycode) {
1053 case KEY_PAUSE:
1054 put_queue(vc, 0xe1);
1055 put_queue(vc, 0x1d | up_flag);
1056 put_queue(vc, 0x45 | up_flag);
1057 break;
1059 case KEY_HANGEUL:
1060 if (!up_flag)
1061 put_queue(vc, 0xf2);
1062 break;
1064 case KEY_HANJA:
1065 if (!up_flag)
1066 put_queue(vc, 0xf1);
1067 break;
1069 case KEY_SYSRQ:
1070 /*
1071 * Real AT keyboards (that's what we're trying
1072 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1073 * pressing PrtSc/SysRq alone, but simply 0x54
1074 * when pressing Alt+PrtSc/SysRq.
1075 */
1076 if (sysrq_alt) {
1077 put_queue(vc, 0x54 | up_flag);
1078 } else {
1079 put_queue(vc, 0xe0);
1080 put_queue(vc, 0x2a | up_flag);
1081 put_queue(vc, 0xe0);
1082 put_queue(vc, 0x37 | up_flag);
1084 break;
1086 default:
1087 if (keycode > 255)
1088 return -1;
1090 code = x86_keycodes[keycode];
1091 if (!code)
1092 return -1;
1094 if (code & 0x100)
1095 put_queue(vc, 0xe0);
1096 put_queue(vc, (code & 0x7f) | up_flag);
1098 break;
1101 return 0;
1104 #else
1106 #define HW_RAW(dev) 0
1108 #warning "Cannot generate rawmode keyboard for your architecture yet."
1110 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1112 if (keycode > 127)
1113 return -1;
1115 put_queue(vc, keycode | up_flag);
1116 return 0;
1118 #endif
1120 static void kbd_rawcode(unsigned char data)
1122 struct vc_data *vc = vc_cons[fg_console].d;
1123 kbd = kbd_table + fg_console;
1124 if (kbd->kbdmode == VC_RAW)
1125 put_queue(vc, data);
1128 static void kbd_keycode(unsigned int keycode, int down,
1129 int hw_raw, struct pt_regs *regs)
1131 struct vc_data *vc = vc_cons[fg_console].d;
1132 unsigned short keysym, *key_map;
1133 unsigned char type, raw_mode;
1134 struct tty_struct *tty;
1135 int shift_final;
1137 tty = vc->vc_tty;
1139 if (tty && (!tty->driver_data)) {
1140 /* No driver data? Strange. Okay we fix it then. */
1141 tty->driver_data = vc;
1144 kbd = kbd_table + fg_console;
1146 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1147 sysrq_alt = down ? keycode : 0;
1148 #ifdef CONFIG_SPARC
1149 if (keycode == KEY_STOP)
1150 sparc_l1_a_state = down;
1151 #endif
1153 rep = (down == 2);
1155 #ifdef CONFIG_MAC_EMUMOUSEBTN
1156 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1157 return;
1158 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1160 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1161 if (emulate_raw(vc, keycode, !down << 7))
1162 if (keycode < BTN_MISC)
1163 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1165 #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1166 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1167 if (!sysrq_down) {
1168 sysrq_down = down;
1169 sysrq_alt_use = sysrq_alt;
1171 return;
1173 if (sysrq_down && !down && keycode == sysrq_alt_use)
1174 sysrq_down = 0;
1175 if (sysrq_down && down && !rep) {
1176 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1177 return;
1179 #endif
1180 #ifdef CONFIG_SPARC
1181 if (keycode == KEY_A && sparc_l1_a_state) {
1182 sparc_l1_a_state = 0;
1183 sun_do_break();
1185 #endif
1187 if (kbd->kbdmode == VC_MEDIUMRAW) {
1188 /*
1189 * This is extended medium raw mode, with keys above 127
1190 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1191 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1192 * interfere with anything else. The two bytes after 0 will
1193 * always have the up flag set not to interfere with older
1194 * applications. This allows for 16384 different keycodes,
1195 * which should be enough.
1196 */
1197 if (keycode < 128) {
1198 put_queue(vc, keycode | (!down << 7));
1199 } else {
1200 put_queue(vc, !down << 7);
1201 put_queue(vc, (keycode >> 7) | 0x80);
1202 put_queue(vc, keycode | 0x80);
1204 raw_mode = 1;
1207 if (down)
1208 set_bit(keycode, key_down);
1209 else
1210 clear_bit(keycode, key_down);
1212 if (rep &&
1213 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1214 (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1215 /*
1216 * Don't repeat a key if the input buffers are not empty and the
1217 * characters get aren't echoed locally. This makes key repeat
1218 * usable with slow applications and under heavy loads.
1219 */
1220 return;
1223 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1224 key_map = key_maps[shift_final];
1226 if (!key_map) {
1227 compute_shiftstate();
1228 kbd->slockstate = 0;
1229 return;
1232 if (keycode > NR_KEYS)
1233 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1234 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1235 else
1236 return;
1237 else
1238 keysym = key_map[keycode];
1240 type = KTYP(keysym);
1242 if (type < 0xf0) {
1243 if (down && !raw_mode)
1244 to_utf8(vc, keysym);
1245 return;
1248 type -= 0xf0;
1250 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1251 return;
1253 if (type == KT_LETTER) {
1254 type = KT_LATIN;
1255 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1256 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1257 if (key_map)
1258 keysym = key_map[keycode];
1262 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1264 if (type != KT_SLOCK)
1265 kbd->slockstate = 0;
1268 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1269 unsigned int event_code, int value)
1271 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1272 kbd_rawcode(value);
1273 if (event_type == EV_KEY)
1274 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1275 tasklet_schedule(&keyboard_tasklet);
1276 do_poke_blanked_console = 1;
1277 schedule_console_callback();
1280 /*
1281 * When a keyboard (or other input device) is found, the kbd_connect
1282 * function is called. The function then looks at the device, and if it
1283 * likes it, it can open it and get events from it. In this (kbd_connect)
1284 * function, we should decide which VT to bind that keyboard to initially.
1285 */
1286 static struct input_handle *kbd_connect(struct input_handler *handler,
1287 struct input_dev *dev,
1288 struct input_device_id *id)
1290 struct input_handle *handle;
1291 int i;
1293 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1294 if (test_bit(i, dev->keybit))
1295 break;
1297 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1298 return NULL;
1300 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1301 if (!handle)
1302 return NULL;
1304 handle->dev = dev;
1305 handle->handler = handler;
1306 handle->name = "kbd";
1308 input_open_device(handle);
1310 return handle;
1313 static void kbd_disconnect(struct input_handle *handle)
1315 input_close_device(handle);
1316 kfree(handle);
1319 /*
1320 * Start keyboard handler on the new keyboard by refreshing LED state to
1321 * match the rest of the system.
1322 */
1323 static void kbd_start(struct input_handle *handle)
1325 unsigned char leds = ledstate;
1327 tasklet_disable(&keyboard_tasklet);
1328 if (leds != 0xff) {
1329 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1330 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1331 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1332 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1334 tasklet_enable(&keyboard_tasklet);
1337 static struct input_device_id kbd_ids[] = {
1339 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1340 .evbit = { BIT(EV_KEY) },
1341 },
1344 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1345 .evbit = { BIT(EV_SND) },
1346 },
1348 { }, /* Terminating entry */
1349 };
1351 MODULE_DEVICE_TABLE(input, kbd_ids);
1353 static struct input_handler kbd_handler = {
1354 .event = kbd_event,
1355 .connect = kbd_connect,
1356 .disconnect = kbd_disconnect,
1357 .start = kbd_start,
1358 .name = "kbd",
1359 .id_table = kbd_ids,
1360 };
1362 int __init kbd_init(void)
1364 int i;
1366 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1367 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1368 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1369 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1370 kbd_table[i].lockstate = KBD_DEFLOCK;
1371 kbd_table[i].slockstate = 0;
1372 kbd_table[i].modeflags = KBD_DEFMODE;
1373 kbd_table[i].kbdmode = VC_XLATE;
1376 input_register_handler(&kbd_handler);
1378 tasklet_enable(&keyboard_tasklet);
1379 tasklet_schedule(&keyboard_tasklet);
1381 return 0;