2 * linux/drivers/char/keyboard.c
4 * Written for linux by Johan Myreen as a translation from
5 * the assembly version by Linus (with diacriticals added)
7 * Some additional features added by Christoph Niemann (ChN), March 1993
9 * Loadable keymaps by Risto Kankkunen, May 1993
11 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
12 * Added decr/incr_console, dynamic keymaps, Unicode support,
13 * dynamic function/string keys, led setting, Sept 1994
14 * `Sticky' modifier keys, 951006.
16 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
18 * Modified to provide 'generic' keyboard support by Hamish Macdonald
19 * Merge with the m68k keyboard driver and split-off of the PC low-level
20 * parts by Geert Uytterhoeven, May 1997
22 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
23 * 30-07-98: Dead keys redone, aeb@cwi.nl.
24 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
27 #include <linux/config.h>
28 #include <linux/module.h>
29 #include <linux/sched.h>
30 #include <linux/tty.h>
31 #include <linux/tty_flip.h>
33 #include <linux/string.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
37 #include <linux/kbd_kern.h>
38 #include <linux/kbd_diacr.h>
39 #include <linux/vt_kern.h>
40 #include <linux/sysrq.h>
41 #include <linux/input.h>
43 static void kbd_disconnect(struct input_handle *handle);
44 extern void ctrl_alt_del(void);
47 * Exported functions/variables
50 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
53 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
54 * This seems a good reason to start with NumLock off. On HIL keyboards
55 * of PARISC machines however there is no NumLock key and everyone expects the keypad
56 * to be used for numbers.
59 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
60 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
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_ignore, k_ignore
79 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
80 char up_flag, struct pt_regs *regs);
81 static k_handler_fn K_HANDLERS;
82 static k_handler_fn *k_handler[16] = { K_HANDLERS };
85 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
86 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
87 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
88 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
89 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
91 typedef void (fn_handler_fn)(struct vc_data *vc, struct pt_regs *regs);
92 static fn_handler_fn FN_HANDLERS;
93 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
96 * Variables exported for vt_ioctl.c
99 /* maximum values each key_handler can handle */
100 const int max_vals[] = {
101 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
102 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
103 255, NR_LOCK - 1, 255
106 const int NR_TYPES = ARRAY_SIZE(max_vals);
108 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
109 static struct kbd_struct *kbd = kbd_table;
110 static struct kbd_struct kbd0;
112 int spawnpid, spawnsig;
115 * Variables exported for vt.c
124 static struct input_handler kbd_handler;
125 static unsigned long key_down[NBITS(KEY_MAX)]; /* keyboard key bitmap */
126 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
127 static int dead_key_next;
128 static int npadch = -1; /* -1 or number assembled on pad */
129 static unsigned char diacr;
130 static char rep; /* flag telling character repeat */
132 static unsigned char ledstate = 0xff; /* undefined */
133 static unsigned char ledioctl;
135 static struct ledptr {
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] =
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;
154 static int sysrq_alt;
157 * Translation of scancodes to keycodes. We set them on only the first attached
158 * keyboard - for per-keyboard setting, /dev/input/event is more useful.
160 int getkeycode(unsigned int scancode)
162 struct list_head * node;
163 struct input_dev *dev = NULL;
165 list_for_each(node,&kbd_handler.h_list) {
166 struct input_handle * handle = to_handle_h(node);
167 if (handle->dev->keycodesize) {
176 if (scancode < 0 || scancode >= dev->keycodemax)
179 return INPUT_KEYCODE(dev, scancode);
182 int setkeycode(unsigned int scancode, unsigned int keycode)
184 struct list_head * node;
185 struct input_dev *dev = NULL;
188 list_for_each(node,&kbd_handler.h_list) {
189 struct input_handle *handle = to_handle_h(node);
190 if (handle->dev->keycodesize) {
199 if (scancode < 0 || scancode >= dev->keycodemax)
201 if (keycode < 0 || keycode > KEY_MAX)
204 oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
206 clear_bit(oldkey, dev->keybit);
207 set_bit(keycode, dev->keybit);
209 for (i = 0; i < dev->keycodemax; i++)
210 if (INPUT_KEYCODE(dev,i) == oldkey)
211 set_bit(oldkey, dev->keybit);
217 * Making beeps and bells.
219 static void kd_nosound(unsigned long ignored)
221 struct list_head * node;
223 list_for_each(node,&kbd_handler.h_list) {
224 struct input_handle *handle = to_handle_h(node);
225 if (test_bit(EV_SND, handle->dev->evbit)) {
226 if (test_bit(SND_TONE, handle->dev->sndbit))
227 input_event(handle->dev, EV_SND, SND_TONE, 0);
228 if (test_bit(SND_BELL, handle->dev->sndbit))
229 input_event(handle->dev, EV_SND, SND_BELL, 0);
234 static struct timer_list kd_mksound_timer =
235 TIMER_INITIALIZER(kd_nosound, 0, 0);
237 void kd_mksound(unsigned int hz, unsigned int ticks)
239 struct list_head * node;
241 del_timer(&kd_mksound_timer);
244 list_for_each_prev(node,&kbd_handler.h_list) {
245 struct input_handle *handle = to_handle_h(node);
246 if (test_bit(EV_SND, handle->dev->evbit)) {
247 if (test_bit(SND_TONE, handle->dev->sndbit)) {
248 input_event(handle->dev, EV_SND, SND_TONE, hz);
251 if (test_bit(SND_BELL, handle->dev->sndbit)) {
252 input_event(handle->dev, EV_SND, SND_BELL, 1);
258 mod_timer(&kd_mksound_timer, jiffies + ticks);
264 * Setting the keyboard rate.
267 int kbd_rate(struct kbd_repeat *rep)
269 struct list_head *node;
273 list_for_each(node,&kbd_handler.h_list) {
274 struct input_handle *handle = to_handle_h(node);
275 struct input_dev *dev = handle->dev;
277 if (test_bit(EV_REP, dev->evbit)) {
279 input_event(dev, EV_REP, REP_DELAY, rep->delay);
281 input_event(dev, EV_REP, REP_PERIOD, rep->period);
282 d = dev->rep[REP_DELAY];
283 p = dev->rep[REP_PERIOD];
294 static void put_queue(struct vc_data *vc, int ch)
296 struct tty_struct *tty = vc->vc_tty;
299 tty_insert_flip_char(tty, ch, 0);
300 con_schedule_flip(tty);
304 static void puts_queue(struct vc_data *vc, char *cp)
306 struct tty_struct *tty = vc->vc_tty;
312 tty_insert_flip_char(tty, *cp, 0);
315 con_schedule_flip(tty);
318 static void applkey(struct vc_data *vc, int key, char mode)
320 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
322 buf[1] = (mode ? 'O' : '[');
328 * Many other routines do put_queue, but I think either
329 * they produce ASCII, or they produce some user-assigned
330 * string, and in both cases we might assume that it is
331 * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
332 * but we need only 16 bits here
334 static void to_utf8(struct vc_data *vc, ushort c)
339 else if (c < 0x800) {
340 /* 110***** 10****** */
341 put_queue(vc, 0xc0 | (c >> 6));
342 put_queue(vc, 0x80 | (c & 0x3f));
344 /* 1110**** 10****** 10****** */
345 put_queue(vc, 0xe0 | (c >> 12));
346 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
347 put_queue(vc, 0x80 | (c & 0x3f));
352 * Called after returning from RAW mode or when changing consoles - recompute
353 * shift_down[] and shift_state from key_down[] maybe called when keymap is
354 * undefined, so that shiftkey release is seen
356 void compute_shiftstate(void)
358 int i, j, k, sym, val;
361 memset(shift_down, 0, sizeof(shift_down));
363 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
368 k = i * BITS_PER_LONG;
370 for (j = 0; j < BITS_PER_LONG; j++, k++) {
372 if (!test_bit(k, key_down))
375 sym = U(key_maps[0][k]);
376 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
380 if (val == KVAL(K_CAPSSHIFT))
384 shift_state |= (1 << val);
390 * We have a combining character DIACR here, followed by the character CH.
391 * If the combination occurs in the table, return the corresponding value.
392 * Otherwise, if CH is a space or equals DIACR, return DIACR.
393 * Otherwise, conclude that DIACR was not combining after all,
394 * queue it and return CH.
396 static unsigned char handle_diacr(struct vc_data *vc, unsigned char ch)
403 for (i = 0; i < accent_table_size; i++) {
404 if (accent_table[i].diacr == d && accent_table[i].base == ch)
405 return accent_table[i].result;
408 if (ch == ' ' || ch == d)
416 * Special function handlers
418 static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
421 put_queue(vc, diacr);
425 if (vc_kbd_mode(kbd, VC_CRLF))
429 static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
433 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
436 static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
440 set_vc_kbd_led(kbd, VC_CAPSLOCK);
443 static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
449 static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
451 struct tty_struct *tty = vc->vc_tty;
457 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
458 * these routines are also activated by ^S/^Q.
459 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
467 static void fn_num(struct vc_data *vc, struct pt_regs *regs)
469 if (vc_kbd_mode(kbd,VC_APPLIC))
472 fn_bare_num(vc, regs);
476 * Bind this to Shift-NumLock if you work in application keypad mode
477 * but want to be able to change the NumLock flag.
478 * Bind this to NumLock if you prefer that the NumLock key always
479 * changes the NumLock flag.
481 static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
484 chg_vc_kbd_led(kbd, VC_NUMLOCK);
487 static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
489 /* switch to the last used console, ChN */
490 set_console(last_console);
493 static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
495 int i, cur = fg_console;
497 /* Currently switching? Queue this next switch relative to that. */
498 if (want_console != -1)
501 for (i = cur-1; i != cur; i--) {
503 i = MAX_NR_CONSOLES-1;
504 if (vc_cons_allocated(i))
510 static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
512 int i, cur = fg_console;
514 /* Currently switching? Queue this next switch relative to that. */
515 if (want_console != -1)
518 for (i = cur+1; i != cur; i++) {
519 if (i == MAX_NR_CONSOLES)
521 if (vc_cons_allocated(i))
527 static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
529 struct tty_struct *tty = vc->vc_tty;
533 tty_insert_flip_char(tty, 0, TTY_BREAK);
534 con_schedule_flip(tty);
537 static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
542 static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
547 static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
552 static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
557 static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
562 static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
567 static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
570 if(kill_proc(spawnpid, spawnsig, 1))
574 static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
576 struct tty_struct *tty = vc->vc_tty;
579 * SAK should also work in all raw modes and reset
584 reset_vc(fg_console);
587 static void fn_null(struct vc_data *vc, struct pt_regs *regs)
589 compute_shiftstate();
593 * Special key handlers
595 static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
599 static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
603 if (value >= ARRAY_SIZE(fn_handler))
605 if ((kbd->kbdmode == VC_RAW ||
606 kbd->kbdmode == VC_MEDIUMRAW) &&
607 value != KVAL(K_SAK))
608 return; /* SAK is allowed even in raw mode */
609 fn_handler[value](vc, regs);
612 static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
614 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
617 static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
620 return; /* no action, if this is a key release */
623 value = handle_diacr(vc, value);
630 put_queue(vc, value);
634 * Handle dead key. Note that we now may have several
635 * dead keys modifying the same character. Very useful
638 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
642 diacr = (diacr ? handle_diacr(vc, value) : value);
646 * Obsolete - for backwards compatibility only
648 static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
650 static unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
651 value = ret_diacr[value];
652 k_dead2(vc, value, up_flag, regs);
655 static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
662 static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
669 if (v < ARRAY_SIZE(func_table)) {
670 if (func_table[value])
671 puts_queue(vc, func_table[value]);
673 printk(KERN_ERR "k_fn called with value=%d\n", value);
676 static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
678 static const char *cur_chars = "BDCA";
682 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
685 static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
687 static const char *pad_chars = "0123456789+-*/\015,.?()#";
688 static const char *app_map = "pqrstuvwxylSRQMnnmPQS";
691 return; /* no action, if this is a key release */
693 /* kludge... shift forces cursor/number keys */
694 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
695 applkey(vc, app_map[value], 1);
699 if (!vc_kbd_led(kbd, VC_NUMLOCK))
703 k_fn(vc, KVAL(K_REMOVE), 0, regs);
706 k_fn(vc, KVAL(K_INSERT), 0, regs);
709 k_fn(vc, KVAL(K_SELECT), 0, regs);
712 k_cur(vc, KVAL(K_DOWN), 0, regs);
715 k_fn(vc, KVAL(K_PGDN), 0, regs);
718 k_cur(vc, KVAL(K_LEFT), 0, regs);
721 k_cur(vc, KVAL(K_RIGHT), 0, regs);
724 k_fn(vc, KVAL(K_FIND), 0, regs);
727 k_cur(vc, KVAL(K_UP), 0, regs);
730 k_fn(vc, KVAL(K_PGUP), 0, regs);
733 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
737 put_queue(vc, pad_chars[value]);
738 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
742 static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
744 int old_state = shift_state;
750 * a CapsShift key acts like Shift but undoes CapsLock
752 if (value == KVAL(K_CAPSSHIFT)) {
753 value = KVAL(K_SHIFT);
755 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
760 * handle the case that two shift or control
761 * keys are depressed simultaneously
763 if (shift_down[value])
768 if (shift_down[value])
769 shift_state |= (1 << value);
771 shift_state &= ~(1 << value);
774 if (up_flag && shift_state != old_state && npadch != -1) {
775 if (kbd->kbdmode == VC_UNICODE)
776 to_utf8(vc, npadch & 0xffff);
778 put_queue(vc, npadch & 0xff);
783 static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
788 if (vc_kbd_mode(kbd, VC_META)) {
789 put_queue(vc, '\033');
790 put_queue(vc, value);
792 put_queue(vc, value | 0x80);
795 static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
803 /* decimal input of code, while Alt depressed */
806 /* hexadecimal input of code, while AltGr depressed */
814 npadch = npadch * base + value;
817 static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
821 chg_vc_kbd_lock(kbd, value);
824 static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
826 k_shift(vc, value, up_flag, regs);
829 chg_vc_kbd_slock(kbd, value);
830 /* try to make Alt, oops, AltGr and such work */
831 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
833 chg_vc_kbd_slock(kbd, value);
838 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
839 * or (ii) whatever pattern of lights people want to show using KDSETLED,
840 * or (iii) specified bits of specified words in kernel memory.
842 unsigned char getledstate(void)
847 void setledstate(struct kbd_struct *kbd, unsigned int led)
851 kbd->ledmode = LED_SHOW_IOCTL;
853 kbd->ledmode = LED_SHOW_FLAGS;
857 static inline unsigned char getleds(void)
859 struct kbd_struct *kbd = kbd_table + fg_console;
863 if (kbd->ledmode == LED_SHOW_IOCTL)
866 leds = kbd->ledflagstate;
868 if (kbd->ledmode == LED_SHOW_MEM) {
869 for (i = 0; i < 3; i++)
870 if (ledptrs[i].valid) {
871 if (*ledptrs[i].addr & ledptrs[i].mask)
881 * This routine is the bottom half of the keyboard interrupt
882 * routine, and runs with all interrupts enabled. It does
883 * console changing, led setting and copy_to_cooked, which can
884 * take a reasonably long time.
886 * Aside from timing (which isn't really that important for
887 * keyboard interrupts as they happen often), using the software
888 * interrupt routines for this thing allows us to easily mask
889 * this when we don't want any of the above to happen.
890 * This allows for easy and efficient race-condition prevention
891 * for kbd_refresh_leds => input_event(dev, EV_LED, ...) => ...
894 static void kbd_bh(unsigned long dummy)
896 struct list_head * node;
897 unsigned char leds = getleds();
899 if (leds != ledstate) {
900 list_for_each(node,&kbd_handler.h_list) {
901 struct input_handle * handle = to_handle_h(node);
902 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
903 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
904 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
905 input_sync(handle->dev);
912 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
915 * This allows a newly plugged keyboard to pick the LED state.
917 static void kbd_refresh_leds(struct input_handle *handle)
919 unsigned char leds = ledstate;
921 tasklet_disable(&keyboard_tasklet);
923 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
924 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
925 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
926 input_sync(handle->dev);
928 tasklet_enable(&keyboard_tasklet);
931 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
932 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC32) ||\
933 defined(CONFIG_SPARC64) || defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
934 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_RPC))
936 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
937 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
939 static unsigned short x86_keycodes[256] =
940 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
941 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
942 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
943 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
944 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
945 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
946 284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
947 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
948 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
949 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
950 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
951 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
952 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
953 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
954 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
956 #ifdef CONFIG_MAC_EMUMOUSEBTN
957 extern int mac_hid_mouse_emulate_buttons(int, int, int);
958 #endif /* CONFIG_MAC_EMUMOUSEBTN */
960 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
961 static int sparc_l1_a_state = 0;
962 extern void sun_do_break(void);
965 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
966 unsigned char up_flag)
968 if (keycode > 255 || !x86_keycodes[keycode])
974 put_queue(vc, 0x1d | up_flag);
975 put_queue(vc, 0x45 | up_flag);
978 if (!up_flag) put_queue(vc, 0xf1);
981 if (!up_flag) put_queue(vc, 0xf2);
985 if (keycode == KEY_SYSRQ && sysrq_alt) {
986 put_queue(vc, 0x54 | up_flag);
990 if (x86_keycodes[keycode] & 0x100)
993 put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
995 if (keycode == KEY_SYSRQ) {
997 put_queue(vc, 0x37 | up_flag);
1005 #define HW_RAW(dev) 0
1007 #warning "Cannot generate rawmode keyboard for your architecture yet."
1009 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1014 put_queue(vc, keycode | up_flag);
1019 static void kbd_rawcode(unsigned char data)
1021 struct vc_data *vc = vc_cons[fg_console].d;
1022 kbd = kbd_table + fg_console;
1023 if (kbd->kbdmode == VC_RAW)
1024 put_queue(vc, data);
1027 void kbd_keycode(unsigned int keycode, int down, int hw_raw, struct pt_regs *regs)
1029 struct vc_data *vc = vc_cons[fg_console].d;
1030 unsigned short keysym, *key_map;
1031 unsigned char type, raw_mode;
1032 struct tty_struct *tty;
1037 if (tty && (!tty->driver_data)) {
1038 /* No driver data? Strange. Okay we fix it then. */
1039 tty->driver_data = vc;
1042 kbd = kbd_table + fg_console;
1044 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1046 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1047 if (keycode == KEY_STOP)
1048 sparc_l1_a_state = down;
1053 #ifdef CONFIG_MAC_EMUMOUSEBTN
1054 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1056 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1058 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1059 if (emulate_raw(vc, keycode, !down << 7))
1060 if (keycode < BTN_MISC)
1061 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1063 #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1064 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1068 if (sysrq_down && down && !rep) {
1069 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1073 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1074 if (keycode == KEY_A && sparc_l1_a_state) {
1075 sparc_l1_a_state = 0;
1080 if (kbd->kbdmode == VC_MEDIUMRAW) {
1082 * This is extended medium raw mode, with keys above 127
1083 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1084 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1085 * interfere with anything else. The two bytes after 0 will
1086 * always have the up flag set not to interfere with older
1087 * applications. This allows for 16384 different keycodes,
1088 * which should be enough.
1090 if (keycode < 128) {
1091 put_queue(vc, keycode | (!down << 7));
1093 put_queue(vc, !down << 7);
1094 put_queue(vc, (keycode >> 7) | 0x80);
1095 put_queue(vc, keycode | 0x80);
1101 set_bit(keycode, key_down);
1103 clear_bit(keycode, key_down);
1105 if (rep && (!vc_kbd_mode(kbd, VC_REPEAT) || (tty &&
1106 (!L_ECHO(tty) && tty->driver->chars_in_buffer(tty))))) {
1108 * Don't repeat a key if the input buffers are not empty and the
1109 * characters get aren't echoed locally. This makes key repeat
1110 * usable with slow applications and under heavy loads.
1115 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1116 key_map = key_maps[shift_final];
1119 compute_shiftstate();
1120 kbd->slockstate = 0;
1124 if (keycode > NR_KEYS)
1127 keysym = key_map[keycode];
1128 type = KTYP(keysym);
1131 if (down && !raw_mode) to_utf8(vc, keysym);
1137 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1140 if (type == KT_LETTER) {
1142 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1143 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1145 keysym = key_map[keycode];
1149 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1151 if (type != KT_SLOCK)
1152 kbd->slockstate = 0;
1155 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1156 unsigned int event_code, int value)
1158 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1160 if (event_type == EV_KEY)
1161 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1162 tasklet_schedule(&keyboard_tasklet);
1163 do_poke_blanked_console = 1;
1164 schedule_console_callback();
1167 static char kbd_name[] = "kbd";
1170 * When a keyboard (or other input device) is found, the kbd_connect
1171 * function is called. The function then looks at the device, and if it
1172 * likes it, it can open it and get events from it. In this (kbd_connect)
1173 * function, we should decide which VT to bind that keyboard to initially.
1175 static struct input_handle *kbd_connect(struct input_handler *handler,
1176 struct input_dev *dev,
1177 struct input_device_id *id)
1179 struct input_handle *handle;
1182 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1183 if (test_bit(i, dev->keybit)) break;
1185 if ((i == BTN_MISC) && !test_bit(EV_SND, dev->evbit))
1188 if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1190 memset(handle, 0, sizeof(struct input_handle));
1193 handle->handler = handler;
1194 handle->name = kbd_name;
1196 input_open_device(handle);
1197 kbd_refresh_leds(handle);
1202 static void kbd_disconnect(struct input_handle *handle)
1204 input_close_device(handle);
1208 static struct input_device_id kbd_ids[] = {
1210 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1211 .evbit = { BIT(EV_KEY) },
1215 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1216 .evbit = { BIT(EV_SND) },
1219 { }, /* Terminating entry */
1222 MODULE_DEVICE_TABLE(input, kbd_ids);
1224 static struct input_handler kbd_handler = {
1226 .connect = kbd_connect,
1227 .disconnect = kbd_disconnect,
1229 .id_table = kbd_ids,
1232 int __init kbd_init(void)
1236 kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1237 kbd0.ledmode = LED_SHOW_FLAGS;
1238 kbd0.lockstate = KBD_DEFLOCK;
1239 kbd0.slockstate = 0;
1240 kbd0.modeflags = KBD_DEFMODE;
1241 kbd0.kbdmode = VC_XLATE;
1243 for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1244 kbd_table[i] = kbd0;
1246 input_register_handler(&kbd_handler);
1248 tasklet_enable(&keyboard_tasklet);
1249 tasklet_schedule(&keyboard_tasklet);