2 * Written for linux by Johan Myreen as a translation from
3 * the assembly version by Linus (with diacriticals added)
5 * Some additional features added by Christoph Niemann (ChN), March 1993
7 * Loadable keymaps by Risto Kankkunen, May 1993
9 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
10 * Added decr/incr_console, dynamic keymaps, Unicode support,
11 * dynamic function/string keys, led setting, Sept 1994
12 * `Sticky' modifier keys, 951006.
14 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
16 * Modified to provide 'generic' keyboard support by Hamish Macdonald
17 * Merge with the m68k keyboard driver and split-off of the PC low-level
18 * parts by Geert Uytterhoeven, May 1997
20 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
21 * 30-07-98: Dead keys redone, aeb@cwi.nl.
22 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
37 #include <linux/kbd_kern.h>
38 #include <linux/kbd_diacr.h>
39 #include <linux/vt_kern.h>
40 #include <linux/input.h>
41 #include <linux/reboot.h>
42 #include <linux/notifier.h>
43 #include <linux/jiffies.h>
45 #include <asm/irq_regs.h>
47 extern void ctrl_alt_del(void);
50 * Exported functions/variables
53 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
56 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
57 * This seems a good reason to start with NumLock off. On HIL keyboards
58 * of PARISC machines however there is no NumLock key and everyone expects the keypad
59 * to be used for numbers.
62 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
63 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
70 void compute_shiftstate(void);
77 k_self, k_fn, k_spec, k_pad,\
78 k_dead, k_cons, k_cur, k_shift,\
79 k_meta, k_ascii, k_lock, k_lowercase,\
80 k_slock, k_dead2, k_brl, k_ignore
82 typedef void (k_handler_fn
)(struct vc_data
*vc
, unsigned char value
,
84 static k_handler_fn K_HANDLERS
;
85 static k_handler_fn
*k_handler
[16] = { K_HANDLERS
};
88 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
89 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
90 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
91 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
92 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
94 typedef void (fn_handler_fn
)(struct vc_data
*vc
);
95 static fn_handler_fn FN_HANDLERS
;
96 static fn_handler_fn
*fn_handler
[] = { FN_HANDLERS
};
99 * Variables exported for vt_ioctl.c
102 /* maximum values each key_handler can handle */
103 const int max_vals
[] = {
104 255, ARRAY_SIZE(func_table
) - 1, ARRAY_SIZE(fn_handler
) - 1, NR_PAD
- 1,
105 NR_DEAD
- 1, 255, 3, NR_SHIFT
- 1, 255, NR_ASCII
- 1, NR_LOCK
- 1,
106 255, NR_LOCK
- 1, 255, NR_BRL
- 1
109 const int NR_TYPES
= ARRAY_SIZE(max_vals
);
111 struct kbd_struct kbd_table
[MAX_NR_CONSOLES
];
112 EXPORT_SYMBOL_GPL(kbd_table
);
113 static struct kbd_struct
*kbd
= kbd_table
;
115 struct vt_spawn_console vt_spawn_con
= {
116 .lock
= __SPIN_LOCK_UNLOCKED(vt_spawn_con
.lock
),
122 * Variables exported for vt.c
131 static struct input_handler kbd_handler
;
132 static DEFINE_SPINLOCK(kbd_event_lock
);
133 static unsigned long key_down
[BITS_TO_LONGS(KEY_CNT
)]; /* keyboard key bitmap */
134 static unsigned char shift_down
[NR_SHIFT
]; /* shift state counters.. */
135 static bool dead_key_next
;
136 static int npadch
= -1; /* -1 or number assembled on pad */
137 static unsigned int diacr
;
138 static char rep
; /* flag telling character repeat */
140 static unsigned char ledstate
= 0xff; /* undefined */
141 static unsigned char ledioctl
;
143 static struct ledptr
{
146 unsigned char valid
:1;
150 * Notifier list for console keyboard events
152 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list
);
154 int register_keyboard_notifier(struct notifier_block
*nb
)
156 return atomic_notifier_chain_register(&keyboard_notifier_list
, nb
);
158 EXPORT_SYMBOL_GPL(register_keyboard_notifier
);
160 int unregister_keyboard_notifier(struct notifier_block
*nb
)
162 return atomic_notifier_chain_unregister(&keyboard_notifier_list
, nb
);
164 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier
);
167 * Translation of scancodes to keycodes. We set them on only the first
168 * keyboard in the list that accepts the scancode and keycode.
169 * Explanation for not choosing the first attached keyboard anymore:
170 * USB keyboards for example have two event devices: one for all "normal"
171 * keys and one for extra function keys (like "volume up", "make coffee",
172 * etc.). So this means that scancodes for the extra function keys won't
173 * be valid for the first event device, but will be for the second.
176 struct getset_keycode_data
{
177 struct input_keymap_entry ke
;
181 static int getkeycode_helper(struct input_handle
*handle
, void *data
)
183 struct getset_keycode_data
*d
= data
;
185 d
->error
= input_get_keycode(handle
->dev
, &d
->ke
);
187 return d
->error
== 0; /* stop as soon as we successfully get one */
190 int getkeycode(unsigned int scancode
)
192 struct getset_keycode_data d
= {
195 .len
= sizeof(scancode
),
201 memcpy(d
.ke
.scancode
, &scancode
, sizeof(scancode
));
203 input_handler_for_each_handle(&kbd_handler
, &d
, getkeycode_helper
);
205 return d
.error
?: d
.ke
.keycode
;
208 static int setkeycode_helper(struct input_handle
*handle
, void *data
)
210 struct getset_keycode_data
*d
= data
;
212 d
->error
= input_set_keycode(handle
->dev
, &d
->ke
);
214 return d
->error
== 0; /* stop as soon as we successfully set one */
217 int setkeycode(unsigned int scancode
, unsigned int keycode
)
219 struct getset_keycode_data d
= {
222 .len
= sizeof(scancode
),
228 memcpy(d
.ke
.scancode
, &scancode
, sizeof(scancode
));
230 input_handler_for_each_handle(&kbd_handler
, &d
, setkeycode_helper
);
236 * Making beeps and bells. Note that we prefer beeps to bells, but when
237 * shutting the sound off we do both.
240 static int kd_sound_helper(struct input_handle
*handle
, void *data
)
242 unsigned int *hz
= data
;
243 struct input_dev
*dev
= handle
->dev
;
245 if (test_bit(EV_SND
, dev
->evbit
)) {
246 if (test_bit(SND_TONE
, dev
->sndbit
)) {
247 input_inject_event(handle
, EV_SND
, SND_TONE
, *hz
);
251 if (test_bit(SND_BELL
, dev
->sndbit
))
252 input_inject_event(handle
, EV_SND
, SND_BELL
, *hz
? 1 : 0);
258 static void kd_nosound(unsigned long ignored
)
260 static unsigned int zero
;
262 input_handler_for_each_handle(&kbd_handler
, &zero
, kd_sound_helper
);
265 static DEFINE_TIMER(kd_mksound_timer
, kd_nosound
, 0, 0);
267 void kd_mksound(unsigned int hz
, unsigned int ticks
)
269 del_timer_sync(&kd_mksound_timer
);
271 input_handler_for_each_handle(&kbd_handler
, &hz
, kd_sound_helper
);
274 mod_timer(&kd_mksound_timer
, jiffies
+ ticks
);
276 EXPORT_SYMBOL(kd_mksound
);
279 * Setting the keyboard rate.
282 static int kbd_rate_helper(struct input_handle
*handle
, void *data
)
284 struct input_dev
*dev
= handle
->dev
;
285 struct kbd_repeat
*rep
= data
;
287 if (test_bit(EV_REP
, dev
->evbit
)) {
289 if (rep
[0].delay
> 0)
290 input_inject_event(handle
,
291 EV_REP
, REP_DELAY
, rep
[0].delay
);
292 if (rep
[0].period
> 0)
293 input_inject_event(handle
,
294 EV_REP
, REP_PERIOD
, rep
[0].period
);
296 rep
[1].delay
= dev
->rep
[REP_DELAY
];
297 rep
[1].period
= dev
->rep
[REP_PERIOD
];
303 int kbd_rate(struct kbd_repeat
*rep
)
305 struct kbd_repeat data
[2] = { *rep
};
307 input_handler_for_each_handle(&kbd_handler
, data
, kbd_rate_helper
);
308 *rep
= data
[1]; /* Copy currently used settings */
316 static void put_queue(struct vc_data
*vc
, int ch
)
318 struct tty_struct
*tty
= vc
->port
.tty
;
321 tty_insert_flip_char(tty
, ch
, 0);
322 con_schedule_flip(tty
);
326 static void puts_queue(struct vc_data
*vc
, char *cp
)
328 struct tty_struct
*tty
= vc
->port
.tty
;
334 tty_insert_flip_char(tty
, *cp
, 0);
337 con_schedule_flip(tty
);
340 static void applkey(struct vc_data
*vc
, int key
, char mode
)
342 static char buf
[] = { 0x1b, 'O', 0x00, 0x00 };
344 buf
[1] = (mode
? 'O' : '[');
350 * Many other routines do put_queue, but I think either
351 * they produce ASCII, or they produce some user-assigned
352 * string, and in both cases we might assume that it is
355 static void to_utf8(struct vc_data
*vc
, uint c
)
360 else if (c
< 0x800) {
361 /* 110***** 10****** */
362 put_queue(vc
, 0xc0 | (c
>> 6));
363 put_queue(vc
, 0x80 | (c
& 0x3f));
364 } else if (c
< 0x10000) {
365 if (c
>= 0xD800 && c
< 0xE000)
369 /* 1110**** 10****** 10****** */
370 put_queue(vc
, 0xe0 | (c
>> 12));
371 put_queue(vc
, 0x80 | ((c
>> 6) & 0x3f));
372 put_queue(vc
, 0x80 | (c
& 0x3f));
373 } else if (c
< 0x110000) {
374 /* 11110*** 10****** 10****** 10****** */
375 put_queue(vc
, 0xf0 | (c
>> 18));
376 put_queue(vc
, 0x80 | ((c
>> 12) & 0x3f));
377 put_queue(vc
, 0x80 | ((c
>> 6) & 0x3f));
378 put_queue(vc
, 0x80 | (c
& 0x3f));
383 * Called after returning from RAW mode or when changing consoles - recompute
384 * shift_down[] and shift_state from key_down[] maybe called when keymap is
385 * undefined, so that shiftkey release is seen
387 void compute_shiftstate(void)
389 unsigned int i
, j
, k
, sym
, val
;
392 memset(shift_down
, 0, sizeof(shift_down
));
394 for (i
= 0; i
< ARRAY_SIZE(key_down
); i
++) {
399 k
= i
* BITS_PER_LONG
;
401 for (j
= 0; j
< BITS_PER_LONG
; j
++, k
++) {
403 if (!test_bit(k
, key_down
))
406 sym
= U(key_maps
[0][k
]);
407 if (KTYP(sym
) != KT_SHIFT
&& KTYP(sym
) != KT_SLOCK
)
411 if (val
== KVAL(K_CAPSSHIFT
))
415 shift_state
|= (1 << val
);
421 * We have a combining character DIACR here, followed by the character CH.
422 * If the combination occurs in the table, return the corresponding value.
423 * Otherwise, if CH is a space or equals DIACR, return DIACR.
424 * Otherwise, conclude that DIACR was not combining after all,
425 * queue it and return CH.
427 static unsigned int handle_diacr(struct vc_data
*vc
, unsigned int ch
)
429 unsigned int d
= diacr
;
434 if ((d
& ~0xff) == BRL_UC_ROW
) {
435 if ((ch
& ~0xff) == BRL_UC_ROW
)
438 for (i
= 0; i
< accent_table_size
; i
++)
439 if (accent_table
[i
].diacr
== d
&& accent_table
[i
].base
== ch
)
440 return accent_table
[i
].result
;
443 if (ch
== ' ' || ch
== (BRL_UC_ROW
|0) || ch
== d
)
446 if (kbd
->kbdmode
== VC_UNICODE
)
449 int c
= conv_uni_to_8bit(d
);
458 * Special function handlers
460 static void fn_enter(struct vc_data
*vc
)
463 if (kbd
->kbdmode
== VC_UNICODE
)
466 int c
= conv_uni_to_8bit(diacr
);
474 if (vc_kbd_mode(kbd
, VC_CRLF
))
478 static void fn_caps_toggle(struct vc_data
*vc
)
483 chg_vc_kbd_led(kbd
, VC_CAPSLOCK
);
486 static void fn_caps_on(struct vc_data
*vc
)
491 set_vc_kbd_led(kbd
, VC_CAPSLOCK
);
494 static void fn_show_ptregs(struct vc_data
*vc
)
496 struct pt_regs
*regs
= get_irq_regs();
502 static void fn_hold(struct vc_data
*vc
)
504 struct tty_struct
*tty
= vc
->port
.tty
;
510 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
511 * these routines are also activated by ^S/^Q.
512 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
520 static void fn_num(struct vc_data
*vc
)
522 if (vc_kbd_mode(kbd
, VC_APPLIC
))
529 * Bind this to Shift-NumLock if you work in application keypad mode
530 * but want to be able to change the NumLock flag.
531 * Bind this to NumLock if you prefer that the NumLock key always
532 * changes the NumLock flag.
534 static void fn_bare_num(struct vc_data
*vc
)
537 chg_vc_kbd_led(kbd
, VC_NUMLOCK
);
540 static void fn_lastcons(struct vc_data
*vc
)
542 /* switch to the last used console, ChN */
543 set_console(last_console
);
546 static void fn_dec_console(struct vc_data
*vc
)
548 int i
, cur
= fg_console
;
550 /* Currently switching? Queue this next switch relative to that. */
551 if (want_console
!= -1)
554 for (i
= cur
- 1; i
!= cur
; i
--) {
556 i
= MAX_NR_CONSOLES
- 1;
557 if (vc_cons_allocated(i
))
563 static void fn_inc_console(struct vc_data
*vc
)
565 int i
, cur
= fg_console
;
567 /* Currently switching? Queue this next switch relative to that. */
568 if (want_console
!= -1)
571 for (i
= cur
+1; i
!= cur
; i
++) {
572 if (i
== MAX_NR_CONSOLES
)
574 if (vc_cons_allocated(i
))
580 static void fn_send_intr(struct vc_data
*vc
)
582 struct tty_struct
*tty
= vc
->port
.tty
;
586 tty_insert_flip_char(tty
, 0, TTY_BREAK
);
587 con_schedule_flip(tty
);
590 static void fn_scroll_forw(struct vc_data
*vc
)
595 static void fn_scroll_back(struct vc_data
*vc
)
600 static void fn_show_mem(struct vc_data
*vc
)
605 static void fn_show_state(struct vc_data
*vc
)
610 static void fn_boot_it(struct vc_data
*vc
)
615 static void fn_compose(struct vc_data
*vc
)
617 dead_key_next
= true;
620 static void fn_spawn_con(struct vc_data
*vc
)
622 spin_lock(&vt_spawn_con
.lock
);
623 if (vt_spawn_con
.pid
)
624 if (kill_pid(vt_spawn_con
.pid
, vt_spawn_con
.sig
, 1)) {
625 put_pid(vt_spawn_con
.pid
);
626 vt_spawn_con
.pid
= NULL
;
628 spin_unlock(&vt_spawn_con
.lock
);
631 static void fn_SAK(struct vc_data
*vc
)
633 struct work_struct
*SAK_work
= &vc_cons
[fg_console
].SAK_work
;
634 schedule_work(SAK_work
);
637 static void fn_null(struct vc_data
*vc
)
639 compute_shiftstate();
643 * Special key handlers
645 static void k_ignore(struct vc_data
*vc
, unsigned char value
, char up_flag
)
649 static void k_spec(struct vc_data
*vc
, unsigned char value
, char up_flag
)
653 if (value
>= ARRAY_SIZE(fn_handler
))
655 if ((kbd
->kbdmode
== VC_RAW
||
656 kbd
->kbdmode
== VC_MEDIUMRAW
||
657 kbd
->kbdmode
== VC_OFF
) &&
658 value
!= KVAL(K_SAK
))
659 return; /* SAK is allowed even in raw mode */
660 fn_handler
[value
](vc
);
663 static void k_lowercase(struct vc_data
*vc
, unsigned char value
, char up_flag
)
665 pr_err("k_lowercase was called - impossible\n");
668 static void k_unicode(struct vc_data
*vc
, unsigned int value
, char up_flag
)
671 return; /* no action, if this is a key release */
674 value
= handle_diacr(vc
, value
);
677 dead_key_next
= false;
681 if (kbd
->kbdmode
== VC_UNICODE
)
684 int c
= conv_uni_to_8bit(value
);
691 * Handle dead key. Note that we now may have several
692 * dead keys modifying the same character. Very useful
695 static void k_deadunicode(struct vc_data
*vc
, unsigned int value
, char up_flag
)
700 diacr
= (diacr
? handle_diacr(vc
, value
) : value
);
703 static void k_self(struct vc_data
*vc
, unsigned char value
, char up_flag
)
705 k_unicode(vc
, conv_8bit_to_uni(value
), up_flag
);
708 static void k_dead2(struct vc_data
*vc
, unsigned char value
, char up_flag
)
710 k_deadunicode(vc
, value
, up_flag
);
714 * Obsolete - for backwards compatibility only
716 static void k_dead(struct vc_data
*vc
, unsigned char value
, char up_flag
)
718 static const unsigned char ret_diacr
[NR_DEAD
] = {'`', '\'', '^', '~', '"', ',' };
720 k_deadunicode(vc
, ret_diacr
[value
], up_flag
);
723 static void k_cons(struct vc_data
*vc
, unsigned char value
, char up_flag
)
731 static void k_fn(struct vc_data
*vc
, unsigned char value
, char up_flag
)
736 if ((unsigned)value
< ARRAY_SIZE(func_table
)) {
737 if (func_table
[value
])
738 puts_queue(vc
, func_table
[value
]);
740 pr_err("k_fn called with value=%d\n", value
);
743 static void k_cur(struct vc_data
*vc
, unsigned char value
, char up_flag
)
745 static const char cur_chars
[] = "BDCA";
750 applkey(vc
, cur_chars
[value
], vc_kbd_mode(kbd
, VC_CKMODE
));
753 static void k_pad(struct vc_data
*vc
, unsigned char value
, char up_flag
)
755 static const char pad_chars
[] = "0123456789+-*/\015,.?()#";
756 static const char app_map
[] = "pqrstuvwxylSRQMnnmPQS";
759 return; /* no action, if this is a key release */
761 /* kludge... shift forces cursor/number keys */
762 if (vc_kbd_mode(kbd
, VC_APPLIC
) && !shift_down
[KG_SHIFT
]) {
763 applkey(vc
, app_map
[value
], 1);
767 if (!vc_kbd_led(kbd
, VC_NUMLOCK
)) {
772 k_fn(vc
, KVAL(K_REMOVE
), 0);
775 k_fn(vc
, KVAL(K_INSERT
), 0);
778 k_fn(vc
, KVAL(K_SELECT
), 0);
781 k_cur(vc
, KVAL(K_DOWN
), 0);
784 k_fn(vc
, KVAL(K_PGDN
), 0);
787 k_cur(vc
, KVAL(K_LEFT
), 0);
790 k_cur(vc
, KVAL(K_RIGHT
), 0);
793 k_fn(vc
, KVAL(K_FIND
), 0);
796 k_cur(vc
, KVAL(K_UP
), 0);
799 k_fn(vc
, KVAL(K_PGUP
), 0);
802 applkey(vc
, 'G', vc_kbd_mode(kbd
, VC_APPLIC
));
807 put_queue(vc
, pad_chars
[value
]);
808 if (value
== KVAL(K_PENTER
) && vc_kbd_mode(kbd
, VC_CRLF
))
812 static void k_shift(struct vc_data
*vc
, unsigned char value
, char up_flag
)
814 int old_state
= shift_state
;
820 * a CapsShift key acts like Shift but undoes CapsLock
822 if (value
== KVAL(K_CAPSSHIFT
)) {
823 value
= KVAL(K_SHIFT
);
825 clr_vc_kbd_led(kbd
, VC_CAPSLOCK
);
830 * handle the case that two shift or control
831 * keys are depressed simultaneously
833 if (shift_down
[value
])
838 if (shift_down
[value
])
839 shift_state
|= (1 << value
);
841 shift_state
&= ~(1 << value
);
844 if (up_flag
&& shift_state
!= old_state
&& npadch
!= -1) {
845 if (kbd
->kbdmode
== VC_UNICODE
)
848 put_queue(vc
, npadch
& 0xff);
853 static void k_meta(struct vc_data
*vc
, unsigned char value
, char up_flag
)
858 if (vc_kbd_mode(kbd
, VC_META
)) {
859 put_queue(vc
, '\033');
860 put_queue(vc
, value
);
862 put_queue(vc
, value
| 0x80);
865 static void k_ascii(struct vc_data
*vc
, unsigned char value
, char up_flag
)
873 /* decimal input of code, while Alt depressed */
876 /* hexadecimal input of code, while AltGr depressed */
884 npadch
= npadch
* base
+ value
;
887 static void k_lock(struct vc_data
*vc
, unsigned char value
, char up_flag
)
892 chg_vc_kbd_lock(kbd
, value
);
895 static void k_slock(struct vc_data
*vc
, unsigned char value
, char up_flag
)
897 k_shift(vc
, value
, up_flag
);
901 chg_vc_kbd_slock(kbd
, value
);
902 /* try to make Alt, oops, AltGr and such work */
903 if (!key_maps
[kbd
->lockstate
^ kbd
->slockstate
]) {
905 chg_vc_kbd_slock(kbd
, value
);
909 /* by default, 300ms interval for combination release */
910 static unsigned brl_timeout
= 300;
911 MODULE_PARM_DESC(brl_timeout
, "Braille keys release delay in ms (0 for commit on first key release)");
912 module_param(brl_timeout
, uint
, 0644);
914 static unsigned brl_nbchords
= 1;
915 MODULE_PARM_DESC(brl_nbchords
, "Number of chords that produce a braille pattern (0 for dead chords)");
916 module_param(brl_nbchords
, uint
, 0644);
918 static void k_brlcommit(struct vc_data
*vc
, unsigned int pattern
, char up_flag
)
920 static unsigned long chords
;
921 static unsigned committed
;
924 k_deadunicode(vc
, BRL_UC_ROW
| pattern
, up_flag
);
926 committed
|= pattern
;
928 if (chords
== brl_nbchords
) {
929 k_unicode(vc
, BRL_UC_ROW
| committed
, up_flag
);
936 static void k_brl(struct vc_data
*vc
, unsigned char value
, char up_flag
)
938 static unsigned pressed
, committing
;
939 static unsigned long releasestart
;
941 if (kbd
->kbdmode
!= VC_UNICODE
) {
943 pr_warning("keyboard mode must be unicode for braille patterns\n");
948 k_unicode(vc
, BRL_UC_ROW
, up_flag
);
956 pressed
|= 1 << (value
- 1);
958 committing
= pressed
;
959 } else if (brl_timeout
) {
962 releasestart
+ msecs_to_jiffies(brl_timeout
))) {
963 committing
= pressed
;
964 releasestart
= jiffies
;
966 pressed
&= ~(1 << (value
- 1));
967 if (!pressed
&& committing
) {
968 k_brlcommit(vc
, committing
, 0);
973 k_brlcommit(vc
, committing
, 0);
976 pressed
&= ~(1 << (value
- 1));
981 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
982 * or (ii) whatever pattern of lights people want to show using KDSETLED,
983 * or (iii) specified bits of specified words in kernel memory.
985 unsigned char getledstate(void)
990 void setledstate(struct kbd_struct
*kbd
, unsigned int led
)
994 kbd
->ledmode
= LED_SHOW_IOCTL
;
996 kbd
->ledmode
= LED_SHOW_FLAGS
;
1001 static inline unsigned char getleds(void)
1003 struct kbd_struct
*kbd
= kbd_table
+ fg_console
;
1007 if (kbd
->ledmode
== LED_SHOW_IOCTL
)
1010 leds
= kbd
->ledflagstate
;
1012 if (kbd
->ledmode
== LED_SHOW_MEM
) {
1013 for (i
= 0; i
< 3; i
++)
1014 if (ledptrs
[i
].valid
) {
1015 if (*ledptrs
[i
].addr
& ledptrs
[i
].mask
)
1024 static int kbd_update_leds_helper(struct input_handle
*handle
, void *data
)
1026 unsigned char leds
= *(unsigned char *)data
;
1028 if (test_bit(EV_LED
, handle
->dev
->evbit
)) {
1029 input_inject_event(handle
, EV_LED
, LED_SCROLLL
, !!(leds
& 0x01));
1030 input_inject_event(handle
, EV_LED
, LED_NUML
, !!(leds
& 0x02));
1031 input_inject_event(handle
, EV_LED
, LED_CAPSL
, !!(leds
& 0x04));
1032 input_inject_event(handle
, EV_SYN
, SYN_REPORT
, 0);
1039 * This is the tasklet that updates LED state on all keyboards
1040 * attached to the box. The reason we use tasklet is that we
1041 * need to handle the scenario when keyboard handler is not
1042 * registered yet but we already getting updates form VT to
1045 static void kbd_bh(unsigned long dummy
)
1047 unsigned char leds
= getleds();
1049 if (leds
!= ledstate
) {
1050 input_handler_for_each_handle(&kbd_handler
, &leds
,
1051 kbd_update_leds_helper
);
1056 DECLARE_TASKLET_DISABLED(keyboard_tasklet
, kbd_bh
, 0);
1058 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1059 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1060 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1061 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1062 defined(CONFIG_AVR32)
1064 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1065 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1067 static const unsigned short x86_keycodes
[256] =
1068 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1069 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1070 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1071 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1072 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1073 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1074 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1075 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1076 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1077 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1078 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1079 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1080 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1081 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1082 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1085 static int sparc_l1_a_state
;
1086 extern void sun_do_break(void);
1089 static int emulate_raw(struct vc_data
*vc
, unsigned int keycode
,
1090 unsigned char up_flag
)
1097 put_queue(vc
, 0xe1);
1098 put_queue(vc
, 0x1d | up_flag
);
1099 put_queue(vc
, 0x45 | up_flag
);
1104 put_queue(vc
, 0xf2);
1109 put_queue(vc
, 0xf1);
1114 * Real AT keyboards (that's what we're trying
1115 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1116 * pressing PrtSc/SysRq alone, but simply 0x54
1117 * when pressing Alt+PrtSc/SysRq.
1119 if (test_bit(KEY_LEFTALT
, key_down
) ||
1120 test_bit(KEY_RIGHTALT
, key_down
)) {
1121 put_queue(vc
, 0x54 | up_flag
);
1123 put_queue(vc
, 0xe0);
1124 put_queue(vc
, 0x2a | up_flag
);
1125 put_queue(vc
, 0xe0);
1126 put_queue(vc
, 0x37 | up_flag
);
1134 code
= x86_keycodes
[keycode
];
1139 put_queue(vc
, 0xe0);
1140 put_queue(vc
, (code
& 0x7f) | up_flag
);
1150 #define HW_RAW(dev) 0
1152 static int emulate_raw(struct vc_data
*vc
, unsigned int keycode
, unsigned char up_flag
)
1157 put_queue(vc
, keycode
| up_flag
);
1162 static void kbd_rawcode(unsigned char data
)
1164 struct vc_data
*vc
= vc_cons
[fg_console
].d
;
1166 kbd
= kbd_table
+ vc
->vc_num
;
1167 if (kbd
->kbdmode
== VC_RAW
)
1168 put_queue(vc
, data
);
1171 static void kbd_keycode(unsigned int keycode
, int down
, int hw_raw
)
1173 struct vc_data
*vc
= vc_cons
[fg_console
].d
;
1174 unsigned short keysym
, *key_map
;
1177 struct tty_struct
*tty
;
1179 struct keyboard_notifier_param param
= { .vc
= vc
, .value
= keycode
, .down
= down
};
1184 if (tty
&& (!tty
->driver_data
)) {
1185 /* No driver data? Strange. Okay we fix it then. */
1186 tty
->driver_data
= vc
;
1189 kbd
= kbd_table
+ vc
->vc_num
;
1192 if (keycode
== KEY_STOP
)
1193 sparc_l1_a_state
= down
;
1198 raw_mode
= (kbd
->kbdmode
== VC_RAW
);
1199 if (raw_mode
&& !hw_raw
)
1200 if (emulate_raw(vc
, keycode
, !down
<< 7))
1201 if (keycode
< BTN_MISC
&& printk_ratelimit())
1202 pr_warning("can't emulate rawmode for keycode %d\n",
1206 if (keycode
== KEY_A
&& sparc_l1_a_state
) {
1207 sparc_l1_a_state
= false;
1212 if (kbd
->kbdmode
== VC_MEDIUMRAW
) {
1214 * This is extended medium raw mode, with keys above 127
1215 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1216 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1217 * interfere with anything else. The two bytes after 0 will
1218 * always have the up flag set not to interfere with older
1219 * applications. This allows for 16384 different keycodes,
1220 * which should be enough.
1222 if (keycode
< 128) {
1223 put_queue(vc
, keycode
| (!down
<< 7));
1225 put_queue(vc
, !down
<< 7);
1226 put_queue(vc
, (keycode
>> 7) | 0x80);
1227 put_queue(vc
, keycode
| 0x80);
1233 set_bit(keycode
, key_down
);
1235 clear_bit(keycode
, key_down
);
1238 (!vc_kbd_mode(kbd
, VC_REPEAT
) ||
1239 (tty
&& !L_ECHO(tty
) && tty_chars_in_buffer(tty
)))) {
1241 * Don't repeat a key if the input buffers are not empty and the
1242 * characters get aren't echoed locally. This makes key repeat
1243 * usable with slow applications and under heavy loads.
1248 param
.shift
= shift_final
= (shift_state
| kbd
->slockstate
) ^ kbd
->lockstate
;
1249 param
.ledstate
= kbd
->ledflagstate
;
1250 key_map
= key_maps
[shift_final
];
1252 rc
= atomic_notifier_call_chain(&keyboard_notifier_list
,
1253 KBD_KEYCODE
, ¶m
);
1254 if (rc
== NOTIFY_STOP
|| !key_map
) {
1255 atomic_notifier_call_chain(&keyboard_notifier_list
,
1256 KBD_UNBOUND_KEYCODE
, ¶m
);
1257 compute_shiftstate();
1258 kbd
->slockstate
= 0;
1262 if (keycode
< NR_KEYS
)
1263 keysym
= key_map
[keycode
];
1264 else if (keycode
>= KEY_BRL_DOT1
&& keycode
<= KEY_BRL_DOT8
)
1265 keysym
= U(K(KT_BRL
, keycode
- KEY_BRL_DOT1
+ 1));
1269 type
= KTYP(keysym
);
1272 param
.value
= keysym
;
1273 rc
= atomic_notifier_call_chain(&keyboard_notifier_list
,
1274 KBD_UNICODE
, ¶m
);
1275 if (rc
!= NOTIFY_STOP
)
1276 if (down
&& !raw_mode
)
1277 to_utf8(vc
, keysym
);
1283 if (type
== KT_LETTER
) {
1285 if (vc_kbd_led(kbd
, VC_CAPSLOCK
)) {
1286 key_map
= key_maps
[shift_final
^ (1 << KG_SHIFT
)];
1288 keysym
= key_map
[keycode
];
1292 param
.value
= keysym
;
1293 rc
= atomic_notifier_call_chain(&keyboard_notifier_list
,
1294 KBD_KEYSYM
, ¶m
);
1295 if (rc
== NOTIFY_STOP
)
1298 if ((raw_mode
|| kbd
->kbdmode
== VC_OFF
) && type
!= KT_SPEC
&& type
!= KT_SHIFT
)
1301 (*k_handler
[type
])(vc
, keysym
& 0xff, !down
);
1303 param
.ledstate
= kbd
->ledflagstate
;
1304 atomic_notifier_call_chain(&keyboard_notifier_list
, KBD_POST_KEYSYM
, ¶m
);
1306 if (type
!= KT_SLOCK
)
1307 kbd
->slockstate
= 0;
1310 static void kbd_event(struct input_handle
*handle
, unsigned int event_type
,
1311 unsigned int event_code
, int value
)
1313 /* We are called with interrupts disabled, just take the lock */
1314 spin_lock(&kbd_event_lock
);
1316 if (event_type
== EV_MSC
&& event_code
== MSC_RAW
&& HW_RAW(handle
->dev
))
1318 if (event_type
== EV_KEY
)
1319 kbd_keycode(event_code
, value
, HW_RAW(handle
->dev
));
1321 spin_unlock(&kbd_event_lock
);
1323 tasklet_schedule(&keyboard_tasklet
);
1324 do_poke_blanked_console
= 1;
1325 schedule_console_callback();
1328 static bool kbd_match(struct input_handler
*handler
, struct input_dev
*dev
)
1332 if (test_bit(EV_SND
, dev
->evbit
))
1335 if (test_bit(EV_KEY
, dev
->evbit
)) {
1336 for (i
= KEY_RESERVED
; i
< BTN_MISC
; i
++)
1337 if (test_bit(i
, dev
->keybit
))
1339 for (i
= KEY_BRL_DOT1
; i
<= KEY_BRL_DOT10
; i
++)
1340 if (test_bit(i
, dev
->keybit
))
1348 * When a keyboard (or other input device) is found, the kbd_connect
1349 * function is called. The function then looks at the device, and if it
1350 * likes it, it can open it and get events from it. In this (kbd_connect)
1351 * function, we should decide which VT to bind that keyboard to initially.
1353 static int kbd_connect(struct input_handler
*handler
, struct input_dev
*dev
,
1354 const struct input_device_id
*id
)
1356 struct input_handle
*handle
;
1359 handle
= kzalloc(sizeof(struct input_handle
), GFP_KERNEL
);
1364 handle
->handler
= handler
;
1365 handle
->name
= "kbd";
1367 error
= input_register_handle(handle
);
1369 goto err_free_handle
;
1371 error
= input_open_device(handle
);
1373 goto err_unregister_handle
;
1377 err_unregister_handle
:
1378 input_unregister_handle(handle
);
1384 static void kbd_disconnect(struct input_handle
*handle
)
1386 input_close_device(handle
);
1387 input_unregister_handle(handle
);
1392 * Start keyboard handler on the new keyboard by refreshing LED state to
1393 * match the rest of the system.
1395 static void kbd_start(struct input_handle
*handle
)
1397 tasklet_disable(&keyboard_tasklet
);
1399 if (ledstate
!= 0xff)
1400 kbd_update_leds_helper(handle
, &ledstate
);
1402 tasklet_enable(&keyboard_tasklet
);
1405 static const struct input_device_id kbd_ids
[] = {
1407 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
,
1408 .evbit
= { BIT_MASK(EV_KEY
) },
1412 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
,
1413 .evbit
= { BIT_MASK(EV_SND
) },
1416 { }, /* Terminating entry */
1419 MODULE_DEVICE_TABLE(input
, kbd_ids
);
1421 static struct input_handler kbd_handler
= {
1424 .connect
= kbd_connect
,
1425 .disconnect
= kbd_disconnect
,
1428 .id_table
= kbd_ids
,
1431 int __init
kbd_init(void)
1436 for (i
= 0; i
< MAX_NR_CONSOLES
; i
++) {
1437 kbd_table
[i
].ledflagstate
= KBD_DEFLEDS
;
1438 kbd_table
[i
].default_ledflagstate
= KBD_DEFLEDS
;
1439 kbd_table
[i
].ledmode
= LED_SHOW_FLAGS
;
1440 kbd_table
[i
].lockstate
= KBD_DEFLOCK
;
1441 kbd_table
[i
].slockstate
= 0;
1442 kbd_table
[i
].modeflags
= KBD_DEFMODE
;
1443 kbd_table
[i
].kbdmode
= default_utf8
? VC_UNICODE
: VC_XLATE
;
1446 error
= input_register_handler(&kbd_handler
);
1450 tasklet_enable(&keyboard_tasklet
);
1451 tasklet_schedule(&keyboard_tasklet
);