projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Input: allow passing NULL to input_free_device()
[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
27#include <linux/config.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
37#include <linux/kbd_kern.h>
38#include <linux/kbd_diacr.h>
39#include <linux/vt_kern.h>
40#include <linux/sysrq.h>
41#include <linux/input.h>
42
43static void kbd_disconnect(struct input_handle *handle);
44extern void ctrl_alt_del(void);
45
46/*
47 * Exported functions/variables
48 */
49
50#define KBD_DEFMODE ((1 << VC_REPEAT) | (1 << VC_META))
51
52/*
53 * Some laptops take the 789uiojklm,. keys as number pad when NumLock is on.
54 * This seems a good reason to start with NumLock off. On HIL keyboards
fe1e8604 55 * of PARISC machines however there is no NumLock key and everyone expects the keypad
1da177e4
LT		 56 * to be used for numbers.
57 */
58
59#if defined(CONFIG_PARISC) && (defined(CONFIG_KEYBOARD_HIL) || defined(CONFIG_KEYBOARD_HIL_OLD))
60#define KBD_DEFLEDS (1 << VC_NUMLOCK)
61#else
62#define KBD_DEFLEDS 0
63#endif
64
65#define KBD_DEFLOCK 0
66
67void compute_shiftstate(void);
68
69/*
70 * Handler Tables.
71 */
72
73#define K_HANDLERS\
74 k_self, k_fn, k_spec, k_pad,\
75 k_dead, k_cons, k_cur, k_shift,\
76 k_meta, k_ascii, k_lock, k_lowercase,\
b9ec4e10 77 k_slock, k_dead2, k_brl, k_ignore
1da177e4 78
fe1e8604 79typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
1da177e4
LT		 80 char up_flag, struct pt_regs *regs);
81static k_handler_fn K_HANDLERS;
82static k_handler_fn *k_handler[16] = { K_HANDLERS };
83
84#define FN_HANDLERS\
fe1e8604
DT		 85 fn_null, fn_enter, fn_show_ptregs, fn_show_mem,\
86 fn_show_state, fn_send_intr, fn_lastcons, fn_caps_toggle,\
87 fn_num, fn_hold, fn_scroll_forw, fn_scroll_back,\
88 fn_boot_it, fn_caps_on, fn_compose, fn_SAK,\
89 fn_dec_console, fn_inc_console, fn_spawn_con, fn_bare_num
1da177e4
LT		 90
91typedef void (fn_handler_fn)(struct vc_data *vc, struct pt_regs *regs);
92static fn_handler_fn FN_HANDLERS;
93static fn_handler_fn *fn_handler[] = { FN_HANDLERS };
94
95/*
96 * Variables exported for vt_ioctl.c
97 */
98
99/* maximum values each key_handler can handle */
100const int max_vals[] = {
101 255, ARRAY_SIZE(func_table) - 1, ARRAY_SIZE(fn_handler) - 1, NR_PAD - 1,
102 NR_DEAD - 1, 255, 3, NR_SHIFT - 1, 255, NR_ASCII - 1, NR_LOCK - 1,
b9ec4e10 103 255, NR_LOCK - 1, 255, NR_BRL - 1
1da177e4
LT		 104};
105
106const int NR_TYPES = ARRAY_SIZE(max_vals);
107
108struct kbd_struct kbd_table[MAX_NR_CONSOLES];
109static struct kbd_struct *kbd = kbd_table;
110static struct kbd_struct kbd0;
111
112int spawnpid, spawnsig;
113
114/*
115 * Variables exported for vt.c
116 */
117
118int shift_state = 0;
119
120/*
121 * Internal Data.
122 */
123
124static struct input_handler kbd_handler;
125static unsigned long key_down[NBITS(KEY_MAX)]; /* keyboard key bitmap */
126static unsigned char shift_down[NR_SHIFT]; /* shift state counters.. */
127static int dead_key_next;
128static int npadch = -1; /* -1 or number assembled on pad */
b9ec4e10 129static unsigned int diacr;
1da177e4
LT		 130static char rep; /* flag telling character repeat */
131
132static unsigned char ledstate = 0xff; /* undefined */
133static unsigned char ledioctl;
134
135static struct ledptr {
136 unsigned int *addr;
137 unsigned int mask;
138 unsigned char valid:1;
139} ledptrs[3];
140
141/* Simple translation table for the SysRq keys */
142
143#ifdef CONFIG_MAGIC_SYSRQ
144unsigned char kbd_sysrq_xlate[KEY_MAX + 1] =
145 "\000\0331234567890-=\177\t" /* 0x00 - 0x0f */
146 "qwertyuiop[]\r\000as" /* 0x10 - 0x1f */
147 "dfghjkl;'`\000\\zxcv" /* 0x20 - 0x2f */
148 "bnm,./\000*\000 \000\201\202\203\204\205" /* 0x30 - 0x3f */
149 "\206\207\210\211\212\000\000789-456+1" /* 0x40 - 0x4f */
150 "230\177\000\000\213\214\000\000\000\000\000\000\000\000\000\000" /* 0x50 - 0x5f */
151 "\r\000/"; /* 0x60 - 0x6f */
152static int sysrq_down;
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
LT		 224
225 list_for_each(node,&kbd_handler.h_list) {
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))
229 input_event(handle->dev, EV_SND, SND_TONE, 0);
230 if (test_bit(SND_BELL, handle->dev->sndbit))
231 input_event(handle->dev, EV_SND, SND_BELL, 0);
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)) {
249 input_event(handle->dev, EV_SND, SND_TONE, hz);
250 break;
251 }
252 if (test_bit(SND_BELL, handle->dev->sndbit)) {
253 input_event(handle->dev, EV_SND, SND_BELL, 1);
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
274 list_for_each(node,&kbd_handler.h_list) {
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)
280 input_event(dev, EV_REP, REP_DELAY, rep->delay);
281 if (rep->period > 0)
282 input_event(dev, EV_REP, REP_PERIOD, rep->period);
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{
675 static unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
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{
712 static const char *pad_chars = "0123456789+-*/\015,.?()#";
713 static const char *app_map = "pqrstuvwxylSRQMnnmPQS";
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
ST		 862/* by default, 300ms interval for combination release */
863static long brl_timeout = 300;
864MODULE_PARM_DESC(brl_timeout, "Braille keys release delay in ms (0 for combination on first release, < 0 for dead characters)");
865module_param(brl_timeout, long, 0644);
866static void k_brl(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
867{
868 static unsigned pressed,committing;
869 static unsigned long releasestart;
870
871 if (kbd->kbdmode != VC_UNICODE) {
872 if (!up_flag)
873 printk("keyboard mode must be unicode for braille patterns\n");
874 return;
875 }
876
877 if (!value) {
878 k_unicode(vc, BRL_UC_ROW, up_flag, regs);
879 return;
880 }
881
882 if (value > 8)
883 return;
884
885 if (brl_timeout < 0) {
886 k_deadunicode(vc, BRL_UC_ROW | (1 << (value - 1)), up_flag, regs);
887 return;
888 }
889
890 if (up_flag) {
891 if (brl_timeout) {
892 if (!committing ||
893 jiffies - releasestart > (brl_timeout * HZ) / 1000) {
894 committing = pressed;
895 releasestart = jiffies;
896 }
897 pressed &= ~(1 << (value - 1));
898 if (!pressed) {
899 if (committing) {
900 k_unicode(vc, BRL_UC_ROW | committing, 0, regs);
901 committing = 0;
902 }
903 }
904 } else {
905 if (committing) {
906 k_unicode(vc, BRL_UC_ROW | committing, 0, regs);
907 committing = 0;
908 }
909 pressed &= ~(1 << (value - 1));
910 }
911 } else {
912 pressed |= 1 << (value - 1);
913 if (!brl_timeout)
914 committing = pressed;
915 }
916}
917
1da177e4
LT		 918/*
919 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
920 * or (ii) whatever pattern of lights people want to show using KDSETLED,
921 * or (iii) specified bits of specified words in kernel memory.
922 */
923unsigned char getledstate(void)
924{
925 return ledstate;
926}
927
928void setledstate(struct kbd_struct *kbd, unsigned int led)
929{
930 if (!(led & ~7)) {
931 ledioctl = led;
932 kbd->ledmode = LED_SHOW_IOCTL;
933 } else
934 kbd->ledmode = LED_SHOW_FLAGS;
935 set_leds();
936}
937
938static inline unsigned char getleds(void)
939{
940 struct kbd_struct *kbd = kbd_table + fg_console;
941 unsigned char leds;
942 int i;
943
944 if (kbd->ledmode == LED_SHOW_IOCTL)
945 return ledioctl;
946
947 leds = kbd->ledflagstate;
948
949 if (kbd->ledmode == LED_SHOW_MEM) {
950 for (i = 0; i < 3; i++)
951 if (ledptrs[i].valid) {
952 if (*ledptrs[i].addr & ledptrs[i].mask)
953 leds |= (1 << i);
954 else
955 leds &= ~(1 << i);
956 }
957 }
958 return leds;
959}
960
961/*
962 * This routine is the bottom half of the keyboard interrupt
963 * routine, and runs with all interrupts enabled. It does
964 * console changing, led setting and copy_to_cooked, which can
965 * take a reasonably long time.
966 *
967 * Aside from timing (which isn't really that important for
968 * keyboard interrupts as they happen often), using the software
969 * interrupt routines for this thing allows us to easily mask
970 * this when we don't want any of the above to happen.
971 * This allows for easy and efficient race-condition prevention
972 * for kbd_refresh_leds => input_event(dev, EV_LED, ...) => ...
973 */
974
975static void kbd_bh(unsigned long dummy)
976{
fe1e8604 977 struct list_head *node;
1da177e4
LT		 978 unsigned char leds = getleds();
979
980 if (leds != ledstate) {
fe1e8604 981 list_for_each(node, &kbd_handler.h_list) {
1da177e4
LT		 982 struct input_handle * handle = to_handle_h(node);
983 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
984 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
985 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
986 input_sync(handle->dev);
987 }
988 }
989
990 ledstate = leds;
991}
992
993DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
994
995/*
996 * This allows a newly plugged keyboard to pick the LED state.
997 */
998static void kbd_refresh_leds(struct input_handle *handle)
999{
1000 unsigned char leds = ledstate;
1001
1002 tasklet_disable(&keyboard_tasklet);
1003 if (leds != 0xff) {
1004 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1005 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
1006 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
1007 input_sync(handle->dev);
1008 }
1009 tasklet_enable(&keyboard_tasklet);
1010}
1011
1012#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
0b57ee9e
AB		 1013 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
1014 defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
1da177e4
LT		 1015 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
1016
1017#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1018 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1019
1020static unsigned short x86_keycodes[256] =
1021 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1022 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1023 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1024 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1025 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1026 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1027 284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
1028 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1029 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1030 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
1031 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
1032 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1033 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1034 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1035 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1036
1037#ifdef CONFIG_MAC_EMUMOUSEBTN
1038extern int mac_hid_mouse_emulate_buttons(int, int, int);
1039#endif /* CONFIG_MAC_EMUMOUSEBTN */
1040
0b57ee9e 1041#ifdef CONFIG_SPARC
1da177e4
LT		 1042static int sparc_l1_a_state = 0;
1043extern void sun_do_break(void);
1044#endif
1045
fe1e8604 1046static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1da177e4
LT		 1047 unsigned char up_flag)
1048{
1049 if (keycode > 255 || !x86_keycodes[keycode])
fe1e8604 1050 return -1;
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);
1057 return 0;
1058 case KEY_HANGUEL:
1059 if (!up_flag) put_queue(vc, 0xf1);
1060 return 0;
1061 case KEY_HANJA:
1062 if (!up_flag) put_queue(vc, 0xf2);
1063 return 0;
fe1e8604 1064 }
1da177e4
LT		 1065
1066 if (keycode == KEY_SYSRQ && sysrq_alt) {
1067 put_queue(vc, 0x54 | up_flag);
1068 return 0;
1069 }
1070
1071 if (x86_keycodes[keycode] & 0x100)
1072 put_queue(vc, 0xe0);
1073
1074 put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
1075
1076 if (keycode == KEY_SYSRQ) {
1077 put_queue(vc, 0xe0);
1078 put_queue(vc, 0x37 | up_flag);
1079 }
1080
1081 return 0;
1082}
1083
1084#else
1085
1086#define HW_RAW(dev) 0
1087
1088#warning "Cannot generate rawmode keyboard for your architecture yet."
1089
1090static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1091{
1092 if (keycode > 127)
1093 return -1;
1094
1095 put_queue(vc, keycode | up_flag);
1096 return 0;
1097}
1098#endif
1099
1100static void kbd_rawcode(unsigned char data)
1101{
1102 struct vc_data *vc = vc_cons[fg_console].d;
1103 kbd = kbd_table + fg_console;
1104 if (kbd->kbdmode == VC_RAW)
1105 put_queue(vc, data);
1106}
1107
75c96f85
AB		 1108static void kbd_keycode(unsigned int keycode, int down,
1109 int hw_raw, struct pt_regs *regs)
1da177e4
LT		 1110{
1111 struct vc_data *vc = vc_cons[fg_console].d;
1112 unsigned short keysym, *key_map;
1113 unsigned char type, raw_mode;
1114 struct tty_struct *tty;
1115 int shift_final;
1116
1117 tty = vc->vc_tty;
1118
1119 if (tty && (!tty->driver_data)) {
1120 /* No driver data? Strange. Okay we fix it then. */
1121 tty->driver_data = vc;
1122 }
1123
1124 kbd = kbd_table + fg_console;
1125
1126 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1127 sysrq_alt = down;
0b57ee9e 1128#ifdef CONFIG_SPARC
1da177e4
LT		 1129 if (keycode == KEY_STOP)
1130 sparc_l1_a_state = down;
1131#endif
1132
1133 rep = (down == 2);
1134
1135#ifdef CONFIG_MAC_EMUMOUSEBTN
1136 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1137 return;
1138#endif /* CONFIG_MAC_EMUMOUSEBTN */
1139
1140 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1141 if (emulate_raw(vc, keycode, !down << 7))
1142 if (keycode < BTN_MISC)
1143 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1144
1145#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1146 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1147 sysrq_down = down;
1148 return;
1149 }
1150 if (sysrq_down && down && !rep) {
1151 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1152 return;
1153 }
1154#endif
0b57ee9e 1155#ifdef CONFIG_SPARC
1da177e4
LT		 1156 if (keycode == KEY_A && sparc_l1_a_state) {
1157 sparc_l1_a_state = 0;
1158 sun_do_break();
1159 }
1160#endif
1161
1162 if (kbd->kbdmode == VC_MEDIUMRAW) {
1163 /*
1164 * This is extended medium raw mode, with keys above 127
1165 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1166 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1167 * interfere with anything else. The two bytes after 0 will
1168 * always have the up flag set not to interfere with older
1169 * applications. This allows for 16384 different keycodes,
1170 * which should be enough.
1171 */
1172 if (keycode < 128) {
1173 put_queue(vc, keycode | (!down << 7));
1174 } else {
1175 put_queue(vc, !down << 7);
1176 put_queue(vc, (keycode >> 7) | 0x80);
1177 put_queue(vc, keycode | 0x80);
1178 }
1179 raw_mode = 1;
1180 }
1181
1182 if (down)
1183 set_bit(keycode, key_down);
1184 else
1185 clear_bit(keycode, key_down);
1186
fe1e8604
DT		 1187 if (rep &&
1188 (!vc_kbd_mode(kbd, VC_REPEAT) ||
1189 (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1da177e4
LT		 1190 /*
1191 * Don't repeat a key if the input buffers are not empty and the
fe1e8604 1192 * characters get aren't echoed locally. This makes key repeat
1da177e4
LT		 1193 * usable with slow applications and under heavy loads.
1194 */
1195 return;
1196 }
1197
1198 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1199 key_map = key_maps[shift_final];
1200
1201 if (!key_map) {
1202 compute_shiftstate();
1203 kbd->slockstate = 0;
1204 return;
1205 }
1206
1207 if (keycode > NR_KEYS)
b9ec4e10
ST		 1208 if (keycode >= KEY_BRL_DOT1 && keycode <= KEY_BRL_DOT8)
1209 keysym = K(KT_BRL, keycode - KEY_BRL_DOT1 + 1);
1210 else
1211 return;
1212 else
1213 keysym = key_map[keycode];
1da177e4 1214
1da177e4
LT		 1215 type = KTYP(keysym);
1216
1217 if (type < 0xf0) {
fe1e8604
DT		 1218 if (down && !raw_mode)
1219 to_utf8(vc, keysym);
1da177e4
LT		 1220 return;
1221 }
1222
1223 type -= 0xf0;
1224
1225 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1226 return;
1227
1228 if (type == KT_LETTER) {
1229 type = KT_LATIN;
1230 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1231 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1232 if (key_map)
1233 keysym = key_map[keycode];
1234 }
1235 }
1236
1237 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1238
1239 if (type != KT_SLOCK)
1240 kbd->slockstate = 0;
1241}
1242
fe1e8604 1243static void kbd_event(struct input_handle *handle, unsigned int event_type,
1da177e4
LT		 1244 unsigned int event_code, int value)
1245{
1246 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1247 kbd_rawcode(value);
1248 if (event_type == EV_KEY)
1249 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1250 tasklet_schedule(&keyboard_tasklet);
1251 do_poke_blanked_console = 1;
1252 schedule_console_callback();
1253}
1254
1da177e4
LT		 1255/*
1256 * When a keyboard (or other input device) is found, the kbd_connect
1257 * function is called. The function then looks at the device, and if it
1258 * likes it, it can open it and get events from it. In this (kbd_connect)
1259 * function, we should decide which VT to bind that keyboard to initially.
1260 */
fe1e8604 1261static struct input_handle *kbd_connect(struct input_handler *handler,
1da177e4
LT		 1262 struct input_dev *dev,
1263 struct input_device_id *id)
1264{
1265 struct input_handle *handle;
1266 int i;
1267
1268 for (i = KEY_RESERVED; i < BTN_MISC; i++)
fe1e8604
DT		 1269 if (test_bit(i, dev->keybit))
1270 break;
1da177e4 1271
fe1e8604 1272 if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1da177e4
LT		 1273 return NULL;
1274
fe1e8604 1275 if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1da177e4
LT		 1276 return NULL;
1277 memset(handle, 0, sizeof(struct input_handle));
1278
1279 handle->dev = dev;
1280 handle->handler = handler;
fe1e8604 1281 handle->name = "kbd";
1da177e4
LT		 1282
1283 input_open_device(handle);
1284 kbd_refresh_leds(handle);
1285
1286 return handle;
1287}
1288
1289static void kbd_disconnect(struct input_handle *handle)
1290{
1291 input_close_device(handle);
1292 kfree(handle);
1293}
1294
1295static struct input_device_id kbd_ids[] = {
1296 {
1297 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1298 .evbit = { BIT(EV_KEY) },
1299 },
fe1e8604 1300
1da177e4
LT		 1301 {
1302 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1303 .evbit = { BIT(EV_SND) },
fe1e8604 1304 },
1da177e4
LT		 1305
1306 { }, /* Terminating entry */
1307};
1308
1309MODULE_DEVICE_TABLE(input, kbd_ids);
1310
1311static struct input_handler kbd_handler = {
1312 .event = kbd_event,
1313 .connect = kbd_connect,
1314 .disconnect = kbd_disconnect,
1315 .name = "kbd",
1316 .id_table = kbd_ids,
1317};
1318
1319int __init kbd_init(void)
1320{
1321 int i;
1322
1323 kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1324 kbd0.ledmode = LED_SHOW_FLAGS;
1325 kbd0.lockstate = KBD_DEFLOCK;
1326 kbd0.slockstate = 0;
1327 kbd0.modeflags = KBD_DEFMODE;
1328 kbd0.kbdmode = VC_XLATE;
1329
1330 for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1331 kbd_table[i] = kbd0;
1332
1333 input_register_handler(&kbd_handler);
1334
1335 tasklet_enable(&keyboard_tasklet);
1336 tasklet_schedule(&keyboard_tasklet);
1337
1338 return 0;
1339}
Linux kernel - Deliverables
This page took 0.129834 seconds and 5 git commands to generate.