2 * AT and PS/2 keyboard driver
4 * Copyright (c) 1999-2002 Vojtech Pavlik
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published by
10 * the Free Software Foundation.
14 * This driver can handle standard AT keyboards and PS/2 keyboards in
15 * Translated and Raw Set 2 and Set 3, as well as AT keyboards on dumb
16 * input-only controllers and AT keyboards connected over a one way RS232
20 #include <linux/delay.h>
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/slab.h>
24 #include <linux/interrupt.h>
25 #include <linux/init.h>
26 #include <linux/input.h>
27 #include <linux/serio.h>
28 #include <linux/workqueue.h>
29 #include <linux/libps2.h>
31 #define DRIVER_DESC "AT and PS/2 keyboard driver"
33 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
34 MODULE_DESCRIPTION(DRIVER_DESC);
35 MODULE_LICENSE("GPL");
37 static int atkbd_set = 2;
38 module_param_named(set, atkbd_set, int, 0);
39 MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");
41 #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
42 static int atkbd_reset;
44 static int atkbd_reset = 1;
46 module_param_named(reset, atkbd_reset, bool, 0);
47 MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
49 static int atkbd_softrepeat;
50 module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
51 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
53 static int atkbd_softraw = 1;
54 module_param_named(softraw, atkbd_softraw, bool, 0);
55 MODULE_PARM_DESC(softraw, "Use software generated rawmode");
57 static int atkbd_scroll;
58 module_param_named(scroll, atkbd_scroll, bool, 0);
59 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
61 static int atkbd_extra;
62 module_param_named(extra, atkbd_extra, bool, 0);
63 MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
65 __obsolete_setup("atkbd_set=");
66 __obsolete_setup("atkbd_reset");
67 __obsolete_setup("atkbd_softrepeat=");
70 * Scancode to keycode tables. These are just the default setting, and
71 * are loadable via an userland utility.
75 #include "hpps2atkbd.h"
78 static unsigned char atkbd_set2_keycode[512] = {
80 0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117,
81 0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0,
82 0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183,
83 0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185,
84 0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0,
85 0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85,
86 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0,
87 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
89 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
90 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
91 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
92 159, 0,115, 0,164, 0, 0,116,158, 0,150,166, 0, 0, 0,142,
93 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
94 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
95 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
96 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
103 static unsigned char atkbd_set3_keycode[512] = {
105 0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60,
106 131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62,
107 134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64,
108 136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66,
109 125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
110 113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
111 108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104,
112 82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183,
114 184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0,
115 0,139,150,163,165,115,152,150,166,140,160,154,113,114,167,168,
119 static unsigned char atkbd_unxlate_table[128] = {
120 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
121 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
122 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
123 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3,
124 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105,
125 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63,
126 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
127 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
130 #define ATKBD_CMD_SETLEDS 0x10ed
131 #define ATKBD_CMD_GSCANSET 0x11f0
132 #define ATKBD_CMD_SSCANSET 0x10f0
133 #define ATKBD_CMD_GETID 0x02f2
134 #define ATKBD_CMD_SETREP 0x10f3
135 #define ATKBD_CMD_ENABLE 0x00f4
136 #define ATKBD_CMD_RESET_DIS 0x00f5
137 #define ATKBD_CMD_SETALL_MBR 0x00fa
138 #define ATKBD_CMD_RESET_BAT 0x02ff
139 #define ATKBD_CMD_RESEND 0x00fe
140 #define ATKBD_CMD_EX_ENABLE 0x10ea
141 #define ATKBD_CMD_EX_SETLEDS 0x20eb
142 #define ATKBD_CMD_OK_GETID 0x02e8
145 #define ATKBD_RET_ACK 0xfa
146 #define ATKBD_RET_NAK 0xfe
147 #define ATKBD_RET_BAT 0xaa
148 #define ATKBD_RET_EMUL0 0xe0
149 #define ATKBD_RET_EMUL1 0xe1
150 #define ATKBD_RET_RELEASE 0xf0
151 #define ATKBD_RET_HANGUEL 0xf1
152 #define ATKBD_RET_HANJA 0xf2
153 #define ATKBD_RET_ERR 0xff
155 #define ATKBD_KEY_UNKNOWN 0
156 #define ATKBD_KEY_NULL 255
158 #define ATKBD_SCR_1 254
159 #define ATKBD_SCR_2 253
160 #define ATKBD_SCR_4 252
161 #define ATKBD_SCR_8 251
162 #define ATKBD_SCR_CLICK 250
164 #define ATKBD_SPECIAL 250
166 static unsigned char atkbd_scroll_keys[5][2] = {
167 { ATKBD_SCR_1, 0x45 },
168 { ATKBD_SCR_2, 0x29 },
169 { ATKBD_SCR_4, 0x36 },
170 { ATKBD_SCR_8, 0x27 },
171 { ATKBD_SCR_CLICK, 0x60 },
175 * The atkbd control structure
180 struct ps2dev ps2dev;
182 /* Written only during init */
185 struct input_dev dev;
188 unsigned char keycode[512];
190 unsigned char translated;
193 unsigned char softrepeat;
194 unsigned char softraw;
195 unsigned char scroll;
196 unsigned char enabled;
198 /* Accessed only from interrupt */
200 unsigned char resend;
201 unsigned char release;
202 unsigned char bat_xl;
207 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
208 ssize_t (*handler)(struct atkbd *, char *));
209 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
210 ssize_t (*handler)(struct atkbd *, const char *, size_t));
211 #define ATKBD_DEFINE_ATTR(_name) \
212 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
213 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \
214 static ssize_t atkbd_do_show_##_name(struct device *d, char *b) \
216 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
218 static ssize_t atkbd_do_set_##_name(struct device *d, const char *b, size_t s) \
220 return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \
222 static struct device_attribute atkbd_attr_##_name = \
223 __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
225 ATKBD_DEFINE_ATTR(extra);
226 ATKBD_DEFINE_ATTR(scroll);
227 ATKBD_DEFINE_ATTR(set);
228 ATKBD_DEFINE_ATTR(softrepeat);
229 ATKBD_DEFINE_ATTR(softraw);
232 static void atkbd_report_key(struct input_dev *dev, struct pt_regs *regs, int code, int value)
234 input_regs(dev, regs);
236 input_report_key(dev, code, 1);
238 input_report_key(dev, code, 0);
240 input_event(dev, EV_KEY, code, value);
245 * atkbd_interrupt(). Here takes place processing of data received from
246 * the keyboard into events.
249 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
250 unsigned int flags, struct pt_regs *regs)
252 struct atkbd *atkbd = serio->private;
253 unsigned int code = data;
254 int scroll = 0, click = -1;
258 printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
261 #if !defined(__i386__) && !defined (__x86_64__)
262 if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
263 printk(KERN_WARNING "atkbd.c: frame/parity error: %02x\n", flags);
264 serio_write(serio, ATKBD_CMD_RESEND);
269 if (!flags && data == ATKBD_RET_ACK)
273 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
274 if (ps2_handle_ack(&atkbd->ps2dev, data))
277 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
278 if (ps2_handle_response(&atkbd->ps2dev, data))
284 input_event(&atkbd->dev, EV_MSC, MSC_RAW, code);
286 if (atkbd->translated) {
289 !(code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1 ||
290 code == ATKBD_RET_HANGUEL || code == ATKBD_RET_HANJA ||
291 code == ATKBD_RET_ERR ||
292 (code == ATKBD_RET_BAT && !atkbd->bat_xl))) {
293 atkbd->release = code >> 7;
298 (code & 0x7f) == (ATKBD_RET_BAT & 0x7f))
299 atkbd->bat_xl = !atkbd->release;
305 serio_rescan(atkbd->ps2dev.serio);
307 case ATKBD_RET_EMUL0:
310 case ATKBD_RET_EMUL1:
313 case ATKBD_RET_RELEASE:
316 case ATKBD_RET_HANGUEL:
317 atkbd_report_key(&atkbd->dev, regs, KEY_HANGUEL, 3);
319 case ATKBD_RET_HANJA:
320 atkbd_report_key(&atkbd->dev, regs, KEY_HANJA, 3);
323 printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys);
328 code = (code & 0x7f) | ((code & 0x80) << 1);
332 code |= (atkbd->set != 3) ? 0x80 : 0x100;
335 if (atkbd->keycode[code] != ATKBD_KEY_NULL)
336 input_event(&atkbd->dev, EV_MSC, MSC_SCAN, code);
338 switch (atkbd->keycode[code]) {
341 case ATKBD_KEY_UNKNOWN:
342 if (data == ATKBD_RET_ACK || data == ATKBD_RET_NAK) {
343 printk(KERN_WARNING "atkbd.c: Spurious %s on %s. Some program, "
344 "like XFree86, might be trying access hardware directly.\n",
345 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
347 printk(KERN_WARNING "atkbd.c: Unknown key %s "
348 "(%s set %d, code %#x on %s).\n",
349 atkbd->release ? "released" : "pressed",
350 atkbd->translated ? "translated" : "raw",
351 atkbd->set, code, serio->phys);
352 printk(KERN_WARNING "atkbd.c: Use 'setkeycodes %s%02x <keycode>' "
353 "to make it known.\n",
354 code & 0x80 ? "e0" : "", code & 0x7f);
356 input_sync(&atkbd->dev);
359 scroll = 1 - atkbd->release * 2;
362 scroll = 2 - atkbd->release * 4;
365 scroll = 4 - atkbd->release * 8;
368 scroll = 8 - atkbd->release * 16;
370 case ATKBD_SCR_CLICK:
371 click = !atkbd->release;
374 value = atkbd->release ? 0 :
375 (1 + (!atkbd->softrepeat && test_bit(atkbd->keycode[code], atkbd->dev.key)));
377 switch (value) { /* Workaround Toshiba laptop multiple keypress */
383 atkbd->time = jiffies + (atkbd->dev.rep[REP_DELAY] * HZ + 500) / 1000 / 2;
386 if (!time_after(jiffies, atkbd->time) && atkbd->last == code)
391 atkbd_report_key(&atkbd->dev, regs, atkbd->keycode[code], value);
394 if (scroll || click != -1) {
395 input_regs(&atkbd->dev, regs);
396 input_report_key(&atkbd->dev, BTN_MIDDLE, click);
397 input_report_rel(&atkbd->dev, REL_WHEEL, scroll);
398 input_sync(&atkbd->dev);
408 * Event callback from the input module. Events that change the state of
409 * the hardware are processed here.
412 static int atkbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
414 struct atkbd *atkbd = dev->private;
415 const short period[32] =
416 { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125,
417 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
418 const short delay[4] =
419 { 250, 500, 750, 1000 };
420 unsigned char param[2];
430 param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
431 | (test_bit(LED_NUML, dev->led) ? 2 : 0)
432 | (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
433 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS);
437 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
438 | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
439 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
440 | (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
441 | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
442 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS);
450 if (atkbd->softrepeat) return 0;
453 while (i < 32 && period[i] < dev->rep[REP_PERIOD]) i++;
454 while (j < 4 && delay[j] < dev->rep[REP_DELAY]) j++;
455 dev->rep[REP_PERIOD] = period[i];
456 dev->rep[REP_DELAY] = delay[j];
457 param[0] = i | (j << 5);
458 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_SETREP);
467 * atkbd_enable() signals that interrupt handler is allowed to
468 * generate input events.
471 static inline void atkbd_enable(struct atkbd *atkbd)
473 serio_pause_rx(atkbd->ps2dev.serio);
475 serio_continue_rx(atkbd->ps2dev.serio);
479 * atkbd_disable() tells input handler that all incoming data except
480 * for ACKs and command response should be dropped.
483 static inline void atkbd_disable(struct atkbd *atkbd)
485 serio_pause_rx(atkbd->ps2dev.serio);
487 serio_continue_rx(atkbd->ps2dev.serio);
491 * atkbd_probe() probes for an AT keyboard on a serio port.
494 static int atkbd_probe(struct atkbd *atkbd)
496 struct ps2dev *ps2dev = &atkbd->ps2dev;
497 unsigned char param[2];
500 * Some systems, where the bit-twiddling when testing the io-lines of the
501 * controller may confuse the keyboard need a full reset of the keyboard. On
502 * these systems the BIOS also usually doesn't do it for us.
506 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
507 printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys);
510 * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
511 * Some keyboards report different values, but the first byte is always 0xab or
512 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
513 * should make sure we don't try to set the LEDs on it.
516 param[0] = param[1] = 0xa5; /* initialize with invalid values */
517 if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
520 * If the get ID command failed, we check if we can at least set the LEDs on
521 * the keyboard. This should work on every keyboard out there. It also turns
522 * the LEDs off, which we want anyway.
525 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
531 if (param[0] != 0xab && param[0] != 0xac && /* Regular and NCD Sun keyboards */
532 param[0] != 0x2b && param[0] != 0x5d && /* Trust keyboard, raw and translated */
533 param[0] != 0x60 && param[0] != 0x47) /* NMB SGI keyboard, raw and translated */
536 atkbd->id = (param[0] << 8) | param[1];
538 if (atkbd->id == 0xaca1 && atkbd->translated) {
539 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n");
540 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n");
548 * atkbd_select_set checks if a keyboard has a working Set 3 support, and
549 * sets it into that. Unfortunately there are keyboards that can be switched
550 * to Set 3, but don't work well in that (BTC Multimedia ...)
553 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
555 struct ps2dev *ps2dev = &atkbd->ps2dev;
556 unsigned char param[2];
560 * For known special keyboards we can go ahead and set the correct set.
561 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
562 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
565 if (atkbd->translated)
568 if (atkbd->id == 0xaca1) {
570 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
576 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
585 if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
586 atkbd->id = param[0] << 8 | param[1];
591 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
595 if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
600 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
604 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
609 static int atkbd_activate(struct atkbd *atkbd)
611 struct ps2dev *ps2dev = &atkbd->ps2dev;
612 unsigned char param[1];
615 * Set the LEDs to a defined state.
619 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
623 * Set autorepeat to fastest possible.
627 if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
631 * Enable the keyboard to receive keystrokes.
634 if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
635 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
636 ps2dev->serio->phys);
644 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
648 static void atkbd_cleanup(struct serio *serio)
650 struct atkbd *atkbd = serio->private;
651 ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT);
656 * atkbd_disconnect() closes and frees.
659 static void atkbd_disconnect(struct serio *serio)
661 struct atkbd *atkbd = serio->private;
663 atkbd_disable(atkbd);
665 /* make sure we don't have a command in flight */
666 synchronize_kernel();
667 flush_scheduled_work();
669 device_remove_file(&serio->dev, &atkbd_attr_extra);
670 device_remove_file(&serio->dev, &atkbd_attr_scroll);
671 device_remove_file(&serio->dev, &atkbd_attr_set);
672 device_remove_file(&serio->dev, &atkbd_attr_softrepeat);
673 device_remove_file(&serio->dev, &atkbd_attr_softraw);
675 input_unregister_device(&atkbd->dev);
682 * atkbd_set_device_attrs() initializes keyboard's keycode table
683 * according to the selected scancode set
686 static void atkbd_set_keycode_table(struct atkbd *atkbd)
690 memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
692 if (atkbd->translated) {
693 for (i = 0; i < 128; i++) {
694 atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
695 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
697 for (j = 0; i < 5; i++) {
698 if (atkbd_unxlate_table[i] == atkbd_scroll_keys[j][1])
699 atkbd->keycode[i] = atkbd_scroll_keys[j][0];
700 if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j][1])
701 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j][0];
704 } else if (atkbd->set == 3) {
705 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
707 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
710 for (i = 0; i < 5; i++)
711 atkbd->keycode[atkbd_scroll_keys[i][1]] = atkbd_scroll_keys[i][0];
716 * atkbd_set_device_attrs() sets up keyboard's input device structure
719 static void atkbd_set_device_attrs(struct atkbd *atkbd)
723 memset(&atkbd->dev, 0, sizeof(struct input_dev));
725 init_input_dev(&atkbd->dev);
727 atkbd->dev.name = atkbd->name;
728 atkbd->dev.phys = atkbd->phys;
729 atkbd->dev.id.bustype = BUS_I8042;
730 atkbd->dev.id.vendor = 0x0001;
731 atkbd->dev.id.product = atkbd->translated ? 1 : atkbd->set;
732 atkbd->dev.id.version = atkbd->id;
733 atkbd->dev.event = atkbd_event;
734 atkbd->dev.private = atkbd;
735 atkbd->dev.dev = &atkbd->ps2dev.serio->dev;
737 atkbd->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_MSC);
740 atkbd->dev.evbit[0] |= BIT(EV_LED);
741 atkbd->dev.ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL);
745 atkbd->dev.ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) |
746 BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC);
748 if (!atkbd->softrepeat) {
749 atkbd->dev.rep[REP_DELAY] = 250;
750 atkbd->dev.rep[REP_PERIOD] = 33;
753 atkbd->dev.mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN);
756 atkbd->dev.evbit[0] |= BIT(EV_REL);
757 atkbd->dev.relbit[0] = BIT(REL_WHEEL);
758 set_bit(BTN_MIDDLE, atkbd->dev.keybit);
761 atkbd->dev.keycode = atkbd->keycode;
762 atkbd->dev.keycodesize = sizeof(unsigned char);
763 atkbd->dev.keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
765 for (i = 0; i < 512; i++)
766 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
767 set_bit(atkbd->keycode[i], atkbd->dev.keybit);
771 * atkbd_connect() is called when the serio module finds and interface
772 * that isn't handled yet by an appropriate device driver. We check if
773 * there is an AT keyboard out there and if yes, we register ourselves
774 * to the input module.
777 static void atkbd_connect(struct serio *serio, struct serio_driver *drv)
781 if (!(atkbd = kmalloc(sizeof(struct atkbd), GFP_KERNEL)))
783 memset(atkbd, 0, sizeof(struct atkbd));
785 ps2_init(&atkbd->ps2dev, serio);
787 switch (serio->type & SERIO_TYPE) {
790 atkbd->translated = 1;
796 if ((serio->type & SERIO_PROTO) == SERIO_PS2SER)
803 atkbd->softraw = atkbd_softraw;
804 atkbd->softrepeat = atkbd_softrepeat;
805 atkbd->scroll = atkbd_scroll;
808 atkbd->softrepeat = 1;
810 if (atkbd->softrepeat)
813 serio->private = atkbd;
815 if (serio_open(serio, drv)) {
822 if (atkbd_probe(atkbd)) {
824 serio->private = NULL;
829 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
830 atkbd_activate(atkbd);
838 sprintf(atkbd->name, "AT Set 2 Extra keyboard");
840 sprintf(atkbd->name, "AT %s Set %d keyboard",
841 atkbd->translated ? "Translated" : "Raw", atkbd->set);
843 sprintf(atkbd->phys, "%s/input0", serio->phys);
845 atkbd_set_keycode_table(atkbd);
846 atkbd_set_device_attrs(atkbd);
848 input_register_device(&atkbd->dev);
850 device_create_file(&serio->dev, &atkbd_attr_extra);
851 device_create_file(&serio->dev, &atkbd_attr_scroll);
852 device_create_file(&serio->dev, &atkbd_attr_set);
853 device_create_file(&serio->dev, &atkbd_attr_softrepeat);
854 device_create_file(&serio->dev, &atkbd_attr_softraw);
858 printk(KERN_INFO "input: %s on %s\n", atkbd->name, serio->phys);
862 * atkbd_reconnect() tries to restore keyboard into a sane state and is
863 * most likely called on resume.
866 static int atkbd_reconnect(struct serio *serio)
868 struct atkbd *atkbd = serio->private;
869 struct serio_driver *drv = serio->drv;
870 unsigned char param[1];
872 if (!atkbd || !drv) {
873 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
877 atkbd_disable(atkbd);
880 param[0] = (test_bit(LED_SCROLLL, atkbd->dev.led) ? 1 : 0)
881 | (test_bit(LED_NUML, atkbd->dev.led) ? 2 : 0)
882 | (test_bit(LED_CAPSL, atkbd->dev.led) ? 4 : 0);
884 if (atkbd_probe(atkbd))
886 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
889 atkbd_activate(atkbd);
891 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
900 static struct serio_driver atkbd_drv = {
904 .description = DRIVER_DESC,
905 .interrupt = atkbd_interrupt,
906 .connect = atkbd_connect,
907 .reconnect = atkbd_reconnect,
908 .disconnect = atkbd_disconnect,
909 .cleanup = atkbd_cleanup,
912 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
913 ssize_t (*handler)(struct atkbd *, char *))
915 struct serio *serio = to_serio_port(dev);
918 retval = serio_pin_driver(serio);
922 if (serio->drv != &atkbd_drv) {
927 retval = handler((struct atkbd *)serio->private, buf);
930 serio_unpin_driver(serio);
934 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
935 ssize_t (*handler)(struct atkbd *, const char *, size_t))
937 struct serio *serio = to_serio_port(dev);
941 retval = serio_pin_driver(serio);
945 if (serio->drv != &atkbd_drv) {
950 atkbd = serio->private;
951 atkbd_disable(atkbd);
952 retval = handler(atkbd, buf, count);
956 serio_unpin_driver(serio);
960 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
962 return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
965 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
973 value = simple_strtoul(buf, &rest, 10);
974 if (*rest || value > 1)
977 if (atkbd->extra != value) {
978 /* unregister device as it's properties will change */
979 input_unregister_device(&atkbd->dev);
980 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
981 atkbd_activate(atkbd);
982 atkbd_set_device_attrs(atkbd);
983 input_register_device(&atkbd->dev);
988 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
990 return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
993 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
998 value = simple_strtoul(buf, &rest, 10);
999 if (*rest || value > 1)
1002 if (atkbd->scroll != value) {
1003 /* unregister device as it's properties will change */
1004 input_unregister_device(&atkbd->dev);
1005 atkbd->scroll = value;
1006 atkbd_set_keycode_table(atkbd);
1007 atkbd_set_device_attrs(atkbd);
1008 input_register_device(&atkbd->dev);
1013 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1015 return sprintf(buf, "%d\n", atkbd->set);
1018 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1020 unsigned long value;
1026 value = simple_strtoul(buf, &rest, 10);
1027 if (*rest || (value != 2 && value != 3))
1030 if (atkbd->set != value) {
1031 /* unregister device as it's properties will change */
1032 input_unregister_device(&atkbd->dev);
1033 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1034 atkbd_activate(atkbd);
1035 atkbd_set_keycode_table(atkbd);
1036 atkbd_set_device_attrs(atkbd);
1037 input_register_device(&atkbd->dev);
1042 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1044 return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1047 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1049 unsigned long value;
1055 value = simple_strtoul(buf, &rest, 10);
1056 if (*rest || value > 1)
1059 if (atkbd->softrepeat != value) {
1060 /* unregister device as it's properties will change */
1061 input_unregister_device(&atkbd->dev);
1062 atkbd->softrepeat = value;
1063 if (atkbd->softrepeat)
1065 atkbd_set_device_attrs(atkbd);
1066 input_register_device(&atkbd->dev);
1073 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1075 return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1078 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1080 unsigned long value;
1083 value = simple_strtoul(buf, &rest, 10);
1084 if (*rest || value > 1)
1087 if (atkbd->softraw != value) {
1088 /* unregister device as it's properties will change */
1089 input_unregister_device(&atkbd->dev);
1090 atkbd->softraw = value;
1091 atkbd_set_device_attrs(atkbd);
1092 input_register_device(&atkbd->dev);
1098 int __init atkbd_init(void)
1100 serio_register_driver(&atkbd_drv);
1104 void __exit atkbd_exit(void)
1106 serio_unregister_driver(&atkbd_drv);
1109 module_init(atkbd_init);
1110 module_exit(atkbd_exit);