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/random.h>
35 #include <linux/init.h>
36 #include <linux/slab.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>
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 PC9800 and 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_X86_PC9800) || \
61 defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
62 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
69 void compute_shiftstate(void);
76 k_self, k_fn, k_spec, k_pad,\
77 k_dead, k_cons, k_cur, k_shift,\
78 k_meta, k_ascii, k_lock, k_lowercase,\
79 k_slock, k_dead2, k_ignore, k_ignore
81 typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
82 char up_flag, struct pt_regs *regs);
83 static k_handler_fn K_HANDLERS;
84 static k_handler_fn *k_handler[16] = { K_HANDLERS };
87 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
88 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
89 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
90 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
91 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
93 typedef void (fn_handler_fn)(struct vc_data *vc, struct pt_regs *regs);
94 static fn_handler_fn FN_HANDLERS;
95 static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
98 * Variables exported for vt_ioctl.c
101 /* maximum values each key_handler can handle */
102 const int max_vals[] = {
103 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
104 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
105 255, NR_LOCK - 1, 255
108 const int NR_TYPES = ARRAY_SIZE(max_vals);
110 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
111 static struct kbd_struct *kbd = kbd_table;
112 static struct kbd_struct kbd0;
114 int spawnpid, spawnsig;
117 * Variables exported for vt.c
126 static struct input_handler kbd_handler;
127 static unsigned long key_down[256/BITS_PER_LONG]; /* keyboard key bitmap */
128 static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
129 static int dead_key_next;
130 static int npadch = -1; /* -1 or number assembled on pad */
131 static unsigned char diacr;
132 static char rep; /* flag telling character repeat */
134 static unsigned char ledstate = 0xff; /* undefined */
135 static unsigned char ledioctl;
137 static struct ledptr {
140 unsigned char valid:1;
143 /* Simple translation table for the SysRq keys */
145 #ifdef CONFIG_MAGIC_SYSRQ
146 unsigned char kbd_sysrq_xlate[128] =
147 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
148 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
149 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
150 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
151 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
152 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
153 "\r\000/"; /* 0x60 - 0x6f */
154 static int sysrq_down;
156 static int sysrq_alt;
159 * Translation of scancodes to keycodes. We set them on only the first attached
160 * keyboard - for per-keyboard setting, /dev/input/event is more useful.
162 int getkeycode(unsigned int scancode)
164 struct list_head * node;
165 struct input_dev *dev = NULL;
167 list_for_each(node,&kbd_handler.h_list) {
168 struct input_handle * handle = to_handle_h(node);
169 if (handle->dev->keycodesize) {
178 if (scancode < 0 || scancode >= dev->keycodemax)
181 return INPUT_KEYCODE(dev, scancode);
184 int setkeycode(unsigned int scancode, unsigned int keycode)
186 struct list_head * node;
187 struct input_dev *dev = NULL;
190 list_for_each(node,&kbd_handler.h_list) {
191 struct input_handle *handle = to_handle_h(node);
192 if (handle->dev->keycodesize) {
201 if (scancode < 0 || scancode >= dev->keycodemax)
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 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 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 void register_leds(struct kbd_struct *kbd, unsigned int led,
858 unsigned int *addr, unsigned int mask)
861 ledptrs[led].addr = addr;
862 ledptrs[led].mask = mask;
863 ledptrs[led].valid = 1;
864 kbd->ledmode = LED_SHOW_MEM;
866 kbd->ledmode = LED_SHOW_FLAGS;
869 static inline unsigned char getleds(void)
871 struct kbd_struct *kbd = kbd_table + fg_console;
875 if (kbd->ledmode == LED_SHOW_IOCTL)
878 leds = kbd->ledflagstate;
880 if (kbd->ledmode == LED_SHOW_MEM) {
881 for (i = 0; i < 3; i++)
882 if (ledptrs[i].valid) {
883 if (*ledptrs[i].addr & ledptrs[i].mask)
893 * This routine is the bottom half of the keyboard interrupt
894 * routine, and runs with all interrupts enabled. It does
895 * console changing, led setting and copy_to_cooked, which can
896 * take a reasonably long time.
898 * Aside from timing (which isn't really that important for
899 * keyboard interrupts as they happen often), using the software
900 * interrupt routines for this thing allows us to easily mask
901 * this when we don't want any of the above to happen.
902 * This allows for easy and efficient race-condition prevention
903 * for kbd_refresh_leds => input_event(dev, EV_LED, ...) => ...
906 static void kbd_bh(unsigned long dummy)
908 struct list_head * node;
909 unsigned char leds = getleds();
911 if (leds != ledstate) {
912 list_for_each(node,&kbd_handler.h_list) {
913 struct input_handle * handle = to_handle_h(node);
914 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
915 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
916 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
917 input_sync(handle->dev);
924 DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
927 * This allows a newly plugged keyboard to pick the LED state.
929 void kbd_refresh_leds(struct input_handle *handle)
931 unsigned char leds = ledstate;
933 tasklet_disable(&keyboard_tasklet);
935 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
936 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
937 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
938 input_sync(handle->dev);
940 tasklet_enable(&keyboard_tasklet);
943 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) || defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64) || defined(CONFIG_PARISC) || defined(CONFIG_SH_MPC1211)
945 static unsigned short x86_keycodes[256] =
946 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
947 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
948 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
949 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
950 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
951 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
952 284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
953 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
954 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
955 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
956 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
957 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
958 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
959 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
960 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
962 #ifdef CONFIG_MAC_EMUMOUSEBTN
963 extern int mac_hid_mouse_emulate_buttons(int, int, int);
964 #endif /* CONFIG_MAC_EMUMOUSEBTN */
966 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
967 static int sparc_l1_a_state = 0;
968 extern void sun_do_break(void);
971 static int emulate_raw(struct vc_data *vc, unsigned int keycode,
972 unsigned char up_flag)
974 if (keycode > 255 || !x86_keycodes[keycode])
980 put_queue(vc, 0x1d | up_flag);
981 put_queue(vc, 0x45 | up_flag);
984 if (!up_flag) put_queue(vc, 0xf1);
987 if (!up_flag) put_queue(vc, 0xf2);
991 if (keycode == KEY_SYSRQ && sysrq_alt) {
992 put_queue(vc, 0x54 | up_flag);
996 if (x86_keycodes[keycode] & 0x100)
999 put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
1001 if (keycode == KEY_SYSRQ) {
1002 put_queue(vc, 0xe0);
1003 put_queue(vc, 0x37 | up_flag);
1011 #warning "Cannot generate rawmode keyboard for your architecture yet."
1013 static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1018 put_queue(vc, keycode | up_flag);
1023 void kbd_keycode(unsigned int keycode, int down, struct pt_regs *regs)
1025 struct vc_data *vc = vc_cons[fg_console].d;
1026 unsigned short keysym, *key_map;
1027 unsigned char type, raw_mode;
1028 struct tty_struct *tty;
1032 add_keyboard_randomness((keycode << 1) ^ down);
1036 if (tty && (!tty->driver_data)) {
1037 /* No driver data? Strange. Okay we fix it then. */
1038 tty->driver_data = vc;
1041 kbd = kbd_table + fg_console;
1043 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1045 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1046 if (keycode == KEY_STOP)
1047 sparc_l1_a_state = down;
1052 #ifdef CONFIG_MAC_EMUMOUSEBTN
1053 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1055 #endif /* CONFIG_MAC_EMUMOUSEBTN */
1057 if ((raw_mode = (kbd->kbdmode == VC_RAW)))
1058 if (emulate_raw(vc, keycode, !down << 7))
1059 if (keycode < BTN_MISC)
1060 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1062 #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1063 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1067 if (sysrq_down && down && !rep) {
1068 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1072 #if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1073 if (keycode == KEY_A && sparc_l1_a_state) {
1074 sparc_l1_a_state = 0;
1079 if (kbd->kbdmode == VC_MEDIUMRAW) {
1081 * This is extended medium raw mode, with keys above 127
1082 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1083 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1084 * interfere with anything else. The two bytes after 0 will
1085 * always have the up flag set not to interfere with older
1086 * applications. This allows for 16384 different keycodes,
1087 * which should be enough.
1089 if (keycode < 128) {
1090 put_queue(vc, keycode | (!down << 7));
1092 put_queue(vc, !down << 7);
1093 put_queue(vc, (keycode >> 7) | 0x80);
1094 put_queue(vc, keycode | 0x80);
1100 set_bit(keycode, key_down);
1102 clear_bit(keycode, key_down);
1104 if (rep && (!vc_kbd_mode(kbd, VC_REPEAT) || (tty &&
1105 (!L_ECHO(tty) && tty->driver->chars_in_buffer(tty))))) {
1107 * Don't repeat a key if the input buffers are not empty and the
1108 * characters get aren't echoed locally. This makes key repeat
1109 * usable with slow applications and under heavy loads.
1114 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1115 key_map = key_maps[shift_final];
1118 compute_shiftstate();
1119 kbd->slockstate = 0;
1123 keysym = key_map[keycode];
1124 type = KTYP(keysym);
1127 if (down && !raw_mode) to_utf8(vc, keysym);
1133 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1136 if (type == KT_LETTER) {
1138 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1139 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1141 keysym = key_map[keycode];
1145 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1147 if (type != KT_SLOCK)
1148 kbd->slockstate = 0;
1151 static void kbd_event(struct input_handle *handle, unsigned int event_type,
1152 unsigned int keycode, int down)
1154 if (event_type != EV_KEY)
1156 kbd_keycode(keycode, down, handle->dev->regs);
1157 tasklet_schedule(&keyboard_tasklet);
1158 do_poke_blanked_console = 1;
1159 schedule_console_callback();
1162 static char kbd_name[] = "kbd";
1165 * When a keyboard (or other input device) is found, the kbd_connect
1166 * function is called. The function then looks at the device, and if it
1167 * likes it, it can open it and get events from it. In this (kbd_connect)
1168 * function, we should decide which VT to bind that keyboard to initially.
1170 static struct input_handle *kbd_connect(struct input_handler *handler,
1171 struct input_dev *dev,
1172 struct input_device_id *id)
1174 struct input_handle *handle;
1177 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1178 if (test_bit(i, dev->keybit)) break;
1180 if ((i == BTN_MISC) && !test_bit(EV_SND, dev->evbit))
1183 if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1185 memset(handle, 0, sizeof(struct input_handle));
1188 handle->handler = handler;
1189 handle->name = kbd_name;
1191 input_open_device(handle);
1192 kbd_refresh_leds(handle);
1197 static void kbd_disconnect(struct input_handle *handle)
1199 input_close_device(handle);
1203 static struct input_device_id kbd_ids[] = {
1205 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1206 .evbit = { BIT(EV_KEY) },
1210 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1211 .evbit = { BIT(EV_SND) },
1214 { }, /* Terminating entry */
1217 MODULE_DEVICE_TABLE(input, kbd_ids);
1219 static struct input_handler kbd_handler = {
1221 .connect = kbd_connect,
1222 .disconnect = kbd_disconnect,
1224 .id_table = kbd_ids,
1227 int __init kbd_init(void)
1231 kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1232 kbd0.ledmode = LED_SHOW_FLAGS;
1233 kbd0.lockstate = KBD_DEFLOCK;
1234 kbd0.slockstate = 0;
1235 kbd0.modeflags = KBD_DEFMODE;
1236 kbd0.kbdmode = VC_XLATE;
1238 for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1239 kbd_table[i] = kbd0;
1241 input_register_handler(&kbd_handler);
1243 tasklet_enable(&keyboard_tasklet);
1244 tasklet_schedule(&keyboard_tasklet);