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 = 0;
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, 0x9d },
175 { ATKBD_SCR_4, 0xa4 },
176 { ATKBD_SCR_8, 0x9b },
177 { ATKBD_SCR_CLICK, 0xe0 },
178 { ATKBD_SCR_LEFT, 0xcb },
179 { ATKBD_SCR_RIGHT, 0xd2 },
183 * The atkbd control structure
188 struct ps2dev ps2dev;
189 struct input_dev *dev;
191 /* Written only during init */
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;
211 unsigned char err_xl;
216 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
217 ssize_t (*handler)(struct atkbd *, char *));
218 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
219 ssize_t (*handler)(struct atkbd *, const char *, size_t));
220 #define ATKBD_DEFINE_ATTR(_name) \
221 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
222 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \
223 static ssize_t atkbd_do_show_##_name(struct device *d, struct device_attribute *attr, char *b) \
225 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
227 static ssize_t atkbd_do_set_##_name(struct device *d, struct device_attribute *attr, const char *b, size_t s) \
229 return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \
231 static struct device_attribute atkbd_attr_##_name = \
232 __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
234 ATKBD_DEFINE_ATTR(extra);
235 ATKBD_DEFINE_ATTR(scroll);
236 ATKBD_DEFINE_ATTR(set);
237 ATKBD_DEFINE_ATTR(softrepeat);
238 ATKBD_DEFINE_ATTR(softraw);
241 static void atkbd_report_key(struct input_dev *dev, struct pt_regs *regs, int code, int value)
243 input_regs(dev, regs);
245 input_report_key(dev, code, 1);
247 input_report_key(dev, code, 0);
249 input_event(dev, EV_KEY, code, value);
254 * atkbd_interrupt(). Here takes place processing of data received from
255 * the keyboard into events.
258 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
259 unsigned int flags, struct pt_regs *regs)
261 struct atkbd *atkbd = serio_get_drvdata(serio);
262 unsigned int code = data;
263 int scroll = 0, hscroll = 0, click = -1;
267 printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
270 #if !defined(__i386__) && !defined (__x86_64__)
271 if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
272 printk(KERN_WARNING "atkbd.c: frame/parity error: %02x\n", flags);
273 serio_write(serio, ATKBD_CMD_RESEND);
278 if (!flags && data == ATKBD_RET_ACK)
282 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
283 if (ps2_handle_ack(&atkbd->ps2dev, data))
286 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
287 if (ps2_handle_response(&atkbd->ps2dev, data))
293 input_event(atkbd->dev, EV_MSC, MSC_RAW, code);
295 if (atkbd->translated) {
298 !(code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1 ||
299 code == ATKBD_RET_HANGUEL || code == ATKBD_RET_HANJA ||
300 (code == ATKBD_RET_ERR && !atkbd->err_xl) ||
301 (code == ATKBD_RET_BAT && !atkbd->bat_xl))) {
302 atkbd->release = code >> 7;
307 if ((code & 0x7f) == (ATKBD_RET_BAT & 0x7f))
308 atkbd->bat_xl = !atkbd->release;
309 if ((code & 0x7f) == (ATKBD_RET_ERR & 0x7f))
310 atkbd->err_xl = !atkbd->release;
317 serio_rescan(atkbd->ps2dev.serio);
319 case ATKBD_RET_EMUL0:
322 case ATKBD_RET_EMUL1:
325 case ATKBD_RET_RELEASE:
328 case ATKBD_RET_HANGUEL:
329 atkbd_report_key(atkbd->dev, regs, KEY_HANGUEL, 3);
331 case ATKBD_RET_HANJA:
332 atkbd_report_key(atkbd->dev, regs, KEY_HANJA, 3);
335 printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys);
340 code = (code & 0x7f) | ((code & 0x80) << 1);
344 code |= (atkbd->set != 3) ? 0x80 : 0x100;
347 if (atkbd->keycode[code] != ATKBD_KEY_NULL)
348 input_event(atkbd->dev, EV_MSC, MSC_SCAN, code);
350 switch (atkbd->keycode[code]) {
353 case ATKBD_KEY_UNKNOWN:
354 if (data == ATKBD_RET_ACK || data == ATKBD_RET_NAK) {
355 printk(KERN_WARNING "atkbd.c: Spurious %s on %s. Some program, "
356 "like XFree86, might be trying access hardware directly.\n",
357 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
359 printk(KERN_WARNING "atkbd.c: Unknown key %s "
360 "(%s set %d, code %#x on %s).\n",
361 atkbd->release ? "released" : "pressed",
362 atkbd->translated ? "translated" : "raw",
363 atkbd->set, code, serio->phys);
364 printk(KERN_WARNING "atkbd.c: Use 'setkeycodes %s%02x <keycode>' "
365 "to make it known.\n",
366 code & 0x80 ? "e0" : "", code & 0x7f);
368 input_sync(atkbd->dev);
371 scroll = 1 - atkbd->release * 2;
374 scroll = 2 - atkbd->release * 4;
377 scroll = 4 - atkbd->release * 8;
380 scroll = 8 - atkbd->release * 16;
382 case ATKBD_SCR_CLICK:
383 click = !atkbd->release;
388 case ATKBD_SCR_RIGHT:
392 value = atkbd->release ? 0 :
393 (1 + (!atkbd->softrepeat && test_bit(atkbd->keycode[code], atkbd->dev->key)));
395 switch (value) { /* Workaround Toshiba laptop multiple keypress */
401 atkbd->time = jiffies + msecs_to_jiffies(atkbd->dev->rep[REP_DELAY]) / 2;
404 if (!time_after(jiffies, atkbd->time) && atkbd->last == code)
409 atkbd_report_key(atkbd->dev, regs, atkbd->keycode[code], value);
413 input_regs(atkbd->dev, regs);
415 input_report_key(atkbd->dev, BTN_MIDDLE, click);
416 input_report_rel(atkbd->dev, REL_WHEEL, scroll);
417 input_report_rel(atkbd->dev, REL_HWHEEL, hscroll);
418 input_sync(atkbd->dev);
427 * Event callback from the input module. Events that change the state of
428 * the hardware are processed here.
431 static int atkbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
433 struct atkbd *atkbd = dev->private;
434 const short period[32] =
435 { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125,
436 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
437 const short delay[4] =
438 { 250, 500, 750, 1000 };
439 unsigned char param[2];
449 param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
450 | (test_bit(LED_NUML, dev->led) ? 2 : 0)
451 | (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
452 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS);
456 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
457 | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
458 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
459 | (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
460 | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
461 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS);
468 if (atkbd->softrepeat) return 0;
471 while (i < 31 && period[i] < dev->rep[REP_PERIOD])
473 while (j < 3 && delay[j] < dev->rep[REP_DELAY])
475 dev->rep[REP_PERIOD] = period[i];
476 dev->rep[REP_DELAY] = delay[j];
477 param[0] = i | (j << 5);
478 ps2_schedule_command(&atkbd->ps2dev, param, ATKBD_CMD_SETREP);
487 * atkbd_enable() signals that interrupt handler is allowed to
488 * generate input events.
491 static inline void atkbd_enable(struct atkbd *atkbd)
493 serio_pause_rx(atkbd->ps2dev.serio);
495 serio_continue_rx(atkbd->ps2dev.serio);
499 * atkbd_disable() tells input handler that all incoming data except
500 * for ACKs and command response should be dropped.
503 static inline void atkbd_disable(struct atkbd *atkbd)
505 serio_pause_rx(atkbd->ps2dev.serio);
507 serio_continue_rx(atkbd->ps2dev.serio);
511 * atkbd_probe() probes for an AT keyboard on a serio port.
514 static int atkbd_probe(struct atkbd *atkbd)
516 struct ps2dev *ps2dev = &atkbd->ps2dev;
517 unsigned char param[2];
520 * Some systems, where the bit-twiddling when testing the io-lines of the
521 * controller may confuse the keyboard need a full reset of the keyboard. On
522 * these systems the BIOS also usually doesn't do it for us.
526 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
527 printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys);
530 * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
531 * Some keyboards report different values, but the first byte is always 0xab or
532 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
533 * should make sure we don't try to set the LEDs on it.
536 param[0] = param[1] = 0xa5; /* initialize with invalid values */
537 if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
540 * If the get ID command failed, we check if we can at least set the LEDs on
541 * the keyboard. This should work on every keyboard out there. It also turns
542 * the LEDs off, which we want anyway.
545 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
551 if (param[0] != 0xab && param[0] != 0xac && /* Regular and NCD Sun keyboards */
552 param[0] != 0x2b && param[0] != 0x5d && /* Trust keyboard, raw and translated */
553 param[0] != 0x60 && param[0] != 0x47) /* NMB SGI keyboard, raw and translated */
556 atkbd->id = (param[0] << 8) | param[1];
558 if (atkbd->id == 0xaca1 && atkbd->translated) {
559 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n");
560 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n");
568 * atkbd_select_set checks if a keyboard has a working Set 3 support, and
569 * sets it into that. Unfortunately there are keyboards that can be switched
570 * to Set 3, but don't work well in that (BTC Multimedia ...)
573 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
575 struct ps2dev *ps2dev = &atkbd->ps2dev;
576 unsigned char param[2];
580 * For known special keyboards we can go ahead and set the correct set.
581 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
582 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
585 if (atkbd->translated)
588 if (atkbd->id == 0xaca1) {
590 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
596 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
605 if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
606 atkbd->id = param[0] << 8 | param[1];
611 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
615 if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
620 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
624 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
629 static int atkbd_activate(struct atkbd *atkbd)
631 struct ps2dev *ps2dev = &atkbd->ps2dev;
632 unsigned char param[1];
635 * Set the LEDs to a defined state.
639 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
643 * Set autorepeat to fastest possible.
647 if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
651 * Enable the keyboard to receive keystrokes.
654 if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
655 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
656 ps2dev->serio->phys);
664 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
668 static void atkbd_cleanup(struct serio *serio)
670 struct atkbd *atkbd = serio_get_drvdata(serio);
671 ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_BAT);
676 * atkbd_disconnect() closes and frees.
679 static void atkbd_disconnect(struct serio *serio)
681 struct atkbd *atkbd = serio_get_drvdata(serio);
683 atkbd_disable(atkbd);
685 /* make sure we don't have a command in flight */
686 synchronize_sched(); /* Allow atkbd_interrupt()s to complete. */
687 flush_scheduled_work();
689 device_remove_file(&serio->dev, &atkbd_attr_extra);
690 device_remove_file(&serio->dev, &atkbd_attr_scroll);
691 device_remove_file(&serio->dev, &atkbd_attr_set);
692 device_remove_file(&serio->dev, &atkbd_attr_softrepeat);
693 device_remove_file(&serio->dev, &atkbd_attr_softraw);
695 input_unregister_device(atkbd->dev);
697 serio_set_drvdata(serio, NULL);
703 * atkbd_set_keycode_table() initializes keyboard's keycode table
704 * according to the selected scancode set
707 static void atkbd_set_keycode_table(struct atkbd *atkbd)
711 memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
713 if (atkbd->translated) {
714 for (i = 0; i < 128; i++) {
715 atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
716 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
718 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
719 if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j].set2)
720 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
722 } else if (atkbd->set == 3) {
723 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
725 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
728 for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++)
729 atkbd->keycode[atkbd_scroll_keys[i].set2] = atkbd_scroll_keys[i].keycode;
734 * atkbd_set_device_attrs() sets up keyboard's input device structure
737 static void atkbd_set_device_attrs(struct atkbd *atkbd)
739 struct input_dev *input_dev = atkbd->dev;
743 sprintf(atkbd->name, "AT Set 2 Extra keyboard");
745 sprintf(atkbd->name, "AT %s Set %d keyboard",
746 atkbd->translated ? "Translated" : "Raw", atkbd->set);
748 sprintf(atkbd->phys, "%s/input0", atkbd->ps2dev.serio->phys);
750 input_dev->name = atkbd->name;
751 input_dev->phys = atkbd->phys;
752 input_dev->id.bustype = BUS_I8042;
753 input_dev->id.vendor = 0x0001;
754 input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
755 input_dev->id.version = atkbd->id;
756 input_dev->event = atkbd_event;
757 input_dev->private = atkbd;
758 input_dev->cdev.dev = &atkbd->ps2dev.serio->dev;
760 input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_MSC);
763 input_dev->evbit[0] |= BIT(EV_LED);
764 input_dev->ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL);
768 input_dev->ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) |
769 BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC);
771 if (!atkbd->softrepeat) {
772 input_dev->rep[REP_DELAY] = 250;
773 input_dev->rep[REP_PERIOD] = 33;
776 input_dev->mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN);
779 input_dev->evbit[0] |= BIT(EV_REL);
780 input_dev->relbit[0] = BIT(REL_WHEEL) | BIT(REL_HWHEEL);
781 set_bit(BTN_MIDDLE, input_dev->keybit);
784 input_dev->keycode = atkbd->keycode;
785 input_dev->keycodesize = sizeof(unsigned char);
786 input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
788 for (i = 0; i < 512; i++)
789 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
790 set_bit(atkbd->keycode[i], input_dev->keybit);
794 * atkbd_connect() is called when the serio module finds an interface
795 * that isn't handled yet by an appropriate device driver. We check if
796 * there is an AT keyboard out there and if yes, we register ourselves
797 * to the input module.
800 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
803 struct input_dev *dev;
806 atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
807 dev = input_allocate_device();
812 ps2_init(&atkbd->ps2dev, serio);
814 switch (serio->id.type) {
817 atkbd->translated = 1;
824 atkbd->softraw = atkbd_softraw;
825 atkbd->softrepeat = atkbd_softrepeat;
826 atkbd->scroll = atkbd_scroll;
829 atkbd->softrepeat = 1;
831 if (atkbd->softrepeat)
834 serio_set_drvdata(serio, atkbd);
836 err = serio_open(serio, drv);
842 if (atkbd_probe(atkbd)) {
848 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
849 atkbd_activate(atkbd);
856 atkbd_set_keycode_table(atkbd);
857 atkbd_set_device_attrs(atkbd);
859 device_create_file(&serio->dev, &atkbd_attr_extra);
860 device_create_file(&serio->dev, &atkbd_attr_scroll);
861 device_create_file(&serio->dev, &atkbd_attr_set);
862 device_create_file(&serio->dev, &atkbd_attr_softrepeat);
863 device_create_file(&serio->dev, &atkbd_attr_softraw);
867 input_register_device(atkbd->dev);
871 fail: serio_set_drvdata(serio, NULL);
872 input_free_device(dev);
878 * atkbd_reconnect() tries to restore keyboard into a sane state and is
879 * most likely called on resume.
882 static int atkbd_reconnect(struct serio *serio)
884 struct atkbd *atkbd = serio_get_drvdata(serio);
885 struct serio_driver *drv = serio->drv;
886 unsigned char param[1];
888 if (!atkbd || !drv) {
889 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
893 atkbd_disable(atkbd);
896 param[0] = (test_bit(LED_SCROLLL, atkbd->dev->led) ? 1 : 0)
897 | (test_bit(LED_NUML, atkbd->dev->led) ? 2 : 0)
898 | (test_bit(LED_CAPSL, atkbd->dev->led) ? 4 : 0);
900 if (atkbd_probe(atkbd))
902 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
905 atkbd_activate(atkbd);
907 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
916 static struct serio_device_id atkbd_serio_ids[] = {
924 .type = SERIO_8042_XL,
931 .proto = SERIO_PS2SER,
938 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
940 static struct serio_driver atkbd_drv = {
944 .description = DRIVER_DESC,
945 .id_table = atkbd_serio_ids,
946 .interrupt = atkbd_interrupt,
947 .connect = atkbd_connect,
948 .reconnect = atkbd_reconnect,
949 .disconnect = atkbd_disconnect,
950 .cleanup = atkbd_cleanup,
953 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
954 ssize_t (*handler)(struct atkbd *, char *))
956 struct serio *serio = to_serio_port(dev);
959 retval = serio_pin_driver(serio);
963 if (serio->drv != &atkbd_drv) {
968 retval = handler((struct atkbd *)serio_get_drvdata(serio), buf);
971 serio_unpin_driver(serio);
975 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
976 ssize_t (*handler)(struct atkbd *, const char *, size_t))
978 struct serio *serio = to_serio_port(dev);
982 retval = serio_pin_driver(serio);
986 if (serio->drv != &atkbd_drv) {
991 atkbd = serio_get_drvdata(serio);
992 atkbd_disable(atkbd);
993 retval = handler(atkbd, buf, count);
997 serio_unpin_driver(serio);
1001 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1003 return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1006 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1008 struct input_dev *new_dev;
1009 unsigned long value;
1015 value = simple_strtoul(buf, &rest, 10);
1016 if (*rest || value > 1)
1019 if (atkbd->extra != value) {
1021 * Since device's properties will change we need to
1022 * unregister old device. But allocate new one first
1023 * to make sure we have it.
1025 if (!(new_dev = input_allocate_device()))
1027 input_unregister_device(atkbd->dev);
1028 atkbd->dev = new_dev;
1029 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1030 atkbd_activate(atkbd);
1031 atkbd_set_device_attrs(atkbd);
1032 input_register_device(atkbd->dev);
1037 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1039 return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1042 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1044 struct input_dev *new_dev;
1045 unsigned long value;
1048 value = simple_strtoul(buf, &rest, 10);
1049 if (*rest || value > 1)
1052 if (atkbd->scroll != value) {
1053 if (!(new_dev = input_allocate_device()))
1055 input_unregister_device(atkbd->dev);
1056 atkbd->dev = new_dev;
1057 atkbd->scroll = value;
1058 atkbd_set_keycode_table(atkbd);
1059 atkbd_set_device_attrs(atkbd);
1060 input_register_device(atkbd->dev);
1065 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1067 return sprintf(buf, "%d\n", atkbd->set);
1070 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1072 struct input_dev *new_dev;
1073 unsigned long value;
1079 value = simple_strtoul(buf, &rest, 10);
1080 if (*rest || (value != 2 && value != 3))
1083 if (atkbd->set != value) {
1084 if (!(new_dev = input_allocate_device()))
1086 input_unregister_device(atkbd->dev);
1087 atkbd->dev = new_dev;
1088 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1089 atkbd_activate(atkbd);
1090 atkbd_set_keycode_table(atkbd);
1091 atkbd_set_device_attrs(atkbd);
1092 input_register_device(atkbd->dev);
1097 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1099 return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1102 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1104 struct input_dev *new_dev;
1105 unsigned long value;
1111 value = simple_strtoul(buf, &rest, 10);
1112 if (*rest || value > 1)
1115 if (atkbd->softrepeat != value) {
1116 if (!(new_dev = input_allocate_device()))
1118 input_unregister_device(atkbd->dev);
1119 atkbd->dev = new_dev;
1120 atkbd->softrepeat = value;
1121 if (atkbd->softrepeat)
1123 atkbd_set_device_attrs(atkbd);
1124 input_register_device(atkbd->dev);
1130 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1132 return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1135 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1137 struct input_dev *new_dev;
1138 unsigned long value;
1141 value = simple_strtoul(buf, &rest, 10);
1142 if (*rest || value > 1)
1145 if (atkbd->softraw != value) {
1146 if (!(new_dev = input_allocate_device()))
1148 input_unregister_device(atkbd->dev);
1149 atkbd->dev = new_dev;
1150 atkbd->softraw = value;
1151 atkbd_set_device_attrs(atkbd);
1152 input_register_device(atkbd->dev);
1158 static int __init atkbd_init(void)
1160 serio_register_driver(&atkbd_drv);
1164 static void __exit atkbd_exit(void)
1166 serio_unregister_driver(&atkbd_drv);
1169 module_init(atkbd_init);
1170 module_exit(atkbd_exit);