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