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