blob: 54109dc9240ceb31581f060c8520d5e40c68bbf3 [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
Dmitry Torokhov9272e9a2010-03-21 22:31:26 -070027#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28
Jan Engelhardt759448f2007-07-15 23:40:40 -070029#include <linux/consolemap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/module.h>
31#include <linux/sched.h>
32#include <linux/tty.h>
33#include <linux/tty_flip.h>
34#include <linux/mm.h>
35#include <linux/string.h>
36#include <linux/init.h>
37#include <linux/slab.h>
David Howells7d12e782006-10-05 14:55:46 +010038#include <linux/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40#include <linux/kbd_kern.h>
41#include <linux/kbd_diacr.h>
42#include <linux/vt_kern.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/input.h>
Adrian Bunk83cc5ed2006-06-25 05:47:41 -070044#include <linux/reboot.h>
Samuel Thibault41ab4392007-10-18 23:39:12 -070045#include <linux/notifier.h>
Julia Lawallb39b0442008-04-17 09:28:25 -040046#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Linus Torvalds1da177e2005-04-16 15:20:36 -070048extern void ctrl_alt_del(void);
49
50/*
51 * Exported functions/variables
52 */
53
54#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
55
56/*
57 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
58 * This seems a good reason to start with NumLock off. On HIL keyboards
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050059 * of PARISC machines however there is no NumLock key and everyone expects the keypad
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 * to be used for numbers.
61 */
62
63#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
64#define KBD_DEFLEDS (1 << VC_NUMLOCK)
65#else
66#define KBD_DEFLEDS 0
67#endif
68
69#define KBD_DEFLOCK 0
70
71void compute_shiftstate(void);
72
73/*
74 * Handler Tables.
75 */
76
77#define K_HANDLERS\
78 k_self, k_fn, k_spec, k_pad,\
79 k_dead, k_cons, k_cur, k_shift,\
80 k_meta, k_ascii, k_lock, k_lowercase,\
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -050081 k_slock, k_dead2, k_brl, k_ignore
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -050083typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
David Howells7d12e782006-10-05 14:55:46 +010084 char up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085static k_handler_fn K_HANDLERS;
Dmitry Torokhov97f5f0c2010-03-21 22:31:26 -070086static k_handler_fn *k_handler[16] = { K_HANDLERS };
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];
Samuel Thibaultf7511d52008-04-30 00:54:51 -0700113EXPORT_SYMBOL_GPL(kbd_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114static struct kbd_struct *kbd = kbd_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
Eric W. Biederman81af8d62006-10-02 02:17:13 -0700116struct vt_spawn_console vt_spawn_con = {
Milind Arun Choudharyccc94252007-05-08 00:30:09 -0700117 .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
Eric W. Biederman81af8d62006-10-02 02:17:13 -0700118 .pid = NULL,
119 .sig = 0,
120};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
122/*
123 * Variables exported for vt.c
124 */
125
126int shift_state = 0;
127
128/*
129 * Internal Data.
130 */
131
132static struct input_handler kbd_handler;
Dmitry Torokhov21cea582009-11-29 23:40:58 -0800133static DEFINE_SPINLOCK(kbd_event_lock);
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700134static unsigned long key_down[BITS_TO_LONGS(KEY_CNT)]; /* keyboard key bitmap */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
Dmitry Torokhove0785572010-03-21 22:31:26 -0700136static bool dead_key_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137static int npadch = -1; /* -1 or number assembled on pad */
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500138static unsigned int diacr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139static char rep; /* flag telling character repeat */
140
141static unsigned char ledstate = 0xff; /* undefined */
142static unsigned char ledioctl;
143
144static struct ledptr {
145 unsigned int *addr;
146 unsigned int mask;
147 unsigned char valid:1;
148} ledptrs[3];
149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150/*
Samuel Thibault41ab4392007-10-18 23:39:12 -0700151 * Notifier list for console keyboard events
152 */
153static ATOMIC_NOTIFIER_HEAD(keyboard_notifier_list);
154
155int register_keyboard_notifier(struct notifier_block *nb)
156{
157 return atomic_notifier_chain_register(&keyboard_notifier_list, nb);
158}
159EXPORT_SYMBOL_GPL(register_keyboard_notifier);
160
161int unregister_keyboard_notifier(struct notifier_block *nb)
162{
163 return atomic_notifier_chain_unregister(&keyboard_notifier_list, nb);
164}
165EXPORT_SYMBOL_GPL(unregister_keyboard_notifier);
166
167/*
Marvin Raaijmakersc8e4c772007-03-14 22:50:42 -0400168 * Translation of scancodes to keycodes. We set them on only the first
169 * keyboard in the list that accepts the scancode and keycode.
170 * Explanation for not choosing the first attached keyboard anymore:
171 * USB keyboards for example have two event devices: one for all "normal"
172 * keys and one for extra function keys (like "volume up", "make coffee",
173 * etc.). So this means that scancodes for the extra function keys won't
174 * be valid for the first event device, but will be for the second.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 */
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800176
177struct getset_keycode_data {
178 unsigned int scancode;
179 unsigned int keycode;
180 int error;
181};
182
183static int getkeycode_helper(struct input_handle *handle, void *data)
184{
185 struct getset_keycode_data *d = data;
186
187 d->error = input_get_keycode(handle->dev, d->scancode, &d->keycode);
188
189 return d->error == 0; /* stop as soon as we successfully get one */
190}
191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192int getkeycode(unsigned int scancode)
193{
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800194 struct getset_keycode_data d = { scancode, 0, -ENODEV };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800196 input_handler_for_each_handle(&kbd_handler, &d, getkeycode_helper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800198 return d.error ?: d.keycode;
199}
200
201static int setkeycode_helper(struct input_handle *handle, void *data)
202{
203 struct getset_keycode_data *d = data;
204
205 d->error = input_set_keycode(handle->dev, d->scancode, d->keycode);
206
207 return d->error == 0; /* stop as soon as we successfully set one */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208}
209
210int setkeycode(unsigned int scancode, unsigned int keycode)
211{
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800212 struct getset_keycode_data d = { scancode, keycode, -ENODEV };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800214 input_handler_for_each_handle(&kbd_handler, &d, setkeycode_helper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800216 return d.error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217}
218
219/*
Dmitry Torokhov18f7ad52009-12-15 16:26:53 -0800220 * Making beeps and bells. Note that we prefer beeps to bells, but when
221 * shutting the sound off we do both.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 */
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800223
224static int kd_sound_helper(struct input_handle *handle, void *data)
225{
226 unsigned int *hz = data;
227 struct input_dev *dev = handle->dev;
228
229 if (test_bit(EV_SND, dev->evbit)) {
Dmitry Torokhov18f7ad52009-12-15 16:26:53 -0800230 if (test_bit(SND_TONE, dev->sndbit)) {
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800231 input_inject_event(handle, EV_SND, SND_TONE, *hz);
Dmitry Torokhov18f7ad52009-12-15 16:26:53 -0800232 if (*hz)
233 return 0;
234 }
235 if (test_bit(SND_BELL, dev->sndbit))
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800236 input_inject_event(handle, EV_SND, SND_BELL, *hz ? 1 : 0);
237 }
238
239 return 0;
240}
241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242static void kd_nosound(unsigned long ignored)
243{
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800244 static unsigned int zero;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800246 input_handler_for_each_handle(&kbd_handler, &zero, kd_sound_helper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247}
248
Ingo Molnar8d06afa2005-09-09 13:10:40 -0700249static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
251void kd_mksound(unsigned int hz, unsigned int ticks)
252{
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800253 del_timer_sync(&kd_mksound_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800255 input_handler_for_each_handle(&kbd_handler, &hz, kd_sound_helper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800257 if (hz && ticks)
258 mod_timer(&kd_mksound_timer, jiffies + ticks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259}
Samuel Thibaultf7511d52008-04-30 00:54:51 -0700260EXPORT_SYMBOL(kd_mksound);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261
262/*
263 * Setting the keyboard rate.
264 */
265
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800266static int kbd_rate_helper(struct input_handle *handle, void *data)
267{
268 struct input_dev *dev = handle->dev;
269 struct kbd_repeat *rep = data;
270
271 if (test_bit(EV_REP, dev->evbit)) {
272
273 if (rep[0].delay > 0)
274 input_inject_event(handle,
275 EV_REP, REP_DELAY, rep[0].delay);
276 if (rep[0].period > 0)
277 input_inject_event(handle,
278 EV_REP, REP_PERIOD, rep[0].period);
279
280 rep[1].delay = dev->rep[REP_DELAY];
281 rep[1].period = dev->rep[REP_PERIOD];
282 }
283
284 return 0;
285}
286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287int kbd_rate(struct kbd_repeat *rep)
288{
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800289 struct kbd_repeat data[2] = { *rep };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Dmitry Torokhov66d2a592009-12-01 21:54:35 -0800291 input_handler_for_each_handle(&kbd_handler, data, kbd_rate_helper);
292 *rep = data[1]; /* Copy currently used settings */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 return 0;
295}
296
297/*
298 * Helper Functions.
299 */
300static void put_queue(struct vc_data *vc, int ch)
301{
302 struct tty_struct *tty = vc->vc_tty;
303
304 if (tty) {
305 tty_insert_flip_char(tty, ch, 0);
306 con_schedule_flip(tty);
307 }
308}
309
310static void puts_queue(struct vc_data *vc, char *cp)
311{
312 struct tty_struct *tty = vc->vc_tty;
313
314 if (!tty)
315 return;
316
317 while (*cp) {
318 tty_insert_flip_char(tty, *cp, 0);
319 cp++;
320 }
321 con_schedule_flip(tty);
322}
323
324static void applkey(struct vc_data *vc, int key, char mode)
325{
326 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
327
328 buf[1] = (mode ? 'O' : '[');
329 buf[2] = key;
330 puts_queue(vc, buf);
331}
332
333/*
334 * Many other routines do put_queue, but I think either
335 * they produce ASCII, or they produce some user-assigned
336 * string, and in both cases we might assume that it is
Jan Engelhardt759448f2007-07-15 23:40:40 -0700337 * in utf-8 already.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 */
Jan Engelhardt759448f2007-07-15 23:40:40 -0700339static void to_utf8(struct vc_data *vc, uint c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
341 if (c < 0x80)
342 /* 0******* */
343 put_queue(vc, c);
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500344 else if (c < 0x800) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 /* 110***** 10****** */
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500346 put_queue(vc, 0xc0 | (c >> 6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 put_queue(vc, 0x80 | (c & 0x3f));
Dmitry Torokhove0785572010-03-21 22:31:26 -0700348 } else if (c < 0x10000) {
349 if (c >= 0xD800 && c < 0xE000)
Jan Engelhardt759448f2007-07-15 23:40:40 -0700350 return;
351 if (c == 0xFFFF)
352 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 /* 1110**** 10****** 10****** */
354 put_queue(vc, 0xe0 | (c >> 12));
355 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
356 put_queue(vc, 0x80 | (c & 0x3f));
Dmitry Torokhove0785572010-03-21 22:31:26 -0700357 } else if (c < 0x110000) {
Jan Engelhardt759448f2007-07-15 23:40:40 -0700358 /* 11110*** 10****** 10****** 10****** */
359 put_queue(vc, 0xf0 | (c >> 18));
360 put_queue(vc, 0x80 | ((c >> 12) & 0x3f));
361 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
362 put_queue(vc, 0x80 | (c & 0x3f));
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364}
365
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500366/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 * Called after returning from RAW mode or when changing consoles - recompute
368 * shift_down[] and shift_state from key_down[] maybe called when keymap is
369 * undefined, so that shiftkey release is seen
370 */
371void compute_shiftstate(void)
372{
373 unsigned int i, j, k, sym, val;
374
375 shift_state = 0;
376 memset(shift_down, 0, sizeof(shift_down));
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
379
380 if (!key_down[i])
381 continue;
382
383 k = i * BITS_PER_LONG;
384
385 for (j = 0; j < BITS_PER_LONG; j++, k++) {
386
387 if (!test_bit(k, key_down))
388 continue;
389
390 sym = U(key_maps[0][k]);
391 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
392 continue;
393
394 val = KVAL(sym);
395 if (val == KVAL(K_CAPSSHIFT))
396 val = KVAL(K_SHIFT);
397
398 shift_down[val]++;
399 shift_state |= (1 << val);
400 }
401 }
402}
403
404/*
405 * We have a combining character DIACR here, followed by the character CH.
406 * If the combination occurs in the table, return the corresponding value.
407 * Otherwise, if CH is a space or equals DIACR, return DIACR.
408 * Otherwise, conclude that DIACR was not combining after all,
409 * queue it and return CH.
410 */
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500411static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412{
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500413 unsigned int d = diacr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 unsigned int i;
415
416 diacr = 0;
417
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500418 if ((d & ~0xff) == BRL_UC_ROW) {
419 if ((ch & ~0xff) == BRL_UC_ROW)
420 return d | ch;
421 } else {
422 for (i = 0; i < accent_table_size; i++)
423 if (accent_table[i].diacr == d && accent_table[i].base == ch)
424 return accent_table[i].result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 }
426
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500427 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 return d;
429
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500430 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700431 to_utf8(vc, d);
432 else {
433 int c = conv_uni_to_8bit(d);
434 if (c != -1)
435 put_queue(vc, c);
436 }
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 return ch;
439}
440
441/*
442 * Special function handlers
443 */
David Howells7d12e782006-10-05 14:55:46 +0100444static void fn_enter(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445{
446 if (diacr) {
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500447 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700448 to_utf8(vc, diacr);
449 else {
450 int c = conv_uni_to_8bit(diacr);
451 if (c != -1)
452 put_queue(vc, c);
453 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 diacr = 0;
455 }
Dmitry Torokhove0785572010-03-21 22:31:26 -0700456
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 put_queue(vc, 13);
458 if (vc_kbd_mode(kbd, VC_CRLF))
459 put_queue(vc, 10);
460}
461
David Howells7d12e782006-10-05 14:55:46 +0100462static void fn_caps_toggle(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463{
464 if (rep)
465 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
468}
469
David Howells7d12e782006-10-05 14:55:46 +0100470static void fn_caps_on(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471{
472 if (rep)
473 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700474
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 set_vc_kbd_led(kbd, VC_CAPSLOCK);
476}
477
David Howells7d12e782006-10-05 14:55:46 +0100478static void fn_show_ptregs(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479{
David Howells7d12e782006-10-05 14:55:46 +0100480 struct pt_regs *regs = get_irq_regs();
Dmitry Torokhove0785572010-03-21 22:31:26 -0700481
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 if (regs)
483 show_regs(regs);
484}
485
David Howells7d12e782006-10-05 14:55:46 +0100486static void fn_hold(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487{
488 struct tty_struct *tty = vc->vc_tty;
489
490 if (rep || !tty)
491 return;
492
493 /*
494 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
495 * these routines are also activated by ^S/^Q.
496 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
497 */
498 if (tty->stopped)
499 start_tty(tty);
500 else
501 stop_tty(tty);
502}
503
David Howells7d12e782006-10-05 14:55:46 +0100504static void fn_num(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505{
Dmitry Torokhove0785572010-03-21 22:31:26 -0700506 if (vc_kbd_mode(kbd, VC_APPLIC))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 applkey(vc, 'P', 1);
508 else
David Howells7d12e782006-10-05 14:55:46 +0100509 fn_bare_num(vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510}
511
512/*
513 * Bind this to Shift-NumLock if you work in application keypad mode
514 * but want to be able to change the NumLock flag.
515 * Bind this to NumLock if you prefer that the NumLock key always
516 * changes the NumLock flag.
517 */
David Howells7d12e782006-10-05 14:55:46 +0100518static void fn_bare_num(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519{
520 if (!rep)
521 chg_vc_kbd_led(kbd, VC_NUMLOCK);
522}
523
David Howells7d12e782006-10-05 14:55:46 +0100524static void fn_lastcons(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525{
526 /* switch to the last used console, ChN */
527 set_console(last_console);
528}
529
David Howells7d12e782006-10-05 14:55:46 +0100530static void fn_dec_console(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531{
532 int i, cur = fg_console;
533
534 /* Currently switching? Queue this next switch relative to that. */
535 if (want_console != -1)
536 cur = want_console;
537
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500538 for (i = cur - 1; i != cur; i--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 if (i == -1)
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500540 i = MAX_NR_CONSOLES - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 if (vc_cons_allocated(i))
542 break;
543 }
544 set_console(i);
545}
546
David Howells7d12e782006-10-05 14:55:46 +0100547static void fn_inc_console(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{
549 int i, cur = fg_console;
550
551 /* Currently switching? Queue this next switch relative to that. */
552 if (want_console != -1)
553 cur = want_console;
554
555 for (i = cur+1; i != cur; i++) {
556 if (i == MAX_NR_CONSOLES)
557 i = 0;
558 if (vc_cons_allocated(i))
559 break;
560 }
561 set_console(i);
562}
563
David Howells7d12e782006-10-05 14:55:46 +0100564static void fn_send_intr(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{
566 struct tty_struct *tty = vc->vc_tty;
567
568 if (!tty)
569 return;
570 tty_insert_flip_char(tty, 0, TTY_BREAK);
571 con_schedule_flip(tty);
572}
573
David Howells7d12e782006-10-05 14:55:46 +0100574static void fn_scroll_forw(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575{
576 scrollfront(vc, 0);
577}
578
David Howells7d12e782006-10-05 14:55:46 +0100579static void fn_scroll_back(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580{
581 scrollback(vc, 0);
582}
583
David Howells7d12e782006-10-05 14:55:46 +0100584static void fn_show_mem(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
586 show_mem();
587}
588
David Howells7d12e782006-10-05 14:55:46 +0100589static void fn_show_state(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590{
591 show_state();
592}
593
David Howells7d12e782006-10-05 14:55:46 +0100594static void fn_boot_it(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
596 ctrl_alt_del();
597}
598
David Howells7d12e782006-10-05 14:55:46 +0100599static void fn_compose(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600{
Dmitry Torokhove0785572010-03-21 22:31:26 -0700601 dead_key_next = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602}
603
David Howells7d12e782006-10-05 14:55:46 +0100604static void fn_spawn_con(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605{
Eric W. Biederman81af8d62006-10-02 02:17:13 -0700606 spin_lock(&vt_spawn_con.lock);
607 if (vt_spawn_con.pid)
608 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
609 put_pid(vt_spawn_con.pid);
610 vt_spawn_con.pid = NULL;
611 }
612 spin_unlock(&vt_spawn_con.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613}
614
David Howells7d12e782006-10-05 14:55:46 +0100615static void fn_SAK(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616{
Eric W. Biederman8b6312f2007-02-10 01:44:34 -0800617 struct work_struct *SAK_work = &vc_cons[fg_console].SAK_work;
Eric W. Biederman8b6312f2007-02-10 01:44:34 -0800618 schedule_work(SAK_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619}
620
David Howells7d12e782006-10-05 14:55:46 +0100621static void fn_null(struct vc_data *vc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622{
623 compute_shiftstate();
624}
625
626/*
627 * Special key handlers
628 */
David Howells7d12e782006-10-05 14:55:46 +0100629static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630{
631}
632
David Howells7d12e782006-10-05 14:55:46 +0100633static void k_spec(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634{
635 if (up_flag)
636 return;
637 if (value >= ARRAY_SIZE(fn_handler))
638 return;
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -0500639 if ((kbd->kbdmode == VC_RAW ||
640 kbd->kbdmode == VC_MEDIUMRAW) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 value != KVAL(K_SAK))
642 return; /* SAK is allowed even in raw mode */
David Howells7d12e782006-10-05 14:55:46 +0100643 fn_handler[value](vc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644}
645
David Howells7d12e782006-10-05 14:55:46 +0100646static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647{
Dmitry Torokhov9272e9a2010-03-21 22:31:26 -0700648 pr_err("k_lowercase was called - impossible\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649}
650
David Howells7d12e782006-10-05 14:55:46 +0100651static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652{
653 if (up_flag)
654 return; /* no action, if this is a key release */
655
656 if (diacr)
657 value = handle_diacr(vc, value);
658
659 if (dead_key_next) {
Dmitry Torokhove0785572010-03-21 22:31:26 -0700660 dead_key_next = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 diacr = value;
662 return;
663 }
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500664 if (kbd->kbdmode == VC_UNICODE)
Samuel Thibault04c71972007-10-16 23:27:04 -0700665 to_utf8(vc, value);
666 else {
667 int c = conv_uni_to_8bit(value);
668 if (c != -1)
669 put_queue(vc, c);
670 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671}
672
673/*
674 * Handle dead key. Note that we now may have several
675 * dead keys modifying the same character. Very useful
676 * for Vietnamese.
677 */
David Howells7d12e782006-10-05 14:55:46 +0100678static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679{
680 if (up_flag)
681 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700682
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 diacr = (diacr ? handle_diacr(vc, value) : value);
684}
685
David Howells7d12e782006-10-05 14:55:46 +0100686static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500687{
Jiri Bohacd2187eb2008-06-12 15:21:51 -0700688 k_unicode(vc, conv_8bit_to_uni(value), up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500689}
690
David Howells7d12e782006-10-05 14:55:46 +0100691static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500692{
David Howells7d12e782006-10-05 14:55:46 +0100693 k_deadunicode(vc, value, up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500694}
695
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696/*
697 * Obsolete - for backwards compatibility only
698 */
David Howells7d12e782006-10-05 14:55:46 +0100699static void k_dead(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
Andreas Mohr0f5e5602006-06-05 00:18:00 -0400701 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
Dmitry Torokhove0785572010-03-21 22:31:26 -0700702
703 k_deadunicode(vc, ret_diacr[value], up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704}
705
David Howells7d12e782006-10-05 14:55:46 +0100706static void k_cons(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
708 if (up_flag)
709 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700710
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 set_console(value);
712}
713
David Howells7d12e782006-10-05 14:55:46 +0100714static void k_fn(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 if (up_flag)
717 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700718
719 if ((unsigned)value < ARRAY_SIZE(func_table)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 if (func_table[value])
721 puts_queue(vc, func_table[value]);
722 } else
Dmitry Torokhov9272e9a2010-03-21 22:31:26 -0700723 pr_err("k_fn called with value=%d\n", value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724}
725
David Howells7d12e782006-10-05 14:55:46 +0100726static void k_cur(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727{
Brandon Philipse52b29c2006-11-04 22:09:08 -0500728 static const char cur_chars[] = "BDCA";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
730 if (up_flag)
731 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
734}
735
David Howells7d12e782006-10-05 14:55:46 +0100736static void k_pad(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{
Andreas Mohr0f5e5602006-06-05 00:18:00 -0400738 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
739 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
741 if (up_flag)
742 return; /* no action, if this is a key release */
743
744 /* kludge... shift forces cursor/number keys */
745 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
746 applkey(vc, app_map[value], 1);
747 return;
748 }
749
Dmitry Torokhove0785572010-03-21 22:31:26 -0700750 if (!vc_kbd_led(kbd, VC_NUMLOCK)) {
751
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 switch (value) {
Dmitry Torokhove0785572010-03-21 22:31:26 -0700753 case KVAL(K_PCOMMA):
754 case KVAL(K_PDOT):
755 k_fn(vc, KVAL(K_REMOVE), 0);
756 return;
757 case KVAL(K_P0):
758 k_fn(vc, KVAL(K_INSERT), 0);
759 return;
760 case KVAL(K_P1):
761 k_fn(vc, KVAL(K_SELECT), 0);
762 return;
763 case KVAL(K_P2):
764 k_cur(vc, KVAL(K_DOWN), 0);
765 return;
766 case KVAL(K_P3):
767 k_fn(vc, KVAL(K_PGDN), 0);
768 return;
769 case KVAL(K_P4):
770 k_cur(vc, KVAL(K_LEFT), 0);
771 return;
772 case KVAL(K_P6):
773 k_cur(vc, KVAL(K_RIGHT), 0);
774 return;
775 case KVAL(K_P7):
776 k_fn(vc, KVAL(K_FIND), 0);
777 return;
778 case KVAL(K_P8):
779 k_cur(vc, KVAL(K_UP), 0);
780 return;
781 case KVAL(K_P9):
782 k_fn(vc, KVAL(K_PGUP), 0);
783 return;
784 case KVAL(K_P5):
785 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
786 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 }
Dmitry Torokhove0785572010-03-21 22:31:26 -0700788 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
790 put_queue(vc, pad_chars[value]);
791 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
792 put_queue(vc, 10);
793}
794
David Howells7d12e782006-10-05 14:55:46 +0100795static void k_shift(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796{
797 int old_state = shift_state;
798
799 if (rep)
800 return;
801 /*
802 * Mimic typewriter:
803 * a CapsShift key acts like Shift but undoes CapsLock
804 */
805 if (value == KVAL(K_CAPSSHIFT)) {
806 value = KVAL(K_SHIFT);
807 if (!up_flag)
808 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
809 }
810
811 if (up_flag) {
812 /*
813 * handle the case that two shift or control
814 * keys are depressed simultaneously
815 */
816 if (shift_down[value])
817 shift_down[value]--;
818 } else
819 shift_down[value]++;
820
821 if (shift_down[value])
822 shift_state |= (1 << value);
823 else
824 shift_state &= ~(1 << value);
825
826 /* kludge */
827 if (up_flag && shift_state != old_state && npadch != -1) {
828 if (kbd->kbdmode == VC_UNICODE)
Jan Engelhardt759448f2007-07-15 23:40:40 -0700829 to_utf8(vc, npadch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 else
831 put_queue(vc, npadch & 0xff);
832 npadch = -1;
833 }
834}
835
David Howells7d12e782006-10-05 14:55:46 +0100836static void k_meta(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837{
838 if (up_flag)
839 return;
840
841 if (vc_kbd_mode(kbd, VC_META)) {
842 put_queue(vc, '\033');
843 put_queue(vc, value);
844 } else
845 put_queue(vc, value | 0x80);
846}
847
David Howells7d12e782006-10-05 14:55:46 +0100848static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849{
850 int base;
851
852 if (up_flag)
853 return;
854
855 if (value < 10) {
856 /* decimal input of code, while Alt depressed */
857 base = 10;
858 } else {
859 /* hexadecimal input of code, while AltGr depressed */
860 value -= 10;
861 base = 16;
862 }
863
864 if (npadch == -1)
865 npadch = value;
866 else
867 npadch = npadch * base + value;
868}
869
David Howells7d12e782006-10-05 14:55:46 +0100870static void k_lock(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871{
872 if (up_flag || rep)
873 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700874
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 chg_vc_kbd_lock(kbd, value);
876}
877
David Howells7d12e782006-10-05 14:55:46 +0100878static void k_slock(struct vc_data *vc, unsigned char value, char up_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879{
David Howells7d12e782006-10-05 14:55:46 +0100880 k_shift(vc, value, up_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 if (up_flag || rep)
882 return;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700883
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 chg_vc_kbd_slock(kbd, value);
885 /* try to make Alt, oops, AltGr and such work */
886 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
887 kbd->slockstate = 0;
888 chg_vc_kbd_slock(kbd, value);
889 }
890}
891
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500892/* by default, 300ms interval for combination release */
Samuel Thibault77426d72006-04-26 00:14:10 -0400893static unsigned brl_timeout = 300;
894MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
895module_param(brl_timeout, uint, 0644);
896
897static unsigned brl_nbchords = 1;
898MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
899module_param(brl_nbchords, uint, 0644);
900
David Howells7d12e782006-10-05 14:55:46 +0100901static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag)
Samuel Thibault77426d72006-04-26 00:14:10 -0400902{
903 static unsigned long chords;
904 static unsigned committed;
905
906 if (!brl_nbchords)
David Howells7d12e782006-10-05 14:55:46 +0100907 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag);
Samuel Thibault77426d72006-04-26 00:14:10 -0400908 else {
909 committed |= pattern;
910 chords++;
911 if (chords == brl_nbchords) {
David Howells7d12e782006-10-05 14:55:46 +0100912 k_unicode(vc, BRL_UC_ROW | committed, up_flag);
Samuel Thibault77426d72006-04-26 00:14:10 -0400913 chords = 0;
914 committed = 0;
915 }
916 }
917}
918
David Howells7d12e782006-10-05 14:55:46 +0100919static void k_brl(struct vc_data *vc, unsigned char value, char up_flag)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500920{
Dmitry Torokhove0785572010-03-21 22:31:26 -0700921 static unsigned pressed, committing;
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500922 static unsigned long releasestart;
923
924 if (kbd->kbdmode != VC_UNICODE) {
925 if (!up_flag)
Dmitry Torokhov9272e9a2010-03-21 22:31:26 -0700926 pr_warning("keyboard mode must be unicode for braille patterns\n");
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500927 return;
928 }
929
930 if (!value) {
David Howells7d12e782006-10-05 14:55:46 +0100931 k_unicode(vc, BRL_UC_ROW, up_flag);
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500932 return;
933 }
934
935 if (value > 8)
936 return;
937
Dmitry Torokhove0785572010-03-21 22:31:26 -0700938 if (!up_flag) {
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500939 pressed |= 1 << (value - 1);
940 if (!brl_timeout)
941 committing = pressed;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700942 } else if (brl_timeout) {
943 if (!committing ||
944 time_after(jiffies,
945 releasestart + msecs_to_jiffies(brl_timeout))) {
946 committing = pressed;
947 releasestart = jiffies;
948 }
949 pressed &= ~(1 << (value - 1));
950 if (!pressed && committing) {
951 k_brlcommit(vc, committing, 0);
952 committing = 0;
953 }
954 } else {
955 if (committing) {
956 k_brlcommit(vc, committing, 0);
957 committing = 0;
958 }
959 pressed &= ~(1 << (value - 1));
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -0500960 }
961}
962
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963/*
964 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
965 * or (ii) whatever pattern of lights people want to show using KDSETLED,
966 * or (iii) specified bits of specified words in kernel memory.
967 */
968unsigned char getledstate(void)
969{
970 return ledstate;
971}
972
973void setledstate(struct kbd_struct *kbd, unsigned int led)
974{
975 if (!(led & ~7)) {
976 ledioctl = led;
977 kbd->ledmode = LED_SHOW_IOCTL;
978 } else
979 kbd->ledmode = LED_SHOW_FLAGS;
Dmitry Torokhove0785572010-03-21 22:31:26 -0700980
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 set_leds();
982}
983
984static inline unsigned char getleds(void)
985{
986 struct kbd_struct *kbd = kbd_table + fg_console;
987 unsigned char leds;
988 int i;
989
990 if (kbd->ledmode == LED_SHOW_IOCTL)
991 return ledioctl;
992
993 leds = kbd->ledflagstate;
994
995 if (kbd->ledmode == LED_SHOW_MEM) {
996 for (i = 0; i < 3; i++)
997 if (ledptrs[i].valid) {
998 if (*ledptrs[i].addr & ledptrs[i].mask)
999 leds |= (1 << i);
1000 else
1001 leds &= ~(1 << i);
1002 }
1003 }
1004 return leds;
1005}
1006
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08001007static int kbd_update_leds_helper(struct input_handle *handle, void *data)
1008{
1009 unsigned char leds = *(unsigned char *)data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08001011 if (test_bit(EV_LED, handle->dev->evbit)) {
1012 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1013 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1014 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1015 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1016 }
1017
1018 return 0;
1019}
1020
1021/*
1022 * This is the tasklet that updates LED state on all keyboards
1023 * attached to the box. The reason we use tasklet is that we
1024 * need to handle the scenario when keyboard handler is not
1025 * registered yet but we already getting updates form VT to
1026 * update led state.
1027 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028static void kbd_bh(unsigned long dummy)
1029{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 unsigned char leds = getleds();
1031
1032 if (leds != ledstate) {
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08001033 input_handler_for_each_handle(&kbd_handler, &leds,
1034 kbd_update_leds_helper);
1035 ledstate = leds;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037}
1038
1039DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1040
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001042 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1043 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
Hans-Christian Egtvedt3a4e8322007-12-04 13:15:41 +01001044 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
1045 defined(CONFIG_AVR32)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046
1047#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1048 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1049
Andreas Mohr0f5e5602006-06-05 00:18:00 -04001050static const unsigned short x86_keycodes[256] =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1052 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1053 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1054 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1055 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1056 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001057 284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1059 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
Hans de Goede72a42f22007-07-03 01:55:18 -04001060 103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1061 291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1063 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1064 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1065 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1066
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001067#ifdef CONFIG_SPARC
Dmitry Torokhove0785572010-03-21 22:31:26 -07001068static int sparc_l1_a_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069extern void sun_do_break(void);
1070#endif
1071
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001072static int emulate_raw(struct vc_data *vc, unsigned int keycode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 unsigned char up_flag)
1074{
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001075 int code;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
1077 switch (keycode) {
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001078
Dmitry Torokhove0785572010-03-21 22:31:26 -07001079 case KEY_PAUSE:
1080 put_queue(vc, 0xe1);
1081 put_queue(vc, 0x1d | up_flag);
1082 put_queue(vc, 0x45 | up_flag);
1083 break;
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001084
Dmitry Torokhove0785572010-03-21 22:31:26 -07001085 case KEY_HANGEUL:
1086 if (!up_flag)
1087 put_queue(vc, 0xf2);
1088 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
Dmitry Torokhove0785572010-03-21 22:31:26 -07001090 case KEY_HANJA:
1091 if (!up_flag)
1092 put_queue(vc, 0xf1);
1093 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094
Dmitry Torokhove0785572010-03-21 22:31:26 -07001095 case KEY_SYSRQ:
1096 /*
1097 * Real AT keyboards (that's what we're trying
1098 * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1099 * pressing PrtSc/SysRq alone, but simply 0x54
1100 * when pressing Alt+PrtSc/SysRq.
1101 */
1102 if (test_bit(KEY_LEFTALT, key_down) ||
1103 test_bit(KEY_RIGHTALT, key_down)) {
1104 put_queue(vc, 0x54 | up_flag);
1105 } else {
1106 put_queue(vc, 0xe0);
1107 put_queue(vc, 0x2a | up_flag);
1108 put_queue(vc, 0xe0);
1109 put_queue(vc, 0x37 | up_flag);
1110 }
1111 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
Dmitry Torokhove0785572010-03-21 22:31:26 -07001113 default:
1114 if (keycode > 255)
1115 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
Dmitry Torokhove0785572010-03-21 22:31:26 -07001117 code = x86_keycodes[keycode];
1118 if (!code)
1119 return -1;
Dmitry Torokhov896cdc72006-07-19 01:14:25 -04001120
Dmitry Torokhove0785572010-03-21 22:31:26 -07001121 if (code & 0x100)
1122 put_queue(vc, 0xe0);
1123 put_queue(vc, (code & 0x7f) | up_flag);
1124
1125 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 }
1127
1128 return 0;
1129}
1130
1131#else
1132
1133#define HW_RAW(dev) 0
1134
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1136{
1137 if (keycode > 127)
1138 return -1;
1139
1140 put_queue(vc, keycode | up_flag);
1141 return 0;
1142}
1143#endif
1144
1145static void kbd_rawcode(unsigned char data)
1146{
1147 struct vc_data *vc = vc_cons[fg_console].d;
Dmitry Torokhove0785572010-03-21 22:31:26 -07001148
Alan Jenkins0c09b2a2009-11-18 00:40:48 -08001149 kbd = kbd_table + vc->vc_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 if (kbd->kbdmode == VC_RAW)
1151 put_queue(vc, data);
1152}
1153
David Howells7d12e782006-10-05 14:55:46 +01001154static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155{
1156 struct vc_data *vc = vc_cons[fg_console].d;
1157 unsigned short keysym, *key_map;
Dmitry Torokhove0785572010-03-21 22:31:26 -07001158 unsigned char type;
1159 bool raw_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 struct tty_struct *tty;
1161 int shift_final;
Samuel Thibault41ab4392007-10-18 23:39:12 -07001162 struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
Dmitry Torokhove0785572010-03-21 22:31:26 -07001163 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
1165 tty = vc->vc_tty;
1166
1167 if (tty && (!tty->driver_data)) {
1168 /* No driver data? Strange. Okay we fix it then. */
1169 tty->driver_data = vc;
1170 }
1171
Alan Jenkins0c09b2a2009-11-18 00:40:48 -08001172 kbd = kbd_table + vc->vc_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001174#ifdef CONFIG_SPARC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 if (keycode == KEY_STOP)
1176 sparc_l1_a_state = down;
1177#endif
1178
1179 rep = (down == 2);
1180
Dmitry Torokhove0785572010-03-21 22:31:26 -07001181 raw_mode = (kbd->kbdmode == VC_RAW);
1182 if (raw_mode && !hw_raw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 if (emulate_raw(vc, keycode, !down << 7))
Dmitry Torokhov9e35d202007-04-12 01:30:52 -04001184 if (keycode < BTN_MISC && printk_ratelimit())
Dmitry Torokhov9272e9a2010-03-21 22:31:26 -07001185 pr_warning("can't emulate rawmode for keycode %d\n",
1186 keycode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187
Adrian Bunk0b57ee92005-12-22 21:03:47 -08001188#ifdef CONFIG_SPARC
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 if (keycode == KEY_A && sparc_l1_a_state) {
Dmitry Torokhove0785572010-03-21 22:31:26 -07001190 sparc_l1_a_state = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 sun_do_break();
1192 }
1193#endif
1194
1195 if (kbd->kbdmode == VC_MEDIUMRAW) {
1196 /*
1197 * This is extended medium raw mode, with keys above 127
1198 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1199 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1200 * interfere with anything else. The two bytes after 0 will
1201 * always have the up flag set not to interfere with older
1202 * applications. This allows for 16384 different keycodes,
1203 * which should be enough.
1204 */
1205 if (keycode < 128) {
1206 put_queue(vc, keycode | (!down << 7));
1207 } else {
1208 put_queue(vc, !down << 7);
1209 put_queue(vc, (keycode >> 7) | 0x80);
1210 put_queue(vc, keycode | 0x80);
1211 }
Dmitry Torokhove0785572010-03-21 22:31:26 -07001212 raw_mode = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 }
1214
1215 if (down)
1216 set_bit(keycode, key_down);
1217 else
1218 clear_bit(keycode, key_down);
1219
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001220 if (rep &&
1221 (!vc_kbd_mode(kbd, VC_REPEAT) ||
Alan Coxf34d7a52008-04-30 00:54:13 -07001222 (tty && !L_ECHO(tty) && tty_chars_in_buffer(tty)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 /*
1224 * Don't repeat a key if the input buffers are not empty and the
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001225 * characters get aren't echoed locally. This makes key repeat
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 * usable with slow applications and under heavy loads.
1227 */
1228 return;
1229 }
1230
Samuel Thibault41ab4392007-10-18 23:39:12 -07001231 param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
Karl Dahlke0beb4f62008-04-15 01:30:32 -04001232 param.ledstate = kbd->ledflagstate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 key_map = key_maps[shift_final];
1234
Dmitry Torokhove0785572010-03-21 22:31:26 -07001235 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1236 KBD_KEYCODE, &param);
1237 if (rc == NOTIFY_STOP || !key_map) {
1238 atomic_notifier_call_chain(&keyboard_notifier_list,
1239 KBD_UNBOUND_KEYCODE, &param);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 compute_shiftstate();
1241 kbd->slockstate = 0;
1242 return;
1243 }
1244
Dmitry Torokhove0785572010-03-21 22:31:26 -07001245 if (keycode < NR_KEYS)
Samuel Thibaultb9ec4e12006-04-02 00:10:28 -05001246 keysym = key_map[keycode];
Dmitry Torokhove0785572010-03-21 22:31:26 -07001247 else if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1248 keysym = U(K(KT_BRL, keycode - KEY_BRL_DOT1 + 1));
1249 else
1250 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 type = KTYP(keysym);
1253
1254 if (type < 0xf0) {
Samuel Thibault41ab4392007-10-18 23:39:12 -07001255 param.value = keysym;
Dmitry Torokhove0785572010-03-21 22:31:26 -07001256 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1257 KBD_UNICODE, &param);
1258 if (rc != NOTIFY_STOP)
1259 if (down && !raw_mode)
1260 to_utf8(vc, keysym);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 return;
1262 }
1263
1264 type -= 0xf0;
1265
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 if (type == KT_LETTER) {
1267 type = KT_LATIN;
1268 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1269 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1270 if (key_map)
1271 keysym = key_map[keycode];
1272 }
1273 }
Samuel Thibault41ab4392007-10-18 23:39:12 -07001274
Dmitry Torokhove0785572010-03-21 22:31:26 -07001275 param.value = keysym;
1276 rc = atomic_notifier_call_chain(&keyboard_notifier_list,
1277 KBD_KEYSYM, &param);
1278 if (rc == NOTIFY_STOP)
Samuel Thibault41ab4392007-10-18 23:39:12 -07001279 return;
1280
1281 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1282 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
David Howells7d12e782006-10-05 14:55:46 +01001284 (*k_handler[type])(vc, keysym & 0xff, !down);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
Karl Dahlke0beb4f62008-04-15 01:30:32 -04001286 param.ledstate = kbd->ledflagstate;
Samuel Thibault41ab4392007-10-18 23:39:12 -07001287 atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1288
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 if (type != KT_SLOCK)
1290 kbd->slockstate = 0;
1291}
1292
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001293static void kbd_event(struct input_handle *handle, unsigned int event_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 unsigned int event_code, int value)
1295{
Dmitry Torokhov21cea582009-11-29 23:40:58 -08001296 /* We are called with interrupts disabled, just take the lock */
1297 spin_lock(&kbd_event_lock);
1298
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1300 kbd_rawcode(value);
1301 if (event_type == EV_KEY)
David Howells7d12e782006-10-05 14:55:46 +01001302 kbd_keycode(event_code, value, HW_RAW(handle->dev));
Dmitry Torokhov21cea582009-11-29 23:40:58 -08001303
1304 spin_unlock(&kbd_event_lock);
1305
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 tasklet_schedule(&keyboard_tasklet);
1307 do_poke_blanked_console = 1;
1308 schedule_console_callback();
1309}
1310
Dmitry Torokhov0b7024ac2010-02-02 21:08:26 -08001311static bool kbd_match(struct input_handler *handler, struct input_dev *dev)
1312{
1313 int i;
1314
1315 if (test_bit(EV_SND, dev->evbit))
1316 return true;
1317
1318 if (test_bit(EV_KEY, dev->evbit))
1319 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1320 if (test_bit(i, dev->keybit))
1321 return true;
1322
1323 return false;
1324}
1325
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326/*
1327 * When a keyboard (or other input device) is found, the kbd_connect
1328 * function is called. The function then looks at the device, and if it
1329 * likes it, it can open it and get events from it. In this (kbd_connect)
1330 * function, we should decide which VT to bind that keyboard to initially.
1331 */
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001332static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1333 const struct input_device_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334{
1335 struct input_handle *handle;
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001336 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337
Dmitry Torokhov22479e12006-08-04 22:51:51 -04001338 handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1339 if (!handle)
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001340 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
1342 handle->dev = dev;
1343 handle->handler = handler;
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001344 handle->name = "kbd";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001346 error = input_register_handle(handle);
1347 if (error)
1348 goto err_free_handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001350 error = input_open_device(handle);
1351 if (error)
1352 goto err_unregister_handle;
1353
1354 return 0;
1355
1356 err_unregister_handle:
1357 input_unregister_handle(handle);
1358 err_free_handle:
1359 kfree(handle);
1360 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361}
1362
1363static void kbd_disconnect(struct input_handle *handle)
1364{
1365 input_close_device(handle);
Dmitry Torokhov5b2a0822007-04-12 01:29:46 -04001366 input_unregister_handle(handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 kfree(handle);
1368}
1369
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001370/*
1371 * Start keyboard handler on the new keyboard by refreshing LED state to
1372 * match the rest of the system.
1373 */
1374static void kbd_start(struct input_handle *handle)
1375{
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001376 tasklet_disable(&keyboard_tasklet);
Dmitry Torokhov66d2a592009-12-01 21:54:35 -08001377
1378 if (ledstate != 0xff)
1379 kbd_update_leds_helper(handle, &ledstate);
1380
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001381 tasklet_enable(&keyboard_tasklet);
1382}
1383
Dmitry Torokhov66e66112006-09-14 01:31:59 -04001384static const struct input_device_id kbd_ids[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 {
1386 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
Jiri Slaby7b19ada2007-10-18 23:40:32 -07001387 .evbit = { BIT_MASK(EV_KEY) },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 },
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001389
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 {
1391 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
Jiri Slaby7b19ada2007-10-18 23:40:32 -07001392 .evbit = { BIT_MASK(EV_SND) },
Dmitry Torokhovfe1e8602005-09-10 12:03:38 -05001393 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394
1395 { }, /* Terminating entry */
1396};
1397
1398MODULE_DEVICE_TABLE(input, kbd_ids);
1399
1400static struct input_handler kbd_handler = {
1401 .event = kbd_event,
Dmitry Torokhov0b7024ac2010-02-02 21:08:26 -08001402 .match = kbd_match,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 .connect = kbd_connect,
1404 .disconnect = kbd_disconnect,
Dmitry Torokhovc7e8dc62006-07-06 00:21:03 -04001405 .start = kbd_start,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 .name = "kbd",
1407 .id_table = kbd_ids,
1408};
1409
1410int __init kbd_init(void)
1411{
1412 int i;
Dmitry Torokhov4263cf02006-09-14 01:32:39 -04001413 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
Dmitry Torokhov2b192902006-07-19 01:13:26 -04001415 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1416 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1417 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1418 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1419 kbd_table[i].lockstate = KBD_DEFLOCK;
1420 kbd_table[i].slockstate = 0;
1421 kbd_table[i].modeflags = KBD_DEFMODE;
Bill Nottingham2e8ecb92007-10-16 23:29:38 -07001422 kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
Dmitry Torokhov2b192902006-07-19 01:13:26 -04001423 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424
Dmitry Torokhov4263cf02006-09-14 01:32:39 -04001425 error = input_register_handler(&kbd_handler);
1426 if (error)
1427 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428
1429 tasklet_enable(&keyboard_tasklet);
1430 tasklet_schedule(&keyboard_tasklet);
1431
1432 return 0;
1433}