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>
35 #include <linux/irq.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>
42 #include <linux/reboot.h>
44 static void kbd_disconnect(struct input_handle *handle);
45 extern void ctrl_alt_del(void);
48 * Exported functions/variables
51 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
54 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
55 * This seems a good reason to start with NumLock off. On HIL keyboards
56 * of PARISC machines however there is no NumLock key and everyone expects the keypad
57 * to be used for numbers.
60 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
61 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
68 void compute_shiftstate(void);
75 k_self, k_fn, k_spec, k_pad,\
76 k_dead, k_cons, k_cur, k_shift,\
77 k_meta, k_ascii, k_lock, k_lowercase,\
78 k_slock, k_dead2, k_brl, k_ignore
80 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
82 static k_handler_fn K_HANDLERS;
83 static k_handler_fn *k_handler[16] = { K_HANDLERS };
86 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
87 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
88 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
89 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
90 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
92 typedef void (fn_handler_fn)(struct vc_data *vc);
93 static fn_handler_fn FN_HANDLERS;
94 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
97 * Variables exported for vt_ioctl.c
100 /* maximum values each key_handler can handle */
101 const int max_vals[] = {
102 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
103 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
104 255, NR_LOCK - 1, 255, NR_BRL - 1
107 const int NR_TYPES = ARRAY_SIZE(max_vals);
109 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
110 static struct kbd_struct *kbd = kbd_table;
112 struct vt_spawn_console vt_spawn_con = {
113 .lock = SPIN_LOCK_UNLOCKED,
119 * Variables exported for vt.c
128 static struct input_handler kbd_handler;
129 static unsigned long key_down[NBITS(KEY_MAX)]; /* keyboard key bitmap */
130 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
131 static int dead_key_next;
132 static int npadch = -1; /* -1 or number assembled on pad */
133 static unsigned int diacr;
134 static char rep; /* flag telling character repeat */
136 static unsigned char ledstate = 0xff; /* undefined */
137 static unsigned char ledioctl;
139 static struct ledptr {
142 unsigned char valid:1;
145 /* Simple translation table for the SysRq keys */
147 #ifdef CONFIG_MAGIC_SYSRQ
148 unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
149 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
150 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
151 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
152 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
153 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
154 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
155 "\r\000/"; /* 0x60 - 0x6f */
156 static int sysrq_down;
157 static int sysrq_alt_use;
159 static int sysrq_alt;
162 * Translation of scancodes to keycodes. We set them on only the first
163 * keyboard in the list that accepts the scancode and keycode.
164 * Explanation for not choosing the first attached keyboard anymore:
165 * USB keyboards for example have two event devices: one for all "normal"
166 * keys and one for extra function keys (like "volume up", "make coffee",
167 * etc.). So this means that scancodes for the extra function keys won't
168 * be valid for the first event device, but will be for the second.
170 int getkeycode(unsigned int scancode)
172 struct input_handle *handle;
176 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
177 error = handle->dev->getkeycode(handle->dev, scancode, &keycode);
185 int setkeycode(unsigned int scancode, unsigned int keycode)
187 struct input_handle *handle;
190 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
191 error = handle->dev->setkeycode(handle->dev, scancode, keycode);
200 * Making beeps and bells.
202 static void kd_nosound(unsigned long ignored)
204 struct input_handle *handle;
206 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
207 if (test_bit(EV_SND, handle->dev->evbit)) {
208 if (test_bit(SND_TONE, handle->dev->sndbit))
209 input_inject_event(handle, EV_SND, SND_TONE, 0);
210 if (test_bit(SND_BELL, handle->dev->sndbit))
211 input_inject_event(handle, EV_SND, SND_BELL, 0);
216 static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
218 void kd_mksound(unsigned int hz, unsigned int ticks)
220 struct list_head *node;
222 del_timer(&kd_mksound_timer);
225 list_for_each_prev(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_inject_event(handle, EV_SND, SND_TONE, hz);
232 if (test_bit(SND_BELL, handle->dev->sndbit)) {
233 input_inject_event(handle, EV_SND, SND_BELL, 1);
239 mod_timer(&kd_mksound_timer, jiffies + ticks);
245 * Setting the keyboard rate.
248 int kbd_rate(struct kbd_repeat *rep)
250 struct list_head *node;
254 list_for_each(node, &kbd_handler.h_list) {
255 struct input_handle *handle = to_handle_h(node);
256 struct input_dev *dev = handle->dev;
258 if (test_bit(EV_REP, dev->evbit)) {
260 input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
262 input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
263 d = dev->rep[REP_DELAY];
264 p = dev->rep[REP_PERIOD];
275 static void put_queue(struct vc_data *vc, int ch)
277 struct tty_struct *tty = vc->vc_tty;
280 tty_insert_flip_char(tty, ch, 0);
281 con_schedule_flip(tty);
285 static void puts_queue(struct vc_data *vc, char *cp)
287 struct tty_struct *tty = vc->vc_tty;
293 tty_insert_flip_char(tty, *cp, 0);
296 con_schedule_flip(tty);
299 static void applkey(struct vc_data *vc, int key, char mode)
301 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
303 buf[1] = (mode ? 'O' : '[');
309 * Many other routines do put_queue, but I think either
310 * they produce ASCII, or they produce some user-assigned
311 * string, and in both cases we might assume that it is
312 * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
313 * but we need only 16 bits here
315 static void to_utf8(struct vc_data *vc, ushort c)
320 else if (c < 0x800) {
321 /* 110***** 10****** */
322 put_queue(vc, 0xc0 | (c >> 6));
323 put_queue(vc, 0x80 | (c & 0x3f));
325 /* 1110**** 10****** 10****** */
326 put_queue(vc, 0xe0 | (c >> 12));
327 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
328 put_queue(vc, 0x80 | (c & 0x3f));
333 * Called after returning from RAW mode or when changing consoles - recompute
334 * shift_down[] and shift_state from key_down[] maybe called when keymap is
335 * undefined, so that shiftkey release is seen
337 void compute_shiftstate(void)
339 unsigned int i, j, k, sym, val;
342 memset(shift_down, 0, sizeof(shift_down));
344 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
349 k = i * BITS_PER_LONG;
351 for (j = 0; j < BITS_PER_LONG; j++, k++) {
353 if (!test_bit(k, key_down))
356 sym = U(key_maps[0][k]);
357 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
361 if (val == KVAL(K_CAPSSHIFT))
365 shift_state |= (1 << val);
371 * We have a combining character DIACR here, followed by the character CH.
372 * If the combination occurs in the table, return the corresponding value.
373 * Otherwise, if CH is a space or equals DIACR, return DIACR.
374 * Otherwise, conclude that DIACR was not combining after all,
375 * queue it and return CH.
377 static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
379 unsigned int d = diacr;
384 if ((d & ~0xff) == BRL_UC_ROW) {
385 if ((ch & ~0xff) == BRL_UC_ROW)
388 for (i = 0; i < accent_table_size; i++)
389 if (accent_table[i].diacr == d && accent_table[i].base == ch)
390 return accent_table[i].result;
393 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
396 if (kbd->kbdmode == VC_UNICODE)
405 * Special function handlers
407 static void fn_enter(struct vc_data *vc)
410 if (kbd->kbdmode == VC_UNICODE)
412 else if (diacr < 0x100)
413 put_queue(vc, diacr);
417 if (vc_kbd_mode(kbd, VC_CRLF))
421 static void fn_caps_toggle(struct vc_data *vc)
425 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
428 static void fn_caps_on(struct vc_data *vc)
432 set_vc_kbd_led(kbd, VC_CAPSLOCK);
435 static void fn_show_ptregs(struct vc_data *vc)
437 struct pt_regs *regs = get_irq_regs();
442 static void fn_hold(struct vc_data *vc)
444 struct tty_struct *tty = vc->vc_tty;
450 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
451 * these routines are also activated by ^S/^Q.
452 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
460 static void fn_num(struct vc_data *vc)
462 if (vc_kbd_mode(kbd,VC_APPLIC))
469 * Bind this to Shift-NumLock if you work in application keypad mode
470 * but want to be able to change the NumLock flag.
471 * Bind this to NumLock if you prefer that the NumLock key always
472 * changes the NumLock flag.
474 static void fn_bare_num(struct vc_data *vc)
477 chg_vc_kbd_led(kbd, VC_NUMLOCK);
480 static void fn_lastcons(struct vc_data *vc)
482 /* switch to the last used console, ChN */
483 set_console(last_console);
486 static void fn_dec_console(struct vc_data *vc)
488 int i, cur = fg_console;
490 /* Currently switching? Queue this next switch relative to that. */
491 if (want_console != -1)
494 for (i = cur - 1; i != cur; i--) {
496 i = MAX_NR_CONSOLES - 1;
497 if (vc_cons_allocated(i))
503 static void fn_inc_console(struct vc_data *vc)
505 int i, cur = fg_console;
507 /* Currently switching? Queue this next switch relative to that. */
508 if (want_console != -1)
511 for (i = cur+1; i != cur; i++) {
512 if (i == MAX_NR_CONSOLES)
514 if (vc_cons_allocated(i))
520 static void fn_send_intr(struct vc_data *vc)
522 struct tty_struct *tty = vc->vc_tty;
526 tty_insert_flip_char(tty, 0, TTY_BREAK);
527 con_schedule_flip(tty);
530 static void fn_scroll_forw(struct vc_data *vc)
535 static void fn_scroll_back(struct vc_data *vc)
540 static void fn_show_mem(struct vc_data *vc)
545 static void fn_show_state(struct vc_data *vc)
550 static void fn_boot_it(struct vc_data *vc)
555 static void fn_compose(struct vc_data *vc)
560 static void fn_spawn_con(struct vc_data *vc)
562 spin_lock(&vt_spawn_con.lock);
563 if (vt_spawn_con.pid)
564 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
565 put_pid(vt_spawn_con.pid);
566 vt_spawn_con.pid = NULL;
568 spin_unlock(&vt_spawn_con.lock);
571 static void fn_SAK(struct vc_data *vc)
573 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
574 schedule_work(SAK_work);
577 static void fn_null(struct vc_data *vc)
579 compute_shiftstate();
583 * Special key handlers
585 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
589 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
593 if (value >= ARRAY_SIZE(fn_handler))
595 if ((kbd->kbdmode == VC_RAW ||
596 kbd->kbdmode == VC_MEDIUMRAW) &&
597 value != KVAL(K_SAK))
598 return; /* SAK is allowed even in raw mode */
599 fn_handler[value](vc);
602 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
604 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
607 static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
610 return; /* no action, if this is a key release */
613 value = handle_diacr(vc, value);
620 if (kbd->kbdmode == VC_UNICODE)
622 else if (value < 0x100)
623 put_queue(vc, value);
627 * Handle dead key. Note that we now may have several
628 * dead keys modifying the same character. Very useful
631 static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
635 diacr = (diacr ? handle_diacr(vc, value) : value);
638 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
640 k_unicode(vc, value, up_flag);
643 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
645 k_deadunicode(vc, value, up_flag);
649 * Obsolete - for backwards compatibility only
651 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
653 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
654 value = ret_diacr[value];
655 k_deadunicode(vc, value, up_flag);
658 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
665 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
672 if (v < ARRAY_SIZE(func_table)) {
673 if (func_table[value])
674 puts_queue(vc, func_table[value]);
676 printk(KERN_ERR "k_fn called with value=%d\n", value);
679 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
681 static const char cur_chars[] = "BDCA";
685 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
688 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
690 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
691 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
694 return; /* no action, if this is a key release */
696 /* kludge... shift forces cursor/number keys */
697 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
698 applkey(vc, app_map[value], 1);
702 if (!vc_kbd_led(kbd, VC_NUMLOCK))
706 k_fn(vc, KVAL(K_REMOVE), 0);
709 k_fn(vc, KVAL(K_INSERT), 0);
712 k_fn(vc, KVAL(K_SELECT), 0);
715 k_cur(vc, KVAL(K_DOWN), 0);
718 k_fn(vc, KVAL(K_PGDN), 0);
721 k_cur(vc, KVAL(K_LEFT), 0);
724 k_cur(vc, KVAL(K_RIGHT), 0);
727 k_fn(vc, KVAL(K_FIND), 0);
730 k_cur(vc, KVAL(K_UP), 0);
733 k_fn(vc, KVAL(K_PGUP), 0);
736 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
740 put_queue(vc, pad_chars[value]);
741 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
745 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
747 int old_state = shift_state;
753 * a CapsShift key acts like Shift but undoes CapsLock
755 if (value == KVAL(K_CAPSSHIFT)) {
756 value = KVAL(K_SHIFT);
758 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
763 * handle the case that two shift or control
764 * keys are depressed simultaneously
766 if (shift_down[value])
771 if (shift_down[value])
772 shift_state |= (1 << value);
774 shift_state &= ~(1 << value);
777 if (up_flag && shift_state != old_state && npadch != -1) {
778 if (kbd->kbdmode == VC_UNICODE)
779 to_utf8(vc, npadch & 0xffff);
781 put_queue(vc, npadch & 0xff);
786 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
791 if (vc_kbd_mode(kbd, VC_META)) {
792 put_queue(vc, '\033');
793 put_queue(vc, value);
795 put_queue(vc, value | 0x80);
798 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
806 /* decimal input of code, while Alt depressed */
809 /* hexadecimal input of code, while AltGr depressed */
817 npadch = npadch * base + value;
820 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
824 chg_vc_kbd_lock(kbd, value);
827 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
829 k_shift(vc, value, up_flag);
832 chg_vc_kbd_slock(kbd, value);
833 /* try to make Alt, oops, AltGr and such work */
834 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
836 chg_vc_kbd_slock(kbd, value);
840 /* by default, 300ms interval for combination release */
841 static unsigned brl_timeout = 300;
842 MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
843 module_param(brl_timeout, uint, 0644);
845 static unsigned brl_nbchords = 1;
846 MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
847 module_param(brl_nbchords, uint, 0644);
849 static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
851 static unsigned long chords;
852 static unsigned committed;
855 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
857 committed |= pattern;
859 if (chords == brl_nbchords) {
860 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
867 static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
869 static unsigned pressed,committing;
870 static unsigned long releasestart;
872 if (kbd->kbdmode != VC_UNICODE) {
874 printk("keyboard mode must be unicode for braille patterns\n");
879 k_unicode(vc, BRL_UC_ROW, up_flag);
889 jiffies - releasestart > (brl_timeout * HZ) / 1000) {
890 committing = pressed;
891 releasestart = jiffies;
893 pressed &= ~(1 << (value - 1));
896 k_brlcommit(vc, committing, 0);
902 k_brlcommit(vc, committing, 0);
905 pressed &= ~(1 << (value - 1));
908 pressed |= 1 << (value - 1);
910 committing = pressed;
915 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
916 * or (ii) whatever pattern of lights people want to show using KDSETLED,
917 * or (iii) specified bits of specified words in kernel memory.
919 unsigned char getledstate(void)
924 void setledstate(struct kbd_struct *kbd, unsigned int led)
928 kbd->ledmode = LED_SHOW_IOCTL;
930 kbd->ledmode = LED_SHOW_FLAGS;
934 static inline unsigned char getleds(void)
936 struct kbd_struct *kbd = kbd_table + fg_console;
940 if (kbd->ledmode == LED_SHOW_IOCTL)
943 leds = kbd->ledflagstate;
945 if (kbd->ledmode == LED_SHOW_MEM) {
946 for (i = 0; i < 3; i++)
947 if (ledptrs[i].valid) {
948 if (*ledptrs[i].addr & ledptrs[i].mask)
958 * This routine is the bottom half of the keyboard interrupt
959 * routine, and runs with all interrupts enabled. It does
960 * console changing, led setting and copy_to_cooked, which can
961 * take a reasonably long time.
963 * Aside from timing (which isn't really that important for
964 * keyboard interrupts as they happen often), using the software
965 * interrupt routines for this thing allows us to easily mask
966 * this when we don't want any of the above to happen.
967 * This allows for easy and efficient race-condition prevention
968 * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
971 static void kbd_bh(unsigned long dummy)
973 struct list_head *node;
974 unsigned char leds = getleds();
976 if (leds != ledstate) {
977 list_for_each(node, &kbd_handler.h_list) {
978 struct input_handle *handle = to_handle_h(node);
979 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
980 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
981 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
982 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
989 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
991 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
992 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
993 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
994 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
996 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
997 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
999 static const unsigned short x86_keycodes[256] =
1000 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1001 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1002 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1003 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1004 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1005 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1006 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1007 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1008 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1009 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1010 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1011 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1012 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1013 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1014 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1016 #ifdef CONFIG_MAC_EMUMOUSEBTN
1017 extern int mac_hid_mouse_emulate_buttons(int, int, int);
1018 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1021 static int sparc_l1_a_state = 0;
1022 extern void sun_do_break(void);
1025 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1026 unsigned char up_flag)
1032 put_queue(vc, 0xe1);
1033 put_queue(vc, 0x1d | up_flag);
1034 put_queue(vc, 0x45 | up_flag);
1039 put_queue(vc, 0xf2);
1044 put_queue(vc, 0xf1);
1049 * Real AT keyboards (that's what we're trying
1050 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1051 * pressing PrtSc/SysRq alone, but simply 0x54
1052 * when pressing Alt+PrtSc/SysRq.
1055 put_queue(vc, 0x54 | up_flag);
1057 put_queue(vc, 0xe0);
1058 put_queue(vc, 0x2a | up_flag);
1059 put_queue(vc, 0xe0);
1060 put_queue(vc, 0x37 | up_flag);
1068 code = x86_keycodes[keycode];
1073 put_queue(vc, 0xe0);
1074 put_queue(vc, (code & 0x7f) | up_flag);
1084 #define HW_RAW(dev) 0
1086 #warning "Cannot generate rawmode keyboard for your architecture yet."
1088 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1093 put_queue(vc, keycode | up_flag);
1098 static void kbd_rawcode(unsigned char data)
1100 struct vc_data *vc = vc_cons[fg_console].d;
1101 kbd = kbd_table + fg_console;
1102 if (kbd->kbdmode == VC_RAW)
1103 put_queue(vc, data);
1106 static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1108 struct vc_data *vc = vc_cons[fg_console].d;
1109 unsigned short keysym, *key_map;
1110 unsigned char type, raw_mode;
1111 struct tty_struct *tty;
1116 if (tty && (!tty->driver_data)) {
1117 /* No driver data? Strange. Okay we fix it then. */
1118 tty->driver_data = vc;
1121 kbd = kbd_table + fg_console;
1123 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1124 sysrq_alt = down ? keycode : 0;
1126 if (keycode == KEY_STOP)
1127 sparc_l1_a_state = down;
1132 #ifdef CONFIG_MAC_EMUMOUSEBTN
1133 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1135 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1137 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1138 if (emulate_raw(vc, keycode, !down << 7))
1139 if (keycode < BTN_MISC)
1140 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1142 #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1143 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1146 sysrq_alt_use = sysrq_alt;
1150 if (sysrq_down && !down && keycode == sysrq_alt_use)
1152 if (sysrq_down && down && !rep) {
1153 handle_sysrq(kbd_sysrq_xlate[keycode], tty);
1158 if (keycode == KEY_A && sparc_l1_a_state) {
1159 sparc_l1_a_state = 0;
1164 if (kbd->kbdmode == VC_MEDIUMRAW) {
1166 * This is extended medium raw mode, with keys above 127
1167 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1168 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1169 * interfere with anything else. The two bytes after 0 will
1170 * always have the up flag set not to interfere with older
1171 * applications. This allows for 16384 different keycodes,
1172 * which should be enough.
1174 if (keycode < 128) {
1175 put_queue(vc, keycode | (!down << 7));
1177 put_queue(vc, !down << 7);
1178 put_queue(vc, (keycode >> 7) | 0x80);
1179 put_queue(vc, keycode | 0x80);
1185 set_bit(keycode, key_down);
1187 clear_bit(keycode, key_down);
1190 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1191 (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1193 * Don't repeat a key if the input buffers are not empty and the
1194 * characters get aren't echoed locally. This makes key repeat
1195 * usable with slow applications and under heavy loads.
1200 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1201 key_map = key_maps[shift_final];
1204 compute_shiftstate();
1205 kbd->slockstate = 0;
1209 if (keycode > NR_KEYS)
1210 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1211 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1215 keysym = key_map[keycode];
1217 type = KTYP(keysym);
1220 if (down && !raw_mode)
1221 to_utf8(vc, keysym);
1227 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1230 if (type == KT_LETTER) {
1232 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1233 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1235 keysym = key_map[keycode];
1239 (*k_handler[type])(vc, keysym & 0xff, !down);
1241 if (type != KT_SLOCK)
1242 kbd->slockstate = 0;
1245 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1246 unsigned int event_code, int value)
1248 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1250 if (event_type == EV_KEY)
1251 kbd_keycode(event_code, value, HW_RAW(handle->dev));
1252 tasklet_schedule(&keyboard_tasklet);
1253 do_poke_blanked_console = 1;
1254 schedule_console_callback();
1258 * When a keyboard (or other input device) is found, the kbd_connect
1259 * function is called. The function then looks at the device, and if it
1260 * likes it, it can open it and get events from it. In this (kbd_connect)
1261 * function, we should decide which VT to bind that keyboard to initially.
1263 static struct input_handle *kbd_connect(struct input_handler *handler,
1264 struct input_dev *dev,
1265 const struct input_device_id *id)
1267 struct input_handle *handle;
1270 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1271 if (test_bit(i, dev->keybit))
1274 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1277 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1282 handle->handler = handler;
1283 handle->name = "kbd";
1285 input_open_device(handle);
1290 static void kbd_disconnect(struct input_handle *handle)
1292 input_close_device(handle);
1297 * Start keyboard handler on the new keyboard by refreshing LED state to
1298 * match the rest of the system.
1300 static void kbd_start(struct input_handle *handle)
1302 unsigned char leds = ledstate;
1304 tasklet_disable(&keyboard_tasklet);
1306 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1307 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1308 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1309 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1311 tasklet_enable(&keyboard_tasklet);
1314 static const struct input_device_id kbd_ids[] = {
1316 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1317 .evbit = { BIT(EV_KEY) },
1321 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1322 .evbit = { BIT(EV_SND) },
1325 { }, /* Terminating entry */
1328 MODULE_DEVICE_TABLE(input, kbd_ids);
1330 static struct input_handler kbd_handler = {
1332 .connect = kbd_connect,
1333 .disconnect = kbd_disconnect,
1336 .id_table = kbd_ids,
1339 int __init kbd_init(void)
1344 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1345 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1346 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1347 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1348 kbd_table[i].lockstate = KBD_DEFLOCK;
1349 kbd_table[i].slockstate = 0;
1350 kbd_table[i].modeflags = KBD_DEFMODE;
1351 kbd_table[i].kbdmode = VC_XLATE;
1354 error = input_register_handler(&kbd_handler);
1358 tasklet_enable(&keyboard_tasklet);
1359 tasklet_schedule(&keyboard_tasklet);