OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [char/] [keyboard.c] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/*
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/consolemap.h>
42
#include <linux/sysrq.h>
43
#include <linux/input.h>
44
#include <linux/reboot.h>
45
#include <linux/notifier.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 = handle->dev->getkeycode(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 = handle->dev->setkeycode(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
                            jiffies - releasestart > (brl_timeout * HZ) / 1000) {
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
 
1039
#define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
1040
                        ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
1041
 
1042
static const unsigned short x86_keycodes[256] =
1043
        { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
1044
         16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1045
         32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1046
         48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1047
         64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1048
         80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
1049
        284,285,309,  0,312, 91,327,328,329,331,333,335,336,337,338,339,
1050
        367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
1051
        360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
1052
        103,104,105,275,287,279,258,106,274,107,294,364,358,363,362,361,
1053
        291,108,381,281,290,272,292,305,280, 99,112,257,306,359,113,114,
1054
        264,117,271,374,379,265,266, 93, 94, 95, 85,259,375,260, 90,116,
1055
        377,109,111,277,278,282,283,295,296,297,299,300,301,293,303,307,
1056
        308,310,313,314,315,317,318,319,320,357,322,323,324,325,276,330,
1057
        332,340,365,342,343,344,345,346,356,270,341,368,369,370,371,372 };
1058
 
1059
#ifdef CONFIG_SPARC
1060
static int sparc_l1_a_state = 0;
1061
extern void sun_do_break(void);
1062
#endif
1063
 
1064
static int emulate_raw(struct vc_data *vc, unsigned int keycode,
1065
                       unsigned char up_flag)
1066
{
1067
        int code;
1068
 
1069
        switch (keycode) {
1070
                case KEY_PAUSE:
1071
                        put_queue(vc, 0xe1);
1072
                        put_queue(vc, 0x1d | up_flag);
1073
                        put_queue(vc, 0x45 | up_flag);
1074
                        break;
1075
 
1076
                case KEY_HANGEUL:
1077
                        if (!up_flag)
1078
                                put_queue(vc, 0xf2);
1079
                        break;
1080
 
1081
                case KEY_HANJA:
1082
                        if (!up_flag)
1083
                                put_queue(vc, 0xf1);
1084
                        break;
1085
 
1086
                case KEY_SYSRQ:
1087
                        /*
1088
                         * Real AT keyboards (that's what we're trying
1089
                         * to emulate here emit 0xe0 0x2a 0xe0 0x37 when
1090
                         * pressing PrtSc/SysRq alone, but simply 0x54
1091
                         * when pressing Alt+PrtSc/SysRq.
1092
                         */
1093
                        if (sysrq_alt) {
1094
                                put_queue(vc, 0x54 | up_flag);
1095
                        } else {
1096
                                put_queue(vc, 0xe0);
1097
                                put_queue(vc, 0x2a | up_flag);
1098
                                put_queue(vc, 0xe0);
1099
                                put_queue(vc, 0x37 | up_flag);
1100
                        }
1101
                        break;
1102
 
1103
                default:
1104
                        if (keycode > 255)
1105
                                return -1;
1106
 
1107
                        code = x86_keycodes[keycode];
1108
                        if (!code)
1109
                                return -1;
1110
 
1111
                        if (code & 0x100)
1112
                                put_queue(vc, 0xe0);
1113
                        put_queue(vc, (code & 0x7f) | up_flag);
1114
 
1115
                        break;
1116
        }
1117
 
1118
        return 0;
1119
}
1120
 
1121
#else
1122
 
1123
#define HW_RAW(dev)     0
1124
 
1125
#warning "Cannot generate rawmode keyboard for your architecture yet."
1126
 
1127
static int emulate_raw(struct vc_data *vc, unsigned int keycode, unsigned char up_flag)
1128
{
1129
        if (keycode > 127)
1130
                return -1;
1131
 
1132
        put_queue(vc, keycode | up_flag);
1133
        return 0;
1134
}
1135
#endif
1136
 
1137
static void kbd_rawcode(unsigned char data)
1138
{
1139
        struct vc_data *vc = vc_cons[fg_console].d;
1140
        kbd = kbd_table + fg_console;
1141
        if (kbd->kbdmode == VC_RAW)
1142
                put_queue(vc, data);
1143
}
1144
 
