Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0-only
2 : /*
3 : * AT and PS/2 keyboard driver
4 : *
5 : * Copyright (c) 1999-2002 Vojtech Pavlik
6 : */
7 :
8 :
9 : /*
10 : * This driver can handle standard AT keyboards and PS/2 keyboards in
11 : * Translated and Raw Set 2 and Set 3, as well as AT keyboards on dumb
12 : * input-only controllers and AT keyboards connected over a one way RS232
13 : * converter.
14 : */
15 :
16 : #include <linux/delay.h>
17 : #include <linux/module.h>
18 : #include <linux/slab.h>
19 : #include <linux/interrupt.h>
20 : #include <linux/init.h>
21 : #include <linux/input.h>
22 : #include <linux/input/vivaldi-fmap.h>
23 : #include <linux/serio.h>
24 : #include <linux/workqueue.h>
25 : #include <linux/libps2.h>
26 : #include <linux/mutex.h>
27 : #include <linux/dmi.h>
28 : #include <linux/property.h>
29 :
30 : #define DRIVER_DESC "AT and PS/2 keyboard driver"
31 :
32 : MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
33 : MODULE_DESCRIPTION(DRIVER_DESC);
34 : MODULE_LICENSE("GPL");
35 :
36 : static int atkbd_set = 2;
37 : module_param_named(set, atkbd_set, int, 0);
38 : MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");
39 :
40 : #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
41 : static bool atkbd_reset;
42 : #else
43 : static bool atkbd_reset = true;
44 : #endif
45 : module_param_named(reset, atkbd_reset, bool, 0);
46 : MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
47 :
48 : static bool atkbd_softrepeat;
49 : module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
50 : MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
51 :
52 : static bool atkbd_softraw = true;
53 : module_param_named(softraw, atkbd_softraw, bool, 0);
54 : MODULE_PARM_DESC(softraw, "Use software generated rawmode");
55 :
56 : static bool atkbd_scroll;
57 : module_param_named(scroll, atkbd_scroll, bool, 0);
58 : MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
59 :
60 : static bool atkbd_extra;
61 : module_param_named(extra, atkbd_extra, bool, 0);
62 : MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
63 :
64 : static bool atkbd_terminal;
65 : module_param_named(terminal, atkbd_terminal, bool, 0);
66 : MODULE_PARM_DESC(terminal, "Enable break codes on an IBM Terminal keyboard connected via AT/PS2");
67 :
68 : #define SCANCODE(keymap) ((keymap >> 16) & 0xFFFF)
69 : #define KEYCODE(keymap) (keymap & 0xFFFF)
70 :
71 : /*
72 : * Scancode to keycode tables. These are just the default setting, and
73 : * are loadable via a userland utility.
74 : */
75 :
76 : #define ATKBD_KEYMAP_SIZE 512
77 :
78 : static const unsigned short atkbd_set2_keycode[ATKBD_KEYMAP_SIZE] = {
79 :
80 : #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
81 :
82 : /* XXX: need a more general approach */
83 :
84 : #include "hpps2atkbd.h" /* include the keyboard scancodes */
85 :
86 : #else
87 : 0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117,
88 : 0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0,
89 : 0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183,
90 : 0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185,
91 : 0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0,
92 : 0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85,
93 : 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0,
94 : 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
95 :
96 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
97 : 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
98 : 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
99 : 159, 0,115, 0,164, 0, 0,116,158, 0,172,166, 0, 0, 0,142,
100 : 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
101 : 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
102 : 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
103 : 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
104 :
105 : 0, 0, 0, 65, 99,
106 : #endif
107 : };
108 :
109 : static const unsigned short atkbd_set3_keycode[ATKBD_KEYMAP_SIZE] = {
110 :
111 : 0, 0, 0, 0, 0, 0, 0, 59, 1,138,128,129,130, 15, 41, 60,
112 : 131, 29, 42, 86, 58, 16, 2, 61,133, 56, 44, 31, 30, 17, 3, 62,
113 : 134, 46, 45, 32, 18, 5, 4, 63,135, 57, 47, 33, 20, 19, 6, 64,
114 : 136, 49, 48, 35, 34, 21, 7, 65,137,100, 50, 36, 22, 8, 9, 66,
115 : 125, 51, 37, 23, 24, 11, 10, 67,126, 52, 53, 38, 39, 25, 12, 68,
116 : 113,114, 40, 43, 26, 13, 87, 99, 97, 54, 28, 27, 43, 43, 88, 70,
117 : 108,105,119,103,111,107, 14,110, 0, 79,106, 75, 71,109,102,104,
118 : 82, 83, 80, 76, 77, 72, 69, 98, 0, 96, 81, 0, 78, 73, 55,183,
119 :
120 : 184,185,186,187, 74, 94, 92, 93, 0, 0, 0,125,126,127,112, 0,
121 : 0,139,172,163,165,115,152,172,166,140,160,154,113,114,167,168,
122 : 148,149,147,140
123 : };
124 :
125 : static const unsigned short atkbd_unxlate_table[128] = {
126 : 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
127 : 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
128 : 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
129 : 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3,
130 : 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105,
131 : 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63,
132 : 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
133 : 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
134 : };
135 :
136 : #define ATKBD_CMD_SETLEDS 0x10ed
137 : #define ATKBD_CMD_GSCANSET 0x11f0
138 : #define ATKBD_CMD_SSCANSET 0x10f0
139 : #define ATKBD_CMD_GETID 0x02f2
140 : #define ATKBD_CMD_SETREP 0x10f3
141 : #define ATKBD_CMD_ENABLE 0x00f4
142 : #define ATKBD_CMD_RESET_DIS 0x00f5 /* Reset to defaults and disable */
143 : #define ATKBD_CMD_RESET_DEF 0x00f6 /* Reset to defaults */
144 : #define ATKBD_CMD_SETALL_MB 0x00f8 /* Set all keys to give break codes */
145 : #define ATKBD_CMD_SETALL_MBR 0x00fa /* ... and repeat */
146 : #define ATKBD_CMD_RESET_BAT 0x02ff
147 : #define ATKBD_CMD_RESEND 0x00fe
148 : #define ATKBD_CMD_EX_ENABLE 0x10ea
149 : #define ATKBD_CMD_EX_SETLEDS 0x20eb
150 : #define ATKBD_CMD_OK_GETID 0x02e8
151 :
152 : #define ATKBD_RET_ACK 0xfa
153 : #define ATKBD_RET_NAK 0xfe
154 : #define ATKBD_RET_BAT 0xaa
155 : #define ATKBD_RET_EMUL0 0xe0
156 : #define ATKBD_RET_EMUL1 0xe1
157 : #define ATKBD_RET_RELEASE 0xf0
158 : #define ATKBD_RET_HANJA 0xf1
159 : #define ATKBD_RET_HANGEUL 0xf2
160 : #define ATKBD_RET_ERR 0xff
161 :
162 : #define ATKBD_KEY_UNKNOWN 0
163 : #define ATKBD_KEY_NULL 255
164 :
165 : #define ATKBD_SCR_1 0xfffe
166 : #define ATKBD_SCR_2 0xfffd
167 : #define ATKBD_SCR_4 0xfffc
168 : #define ATKBD_SCR_8 0xfffb
169 : #define ATKBD_SCR_CLICK 0xfffa
170 : #define ATKBD_SCR_LEFT 0xfff9
171 : #define ATKBD_SCR_RIGHT 0xfff8
172 :
173 : #define ATKBD_SPECIAL ATKBD_SCR_RIGHT
174 :
175 : #define ATKBD_LED_EVENT_BIT 0
176 : #define ATKBD_REP_EVENT_BIT 1
177 :
178 : #define ATKBD_XL_ERR 0x01
179 : #define ATKBD_XL_BAT 0x02
180 : #define ATKBD_XL_ACK 0x04
181 : #define ATKBD_XL_NAK 0x08
182 : #define ATKBD_XL_HANGEUL 0x10
183 : #define ATKBD_XL_HANJA 0x20
184 :
185 : static const struct {
186 : unsigned short keycode;
187 : unsigned char set2;
188 : } atkbd_scroll_keys[] = {
189 : { ATKBD_SCR_1, 0xc5 },
190 : { ATKBD_SCR_2, 0x9d },
191 : { ATKBD_SCR_4, 0xa4 },
192 : { ATKBD_SCR_8, 0x9b },
193 : { ATKBD_SCR_CLICK, 0xe0 },
194 : { ATKBD_SCR_LEFT, 0xcb },
195 : { ATKBD_SCR_RIGHT, 0xd2 },
196 : };
197 :
198 : /*
199 : * The atkbd control structure
200 : */
201 :
202 : struct atkbd {
203 :
204 : struct ps2dev ps2dev;
205 : struct input_dev *dev;
206 :
207 : /* Written only during init */
208 : char name[64];
209 : char phys[32];
210 :
211 : unsigned short id;
212 : unsigned short keycode[ATKBD_KEYMAP_SIZE];
213 : DECLARE_BITMAP(force_release_mask, ATKBD_KEYMAP_SIZE);
214 : unsigned char set;
215 : bool translated;
216 : bool extra;
217 : bool write;
218 : bool softrepeat;
219 : bool softraw;
220 : bool scroll;
221 : bool enabled;
222 :
223 : /* Accessed only from interrupt */
224 : unsigned char emul;
225 : bool resend;
226 : bool release;
227 : unsigned long xl_bit;
228 : unsigned int last;
229 : unsigned long time;
230 : unsigned long err_count;
231 :
232 : struct delayed_work event_work;
233 : unsigned long event_jiffies;
234 : unsigned long event_mask;
235 :
236 : /* Serializes reconnect(), attr->set() and event work */
237 : struct mutex mutex;
238 :
239 : struct vivaldi_data vdata;
240 : };
241 :
242 : /*
243 : * System-specific keymap fixup routine
244 : */
245 : static void (*atkbd_platform_fixup)(struct atkbd *, const void *data);
246 : static void *atkbd_platform_fixup_data;
247 : static unsigned int (*atkbd_platform_scancode_fixup)(struct atkbd *, unsigned int);
248 :
249 : /*
250 : * Certain keyboards to not like ATKBD_CMD_RESET_DIS and stop responding
251 : * to many commands until full reset (ATKBD_CMD_RESET_BAT) is performed.
252 : */
253 : static bool atkbd_skip_deactivate;
254 :
255 : static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
256 : ssize_t (*handler)(struct atkbd *, char *));
257 : static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
258 : ssize_t (*handler)(struct atkbd *, const char *, size_t));
259 : #define ATKBD_DEFINE_ATTR(_name) \
260 : static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
261 : static ssize_t atkbd_set_##_name(struct atkbd *, const char *, size_t); \
262 : static ssize_t atkbd_do_show_##_name(struct device *d, \
263 : struct device_attribute *attr, char *b) \
264 : { \
265 : return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
266 : } \
267 : static ssize_t atkbd_do_set_##_name(struct device *d, \
268 : struct device_attribute *attr, const char *b, size_t s) \
269 : { \
270 : return atkbd_attr_set_helper(d, b, s, atkbd_set_##_name); \
271 : } \
272 : static struct device_attribute atkbd_attr_##_name = \
273 : __ATTR(_name, S_IWUSR | S_IRUGO, atkbd_do_show_##_name, atkbd_do_set_##_name);
274 :
275 0 : ATKBD_DEFINE_ATTR(extra);
276 0 : ATKBD_DEFINE_ATTR(force_release);
277 0 : ATKBD_DEFINE_ATTR(scroll);
278 0 : ATKBD_DEFINE_ATTR(set);
279 0 : ATKBD_DEFINE_ATTR(softrepeat);
280 0 : ATKBD_DEFINE_ATTR(softraw);
281 :
282 : #define ATKBD_DEFINE_RO_ATTR(_name) \
283 : static ssize_t atkbd_show_##_name(struct atkbd *, char *); \
284 : static ssize_t atkbd_do_show_##_name(struct device *d, \
285 : struct device_attribute *attr, char *b) \
286 : { \
287 : return atkbd_attr_show_helper(d, b, atkbd_show_##_name); \
288 : } \
289 : static struct device_attribute atkbd_attr_##_name = \
290 : __ATTR(_name, S_IRUGO, atkbd_do_show_##_name, NULL);
291 :
292 0 : ATKBD_DEFINE_RO_ATTR(err_count);
293 0 : ATKBD_DEFINE_RO_ATTR(function_row_physmap);
294 :
295 : static struct attribute *atkbd_attributes[] = {
296 : &atkbd_attr_extra.attr,
297 : &atkbd_attr_force_release.attr,
298 : &atkbd_attr_scroll.attr,
299 : &atkbd_attr_set.attr,
300 : &atkbd_attr_softrepeat.attr,
301 : &atkbd_attr_softraw.attr,
302 : &atkbd_attr_err_count.attr,
303 : &atkbd_attr_function_row_physmap.attr,
304 : NULL
305 : };
306 :
307 0 : static ssize_t atkbd_show_function_row_physmap(struct atkbd *atkbd, char *buf)
308 : {
309 0 : return vivaldi_function_row_physmap_show(&atkbd->vdata, buf);
310 : }
311 :
312 0 : static umode_t atkbd_attr_is_visible(struct kobject *kobj,
313 : struct attribute *attr, int i)
314 : {
315 0 : struct device *dev = kobj_to_dev(kobj);
316 0 : struct serio *serio = to_serio_port(dev);
317 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
318 :
319 0 : if (attr == &atkbd_attr_function_row_physmap.attr &&
320 0 : !atkbd->vdata.num_function_row_keys)
321 : return 0;
322 :
323 0 : return attr->mode;
324 : }
325 :
326 : static struct attribute_group atkbd_attribute_group = {
327 : .attrs = atkbd_attributes,
328 : .is_visible = atkbd_attr_is_visible,
329 : };
330 :
331 : static const unsigned int xl_table[] = {
332 : ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK,
333 : ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL,
334 : };
335 :
336 : /*
337 : * Checks if we should mangle the scancode to extract 'release' bit
338 : * in translated mode.
339 : */
340 0 : static bool atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
341 : {
342 : int i;
343 :
344 0 : if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
345 : return false;
346 :
347 0 : for (i = 0; i < ARRAY_SIZE(xl_table); i++)
348 0 : if (code == xl_table[i])
349 0 : return test_bit(i, &xl_bit);
350 :
351 : return true;
352 : }
353 :
354 : /*
355 : * Calculates new value of xl_bit so the driver can distinguish
356 : * between make/break pair of scancodes for select keys and PS/2
357 : * protocol responses.
358 : */
359 : static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code)
360 : {
361 : int i;
362 :
363 0 : for (i = 0; i < ARRAY_SIZE(xl_table); i++) {
364 0 : if (!((code ^ xl_table[i]) & 0x7f)) {
365 0 : if (code & 0x80)
366 0 : __clear_bit(i, &atkbd->xl_bit);
367 : else
368 0 : __set_bit(i, &atkbd->xl_bit);
369 : break;
370 : }
371 : }
372 : }
373 :
374 : /*
375 : * Encode the scancode, 0xe0 prefix, and high bit into a single integer,
376 : * keeping kernel 2.4 compatibility for set 2
377 : */
378 : static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code)
379 : {
380 0 : if (atkbd->set == 3) {
381 0 : if (atkbd->emul == 1)
382 0 : code |= 0x100;
383 : } else {
384 0 : code = (code & 0x7f) | ((code & 0x80) << 1);
385 0 : if (atkbd->emul == 1)
386 0 : code |= 0x80;
387 : }
388 :
389 : return code;
390 : }
391 :
392 : /*
393 : * atkbd_interrupt(). Here takes place processing of data received from
394 : * the keyboard into events.
395 : */
396 :
397 0 : static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
398 : unsigned int flags)
399 : {
400 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
401 0 : struct input_dev *dev = atkbd->dev;
402 0 : unsigned int code = data;
403 0 : int scroll = 0, hscroll = 0, click = -1;
404 : int value;
405 : unsigned short keycode;
406 :
407 : dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags);
408 :
409 : #if !defined(__i386__) && !defined (__x86_64__)
410 : if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
411 : dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags);
412 : serio_write(serio, ATKBD_CMD_RESEND);
413 : atkbd->resend = true;
414 : goto out;
415 : }
416 :
417 : if (!flags && data == ATKBD_RET_ACK)
418 : atkbd->resend = false;
419 : #endif
420 :
421 0 : if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
422 0 : if (ps2_handle_ack(&atkbd->ps2dev, data))
423 : goto out;
424 :
425 0 : if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
426 0 : if (ps2_handle_response(&atkbd->ps2dev, data))
427 : goto out;
428 :
429 0 : pm_wakeup_event(&serio->dev, 0);
430 :
431 0 : if (!atkbd->enabled)
432 : goto out;
433 :
434 0 : input_event(dev, EV_MSC, MSC_RAW, code);
435 :
436 0 : if (atkbd_platform_scancode_fixup)
437 0 : code = atkbd_platform_scancode_fixup(atkbd, code);
438 :
439 0 : if (atkbd->translated) {
440 :
441 0 : if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
442 0 : atkbd->release = code >> 7;
443 0 : code &= 0x7f;
444 : }
445 :
446 0 : if (!atkbd->emul)
447 : atkbd_calculate_xl_bit(atkbd, data);
448 : }
449 :
450 0 : switch (code) {
451 : case ATKBD_RET_BAT:
452 0 : atkbd->enabled = false;
453 0 : serio_reconnect(atkbd->ps2dev.serio);
454 0 : goto out;
455 : case ATKBD_RET_EMUL0:
456 0 : atkbd->emul = 1;
457 0 : goto out;
458 : case ATKBD_RET_EMUL1:
459 0 : atkbd->emul = 2;
460 0 : goto out;
461 : case ATKBD_RET_RELEASE:
462 0 : atkbd->release = true;
463 0 : goto out;
464 : case ATKBD_RET_ACK:
465 : case ATKBD_RET_NAK:
466 0 : if (printk_ratelimit())
467 0 : dev_warn(&serio->dev,
468 : "Spurious %s on %s. "
469 : "Some program might be trying to access hardware directly.\n",
470 : data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
471 : goto out;
472 : case ATKBD_RET_ERR:
473 0 : atkbd->err_count++;
474 : dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n",
475 : serio->phys);
476 0 : goto out;
477 : }
478 :
479 0 : code = atkbd_compat_scancode(atkbd, code);
480 :
481 0 : if (atkbd->emul && --atkbd->emul)
482 : goto out;
483 :
484 0 : keycode = atkbd->keycode[code];
485 :
486 0 : if (!(atkbd->release && test_bit(code, atkbd->force_release_mask)))
487 0 : if (keycode != ATKBD_KEY_NULL)
488 0 : input_event(dev, EV_MSC, MSC_SCAN, code);
489 :
490 0 : switch (keycode) {
491 : case ATKBD_KEY_NULL:
492 : break;
493 : case ATKBD_KEY_UNKNOWN:
494 0 : dev_warn(&serio->dev,
495 : "Unknown key %s (%s set %d, code %#x on %s).\n",
496 : atkbd->release ? "released" : "pressed",
497 : atkbd->translated ? "translated" : "raw",
498 : atkbd->set, code, serio->phys);
499 0 : dev_warn(&serio->dev,
500 : "Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
501 : code & 0x80 ? "e0" : "", code & 0x7f);
502 : input_sync(dev);
503 : break;
504 : case ATKBD_SCR_1:
505 0 : scroll = 1;
506 0 : break;
507 : case ATKBD_SCR_2:
508 0 : scroll = 2;
509 0 : break;
510 : case ATKBD_SCR_4:
511 0 : scroll = 4;
512 0 : break;
513 : case ATKBD_SCR_8:
514 0 : scroll = 8;
515 0 : break;
516 : case ATKBD_SCR_CLICK:
517 0 : click = !atkbd->release;
518 0 : break;
519 : case ATKBD_SCR_LEFT:
520 0 : hscroll = -1;
521 0 : break;
522 : case ATKBD_SCR_RIGHT:
523 0 : hscroll = 1;
524 0 : break;
525 : default:
526 0 : if (atkbd->release) {
527 0 : value = 0;
528 0 : atkbd->last = 0;
529 0 : } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
530 : /* Workaround Toshiba laptop multiple keypress */
531 0 : value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
532 : } else {
533 0 : value = 1;
534 0 : atkbd->last = code;
535 0 : atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
536 : }
537 :
538 0 : input_event(dev, EV_KEY, keycode, value);
539 0 : input_sync(dev);
540 :
541 0 : if (value && test_bit(code, atkbd->force_release_mask)) {
542 0 : input_event(dev, EV_MSC, MSC_SCAN, code);
543 0 : input_report_key(dev, keycode, 0);
544 : input_sync(dev);
545 : }
546 : }
547 :
548 0 : if (atkbd->scroll) {
549 0 : if (click != -1)
550 : input_report_key(dev, BTN_MIDDLE, click);
551 0 : input_report_rel(dev, REL_WHEEL,
552 0 : atkbd->release ? -scroll : scroll);
553 0 : input_report_rel(dev, REL_HWHEEL, hscroll);
554 : input_sync(dev);
555 : }
556 :
557 0 : atkbd->release = false;
558 : out:
559 0 : return IRQ_HANDLED;
560 : }
561 :
562 0 : static int atkbd_set_repeat_rate(struct atkbd *atkbd)
563 : {
564 0 : const short period[32] =
565 : { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125,
566 : 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
567 0 : const short delay[4] =
568 : { 250, 500, 750, 1000 };
569 :
570 0 : struct input_dev *dev = atkbd->dev;
571 : unsigned char param;
572 0 : int i = 0, j = 0;
573 :
574 0 : while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
575 0 : i++;
576 0 : dev->rep[REP_PERIOD] = period[i];
577 :
578 0 : while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
579 0 : j++;
580 0 : dev->rep[REP_DELAY] = delay[j];
581 :
582 0 : param = i | (j << 5);
583 0 : return ps2_command(&atkbd->ps2dev, ¶m, ATKBD_CMD_SETREP);
584 : }
585 :
586 0 : static int atkbd_set_leds(struct atkbd *atkbd)
587 : {
588 0 : struct input_dev *dev = atkbd->dev;
589 : unsigned char param[2];
590 :
591 0 : param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
592 0 : | (test_bit(LED_NUML, dev->led) ? 2 : 0)
593 0 : | (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
594 0 : if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
595 : return -1;
596 :
597 0 : if (atkbd->extra) {
598 0 : param[0] = 0;
599 0 : param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
600 0 : | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
601 0 : | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
602 0 : | (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
603 0 : | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
604 0 : if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
605 : return -1;
606 : }
607 :
608 : return 0;
609 : }
610 :
611 : /*
612 : * atkbd_event_work() is used to complete processing of events that
613 : * can not be processed by input_event() which is often called from
614 : * interrupt context.
615 : */
616 :
617 0 : static void atkbd_event_work(struct work_struct *work)
618 : {
619 0 : struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work);
620 :
621 0 : mutex_lock(&atkbd->mutex);
622 :
623 0 : if (!atkbd->enabled) {
624 : /*
625 : * Serio ports are resumed asynchronously so while driver core
626 : * thinks that device is already fully operational in reality
627 : * it may not be ready yet. In this case we need to keep
628 : * rescheduling till reconnect completes.
629 : */
630 0 : schedule_delayed_work(&atkbd->event_work,
631 : msecs_to_jiffies(100));
632 : } else {
633 0 : if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
634 0 : atkbd_set_leds(atkbd);
635 :
636 0 : if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
637 0 : atkbd_set_repeat_rate(atkbd);
638 : }
639 :
640 0 : mutex_unlock(&atkbd->mutex);
641 0 : }
642 :
643 : /*
644 : * Schedule switch for execution. We need to throttle requests,
645 : * otherwise keyboard may become unresponsive.
646 : */
647 0 : static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit)
648 : {
649 0 : unsigned long delay = msecs_to_jiffies(50);
650 :
651 0 : if (time_after(jiffies, atkbd->event_jiffies + delay))
652 0 : delay = 0;
653 :
654 0 : atkbd->event_jiffies = jiffies;
655 0 : set_bit(event_bit, &atkbd->event_mask);
656 0 : mb();
657 0 : schedule_delayed_work(&atkbd->event_work, delay);
658 0 : }
659 :
660 : /*
661 : * Event callback from the input module. Events that change the state of
662 : * the hardware are processed here. If action can not be performed in
663 : * interrupt context it is offloaded to atkbd_event_work.
664 : */
665 :
666 0 : static int atkbd_event(struct input_dev *dev,
667 : unsigned int type, unsigned int code, int value)
668 : {
669 0 : struct atkbd *atkbd = input_get_drvdata(dev);
670 :
671 0 : if (!atkbd->write)
672 : return -1;
673 :
674 0 : switch (type) {
675 :
676 : case EV_LED:
677 0 : atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
678 0 : return 0;
679 :
680 : case EV_REP:
681 0 : if (!atkbd->softrepeat)
682 0 : atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
683 : return 0;
684 :
685 : default:
686 : return -1;
687 : }
688 : }
689 :
690 : /*
691 : * atkbd_enable() signals that interrupt handler is allowed to
692 : * generate input events.
693 : */
694 :
695 : static inline void atkbd_enable(struct atkbd *atkbd)
696 : {
697 0 : serio_pause_rx(atkbd->ps2dev.serio);
698 0 : atkbd->enabled = true;
699 0 : serio_continue_rx(atkbd->ps2dev.serio);
700 : }
701 :
702 : /*
703 : * atkbd_disable() tells input handler that all incoming data except
704 : * for ACKs and command response should be dropped.
705 : */
706 :
707 : static inline void atkbd_disable(struct atkbd *atkbd)
708 : {
709 0 : serio_pause_rx(atkbd->ps2dev.serio);
710 0 : atkbd->enabled = false;
711 0 : serio_continue_rx(atkbd->ps2dev.serio);
712 : }
713 :
714 0 : static int atkbd_activate(struct atkbd *atkbd)
715 : {
716 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
717 :
718 : /*
719 : * Enable the keyboard to receive keystrokes.
720 : */
721 :
722 0 : if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
723 0 : dev_err(&ps2dev->serio->dev,
724 : "Failed to enable keyboard on %s\n",
725 : ps2dev->serio->phys);
726 0 : return -1;
727 : }
728 :
729 : return 0;
730 : }
731 :
732 : /*
733 : * atkbd_deactivate() resets and disables the keyboard from sending
734 : * keystrokes.
735 : */
736 :
737 0 : static void atkbd_deactivate(struct atkbd *atkbd)
738 : {
739 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
740 :
741 0 : if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_DIS))
742 0 : dev_err(&ps2dev->serio->dev,
743 : "Failed to deactivate keyboard on %s\n",
744 : ps2dev->serio->phys);
745 0 : }
746 :
747 : /*
748 : * atkbd_probe() probes for an AT keyboard on a serio port.
749 : */
750 :
751 0 : static int atkbd_probe(struct atkbd *atkbd)
752 : {
753 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
754 : unsigned char param[2];
755 :
756 : /*
757 : * Some systems, where the bit-twiddling when testing the io-lines of the
758 : * controller may confuse the keyboard need a full reset of the keyboard. On
759 : * these systems the BIOS also usually doesn't do it for us.
760 : */
761 :
762 0 : if (atkbd_reset)
763 0 : if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
764 0 : dev_warn(&ps2dev->serio->dev,
765 : "keyboard reset failed on %s\n",
766 : ps2dev->serio->phys);
767 :
768 : /*
769 : * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
770 : * Some keyboards report different values, but the first byte is always 0xab or
771 : * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
772 : * should make sure we don't try to set the LEDs on it.
773 : */
774 :
775 0 : param[0] = param[1] = 0xa5; /* initialize with invalid values */
776 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
777 :
778 : /*
779 : * If the get ID command failed, we check if we can at least set the LEDs on
780 : * the keyboard. This should work on every keyboard out there. It also turns
781 : * the LEDs off, which we want anyway.
782 : */
783 0 : param[0] = 0;
784 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
785 : return -1;
786 0 : atkbd->id = 0xabba;
787 0 : return 0;
788 : }
789 :
790 0 : if (!ps2_is_keyboard_id(param[0]))
791 : return -1;
792 :
793 0 : atkbd->id = (param[0] << 8) | param[1];
794 :
795 0 : if (atkbd->id == 0xaca1 && atkbd->translated) {
796 0 : dev_err(&ps2dev->serio->dev,
797 : "NCD terminal keyboards are only supported on non-translating controllers. "
798 : "Use i8042.direct=1 to disable translation.\n");
799 0 : return -1;
800 : }
801 :
802 : /*
803 : * Make sure nothing is coming from the keyboard and disturbs our
804 : * internal state.
805 : */
806 0 : if (!atkbd_skip_deactivate)
807 0 : atkbd_deactivate(atkbd);
808 :
809 : return 0;
810 : }
811 :
812 : /*
813 : * atkbd_select_set checks if a keyboard has a working Set 3 support, and
814 : * sets it into that. Unfortunately there are keyboards that can be switched
815 : * to Set 3, but don't work well in that (BTC Multimedia ...)
816 : */
817 :
818 0 : static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
819 : {
820 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
821 : unsigned char param[2];
822 :
823 0 : atkbd->extra = false;
824 : /*
825 : * For known special keyboards we can go ahead and set the correct set.
826 : * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
827 : * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
828 : */
829 :
830 0 : if (atkbd->translated)
831 : return 2;
832 :
833 0 : if (atkbd->id == 0xaca1) {
834 0 : param[0] = 3;
835 0 : ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
836 0 : return 3;
837 : }
838 :
839 0 : if (allow_extra) {
840 0 : param[0] = 0x71;
841 0 : if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
842 0 : atkbd->extra = true;
843 0 : return 2;
844 : }
845 : }
846 :
847 0 : if (atkbd_terminal) {
848 0 : ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MB);
849 0 : return 3;
850 : }
851 :
852 0 : if (target_set != 3)
853 : return 2;
854 :
855 0 : if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
856 0 : atkbd->id = param[0] << 8 | param[1];
857 0 : return 2;
858 : }
859 :
860 0 : param[0] = 3;
861 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
862 : return 2;
863 :
864 0 : param[0] = 0;
865 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
866 : return 2;
867 :
868 0 : if (param[0] != 3) {
869 0 : param[0] = 2;
870 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
871 : return 2;
872 : }
873 :
874 0 : ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
875 :
876 0 : return 3;
877 : }
878 :
879 0 : static int atkbd_reset_state(struct atkbd *atkbd)
880 : {
881 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
882 : unsigned char param[1];
883 :
884 : /*
885 : * Set the LEDs to a predefined state (all off).
886 : */
887 :
888 0 : param[0] = 0;
889 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
890 : return -1;
891 :
892 : /*
893 : * Set autorepeat to fastest possible.
894 : */
895 :
896 0 : param[0] = 0;
897 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
898 : return -1;
899 :
900 0 : return 0;
901 : }
902 :
903 : /*
904 : * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
905 : * reboot.
906 : */
907 :
908 0 : static void atkbd_cleanup(struct serio *serio)
909 : {
910 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
911 :
912 : atkbd_disable(atkbd);
913 0 : ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF);
914 0 : }
915 :
916 :
917 : /*
918 : * atkbd_disconnect() closes and frees.
919 : */
920 :
921 0 : static void atkbd_disconnect(struct serio *serio)
922 : {
923 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
924 :
925 0 : sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
926 :
927 : atkbd_disable(atkbd);
928 :
929 0 : input_unregister_device(atkbd->dev);
930 :
931 : /*
932 : * Make sure we don't have a command in flight.
933 : * Note that since atkbd->enabled is false event work will keep
934 : * rescheduling itself until it gets canceled and will not try
935 : * accessing freed input device or serio port.
936 : */
937 0 : cancel_delayed_work_sync(&atkbd->event_work);
938 :
939 0 : serio_close(serio);
940 0 : serio_set_drvdata(serio, NULL);
941 0 : kfree(atkbd);
942 0 : }
943 :
944 : /*
945 : * generate release events for the keycodes given in data
946 : */
947 : static void atkbd_apply_forced_release_keylist(struct atkbd* atkbd,
948 : const void *data)
949 : {
950 : const unsigned int *keys = data;
951 : unsigned int i;
952 :
953 : if (atkbd->set == 2)
954 : for (i = 0; keys[i] != -1U; i++)
955 : __set_bit(keys[i], atkbd->force_release_mask);
956 : }
957 :
958 : /*
959 : * Most special keys (Fn+F?) on Dell laptops do not generate release
960 : * events so we have to do it ourselves.
961 : */
962 : static unsigned int atkbd_dell_laptop_forced_release_keys[] = {
963 : 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93, -1U
964 : };
965 :
966 : /*
967 : * Perform fixup for HP system that doesn't generate release
968 : * for its video switch
969 : */
970 : static unsigned int atkbd_hp_forced_release_keys[] = {
971 : 0x94, -1U
972 : };
973 :
974 : /*
975 : * Samsung NC10,NC20 with Fn+F? key release not working
976 : */
977 : static unsigned int atkbd_samsung_forced_release_keys[] = {
978 : 0x82, 0x83, 0x84, 0x86, 0x88, 0x89, 0xb3, 0xf7, 0xf9, -1U
979 : };
980 :
981 : /*
982 : * Amilo Pi 3525 key release for Fn+Volume keys not working
983 : */
984 : static unsigned int atkbd_amilo_pi3525_forced_release_keys[] = {
985 : 0x20, 0xa0, 0x2e, 0xae, 0x30, 0xb0, -1U
986 : };
987 :
988 : /*
989 : * Amilo Xi 3650 key release for light touch bar not working
990 : */
991 : static unsigned int atkbd_amilo_xi3650_forced_release_keys[] = {
992 : 0x67, 0xed, 0x90, 0xa2, 0x99, 0xa4, 0xae, 0xb0, -1U
993 : };
994 :
995 : /*
996 : * Soltech TA12 system with broken key release on volume keys and mute key
997 : */
998 : static unsigned int atkdb_soltech_ta12_forced_release_keys[] = {
999 : 0xa0, 0xae, 0xb0, -1U
1000 : };
1001 :
1002 : /*
1003 : * Many notebooks don't send key release event for volume up/down
1004 : * keys, with key list below common among them
1005 : */
1006 : static unsigned int atkbd_volume_forced_release_keys[] = {
1007 : 0xae, 0xb0, -1U
1008 : };
1009 :
1010 : /*
1011 : * OQO 01+ multimedia keys (64--66) generate e0 6x upon release whereas
1012 : * they should be generating e4-e6 (0x80 | code).
1013 : */
1014 : static unsigned int atkbd_oqo_01plus_scancode_fixup(struct atkbd *atkbd,
1015 : unsigned int code)
1016 : {
1017 : if (atkbd->translated && atkbd->emul == 1 &&
1018 : (code == 0x64 || code == 0x65 || code == 0x66)) {
1019 : atkbd->emul = 0;
1020 : code |= 0x80;
1021 : }
1022 :
1023 : return code;
1024 : }
1025 :
1026 0 : static int atkbd_get_keymap_from_fwnode(struct atkbd *atkbd)
1027 : {
1028 0 : struct device *dev = &atkbd->ps2dev.serio->dev;
1029 : int i, n;
1030 : u32 *ptr;
1031 : u16 scancode, keycode;
1032 :
1033 : /* Parse "linux,keymap" property */
1034 0 : n = device_property_count_u32(dev, "linux,keymap");
1035 0 : if (n <= 0 || n > ATKBD_KEYMAP_SIZE)
1036 : return -ENXIO;
1037 :
1038 0 : ptr = kcalloc(n, sizeof(u32), GFP_KERNEL);
1039 0 : if (!ptr)
1040 : return -ENOMEM;
1041 :
1042 0 : if (device_property_read_u32_array(dev, "linux,keymap", ptr, n)) {
1043 0 : dev_err(dev, "problem parsing FW keymap property\n");
1044 0 : kfree(ptr);
1045 0 : return -EINVAL;
1046 : }
1047 :
1048 0 : memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
1049 0 : for (i = 0; i < n; i++) {
1050 0 : scancode = SCANCODE(ptr[i]);
1051 0 : keycode = KEYCODE(ptr[i]);
1052 0 : atkbd->keycode[scancode] = keycode;
1053 : }
1054 :
1055 0 : kfree(ptr);
1056 0 : return 0;
1057 : }
1058 :
1059 : /*
1060 : * atkbd_set_keycode_table() initializes keyboard's keycode table
1061 : * according to the selected scancode set
1062 : */
1063 :
1064 0 : static void atkbd_set_keycode_table(struct atkbd *atkbd)
1065 : {
1066 0 : struct device *dev = &atkbd->ps2dev.serio->dev;
1067 : unsigned int scancode;
1068 : int i, j;
1069 :
1070 0 : memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
1071 0 : bitmap_zero(atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1072 :
1073 0 : if (!atkbd_get_keymap_from_fwnode(atkbd)) {
1074 : dev_dbg(dev, "Using FW keymap\n");
1075 0 : } else if (atkbd->translated) {
1076 0 : for (i = 0; i < 128; i++) {
1077 0 : scancode = atkbd_unxlate_table[i];
1078 0 : atkbd->keycode[i] = atkbd_set2_keycode[scancode];
1079 0 : atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
1080 0 : if (atkbd->scroll)
1081 0 : for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
1082 0 : if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
1083 0 : atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
1084 : }
1085 0 : } else if (atkbd->set == 3) {
1086 0 : memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
1087 : } else {
1088 0 : memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
1089 :
1090 0 : if (atkbd->scroll)
1091 0 : for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
1092 0 : scancode = atkbd_scroll_keys[i].set2;
1093 0 : atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
1094 : }
1095 : }
1096 :
1097 : /*
1098 : * HANGEUL and HANJA keys do not send release events so we need to
1099 : * generate such events ourselves
1100 : */
1101 0 : scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
1102 0 : atkbd->keycode[scancode] = KEY_HANGEUL;
1103 0 : __set_bit(scancode, atkbd->force_release_mask);
1104 :
1105 0 : scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
1106 0 : atkbd->keycode[scancode] = KEY_HANJA;
1107 0 : __set_bit(scancode, atkbd->force_release_mask);
1108 :
1109 : /*
1110 : * Perform additional fixups
1111 : */
1112 0 : if (atkbd_platform_fixup)
1113 0 : atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
1114 0 : }
1115 :
1116 : /*
1117 : * atkbd_set_device_attrs() sets up keyboard's input device structure
1118 : */
1119 :
1120 0 : static void atkbd_set_device_attrs(struct atkbd *atkbd)
1121 : {
1122 0 : struct input_dev *input_dev = atkbd->dev;
1123 : int i;
1124 :
1125 0 : if (atkbd->extra)
1126 0 : snprintf(atkbd->name, sizeof(atkbd->name),
1127 : "AT Set 2 Extra keyboard");
1128 : else
1129 0 : snprintf(atkbd->name, sizeof(atkbd->name),
1130 : "AT %s Set %d keyboard",
1131 0 : atkbd->translated ? "Translated" : "Raw", atkbd->set);
1132 :
1133 0 : snprintf(atkbd->phys, sizeof(atkbd->phys),
1134 0 : "%s/input0", atkbd->ps2dev.serio->phys);
1135 :
1136 0 : input_dev->name = atkbd->name;
1137 0 : input_dev->phys = atkbd->phys;
1138 0 : input_dev->id.bustype = BUS_I8042;
1139 0 : input_dev->id.vendor = 0x0001;
1140 0 : input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
1141 0 : input_dev->id.version = atkbd->id;
1142 0 : input_dev->event = atkbd_event;
1143 0 : input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
1144 :
1145 0 : input_set_drvdata(input_dev, atkbd);
1146 :
1147 0 : input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
1148 : BIT_MASK(EV_MSC);
1149 :
1150 0 : if (atkbd->write) {
1151 0 : input_dev->evbit[0] |= BIT_MASK(EV_LED);
1152 0 : input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1153 : BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
1154 : }
1155 :
1156 0 : if (atkbd->extra)
1157 0 : input_dev->ledbit[0] |= BIT_MASK(LED_COMPOSE) |
1158 : BIT_MASK(LED_SUSPEND) | BIT_MASK(LED_SLEEP) |
1159 : BIT_MASK(LED_MUTE) | BIT_MASK(LED_MISC);
1160 :
1161 0 : if (!atkbd->softrepeat) {
1162 0 : input_dev->rep[REP_DELAY] = 250;
1163 0 : input_dev->rep[REP_PERIOD] = 33;
1164 : }
1165 :
1166 0 : input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1167 : BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1168 :
1169 0 : if (atkbd->scroll) {
1170 0 : input_dev->evbit[0] |= BIT_MASK(EV_REL);
1171 0 : input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1172 : BIT_MASK(REL_HWHEEL);
1173 0 : __set_bit(BTN_MIDDLE, input_dev->keybit);
1174 : }
1175 :
1176 0 : input_dev->keycode = atkbd->keycode;
1177 0 : input_dev->keycodesize = sizeof(unsigned short);
1178 0 : input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1179 :
1180 0 : for (i = 0; i < ATKBD_KEYMAP_SIZE; i++) {
1181 0 : if (atkbd->keycode[i] != KEY_RESERVED &&
1182 0 : atkbd->keycode[i] != ATKBD_KEY_NULL &&
1183 : atkbd->keycode[i] < ATKBD_SPECIAL) {
1184 0 : __set_bit(atkbd->keycode[i], input_dev->keybit);
1185 : }
1186 : }
1187 0 : }
1188 :
1189 0 : static void atkbd_parse_fwnode_data(struct serio *serio)
1190 : {
1191 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
1192 0 : struct device *dev = &serio->dev;
1193 : int n;
1194 :
1195 : /* Parse "function-row-physmap" property */
1196 0 : n = device_property_count_u32(dev, "function-row-physmap");
1197 0 : if (n > 0 && n <= VIVALDI_MAX_FUNCTION_ROW_KEYS &&
1198 0 : !device_property_read_u32_array(dev, "function-row-physmap",
1199 0 : atkbd->vdata.function_row_physmap,
1200 : n)) {
1201 0 : atkbd->vdata.num_function_row_keys = n;
1202 : dev_dbg(dev, "FW reported %d function-row key locations\n", n);
1203 : }
1204 0 : }
1205 :
1206 : /*
1207 : * atkbd_connect() is called when the serio module finds an interface
1208 : * that isn't handled yet by an appropriate device driver. We check if
1209 : * there is an AT keyboard out there and if yes, we register ourselves
1210 : * to the input module.
1211 : */
1212 :
1213 0 : static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1214 : {
1215 : struct atkbd *atkbd;
1216 : struct input_dev *dev;
1217 0 : int err = -ENOMEM;
1218 :
1219 0 : atkbd = kzalloc(sizeof(struct atkbd), GFP_KERNEL);
1220 0 : dev = input_allocate_device();
1221 0 : if (!atkbd || !dev)
1222 : goto fail1;
1223 :
1224 0 : atkbd->dev = dev;
1225 0 : ps2_init(&atkbd->ps2dev, serio);
1226 0 : INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1227 0 : mutex_init(&atkbd->mutex);
1228 :
1229 0 : switch (serio->id.type) {
1230 :
1231 : case SERIO_8042_XL:
1232 0 : atkbd->translated = true;
1233 : fallthrough;
1234 :
1235 : case SERIO_8042:
1236 0 : if (serio->write)
1237 0 : atkbd->write = true;
1238 : break;
1239 : }
1240 :
1241 0 : atkbd->softraw = atkbd_softraw;
1242 0 : atkbd->softrepeat = atkbd_softrepeat;
1243 0 : atkbd->scroll = atkbd_scroll;
1244 :
1245 0 : if (atkbd->softrepeat)
1246 0 : atkbd->softraw = true;
1247 :
1248 0 : serio_set_drvdata(serio, atkbd);
1249 :
1250 0 : err = serio_open(serio, drv);
1251 0 : if (err)
1252 : goto fail2;
1253 :
1254 0 : if (atkbd->write) {
1255 :
1256 0 : if (atkbd_probe(atkbd)) {
1257 : err = -ENODEV;
1258 : goto fail3;
1259 : }
1260 :
1261 0 : atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
1262 0 : atkbd_reset_state(atkbd);
1263 :
1264 : } else {
1265 0 : atkbd->set = 2;
1266 0 : atkbd->id = 0xab00;
1267 : }
1268 :
1269 0 : atkbd_parse_fwnode_data(serio);
1270 :
1271 0 : atkbd_set_keycode_table(atkbd);
1272 0 : atkbd_set_device_attrs(atkbd);
1273 :
1274 0 : err = sysfs_create_group(&serio->dev.kobj, &atkbd_attribute_group);
1275 0 : if (err)
1276 : goto fail3;
1277 :
1278 0 : atkbd_enable(atkbd);
1279 0 : if (serio->write)
1280 0 : atkbd_activate(atkbd);
1281 :
1282 0 : err = input_register_device(atkbd->dev);
1283 0 : if (err)
1284 : goto fail4;
1285 :
1286 : return 0;
1287 :
1288 0 : fail4: sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
1289 0 : fail3: serio_close(serio);
1290 : fail2: serio_set_drvdata(serio, NULL);
1291 0 : fail1: input_free_device(dev);
1292 0 : kfree(atkbd);
1293 0 : return err;
1294 : }
1295 :
1296 : /*
1297 : * atkbd_reconnect() tries to restore keyboard into a sane state and is
1298 : * most likely called on resume.
1299 : */
1300 :
1301 0 : static int atkbd_reconnect(struct serio *serio)
1302 : {
1303 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
1304 0 : struct serio_driver *drv = serio->drv;
1305 0 : int retval = -1;
1306 :
1307 0 : if (!atkbd || !drv) {
1308 : dev_dbg(&serio->dev,
1309 : "reconnect request, but serio is disconnected, ignoring...\n");
1310 : return -1;
1311 : }
1312 :
1313 0 : mutex_lock(&atkbd->mutex);
1314 :
1315 : atkbd_disable(atkbd);
1316 :
1317 0 : if (atkbd->write) {
1318 0 : if (atkbd_probe(atkbd))
1319 : goto out;
1320 :
1321 0 : if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1322 : goto out;
1323 :
1324 : /*
1325 : * Restore LED state and repeat rate. While input core
1326 : * will do this for us at resume time reconnect may happen
1327 : * because user requested it via sysfs or simply because
1328 : * keyboard was unplugged and plugged in again so we need
1329 : * to do it ourselves here.
1330 : */
1331 0 : atkbd_set_leds(atkbd);
1332 0 : if (!atkbd->softrepeat)
1333 0 : atkbd_set_repeat_rate(atkbd);
1334 :
1335 : }
1336 :
1337 : /*
1338 : * Reset our state machine in case reconnect happened in the middle
1339 : * of multi-byte scancode.
1340 : */
1341 0 : atkbd->xl_bit = 0;
1342 0 : atkbd->emul = 0;
1343 :
1344 : atkbd_enable(atkbd);
1345 0 : if (atkbd->write)
1346 0 : atkbd_activate(atkbd);
1347 :
1348 : retval = 0;
1349 :
1350 : out:
1351 0 : mutex_unlock(&atkbd->mutex);
1352 0 : return retval;
1353 : }
1354 :
1355 : static const struct serio_device_id atkbd_serio_ids[] = {
1356 : {
1357 : .type = SERIO_8042,
1358 : .proto = SERIO_ANY,
1359 : .id = SERIO_ANY,
1360 : .extra = SERIO_ANY,
1361 : },
1362 : {
1363 : .type = SERIO_8042_XL,
1364 : .proto = SERIO_ANY,
1365 : .id = SERIO_ANY,
1366 : .extra = SERIO_ANY,
1367 : },
1368 : {
1369 : .type = SERIO_RS232,
1370 : .proto = SERIO_PS2SER,
1371 : .id = SERIO_ANY,
1372 : .extra = SERIO_ANY,
1373 : },
1374 : { 0 }
1375 : };
1376 :
1377 : MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1378 :
1379 : static struct serio_driver atkbd_drv = {
1380 : .driver = {
1381 : .name = "atkbd",
1382 : },
1383 : .description = DRIVER_DESC,
1384 : .id_table = atkbd_serio_ids,
1385 : .interrupt = atkbd_interrupt,
1386 : .connect = atkbd_connect,
1387 : .reconnect = atkbd_reconnect,
1388 : .disconnect = atkbd_disconnect,
1389 : .cleanup = atkbd_cleanup,
1390 : };
1391 :
1392 : static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1393 : ssize_t (*handler)(struct atkbd *, char *))
1394 : {
1395 0 : struct serio *serio = to_serio_port(dev);
1396 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
1397 :
1398 0 : return handler(atkbd, buf);
1399 : }
1400 :
1401 0 : static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1402 : ssize_t (*handler)(struct atkbd *, const char *, size_t))
1403 : {
1404 0 : struct serio *serio = to_serio_port(dev);
1405 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
1406 : int retval;
1407 :
1408 0 : retval = mutex_lock_interruptible(&atkbd->mutex);
1409 0 : if (retval)
1410 0 : return retval;
1411 :
1412 : atkbd_disable(atkbd);
1413 0 : retval = handler(atkbd, buf, count);
1414 : atkbd_enable(atkbd);
1415 :
1416 0 : mutex_unlock(&atkbd->mutex);
1417 :
1418 0 : return retval;
1419 : }
1420 :
1421 0 : static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1422 : {
1423 0 : return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1424 : }
1425 :
1426 0 : static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1427 : {
1428 : struct input_dev *old_dev, *new_dev;
1429 : unsigned int value;
1430 : int err;
1431 : bool old_extra;
1432 : unsigned char old_set;
1433 :
1434 0 : if (!atkbd->write)
1435 : return -EIO;
1436 :
1437 0 : err = kstrtouint(buf, 10, &value);
1438 0 : if (err)
1439 0 : return err;
1440 :
1441 0 : if (value > 1)
1442 : return -EINVAL;
1443 :
1444 0 : if (atkbd->extra != value) {
1445 : /*
1446 : * Since device's properties will change we need to
1447 : * unregister old device. But allocate and register
1448 : * new one first to make sure we have it.
1449 : */
1450 0 : old_dev = atkbd->dev;
1451 0 : old_extra = atkbd->extra;
1452 0 : old_set = atkbd->set;
1453 :
1454 0 : new_dev = input_allocate_device();
1455 0 : if (!new_dev)
1456 : return -ENOMEM;
1457 :
1458 0 : atkbd->dev = new_dev;
1459 0 : atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1460 0 : atkbd_reset_state(atkbd);
1461 0 : atkbd_activate(atkbd);
1462 0 : atkbd_set_keycode_table(atkbd);
1463 0 : atkbd_set_device_attrs(atkbd);
1464 :
1465 0 : err = input_register_device(atkbd->dev);
1466 0 : if (err) {
1467 0 : input_free_device(new_dev);
1468 :
1469 0 : atkbd->dev = old_dev;
1470 0 : atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1471 0 : atkbd_set_keycode_table(atkbd);
1472 0 : atkbd_set_device_attrs(atkbd);
1473 :
1474 0 : return err;
1475 : }
1476 0 : input_unregister_device(old_dev);
1477 :
1478 : }
1479 0 : return count;
1480 : }
1481 :
1482 0 : static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
1483 : {
1484 0 : size_t len = scnprintf(buf, PAGE_SIZE - 1, "%*pbl",
1485 0 : ATKBD_KEYMAP_SIZE, atkbd->force_release_mask);
1486 :
1487 0 : buf[len++] = '\n';
1488 0 : buf[len] = '\0';
1489 :
1490 0 : return len;
1491 : }
1492 :
1493 0 : static ssize_t atkbd_set_force_release(struct atkbd *atkbd,
1494 : const char *buf, size_t count)
1495 : {
1496 : /* 64 bytes on stack should be acceptable */
1497 : DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE);
1498 : int err;
1499 :
1500 0 : err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE);
1501 0 : if (err)
1502 0 : return err;
1503 :
1504 0 : memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1505 0 : return count;
1506 : }
1507 :
1508 :
1509 0 : static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1510 : {
1511 0 : return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1512 : }
1513 :
1514 0 : static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1515 : {
1516 : struct input_dev *old_dev, *new_dev;
1517 : unsigned int value;
1518 : int err;
1519 : bool old_scroll;
1520 :
1521 0 : err = kstrtouint(buf, 10, &value);
1522 0 : if (err)
1523 0 : return err;
1524 :
1525 0 : if (value > 1)
1526 : return -EINVAL;
1527 :
1528 0 : if (atkbd->scroll != value) {
1529 0 : old_dev = atkbd->dev;
1530 0 : old_scroll = atkbd->scroll;
1531 :
1532 0 : new_dev = input_allocate_device();
1533 0 : if (!new_dev)
1534 : return -ENOMEM;
1535 :
1536 0 : atkbd->dev = new_dev;
1537 0 : atkbd->scroll = value;
1538 0 : atkbd_set_keycode_table(atkbd);
1539 0 : atkbd_set_device_attrs(atkbd);
1540 :
1541 0 : err = input_register_device(atkbd->dev);
1542 0 : if (err) {
1543 0 : input_free_device(new_dev);
1544 :
1545 0 : atkbd->scroll = old_scroll;
1546 0 : atkbd->dev = old_dev;
1547 0 : atkbd_set_keycode_table(atkbd);
1548 0 : atkbd_set_device_attrs(atkbd);
1549 :
1550 0 : return err;
1551 : }
1552 0 : input_unregister_device(old_dev);
1553 : }
1554 0 : return count;
1555 : }
1556 :
1557 0 : static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1558 : {
1559 0 : return sprintf(buf, "%d\n", atkbd->set);
1560 : }
1561 :
1562 0 : static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1563 : {
1564 : struct input_dev *old_dev, *new_dev;
1565 : unsigned int value;
1566 : int err;
1567 : unsigned char old_set;
1568 : bool old_extra;
1569 :
1570 0 : if (!atkbd->write)
1571 : return -EIO;
1572 :
1573 0 : err = kstrtouint(buf, 10, &value);
1574 0 : if (err)
1575 0 : return err;
1576 :
1577 0 : if (value != 2 && value != 3)
1578 : return -EINVAL;
1579 :
1580 0 : if (atkbd->set != value) {
1581 0 : old_dev = atkbd->dev;
1582 0 : old_extra = atkbd->extra;
1583 0 : old_set = atkbd->set;
1584 :
1585 0 : new_dev = input_allocate_device();
1586 0 : if (!new_dev)
1587 : return -ENOMEM;
1588 :
1589 0 : atkbd->dev = new_dev;
1590 0 : atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1591 0 : atkbd_reset_state(atkbd);
1592 0 : atkbd_activate(atkbd);
1593 0 : atkbd_set_keycode_table(atkbd);
1594 0 : atkbd_set_device_attrs(atkbd);
1595 :
1596 0 : err = input_register_device(atkbd->dev);
1597 0 : if (err) {
1598 0 : input_free_device(new_dev);
1599 :
1600 0 : atkbd->dev = old_dev;
1601 0 : atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1602 0 : atkbd_set_keycode_table(atkbd);
1603 0 : atkbd_set_device_attrs(atkbd);
1604 :
1605 0 : return err;
1606 : }
1607 0 : input_unregister_device(old_dev);
1608 : }
1609 0 : return count;
1610 : }
1611 :
1612 0 : static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1613 : {
1614 0 : return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1615 : }
1616 :
1617 0 : static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1618 : {
1619 : struct input_dev *old_dev, *new_dev;
1620 : unsigned int value;
1621 : int err;
1622 : bool old_softrepeat, old_softraw;
1623 :
1624 0 : if (!atkbd->write)
1625 : return -EIO;
1626 :
1627 0 : err = kstrtouint(buf, 10, &value);
1628 0 : if (err)
1629 0 : return err;
1630 :
1631 0 : if (value > 1)
1632 : return -EINVAL;
1633 :
1634 0 : if (atkbd->softrepeat != value) {
1635 0 : old_dev = atkbd->dev;
1636 0 : old_softrepeat = atkbd->softrepeat;
1637 0 : old_softraw = atkbd->softraw;
1638 :
1639 0 : new_dev = input_allocate_device();
1640 0 : if (!new_dev)
1641 : return -ENOMEM;
1642 :
1643 0 : atkbd->dev = new_dev;
1644 0 : atkbd->softrepeat = value;
1645 0 : if (atkbd->softrepeat)
1646 0 : atkbd->softraw = true;
1647 0 : atkbd_set_device_attrs(atkbd);
1648 :
1649 0 : err = input_register_device(atkbd->dev);
1650 0 : if (err) {
1651 0 : input_free_device(new_dev);
1652 :
1653 0 : atkbd->dev = old_dev;
1654 0 : atkbd->softrepeat = old_softrepeat;
1655 0 : atkbd->softraw = old_softraw;
1656 0 : atkbd_set_device_attrs(atkbd);
1657 :
1658 0 : return err;
1659 : }
1660 0 : input_unregister_device(old_dev);
1661 : }
1662 0 : return count;
1663 : }
1664 :
1665 :
1666 0 : static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1667 : {
1668 0 : return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1669 : }
1670 :
1671 0 : static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1672 : {
1673 : struct input_dev *old_dev, *new_dev;
1674 : unsigned int value;
1675 : int err;
1676 : bool old_softraw;
1677 :
1678 0 : err = kstrtouint(buf, 10, &value);
1679 0 : if (err)
1680 0 : return err;
1681 :
1682 0 : if (value > 1)
1683 : return -EINVAL;
1684 :
1685 0 : if (atkbd->softraw != value) {
1686 0 : old_dev = atkbd->dev;
1687 0 : old_softraw = atkbd->softraw;
1688 :
1689 0 : new_dev = input_allocate_device();
1690 0 : if (!new_dev)
1691 : return -ENOMEM;
1692 :
1693 0 : atkbd->dev = new_dev;
1694 0 : atkbd->softraw = value;
1695 0 : atkbd_set_device_attrs(atkbd);
1696 :
1697 0 : err = input_register_device(atkbd->dev);
1698 0 : if (err) {
1699 0 : input_free_device(new_dev);
1700 :
1701 0 : atkbd->dev = old_dev;
1702 0 : atkbd->softraw = old_softraw;
1703 0 : atkbd_set_device_attrs(atkbd);
1704 :
1705 0 : return err;
1706 : }
1707 0 : input_unregister_device(old_dev);
1708 : }
1709 0 : return count;
1710 : }
1711 :
1712 0 : static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1713 : {
1714 0 : return sprintf(buf, "%lu\n", atkbd->err_count);
1715 : }
1716 :
1717 : static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1718 : {
1719 : atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
1720 : atkbd_platform_fixup_data = id->driver_data;
1721 :
1722 : return 1;
1723 : }
1724 :
1725 : static int __init atkbd_setup_scancode_fixup(const struct dmi_system_id *id)
1726 : {
1727 : atkbd_platform_scancode_fixup = id->driver_data;
1728 :
1729 : return 1;
1730 : }
1731 :
1732 : static int __init atkbd_deactivate_fixup(const struct dmi_system_id *id)
1733 : {
1734 : atkbd_skip_deactivate = true;
1735 : return 1;
1736 : }
1737 :
1738 : /*
1739 : * NOTE: do not add any more "force release" quirks to this table. The
1740 : * task of adjusting list of keys that should be "released" automatically
1741 : * by the driver is now delegated to userspace tools, such as udev, so
1742 : * submit such quirks there.
1743 : */
1744 : static const struct dmi_system_id atkbd_dmi_quirk_table[] __initconst = {
1745 : {
1746 : .matches = {
1747 : DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1748 : DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1749 : },
1750 : .callback = atkbd_setup_forced_release,
1751 : .driver_data = atkbd_dell_laptop_forced_release_keys,
1752 : },
1753 : {
1754 : .matches = {
1755 : DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
1756 : DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1757 : },
1758 : .callback = atkbd_setup_forced_release,
1759 : .driver_data = atkbd_dell_laptop_forced_release_keys,
1760 : },
1761 : {
1762 : .matches = {
1763 : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1764 : DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1765 : },
1766 : .callback = atkbd_setup_forced_release,
1767 : .driver_data = atkbd_hp_forced_release_keys,
1768 : },
1769 : {
1770 : .matches = {
1771 : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1772 : DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1773 : },
1774 : .callback = atkbd_setup_forced_release,
1775 : .driver_data = atkbd_volume_forced_release_keys,
1776 : },
1777 : {
1778 : .matches = {
1779 : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1780 : DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"),
1781 : },
1782 : .callback = atkbd_setup_forced_release,
1783 : .driver_data = atkbd_volume_forced_release_keys,
1784 : },
1785 : {
1786 : .matches = {
1787 : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1788 : DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"),
1789 : },
1790 : .callback = atkbd_setup_forced_release,
1791 : .driver_data = atkbd_volume_forced_release_keys,
1792 : },
1793 : {
1794 : .matches = {
1795 : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1796 : DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"),
1797 : },
1798 : .callback = atkbd_setup_forced_release,
1799 : .driver_data = atkbd_volume_forced_release_keys,
1800 : },
1801 : {
1802 : /* Inventec Symphony */
1803 : .matches = {
1804 : DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1805 : DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1806 : },
1807 : .callback = atkbd_setup_forced_release,
1808 : .driver_data = atkbd_volume_forced_release_keys,
1809 : },
1810 : {
1811 : /* Samsung NC10 */
1812 : .matches = {
1813 : DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1814 : DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
1815 : },
1816 : .callback = atkbd_setup_forced_release,
1817 : .driver_data = atkbd_samsung_forced_release_keys,
1818 : },
1819 : {
1820 : /* Samsung NC20 */
1821 : .matches = {
1822 : DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1823 : DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
1824 : },
1825 : .callback = atkbd_setup_forced_release,
1826 : .driver_data = atkbd_samsung_forced_release_keys,
1827 : },
1828 : {
1829 : /* Samsung SQ45S70S */
1830 : .matches = {
1831 : DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1832 : DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
1833 : },
1834 : .callback = atkbd_setup_forced_release,
1835 : .driver_data = atkbd_samsung_forced_release_keys,
1836 : },
1837 : {
1838 : /* Fujitsu Amilo PA 1510 */
1839 : .matches = {
1840 : DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1841 : DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
1842 : },
1843 : .callback = atkbd_setup_forced_release,
1844 : .driver_data = atkbd_volume_forced_release_keys,
1845 : },
1846 : {
1847 : /* Fujitsu Amilo Pi 3525 */
1848 : .matches = {
1849 : DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1850 : DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
1851 : },
1852 : .callback = atkbd_setup_forced_release,
1853 : .driver_data = atkbd_amilo_pi3525_forced_release_keys,
1854 : },
1855 : {
1856 : /* Fujitsu Amilo Xi 3650 */
1857 : .matches = {
1858 : DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1859 : DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
1860 : },
1861 : .callback = atkbd_setup_forced_release,
1862 : .driver_data = atkbd_amilo_xi3650_forced_release_keys,
1863 : },
1864 : {
1865 : .matches = {
1866 : DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"),
1867 : DMI_MATCH(DMI_PRODUCT_NAME, "TA12"),
1868 : },
1869 : .callback = atkbd_setup_forced_release,
1870 : .driver_data = atkdb_soltech_ta12_forced_release_keys,
1871 : },
1872 : {
1873 : /* OQO Model 01+ */
1874 : .matches = {
1875 : DMI_MATCH(DMI_SYS_VENDOR, "OQO"),
1876 : DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"),
1877 : },
1878 : .callback = atkbd_setup_scancode_fixup,
1879 : .driver_data = atkbd_oqo_01plus_scancode_fixup,
1880 : },
1881 : {
1882 : .matches = {
1883 : DMI_MATCH(DMI_SYS_VENDOR, "LG Electronics"),
1884 : },
1885 : .callback = atkbd_deactivate_fixup,
1886 : },
1887 : { }
1888 : };
1889 :
1890 1 : static int __init atkbd_init(void)
1891 : {
1892 1 : dmi_check_system(atkbd_dmi_quirk_table);
1893 :
1894 1 : return serio_register_driver(&atkbd_drv);
1895 : }
1896 :
1897 0 : static void __exit atkbd_exit(void)
1898 : {
1899 0 : serio_unregister_driver(&atkbd_drv);
1900 0 : }
1901 :
1902 : module_init(atkbd_init);
1903 : module_exit(atkbd_exit);
|
