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