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 const struct attribute_group atkbd_attribute_group = {
327 : .attrs = atkbd_attributes,
328 : .is_visible = atkbd_attr_is_visible,
329 : };
330 :
331 : __ATTRIBUTE_GROUPS(atkbd_attribute);
332 :
333 : static const unsigned int xl_table[] = {
334 : ATKBD_RET_BAT, ATKBD_RET_ERR, ATKBD_RET_ACK,
335 : ATKBD_RET_NAK, ATKBD_RET_HANJA, ATKBD_RET_HANGEUL,
336 : };
337 :
338 : /*
339 : * Checks if we should mangle the scancode to extract 'release' bit
340 : * in translated mode.
341 : */
342 0 : static bool atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
343 : {
344 : int i;
345 :
346 0 : if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
347 : return false;
348 :
349 0 : for (i = 0; i < ARRAY_SIZE(xl_table); i++)
350 0 : if (code == xl_table[i])
351 0 : return test_bit(i, &xl_bit);
352 :
353 : return true;
354 : }
355 :
356 : /*
357 : * Calculates new value of xl_bit so the driver can distinguish
358 : * between make/break pair of scancodes for select keys and PS/2
359 : * protocol responses.
360 : */
361 0 : static void atkbd_calculate_xl_bit(struct atkbd *atkbd, unsigned char code)
362 : {
363 : int i;
364 :
365 0 : for (i = 0; i < ARRAY_SIZE(xl_table); i++) {
366 0 : if (!((code ^ xl_table[i]) & 0x7f)) {
367 0 : if (code & 0x80)
368 0 : __clear_bit(i, &atkbd->xl_bit);
369 : else
370 0 : __set_bit(i, &atkbd->xl_bit);
371 : break;
372 : }
373 : }
374 0 : }
375 :
376 : /*
377 : * Encode the scancode, 0xe0 prefix, and high bit into a single integer,
378 : * keeping kernel 2.4 compatibility for set 2
379 : */
380 : static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code)
381 : {
382 0 : if (atkbd->set == 3) {
383 0 : if (atkbd->emul == 1)
384 0 : code |= 0x100;
385 : } else {
386 0 : code = (code & 0x7f) | ((code & 0x80) << 1);
387 0 : if (atkbd->emul == 1)
388 0 : code |= 0x80;
389 : }
390 :
391 : return code;
392 : }
393 :
394 : /*
395 : * atkbd_interrupt(). Here takes place processing of data received from
396 : * the keyboard into events.
397 : */
398 :
399 0 : static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
400 : unsigned int flags)
401 : {
402 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
403 0 : struct input_dev *dev = atkbd->dev;
404 0 : unsigned int code = data;
405 0 : int scroll = 0, hscroll = 0, click = -1;
406 : int value;
407 : unsigned short keycode;
408 :
409 : dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags);
410 :
411 : #if !defined(__i386__) && !defined (__x86_64__)
412 : if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
413 : dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags);
414 : serio_write(serio, ATKBD_CMD_RESEND);
415 : atkbd->resend = true;
416 : goto out;
417 : }
418 :
419 : if (!flags && data == ATKBD_RET_ACK)
420 : atkbd->resend = false;
421 : #endif
422 :
423 0 : if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
424 0 : if (ps2_handle_ack(&atkbd->ps2dev, data))
425 : goto out;
426 :
427 0 : if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_CMD))
428 0 : if (ps2_handle_response(&atkbd->ps2dev, data))
429 : goto out;
430 :
431 0 : pm_wakeup_event(&serio->dev, 0);
432 :
433 0 : if (!atkbd->enabled)
434 : goto out;
435 :
436 0 : input_event(dev, EV_MSC, MSC_RAW, code);
437 :
438 0 : if (atkbd_platform_scancode_fixup)
439 0 : code = atkbd_platform_scancode_fixup(atkbd, code);
440 :
441 0 : if (atkbd->translated) {
442 :
443 0 : if (atkbd->emul || atkbd_need_xlate(atkbd->xl_bit, code)) {
444 0 : atkbd->release = code >> 7;
445 0 : code &= 0x7f;
446 : }
447 :
448 0 : if (!atkbd->emul)
449 0 : atkbd_calculate_xl_bit(atkbd, data);
450 : }
451 :
452 0 : switch (code) {
453 : case ATKBD_RET_BAT:
454 0 : atkbd->enabled = false;
455 0 : serio_reconnect(atkbd->ps2dev.serio);
456 0 : goto out;
457 : case ATKBD_RET_EMUL0:
458 0 : atkbd->emul = 1;
459 0 : goto out;
460 : case ATKBD_RET_EMUL1:
461 0 : atkbd->emul = 2;
462 0 : goto out;
463 : case ATKBD_RET_RELEASE:
464 0 : atkbd->release = true;
465 0 : goto out;
466 : case ATKBD_RET_ACK:
467 : case ATKBD_RET_NAK:
468 0 : if (printk_ratelimit())
469 0 : dev_warn(&serio->dev,
470 : "Spurious %s on %s. "
471 : "Some program might be trying to access hardware directly.\n",
472 : data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
473 : goto out;
474 : case ATKBD_RET_ERR:
475 0 : atkbd->err_count++;
476 : dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n",
477 : serio->phys);
478 0 : goto out;
479 : }
480 :
481 0 : code = atkbd_compat_scancode(atkbd, code);
482 :
483 0 : if (atkbd->emul && --atkbd->emul)
484 : goto out;
485 :
486 0 : keycode = atkbd->keycode[code];
487 :
488 0 : if (!(atkbd->release && test_bit(code, atkbd->force_release_mask)))
489 0 : if (keycode != ATKBD_KEY_NULL)
490 0 : input_event(dev, EV_MSC, MSC_SCAN, code);
491 :
492 0 : switch (keycode) {
493 : case ATKBD_KEY_NULL:
494 : break;
495 : case ATKBD_KEY_UNKNOWN:
496 0 : dev_warn(&serio->dev,
497 : "Unknown key %s (%s set %d, code %#x on %s).\n",
498 : atkbd->release ? "released" : "pressed",
499 : atkbd->translated ? "translated" : "raw",
500 : atkbd->set, code, serio->phys);
501 0 : dev_warn(&serio->dev,
502 : "Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
503 : code & 0x80 ? "e0" : "", code & 0x7f);
504 : input_sync(dev);
505 : break;
506 : case ATKBD_SCR_1:
507 0 : scroll = 1;
508 0 : break;
509 : case ATKBD_SCR_2:
510 0 : scroll = 2;
511 0 : break;
512 : case ATKBD_SCR_4:
513 0 : scroll = 4;
514 0 : break;
515 : case ATKBD_SCR_8:
516 0 : scroll = 8;
517 0 : break;
518 : case ATKBD_SCR_CLICK:
519 0 : click = !atkbd->release;
520 0 : break;
521 : case ATKBD_SCR_LEFT:
522 0 : hscroll = -1;
523 0 : break;
524 : case ATKBD_SCR_RIGHT:
525 0 : hscroll = 1;
526 0 : break;
527 : default:
528 0 : if (atkbd->release) {
529 0 : value = 0;
530 0 : atkbd->last = 0;
531 0 : } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
532 : /* Workaround Toshiba laptop multiple keypress */
533 0 : value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
534 : } else {
535 0 : value = 1;
536 0 : atkbd->last = code;
537 0 : atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
538 : }
539 :
540 0 : input_event(dev, EV_KEY, keycode, value);
541 0 : input_sync(dev);
542 :
543 0 : if (value && test_bit(code, atkbd->force_release_mask)) {
544 0 : input_event(dev, EV_MSC, MSC_SCAN, code);
545 0 : input_report_key(dev, keycode, 0);
546 : input_sync(dev);
547 : }
548 : }
549 :
550 0 : if (atkbd->scroll) {
551 0 : if (click != -1)
552 : input_report_key(dev, BTN_MIDDLE, click);
553 0 : input_report_rel(dev, REL_WHEEL,
554 0 : atkbd->release ? -scroll : scroll);
555 0 : input_report_rel(dev, REL_HWHEEL, hscroll);
556 : input_sync(dev);
557 : }
558 :
559 0 : atkbd->release = false;
560 : out:
561 0 : return IRQ_HANDLED;
562 : }
563 :
564 0 : static int atkbd_set_repeat_rate(struct atkbd *atkbd)
565 : {
566 0 : const short period[32] =
567 : { 33, 37, 42, 46, 50, 54, 58, 63, 67, 75, 83, 92, 100, 109, 116, 125,
568 : 133, 149, 167, 182, 200, 217, 232, 250, 270, 303, 333, 370, 400, 435, 470, 500 };
569 0 : const short delay[4] =
570 : { 250, 500, 750, 1000 };
571 :
572 0 : struct input_dev *dev = atkbd->dev;
573 : unsigned char param;
574 0 : int i = 0, j = 0;
575 :
576 0 : while (i < ARRAY_SIZE(period) - 1 && period[i] < dev->rep[REP_PERIOD])
577 0 : i++;
578 0 : dev->rep[REP_PERIOD] = period[i];
579 :
580 0 : while (j < ARRAY_SIZE(delay) - 1 && delay[j] < dev->rep[REP_DELAY])
581 0 : j++;
582 0 : dev->rep[REP_DELAY] = delay[j];
583 :
584 0 : param = i | (j << 5);
585 0 : return ps2_command(&atkbd->ps2dev, ¶m, ATKBD_CMD_SETREP);
586 : }
587 :
588 0 : static int atkbd_set_leds(struct atkbd *atkbd)
589 : {
590 0 : struct input_dev *dev = atkbd->dev;
591 : unsigned char param[2];
592 :
593 0 : param[0] = (test_bit(LED_SCROLLL, dev->led) ? 1 : 0)
594 0 : | (test_bit(LED_NUML, dev->led) ? 2 : 0)
595 0 : | (test_bit(LED_CAPSL, dev->led) ? 4 : 0);
596 0 : if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_SETLEDS))
597 : return -1;
598 :
599 0 : if (atkbd->extra) {
600 0 : param[0] = 0;
601 0 : param[1] = (test_bit(LED_COMPOSE, dev->led) ? 0x01 : 0)
602 0 : | (test_bit(LED_SLEEP, dev->led) ? 0x02 : 0)
603 0 : | (test_bit(LED_SUSPEND, dev->led) ? 0x04 : 0)
604 0 : | (test_bit(LED_MISC, dev->led) ? 0x10 : 0)
605 0 : | (test_bit(LED_MUTE, dev->led) ? 0x20 : 0);
606 0 : if (ps2_command(&atkbd->ps2dev, param, ATKBD_CMD_EX_SETLEDS))
607 : return -1;
608 : }
609 :
610 : return 0;
611 : }
612 :
613 : /*
614 : * atkbd_event_work() is used to complete processing of events that
615 : * can not be processed by input_event() which is often called from
616 : * interrupt context.
617 : */
618 :
619 0 : static void atkbd_event_work(struct work_struct *work)
620 : {
621 0 : struct atkbd *atkbd = container_of(work, struct atkbd, event_work.work);
622 :
623 0 : mutex_lock(&atkbd->mutex);
624 :
625 0 : if (!atkbd->enabled) {
626 : /*
627 : * Serio ports are resumed asynchronously so while driver core
628 : * thinks that device is already fully operational in reality
629 : * it may not be ready yet. In this case we need to keep
630 : * rescheduling till reconnect completes.
631 : */
632 0 : schedule_delayed_work(&atkbd->event_work,
633 : msecs_to_jiffies(100));
634 : } else {
635 0 : if (test_and_clear_bit(ATKBD_LED_EVENT_BIT, &atkbd->event_mask))
636 0 : atkbd_set_leds(atkbd);
637 :
638 0 : if (test_and_clear_bit(ATKBD_REP_EVENT_BIT, &atkbd->event_mask))
639 0 : atkbd_set_repeat_rate(atkbd);
640 : }
641 :
642 0 : mutex_unlock(&atkbd->mutex);
643 0 : }
644 :
645 : /*
646 : * Schedule switch for execution. We need to throttle requests,
647 : * otherwise keyboard may become unresponsive.
648 : */
649 0 : static void atkbd_schedule_event_work(struct atkbd *atkbd, int event_bit)
650 : {
651 0 : unsigned long delay = msecs_to_jiffies(50);
652 :
653 0 : if (time_after(jiffies, atkbd->event_jiffies + delay))
654 0 : delay = 0;
655 :
656 0 : atkbd->event_jiffies = jiffies;
657 0 : set_bit(event_bit, &atkbd->event_mask);
658 0 : mb();
659 0 : schedule_delayed_work(&atkbd->event_work, delay);
660 0 : }
661 :
662 : /*
663 : * Event callback from the input module. Events that change the state of
664 : * the hardware are processed here. If action can not be performed in
665 : * interrupt context it is offloaded to atkbd_event_work.
666 : */
667 :
668 0 : static int atkbd_event(struct input_dev *dev,
669 : unsigned int type, unsigned int code, int value)
670 : {
671 0 : struct atkbd *atkbd = input_get_drvdata(dev);
672 :
673 0 : if (!atkbd->write)
674 : return -1;
675 :
676 0 : switch (type) {
677 :
678 : case EV_LED:
679 0 : atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
680 0 : return 0;
681 :
682 : case EV_REP:
683 0 : if (!atkbd->softrepeat)
684 0 : atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
685 : return 0;
686 :
687 : default:
688 : return -1;
689 : }
690 : }
691 :
692 : /*
693 : * atkbd_enable() signals that interrupt handler is allowed to
694 : * generate input events.
695 : */
696 :
697 : static inline void atkbd_enable(struct atkbd *atkbd)
698 : {
699 0 : serio_pause_rx(atkbd->ps2dev.serio);
700 0 : atkbd->enabled = true;
701 0 : serio_continue_rx(atkbd->ps2dev.serio);
702 : }
703 :
704 : /*
705 : * atkbd_disable() tells input handler that all incoming data except
706 : * for ACKs and command response should be dropped.
707 : */
708 :
709 : static inline void atkbd_disable(struct atkbd *atkbd)
710 : {
711 0 : serio_pause_rx(atkbd->ps2dev.serio);
712 0 : atkbd->enabled = false;
713 0 : serio_continue_rx(atkbd->ps2dev.serio);
714 : }
715 :
716 0 : static int atkbd_activate(struct atkbd *atkbd)
717 : {
718 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
719 :
720 : /*
721 : * Enable the keyboard to receive keystrokes.
722 : */
723 :
724 0 : if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
725 0 : dev_err(&ps2dev->serio->dev,
726 : "Failed to enable keyboard on %s\n",
727 : ps2dev->serio->phys);
728 0 : return -1;
729 : }
730 :
731 : return 0;
732 : }
733 :
734 : /*
735 : * atkbd_deactivate() resets and disables the keyboard from sending
736 : * keystrokes.
737 : */
738 :
739 0 : static void atkbd_deactivate(struct atkbd *atkbd)
740 : {
741 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
742 :
743 0 : if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_DIS))
744 0 : dev_err(&ps2dev->serio->dev,
745 : "Failed to deactivate keyboard on %s\n",
746 : ps2dev->serio->phys);
747 0 : }
748 :
749 : /*
750 : * atkbd_probe() probes for an AT keyboard on a serio port.
751 : */
752 :
753 0 : static int atkbd_probe(struct atkbd *atkbd)
754 : {
755 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
756 : unsigned char param[2];
757 :
758 : /*
759 : * Some systems, where the bit-twiddling when testing the io-lines of the
760 : * controller may confuse the keyboard need a full reset of the keyboard. On
761 : * these systems the BIOS also usually doesn't do it for us.
762 : */
763 :
764 0 : if (atkbd_reset)
765 0 : if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
766 0 : dev_warn(&ps2dev->serio->dev,
767 : "keyboard reset failed on %s\n",
768 : ps2dev->serio->phys);
769 :
770 : /*
771 : * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
772 : * Some keyboards report different values, but the first byte is always 0xab or
773 : * 0xac. Some old AT keyboards don't report anything. If a mouse is connected, this
774 : * should make sure we don't try to set the LEDs on it.
775 : */
776 :
777 0 : param[0] = param[1] = 0xa5; /* initialize with invalid values */
778 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_GETID)) {
779 :
780 : /*
781 : * If the get ID command failed, we check if we can at least set the LEDs on
782 : * the keyboard. This should work on every keyboard out there. It also turns
783 : * the LEDs off, which we want anyway.
784 : */
785 0 : param[0] = 0;
786 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
787 : return -1;
788 0 : atkbd->id = 0xabba;
789 0 : return 0;
790 : }
791 :
792 0 : if (!ps2_is_keyboard_id(param[0]))
793 : return -1;
794 :
795 0 : atkbd->id = (param[0] << 8) | param[1];
796 :
797 0 : if (atkbd->id == 0xaca1 && atkbd->translated) {
798 0 : dev_err(&ps2dev->serio->dev,
799 : "NCD terminal keyboards are only supported on non-translating controllers. "
800 : "Use i8042.direct=1 to disable translation.\n");
801 0 : return -1;
802 : }
803 :
804 : /*
805 : * Make sure nothing is coming from the keyboard and disturbs our
806 : * internal state.
807 : */
808 0 : if (!atkbd_skip_deactivate)
809 0 : atkbd_deactivate(atkbd);
810 :
811 : return 0;
812 : }
813 :
814 : /*
815 : * atkbd_select_set checks if a keyboard has a working Set 3 support, and
816 : * sets it into that. Unfortunately there are keyboards that can be switched
817 : * to Set 3, but don't work well in that (BTC Multimedia ...)
818 : */
819 :
820 0 : static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
821 : {
822 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
823 : unsigned char param[2];
824 :
825 0 : atkbd->extra = false;
826 : /*
827 : * For known special keyboards we can go ahead and set the correct set.
828 : * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
829 : * IBM RapidAccess / IBM EzButton / Chicony KBP-8993 keyboards.
830 : */
831 :
832 0 : if (atkbd->translated)
833 : return 2;
834 :
835 0 : if (atkbd->id == 0xaca1) {
836 0 : param[0] = 3;
837 0 : ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
838 0 : return 3;
839 : }
840 :
841 0 : if (allow_extra) {
842 0 : param[0] = 0x71;
843 0 : if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
844 0 : atkbd->extra = true;
845 0 : return 2;
846 : }
847 : }
848 :
849 0 : if (atkbd_terminal) {
850 0 : ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MB);
851 0 : return 3;
852 : }
853 :
854 0 : if (target_set != 3)
855 : return 2;
856 :
857 0 : if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
858 0 : atkbd->id = param[0] << 8 | param[1];
859 0 : return 2;
860 : }
861 :
862 0 : param[0] = 3;
863 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
864 : return 2;
865 :
866 0 : param[0] = 0;
867 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
868 : return 2;
869 :
870 0 : if (param[0] != 3) {
871 0 : param[0] = 2;
872 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
873 : return 2;
874 : }
875 :
876 0 : ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
877 :
878 0 : return 3;
879 : }
880 :
881 0 : static int atkbd_reset_state(struct atkbd *atkbd)
882 : {
883 0 : struct ps2dev *ps2dev = &atkbd->ps2dev;
884 : unsigned char param[1];
885 :
886 : /*
887 : * Set the LEDs to a predefined state (all off).
888 : */
889 :
890 0 : param[0] = 0;
891 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
892 : return -1;
893 :
894 : /*
895 : * Set autorepeat to fastest possible.
896 : */
897 :
898 0 : param[0] = 0;
899 0 : if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
900 : return -1;
901 :
902 0 : return 0;
903 : }
904 :
905 : /*
906 : * atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
907 : * reboot.
908 : */
909 :
910 0 : static void atkbd_cleanup(struct serio *serio)
911 : {
912 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
913 :
914 : atkbd_disable(atkbd);
915 0 : ps2_command(&atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF);
916 0 : }
917 :
918 :
919 : /*
920 : * atkbd_disconnect() closes and frees.
921 : */
922 :
923 0 : static void atkbd_disconnect(struct serio *serio)
924 : {
925 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
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 : atkbd_enable(atkbd);
1275 0 : if (serio->write)
1276 0 : atkbd_activate(atkbd);
1277 :
1278 0 : err = input_register_device(atkbd->dev);
1279 0 : if (err)
1280 : goto fail3;
1281 :
1282 : return 0;
1283 :
1284 0 : fail3: serio_close(serio);
1285 : fail2: serio_set_drvdata(serio, NULL);
1286 0 : fail1: input_free_device(dev);
1287 0 : kfree(atkbd);
1288 0 : return err;
1289 : }
1290 :
1291 : /*
1292 : * atkbd_reconnect() tries to restore keyboard into a sane state and is
1293 : * most likely called on resume.
1294 : */
1295 :
1296 0 : static int atkbd_reconnect(struct serio *serio)
1297 : {
1298 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
1299 0 : struct serio_driver *drv = serio->drv;
1300 0 : int retval = -1;
1301 :
1302 0 : if (!atkbd || !drv) {
1303 : dev_dbg(&serio->dev,
1304 : "reconnect request, but serio is disconnected, ignoring...\n");
1305 : return -1;
1306 : }
1307 :
1308 0 : mutex_lock(&atkbd->mutex);
1309 :
1310 : atkbd_disable(atkbd);
1311 :
1312 0 : if (atkbd->write) {
1313 0 : if (atkbd_probe(atkbd))
1314 : goto out;
1315 :
1316 0 : if (atkbd->set != atkbd_select_set(atkbd, atkbd->set, atkbd->extra))
1317 : goto out;
1318 :
1319 : /*
1320 : * Restore LED state and repeat rate. While input core
1321 : * will do this for us at resume time reconnect may happen
1322 : * because user requested it via sysfs or simply because
1323 : * keyboard was unplugged and plugged in again so we need
1324 : * to do it ourselves here.
1325 : */
1326 0 : atkbd_set_leds(atkbd);
1327 0 : if (!atkbd->softrepeat)
1328 0 : atkbd_set_repeat_rate(atkbd);
1329 :
1330 : }
1331 :
1332 : /*
1333 : * Reset our state machine in case reconnect happened in the middle
1334 : * of multi-byte scancode.
1335 : */
1336 0 : atkbd->xl_bit = 0;
1337 0 : atkbd->emul = 0;
1338 :
1339 : atkbd_enable(atkbd);
1340 0 : if (atkbd->write)
1341 0 : atkbd_activate(atkbd);
1342 :
1343 : retval = 0;
1344 :
1345 : out:
1346 0 : mutex_unlock(&atkbd->mutex);
1347 0 : return retval;
1348 : }
1349 :
1350 : static const struct serio_device_id atkbd_serio_ids[] = {
1351 : {
1352 : .type = SERIO_8042,
1353 : .proto = SERIO_ANY,
1354 : .id = SERIO_ANY,
1355 : .extra = SERIO_ANY,
1356 : },
1357 : {
1358 : .type = SERIO_8042_XL,
1359 : .proto = SERIO_ANY,
1360 : .id = SERIO_ANY,
1361 : .extra = SERIO_ANY,
1362 : },
1363 : {
1364 : .type = SERIO_RS232,
1365 : .proto = SERIO_PS2SER,
1366 : .id = SERIO_ANY,
1367 : .extra = SERIO_ANY,
1368 : },
1369 : { 0 }
1370 : };
1371 :
1372 : MODULE_DEVICE_TABLE(serio, atkbd_serio_ids);
1373 :
1374 : static struct serio_driver atkbd_drv = {
1375 : .driver = {
1376 : .name = "atkbd",
1377 : .dev_groups = atkbd_attribute_groups,
1378 : },
1379 : .description = DRIVER_DESC,
1380 : .id_table = atkbd_serio_ids,
1381 : .interrupt = atkbd_interrupt,
1382 : .connect = atkbd_connect,
1383 : .reconnect = atkbd_reconnect,
1384 : .disconnect = atkbd_disconnect,
1385 : .cleanup = atkbd_cleanup,
1386 : };
1387 :
1388 : static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
1389 : ssize_t (*handler)(struct atkbd *, char *))
1390 : {
1391 0 : struct serio *serio = to_serio_port(dev);
1392 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
1393 :
1394 0 : return handler(atkbd, buf);
1395 : }
1396 :
1397 0 : static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
1398 : ssize_t (*handler)(struct atkbd *, const char *, size_t))
1399 : {
1400 0 : struct serio *serio = to_serio_port(dev);
1401 0 : struct atkbd *atkbd = serio_get_drvdata(serio);
1402 : int retval;
1403 :
1404 0 : retval = mutex_lock_interruptible(&atkbd->mutex);
1405 0 : if (retval)
1406 0 : return retval;
1407 :
1408 : atkbd_disable(atkbd);
1409 0 : retval = handler(atkbd, buf, count);
1410 : atkbd_enable(atkbd);
1411 :
1412 0 : mutex_unlock(&atkbd->mutex);
1413 :
1414 0 : return retval;
1415 : }
1416 :
1417 0 : static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1418 : {
1419 0 : return sprintf(buf, "%d\n", atkbd->extra ? 1 : 0);
1420 : }
1421 :
1422 0 : static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)
1423 : {
1424 : struct input_dev *old_dev, *new_dev;
1425 : unsigned int value;
1426 : int err;
1427 : bool old_extra;
1428 : unsigned char old_set;
1429 :
1430 0 : if (!atkbd->write)
1431 : return -EIO;
1432 :
1433 0 : err = kstrtouint(buf, 10, &value);
1434 0 : if (err)
1435 0 : return err;
1436 :
1437 0 : if (value > 1)
1438 : return -EINVAL;
1439 :
1440 0 : if (atkbd->extra != value) {
1441 : /*
1442 : * Since device's properties will change we need to
1443 : * unregister old device. But allocate and register
1444 : * new one first to make sure we have it.
1445 : */
1446 0 : old_dev = atkbd->dev;
1447 0 : old_extra = atkbd->extra;
1448 0 : old_set = atkbd->set;
1449 :
1450 0 : new_dev = input_allocate_device();
1451 0 : if (!new_dev)
1452 : return -ENOMEM;
1453 :
1454 0 : atkbd->dev = new_dev;
1455 0 : atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);
1456 0 : atkbd_reset_state(atkbd);
1457 0 : atkbd_activate(atkbd);
1458 0 : atkbd_set_keycode_table(atkbd);
1459 0 : atkbd_set_device_attrs(atkbd);
1460 :
1461 0 : err = input_register_device(atkbd->dev);
1462 0 : if (err) {
1463 0 : input_free_device(new_dev);
1464 :
1465 0 : atkbd->dev = old_dev;
1466 0 : atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1467 0 : atkbd_set_keycode_table(atkbd);
1468 0 : atkbd_set_device_attrs(atkbd);
1469 :
1470 0 : return err;
1471 : }
1472 0 : input_unregister_device(old_dev);
1473 :
1474 : }
1475 0 : return count;
1476 : }
1477 :
1478 0 : static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
1479 : {
1480 0 : size_t len = scnprintf(buf, PAGE_SIZE - 1, "%*pbl",
1481 0 : ATKBD_KEYMAP_SIZE, atkbd->force_release_mask);
1482 :
1483 0 : buf[len++] = '\n';
1484 0 : buf[len] = '\0';
1485 :
1486 0 : return len;
1487 : }
1488 :
1489 0 : static ssize_t atkbd_set_force_release(struct atkbd *atkbd,
1490 : const char *buf, size_t count)
1491 : {
1492 : /* 64 bytes on stack should be acceptable */
1493 : DECLARE_BITMAP(new_mask, ATKBD_KEYMAP_SIZE);
1494 : int err;
1495 :
1496 0 : err = bitmap_parselist(buf, new_mask, ATKBD_KEYMAP_SIZE);
1497 0 : if (err)
1498 0 : return err;
1499 :
1500 0 : memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1501 0 : return count;
1502 : }
1503 :
1504 :
1505 0 : static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1506 : {
1507 0 : return sprintf(buf, "%d\n", atkbd->scroll ? 1 : 0);
1508 : }
1509 :
1510 0 : static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)
1511 : {
1512 : struct input_dev *old_dev, *new_dev;
1513 : unsigned int value;
1514 : int err;
1515 : bool old_scroll;
1516 :
1517 0 : err = kstrtouint(buf, 10, &value);
1518 0 : if (err)
1519 0 : return err;
1520 :
1521 0 : if (value > 1)
1522 : return -EINVAL;
1523 :
1524 0 : if (atkbd->scroll != value) {
1525 0 : old_dev = atkbd->dev;
1526 0 : old_scroll = atkbd->scroll;
1527 :
1528 0 : new_dev = input_allocate_device();
1529 0 : if (!new_dev)
1530 : return -ENOMEM;
1531 :
1532 0 : atkbd->dev = new_dev;
1533 0 : atkbd->scroll = value;
1534 0 : atkbd_set_keycode_table(atkbd);
1535 0 : atkbd_set_device_attrs(atkbd);
1536 :
1537 0 : err = input_register_device(atkbd->dev);
1538 0 : if (err) {
1539 0 : input_free_device(new_dev);
1540 :
1541 0 : atkbd->scroll = old_scroll;
1542 0 : atkbd->dev = old_dev;
1543 0 : atkbd_set_keycode_table(atkbd);
1544 0 : atkbd_set_device_attrs(atkbd);
1545 :
1546 0 : return err;
1547 : }
1548 0 : input_unregister_device(old_dev);
1549 : }
1550 0 : return count;
1551 : }
1552 :
1553 0 : static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1554 : {
1555 0 : return sprintf(buf, "%d\n", atkbd->set);
1556 : }
1557 :
1558 0 : static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
1559 : {
1560 : struct input_dev *old_dev, *new_dev;
1561 : unsigned int value;
1562 : int err;
1563 : unsigned char old_set;
1564 : bool old_extra;
1565 :
1566 0 : if (!atkbd->write)
1567 : return -EIO;
1568 :
1569 0 : err = kstrtouint(buf, 10, &value);
1570 0 : if (err)
1571 0 : return err;
1572 :
1573 0 : if (value != 2 && value != 3)
1574 : return -EINVAL;
1575 :
1576 0 : if (atkbd->set != value) {
1577 0 : old_dev = atkbd->dev;
1578 0 : old_extra = atkbd->extra;
1579 0 : old_set = atkbd->set;
1580 :
1581 0 : new_dev = input_allocate_device();
1582 0 : if (!new_dev)
1583 : return -ENOMEM;
1584 :
1585 0 : atkbd->dev = new_dev;
1586 0 : atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);
1587 0 : atkbd_reset_state(atkbd);
1588 0 : atkbd_activate(atkbd);
1589 0 : atkbd_set_keycode_table(atkbd);
1590 0 : atkbd_set_device_attrs(atkbd);
1591 :
1592 0 : err = input_register_device(atkbd->dev);
1593 0 : if (err) {
1594 0 : input_free_device(new_dev);
1595 :
1596 0 : atkbd->dev = old_dev;
1597 0 : atkbd->set = atkbd_select_set(atkbd, old_set, old_extra);
1598 0 : atkbd_set_keycode_table(atkbd);
1599 0 : atkbd_set_device_attrs(atkbd);
1600 :
1601 0 : return err;
1602 : }
1603 0 : input_unregister_device(old_dev);
1604 : }
1605 0 : return count;
1606 : }
1607 :
1608 0 : static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1609 : {
1610 0 : return sprintf(buf, "%d\n", atkbd->softrepeat ? 1 : 0);
1611 : }
1612 :
1613 0 : static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)
1614 : {
1615 : struct input_dev *old_dev, *new_dev;
1616 : unsigned int value;
1617 : int err;
1618 : bool old_softrepeat, old_softraw;
1619 :
1620 0 : if (!atkbd->write)
1621 : return -EIO;
1622 :
1623 0 : err = kstrtouint(buf, 10, &value);
1624 0 : if (err)
1625 0 : return err;
1626 :
1627 0 : if (value > 1)
1628 : return -EINVAL;
1629 :
1630 0 : if (atkbd->softrepeat != value) {
1631 0 : old_dev = atkbd->dev;
1632 0 : old_softrepeat = atkbd->softrepeat;
1633 0 : old_softraw = atkbd->softraw;
1634 :
1635 0 : new_dev = input_allocate_device();
1636 0 : if (!new_dev)
1637 : return -ENOMEM;
1638 :
1639 0 : atkbd->dev = new_dev;
1640 0 : atkbd->softrepeat = value;
1641 0 : if (atkbd->softrepeat)
1642 0 : atkbd->softraw = true;
1643 0 : atkbd_set_device_attrs(atkbd);
1644 :
1645 0 : err = input_register_device(atkbd->dev);
1646 0 : if (err) {
1647 0 : input_free_device(new_dev);
1648 :
1649 0 : atkbd->dev = old_dev;
1650 0 : atkbd->softrepeat = old_softrepeat;
1651 0 : atkbd->softraw = old_softraw;
1652 0 : atkbd_set_device_attrs(atkbd);
1653 :
1654 0 : return err;
1655 : }
1656 0 : input_unregister_device(old_dev);
1657 : }
1658 0 : return count;
1659 : }
1660 :
1661 :
1662 0 : static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1663 : {
1664 0 : return sprintf(buf, "%d\n", atkbd->softraw ? 1 : 0);
1665 : }
1666 :
1667 0 : static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)
1668 : {
1669 : struct input_dev *old_dev, *new_dev;
1670 : unsigned int value;
1671 : int err;
1672 : bool old_softraw;
1673 :
1674 0 : err = kstrtouint(buf, 10, &value);
1675 0 : if (err)
1676 0 : return err;
1677 :
1678 0 : if (value > 1)
1679 : return -EINVAL;
1680 :
1681 0 : if (atkbd->softraw != value) {
1682 0 : old_dev = atkbd->dev;
1683 0 : old_softraw = atkbd->softraw;
1684 :
1685 0 : new_dev = input_allocate_device();
1686 0 : if (!new_dev)
1687 : return -ENOMEM;
1688 :
1689 0 : atkbd->dev = new_dev;
1690 0 : atkbd->softraw = value;
1691 0 : atkbd_set_device_attrs(atkbd);
1692 :
1693 0 : err = input_register_device(atkbd->dev);
1694 0 : if (err) {
1695 0 : input_free_device(new_dev);
1696 :
1697 0 : atkbd->dev = old_dev;
1698 0 : atkbd->softraw = old_softraw;
1699 0 : atkbd_set_device_attrs(atkbd);
1700 :
1701 0 : return err;
1702 : }
1703 0 : input_unregister_device(old_dev);
1704 : }
1705 0 : return count;
1706 : }
1707 :
1708 0 : static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1709 : {
1710 0 : return sprintf(buf, "%lu\n", atkbd->err_count);
1711 : }
1712 :
1713 : static int __init atkbd_setup_forced_release(const struct dmi_system_id *id)
1714 : {
1715 : atkbd_platform_fixup = atkbd_apply_forced_release_keylist;
1716 : atkbd_platform_fixup_data = id->driver_data;
1717 :
1718 : return 1;
1719 : }
1720 :
1721 : static int __init atkbd_setup_scancode_fixup(const struct dmi_system_id *id)
1722 : {
1723 : atkbd_platform_scancode_fixup = id->driver_data;
1724 :
1725 : return 1;
1726 : }
1727 :
1728 : static int __init atkbd_deactivate_fixup(const struct dmi_system_id *id)
1729 : {
1730 : atkbd_skip_deactivate = true;
1731 : return 1;
1732 : }
1733 :
1734 : /*
1735 : * NOTE: do not add any more "force release" quirks to this table. The
1736 : * task of adjusting list of keys that should be "released" automatically
1737 : * by the driver is now delegated to userspace tools, such as udev, so
1738 : * submit such quirks there.
1739 : */
1740 : static const struct dmi_system_id atkbd_dmi_quirk_table[] __initconst = {
1741 : {
1742 : .matches = {
1743 : DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1744 : DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1745 : },
1746 : .callback = atkbd_setup_forced_release,
1747 : .driver_data = atkbd_dell_laptop_forced_release_keys,
1748 : },
1749 : {
1750 : .matches = {
1751 : DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
1752 : DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */
1753 : },
1754 : .callback = atkbd_setup_forced_release,
1755 : .driver_data = atkbd_dell_laptop_forced_release_keys,
1756 : },
1757 : {
1758 : .matches = {
1759 : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1760 : DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
1761 : },
1762 : .callback = atkbd_setup_forced_release,
1763 : .driver_data = atkbd_hp_forced_release_keys,
1764 : },
1765 : {
1766 : .matches = {
1767 : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1768 : DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion ZV6100"),
1769 : },
1770 : .callback = atkbd_setup_forced_release,
1771 : .driver_data = atkbd_volume_forced_release_keys,
1772 : },
1773 : {
1774 : .matches = {
1775 : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1776 : DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4000"),
1777 : },
1778 : .callback = atkbd_setup_forced_release,
1779 : .driver_data = atkbd_volume_forced_release_keys,
1780 : },
1781 : {
1782 : .matches = {
1783 : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1784 : DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4100"),
1785 : },
1786 : .callback = atkbd_setup_forced_release,
1787 : .driver_data = atkbd_volume_forced_release_keys,
1788 : },
1789 : {
1790 : .matches = {
1791 : DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1792 : DMI_MATCH(DMI_PRODUCT_NAME, "Presario R4200"),
1793 : },
1794 : .callback = atkbd_setup_forced_release,
1795 : .driver_data = atkbd_volume_forced_release_keys,
1796 : },
1797 : {
1798 : /* Inventec Symphony */
1799 : .matches = {
1800 : DMI_MATCH(DMI_SYS_VENDOR, "INVENTEC"),
1801 : DMI_MATCH(DMI_PRODUCT_NAME, "SYMPHONY 6.0/7.0"),
1802 : },
1803 : .callback = atkbd_setup_forced_release,
1804 : .driver_data = atkbd_volume_forced_release_keys,
1805 : },
1806 : {
1807 : /* Samsung NC10 */
1808 : .matches = {
1809 : DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1810 : DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
1811 : },
1812 : .callback = atkbd_setup_forced_release,
1813 : .driver_data = atkbd_samsung_forced_release_keys,
1814 : },
1815 : {
1816 : /* Samsung NC20 */
1817 : .matches = {
1818 : DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1819 : DMI_MATCH(DMI_PRODUCT_NAME, "NC20"),
1820 : },
1821 : .callback = atkbd_setup_forced_release,
1822 : .driver_data = atkbd_samsung_forced_release_keys,
1823 : },
1824 : {
1825 : /* Samsung SQ45S70S */
1826 : .matches = {
1827 : DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1828 : DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
1829 : },
1830 : .callback = atkbd_setup_forced_release,
1831 : .driver_data = atkbd_samsung_forced_release_keys,
1832 : },
1833 : {
1834 : /* Fujitsu Amilo PA 1510 */
1835 : .matches = {
1836 : DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1837 : DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 1510"),
1838 : },
1839 : .callback = atkbd_setup_forced_release,
1840 : .driver_data = atkbd_volume_forced_release_keys,
1841 : },
1842 : {
1843 : /* Fujitsu Amilo Pi 3525 */
1844 : .matches = {
1845 : DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1846 : DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pi 3525"),
1847 : },
1848 : .callback = atkbd_setup_forced_release,
1849 : .driver_data = atkbd_amilo_pi3525_forced_release_keys,
1850 : },
1851 : {
1852 : /* Fujitsu Amilo Xi 3650 */
1853 : .matches = {
1854 : DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
1855 : DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 3650"),
1856 : },
1857 : .callback = atkbd_setup_forced_release,
1858 : .driver_data = atkbd_amilo_xi3650_forced_release_keys,
1859 : },
1860 : {
1861 : .matches = {
1862 : DMI_MATCH(DMI_SYS_VENDOR, "Soltech Corporation"),
1863 : DMI_MATCH(DMI_PRODUCT_NAME, "TA12"),
1864 : },
1865 : .callback = atkbd_setup_forced_release,
1866 : .driver_data = atkdb_soltech_ta12_forced_release_keys,
1867 : },
1868 : {
1869 : /* OQO Model 01+ */
1870 : .matches = {
1871 : DMI_MATCH(DMI_SYS_VENDOR, "OQO"),
1872 : DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"),
1873 : },
1874 : .callback = atkbd_setup_scancode_fixup,
1875 : .driver_data = atkbd_oqo_01plus_scancode_fixup,
1876 : },
1877 : {
1878 : .matches = {
1879 : DMI_MATCH(DMI_SYS_VENDOR, "LG Electronics"),
1880 : },
1881 : .callback = atkbd_deactivate_fixup,
1882 : },
1883 : { }
1884 : };
1885 :
1886 1 : static int __init atkbd_init(void)
1887 : {
1888 1 : dmi_check_system(atkbd_dmi_quirk_table);
1889 :
1890 1 : return serio_register_driver(&atkbd_drv);
1891 : }
1892 :
1893 0 : static void __exit atkbd_exit(void)
1894 : {
1895 0 : serio_unregister_driver(&atkbd_drv);
1896 0 : }
1897 :
1898 : module_init(atkbd_init);
1899 : module_exit(atkbd_exit);
|