1145
static void kbd_keycode(unsigned int keycode, int down, int hw_raw)
1146
{
1147
        struct vc_data *vc = vc_cons[fg_console].d;
1148
        unsigned short keysym, *key_map;
1149
        unsigned char type, raw_mode;
1150
        struct tty_struct *tty;
1151
        int shift_final;
1152
        struct keyboard_notifier_param param = { .vc = vc, .value = keycode, .down = down };
1153
 
1154
        tty = vc->vc_tty;
1155
 
1156
        if (tty && (!tty->driver_data)) {
1157
                /* No driver data? Strange. Okay we fix it then. */
1158
                tty->driver_data = vc;
1159
        }
1160
 
1161
        kbd = kbd_table + fg_console;
1162
 
1163
        if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
1164
                sysrq_alt = down ? keycode : 0;
1165
#ifdef CONFIG_SPARC
1166
        if (keycode == KEY_STOP)
1167
                sparc_l1_a_state = down;
1168
#endif
1169
 
1170
        rep = (down == 2);
1171
 
1172
#ifdef CONFIG_MAC_EMUMOUSEBTN
1173
        if (mac_hid_mouse_emulate_buttons(1, keycode, down))
1174
                return;
1175
#endif /* CONFIG_MAC_EMUMOUSEBTN */
1176
 
1177
        if ((raw_mode = (kbd->kbdmode == VC_RAW)) && !hw_raw)
1178
                if (emulate_raw(vc, keycode, !down << 7))
1179
                        if (keycode < BTN_MISC && printk_ratelimit())
1180
                                printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
1181
 
1182
#ifdef CONFIG_MAGIC_SYSRQ              /* Handle the SysRq Hack */
1183
        if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
1184
                if (!sysrq_down) {
1185
                        sysrq_down = down;
1186
                        sysrq_alt_use = sysrq_alt;
1187
                }
1188
                return;
1189
        }
1190
        if (sysrq_down && !down && keycode == sysrq_alt_use)
1191
                sysrq_down = 0;
1192
        if (sysrq_down && down && !rep) {
1193
                handle_sysrq(kbd_sysrq_xlate[keycode], tty);
1194
                return;
1195
        }
1196
#endif
1197
#ifdef CONFIG_SPARC
1198
        if (keycode == KEY_A && sparc_l1_a_state) {
1199
                sparc_l1_a_state = 0;
1200
                sun_do_break();
1201
        }
1202
#endif
1203
 
1204
        if (kbd->kbdmode == VC_MEDIUMRAW) {
1205
                /*
1206
                 * This is extended medium raw mode, with keys above 127
1207
                 * encoded as 0, high 7 bits, low 7 bits, with the 0 bearing
1208
                 * the 'up' flag if needed. 0 is reserved, so this shouldn't
1209
                 * interfere with anything else. The two bytes after 0 will
1210
                 * always have the up flag set not to interfere with older
1211
                 * applications. This allows for 16384 different keycodes,
1212
                 * which should be enough.
1213
                 */
1214
                if (keycode < 128) {
1215
                        put_queue(vc, keycode | (!down << 7));
1216
                } else {
1217
                        put_queue(vc, !down << 7);
1218
                        put_queue(vc, (keycode >> 7) | 0x80);
1219
                        put_queue(vc, keycode | 0x80);
1220
                }
1221
                raw_mode = 1;
1222
        }
1223
 
1224
        if (down)
1225
                set_bit(keycode, key_down);
1226
        else
1227
                clear_bit(keycode, key_down);
1228
 
1229
        if (rep &&
1230
            (!vc_kbd_mode(kbd, VC_REPEAT) ||
1231
             (tty && !L_ECHO(tty) && tty->driver->chars_in_buffer(tty)))) {
1232
                /*
1233
                 * Don't repeat a key if the input buffers are not empty and the
1234
                 * characters get aren't echoed locally. This makes key repeat
1235
                 * usable with slow applications and under heavy loads.
1236
                 */
1237
                return;
1238
        }
1239
 
1240
        param.shift = shift_final = (shift_state | kbd->slockstate) ^ kbd->lockstate;
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
        atomic_notifier_call_chain(&keyboard_notifier_list, KBD_POST_KEYSYM, &param);
1290
 
1291
        if (type != KT_SLOCK)
1292
                kbd->slockstate = 0;
1293
}
1294
 
1295
static void kbd_event(struct input_handle *handle, unsigned int event_type,
1296
                      unsigned int event_code, int value)
