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/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/init.h>
25 #include <linux/input.h>
26 #include <linux/serio.h>
27 #include <linux/workqueue.h>
28 #include <linux/libps2.h>
29 #include <linux/mutex.h>
30 #include <linux/dmi.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 bool atkbd_reset;
45 static bool atkbd_reset = true;
47 module_param_named(reset, atkbd_reset, bool, 0);
48 MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
50 static bool atkbd_softrepeat;
51 module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
52 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
54 static bool atkbd_softraw = true;
55 module_param_named(softraw, atkbd_softraw, bool, 0);
56 MODULE_PARM_DESC(softraw, "Use software generated rawmode");
58 static bool 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 bool 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");
67 * Scancode to keycode tables. These are just the default setting, and
68 * are loadable via a userland utility.
71 #define ATKBD_KEYMAP_SIZE 512
73 static const unsigned short atkbd_set2_keycode[ATKBD_KEYMAP_SIZE] = {
75 #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
77 /* XXX: need a more general approach */
79 #include "hpps2atkbd.h" /* include the keyboard scancodes */
82 0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117,
83 0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0,
84 0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183,
85 0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185,
86 0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0,
87 0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85,
88 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0,
89 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
91 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
92 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
93 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
94 159, 0,115, 0,164, 0, 0,116,158, 0,172,166, 0, 0, 0,142,
95 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
96 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
97 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
98 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
104 static const unsigned short atkbd_set3_keycode[ATKBD_KEYMAP_SIZE] = {
106 0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60,
107 131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62,
108 134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64,
109 136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66,
110 125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
111 113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
112 108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104,
113 82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183,
115 184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0,
116 0,139,172,163,165,115,152,172,166,140,160,154,113,114,167,168,
120 static const unsigned short atkbd_unxlate_table[128] = {
121 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
122 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
123 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
124 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3,
125 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105,
126 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63,
127 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
128 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
131 #define ATKBD_CMD_SETLEDS 0x10ed
132 #define ATKBD_CMD_GSCANSET 0x11f0
133 #define ATKBD_CMD_SSCANSET 0x10f0
134 #define ATKBD_CMD_GETID 0x02f2
135 #define ATKBD_CMD_SETREP 0x10f3
136 #define ATKBD_CMD_ENABLE 0x00f4
137 #define ATKBD_CMD_RESET_DIS 0x00f5 /* Reset to defaults and disable */
138 #define ATKBD_CMD_RESET_DEF 0x00f6 /* Reset to defaults */
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_HANJA 0xf1
153 #define ATKBD_RET_HANGEUL 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 ATKBD_SCR_RIGHT
169 #define ATKBD_LED_EVENT_BIT 0
170 #define ATKBD_REP_EVENT_BIT 1
172 #define ATKBD_XL_ERR 0x01
173 #define ATKBD_XL_BAT 0x02
174 #define ATKBD_XL_ACK 0x04
175 #define ATKBD_XL_NAK 0x08
176 #define ATKBD_XL_HANGEUL 0x10
177 #define ATKBD_XL_HANJA 0x20
179 static const struct {
180 unsigned char keycode;
182 } atkbd_scroll_keys[] = {
183 { ATKBD_SCR_1, 0xc5 },
184 { ATKBD_SCR_2, 0x9d },
185 { ATKBD_SCR_4, 0xa4 },
186 { ATKBD_SCR_8, 0x9b },
187 { ATKBD_SCR_CLICK, 0xe0 },
188 { ATKBD_SCR_LEFT, 0xcb },
189 { ATKBD_SCR_RIGHT, 0xd2 },
193 * The atkbd control structure
198 struct ps2dev ps2dev;
199 struct input_dev *dev;
201 /* Written only during init */
206 unsigned short keycode[ATKBD_KEYMAP_SIZE];
207 DECLARE_BITMAP(force_release_mask, ATKBD_KEYMAP_SIZE);
217 /* Accessed only from interrupt */
221 unsigned long xl_bit;
224 unsigned long err_count;
226 struct delayed_work event_work;
227 unsigned long event_jiffies;
228 unsigned long event_mask;
230 /* Serializes reconnect(), attr->set() and event work */
235 * System-specific keymap fixup routine
237 static void (*atkbd_platform_fixup)(struct atkbd *, const void *data);
238 static void *atkbd_platform_fixup_data;
239 static unsigned int (*atkbd_platform_scancode_fixup)(struct atkbd *, unsigned int);
241 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
242 ssize_t (*handler)(struct atkbd *, char *));
243 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
244 ssize_t (*handler)(struct atkbd *, const char *, size_t));
245 #define ATKBD_DEFINE_ATTR(_name) \
246 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
247 static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \
248 static ssize_t atkbd_do_show_##_name(struct device *d, \
249 struct device_attribute *attr, char *b) \
251 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
253 static ssize_t atkbd_do_set_##_name(struct device *d, \
254 struct device_attribute *attr, const char *b, size_t s) \
256 return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \
258 static struct device_attribute atkbd_attr_##_name = \
259 __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
261 ATKBD_DEFINE_ATTR(extra);
262 ATKBD_DEFINE_ATTR(force_release);
263 ATKBD_DEFINE_ATTR(scroll);
264 ATKBD_DEFINE_ATTR(set);
265 ATKBD_DEFINE_ATTR(softrepeat);
266 ATKBD_DEFINE_ATTR(softraw);
268 #define ATKBD_DEFINE_RO_ATTR(_name) \
269 static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
270 static ssize_t atkbd_do_show_##_name(struct device *d, \
271 struct device_attribute *attr, char *b) \
273 return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
275 static struct device_attribute atkbd_attr_##_name = \
276 __ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL);
278 ATKBD_DEFINE_RO_ATTR(err_count);
280 static struct attribute *atkbd_attributes[] = {
281 &atkbd_attr_extra.attr,
282 &atkbd_attr_force_release.attr,
283 &atkbd_attr_scroll.attr,
284 &atkbd_attr_set.attr,
285 &atkbd_attr_softrepeat.attr,
286 &atkbd_attr_softraw.attr,
287 &atkbd_attr_err_count.attr,
291 static struct attribute_group atkbd_attribute_group = {
292 .attrs = atkbd_attributes,
295 static const unsigned int xl_table[] = {
296 ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK,
297 ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL,
301 * Checks if we should mangle the scancode to extract 'release' bit
302 * in translated mode.
304 static bool atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
308 if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
311 for (i = 0; i < ARRAY_SIZE(xl_table); i++)
312 if (code == xl_table[i])
313 return test_bit(i, &xl_bit);
319 * Calculates new value of xl_bit so the driver can distinguish
320 * between make/break pair of scancodes for select keys and PS/2
321 * protocol responses.
323 static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code)
327 for (i = 0; i < ARRAY_SIZE(xl_table); i++) {
328 if (!((code ^ xl_table[i]) & 0x7f)) {
330 __clear_bit(i, &atkbd->xl_bit);
332 __set_bit(i, &atkbd->xl_bit);
339 * Encode the scancode, 0xe0 prefix, and high bit into a single integer,
340 * keeping kernel 2.4 compatibility for set 2
342 static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code)
344 if (atkbd->set == 3) {
345 if (atkbd->emul == 1)
348 code = (code & 0x7f) | ((code & 0x80) << 1);
349 if (atkbd->emul == 1)
357 * atkbd_interrupt(). Here takes place processing of data received from
358 * the keyboard into events.
361 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
364 struct atkbd *atkbd = serio_get_drvdata(serio);
365 struct input_dev *dev = atkbd->dev;
366 unsigned int code = data;
367 int scroll = 0, hscroll = 0, click = -1;
369 unsigned short keycode;
371 dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags);
373 #if !defined(__i386__) && !defined (__x86_64__)
374 if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
375 dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags);
376 serio_write(serio, ATKBD_CMD_RESEND);
377 atkbd->resend = true;
381 if (!flags && data == ATKBD_RET_ACK)
382 atkbd->resend = false;
385 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
386 if (ps2_handle_ack(&atkbd->ps2dev, data))
389 if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
390 if (ps2_handle_response(&atkbd->ps2dev, data))
396 input_event(dev, EV_MSC, MSC_RAW, code);
398 if (atkbd_platform_scancode_fixup)
399 code = atkbd_platform_scancode_fixup(atkbd, code);
401 if (atkbd->translated) {
403 if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
404 atkbd->release = code >> 7;
409 atkbd_calculate_xl_bit(atkbd, data);
414 atkbd->enabled = false;
415 serio_reconnect(atkbd->ps2dev.serio);
417 case ATKBD_RET_EMUL0:
420 case ATKBD_RET_EMUL1:
423 case ATKBD_RET_RELEASE:
424 atkbd->release = true;
428 if (printk_ratelimit())
429 dev_warn(&serio->dev,
430 "Spurious %s on %s. "
431 "Some program might be trying access hardware directly.\n",
432 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
436 dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n",
441 code = atkbd_compat_scancode(atkbd, code);
443 if (atkbd->emul && --atkbd->emul)
446 keycode = atkbd->keycode[code];
448 if (keycode != ATKBD_KEY_NULL)
449 input_event(dev, EV_MSC, MSC_SCAN, code);
454 case ATKBD_KEY_UNKNOWN:
455 dev_warn(&serio->dev,
456 "Unknown key %s (%s set %d, code %#x on %s).\n",
457 atkbd->release ? "released" : "pressed",
458 atkbd->translated ? "translated" : "raw",
459 atkbd->set, code, serio->phys);
460 dev_warn(&serio->dev,
461 "Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
462 code & 0x80 ? "e0" : "", code & 0x7f);
477 case ATKBD_SCR_CLICK:
478 click = !atkbd->release;
483 case ATKBD_SCR_RIGHT:
487 if (atkbd->release) {
490 } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
491 /* Workaround Toshiba laptop multiple keypress */
492 value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
496 atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
499 input_event(dev, EV_KEY, keycode, value);
502 if (value && test_bit(code, atkbd->force_release_mask)) {
503 input_report_key(dev, keycode, 0);
510 input_report_key(dev, BTN_MIDDLE, click);
511 input_report_rel(dev, REL_WHEEL,
512 atkbd->release ? -scroll : scroll);
513 input_report_rel(dev, REL_HWHEEL, hscroll);
517 atkbd->release = false;
522 static int atkbd_set_repeat_rate(struct atkbd *atkbd)
524 const short period[32] =
525 { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125,
526 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
527 const short delay[4] =
528 { 250, 500, 750, 1000 };
530 struct input_dev *dev = atkbd->dev;
534 while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
536 dev->rep[REP_PERIOD] = period[i];
538 while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
540 dev->rep[REP_DELAY] = delay[j];
542 param = i | (j << 5);
543 return ps2_command(&atkbd->ps2dev, ¶m, ATKBD_CMD_SETREP);
546 static int atkbd_set_leds(struct atkbd *atkbd)
548 struct input_dev *dev = atkbd->dev;
549 unsigned char param[2];
551 param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
552 | (test_bit(LED_NUML, dev->led) ? 2 : 0)
553 | (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
554 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
559 param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
560 | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
561 | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
562 | (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
563 | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
564 if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
572 * atkbd_event_work() is used to complete processing of events that
573 * can not be processed by input_event() which is often called from
577 static void atkbd_event_work(struct work_struct *work)
579 struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work);
581 mutex_lock(&atkbd->mutex);
583 if (!atkbd->enabled) {
585 * Serio ports are resumed asynchronously so while driver core
586 * thinks that device is already fully operational in reality
587 * it may not be ready yet. In this case we need to keep
588 * rescheduling till reconnect completes.
590 schedule_delayed_work(&atkbd->event_work,
591 msecs_to_jiffies(100));
593 if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
594 atkbd_set_leds(atkbd);
596 if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
597 atkbd_set_repeat_rate(atkbd);
600 mutex_unlock(&atkbd->mutex);
604 * Schedule switch for execution. We need to throttle requests,
605 * otherwise keyboard may become unresponsive.
607 static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit)
609 unsigned long delay = msecs_to_jiffies(50);
611 if (time_after(jiffies, atkbd->event_jiffies + delay))
614 atkbd->event_jiffies = jiffies;
615 set_bit(event_bit, &atkbd->event_mask);
617 schedule_delayed_work(&atkbd->event_work, delay);
621 * Event callback from the input module. Events that change the state of
622 * the hardware are processed here. If action can not be performed in
623 * interrupt context it is offloaded to atkbd_event_work.
626 static int atkbd_event(struct input_dev *dev,
627 unsigned int type, unsigned int code, int value)
629 struct atkbd *atkbd = input_get_drvdata(dev);
637 atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
641 if (!atkbd->softrepeat)
642 atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
651 * atkbd_enable() signals that interrupt handler is allowed to
652 * generate input events.
655 static inline void atkbd_enable(struct atkbd *atkbd)
657 serio_pause_rx(atkbd->ps2dev.serio);
658 atkbd->enabled = true;
659 serio_continue_rx(atkbd->ps2dev.serio);
663 * atkbd_disable() tells input handler that all incoming data except
664 * for ACKs and command response should be dropped.
667 static inline void atkbd_disable(struct atkbd *atkbd)
669 serio_pause_rx(atkbd->ps2dev.serio);
670 atkbd->enabled = false;
671 serio_continue_rx(atkbd->ps2dev.serio);
675 * atkbd_probe() probes for an AT keyboard on a serio port.
678 static int atkbd_probe(struct atkbd *atkbd)
680 struct ps2dev *ps2dev = &atkbd->ps2dev;
681 unsigned char param[2];
684 * Some systems, where the bit-twiddling when testing the io-lines of the
685 * controller may confuse the keyboard need a full reset of the keyboard. On
686 * these systems the BIOS also usually doesn't do it for us.
690 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
691 dev_warn(&ps2dev->serio->dev,
692 "keyboard reset failed on %s\n",
693 ps2dev->serio->phys);
696 * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
697 * Some keyboards report different values, but the first byte is always 0xab or
698 * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
699 * should make sure we don't try to set the LEDs on it.
702 param[0] = param[1] = 0xa5; /* initialize with invalid values */
703 if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
706 * If the get ID command failed, we check if we can at least set the LEDs on
707 * the keyboard. This should work on every keyboard out there. It also turns
708 * the LEDs off, which we want anyway.
711 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
717 if (!ps2_is_keyboard_id(param[0]))
720 atkbd->id = (param[0] << 8) | param[1];
722 if (atkbd->id == 0xaca1 && atkbd->translated) {
723 dev_err(&ps2dev->serio->dev,
724 "NCD terminal keyboards are only supported on non-translating controlelrs. "
725 "Use i8042.direct=1 to disable translation.\n");
733 * atkbd_select_set checks if a keyboard has a working Set 3 support, and
734 * sets it into that. Unfortunately there are keyboards that can be switched
735 * to Set 3, but don't work well in that (BTC Multimedia ...)
738 static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
740 struct ps2dev *ps2dev = &atkbd->ps2dev;
741 unsigned char param[2];
743 atkbd->extra = false;
745 * For known special keyboards we can go ahead and set the correct set.
746 * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
747 * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
750 if (atkbd->translated)
753 if (atkbd->id == 0xaca1) {
755 ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
761 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
770 if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
771 atkbd->id = param[0] << 8 | param[1];
776 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
780 if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
785 if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
789 ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
794 static int atkbd_reset_state(struct atkbd *atkbd)
796 struct ps2dev *ps2dev = &atkbd->ps2dev;
797 unsigned char param[1];
800 * Set the LEDs to a predefined state (all off).
804 if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
808 * Set autorepeat to fastest possible.
812 if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
818 static int atkbd_activate(struct atkbd *atkbd)
820 struct ps2dev *ps2dev = &atkbd->ps2dev;
823 * Enable the keyboard to receive keystrokes.
826 if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
827 dev_err(&ps2dev->serio->dev,
828 "Failed to enable keyboard on %s\n",
829 ps2dev->serio->phys);
837 * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
841 static void atkbd_cleanup(struct serio *serio)
843 struct atkbd *atkbd = serio_get_drvdata(serio);
845 atkbd_disable(atkbd);
846 ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF);
851 * atkbd_disconnect() closes and frees.
854 static void atkbd_disconnect(struct serio *serio)
856 struct atkbd *atkbd = serio_get_drvdata(serio);
858 sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
860 atkbd_disable(atkbd);
862 input_unregister_device(atkbd->dev);
865 * Make sure we don't have a command in flight.
866 * Note that since atkbd->enabled is false event work will keep
867 * rescheduling itself until it gets canceled and will not try
868 * accessing freed input device or serio port.
870 cancel_delayed_work_sync(&atkbd->event_work);
873 serio_set_drvdata(serio, NULL);
878 * generate release events for the keycodes given in data
880 static void atkbd_apply_forced_release_keylist(struct atkbd* atkbd,
883 const unsigned int *keys = data;
887 for (i = 0; keys[i] != -1U; i++)
888 __set_bit(keys[i], atkbd->force_release_mask);
892 * Most special keys (Fn+F?) on Dell laptops do not generate release
893 * events so we have to do it ourselves.
895 static unsigned int atkbd_dell_laptop_forced_release_keys[] = {
896 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U
900 * Perform fixup for HP system that doesn't generate release
901 * for its video switch
903 static unsigned int atkbd_hp_forced_release_keys[] = {
908 * Samsung NC10,NC20 with Fn+F? key release not working
910 static unsigned int atkbd_samsung_forced_release_keys[] = {
911 0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U
915 * Amilo Pi 3525 key release for Fn+Volume keys not working
917 static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = {
918 0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
922 * Amilo Xi 3650 key release for light touch bar not working
924 static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = {
925 0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
929 * Soltech TA12 system with broken key release on volume keys and mute key
931 static unsigned int atkdb_soltech_ta12_forced_release_keys[] = {
932 0xa0, 0xae, 0xb0, -1U
936 * Many notebooks don't send key release event for volume up/down
937 * keys, with key list below common among them
939 static unsigned int atkbd_volume_forced_release_keys[] = {
944 * OQO 01+ multimedia keys (64--66) generate e0 6x upon release whereas
945 * they should be generating e4-e6 (0x80 | code).
947 static unsigned int atkbd_oqo_01plus_scancode_fixup(struct atkbd *atkbd,
950 if (atkbd->translated && atkbd->emul == 1 &&
951 (code == 0x64 || code == 0x65 || code == 0x66)) {
960 * atkbd_set_keycode_table() initializes keyboard's keycode table
961 * according to the selected scancode set
964 static void atkbd_set_keycode_table(struct atkbd *atkbd)
966 unsigned int scancode;
969 memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
970 bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
972 if (atkbd->translated) {
973 for (i = 0; i < 128; i++) {
974 scancode = atkbd_unxlate_table[i];
975 atkbd->keycode[i] = atkbd_set2_keycode[scancode];
976 atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
978 for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
979 if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
980 atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
982 } else if (atkbd->set == 3) {
983 memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
985 memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
988 for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
989 scancode = atkbd_scroll_keys[i].set2;
990 atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
995 * HANGEUL and HANJA keys do not send release events so we need to
996 * generate such events ourselves
998 scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
999 atkbd->keycode[scancode] = KEY_HANGEUL;
1000 __set_bit(scancode, atkbd->force_release_mask);
1002 scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
1003 atkbd->keycode[scancode] = KEY_HANJA;
1004 __set_bit(scancode, atkbd->force_release_mask);
1007 * Perform additional fixups
1009 if (atkbd_platform_fixup)
1010 atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
1014 * atkbd_set_device_attrs() sets up keyboard's input device structure
1017 static void atkbd_set_device_attrs(struct atkbd *atkbd)
1019 struct input_dev *input_dev = atkbd->dev;
1023 snprintf(atkbd->name, sizeof(atkbd->name),
1024 "AT Set 2 Extra keyboard");
1026 snprintf(atkbd->name, sizeof(atkbd->name),
1027 "AT %s Set %d keyboard",
1028 atkbd->translated ? "Translated" : "Raw", atkbd->set);
1030 snprintf(atkbd->phys, sizeof(atkbd->phys),
1031 "%s/input0", atkbd->ps2dev.serio->phys);
1033 input_dev->name = atkbd->name;
1034 input_dev->phys = atkbd->phys;
1035 input_dev->id.bustype = BUS_I8042;
1036 input_dev->id.vendor = 0x0001;
1037 input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
1038 input_dev->id.version = atkbd->id;
1039 input_dev->event = atkbd_event;
1040 input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
1042 input_set_drvdata(input_dev, atkbd);
1044 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
1048 input_dev->evbit[0] |= BIT_MASK(EV_LED);
1049 input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1050 BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
1054 input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
1055 BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
1056 BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
1058 if (!atkbd->softrepeat) {
1059 input_dev->rep[REP_DELAY] = 250;
1060 input_dev->rep[REP_PERIOD] = 33;
1063 input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1064 BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1066 if (atkbd->scroll) {
1067 input_dev->evbit[0] |= BIT_MASK(EV_REL);
1068 input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1069 BIT_MASK(REL_HWHEEL);
1070 __set_bit(BTN_MIDDLE, input_dev->keybit);
1073 input_dev->keycode = atkbd->keycode;
1074 input_dev->keycodesize = sizeof(unsigned short);
1075 input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1077 for (i = 0; i < ATKBD_KEYMAP_SIZE; i++)
1078 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
1079 __set_bit(atkbd->keycode[i], input_dev->keybit);
1083 * atkbd_connect() is called when the serio module finds an interface
1084 * that isn't handled yet by an appropriate device driver. We check if
1085 * there is an AT keyboard out there and if yes, we register ourselves
1086 * to the input module.
1089 static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1091 struct atkbd *atkbd;
1092 struct input_dev *dev;
1095 atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
1096 dev = input_allocate_device();
1101 ps2_init(&atkbd->ps2dev, serio);
1102 INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1103 mutex_init(&atkbd->mutex);
1105 switch (serio->id.type) {
1108 atkbd->translated = true;
1113 atkbd->write = true;
1117 atkbd->softraw = atkbd_softraw;
1118 atkbd->softrepeat = atkbd_softrepeat;
1119 atkbd->scroll = atkbd_scroll;
1121 if (atkbd->softrepeat)
1122 atkbd->softraw = true;
1124 serio_set_drvdata(serio, atkbd);
1126 err = serio_open(serio, drv);
1132 if (atkbd_probe(atkbd)) {
1137 atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1138 atkbd_reset_state(atkbd);
1139 atkbd_activate(atkbd);
1146 atkbd_set_keycode_table(atkbd);
1147 atkbd_set_device_attrs(atkbd);
1149 err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1153 atkbd_enable(atkbd);
1155 err = input_register_device(atkbd->dev);
1161 fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1162 fail3: serio_close(serio);
1163 fail2: serio_set_drvdata(serio, NULL);
1164 fail1: input_free_device(dev);
1170 * atkbd_reconnect() tries to restore keyboard into a sane state and is
1171 * most likely called on resume.
1174 static int atkbd_reconnect(struct serio *serio)
1176 struct atkbd *atkbd = serio_get_drvdata(serio);
1177 struct serio_driver *drv = serio->drv;
1180 if (!atkbd || !drv) {
1181 dev_dbg(&serio->dev,
1182 "reconnect request, but serio is disconnected, ignoring...\n");
1186 mutex_lock(&atkbd->mutex);
1188 atkbd_disable(atkbd);
1191 if (atkbd_probe(atkbd))
1194 if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1197 atkbd_activate(atkbd);
1200 * Restore LED state and repeat rate. While input core
1201 * will do this for us at resume time reconnect may happen
1202 * because user requested it via sysfs or simply because
1203 * keyboard was unplugged and plugged in again so we need
1204 * to do it ourselves here.
1206 atkbd_set_leds(atkbd);
1207 if (!atkbd->softrepeat)
1208 atkbd_set_repeat_rate(atkbd);
1212 atkbd_enable(atkbd);
1216 mutex_unlock(&atkbd->mutex);
1220 static struct serio_device_id atkbd_serio_ids[] = {
1228 .type = SERIO_8042_XL,
1234 .type = SERIO_RS232,
1235 .proto = SERIO_PS2SER,
1242 MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1244 static struct serio_driver atkbd_drv = {
1248 .description = DRIVER_DESC,
1249 .id_table = atkbd_serio_ids,
1250 .interrupt = atkbd_interrupt,
1251 .connect = atkbd_connect,
1252 .reconnect = atkbd_reconnect,
1253 .disconnect = atkbd_disconnect,
1254 .cleanup = atkbd_cleanup,
1257 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1258 ssize_t (*handler)(struct atkbd *, char *))
1260 struct serio *serio = to_serio_port(dev);
1261 struct atkbd *atkbd = serio_get_drvdata(serio);
1263 return handler(atkbd, buf);
1266 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1267 ssize_t (*handler)(struct atkbd *, const char *, size_t))
1269 struct serio *serio = to_serio_port(dev);
1270 struct atkbd *atkbd = serio_get_drvdata(serio);
1273 retval = mutex_lock_interruptible(&atkbd->mutex);
1277 atkbd_disable(atkbd);
1278 retval = handler(atkbd, buf, count);
1279 atkbd_enable(atkbd);
1281 mutex_unlock(&atkbd->mutex);
1286 static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1288 return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1291 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1293 struct input_dev *old_dev, *new_dev;
1294 unsigned long value;
1297 unsigned char old_set;
1302 if (strict_strtoul(buf, 10, &value) || value > 1)
1305 if (atkbd->extra != value) {
1307 * Since device's properties will change we need to
1308 * unregister old device. But allocate and register
1309 * new one first to make sure we have it.
1311 old_dev = atkbd->dev;
1312 old_extra = atkbd->extra;
1313 old_set = atkbd->set;
1315 new_dev = input_allocate_device();
1319 atkbd->dev = new_dev;
1320 atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1321 atkbd_reset_state(atkbd);
1322 atkbd_activate(atkbd);
1323 atkbd_set_keycode_table(atkbd);
1324 atkbd_set_device_attrs(atkbd);
1326 err = input_register_device(atkbd->dev);
1328 input_free_device(new_dev);
1330 atkbd->dev = old_dev;
1331 atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1332 atkbd_set_keycode_table(atkbd);
1333 atkbd_set_device_attrs(atkbd);
1337 input_unregister_device(old_dev);
1343 static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
1345 size_t len = bitmap_scnlistprintf(buf, PAGE_SIZE - 2,
1346 atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1354 static ssize_t atkbd_set_force_release(struct atkbd *atkbd,
1355 const char *buf, size_t count)
1357 /* 64 bytes on stack should be acceptable */
1358 DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE);
1361 err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE);
1365 memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1370 static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1372 return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1375 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1377 struct input_dev *old_dev, *new_dev;
1378 unsigned long value;
1382 if (strict_strtoul(buf, 10, &value) || value > 1)
1385 if (atkbd->scroll != value) {
1386 old_dev = atkbd->dev;
1387 old_scroll = atkbd->scroll;
1389 new_dev = input_allocate_device();
1393 atkbd->dev = new_dev;
1394 atkbd->scroll = value;
1395 atkbd_set_keycode_table(atkbd);
1396 atkbd_set_device_attrs(atkbd);
1398 err = input_register_device(atkbd->dev);
1400 input_free_device(new_dev);
1402 atkbd->scroll = old_scroll;
1403 atkbd->dev = old_dev;
1404 atkbd_set_keycode_table(atkbd);
1405 atkbd_set_device_attrs(atkbd);
1409 input_unregister_device(old_dev);
1414 static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1416 return sprintf(buf, "%d\n", atkbd->set);
1419 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1421 struct input_dev *old_dev, *new_dev;
1422 unsigned long value;
1424 unsigned char old_set;
1430 if (strict_strtoul(buf, 10, &value) || (value != 2 && value != 3))
1433 if (atkbd->set != value) {
1434 old_dev = atkbd->dev;
1435 old_extra = atkbd->extra;
1436 old_set = atkbd->set;
1438 new_dev = input_allocate_device();
1442 atkbd->dev = new_dev;
1443 atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1444 atkbd_reset_state(atkbd);
1445 atkbd_activate(atkbd);
1446 atkbd_set_keycode_table(atkbd);
1447 atkbd_set_device_attrs(atkbd);
1449 err = input_register_device(atkbd->dev);
1451 input_free_device(new_dev);
1453 atkbd->dev = old_dev;
1454 atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1455 atkbd_set_keycode_table(atkbd);
1456 atkbd_set_device_attrs(atkbd);
1460 input_unregister_device(old_dev);
1465 static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1467 return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1470 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1472 struct input_dev *old_dev, *new_dev;
1473 unsigned long value;
1475 bool old_softrepeat, old_softraw;
1480 if (strict_strtoul(buf, 10, &value) || value > 1)
1483 if (atkbd->softrepeat != value) {
1484 old_dev = atkbd->dev;
1485 old_softrepeat = atkbd->softrepeat;
1486 old_softraw = atkbd->softraw;
1488 new_dev = input_allocate_device();
1492 atkbd->dev = new_dev;
1493 atkbd->softrepeat = value;
1494 if (atkbd->softrepeat)
1495 atkbd->softraw = true;
1496 atkbd_set_device_attrs(atkbd);
1498 err = input_register_device(atkbd->dev);
1500 input_free_device(new_dev);
1502 atkbd->dev = old_dev;
1503 atkbd->softrepeat = old_softrepeat;
1504 atkbd->softraw = old_softraw;
1505 atkbd_set_device_attrs(atkbd);
1509 input_unregister_device(old_dev);
1515 static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1517 return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1520 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1522 struct input_dev *old_dev, *new_dev;
1523 unsigned long value;
1527 if (strict_strtoul(buf, 10, &value) || value > 1)
1530 if (atkbd->softraw != value) {
1531 old_dev = atkbd->dev;
1532 old_softraw = atkbd->softraw;
1534 new_dev = input_allocate_device();
1538 atkbd->dev = new_dev;
1539 atkbd->softraw = value;
1540 atkbd_set_device_attrs(atkbd);
1542 err = input_register_device(atkbd->dev);
1544 input_free_device(new_dev);
1546 atkbd->dev = old_dev;
1547 atkbd->softraw = old_softraw;
1548 atkbd_set_device_attrs(atkbd);
1552 input_unregister_device(old_dev);
1557 static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1559 return sprintf(buf, "%lu\n", atkbd->err_count);
1562 static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1564 atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
1565 atkbd_platform_fixup_data = id->driver_data;
1570 static int __init atkbd_setup_scancode_fixup(const struct dmi_system_id *id)
1572 atkbd_platform_scancode_fixup = id->driver_data;
1577 static const struct dmi_system_id atkbd_dmi_quirk_table[] __initconst = {
1580 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1581 DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1583 .callback = atkbd_setup_forced_release,
1584 .driver_data = atkbd_dell_laptop_forced_release_keys,
1588 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
1589 DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1591 .callback = atkbd_setup_forced_release,
1592 .driver_data = atkbd_dell_laptop_forced_release_keys,
1596 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1597 DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1599 .callback = atkbd_setup_forced_release,
1600 .driver_data = atkbd_hp_forced_release_keys,
1604 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1605 DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1607 .callback = atkbd_setup_forced_release,
1608 .driver_data = atkbd_volume_forced_release_keys,
1612 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1613 DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"),
1615 .callback = atkbd_setup_forced_release,
1616 .driver_data = atkbd_volume_forced_release_keys,
1620 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1621 DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"),
1623 .callback = atkbd_setup_forced_release,
1624 .driver_data = atkbd_volume_forced_release_keys,
1628 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1629 DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"),
1631 .callback = atkbd_setup_forced_release,
1632 .driver_data = atkbd_volume_forced_release_keys,
1635 /* Inventec Symphony */
1637 DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1638 DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1640 .callback = atkbd_setup_forced_release,
1641 .driver_data = atkbd_volume_forced_release_keys,
1646 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1647 DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
1649 .callback = atkbd_setup_forced_release,
1650 .driver_data = atkbd_samsung_forced_release_keys,
1655 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1656 DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
1658 .callback = atkbd_setup_forced_release,
1659 .driver_data = atkbd_samsung_forced_release_keys,
1662 /* Samsung SQ45S70S */
1664 DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1665 DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
1667 .callback = atkbd_setup_forced_release,
1668 .driver_data = atkbd_samsung_forced_release_keys,
1671 /* Fujitsu Amilo PA 1510 */
1673 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1674 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
1676 .callback = atkbd_setup_forced_release,
1677 .driver_data = atkbd_volume_forced_release_keys,
1680 /* Fujitsu Amilo Pi 3525 */
1682 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1683 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
1685 .callback = atkbd_setup_forced_release,
1686 .driver_data = atkbd_amilo_pi3525_forced_release_keys,
1689 /* Fujitsu Amilo Xi 3650 */
1691 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1692 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
1694 .callback = atkbd_setup_forced_release,
1695 .driver_data = atkbd_amilo_xi3650_forced_release_keys,
1699 DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"),
1700 DMI_MATCH(DMI_PRODUCT_NAME, "TA12"),
1702 .callback = atkbd_setup_forced_release,
1703 .driver_data = atkdb_soltech_ta12_forced_release_keys,
1708 DMI_MATCH(DMI_SYS_VENDOR, "OQO"),
1709 DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"),
1711 .callback = atkbd_setup_scancode_fixup,
1712 .driver_data = atkbd_oqo_01plus_scancode_fixup,
1717 static int __init atkbd_init(void)
1719 dmi_check_system(atkbd_dmi_quirk_table);
1721 return serio_register_driver(&atkbd_drv);
1724 static void __exit atkbd_exit(void)
1726 serio_unregister_driver(&atkbd_drv);
1729 module_init(atkbd_init);
1730 module_exit(atkbd_exit);