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