projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Pull ibm into release branch
[deliverable/linux.git] / drivers / char / keyboard.c
1 /*
2 * linux/drivers/char/keyboard.c
3 *
4 * Written for linux by Johan Myreen as a translation from
5 * the assembly version by Linus (with diacriticals added)
6 *
7 * Some additional features added by Christoph Niemann (ChN), March 1993
8 *
9 * Loadable keymaps by Risto Kankkunen, May 1993
10 *
11 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
12 * Added decr/incr_console, dynamic keymaps, Unicode support,
13 * dynamic function/string keys, led setting, Sept 1994
14 * `Sticky' modifier keys, 951006.
15 *
16 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
17 *
18 * Modified to provide 'generic' keyboard support by Hamish Macdonald
19 * Merge with the m68k keyboard driver and split-off of the PC low-level
20 * parts by Geert Uytterhoeven, May 1997
21 *
22 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
23 * 30-07-98: Dead keys redone, aeb@cwi.nl.
24 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
25 */
26
27 #include <linux/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 schedule_work(SAK_work);
600 }
601
602 static void fn_null(struct vc_data *vc)
603 {
604 compute_shiftstate();
605 }
606
607 /*
608 * Special key handlers
609 */
610 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
611 {
612 }
613
614 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
615 {
616 if (up_flag)
617 return;
618 if (value >= ARRAY_SIZE(fn_handler))
619 return;
620 if ((kbd->kbdmode == VC_RAW ||
621 kbd->kbdmode == VC_MEDIUMRAW) &&
622 value != KVAL(K_SAK))
623 return; /* SAK is allowed even in raw mode */
624 fn_handler[value](vc);
625 }
626
627 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
628 {
629 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
630 }
631
632 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
633 {
634 if (up_flag)
635 return; /* no action, if this is a key release */
636
637 if (diacr)
638 value = handle_diacr(vc, value);
639
640 if (dead_key_next) {
641 dead_key_next = 0;
642 diacr = value;
643 return;
644 }
645 if (kbd->kbdmode == VC_UNICODE)
646 to_utf8(vc, value);
647 else if (value < 0x100)
648 put_queue(vc, value);
649 }
650
651 /*
652 * Handle dead key. Note that we now may have several
653 * dead keys modifying the same character. Very useful
654 * for Vietnamese.
655 */
656 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
657 {
658 if (up_flag)
659 return;
660 diacr = (diacr ? handle_diacr(vc, value) : value);
661 }
662
663 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
664 {
665 k_unicode(vc, value, up_flag);
666 }
667
668 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
669 {
670 k_deadunicode(vc, value, up_flag);
671 }
672
673 /*
674 * Obsolete - for backwards compatibility only
675 */
676 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
677 {
678 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
679 value = ret_diacr[value];
680 k_deadunicode(vc, value, up_flag);
681 }
682
683 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
684 {
685 if (up_flag)
686 return;
687 set_console(value);
688 }
689
690 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
691 {
692 unsigned v;
693
694 if (up_flag)
695 return;
696 v = value;
697 if (v < ARRAY_SIZE(func_table)) {
698 if (func_table[value])
699 puts_queue(vc, func_table[value]);
700 } else
701 printk(KERN_ERR "k_fn called with value=%d\n", value);
702 }
703
704 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
705 {
706 static const char cur_chars[] = "BDCA";
707
708 if (up_flag)
709 return;
710 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
711 }
712
713 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
714 {
715 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
716 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
717
718 if (up_flag)
719 return; /* no action, if this is a key release */
720
721 /* kludge... shift forces cursor/number keys */
722 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
723 applkey(vc, app_map[value], 1);
724 return;
725 }
726
727 if (!vc_kbd_led(kbd, VC_NUMLOCK))
728 switch (value) {
729 case KVAL(K_PCOMMA):
730 case KVAL(K_PDOT):
731 k_fn(vc, KVAL(K_REMOVE), 0);
732 return;
733 case KVAL(K_P0):
734 k_fn(vc, KVAL(K_INSERT), 0);
735 return;
736 case KVAL(K_P1):
737 k_fn(vc, KVAL(K_SELECT), 0);
738 return;
739 case KVAL(K_P2):
740 k_cur(vc, KVAL(K_DOWN), 0);
741 return;
742 case KVAL(K_P3):
743 k_fn(vc, KVAL(K_PGDN), 0);
744 return;
745 case KVAL(K_P4):
746 k_cur(vc, KVAL(K_LEFT), 0);
747 return;
748 case KVAL(K_P6):
749 k_cur(vc, KVAL(K_RIGHT), 0);
750 return;
751 case KVAL(K_P7):
752 k_fn(vc, KVAL(K_FIND), 0);
753 return;
754 case KVAL(K_P8):
755 k_cur(vc, KVAL(K_UP), 0);
756 return;
757 case KVAL(K_P9):
758 k_fn(vc, KVAL(K_PGUP), 0);
759 return;
760 case KVAL(K_P5):
761 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
762 return;
763 }
764
765 put_queue(vc, pad_chars[value]);
766 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
767 put_queue(vc, 10);
768 }
769
770 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
771 {
772 int old_state = shift_state;
773
774 if (rep)
775 return;
776 /*
777 * Mimic typewriter:
778 * a CapsShift key acts like Shift but undoes CapsLock
779 */
780 if (value == KVAL(K_CAPSSHIFT)) {
781 value = KVAL(K_SHIFT);
782 if (!up_flag)
783 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
784 }
785
786 if (up_flag) {
787 /*
788 * handle the case that two shift or control
789 * keys are depressed simultaneously
790 */
791 if (shift_down[value])
792 shift_down[value]--;
793 } else
794 shift_down[value]++;
795
796 if (shift_down[value])
797 shift_state |= (1 << value);
798 else
799 shift_state &= ~(1 << value);
800
801 /* kludge */
802 if (up_flag && shift_state != old_state && npadch != -1) {
803 if (kbd->kbdmode == VC_UNICODE)
804 to_utf8(vc, npadch & 0xffff);
805 else
806 put_queue(vc, npadch & 0xff);
807 npadch = -1;
808 }
809 }
810
811 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
812 {
813 if (up_flag)
814 return;
815
816 if (vc_kbd_mode(kbd, VC_META)) {
817 put_queue(vc, '\033');
818 put_queue(vc, value);
819 } else
820 put_queue(vc, value | 0x80);
821 }
822
823 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
824 {
825 int base;
826
827 if (up_flag)
828 return;
829
830 if (value < 10) {
831 /* decimal input of code, while Alt depressed */
832 base = 10;
833 } else {
834 /* hexadecimal input of code, while AltGr depressed */
835 value -= 10;
836 base = 16;
837 }
838
839 if (npadch == -1)
840 npadch = value;
841 else
842 npadch = npadch * base + value;
843 }
844
845 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
846 {
847 if (up_flag || rep)
848 return;
849 chg_vc_kbd_lock(kbd, value);
850 }
851
852 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
853 {
854 k_shift(vc, value, up_flag);
855 if (up_flag || rep)
856 return;
857 chg_vc_kbd_slock(kbd, value);
858 /* try to make Alt, oops, AltGr and such work */
859 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
860 kbd->slockstate = 0;
861 chg_vc_kbd_slock(kbd, value);
862 }
863 }
864
865 /* by default, 300ms interval for combination release */
866 static unsigned brl_timeout = 300;
867 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
868 module_param(brl_timeout, uint, 0644);
869
870 static unsigned brl_nbchords = 1;
871 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
872 module_param(brl_nbchords, uint, 0644);
873
874 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
875 {
876 static unsigned long chords;
877 static unsigned committed;
878
879 if (!brl_nbchords)
880 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
881 else {
882 committed |= pattern;
883 chords++;
884 if (chords == brl_nbchords) {
885 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
886 chords = 0;
887 committed = 0;
888 }
889 }
890 }
891
892 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
893 {
894 static unsigned pressed,committing;
895 static unsigned long releasestart;
896
897 if (kbd->kbdmode != VC_UNICODE) {
898 if (!up_flag)
899 printk("keyboard mode must be unicode for braille patterns\n");
900 return;
901 }
902
903 if (!value) {
904 k_unicode(vc, BRL_UC_ROW, up_flag);
905 return;
906 }
907
908 if (value > 8)
909 return;
910
911 if (up_flag) {
912 if (brl_timeout) {
913 if (!committing ||
914 jiffies - releasestart > (brl_timeout * HZ) / 1000) {
915 committing = pressed;
916 releasestart = jiffies;
917 }
918 pressed &= ~(1 << (value - 1));
919 if (!pressed) {
920 if (committing) {
921 k_brlcommit(vc, committing, 0);
922 committing = 0;
923 }
924 }
925 } else {
926 if (committing) {
927 k_brlcommit(vc, committing, 0);
928 committing = 0;
929 }
930 pressed &= ~(1 << (value - 1));
931 }
932 } else {
933 pressed |= 1 << (value - 1);
934 if (!brl_timeout)
935 committing = pressed;
936 }
937 }
938
939 /*
940 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
941 * or (ii) whatever pattern of lights people want to show using KDSETLED,
942 * or (iii) specified bits of specified words in kernel memory.
943 */
944 unsigned char getledstate(void)
945 {
946 return ledstate;
947 }
948
949 void setledstate(struct kbd_struct *kbd, unsigned int led)
950 {
951 if (!(led & ~7)) {
952 ledioctl = led;
953 kbd->ledmode = LED_SHOW_IOCTL;
954 } else
955 kbd->ledmode = LED_SHOW_FLAGS;
956 set_leds();
957 }
958
959 static inline unsigned char getleds(void)
960 {
961 struct kbd_struct *kbd = kbd_table + fg_console;
962 unsigned char leds;
963 int i;
964
965 if (kbd->ledmode == LED_SHOW_IOCTL)
966 return ledioctl;
967
968 leds = kbd->ledflagstate;
969
970 if (kbd->ledmode == LED_SHOW_MEM) {
971 for (i = 0; i < 3; i++)
972 if (ledptrs[i].valid) {
973 if (*ledptrs[i].addr & ledptrs[i].mask)
974 leds |= (1 << i);
975 else
976 leds &= ~(1 << i);
977 }
978 }
979 return leds;
980 }
981
982 /*
983 * This routine is the bottom half of the keyboard interrupt
984 * routine, and runs with all interrupts enabled. It does
985 * console changing, led setting and copy_to_cooked, which can
986 * take a reasonably long time.
987 *
988 * Aside from timing (which isn't really that important for
989 * keyboard interrupts as they happen often), using the software
990 * interrupt routines for this thing allows us to easily mask
991 * this when we don't want any of the above to happen.
992 * This allows for easy and efficient race-condition prevention
993 * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
994 */
995
996 static void kbd_bh(unsigned long dummy)
997 {
998 struct list_head *node;
999 unsigned char leds = getleds();
1000
1001 if (leds != ledstate) {
1002 list_for_each(node, &kbd_handler.h_list) {
1003 struct input_handle *handle = to_handle_h(node);
1004 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1005 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1006 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1007 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1008 }
1009 }
1010
1011 ledstate = leds;
1012 }
1013
1014 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1015
1016 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1017 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1018 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1019 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1020
1021 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1022 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1023
1024 static const unsigned short x86_keycodes[256] =
1025 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1026 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1027 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1028 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1029 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1030 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1031 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1032 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1033 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1034 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1035 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1036 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1037 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1038 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1039 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1040
1041 #ifdef CONFIG_MAC_EMUMOUSEBTN
1042 extern int mac_hid_mouse_emulate_buttons(int, int, int);
1043 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1044
1045 #ifdef CONFIG_SPARC
1046 static int sparc_l1_a_state = 0;
1047 extern void sun_do_break(void);
1048 #endif
1049
1050 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1051 unsigned char up_flag)
1052 {
1053 int code;
1054
1055 switch (keycode) {
1056 case KEY_PAUSE:
1057 put_queue(vc, 0xe1);
1058 put_queue(vc, 0x1d | up_flag);
1059 put_queue(vc, 0x45 | up_flag);
1060 break;
1061
1062 case KEY_HANGEUL:
1063 if (!up_flag)
1064 put_queue(vc, 0xf2);
1065 break;
1066
1067 case KEY_HANJA:
1068 if (!up_flag)
1069 put_queue(vc, 0xf1);
1070 break;
1071
1072 case KEY_SYSRQ:
1073 /*
1074 * Real AT keyboards (that's what we're trying
1075 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1076 * pressing PrtSc/SysRq alone, but simply 0x54
1077 * when pressing Alt+PrtSc/SysRq.
1078 */
1079 if (sysrq_alt) {
1080 put_queue(vc, 0x54 | up_flag);
1081 } else {
1082 put_queue(vc, 0xe0);
1083 put_queue(vc, 0x2a | up_flag);
1084 put_queue(vc, 0xe0);
1085 put_queue(vc, 0x37 | up_flag);
1086 }
1087 break;
1088
1089 default:
1090 if (keycode > 255)
1091 return -1;
1092
1093 code = x86_keycodes[keycode];
1094 if (!code)
1095 return -1;
1096
1097 if (code & 0x100)
1098 put_queue(vc, 0xe0);
1099 put_queue(vc, (code & 0x7f) | up_flag);
1100
1101 break;
1102 }
1103
1104 return 0;
1105 }
1106
1107 #else
1108
1109 #define HW_RAW(dev) 0
1110
1111 #warning "Cannot generate rawmode keyboard for your architecture yet."
1112
1113 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1114 {
1115 if (keycode > 127)
1116 return -1;
1117
1118 put_queue(vc, keycode | up_flag);
1119 return 0;
1120 }
1121 #endif
1122
1123 static void kbd_rawcode(unsigned char data)
1124 {
1125 struct vc_data *vc = vc_cons[fg_console].d;
1126 kbd = kbd_table + fg_console;
1127 if (kbd->kbdmode == VC_RAW)
1128 put_queue(vc, data);
1129 }
1130
1131 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1132 {
1133 struct vc_data *vc = vc_cons[fg_console].d;
1134 unsigned short keysym, *key_map;
1135 unsigned char type, raw_mode;
1136 struct tty_struct *tty;
1137 int shift_final;
1138
1139 tty = vc->vc_tty;
1140
1141 if (tty && (!tty->driver_data)) {
1142 /* No driver data? Strange. Okay we fix it then. */
1143 tty->driver_data = vc;
1144 }
1145
1146 kbd = kbd_table + fg_console;
1147
1148 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1149 sysrq_alt = down ? keycode : 0;
1150 #ifdef CONFIG_SPARC
1151 if (keycode == KEY_STOP)
1152 sparc_l1_a_state = down;
1153 #endif
1154
1155 rep = (down == 2);
1156
1157 #ifdef CONFIG_MAC_EMUMOUSEBTN
1158 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1159 return;
1160 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1161
1162 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1163 if (emulate_raw(vc, keycode, !down << 7))
1164 if (keycode < BTN_MISC)
1165 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1166
1167 #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1168 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1169 if (!sysrq_down) {
1170 sysrq_down = down;
1171 sysrq_alt_use = sysrq_alt;
1172 }
1173 return;
1174 }
1175 if (sysrq_down && !down && keycode == sysrq_alt_use)
1176 sysrq_down = 0;
1177 if (sysrq_down && down && !rep) {
1178 handle_sysrq(kbd_sysrq_xlate[keycode], tty);
1179 return;
1180 }
1181 #endif
1182 #ifdef CONFIG_SPARC
1183 if (keycode == KEY_A && sparc_l1_a_state) {
1184 sparc_l1_a_state = 0;
1185 sun_do_break();
1186 }
1187 #endif
1188
1189 if (kbd->kbdmode == VC_MEDIUMRAW) {
1190 /*
1191 * This is extended medium raw mode, with keys above 127
1192 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1193 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1194 * interfere with anything else. The two bytes after 0 will
1195 * always have the up flag set not to interfere with older
1196 * applications. This allows for 16384 different keycodes,
1197 * which should be enough.
1198 */
1199 if (keycode < 128) {
1200 put_queue(vc, keycode | (!down << 7));
1201 } else {
1202 put_queue(vc, !down << 7);
1203 put_queue(vc, (keycode >> 7) | 0x80);
1204 put_queue(vc, keycode | 0x80);
1205 }
1206 raw_mode = 1;
1207 }
1208
1209 if (down)
1210 set_bit(keycode, key_down);
1211 else
1212 clear_bit(keycode, key_down);
1213
1214 if (rep &&
1215 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1216 (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1217 /*
1218 * Don't repeat a key if the input buffers are not empty and the
1219 * characters get aren't echoed locally. This makes key repeat
1220 * usable with slow applications and under heavy loads.
1221 */
1222 return;
1223 }
1224
1225 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1226 key_map = key_maps[shift_final];
1227
1228 if (!key_map) {
1229 compute_shiftstate();
1230 kbd->slockstate = 0;
1231 return;
1232 }
1233
1234 if (keycode > NR_KEYS)
1235 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1236 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1237 else
1238 return;
1239 else
1240 keysym = key_map[keycode];
1241
1242 type = KTYP(keysym);
1243
1244 if (type < 0xf0) {
1245 if (down && !raw_mode)
1246 to_utf8(vc, keysym);
1247 return;
1248 }
1249
1250 type -= 0xf0;
1251
1252 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1253 return;
1254
1255 if (type == KT_LETTER) {
1256 type = KT_LATIN;
1257 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1258 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1259 if (key_map)
1260 keysym = key_map[keycode];
1261 }
1262 }
1263
1264 (*k_handler[type])(vc, keysym & 0xff, !down);
1265
1266 if (type != KT_SLOCK)
1267 kbd->slockstate = 0;
1268 }
1269
1270 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1271 unsigned int event_code, int value)
1272 {
1273 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1274 kbd_rawcode(value);
1275 if (event_type == EV_KEY)
1276 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1277 tasklet_schedule(&keyboard_tasklet);
1278 do_poke_blanked_console = 1;
1279 schedule_console_callback();
1280 }
1281
1282 /*
1283 * When a keyboard (or other input device) is found, the kbd_connect
1284 * function is called. The function then looks at the device, and if it
1285 * likes it, it can open it and get events from it. In this (kbd_connect)
1286 * function, we should decide which VT to bind that keyboard to initially.
1287 */
1288 static struct input_handle *kbd_connect(struct input_handler *handler,
1289 struct input_dev *dev,
1290 const struct input_device_id *id)
1291 {
1292 struct input_handle *handle;
1293 int i;
1294
1295 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1296 if (test_bit(i, dev->keybit))
1297 break;
1298
1299 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1300 return NULL;
1301
1302 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1303 if (!handle)
1304 return NULL;
1305
1306 handle->dev = dev;
1307 handle->handler = handler;
1308 handle->name = "kbd";
1309
1310 input_open_device(handle);
1311
1312 return handle;
1313 }
1314
1315 static void kbd_disconnect(struct input_handle *handle)
1316 {
1317 input_close_device(handle);
1318 kfree(handle);
1319 }
1320
1321 /*
1322 * Start keyboard handler on the new keyboard by refreshing LED state to
1323 * match the rest of the system.
1324 */
1325 static void kbd_start(struct input_handle *handle)
1326 {
1327 unsigned char leds = ledstate;
1328
1329 tasklet_disable(&keyboard_tasklet);
1330 if (leds != 0xff) {
1331 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1332 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1333 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1334 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1335 }
1336 tasklet_enable(&keyboard_tasklet);
1337 }
1338
1339 static const struct input_device_id kbd_ids[] = {
1340 {
1341 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1342 .evbit = { BIT(EV_KEY) },
1343 },
1344
1345 {
1346 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1347 .evbit = { BIT(EV_SND) },
1348 },
1349
1350 { }, /* Terminating entry */
1351 };
1352
1353 MODULE_DEVICE_TABLE(input, kbd_ids);
1354
1355 static struct input_handler kbd_handler = {
1356 .event = kbd_event,
1357 .connect = kbd_connect,
1358 .disconnect = kbd_disconnect,
1359 .start = kbd_start,
1360 .name = "kbd",
1361 .id_table = kbd_ids,
1362 };
1363
1364 int __init kbd_init(void)
1365 {
1366 int i;
1367 int error;
1368
1369 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1370 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1371 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1372 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1373 kbd_table[i].lockstate = KBD_DEFLOCK;
1374 kbd_table[i].slockstate = 0;
1375 kbd_table[i].modeflags = KBD_DEFMODE;
1376 kbd_table[i].kbdmode = VC_XLATE;
1377 }
1378
1379 error = input_register_handler(&kbd_handler);
1380 if (error)
1381 return error;
1382
1383 tasklet_enable(&keyboard_tasklet);
1384 tasklet_schedule(&keyboard_tasklet);
1385
1386 return 0;
1387 }
Linux kernel - Deliverables
This page took 0.058619 seconds and 5 git commands to generate.