[CONNECTOR]: async connector mode.
[linux-2.6/verdex.git] / drivers / char / keyboard.c
blob449d029ad4f40abc936fb85f6ee66f60511201a6
1 /*
2 * linux/drivers/char/keyboard.c
4 * Written for linux by Johan Myreen as a translation from
5 * the assembly version by Linus (with diacriticals added)
7 * Some additional features added by Christoph Niemann (ChN), March 1993
9 * Loadable keymaps by Risto Kankkunen, May 1993
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.
16 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
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
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)
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>
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>
43 static void kbd_disconnect(struct input_handle *handle);
44 extern void ctrl_alt_del(void);
47 * Exported functions/variables
50 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
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.
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
65 #define KBD_DEFLOCK 0
67 void compute_shiftstate(void);
70 * Handler Tables.
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
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 };
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
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 };
96 * Variables exported for vt_ioctl.c
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
106 const int NR_TYPES = ARRAY_SIZE(max_vals);
108 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
109 static struct kbd_struct *kbd = kbd_table;
110 static struct kbd_struct kbd0;
112 int spawnpid, spawnsig;
115 * Variables exported for vt.c
118 int shift_state = 0;
121 * Internal Data.
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 */
132 static unsigned char ledstate = 0xff; /* undefined */
133 static unsigned char ledioctl;
135 static struct ledptr {
136 unsigned int *addr;
137 unsigned int mask;
138 unsigned char valid:1;
139 } ledptrs[3];
141 /* Simple translation table for the SysRq keys */
143 #ifdef CONFIG_MAGIC_SYSRQ
144 unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
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;
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.
160 int getkeycode(unsigned int scancode)
162 struct list_head *node;
163 struct input_dev *dev = NULL;
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;
173 if (!dev)
174 return -ENODEV;
176 if (scancode >= dev->keycodemax)
177 return -EINVAL;
179 return INPUT_KEYCODE(dev, scancode);
182 int setkeycode(unsigned int scancode, unsigned int keycode)
184 struct list_head *node;
185 struct input_dev *dev = NULL;
186 unsigned int i, oldkey;
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;
196 if (!dev)
197 return -ENODEV;
199 if (scancode >= dev->keycodemax)
200 return -EINVAL;
201 if (keycode < 0 || keycode > KEY_MAX)
202 return -EINVAL;
203 if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
204 return -EINVAL;
206 oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
208 clear_bit(oldkey, dev->keybit);
209 set_bit(keycode, dev->keybit);
211 for (i = 0; i < dev->keycodemax; i++)
212 if (INPUT_KEYCODE(dev,i) == oldkey)
213 set_bit(oldkey, dev->keybit);
215 return 0;
219 * Making beeps and bells.
221 static void kd_nosound(unsigned long ignored)
223 struct list_head *node;
225 list_for_each(node,&kbd_handler.h_list) {
226 struct input_handle *handle = to_handle_h(node);
227 if (test_bit(EV_SND, handle->dev->evbit)) {
228 if (test_bit(SND_TONE, handle->dev->sndbit))
229 input_event(handle->dev, EV_SND, SND_TONE, 0);
230 if (test_bit(SND_BELL, handle->dev->sndbit))
231 input_event(handle->dev, EV_SND, SND_BELL, 0);
236 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
238 void kd_mksound(unsigned int hz, unsigned int ticks)
240 struct list_head *node;
242 del_timer(&kd_mksound_timer);
244 if (hz) {
245 list_for_each_prev(node, &kbd_handler.h_list) {
246 struct input_handle *handle = to_handle_h(node);
247 if (test_bit(EV_SND, handle->dev->evbit)) {
248 if (test_bit(SND_TONE, handle->dev->sndbit)) {
249 input_event(handle->dev, EV_SND, SND_TONE, hz);
250 break;
252 if (test_bit(SND_BELL, handle->dev->sndbit)) {
253 input_event(handle->dev, EV_SND, SND_BELL, 1);
254 break;
258 if (ticks)
259 mod_timer(&kd_mksound_timer, jiffies + ticks);
260 } else
261 kd_nosound(0);
265 * Setting the keyboard rate.
268 int kbd_rate(struct kbd_repeat *rep)
270 struct list_head *node;
271 unsigned int d = 0;
272 unsigned int p = 0;
274 list_for_each(node,&kbd_handler.h_list) {
275 struct input_handle *handle = to_handle_h(node);
276 struct input_dev *dev = handle->dev;
278 if (test_bit(EV_REP, dev->evbit)) {
279 if (rep->delay > 0)
280 input_event(dev, EV_REP, REP_DELAY, rep->delay);
281 if (rep->period > 0)
282 input_event(dev, EV_REP, REP_PERIOD, rep->period);
283 d = dev->rep[REP_DELAY];
284 p = dev->rep[REP_PERIOD];
287 rep->delay = d;
288 rep->period = p;
289 return 0;
293 * Helper Functions.
295 static void put_queue(struct vc_data *vc, int ch)
297 struct tty_struct *tty = vc->vc_tty;
299 if (tty) {
300 tty_insert_flip_char(tty, ch, 0);
301 con_schedule_flip(tty);
305 static void puts_queue(struct vc_data *vc, char *cp)
307 struct tty_struct *tty = vc->vc_tty;
309 if (!tty)
310 return;
312 while (*cp) {
313 tty_insert_flip_char(tty, *cp, 0);
314 cp++;
316 con_schedule_flip(tty);
319 static void applkey(struct vc_data *vc, int key, char mode)
321 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
323 buf[1] = (mode ? 'O' : '[');
324 buf[2] = key;
325 puts_queue(vc, buf);
329 * Many other routines do put_queue, but I think either
330 * they produce ASCII, or they produce some user-assigned
331 * string, and in both cases we might assume that it is
332 * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
333 * but we need only 16 bits here
335 static void to_utf8(struct vc_data *vc, ushort c)
337 if (c < 0x80)
338 /* 0******* */
339 put_queue(vc, c);
340 else if (c < 0x800) {
341 /* 110***** 10****** */
342 put_queue(vc, 0xc0 | (c >> 6));
343 put_queue(vc, 0x80 | (c & 0x3f));
344 } else {
345 /* 1110**** 10****** 10****** */
346 put_queue(vc, 0xe0 | (c >> 12));
347 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
348 put_queue(vc, 0x80 | (c & 0x3f));
353 * Called after returning from RAW mode or when changing consoles - recompute
354 * shift_down[] and shift_state from key_down[] maybe called when keymap is
355 * undefined, so that shiftkey release is seen
357 void compute_shiftstate(void)
359 unsigned int i, j, k, sym, val;
361 shift_state = 0;
362 memset(shift_down, 0, sizeof(shift_down));
364 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
366 if (!key_down[i])
367 continue;
369 k = i * BITS_PER_LONG;
371 for (j = 0; j < BITS_PER_LONG; j++, k++) {
373 if (!test_bit(k, key_down))
374 continue;
376 sym = U(key_maps[0][k]);
377 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
378 continue;
380 val = KVAL(sym);
381 if (val == KVAL(K_CAPSSHIFT))
382 val = KVAL(K_SHIFT);
384 shift_down[val]++;
385 shift_state |= (1 << val);
391 * We have a combining character DIACR here, followed by the character CH.
392 * If the combination occurs in the table, return the corresponding value.
393 * Otherwise, if CH is a space or equals DIACR, return DIACR.
394 * Otherwise, conclude that DIACR was not combining after all,
395 * queue it and return CH.
397 static unsigned char handle_diacr(struct vc_data *vc, unsigned char ch)
399 int d = diacr;
400 unsigned int i;
402 diacr = 0;
404 for (i = 0; i < accent_table_size; i++) {
405 if (accent_table[i].diacr == d && accent_table[i].base == ch)
406 return accent_table[i].result;
409 if (ch == ' ' || ch == d)
410 return d;
412 put_queue(vc, d);
413 return ch;
417 * Special function handlers
419 static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
421 if (diacr) {
422 put_queue(vc, diacr);
423 diacr = 0;
425 put_queue(vc, 13);
426 if (vc_kbd_mode(kbd, VC_CRLF))
427 put_queue(vc, 10);
430 static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
432 if (rep)
433 return;
434 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
437 static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
439 if (rep)
440 return;
441 set_vc_kbd_led(kbd, VC_CAPSLOCK);
444 static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
446 if (regs)
447 show_regs(regs);
450 static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
452 struct tty_struct *tty = vc->vc_tty;
454 if (rep || !tty)
455 return;
458 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
459 * these routines are also activated by ^S/^Q.
460 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
462 if (tty->stopped)
463 start_tty(tty);
464 else
465 stop_tty(tty);
468 static void fn_num(struct vc_data *vc, struct pt_regs *regs)
470 if (vc_kbd_mode(kbd,VC_APPLIC))
471 applkey(vc, 'P', 1);
472 else
473 fn_bare_num(vc, regs);
477 * Bind this to Shift-NumLock if you work in application keypad mode
478 * but want to be able to change the NumLock flag.
479 * Bind this to NumLock if you prefer that the NumLock key always
480 * changes the NumLock flag.
482 static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
484 if (!rep)
485 chg_vc_kbd_led(kbd, VC_NUMLOCK);
488 static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
490 /* switch to the last used console, ChN */
491 set_console(last_console);
494 static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
496 int i, cur = fg_console;
498 /* Currently switching? Queue this next switch relative to that. */
499 if (want_console != -1)
500 cur = want_console;
502 for (i = cur - 1; i != cur; i--) {
503 if (i == -1)
504 i = MAX_NR_CONSOLES - 1;
505 if (vc_cons_allocated(i))
506 break;
508 set_console(i);
511 static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
513 int i, cur = fg_console;
515 /* Currently switching? Queue this next switch relative to that. */
516 if (want_console != -1)
517 cur = want_console;
519 for (i = cur+1; i != cur; i++) {
520 if (i == MAX_NR_CONSOLES)
521 i = 0;
522 if (vc_cons_allocated(i))
523 break;
525 set_console(i);
528 static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
530 struct tty_struct *tty = vc->vc_tty;
532 if (!tty)
533 return;
534 tty_insert_flip_char(tty, 0, TTY_BREAK);
535 con_schedule_flip(tty);
538 static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
540 scrollfront(vc, 0);
543 static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
545 scrollback(vc, 0);
548 static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
550 show_mem();
553 static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
555 show_state();
558 static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
560 ctrl_alt_del();
563 static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
565 dead_key_next = 1;
568 static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
570 if (spawnpid)
571 if (kill_proc(spawnpid, spawnsig, 1))
572 spawnpid = 0;
575 static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
577 struct tty_struct *tty = vc->vc_tty;
580 * SAK should also work in all raw modes and reset
581 * them properly.
583 if (tty)
584 do_SAK(tty);
585 reset_vc(vc);
588 static void fn_null(struct vc_data *vc, struct pt_regs *regs)
590 compute_shiftstate();
594 * Special key handlers
596 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
600 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
602 if (up_flag)
603 return;
604 if (value >= ARRAY_SIZE(fn_handler))
605 return;
606 if ((kbd->kbdmode == VC_RAW ||
607 kbd->kbdmode == VC_MEDIUMRAW) &&
608 value != KVAL(K_SAK))
609 return; /* SAK is allowed even in raw mode */
610 fn_handler[value](vc, regs);
613 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
615 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
618 static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
620 if (up_flag)
621 return; /* no action, if this is a key release */
623 if (diacr)
624 value = handle_diacr(vc, value);
626 if (dead_key_next) {
627 dead_key_next = 0;
628 diacr = value;
629 return;
631 put_queue(vc, value);
635 * Handle dead key. Note that we now may have several
636 * dead keys modifying the same character. Very useful
637 * for Vietnamese.
639 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
641 if (up_flag)
642 return;
643 diacr = (diacr ? handle_diacr(vc, value) : value);
647 * Obsolete - for backwards compatibility only
649 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
651 static unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
652 value = ret_diacr[value];
653 k_dead2(vc, value, up_flag, regs);
656 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
658 if (up_flag)
659 return;
660 set_console(value);
663 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
665 unsigned v;
667 if (up_flag)
668 return;
669 v = value;
670 if (v < ARRAY_SIZE(func_table)) {
671 if (func_table[value])
672 puts_queue(vc, func_table[value]);
673 } else
674 printk(KERN_ERR "k_fn called with value=%d\n", value);
677 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
679 static const char *cur_chars = "BDCA";
681 if (up_flag)
682 return;
683 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
686 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
688 static const char *pad_chars = "0123456789+-*/\015,.?()#";
689 static const char *app_map = "pqrstuvwxylSRQMnnmPQS";
691 if (up_flag)
692 return; /* no action, if this is a key release */
694 /* kludge... shift forces cursor/number keys */
695 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
696 applkey(vc, app_map[value], 1);
697 return;
700 if (!vc_kbd_led(kbd, VC_NUMLOCK))
701 switch (value) {
702 case KVAL(K_PCOMMA):
703 case KVAL(K_PDOT):
704 k_fn(vc, KVAL(K_REMOVE), 0, regs);
705 return;
706 case KVAL(K_P0):
707 k_fn(vc, KVAL(K_INSERT), 0, regs);
708 return;
709 case KVAL(K_P1):
710 k_fn(vc, KVAL(K_SELECT), 0, regs);
711 return;
712 case KVAL(K_P2):
713 k_cur(vc, KVAL(K_DOWN), 0, regs);
714 return;
715 case KVAL(K_P3):
716 k_fn(vc, KVAL(K_PGDN), 0, regs);
717 return;
718 case KVAL(K_P4):
719 k_cur(vc, KVAL(K_LEFT), 0, regs);
720 return;
721 case KVAL(K_P6):
722 k_cur(vc, KVAL(K_RIGHT), 0, regs);
723 return;
724 case KVAL(K_P7):
725 k_fn(vc, KVAL(K_FIND), 0, regs);
726 return;
727 case KVAL(K_P8):
728 k_cur(vc, KVAL(K_UP), 0, regs);
729 return;
730 case KVAL(K_P9):
731 k_fn(vc, KVAL(K_PGUP), 0, regs);
732 return;
733 case KVAL(K_P5):
734 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
735 return;
738 put_queue(vc, pad_chars[value]);
739 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
740 put_queue(vc, 10);
743 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
745 int old_state = shift_state;
747 if (rep)
748 return;
750 * Mimic typewriter:
751 * a CapsShift key acts like Shift but undoes CapsLock
753 if (value == KVAL(K_CAPSSHIFT)) {
754 value = KVAL(K_SHIFT);
755 if (!up_flag)
756 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
759 if (up_flag) {
761 * handle the case that two shift or control
762 * keys are depressed simultaneously
764 if (shift_down[value])
765 shift_down[value]--;
766 } else
767 shift_down[value]++;
769 if (shift_down[value])
770 shift_state |= (1 << value);
771 else
772 shift_state &= ~(1 << value);
774 /* kludge */
775 if (up_flag && shift_state != old_state && npadch != -1) {
776 if (kbd->kbdmode == VC_UNICODE)
777 to_utf8(vc, npadch & 0xffff);
778 else
779 put_queue(vc, npadch & 0xff);
780 npadch = -1;
784 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
786 if (up_flag)
787 return;
789 if (vc_kbd_mode(kbd, VC_META)) {
790 put_queue(vc, '\033');
791 put_queue(vc, value);
792 } else
793 put_queue(vc, value | 0x80);
796 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
798 int base;
800 if (up_flag)
801 return;
803 if (value < 10) {
804 /* decimal input of code, while Alt depressed */
805 base = 10;
806 } else {
807 /* hexadecimal input of code, while AltGr depressed */
808 value -= 10;
809 base = 16;
812 if (npadch == -1)
813 npadch = value;
814 else
815 npadch = npadch * base + value;
818 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
820 if (up_flag || rep)
821 return;
822 chg_vc_kbd_lock(kbd, value);
825 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
827 k_shift(vc, value, up_flag, regs);
828 if (up_flag || rep)
829 return;
830 chg_vc_kbd_slock(kbd, value);
831 /* try to make Alt, oops, AltGr and such work */
832 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
833 kbd->slockstate = 0;
834 chg_vc_kbd_slock(kbd, value);
839 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
840 * or (ii) whatever pattern of lights people want to show using KDSETLED,
841 * or (iii) specified bits of specified words in kernel memory.
843 unsigned char getledstate(void)
845 return ledstate;
848 void setledstate(struct kbd_struct *kbd, unsigned int led)
850 if (!(led & ~7)) {
851 ledioctl = led;
852 kbd->ledmode = LED_SHOW_IOCTL;
853 } else
854 kbd->ledmode = LED_SHOW_FLAGS;
855 set_leds();
858 static inline unsigned char getleds(void)
860 struct kbd_struct *kbd = kbd_table + fg_console;
861 unsigned char leds;
862 int i;
864 if (kbd->ledmode == LED_SHOW_IOCTL)
865 return ledioctl;
867 leds = kbd->ledflagstate;
869 if (kbd->ledmode == LED_SHOW_MEM) {
870 for (i = 0; i < 3; i++)
871 if (ledptrs[i].valid) {
872 if (*ledptrs[i].addr & ledptrs[i].mask)
873 leds |= (1 << i);
874 else
875 leds &= ~(1 << i);
878 return leds;
882 * This routine is the bottom half of the keyboard interrupt
883 * routine, and runs with all interrupts enabled. It does
884 * console changing, led setting and copy_to_cooked, which can
885 * take a reasonably long time.
887 * Aside from timing (which isn't really that important for
888 * keyboard interrupts as they happen often), using the software
889 * interrupt routines for this thing allows us to easily mask
890 * this when we don't want any of the above to happen.
891 * This allows for easy and efficient race-condition prevention
892 * for kbd_refresh_leds => input_event(dev, EV_LED, ...) => ...
895 static void kbd_bh(unsigned long dummy)
897 struct list_head *node;
898 unsigned char leds = getleds();
900 if (leds != ledstate) {
901 list_for_each(node, &kbd_handler.h_list) {
902 struct input_handle * handle = to_handle_h(node);
903 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
904 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
905 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
906 input_sync(handle->dev);
910 ledstate = leds;
913 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
916 * This allows a newly plugged keyboard to pick the LED state.
918 static void kbd_refresh_leds(struct input_handle *handle)
920 unsigned char leds = ledstate;
922 tasklet_disable(&keyboard_tasklet);
923 if (leds != 0xff) {
924 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
925 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
926 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
927 input_sync(handle->dev);
929 tasklet_enable(&keyboard_tasklet);
932 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
933 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC32) ||\
934 defined(CONFIG_SPARC64) || defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
935 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
937 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
938 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
940 static unsigned short x86_keycodes[256] =
941 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
942 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
943 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
944 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
945 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
946 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
947 284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
948 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
949 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
950 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
951 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
952 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
953 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
954 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
955 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
957 #ifdef CONFIG_MAC_EMUMOUSEBTN
958 extern int mac_hid_mouse_emulate_buttons(int, int, int);
959 #endif /* CONFIG_MAC_EMUMOUSEBTN */
961 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
962 static int sparc_l1_a_state = 0;
963 extern void sun_do_break(void);
964 #endif
966 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
967 unsigned char up_flag)
969 if (keycode > 255 || !x86_keycodes[keycode])
970 return -1;
972 switch (keycode) {
973 case KEY_PAUSE:
974 put_queue(vc, 0xe1);
975 put_queue(vc, 0x1d | up_flag);
976 put_queue(vc, 0x45 | up_flag);
977 return 0;
978 case KEY_HANGUEL:
979 if (!up_flag) put_queue(vc, 0xf1);
980 return 0;
981 case KEY_HANJA:
982 if (!up_flag) put_queue(vc, 0xf2);
983 return 0;
986 if (keycode == KEY_SYSRQ && sysrq_alt) {
987 put_queue(vc, 0x54 | up_flag);
988 return 0;
991 if (x86_keycodes[keycode] & 0x100)
992 put_queue(vc, 0xe0);
994 put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
996 if (keycode == KEY_SYSRQ) {
997 put_queue(vc, 0xe0);
998 put_queue(vc, 0x37 | up_flag);
1001 return 0;
1004 #else
1006 #define HW_RAW(dev) 0
1008 #warning "Cannot generate rawmode keyboard for your architecture yet."
1010 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1012 if (keycode > 127)
1013 return -1;
1015 put_queue(vc, keycode | up_flag);
1016 return 0;
1018 #endif
1020 static void kbd_rawcode(unsigned char data)
1022 struct vc_data *vc = vc_cons[fg_console].d;
1023 kbd = kbd_table + fg_console;
1024 if (kbd->kbdmode == VC_RAW)
1025 put_queue(vc, data);
1028 static void kbd_keycode(unsigned int keycode, int down,
1029 int hw_raw, struct pt_regs *regs)
1031 struct vc_data *vc = vc_cons[fg_console].d;
1032 unsigned short keysym, *key_map;
1033 unsigned char type, raw_mode;
1034 struct tty_struct *tty;
1035 int shift_final;
1037 tty = vc->vc_tty;
1039 if (tty && (!tty->driver_data)) {
1040 /* No driver data? Strange. Okay we fix it then. */
1041 tty->driver_data = vc;
1044 kbd = kbd_table + fg_console;
1046 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1047 sysrq_alt = down;
1048 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1049 if (keycode == KEY_STOP)
1050 sparc_l1_a_state = down;
1051 #endif
1053 rep = (down == 2);
1055 #ifdef CONFIG_MAC_EMUMOUSEBTN
1056 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1057 return;
1058 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1060 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1061 if (emulate_raw(vc, keycode, !down << 7))
1062 if (keycode < BTN_MISC)
1063 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1065 #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1066 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1067 sysrq_down = down;
1068 return;
1070 if (sysrq_down && down && !rep) {
1071 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1072 return;
1074 #endif
1075 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1076 if (keycode == KEY_A && sparc_l1_a_state) {
1077 sparc_l1_a_state = 0;
1078 sun_do_break();
1080 #endif
1082 if (kbd->kbdmode == VC_MEDIUMRAW) {
1084 * This is extended medium raw mode, with keys above 127
1085 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1086 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1087 * interfere with anything else. The two bytes after 0 will
1088 * always have the up flag set not to interfere with older
1089 * applications. This allows for 16384 different keycodes,
1090 * which should be enough.
1092 if (keycode < 128) {
1093 put_queue(vc, keycode | (!down << 7));
1094 } else {
1095 put_queue(vc, !down << 7);
1096 put_queue(vc, (keycode >> 7) | 0x80);
1097 put_queue(vc, keycode | 0x80);
1099 raw_mode = 1;
1102 if (down)
1103 set_bit(keycode, key_down);
1104 else
1105 clear_bit(keycode, key_down);
1107 if (rep &&
1108 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1109 (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1111 * Don't repeat a key if the input buffers are not empty and the
1112 * characters get aren't echoed locally. This makes key repeat
1113 * usable with slow applications and under heavy loads.
1115 return;
1118 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1119 key_map = key_maps[shift_final];
1121 if (!key_map) {
1122 compute_shiftstate();
1123 kbd->slockstate = 0;
1124 return;
1127 if (keycode > NR_KEYS)
1128 return;
1130 keysym = key_map[keycode];
1131 type = KTYP(keysym);
1133 if (type < 0xf0) {
1134 if (down && !raw_mode)
1135 to_utf8(vc, keysym);
1136 return;
1139 type -= 0xf0;
1141 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1142 return;
1144 if (type == KT_LETTER) {
1145 type = KT_LATIN;
1146 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1147 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1148 if (key_map)
1149 keysym = key_map[keycode];
1153 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1155 if (type != KT_SLOCK)
1156 kbd->slockstate = 0;
1159 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1160 unsigned int event_code, int value)
1162 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1163 kbd_rawcode(value);
1164 if (event_type == EV_KEY)
1165 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1166 tasklet_schedule(&keyboard_tasklet);
1167 do_poke_blanked_console = 1;
1168 schedule_console_callback();
1172 * When a keyboard (or other input device) is found, the kbd_connect
1173 * function is called. The function then looks at the device, and if it
1174 * likes it, it can open it and get events from it. In this (kbd_connect)
1175 * function, we should decide which VT to bind that keyboard to initially.
1177 static struct input_handle *kbd_connect(struct input_handler *handler,
1178 struct input_dev *dev,
1179 struct input_device_id *id)
1181 struct input_handle *handle;
1182 int i;
1184 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1185 if (test_bit(i, dev->keybit))
1186 break;
1188 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1189 return NULL;
1191 if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1192 return NULL;
1193 memset(handle, 0, sizeof(struct input_handle));
1195 handle->dev = dev;
1196 handle->handler = handler;
1197 handle->name = "kbd";
1199 input_open_device(handle);
1200 kbd_refresh_leds(handle);
1202 return handle;
1205 static void kbd_disconnect(struct input_handle *handle)
1207 input_close_device(handle);
1208 kfree(handle);
1211 static struct input_device_id kbd_ids[] = {
1213 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1214 .evbit = { BIT(EV_KEY) },
1218 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1219 .evbit = { BIT(EV_SND) },
1222 { }, /* Terminating entry */
1225 MODULE_DEVICE_TABLE(input, kbd_ids);
1227 static struct input_handler kbd_handler = {
1228 .event = kbd_event,
1229 .connect = kbd_connect,
1230 .disconnect = kbd_disconnect,
1231 .name = "kbd",
1232 .id_table = kbd_ids,
1235 int __init kbd_init(void)
1237 int i;
1239 kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1240 kbd0.ledmode = LED_SHOW_FLAGS;
1241 kbd0.lockstate = KBD_DEFLOCK;
1242 kbd0.slockstate = 0;
1243 kbd0.modeflags = KBD_DEFMODE;
1244 kbd0.kbdmode = VC_XLATE;
1246 for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1247 kbd_table[i] = kbd0;
1249 input_register_handler(&kbd_handler);
1251 tasklet_enable(&keyboard_tasklet);
1252 tasklet_schedule(&keyboard_tasklet);
1254 return 0;