]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - drivers/char/keyboard.c
projects / mirror_ubuntu-jammy-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Input: keyboard - remove static variable and clean up initialization
[mirror_ubuntu-jammy-kernel.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,
1028 284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
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{
1050 if (keycode > 255 || !x86_keycodes[keycode])
fe1e8604 1051 return -1;
1da177e4
LT		 1052
1053 switch (keycode) {
1054 case KEY_PAUSE:
1055 put_queue(vc, 0xe1);
1056 put_queue(vc, 0x1d | up_flag);
1057 put_queue(vc, 0x45 | up_flag);
1058 return 0;
b9ab58dd 1059 case KEY_HANGEUL:
0ae051a1
DT		 1060 if (!up_flag)
1061 put_queue(vc, 0xf2);
1da177e4
LT		 1062 return 0;
1063 case KEY_HANJA:
0ae051a1
DT		 1064 if (!up_flag)
1065 put_queue(vc, 0xf1);
1da177e4 1066 return 0;
fe1e8604 1067 }
1da177e4
LT		 1068
1069 if (keycode == KEY_SYSRQ && sysrq_alt) {
1070 put_queue(vc, 0x54 | up_flag);
1071 return 0;
1072 }
1073
1074 if (x86_keycodes[keycode] & 0x100)
1075 put_queue(vc, 0xe0);
1076
1077 put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
1078
1079 if (keycode == KEY_SYSRQ) {
1080 put_queue(vc, 0xe0);
1081 put_queue(vc, 0x37 | up_flag);
1082 }
1083
1084 return 0;
1085}
1086
1087#else
1088
1089#define HW_RAW(dev) 0
1090
1091#warning "Cannot generate rawmode keyboard for your architecture yet."
1092
1093static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1094{
1095 if (keycode > 127)
1096 return -1;
1097
1098 put_queue(vc, keycode | up_flag);
1099 return 0;
1100}
1101#endif
1102
1103static void kbd_rawcode(unsigned char data)
1104{
1105 struct vc_data *vc = vc_cons[fg_console].d;
1106 kbd = kbd_table + fg_console;
1107 if (kbd->kbdmode == VC_RAW)
1108 put_queue(vc, data);
1109}
1110
75c96f85
AB		 1111static void kbd_keycode(unsigned int keycode, int down,
1112 int hw_raw, struct pt_regs *regs)
1da177e4
LT		 1113{
1114 struct vc_data *vc = vc_cons[fg_console].d;
1115 unsigned short keysym, *key_map;
1116 unsigned char type, raw_mode;
1117 struct tty_struct *tty;
1118 int shift_final;
1119
1120 tty = vc->vc_tty;
1121
1122 if (tty && (!tty->driver_data)) {
1123 /* No driver data? Strange. Okay we fix it then. */
1124 tty->driver_data = vc;
1125 }
1126
1127 kbd = kbd_table + fg_console;
1128
1129 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
d2be8ee5 1130 sysrq_alt = down ? keycode : 0;
0b57ee9e 1131#ifdef CONFIG_SPARC
1da177e4
LT		 1132 if (keycode == KEY_STOP)
1133 sparc_l1_a_state = down;
1134#endif
1135
1136 rep = (down == 2);
1137
1138#ifdef CONFIG_MAC_EMUMOUSEBTN
1139 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1140 return;
1141#endif /* CONFIG_MAC_EMUMOUSEBTN */
1142
1143 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1144 if (emulate_raw(vc, keycode, !down << 7))
1145 if (keycode < BTN_MISC)
1146 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1147
1148#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1149 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
d2be8ee5
FR		 1150 if (!sysrq_down) {
1151 sysrq_down = down;
1152 sysrq_alt_use = sysrq_alt;
1153 }
1da177e4
LT		 1154 return;
1155 }
d2be8ee5
FR		 1156 if (sysrq_down && !down && keycode == sysrq_alt_use)
1157 sysrq_down = 0;
1da177e4
LT		 1158 if (sysrq_down && down && !rep) {
1159 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1160 return;
1161 }
1162#endif
0b57ee9e 1163#ifdef CONFIG_SPARC
1da177e4
LT		 1164 if (keycode == KEY_A && sparc_l1_a_state) {
1165 sparc_l1_a_state = 0;
1166 sun_do_break();
1167 }
1168#endif
1169
1170 if (kbd->kbdmode == VC_MEDIUMRAW) {
1171 /*
1172 * This is extended medium raw mode, with keys above 127
1173 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1174 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1175 * interfere with anything else. The two bytes after 0 will
1176 * always have the up flag set not to interfere with older
1177 * applications. This allows for 16384 different keycodes,
1178 * which should be enough.
1179 */
1180 if (keycode < 128) {
1181 put_queue(vc, keycode | (!down << 7));
1182 } else {
1183 put_queue(vc, !down << 7);
1184 put_queue(vc, (keycode >> 7) | 0x80);
1185 put_queue(vc, keycode | 0x80);
1186 }
1187 raw_mode = 1;
1188 }
1189
1190 if (down)
1191 set_bit(keycode, key_down);
1192 else
1193 clear_bit(keycode, key_down);
1194
fe1e8604
DT		 1195 if (rep &&
1196 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1197 (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1da177e4
LT		 1198 /*
1199 * Don't repeat a key if the input buffers are not empty and the
fe1e8604 1200 * characters get aren't echoed locally. This makes key repeat
1da177e4
LT		 1201 * usable with slow applications and under heavy loads.
1202 */
1203 return;
1204 }
1205
1206 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1207 key_map = key_maps[shift_final];
1208
1209 if (!key_map) {
1210 compute_shiftstate();
1211 kbd->slockstate = 0;
1212 return;
1213 }
1214
1215 if (keycode > NR_KEYS)
b9ec4e10
ST		 1216 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1217 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1218 else
1219 return;
1220 else
1221 keysym = key_map[keycode];
1da177e4 1222
1da177e4
LT		 1223 type = KTYP(keysym);
1224
1225 if (type < 0xf0) {
fe1e8604
DT		 1226 if (down && !raw_mode)
1227 to_utf8(vc, keysym);
1da177e4
LT		 1228 return;
1229 }
1230
1231 type -= 0xf0;
1232
1233 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1234 return;
1235
1236 if (type == KT_LETTER) {
1237 type = KT_LATIN;
1238 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1239 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1240 if (key_map)
1241 keysym = key_map[keycode];
1242 }
1243 }
1244
1245 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1246
1247 if (type != KT_SLOCK)
1248 kbd->slockstate = 0;
1249}
1250
fe1e8604 1251static void kbd_event(struct input_handle *handle, unsigned int event_type,
1da177e4
LT		 1252 unsigned int event_code, int value)
1253{
1254 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1255 kbd_rawcode(value);
1256 if (event_type == EV_KEY)
1257 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1258 tasklet_schedule(&keyboard_tasklet);
1259 do_poke_blanked_console = 1;
1260 schedule_console_callback();
1261}
1262
1da177e4
LT		 1263/*
1264 * When a keyboard (or other input device) is found, the kbd_connect
1265 * function is called. The function then looks at the device, and if it
1266 * likes it, it can open it and get events from it. In this (kbd_connect)
1267 * function, we should decide which VT to bind that keyboard to initially.
1268 */
fe1e8604 1269static struct input_handle *kbd_connect(struct input_handler *handler,
1da177e4
LT		 1270 struct input_dev *dev,
1271 struct input_device_id *id)
1272{
1273 struct input_handle *handle;
1274 int i;
1275
1276 for (i = KEY_RESERVED; i < BTN_MISC; i++)
fe1e8604
DT		 1277 if (test_bit(i, dev->keybit))
1278 break;
1da177e4 1279
fe1e8604 1280 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1da177e4
LT		 1281 return NULL;
1282
fe1e8604 1283 if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1da177e4
LT		 1284 return NULL;
1285 memset(handle, 0, sizeof(struct input_handle));
1286
1287 handle->dev = dev;
1288 handle->handler = handler;
fe1e8604 1289 handle->name = "kbd";
1da177e4
LT		 1290
1291 input_open_device(handle);
1da177e4
LT		 1292
1293 return handle;
1294}
1295
1296static void kbd_disconnect(struct input_handle *handle)
1297{
1298 input_close_device(handle);
1299 kfree(handle);
1300}
1301
c7e8dc6e
DT		 1302/*
1303 * Start keyboard handler on the new keyboard by refreshing LED state to
1304 * match the rest of the system.
1305 */
1306static void kbd_start(struct input_handle *handle)
1307{
1308 unsigned char leds = ledstate;
1309
1310 tasklet_disable(&keyboard_tasklet);
1311 if (leds != 0xff) {
0e739d28
DT		 1312 input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1313 input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
1314 input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
1315 input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
c7e8dc6e
DT		 1316 }
1317 tasklet_enable(&keyboard_tasklet);
1318}
1319
1da177e4
LT		 1320static struct input_device_id kbd_ids[] = {
1321 {
1322 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1323 .evbit = { BIT(EV_KEY) },
1324 },
fe1e8604 1325
1da177e4
LT		 1326 {
1327 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1328 .evbit = { BIT(EV_SND) },
fe1e8604 1329 },
1da177e4
LT		 1330
1331 { }, /* Terminating entry */
1332};
1333
1334MODULE_DEVICE_TABLE(input, kbd_ids);
1335
1336static struct input_handler kbd_handler = {
1337 .event = kbd_event,
1338 .connect = kbd_connect,
1339 .disconnect = kbd_disconnect,
c7e8dc6e 1340 .start = kbd_start,
1da177e4
LT		 1341 .name = "kbd",
1342 .id_table = kbd_ids,
1343};
1344
1345int __init kbd_init(void)
1346{
1347 int i;
1348
2b192908
DT		 1349 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1350 kbd_table[i].ledflagstate = KBD_DEFLEDS;
1351 kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1352 kbd_table[i].ledmode = LED_SHOW_FLAGS;
1353 kbd_table[i].lockstate = KBD_DEFLOCK;
1354 kbd_table[i].slockstate = 0;
1355 kbd_table[i].modeflags = KBD_DEFMODE;
1356 kbd_table[i].kbdmode = VC_XLATE;
1357 }
1da177e4
LT		 1358
1359 input_register_handler(&kbd_handler);
1360
1361 tasklet_enable(&keyboard_tasklet);
1362 tasklet_schedule(&keyboard_tasklet);
1363
1364 return 0;
1365}
Ubuntu Jammy Linux kernel mirror