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