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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29 #include <linux/consolemap.h>
30 #include <linux/module.h>
31 #include <linux/sched.h>
32 #include <linux/tty.h>
33 #include <linux/tty_flip.h>
35 #include <linux/string.h>
36 #include <linux/init.h>
37 #include <linux/slab.h>
38 #include <linux/irq.h>
40 #include <linux/kbd_kern.h>
41 #include <linux/kbd_diacr.h>
42 #include <linux/vt_kern.h>
43 #include <linux/input.h>
44 #include <linux/reboot.h>
45 #include <linux/notifier.h>
46 #include <linux/jiffies.h>
48 extern void ctrl_alt_del(void);
51 * Exported functions/variables
54 #define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
57 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
58 * This seems a good reason to start with NumLock off. On HIL keyboards
59 * of PARISC machines however there is no NumLock key and everyone expects the keypad
60 * to be used for numbers.
63 #if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
64 #define KBD_DEFLEDS (1 << VC_NUMLOCK)
71 void compute_shiftstate(void);
78 k_self, k_fn, k_spec, k_pad,\
79 k_dead, k_cons, k_cur, k_shift,\
80 k_meta, k_ascii, k_lock, k_lowercase,\
81 k_slock, k_dead2, k_brl, k_ignore
83 typedef void (k_handler_fn
)(struct vc_data
*vc
, unsigned char value
,
85 static k_handler_fn K_HANDLERS
;
86 static k_handler_fn
*k_handler
[16] = { K_HANDLERS
};
89 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
90 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
91 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
92 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
93 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
95 typedef void (fn_handler_fn
)(struct vc_data
*vc
);
96 static fn_handler_fn FN_HANDLERS
;
97 static fn_handler_fn
*fn_handler
[] = { FN_HANDLERS
};
100 * Variables exported for vt_ioctl.c
103 /* maximum values each key_handler can handle */
104 const int max_vals
[] = {
105 255, ARRAY_SIZE(func_table
) - 1, ARRAY_SIZE(fn_handler
) - 1, NR_PAD
- 1,
106 NR_DEAD
- 1, 255, 3, NR_SHIFT
- 1, 255, NR_ASCII
- 1, NR_LOCK
- 1,
107 255, NR_LOCK
- 1, 255, NR_BRL
- 1
110 const int NR_TYPES
= ARRAY_SIZE(max_vals
);
112 struct kbd_struct kbd_table
[MAX_NR_CONSOLES
];
113 EXPORT_SYMBOL_GPL(kbd_table
);
114 static struct kbd_struct
*kbd
= kbd_table
;
116 struct vt_spawn_console vt_spawn_con
= {
117 .lock
= __SPIN_LOCK_UNLOCKED(vt_spawn_con
.lock
),
123 * Variables exported for vt.c
132 static struct input_handler kbd_handler
;
133 static DEFINE_SPINLOCK(kbd_event_lock
);
134 static unsigned long key_down
[BITS_TO_LONGS(KEY_CNT
)]; /* keyboard key bitmap */
135 static unsigned char shift_down
[NR_SHIFT
]; /* shift state counters.. */
136 static int dead_key_next
;
137 static int npadch
= -1; /* -1 or number assembled on pad */
138 static unsigned int diacr
;
139 static char rep
; /* flag telling character repeat */
141 static unsigned char ledstate
= 0xff; /* undefined */
142 static unsigned char ledioctl
;
144 static struct ledptr
{
147 unsigned char valid
:1;
151 * Notifier list for console keyboard events
153 static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list
);
155 int register_keyboard_notifier(struct notifier_block
*nb
)
157 return atomic_notifier_chain_register(&keyboard_notifier_list
, nb
);
159 EXPORT_SYMBOL_GPL(register_keyboard_notifier
);
161 int unregister_keyboard_notifier(struct notifier_block
*nb
)
163 return atomic_notifier_chain_unregister(&keyboard_notifier_list
, nb
);
165 EXPORT_SYMBOL_GPL(unregister_keyboard_notifier
);
168 * Translation of scancodes to keycodes. We set them on only the first
169 * keyboard in the list that accepts the scancode and keycode.
170 * Explanation for not choosing the first attached keyboard anymore:
171 * USB keyboards for example have two event devices: one for all "normal"
172 * keys and one for extra function keys (like "volume up", "make coffee",
173 * etc.). So this means that scancodes for the extra function keys won't
174 * be valid for the first event device, but will be for the second.
177 struct getset_keycode_data
{
178 unsigned int scancode
;
179 unsigned int keycode
;
183 static int getkeycode_helper(struct input_handle
*handle
, void *data
)
185 struct getset_keycode_data
*d
= data
;
187 d
->error
= input_get_keycode(handle
->dev
, d
->scancode
, &d
->keycode
);
189 return d
->error
== 0; /* stop as soon as we successfully get one */
192 int getkeycode(unsigned int scancode
)
194 struct getset_keycode_data d
= { scancode
, 0, -ENODEV
};
196 input_handler_for_each_handle(&kbd_handler
, &d
, getkeycode_helper
);
198 return d
.error
?: d
.keycode
;
201 static int setkeycode_helper(struct input_handle
*handle
, void *data
)
203 struct getset_keycode_data
*d
= data
;
205 d
->error
= input_set_keycode(handle
->dev
, d
->scancode
, d
->keycode
);
207 return d
->error
== 0; /* stop as soon as we successfully set one */
210 int setkeycode(unsigned int scancode
, unsigned int keycode
)
212 struct getset_keycode_data d
= { scancode
, keycode
, -ENODEV
};
214 input_handler_for_each_handle(&kbd_handler
, &d
, setkeycode_helper
);
220 * Making beeps and bells. Note that we prefer beeps to bells, but when
221 * shutting the sound off we do both.
224 static int kd_sound_helper(struct input_handle
*handle
, void *data
)
226 unsigned int *hz
= data
;
227 struct input_dev
*dev
= handle
->dev
;
229 if (test_bit(EV_SND
, dev
->evbit
)) {
230 if (test_bit(SND_TONE
, dev
->sndbit
)) {
231 input_inject_event(handle
, EV_SND
, SND_TONE
, *hz
);
235 if (test_bit(SND_BELL
, dev
->sndbit
))
236 input_inject_event(handle
, EV_SND
, SND_BELL
, *hz
? 1 : 0);
242 static void kd_nosound(unsigned long ignored
)
244 static unsigned int zero
;
246 input_handler_for_each_handle(&kbd_handler
, &zero
, kd_sound_helper
);
249 static DEFINE_TIMER(kd_mksound_timer
, kd_nosound
, 0, 0);
251 void kd_mksound(unsigned int hz
, unsigned int ticks
)
253 del_timer_sync(&kd_mksound_timer
);
255 input_handler_for_each_handle(&kbd_handler
, &hz
, kd_sound_helper
);
258 mod_timer(&kd_mksound_timer
, jiffies
+ ticks
);
260 EXPORT_SYMBOL(kd_mksound
);
263 * Setting the keyboard rate.
266 static int kbd_rate_helper(struct input_handle
*handle
, void *data
)
268 struct input_dev
*dev
= handle
->dev
;
269 struct kbd_repeat
*rep
= data
;
271 if (test_bit(EV_REP
, dev
->evbit
)) {
273 if (rep
[0].delay
> 0)
274 input_inject_event(handle
,
275 EV_REP
, REP_DELAY
, rep
[0].delay
);
276 if (rep
[0].period
> 0)
277 input_inject_event(handle
,
278 EV_REP
, REP_PERIOD
, rep
[0].period
);
280 rep
[1].delay
= dev
->rep
[REP_DELAY
];
281 rep
[1].period
= dev
->rep
[REP_PERIOD
];
287 int kbd_rate(struct kbd_repeat
*rep
)
289 struct kbd_repeat data
[2] = { *rep
};
291 input_handler_for_each_handle(&kbd_handler
, data
, kbd_rate_helper
);
292 *rep
= data
[1]; /* Copy currently used settings */
300 static void put_queue(struct vc_data
*vc
, int ch
)
302 struct tty_struct
*tty
= vc
->vc_tty
;
305 tty_insert_flip_char(tty
, ch
, 0);
306 con_schedule_flip(tty
);
310 static void puts_queue(struct vc_data
*vc
, char *cp
)
312 struct tty_struct
*tty
= vc
->vc_tty
;
318 tty_insert_flip_char(tty
, *cp
, 0);
321 con_schedule_flip(tty
);
324 static void applkey(struct vc_data
*vc
, int key
, char mode
)
326 static char buf
[] = { 0x1b, 'O', 0x00, 0x00 };
328 buf
[1] = (mode
? 'O' : '[');
334 * Many other routines do put_queue, but I think either
335 * they produce ASCII, or they produce some user-assigned
336 * string, and in both cases we might assume that it is
339 static void to_utf8(struct vc_data
*vc
, uint c
)
344 else if (c
< 0x800) {
345 /* 110***** 10****** */
346 put_queue(vc
, 0xc0 | (c
>> 6));
347 put_queue(vc
, 0x80 | (c
& 0x3f));
348 } else if (c
< 0x10000) {
349 if (c
>= 0xD800 && c
< 0xE000)
353 /* 1110**** 10****** 10****** */
354 put_queue(vc
, 0xe0 | (c
>> 12));
355 put_queue(vc
, 0x80 | ((c
>> 6) & 0x3f));
356 put_queue(vc
, 0x80 | (c
& 0x3f));
357 } else if (c
< 0x110000) {
358 /* 11110*** 10****** 10****** 10****** */
359 put_queue(vc
, 0xf0 | (c
>> 18));
360 put_queue(vc
, 0x80 | ((c
>> 12) & 0x3f));
361 put_queue(vc
, 0x80 | ((c
>> 6) & 0x3f));
362 put_queue(vc
, 0x80 | (c
& 0x3f));
367 * Called after returning from RAW mode or when changing consoles - recompute
368 * shift_down[] and shift_state from key_down[] maybe called when keymap is
369 * undefined, so that shiftkey release is seen
371 void compute_shiftstate(void)
373 unsigned int i
, j
, k
, sym
, val
;
376 memset(shift_down
, 0, sizeof(shift_down
));
378 for (i
= 0; i
< ARRAY_SIZE(key_down
); i
++) {
383 k
= i
* BITS_PER_LONG
;
385 for (j
= 0; j
< BITS_PER_LONG
; j
++, k
++) {
387 if (!test_bit(k
, key_down
))
390 sym
= U(key_maps
[0][k
]);
391 if (KTYP(sym
) != KT_SHIFT
&& KTYP(sym
) != KT_SLOCK
)
395 if (val
== KVAL(K_CAPSSHIFT
))
399 shift_state
|= (1 << val
);
405 * We have a combining character DIACR here, followed by the character CH.
406 * If the combination occurs in the table, return the corresponding value.
407 * Otherwise, if CH is a space or equals DIACR, return DIACR.
408 * Otherwise, conclude that DIACR was not combining after all,
409 * queue it and return CH.
411 static unsigned int handle_diacr(struct vc_data
*vc
, unsigned int ch
)
413 unsigned int d
= diacr
;
418 if ((d
& ~0xff) == BRL_UC_ROW
) {
419 if ((ch
& ~0xff) == BRL_UC_ROW
)
422 for (i
= 0; i
< accent_table_size
; i
++)
423 if (accent_table
[i
].diacr
== d
&& accent_table
[i
].base
== ch
)
424 return accent_table
[i
].result
;
427 if (ch
== ' ' || ch
== (BRL_UC_ROW
|0) || ch
== d
)
430 if (kbd
->kbdmode
== VC_UNICODE
)
433 int c
= conv_uni_to_8bit(d
);
442 * Special function handlers
444 static void fn_enter(struct vc_data
*vc
)
447 if (kbd
->kbdmode
== VC_UNICODE
)
450 int c
= conv_uni_to_8bit(diacr
);
457 if (vc_kbd_mode(kbd
, VC_CRLF
))
461 static void fn_caps_toggle(struct vc_data
*vc
)
465 chg_vc_kbd_led(kbd
, VC_CAPSLOCK
);
468 static void fn_caps_on(struct vc_data
*vc
)
472 set_vc_kbd_led(kbd
, VC_CAPSLOCK
);
475 static void fn_show_ptregs(struct vc_data
*vc
)
477 struct pt_regs
*regs
= get_irq_regs();
482 static void fn_hold(struct vc_data
*vc
)
484 struct tty_struct
*tty
= vc
->vc_tty
;
490 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
491 * these routines are also activated by ^S/^Q.
492 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
500 static void fn_num(struct vc_data
*vc
)
502 if (vc_kbd_mode(kbd
,VC_APPLIC
))
509 * Bind this to Shift-NumLock if you work in application keypad mode
510 * but want to be able to change the NumLock flag.
511 * Bind this to NumLock if you prefer that the NumLock key always
512 * changes the NumLock flag.
514 static void fn_bare_num(struct vc_data
*vc
)
517 chg_vc_kbd_led(kbd
, VC_NUMLOCK
);
520 static void fn_lastcons(struct vc_data
*vc
)
522 /* switch to the last used console, ChN */
523 set_console(last_console
);
526 static void fn_dec_console(struct vc_data
*vc
)
528 int i
, cur
= fg_console
;
530 /* Currently switching? Queue this next switch relative to that. */
531 if (want_console
!= -1)
534 for (i
= cur
- 1; i
!= cur
; i
--) {
536 i
= MAX_NR_CONSOLES
- 1;
537 if (vc_cons_allocated(i
))
543 static void fn_inc_console(struct vc_data
*vc
)
545 int i
, cur
= fg_console
;
547 /* Currently switching? Queue this next switch relative to that. */
548 if (want_console
!= -1)
551 for (i
= cur
+1; i
!= cur
; i
++) {
552 if (i
== MAX_NR_CONSOLES
)
554 if (vc_cons_allocated(i
))
560 static void fn_send_intr(struct vc_data
*vc
)
562 struct tty_struct
*tty
= vc
->vc_tty
;
566 tty_insert_flip_char(tty
, 0, TTY_BREAK
);
567 con_schedule_flip(tty
);
570 static void fn_scroll_forw(struct vc_data
*vc
)
575 static void fn_scroll_back(struct vc_data
*vc
)
580 static void fn_show_mem(struct vc_data
*vc
)
585 static void fn_show_state(struct vc_data
*vc
)
590 static void fn_boot_it(struct vc_data
*vc
)
595 static void fn_compose(struct vc_data
*vc
)
600 static void fn_spawn_con(struct vc_data
*vc
)
602 spin_lock(&vt_spawn_con
.lock
);
603 if (vt_spawn_con
.pid
)
604 if (kill_pid(vt_spawn_con
.pid
, vt_spawn_con
.sig
, 1)) {
605 put_pid(vt_spawn_con
.pid
);
606 vt_spawn_con
.pid
= NULL
;
608 spin_unlock(&vt_spawn_con
.lock
);
611 static void fn_SAK(struct vc_data
*vc
)
613 struct work_struct
*SAK_work
= &vc_cons
[fg_console
].SAK_work
;
614 schedule_work(SAK_work
);
617 static void fn_null(struct vc_data
*vc
)
619 compute_shiftstate();
623 * Special key handlers
625 static void k_ignore(struct vc_data
*vc
, unsigned char value
, char up_flag
)
629 static void k_spec(struct vc_data
*vc
, unsigned char value
, char up_flag
)
633 if (value
>= ARRAY_SIZE(fn_handler
))
635 if ((kbd
->kbdmode
== VC_RAW
||
636 kbd
->kbdmode
== VC_MEDIUMRAW
) &&
637 value
!= KVAL(K_SAK
))
638 return; /* SAK is allowed even in raw mode */
639 fn_handler
[value
](vc
);
642 static void k_lowercase(struct vc_data
*vc
, unsigned char value
, char up_flag
)
644 pr_err("k_lowercase was called - impossible\n");
647 static void k_unicode(struct vc_data
*vc
, unsigned int value
, char up_flag
)
650 return; /* no action, if this is a key release */
653 value
= handle_diacr(vc
, value
);
660 if (kbd
->kbdmode
== VC_UNICODE
)
663 int c
= conv_uni_to_8bit(value
);
670 * Handle dead key. Note that we now may have several
671 * dead keys modifying the same character. Very useful
674 static void k_deadunicode(struct vc_data
*vc
, unsigned int value
, char up_flag
)
678 diacr
= (diacr
? handle_diacr(vc
, value
) : value
);
681 static void k_self(struct vc_data
*vc
, unsigned char value
, char up_flag
)
683 k_unicode(vc
, conv_8bit_to_uni(value
), up_flag
);
686 static void k_dead2(struct vc_data
*vc
, unsigned char value
, char up_flag
)
688 k_deadunicode(vc
, value
, up_flag
);
692 * Obsolete - for backwards compatibility only
694 static void k_dead(struct vc_data
*vc
, unsigned char value
, char up_flag
)
696 static const unsigned char ret_diacr
[NR_DEAD
] = {'`', '\'', '^', '~', '"', ',' };
697 value
= ret_diacr
[value
];
698 k_deadunicode(vc
, value
, up_flag
);
701 static void k_cons(struct vc_data
*vc
, unsigned char value
, char up_flag
)
708 static void k_fn(struct vc_data
*vc
, unsigned char value
, char up_flag
)
715 if (v
< ARRAY_SIZE(func_table
)) {
716 if (func_table
[value
])
717 puts_queue(vc
, func_table
[value
]);
719 pr_err("k_fn called with value=%d\n", value
);
722 static void k_cur(struct vc_data
*vc
, unsigned char value
, char up_flag
)
724 static const char cur_chars
[] = "BDCA";
728 applkey(vc
, cur_chars
[value
], vc_kbd_mode(kbd
, VC_CKMODE
));
731 static void k_pad(struct vc_data
*vc
, unsigned char value
, char up_flag
)
733 static const char pad_chars
[] = "0123456789+-*/\015,.?()#";
734 static const char app_map
[] = "pqrstuvwxylSRQMnnmPQS";
737 return; /* no action, if this is a key release */
739 /* kludge... shift forces cursor/number keys */
740 if (vc_kbd_mode(kbd
, VC_APPLIC
) && !shift_down
[KG_SHIFT
]) {
741 applkey(vc
, app_map
[value
], 1);
745 if (!vc_kbd_led(kbd
, VC_NUMLOCK
))
749 k_fn(vc
, KVAL(K_REMOVE
), 0);
752 k_fn(vc
, KVAL(K_INSERT
), 0);
755 k_fn(vc
, KVAL(K_SELECT
), 0);
758 k_cur(vc
, KVAL(K_DOWN
), 0);
761 k_fn(vc
, KVAL(K_PGDN
), 0);
764 k_cur(vc
, KVAL(K_LEFT
), 0);
767 k_cur(vc
, KVAL(K_RIGHT
), 0);
770 k_fn(vc
, KVAL(K_FIND
), 0);
773 k_cur(vc
, KVAL(K_UP
), 0);
776 k_fn(vc
, KVAL(K_PGUP
), 0);
779 applkey(vc
, 'G', vc_kbd_mode(kbd
, VC_APPLIC
));
783 put_queue(vc
, pad_chars
[value
]);
784 if (value
== KVAL(K_PENTER
) && vc_kbd_mode(kbd
, VC_CRLF
))
788 static void k_shift(struct vc_data
*vc
, unsigned char value
, char up_flag
)
790 int old_state
= shift_state
;
796 * a CapsShift key acts like Shift but undoes CapsLock
798 if (value
== KVAL(K_CAPSSHIFT
)) {
799 value
= KVAL(K_SHIFT
);
801 clr_vc_kbd_led(kbd
, VC_CAPSLOCK
);
806 * handle the case that two shift or control
807 * keys are depressed simultaneously
809 if (shift_down
[value
])
814 if (shift_down
[value
])
815 shift_state
|= (1 << value
);
817 shift_state
&= ~(1 << value
);
820 if (up_flag
&& shift_state
!= old_state
&& npadch
!= -1) {
821 if (kbd
->kbdmode
== VC_UNICODE
)
824 put_queue(vc
, npadch
& 0xff);
829 static void k_meta(struct vc_data
*vc
, unsigned char value
, char up_flag
)
834 if (vc_kbd_mode(kbd
, VC_META
)) {
835 put_queue(vc
, '\033');
836 put_queue(vc
, value
);
838 put_queue(vc
, value
| 0x80);
841 static void k_ascii(struct vc_data
*vc
, unsigned char value
, char up_flag
)
849 /* decimal input of code, while Alt depressed */
852 /* hexadecimal input of code, while AltGr depressed */
860 npadch
= npadch
* base
+ value
;
863 static void k_lock(struct vc_data
*vc
, unsigned char value
, char up_flag
)
867 chg_vc_kbd_lock(kbd
, value
);
870 static void k_slock(struct vc_data
*vc
, unsigned char value
, char up_flag
)
872 k_shift(vc
, value
, up_flag
);
875 chg_vc_kbd_slock(kbd
, value
);
876 /* try to make Alt, oops, AltGr and such work */
877 if (!key_maps
[kbd
->lockstate
^ kbd
->slockstate
]) {
879 chg_vc_kbd_slock(kbd
, value
);
883 /* by default, 300ms interval for combination release */
884 static unsigned brl_timeout
= 300;
885 MODULE_PARM_DESC(brl_timeout
, "Braille keys release delay in ms (0 for commit on first key release)");
886 module_param(brl_timeout
, uint
, 0644);
888 static unsigned brl_nbchords
= 1;
889 MODULE_PARM_DESC(brl_nbchords
, "Number of chords that produce a braille pattern (0 for dead chords)");
890 module_param(brl_nbchords
, uint
, 0644);
892 static void k_brlcommit(struct vc_data
*vc
, unsigned int pattern
, char up_flag
)
894 static unsigned long chords
;
895 static unsigned committed
;
898 k_deadunicode(vc
, BRL_UC_ROW
| pattern
, up_flag
);
900 committed
|= pattern
;
902 if (chords
== brl_nbchords
) {
903 k_unicode(vc
, BRL_UC_ROW
| committed
, up_flag
);
910 static void k_brl(struct vc_data
*vc
, unsigned char value
, char up_flag
)
912 static unsigned pressed
,committing
;
913 static unsigned long releasestart
;
915 if (kbd
->kbdmode
!= VC_UNICODE
) {
917 pr_warning("keyboard mode must be unicode for braille patterns\n");
922 k_unicode(vc
, BRL_UC_ROW
, up_flag
);
933 releasestart
+ msecs_to_jiffies(brl_timeout
))) {
934 committing
= pressed
;
935 releasestart
= jiffies
;
937 pressed
&= ~(1 << (value
- 1));
940 k_brlcommit(vc
, committing
, 0);
946 k_brlcommit(vc
, committing
, 0);
949 pressed
&= ~(1 << (value
- 1));
952 pressed
|= 1 << (value
- 1);
954 committing
= pressed
;
959 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
960 * or (ii) whatever pattern of lights people want to show using KDSETLED,
961 * or (iii) specified bits of specified words in kernel memory.
963 unsigned char getledstate(void)
968 void setledstate(struct kbd_struct
*kbd
, unsigned int led
)
972 kbd
->ledmode
= LED_SHOW_IOCTL
;
974 kbd
->ledmode
= LED_SHOW_FLAGS
;
978 static inline unsigned char getleds(void)
980 struct kbd_struct
*kbd
= kbd_table
+ fg_console
;
984 if (kbd
->ledmode
== LED_SHOW_IOCTL
)
987 leds
= kbd
->ledflagstate
;
989 if (kbd
->ledmode
== LED_SHOW_MEM
) {
990 for (i
= 0; i
< 3; i
++)
991 if (ledptrs
[i
].valid
) {
992 if (*ledptrs
[i
].addr
& ledptrs
[i
].mask
)
1001 static int kbd_update_leds_helper(struct input_handle
*handle
, void *data
)
1003 unsigned char leds
= *(unsigned char *)data
;
1005 if (test_bit(EV_LED
, handle
->dev
->evbit
)) {
1006 input_inject_event(handle
, EV_LED
, LED_SCROLLL
, !!(leds
& 0x01));
1007 input_inject_event(handle
, EV_LED
, LED_NUML
, !!(leds
& 0x02));
1008 input_inject_event(handle
, EV_LED
, LED_CAPSL
, !!(leds
& 0x04));
1009 input_inject_event(handle
, EV_SYN
, SYN_REPORT
, 0);
1016 * This is the tasklet that updates LED state on all keyboards
1017 * attached to the box. The reason we use tasklet is that we
1018 * need to handle the scenario when keyboard handler is not
1019 * registered yet but we already getting updates form VT to
1022 static void kbd_bh(unsigned long dummy
)
1024 unsigned char leds
= getleds();
1026 if (leds
!= ledstate
) {
1027 input_handler_for_each_handle(&kbd_handler
, &leds
,
1028 kbd_update_leds_helper
);
1033 DECLARE_TASKLET_DISABLED(keyboard_tasklet
, kbd_bh
, 0);
1035 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
1036 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1037 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1038 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1039 defined(CONFIG_AVR32)
1041 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1042 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1044 static const unsigned short x86_keycodes
[256] =
1045 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1046 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1047 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1048 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1049 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1050 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1051 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
1052 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1053 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1054 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1055 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1056 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1057 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1058 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1059 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1062 static int sparc_l1_a_state
= 0;
1063 extern void sun_do_break(void);
1066 static int emulate_raw(struct vc_data
*vc
, unsigned int keycode
,
1067 unsigned char up_flag
)
1073 put_queue(vc
, 0xe1);
1074 put_queue(vc
, 0x1d | up_flag
);
1075 put_queue(vc
, 0x45 | up_flag
);
1080 put_queue(vc
, 0xf2);
1085 put_queue(vc
, 0xf1);
1090 * Real AT keyboards (that's what we're trying
1091 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1092 * pressing PrtSc/SysRq alone, but simply 0x54
1093 * when pressing Alt+PrtSc/SysRq.
1095 if (test_bit(KEY_LEFTALT
, key_down
) ||
1096 test_bit(KEY_RIGHTALT
, key_down
)) {
1097 put_queue(vc
, 0x54 | up_flag
);
1099 put_queue(vc
, 0xe0);
1100 put_queue(vc
, 0x2a | up_flag
);
1101 put_queue(vc
, 0xe0);
1102 put_queue(vc
, 0x37 | up_flag
);
1110 code
= x86_keycodes
[keycode
];
1115 put_queue(vc
, 0xe0);
1116 put_queue(vc
, (code
& 0x7f) | up_flag
);
1126 #define HW_RAW(dev) 0
1128 static int emulate_raw(struct vc_data
*vc
, unsigned int keycode
, unsigned char up_flag
)
1133 put_queue(vc
, keycode
| up_flag
);
1138 static void kbd_rawcode(unsigned char data
)
1140 struct vc_data
*vc
= vc_cons
[fg_console
].d
;
1141 kbd
= kbd_table
+ vc
->vc_num
;
1142 if (kbd
->kbdmode
== VC_RAW
)
1143 put_queue(vc
, data
);
1146 static void kbd_keycode(unsigned int keycode
, int down
, int hw_raw
)
1148 struct vc_data
*vc
= vc_cons
[fg_console
].d
;
1149 unsigned short keysym
, *key_map
;
1150 unsigned char type
, raw_mode
;
1151 struct tty_struct
*tty
;
1153 struct keyboard_notifier_param param
= { .vc
= vc
, .value
= keycode
, .down
= down
};
1157 if (tty
&& (!tty
->driver_data
)) {
1158 /* No driver data? Strange. Okay we fix it then. */
1159 tty
->driver_data
= vc
;
1162 kbd
= kbd_table
+ vc
->vc_num
;
1165 if (keycode
== KEY_STOP
)
1166 sparc_l1_a_state
= down
;
1171 if ((raw_mode
= (kbd
->kbdmode
== VC_RAW
)) && !hw_raw
)
1172 if (emulate_raw(vc
, keycode
, !down
<< 7))
1173 if (keycode
< BTN_MISC
&& printk_ratelimit())
1174 pr_warning("can't emulate rawmode for keycode %d\n",
1178 if (keycode
== KEY_A
&& sparc_l1_a_state
) {
1179 sparc_l1_a_state
= 0;
1184 if (kbd
->kbdmode
== VC_MEDIUMRAW
) {
1186 * This is extended medium raw mode, with keys above 127
1187 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1188 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1189 * interfere with anything else. The two bytes after 0 will
1190 * always have the up flag set not to interfere with older
1191 * applications. This allows for 16384 different keycodes,
1192 * which should be enough.
1194 if (keycode
< 128) {
1195 put_queue(vc
, keycode
| (!down
<< 7));
1197 put_queue(vc
, !down
<< 7);
1198 put_queue(vc
, (keycode
>> 7) | 0x80);
1199 put_queue(vc
, keycode
| 0x80);
1205 set_bit(keycode
, key_down
);
1207 clear_bit(keycode
, key_down
);
1210 (!vc_kbd_mode(kbd
, VC_REPEAT
) ||
1211 (tty
&& !L_ECHO(tty
) && tty_chars_in_buffer(tty
)))) {
1213 * Don't repeat a key if the input buffers are not empty and the
1214 * characters get aren't echoed locally. This makes key repeat
1215 * usable with slow applications and under heavy loads.
1220 param
.shift
= shift_final
= (shift_state
| kbd
->slockstate
) ^ kbd
->lockstate
;
1221 param
.ledstate
= kbd
->ledflagstate
;
1222 key_map
= key_maps
[shift_final
];
1224 if (atomic_notifier_call_chain(&keyboard_notifier_list
, KBD_KEYCODE
, ¶m
) == NOTIFY_STOP
|| !key_map
) {
1225 atomic_notifier_call_chain(&keyboard_notifier_list
, KBD_UNBOUND_KEYCODE
, ¶m
);
1226 compute_shiftstate();
1227 kbd
->slockstate
= 0;
1231 if (keycode
>= NR_KEYS
)
1232 if (keycode
>= KEY_BRL_DOT1
&& keycode
<= KEY_BRL_DOT8
)
1233 keysym
= U(K(KT_BRL
, keycode
- KEY_BRL_DOT1
+ 1));
1237 keysym
= key_map
[keycode
];
1239 type
= KTYP(keysym
);
1242 param
.value
= keysym
;
1243 if (atomic_notifier_call_chain(&keyboard_notifier_list
, KBD_UNICODE
, ¶m
) == NOTIFY_STOP
)
1245 if (down
&& !raw_mode
)
1246 to_utf8(vc
, keysym
);
1252 if (type
== KT_LETTER
) {
1254 if (vc_kbd_led(kbd
, VC_CAPSLOCK
)) {
1255 key_map
= key_maps
[shift_final
^ (1 << KG_SHIFT
)];
1257 keysym
= key_map
[keycode
];
1260 param
.value
= keysym
;
1262 if (atomic_notifier_call_chain(&keyboard_notifier_list
, KBD_KEYSYM
, ¶m
) == NOTIFY_STOP
)
1265 if (raw_mode
&& type
!= KT_SPEC
&& type
!= KT_SHIFT
)
1268 (*k_handler
[type
])(vc
, keysym
& 0xff, !down
);
1270 param
.ledstate
= kbd
->ledflagstate
;
1271 atomic_notifier_call_chain(&keyboard_notifier_list
, KBD_POST_KEYSYM
, ¶m
);
1273 if (type
!= KT_SLOCK
)
1274 kbd
->slockstate
= 0;
1277 static void kbd_event(struct input_handle
*handle
, unsigned int event_type
,
1278 unsigned int event_code
, int value
)
1280 /* We are called with interrupts disabled, just take the lock */
1281 spin_lock(&kbd_event_lock
);
1283 if (event_type
== EV_MSC
&& event_code
== MSC_RAW
&& HW_RAW(handle
->dev
))
1285 if (event_type
== EV_KEY
)
1286 kbd_keycode(event_code
, value
, HW_RAW(handle
->dev
));
1288 spin_unlock(&kbd_event_lock
);
1290 tasklet_schedule(&keyboard_tasklet
);
1291 do_poke_blanked_console
= 1;
1292 schedule_console_callback();
1295 static bool kbd_match(struct input_handler
*handler
, struct input_dev
*dev
)
1299 if (test_bit(EV_SND
, dev
->evbit
))
1302 if (test_bit(EV_KEY
, dev
->evbit
))
1303 for (i
= KEY_RESERVED
; i
< BTN_MISC
; i
++)
1304 if (test_bit(i
, dev
->keybit
))
1311 * When a keyboard (or other input device) is found, the kbd_connect
1312 * function is called. The function then looks at the device, and if it
1313 * likes it, it can open it and get events from it. In this (kbd_connect)
1314 * function, we should decide which VT to bind that keyboard to initially.
1316 static int kbd_connect(struct input_handler
*handler
, struct input_dev
*dev
,
1317 const struct input_device_id
*id
)
1319 struct input_handle
*handle
;
1322 handle
= kzalloc(sizeof(struct input_handle
), GFP_KERNEL
);
1327 handle
->handler
= handler
;
1328 handle
->name
= "kbd";
1330 error
= input_register_handle(handle
);
1332 goto err_free_handle
;
1334 error
= input_open_device(handle
);
1336 goto err_unregister_handle
;
1340 err_unregister_handle
:
1341 input_unregister_handle(handle
);
1347 static void kbd_disconnect(struct input_handle
*handle
)
1349 input_close_device(handle
);
1350 input_unregister_handle(handle
);
1355 * Start keyboard handler on the new keyboard by refreshing LED state to
1356 * match the rest of the system.
1358 static void kbd_start(struct input_handle
*handle
)
1360 tasklet_disable(&keyboard_tasklet
);
1362 if (ledstate
!= 0xff)
1363 kbd_update_leds_helper(handle
, &ledstate
);
1365 tasklet_enable(&keyboard_tasklet
);
1368 static const struct input_device_id kbd_ids
[] = {
1370 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
,
1371 .evbit
= { BIT_MASK(EV_KEY
) },
1375 .flags
= INPUT_DEVICE_ID_MATCH_EVBIT
,
1376 .evbit
= { BIT_MASK(EV_SND
) },
1379 { }, /* Terminating entry */
1382 MODULE_DEVICE_TABLE(input
, kbd_ids
);
1384 static struct input_handler kbd_handler
= {
1387 .connect
= kbd_connect
,
1388 .disconnect
= kbd_disconnect
,
1391 .id_table
= kbd_ids
,
1394 int __init
kbd_init(void)
1399 for (i
= 0; i
< MAX_NR_CONSOLES
; i
++) {
1400 kbd_table
[i
].ledflagstate
= KBD_DEFLEDS
;
1401 kbd_table
[i
].default_ledflagstate
= KBD_DEFLEDS
;
1402 kbd_table
[i
].ledmode
= LED_SHOW_FLAGS
;
1403 kbd_table
[i
].lockstate
= KBD_DEFLOCK
;
1404 kbd_table
[i
].slockstate
= 0;
1405 kbd_table
[i
].modeflags
= KBD_DEFMODE
;
1406 kbd_table
[i
].kbdmode
= default_utf8
? VC_UNICODE
: VC_XLATE
;
1409 error
= input_register_handler(&kbd_handler
);
1413 tasklet_enable(&keyboard_tasklet
);
1414 tasklet_schedule(&keyboard_tasklet
);