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");
66
static bool atkbd_terminal;
67
module_param_named(terminal, atkbd_terminal, bool, 0);
68
MODULE_PARM_DESC(terminal, "Enable break codes on an IBM Terminal keyboard connected via AT/PS2");
71
* Scancode to keycode tables. These are just the default setting, and
72
* are loadable via a userland utility.
75
#define ATKBD_KEYMAP_SIZE 512
77
static const unsigned short atkbd_set2_keycode[ATKBD_KEYMAP_SIZE] = {
79
#ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
81
/* XXX: need a more general approach */
83
#include "hpps2atkbd.h" /* include the keyboard scancodes */
86
0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117,
87
0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0,
88
0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183,
89
0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185,
90
0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0,
91
0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85,
92
0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0,
93
82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
95
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
96
217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
97
173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
98
159, 0,115, 0,164, 0, 0,116,158, 0,172,166, 0, 0, 0,142,
99
157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
100
226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
101
0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
102
110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
108
static const unsigned short atkbd_set3_keycode[ATKBD_KEYMAP_SIZE] = {
110
0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60,
111
131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62,
112
134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64,
113
136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66,
114
125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
115
113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
116
108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104,
117
82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183,
119
184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0,
120
0,139,172,163,165,115,152,172,166,140,160,154,113,114,167,168,
124
static const unsigned short atkbd_unxlate_table[128] = {
125
0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
126
21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
127
35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
128
50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3,
129
11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105,
130
114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63,
131
71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
132
19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
135
#define ATKBD_CMD_SETLEDS 0x10ed
136
#define ATKBD_CMD_GSCANSET 0x11f0
137
#define ATKBD_CMD_SSCANSET 0x10f0
138
#define ATKBD_CMD_GETID 0x02f2
139
#define ATKBD_CMD_SETREP 0x10f3
140
#define ATKBD_CMD_ENABLE 0x00f4
141
#define ATKBD_CMD_RESET_DIS 0x00f5 /* Reset to defaults and disable */
142
#define ATKBD_CMD_RESET_DEF 0x00f6 /* Reset to defaults */
143
#define ATKBD_CMD_SETALL_MB 0x00f8 /* Set all keys to give break codes */
144
#define ATKBD_CMD_SETALL_MBR 0x00fa /* ... and repeat */
145
#define ATKBD_CMD_RESET_BAT 0x02ff
146
#define ATKBD_CMD_RESEND 0x00fe
147
#define ATKBD_CMD_EX_ENABLE 0x10ea
148
#define ATKBD_CMD_EX_SETLEDS 0x20eb
149
#define ATKBD_CMD_OK_GETID 0x02e8
151
#define ATKBD_RET_ACK 0xfa
152
#define ATKBD_RET_NAK 0xfe
153
#define ATKBD_RET_BAT 0xaa
154
#define ATKBD_RET_EMUL0 0xe0
155
#define ATKBD_RET_EMUL1 0xe1
156
#define ATKBD_RET_RELEASE 0xf0
157
#define ATKBD_RET_HANJA 0xf1
158
#define ATKBD_RET_HANGEUL 0xf2
159
#define ATKBD_RET_ERR 0xff
161
#define ATKBD_KEY_UNKNOWN 0
162
#define ATKBD_KEY_NULL 255
164
#define ATKBD_SCR_1 0xfffe
165
#define ATKBD_SCR_2 0xfffd
166
#define ATKBD_SCR_4 0xfffc
167
#define ATKBD_SCR_8 0xfffb
168
#define ATKBD_SCR_CLICK 0xfffa
169
#define ATKBD_SCR_LEFT 0xfff9
170
#define ATKBD_SCR_RIGHT 0xfff8
172
#define ATKBD_SPECIAL ATKBD_SCR_RIGHT
174
#define ATKBD_LED_EVENT_BIT 0
175
#define ATKBD_REP_EVENT_BIT 1
177
#define ATKBD_XL_ERR 0x01
178
#define ATKBD_XL_BAT 0x02
179
#define ATKBD_XL_ACK 0x04
180
#define ATKBD_XL_NAK 0x08
181
#define ATKBD_XL_HANGEUL 0x10
182
#define ATKBD_XL_HANJA 0x20
184
static const struct {
185
unsigned short keycode;
187
} atkbd_scroll_keys[] = {
188
{ ATKBD_SCR_1, 0xc5 },
189
{ ATKBD_SCR_2, 0x9d },
190
{ ATKBD_SCR_4, 0xa4 },
191
{ ATKBD_SCR_8, 0x9b },
192
{ ATKBD_SCR_CLICK, 0xe0 },
193
{ ATKBD_SCR_LEFT, 0xcb },
194
{ ATKBD_SCR_RIGHT, 0xd2 },
198
* The atkbd control structure
203
struct ps2dev ps2dev;
204
struct input_dev *dev;
206
/* Written only during init */
211
unsigned short keycode[ATKBD_KEYMAP_SIZE];
212
DECLARE_BITMAP(force_release_mask, ATKBD_KEYMAP_SIZE);
222
/* Accessed only from interrupt */
226
unsigned long xl_bit;
229
unsigned long err_count;
231
struct delayed_work event_work;
232
unsigned long event_jiffies;
233
unsigned long event_mask;
235
/* Serializes reconnect(), attr->set() and event work */
240
* System-specific keymap fixup routine
242
static void (*atkbd_platform_fixup)(struct atkbd *, const void *data);
243
static void *atkbd_platform_fixup_data;
244
static unsigned int (*atkbd_platform_scancode_fixup)(struct atkbd *, unsigned int);
246
static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
247
ssize_t (*handler)(struct atkbd *, char *));
248
static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
249
ssize_t (*handler)(struct atkbd *, const char *, size_t));
250
#define ATKBD_DEFINE_ATTR(_name) \
251
static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
252
static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \
253
static ssize_t atkbd_do_show_##_name(struct device *d, \
254
struct device_attribute *attr, char *b) \
256
return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
258
static ssize_t atkbd_do_set_##_name(struct device *d, \
259
struct device_attribute *attr, const char *b, size_t s) \
261
return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \
263
static struct device_attribute atkbd_attr_##_name = \
264
__ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
266
ATKBD_DEFINE_ATTR(extra);
267
ATKBD_DEFINE_ATTR(force_release);
268
ATKBD_DEFINE_ATTR(scroll);
269
ATKBD_DEFINE_ATTR(set);
270
ATKBD_DEFINE_ATTR(softrepeat);
271
ATKBD_DEFINE_ATTR(softraw);
273
#define ATKBD_DEFINE_RO_ATTR(_name) \
274
static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
275
static ssize_t atkbd_do_show_##_name(struct device *d, \
276
struct device_attribute *attr, char *b) \
278
return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
280
static struct device_attribute atkbd_attr_##_name = \
281
__ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL);
283
ATKBD_DEFINE_RO_ATTR(err_count);
285
static struct attribute *atkbd_attributes[] = {
286
&atkbd_attr_extra.attr,
287
&atkbd_attr_force_release.attr,
288
&atkbd_attr_scroll.attr,
289
&atkbd_attr_set.attr,
290
&atkbd_attr_softrepeat.attr,
291
&atkbd_attr_softraw.attr,
292
&atkbd_attr_err_count.attr,
296
static struct attribute_group atkbd_attribute_group = {
297
.attrs = atkbd_attributes,
300
static const unsigned int xl_table[] = {
301
ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK,
302
ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL,
306
* Checks if we should mangle the scancode to extract 'release' bit
307
* in translated mode.
309
static bool atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
313
if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
316
for (i = 0; i < ARRAY_SIZE(xl_table); i++)
317
if (code == xl_table[i])
318
return test_bit(i, &xl_bit);
324
* Calculates new value of xl_bit so the driver can distinguish
325
* between make/break pair of scancodes for select keys and PS/2
326
* protocol responses.
328
static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code)
332
for (i = 0; i < ARRAY_SIZE(xl_table); i++) {
333
if (!((code ^ xl_table[i]) & 0x7f)) {
335
__clear_bit(i, &atkbd->xl_bit);
337
__set_bit(i, &atkbd->xl_bit);
344
* Encode the scancode, 0xe0 prefix, and high bit into a single integer,
345
* keeping kernel 2.4 compatibility for set 2
347
static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code)
349
if (atkbd->set == 3) {
350
if (atkbd->emul == 1)
353
code = (code & 0x7f) | ((code & 0x80) << 1);
354
if (atkbd->emul == 1)
362
* atkbd_interrupt(). Here takes place processing of data received from
363
* the keyboard into events.
366
static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
369
struct atkbd *atkbd = serio_get_drvdata(serio);
370
struct input_dev *dev = atkbd->dev;
371
unsigned int code = data;
372
int scroll = 0, hscroll = 0, click = -1;
374
unsigned short keycode;
376
dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags);
378
#if !defined(__i386__) && !defined (__x86_64__)
379
if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
380
dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags);
381
serio_write(serio, ATKBD_CMD_RESEND);
382
atkbd->resend = true;
386
if (!flags && data == ATKBD_RET_ACK)
387
atkbd->resend = false;
390
if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
391
if (ps2_handle_ack(&atkbd->ps2dev, data))
394
if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
395
if (ps2_handle_response(&atkbd->ps2dev, data))
401
input_event(dev, EV_MSC, MSC_RAW, code);
403
if (atkbd_platform_scancode_fixup)
404
code = atkbd_platform_scancode_fixup(atkbd, code);
406
if (atkbd->translated) {
408
if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
409
atkbd->release = code >> 7;
414
atkbd_calculate_xl_bit(atkbd, data);
419
atkbd->enabled = false;
420
serio_reconnect(atkbd->ps2dev.serio);
422
case ATKBD_RET_EMUL0:
425
case ATKBD_RET_EMUL1:
428
case ATKBD_RET_RELEASE:
429
atkbd->release = true;
433
if (printk_ratelimit())
434
dev_warn(&serio->dev,
435
"Spurious %s on %s. "
436
"Some program might be trying access hardware directly.\n",
437
data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
441
dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n",
446
code = atkbd_compat_scancode(atkbd, code);
448
if (atkbd->emul && --atkbd->emul)
451
keycode = atkbd->keycode[code];
453
if (keycode != ATKBD_KEY_NULL)
454
input_event(dev, EV_MSC, MSC_SCAN, code);
459
case ATKBD_KEY_UNKNOWN:
460
dev_warn(&serio->dev,
461
"Unknown key %s (%s set %d, code %#x on %s).\n",
462
atkbd->release ? "released" : "pressed",
463
atkbd->translated ? "translated" : "raw",
464
atkbd->set, code, serio->phys);
465
dev_warn(&serio->dev,
466
"Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
467
code & 0x80 ? "e0" : "", code & 0x7f);
482
case ATKBD_SCR_CLICK:
483
click = !atkbd->release;
488
case ATKBD_SCR_RIGHT:
492
if (atkbd->release) {
495
} else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
496
/* Workaround Toshiba laptop multiple keypress */
497
value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
501
atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
504
input_event(dev, EV_KEY, keycode, value);
507
if (value && test_bit(code, atkbd->force_release_mask)) {
508
input_report_key(dev, keycode, 0);
515
input_report_key(dev, BTN_MIDDLE, click);
516
input_report_rel(dev, REL_WHEEL,
517
atkbd->release ? -scroll : scroll);
518
input_report_rel(dev, REL_HWHEEL, hscroll);
522
atkbd->release = false;
527
static int atkbd_set_repeat_rate(struct atkbd *atkbd)
529
const short period[32] =
530
{ 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125,
531
133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
532
const short delay[4] =
533
{ 250, 500, 750, 1000 };
535
struct input_dev *dev = atkbd->dev;
539
while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
541
dev->rep[REP_PERIOD] = period[i];
543
while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
545
dev->rep[REP_DELAY] = delay[j];
547
param = i | (j << 5);
548
return ps2_command(&atkbd->ps2dev, ¶m, ATKBD_CMD_SETREP);
551
static int atkbd_set_leds(struct atkbd *atkbd)
553
struct input_dev *dev = atkbd->dev;
554
unsigned char param[2];
556
param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
557
| (test_bit(LED_NUML, dev->led) ? 2 : 0)
558
| (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
559
if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
564
param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
565
| (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
566
| (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
567
| (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
568
| (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
569
if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
577
* atkbd_event_work() is used to complete processing of events that
578
* can not be processed by input_event() which is often called from
582
static void atkbd_event_work(struct work_struct *work)
584
struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work);
586
mutex_lock(&atkbd->mutex);
588
if (!atkbd->enabled) {
590
* Serio ports are resumed asynchronously so while driver core
591
* thinks that device is already fully operational in reality
592
* it may not be ready yet. In this case we need to keep
593
* rescheduling till reconnect completes.
595
schedule_delayed_work(&atkbd->event_work,
596
msecs_to_jiffies(100));
598
if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
599
atkbd_set_leds(atkbd);
601
if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
602
atkbd_set_repeat_rate(atkbd);
605
mutex_unlock(&atkbd->mutex);
609
* Schedule switch for execution. We need to throttle requests,
610
* otherwise keyboard may become unresponsive.
612
static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit)
614
unsigned long delay = msecs_to_jiffies(50);
616
if (time_after(jiffies, atkbd->event_jiffies + delay))
619
atkbd->event_jiffies = jiffies;
620
set_bit(event_bit, &atkbd->event_mask);
622
schedule_delayed_work(&atkbd->event_work, delay);
626
* Event callback from the input module. Events that change the state of
627
* the hardware are processed here. If action can not be performed in
628
* interrupt context it is offloaded to atkbd_event_work.
631
static int atkbd_event(struct input_dev *dev,
632
unsigned int type, unsigned int code, int value)
634
struct atkbd *atkbd = input_get_drvdata(dev);
642
atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
646
if (!atkbd->softrepeat)
647
atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
656
* atkbd_enable() signals that interrupt handler is allowed to
657
* generate input events.
660
static inline void atkbd_enable(struct atkbd *atkbd)
662
serio_pause_rx(atkbd->ps2dev.serio);
663
atkbd->enabled = true;
664
serio_continue_rx(atkbd->ps2dev.serio);
668
* atkbd_disable() tells input handler that all incoming data except
669
* for ACKs and command response should be dropped.
672
static inline void atkbd_disable(struct atkbd *atkbd)
674
serio_pause_rx(atkbd->ps2dev.serio);
675
atkbd->enabled = false;
676
serio_continue_rx(atkbd->ps2dev.serio);
680
* atkbd_probe() probes for an AT keyboard on a serio port.
683
static int atkbd_probe(struct atkbd *atkbd)
685
struct ps2dev *ps2dev = &atkbd->ps2dev;
686
unsigned char param[2];
689
* Some systems, where the bit-twiddling when testing the io-lines of the
690
* controller may confuse the keyboard need a full reset of the keyboard. On
691
* these systems the BIOS also usually doesn't do it for us.
695
if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
696
dev_warn(&ps2dev->serio->dev,
697
"keyboard reset failed on %s\n",
698
ps2dev->serio->phys);
701
* Then we check the keyboard ID. We should get 0xab83 under normal conditions.
702
* Some keyboards report different values, but the first byte is always 0xab or
703
* 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
704
* should make sure we don't try to set the LEDs on it.
707
param[0] = param[1] = 0xa5; /* initialize with invalid values */
708
if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
711
* If the get ID command failed, we check if we can at least set the LEDs on
712
* the keyboard. This should work on every keyboard out there. It also turns
713
* the LEDs off, which we want anyway.
716
if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
722
if (!ps2_is_keyboard_id(param[0]))
725
atkbd->id = (param[0] << 8) | param[1];
727
if (atkbd->id == 0xaca1 && atkbd->translated) {
728
dev_err(&ps2dev->serio->dev,
729
"NCD terminal keyboards are only supported on non-translating controlelrs. "
730
"Use i8042.direct=1 to disable translation.\n");
738
* atkbd_select_set checks if a keyboard has a working Set 3 support, and
739
* sets it into that. Unfortunately there are keyboards that can be switched
740
* to Set 3, but don't work well in that (BTC Multimedia ...)
743
static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
745
struct ps2dev *ps2dev = &atkbd->ps2dev;
746
unsigned char param[2];
748
atkbd->extra = false;
750
* For known special keyboards we can go ahead and set the correct set.
751
* We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
752
* IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
755
if (atkbd->translated)
758
if (atkbd->id == 0xaca1) {
760
ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
766
if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
772
if (atkbd_terminal) {
773
ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MB);
780
if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
781
atkbd->id = param[0] << 8 | param[1];
786
if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
790
if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
795
if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
799
ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
804
static int atkbd_reset_state(struct atkbd *atkbd)
806
struct ps2dev *ps2dev = &atkbd->ps2dev;
807
unsigned char param[1];
810
* Set the LEDs to a predefined state (all off).
814
if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
818
* Set autorepeat to fastest possible.
822
if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
828
static int atkbd_activate(struct atkbd *atkbd)
830
struct ps2dev *ps2dev = &atkbd->ps2dev;
833
* Enable the keyboard to receive keystrokes.
836
if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
837
dev_err(&ps2dev->serio->dev,
838
"Failed to enable keyboard on %s\n",
839
ps2dev->serio->phys);
847
* atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
851
static void atkbd_cleanup(struct serio *serio)
853
struct atkbd *atkbd = serio_get_drvdata(serio);
855
atkbd_disable(atkbd);
856
ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF);
861
* atkbd_disconnect() closes and frees.
864
static void atkbd_disconnect(struct serio *serio)
866
struct atkbd *atkbd = serio_get_drvdata(serio);
868
sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
870
atkbd_disable(atkbd);
872
input_unregister_device(atkbd->dev);
875
* Make sure we don't have a command in flight.
876
* Note that since atkbd->enabled is false event work will keep
877
* rescheduling itself until it gets canceled and will not try
878
* accessing freed input device or serio port.
880
cancel_delayed_work_sync(&atkbd->event_work);
883
serio_set_drvdata(serio, NULL);
888
* generate release events for the keycodes given in data
890
static void atkbd_apply_forced_release_keylist(struct atkbd* atkbd,
893
const unsigned int *keys = data;
897
for (i = 0; keys[i] != -1U; i++)
898
__set_bit(keys[i], atkbd->force_release_mask);
902
* Most special keys (Fn+F?) on Dell laptops do not generate release
903
* events so we have to do it ourselves.
905
static unsigned int atkbd_dell_laptop_forced_release_keys[] = {
906
0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U
910
* Perform fixup for HP system that doesn't generate release
911
* for its video switch
913
static unsigned int atkbd_hp_forced_release_keys[] = {
918
* Samsung NC10,NC20 with Fn+F? key release not working
920
static unsigned int atkbd_samsung_forced_release_keys[] = {
921
0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U
925
* Amilo Pi 3525 key release for Fn+Volume keys not working
927
static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = {
928
0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
932
* Amilo Xi 3650 key release for light touch bar not working
934
static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = {
935
0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
939
* Soltech TA12 system with broken key release on volume keys and mute key
941
static unsigned int atkdb_soltech_ta12_forced_release_keys[] = {
942
0xa0, 0xae, 0xb0, -1U
946
* Many notebooks don't send key release event for volume up/down
947
* keys, with key list below common among them
949
static unsigned int atkbd_volume_forced_release_keys[] = {
954
* OQO 01+ multimedia keys (64--66) generate e0 6x upon release whereas
955
* they should be generating e4-e6 (0x80 | code).
957
static unsigned int atkbd_oqo_01plus_scancode_fixup(struct atkbd *atkbd,
960
if (atkbd->translated && atkbd->emul == 1 &&
961
(code == 0x64 || code == 0x65 || code == 0x66)) {
970
* atkbd_set_keycode_table() initializes keyboard's keycode table
971
* according to the selected scancode set
974
static void atkbd_set_keycode_table(struct atkbd *atkbd)
976
unsigned int scancode;
979
memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
980
bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
982
if (atkbd->translated) {
983
for (i = 0; i < 128; i++) {
984
scancode = atkbd_unxlate_table[i];
985
atkbd->keycode[i] = atkbd_set2_keycode[scancode];
986
atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
988
for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
989
if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
990
atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
992
} else if (atkbd->set == 3) {
993
memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
995
memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
998
for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
999
scancode = atkbd_scroll_keys[i].set2;
1000
atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
1005
* HANGEUL and HANJA keys do not send release events so we need to
1006
* generate such events ourselves
1008
scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
1009
atkbd->keycode[scancode] = KEY_HANGEUL;
1010
__set_bit(scancode, atkbd->force_release_mask);
1012
scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
1013
atkbd->keycode[scancode] = KEY_HANJA;
1014
__set_bit(scancode, atkbd->force_release_mask);
1017
* Perform additional fixups
1019
if (atkbd_platform_fixup)
1020
atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
1024
* atkbd_set_device_attrs() sets up keyboard's input device structure
1027
static void atkbd_set_device_attrs(struct atkbd *atkbd)
1029
struct input_dev *input_dev = atkbd->dev;
1033
snprintf(atkbd->name, sizeof(atkbd->name),
1034
"AT Set 2 Extra keyboard");
1036
snprintf(atkbd->name, sizeof(atkbd->name),
1037
"AT %s Set %d keyboard",
1038
atkbd->translated ? "Translated" : "Raw", atkbd->set);
1040
snprintf(atkbd->phys, sizeof(atkbd->phys),
1041
"%s/input0", atkbd->ps2dev.serio->phys);
1043
input_dev->name = atkbd->name;
1044
input_dev->phys = atkbd->phys;
1045
input_dev->id.bustype = BUS_I8042;
1046
input_dev->id.vendor = 0x0001;
1047
input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
1048
input_dev->id.version = atkbd->id;
1049
input_dev->event = atkbd_event;
1050
input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
1052
input_set_drvdata(input_dev, atkbd);
1054
input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
1058
input_dev->evbit[0] |= BIT_MASK(EV_LED);
1059
input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1060
BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
1064
input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
1065
BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
1066
BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
1068
if (!atkbd->softrepeat) {
1069
input_dev->rep[REP_DELAY] = 250;
1070
input_dev->rep[REP_PERIOD] = 33;
1073
input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1074
BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1076
if (atkbd->scroll) {
1077
input_dev->evbit[0] |= BIT_MASK(EV_REL);
1078
input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1079
BIT_MASK(REL_HWHEEL);
1080
__set_bit(BTN_MIDDLE, input_dev->keybit);
1083
input_dev->keycode = atkbd->keycode;
1084
input_dev->keycodesize = sizeof(unsigned short);
1085
input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1087
for (i = 0; i < ATKBD_KEYMAP_SIZE; i++) {
1088
if (atkbd->keycode[i] != KEY_RESERVED &&
1089
atkbd->keycode[i] != ATKBD_KEY_NULL &&
1090
atkbd->keycode[i] < ATKBD_SPECIAL) {
1091
__set_bit(atkbd->keycode[i], input_dev->keybit);
1097
* atkbd_connect() is called when the serio module finds an interface
1098
* that isn't handled yet by an appropriate device driver. We check if
1099
* there is an AT keyboard out there and if yes, we register ourselves
1100
* to the input module.
1103
static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1105
struct atkbd *atkbd;
1106
struct input_dev *dev;
1109
atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
1110
dev = input_allocate_device();
1115
ps2_init(&atkbd->ps2dev, serio);
1116
INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1117
mutex_init(&atkbd->mutex);
1119
switch (serio->id.type) {
1122
atkbd->translated = true;
1127
atkbd->write = true;
1131
atkbd->softraw = atkbd_softraw;
1132
atkbd->softrepeat = atkbd_softrepeat;
1133
atkbd->scroll = atkbd_scroll;
1135
if (atkbd->softrepeat)
1136
atkbd->softraw = true;
1138
serio_set_drvdata(serio, atkbd);
1140
err = serio_open(serio, drv);
1146
if (atkbd_probe(atkbd)) {
1151
atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1152
atkbd_reset_state(atkbd);
1153
atkbd_activate(atkbd);
1160
atkbd_set_keycode_table(atkbd);
1161
atkbd_set_device_attrs(atkbd);
1163
err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1167
atkbd_enable(atkbd);
1169
err = input_register_device(atkbd->dev);
1175
fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1176
fail3: serio_close(serio);
1177
fail2: serio_set_drvdata(serio, NULL);
1178
fail1: input_free_device(dev);
1184
* atkbd_reconnect() tries to restore keyboard into a sane state and is
1185
* most likely called on resume.
1188
static int atkbd_reconnect(struct serio *serio)
1190
struct atkbd *atkbd = serio_get_drvdata(serio);
1191
struct serio_driver *drv = serio->drv;
1194
if (!atkbd || !drv) {
1195
dev_dbg(&serio->dev,
1196
"reconnect request, but serio is disconnected, ignoring...\n");
1200
mutex_lock(&atkbd->mutex);
1202
atkbd_disable(atkbd);
1205
if (atkbd_probe(atkbd))
1208
if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1211
atkbd_activate(atkbd);
1214
* Restore LED state and repeat rate. While input core
1215
* will do this for us at resume time reconnect may happen
1216
* because user requested it via sysfs or simply because
1217
* keyboard was unplugged and plugged in again so we need
1218
* to do it ourselves here.
1220
atkbd_set_leds(atkbd);
1221
if (!atkbd->softrepeat)
1222
atkbd_set_repeat_rate(atkbd);
1226
atkbd_enable(atkbd);
1230
mutex_unlock(&atkbd->mutex);
1234
static struct serio_device_id atkbd_serio_ids[] = {
1242
.type = SERIO_8042_XL,
1248
.type = SERIO_RS232,
1249
.proto = SERIO_PS2SER,
1256
MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1258
static struct serio_driver atkbd_drv = {
1262
.description = DRIVER_DESC,
1263
.id_table = atkbd_serio_ids,
1264
.interrupt = atkbd_interrupt,
1265
.connect = atkbd_connect,
1266
.reconnect = atkbd_reconnect,
1267
.disconnect = atkbd_disconnect,
1268
.cleanup = atkbd_cleanup,
1271
static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1272
ssize_t (*handler)(struct atkbd *, char *))
1274
struct serio *serio = to_serio_port(dev);
1275
struct atkbd *atkbd = serio_get_drvdata(serio);
1277
return handler(atkbd, buf);
1280
static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1281
ssize_t (*handler)(struct atkbd *, const char *, size_t))
1283
struct serio *serio = to_serio_port(dev);
1284
struct atkbd *atkbd = serio_get_drvdata(serio);
1287
retval = mutex_lock_interruptible(&atkbd->mutex);
1291
atkbd_disable(atkbd);
1292
retval = handler(atkbd, buf, count);
1293
atkbd_enable(atkbd);
1295
mutex_unlock(&atkbd->mutex);
1300
static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1302
return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1305
static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1307
struct input_dev *old_dev, *new_dev;
1308
unsigned long value;
1311
unsigned char old_set;
1316
if (strict_strtoul(buf, 10, &value) || value > 1)
1319
if (atkbd->extra != value) {
1321
* Since device's properties will change we need to
1322
* unregister old device. But allocate and register
1323
* new one first to make sure we have it.
1325
old_dev = atkbd->dev;
1326
old_extra = atkbd->extra;
1327
old_set = atkbd->set;
1329
new_dev = input_allocate_device();
1333
atkbd->dev = new_dev;
1334
atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1335
atkbd_reset_state(atkbd);
1336
atkbd_activate(atkbd);
1337
atkbd_set_keycode_table(atkbd);
1338
atkbd_set_device_attrs(atkbd);
1340
err = input_register_device(atkbd->dev);
1342
input_free_device(new_dev);
1344
atkbd->dev = old_dev;
1345
atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1346
atkbd_set_keycode_table(atkbd);
1347
atkbd_set_device_attrs(atkbd);
1351
input_unregister_device(old_dev);
1357
static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
1359
size_t len = bitmap_scnlistprintf(buf, PAGE_SIZE - 2,
1360
atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1368
static ssize_t atkbd_set_force_release(struct atkbd *atkbd,
1369
const char *buf, size_t count)
1371
/* 64 bytes on stack should be acceptable */
1372
DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE);
1375
err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE);
1379
memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1384
static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1386
return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1389
static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1391
struct input_dev *old_dev, *new_dev;
1392
unsigned long value;
1396
if (strict_strtoul(buf, 10, &value) || value > 1)
1399
if (atkbd->scroll != value) {
1400
old_dev = atkbd->dev;
1401
old_scroll = atkbd->scroll;
1403
new_dev = input_allocate_device();
1407
atkbd->dev = new_dev;
1408
atkbd->scroll = value;
1409
atkbd_set_keycode_table(atkbd);
1410
atkbd_set_device_attrs(atkbd);
1412
err = input_register_device(atkbd->dev);
1414
input_free_device(new_dev);
1416
atkbd->scroll = old_scroll;
1417
atkbd->dev = old_dev;
1418
atkbd_set_keycode_table(atkbd);
1419
atkbd_set_device_attrs(atkbd);
1423
input_unregister_device(old_dev);
1428
static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1430
return sprintf(buf, "%d\n", atkbd->set);
1433
static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1435
struct input_dev *old_dev, *new_dev;
1436
unsigned long value;
1438
unsigned char old_set;
1444
if (strict_strtoul(buf, 10, &value) || (value != 2 && value != 3))
1447
if (atkbd->set != value) {
1448
old_dev = atkbd->dev;
1449
old_extra = atkbd->extra;
1450
old_set = atkbd->set;
1452
new_dev = input_allocate_device();
1456
atkbd->dev = new_dev;
1457
atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1458
atkbd_reset_state(atkbd);
1459
atkbd_activate(atkbd);
1460
atkbd_set_keycode_table(atkbd);
1461
atkbd_set_device_attrs(atkbd);
1463
err = input_register_device(atkbd->dev);
1465
input_free_device(new_dev);
1467
atkbd->dev = old_dev;
1468
atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1469
atkbd_set_keycode_table(atkbd);
1470
atkbd_set_device_attrs(atkbd);
1474
input_unregister_device(old_dev);
1479
static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1481
return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1484
static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1486
struct input_dev *old_dev, *new_dev;
1487
unsigned long value;
1489
bool old_softrepeat, old_softraw;
1494
if (strict_strtoul(buf, 10, &value) || value > 1)
1497
if (atkbd->softrepeat != value) {
1498
old_dev = atkbd->dev;
1499
old_softrepeat = atkbd->softrepeat;
1500
old_softraw = atkbd->softraw;
1502
new_dev = input_allocate_device();
1506
atkbd->dev = new_dev;
1507
atkbd->softrepeat = value;
1508
if (atkbd->softrepeat)
1509
atkbd->softraw = true;
1510
atkbd_set_device_attrs(atkbd);
1512
err = input_register_device(atkbd->dev);
1514
input_free_device(new_dev);
1516
atkbd->dev = old_dev;
1517
atkbd->softrepeat = old_softrepeat;
1518
atkbd->softraw = old_softraw;
1519
atkbd_set_device_attrs(atkbd);
1523
input_unregister_device(old_dev);
1529
static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1531
return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1534
static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1536
struct input_dev *old_dev, *new_dev;
1537
unsigned long value;
1541
if (strict_strtoul(buf, 10, &value) || value > 1)
1544
if (atkbd->softraw != value) {
1545
old_dev = atkbd->dev;
1546
old_softraw = atkbd->softraw;
1548
new_dev = input_allocate_device();
1552
atkbd->dev = new_dev;
1553
atkbd->softraw = value;
1554
atkbd_set_device_attrs(atkbd);
1556
err = input_register_device(atkbd->dev);
1558
input_free_device(new_dev);
1560
atkbd->dev = old_dev;
1561
atkbd->softraw = old_softraw;
1562
atkbd_set_device_attrs(atkbd);
1566
input_unregister_device(old_dev);
1571
static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1573
return sprintf(buf, "%lu\n", atkbd->err_count);
1576
static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1578
atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
1579
atkbd_platform_fixup_data = id->driver_data;
1584
static int __init atkbd_setup_scancode_fixup(const struct dmi_system_id *id)
1586
atkbd_platform_scancode_fixup = id->driver_data;
1591
static const struct dmi_system_id atkbd_dmi_quirk_table[] __initconst = {
1594
DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1595
DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1597
.callback = atkbd_setup_forced_release,
1598
.driver_data = atkbd_dell_laptop_forced_release_keys,
1602
DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
1603
DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1605
.callback = atkbd_setup_forced_release,
1606
.driver_data = atkbd_dell_laptop_forced_release_keys,
1610
DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1611
DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1613
.callback = atkbd_setup_forced_release,
1614
.driver_data = atkbd_hp_forced_release_keys,
1618
DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1619
DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1621
.callback = atkbd_setup_forced_release,
1622
.driver_data = atkbd_volume_forced_release_keys,
1626
DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1627
DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"),
1629
.callback = atkbd_setup_forced_release,
1630
.driver_data = atkbd_volume_forced_release_keys,
1634
DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1635
DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"),
1637
.callback = atkbd_setup_forced_release,
1638
.driver_data = atkbd_volume_forced_release_keys,
1642
DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1643
DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"),
1645
.callback = atkbd_setup_forced_release,
1646
.driver_data = atkbd_volume_forced_release_keys,
1649
/* Inventec Symphony */
1651
DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1652
DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1654
.callback = atkbd_setup_forced_release,
1655
.driver_data = atkbd_volume_forced_release_keys,
1660
DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1661
DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
1663
.callback = atkbd_setup_forced_release,
1664
.driver_data = atkbd_samsung_forced_release_keys,
1669
DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1670
DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
1672
.callback = atkbd_setup_forced_release,
1673
.driver_data = atkbd_samsung_forced_release_keys,
1676
/* Samsung SQ45S70S */
1678
DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1679
DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
1681
.callback = atkbd_setup_forced_release,
1682
.driver_data = atkbd_samsung_forced_release_keys,
1685
/* Fujitsu Amilo PA 1510 */
1687
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1688
DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
1690
.callback = atkbd_setup_forced_release,
1691
.driver_data = atkbd_volume_forced_release_keys,
1694
/* Fujitsu Amilo Pi 3525 */
1696
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1697
DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
1699
.callback = atkbd_setup_forced_release,
1700
.driver_data = atkbd_amilo_pi3525_forced_release_keys,
1703
/* Fujitsu Amilo Xi 3650 */
1705
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1706
DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
1708
.callback = atkbd_setup_forced_release,
1709
.driver_data = atkbd_amilo_xi3650_forced_release_keys,
1713
DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"),
1714
DMI_MATCH(DMI_PRODUCT_NAME, "TA12"),
1716
.callback = atkbd_setup_forced_release,
1717
.driver_data = atkdb_soltech_ta12_forced_release_keys,
1722
DMI_MATCH(DMI_SYS_VENDOR, "OQO"),
1723
DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"),
1725
.callback = atkbd_setup_scancode_fixup,
1726
.driver_data = atkbd_oqo_01plus_scancode_fixup,
1731
static int __init atkbd_init(void)
1733
dmi_check_system(atkbd_dmi_quirk_table);
1735
return serio_register_driver(&atkbd_drv);
1738
static void __exit atkbd_exit(void)
1740
serio_unregister_driver(&atkbd_drv);
1743
module_init(atkbd_init);
1744
module_exit(atkbd_exit);