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