aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/char/keyboard.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/char/keyboard.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'drivers/char/keyboard.c')
-rw-r--r--drivers/char/keyboard.c1254
1 files changed, 1254 insertions, 0 deletions
diff --git a/drivers/char/keyboard.c b/drivers/char/keyboard.c
new file mode 100644
index 000000000000..3ce51c6a1b18
--- /dev/null
+++ b/drivers/char/keyboard.c
@@ -0,0 +1,1254 @@
1/*
2 * linux/drivers/char/keyboard.c
3 *
4 * Written for linux by Johan Myreen as a translation from
5 * the assembly version by Linus (with diacriticals added)
6 *
7 * Some additional features added by Christoph Niemann (ChN), March 1993
8 *
9 * Loadable keymaps by Risto Kankkunen, May 1993
10 *
11 * Diacriticals redone & other small changes, aeb@cwi.nl, June 1993
12 * Added decr/incr_console, dynamic keymaps, Unicode support,
13 * dynamic function/string keys, led setting, Sept 1994
14 * `Sticky' modifier keys, 951006.
15 *
16 * 11-11-96: SAK should now work in the raw mode (Martin Mares)
17 *
18 * Modified to provide 'generic' keyboard support by Hamish Macdonald
19 * Merge with the m68k keyboard driver and split-off of the PC low-level
20 * parts by Geert Uytterhoeven, May 1997
21 *
22 * 27-05-97: Added support for the Magic SysRq Key (Martin Mares)
23 * 30-07-98: Dead keys redone, aeb@cwi.nl.
24 * 21-08-02: Converted to input API, major cleanup. (Vojtech Pavlik)
25 */
26
27#include <linux/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
55 * of PARISC machines however there is no NumLock key and everyone expects the keypad
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,\
77 k_slock, k_dead2, k_ignore, k_ignore
78
79typedef void (k_handler_fn)(struct vc_data *vc, unsigned char value,
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\
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
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,
103 255, NR_LOCK - 1, 255
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 */
129static unsigned char diacr;
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{
162 struct list_head * node;
163 struct input_dev *dev = NULL;
164
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;
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{
184 struct list_head * node;
185 struct input_dev *dev = NULL;
186 unsigned int i, oldkey;
187
188 list_for_each(node,&kbd_handler.h_list) {
189 struct input_handle *handle = to_handle_h(node);
190 if (handle->dev->keycodesize) {
191 dev = handle->dev;
192 break;
193 }
194 }
195
196 if (!dev)
197 return -ENODEV;
198
199 if (scancode >= dev->keycodemax)
200 return -EINVAL;
201 if (keycode > KEY_MAX)
202 return -EINVAL;
203 if (keycode < 0 || keycode > KEY_MAX)
204 return -EINVAL;
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/*
219 * Making beeps and bells.
220 */
221static void kd_nosound(unsigned long ignored)
222{
223 struct list_head * node;
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
236static struct timer_list kd_mksound_timer =
237 TIMER_INITIALIZER(kd_nosound, 0, 0);
238
239void kd_mksound(unsigned int hz, unsigned int ticks)
240{
241 struct list_head * node;
242
243 del_timer(&kd_mksound_timer);
244
245 if (hz) {
246 list_for_each_prev(node,&kbd_handler.h_list) {
247 struct input_handle *handle = to_handle_h(node);
248 if (test_bit(EV_SND, handle->dev->evbit)) {
249 if (test_bit(SND_TONE, handle->dev->sndbit)) {
250 input_event(handle->dev, EV_SND, SND_TONE, hz);
251 break;
252 }
253 if (test_bit(SND_BELL, handle->dev->sndbit)) {
254 input_event(handle->dev, EV_SND, SND_BELL, 1);
255 break;
256 }
257 }
258 }
259 if (ticks)
260 mod_timer(&kd_mksound_timer, jiffies + ticks);
261 } else
262 kd_nosound(0);
263}
264
265/*
266 * Setting the keyboard rate.
267 */
268
269int kbd_rate(struct kbd_repeat *rep)
270{
271 struct list_head *node;
272 unsigned int d = 0;
273 unsigned int p = 0;
274
275 list_for_each(node,&kbd_handler.h_list) {
276 struct input_handle *handle = to_handle_h(node);
277 struct input_dev *dev = handle->dev;
278
279 if (test_bit(EV_REP, dev->evbit)) {
280 if (rep->delay > 0)
281 input_event(dev, EV_REP, REP_DELAY, rep->delay);
282 if (rep->period > 0)
283 input_event(dev, EV_REP, REP_PERIOD, rep->period);
284 d = dev->rep[REP_DELAY];
285 p = dev->rep[REP_PERIOD];
286 }
287 }
288 rep->delay = d;
289 rep->period = p;
290 return 0;
291}
292
293/*
294 * Helper Functions.
295 */
296static void put_queue(struct vc_data *vc, int ch)
297{
298 struct tty_struct *tty = vc->vc_tty;
299
300 if (tty) {
301 tty_insert_flip_char(tty, ch, 0);
302 con_schedule_flip(tty);
303 }
304}
305
306static void puts_queue(struct vc_data *vc, char *cp)
307{
308 struct tty_struct *tty = vc->vc_tty;
309
310 if (!tty)
311 return;
312
313 while (*cp) {
314 tty_insert_flip_char(tty, *cp, 0);
315 cp++;
316 }
317 con_schedule_flip(tty);
318}
319
320static void applkey(struct vc_data *vc, int key, char mode)
321{
322 static char buf[] = { 0x1b, 'O', 0x00, 0x00 };
323
324 buf[1] = (mode ? 'O' : '[');
325 buf[2] = key;
326 puts_queue(vc, buf);
327}
328
329/*
330 * Many other routines do put_queue, but I think either
331 * they produce ASCII, or they produce some user-assigned
332 * string, and in both cases we might assume that it is
333 * in utf-8 already. UTF-8 is defined for words of up to 31 bits,
334 * but we need only 16 bits here
335 */
336static void to_utf8(struct vc_data *vc, ushort c)
337{
338 if (c < 0x80)
339 /* 0******* */
340 put_queue(vc, c);
341 else if (c < 0x800) {
342 /* 110***** 10****** */
343 put_queue(vc, 0xc0 | (c >> 6));
344 put_queue(vc, 0x80 | (c & 0x3f));
345 } else {
346 /* 1110**** 10****** 10****** */
347 put_queue(vc, 0xe0 | (c >> 12));
348 put_queue(vc, 0x80 | ((c >> 6) & 0x3f));
349 put_queue(vc, 0x80 | (c & 0x3f));
350 }
351}
352
353/*
354 * Called after returning from RAW mode or when changing consoles - recompute
355 * shift_down[] and shift_state from key_down[] maybe called when keymap is
356 * undefined, so that shiftkey release is seen
357 */
358void compute_shiftstate(void)
359{
360 unsigned int i, j, k, sym, val;
361
362 shift_state = 0;
363 memset(shift_down, 0, sizeof(shift_down));
364
365 for (i = 0; i < ARRAY_SIZE(key_down); i++) {
366
367 if (!key_down[i])
368 continue;
369
370 k = i * BITS_PER_LONG;
371
372 for (j = 0; j < BITS_PER_LONG; j++, k++) {
373
374 if (!test_bit(k, key_down))
375 continue;
376
377 sym = U(key_maps[0][k]);
378 if (KTYP(sym) != KT_SHIFT && KTYP(sym) != KT_SLOCK)
379 continue;
380
381 val = KVAL(sym);
382 if (val == KVAL(K_CAPSSHIFT))
383 val = KVAL(K_SHIFT);
384
385 shift_down[val]++;
386 shift_state |= (1 << val);
387 }
388 }
389}
390
391/*
392 * We have a combining character DIACR here, followed by the character CH.
393 * If the combination occurs in the table, return the corresponding value.
394 * Otherwise, if CH is a space or equals DIACR, return DIACR.
395 * Otherwise, conclude that DIACR was not combining after all,
396 * queue it and return CH.
397 */
398static unsigned char handle_diacr(struct vc_data *vc, unsigned char ch)
399{
400 int d = diacr;
401 unsigned int i;
402
403 diacr = 0;
404
405 for (i = 0; i < accent_table_size; i++) {
406 if (accent_table[i].diacr == d && accent_table[i].base == ch)
407 return accent_table[i].result;
408 }
409
410 if (ch == ' ' || ch == d)
411 return d;
412
413 put_queue(vc, d);
414 return ch;
415}
416
417/*
418 * Special function handlers
419 */
420static void fn_enter(struct vc_data *vc, struct pt_regs *regs)
421{
422 if (diacr) {
423 put_queue(vc, diacr);
424 diacr = 0;
425 }
426 put_queue(vc, 13);
427 if (vc_kbd_mode(kbd, VC_CRLF))
428 put_queue(vc, 10);
429}
430
431static void fn_caps_toggle(struct vc_data *vc, struct pt_regs *regs)
432{
433 if (rep)
434 return;
435 chg_vc_kbd_led(kbd, VC_CAPSLOCK);
436}
437
438static void fn_caps_on(struct vc_data *vc, struct pt_regs *regs)
439{
440 if (rep)
441 return;
442 set_vc_kbd_led(kbd, VC_CAPSLOCK);
443}
444
445static void fn_show_ptregs(struct vc_data *vc, struct pt_regs *regs)
446{
447 if (regs)
448 show_regs(regs);
449}
450
451static void fn_hold(struct vc_data *vc, struct pt_regs *regs)
452{
453 struct tty_struct *tty = vc->vc_tty;
454
455 if (rep || !tty)
456 return;
457
458 /*
459 * Note: SCROLLOCK will be set (cleared) by stop_tty (start_tty);
460 * these routines are also activated by ^S/^Q.
461 * (And SCROLLOCK can also be set by the ioctl KDSKBLED.)
462 */
463 if (tty->stopped)
464 start_tty(tty);
465 else
466 stop_tty(tty);
467}
468
469static void fn_num(struct vc_data *vc, struct pt_regs *regs)
470{
471 if (vc_kbd_mode(kbd,VC_APPLIC))
472 applkey(vc, 'P', 1);
473 else
474 fn_bare_num(vc, regs);
475}
476
477/*
478 * Bind this to Shift-NumLock if you work in application keypad mode
479 * but want to be able to change the NumLock flag.
480 * Bind this to NumLock if you prefer that the NumLock key always
481 * changes the NumLock flag.
482 */
483static void fn_bare_num(struct vc_data *vc, struct pt_regs *regs)
484{
485 if (!rep)
486 chg_vc_kbd_led(kbd, VC_NUMLOCK);
487}
488
489static void fn_lastcons(struct vc_data *vc, struct pt_regs *regs)
490{
491 /* switch to the last used console, ChN */
492 set_console(last_console);
493}
494
495static void fn_dec_console(struct vc_data *vc, struct pt_regs *regs)
496{
497 int i, cur = fg_console;
498
499 /* Currently switching? Queue this next switch relative to that. */
500 if (want_console != -1)
501 cur = want_console;
502
503 for (i = cur-1; i != cur; i--) {
504 if (i == -1)
505 i = MAX_NR_CONSOLES-1;
506 if (vc_cons_allocated(i))
507 break;
508 }
509 set_console(i);
510}
511
512static void fn_inc_console(struct vc_data *vc, struct pt_regs *regs)
513{
514 int i, cur = fg_console;
515
516 /* Currently switching? Queue this next switch relative to that. */
517 if (want_console != -1)
518 cur = want_console;
519
520 for (i = cur+1; i != cur; i++) {
521 if (i == MAX_NR_CONSOLES)
522 i = 0;
523 if (vc_cons_allocated(i))
524 break;
525 }
526 set_console(i);
527}
528
529static void fn_send_intr(struct vc_data *vc, struct pt_regs *regs)
530{
531 struct tty_struct *tty = vc->vc_tty;
532
533 if (!tty)
534 return;
535 tty_insert_flip_char(tty, 0, TTY_BREAK);
536 con_schedule_flip(tty);
537}
538
539static void fn_scroll_forw(struct vc_data *vc, struct pt_regs *regs)
540{
541 scrollfront(vc, 0);
542}
543
544static void fn_scroll_back(struct vc_data *vc, struct pt_regs *regs)
545{
546 scrollback(vc, 0);
547}
548
549static void fn_show_mem(struct vc_data *vc, struct pt_regs *regs)
550{
551 show_mem();
552}
553
554static void fn_show_state(struct vc_data *vc, struct pt_regs *regs)
555{
556 show_state();
557}
558
559static void fn_boot_it(struct vc_data *vc, struct pt_regs *regs)
560{
561 ctrl_alt_del();
562}
563
564static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
565{
566 dead_key_next = 1;
567}
568
569static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
570{
571 if (spawnpid)
572 if(kill_proc(spawnpid, spawnsig, 1))
573 spawnpid = 0;
574}
575
576static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
577{
578 struct tty_struct *tty = vc->vc_tty;
579
580 /*
581 * SAK should also work in all raw modes and reset
582 * them properly.
583 */
584 if (tty)
585 do_SAK(tty);
586 reset_vc(vc);
587}
588
589static void fn_null(struct vc_data *vc, struct pt_regs *regs)
590{
591 compute_shiftstate();
592}
593
594/*
595 * Special key handlers
596 */
597static void k_ignore(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
598{
599}
600
601static void k_spec(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
602{
603 if (up_flag)
604 return;
605 if (value >= ARRAY_SIZE(fn_handler))
606 return;
607 if ((kbd->kbdmode == VC_RAW ||
608 kbd->kbdmode == VC_MEDIUMRAW) &&
609 value != KVAL(K_SAK))
610 return; /* SAK is allowed even in raw mode */
611 fn_handler[value](vc, regs);
612}
613
614static void k_lowercase(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
615{
616 printk(KERN_ERR "keyboard.c: k_lowercase was called - impossible\n");
617}
618
619static void k_self(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
620{
621 if (up_flag)
622 return; /* no action, if this is a key release */
623
624 if (diacr)
625 value = handle_diacr(vc, value);
626
627 if (dead_key_next) {
628 dead_key_next = 0;
629 diacr = value;
630 return;
631 }
632 put_queue(vc, value);
633}
634
635/*
636 * Handle dead key. Note that we now may have several
637 * dead keys modifying the same character. Very useful
638 * for Vietnamese.
639 */
640static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
641{
642 if (up_flag)
643 return;
644 diacr = (diacr ? handle_diacr(vc, value) : value);
645}
646
647/*
648 * Obsolete - for backwards compatibility only
649 */
650static void k_dead(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
651{
652 static unsigned char ret_diacr[NR_DEAD] = {'`', '\'', '^', '~', '"', ',' };
653 value = ret_diacr[value];
654 k_dead2(vc, value, up_flag, regs);
655}
656
657static void k_cons(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
658{
659 if (up_flag)
660 return;
661 set_console(value);
662}
663
664static void k_fn(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
665{
666 unsigned v;
667
668 if (up_flag)
669 return;
670 v = value;
671 if (v < ARRAY_SIZE(func_table)) {
672 if (func_table[value])
673 puts_queue(vc, func_table[value]);
674 } else
675 printk(KERN_ERR "k_fn called with value=%d\n", value);
676}
677
678static void k_cur(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
679{
680 static const char *cur_chars = "BDCA";
681
682 if (up_flag)
683 return;
684 applkey(vc, cur_chars[value], vc_kbd_mode(kbd, VC_CKMODE));
685}
686
687static void k_pad(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
688{
689 static const char *pad_chars = "0123456789+-*/\015,.?()#";
690 static const char *app_map = "pqrstuvwxylSRQMnnmPQS";
691
692 if (up_flag)
693 return; /* no action, if this is a key release */
694
695 /* kludge... shift forces cursor/number keys */
696 if (vc_kbd_mode(kbd, VC_APPLIC) && !shift_down[KG_SHIFT]) {
697 applkey(vc, app_map[value], 1);
698 return;
699 }
700
701 if (!vc_kbd_led(kbd, VC_NUMLOCK))
702 switch (value) {
703 case KVAL(K_PCOMMA):
704 case KVAL(K_PDOT):
705 k_fn(vc, KVAL(K_REMOVE), 0, regs);
706 return;
707 case KVAL(K_P0):
708 k_fn(vc, KVAL(K_INSERT), 0, regs);
709 return;
710 case KVAL(K_P1):
711 k_fn(vc, KVAL(K_SELECT), 0, regs);
712 return;
713 case KVAL(K_P2):
714 k_cur(vc, KVAL(K_DOWN), 0, regs);
715 return;
716 case KVAL(K_P3):
717 k_fn(vc, KVAL(K_PGDN), 0, regs);
718 return;
719 case KVAL(K_P4):
720 k_cur(vc, KVAL(K_LEFT), 0, regs);
721 return;
722 case KVAL(K_P6):
723 k_cur(vc, KVAL(K_RIGHT), 0, regs);
724 return;
725 case KVAL(K_P7):
726 k_fn(vc, KVAL(K_FIND), 0, regs);
727 return;
728 case KVAL(K_P8):
729 k_cur(vc, KVAL(K_UP), 0, regs);
730 return;
731 case KVAL(K_P9):
732 k_fn(vc, KVAL(K_PGUP), 0, regs);
733 return;
734 case KVAL(K_P5):
735 applkey(vc, 'G', vc_kbd_mode(kbd, VC_APPLIC));
736 return;
737 }
738
739 put_queue(vc, pad_chars[value]);
740 if (value == KVAL(K_PENTER) && vc_kbd_mode(kbd, VC_CRLF))
741 put_queue(vc, 10);
742}
743
744static void k_shift(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
745{
746 int old_state = shift_state;
747
748 if (rep)
749 return;
750 /*
751 * Mimic typewriter:
752 * a CapsShift key acts like Shift but undoes CapsLock
753 */
754 if (value == KVAL(K_CAPSSHIFT)) {
755 value = KVAL(K_SHIFT);
756 if (!up_flag)
757 clr_vc_kbd_led(kbd, VC_CAPSLOCK);
758 }
759
760 if (up_flag) {
761 /*
762 * handle the case that two shift or control
763 * keys are depressed simultaneously
764 */
765 if (shift_down[value])
766 shift_down[value]--;
767 } else
768 shift_down[value]++;
769
770 if (shift_down[value])
771 shift_state |= (1 << value);
772 else
773 shift_state &= ~(1 << value);
774
775 /* kludge */
776 if (up_flag && shift_state != old_state && npadch != -1) {
777 if (kbd->kbdmode == VC_UNICODE)
778 to_utf8(vc, npadch & 0xffff);
779 else
780 put_queue(vc, npadch & 0xff);
781 npadch = -1;
782 }
783}
784
785static void k_meta(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
786{
787 if (up_flag)
788 return;
789
790 if (vc_kbd_mode(kbd, VC_META)) {
791 put_queue(vc, '\033');
792 put_queue(vc, value);
793 } else
794 put_queue(vc, value | 0x80);
795}
796
797static void k_ascii(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
798{
799 int base;
800
801 if (up_flag)
802 return;
803
804 if (value < 10) {
805 /* decimal input of code, while Alt depressed */
806 base = 10;
807 } else {
808 /* hexadecimal input of code, while AltGr depressed */
809 value -= 10;
810 base = 16;
811 }
812
813 if (npadch == -1)
814 npadch = value;
815 else
816 npadch = npadch * base + value;
817}
818
819static void k_lock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
820{
821 if (up_flag || rep)
822 return;
823 chg_vc_kbd_lock(kbd, value);
824}
825
826static void k_slock(struct vc_data *vc, unsigned char value, char up_flag, struct pt_regs *regs)
827{
828 k_shift(vc, value, up_flag, regs);
829 if (up_flag || rep)
830 return;
831 chg_vc_kbd_slock(kbd, value);
832 /* try to make Alt, oops, AltGr and such work */
833 if (!key_maps[kbd->lockstate ^ kbd->slockstate]) {
834 kbd->slockstate = 0;
835 chg_vc_kbd_slock(kbd, value);
836 }
837}
838
839/*
840 * The leds display either (i) the status of NumLock, CapsLock, ScrollLock,
841 * or (ii) whatever pattern of lights people want to show using KDSETLED,
842 * or (iii) specified bits of specified words in kernel memory.
843 */
844unsigned char getledstate(void)
845{
846 return ledstate;
847}
848
849void setledstate(struct kbd_struct *kbd, unsigned int led)
850{
851 if (!(led & ~7)) {
852 ledioctl = led;
853 kbd->ledmode = LED_SHOW_IOCTL;
854 } else
855 kbd->ledmode = LED_SHOW_FLAGS;
856 set_leds();
857}
858
859static inline unsigned char getleds(void)
860{
861 struct kbd_struct *kbd = kbd_table + fg_console;
862 unsigned char leds;
863 int i;
864
865 if (kbd->ledmode == LED_SHOW_IOCTL)
866 return ledioctl;
867
868 leds = kbd->ledflagstate;
869
870 if (kbd->ledmode == LED_SHOW_MEM) {
871 for (i = 0; i < 3; i++)
872 if (ledptrs[i].valid) {
873 if (*ledptrs[i].addr & ledptrs[i].mask)
874 leds |= (1 << i);
875 else
876 leds &= ~(1 << i);
877 }
878 }
879 return leds;
880}
881
882/*
883 * This routine is the bottom half of the keyboard interrupt
884 * routine, and runs with all interrupts enabled. It does
885 * console changing, led setting and copy_to_cooked, which can
886 * take a reasonably long time.
887 *
888 * Aside from timing (which isn't really that important for
889 * keyboard interrupts as they happen often), using the software
890 * interrupt routines for this thing allows us to easily mask
891 * this when we don't want any of the above to happen.
892 * This allows for easy and efficient race-condition prevention
893 * for kbd_refresh_leds => input_event(dev, EV_LED, ...) => ...
894 */
895
896static void kbd_bh(unsigned long dummy)
897{
898 struct list_head * node;
899 unsigned char leds = getleds();
900
901 if (leds != ledstate) {
902 list_for_each(node,&kbd_handler.h_list) {
903 struct input_handle * handle = to_handle_h(node);
904 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
905 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
906 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
907 input_sync(handle->dev);
908 }
909 }
910
911 ledstate = leds;
912}
913
914DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
915
916/*
917 * This allows a newly plugged keyboard to pick the LED state.
918 */
919static void kbd_refresh_leds(struct input_handle *handle)
920{
921 unsigned char leds = ledstate;
922
923 tasklet_disable(&keyboard_tasklet);
924 if (leds != 0xff) {
925 input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
926 input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
927 input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
928 input_sync(handle->dev);
929 }
930 tasklet_enable(&keyboard_tasklet);
931}
932
933#if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
934 defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC32) ||\
935 defined(CONFIG_SPARC64) || defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
936 (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
937
938#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
939 ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
940
941static unsigned short x86_keycodes[256] =
942 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
943 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
944 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
945 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
946 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
947 80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
948 284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
949 367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
950 360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
951 103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
952 291,108,381,281,290,272,292,305,280, 99,112,257,258,359,113,114,
953 264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
954 377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
955 308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
956 332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
957
958#ifdef CONFIG_MAC_EMUMOUSEBTN
959extern int mac_hid_mouse_emulate_buttons(int, int, int);
960#endif /* CONFIG_MAC_EMUMOUSEBTN */
961
962#if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
963static int sparc_l1_a_state = 0;
964extern void sun_do_break(void);
965#endif
966
967static int emulate_raw(struct vc_data *vc, unsigned int keycode,
968 unsigned char up_flag)
969{
970 if (keycode > 255 || !x86_keycodes[keycode])
971 return -1;
972
973 switch (keycode) {
974 case KEY_PAUSE:
975 put_queue(vc, 0xe1);
976 put_queue(vc, 0x1d | up_flag);
977 put_queue(vc, 0x45 | up_flag);
978 return 0;
979 case KEY_HANGUEL:
980 if (!up_flag) put_queue(vc, 0xf1);
981 return 0;
982 case KEY_HANJA:
983 if (!up_flag) put_queue(vc, 0xf2);
984 return 0;
985 }
986
987 if (keycode == KEY_SYSRQ && sysrq_alt) {
988 put_queue(vc, 0x54 | up_flag);
989 return 0;
990 }
991
992 if (x86_keycodes[keycode] & 0x100)
993 put_queue(vc, 0xe0);
994
995 put_queue(vc, (x86_keycodes[keycode] & 0x7f) | up_flag);
996
997 if (keycode == KEY_SYSRQ) {
998 put_queue(vc, 0xe0);
999 put_queue(vc, 0x37 | up_flag);
1000 }
1001
1002 return 0;
1003}
1004
1005#else
1006
1007#define HW_RAW(dev) 0
1008
1009#warning "Cannot generate rawmode keyboard for your architecture yet."
1010
1011static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1012{
1013 if (keycode > 127)
1014 return -1;
1015
1016 put_queue(vc, keycode | up_flag);
1017 return 0;
1018}
1019#endif
1020
1021static void kbd_rawcode(unsigned char data)
1022{
1023 struct vc_data *vc = vc_cons[fg_console].d;
1024 kbd = kbd_table + fg_console;
1025 if (kbd->kbdmode == VC_RAW)
1026 put_queue(vc, data);
1027}
1028
1029void kbd_keycode(unsigned int keycode, int down, int hw_raw, struct pt_regs *regs)
1030{
1031 struct vc_data *vc = vc_cons[fg_console].d;
1032 unsigned short keysym, *key_map;
1033 unsigned char type, raw_mode;
1034 struct tty_struct *tty;
1035 int shift_final;
1036
1037 tty = vc->vc_tty;
1038
1039 if (tty && (!tty->driver_data)) {
1040 /* No driver data? Strange. Okay we fix it then. */
1041 tty->driver_data = vc;
1042 }
1043
1044 kbd = kbd_table + fg_console;
1045
1046 if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1047 sysrq_alt = down;
1048#if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1049 if (keycode == KEY_STOP)
1050 sparc_l1_a_state = down;
1051#endif
1052
1053 rep = (down == 2);
1054
1055#ifdef CONFIG_MAC_EMUMOUSEBTN
1056 if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1057 return;
1058#endif /* CONFIG_MAC_EMUMOUSEBTN */
1059
1060 if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1061 if (emulate_raw(vc, keycode, !down << 7))
1062 if (keycode < BTN_MISC)
1063 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1064
1065#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
1066 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1067 sysrq_down = down;
1068 return;
1069 }
1070 if (sysrq_down && down && !rep) {
1071 handle_sysrq(kbd_sysrq_xlate[keycode], regs, tty);
1072 return;
1073 }
1074#endif
1075#if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
1076 if (keycode == KEY_A && sparc_l1_a_state) {
1077 sparc_l1_a_state = 0;
1078 sun_do_break();
1079 }
1080#endif
1081
1082 if (kbd->kbdmode == VC_MEDIUMRAW) {
1083 /*
1084 * This is extended medium raw mode, with keys above 127
1085 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1086 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1087 * interfere with anything else. The two bytes after 0 will
1088 * always have the up flag set not to interfere with older
1089 * applications. This allows for 16384 different keycodes,
1090 * which should be enough.
1091 */
1092 if (keycode < 128) {
1093 put_queue(vc, keycode | (!down << 7));
1094 } else {
1095 put_queue(vc, !down << 7);
1096 put_queue(vc, (keycode >> 7) | 0x80);
1097 put_queue(vc, keycode | 0x80);
1098 }
1099 raw_mode = 1;
1100 }
1101
1102 if (down)
1103 set_bit(keycode, key_down);
1104 else
1105 clear_bit(keycode, key_down);
1106
1107 if (rep && (!vc_kbd_mode(kbd, VC_REPEAT) || (tty &&
1108 (!L_ECHO(tty) && tty->driver->chars_in_buffer(tty))))) {
1109 /*
1110 * Don't repeat a key if the input buffers are not empty and the
1111 * characters get aren't echoed locally. This makes key repeat
1112 * usable with slow applications and under heavy loads.
1113 */
1114 return;
1115 }
1116
1117 shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
1118 key_map = key_maps[shift_final];
1119
1120 if (!key_map) {
1121 compute_shiftstate();
1122 kbd->slockstate = 0;
1123 return;
1124 }
1125
1126 if (keycode > NR_KEYS)
1127 return;
1128
1129 keysym = key_map[keycode];
1130 type = KTYP(keysym);
1131
1132 if (type < 0xf0) {
1133 if (down && !raw_mode) to_utf8(vc, keysym);
1134 return;
1135 }
1136
1137 type -= 0xf0;
1138
1139 if (raw_mode && type != KT_SPEC && type != KT_SHIFT)
1140 return;
1141
1142 if (type == KT_LETTER) {
1143 type = KT_LATIN;
1144 if (vc_kbd_led(kbd, VC_CAPSLOCK)) {
1145 key_map = key_maps[shift_final ^ (1 << KG_SHIFT)];
1146 if (key_map)
1147 keysym = key_map[keycode];
1148 }
1149 }
1150
1151 (*k_handler[type])(vc, keysym & 0xff, !down, regs);
1152
1153 if (type != KT_SLOCK)
1154 kbd->slockstate = 0;
1155}
1156
1157static void kbd_event(struct input_handle *handle, unsigned int event_type,
1158 unsigned int event_code, int value)
1159{
1160 if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1161 kbd_rawcode(value);
1162 if (event_type == EV_KEY)
1163 kbd_keycode(event_code, value, HW_RAW(handle->dev), handle->dev->regs);
1164 tasklet_schedule(&keyboard_tasklet);
1165 do_poke_blanked_console = 1;
1166 schedule_console_callback();
1167}
1168
1169static char kbd_name[] = "kbd";
1170
1171/*
1172 * When a keyboard (or other input device) is found, the kbd_connect
1173 * function is called. The function then looks at the device, and if it
1174 * likes it, it can open it and get events from it. In this (kbd_connect)
1175 * function, we should decide which VT to bind that keyboard to initially.
1176 */
1177static struct input_handle *kbd_connect(struct input_handler *handler,
1178 struct input_dev *dev,
1179 struct input_device_id *id)
1180{
1181 struct input_handle *handle;
1182 int i;
1183
1184 for (i = KEY_RESERVED; i < BTN_MISC; i++)
1185 if (test_bit(i, dev->keybit)) break;
1186
1187 if ((i == BTN_MISC) && !test_bit(EV_SND, dev->evbit))
1188 return NULL;
1189
1190 if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
1191 return NULL;
1192 memset(handle, 0, sizeof(struct input_handle));
1193
1194 handle->dev = dev;
1195 handle->handler = handler;
1196 handle->name = kbd_name;
1197
1198 input_open_device(handle);
1199 kbd_refresh_leds(handle);
1200
1201 return handle;
1202}
1203
1204static void kbd_disconnect(struct input_handle *handle)
1205{
1206 input_close_device(handle);
1207 kfree(handle);
1208}
1209
1210static struct input_device_id kbd_ids[] = {
1211 {
1212 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1213 .evbit = { BIT(EV_KEY) },
1214 },
1215
1216 {
1217 .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1218 .evbit = { BIT(EV_SND) },
1219 },
1220
1221 { }, /* Terminating entry */
1222};
1223
1224MODULE_DEVICE_TABLE(input, kbd_ids);
1225
1226static struct input_handler kbd_handler = {
1227 .event = kbd_event,
1228 .connect = kbd_connect,
1229 .disconnect = kbd_disconnect,
1230 .name = "kbd",
1231 .id_table = kbd_ids,
1232};
1233
1234int __init kbd_init(void)
1235{
1236 int i;
1237
1238 kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
1239 kbd0.ledmode = LED_SHOW_FLAGS;
1240 kbd0.lockstate = KBD_DEFLOCK;
1241 kbd0.slockstate = 0;
1242 kbd0.modeflags = KBD_DEFMODE;
1243 kbd0.kbdmode = VC_XLATE;
1244
1245 for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
1246 kbd_table[i] = kbd0;
1247
1248 input_register_handler(&kbd_handler);
1249
1250 tasklet_enable(&keyboard_tasklet);
1251 tasklet_schedule(&keyboard_tasklet);
1252
1253 return 0;
1254}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-23 07:05:37 -0500