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>
30 #include <linux/mutex.h>
32 #define DRIVER_DESC "AT and PS/2 keyboard driver"
34 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
35 MODULE_DESCRIPTION(DRIVER_DESC);
36 MODULE_LICENSE("GPL");
38 static int atkbd_set = 2;
39 module_param_named(set, atkbd_set, int, 0);
40 MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");
42 #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
43 static int atkbd_reset;
45 static int atkbd_reset = 1;
47 module_param_named(reset, atkbd_reset, bool, 0);
48 MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
50 static int atkbd_softrepeat;
51 module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
52 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
54 static int atkbd_softraw = 1;
55 module_param_named(softraw, atkbd_softraw, bool, 0);
56 MODULE_PARM_DESC(softraw, "Use software generated rawmode");
58 static int atkbd_scroll;
59 module_param_named(scroll, atkbd_scroll, bool, 0);
60 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
62 static int atkbd_extra;
63 module_param_named(extra, atkbd_extra, bool, 0);
64 MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
66 __obsolete_setup("atkbd_set=");
67 __obsolete_setup("atkbd_reset");
68 __obsolete_setup("atkbd_softrepeat=");
71 * Scancode to keycode tables. These are just the default setting, and
72 * are loadable via an userland utility.
75 static unsigned char atkbd_set2_keycode[512] = {
77 #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
79 /* XXX: need a more general approach */
81 #include "hpps2atkbd.h" /* include the keyboard scancodes */
84 0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117,
85 0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0,
86 0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183,
87 0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185,
88 0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0,
89 0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85,
90 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0,
91 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
93 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
94 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
95 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
96 159, 0,115, 0,164, 0, 0,116,158, 0,150,166, 0, 0, 0,142,
97 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
98 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
99 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
100 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
106 static unsigned char atkbd_set3_keycode[512] = {
108 0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60,
109 131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62,
110 134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64,
111 136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66,
112 125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
113 113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
114 108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104,
115 82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183,
117 184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0,
118 0,139,150,163,165,115,152,150,166,140,160,154,113,114,167,168,
122 static unsigned char atkbd_unxlate_table[128] = {
123 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
124 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
125 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
126 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3,
127 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105,
128 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63,
129 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
130 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
133 #define ATKBD_CMD_SETLEDS 0x10ed
134 #define ATKBD_CMD_GSCANSET 0x11f0
135 #define ATKBD_CMD_SSCANSET 0x10f0
136 #define ATKBD_CMD_GETID 0x02f2
137 #define ATKBD_CMD_SETREP 0x10f3
138 #define ATKBD_CMD_ENABLE 0x00f4
139 #define ATKBD_CMD_RESET_DIS 0x00f5
140 #define ATKBD_CMD_SETALL_MBR 0x00fa
141 #define ATKBD_CMD_RESET_BAT 0x02ff
142 #define ATKBD_CMD_RESEND 0x00fe
143 #define ATKBD_CMD_EX_ENABLE 0x10ea
144 #define ATKBD_CMD_EX_SETLEDS 0x20eb
145 #define ATKBD_CMD_OK_GETID 0x02e8
147 #define ATKBD_RET_ACK 0xfa
148 #define ATKBD_RET_NAK 0xfe
149 #define ATKBD_RET_BAT 0xaa
150 #define ATKBD_RET_EMUL0 0xe0
151 #define ATKBD_RET_EMUL1 0xe1
152 #define ATKBD_RET_RELEASE 0xf0
153 #define ATKBD_RET_HANJA 0xf1
154 #define ATKBD_RET_HANGEUL 0xf2
155 #define ATKBD_RET_ERR 0xff
157 #define ATKBD_KEY_UNKNOWN 0
158 #define ATKBD_KEY_NULL 255
160 #define ATKBD_SCR_1 254
161 #define ATKBD_SCR_2 253
162 #define ATKBD_SCR_4 252
163 #define ATKBD_SCR_8 251
164 #define ATKBD_SCR_CLICK 250
165 #define ATKBD_SCR_LEFT 249
166 #define ATKBD_SCR_RIGHT 248
168 #define ATKBD_SPECIAL 248
170 #define ATKBD_LED_EVENT_BIT 0
171 #define ATKBD_REP_EVENT_BIT 1
173 #define ATKBD_XL_ERR 0x01
174 #define ATKBD_XL_BAT 0x02
175 #define ATKBD_XL_ACK 0x04
176 #define ATKBD_XL_NAK 0x08
177 #define ATKBD_XL_HANGEUL 0x10
178 #define ATKBD_XL_HANJA 0x20
181 unsigned char keycode;
183 } atkbd_scroll_keys[] = {
184 { ATKBD_SCR_1, 0xc5 },
185 { ATKBD_SCR_2, 0x9d },
186 { ATKBD_SCR_4, 0xa4 },
187 { ATKBD_SCR_8, 0x9b },
188 { ATKBD_SCR_CLICK, 0xe0 },
189 { ATKBD_SCR_LEFT, 0xcb },
190 { ATKBD_SCR_RIGHT, 0xd2 },
194 * The atkbd control structure
199 struct ps2dev ps2dev;
200 struct input_dev *dev;
202 /* Written only during init */
207 unsigned char keycode[512];
209 unsigned char translated;
212 unsigned char softrepeat;
213 unsigned char softraw;
214 unsigned char scroll;
215 unsigned char enabled;
217 /* Accessed only from interrupt */
219 unsigned char resend;
220 unsigned char release;
221 unsigned long xl_bit;
225 struct work_struct event_work;
226 struct mutex event_mutex;
227 unsigned long event_mask;
230 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
231 ssize_t (*handler)(struct atkbd *, char *));
232 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
233 ssize_t (*handler)(struct atkbd *, const char *, size_t));
234 #define ATKBD_DEFINE_ATTR(_name) \
235 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
236 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \
237 static ssize_t atkbd_do_show_##_name(struct device *d, struct device_attribute *attr, char *b) \
239 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
241 static ssize_t atkbd_do_set_##_name(struct device *d, struct device_attribute *attr, const char *b, size_t s) \
243 return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \
245 static struct device_attribute atkbd_attr_##_name = \
246 __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
248 ATKBD_DEFINE_ATTR(extra);
249 ATKBD_DEFINE_ATTR(scroll);
250 ATKBD_DEFINE_ATTR(set);
251 ATKBD_DEFINE_ATTR(softrepeat);
252 ATKBD_DEFINE_ATTR(softraw);
254 static const unsigned int xl_table[] = {
255 ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK,
256 ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL,
260 * Checks if we should mangle the scancode to extract 'release' bit
261 * in translated mode.
263 static int atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
267 if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
270 for (i = 0; i < ARRAY_SIZE(xl_table); i++)
271 if (code == xl_table[i])
272 return test_bit(i, &xl_bit);
278 * Calculates new value of xl_bit so the driver can distinguish
279 * between make/break pair of scancodes for select keys and PS/2
280 * protocol responses.
282 static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code)
286 for (i = 0; i < ARRAY_SIZE(xl_table); i++) {
287 if (!((code ^ xl_table[i]) & 0x7f)) {
289 __clear_bit(i, &atkbd->xl_bit);
291 __set_bit(i, &atkbd->xl_bit);
298 * Encode the scancode, 0xe0 prefix, and high bit into a single integer,
299 * keeping kernel 2.4 compatibility for set 2
301 static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code)
303 if (atkbd->set == 3) {
304 if (atkbd->emul == 1)
307 code = (code & 0x7f) | ((code & 0x80) << 1);
308 if (atkbd->emul == 1)
316 * atkbd_interrupt(). Here takes place processing of data received from
317 * the keyboard into events.
320 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
321 unsigned int flags, struct pt_regs *regs)
323 struct atkbd *atkbd = serio_get_drvdata(serio);
324 struct input_dev *dev = atkbd->dev;
325 unsigned int code = data;
326 int scroll = 0, hscroll = 0, click = -1, add_release_event = 0;
328 unsigned char keycode;
331 printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
334 #if !defined(__i386__) && !defined (__x86_64__)
335 if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
336 printk(KERN_WARNING "atkbd.c: frame/parity error: %02x\n", flags);
337 serio_write(serio, ATKBD_CMD_RESEND);
342 if (!flags && data == ATKBD_RET_ACK)
346 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
347 if (ps2_handle_ack(&atkbd->ps2dev, data))
350 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
351 if (ps2_handle_response(&atkbd->ps2dev, data))
357 input_event(dev, EV_MSC, MSC_RAW, code);
359 if (atkbd->translated) {
361 if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
362 atkbd->release = code >> 7;
367 atkbd_calculate_xl_bit(atkbd, data);
373 serio_reconnect(atkbd->ps2dev.serio);
375 case ATKBD_RET_EMUL0:
378 case ATKBD_RET_EMUL1:
381 case ATKBD_RET_RELEASE:
387 /* Quite a few key switchers and other tools trigger this and it confuses
388 people who can do nothing about it */
389 printk(KERN_WARNING "atkbd.c: Spurious %s on %s. "
390 "Some program might be trying access hardware directly.\n",
391 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
394 case ATKBD_RET_HANGEUL:
395 case ATKBD_RET_HANJA:
397 * These keys do not report release and thus need to be
400 add_release_event = 1;
403 // printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys);
407 code = atkbd_compat_scancode(atkbd, code);
409 if (atkbd->emul && --atkbd->emul)
412 keycode = atkbd->keycode[code];
414 if (keycode != ATKBD_KEY_NULL)
415 input_event(dev, EV_MSC, MSC_SCAN, code);
420 case ATKBD_KEY_UNKNOWN:
422 "atkbd.c: Unknown key %s (%s set %d, code %#x on %s).\n",
423 atkbd->release ? "released" : "pressed",
424 atkbd->translated ? "translated" : "raw",
425 atkbd->set, code, serio->phys);
427 "atkbd.c: Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
428 code & 0x80 ? "e0" : "", code & 0x7f);
432 scroll = 1 - atkbd->release * 2;
435 scroll = 2 - atkbd->release * 4;
438 scroll = 4 - atkbd->release * 8;
441 scroll = 8 - atkbd->release * 16;
443 case ATKBD_SCR_CLICK:
444 click = !atkbd->release;
449 case ATKBD_SCR_RIGHT:
453 if (atkbd->release) {
456 } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
457 /* Workaround Toshiba laptop multiple keypress */
458 value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
462 atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
465 input_regs(dev, regs);
466 input_event(dev, EV_KEY, keycode, value);
469 if (value && add_release_event) {
470 input_report_key(dev, keycode, 0);
476 input_regs(dev, regs);
478 input_report_key(dev, BTN_MIDDLE, click);
479 input_report_rel(dev, REL_WHEEL, scroll);
480 input_report_rel(dev, REL_HWHEEL, hscroll);
489 static int atkbd_set_repeat_rate(struct atkbd *atkbd)
491 const short period[32] =
492 { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125,
493 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
494 const short delay[4] =
495 { 250, 500, 750, 1000 };
497 struct input_dev *dev = atkbd->dev;
501 while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
503 dev->rep[REP_PERIOD] = period[i];
505 while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
507 dev->rep[REP_DELAY] = delay[j];
509 param = i | (j << 5);
510 return ps2_command(&atkbd->ps2dev, ¶m, ATKBD_CMD_SETREP);
513 static int atkbd_set_leds(struct atkbd *atkbd)
515 struct input_dev *dev = atkbd->dev;
516 unsigned char param[2];
518 param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
519 | (test_bit(LED_NUML, dev->led) ? 2 : 0)
520 | (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
521 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
526 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
527 | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
528 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
529 | (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
530 | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
531 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
539 * atkbd_event_work() is used to complete processing of events that
540 * can not be processed by input_event() which is often called from
544 static void atkbd_event_work(void *data)
546 struct atkbd *atkbd = data;
548 mutex_lock(&atkbd->event_mutex);
550 if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
551 atkbd_set_leds(atkbd);
553 if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
554 atkbd_set_repeat_rate(atkbd);
556 mutex_unlock(&atkbd->event_mutex);
560 * Event callback from the input module. Events that change the state of
561 * the hardware are processed here. If action can not be performed in
562 * interrupt context it is offloaded to atkbd_event_work.
565 static int atkbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
567 struct atkbd *atkbd = dev->private;
575 set_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask);
577 schedule_work(&atkbd->event_work);
582 if (!atkbd->softrepeat) {
583 set_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask);
585 schedule_work(&atkbd->event_work);
595 * atkbd_enable() signals that interrupt handler is allowed to
596 * generate input events.
599 static inline void atkbd_enable(struct atkbd *atkbd)
601 serio_pause_rx(atkbd->ps2dev.serio);
603 serio_continue_rx(atkbd->ps2dev.serio);
607 * atkbd_disable() tells input handler that all incoming data except
608 * for ACKs and command response should be dropped.
611 static inline void atkbd_disable(struct atkbd *atkbd)
613 serio_pause_rx(atkbd->ps2dev.serio);
615 serio_continue_rx(atkbd->ps2dev.serio);
619 * atkbd_probe() probes for an AT keyboard on a serio port.
622 static int atkbd_probe(struct atkbd *atkbd)
624 struct ps2dev *ps2dev = &atkbd->ps2dev;
625 unsigned char param[2];
628 * Some systems, where the bit-twiddling when testing the io-lines of the
629 * controller may confuse the keyboard need a full reset of the keyboard. On
630 * these systems the BIOS also usually doesn't do it for us.
634 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
635 printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys);
638 * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
639 * Some keyboards report different values, but the first byte is always 0xab or
640 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
641 * should make sure we don't try to set the LEDs on it.
644 param[0] = param[1] = 0xa5; /* initialize with invalid values */
645 if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
648 * If the get ID command failed, we check if we can at least set the LEDs on
649 * the keyboard. This should work on every keyboard out there. It also turns
650 * the LEDs off, which we want anyway.
653 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
659 if (param[0] != 0xab && param[0] != 0xac && /* Regular and NCD Sun keyboards */
660 param[0] != 0x2b && param[0] != 0x5d && /* Trust keyboard, raw and translated */
661 param[0] != 0x60 && param[0] != 0x47) /* NMB SGI keyboard, raw and translated */
664 atkbd->id = (param[0] << 8) | param[1];
666 if (atkbd->id == 0xaca1 && atkbd->translated) {
667 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n");
668 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n");
676 * atkbd_select_set checks if a keyboard has a working Set 3 support, and
677 * sets it into that. Unfortunately there are keyboards that can be switched
678 * to Set 3, but don't work well in that (BTC Multimedia ...)
681 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
683 struct ps2dev *ps2dev = &atkbd->ps2dev;
684 unsigned char param[2];
688 * For known special keyboards we can go ahead and set the correct set.
689 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
690 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
693 if (atkbd->translated)
696 if (atkbd->id == 0xaca1) {
698 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
704 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
713 if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
714 atkbd->id = param[0] << 8 | param[1];
719 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
723 if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
728 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
732 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
737 static int atkbd_activate(struct atkbd *atkbd)
739 struct ps2dev *ps2dev = &atkbd->ps2dev;
740 unsigned char param[1];
743 * Set the LEDs to a defined state.
747 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
751 * Set autorepeat to fastest possible.
755 if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
759 * Enable the keyboard to receive keystrokes.
762 if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
763 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
764 ps2dev->serio->phys);
772 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
776 static void atkbd_cleanup(struct serio *serio)
778 struct atkbd *atkbd = serio_get_drvdata(serio);
779 ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT);
784 * atkbd_disconnect() closes and frees.
787 static void atkbd_disconnect(struct serio *serio)
789 struct atkbd *atkbd = serio_get_drvdata(serio);
791 atkbd_disable(atkbd);
793 /* make sure we don't have a command in flight */
794 synchronize_sched(); /* Allow atkbd_interrupt()s to complete. */
795 flush_scheduled_work();
797 device_remove_file(&serio->dev, &atkbd_attr_extra);
798 device_remove_file(&serio->dev, &atkbd_attr_scroll);
799 device_remove_file(&serio->dev, &atkbd_attr_set);
800 device_remove_file(&serio->dev, &atkbd_attr_softrepeat);
801 device_remove_file(&serio->dev, &atkbd_attr_softraw);
803 input_unregister_device(atkbd->dev);
805 serio_set_drvdata(serio, NULL);
811 * atkbd_set_keycode_table() initializes keyboard's keycode table
812 * according to the selected scancode set
815 static void atkbd_set_keycode_table(struct atkbd *atkbd)
819 memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
821 if (atkbd->translated) {
822 for (i = 0; i < 128; i++) {
823 atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
824 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
826 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
827 if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j].set2)
828 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
830 } else if (atkbd->set == 3) {
831 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
833 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
836 for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++)
837 atkbd->keycode[atkbd_scroll_keys[i].set2] = atkbd_scroll_keys[i].keycode;
840 atkbd->keycode[atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL)] = KEY_HANGUEL;
841 atkbd->keycode[atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA)] = KEY_HANJA;
845 * atkbd_set_device_attrs() sets up keyboard's input device structure
848 static void atkbd_set_device_attrs(struct atkbd *atkbd)
850 struct input_dev *input_dev = atkbd->dev;
854 snprintf(atkbd->name, sizeof(atkbd->name),
855 "AT Set 2 Extra keyboard");
857 snprintf(atkbd->name, sizeof(atkbd->name),
858 "AT %s Set %d keyboard",
859 atkbd->translated ? "Translated" : "Raw", atkbd->set);
861 snprintf(atkbd->phys, sizeof(atkbd->phys),
862 "%s/input0", atkbd->ps2dev.serio->phys);
864 input_dev->name = atkbd->name;
865 input_dev->phys = atkbd->phys;
866 input_dev->id.bustype = BUS_I8042;
867 input_dev->id.vendor = 0x0001;
868 input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
869 input_dev->id.version = atkbd->id;
870 input_dev->event = atkbd_event;
871 input_dev->private = atkbd;
872 input_dev->cdev.dev = &atkbd->ps2dev.serio->dev;
874 input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_MSC);
877 input_dev->evbit[0] |= BIT(EV_LED);
878 input_dev->ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL);
882 input_dev->ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) |
883 BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC);
885 if (!atkbd->softrepeat) {
886 input_dev->rep[REP_DELAY] = 250;
887 input_dev->rep[REP_PERIOD] = 33;
890 input_dev->mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN);
893 input_dev->evbit[0] |= BIT(EV_REL);
894 input_dev->relbit[0] = BIT(REL_WHEEL) | BIT(REL_HWHEEL);
895 set_bit(BTN_MIDDLE, input_dev->keybit);
898 input_dev->keycode = atkbd->keycode;
899 input_dev->keycodesize = sizeof(unsigned char);
900 input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
902 for (i = 0; i < 512; i++)
903 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
904 set_bit(atkbd->keycode[i], input_dev->keybit);
908 * atkbd_connect() is called when the serio module finds an interface
909 * that isn't handled yet by an appropriate device driver. We check if
910 * there is an AT keyboard out there and if yes, we register ourselves
911 * to the input module.
914 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
917 struct input_dev *dev;
920 atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
921 dev = input_allocate_device();
926 ps2_init(&atkbd->ps2dev, serio);
927 INIT_WORK(&atkbd->event_work, atkbd_event_work, atkbd);
928 mutex_init(&atkbd->event_mutex);
930 switch (serio->id.type) {
933 atkbd->translated = 1;
940 atkbd->softraw = atkbd_softraw;
941 atkbd->softrepeat = atkbd_softrepeat;
942 atkbd->scroll = atkbd_scroll;
944 if (atkbd->softrepeat)
947 serio_set_drvdata(serio, atkbd);
949 err = serio_open(serio, drv);
955 if (atkbd_probe(atkbd)) {
961 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
962 atkbd_activate(atkbd);
969 atkbd_set_keycode_table(atkbd);
970 atkbd_set_device_attrs(atkbd);
972 device_create_file(&serio->dev, &atkbd_attr_extra);
973 device_create_file(&serio->dev, &atkbd_attr_scroll);
974 device_create_file(&serio->dev, &atkbd_attr_set);
975 device_create_file(&serio->dev, &atkbd_attr_softrepeat);
976 device_create_file(&serio->dev, &atkbd_attr_softraw);
980 input_register_device(atkbd->dev);
984 fail: serio_set_drvdata(serio, NULL);
985 input_free_device(dev);
991 * atkbd_reconnect() tries to restore keyboard into a sane state and is
992 * most likely called on resume.
995 static int atkbd_reconnect(struct serio *serio)
997 struct atkbd *atkbd = serio_get_drvdata(serio);
998 struct serio_driver *drv = serio->drv;
1000 if (!atkbd || !drv) {
1001 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
1005 atkbd_disable(atkbd);
1008 if (atkbd_probe(atkbd))
1010 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1013 atkbd_activate(atkbd);
1016 * Restore repeat rate and LEDs (that were reset by atkbd_activate)
1017 * to pre-resume state
1019 if (!atkbd->softrepeat)
1020 atkbd_set_repeat_rate(atkbd);
1021 atkbd_set_leds(atkbd);
1024 atkbd_enable(atkbd);
1029 static struct serio_device_id atkbd_serio_ids[] = {
1037 .type = SERIO_8042_XL,
1043 .type = SERIO_RS232,
1044 .proto = SERIO_PS2SER,
1051 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1053 static struct serio_driver atkbd_drv = {
1057 .description = DRIVER_DESC,
1058 .id_table = atkbd_serio_ids,
1059 .interrupt = atkbd_interrupt,
1060 .connect = atkbd_connect,
1061 .reconnect = atkbd_reconnect,
1062 .disconnect = atkbd_disconnect,
1063 .cleanup = atkbd_cleanup,
1066 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1067 ssize_t (*handler)(struct atkbd *, char *))
1069 struct serio *serio = to_serio_port(dev);
1072 retval = serio_pin_driver(serio);
1076 if (serio->drv != &atkbd_drv) {
1081 retval = handler((struct atkbd *)serio_get_drvdata(serio), buf);
1084 serio_unpin_driver(serio);
1088 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1089 ssize_t (*handler)(struct atkbd *, const char *, size_t))
1091 struct serio *serio = to_serio_port(dev);
1092 struct atkbd *atkbd;
1095 retval = serio_pin_driver(serio);
1099 if (serio->drv != &atkbd_drv) {
1104 atkbd = serio_get_drvdata(serio);
1105 atkbd_disable(atkbd);
1106 retval = handler(atkbd, buf, count);
1107 atkbd_enable(atkbd);
1110 serio_unpin_driver(serio);
1114 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1116 return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1119 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1121 struct input_dev *new_dev;
1122 unsigned long value;
1128 value = simple_strtoul(buf, &rest, 10);
1129 if (*rest || value > 1)
1132 if (atkbd->extra != value) {
1134 * Since device's properties will change we need to
1135 * unregister old device. But allocate new one first
1136 * to make sure we have it.
1138 if (!(new_dev = input_allocate_device()))
1140 input_unregister_device(atkbd->dev);
1141 atkbd->dev = new_dev;
1142 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1143 atkbd_activate(atkbd);
1144 atkbd_set_device_attrs(atkbd);
1145 input_register_device(atkbd->dev);
1150 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1152 return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1155 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1157 struct input_dev *new_dev;
1158 unsigned long value;
1161 value = simple_strtoul(buf, &rest, 10);
1162 if (*rest || value > 1)
1165 if (atkbd->scroll != value) {
1166 if (!(new_dev = input_allocate_device()))
1168 input_unregister_device(atkbd->dev);
1169 atkbd->dev = new_dev;
1170 atkbd->scroll = value;
1171 atkbd_set_keycode_table(atkbd);
1172 atkbd_set_device_attrs(atkbd);
1173 input_register_device(atkbd->dev);
1178 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1180 return sprintf(buf, "%d\n", atkbd->set);
1183 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1185 struct input_dev *new_dev;
1186 unsigned long value;
1192 value = simple_strtoul(buf, &rest, 10);
1193 if (*rest || (value != 2 && value != 3))
1196 if (atkbd->set != value) {
1197 if (!(new_dev = input_allocate_device()))
1199 input_unregister_device(atkbd->dev);
1200 atkbd->dev = new_dev;
1201 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1202 atkbd_activate(atkbd);
1203 atkbd_set_keycode_table(atkbd);
1204 atkbd_set_device_attrs(atkbd);
1205 input_register_device(atkbd->dev);
1210 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1212 return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1215 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1217 struct input_dev *new_dev;
1218 unsigned long value;
1224 value = simple_strtoul(buf, &rest, 10);
1225 if (*rest || value > 1)
1228 if (atkbd->softrepeat != value) {
1229 if (!(new_dev = input_allocate_device()))
1231 input_unregister_device(atkbd->dev);
1232 atkbd->dev = new_dev;
1233 atkbd->softrepeat = value;
1234 if (atkbd->softrepeat)
1236 atkbd_set_device_attrs(atkbd);
1237 input_register_device(atkbd->dev);
1243 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1245 return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1248 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1250 struct input_dev *new_dev;
1251 unsigned long value;
1254 value = simple_strtoul(buf, &rest, 10);
1255 if (*rest || value > 1)
1258 if (atkbd->softraw != value) {
1259 if (!(new_dev = input_allocate_device()))
1261 input_unregister_device(atkbd->dev);
1262 atkbd->dev = new_dev;
1263 atkbd->softraw = value;
1264 atkbd_set_device_attrs(atkbd);
1265 input_register_device(atkbd->dev);
1271 static int __init atkbd_init(void)
1273 serio_register_driver(&atkbd_drv);
1277 static void __exit atkbd_exit(void)
1279 serio_unregister_driver(&atkbd_drv);
1282 module_init(atkbd_init);
1283 module_exit(atkbd_exit);