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;
110 static struct kbd_struct kbd0;
112 int spawnpid, spawnsig;
115 * Variables exported for vt.c
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 int 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 {
138 unsigned char valid:1;
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 static int sysrq_alt_use;
155 static int sysrq_alt;
158 * Translation of scancodes to keycodes. We set them on only the first attached
159 * keyboard - for per-keyboard setting, /dev/input/event is more useful.
161 int getkeycode(unsigned int scancode)
163 struct list_head *node;
164 struct input_dev *dev = NULL;
166 list_for_each(node, &kbd_handler.h_list) {
167 struct input_handle *handle = to_handle_h(node);
168 if (handle->dev->keycodesize) {
177 if (scancode >= dev->keycodemax)
180 return INPUT_KEYCODE(dev, scancode);
183 int setkeycode(unsigned int scancode, unsigned int keycode)
185 struct list_head *node;
186 struct input_dev *dev = NULL;
187 unsigned int i, oldkey;
189 list_for_each(node, &kbd_handler.h_list) {
190 struct input_handle *handle = to_handle_h(node);
191 if (handle->dev->keycodesize) {
200 if (scancode >= dev->keycodemax)
202 if (keycode < 0 || keycode > KEY_MAX)
204 if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
207 oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
209 clear_bit(oldkey, dev->keybit);
210 set_bit(keycode, dev->keybit);
212 for (i = 0; i < dev->keycodemax; i++)
213 if (INPUT_KEYCODE(dev,i) == oldkey)
214 set_bit(oldkey, dev->keybit);
220 * Making beeps and bells.
222 static void kd_nosound(unsigned long ignored)
224 struct list_head *node;
226 list_for_each(node, &kbd_handler.h_list) {
227 struct input_handle *handle = to_handle_h(node);
228 if (test_bit(EV_SND, handle->dev->evbit)) {
229 if (test_bit(SND_TONE, handle->dev->sndbit))
230 input_inject_event(handle, EV_SND, SND_TONE, 0);
231 if (test_bit(SND_BELL, handle->dev->sndbit))
232 input_inject_event(handle, EV_SND, SND_BELL, 0);
237 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
239 void kd_mksound(unsigned int hz, unsigned int ticks)
241 struct list_head *node;
243 del_timer(&kd_mksound_timer);
246 list_for_each_prev(node, &kbd_handler.h_list) {
247 struct input_handle *handle = to_handle_h(node);
248 if (test_bit(EV_SND, handle->dev->evbit)) {
249 if (test_bit(SND_TONE, handle->dev->sndbit)) {
250 input_inject_event(handle, EV_SND, SND_TONE, hz);
253 if (test_bit(SND_BELL, handle->dev->sndbit)) {
254 input_inject_event(handle, EV_SND, SND_BELL, 1);
260 mod_timer(&kd_mksound_timer, jiffies + ticks);
266 * Setting the keyboard rate.
269 int kbd_rate(struct kbd_repeat *rep)
271 struct list_head *node;
275 list_for_each(node, &kbd_handler.h_list) {
276 struct input_handle *handle = to_handle_h(node);
277 struct input_dev *dev = handle->dev;
279 if (test_bit(EV_REP, dev->evbit)) {
281 input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
283 input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
284 d = dev->rep[REP_DELAY];
285 p = dev->rep[REP_PERIOD];
296 static void put_queue(struct vc_data *vc, int ch)
298 struct tty_struct *tty = vc->vc_tty;
301 tty_insert_flip_char(tty, ch, 0);
302 con_schedule_flip(tty);
306 static void puts_queue(struct vc_data *vc, char *cp)
308 struct tty_struct *tty = vc->vc_tty;
314 tty_insert_flip_char(tty, *cp, 0);
317 con_schedule_flip(tty);
320 static void applkey(struct vc_data *vc, int key, char mode)
322 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
324 buf[1] = (mode ? 'O' : '[');
330 * Many other routines do put_queue, but I think either
331 * they produce ASCII, or they produce some user-assigned
332 * string, and in both cases we might assume that it is
333 * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
334 * but we need only 16 bits here
336 static void to_utf8(struct vc_data *vc, ushort c)
341 else if (c < 0x800) {
342 /* 110***** 10****** */
343 put_queue(vc, 0xc0 | (c >> 6));
344 put_queue(vc, 0x80 | (c & 0x3f));
346 /* 1110**** 10****** 10****** */
347 put_queue(vc, 0xe0 | (c >> 12));
348 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
349 put_queue(vc, 0x80 | (c & 0x3f));
354 * Called after returning from RAW mode or when changing consoles - recompute
355 * shift_down[] and shift_state from key_down[] maybe called when keymap is
356 * undefined, so that shiftkey release is seen
358 void compute_shiftstate(void)
360 unsigned int i, j, k, sym, val;
363 memset(shift_down, 0, sizeof(shift_down));
365 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
370 k = i * BITS_PER_LONG;
372 for (j = 0; j < BITS_PER_LONG; j++, k++) {
374 if (!test_bit(k, key_down))
377 sym = U(key_maps[0][k]);
378 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
382 if (val == KVAL(K_CAPSSHIFT))
386 shift_state |= (1 << val);
392 * We have a combining character DIACR here, followed by the character CH.
393 * If the combination occurs in the table, return the corresponding value.
394 * Otherwise, if CH is a space or equals DIACR, return DIACR.
395 * Otherwise, conclude that DIACR was not combining after all,
396 * queue it and return CH.
398 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
400 unsigned int d = diacr;
405 if ((d & ~0xff) == BRL_UC_ROW) {
406 if ((ch & ~0xff) == BRL_UC_ROW)
409 for (i = 0; i < accent_table_size; i++)
410 if (accent_table[i].diacr == d && accent_table[i].base == ch)
411 return accent_table[i].result;
414 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
417 if (kbd->kbdmode == VC_UNICODE)
426 * Special function handlers
428 static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
431 if (kbd->kbdmode == VC_UNICODE)
433 else if (diacr < 0x100)
434 put_queue(vc, diacr);
438 if (vc_kbd_mode(kbd, VC_CRLF))
442 static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
446 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
449 static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
453 set_vc_kbd_led(kbd, VC_CAPSLOCK);
456 static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
462 static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
464 struct tty_struct *tty = vc->vc_tty;
470 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
471 * these routines are also activated by ^S/^Q.
472 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
480 static void fn_num(struct vc_data *vc, struct pt_regs *regs)
482 if (vc_kbd_mode(kbd,VC_APPLIC))
485 fn_bare_num(vc, regs);
489 * Bind this to Shift-NumLock if you work in application keypad mode
490 * but want to be able to change the NumLock flag.
491 * Bind this to NumLock if you prefer that the NumLock key always
492 * changes the NumLock flag.
494 static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
497 chg_vc_kbd_led(kbd, VC_NUMLOCK);
500 static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
502 /* switch to the last used console, ChN */
503 set_console(last_console);
506 static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
508 int i, cur = fg_console;
510 /* Currently switching? Queue this next switch relative to that. */
511 if (want_console != -1)
514 for (i = cur - 1; i != cur; i--) {
516 i = MAX_NR_CONSOLES - 1;
517 if (vc_cons_allocated(i))
523 static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
525 int i, cur = fg_console;
527 /* Currently switching? Queue this next switch relative to that. */
528 if (want_console != -1)
531 for (i = cur+1; i != cur; i++) {
532 if (i == MAX_NR_CONSOLES)
534 if (vc_cons_allocated(i))
540 static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
542 struct tty_struct *tty = vc->vc_tty;
546 tty_insert_flip_char(tty, 0, TTY_BREAK);
547 con_schedule_flip(tty);
550 static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
555 static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
560 static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
565 static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
570 static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
575 static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
580 static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
583 if (kill_proc(spawnpid, spawnsig, 1))
587 static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
589 struct tty_struct *tty = vc->vc_tty;
592 * SAK should also work in all raw modes and reset
600 static void fn_null(struct vc_data *vc, struct pt_regs *regs)
602 compute_shiftstate();
606 * Special key handlers
608 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
612 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
616 if (value >= ARRAY_SIZE(fn_handler))
618 if ((kbd->kbdmode == VC_RAW ||
619 kbd->kbdmode == VC_MEDIUMRAW) &&
620 value != KVAL(K_SAK))
621 return; /* SAK is allowed even in raw mode */
622 fn_handler[value](vc, regs);
625 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
627 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
630 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
633 return; /* no action, if this is a key release */
636 value = handle_diacr(vc, value);
643 if (kbd->kbdmode == VC_UNICODE)
645 else if (value < 0x100)
646 put_queue(vc, value);
650 * Handle dead key. Note that we now may have several
651 * dead keys modifying the same character. Very useful
654 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
658 diacr = (diacr ? handle_diacr(vc, value) : value);
661 static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
663 k_unicode(vc, value, up_flag, regs);
666 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
668 k_deadunicode(vc, value, up_flag, regs);
672 * Obsolete - for backwards compatibility only
674 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
676 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
677 value = ret_diacr[value];
678 k_deadunicode(vc, value, up_flag, regs);
681 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
688 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
695 if (v < ARRAY_SIZE(func_table)) {
696 if (func_table[value])
697 puts_queue(vc, func_table[value]);
699 printk(KERN_ERR "k_fn called with value=%d\n", value);
702 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
704 static const char *cur_chars = "BDCA";
708 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
711 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
713 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
714 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
717 return; /* no action, if this is a key release */
719 /* kludge... shift forces cursor/number keys */
720 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
721 applkey(vc, app_map[value], 1);
725 if (!vc_kbd_led(kbd, VC_NUMLOCK))
729 k_fn(vc, KVAL(K_REMOVE), 0, regs);
732 k_fn(vc, KVAL(K_INSERT), 0, regs);
735 k_fn(vc, KVAL(K_SELECT), 0, regs);
738 k_cur(vc, KVAL(K_DOWN), 0, regs);
741 k_fn(vc, KVAL(K_PGDN), 0, regs);
744 k_cur(vc, KVAL(K_LEFT), 0, regs);
747 k_cur(vc, KVAL(K_RIGHT), 0, regs);
750 k_fn(vc, KVAL(K_FIND), 0, regs);
753 k_cur(vc, KVAL(K_UP), 0, regs);
756 k_fn(vc, KVAL(K_PGUP), 0, regs);
759 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
763 put_queue(vc, pad_chars[value]);
764 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
768 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
770 int old_state = shift_state;
776 * a CapsShift key acts like Shift but undoes CapsLock
778 if (value == KVAL(K_CAPSSHIFT)) {
779 value = KVAL(K_SHIFT);
781 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
786 * handle the case that two shift or control
787 * keys are depressed simultaneously
789 if (shift_down[value])
794 if (shift_down[value])
795 shift_state |= (1 << value);
797 shift_state &= ~(1 << value);
800 if (up_flag && shift_state != old_state && npadch != -1) {
801 if (kbd->kbdmode == VC_UNICODE)
802 to_utf8(vc, npadch & 0xffff);
804 put_queue(vc, npadch & 0xff);
809 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
814 if (vc_kbd_mode(kbd, VC_META)) {
815 put_queue(vc, '\033');
816 put_queue(vc, value);
818 put_queue(vc, value | 0x80);
821 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
829 /* decimal input of code, while Alt depressed */
832 /* hexadecimal input of code, while AltGr depressed */
840 npadch = npadch * base + value;
843 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
847 chg_vc_kbd_lock(kbd, value);
850 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
852 k_shift(vc, value, up_flag, regs);
855 chg_vc_kbd_slock(kbd, value);
856 /* try to make Alt, oops, AltGr and such work */
857 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
859 chg_vc_kbd_slock(kbd, value);
863 /* by default, 300ms interval for combination release */
864 static unsigned brl_timeout = 300;
865 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
866 module_param(brl_timeout, uint, 0644);
868 static unsigned brl_nbchords = 1;
869 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
870 module_param(brl_nbchords, uint, 0644);
872 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag, struct pt_regs *regs)
874 static unsigned long chords;
875 static unsigned committed;
878 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag, regs);
880 committed |= pattern;
882 if (chords == brl_nbchords) {
883 k_unicode(vc, BRL_UC_ROW | committed, up_flag, regs);
890 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
892 static unsigned pressed,committing;
893 static unsigned long releasestart;
895 if (kbd->kbdmode != VC_UNICODE) {
897 printk("keyboard mode must be unicode for braille patterns\n");
902 k_unicode(vc, BRL_UC_ROW, up_flag, regs);
912 jiffies - releasestart > (brl_timeout * HZ) / 1000) {
913 committing = pressed;
914 releasestart = jiffies;
916 pressed &= ~(1 << (value - 1));
919 k_brlcommit(vc, committing, 0, regs);
925 k_brlcommit(vc, committing, 0, regs);
928 pressed &= ~(1 << (value - 1));
931 pressed |= 1 << (value - 1);
933 committing = pressed;
938 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
939 * or (ii) whatever pattern of lights people want to show using KDSETLED,
940 * or (iii) specified bits of specified words in kernel memory.
942 unsigned char getledstate(void)
947 void setledstate(struct kbd_struct *kbd, unsigned int led)
951 kbd->ledmode = LED_SHOW_IOCTL;
953 kbd->ledmode = LED_SHOW_FLAGS;
957 static inline unsigned char getleds(void)
959 struct kbd_struct *kbd = kbd_table + fg_console;
963 if (kbd->ledmode == LED_SHOW_IOCTL)
966 leds = kbd->ledflagstate;
968 if (kbd->ledmode == LED_SHOW_MEM) {
969 for (i = 0; i < 3; i++)
970 if (ledptrs[i].valid) {
971 if (*ledptrs[i].addr & ledptrs[i].mask)
981 * This routine is the bottom half of the keyboard interrupt
982 * routine, and runs with all interrupts enabled. It does
983 * console changing, led setting and copy_to_cooked, which can
984 * take a reasonably long time.
986 * Aside from timing (which isn't really that important for
987 * keyboard interrupts as they happen often), using the software
988 * interrupt routines for this thing allows us to easily mask
989 * this when we don't want any of the above to happen.
990 * This allows for easy and efficient race-condition prevention
991 * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
994 static void kbd_bh(unsigned long dummy)
996 struct list_head *node;
997 unsigned char leds = getleds();
999 if (leds != ledstate) {
1000 list_for_each(node, &kbd_handler.h_list) {
1001 struct input_handle *handle = to_handle_h(node);
1002 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1003 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1004 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1005 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1012 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1014 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1015 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1016 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1017 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1019 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1020 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1022 static const unsigned short x86_keycodes[256] =
1023 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1024 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1025 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1026 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1027 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1028 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1029 284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
1030 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1031 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1032 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1033 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1034 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1035 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1036 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1037 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1039 #ifdef CONFIG_MAC_EMUMOUSEBTN
1040 extern int mac_hid_mouse_emulate_buttons(int, int, int);
1041 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1044 static int sparc_l1_a_state = 0;
1045 extern void sun_do_break(void);
1048 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1049 unsigned char up_flag)
1051 if (keycode > 255 || !x86_keycodes[keycode])
1056 put_queue(vc, 0xe1);
1057 put_queue(vc, 0x1d | up_flag);
1058 put_queue(vc, 0x45 | up_flag);
1062 put_queue(vc, 0xf2);
1066 put_queue(vc, 0xf1);
1070 if (keycode == KEY_SYSRQ && sysrq_alt) {
1071 put_queue(vc, 0x54 | up_flag);
1075 if (x86_keycodes[keycode] & 0x100)
1076 put_queue(vc, 0xe0);
1078 put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
1080 if (keycode == KEY_SYSRQ) {
1081 put_queue(vc, 0xe0);
1082 put_queue(vc, 0x37 | up_flag);
1090 #define HW_RAW(dev) 0
1092 #warning "Cannot generate rawmode keyboard for your architecture yet."
1094 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1099 put_queue(vc, keycode | up_flag);
1104 static void kbd_rawcode(unsigned char data)
1106 struct vc_data *vc = vc_cons[fg_console].d;
1107 kbd = kbd_table + fg_console;
1108 if (kbd->kbdmode == VC_RAW)
1109 put_queue(vc, data);
1112 static void kbd_keycode(unsigned int keycode, int down,
1113 int hw_raw, struct pt_regs *regs)
1115 struct vc_data *vc = vc_cons[fg_console].d;
1116 unsigned short keysym, *key_map;
1117 unsigned char type, raw_mode;
1118 struct tty_struct *tty;
1123 if (tty && (!tty->driver_data)) {
1124 /* No driver data? Strange. Okay we fix it then. */
1125 tty->driver_data = vc;
1128 kbd = kbd_table + fg_console;
1130 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1131 sysrq_alt = down ? keycode : 0;
1133 if (keycode == KEY_STOP)
1134 sparc_l1_a_state = down;
1139 #ifdef CONFIG_MAC_EMUMOUSEBTN
1140 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1142 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1144 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1145 if (emulate_raw(vc, keycode, !down << 7))
1146 if (keycode < BTN_MISC)
1147 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1149 #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1150 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1153 sysrq_alt_use = sysrq_alt;
1157 if (sysrq_down && !down && keycode == sysrq_alt_use)
1159 if (sysrq_down && down && !rep) {
1160 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1165 if (keycode == KEY_A && sparc_l1_a_state) {
1166 sparc_l1_a_state = 0;
1171 if (kbd->kbdmode == VC_MEDIUMRAW) {
1173 * This is extended medium raw mode, with keys above 127
1174 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1175 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1176 * interfere with anything else. The two bytes after 0 will
1177 * always have the up flag set not to interfere with older
1178 * applications. This allows for 16384 different keycodes,
1179 * which should be enough.
1181 if (keycode < 128) {
1182 put_queue(vc, keycode | (!down << 7));
1184 put_queue(vc, !down << 7);
1185 put_queue(vc, (keycode >> 7) | 0x80);
1186 put_queue(vc, keycode | 0x80);
1192 set_bit(keycode, key_down);
1194 clear_bit(keycode, key_down);
1197 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1198 (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1200 * Don't repeat a key if the input buffers are not empty and the
1201 * characters get aren't echoed locally. This makes key repeat
1202 * usable with slow applications and under heavy loads.
1207 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1208 key_map = key_maps[shift_final];
1211 compute_shiftstate();
1212 kbd->slockstate = 0;
1216 if (keycode > NR_KEYS)
1217 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1218 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1222 keysym = key_map[keycode];
1224 type = KTYP(keysym);
1227 if (down && !raw_mode)
1228 to_utf8(vc, keysym);
1234 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1237 if (type == KT_LETTER) {
1239 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1240 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1242 keysym = key_map[keycode];
1246 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1248 if (type != KT_SLOCK)
1249 kbd->slockstate = 0;
1252 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1253 unsigned int event_code, int value)
1255 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1257 if (event_type == EV_KEY)
1258 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1259 tasklet_schedule(&keyboard_tasklet);
1260 do_poke_blanked_console = 1;
1261 schedule_console_callback();
1265 * When a keyboard (or other input device) is found, the kbd_connect
1266 * function is called. The function then looks at the device, and if it
1267 * likes it, it can open it and get events from it. In this (kbd_connect)
1268 * function, we should decide which VT to bind that keyboard to initially.
1270 static struct input_handle *kbd_connect(struct input_handler *handler,
1271 struct input_dev *dev,
1272 struct input_device_id *id)
1274 struct input_handle *handle;
1277 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1278 if (test_bit(i, dev->keybit))
1281 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1284 if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1286 memset(handle, 0, sizeof(struct input_handle));
1289 handle->handler = handler;
1290 handle->name = "kbd";
1292 input_open_device(handle);
1297 static void kbd_disconnect(struct input_handle *handle)
1299 input_close_device(handle);
1304 * Start keyboard handler on the new keyboard by refreshing LED state to
1305 * match the rest of the system.
1307 static void kbd_start(struct input_handle *handle)
1309 unsigned char leds = ledstate;
1311 tasklet_disable(&keyboard_tasklet);
1313 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1314 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1315 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1316 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1318 tasklet_enable(&keyboard_tasklet);
1321 static struct input_device_id kbd_ids[] = {
1323 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1324 .evbit = { BIT(EV_KEY) },
1328 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1329 .evbit = { BIT(EV_SND) },
1332 { }, /* Terminating entry */
1335 MODULE_DEVICE_TABLE(input, kbd_ids);
1337 static struct input_handler kbd_handler = {
1339 .connect = kbd_connect,
1340 .disconnect = kbd_disconnect,
1343 .id_table = kbd_ids,
1346 int __init kbd_init(void)
1350 kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1351 kbd0.ledmode = LED_SHOW_FLAGS;
1352 kbd0.lockstate = KBD_DEFLOCK;
1353 kbd0.slockstate = 0;
1354 kbd0.modeflags = KBD_DEFMODE;
1355 kbd0.kbdmode = VC_XLATE;
1357 for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1358 kbd_table[i] = kbd0;
1360 input_register_handler(&kbd_handler);
1362 tasklet_enable(&keyboard_tasklet);
1363 tasklet_schedule(&keyboard_tasklet);