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