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>
30 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
31 MODULE_DESCRIPTION("AT and PS/2 keyboard driver");
32 MODULE_LICENSE("GPL");
34 static int atkbd_set = 2;
35 module_param_named(set, atkbd_set, int, 0);
36 MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");
38 #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
39 static int atkbd_reset;
41 static int atkbd_reset = 1;
43 module_param_named(reset, atkbd_reset, bool, 0);
44 MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
46 static int atkbd_softrepeat;
47 module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
48 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
50 static int atkbd_scroll;
51 module_param_named(scroll, atkbd_scroll, bool, 0);
52 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
54 static int atkbd_extra;
55 module_param_named(extra, atkbd_extra, bool, 0);
56 MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
58 __obsolete_setup("atkbd_set=");
59 __obsolete_setup("atkbd_reset");
60 __obsolete_setup("atkbd_softrepeat=");
63 * Scancode to keycode tables. These are just the default setting, and
64 * are loadable via an userland utility.
68 #include "hpps2atkbd.h"
71 static unsigned char atkbd_set2_keycode[512] = {
73 0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117,
74 0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0,
75 0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183,
76 0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185,
77 0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0,
78 0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85,
79 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0,
80 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
82 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
83 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
84 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
85 159, 0,115, 0,164, 0, 0,116,158, 0,150,166, 0, 0, 0,142,
86 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
87 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
88 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
89 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
96 static unsigned char atkbd_set3_keycode[512] = {
98 0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60,
99 131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62,
100 134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64,
101 136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66,
102 125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
103 113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
104 108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104,
105 82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183,
107 184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0,
108 0,139,150,163,165,115,152,150,166,140,160,154,113,114,167,168,
112 static unsigned char atkbd_unxlate_table[128] = {
113 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
114 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
115 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
116 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3,
117 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105,
118 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63,
119 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
120 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
123 #define ATKBD_CMD_SETLEDS 0x10ed
124 #define ATKBD_CMD_GSCANSET 0x11f0
125 #define ATKBD_CMD_SSCANSET 0x10f0
126 #define ATKBD_CMD_GETID 0x02f2
127 #define ATKBD_CMD_SETREP 0x10f3
128 #define ATKBD_CMD_ENABLE 0x00f4
129 #define ATKBD_CMD_RESET_DIS 0x00f5
130 #define ATKBD_CMD_SETALL_MBR 0x00fa
131 #define ATKBD_CMD_RESET_BAT 0x02ff
132 #define ATKBD_CMD_RESEND 0x00fe
133 #define ATKBD_CMD_EX_ENABLE 0x10ea
134 #define ATKBD_CMD_EX_SETLEDS 0x20eb
135 #define ATKBD_CMD_OK_GETID 0x02e8
138 #define ATKBD_RET_ACK 0xfa
139 #define ATKBD_RET_NAK 0xfe
140 #define ATKBD_RET_BAT 0xaa
141 #define ATKBD_RET_EMUL0 0xe0
142 #define ATKBD_RET_EMUL1 0xe1
143 #define ATKBD_RET_RELEASE 0xf0
144 #define ATKBD_RET_HANGUEL 0xf1
145 #define ATKBD_RET_HANJA 0xf2
146 #define ATKBD_RET_ERR 0xff
148 #define ATKBD_KEY_UNKNOWN 0
149 #define ATKBD_KEY_NULL 255
151 #define ATKBD_SCR_1 254
152 #define ATKBD_SCR_2 253
153 #define ATKBD_SCR_4 252
154 #define ATKBD_SCR_8 251
155 #define ATKBD_SCR_CLICK 250
157 #define ATKBD_SPECIAL 250
159 static unsigned char atkbd_scroll_keys[5][2] = {
160 { ATKBD_SCR_1, 0x45 },
161 { ATKBD_SCR_2, 0x29 },
162 { ATKBD_SCR_4, 0x36 },
163 { ATKBD_SCR_8, 0x27 },
164 { ATKBD_SCR_CLICK, 0x60 },
168 * The atkbd control structure
172 unsigned char keycode[512];
173 struct input_dev dev;
180 unsigned int translated:1;
181 unsigned int extra:1;
182 unsigned int write:1;
184 unsigned char cmdbuf[4];
185 unsigned char cmdcnt;
186 volatile signed char ack;
188 unsigned int resend:1;
189 unsigned int release:1;
190 unsigned int bat_xl:1;
191 unsigned int enabled:1;
197 static void atkbd_report_key(struct input_dev *dev, struct pt_regs *regs, int code, int value)
199 input_regs(dev, regs);
201 input_report_key(dev, code, 1);
202 input_report_key(dev, code, 0);
204 input_event(dev, EV_KEY, code, value);
209 * atkbd_interrupt(). Here takes place processing of data received from
210 * the keyboard into events.
213 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
214 unsigned int flags, struct pt_regs *regs)
216 struct atkbd *atkbd = serio->private;
217 unsigned int code = data;
218 int scroll = 0, click = -1;
222 printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
225 #if !defined(__i386__) && !defined (__x86_64__)
226 if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
227 printk("atkbd.c: frame/parity error: %02x\n", flags);
228 serio_write(serio, ATKBD_CMD_RESEND);
233 if (!flags && data == ATKBD_RET_ACK)
248 atkbd->cmdbuf[--atkbd->cmdcnt] = code;
255 if (atkbd->translated) {
258 !(code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1 ||
259 code == ATKBD_RET_HANGUEL || code == ATKBD_RET_HANJA ||
260 code == ATKBD_RET_ERR ||
261 (code == ATKBD_RET_BAT && !atkbd->bat_xl))) {
262 atkbd->release = code >> 7;
267 (code & 0x7f) == (ATKBD_RET_BAT & 0x7f))
268 atkbd->bat_xl = !atkbd->release;
273 serio_rescan(atkbd->serio);
275 case ATKBD_RET_EMUL0:
278 case ATKBD_RET_EMUL1:
281 case ATKBD_RET_RELEASE:
284 case ATKBD_RET_HANGUEL:
285 atkbd_report_key(&atkbd->dev, regs, KEY_HANGUEL, 3);
287 case ATKBD_RET_HANJA:
288 atkbd_report_key(&atkbd->dev, regs, KEY_HANJA, 3);
291 printk(KERN_WARNING "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys);
296 code = (code & 0x7f) | ((code & 0x80) << 1);
300 code |= (atkbd->set != 3) ? 0x80 : 0x100;
303 switch (atkbd->keycode[code]) {
306 case ATKBD_KEY_UNKNOWN:
307 if (data == ATKBD_RET_ACK || data == ATKBD_RET_NAK) {
308 printk(KERN_WARNING "atkbd.c: Spurious %s on %s. Some program, "
309 "like XFree86, might be trying access hardware directly.\n",
310 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
312 printk(KERN_WARNING "atkbd.c: Unknown key %s "
313 "(%s set %d, code %#x on %s).\n",
314 atkbd->release ? "released" : "pressed",
315 atkbd->translated ? "translated" : "raw",
316 atkbd->set, code, serio->phys);
317 printk(KERN_WARNING "atkbd.c: Use 'setkeycodes %s%02x <keycode>' "
318 "to make it known.\n",
319 code & 0x80 ? "e0" : "", code & 0x7f);
323 scroll = 1 - atkbd->release * 2;
326 scroll = 2 - atkbd->release * 4;
329 scroll = 4 - atkbd->release * 8;
332 scroll = 8 - atkbd->release * 16;
334 case ATKBD_SCR_CLICK:
335 click = !atkbd->release;
338 value = atkbd->release ? 0 :
339 (1 + (!atkbd_softrepeat && test_bit(atkbd->keycode[code], atkbd->dev.key)));
341 switch (value) { /* Workaround Toshiba laptop multiple keypress */
347 atkbd->time = jiffies + (atkbd->dev.rep[REP_DELAY] * HZ + 500) / 1000 / 2;
350 if (!time_after(jiffies, atkbd->time) && atkbd->last == code)
355 atkbd_report_key(&atkbd->dev, regs, atkbd->keycode[code], value);
358 if (scroll || click != -1) {
359 input_regs(&atkbd->dev, regs);
360 input_report_key(&atkbd->dev, BTN_MIDDLE, click);
361 input_report_rel(&atkbd->dev, REL_WHEEL, scroll);
362 input_sync(&atkbd->dev);
371 * atkbd_sendbyte() sends a byte to the keyboard, and waits for
372 * acknowledge. It doesn't handle resends according to the keyboard
373 * protocol specs, because if these are needed, the keyboard needs
374 * replacement anyway, and they only make a mess in the protocol.
377 static int atkbd_sendbyte(struct atkbd *atkbd, unsigned char byte)
379 int timeout = 20000; /* 200 msec */
383 printk(KERN_DEBUG "atkbd.c: Sent: %02x\n", byte);
385 if (serio_write(atkbd->serio, byte))
388 while (!atkbd->ack && timeout--) udelay(10);
390 return -(atkbd->ack <= 0);
394 * atkbd_command() sends a command, and its parameters to the keyboard,
395 * then waits for the response and puts it in the param array.
398 static int atkbd_command(struct atkbd *atkbd, unsigned char *param, int command)
400 int timeout = 500000; /* 500 msec */
401 int send = (command >> 12) & 0xf;
402 int receive = (command >> 8) & 0xf;
405 atkbd->cmdcnt = receive;
407 if (command == ATKBD_CMD_RESET_BAT)
408 timeout = 2000000; /* 2 sec */
410 if (receive && param)
411 for (i = 0; i < receive; i++)
412 atkbd->cmdbuf[(receive - 1) - i] = param[i];
415 if (atkbd_sendbyte(atkbd, command & 0xff))
416 return (atkbd->cmdcnt = 0) - 1;
418 for (i = 0; i < send; i++)
419 if (atkbd_sendbyte(atkbd, param[i]))
420 return (atkbd->cmdcnt = 0) - 1;
422 while (atkbd->cmdcnt && timeout--) {
424 if (atkbd->cmdcnt == 1 &&
425 command == ATKBD_CMD_RESET_BAT && timeout > 100000)
428 if (atkbd->cmdcnt == 1 && command == ATKBD_CMD_GETID &&
429 atkbd->cmdbuf[1] != 0xab && atkbd->cmdbuf[1] != 0xac) {
438 for (i = 0; i < receive; i++)
439 param[i] = atkbd->cmdbuf[(receive - 1) - i];
441 if (command == ATKBD_CMD_RESET_BAT && atkbd->cmdcnt == 1)
453 * Event callback from the input module. Events that change the state of
454 * the hardware are processed here.
457 static int atkbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
459 struct atkbd *atkbd = dev->private;
460 const short period[32] =
461 { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125,
462 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
463 const short delay[4] =
464 { 250, 500, 750, 1000 };
465 unsigned char param[2];
475 param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
476 | (test_bit(LED_NUML, dev->led) ? 2 : 0)
477 | (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
478 atkbd_command(atkbd, param, ATKBD_CMD_SETLEDS);
482 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
483 | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
484 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
485 | (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
486 | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
487 atkbd_command(atkbd, param, ATKBD_CMD_EX_SETLEDS);
495 if (atkbd_softrepeat) return 0;
498 while (i < 32 && period[i] < dev->rep[REP_PERIOD]) i++;
499 while (j < 4 && delay[j] < dev->rep[REP_DELAY]) j++;
500 dev->rep[REP_PERIOD] = period[i];
501 dev->rep[REP_DELAY] = delay[j];
502 param[0] = i | (j << 5);
503 atkbd_command(atkbd, param, ATKBD_CMD_SETREP);
512 * atkbd_probe() probes for an AT keyboard on a serio port.
515 static int atkbd_probe(struct atkbd *atkbd)
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 (atkbd_command(atkbd, NULL, ATKBD_CMD_RESET_BAT))
527 printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", atkbd->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 (atkbd_command(atkbd, 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 (atkbd_command(atkbd, param, ATKBD_CMD_SETLEDS))
551 if (param[0] != 0xab && param[0] != 0xac)
553 atkbd->id = (param[0] << 8) | param[1];
555 if (atkbd->id == 0xaca1 && atkbd->translated) {
556 printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n");
557 printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n");
565 * atkbd_set_3 checks if a keyboard has a working Set 3 support, and
566 * sets it into that. Unfortunately there are keyboards that can be switched
567 * to Set 3, but don't work well in that (BTC Multimedia ...)
570 static int atkbd_set_3(struct atkbd *atkbd)
572 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 atkbd_command(atkbd, param, ATKBD_CMD_SSCANSET);
591 if (!atkbd_command(atkbd, param, ATKBD_CMD_EX_ENABLE)) {
600 if (!atkbd_command(atkbd, param, ATKBD_CMD_OK_GETID)) {
601 atkbd->id = param[0] << 8 | param[1];
606 if (atkbd_command(atkbd, param, ATKBD_CMD_SSCANSET))
610 if (atkbd_command(atkbd, param, ATKBD_CMD_GSCANSET))
615 if (atkbd_command(atkbd, param, ATKBD_CMD_SSCANSET))
619 atkbd_command(atkbd, param, ATKBD_CMD_SETALL_MBR);
624 static int atkbd_enable(struct atkbd *atkbd)
626 unsigned char param[1];
629 * Set the LEDs to a defined state.
633 if (atkbd_command(atkbd, param, ATKBD_CMD_SETLEDS))
637 * Set autorepeat to fastest possible.
641 if (atkbd_command(atkbd, param, ATKBD_CMD_SETREP))
645 * Enable the keyboard to receive keystrokes.
648 if (atkbd_command(atkbd, NULL, ATKBD_CMD_ENABLE)) {
649 printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
658 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
662 static void atkbd_cleanup(struct serio *serio)
664 struct atkbd *atkbd = serio->private;
665 atkbd_command(atkbd, NULL, ATKBD_CMD_RESET_BAT);
669 * atkbd_disconnect() closes and frees.
672 static void atkbd_disconnect(struct serio *serio)
674 struct atkbd *atkbd = serio->private;
675 input_unregister_device(&atkbd->dev);
681 * atkbd_connect() is called when the serio module finds and interface
682 * that isn't handled yet by an appropriate device driver. We check if
683 * there is an AT keyboard out there and if yes, we register ourselves
684 * to the input module.
687 static void atkbd_connect(struct serio *serio, struct serio_dev *dev)
692 if (!(atkbd = kmalloc(sizeof(struct atkbd), GFP_KERNEL)))
694 memset(atkbd, 0, sizeof(struct atkbd));
696 switch (serio->type & SERIO_TYPE) {
699 atkbd->translated = 1;
705 if ((serio->type & SERIO_PROTO) == SERIO_PS2SER)
713 atkbd->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_LED) | BIT(EV_REP);
714 atkbd->dev.ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL);
715 } else atkbd->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
717 if (!atkbd_softrepeat) {
718 atkbd->dev.rep[REP_DELAY] = 250;
719 atkbd->dev.rep[REP_PERIOD] = 33;
723 atkbd->serio = serio;
725 init_input_dev(&atkbd->dev);
727 atkbd->dev.keycode = atkbd->keycode;
728 atkbd->dev.keycodesize = sizeof(unsigned char);
729 atkbd->dev.keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
730 atkbd->dev.event = atkbd_event;
731 atkbd->dev.private = atkbd;
733 serio->private = atkbd;
735 if (serio_open(serio, dev)) {
742 if (atkbd_probe(atkbd)) {
744 serio->private = NULL;
749 atkbd->set = atkbd_set_3(atkbd);
760 atkbd->dev.ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) | BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC);
761 sprintf(atkbd->name, "AT Set 2 Extra keyboard");
763 sprintf(atkbd->name, "AT %s Set %d keyboard",
764 atkbd->translated ? "Translated" : "Raw", atkbd->set);
766 sprintf(atkbd->phys, "%s/input0", serio->phys);
769 for (i = 0; i < 5; i++)
770 atkbd_set2_keycode[atkbd_scroll_keys[i][1]] = atkbd_scroll_keys[i][0];
771 atkbd->dev.evbit[0] |= BIT(EV_REL);
772 atkbd->dev.relbit[0] = BIT(REL_WHEEL);
773 set_bit(BTN_MIDDLE, atkbd->dev.keybit);
776 if (atkbd->translated) {
777 for (i = 0; i < 128; i++) {
778 atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
779 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
781 } else if (atkbd->set == 3) {
782 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
784 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
787 atkbd->dev.name = atkbd->name;
788 atkbd->dev.phys = atkbd->phys;
789 atkbd->dev.id.bustype = BUS_I8042;
790 atkbd->dev.id.vendor = 0x0001;
791 atkbd->dev.id.product = atkbd->translated ? 1 : atkbd->set;
792 atkbd->dev.id.version = atkbd->id;
794 for (i = 0; i < 512; i++)
795 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
796 set_bit(atkbd->keycode[i], atkbd->dev.keybit);
798 input_register_device(&atkbd->dev);
800 printk(KERN_INFO "input: %s on %s\n", atkbd->name, serio->phys);
804 * atkbd_reconnect() tries to restore keyboard into a sane state and is
805 * most likely called on resume.
808 static int atkbd_reconnect(struct serio *serio)
810 struct atkbd *atkbd = serio->private;
811 struct serio_dev *dev = serio->dev;
812 unsigned char param[1];
815 printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
820 param[0] = (test_bit(LED_SCROLLL, atkbd->dev.led) ? 1 : 0)
821 | (test_bit(LED_NUML, atkbd->dev.led) ? 2 : 0)
822 | (test_bit(LED_CAPSL, atkbd->dev.led) ? 4 : 0);
824 if (atkbd_probe(atkbd))
826 if (atkbd->set != atkbd_set_3(atkbd))
831 if (atkbd_command(atkbd, param, ATKBD_CMD_SETLEDS))
838 static struct serio_dev atkbd_dev = {
839 .interrupt = atkbd_interrupt,
840 .connect = atkbd_connect,
841 .reconnect = atkbd_reconnect,
842 .disconnect = atkbd_disconnect,
843 .cleanup = atkbd_cleanup,
846 int __init atkbd_init(void)
848 serio_register_device(&atkbd_dev);
852 void __exit atkbd_exit(void)
854 serio_unregister_device(&atkbd_dev);
857 module_init(atkbd_init);
858 module_exit(atkbd_exit);