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