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/module.h>
28 #include <linux/sched.h>
29 #include <linux/tty.h>
30 #include <linux/tty_flip.h>
32 #include <linux/string.h>
33 #include <linux/init.h>
34 #include <linux/slab.h>
36 #include <linux/kbd_kern.h>
37 #include <linux/kbd_diacr.h>
38 #include <linux/vt_kern.h>
39 #include <linux/sysrq.h>
40 #include <linux/input.h>
41 #include <linux/reboot.h>
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)
67 void compute_shiftstate(void);
74 k_self, k_fn, k_spec, k_pad,\
75 k_dead, k_cons, k_cur, k_shift,\
76 k_meta, k_ascii, k_lock, k_lowercase,\
77 k_slock, k_dead2, k_brl, k_ignore
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 };
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, NR_BRL - 1
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;
111 struct vt_spawn_console vt_spawn_con = {
112 .lock = SPIN_LOCK_UNLOCKED,
118 * Variables exported for vt.c
127 static struct input_handler kbd_handler;
128 static unsigned long key_down[NBITS(KEY_MAX)]; /* keyboard key bitmap */
129 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
130 static int dead_key_next;
131 static int npadch = -1; /* -1 or number assembled on pad */
132 static unsigned int diacr;
133 static char rep; /* flag telling character repeat */
135 static unsigned char ledstate = 0xff; /* undefined */
136 static unsigned char ledioctl;
138 static struct ledptr {
141 unsigned char valid:1;
144 /* Simple translation table for the SysRq keys */
146 #ifdef CONFIG_MAGIC_SYSRQ
147 unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
148 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
149 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
150 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
151 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
152 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
153 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
154 "\r\000/"; /* 0x60 - 0x6f */
155 static int sysrq_down;
156 static int sysrq_alt_use;
158 static int sysrq_alt;
161 * Translation of scancodes to keycodes. We set them on only the first attached
162 * keyboard - for per-keyboard setting, /dev/input/event is more useful.
164 int getkeycode(unsigned int scancode)
166 struct list_head *node;
167 struct input_dev *dev = NULL;
169 list_for_each(node, &kbd_handler.h_list) {
170 struct input_handle *handle = to_handle_h(node);
171 if (handle->dev->keycodesize) {
180 if (scancode >= dev->keycodemax)
183 return INPUT_KEYCODE(dev, scancode);
186 int setkeycode(unsigned int scancode, unsigned int keycode)
188 struct list_head *node;
189 struct input_dev *dev = NULL;
190 unsigned int i, oldkey;
192 list_for_each(node, &kbd_handler.h_list) {
193 struct input_handle *handle = to_handle_h(node);
194 if (handle->dev->keycodesize) {
203 if (scancode >= dev->keycodemax)
205 if (keycode < 0 || keycode > KEY_MAX)
207 if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
210 oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
212 clear_bit(oldkey, dev->keybit);
213 set_bit(keycode, dev->keybit);
215 for (i = 0; i < dev->keycodemax; i++)
216 if (INPUT_KEYCODE(dev,i) == oldkey)
217 set_bit(oldkey, dev->keybit);
223 * Making beeps and bells.
225 static void kd_nosound(unsigned long ignored)
227 struct list_head *node;
229 list_for_each(node, &kbd_handler.h_list) {
230 struct input_handle *handle = to_handle_h(node);
231 if (test_bit(EV_SND, handle->dev->evbit)) {
232 if (test_bit(SND_TONE, handle->dev->sndbit))
233 input_inject_event(handle, EV_SND, SND_TONE, 0);
234 if (test_bit(SND_BELL, handle->dev->sndbit))
235 input_inject_event(handle, EV_SND, SND_BELL, 0);
240 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
242 void kd_mksound(unsigned int hz, unsigned int ticks)
244 struct list_head *node;
246 del_timer(&kd_mksound_timer);
249 list_for_each_prev(node, &kbd_handler.h_list) {
250 struct input_handle *handle = to_handle_h(node);
251 if (test_bit(EV_SND, handle->dev->evbit)) {
252 if (test_bit(SND_TONE, handle->dev->sndbit)) {
253 input_inject_event(handle, EV_SND, SND_TONE, hz);
256 if (test_bit(SND_BELL, handle->dev->sndbit)) {
257 input_inject_event(handle, EV_SND, SND_BELL, 1);
263 mod_timer(&kd_mksound_timer, jiffies + ticks);
269 * Setting the keyboard rate.
272 int kbd_rate(struct kbd_repeat *rep)
274 struct list_head *node;
278 list_for_each(node, &kbd_handler.h_list) {
279 struct input_handle *handle = to_handle_h(node);
280 struct input_dev *dev = handle->dev;
282 if (test_bit(EV_REP, dev->evbit)) {
284 input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
286 input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
287 d = dev->rep[REP_DELAY];
288 p = dev->rep[REP_PERIOD];
299 static void put_queue(struct vc_data *vc, int ch)
301 struct tty_struct *tty = vc->vc_tty;
304 tty_insert_flip_char(tty, ch, 0);
305 con_schedule_flip(tty);
309 static void puts_queue(struct vc_data *vc, char *cp)
311 struct tty_struct *tty = vc->vc_tty;
317 tty_insert_flip_char(tty, *cp, 0);
320 con_schedule_flip(tty);
323 static void applkey(struct vc_data *vc, int key, char mode)
325 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
327 buf[1] = (mode ? 'O' : '[');
333 * Many other routines do put_queue, but I think either
334 * they produce ASCII, or they produce some user-assigned
335 * string, and in both cases we might assume that it is
336 * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
337 * but we need only 16 bits here
339 static void to_utf8(struct vc_data *vc, ushort c)
344 else if (c < 0x800) {
345 /* 110***** 10****** */
346 put_queue(vc, 0xc0 | (c >> 6));
347 put_queue(vc, 0x80 | (c & 0x3f));
349 /* 1110**** 10****** 10****** */
350 put_queue(vc, 0xe0 | (c >> 12));
351 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
352 put_queue(vc, 0x80 | (c & 0x3f));
357 * Called after returning from RAW mode or when changing consoles - recompute
358 * shift_down[] and shift_state from key_down[] maybe called when keymap is
359 * undefined, so that shiftkey release is seen
361 void compute_shiftstate(void)
363 unsigned int i, j, k, sym, val;
366 memset(shift_down, 0, sizeof(shift_down));
368 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
373 k = i * BITS_PER_LONG;
375 for (j = 0; j < BITS_PER_LONG; j++, k++) {
377 if (!test_bit(k, key_down))
380 sym = U(key_maps[0][k]);
381 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
385 if (val == KVAL(K_CAPSSHIFT))
389 shift_state |= (1 << val);
395 * We have a combining character DIACR here, followed by the character CH.
396 * If the combination occurs in the table, return the corresponding value.
397 * Otherwise, if CH is a space or equals DIACR, return DIACR.
398 * Otherwise, conclude that DIACR was not combining after all,
399 * queue it and return CH.
401 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
403 unsigned int d = diacr;
408 if ((d & ~0xff) == BRL_UC_ROW) {
409 if ((ch & ~0xff) == BRL_UC_ROW)
412 for (i = 0; i < accent_table_size; i++)
413 if (accent_table[i].diacr == d && accent_table[i].base == ch)
414 return accent_table[i].result;
417 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
420 if (kbd->kbdmode == VC_UNICODE)
429 * Special function handlers
431 static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
434 if (kbd->kbdmode == VC_UNICODE)
436 else if (diacr < 0x100)
437 put_queue(vc, diacr);
441 if (vc_kbd_mode(kbd, VC_CRLF))
445 static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
449 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
452 static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
456 set_vc_kbd_led(kbd, VC_CAPSLOCK);
459 static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
465 static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
467 struct tty_struct *tty = vc->vc_tty;
473 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
474 * these routines are also activated by ^S/^Q.
475 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
483 static void fn_num(struct vc_data *vc, struct pt_regs *regs)
485 if (vc_kbd_mode(kbd,VC_APPLIC))
488 fn_bare_num(vc, regs);
492 * Bind this to Shift-NumLock if you work in application keypad mode
493 * but want to be able to change the NumLock flag.
494 * Bind this to NumLock if you prefer that the NumLock key always
495 * changes the NumLock flag.
497 static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
500 chg_vc_kbd_led(kbd, VC_NUMLOCK);
503 static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
505 /* switch to the last used console, ChN */
506 set_console(last_console);
509 static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
511 int i, cur = fg_console;
513 /* Currently switching? Queue this next switch relative to that. */
514 if (want_console != -1)
517 for (i = cur - 1; i != cur; i--) {
519 i = MAX_NR_CONSOLES - 1;
520 if (vc_cons_allocated(i))
526 static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
528 int i, cur = fg_console;
530 /* Currently switching? Queue this next switch relative to that. */
531 if (want_console != -1)
534 for (i = cur+1; i != cur; i++) {
535 if (i == MAX_NR_CONSOLES)
537 if (vc_cons_allocated(i))
543 static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
545 struct tty_struct *tty = vc->vc_tty;
549 tty_insert_flip_char(tty, 0, TTY_BREAK);
550 con_schedule_flip(tty);
553 static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
558 static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
563 static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
568 static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
573 static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
578 static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
583 static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
585 spin_lock(&vt_spawn_con.lock);
586 if (vt_spawn_con.pid)
587 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
588 put_pid(vt_spawn_con.pid);
589 vt_spawn_con.pid = NULL;
591 spin_unlock(&vt_spawn_con.lock);
594 static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
596 struct tty_struct *tty = vc->vc_tty;
599 * SAK should also work in all raw modes and reset
607 static void fn_null(struct vc_data *vc, struct pt_regs *regs)
609 compute_shiftstate();
613 * Special key handlers
615 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
619 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
623 if (value >= ARRAY_SIZE(fn_handler))
625 if ((kbd->kbdmode == VC_RAW ||
626 kbd->kbdmode == VC_MEDIUMRAW) &&
627 value != KVAL(K_SAK))
628 return; /* SAK is allowed even in raw mode */
629 fn_handler[value](vc, regs);
632 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
634 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
637 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
640 return; /* no action, if this is a key release */
643 value = handle_diacr(vc, value);
650 if (kbd->kbdmode == VC_UNICODE)
652 else if (value < 0x100)
653 put_queue(vc, value);
657 * Handle dead key. Note that we now may have several
658 * dead keys modifying the same character. Very useful
661 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
665 diacr = (diacr ? handle_diacr(vc, value) : value);
668 static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
670 k_unicode(vc, value, up_flag, regs);
673 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
675 k_deadunicode(vc, value, up_flag, regs);
679 * Obsolete - for backwards compatibility only
681 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
683 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
684 value = ret_diacr[value];
685 k_deadunicode(vc, value, up_flag, regs);
688 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
695 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
702 if (v < ARRAY_SIZE(func_table)) {
703 if (func_table[value])
704 puts_queue(vc, func_table[value]);
706 printk(KERN_ERR "k_fn called with value=%d\n", value);
709 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
711 static const char *cur_chars = "BDCA";
715 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
718 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
720 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
721 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
724 return; /* no action, if this is a key release */
726 /* kludge... shift forces cursor/number keys */
727 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
728 applkey(vc, app_map[value], 1);
732 if (!vc_kbd_led(kbd, VC_NUMLOCK))
736 k_fn(vc, KVAL(K_REMOVE), 0, regs);
739 k_fn(vc, KVAL(K_INSERT), 0, regs);
742 k_fn(vc, KVAL(K_SELECT), 0, regs);
745 k_cur(vc, KVAL(K_DOWN), 0, regs);
748 k_fn(vc, KVAL(K_PGDN), 0, regs);
751 k_cur(vc, KVAL(K_LEFT), 0, regs);
754 k_cur(vc, KVAL(K_RIGHT), 0, regs);
757 k_fn(vc, KVAL(K_FIND), 0, regs);
760 k_cur(vc, KVAL(K_UP), 0, regs);
763 k_fn(vc, KVAL(K_PGUP), 0, regs);
766 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
770 put_queue(vc, pad_chars[value]);
771 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
775 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
777 int old_state = shift_state;
783 * a CapsShift key acts like Shift but undoes CapsLock
785 if (value == KVAL(K_CAPSSHIFT)) {
786 value = KVAL(K_SHIFT);
788 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
793 * handle the case that two shift or control
794 * keys are depressed simultaneously
796 if (shift_down[value])
801 if (shift_down[value])
802 shift_state |= (1 << value);
804 shift_state &= ~(1 << value);
807 if (up_flag && shift_state != old_state && npadch != -1) {
808 if (kbd->kbdmode == VC_UNICODE)
809 to_utf8(vc, npadch & 0xffff);
811 put_queue(vc, npadch & 0xff);
816 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
821 if (vc_kbd_mode(kbd, VC_META)) {
822 put_queue(vc, '\033');
823 put_queue(vc, value);
825 put_queue(vc, value | 0x80);
828 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
836 /* decimal input of code, while Alt depressed */
839 /* hexadecimal input of code, while AltGr depressed */
847 npadch = npadch * base + value;
850 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
854 chg_vc_kbd_lock(kbd, value);
857 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
859 k_shift(vc, value, up_flag, regs);
862 chg_vc_kbd_slock(kbd, value);
863 /* try to make Alt, oops, AltGr and such work */
864 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
866 chg_vc_kbd_slock(kbd, value);
870 /* by default, 300ms interval for combination release */
871 static unsigned brl_timeout = 300;
872 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
873 module_param(brl_timeout, uint, 0644);
875 static unsigned brl_nbchords = 1;
876 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
877 module_param(brl_nbchords, uint, 0644);
879 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag, struct pt_regs *regs)
881 static unsigned long chords;
882 static unsigned committed;
885 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag, regs);
887 committed |= pattern;
889 if (chords == brl_nbchords) {
890 k_unicode(vc, BRL_UC_ROW | committed, up_flag, regs);
897 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
899 static unsigned pressed,committing;
900 static unsigned long releasestart;
902 if (kbd->kbdmode != VC_UNICODE) {
904 printk("keyboard mode must be unicode for braille patterns\n");
909 k_unicode(vc, BRL_UC_ROW, up_flag, regs);
919 jiffies - releasestart > (brl_timeout * HZ) / 1000) {
920 committing = pressed;
921 releasestart = jiffies;
923 pressed &= ~(1 << (value - 1));
926 k_brlcommit(vc, committing, 0, regs);
932 k_brlcommit(vc, committing, 0, regs);
935 pressed &= ~(1 << (value - 1));
938 pressed |= 1 << (value - 1);
940 committing = pressed;
945 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
946 * or (ii) whatever pattern of lights people want to show using KDSETLED,
947 * or (iii) specified bits of specified words in kernel memory.
949 unsigned char getledstate(void)
954 void setledstate(struct kbd_struct *kbd, unsigned int led)
958 kbd->ledmode = LED_SHOW_IOCTL;
960 kbd->ledmode = LED_SHOW_FLAGS;
964 static inline unsigned char getleds(void)
966 struct kbd_struct *kbd = kbd_table + fg_console;
970 if (kbd->ledmode == LED_SHOW_IOCTL)
973 leds = kbd->ledflagstate;
975 if (kbd->ledmode == LED_SHOW_MEM) {
976 for (i = 0; i < 3; i++)
977 if (ledptrs[i].valid) {
978 if (*ledptrs[i].addr & ledptrs[i].mask)
988 * This routine is the bottom half of the keyboard interrupt
989 * routine, and runs with all interrupts enabled. It does
990 * console changing, led setting and copy_to_cooked, which can
991 * take a reasonably long time.
993 * Aside from timing (which isn't really that important for
994 * keyboard interrupts as they happen often), using the software
995 * interrupt routines for this thing allows us to easily mask
996 * this when we don't want any of the above to happen.
997 * This allows for easy and efficient race-condition prevention
998 * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
1001 static void kbd_bh(unsigned long dummy)
1003 struct list_head *node;
1004 unsigned char leds = getleds();
1006 if (leds != ledstate) {
1007 list_for_each(node, &kbd_handler.h_list) {
1008 struct input_handle *handle = to_handle_h(node);
1009 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1010 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1011 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1012 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1019 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1021 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1022 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1023 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1024 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1026 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1027 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1029 static const unsigned short x86_keycodes[256] =
1030 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1031 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1032 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1033 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1034 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1035 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1036 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1037 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1038 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1039 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1040 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1041 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1042 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1043 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1044 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1046 #ifdef CONFIG_MAC_EMUMOUSEBTN
1047 extern int mac_hid_mouse_emulate_buttons(int, int, int);
1048 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1051 static int sparc_l1_a_state = 0;
1052 extern void sun_do_break(void);
1055 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1056 unsigned char up_flag)
1062 put_queue(vc, 0xe1);
1063 put_queue(vc, 0x1d | up_flag);
1064 put_queue(vc, 0x45 | up_flag);
1069 put_queue(vc, 0xf2);
1074 put_queue(vc, 0xf1);
1079 * Real AT keyboards (that's what we're trying
1080 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1081 * pressing PrtSc/SysRq alone, but simply 0x54
1082 * when pressing Alt+PrtSc/SysRq.
1085 put_queue(vc, 0x54 | up_flag);
1087 put_queue(vc, 0xe0);
1088 put_queue(vc, 0x2a | up_flag);
1089 put_queue(vc, 0xe0);
1090 put_queue(vc, 0x37 | up_flag);
1098 code = x86_keycodes[keycode];
1103 put_queue(vc, 0xe0);
1104 put_queue(vc, (code & 0x7f) | up_flag);
1114 #define HW_RAW(dev) 0
1116 #warning "Cannot generate rawmode keyboard for your architecture yet."
1118 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1123 put_queue(vc, keycode | up_flag);
1128 static void kbd_rawcode(unsigned char data)
1130 struct vc_data *vc = vc_cons[fg_console].d;
1131 kbd = kbd_table + fg_console;
1132 if (kbd->kbdmode == VC_RAW)
1133 put_queue(vc, data);
1136 static void kbd_keycode(unsigned int keycode, int down,
1137 int hw_raw, struct pt_regs *regs)
1139 struct vc_data *vc = vc_cons[fg_console].d;
1140 unsigned short keysym, *key_map;
1141 unsigned char type, raw_mode;
1142 struct tty_struct *tty;
1147 if (tty && (!tty->driver_data)) {
1148 /* No driver data? Strange. Okay we fix it then. */
1149 tty->driver_data = vc;
1152 kbd = kbd_table + fg_console;
1154 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1155 sysrq_alt = down ? keycode : 0;
1157 if (keycode == KEY_STOP)
1158 sparc_l1_a_state = down;
1163 #ifdef CONFIG_MAC_EMUMOUSEBTN
1164 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1166 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1168 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1169 if (emulate_raw(vc, keycode, !down << 7))
1170 if (keycode < BTN_MISC)
1171 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1173 #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1174 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1177 sysrq_alt_use = sysrq_alt;
1181 if (sysrq_down && !down && keycode == sysrq_alt_use)
1183 if (sysrq_down && down && !rep) {
1184 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1189 if (keycode == KEY_A && sparc_l1_a_state) {
1190 sparc_l1_a_state = 0;
1195 if (kbd->kbdmode == VC_MEDIUMRAW) {
1197 * This is extended medium raw mode, with keys above 127
1198 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1199 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1200 * interfere with anything else. The two bytes after 0 will
1201 * always have the up flag set not to interfere with older
1202 * applications. This allows for 16384 different keycodes,
1203 * which should be enough.
1205 if (keycode < 128) {
1206 put_queue(vc, keycode | (!down << 7));
1208 put_queue(vc, !down << 7);
1209 put_queue(vc, (keycode >> 7) | 0x80);
1210 put_queue(vc, keycode | 0x80);
1216 set_bit(keycode, key_down);
1218 clear_bit(keycode, key_down);
1221 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1222 (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1224 * Don't repeat a key if the input buffers are not empty and the
1225 * characters get aren't echoed locally. This makes key repeat
1226 * usable with slow applications and under heavy loads.
1231 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1232 key_map = key_maps[shift_final];
1235 compute_shiftstate();
1236 kbd->slockstate = 0;
1240 if (keycode > NR_KEYS)
1241 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1242 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1246 keysym = key_map[keycode];
1248 type = KTYP(keysym);
1251 if (down && !raw_mode)
1252 to_utf8(vc, keysym);
1258 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1261 if (type == KT_LETTER) {
1263 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1264 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1266 keysym = key_map[keycode];
1270 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1272 if (type != KT_SLOCK)
1273 kbd->slockstate = 0;
1276 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1277 unsigned int event_code, int value)
1279 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1281 if (event_type == EV_KEY)
1282 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1283 tasklet_schedule(&keyboard_tasklet);
1284 do_poke_blanked_console = 1;
1285 schedule_console_callback();
1289 * When a keyboard (or other input device) is found, the kbd_connect
1290 * function is called. The function then looks at the device, and if it
1291 * likes it, it can open it and get events from it. In this (kbd_connect)
1292 * function, we should decide which VT to bind that keyboard to initially.
1294 static struct input_handle *kbd_connect(struct input_handler *handler,
1295 struct input_dev *dev,
1296 struct input_device_id *id)
1298 struct input_handle *handle;
1301 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1302 if (test_bit(i, dev->keybit))
1305 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1308 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1313 handle->handler = handler;
1314 handle->name = "kbd";
1316 input_open_device(handle);
1321 static void kbd_disconnect(struct input_handle *handle)
1323 input_close_device(handle);
1328 * Start keyboard handler on the new keyboard by refreshing LED state to
1329 * match the rest of the system.
1331 static void kbd_start(struct input_handle *handle)
1333 unsigned char leds = ledstate;
1335 tasklet_disable(&keyboard_tasklet);
1337 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1338 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1339 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1340 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1342 tasklet_enable(&keyboard_tasklet);
1345 static struct input_device_id kbd_ids[] = {
1347 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1348 .evbit = { BIT(EV_KEY) },
1352 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1353 .evbit = { BIT(EV_SND) },
1356 { }, /* Terminating entry */
1359 MODULE_DEVICE_TABLE(input, kbd_ids);
1361 static struct input_handler kbd_handler = {
1363 .connect = kbd_connect,
1364 .disconnect = kbd_disconnect,
1367 .id_table = kbd_ids,
1370 int __init kbd_init(void)
1374 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1375 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1376 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1377 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1378 kbd_table[i].lockstate = KBD_DEFLOCK;
1379 kbd_table[i].slockstate = 0;
1380 kbd_table[i].modeflags = KBD_DEFMODE;
1381 kbd_table[i].kbdmode = VC_XLATE;
1384 input_register_handler(&kbd_handler);
1386 tasklet_enable(&keyboard_tasklet);
1387 tasklet_schedule(&keyboard_tasklet);