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	/*
769	* atkbd_probe() probes for an AT keyboard on a serio port.
770	*/
771
772	static int atkbd_probe(struct atkbd *atkbd)
773	{
774	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	if (atkbd_reset)
784	if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
785	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	param[0] = param[1] = 0xa5; /* initialize with invalid values */
797	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	param[0] = 0;
805	if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
806	return -1;
807	atkbd->id = 0xabba;
808	return 0;
809	}
810
811	if (!ps2_is_keyboard_id(id: param[0]))
812	return -1;
813
814	atkbd->id = (param[0] << 8) | param[1];
815
816	if (atkbd->id == 0xaca1 && atkbd->translated) {
817	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	return -1;
821	}
822
823	/*
824	* Make sure nothing is coming from the keyboard and disturbs our
825	* internal state.
826	*/
827	if (!atkbd_skip_deactivate)
828	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	static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra)
840	{
841	struct ps2dev *ps2dev = &atkbd->ps2dev;
842	unsigned char param[2];
843
844	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	if (atkbd->translated)
852	return 2;
853
854	if (atkbd->id == 0xaca1) {
855	param[0] = 3;
856	ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET);
857	return 3;
858	}
859
860	if (allow_extra) {
861	param[0] = 0x71;
862	if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
863	atkbd->extra = true;
864	return 2;
865	}
866	}
867
868	if (atkbd_terminal) {
869	ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MB);
870	return 3;
871	}
872
873	if (target_set != 3)
874	return 2;
875
876	if (!ps2_command(ps2dev, param, ATKBD_CMD_OK_GETID)) {
877	atkbd->id = param[0] << 8 | param[1];
878	return 2;
879	}
880
881	param[0] = 3;
882	if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
883	return 2;
884
885	param[0] = 0;
886	if (ps2_command(ps2dev, param, ATKBD_CMD_GSCANSET))
887	return 2;
888
889	if (param[0] != 3) {
890	param[0] = 2;
891	if (ps2_command(ps2dev, param, ATKBD_CMD_SSCANSET))
892	return 2;
893	}
894
895	ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MBR);
896
897	return 3;
898	}
899
900	static int atkbd_reset_state(struct atkbd *atkbd)
901	{
902	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	param[0] = 0;
910	if (ps2_command(ps2dev, param, ATKBD_CMD_SETLEDS))
911	return -1;
912
913	/*
914	* Set autorepeat to fastest possible.
915	*/
916
917	param[0] = 0;
918	if (ps2_command(ps2dev, param, ATKBD_CMD_SETREP))
919	return -1;
920
921	return 0;
922	}
923
924	/*
925	* atkbd_cleanup() restores the keyboard state so that BIOS is happy after a
926	* reboot.
927	*/
928
929	static void atkbd_cleanup(struct serio *serio)
930	{
931	struct atkbd *atkbd = atkbd_from_serio(serio);
932
933	atkbd_disable(atkbd);
934	ps2_command(ps2dev: &atkbd->ps2dev, NULL, ATKBD_CMD_RESET_DEF);
935	}
936
937
938	/*
939	* atkbd_disconnect() closes and frees.
940	*/
941
942	static void atkbd_disconnect(struct serio *serio)
943	{
944	struct atkbd *atkbd = atkbd_from_serio(serio);
945
946	atkbd_disable(atkbd);
947
948	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	cancel_delayed_work_sync(dwork: &atkbd->event_work);
957
958	serio_close(serio);
959	serio_set_drvdata(serio, NULL);
960	kfree(objp: atkbd);
961	}
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	static int atkbd_get_keymap_from_fwnode(struct atkbd *atkbd)
1046	{
1047	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	n = device_property_count_u32(dev, propname: "linux,keymap");
1054	if (n <= 0 || n > ATKBD_KEYMAP_SIZE)
1055	return -ENXIO;
1056
1057	ptr = kcalloc(n, size: sizeof(u32), GFP_KERNEL);
1058	if (!ptr)
1059	return -ENOMEM;
1060
1061	if (device_property_read_u32_array(dev, propname: "linux,keymap", val: ptr, nval: n)) {
1062	dev_err(dev, "problem parsing FW keymap property\n");
1063	kfree(objp: ptr);
1064	return -EINVAL;
1065	}
1066
1067	memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
1068	for (i = 0; i < n; i++) {
1069	scancode = SCANCODE(ptr[i]);
1070	keycode = KEYCODE(ptr[i]);
1071	atkbd->keycode[scancode] = keycode;
1072	}
1073
1074	kfree(objp: ptr);
1075	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	static void atkbd_set_keycode_table(struct atkbd *atkbd)
1084	{
1085	struct device *dev = &atkbd->ps2dev.serio->dev;
1086	unsigned int scancode;
1087	int i, j;
1088
1089	memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
1090	bitmap_zero(dst: atkbd->force_release_mask, ATKBD_KEYMAP_SIZE);
1091
1092	if (!atkbd_get_keymap_from_fwnode(atkbd)) {
1093	dev_dbg(dev, "Using FW keymap\n");
1094	} else if (atkbd->translated) {
1095	for (i = 0; i < 128; i++) {
1096	scancode = atkbd_unxlate_table[i];
1097	atkbd->keycode[i] = atkbd_set2_keycode[scancode];
1098	atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
1099	if (atkbd->scroll)
1100	for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
1101	if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
1102	atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
1103	}
1104	} else if (atkbd->set == 3) {
1105	memcpy(atkbd->keycode, atkbd_set3_keycode, sizeof(atkbd->keycode));
1106	} else {
1107	memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
1108
1109	if (atkbd->scroll)
1110	for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
1111	scancode = atkbd_scroll_keys[i].set2;
1112	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	scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
1121	atkbd->keycode[scancode] = KEY_HANGEUL;
1122	__set_bit(scancode, atkbd->force_release_mask);
1123
1124	scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
1125	atkbd->keycode[scancode] = KEY_HANJA;
1126	__set_bit(scancode, atkbd->force_release_mask);
1127
1128	/*
1129	* Perform additional fixups
1130	*/
1131	if (atkbd_platform_fixup)
1132	atkbd_platform_fixup(atkbd, atkbd_platform_fixup_data);
1133	}
1134
1135	/*
1136	* atkbd_set_device_attrs() sets up keyboard's input device structure
1137	*/
1138
1139	static void atkbd_set_device_attrs(struct atkbd *atkbd)
1140	{
1141	struct input_dev *input_dev = atkbd->dev;
1142	int i;
1143
1144	if (atkbd->extra)
1145	snprintf(buf: atkbd->name, size: sizeof(atkbd->name),
1146	fmt: "AT Set 2 Extra keyboard");
1147	else
1148	snprintf(buf: atkbd->name, size: sizeof(atkbd->name),
1149	fmt: "AT %s Set %d keyboard",
1150	atkbd->translated ? "Translated" : "Raw", atkbd->set);
1151
1152	snprintf(buf: atkbd->phys, size: sizeof(atkbd->phys),
1153	fmt: "%s/input0", atkbd->ps2dev.serio->phys);
1154
1155	input_dev->name = atkbd->name;
1156	input_dev->phys = atkbd->phys;
1157	input_dev->id.bustype = BUS_I8042;
1158	input_dev->id.vendor = 0x0001;
1159	input_dev->id.product = atkbd->translated ? 1 : atkbd->set;
1160	input_dev->id.version = atkbd->id;
1161	input_dev->event = atkbd_event;
1162	input_dev->dev.parent = &atkbd->ps2dev.serio->dev;
1163
1164	input_set_drvdata(dev: input_dev, data: atkbd);
1165
1166	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
1167	BIT_MASK(EV_MSC);
1168
1169	if (atkbd->write) {
1170	input_dev->evbit[0] |= BIT_MASK(EV_LED);
1171	input_dev->ledbit[0] = BIT_MASK(LED_NUML) |
1172	BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL);
1173	}
1174
1175	if (atkbd->extra)
1176	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	if (!atkbd->softrepeat) {
1181	input_dev->rep[REP_DELAY] = 250;
1182	input_dev->rep[REP_PERIOD] = 33;
1183	}
1184
1185	input_dev->mscbit[0] = atkbd->softraw ? BIT_MASK(MSC_SCAN) :
1186	BIT_MASK(MSC_RAW) | BIT_MASK(MSC_SCAN);
1187
1188	if (atkbd->scroll) {
1189	input_dev->evbit[0] |= BIT_MASK(EV_REL);
1190	input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
1191	BIT_MASK(REL_HWHEEL);
1192	__set_bit(BTN_MIDDLE, input_dev->keybit);
1193	}
1194
1195	input_dev->keycode = atkbd->keycode;
1196	input_dev->keycodesize = sizeof(unsigned short);
1197	input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
1198
1199	for (i = 0; i < ATKBD_KEYMAP_SIZE; i++) {
1200	if (atkbd->keycode[i] != KEY_RESERVED &&
1201	atkbd->keycode[i] != ATKBD_KEY_NULL &&
1202	atkbd->keycode[i] < ATKBD_SPECIAL) {
1203	__set_bit(atkbd->keycode[i], input_dev->keybit);
1204	}
1205	}
1206	}
1207
1208	static void atkbd_parse_fwnode_data(struct serio *serio)
1209	{
1210	struct atkbd *atkbd = atkbd_from_serio(serio);
1211	struct device *dev = &serio->dev;
1212	int n;
1213
1214	/* Parse "function-row-physmap" property */
1215	n = device_property_count_u32(dev, propname: "function-row-physmap");
1216	if (n > 0 && n <= VIVALDI_MAX_FUNCTION_ROW_KEYS &&
1217	!device_property_read_u32_array(dev, propname: "function-row-physmap",
1218	val: atkbd->vdata.function_row_physmap,
1219	nval: n)) {
1220	atkbd->vdata.num_function_row_keys = n;
1221	dev_dbg(dev, "FW reported %d function-row key locations\n", n);
1222	}
1223	}
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	static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
1233	{
1234	struct atkbd *atkbd;
1235	struct input_dev *dev;
1236	int err = -ENOMEM;
1237
1238	atkbd = kzalloc(size: sizeof(struct atkbd), GFP_KERNEL);
1239	dev = input_allocate_device();
1240	if (!atkbd || !dev)
1241	goto fail1;
1242
1243	atkbd->dev = dev;
1244	ps2_init(ps2dev: &atkbd->ps2dev, serio,
1245	pre_receive_handler: atkbd_pre_receive_byte, receive_handler: atkbd_receive_byte);
1246	INIT_DELAYED_WORK(&atkbd->event_work, atkbd_event_work);
1247	mutex_init(&atkbd->mutex);
1248
1249	switch (serio->id.type) {
1250
1251	case SERIO_8042_XL:
1252	atkbd->translated = true;
1253	fallthrough;
1254
1255	case SERIO_8042:
1256	if (serio->write)
1257	atkbd->write = true;
1258	break;
1259	}
1260
1261	atkbd->softraw = atkbd_softraw;
1262	atkbd->softrepeat = atkbd_softrepeat;
1263	atkbd->scroll = atkbd_scroll;
1264
1265	if (atkbd->softrepeat)
1266	atkbd->softraw = true;
1267
1268	serio_set_drvdata(serio, data: atkbd);
1269
1270	err = serio_open(serio, drv);
1271	if (err)
1272	goto fail2;
1273
1274	if (atkbd->write) {
1275
1276	if (atkbd_probe(atkbd)) {
1277	err = -ENODEV;
1278	goto fail3;
1279	}
1280
1281	atkbd->set = atkbd_select_set(atkbd, target_set: atkbd_set, allow_extra: atkbd_extra);
1282	atkbd_reset_state(atkbd);
1283
1284	} else {
1285	atkbd->set = 2;
1286	atkbd->id = 0xab00;
1287	}
1288
1289	atkbd_parse_fwnode_data(serio);
1290
1291	atkbd_set_keycode_table(atkbd);
1292	atkbd_set_device_attrs(atkbd);
1293
1294	atkbd_enable(atkbd);
1295	if (serio->write)
1296	atkbd_activate(atkbd);
1297
1298	err = input_register_device(atkbd->dev);
1299	if (err)
1300	goto fail3;
1301
1302	return 0;
1303
1304	fail3: serio_close(serio);
1305	fail2: serio_set_drvdata(serio, NULL);
1306	fail1: input_free_device(dev);
1307	kfree(objp: atkbd);
1308	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	static int atkbd_reconnect(struct serio *serio)
1317	{
1318	struct atkbd *atkbd = atkbd_from_serio(serio);
1319	struct serio_driver *drv = serio->drv;
1320	int retval = -1;
1321
1322	if (!atkbd || !drv) {
1323	dev_dbg(&serio->dev,
1324	"reconnect request, but serio is disconnected, ignoring...\n");
1325	return -1;
1326	}
1327
1328	mutex_lock(&atkbd->mutex);
1329
1330	atkbd_disable(atkbd);
1331
1332	if (atkbd->write) {
1333	if (atkbd_probe(atkbd))
1334	goto out;
1335
1336	if (atkbd->set != atkbd_select_set(atkbd, target_set: atkbd->set, allow_extra: 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	atkbd_set_leds(atkbd);
1347	if (!atkbd->softrepeat)
1348	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	atkbd->xl_bit = 0;
1357	atkbd->emul = 0;
1358
1359	atkbd_enable(atkbd);
1360	if (atkbd->write)
1361	atkbd_activate(atkbd);
1362
1363	retval = 0;
1364
1365	out:
1366	mutex_unlock(lock: &atkbd->mutex);
1367	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	struct serio *serio = to_serio_port(dev);
1412	struct atkbd *atkbd = atkbd_from_serio(serio);
1413
1414	return handler(atkbd, buf);
1415	}
1416
1417	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	struct serio *serio = to_serio_port(dev);
1421	struct atkbd *atkbd = atkbd_from_serio(serio);
1422	int retval;
1423
1424	retval = mutex_lock_interruptible(&atkbd->mutex);
1425	if (retval)
1426	return retval;
1427
1428	atkbd_disable(atkbd);
1429	retval = handler(atkbd, buf, count);
1430	atkbd_enable(atkbd);
1431
1432	mutex_unlock(lock: &atkbd->mutex);
1433
1434	return retval;
1435	}
1436
1437	static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf)
1438	{
1439	return sprintf(buf, fmt: "%d\n", atkbd->extra ? 1 : 0);
1440	}
1441
1442	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	if (!atkbd->write)
1451	return -EIO;
1452
1453	err = kstrtouint(s: buf, base: 10, res: &value);
1454	if (err)
1455	return err;
1456
1457	if (value > 1)
1458	return -EINVAL;
1459
1460	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	old_dev = atkbd->dev;
1467	old_extra = atkbd->extra;
1468	old_set = atkbd->set;
1469
1470	new_dev = input_allocate_device();
1471	if (!new_dev)
1472	return -ENOMEM;
1473
1474	atkbd->dev = new_dev;
1475	atkbd->set = atkbd_select_set(atkbd, target_set: atkbd->set, allow_extra: value);
1476	atkbd_reset_state(atkbd);
1477	atkbd_activate(atkbd);
1478	atkbd_set_keycode_table(atkbd);
1479	atkbd_set_device_attrs(atkbd);
1480
1481	err = input_register_device(atkbd->dev);
1482	if (err) {
1483	input_free_device(dev: new_dev);
1484
1485	atkbd->dev = old_dev;
1486	atkbd->set = atkbd_select_set(atkbd, target_set: old_set, allow_extra: old_extra);
1487	atkbd_set_keycode_table(atkbd);
1488	atkbd_set_device_attrs(atkbd);
1489
1490	return err;
1491	}
1492	input_unregister_device(old_dev);
1493
1494	}
1495	return count;
1496	}
1497
1498	static ssize_t atkbd_show_force_release(struct atkbd *atkbd, char *buf)
1499	{
1500	size_t len = scnprintf(buf, PAGE_SIZE - 1, fmt: "%*pbl",
1501	ATKBD_KEYMAP_SIZE, atkbd->force_release_mask);
1502
1503	buf[len++] = '\n';
1504	buf[len] = '\0';
1505
1506	return len;
1507	}
1508
1509	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	err = bitmap_parselist(buf, maskp: new_mask, ATKBD_KEYMAP_SIZE);
1517	if (err)
1518	return err;
1519
1520	memcpy(atkbd->force_release_mask, new_mask, sizeof(atkbd->force_release_mask));
1521	return count;
1522	}
1523
1524
1525	static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf)
1526	{
1527	return sprintf(buf, fmt: "%d\n", atkbd->scroll ? 1 : 0);
1528	}
1529
1530	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	err = kstrtouint(s: buf, base: 10, res: &value);
1538	if (err)
1539	return err;
1540
1541	if (value > 1)
1542	return -EINVAL;
1543
1544	if (atkbd->scroll != value) {
1545	old_dev = atkbd->dev;
1546	old_scroll = atkbd->scroll;
1547
1548	new_dev = input_allocate_device();
1549	if (!new_dev)
1550	return -ENOMEM;
1551
1552	atkbd->dev = new_dev;
1553	atkbd->scroll = value;
1554	atkbd_set_keycode_table(atkbd);
1555	atkbd_set_device_attrs(atkbd);
1556
1557	err = input_register_device(atkbd->dev);
1558	if (err) {
1559	input_free_device(dev: new_dev);
1560
1561	atkbd->scroll = old_scroll;
1562	atkbd->dev = old_dev;
1563	atkbd_set_keycode_table(atkbd);
1564	atkbd_set_device_attrs(atkbd);
1565
1566	return err;
1567	}
1568	input_unregister_device(old_dev);
1569	}
1570	return count;
1571	}
1572
1573	static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf)
1574	{
1575	return sprintf(buf, fmt: "%d\n", atkbd->set);
1576	}
1577
1578	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	if (!atkbd->write)
1587	return -EIO;
1588
1589	err = kstrtouint(s: buf, base: 10, res: &value);
1590	if (err)
1591	return err;
1592
1593	if (value != 2 && value != 3)
1594	return -EINVAL;
1595
1596	if (atkbd->set != value) {
1597	old_dev = atkbd->dev;
1598	old_extra = atkbd->extra;
1599	old_set = atkbd->set;
1600
1601	new_dev = input_allocate_device();
1602	if (!new_dev)
1603	return -ENOMEM;
1604
1605	atkbd->dev = new_dev;
1606	atkbd->set = atkbd_select_set(atkbd, target_set: value, allow_extra: atkbd->extra);
1607	atkbd_reset_state(atkbd);
1608	atkbd_activate(atkbd);
1609	atkbd_set_keycode_table(atkbd);
1610	atkbd_set_device_attrs(atkbd);
1611
1612	err = input_register_device(atkbd->dev);
1613	if (err) {
1614	input_free_device(dev: new_dev);
1615
1616	atkbd->dev = old_dev;
1617	atkbd->set = atkbd_select_set(atkbd, target_set: old_set, allow_extra: old_extra);
1618	atkbd_set_keycode_table(atkbd);
1619	atkbd_set_device_attrs(atkbd);
1620
1621	return err;
1622	}
1623	input_unregister_device(old_dev);
1624	}
1625	return count;
1626	}
1627
1628	static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf)
1629	{
1630	return sprintf(buf, fmt: "%d\n", atkbd->softrepeat ? 1 : 0);
1631	}
1632
1633	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	if (!atkbd->write)
1641	return -EIO;
1642
1643	err = kstrtouint(s: buf, base: 10, res: &value);
1644	if (err)
1645	return err;
1646
1647	if (value > 1)
1648	return -EINVAL;
1649
1650	if (atkbd->softrepeat != value) {
1651	old_dev = atkbd->dev;
1652	old_softrepeat = atkbd->softrepeat;
1653	old_softraw = atkbd->softraw;
1654
1655	new_dev = input_allocate_device();
1656	if (!new_dev)
1657	return -ENOMEM;
1658
1659	atkbd->dev = new_dev;
1660	atkbd->softrepeat = value;
1661	if (atkbd->softrepeat)
1662	atkbd->softraw = true;
1663	atkbd_set_device_attrs(atkbd);
1664
1665	err = input_register_device(atkbd->dev);
1666	if (err) {
1667	input_free_device(dev: new_dev);
1668
1669	atkbd->dev = old_dev;
1670	atkbd->softrepeat = old_softrepeat;
1671	atkbd->softraw = old_softraw;
1672	atkbd_set_device_attrs(atkbd);
1673
1674	return err;
1675	}
1676	input_unregister_device(old_dev);
1677	}
1678	return count;
1679	}
1680
1681
1682	static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf)
1683	{
1684	return sprintf(buf, fmt: "%d\n", atkbd->softraw ? 1 : 0);
1685	}
1686
1687	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	err = kstrtouint(s: buf, base: 10, res: &value);
1695	if (err)
1696	return err;
1697
1698	if (value > 1)
1699	return -EINVAL;
1700
1701	if (atkbd->softraw != value) {
1702	old_dev = atkbd->dev;
1703	old_softraw = atkbd->softraw;
1704
1705	new_dev = input_allocate_device();
1706	if (!new_dev)
1707	return -ENOMEM;
1708
1709	atkbd->dev = new_dev;
1710	atkbd->softraw = value;
1711	atkbd_set_device_attrs(atkbd);
1712
1713	err = input_register_device(atkbd->dev);
1714	if (err) {
1715	input_free_device(dev: new_dev);
1716
1717	atkbd->dev = old_dev;
1718	atkbd->softraw = old_softraw;
1719	atkbd_set_device_attrs(atkbd);
1720
1721	return err;
1722	}
1723	input_unregister_device(old_dev);
1724	}
1725	return count;
1726	}
1727
1728	static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
1729	{
1730	return sprintf(buf, fmt: "%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	static int __init atkbd_init(void)
1907	{
1908	dmi_check_system(list: atkbd_dmi_quirk_table);
1909
1910	return serio_register_driver(&atkbd_drv);
1911	}
1912
1913	static void __exit atkbd_exit(void)
1914	{
1915	serio_unregister_driver(drv: &atkbd_drv);
1916	}
1917
1918	module_init(atkbd_init);
1919	module_exit(atkbd_exit);
1920