projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Input: remove accept method from input_dev
[linux-2.6-block.git] / drivers / char / keyboard.c
CommitLineData
1da177e4
LT		 1/*
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)
fe1e8604 17 *
1da177e4
LT		 18 * Modified to provide 'generic' keyboard support by Hamish Macdonald
19 * Merge with the m68k keyboard driver and split-off of the PC low-level
20 * parts by Geert Uytterhoeven, May 1997
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
1da177e4
LT		 27#include <linux/module.h>
28#include <linux/sched.h>
29#include <linux/tty.h>
30#include <linux/tty_flip.h>
31#include <linux/mm.h>
32#include <linux/string.h>
33#include <linux/init.h>
34#include <linux/slab.h>
35
36#include <linux/kbd_kern.h>
37#include <linux/kbd_diacr.h>
38#include <linux/vt_kern.h>
39#include <linux/sysrq.h>
40#include <linux/input.h>
83cc5ed3 41#include <linux/reboot.h>
1da177e4
LT		 42
43static void kbd_disconnect(struct input_handle *handle);
44extern void ctrl_alt_del(void);
45
46/*
47 * Exported functions/variables
48 */
49
50#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
51
52/*
53 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
54 * This seems a good reason to start with NumLock off. On HIL keyboards
fe1e8604 55 * of PARISC machines however there is no NumLock key and everyone expects the keypad
1da177e4
LT		 56 * to be used for numbers.
57 */
58
59#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
60#define KBD_DEFLEDS (1 << VC_NUMLOCK)
61#else
62#define KBD_DEFLEDS 0
63#endif
64
65#define KBD_DEFLOCK 0
66
67void compute_shiftstate(void);
68
69/*
70 * Handler Tables.
71 */
72
73#define K_HANDLERS\
74 k_self, k_fn, k_spec, k_pad,\
75 k_dead, k_cons, k_cur, k_shift,\
76 k_meta, k_ascii, k_lock, k_lowercase,\
b9ec4e10 77 k_slock, k_dead2, k_brl, k_ignore
1da177e4 78
fe1e8604 79typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
1da177e4
LT		 80 char up_flag, struct pt_regs *regs);
81static k_handler_fn K_HANDLERS;
82static k_handler_fn *k_handler[16] = { K_HANDLERS };
83
84#define FN_HANDLERS\
fe1e8604
DT		 85 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
86 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
87 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
88 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
89 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
1da177e4
LT		 90
91typedef void (fn_handler_fn)(struct vc_data *vc, struct pt_regs *regs);
92static fn_handler_fn FN_HANDLERS;
93static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
94
95/*
96 * Variables exported for vt_ioctl.c
97 */
98
99/* maximum values each key_handler can handle */
100const int max_vals[] = {
101 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
102 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
b9ec4e10 103 255, NR_LOCK - 1, 255, NR_BRL - 1
1da177e4
LT		 104};
105
106const int NR_TYPES = ARRAY_SIZE(max_vals);
107
108struct kbd_struct kbd_table[MAX_NR_CONSOLES];
109static struct kbd_struct *kbd = kbd_table;
110static struct kbd_struct kbd0;
111
112int spawnpid, spawnsig;
113
114/*
115 * Variables exported for vt.c
116 */
117
118int shift_state = 0;
119
120/*
121 * Internal Data.
122 */
123
124static struct input_handler kbd_handler;
125static unsigned long key_down[NBITS(KEY_MAX)]; /* keyboard key bitmap */
126static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
127static int dead_key_next;
128static int npadch = -1; /* -1 or number assembled on pad */
b9ec4e10 129static unsigned int diacr;
1da177e4
LT		 130static char rep; /* flag telling character repeat */
131
132static unsigned char ledstate = 0xff; /* undefined */
133static unsigned char ledioctl;
134
135static struct ledptr {
136 unsigned int *addr;
137 unsigned int mask;
138 unsigned char valid:1;
139} ledptrs[3];
140
141/* Simple translation table for the SysRq keys */
142
143#ifdef CONFIG_MAGIC_SYSRQ
144unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
145 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
146 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
147 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
148 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
149 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
150 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
151 "\r\000/"; /* 0x60 - 0x6f */
152static int sysrq_down;
d2be8ee5 153static int sysrq_alt_use;
1da177e4
LT		 154#endif
155static int sysrq_alt;
156
157/*
158 * Translation of scancodes to keycodes. We set them on only the first attached
159 * keyboard - for per-keyboard setting, /dev/input/event is more useful.
160 */
161int getkeycode(unsigned int scancode)
162{
fe1e8604 163 struct list_head *node;
1da177e4
LT		 164 struct input_dev *dev = NULL;
165
fe1e8604
DT		 166 list_for_each(node, &kbd_handler.h_list) {
167 struct input_handle *handle = to_handle_h(node);
168 if (handle->dev->keycodesize) {
169 dev = handle->dev;
1da177e4
LT		 170 break;
171 }
172 }
173
174 if (!dev)
175 return -ENODEV;
176
177 if (scancode >= dev->keycodemax)
178 return -EINVAL;
179
180 return INPUT_KEYCODE(dev, scancode);
181}
182
183int setkeycode(unsigned int scancode, unsigned int keycode)
184{
fe1e8604 185 struct list_head *node;
1da177e4
LT		 186 struct input_dev *dev = NULL;
187 unsigned int i, oldkey;
188
fe1e8604 189 list_for_each(node, &kbd_handler.h_list) {
1da177e4 190 struct input_handle *handle = to_handle_h(node);
fe1e8604
DT		 191 if (handle->dev->keycodesize) {
192 dev = handle->dev;
193 break;
1da177e4
LT		 194 }
195 }
196
197 if (!dev)
198 return -ENODEV;
199
200 if (scancode >= dev->keycodemax)
201 return -EINVAL;
1da177e4
LT		 202 if (keycode < 0 || keycode > KEY_MAX)
203 return -EINVAL;
4cee9956 204 if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
5ac7ba3f 205 return -EINVAL;
1da177e4
LT		 206
207 oldkey = SET_INPUT_KEYCODE(dev, scancode, keycode);
208
209 clear_bit(oldkey, dev->keybit);
210 set_bit(keycode, dev->keybit);
211
212 for (i = 0; i < dev->keycodemax; i++)
213 if (INPUT_KEYCODE(dev,i) == oldkey)
214 set_bit(oldkey, dev->keybit);
215
216 return 0;
217}
218
219/*
fe1e8604 220 * Making beeps and bells.
1da177e4
LT		 221 */
222static void kd_nosound(unsigned long ignored)
223{
fe1e8604 224 struct list_head *node;
1da177e4
LT		 225
226 list_for_each(node,&kbd_handler.h_list) {
227 struct input_handle *handle = to_handle_h(node);
228 if (test_bit(EV_SND, handle->dev->evbit)) {
229 if (test_bit(SND_TONE, handle->dev->sndbit))
230 input_event(handle->dev, EV_SND, SND_TONE, 0);
231 if (test_bit(SND_BELL, handle->dev->sndbit))
232 input_event(handle->dev, EV_SND, SND_BELL, 0);
233 }
234 }
235}
236
8d06afab 237static DEFINE_TIMER(kd_mksound_timer, kd_nosound, 0, 0);
1da177e4
LT		 238
239void kd_mksound(unsigned int hz, unsigned int ticks)
240{
fe1e8604 241 struct list_head *node;
1da177e4
LT		 242
243 del_timer(&kd_mksound_timer);
244
245 if (hz) {
fe1e8604 246 list_for_each_prev(node, &kbd_handler.h_list) {
1da177e4
LT		 247 struct input_handle *handle = to_handle_h(node);
248 if (test_bit(EV_SND, handle->dev->evbit)) {
249 if (test_bit(SND_TONE, handle->dev->sndbit)) {
250 input_event(handle->dev, EV_SND, SND_TONE, hz);
251 break;
252 }
253 if (test_bit(SND_BELL, handle->dev->sndbit)) {
254 input_event(handle->dev, EV_SND, SND_BELL, 1);
255 break;
256 }
257 }
258 }
259 if (ticks)
260 mod_timer(&kd_mksound_timer, jiffies + ticks);
261 } else
262 kd_nosound(0);
263}
264
265/*
266 * Setting the keyboard rate.
267 */
268
269int kbd_rate(struct kbd_repeat *rep)
270{
271 struct list_head *node;
272 unsigned int d = 0;
273 unsigned int p = 0;
274
275 list_for_each(node,&kbd_handler.h_list) {
276 struct input_handle *handle = to_handle_h(node);
277 struct input_dev *dev = handle->dev;
278
279 if (test_bit(EV_REP, dev->evbit)) {
280 if (rep->delay > 0)
281 input_event(dev, EV_REP, REP_DELAY, rep->delay);
282 if (rep->period > 0)
283 input_event(dev, EV_REP, REP_PERIOD, rep->period);
284 d = dev->rep[REP_DELAY];
285 p = dev->rep[REP_PERIOD];
286 }
287 }
288 rep->delay = d;
289 rep->period = p;
290 return 0;
291}
292
293/*
294 * Helper Functions.
295 */
296static void put_queue(struct vc_data *vc, int ch)
297{
298 struct tty_struct *tty = vc->vc_tty;
299
300 if (tty) {
301 tty_insert_flip_char(tty, ch, 0);
302 con_schedule_flip(tty);
303 }
304}
305
306static void puts_queue(struct vc_data *vc, char *cp)
307{
308 struct tty_struct *tty = vc->vc_tty;
309
310 if (!tty)
311 return;
312
313 while (*cp) {
314 tty_insert_flip_char(tty, *cp, 0);
315 cp++;
316 }
317 con_schedule_flip(tty);
318}
319
320static void applkey(struct vc_data *vc, int key, char mode)
321{
322 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
323
324 buf[1] = (mode ? 'O' : '[');
325 buf[2] = key;
326 puts_queue(vc, buf);
327}
328
329/*
330 * Many other routines do put_queue, but I think either
331 * they produce ASCII, or they produce some user-assigned
332 * string, and in both cases we might assume that it is
333 * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
334 * but we need only 16 bits here
335 */
336static void to_utf8(struct vc_data *vc, ushort c)
337{
338 if (c < 0x80)
339 /* 0******* */
340 put_queue(vc, c);
fe1e8604 341 else if (c < 0x800) {
1da177e4 342 /* 110***** 10****** */
fe1e8604 343 put_queue(vc, 0xc0 | (c >> 6));
1da177e4 344 put_queue(vc, 0x80 | (c & 0x3f));
fe1e8604 345 } else {
1da177e4
LT		 346 /* 1110**** 10****** 10****** */
347 put_queue(vc, 0xe0 | (c >> 12));
348 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
349 put_queue(vc, 0x80 | (c & 0x3f));
fe1e8604 350 }
1da177e4
LT		 351}
352
fe1e8604 353/*
1da177e4
LT		 354 * Called after returning from RAW mode or when changing consoles - recompute
355 * shift_down[] and shift_state from key_down[] maybe called when keymap is
356 * undefined, so that shiftkey release is seen
357 */
358void compute_shiftstate(void)
359{
360 unsigned int i, j, k, sym, val;
361
362 shift_state = 0;
363 memset(shift_down, 0, sizeof(shift_down));
fe1e8604 364
1da177e4
LT		 365 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
366
367 if (!key_down[i])
368 continue;
369
370 k = i * BITS_PER_LONG;
371
372 for (j = 0; j < BITS_PER_LONG; j++, k++) {
373
374 if (!test_bit(k, key_down))
375 continue;
376
377 sym = U(key_maps[0][k]);
378 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
379 continue;
380
381 val = KVAL(sym);
382 if (val == KVAL(K_CAPSSHIFT))
383 val = KVAL(K_SHIFT);
384
385 shift_down[val]++;
386 shift_state |= (1 << val);
387 }
388 }
389}
390
391/*
392 * We have a combining character DIACR here, followed by the character CH.
393 * If the combination occurs in the table, return the corresponding value.
394 * Otherwise, if CH is a space or equals DIACR, return DIACR.
395 * Otherwise, conclude that DIACR was not combining after all,
396 * queue it and return CH.
397 */
b9ec4e10 398static unsigned int handle_diacr(struct vc_data *vc, unsigned int ch)
1da177e4 399{
b9ec4e10 400 unsigned int d = diacr;
1da177e4
LT		 401 unsigned int i;
402
403 diacr = 0;
404
b9ec4e10
ST		 405 if ((d & ~0xff) == BRL_UC_ROW) {
406 if ((ch & ~0xff) == BRL_UC_ROW)
407 return d | ch;
408 } else {
409 for (i = 0; i < accent_table_size; i++)
410 if (accent_table[i].diacr == d && accent_table[i].base == ch)
411 return accent_table[i].result;
1da177e4
LT		 412 }
413
b9ec4e10 414 if (ch == ' ' || ch == (BRL_UC_ROW|0) || ch == d)
1da177e4
LT		 415 return d;
416
b9ec4e10
ST		 417 if (kbd->kbdmode == VC_UNICODE)
418 to_utf8(vc, d);
419 else if (d < 0x100)
420 put_queue(vc, d);
421
1da177e4
LT		 422 return ch;
423}
424
425/*
426 * Special function handlers
427 */
428static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
429{
430 if (diacr) {
b9ec4e10
ST		 431 if (kbd->kbdmode == VC_UNICODE)
432 to_utf8(vc, diacr);
433 else if (diacr < 0x100)
434 put_queue(vc, diacr);
1da177e4
LT		 435 diacr = 0;
436 }
437 put_queue(vc, 13);
438 if (vc_kbd_mode(kbd, VC_CRLF))
439 put_queue(vc, 10);
440}
441
442static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
443{
444 if (rep)
445 return;
446 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
447}
448
449static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
450{
451 if (rep)
452 return;
453 set_vc_kbd_led(kbd, VC_CAPSLOCK);
454}
455
456static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
457{
458 if (regs)
459 show_regs(regs);
460}
461
462static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
463{
464 struct tty_struct *tty = vc->vc_tty;
465
466 if (rep || !tty)
467 return;
468
469 /*
470 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
471 * these routines are also activated by ^S/^Q.
472 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
473 */
474 if (tty->stopped)
475 start_tty(tty);
476 else
477 stop_tty(tty);
478}
479
480static void fn_num(struct vc_data *vc, struct pt_regs *regs)
481{
482 if (vc_kbd_mode(kbd,VC_APPLIC))
483 applkey(vc, 'P', 1);
484 else
485 fn_bare_num(vc, regs);
486}
487
488/*
489 * Bind this to Shift-NumLock if you work in application keypad mode
490 * but want to be able to change the NumLock flag.
491 * Bind this to NumLock if you prefer that the NumLock key always
492 * changes the NumLock flag.
493 */
494static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
495{
496 if (!rep)
497 chg_vc_kbd_led(kbd, VC_NUMLOCK);
498}
499
500static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
501{
502 /* switch to the last used console, ChN */
503 set_console(last_console);
504}
505
506static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
507{
508 int i, cur = fg_console;
509
510 /* Currently switching? Queue this next switch relative to that. */
511 if (want_console != -1)
512 cur = want_console;
513
fe1e8604 514 for (i = cur - 1; i != cur; i--) {
1da177e4 515 if (i == -1)
fe1e8604 516 i = MAX_NR_CONSOLES - 1;
1da177e4
LT		 517 if (vc_cons_allocated(i))
518 break;
519 }
520 set_console(i);
521}
522
523static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
524{
525 int i, cur = fg_console;
526
527 /* Currently switching? Queue this next switch relative to that. */
528 if (want_console != -1)
529 cur = want_console;
530
531 for (i = cur+1; i != cur; i++) {
532 if (i == MAX_NR_CONSOLES)
533 i = 0;
534 if (vc_cons_allocated(i))
535 break;
536 }
537 set_console(i);
538}
539
540static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
541{
542 struct tty_struct *tty = vc->vc_tty;
543
544 if (!tty)
545 return;
546 tty_insert_flip_char(tty, 0, TTY_BREAK);
547 con_schedule_flip(tty);
548}
549
550static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
551{
552 scrollfront(vc, 0);
553}
554
555static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
556{
557 scrollback(vc, 0);
558}
559
560static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
561{
562 show_mem();
563}
564
565static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
566{
567 show_state();
568}
569
570static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
571{
572 ctrl_alt_del();
573}
574
575static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
576{
577 dead_key_next = 1;
578}
579
580static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
581{
fe1e8604
DT		 582 if (spawnpid)
583 if (kill_proc(spawnpid, spawnsig, 1))
584 spawnpid = 0;
1da177e4
LT		 585}
586
587static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
588{
589 struct tty_struct *tty = vc->vc_tty;
590
591 /*
592 * SAK should also work in all raw modes and reset
593 * them properly.
594 */
595 if (tty)
596 do_SAK(tty);
597 reset_vc(vc);
598}
599
600static void fn_null(struct vc_data *vc, struct pt_regs *regs)
601{
602 compute_shiftstate();
603}
604
605/*
606 * Special key handlers
607 */
608static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
609{
610}
611
612static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
613{
614 if (up_flag)
615 return;
616 if (value >= ARRAY_SIZE(fn_handler))
617 return;
fe1e8604
DT		 618 if ((kbd->kbdmode == VC_RAW ||
619 kbd->kbdmode == VC_MEDIUMRAW) &&
1da177e4
LT		 620 value != KVAL(K_SAK))
621 return; /* SAK is allowed even in raw mode */
622 fn_handler[value](vc, regs);
623}
624
625static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
626{
627 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
628}
629
b9ec4e10 630static void k_unicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
1da177e4
LT		 631{
632 if (up_flag)
633 return; /* no action, if this is a key release */
634
635 if (diacr)
636 value = handle_diacr(vc, value);
637
638 if (dead_key_next) {
639 dead_key_next = 0;
640 diacr = value;
641 return;
642 }
b9ec4e10
ST		 643 if (kbd->kbdmode == VC_UNICODE)
644 to_utf8(vc, value);
645 else if (value < 0x100)
646 put_queue(vc, value);
1da177e4
LT		 647}
648
649/*
650 * Handle dead key. Note that we now may have several
651 * dead keys modifying the same character. Very useful
652 * for Vietnamese.
653 */
b9ec4e10 654static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag, struct pt_regs *regs)
1da177e4
LT		 655{
656 if (up_flag)
657 return;
658 diacr = (diacr ? handle_diacr(vc, value) : value);
659}
660
b9ec4e10
ST		 661static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
662{
663 k_unicode(vc, value, up_flag, regs);
664}
665
666static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
667{
668 k_deadunicode(vc, value, up_flag, regs);
669}
670
1da177e4
LT		 671/*
672 * Obsolete - for backwards compatibility only
673 */
674static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
675{
0f5e560e 676 static const unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
1da177e4 677 value = ret_diacr[value];
b9ec4e10 678 k_deadunicode(vc, value, up_flag, regs);
1da177e4
LT		 679}
680
681static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
682{
683 if (up_flag)
684 return;
685 set_console(value);
686}
687
688static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
689{
690 unsigned v;
691
692 if (up_flag)
693 return;
694 v = value;
695 if (v < ARRAY_SIZE(func_table)) {
696 if (func_table[value])
697 puts_queue(vc, func_table[value]);
698 } else
699 printk(KERN_ERR "k_fn called with value=%d\n", value);
700}
701
702static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
703{
704 static const char *cur_chars = "BDCA";
705
706 if (up_flag)
707 return;
708 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
709}
710
711static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
712{
0f5e560e
AM		 713 static const char pad_chars[] = "0123456789+-*/\015,.?()#";
714 static const char app_map[] = "pqrstuvwxylSRQMnnmPQS";
1da177e4
LT		 715
716 if (up_flag)
717 return; /* no action, if this is a key release */
718
719 /* kludge... shift forces cursor/number keys */
720 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
721 applkey(vc, app_map[value], 1);
722 return;
723 }
724
725 if (!vc_kbd_led(kbd, VC_NUMLOCK))
726 switch (value) {
727 case KVAL(K_PCOMMA):
728 case KVAL(K_PDOT):
729 k_fn(vc, KVAL(K_REMOVE), 0, regs);
730 return;
731 case KVAL(K_P0):
732 k_fn(vc, KVAL(K_INSERT), 0, regs);
733 return;
734 case KVAL(K_P1):
735 k_fn(vc, KVAL(K_SELECT), 0, regs);
736 return;
737 case KVAL(K_P2):
738 k_cur(vc, KVAL(K_DOWN), 0, regs);
739 return;
740 case KVAL(K_P3):
741 k_fn(vc, KVAL(K_PGDN), 0, regs);
742 return;
743 case KVAL(K_P4):
744 k_cur(vc, KVAL(K_LEFT), 0, regs);
745 return;
746 case KVAL(K_P6):
747 k_cur(vc, KVAL(K_RIGHT), 0, regs);
748 return;
749 case KVAL(K_P7):
750 k_fn(vc, KVAL(K_FIND), 0, regs);
751 return;
752 case KVAL(K_P8):
753 k_cur(vc, KVAL(K_UP), 0, regs);
754 return;
755 case KVAL(K_P9):
756 k_fn(vc, KVAL(K_PGUP), 0, regs);
757 return;
758 case KVAL(K_P5):
759 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
760 return;
761 }
762
763 put_queue(vc, pad_chars[value]);
764 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
765 put_queue(vc, 10);
766}
767
768static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
769{
770 int old_state = shift_state;
771
772 if (rep)
773 return;
774 /*
775 * Mimic typewriter:
776 * a CapsShift key acts like Shift but undoes CapsLock
777 */
778 if (value == KVAL(K_CAPSSHIFT)) {
779 value = KVAL(K_SHIFT);
780 if (!up_flag)
781 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
782 }
783
784 if (up_flag) {
785 /*
786 * handle the case that two shift or control
787 * keys are depressed simultaneously
788 */
789 if (shift_down[value])
790 shift_down[value]--;
791 } else
792 shift_down[value]++;
793
794 if (shift_down[value])
795 shift_state |= (1 << value);
796 else
797 shift_state &= ~(1 << value);
798
799 /* kludge */
800 if (up_flag && shift_state != old_state && npadch != -1) {
801 if (kbd->kbdmode == VC_UNICODE)
802 to_utf8(vc, npadch & 0xffff);
803 else
804 put_queue(vc, npadch & 0xff);
805 npadch = -1;
806 }
807}
808
809static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
810{
811 if (up_flag)
812 return;
813
814 if (vc_kbd_mode(kbd, VC_META)) {
815 put_queue(vc, '\033');
816 put_queue(vc, value);
817 } else
818 put_queue(vc, value | 0x80);
819}
820
821static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
822{
823 int base;
824
825 if (up_flag)
826 return;
827
828 if (value < 10) {
829 /* decimal input of code, while Alt depressed */
830 base = 10;
831 } else {
832 /* hexadecimal input of code, while AltGr depressed */
833 value -= 10;
834 base = 16;
835 }
836
837 if (npadch == -1)
838 npadch = value;
839 else
840 npadch = npadch * base + value;
841}
842
843static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
844{
845 if (up_flag || rep)
846 return;
847 chg_vc_kbd_lock(kbd, value);
848}
849
850static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
851{
852 k_shift(vc, value, up_flag, regs);
853 if (up_flag || rep)
854 return;
855 chg_vc_kbd_slock(kbd, value);
856 /* try to make Alt, oops, AltGr and such work */
857 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
858 kbd->slockstate = 0;
859 chg_vc_kbd_slock(kbd, value);
860 }
861}
862
b9ec4e10 863/* by default, 300ms interval for combination release */
77426d72
ST		 864static unsigned brl_timeout = 300;
865MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for commit on first key release)");
866module_param(brl_timeout, uint, 0644);
867
868static unsigned brl_nbchords = 1;
869MODULE_PARM_DESC(brl_nbchords, "Number of chords that produce a braille pattern (0 for dead chords)");
870module_param(brl_nbchords, uint, 0644);
871
872static void k_brlcommit(struct vc_data *vc, unsigned int pattern, char up_flag, struct pt_regs *regs)
873{
874 static unsigned long chords;
875 static unsigned committed;
876
877 if (!brl_nbchords)
878 k_deadunicode(vc, BRL_UC_ROW | pattern, up_flag, regs);
879 else {
880 committed |= pattern;
881 chords++;
882 if (chords == brl_nbchords) {
883 k_unicode(vc, BRL_UC_ROW | committed, up_flag, regs);
884 chords = 0;
885 committed = 0;
886 }
887 }
888}
889
b9ec4e10
ST		 890static void k_brl(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
891{
892 static unsigned pressed,committing;
893 static unsigned long releasestart;
894
895 if (kbd->kbdmode != VC_UNICODE) {
896 if (!up_flag)
897 printk("keyboard mode must be unicode for braille patterns\n");
898 return;
899 }
900
901 if (!value) {
902 k_unicode(vc, BRL_UC_ROW, up_flag, regs);
903 return;
904 }
905
906 if (value > 8)
907 return;
908
b9ec4e10
ST		 909 if (up_flag) {
910 if (brl_timeout) {
911 if (!committing ||
912 jiffies - releasestart > (brl_timeout * HZ) / 1000) {
913 committing = pressed;
914 releasestart = jiffies;
915 }
916 pressed &= ~(1 << (value - 1));
917 if (!pressed) {
918 if (committing) {
77426d72 919 k_brlcommit(vc, committing, 0, regs);
b9ec4e10
ST		 920 committing = 0;
921 }
922 }
923 } else {
924 if (committing) {
77426d72 925 k_brlcommit(vc, committing, 0, regs);
b9ec4e10
ST		 926 committing = 0;
927 }
928 pressed &= ~(1 << (value - 1));
929 }
930 } else {
931 pressed |= 1 << (value - 1);
932 if (!brl_timeout)
933 committing = pressed;
934 }
935}
936
1da177e4
LT		 937/*
938 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
939 * or (ii) whatever pattern of lights people want to show using KDSETLED,
940 * or (iii) specified bits of specified words in kernel memory.
941 */
942unsigned char getledstate(void)
943{
944 return ledstate;
945}
946
947void setledstate(struct kbd_struct *kbd, unsigned int led)
948{
949 if (!(led & ~7)) {
950 ledioctl = led;
951 kbd->ledmode = LED_SHOW_IOCTL;
952 } else
953 kbd->ledmode = LED_SHOW_FLAGS;
954 set_leds();
955}
956
957static inline unsigned char getleds(void)
958{
959 struct kbd_struct *kbd = kbd_table + fg_console;
960 unsigned char leds;
961 int i;
962
963 if (kbd->ledmode == LED_SHOW_IOCTL)
964 return ledioctl;
965
966 leds = kbd->ledflagstate;
967
968 if (kbd->ledmode == LED_SHOW_MEM) {
969 for (i = 0; i < 3; i++)
970 if (ledptrs[i].valid) {
971 if (*ledptrs[i].addr & ledptrs[i].mask)
972 leds |= (1 << i);
973 else
974 leds &= ~(1 << i);
975 }
976 }
977 return leds;
978}
979
980/*
981 * This routine is the bottom half of the keyboard interrupt
982 * routine, and runs with all interrupts enabled. It does
983 * console changing, led setting and copy_to_cooked, which can
984 * take a reasonably long time.
985 *
986 * Aside from timing (which isn't really that important for
987 * keyboard interrupts as they happen often), using the software
988 * interrupt routines for this thing allows us to easily mask
989 * this when we don't want any of the above to happen.
990 * This allows for easy and efficient race-condition prevention
991 * for kbd_refresh_leds => input_event(dev, EV_LED, ...) => ...
992 */
993
994static void kbd_bh(unsigned long dummy)
995{
fe1e8604 996 struct list_head *node;
1da177e4
LT		 997 unsigned char leds = getleds();
998
999 if (leds != ledstate) {
fe1e8604 1000 list_for_each(node, &kbd_handler.h_list) {
1da177e4
LT		 1001 struct input_handle * handle = to_handle_h(node);
1002 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1003 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
1004 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
1005 input_sync(handle->dev);
1006 }
1007 }
1008
1009 ledstate = leds;
1010}
1011
1012DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
1013
1014/*
1015 * This allows a newly plugged keyboard to pick the LED state.
1016 */
1017static void kbd_refresh_leds(struct input_handle *handle)
1018{
1019 unsigned char leds = ledstate;
1020
1021 tasklet_disable(&keyboard_tasklet);
1022 if (leds != 0xff) {
1023 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1024 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
1025 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
1026 input_sync(handle->dev);
1027 }
1028 tasklet_enable(&keyboard_tasklet);
1029}
1030
1031#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
0b57ee9e
AB		 1032 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1033 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1da177e4
LT		 1034 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1035
1036#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1037 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1038
0f5e560e 1039static const unsigned short x86_keycodes[256] =
1da177e4
LT		 1040 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1041 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1042 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1043 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1044 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1045 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1046 284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
1047 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1048 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1049 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1050 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1051 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1052 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1053 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1054 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1055
1056#ifdef CONFIG_MAC_EMUMOUSEBTN
1057extern int mac_hid_mouse_emulate_buttons(int, int, int);
1058#endif /* CONFIG_MAC_EMUMOUSEBTN */
1059
0b57ee9e 1060#ifdef CONFIG_SPARC
1da177e4
LT		 1061static int sparc_l1_a_state = 0;
1062extern void sun_do_break(void);
1063#endif
1064
fe1e8604 1065static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1da177e4
LT		 1066 unsigned char up_flag)
1067{
1068 if (keycode > 255 || !x86_keycodes[keycode])
fe1e8604 1069 return -1;
1da177e4
LT		 1070
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);
1076 return 0;
b9ab58dd 1077 case KEY_HANGEUL:
0ae051a1
DT		 1078 if (!up_flag)
1079 put_queue(vc, 0xf2);
1da177e4
LT		 1080 return 0;
1081 case KEY_HANJA:
0ae051a1
DT		 1082 if (!up_flag)
1083 put_queue(vc, 0xf1);
1da177e4 1084 return 0;
fe1e8604 1085 }
1da177e4
LT		 1086
1087 if (keycode == KEY_SYSRQ && sysrq_alt) {
1088 put_queue(vc, 0x54 | up_flag);
1089 return 0;
1090 }
1091
1092 if (x86_keycodes[keycode] & 0x100)
1093 put_queue(vc, 0xe0);
1094
1095 put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
1096
1097 if (keycode == KEY_SYSRQ) {
1098 put_queue(vc, 0xe0);
1099 put_queue(vc, 0x37 | up_flag);
1100 }
1101
1102 return 0;
1103}
1104
1105#else
1106
1107#define HW_RAW(dev) 0
1108
1109#warning "Cannot generate rawmode keyboard for your architecture yet."
1110
1111static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1112{
1113 if (keycode > 127)
1114 return -1;
1115
1116 put_queue(vc, keycode | up_flag);
1117 return 0;
1118}
1119#endif
1120
1121static void kbd_rawcode(unsigned char data)
1122{
1123 struct vc_data *vc = vc_cons[fg_console].d;
1124 kbd = kbd_table + fg_console;
1125 if (kbd->kbdmode == VC_RAW)
1126 put_queue(vc, data);
1127}
1128
75c96f85
AB		 1129static void kbd_keycode(unsigned int keycode, int down,
1130 int hw_raw, struct pt_regs *regs)
1da177e4
LT		 1131{
1132 struct vc_data *vc = vc_cons[fg_console].d;
1133 unsigned short keysym, *key_map;
1134 unsigned char type, raw_mode;
1135 struct tty_struct *tty;
1136 int shift_final;
1137
1138 tty = vc->vc_tty;
1139
1140 if (tty && (!tty->driver_data)) {
1141 /* No driver data? Strange. Okay we fix it then. */
1142 tty->driver_data = vc;
1143 }
1144
1145 kbd = kbd_table + fg_console;
1146
1147 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
d2be8ee5 1148 sysrq_alt = down ? keycode : 0;
0b57ee9e 1149#ifdef CONFIG_SPARC
1da177e4
LT		 1150 if (keycode == KEY_STOP)
1151 sparc_l1_a_state = down;
1152#endif
1153
1154 rep = (down == 2);
1155
1156#ifdef CONFIG_MAC_EMUMOUSEBTN
1157 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1158 return;
1159#endif /* CONFIG_MAC_EMUMOUSEBTN */
1160
1161 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1162 if (emulate_raw(vc, keycode, !down << 7))
1163 if (keycode < BTN_MISC)
1164 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1165
1166#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1167 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
d2be8ee5
FR		 1168 if (!sysrq_down) {
1169 sysrq_down = down;
1170 sysrq_alt_use = sysrq_alt;
1171 }
1da177e4
LT		 1172 return;
1173 }
d2be8ee5
FR		 1174 if (sysrq_down && !down && keycode == sysrq_alt_use)
1175 sysrq_down = 0;
1da177e4
LT		 1176 if (sysrq_down && down && !rep) {
1177 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1178 return;
1179 }
1180#endif
0b57ee9e 1181#ifdef CONFIG_SPARC
1da177e4
LT		 1182 if (keycode == KEY_A && sparc_l1_a_state) {
1183 sparc_l1_a_state = 0;
1184 sun_do_break();
1185 }
1186#endif
1187
1188 if (kbd->kbdmode == VC_MEDIUMRAW) {
1189 /*
1190 * This is extended medium raw mode, with keys above 127
1191 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1192 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1193 * interfere with anything else. The two bytes after 0 will
1194 * always have the up flag set not to interfere with older
1195 * applications. This allows for 16384 different keycodes,
1196 * which should be enough.
1197 */
1198 if (keycode < 128) {
1199 put_queue(vc, keycode | (!down << 7));
1200 } else {
1201 put_queue(vc, !down << 7);
1202 put_queue(vc, (keycode >> 7) | 0x80);
1203 put_queue(vc, keycode | 0x80);
1204 }
1205 raw_mode = 1;
1206 }
1207
1208 if (down)
1209 set_bit(keycode, key_down);
1210 else
1211 clear_bit(keycode, key_down);
1212
fe1e8604
DT		 1213 if (rep &&
1214 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1215 (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1da177e4
LT		 1216 /*
1217 * Don't repeat a key if the input buffers are not empty and the
fe1e8604 1218 * characters get aren't echoed locally. This makes key repeat
1da177e4
LT		 1219 * usable with slow applications and under heavy loads.
1220 */
1221 return;
1222 }
1223
1224 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1225 key_map = key_maps[shift_final];
1226
1227 if (!key_map) {
1228 compute_shiftstate();
1229 kbd->slockstate = 0;
1230 return;
1231 }
1232
1233 if (keycode > NR_KEYS)
b9ec4e10
ST		 1234 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1235 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1236 else
1237 return;
1238 else
1239 keysym = key_map[keycode];
1da177e4 1240
1da177e4
LT		 1241 type = KTYP(keysym);
1242
1243 if (type < 0xf0) {
fe1e8604
DT		 1244 if (down && !raw_mode)
1245 to_utf8(vc, keysym);
1da177e4
LT		 1246 return;
1247 }
1248
1249 type -= 0xf0;
1250
1251 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1252 return;
1253
1254 if (type == KT_LETTER) {
1255 type = KT_LATIN;
1256 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1257 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1258 if (key_map)
1259 keysym = key_map[keycode];
1260 }
1261 }
1262
1263 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1264
1265 if (type != KT_SLOCK)
1266 kbd->slockstate = 0;
1267}
1268
fe1e8604 1269static void kbd_event(struct input_handle *handle, unsigned int event_type,
1da177e4
LT		 1270 unsigned int event_code, int value)
1271{
1272 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1273 kbd_rawcode(value);
1274 if (event_type == EV_KEY)
1275 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1276 tasklet_schedule(&keyboard_tasklet);
1277 do_poke_blanked_console = 1;
1278 schedule_console_callback();
1279}
1280
1da177e4
LT		 1281/*
1282 * When a keyboard (or other input device) is found, the kbd_connect
1283 * function is called. The function then looks at the device, and if it
1284 * likes it, it can open it and get events from it. In this (kbd_connect)
1285 * function, we should decide which VT to bind that keyboard to initially.
1286 */
fe1e8604 1287static struct input_handle *kbd_connect(struct input_handler *handler,
1da177e4
LT		 1288 struct input_dev *dev,
1289 struct input_device_id *id)
1290{
1291 struct input_handle *handle;
1292 int i;
1293
1294 for (i = KEY_RESERVED; i < BTN_MISC; i++)
fe1e8604
DT		 1295 if (test_bit(i, dev->keybit))
1296 break;
1da177e4 1297
fe1e8604 1298 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1da177e4
LT		 1299 return NULL;
1300
fe1e8604 1301 if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1da177e4
LT		 1302 return NULL;
1303 memset(handle, 0, sizeof(struct input_handle));
1304
1305 handle->dev = dev;
1306 handle->handler = handler;
fe1e8604 1307 handle->name = "kbd";
1da177e4
LT		 1308
1309 input_open_device(handle);
1310 kbd_refresh_leds(handle);
1311
1312 return handle;
1313}
1314
1315static void kbd_disconnect(struct input_handle *handle)
1316{
1317 input_close_device(handle);
1318 kfree(handle);
1319}
1320
1321static struct input_device_id kbd_ids[] = {
1322 {
1323 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1324 .evbit = { BIT(EV_KEY) },
1325 },
fe1e8604 1326
1da177e4
LT		 1327 {
1328 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1329 .evbit = { BIT(EV_SND) },
fe1e8604 1330 },
1da177e4
LT		 1331
1332 { }, /* Terminating entry */
1333};
1334
1335MODULE_DEVICE_TABLE(input, kbd_ids);
1336
1337static struct input_handler kbd_handler = {
1338 .event = kbd_event,
1339 .connect = kbd_connect,
1340 .disconnect = kbd_disconnect,
1341 .name = "kbd",
1342 .id_table = kbd_ids,
1343};
1344
1345int __init kbd_init(void)
1346{
1347 int i;
1348
1349 kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1350 kbd0.ledmode = LED_SHOW_FLAGS;
1351 kbd0.lockstate = KBD_DEFLOCK;
1352 kbd0.slockstate = 0;
1353 kbd0.modeflags = KBD_DEFMODE;
1354 kbd0.kbdmode = VC_XLATE;
1355
1356 for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1357 kbd_table[i] = kbd0;
1358
1359 input_register_handler(&kbd_handler);
1360
1361 tasklet_enable(&keyboard_tasklet);
1362 tasklet_schedule(&keyboard_tasklet);
1363
1364 return 0;
1365}
Linux 6.x block layer and io_uring tree(s)