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