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