blob: d1c50b3302e54247b04879c94e0b83dd162654ee [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
49/*
50 * Exported functions/variables
51 */
52
53#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
54
55/*
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
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050058 * of PARISC machines however there is no NumLock key and everyone expects the keypad
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 * to be used for numbers.
60 */
61
62#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
63#define KBD_DEFLEDS (1 << VC_NUMLOCK)
64#else
65#define KBD_DEFLEDS 0
66#endif
67
68#define KBD_DEFLOCK 0
69
70void compute_shiftstate(void);
71
72/*
73 * Handler Tables.
74 */
75
76#define K_HANDLERS\
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,\
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -050080 k_slock, k_dead2, k_brl, k_ignore
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050082typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
David Howells7d12e782006-10-05 14:55:46 +010083 char up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084static k_handler_fn K_HANDLERS;
Samuel Thibault41ab4392007-10-18 23:39:12 -070085k_handler_fn *k_handler[16] = { K_HANDLERS };
86EXPORT_SYMBOL_GPL(k_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88#define FN_HANDLERS\
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050089 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
David Howells7d12e782006-10-05 14:55:46 +010095typedef void (fn_handler_fn)(struct vc_data *vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096static fn_handler_fn FN_HANDLERS;
97static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
98
99/*
100 * Variables exported for vt_ioctl.c
101 */
102
103/* maximum values each key_handler can handle */
104const 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,
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500107 255, NR_LOCK - 1, 255, NR_BRL - 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108};
109
110const int NR_TYPES = ARRAY_SIZE(max_vals);
111
112struct kbd_struct kbd_table[MAX_NR_CONSOLES];
113static struct kbd_struct *kbd = kbd_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Eric W. Biederman81af8d62006-10-02 02:17:13 -0700115struct vt_spawn_console vt_spawn_con = {
Milind Arun Choudharyccc94252007-05-08 00:30:09 -0700116 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
Eric W. Biederman81af8d62006-10-02 02:17:13 -0700117 .pid = NULL,
118 .sig = 0,
119};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
121/*
122 * Variables exported for vt.c
123 */
124
125int shift_state = 0;
126
127/*
128 * Internal Data.
129 */
130
131static struct input_handler kbd_handler;
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700132static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
134static int dead_key_next;
135static int npadch = -1; /* -1 or number assembled on pad */
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500136static unsigned int diacr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137static char rep; /* flag telling character repeat */
138
139static unsigned char ledstate = 0xff; /* undefined */
140static unsigned char ledioctl;
141
142static struct ledptr {
143 unsigned int *addr;
144 unsigned int mask;
145 unsigned char valid:1;
146} ledptrs[3];
147
148/* Simple translation table for the SysRq keys */
149
150#ifdef CONFIG_MAGIC_SYSRQ
151unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
152 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
153 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
154 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
155 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
156 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
157 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
158 "\r\000/"; /* 0x60 - 0x6f */
159static int sysrq_down;
Fredrik Roubertd2be8ee2006-06-26 00:24:35 -0700160static int sysrq_alt_use;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161#endif
162static int sysrq_alt;
163
164/*
Samuel Thibault41ab4392007-10-18 23:39:12 -0700165 * Notifier list for console keyboard events
166 */
167static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
168
169int register_keyboard_notifier(struct notifier_block *nb)
170{
171 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
172}
173EXPORT_SYMBOL_GPL(register_keyboard_notifier);
174
175int unregister_keyboard_notifier(struct notifier_block *nb)
176{
177 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
178}
179EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
180
181/*
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400182 * Translation of scancodes to keycodes. We set them on only the first
183 * keyboard in the list that accepts the scancode and keycode.
184 * Explanation for not choosing the first attached keyboard anymore:
185 * USB keyboards for example have two event devices: one for all "normal"
186 * keys and one for extra function keys (like "volume up", "make coffee",
187 * etc.). So this means that scancodes for the extra function keys won't
188 * be valid for the first event device, but will be for the second.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 */
190int getkeycode(unsigned int scancode)
191{
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400192 struct input_handle *handle;
193 int keycode;
194 int error = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400196 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400197 error = input_get_keycode(handle->dev, scancode, &keycode);
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400198 if (!error)
199 return keycode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 }
201
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400202 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203}
204
205int setkeycode(unsigned int scancode, unsigned int keycode)
206{
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400207 struct input_handle *handle;
208 int error = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400210 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
Dmitry Torokhovf4f37c82007-11-04 00:41:12 -0400211 error = input_set_keycode(handle->dev, scancode, keycode);
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400212 if (!error)
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500213 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 }
215
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400216 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217}
218
219/*
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500220 * Making beeps and bells.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 */
222static void kd_nosound(unsigned long ignored)
223{
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400224 struct input_handle *handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400226 list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 if (test_bit(EV_SND, handle->dev->evbit)) {
228 if (test_bit(SND_TONE, handle->dev->sndbit))
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400229 input_inject_event(handle, EV_SND, SND_TONE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 if (test_bit(SND_BELL, handle->dev->sndbit))
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400231 input_inject_event(handle, EV_SND, SND_BELL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 }
233 }
234}
235
Ingo Molnar8d06afa2005-09-09 13:10:40 -0700236static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
238void kd_mksound(unsigned int hz, unsigned int ticks)
239{
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500240 struct list_head *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
242 del_timer(&kd_mksound_timer);
243
244 if (hz) {
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500245 list_for_each_prev(node, &kbd_handler.h_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 struct input_handle *handle = to_handle_h(node);
247 if (test_bit(EV_SND, handle->dev->evbit)) {
248 if (test_bit(SND_TONE, handle->dev->sndbit)) {
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400249 input_inject_event(handle, EV_SND, SND_TONE, hz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 break;
251 }
252 if (test_bit(SND_BELL, handle->dev->sndbit)) {
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400253 input_inject_event(handle, EV_SND, SND_BELL, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 break;
255 }
256 }
257 }
258 if (ticks)
259 mod_timer(&kd_mksound_timer, jiffies + ticks);
260 } else
261 kd_nosound(0);
262}
263
264/*
265 * Setting the keyboard rate.
266 */
267
268int kbd_rate(struct kbd_repeat *rep)
269{
270 struct list_head *node;
271 unsigned int d = 0;
272 unsigned int p = 0;
273
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400274 list_for_each(node, &kbd_handler.h_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 struct input_handle *handle = to_handle_h(node);
276 struct input_dev *dev = handle->dev;
277
278 if (test_bit(EV_REP, dev->evbit)) {
279 if (rep->delay > 0)
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400280 input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 if (rep->period > 0)
Dmitry Torokhov0e739d22006-07-06 00:22:43 -0400282 input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 d = dev->rep[REP_DELAY];
284 p = dev->rep[REP_PERIOD];
285 }
286 }
287 rep->delay = d;
288 rep->period = p;
289 return 0;
290}
291
292/*
293 * Helper Functions.
294 */
295static void put_queue(struct vc_data *vc, int ch)
296{
297 struct tty_struct *tty = vc->vc_tty;
298
299 if (tty) {
300 tty_insert_flip_char(tty, ch, 0);
301 con_schedule_flip(tty);
302 }
303}
304
305static void puts_queue(struct vc_data *vc, char *cp)
306{
307 struct tty_struct *tty = vc->vc_tty;
308
309 if (!tty)
310 return;
311
312 while (*cp) {
313 tty_insert_flip_char(tty, *cp, 0);
314 cp++;
315 }
316 con_schedule_flip(tty);
317}
318
319static void applkey(struct vc_data *vc, int key, char mode)
320{
321 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
322
323 buf[1] = (mode ? 'O' : '[');
324 buf[2] = key;
325 puts_queue(vc, buf);
326}
327
328/*
329 * Many other routines do put_queue, but I think either
330 * they produce ASCII, or they produce some user-assigned
331 * string, and in both cases we might assume that it is
Jan Engelhardt759448f2007-07-15 23:40:40 -0700332 * in utf-8 already.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 */
Jan Engelhardt759448f2007-07-15 23:40:40 -0700334static void to_utf8(struct vc_data *vc, uint c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335{
336 if (c < 0x80)
337 /* 0******* */
338 put_queue(vc, c);
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500339 else if (c < 0x800) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 /* 110***** 10****** */
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500341 put_queue(vc, 0xc0 | (c >> 6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 put_queue(vc, 0x80 | (c & 0x3f));
Jan Engelhardt759448f2007-07-15 23:40:40 -0700343 } else if (c < 0x10000) {
344 if (c >= 0xD800 && c < 0xE000)
345 return;
346 if (c == 0xFFFF)
347 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 /* 1110**** 10****** 10****** */
349 put_queue(vc, 0xe0 | (c >> 12));
350 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
351 put_queue(vc, 0x80 | (c & 0x3f));
Jan Engelhardt759448f2007-07-15 23:40:40 -0700352 } else if (c < 0x110000) {
353 /* 11110*** 10****** 10****** 10****** */
354 put_queue(vc, 0xf0 | (c >> 18));
355 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
356 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
357 put_queue(vc, 0x80 | (c & 0x3f));
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500358 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
360
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500361/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 * Called after returning from RAW mode or when changing consoles - recompute
363 * shift_down[] and shift_state from key_down[] maybe called when keymap is
364 * undefined, so that shiftkey release is seen
365 */
366void compute_shiftstate(void)
367{
368 unsigned int i, j, k, sym, val;
369
370 shift_state = 0;
371 memset(shift_down, 0, sizeof(shift_down));
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500372
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
374
375 if (!key_down[i])
376 continue;
377
378 k = i * BITS_PER_LONG;
379
380 for (j = 0; j < BITS_PER_LONG; j++, k++) {
381
382 if (!test_bit(k, key_down))
383 continue;
384
385 sym = U(key_maps[0][k]);
386 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
387 continue;
388
389 val = KVAL(sym);
390 if (val == KVAL(K_CAPSSHIFT))
391 val = KVAL(K_SHIFT);
392
393 shift_down[val]++;
394 shift_state |= (1 << val);
395 }
396 }
397}
398
399/*
400 * We have a combining character DIACR here, followed by the character CH.
401 * If the combination occurs in the table, return the corresponding value.
402 * Otherwise, if CH is a space or equals DIACR, return DIACR.
403 * Otherwise, conclude that DIACR was not combining after all,
404 * queue it and return CH.
405 */
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500406static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407{
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500408 unsigned int d = diacr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 unsigned int i;
410
411 diacr = 0;
412
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500413 if ((d & ~0xff) == BRL_UC_ROW) {
414 if ((ch & ~0xff) == BRL_UC_ROW)
415 return d | ch;
416 } else {
417 for (i = 0; i < accent_table_size; i++)
418 if (accent_table[i].diacr == d && accent_table[i].base == ch)
419 return accent_table[i].result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 }
421
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500422 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 return d;
424
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500425 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700426 to_utf8(vc, d);
427 else {
428 int c = conv_uni_to_8bit(d);
429 if (c != -1)
430 put_queue(vc, c);
431 }
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 return ch;
434}
435
436/*
437 * Special function handlers
438 */
David Howells7d12e782006-10-05 14:55:46 +0100439static void fn_enter(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440{
441 if (diacr) {
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500442 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700443 to_utf8(vc, diacr);
444 else {
445 int c = conv_uni_to_8bit(diacr);
446 if (c != -1)
447 put_queue(vc, c);
448 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 diacr = 0;
450 }
451 put_queue(vc, 13);
452 if (vc_kbd_mode(kbd, VC_CRLF))
453 put_queue(vc, 10);
454}
455
David Howells7d12e782006-10-05 14:55:46 +0100456static void fn_caps_toggle(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457{
458 if (rep)
459 return;
460 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
461}
462
David Howells7d12e782006-10-05 14:55:46 +0100463static void fn_caps_on(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464{
465 if (rep)
466 return;
467 set_vc_kbd_led(kbd, VC_CAPSLOCK);
468}
469
David Howells7d12e782006-10-05 14:55:46 +0100470static void fn_show_ptregs(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471{
David Howells7d12e782006-10-05 14:55:46 +0100472 struct pt_regs *regs = get_irq_regs();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 if (regs)
474 show_regs(regs);
475}
476
David Howells7d12e782006-10-05 14:55:46 +0100477static void fn_hold(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478{
479 struct tty_struct *tty = vc->vc_tty;
480
481 if (rep || !tty)
482 return;
483
484 /*
485 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
486 * these routines are also activated by ^S/^Q.
487 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
488 */
489 if (tty->stopped)
490 start_tty(tty);
491 else
492 stop_tty(tty);
493}
494
David Howells7d12e782006-10-05 14:55:46 +0100495static void fn_num(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
497 if (vc_kbd_mode(kbd,VC_APPLIC))
498 applkey(vc, 'P', 1);
499 else
David Howells7d12e782006-10-05 14:55:46 +0100500 fn_bare_num(vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501}
502
503/*
504 * Bind this to Shift-NumLock if you work in application keypad mode
505 * but want to be able to change the NumLock flag.
506 * Bind this to NumLock if you prefer that the NumLock key always
507 * changes the NumLock flag.
508 */
David Howells7d12e782006-10-05 14:55:46 +0100509static void fn_bare_num(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510{
511 if (!rep)
512 chg_vc_kbd_led(kbd, VC_NUMLOCK);
513}
514
David Howells7d12e782006-10-05 14:55:46 +0100515static void fn_lastcons(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516{
517 /* switch to the last used console, ChN */
518 set_console(last_console);
519}
520
David Howells7d12e782006-10-05 14:55:46 +0100521static void fn_dec_console(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522{
523 int i, cur = fg_console;
524
525 /* Currently switching? Queue this next switch relative to that. */
526 if (want_console != -1)
527 cur = want_console;
528
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500529 for (i = cur - 1; i != cur; i--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 if (i == -1)
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500531 i = MAX_NR_CONSOLES - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 if (vc_cons_allocated(i))
533 break;
534 }
535 set_console(i);
536}
537
David Howells7d12e782006-10-05 14:55:46 +0100538static void fn_inc_console(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539{
540 int i, cur = fg_console;
541
542 /* Currently switching? Queue this next switch relative to that. */
543 if (want_console != -1)
544 cur = want_console;
545
546 for (i = cur+1; i != cur; i++) {
547 if (i == MAX_NR_CONSOLES)
548 i = 0;
549 if (vc_cons_allocated(i))
550 break;
551 }
552 set_console(i);
553}
554
David Howells7d12e782006-10-05 14:55:46 +0100555static void fn_send_intr(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556{
557 struct tty_struct *tty = vc->vc_tty;
558
559 if (!tty)
560 return;
561 tty_insert_flip_char(tty, 0, TTY_BREAK);
562 con_schedule_flip(tty);
563}
564
David Howells7d12e782006-10-05 14:55:46 +0100565static void fn_scroll_forw(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566{
567 scrollfront(vc, 0);
568}
569
David Howells7d12e782006-10-05 14:55:46 +0100570static void fn_scroll_back(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571{
572 scrollback(vc, 0);
573}
574
David Howells7d12e782006-10-05 14:55:46 +0100575static void fn_show_mem(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576{
577 show_mem();
578}
579
David Howells7d12e782006-10-05 14:55:46 +0100580static void fn_show_state(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581{
582 show_state();
583}
584
David Howells7d12e782006-10-05 14:55:46 +0100585static void fn_boot_it(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586{
587 ctrl_alt_del();
588}
589
David Howells7d12e782006-10-05 14:55:46 +0100590static void fn_compose(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591{
592 dead_key_next = 1;
593}
594
David Howells7d12e782006-10-05 14:55:46 +0100595static void fn_spawn_con(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596{
Eric W. Biederman81af8d62006-10-02 02:17:13 -0700597 spin_lock(&vt_spawn_con.lock);
598 if (vt_spawn_con.pid)
599 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
600 put_pid(vt_spawn_con.pid);
601 vt_spawn_con.pid = NULL;
602 }
603 spin_unlock(&vt_spawn_con.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604}
605
David Howells7d12e782006-10-05 14:55:46 +0100606static void fn_SAK(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607{
Eric W. Biederman8b6312f2007-02-10 01:44:34 -0800608 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
Eric W. Biederman8b6312f2007-02-10 01:44:34 -0800609 schedule_work(SAK_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610}
611
David Howells7d12e782006-10-05 14:55:46 +0100612static void fn_null(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613{
614 compute_shiftstate();
615}
616
617/*
618 * Special key handlers
619 */
David Howells7d12e782006-10-05 14:55:46 +0100620static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621{
622}
623
David Howells7d12e782006-10-05 14:55:46 +0100624static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625{
626 if (up_flag)
627 return;
628 if (value >= ARRAY_SIZE(fn_handler))
629 return;
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500630 if ((kbd->kbdmode == VC_RAW ||
631 kbd->kbdmode == VC_MEDIUMRAW) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 value != KVAL(K_SAK))
633 return; /* SAK is allowed even in raw mode */
David Howells7d12e782006-10-05 14:55:46 +0100634 fn_handler[value](vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635}
636
David Howells7d12e782006-10-05 14:55:46 +0100637static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638{
639 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
640}
641
David Howells7d12e782006-10-05 14:55:46 +0100642static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643{
644 if (up_flag)
645 return; /* no action, if this is a key release */
646
647 if (diacr)
648 value = handle_diacr(vc, value);
649
650 if (dead_key_next) {
651 dead_key_next = 0;
652 diacr = value;
653 return;
654 }
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500655 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700656 to_utf8(vc, value);
657 else {
658 int c = conv_uni_to_8bit(value);
659 if (c != -1)
660 put_queue(vc, c);
661 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662}
663
664/*
665 * Handle dead key. Note that we now may have several
666 * dead keys modifying the same character. Very useful
667 * for Vietnamese.
668 */
David Howells7d12e782006-10-05 14:55:46 +0100669static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670{
671 if (up_flag)
672 return;
673 diacr = (diacr ? handle_diacr(vc, value) : value);
674}
675
David Howells7d12e782006-10-05 14:55:46 +0100676static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500677{
Samuel Thibault04c71972007-10-16 23:27:04 -0700678 unsigned int uni;
679 if (kbd->kbdmode == VC_UNICODE)
680 uni = value;
681 else
682 uni = conv_8bit_to_uni(value);
683 k_unicode(vc, uni, up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500684}
685
David Howells7d12e782006-10-05 14:55:46 +0100686static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500687{
David Howells7d12e782006-10-05 14:55:46 +0100688 k_deadunicode(vc, value, up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500689}
690
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691/*
692 * Obsolete - for backwards compatibility only
693 */
David Howells7d12e782006-10-05 14:55:46 +0100694static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695{
Andreas Mohr0f5e5602006-06-05 00:18:00 -0400696 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 value = ret_diacr[value];
David Howells7d12e782006-10-05 14:55:46 +0100698 k_deadunicode(vc, value, up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699}
700
David Howells7d12e782006-10-05 14:55:46 +0100701static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702{
703 if (up_flag)
704 return;
705 set_console(value);
706}
707
David Howells7d12e782006-10-05 14:55:46 +0100708static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709{
710 unsigned v;
711
712 if (up_flag)
713 return;
714 v = value;
715 if (v < ARRAY_SIZE(func_table)) {
716 if (func_table[value])
717 puts_queue(vc, func_table[value]);
718 } else
719 printk(KERN_ERR "k_fn called with value=%d\n", value);
720}
721
David Howells7d12e782006-10-05 14:55:46 +0100722static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723{
Brandon Philipse52b29c2006-11-04 22:09:08 -0500724 static const char cur_chars[] = "BDCA";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
726 if (up_flag)
727 return;
728 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
729}
730
David Howells7d12e782006-10-05 14:55:46 +0100731static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732{
Andreas Mohr0f5e5602006-06-05 00:18:00 -0400733 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
734 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
736 if (up_flag)
737 return; /* no action, if this is a key release */
738
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);
742 return;
743 }
744
745 if (!vc_kbd_led(kbd, VC_NUMLOCK))
746 switch (value) {
747 case KVAL(K_PCOMMA):
748 case KVAL(K_PDOT):
David Howells7d12e782006-10-05 14:55:46 +0100749 k_fn(vc, KVAL(K_REMOVE), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 return;
751 case KVAL(K_P0):
David Howells7d12e782006-10-05 14:55:46 +0100752 k_fn(vc, KVAL(K_INSERT), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 return;
754 case KVAL(K_P1):
David Howells7d12e782006-10-05 14:55:46 +0100755 k_fn(vc, KVAL(K_SELECT), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 return;
757 case KVAL(K_P2):
David Howells7d12e782006-10-05 14:55:46 +0100758 k_cur(vc, KVAL(K_DOWN), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 return;
760 case KVAL(K_P3):
David Howells7d12e782006-10-05 14:55:46 +0100761 k_fn(vc, KVAL(K_PGDN), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 return;
763 case KVAL(K_P4):
David Howells7d12e782006-10-05 14:55:46 +0100764 k_cur(vc, KVAL(K_LEFT), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 return;
766 case KVAL(K_P6):
David Howells7d12e782006-10-05 14:55:46 +0100767 k_cur(vc, KVAL(K_RIGHT), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 return;
769 case KVAL(K_P7):
David Howells7d12e782006-10-05 14:55:46 +0100770 k_fn(vc, KVAL(K_FIND), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 return;
772 case KVAL(K_P8):
David Howells7d12e782006-10-05 14:55:46 +0100773 k_cur(vc, KVAL(K_UP), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 return;
775 case KVAL(K_P9):
David Howells7d12e782006-10-05 14:55:46 +0100776 k_fn(vc, KVAL(K_PGUP), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 return;
778 case KVAL(K_P5):
779 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
780 return;
781 }
782
783 put_queue(vc, pad_chars[value]);
784 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
785 put_queue(vc, 10);
786}
787
David Howells7d12e782006-10-05 14:55:46 +0100788static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789{
790 int old_state = shift_state;
791
792 if (rep)
793 return;
794 /*
795 * Mimic typewriter:
796 * a CapsShift key acts like Shift but undoes CapsLock
797 */
798 if (value == KVAL(K_CAPSSHIFT)) {
799 value = KVAL(K_SHIFT);
800 if (!up_flag)
801 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
802 }
803
804 if (up_flag) {
805 /*
806 * handle the case that two shift or control
807 * keys are depressed simultaneously
808 */
809 if (shift_down[value])
810 shift_down[value]--;
811 } else
812 shift_down[value]++;
813
814 if (shift_down[value])
815 shift_state |= (1 << value);
816 else
817 shift_state &= ~(1 << value);
818
819 /* kludge */
820 if (up_flag && shift_state != old_state && npadch != -1) {
821 if (kbd->kbdmode == VC_UNICODE)
Jan Engelhardt759448f2007-07-15 23:40:40 -0700822 to_utf8(vc, npadch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 else
824 put_queue(vc, npadch & 0xff);
825 npadch = -1;
826 }
827}
828
David Howells7d12e782006-10-05 14:55:46 +0100829static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830{
831 if (up_flag)
832 return;
833
834 if (vc_kbd_mode(kbd, VC_META)) {
835 put_queue(vc, '\033');
836 put_queue(vc, value);
837 } else
838 put_queue(vc, value | 0x80);
839}
840
David Howells7d12e782006-10-05 14:55:46 +0100841static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842{
843 int base;
844
845 if (up_flag)
846 return;
847
848 if (value < 10) {
849 /* decimal input of code, while Alt depressed */
850 base = 10;
851 } else {
852 /* hexadecimal input of code, while AltGr depressed */
853 value -= 10;
854 base = 16;
855 }
856
857 if (npadch == -1)
858 npadch = value;
859 else
860 npadch = npadch * base + value;
861}
862
David Howells7d12e782006-10-05 14:55:46 +0100863static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864{
865 if (up_flag || rep)
866 return;
867 chg_vc_kbd_lock(kbd, value);
868}
869
David Howells7d12e782006-10-05 14:55:46 +0100870static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871{
David Howells7d12e782006-10-05 14:55:46 +0100872 k_shift(vc, value, up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 if (up_flag || rep)
874 return;
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]) {
878 kbd->slockstate = 0;
879 chg_vc_kbd_slock(kbd, value);
880 }
881}
882
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500883/* by default, 300ms interval for combination release */
Samuel Thibault77426d72006-04-26 00:14:10 -0400884static unsigned brl_timeout = 300;
885MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
886module_param(brl_timeout, uint, 0644);
887
888static unsigned brl_nbchords = 1;
889MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
890module_param(brl_nbchords, uint, 0644);
891
David Howells7d12e782006-10-05 14:55:46 +0100892static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
Samuel Thibault77426d72006-04-26 00:14:10 -0400893{
894 static unsigned long chords;
895 static unsigned committed;
896
897 if (!brl_nbchords)
David Howells7d12e782006-10-05 14:55:46 +0100898 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
Samuel Thibault77426d72006-04-26 00:14:10 -0400899 else {
900 committed |= pattern;
901 chords++;
902 if (chords == brl_nbchords) {
David Howells7d12e782006-10-05 14:55:46 +0100903 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
Samuel Thibault77426d72006-04-26 00:14:10 -0400904 chords = 0;
905 committed = 0;
906 }
907 }
908}
909
David Howells7d12e782006-10-05 14:55:46 +0100910static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500911{
912 static unsigned pressed,committing;
913 static unsigned long releasestart;
914
915 if (kbd->kbdmode != VC_UNICODE) {
916 if (!up_flag)
917 printk("keyboard mode must be unicode for braille patterns\n");
918 return;
919 }
920
921 if (!value) {
David Howells7d12e782006-10-05 14:55:46 +0100922 k_unicode(vc, BRL_UC_ROW, up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500923 return;
924 }
925
926 if (value > 8)
927 return;
928
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500929 if (up_flag) {
930 if (brl_timeout) {
931 if (!committing ||
Julia Lawallb39b0442008-04-17 09:28:25 -0400932 time_after(jiffies,
933 releasestart + msecs_to_jiffies(brl_timeout))) {
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500934 committing = pressed;
935 releasestart = jiffies;
936 }
937 pressed &= ~(1 << (value - 1));
938 if (!pressed) {
939 if (committing) {
David Howells7d12e782006-10-05 14:55:46 +0100940 k_brlcommit(vc, committing, 0);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500941 committing = 0;
942 }
943 }
944 } else {
945 if (committing) {
David Howells7d12e782006-10-05 14:55:46 +0100946 k_brlcommit(vc, committing, 0);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500947 committing = 0;
948 }
949 pressed &= ~(1 << (value - 1));
950 }
951 } else {
952 pressed |= 1 << (value - 1);
953 if (!brl_timeout)
954 committing = pressed;
955 }
956}
957
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958/*
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.
962 */
963unsigned char getledstate(void)
964{
965 return ledstate;
966}
967
968void setledstate(struct kbd_struct *kbd, unsigned int led)
969{
970 if (!(led & ~7)) {
971 ledioctl = led;
972 kbd->ledmode = LED_SHOW_IOCTL;
973 } else
974 kbd->ledmode = LED_SHOW_FLAGS;
975 set_leds();
976}
977
978static inline unsigned char getleds(void)
979{
980 struct kbd_struct *kbd = kbd_table + fg_console;
981 unsigned char leds;
982 int i;
983
984 if (kbd->ledmode == LED_SHOW_IOCTL)
985 return ledioctl;
986
987 leds = kbd->ledflagstate;
988
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)
993 leds |= (1 << i);
994 else
995 leds &= ~(1 << i);
996 }
997 }
998 return leds;
999}
1000
1001/*
1002 * This routine is the bottom half of the keyboard interrupt
1003 * routine, and runs with all interrupts enabled. It does
1004 * console changing, led setting and copy_to_cooked, which can
1005 * take a reasonably long time.
1006 *
1007 * Aside from timing (which isn't really that important for
1008 * keyboard interrupts as they happen often), using the software
1009 * interrupt routines for this thing allows us to easily mask
1010 * this when we don't want any of the above to happen.
1011 * This allows for easy and efficient race-condition prevention
Dmitry Torokhov0e739d22006-07-06 00:22:43 -04001012 * for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 */
1014
1015static void kbd_bh(unsigned long dummy)
1016{
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001017 struct list_head *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 unsigned char leds = getleds();
1019
1020 if (leds != ledstate) {
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001021 list_for_each(node, &kbd_handler.h_list) {
Dmitry Torokhov0e739d22006-07-06 00:22:43 -04001022 struct input_handle *handle = to_handle_h(node);
1023 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1024 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1025 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1026 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 }
1028 }
1029
1030 ledstate = leds;
1031}
1032
1033DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1034
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001036 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1037 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
Hans-Christian Egtvedt3a4e8322007-12-04 13:15:41 +01001038 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1039 defined(CONFIG_AVR32)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040
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))
1043
Andreas Mohr0f5e5602006-06-05 00:18:00 -04001044static const unsigned short x86_keycodes[256] =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 { 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,
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001051 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 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,
Hans de Goede72a42f22007-07-03 01:55:18 -04001054 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,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 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 };
1060
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001061#ifdef CONFIG_SPARC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062static int sparc_l1_a_state = 0;
1063extern void sun_do_break(void);
1064#endif
1065
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001066static int emulate_raw(struct vc_data *vc, unsigned int keycode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 unsigned char up_flag)
1068{
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001069 int code;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070
1071 switch (keycode) {
1072 case KEY_PAUSE:
1073 put_queue(vc, 0xe1);
1074 put_queue(vc, 0x1d | up_flag);
1075 put_queue(vc, 0x45 | up_flag);
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001076 break;
1077
Jerome Pinotb9ab58d2006-06-26 01:51:23 -04001078 case KEY_HANGEUL:
Dmitry Torokhov0ae051a2006-06-26 01:52:34 -04001079 if (!up_flag)
1080 put_queue(vc, 0xf2);
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001081 break;
1082
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 case KEY_HANJA:
Dmitry Torokhov0ae051a2006-06-26 01:52:34 -04001084 if (!up_flag)
1085 put_queue(vc, 0xf1);
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001086 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001088 case KEY_SYSRQ:
1089 /*
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.
1094 */
1095 if (sysrq_alt) {
1096 put_queue(vc, 0x54 | up_flag);
1097 } else {
1098 put_queue(vc, 0xe0);
1099 put_queue(vc, 0x2a | up_flag);
1100 put_queue(vc, 0xe0);
1101 put_queue(vc, 0x37 | up_flag);
1102 }
1103 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001105 default:
1106 if (keycode > 255)
1107 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001109 code = x86_keycodes[keycode];
1110 if (!code)
1111 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001113 if (code & 0x100)
1114 put_queue(vc, 0xe0);
1115 put_queue(vc, (code & 0x7f) | up_flag);
1116
1117 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 }
1119
1120 return 0;
1121}
1122
1123#else
1124
1125#define HW_RAW(dev) 0
1126
1127#warning "Cannot generate rawmode keyboard for your architecture yet."
1128
1129static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1130{
1131 if (keycode > 127)
1132 return -1;
1133
1134 put_queue(vc, keycode | up_flag);
1135 return 0;
1136}
1137#endif
1138
1139static void kbd_rawcode(unsigned char data)
1140{
1141 struct vc_data *vc = vc_cons[fg_console].d;
1142 kbd = kbd_table + fg_console;
1143 if (kbd->kbdmode == VC_RAW)
1144 put_queue(vc, data);
1145}
1146
David Howells7d12e782006-10-05 14:55:46 +01001147static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148{
1149 struct vc_data *vc = vc_cons[fg_console].d;
1150 unsigned short keysym, *key_map;
1151 unsigned char type, raw_mode;
1152 struct tty_struct *tty;
1153 int shift_final;
Samuel Thibault41ab4392007-10-18 23:39:12 -07001154 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
1156 tty = vc->vc_tty;
1157
1158 if (tty && (!tty->driver_data)) {
1159 /* No driver data? Strange. Okay we fix it then. */
1160 tty->driver_data = vc;
1161 }
1162
1163 kbd = kbd_table + fg_console;
1164
1165 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
Fredrik Roubertd2be8ee2006-06-26 00:24:35 -07001166 sysrq_alt = down ? keycode : 0;
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001167#ifdef CONFIG_SPARC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 if (keycode == KEY_STOP)
1169 sparc_l1_a_state = down;
1170#endif
1171
1172 rep = (down == 2);
1173
1174#ifdef CONFIG_MAC_EMUMOUSEBTN
1175 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1176 return;
1177#endif /* CONFIG_MAC_EMUMOUSEBTN */
1178
1179 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1180 if (emulate_raw(vc, keycode, !down << 7))
Dmitry Torokhov9e35d202007-04-12 01:30:52 -04001181 if (keycode < BTN_MISC && printk_ratelimit())
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1183
1184#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1185 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
Fredrik Roubertd2be8ee2006-06-26 00:24:35 -07001186 if (!sysrq_down) {
1187 sysrq_down = down;
1188 sysrq_alt_use = sysrq_alt;
1189 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 return;
1191 }
Fredrik Roubertd2be8ee2006-06-26 00:24:35 -07001192 if (sysrq_down && !down && keycode == sysrq_alt_use)
1193 sysrq_down = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 if (sysrq_down && down && !rep) {
David Howells7d12e782006-10-05 14:55:46 +01001195 handle_sysrq(kbd_sysrq_xlate[keycode], tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 return;
1197 }
1198#endif
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001199#ifdef CONFIG_SPARC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 if (keycode == KEY_A && sparc_l1_a_state) {
1201 sparc_l1_a_state = 0;
1202 sun_do_break();
1203 }
1204#endif
1205
1206 if (kbd->kbdmode == VC_MEDIUMRAW) {
1207 /*
1208 * This is extended medium raw mode, with keys above 127
1209 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1210 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1211 * interfere with anything else. The two bytes after 0 will
1212 * always have the up flag set not to interfere with older
1213 * applications. This allows for 16384 different keycodes,
1214 * which should be enough.
1215 */
1216 if (keycode < 128) {
1217 put_queue(vc, keycode | (!down << 7));
1218 } else {
1219 put_queue(vc, !down << 7);
1220 put_queue(vc, (keycode >> 7) | 0x80);
1221 put_queue(vc, keycode | 0x80);
1222 }
1223 raw_mode = 1;
1224 }
1225
1226 if (down)
1227 set_bit(keycode, key_down);
1228 else
1229 clear_bit(keycode, key_down);
1230
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001231 if (rep &&
1232 (!vc_kbd_mode(kbd, VC_REPEAT) ||
Alan Coxf34d7a52008-04-30 00:54:13 -07001233 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 /*
1235 * Don't repeat a key if the input buffers are not empty and the
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001236 * characters get aren't echoed locally. This makes key repeat
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 * usable with slow applications and under heavy loads.
1238 */
1239 return;
1240 }
1241
Samuel Thibault41ab4392007-10-18 23:39:12 -07001242 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
Karl Dahlke0beb4f62008-04-15 01:30:32 -04001243 param.ledstate = kbd->ledflagstate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 key_map = key_maps[shift_final];
1245
Samuel Thibault41ab4392007-10-18 23:39:12 -07001246 if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_KEYCODE, &param) == NOTIFY_STOP || !key_map) {
1247 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_UNBOUND_KEYCODE, &param);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 compute_shiftstate();
1249 kbd->slockstate = 0;
1250 return;
1251 }
1252
1253 if (keycode > NR_KEYS)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -05001254 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1255 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1256 else
1257 return;
1258 else
1259 keysym = key_map[keycode];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 type = KTYP(keysym);
1262
1263 if (type < 0xf0) {
Samuel Thibault41ab4392007-10-18 23:39:12 -07001264 param.value = keysym;
1265 if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_UNICODE, &param) == NOTIFY_STOP)
1266 return;
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001267 if (down && !raw_mode)
1268 to_utf8(vc, keysym);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 return;
1270 }
1271
1272 type -= 0xf0;
1273
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 if (type == KT_LETTER) {
1275 type = KT_LATIN;
1276 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1277 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1278 if (key_map)
1279 keysym = key_map[keycode];
1280 }
1281 }
Samuel Thibault41ab4392007-10-18 23:39:12 -07001282 param.value = keysym;
1283
1284 if (atomic_notifier_call_chain(&keyboard_notifier_list, KBD_KEYSYM, &param) == NOTIFY_STOP)
1285 return;
1286
1287 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1288 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289
David Howells7d12e782006-10-05 14:55:46 +01001290 (*k_handler[type])(vc, keysym & 0xff, !down);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291
Karl Dahlke0beb4f62008-04-15 01:30:32 -04001292 param.ledstate = kbd->ledflagstate;
Samuel Thibault41ab4392007-10-18 23:39:12 -07001293 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1294
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 if (type != KT_SLOCK)
1296 kbd->slockstate = 0;
1297}
1298
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001299static void kbd_event(struct input_handle *handle, unsigned int event_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 unsigned int event_code, int value)
1301{
1302 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1303 kbd_rawcode(value);
1304 if (event_type == EV_KEY)
David Howells7d12e782006-10-05 14:55:46 +01001305 kbd_keycode(event_code, value, HW_RAW(handle->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 tasklet_schedule(&keyboard_tasklet);
1307 do_poke_blanked_console = 1;
1308 schedule_console_callback();
1309}
1310
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311/*
1312 * When a keyboard (or other input device) is found, the kbd_connect
1313 * function is called. The function then looks at the device, and if it
1314 * likes it, it can open it and get events from it. In this (kbd_connect)
1315 * function, we should decide which VT to bind that keyboard to initially.
1316 */
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001317static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1318 const struct input_device_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319{
1320 struct input_handle *handle;
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001321 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 int i;
1323
1324 for (i = KEY_RESERVED; i < BTN_MISC; i++)
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001325 if (test_bit(i, dev->keybit))
1326 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001328 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001329 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
Dmitry Torokhov22479e12006-08-04 22:51:51 -04001331 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1332 if (!handle)
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001333 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334
1335 handle->dev = dev;
1336 handle->handler = handler;
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001337 handle->name = "kbd";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001339 error = input_register_handle(handle);
1340 if (error)
1341 goto err_free_handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001343 error = input_open_device(handle);
1344 if (error)
1345 goto err_unregister_handle;
1346
1347 return 0;
1348
1349 err_unregister_handle:
1350 input_unregister_handle(handle);
1351 err_free_handle:
1352 kfree(handle);
1353 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354}
1355
1356static void kbd_disconnect(struct input_handle *handle)
1357{
1358 input_close_device(handle);
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001359 input_unregister_handle(handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 kfree(handle);
1361}
1362
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001363/*
1364 * Start keyboard handler on the new keyboard by refreshing LED state to
1365 * match the rest of the system.
1366 */
1367static void kbd_start(struct input_handle *handle)
1368{
1369 unsigned char leds = ledstate;
1370
1371 tasklet_disable(&keyboard_tasklet);
1372 if (leds != 0xff) {
Dmitry Torokhov0e739d22006-07-06 00:22:43 -04001373 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1374 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1375 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1376 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001377 }
1378 tasklet_enable(&keyboard_tasklet);
1379}
1380
Dmitry Torokhov66e66112006-09-14 01:31:59 -04001381static const struct input_device_id kbd_ids[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 {
1383 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
Jiri Slaby7b19ada2007-10-18 23:40:32 -07001384 .evbit = { BIT_MASK(EV_KEY) },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 },
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001386
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 {
1388 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
Jiri Slaby7b19ada2007-10-18 23:40:32 -07001389 .evbit = { BIT_MASK(EV_SND) },
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001390 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
1392 { }, /* Terminating entry */
1393};
1394
1395MODULE_DEVICE_TABLE(input, kbd_ids);
1396
1397static struct input_handler kbd_handler = {
1398 .event = kbd_event,
1399 .connect = kbd_connect,
1400 .disconnect = kbd_disconnect,
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001401 .start = kbd_start,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 .name = "kbd",
1403 .id_table = kbd_ids,
1404};
1405
1406int __init kbd_init(void)
1407{
1408 int i;
Dmitry Torokhov4263cf02006-09-14 01:32:39 -04001409 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410
Dmitry Torokhov2b192902006-07-19 01:13:26 -04001411 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1412 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1413 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1414 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1415 kbd_table[i].lockstate = KBD_DEFLOCK;
1416 kbd_table[i].slockstate = 0;
1417 kbd_table[i].modeflags = KBD_DEFMODE;
Bill Nottingham2e8ecb92007-10-16 23:29:38 -07001418 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
Dmitry Torokhov2b192902006-07-19 01:13:26 -04001419 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Dmitry Torokhov4263cf02006-09-14 01:32:39 -04001421 error = input_register_handler(&kbd_handler);
1422 if (error)
1423 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424
1425 tasklet_enable(&keyboard_tasklet);
1426 tasklet_schedule(&keyboard_tasklet);
1427
1428 return 0;
1429}