projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' into upstream
[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
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>
42
43 static void kbd_disconnect(struct input_handle *handle);
44 extern void ctrl_alt_del(void);
45
46 /*
47 * Exported functions/variables
48 */
49
50 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
51
52 /*
53 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
54 * This seems a good reason to start with NumLock off. On HIL keyboards
55 * of PARISC machines however there is no NumLock key and everyone expects the keypad
56 * to be used for numbers.
57 */
58
59 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
60 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
61 #else
62 #define KBD_DEFLEDS 0
63 #endif
64
65 #define KBD_DEFLOCK 0
66
67 void compute_shiftstate(void);
68
69 /*
70 * Handler Tables.
71 */
72
73 #define K_HANDLERS\
74 k_self, k_fn, k_spec, k_pad,\
75 k_dead, k_cons, k_cur, k_shift,\
76 k_meta, k_ascii, k_lock, k_lowercase,\
77 k_slock, k_dead2, k_brl, k_ignore
78
79 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
80 char up_flag, struct pt_regs *regs);
81 static k_handler_fn K_HANDLERS;
82 static k_handler_fn *k_handler[16] = { K_HANDLERS };
83
84 #define FN_HANDLERS\
85 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
86 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
87 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
88 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
89 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
90
91 typedef void (fn_handler_fn)(struct vc_data *vc, struct pt_regs *regs);
92 static fn_handler_fn FN_HANDLERS;
93 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
94
95 /*
96 * Variables exported for vt_ioctl.c
97 */
98
99 /* maximum values each key_handler can handle */
100 const int max_vals[] = {
101 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
102 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
103 255, NR_LOCK - 1, 255, NR_BRL - 1
104 };
105
106 const int NR_TYPES = ARRAY_SIZE(max_vals);
107
108 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
109 static struct kbd_struct *kbd = kbd_table;
110
111 int spawnpid, spawnsig;
112
113 /*
114 * Variables exported for vt.c
115 */
116
117 int shift_state = 0;
118
119 /*
120 * Internal Data.
121 */
122
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 */
130
131 static unsigned char ledstate = 0xff; /* undefined */
132 static unsigned char ledioctl;
133
134 static struct ledptr {
135 unsigned int *addr;
136 unsigned int mask;
137 unsigned char valid:1;
138 } ledptrs[3];
139
140 /* Simple translation table for the SysRq keys */
141
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;
155
156 /*
157 * Translation of scancodes to keycodes. We set them on only the first attached
158 * keyboard - for per-keyboard setting, /dev/input/event is more useful.
159 */
160 int getkeycode(unsigned int scancode)
161 {
162 struct list_head *node;
163 struct input_dev *dev = NULL;
164
165 list_for_each(node, &kbd_handler.h_list) {
166 struct input_handle *handle = to_handle_h(node);
167 if (handle->dev->keycodesize) {
168 dev = handle->dev;
169 break;
170 }
171 }
172
173 if (!dev)
174 return -ENODEV;
175
176 if (scancode >= dev->keycodemax)
177 return -EINVAL;
178
179 return INPUT_KEYCODE(dev, scancode);
180 }
181
182 int setkeycode(unsigned int scancode, unsigned int keycode)
183 {
184 struct list_head *node;
185 struct input_dev *dev = NULL;
186 unsigned int i, oldkey;
187
188 list_for_each(node, &kbd_handler.h_list) {
189 struct input_handle *handle = to_handle_h(node);
190 if (handle->dev->keycodesize) {
191 dev = handle->dev;
192 break;
193 }
194 }
195
196 if (!dev)
197 return -ENODEV;
198
199 if (scancode >= dev->keycodemax)
200 return -EINVAL;
201 if (keycode < 0 || keycode > KEY_MAX)
202 return -EINVAL;
203 if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
204 return -EINVAL;
205
206 oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
207
208 clear_bit(oldkey, dev->keybit);
209 set_bit(keycode, dev->keybit);
210
211 for (i = 0; i < dev->keycodemax; i++)
212 if (INPUT_KEYCODE(dev,i) == oldkey)
213 set_bit(oldkey, dev->keybit);
214
215 return 0;
216 }
217
218 /*
219 * Making beeps and bells.
220 */
221 static void kd_nosound(unsigned long ignored)
222 {
223 struct list_head *node;
224
225 list_for_each(node, &kbd_handler.h_list) {
226 struct input_handle *handle = to_handle_h(node);
227 if (test_bit(EV_SND, handle->dev->evbit)) {
228 if (test_bit(SND_TONE, handle->dev->sndbit))
229 input_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 }
235
236 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
237
238 void kd_mksound(unsigned int hz, unsigned int ticks)
239 {
240 struct list_head *node;
241
242 del_timer(&kd_mksound_timer);
243
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 }
263
264 /*
265 * Setting the keyboard rate.
266 */
267
268 int kbd_rate(struct kbd_repeat *rep)
269 {
270 struct list_head *node;
271 unsigned int d = 0;
272 unsigned int p = 0;
273
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;
277
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 }
291
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;
298
299 if (tty) {
300 tty_insert_flip_char(tty, ch, 0);
301 con_schedule_flip(tty);
302 }
303 }
304
305 static void puts_queue(struct vc_data *vc, char *cp)
306 {
307 struct tty_struct *tty = vc->vc_tty;
308
309 if (!tty)
310 return;
311
312 while (*cp) {
313 tty_insert_flip_char(tty, *cp, 0);
314 cp++;
315 }
316 con_schedule_flip(tty);
317 }
318
319 static void applkey(struct vc_data *vc, int key, char mode)
320 {
321 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
322
323 buf[1] = (mode ? 'O' : '[');
324 buf[2] = key;
325 puts_queue(vc, buf);
326 }
327
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 }
351
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;
360
361 shift_state = 0;
362 memset(shift_down, 0, sizeof(shift_down));
363
364 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
365
366 if (!key_down[i])
367 continue;
368
369 k = i * BITS_PER_LONG;
370
371 for (j = 0; j < BITS_PER_LONG; j++, k++) {
372
373 if (!test_bit(k, key_down))
374 continue;
375
376 sym = U(key_maps[0][k]);
377 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
378 continue;
379
380 val = KVAL(sym);
381 if (val == KVAL(K_CAPSSHIFT))
382 val = KVAL(K_SHIFT);
383
384 shift_down[val]++;
385 shift_state |= (1 << val);
386 }
387 }
388 }
389
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;
401
402 diacr = 0;
403
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 }
412
413 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
414 return d;
415
416 if (kbd->kbdmode == VC_UNICODE)
417 to_utf8(vc, d);
418 else if (d < 0x100)
419 put_queue(vc, d);
420
421 return ch;
422 }
423
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 }
440
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 }
447
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 }
454
455 static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
456 {
457 if (regs)
458 show_regs(regs);
459 }
460
461 static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
462 {
463 struct tty_struct *tty = vc->vc_tty;
464
465 if (rep || !tty)
466 return;
467
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 }
478
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 }
486
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 }
498
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 }
504
505 static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
506 {
507 int i, cur = fg_console;
508
509 /* Currently switching? Queue this next switch relative to that. */
510 if (want_console != -1)
511 cur = want_console;
512
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 }
521
522 static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
523 {
524 int i, cur = fg_console;
525
526 /* Currently switching? Queue this next switch relative to that. */
527 if (want_console != -1)
528 cur = want_console;
529
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 }
538
539 static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
540 {
541 struct tty_struct *tty = vc->vc_tty;
542
543 if (!tty)
544 return;
545 tty_insert_flip_char(tty, 0, TTY_BREAK);
546 con_schedule_flip(tty);
547 }
548
549 static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
550 {
551 scrollfront(vc, 0);
552 }
553
554 static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
555 {
556 scrollback(vc, 0);
557 }
558
559 static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
560 {
561 show_mem();
562 }
563
564 static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
565 {
566 show_state();
567 }
568
569 static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
570 {
571 ctrl_alt_del();
572 }
573
574 static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
575 {
576 dead_key_next = 1;
577 }
578
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 }
585
586 static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
587 {
588 struct tty_struct *tty = vc->vc_tty;
589
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 }
598
599 static void fn_null(struct vc_data *vc, struct pt_regs *regs)
600 {
601 compute_shiftstate();
602 }
603
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 }
610
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 }
623
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 }
628
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 */
633
634 if (diacr)
635 value = handle_diacr(vc, value);
636
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 }
647
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 }
659
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 }
664
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 }
669
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 }
679
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 }
686
687 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
688 {
689 unsigned v;
690
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 }
700
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";
704
705 if (up_flag)
706 return;
707 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
708 }
709
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";
714
715 if (up_flag)
716 return; /* no action, if this is a key release */
717
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 }
723
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 }
761
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 }
766
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;
770
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 }
782
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]++;
792
793 if (shift_down[value])
794 shift_state |= (1 << value);
795 else
796 shift_state &= ~(1 << value);
797
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 }
807
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;
812
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 }
819
820 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
821 {
822 int base;
823
824 if (up_flag)
825 return;
826
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 }
835
836 if (npadch == -1)
837 npadch = value;
838 else
839 npadch = npadch * base + value;
840 }
841
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 }
848
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 }
861
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);
866
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);
870
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;
875
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 }
888
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;
893
894 if (kbd->kbdmode != VC_UNICODE) {
895 if (!up_flag)
896 printk("keyboard mode must be unicode for braille patterns\n");
897 return;
898 }
899
900 if (!value) {
901 k_unicode(vc, BRL_UC_ROW, up_flag, regs);
902 return;
903 }
904
905 if (value > 8)
906 return;
907
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 }
935
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 }
945
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 }
955
956 static inline unsigned char getleds(void)
957 {
958 struct kbd_struct *kbd = kbd_table + fg_console;
959 unsigned char leds;
960 int i;
961
962 if (kbd->ledmode == LED_SHOW_IOCTL)
963 return ledioctl;
964
965 leds = kbd->ledflagstate;
966
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 }
978
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 */
992
993 static void kbd_bh(unsigned long dummy)
994 {
995 struct list_head *node;
996 unsigned char leds = getleds();
997
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);
1005 }
1006 }
1007
1008 ledstate = leds;
1009 }
1010
1011 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1012
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))
1017
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))
1020
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 };
1037
1038 #ifdef CONFIG_MAC_EMUMOUSEBTN
1039 extern int mac_hid_mouse_emulate_buttons(int, int, int);
1040 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1041
1042 #ifdef CONFIG_SPARC
1043 static int sparc_l1_a_state = 0;
1044 extern void sun_do_break(void);
1045 #endif
1046
1047 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1048 unsigned char up_flag)
1049 {
1050 int code;
1051
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;
1058
1059 case KEY_HANGEUL:
1060 if (!up_flag)
1061 put_queue(vc, 0xf2);
1062 break;
1063
1064 case KEY_HANJA:
1065 if (!up_flag)
1066 put_queue(vc, 0xf1);
1067 break;
1068
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);
1083 }
1084 break;
1085
1086 default:
1087 if (keycode > 255)
1088 return -1;
1089
1090 code = x86_keycodes[keycode];
1091 if (!code)
1092 return -1;
1093
1094 if (code & 0x100)
1095 put_queue(vc, 0xe0);
1096 put_queue(vc, (code & 0x7f) | up_flag);
1097
1098 break;
1099 }
1100
1101 return 0;
1102 }
1103
1104 #else
1105
1106 #define HW_RAW(dev) 0
1107
1108 #warning "Cannot generate rawmode keyboard for your architecture yet."
1109
1110 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1111 {
1112 if (keycode > 127)
1113 return -1;
1114
1115 put_queue(vc, keycode | up_flag);
1116 return 0;
1117 }
1118 #endif
1119
1120 static void kbd_rawcode(unsigned char data)
1121 {
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);
1126 }
1127
1128 static void kbd_keycode(unsigned int keycode, int down,
1129 int hw_raw, struct pt_regs *regs)
1130 {
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;
1136
1137 tty = vc->vc_tty;
1138
1139 if (tty && (!tty->driver_data)) {
1140 /* No driver data? Strange. Okay we fix it then. */
1141 tty->driver_data = vc;
1142 }
1143
1144 kbd = kbd_table + fg_console;
1145
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
1152
1153 rep = (down == 2);
1154
1155 #ifdef CONFIG_MAC_EMUMOUSEBTN
1156 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1157 return;
1158 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1159
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);
1164
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;
1170 }
1171 return;
1172 }
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;
1178 }
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();
1184 }
1185 #endif
1186
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);
1203 }
1204 raw_mode = 1;
1205 }
1206
1207 if (down)
1208 set_bit(keycode, key_down);
1209 else
1210 clear_bit(keycode, key_down);
1211
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;
1221 }
1222
1223 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1224 key_map = key_maps[shift_final];
1225
1226 if (!key_map) {
1227 compute_shiftstate();
1228 kbd->slockstate = 0;
1229 return;
1230 }
1231
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];
1239
1240 type = KTYP(keysym);
1241
1242 if (type < 0xf0) {
1243 if (down && !raw_mode)
1244 to_utf8(vc, keysym);
1245 return;
1246 }
1247
1248 type -= 0xf0;
1249
1250 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1251 return;
1252
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];
1259 }
1260 }
1261
1262 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1263
1264 if (type != KT_SLOCK)
1265 kbd->slockstate = 0;
1266 }
1267
1268 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1269 unsigned int event_code, int value)
1270 {
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();
1278 }
1279
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)
1289 {
1290 struct input_handle *handle;
1291 int i;
1292
1293 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1294 if (test_bit(i, dev->keybit))
1295 break;
1296
1297 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1298 return NULL;
1299
1300 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1301 if (!handle)
1302 return NULL;
1303
1304 handle->dev = dev;
1305 handle->handler = handler;
1306 handle->name = "kbd";
1307
1308 input_open_device(handle);
1309
1310 return handle;
1311 }
1312
1313 static void kbd_disconnect(struct input_handle *handle)
1314 {
1315 input_close_device(handle);
1316 kfree(handle);
1317 }
1318
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)
1324 {
1325 unsigned char leds = ledstate;
1326
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);
1333 }
1334 tasklet_enable(&keyboard_tasklet);
1335 }
1336
1337 static struct input_device_id kbd_ids[] = {
1338 {
1339 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1340 .evbit = { BIT(EV_KEY) },
1341 },
1342
1343 {
1344 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1345 .evbit = { BIT(EV_SND) },
1346 },
1347
1348 { }, /* Terminating entry */
1349 };
1350
1351 MODULE_DEVICE_TABLE(input, kbd_ids);
1352
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 };
1361
1362 int __init kbd_init(void)
1363 {
1364 int i;
1365
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;
1374 }
1375
1376 input_register_handler(&kbd_handler);
1377
1378 tasklet_enable(&keyboard_tasklet);
1379 tasklet_schedule(&keyboard_tasklet);
1380
1381 return 0;
1382 }
Linux kernel - Deliverables
This page took 0.075198 seconds and 5 git commands to generate.