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 = 1;
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.
74 static unsigned char atkbd_set2_keycode[512] = {
76 #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
78 /* XXX: need a more general approach */
80 #include "hpps2atkbd.h" /* include the keyboard scancodes */
83 0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117,
84 0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0,
85 0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183,
86 0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185,
87 0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0,
88 0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85,
89 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0,
90 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
92 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
93 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
94 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
95 159, 0,115, 0,164, 0, 0,116,158, 0,150,166, 0, 0, 0,142,
96 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
97 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
98 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
99 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
105 static unsigned char atkbd_set3_keycode[512] = {
107 0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60,
108 131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62,
109 134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64,
110 136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66,
111 125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
112 113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
113 108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104,
114 82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183,
116 184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0,
117 0,139,150,163,165,115,152,150,166,140,160,154,113,114,167,168,
121 static unsigned char atkbd_unxlate_table[128] = {
122 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
123 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
124 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
125 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3,
126 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105,
127 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63,
128 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
129 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
132 #define ATKBD_CMD_SETLEDS 0x10ed
133 #define ATKBD_CMD_GSCANSET 0x11f0
134 #define ATKBD_CMD_SSCANSET 0x10f0
135 #define ATKBD_CMD_GETID 0x02f2
136 #define ATKBD_CMD_SETREP 0x10f3
137 #define ATKBD_CMD_ENABLE 0x00f4
138 #define ATKBD_CMD_RESET_DIS 0x00f5
139 #define ATKBD_CMD_SETALL_MBR 0x00fa
140 #define ATKBD_CMD_RESET_BAT 0x02ff
141 #define ATKBD_CMD_RESEND 0x00fe
142 #define ATKBD_CMD_EX_ENABLE 0x10ea
143 #define ATKBD_CMD_EX_SETLEDS 0x20eb
144 #define ATKBD_CMD_OK_GETID 0x02e8
146 #define ATKBD_RET_ACK 0xfa
147 #define ATKBD_RET_NAK 0xfe
148 #define ATKBD_RET_BAT 0xaa
149 #define ATKBD_RET_EMUL0 0xe0
150 #define ATKBD_RET_EMUL1 0xe1
151 #define ATKBD_RET_RELEASE 0xf0
152 #define ATKBD_RET_HANGUEL 0xf1
153 #define ATKBD_RET_HANJA 0xf2
154 #define ATKBD_RET_ERR 0xff
156 #define ATKBD_KEY_UNKNOWN 0
157 #define ATKBD_KEY_NULL 255
159 #define ATKBD_SCR_1 254
160 #define ATKBD_SCR_2 253
161 #define ATKBD_SCR_4 252
162 #define ATKBD_SCR_8 251
163 #define ATKBD_SCR_CLICK 250
164 #define ATKBD_SCR_LEFT 249
165 #define ATKBD_SCR_RIGHT 248
167 #define ATKBD_SPECIAL 248
170 unsigned char keycode;
172 } atkbd_scroll_keys[] = {
173 { ATKBD_SCR_1, 0xc5 },
174 { ATKBD_SCR_2, 0xa9 },
175 { ATKBD_SCR_4, 0xb6 },
176 { ATKBD_SCR_8, 0xa7 },
177 { ATKBD_SCR_CLICK, 0xe0 },
178 { ATKBD_SCR_LEFT, 0xcb },
179 { ATKBD_SCR_RIGHT, 0xd2 },
183 * The atkbd control structure
188 struct ps2dev ps2dev;
190 /* Written only during init */
193 struct input_dev dev;
196 unsigned char keycode[512];
198 unsigned char translated;
201 unsigned char softrepeat;
202 unsigned char softraw;
203 unsigned char scroll;
204 unsigned char enabled;
206 /* Accessed only from interrupt */
208 unsigned char resend;
209 unsigned char release;
210 unsigned char bat_xl;
215 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
216 ssize_t (*handler)(struct atkbd *, char *));
217 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
218 ssize_t (*handler)(struct atkbd *, const char *, size_t));
219 #define ATKBD_DEFINE_ATTR(_name) \
220 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
221 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \
222 static ssize_t atkbd_do_show_##_name(struct device *d, char *b) \
224 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
226 static ssize_t atkbd_do_set_##_name(struct device *d, const char *b, size_t s) \
228 return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \
230 static struct device_attribute atkbd_attr_##_name = \
231 __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
233 ATKBD_DEFINE_ATTR(extra);
234 ATKBD_DEFINE_ATTR(scroll);
235 ATKBD_DEFINE_ATTR(set);
236 ATKBD_DEFINE_ATTR(softrepeat);
237 ATKBD_DEFINE_ATTR(softraw);
240 static void atkbd_report_key(struct input_dev *dev, struct pt_regs *regs, int code, int value)
242 input_regs(dev, regs);
244 input_report_key(dev, code, 1);
246 input_report_key(dev, code, 0);
248 input_event(dev, EV_KEY, code, value);
253 * atkbd_interrupt(). Here takes place processing of data received from
254 * the keyboard into events.
257 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
258 unsigned int flags, struct pt_regs *regs)
260 struct atkbd *atkbd = serio_get_drvdata(serio);
261 unsigned int code = data;
262 int scroll = 0, hscroll = 0, click = -1;
266 printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
269 #if !defined(__i386__) && !defined (__x86_64__)
270 if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
271 printk(KERN_WARNING "atkbd.c: frame/parity error: %02x\n", flags);
272 serio_write(serio, ATKBD_CMD_RESEND);
277 if (!flags && data == ATKBD_RET_ACK)
281 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
282 if (ps2_handle_ack(&atkbd->ps2dev, data))
285 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
286 if (ps2_handle_response(&atkbd->ps2dev, data))
292 input_event(&atkbd->dev, EV_MSC, MSC_RAW, code);
294 if (atkbd->translated) {
297 !(code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1 ||
298 code == ATKBD_RET_HANGUEL || code == ATKBD_RET_HANJA ||
299 code == ATKBD_RET_ERR ||
300 (code == ATKBD_RET_BAT && !atkbd->bat_xl))) {
301 atkbd->release = code >> 7;
306 (code & 0x7f) == (ATKBD_RET_BAT & 0x7f))
307 atkbd->bat_xl = !atkbd->release;
313 serio_rescan(atkbd->ps2dev.serio);
315 case ATKBD_RET_EMUL0:
318 case ATKBD_RET_EMUL1:
321 case ATKBD_RET_RELEASE:
324 case ATKBD_RET_HANGUEL:
325 atkbd_report_key(&atkbd->dev, regs, KEY_HANGUEL, 3);
327 case ATKBD_RET_HANJA:
328 atkbd_report_key(&atkbd->dev, regs, KEY_HANJA, 3);
331 printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys);
336 code = (code & 0x7f) | ((code & 0x80) << 1);
340 code |= (atkbd->set != 3) ? 0x80 : 0x100;
343 if (atkbd->keycode[code] != ATKBD_KEY_NULL)
344 input_event(&atkbd->dev, EV_MSC, MSC_SCAN, code);
346 switch (atkbd->keycode[code]) {
349 case ATKBD_KEY_UNKNOWN:
350 if (data == ATKBD_RET_ACK || data == ATKBD_RET_NAK) {
351 printk(KERN_WARNING "atkbd.c: Spurious %s on %s. Some program, "
352 "like XFree86, might be trying access hardware directly.\n",
353 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
355 printk(KERN_WARNING "atkbd.c: Unknown key %s "
356 "(%s set %d, code %#x on %s).\n",
357 atkbd->release ? "released" : "pressed",
358 atkbd->translated ? "translated" : "raw",
359 atkbd->set, code, serio->phys);
360 printk(KERN_WARNING "atkbd.c: Use 'setkeycodes %s%02x <keycode>' "
361 "to make it known.\n",
362 code & 0x80 ? "e0" : "", code & 0x7f);
364 input_sync(&atkbd->dev);
367 scroll = 1 - atkbd->release * 2;
370 scroll = 2 - atkbd->release * 4;
373 scroll = 4 - atkbd->release * 8;
376 scroll = 8 - atkbd->release * 16;
378 case ATKBD_SCR_CLICK:
379 click = !atkbd->release;
384 case ATKBD_SCR_RIGHT:
388 value = atkbd->release ? 0 :
389 (1 + (!atkbd->softrepeat && test_bit(atkbd->keycode[code], atkbd->dev.key)));
391 switch (value) { /* Workaround Toshiba laptop multiple keypress */
397 atkbd->time = jiffies + msecs_to_jiffies(atkbd->dev.rep[REP_DELAY]) / 2;
400 if (!time_after(jiffies, atkbd->time) && atkbd->last == code)
405 atkbd_report_key(&atkbd->dev, regs, atkbd->keycode[code], value);
409 input_regs(&atkbd->dev, regs);
411 input_report_key(&atkbd->dev, BTN_MIDDLE, click);
412 input_report_rel(&atkbd->dev, REL_WHEEL, scroll);
413 input_report_rel(&atkbd->dev, REL_HWHEEL, hscroll);
414 input_sync(&atkbd->dev);
423 * Event callback from the input module. Events that change the state of
424 * the hardware are processed here.
427 static int atkbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
429 struct atkbd *atkbd = dev->private;
430 const short period[32] =
431 { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125,
432 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
433 const short delay[4] =
434 { 250, 500, 750, 1000 };
435 unsigned char param[2];
445 param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
446 | (test_bit(LED_NUML, dev->led) ? 2 : 0)
447 | (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
448 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS);
452 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
453 | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
454 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
455 | (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
456 | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
457 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS);
465 if (atkbd->softrepeat) return 0;
468 while (i < 32 && period[i] < dev->rep[REP_PERIOD]) i++;
469 while (j < 4 && delay[j] < dev->rep[REP_DELAY]) j++;
470 dev->rep[REP_PERIOD] = period[i];
471 dev->rep[REP_DELAY] = delay[j];
472 param[0] = i | (j << 5);
473 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_SETREP);
482 * atkbd_enable() signals that interrupt handler is allowed to
483 * generate input events.
486 static inline void atkbd_enable(struct atkbd *atkbd)
488 serio_pause_rx(atkbd->ps2dev.serio);
490 serio_continue_rx(atkbd->ps2dev.serio);
494 * atkbd_disable() tells input handler that all incoming data except
495 * for ACKs and command response should be dropped.
498 static inline void atkbd_disable(struct atkbd *atkbd)
500 serio_pause_rx(atkbd->ps2dev.serio);
502 serio_continue_rx(atkbd->ps2dev.serio);
506 * atkbd_probe() probes for an AT keyboard on a serio port.
509 static int atkbd_probe(struct atkbd *atkbd)
511 struct ps2dev *ps2dev = &atkbd->ps2dev;
512 unsigned char param[2];
515 * Some systems, where the bit-twiddling when testing the io-lines of the
516 * controller may confuse the keyboard need a full reset of the keyboard. On
517 * these systems the BIOS also usually doesn't do it for us.
521 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
522 printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys);
525 * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
526 * Some keyboards report different values, but the first byte is always 0xab or
527 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
528 * should make sure we don't try to set the LEDs on it.
531 param[0] = param[1] = 0xa5; /* initialize with invalid values */
532 if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
535 * If the get ID command failed, we check if we can at least set the LEDs on
536 * the keyboard. This should work on every keyboard out there. It also turns
537 * the LEDs off, which we want anyway.
540 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
546 if (param[0] != 0xab && param[0] != 0xac && /* Regular and NCD Sun keyboards */
547 param[0] != 0x2b && param[0] != 0x5d && /* Trust keyboard, raw and translated */
548 param[0] != 0x60 && param[0] != 0x47) /* NMB SGI keyboard, raw and translated */
551 atkbd->id = (param[0] << 8) | param[1];
553 if (atkbd->id == 0xaca1 && atkbd->translated) {
554 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n");
555 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n");
563 * atkbd_select_set checks if a keyboard has a working Set 3 support, and
564 * sets it into that. Unfortunately there are keyboards that can be switched
565 * to Set 3, but don't work well in that (BTC Multimedia ...)
568 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
570 struct ps2dev *ps2dev = &atkbd->ps2dev;
571 unsigned char param[2];
575 * For known special keyboards we can go ahead and set the correct set.
576 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
577 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
580 if (atkbd->translated)
583 if (atkbd->id == 0xaca1) {
585 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
591 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
600 if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
601 atkbd->id = param[0] << 8 | param[1];
606 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
610 if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
615 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
619 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
624 static int atkbd_activate(struct atkbd *atkbd)
626 struct ps2dev *ps2dev = &atkbd->ps2dev;
627 unsigned char param[1];
630 * Set the LEDs to a defined state.
634 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
638 * Set autorepeat to fastest possible.
642 if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
646 * Enable the keyboard to receive keystrokes.
649 if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
650 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
651 ps2dev->serio->phys);
659 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
663 static void atkbd_cleanup(struct serio *serio)
665 struct atkbd *atkbd = serio_get_drvdata(serio);
666 ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT);
671 * atkbd_disconnect() closes and frees.
674 static void atkbd_disconnect(struct serio *serio)
676 struct atkbd *atkbd = serio_get_drvdata(serio);
678 atkbd_disable(atkbd);
680 /* make sure we don't have a command in flight */
681 synchronize_kernel();
682 flush_scheduled_work();
684 device_remove_file(&serio->dev, &atkbd_attr_extra);
685 device_remove_file(&serio->dev, &atkbd_attr_scroll);
686 device_remove_file(&serio->dev, &atkbd_attr_set);
687 device_remove_file(&serio->dev, &atkbd_attr_softrepeat);
688 device_remove_file(&serio->dev, &atkbd_attr_softraw);
690 input_unregister_device(&atkbd->dev);
692 serio_set_drvdata(serio, NULL);
698 * atkbd_set_device_attrs() initializes keyboard's keycode table
699 * according to the selected scancode set
702 static void atkbd_set_keycode_table(struct atkbd *atkbd)
706 memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
708 if (atkbd->translated) {
709 for (i = 0; i < 128; i++) {
710 atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
711 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
713 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
714 if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j].set2)
715 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
717 } else if (atkbd->set == 3) {
718 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
720 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
723 for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++)
724 atkbd->keycode[atkbd_scroll_keys[i].set2] = atkbd_scroll_keys[i].keycode;
729 * atkbd_set_device_attrs() sets up keyboard's input device structure
732 static void atkbd_set_device_attrs(struct atkbd *atkbd)
736 memset(&atkbd->dev, 0, sizeof(struct input_dev));
738 init_input_dev(&atkbd->dev);
740 atkbd->dev.name = atkbd->name;
741 atkbd->dev.phys = atkbd->phys;
742 atkbd->dev.id.bustype = BUS_I8042;
743 atkbd->dev.id.vendor = 0x0001;
744 atkbd->dev.id.product = atkbd->translated ? 1 : atkbd->set;
745 atkbd->dev.id.version = atkbd->id;
746 atkbd->dev.event = atkbd_event;
747 atkbd->dev.private = atkbd;
748 atkbd->dev.dev = &atkbd->ps2dev.serio->dev;
750 atkbd->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_MSC);
753 atkbd->dev.evbit[0] |= BIT(EV_LED);
754 atkbd->dev.ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL);
758 atkbd->dev.ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) |
759 BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC);
761 if (!atkbd->softrepeat) {
762 atkbd->dev.rep[REP_DELAY] = 250;
763 atkbd->dev.rep[REP_PERIOD] = 33;
766 atkbd->dev.mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN);
769 atkbd->dev.evbit[0] |= BIT(EV_REL);
770 atkbd->dev.relbit[0] = BIT(REL_WHEEL) | BIT(REL_HWHEEL);
771 set_bit(BTN_MIDDLE, atkbd->dev.keybit);
774 atkbd->dev.keycode = atkbd->keycode;
775 atkbd->dev.keycodesize = sizeof(unsigned char);
776 atkbd->dev.keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
778 for (i = 0; i < 512; i++)
779 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
780 set_bit(atkbd->keycode[i], atkbd->dev.keybit);
784 * atkbd_connect() is called when the serio module finds an interface
785 * that isn't handled yet by an appropriate device driver. We check if
786 * there is an AT keyboard out there and if yes, we register ourselves
787 * to the input module.
790 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
795 if (!(atkbd = kmalloc(sizeof(struct atkbd), GFP_KERNEL)))
798 memset(atkbd, 0, sizeof(struct atkbd));
800 ps2_init(&atkbd->ps2dev, serio);
802 switch (serio->id.type) {
805 atkbd->translated = 1;
812 atkbd->softraw = atkbd_softraw;
813 atkbd->softrepeat = atkbd_softrepeat;
814 atkbd->scroll = atkbd_scroll;
817 atkbd->softrepeat = 1;
819 if (atkbd->softrepeat)
822 serio_set_drvdata(serio, atkbd);
824 err = serio_open(serio, drv);
826 serio_set_drvdata(serio, NULL);
833 if (atkbd_probe(atkbd)) {
835 serio_set_drvdata(serio, NULL);
840 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
841 atkbd_activate(atkbd);
849 sprintf(atkbd->name, "AT Set 2 Extra keyboard");
851 sprintf(atkbd->name, "AT %s Set %d keyboard",
852 atkbd->translated ? "Translated" : "Raw", atkbd->set);
854 sprintf(atkbd->phys, "%s/input0", serio->phys);
856 atkbd_set_keycode_table(atkbd);
857 atkbd_set_device_attrs(atkbd);
859 input_register_device(&atkbd->dev);
861 device_create_file(&serio->dev, &atkbd_attr_extra);
862 device_create_file(&serio->dev, &atkbd_attr_scroll);
863 device_create_file(&serio->dev, &atkbd_attr_set);
864 device_create_file(&serio->dev, &atkbd_attr_softrepeat);
865 device_create_file(&serio->dev, &atkbd_attr_softraw);
869 printk(KERN_INFO "input: %s on %s\n", atkbd->name, serio->phys);
875 * atkbd_reconnect() tries to restore keyboard into a sane state and is
876 * most likely called on resume.
879 static int atkbd_reconnect(struct serio *serio)
881 struct atkbd *atkbd = serio_get_drvdata(serio);
882 struct serio_driver *drv = serio->drv;
883 unsigned char param[1];
885 if (!atkbd || !drv) {
886 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
890 atkbd_disable(atkbd);
893 param[0] = (test_bit(LED_SCROLLL, atkbd->dev.led) ? 1 : 0)
894 | (test_bit(LED_NUML, atkbd->dev.led) ? 2 : 0)
895 | (test_bit(LED_CAPSL, atkbd->dev.led) ? 4 : 0);
897 if (atkbd_probe(atkbd))
899 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
902 atkbd_activate(atkbd);
904 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
913 static struct serio_device_id atkbd_serio_ids[] = {
921 .type = SERIO_8042_XL,
928 .proto = SERIO_PS2SER,
935 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
937 static struct serio_driver atkbd_drv = {
941 .description = DRIVER_DESC,
942 .id_table = atkbd_serio_ids,
943 .interrupt = atkbd_interrupt,
944 .connect = atkbd_connect,
945 .reconnect = atkbd_reconnect,
946 .disconnect = atkbd_disconnect,
947 .cleanup = atkbd_cleanup,
950 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
951 ssize_t (*handler)(struct atkbd *, char *))
953 struct serio *serio = to_serio_port(dev);
956 retval = serio_pin_driver(serio);
960 if (serio->drv != &atkbd_drv) {
965 retval = handler((struct atkbd *)serio_get_drvdata(serio), buf);
968 serio_unpin_driver(serio);
972 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
973 ssize_t (*handler)(struct atkbd *, const char *, size_t))
975 struct serio *serio = to_serio_port(dev);
979 retval = serio_pin_driver(serio);
983 if (serio->drv != &atkbd_drv) {
988 atkbd = serio_get_drvdata(serio);
989 atkbd_disable(atkbd);
990 retval = handler(atkbd, buf, count);
994 serio_unpin_driver(serio);
998 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1000 return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1003 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1005 unsigned long value;
1011 value = simple_strtoul(buf, &rest, 10);
1012 if (*rest || value > 1)
1015 if (atkbd->extra != value) {
1016 /* unregister device as it's properties will change */
1017 input_unregister_device(&atkbd->dev);
1018 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1019 atkbd_activate(atkbd);
1020 atkbd_set_device_attrs(atkbd);
1021 input_register_device(&atkbd->dev);
1026 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1028 return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1031 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1033 unsigned long value;
1036 value = simple_strtoul(buf, &rest, 10);
1037 if (*rest || value > 1)
1040 if (atkbd->scroll != value) {
1041 /* unregister device as it's properties will change */
1042 input_unregister_device(&atkbd->dev);
1043 atkbd->scroll = value;
1044 atkbd_set_keycode_table(atkbd);
1045 atkbd_set_device_attrs(atkbd);
1046 input_register_device(&atkbd->dev);
1051 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1053 return sprintf(buf, "%d\n", atkbd->set);
1056 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1058 unsigned long value;
1064 value = simple_strtoul(buf, &rest, 10);
1065 if (*rest || (value != 2 && value != 3))
1068 if (atkbd->set != value) {
1069 /* unregister device as it's properties will change */
1070 input_unregister_device(&atkbd->dev);
1071 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1072 atkbd_activate(atkbd);
1073 atkbd_set_keycode_table(atkbd);
1074 atkbd_set_device_attrs(atkbd);
1075 input_register_device(&atkbd->dev);
1080 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1082 return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1085 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1087 unsigned long value;
1093 value = simple_strtoul(buf, &rest, 10);
1094 if (*rest || value > 1)
1097 if (atkbd->softrepeat != value) {
1098 /* unregister device as it's properties will change */
1099 input_unregister_device(&atkbd->dev);
1100 atkbd->softrepeat = value;
1101 if (atkbd->softrepeat)
1103 atkbd_set_device_attrs(atkbd);
1104 input_register_device(&atkbd->dev);
1111 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1113 return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1116 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1118 unsigned long value;
1121 value = simple_strtoul(buf, &rest, 10);
1122 if (*rest || value > 1)
1125 if (atkbd->softraw != value) {
1126 /* unregister device as it's properties will change */
1127 input_unregister_device(&atkbd->dev);
1128 atkbd->softraw = value;
1129 atkbd_set_device_attrs(atkbd);
1130 input_register_device(&atkbd->dev);
1136 static int __init atkbd_init(void)
1138 serio_register_driver(&atkbd_drv);
1142 static void __exit atkbd_exit(void)
1144 serio_unregister_driver(&atkbd_drv);
1147 module_init(atkbd_init);
1148 module_exit(atkbd_exit);