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/consolemap.h>
28 #include <linux/module.h>
29 #include <linux/sched.h>
30 #include <linux/tty.h>
31 #include <linux/tty_flip.h>
33 #include <linux/string.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
36 #include <linux/irq.h>
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 #include <linux/jiffies.h>
47 extern void ctrl_alt_del(void);
49 #define to_handle_h(n) container_of(n, struct input_handle, h_node)
52 * Exported functions/variables
55 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
58 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
59 * This seems a good reason to start with NumLock off. On HIL keyboards
60 * of PARISC machines however there is no NumLock key and everyone expects the keypad
61 * to be used for numbers.
64 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
65 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
72 void compute_shiftstate(void);
79 k_self, k_fn, k_spec, k_pad,\
80 k_dead, k_cons, k_cur, k_shift,\
81 k_meta, k_ascii, k_lock, k_lowercase,\
82 k_slock, k_dead2, k_brl, k_ignore
84 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
86 static k_handler_fn K_HANDLERS;
87 k_handler_fn *k_handler[16] = { K_HANDLERS };
88 EXPORT_SYMBOL_GPL(k_handler);
91 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
92 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
93 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
94 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
95 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
97 typedef void (fn_handler_fn)(struct vc_data *vc);
98 static fn_handler_fn FN_HANDLERS;
99 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
102 * Variables exported for vt_ioctl.c
105 /* maximum values each key_handler can handle */
106 const int max_vals[] = {
107 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
108 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
109 255, NR_LOCK - 1, 255, NR_BRL - 1
112 const int NR_TYPES = ARRAY_SIZE(max_vals);
114 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
115 EXPORT_SYMBOL_GPL(kbd_table);
116 static struct kbd_struct *kbd = kbd_table;
118 struct vt_spawn_console vt_spawn_con = {
119 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
125 * Variables exported for vt.c
134 static struct input_handler kbd_handler;
135 static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
136 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
137 static int dead_key_next;
138 static int npadch = -1; /* -1 or number assembled on pad */
139 static unsigned int diacr;
140 static char rep; /* flag telling character repeat */
142 static unsigned char ledstate = 0xff; /* undefined */
143 static unsigned char ledioctl;
145 static struct ledptr {
148 unsigned char valid:1;
151 /* Simple translation table for the SysRq keys */
153 #ifdef CONFIG_MAGIC_SYSRQ
154 unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
155 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
156 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
157 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
158 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
159 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
160 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
161 "\r\000/"; /* 0x60 - 0x6f */
162 static int sysrq_down;
163 static int sysrq_alt_use;
165 static int sysrq_alt;
168 * Notifier list for console keyboard events
170 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
172 int register_keyboard_notifier(struct notifier_block *nb)
174 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
176 EXPORT_SYMBOL_GPL(register_keyboard_notifier);
178 int unregister_keyboard_notifier(struct notifier_block *nb)
180 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
182 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
185 * Translation of scancodes to keycodes. We set them on only the first
186 * keyboard in the list that accepts the scancode and keycode.
187 * Explanation for not choosing the first attached keyboard anymore:
188 * USB keyboards for example have two event devices: one for all "normal"
189 * keys and one for extra function keys (like "volume up", "make coffee",
190 * etc.). So this means that scancodes for the extra function keys won't
191 * be valid for the first event device, but will be for the second.
193 int getkeycode(unsigned int scancode)
195 struct input_handle *handle;
199 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
200 error = input_get_keycode(handle->dev, scancode, &keycode);
208 int setkeycode(unsigned int scancode, unsigned int keycode)
210 struct input_handle *handle;
213 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
214 error = input_set_keycode(handle->dev, scancode, keycode);
223 * Making beeps and bells.
225 static void kd_nosound(unsigned long ignored)
227 struct input_handle *handle;
229 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
230 if (test_bit(EV_SND, handle->dev->evbit)) {
231 if (test_bit(SND_TONE, handle->dev->sndbit))
232 input_inject_event(handle, EV_SND, SND_TONE, 0);
233 if (test_bit(SND_BELL, handle->dev->sndbit))
234 input_inject_event(handle, EV_SND, SND_BELL, 0);
239 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
241 void kd_mksound(unsigned int hz, unsigned int ticks)
243 struct list_head *node;
245 del_timer(&kd_mksound_timer);
248 list_for_each_prev(node, &kbd_handler.h_list) {
249 struct input_handle *handle = to_handle_h(node);
250 if (test_bit(EV_SND, handle->dev->evbit)) {
251 if (test_bit(SND_TONE, handle->dev->sndbit)) {
252 input_inject_event(handle, EV_SND, SND_TONE, hz);
255 if (test_bit(SND_BELL, handle->dev->sndbit)) {
256 input_inject_event(handle, EV_SND, SND_BELL, 1);
262 mod_timer(&kd_mksound_timer, jiffies + ticks);
266 EXPORT_SYMBOL(kd_mksound);
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
338 static void to_utf8(struct vc_data *vc, uint c)
343 else if (c < 0x800) {
344 /* 110***** 10****** */
345 put_queue(vc, 0xc0 | (c >> 6));
346 put_queue(vc, 0x80 | (c & 0x3f));
347 } else if (c < 0x10000) {
348 if (c >= 0xD800 && c < 0xE000)
352 /* 1110**** 10****** 10****** */
353 put_queue(vc, 0xe0 | (c >> 12));
354 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
355 put_queue(vc, 0x80 | (c & 0x3f));
356 } else if (c < 0x110000) {
357 /* 11110*** 10****** 10****** 10****** */
358 put_queue(vc, 0xf0 | (c >> 18));
359 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
360 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
361 put_queue(vc, 0x80 | (c & 0x3f));
366 * Called after returning from RAW mode or when changing consoles - recompute
367 * shift_down[] and shift_state from key_down[] maybe called when keymap is
368 * undefined, so that shiftkey release is seen
370 void compute_shiftstate(void)
372 unsigned int i, j, k, sym, val;
375 memset(shift_down, 0, sizeof(shift_down));
377 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
382 k = i * BITS_PER_LONG;
384 for (j = 0; j < BITS_PER_LONG; j++, k++) {
386 if (!test_bit(k, key_down))
389 sym = U(key_maps[0][k]);
390 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
394 if (val == KVAL(K_CAPSSHIFT))
398 shift_state |= (1 << val);
404 * We have a combining character DIACR here, followed by the character CH.
405 * If the combination occurs in the table, return the corresponding value.
406 * Otherwise, if CH is a space or equals DIACR, return DIACR.
407 * Otherwise, conclude that DIACR was not combining after all,
408 * queue it and return CH.
410 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
412 unsigned int d = diacr;
417 if ((d & ~0xff) == BRL_UC_ROW) {
418 if ((ch & ~0xff) == BRL_UC_ROW)
421 for (i = 0; i < accent_table_size; i++)
422 if (accent_table[i].diacr == d && accent_table[i].base == ch)
423 return accent_table[i].result;
426 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
429 if (kbd->kbdmode == VC_UNICODE)
432 int c = conv_uni_to_8bit(d);
441 * Special function handlers
443 static void fn_enter(struct vc_data *vc)
446 if (kbd->kbdmode == VC_UNICODE)
449 int c = conv_uni_to_8bit(diacr);
456 if (vc_kbd_mode(kbd, VC_CRLF))
460 static void fn_caps_toggle(struct vc_data *vc)
464 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
467 static void fn_caps_on(struct vc_data *vc)
471 set_vc_kbd_led(kbd, VC_CAPSLOCK);
474 static void fn_show_ptregs(struct vc_data *vc)
476 struct pt_regs *regs = get_irq_regs();
481 static void fn_hold(struct vc_data *vc)
483 struct tty_struct *tty = vc->vc_tty;
489 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
490 * these routines are also activated by ^S/^Q.
491 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
499 static void fn_num(struct vc_data *vc)
501 if (vc_kbd_mode(kbd,VC_APPLIC))
508 * Bind this to Shift-NumLock if you work in application keypad mode
509 * but want to be able to change the NumLock flag.
510 * Bind this to NumLock if you prefer that the NumLock key always
511 * changes the NumLock flag.
513 static void fn_bare_num(struct vc_data *vc)
516 chg_vc_kbd_led(kbd, VC_NUMLOCK);
519 static void fn_lastcons(struct vc_data *vc)
521 /* switch to the last used console, ChN */
522 set_console(last_console);
525 static void fn_dec_console(struct vc_data *vc)
527 int i, cur = fg_console;
529 /* Currently switching? Queue this next switch relative to that. */
530 if (want_console != -1)
533 for (i = cur - 1; i != cur; i--) {
535 i = MAX_NR_CONSOLES - 1;
536 if (vc_cons_allocated(i))
542 static void fn_inc_console(struct vc_data *vc)
544 int i, cur = fg_console;
546 /* Currently switching? Queue this next switch relative to that. */
547 if (want_console != -1)
550 for (i = cur+1; i != cur; i++) {
551 if (i == MAX_NR_CONSOLES)
553 if (vc_cons_allocated(i))
559 static void fn_send_intr(struct vc_data *vc)
561 struct tty_struct *tty = vc->vc_tty;
565 tty_insert_flip_char(tty, 0, TTY_BREAK);
566 con_schedule_flip(tty);
569 static void fn_scroll_forw(struct vc_data *vc)
574 static void fn_scroll_back(struct vc_data *vc)
579 static void fn_show_mem(struct vc_data *vc)
584 static void fn_show_state(struct vc_data *vc)
589 static void fn_boot_it(struct vc_data *vc)
594 static void fn_compose(struct vc_data *vc)
599 static void fn_spawn_con(struct vc_data *vc)
601 spin_lock(&vt_spawn_con.lock);
602 if (vt_spawn_con.pid)
603 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
604 put_pid(vt_spawn_con.pid);
605 vt_spawn_con.pid = NULL;
607 spin_unlock(&vt_spawn_con.lock);
610 static void fn_SAK(struct vc_data *vc)
612 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
613 schedule_work(SAK_work);
616 static void fn_null(struct vc_data *vc)
618 compute_shiftstate();
622 * Special key handlers
624 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
628 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
632 if (value >= ARRAY_SIZE(fn_handler))
634 if ((kbd->kbdmode == VC_RAW ||
635 kbd->kbdmode == VC_MEDIUMRAW) &&
636 value != KVAL(K_SAK))
637 return; /* SAK is allowed even in raw mode */
638 fn_handler[value](vc);
641 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
643 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
646 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
649 return; /* no action, if this is a key release */
652 value = handle_diacr(vc, value);
659 if (kbd->kbdmode == VC_UNICODE)
662 int c = conv_uni_to_8bit(value);
669 * Handle dead key. Note that we now may have several
670 * dead keys modifying the same character. Very useful
673 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
677 diacr = (diacr ? handle_diacr(vc, value) : value);
680 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
683 if (kbd->kbdmode == VC_UNICODE)
686 uni = conv_8bit_to_uni(value);
687 k_unicode(vc, uni, up_flag);
690 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
692 k_deadunicode(vc, value, up_flag);
696 * Obsolete - for backwards compatibility only
698 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
700 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
701 value = ret_diacr[value];
702 k_deadunicode(vc, value, up_flag);
705 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
712 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
719 if (v < ARRAY_SIZE(func_table)) {
720 if (func_table[value])
721 puts_queue(vc, func_table[value]);
723 printk(KERN_ERR "k_fn called with value=%d\n", value);
726 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
728 static const char cur_chars[] = "BDCA";
732 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
735 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
737 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
738 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
741 return; /* no action, if this is a key release */
743 /* kludge... shift forces cursor/number keys */
744 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
745 applkey(vc, app_map[value], 1);
749 if (!vc_kbd_led(kbd, VC_NUMLOCK))
753 k_fn(vc, KVAL(K_REMOVE), 0);
756 k_fn(vc, KVAL(K_INSERT), 0);
759 k_fn(vc, KVAL(K_SELECT), 0);
762 k_cur(vc, KVAL(K_DOWN), 0);
765 k_fn(vc, KVAL(K_PGDN), 0);
768 k_cur(vc, KVAL(K_LEFT), 0);
771 k_cur(vc, KVAL(K_RIGHT), 0);
774 k_fn(vc, KVAL(K_FIND), 0);
777 k_cur(vc, KVAL(K_UP), 0);
780 k_fn(vc, KVAL(K_PGUP), 0);
783 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
787 put_queue(vc, pad_chars[value]);
788 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
792 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
794 int old_state = shift_state;
800 * a CapsShift key acts like Shift but undoes CapsLock
802 if (value == KVAL(K_CAPSSHIFT)) {
803 value = KVAL(K_SHIFT);
805 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
810 * handle the case that two shift or control
811 * keys are depressed simultaneously
813 if (shift_down[value])
818 if (shift_down[value])
819 shift_state |= (1 << value);
821 shift_state &= ~(1 << value);
824 if (up_flag && shift_state != old_state && npadch != -1) {
825 if (kbd->kbdmode == VC_UNICODE)
828 put_queue(vc, npadch & 0xff);
833 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
838 if (vc_kbd_mode(kbd, VC_META)) {
839 put_queue(vc, '\033');
840 put_queue(vc, value);
842 put_queue(vc, value | 0x80);
845 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
853 /* decimal input of code, while Alt depressed */
856 /* hexadecimal input of code, while AltGr depressed */
864 npadch = npadch * base + value;
867 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
871 chg_vc_kbd_lock(kbd, value);
874 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
876 k_shift(vc, value, up_flag);
879 chg_vc_kbd_slock(kbd, value);
880 /* try to make Alt, oops, AltGr and such work */
881 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
883 chg_vc_kbd_slock(kbd, value);
887 /* by default, 300ms interval for combination release */
888 static unsigned brl_timeout = 300;
889 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
890 module_param(brl_timeout, uint, 0644);
892 static unsigned brl_nbchords = 1;
893 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
894 module_param(brl_nbchords, uint, 0644);
896 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
898 static unsigned long chords;
899 static unsigned committed;
902 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
904 committed |= pattern;
906 if (chords == brl_nbchords) {
907 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
914 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
916 static unsigned pressed,committing;
917 static unsigned long releasestart;
919 if (kbd->kbdmode != VC_UNICODE) {
921 printk("keyboard mode must be unicode for braille patterns\n");
926 k_unicode(vc, BRL_UC_ROW, up_flag);
937 releasestart + msecs_to_jiffies(brl_timeout))) {
938 committing = pressed;
939 releasestart = jiffies;
941 pressed &= ~(1 << (value - 1));
944 k_brlcommit(vc, committing, 0);
950 k_brlcommit(vc, committing, 0);
953 pressed &= ~(1 << (value - 1));
956 pressed |= 1 << (value - 1);
958 committing = pressed;
963 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
964 * or (ii) whatever pattern of lights people want to show using KDSETLED,
965 * or (iii) specified bits of specified words in kernel memory.
967 unsigned char getledstate(void)
972 void setledstate(struct kbd_struct *kbd, unsigned int led)
976 kbd->ledmode = LED_SHOW_IOCTL;
978 kbd->ledmode = LED_SHOW_FLAGS;
982 static inline unsigned char getleds(void)
984 struct kbd_struct *kbd = kbd_table + fg_console;
988 if (kbd->ledmode == LED_SHOW_IOCTL)
991 leds = kbd->ledflagstate;
993 if (kbd->ledmode == LED_SHOW_MEM) {
994 for (i = 0; i < 3; i++)
995 if (ledptrs[i].valid) {
996 if (*ledptrs[i].addr & ledptrs[i].mask)
1006 * This routine is the bottom half of the keyboard interrupt
1007 * routine, and runs with all interrupts enabled. It does
1008 * console changing, led setting and copy_to_cooked, which can
1009 * take a reasonably long time.
1011 * Aside from timing (which isn't really that important for
1012 * keyboard interrupts as they happen often), using the software
1013 * interrupt routines for this thing allows us to easily mask
1014 * this when we don't want any of the above to happen.
1015 * This allows for easy and efficient race-condition prevention
1016 * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
1019 static void kbd_bh(unsigned long dummy)
1021 struct list_head *node;
1022 unsigned char leds = getleds();
1024 if (leds != ledstate) {
1025 list_for_each(node, &kbd_handler.h_list) {
1026 struct input_handle *handle = to_handle_h(node);
1027 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1028 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1029 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1030 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1037 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1039 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1040 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1041 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1042 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1043 defined(CONFIG_AVR32)
1045 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1046 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1048 static const unsigned short x86_keycodes[256] =
1049 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1050 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1051 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1052 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1053 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1054 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1055 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1056 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1057 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1058 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1059 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1060 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1061 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1062 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1063 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1066 static int sparc_l1_a_state = 0;
1067 extern void sun_do_break(void);
1070 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1071 unsigned char up_flag)
1077 put_queue(vc, 0xe1);
1078 put_queue(vc, 0x1d | up_flag);
1079 put_queue(vc, 0x45 | up_flag);
1084 put_queue(vc, 0xf2);
1089 put_queue(vc, 0xf1);
1094 * Real AT keyboards (that's what we're trying
1095 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1096 * pressing PrtSc/SysRq alone, but simply 0x54
1097 * when pressing Alt+PrtSc/SysRq.
1100 put_queue(vc, 0x54 | up_flag);
1102 put_queue(vc, 0xe0);
1103 put_queue(vc, 0x2a | up_flag);
1104 put_queue(vc, 0xe0);
1105 put_queue(vc, 0x37 | up_flag);
1113 code = x86_keycodes[keycode];
1118 put_queue(vc, 0xe0);
1119 put_queue(vc, (code & 0x7f) | up_flag);
1129 #define HW_RAW(dev) 0
1131 #warning "Cannot generate rawmode keyboard for your architecture yet."
1133 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1138 put_queue(vc, keycode | up_flag);
1143 static void kbd_rawcode(unsigned char data)
1145 struct vc_data *vc = vc_cons[fg_console].d;
1146 kbd = kbd_table + fg_console;
1147 if (kbd->kbdmode == VC_RAW)
1148 put_queue(vc, data);
1151 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1153 struct vc_data *vc = vc_cons[fg_console].d;
1154 unsigned short keysym, *key_map;
1155 unsigned char type, raw_mode;
1156 struct tty_struct *tty;
1158 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1162 if (tty && (!tty->driver_data)) {
1163 /* No driver data? Strange. Okay we fix it then. */
1164 tty->driver_data = vc;
1167 kbd = kbd_table + fg_console;
1169 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1170 sysrq_alt = down ? keycode : 0;
1172 if (keycode == KEY_STOP)
1173 sparc_l1_a_state = down;
1178 #ifdef CONFIG_MAC_EMUMOUSEBTN
1179 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1181 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1183 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1184 if (emulate_raw(vc, keycode, !down << 7))
1185 if (keycode < BTN_MISC && printk_ratelimit())
1186 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1188 #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1189 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1192 sysrq_alt_use = sysrq_alt;
1196 if (sysrq_down && !down && keycode == sysrq_alt_use)
1198 if (sysrq_down && down && !rep) {
1199 handle_sysrq(kbd_sysrq_xlate[keycode], tty);
1204 if (keycode == KEY_A && sparc_l1_a_state) {
1205 sparc_l1_a_state = 0;
1210 if (kbd->kbdmode == VC_MEDIUMRAW) {
1212 * This is extended medium raw mode, with keys above 127
1213 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1214 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1215 * interfere with anything else. The two bytes after 0 will
1216 * always have the up flag set not to interfere with older
1217 * applications. This allows for 16384 different keycodes,
1218 * which should be enough.
1220 if (keycode < 128) {
1221 put_queue(vc, keycode | (!down << 7));
1223 put_queue(vc, !down << 7);
1224 put_queue(vc, (keycode >> 7) | 0x80);
1225 put_queue(vc, keycode | 0x80);
1231 set_bit(keycode, key_down);
1233 clear_bit(keycode, key_down);
1236 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1237 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
1239 * Don't repeat a key if the input buffers are not empty and the
1240 * characters get aren't echoed locally. This makes key repeat
1241 * usable with slow applications and under heavy loads.
1246 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1247 param.ledstate = kbd->ledflagstate;
1248 key_map = key_maps[shift_final];
1250 if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_KEYCODE, ¶m) == NOTIFY_STOP || !key_map) {
1251 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_UNBOUND_KEYCODE, ¶m);
1252 compute_shiftstate();
1253 kbd->slockstate = 0;
1257 if (keycode > NR_KEYS)
1258 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1259 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1263 keysym = key_map[keycode];
1265 type = KTYP(keysym);
1268 param.value = keysym;
1269 if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_UNICODE, ¶m) == NOTIFY_STOP)
1271 if (down && !raw_mode)
1272 to_utf8(vc, keysym);
1278 if (type == KT_LETTER) {
1280 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1281 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1283 keysym = key_map[keycode];
1286 param.value = keysym;
1288 if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_KEYSYM, ¶m) == NOTIFY_STOP)
1291 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1294 (*k_handler[type])(vc, keysym & 0xff, !down);
1296 param.ledstate = kbd->ledflagstate;
1297 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, ¶m);
1299 if (type != KT_SLOCK)
1300 kbd->slockstate = 0;
1303 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1304 unsigned int event_code, int value)
1306 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1308 if (event_type == EV_KEY)
1309 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1310 tasklet_schedule(&keyboard_tasklet);
1311 do_poke_blanked_console = 1;
1312 schedule_console_callback();
1316 * When a keyboard (or other input device) is found, the kbd_connect
1317 * function is called. The function then looks at the device, and if it
1318 * likes it, it can open it and get events from it. In this (kbd_connect)
1319 * function, we should decide which VT to bind that keyboard to initially.
1321 static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1322 const struct input_device_id *id)
1324 struct input_handle *handle;
1328 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1329 if (test_bit(i, dev->keybit))
1332 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1335 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1340 handle->handler = handler;
1341 handle->name = "kbd";
1343 error = input_register_handle(handle);
1345 goto err_free_handle;
1347 error = input_open_device(handle);
1349 goto err_unregister_handle;
1353 err_unregister_handle:
1354 input_unregister_handle(handle);
1360 static void kbd_disconnect(struct input_handle *handle)
1362 input_close_device(handle);
1363 input_unregister_handle(handle);
1368 * Start keyboard handler on the new keyboard by refreshing LED state to
1369 * match the rest of the system.
1371 static void kbd_start(struct input_handle *handle)
1373 unsigned char leds = ledstate;
1375 tasklet_disable(&keyboard_tasklet);
1377 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1378 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1379 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1380 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1382 tasklet_enable(&keyboard_tasklet);
1385 static const struct input_device_id kbd_ids[] = {
1387 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1388 .evbit = { BIT_MASK(EV_KEY) },
1392 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1393 .evbit = { BIT_MASK(EV_SND) },
1396 { }, /* Terminating entry */
1399 MODULE_DEVICE_TABLE(input, kbd_ids);
1401 static struct input_handler kbd_handler = {
1403 .connect = kbd_connect,
1404 .disconnect = kbd_disconnect,
1407 .id_table = kbd_ids,
1410 int __init kbd_init(void)
1415 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1416 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1417 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1418 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1419 kbd_table[i].lockstate = KBD_DEFLOCK;
1420 kbd_table[i].slockstate = 0;
1421 kbd_table[i].modeflags = KBD_DEFMODE;
1422 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1425 error = input_register_handler(&kbd_handler);
1429 tasklet_enable(&keyboard_tasklet);
1430 tasklet_schedule(&keyboard_tasklet);