blob: de26a978fbdd140aec88179b99c14fae555c467c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/char/keyboard.c
3 *
4 * Written for linux by Johan Myreen as a translation from
5 * the assembly version by Linus (with diacriticals added)
6 *
7 * Some additional features added by Christoph Niemann (ChN), March 1993
8 *
9 * Loadable keymaps by Risto Kankkunen, May 1993
10 *
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.
15 *
16 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050017 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 * 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
21 *
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)
25 */
26
Jan Engelhardt759448f2007-07-15 23:40:40 -070027#include <linux/consolemap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/module.h>
29#include <linux/sched.h>
30#include <linux/tty.h>
31#include <linux/tty_flip.h>
32#include <linux/mm.h>
33#include <linux/string.h>
34#include <linux/init.h>
35#include <linux/slab.h>
David Howells7d12e782006-10-05 14:55:46 +010036#include <linux/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
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>
Adrian Bunk83cc5ed2006-06-25 05:47:41 -070043#include <linux/reboot.h>
Samuel Thibault41ab4392007-10-18 23:39:12 -070044#include <linux/notifier.h>
Julia Lawallb39b0442008-04-17 09:28:25 -040045#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
Linus Torvalds1da177e2005-04-16 15:20:36 -070047extern void ctrl_alt_del(void);
48
Joe Perches253b00f2008-05-07 11:15:23 -040049#define to_handle_h(n) container_of(n, struct input_handle, h_node)
50
Linus Torvalds1da177e2005-04-16 15:20:36 -070051/*
52 * Exported functions/variables
53 */
54
55#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
56
57/*
58 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
59 * This seems a good reason to start with NumLock off. On HIL keyboards
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050060 * of PARISC machines however there is no NumLock key and everyone expects the keypad
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 * to be used for numbers.
62 */
63
64#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
65#define KBD_DEFLEDS (1 << VC_NUMLOCK)
66#else
67#define KBD_DEFLEDS 0
68#endif
69
70#define KBD_DEFLOCK 0
71
72void compute_shiftstate(void);
73
74/*
75 * Handler Tables.
76 */
77
78#define K_HANDLERS\
79 k_self, k_fn, k_spec, k_pad,\
80 k_dead, k_cons, k_cur, k_shift,\
81 k_meta, k_ascii, k_lock, k_lowercase,\
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -050082 k_slock, k_dead2, k_brl, k_ignore
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050084typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
David Howells7d12e782006-10-05 14:55:46 +010085 char up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086static k_handler_fn K_HANDLERS;
Samuel Thibault41ab4392007-10-18 23:39:12 -070087k_handler_fn *k_handler[16] = { K_HANDLERS };
88EXPORT_SYMBOL_GPL(k_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
90#define FN_HANDLERS\
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050091 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
92 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
93 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
94 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
95 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
David Howells7d12e782006-10-05 14:55:46 +010097typedef void (fn_handler_fn)(struct vc_data *vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098static fn_handler_fn FN_HANDLERS;
99static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
100
101/*
102 * Variables exported for vt_ioctl.c
103 */
104
105/* maximum values each key_handler can handle */
106const int max_vals[] = {
107 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
108 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500109 255, NR_LOCK - 1, 255, NR_BRL - 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110};
111
112const int NR_TYPES = ARRAY_SIZE(max_vals);
113
114struct kbd_struct kbd_table[MAX_NR_CONSOLES];
Samuel Thibaultf7511d52008-04-30 00:54:51 -0700115EXPORT_SYMBOL_GPL(kbd_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116static struct kbd_struct *kbd = kbd_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
Eric W. Biederman81af8d62006-10-02 02:17:13 -0700118struct vt_spawn_console vt_spawn_con = {
Milind Arun Choudharyccc94252007-05-08 00:30:09 -0700119 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
Eric W. Biederman81af8d62006-10-02 02:17:13 -0700120 .pid = NULL,
121 .sig = 0,
122};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124/*
125 * Variables exported for vt.c
126 */
127
128int shift_state = 0;
129
130/*
131 * Internal Data.
132 */
133
134static struct input_handler kbd_handler;
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700135static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
137static int dead_key_next;
138static int npadch = -1; /* -1 or number assembled on pad */
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500139static unsigned int diacr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140static char rep; /* flag telling character repeat */
141
142static unsigned char ledstate = 0xff; /* undefined */
143static unsigned char ledioctl;
144
145static struct ledptr {
146 unsigned int *addr;
147 unsigned int mask;
148 unsigned char valid:1;
149} ledptrs[3];
150
151/* Simple translation table for the SysRq keys */
152
153#ifdef CONFIG_MAGIC_SYSRQ
154unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
155 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
156 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
157 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
158 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
159 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
160 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
161 "\r\000/"; /* 0x60 - 0x6f */
162static int sysrq_down;
Fredrik Roubertd2be8ee2006-06-26 00:24:35 -0700163static int sysrq_alt_use;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164#endif
165static int sysrq_alt;
166
167/*
Samuel Thibault41ab4392007-10-18 23:39:12 -0700168 * Notifier list for console keyboard events
169 */
170static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
171
172int register_keyboard_notifier(struct notifier_block *nb)
173{
174 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
175}
176EXPORT_SYMBOL_GPL(register_keyboard_notifier);
177
178int unregister_keyboard_notifier(struct notifier_block *nb)
179{
180 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
181}
182EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
183
184/*
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400185 * Translation of scancodes to keycodes. We set them on only the first
186 * keyboard in the list that accepts the scancode and keycode.
187 * Explanation for not choosing the first attached keyboard anymore:
188 * USB keyboards for example have two event devices: one for all "normal"
189 * keys and one for extra function keys (like "volume up", "make coffee",
190 * etc.). So this means that scancodes for the extra function keys won't
191 * be valid for the first event device, but will be for the second.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 */
193int getkeycode(unsigned int scancode)
194{
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400195 struct input_handle *handle;
196 int keycode;
197 int error = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400199 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400200 error = input_get_keycode(handle->dev, scancode, &keycode);
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400201 if (!error)
202 return keycode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 }
204
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400205 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
208int setkeycode(unsigned int scancode, unsigned int keycode)
209{
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400210 struct input_handle *handle;
211 int error = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400213 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400214 error = input_set_keycode(handle->dev, scancode, keycode);
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400215 if (!error)
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500216 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 }
218
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400219 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220}
221
222/*
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500223 * Making beeps and bells.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 */
225static void kd_nosound(unsigned long ignored)
226{
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400227 struct input_handle *handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400229 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 if (test_bit(EV_SND, handle->dev->evbit)) {
231 if (test_bit(SND_TONE, handle->dev->sndbit))
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400232 input_inject_event(handle, EV_SND, SND_TONE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 if (test_bit(SND_BELL, handle->dev->sndbit))
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400234 input_inject_event(handle, EV_SND, SND_BELL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 }
236 }
237}
238
Ingo Molnar8d06afa2005-09-09 13:10:40 -0700239static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241void kd_mksound(unsigned int hz, unsigned int ticks)
242{
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500243 struct list_head *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
245 del_timer(&kd_mksound_timer);
246
247 if (hz) {
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500248 list_for_each_prev(node, &kbd_handler.h_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 struct input_handle *handle = to_handle_h(node);
250 if (test_bit(EV_SND, handle->dev->evbit)) {
251 if (test_bit(SND_TONE, handle->dev->sndbit)) {
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400252 input_inject_event(handle, EV_SND, SND_TONE, hz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 break;
254 }
255 if (test_bit(SND_BELL, handle->dev->sndbit)) {
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400256 input_inject_event(handle, EV_SND, SND_BELL, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 break;
258 }
259 }
260 }
261 if (ticks)
262 mod_timer(&kd_mksound_timer, jiffies + ticks);
263 } else
264 kd_nosound(0);
265}
Samuel Thibaultf7511d52008-04-30 00:54:51 -0700266EXPORT_SYMBOL(kd_mksound);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268/*
269 * Setting the keyboard rate.
270 */
271
272int kbd_rate(struct kbd_repeat *rep)
273{
274 struct list_head *node;
275 unsigned int d = 0;
276 unsigned int p = 0;
277
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400278 list_for_each(node, &kbd_handler.h_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 struct input_handle *handle = to_handle_h(node);
280 struct input_dev *dev = handle->dev;
281
282 if (test_bit(EV_REP, dev->evbit)) {
283 if (rep->delay > 0)
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400284 input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 if (rep->period > 0)
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400286 input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 d = dev->rep[REP_DELAY];
288 p = dev->rep[REP_PERIOD];
289 }
290 }
291 rep->delay = d;
292 rep->period = p;
293 return 0;
294}
295
296/*
297 * Helper Functions.
298 */
299static void put_queue(struct vc_data *vc, int ch)
300{
301 struct tty_struct *tty = vc->vc_tty;
302
303 if (tty) {
304 tty_insert_flip_char(tty, ch, 0);
305 con_schedule_flip(tty);
306 }
307}
308
309static void puts_queue(struct vc_data *vc, char *cp)
310{
311 struct tty_struct *tty = vc->vc_tty;
312
313 if (!tty)
314 return;
315
316 while (*cp) {
317 tty_insert_flip_char(tty, *cp, 0);
318 cp++;
319 }
320 con_schedule_flip(tty);
321}
322
323static void applkey(struct vc_data *vc, int key, char mode)
324{
325 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
326
327 buf[1] = (mode ? 'O' : '[');
328 buf[2] = key;
329 puts_queue(vc, buf);
330}
331
332/*
333 * Many other routines do put_queue, but I think either
334 * they produce ASCII, or they produce some user-assigned
335 * string, and in both cases we might assume that it is
Jan Engelhardt759448f2007-07-15 23:40:40 -0700336 * in utf-8 already.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 */
Jan Engelhardt759448f2007-07-15 23:40:40 -0700338static void to_utf8(struct vc_data *vc, uint c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
340 if (c < 0x80)
341 /* 0******* */
342 put_queue(vc, c);
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500343 else if (c < 0x800) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 /* 110***** 10****** */
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500345 put_queue(vc, 0xc0 | (c >> 6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 put_queue(vc, 0x80 | (c & 0x3f));
Jan Engelhardt759448f2007-07-15 23:40:40 -0700347 } else if (c < 0x10000) {
348 if (c >= 0xD800 && c < 0xE000)
349 return;
350 if (c == 0xFFFF)
351 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 /* 1110**** 10****** 10****** */
353 put_queue(vc, 0xe0 | (c >> 12));
354 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
355 put_queue(vc, 0x80 | (c & 0x3f));
Jan Engelhardt759448f2007-07-15 23:40:40 -0700356 } else if (c < 0x110000) {
357 /* 11110*** 10****** 10****** 10****** */
358 put_queue(vc, 0xf0 | (c >> 18));
359 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
360 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
361 put_queue(vc, 0x80 | (c & 0x3f));
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500362 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363}
364
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500365/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 * Called after returning from RAW mode or when changing consoles - recompute
367 * shift_down[] and shift_state from key_down[] maybe called when keymap is
368 * undefined, so that shiftkey release is seen
369 */
370void compute_shiftstate(void)
371{
372 unsigned int i, j, k, sym, val;
373
374 shift_state = 0;
375 memset(shift_down, 0, sizeof(shift_down));
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500376
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
378
379 if (!key_down[i])
380 continue;
381
382 k = i * BITS_PER_LONG;
383
384 for (j = 0; j < BITS_PER_LONG; j++, k++) {
385
386 if (!test_bit(k, key_down))
387 continue;
388
389 sym = U(key_maps[0][k]);
390 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
391 continue;
392
393 val = KVAL(sym);
394 if (val == KVAL(K_CAPSSHIFT))
395 val = KVAL(K_SHIFT);
396
397 shift_down[val]++;
398 shift_state |= (1 << val);
399 }
400 }
401}
402
403/*
404 * We have a combining character DIACR here, followed by the character CH.
405 * If the combination occurs in the table, return the corresponding value.
406 * Otherwise, if CH is a space or equals DIACR, return DIACR.
407 * Otherwise, conclude that DIACR was not combining after all,
408 * queue it and return CH.
409 */
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500410static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411{
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500412 unsigned int d = diacr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 unsigned int i;
414
415 diacr = 0;
416
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500417 if ((d & ~0xff) == BRL_UC_ROW) {
418 if ((ch & ~0xff) == BRL_UC_ROW)
419 return d | ch;
420 } else {
421 for (i = 0; i < accent_table_size; i++)
422 if (accent_table[i].diacr == d && accent_table[i].base == ch)
423 return accent_table[i].result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 }
425
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500426 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 return d;
428
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500429 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700430 to_utf8(vc, d);
431 else {
432 int c = conv_uni_to_8bit(d);
433 if (c != -1)
434 put_queue(vc, c);
435 }
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500436
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 return ch;
438}
439
440/*
441 * Special function handlers
442 */
David Howells7d12e782006-10-05 14:55:46 +0100443static void fn_enter(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444{
445 if (diacr) {
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500446 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700447 to_utf8(vc, diacr);
448 else {
449 int c = conv_uni_to_8bit(diacr);
450 if (c != -1)
451 put_queue(vc, c);
452 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 diacr = 0;
454 }
455 put_queue(vc, 13);
456 if (vc_kbd_mode(kbd, VC_CRLF))
457 put_queue(vc, 10);
458}
459
David Howells7d12e782006-10-05 14:55:46 +0100460static void fn_caps_toggle(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461{
462 if (rep)
463 return;
464 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
465}
466
David Howells7d12e782006-10-05 14:55:46 +0100467static void fn_caps_on(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468{
469 if (rep)
470 return;
471 set_vc_kbd_led(kbd, VC_CAPSLOCK);
472}
473
David Howells7d12e782006-10-05 14:55:46 +0100474static void fn_show_ptregs(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475{
David Howells7d12e782006-10-05 14:55:46 +0100476 struct pt_regs *regs = get_irq_regs();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 if (regs)
478 show_regs(regs);
479}
480
David Howells7d12e782006-10-05 14:55:46 +0100481static void fn_hold(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482{
483 struct tty_struct *tty = vc->vc_tty;
484
485 if (rep || !tty)
486 return;
487
488 /*
489 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
490 * these routines are also activated by ^S/^Q.
491 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
492 */
493 if (tty->stopped)
494 start_tty(tty);
495 else
496 stop_tty(tty);
497}
498
David Howells7d12e782006-10-05 14:55:46 +0100499static void fn_num(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500{
501 if (vc_kbd_mode(kbd,VC_APPLIC))
502 applkey(vc, 'P', 1);
503 else
David Howells7d12e782006-10-05 14:55:46 +0100504 fn_bare_num(vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505}
506
507/*
508 * Bind this to Shift-NumLock if you work in application keypad mode
509 * but want to be able to change the NumLock flag.
510 * Bind this to NumLock if you prefer that the NumLock key always
511 * changes the NumLock flag.
512 */
David Howells7d12e782006-10-05 14:55:46 +0100513static void fn_bare_num(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514{
515 if (!rep)
516 chg_vc_kbd_led(kbd, VC_NUMLOCK);
517}
518
David Howells7d12e782006-10-05 14:55:46 +0100519static void fn_lastcons(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520{
521 /* switch to the last used console, ChN */
522 set_console(last_console);
523}
524
David Howells7d12e782006-10-05 14:55:46 +0100525static void fn_dec_console(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526{
527 int i, cur = fg_console;
528
529 /* Currently switching? Queue this next switch relative to that. */
530 if (want_console != -1)
531 cur = want_console;
532
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500533 for (i = cur - 1; i != cur; i--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 if (i == -1)
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500535 i = MAX_NR_CONSOLES - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 if (vc_cons_allocated(i))
537 break;
538 }
539 set_console(i);
540}
541
David Howells7d12e782006-10-05 14:55:46 +0100542static void fn_inc_console(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543{
544 int i, cur = fg_console;
545
546 /* Currently switching? Queue this next switch relative to that. */
547 if (want_console != -1)
548 cur = want_console;
549
550 for (i = cur+1; i != cur; i++) {
551 if (i == MAX_NR_CONSOLES)
552 i = 0;
553 if (vc_cons_allocated(i))
554 break;
555 }
556 set_console(i);
557}
558
David Howells7d12e782006-10-05 14:55:46 +0100559static void fn_send_intr(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
561 struct tty_struct *tty = vc->vc_tty;
562
563 if (!tty)
564 return;
565 tty_insert_flip_char(tty, 0, TTY_BREAK);
566 con_schedule_flip(tty);
567}
568
David Howells7d12e782006-10-05 14:55:46 +0100569static void fn_scroll_forw(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570{
571 scrollfront(vc, 0);
572}
573
David Howells7d12e782006-10-05 14:55:46 +0100574static void fn_scroll_back(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575{
576 scrollback(vc, 0);
577}
578
David Howells7d12e782006-10-05 14:55:46 +0100579static void fn_show_mem(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580{
581 show_mem();
582}
583
David Howells7d12e782006-10-05 14:55:46 +0100584static void fn_show_state(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
586 show_state();
587}
588
David Howells7d12e782006-10-05 14:55:46 +0100589static void fn_boot_it(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590{
591 ctrl_alt_del();
592}
593
David Howells7d12e782006-10-05 14:55:46 +0100594static void fn_compose(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
596 dead_key_next = 1;
597}
598
David Howells7d12e782006-10-05 14:55:46 +0100599static void fn_spawn_con(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600{
Eric W. Biederman81af8d62006-10-02 02:17:13 -0700601 spin_lock(&vt_spawn_con.lock);
602 if (vt_spawn_con.pid)
603 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
604 put_pid(vt_spawn_con.pid);
605 vt_spawn_con.pid = NULL;
606 }
607 spin_unlock(&vt_spawn_con.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608}
609
David Howells7d12e782006-10-05 14:55:46 +0100610static void fn_SAK(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611{
Eric W. Biederman8b6312f2007-02-10 01:44:34 -0800612 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
Eric W. Biederman8b6312f2007-02-10 01:44:34 -0800613 schedule_work(SAK_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614}
615
David Howells7d12e782006-10-05 14:55:46 +0100616static void fn_null(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617{
618 compute_shiftstate();
619}
620
621/*
622 * Special key handlers
623 */
David Howells7d12e782006-10-05 14:55:46 +0100624static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625{
626}
627
David Howells7d12e782006-10-05 14:55:46 +0100628static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
630 if (up_flag)
631 return;
632 if (value >= ARRAY_SIZE(fn_handler))
633 return;
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500634 if ((kbd->kbdmode == VC_RAW ||
635 kbd->kbdmode == VC_MEDIUMRAW) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 value != KVAL(K_SAK))
637 return; /* SAK is allowed even in raw mode */
David Howells7d12e782006-10-05 14:55:46 +0100638 fn_handler[value](vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639}
640
David Howells7d12e782006-10-05 14:55:46 +0100641static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642{
643 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
644}
645
David Howells7d12e782006-10-05 14:55:46 +0100646static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647{
648 if (up_flag)
649 return; /* no action, if this is a key release */
650
651 if (diacr)
652 value = handle_diacr(vc, value);
653
654 if (dead_key_next) {
655 dead_key_next = 0;
656 diacr = value;
657 return;
658 }
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500659 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700660 to_utf8(vc, value);
661 else {
662 int c = conv_uni_to_8bit(value);
663 if (c != -1)
664 put_queue(vc, c);
665 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666}
667
668/*
669 * Handle dead key. Note that we now may have several
670 * dead keys modifying the same character. Very useful
671 * for Vietnamese.
672 */
David Howells7d12e782006-10-05 14:55:46 +0100673static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674{
675 if (up_flag)
676 return;
677 diacr = (diacr ? handle_diacr(vc, value) : value);
678}
679
David Howells7d12e782006-10-05 14:55:46 +0100680static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500681{
Jiri Bohacd2187eb2008-06-12 15:21:51 -0700682 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500683}
684
David Howells7d12e782006-10-05 14:55:46 +0100685static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500686{
David Howells7d12e782006-10-05 14:55:46 +0100687 k_deadunicode(vc, value, up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500688}
689
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690/*
691 * Obsolete - for backwards compatibility only
692 */
David Howells7d12e782006-10-05 14:55:46 +0100693static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694{
Andreas Mohr0f5e5602006-06-05 00:18:00 -0400695 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 value = ret_diacr[value];
David Howells7d12e782006-10-05 14:55:46 +0100697 k_deadunicode(vc, value, up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698}
699
David Howells7d12e782006-10-05 14:55:46 +0100700static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701{
702 if (up_flag)
703 return;
704 set_console(value);
705}
706
David Howells7d12e782006-10-05 14:55:46 +0100707static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708{
709 unsigned v;
710
711 if (up_flag)
712 return;
713 v = value;
714 if (v < ARRAY_SIZE(func_table)) {
715 if (func_table[value])
716 puts_queue(vc, func_table[value]);
717 } else
718 printk(KERN_ERR "k_fn called with value=%d\n", value);
719}
720
David Howells7d12e782006-10-05 14:55:46 +0100721static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722{
Brandon Philipse52b29c2006-11-04 22:09:08 -0500723 static const char cur_chars[] = "BDCA";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
725 if (up_flag)
726 return;
727 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
728}
729
David Howells7d12e782006-10-05 14:55:46 +0100730static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731{
Andreas Mohr0f5e5602006-06-05 00:18:00 -0400732 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
733 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
735 if (up_flag)
736 return; /* no action, if this is a key release */
737
738 /* kludge... shift forces cursor/number keys */
739 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
740 applkey(vc, app_map[value], 1);
741 return;
742 }
743
744 if (!vc_kbd_led(kbd, VC_NUMLOCK))
745 switch (value) {
746 case KVAL(K_PCOMMA):
747 case KVAL(K_PDOT):
David Howells7d12e782006-10-05 14:55:46 +0100748 k_fn(vc, KVAL(K_REMOVE), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 return;
750 case KVAL(K_P0):
David Howells7d12e782006-10-05 14:55:46 +0100751 k_fn(vc, KVAL(K_INSERT), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 return;
753 case KVAL(K_P1):
David Howells7d12e782006-10-05 14:55:46 +0100754 k_fn(vc, KVAL(K_SELECT), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 return;
756 case KVAL(K_P2):
David Howells7d12e782006-10-05 14:55:46 +0100757 k_cur(vc, KVAL(K_DOWN), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 return;
759 case KVAL(K_P3):
David Howells7d12e782006-10-05 14:55:46 +0100760 k_fn(vc, KVAL(K_PGDN), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 return;
762 case KVAL(K_P4):
David Howells7d12e782006-10-05 14:55:46 +0100763 k_cur(vc, KVAL(K_LEFT), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 return;
765 case KVAL(K_P6):
David Howells7d12e782006-10-05 14:55:46 +0100766 k_cur(vc, KVAL(K_RIGHT), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 return;
768 case KVAL(K_P7):
David Howells7d12e782006-10-05 14:55:46 +0100769 k_fn(vc, KVAL(K_FIND), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 return;
771 case KVAL(K_P8):
David Howells7d12e782006-10-05 14:55:46 +0100772 k_cur(vc, KVAL(K_UP), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 return;
774 case KVAL(K_P9):
David Howells7d12e782006-10-05 14:55:46 +0100775 k_fn(vc, KVAL(K_PGUP), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 return;
777 case KVAL(K_P5):
778 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
779 return;
780 }
781
782 put_queue(vc, pad_chars[value]);
783 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
784 put_queue(vc, 10);
785}
786
David Howells7d12e782006-10-05 14:55:46 +0100787static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788{
789 int old_state = shift_state;
790
791 if (rep)
792 return;
793 /*
794 * Mimic typewriter:
795 * a CapsShift key acts like Shift but undoes CapsLock
796 */
797 if (value == KVAL(K_CAPSSHIFT)) {
798 value = KVAL(K_SHIFT);
799 if (!up_flag)
800 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
801 }
802
803 if (up_flag) {
804 /*
805 * handle the case that two shift or control
806 * keys are depressed simultaneously
807 */
808 if (shift_down[value])
809 shift_down[value]--;
810 } else
811 shift_down[value]++;
812
813 if (shift_down[value])
814 shift_state |= (1 << value);
815 else
816 shift_state &= ~(1 << value);
817
818 /* kludge */
819 if (up_flag && shift_state != old_state && npadch != -1) {
820 if (kbd->kbdmode == VC_UNICODE)
Jan Engelhardt759448f2007-07-15 23:40:40 -0700821 to_utf8(vc, npadch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 else
823 put_queue(vc, npadch & 0xff);
824 npadch = -1;
825 }
826}
827
David Howells7d12e782006-10-05 14:55:46 +0100828static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829{
830 if (up_flag)
831 return;
832
833 if (vc_kbd_mode(kbd, VC_META)) {
834 put_queue(vc, '\033');
835 put_queue(vc, value);
836 } else
837 put_queue(vc, value | 0x80);
838}
839
David Howells7d12e782006-10-05 14:55:46 +0100840static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841{
842 int base;
843
844 if (up_flag)
845 return;
846
847 if (value < 10) {
848 /* decimal input of code, while Alt depressed */
849 base = 10;
850 } else {
851 /* hexadecimal input of code, while AltGr depressed */
852 value -= 10;
853 base = 16;
854 }
855
856 if (npadch == -1)
857 npadch = value;
858 else
859 npadch = npadch * base + value;
860}
861
David Howells7d12e782006-10-05 14:55:46 +0100862static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863{
864 if (up_flag || rep)
865 return;
866 chg_vc_kbd_lock(kbd, value);
867}
868
David Howells7d12e782006-10-05 14:55:46 +0100869static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870{
David Howells7d12e782006-10-05 14:55:46 +0100871 k_shift(vc, value, up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 if (up_flag || rep)
873 return;
874 chg_vc_kbd_slock(kbd, value);
875 /* try to make Alt, oops, AltGr and such work */
876 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
877 kbd->slockstate = 0;
878 chg_vc_kbd_slock(kbd, value);
879 }
880}
881
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500882/* by default, 300ms interval for combination release */
Samuel Thibault77426d72006-04-26 00:14:10 -0400883static unsigned brl_timeout = 300;
884MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
885module_param(brl_timeout, uint, 0644);
886
887static unsigned brl_nbchords = 1;
888MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
889module_param(brl_nbchords, uint, 0644);
890
David Howells7d12e782006-10-05 14:55:46 +0100891static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
Samuel Thibault77426d72006-04-26 00:14:10 -0400892{
893 static unsigned long chords;
894 static unsigned committed;
895
896 if (!brl_nbchords)
David Howells7d12e782006-10-05 14:55:46 +0100897 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
Samuel Thibault77426d72006-04-26 00:14:10 -0400898 else {
899 committed |= pattern;
900 chords++;
901 if (chords == brl_nbchords) {
David Howells7d12e782006-10-05 14:55:46 +0100902 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
Samuel Thibault77426d72006-04-26 00:14:10 -0400903 chords = 0;
904 committed = 0;
905 }
906 }
907}
908
David Howells7d12e782006-10-05 14:55:46 +0100909static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500910{
911 static unsigned pressed,committing;
912 static unsigned long releasestart;
913
914 if (kbd->kbdmode != VC_UNICODE) {
915 if (!up_flag)
916 printk("keyboard mode must be unicode for braille patterns\n");
917 return;
918 }
919
920 if (!value) {
David Howells7d12e782006-10-05 14:55:46 +0100921 k_unicode(vc, BRL_UC_ROW, up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500922 return;
923 }
924
925 if (value > 8)
926 return;
927
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500928 if (up_flag) {
929 if (brl_timeout) {
930 if (!committing ||
Julia Lawallb39b0442008-04-17 09:28:25 -0400931 time_after(jiffies,
932 releasestart + msecs_to_jiffies(brl_timeout))) {
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500933 committing = pressed;
934 releasestart = jiffies;
935 }
936 pressed &= ~(1 << (value - 1));
937 if (!pressed) {
938 if (committing) {
David Howells7d12e782006-10-05 14:55:46 +0100939 k_brlcommit(vc, committing, 0);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500940 committing = 0;
941 }
942 }
943 } else {
944 if (committing) {
David Howells7d12e782006-10-05 14:55:46 +0100945 k_brlcommit(vc, committing, 0);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500946 committing = 0;
947 }
948 pressed &= ~(1 << (value - 1));
949 }
950 } else {
951 pressed |= 1 << (value - 1);
952 if (!brl_timeout)
953 committing = pressed;
954 }
955}
956
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957/*
958 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
959 * or (ii) whatever pattern of lights people want to show using KDSETLED,
960 * or (iii) specified bits of specified words in kernel memory.
961 */
962unsigned char getledstate(void)
963{
964 return ledstate;
965}
966
967void setledstate(struct kbd_struct *kbd, unsigned int led)
968{
969 if (!(led & ~7)) {
970 ledioctl = led;
971 kbd->ledmode = LED_SHOW_IOCTL;
972 } else
973 kbd->ledmode = LED_SHOW_FLAGS;
974 set_leds();
975}
976
977static inline unsigned char getleds(void)
978{
979 struct kbd_struct *kbd = kbd_table + fg_console;
980 unsigned char leds;
981 int i;
982
983 if (kbd->ledmode == LED_SHOW_IOCTL)
984 return ledioctl;
985
986 leds = kbd->ledflagstate;
987
988 if (kbd->ledmode == LED_SHOW_MEM) {
989 for (i = 0; i < 3; i++)
990 if (ledptrs[i].valid) {
991 if (*ledptrs[i].addr & ledptrs[i].mask)
992 leds |= (1 << i);
993 else
994 leds &= ~(1 << i);
995 }
996 }
997 return leds;
998}
999
1000/*
1001 * This routine is the bottom half of the keyboard interrupt
1002 * routine, and runs with all interrupts enabled. It does
1003 * console changing, led setting and copy_to_cooked, which can
1004 * take a reasonably long time.
1005 *
1006 * Aside from timing (which isn't really that important for
1007 * keyboard interrupts as they happen often), using the software
1008 * interrupt routines for this thing allows us to easily mask
1009 * this when we don't want any of the above to happen.
1010 * This allows for easy and efficient race-condition prevention
Dmitry Torokhov0e739d22006-07-06 00:22:43 -04001011 * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 */
1013
1014static void kbd_bh(unsigned long dummy)
1015{
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001016 struct list_head *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 unsigned char leds = getleds();
1018
1019 if (leds != ledstate) {
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001020 list_for_each(node, &kbd_handler.h_list) {
Dmitry Torokhov0e739d22006-07-06 00:22:43 -04001021 struct input_handle *handle = to_handle_h(node);
1022 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1023 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1024 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1025 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 }
1027 }
1028
1029 ledstate = leds;
1030}
1031
1032DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1033
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001035 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1036 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
Hans-Christian Egtvedt3a4e8322007-12-04 13:15:41 +01001037 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1038 defined(CONFIG_AVR32)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039
1040#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1041 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1042
Andreas Mohr0f5e5602006-06-05 00:18:00 -04001043static const unsigned short x86_keycodes[256] =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1045 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1046 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1047 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1048 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1049 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001050 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1052 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
Hans de Goede72a42f22007-07-03 01:55:18 -04001053 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1054 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1056 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1057 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1058 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1059
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001060#ifdef CONFIG_SPARC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061static int sparc_l1_a_state = 0;
1062extern void sun_do_break(void);
1063#endif
1064
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001065static int emulate_raw(struct vc_data *vc, unsigned int keycode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 unsigned char up_flag)
1067{
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001068 int code;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069
1070 switch (keycode) {
1071 case KEY_PAUSE:
1072 put_queue(vc, 0xe1);
1073 put_queue(vc, 0x1d | up_flag);
1074 put_queue(vc, 0x45 | up_flag);
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001075 break;
1076
Jerome Pinotb9ab58d2006-06-26 01:51:23 -04001077 case KEY_HANGEUL:
Dmitry Torokhov0ae051a2006-06-26 01:52:34 -04001078 if (!up_flag)
1079 put_queue(vc, 0xf2);
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001080 break;
1081
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 case KEY_HANJA:
Dmitry Torokhov0ae051a2006-06-26 01:52:34 -04001083 if (!up_flag)
1084 put_queue(vc, 0xf1);
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001085 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001087 case KEY_SYSRQ:
1088 /*
1089 * Real AT keyboards (that's what we're trying
1090 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1091 * pressing PrtSc/SysRq alone, but simply 0x54
1092 * when pressing Alt+PrtSc/SysRq.
1093 */
1094 if (sysrq_alt) {
1095 put_queue(vc, 0x54 | up_flag);
1096 } else {
1097 put_queue(vc, 0xe0);
1098 put_queue(vc, 0x2a | up_flag);
1099 put_queue(vc, 0xe0);
1100 put_queue(vc, 0x37 | up_flag);
1101 }
1102 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001104 default:
1105 if (keycode > 255)
1106 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001108 code = x86_keycodes[keycode];
1109 if (!code)
1110 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001112 if (code & 0x100)
1113 put_queue(vc, 0xe0);
1114 put_queue(vc, (code & 0x7f) | up_flag);
1115
1116 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 }
1118
1119 return 0;
1120}
1121
1122#else
1123
1124#define HW_RAW(dev) 0
1125
1126#warning "Cannot generate rawmode keyboard for your architecture yet."
1127
1128static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1129{
1130 if (keycode > 127)
1131 return -1;
1132
1133 put_queue(vc, keycode | up_flag);
1134 return 0;
1135}
1136#endif
1137
1138static void kbd_rawcode(unsigned char data)
1139{
1140 struct vc_data *vc = vc_cons[fg_console].d;
1141 kbd = kbd_table + fg_console;
1142 if (kbd->kbdmode == VC_RAW)
1143 put_queue(vc, data);
1144}
1145
David Howells7d12e782006-10-05 14:55:46 +01001146static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147{
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;
1152 int shift_final;
Samuel Thibault41ab4392007-10-18 23:39:12 -07001153 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154
1155 tty = vc->vc_tty;
1156
1157 if (tty && (!tty->driver_data)) {
1158 /* No driver data? Strange. Okay we fix it then. */
1159 tty->driver_data = vc;
1160 }
1161
1162 kbd = kbd_table + fg_console;
1163
1164 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
Fredrik Roubertd2be8ee2006-06-26 00:24:35 -07001165 sysrq_alt = down ? keycode : 0;
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001166#ifdef CONFIG_SPARC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 if (keycode == KEY_STOP)
1168 sparc_l1_a_state = down;
1169#endif
1170
1171 rep = (down == 2);
1172
1173#ifdef CONFIG_MAC_EMUMOUSEBTN
1174 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1175 return;
1176#endif /* CONFIG_MAC_EMUMOUSEBTN */
1177
1178 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1179 if (emulate_raw(vc, keycode, !down << 7))
Dmitry Torokhov9e35d202007-04-12 01:30:52 -04001180 if (keycode < BTN_MISC && printk_ratelimit())
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1182
1183#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1184 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
Fredrik Roubertd2be8ee2006-06-26 00:24:35 -07001185 if (!sysrq_down) {
1186 sysrq_down = down;
1187 sysrq_alt_use = sysrq_alt;
1188 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 return;
1190 }
Fredrik Roubertd2be8ee2006-06-26 00:24:35 -07001191 if (sysrq_down && !down && keycode == sysrq_alt_use)
1192 sysrq_down = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 if (sysrq_down && down && !rep) {
David Howells7d12e782006-10-05 14:55:46 +01001194 handle_sysrq(kbd_sysrq_xlate[keycode], tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 return;
1196 }
1197#endif
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001198#ifdef CONFIG_SPARC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 if (keycode == KEY_A && sparc_l1_a_state) {
1200 sparc_l1_a_state = 0;
1201 sun_do_break();
1202 }
1203#endif
1204
1205 if (kbd->kbdmode == VC_MEDIUMRAW) {
1206 /*
1207 * This is extended medium raw mode, with keys above 127
1208 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1209 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1210 * interfere with anything else. The two bytes after 0 will
1211 * always have the up flag set not to interfere with older
1212 * applications. This allows for 16384 different keycodes,
1213 * which should be enough.
1214 */
1215 if (keycode < 128) {
1216 put_queue(vc, keycode | (!down << 7));
1217 } else {
1218 put_queue(vc, !down << 7);
1219 put_queue(vc, (keycode >> 7) | 0x80);
1220 put_queue(vc, keycode | 0x80);
1221 }
1222 raw_mode = 1;
1223 }
1224
1225 if (down)
1226 set_bit(keycode, key_down);
1227 else
1228 clear_bit(keycode, key_down);
1229
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001230 if (rep &&
1231 (!vc_kbd_mode(kbd, VC_REPEAT) ||
Alan Coxf34d7a52008-04-30 00:54:13 -07001232 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 /*
1234 * Don't repeat a key if the input buffers are not empty and the
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001235 * characters get aren't echoed locally. This makes key repeat
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 * usable with slow applications and under heavy loads.
1237 */
1238 return;
1239 }
1240
Samuel Thibault41ab4392007-10-18 23:39:12 -07001241 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
Karl Dahlke0beb4f62008-04-15 01:30:32 -04001242 param.ledstate = kbd->ledflagstate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 key_map = key_maps[shift_final];
1244
Samuel Thibault41ab4392007-10-18 23:39:12 -07001245 if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_KEYCODE, &param) == NOTIFY_STOP || !key_map) {
1246 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_UNBOUND_KEYCODE, &param);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 compute_shiftstate();
1248 kbd->slockstate = 0;
1249 return;
1250 }
1251
Dmitry Torokhov161c6092008-10-08 23:42:26 -04001252 if (keycode >= NR_KEYS)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -05001253 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1254 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1255 else
1256 return;
1257 else
1258 keysym = key_map[keycode];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 type = KTYP(keysym);
1261
1262 if (type < 0xf0) {
Samuel Thibault41ab4392007-10-18 23:39:12 -07001263 param.value = keysym;
1264 if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_UNICODE, &param) == NOTIFY_STOP)
1265 return;
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001266 if (down && !raw_mode)
1267 to_utf8(vc, keysym);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 return;
1269 }
1270
1271 type -= 0xf0;
1272
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 if (type == KT_LETTER) {
1274 type = KT_LATIN;
1275 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1276 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1277 if (key_map)
1278 keysym = key_map[keycode];
1279 }
1280 }
Samuel Thibault41ab4392007-10-18 23:39:12 -07001281 param.value = keysym;
1282
1283 if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_KEYSYM, &param) == NOTIFY_STOP)
1284 return;
1285
1286 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1287 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
David Howells7d12e782006-10-05 14:55:46 +01001289 (*k_handler[type])(vc, keysym & 0xff, !down);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290
Karl Dahlke0beb4f62008-04-15 01:30:32 -04001291 param.ledstate = kbd->ledflagstate;
Samuel Thibault41ab4392007-10-18 23:39:12 -07001292 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1293
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 if (type != KT_SLOCK)
1295 kbd->slockstate = 0;
1296}
1297
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001298static void kbd_event(struct input_handle *handle, unsigned int event_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 unsigned int event_code, int value)
1300{
1301 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1302 kbd_rawcode(value);
1303 if (event_type == EV_KEY)
David Howells7d12e782006-10-05 14:55:46 +01001304 kbd_keycode(event_code, value, HW_RAW(handle->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 tasklet_schedule(&keyboard_tasklet);
1306 do_poke_blanked_console = 1;
1307 schedule_console_callback();
1308}
1309
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310/*
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.
1315 */
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001316static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1317 const struct input_device_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318{
1319 struct input_handle *handle;
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001320 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 int i;
1322
1323 for (i = KEY_RESERVED; i < BTN_MISC; i++)
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001324 if (test_bit(i, dev->keybit))
1325 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001327 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001328 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329
Dmitry Torokhov22479e12006-08-04 22:51:51 -04001330 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1331 if (!handle)
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001332 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333
1334 handle->dev = dev;
1335 handle->handler = handler;
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001336 handle->name = "kbd";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001338 error = input_register_handle(handle);
1339 if (error)
1340 goto err_free_handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001342 error = input_open_device(handle);
1343 if (error)
1344 goto err_unregister_handle;
1345
1346 return 0;
1347
1348 err_unregister_handle:
1349 input_unregister_handle(handle);
1350 err_free_handle:
1351 kfree(handle);
1352 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353}
1354
1355static void kbd_disconnect(struct input_handle *handle)
1356{
1357 input_close_device(handle);
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001358 input_unregister_handle(handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 kfree(handle);
1360}
1361
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001362/*
1363 * Start keyboard handler on the new keyboard by refreshing LED state to
1364 * match the rest of the system.
1365 */
1366static void kbd_start(struct input_handle *handle)
1367{
1368 unsigned char leds = ledstate;
1369
1370 tasklet_disable(&keyboard_tasklet);
1371 if (leds != 0xff) {
Dmitry Torokhov0e739d22006-07-06 00:22:43 -04001372 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1373 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1374 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1375 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001376 }
1377 tasklet_enable(&keyboard_tasklet);
1378}
1379
Dmitry Torokhov66e66112006-09-14 01:31:59 -04001380static const struct input_device_id kbd_ids[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 {
1382 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
Jiri Slaby7b19ada2007-10-18 23:40:32 -07001383 .evbit = { BIT_MASK(EV_KEY) },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 },
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001385
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 {
1387 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
Jiri Slaby7b19ada2007-10-18 23:40:32 -07001388 .evbit = { BIT_MASK(EV_SND) },
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001389 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390
1391 { }, /* Terminating entry */
1392};
1393
1394MODULE_DEVICE_TABLE(input, kbd_ids);
1395
1396static struct input_handler kbd_handler = {
1397 .event = kbd_event,
1398 .connect = kbd_connect,
1399 .disconnect = kbd_disconnect,
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001400 .start = kbd_start,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 .name = "kbd",
1402 .id_table = kbd_ids,
1403};
1404
1405int __init kbd_init(void)
1406{
1407 int i;
Dmitry Torokhov4263cf02006-09-14 01:32:39 -04001408 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409
Dmitry Torokhov2b192902006-07-19 01:13:26 -04001410 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1411 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1412 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1413 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1414 kbd_table[i].lockstate = KBD_DEFLOCK;
1415 kbd_table[i].slockstate = 0;
1416 kbd_table[i].modeflags = KBD_DEFMODE;
Bill Nottingham2e8ecb92007-10-16 23:29:38 -07001417 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
Dmitry Torokhov2b192902006-07-19 01:13:26 -04001418 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419
Dmitry Torokhov4263cf02006-09-14 01:32:39 -04001420 error = input_register_handler(&kbd_handler);
1421 if (error)
1422 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423
1424 tasklet_enable(&keyboard_tasklet);
1425 tasklet_schedule(&keyboard_tasklet);
1426
1427 return 0;
1428}