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