1297
{
1298
        if (event_type == EV_MSC && event_code == MSC_RAW && HW_RAW(handle->dev))
1299
                kbd_rawcode(value);
1300
        if (event_type == EV_KEY)
1301
                kbd_keycode(event_code, value, HW_RAW(handle->dev));
1302
        tasklet_schedule(&keyboard_tasklet);
1303
        do_poke_blanked_console = 1;
1304
        schedule_console_callback();
1305
}
1306
 
1307
/*
1308
 * When a keyboard (or other input device) is found, the kbd_connect
1309
 * function is called. The function then looks at the device, and if it
1310
 * likes it, it can open it and get events from it. In this (kbd_connect)
1311
 * function, we should decide which VT to bind that keyboard to initially.
1312
 */
1313
static int kbd_connect(struct input_handler *handler, struct input_dev *dev,
1314
                        const struct input_device_id *id)
1315
{
1316
        struct input_handle *handle;
1317
        int error;
1318
        int i;
1319
 
1320
        for (i = KEY_RESERVED; i < BTN_MISC; i++)
1321
                if (test_bit(i, dev->keybit))
1322
                        break;
1323
 
1324
        if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
1325
                return -ENODEV;
1326
 
1327
        handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
1328
        if (!handle)
1329
                return -ENOMEM;
1330
 
1331
        handle->dev = dev;
1332
        handle->handler = handler;
1333
        handle->name = "kbd";
1334
 
1335
        error = input_register_handle(handle);
1336
        if (error)
1337
                goto err_free_handle;
1338
 
1339
        error = input_open_device(handle);
1340
        if (error)
1341
                goto err_unregister_handle;
1342
 
1343
        return 0;
1344
 
1345
 err_unregister_handle:
1346
        input_unregister_handle(handle);
1347
 err_free_handle:
1348
        kfree(handle);
1349
        return error;
1350
}
1351
 
1352
static void kbd_disconnect(struct input_handle *handle)
1353
{
1354
        input_close_device(handle);
1355
        input_unregister_handle(handle);
1356
        kfree(handle);
1357
}
1358
 
1359
/*
1360
 * Start keyboard handler on the new keyboard by refreshing LED state to
1361
 * match the rest of the system.
1362
 */
1363
static void kbd_start(struct input_handle *handle)
1364
{
1365
        unsigned char leds = ledstate;
1366
 
1367
        tasklet_disable(&keyboard_tasklet);
1368
        if (leds != 0xff) {
1369
                input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
1370
                input_inject_event(handle, EV_LED, LED_NUML,    !!(leds & 0x02));
1371
                input_inject_event(handle, EV_LED, LED_CAPSL,   !!(leds & 0x04));
1372
                input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
1373
        }
1374
        tasklet_enable(&keyboard_tasklet);
1375
}
1376
 
1377
static const struct input_device_id kbd_ids[] = {
1378
        {
1379
                .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1380
                .evbit = { BIT_MASK(EV_KEY) },
1381
        },
1382
 
1383
        {
1384
                .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
1385
                .evbit = { BIT_MASK(EV_SND) },
1386
        },
1387
 
1388
        { },    /* Terminating entry */
1389
};
1390
 
1391
MODULE_DEVICE_TABLE(input, kbd_ids);
1392
 
1393
static struct input_handler kbd_handler = {
1394
        .event          = kbd_event,
1395
        .connect        = kbd_connect,
1396
        .disconnect     = kbd_disconnect,
1397
        .start          = kbd_start,
1398
        .name           = "kbd",
1399
        .id_table       = kbd_ids,
1400
};
1401
 
1402
int __init kbd_init(void)
1403
{
1404
        int i;
1405
        int error;
1406
 
1407
        for (i = 0; i < MAX_NR_CONSOLES; i++) {
1408
                kbd_table[i].ledflagstate = KBD_DEFLEDS;
1409
                kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
1410
                kbd_table[i].ledmode = LED_SHOW_FLAGS;
1411
                kbd_table[i].lockstate = KBD_DEFLOCK;
1412
                kbd_table[i].slockstate = 0;
1413
                kbd_table[i].modeflags = KBD_DEFMODE;
1414
                kbd_table[i].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE;
1415
        }
1416
 
1417
        error = input_register_handler(&kbd_handler);
1418
        if (error)
1419
                return error;
1420
 
1421
        tasklet_enable(&keyboard_tasklet);
1422
        tasklet_schedule(&keyboard_tasklet);
1423
 
1424
        return 0;
1425
}

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.