1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * (C) Copyright 2002 ELTEC Elektronik AG
4 * Frank Gottschling <fgottschling@eltec.de>
5 */
6
7/* i8042.c - Intel 8042 keyboard driver routines */
8
9#define LOG_CATEGORY UCLASS_KEYBOARD
10
11#include <common.h>
12#include <dm.h>
13#include <env.h>
14#include <errno.h>
15#include <i8042.h>
16#include <input.h>
17#include <keyboard.h>
18#include <log.h>
19#include <asm/global_data.h>
20#include <asm/io.h>
21#include <linux/delay.h>
22
23DECLARE_GLOBAL_DATA_PTR;
24
25/* defines */
26#define in8(p)		inb(p)
27#define out8(p, v)	outb(v, p)
28
29enum {
30	QUIRK_DUP_POR	= 1 << 0,
31};
32
33/* locals */
34struct i8042_kbd_priv {
35	bool extended;	/* true if an extended keycode is expected next */
36	int quirks;	/* quirks that we support */
37};
38
39static unsigned char ext_key_map[] = {
40	0x1c, /* keypad enter */
41	0x1d, /* right control */
42	0x35, /* keypad slash */
43	0x37, /* print screen */
44	0x38, /* right alt */
45	0x46, /* break */
46	0x47, /* editpad home */
47	0x48, /* editpad up */
48	0x49, /* editpad pgup */
49	0x4b, /* editpad left */
50	0x4d, /* editpad right */
51	0x4f, /* editpad end */
52	0x50, /* editpad dn */
53	0x51, /* editpad pgdn */
54	0x52, /* editpad ins */
55	0x53, /* editpad del */
56	0x00  /* map end */
57	};
58
59/**
60 * kbd_input_empty() - Wait until the keyboard is ready for a command
61 *
62 * Checks the IBF flag (input buffer full), waiting for it to indicate that
63 * any previous command has been processed.
64 *
65 * Return: true if ready, false if it timed out
66 */
67static int kbd_input_empty(void)
68{
69	int kbd_timeout = KBD_TIMEOUT * 1000;
70
71	while ((in8(I8042_STS_REG) & STATUS_IBF) && kbd_timeout--)
72		udelay(1);
73
74	return kbd_timeout != -1;
75}
76
77/**
78 * kbd_output_full() - Wait until the keyboard has data available
79 *
80 * Checks the OBF flag (output buffer full), waiting for it to indicate that
81 * a response to a previous command is available
82 */
83static int kbd_output_full(void)
84{
85	int kbd_timeout = KBD_TIMEOUT * 1000;
86
87	while (((in8(I8042_STS_REG) & STATUS_OBF) == 0) && kbd_timeout--)
88		udelay(1);
89
90	return kbd_timeout != -1;
91}
92
93/**
94 * check_leds() - Check the keyboard LEDs and update them it needed
95 *
96 * @ret:	Value to return
97 * Return: value of @ret
98 */
99static int i8042_kbd_update_leds(struct udevice *dev, int leds)
100{
101	kbd_input_empty();
102	out8(I8042_DATA_REG, CMD_SET_KBD_LED);
103	kbd_input_empty();
104	out8(I8042_DATA_REG, leds & 0x7);
105
106	return 0;
107}
108
109static int kbd_write(int reg, int value)
110{
111	if (!kbd_input_empty())
112		return -1;
113	out8(reg, value);
114
115	return 0;
116}
117
118static int kbd_read(int reg)
119{
120	if (!kbd_output_full())
121		return -1;
122
123	return in8(reg);
124}
125
126static int kbd_cmd_read(int cmd)
127{
128	if (kbd_write(I8042_CMD_REG, cmd))
129		return -1;
130
131	return kbd_read(I8042_DATA_REG);
132}
133
134static int kbd_cmd_write(int cmd, int data)
135{
136	if (kbd_write(I8042_CMD_REG, cmd))
137		return -1;
138
139	return kbd_write(I8042_DATA_REG, data);
140}
141
142static int kbd_reset(int quirk)
143{
144	int config;
145
146	if (!kbd_input_empty())
147		goto err;
148
149	/* controller self test */
150	if (kbd_cmd_read(CMD_SELF_TEST) != KBC_TEST_OK)
151		goto err;
152
153	/* keyboard reset */
154	if (kbd_write(I8042_DATA_REG, CMD_RESET_KBD) ||
155	    kbd_read(I8042_DATA_REG) != KBD_ACK ||
156	    kbd_read(I8042_DATA_REG) != KBD_POR)
157		goto err;
158
159	if (kbd_write(I8042_DATA_REG, CMD_DRAIN_OUTPUT) ||
160	    kbd_read(I8042_DATA_REG) != KBD_ACK)
161		goto err;
162
163	/* set AT translation and disable irq */
164	config = kbd_cmd_read(CMD_RD_CONFIG);
165	if (config == -1)
166		goto err;
167
168	/* Sometimes get a second byte */
169	else if ((quirk & QUIRK_DUP_POR) && config == KBD_POR)
170		config = kbd_cmd_read(CMD_RD_CONFIG);
171
172	config |= CFG_AT_TRANS;
173	config &= ~(CFG_KIRQ_EN | CFG_MIRQ_EN);
174	if (kbd_cmd_write(CMD_WR_CONFIG, config))
175		goto err;
176
177	/* enable keyboard */
178	if (kbd_write(I8042_CMD_REG, CMD_KBD_EN) ||
179	    !kbd_input_empty())
180		goto err;
181
182	return 0;
183err:
184	debug("%s: Keyboard failure\n", __func__);
185	return -1;
186}
187
188static int kbd_controller_present(void)
189{
190	return in8(I8042_STS_REG) != 0xff;
191}
192
193/** Flush all buffer from keyboard controller to host*/
194static void i8042_flush(void)
195{
196	int timeout;
197
198	/*
199	 * The delay is to give the keyboard controller some time
200	 * to fill the next byte.
201	 */
202	while (1) {
203		timeout = 100;	/* wait for no longer than 100us */
204		while (timeout > 0 && !(in8(I8042_STS_REG) & STATUS_OBF)) {
205			udelay(1);
206			timeout--;
207		}
208
209		/* Try to pull next byte if not timeout */
210		if (in8(I8042_STS_REG) & STATUS_OBF)
211			in8(I8042_DATA_REG);
212		else
213			break;
214	}
215}
216
217/**
218 * Disables the keyboard so that key strokes no longer generate scancodes to
219 * the host.
220 *
221 * Return: 0 if ok, -1 if keyboard input was found while disabling
222 */
223static int i8042_disable(void)
224{
225	if (kbd_input_empty() == 0)
226		return -1;
227
228	/* Disable keyboard */
229	out8(I8042_CMD_REG, CMD_KBD_DIS);
230
231	if (kbd_input_empty() == 0)
232		return -1;
233
234	return 0;
235}
236
237static int i8042_kbd_check(struct input_config *input)
238{
239	struct i8042_kbd_priv *priv = dev_get_priv(input->dev);
240
241	if ((in8(I8042_STS_REG) & STATUS_OBF) == 0) {
242		return 0;
243	} else {
244		bool release = false;
245		int scan_code;
246		int i;
247
248		scan_code = in8(I8042_DATA_REG);
249		if (scan_code == 0xfa) {
250			return 0;
251		} else if (scan_code == 0xe0) {
252			priv->extended = true;
253			return 0;
254		}
255		if (scan_code & 0x80) {
256			scan_code &= 0x7f;
257			release = true;
258		}
259		if (priv->extended) {
260			priv->extended = false;
261			for (i = 0; ext_key_map[i]; i++) {
262				if (ext_key_map[i] == scan_code) {
263					scan_code = 0x60 + i;
264					break;
265				}
266			}
267			/* not found ? */
268			if (!ext_key_map[i])
269				return 0;
270		}
271
272		input_add_keycode(input, scan_code, release);
273		return 1;
274	}
275}
276
277/* i8042_kbd_init - reset keyboard and init state flags */
278static int i8042_start(struct udevice *dev)
279{
280	struct keyboard_priv *uc_priv = dev_get_uclass_priv(dev);
281	struct i8042_kbd_priv *priv = dev_get_priv(dev);
282	struct input_config *input = &uc_priv->input;
283	int keymap, try;
284	char *penv;
285	int ret;
286
287	if (!kbd_controller_present()) {
288		debug("i8042 keyboard controller is not present\n");
289		return -ENOENT;
290	}
291
292	/* Init keyboard device (default US layout) */
293	keymap = KBD_US;
294	penv = env_get("keymap");
295	if (penv != NULL) {
296		if (strncmp(penv, "de", 3) == 0)
297			keymap = KBD_GER;
298	}
299
300	for (try = 0; kbd_reset(priv->quirks) != 0; try++) {
301		if (try >= KBD_RESET_TRIES)
302			return -1;
303	}
304
305	ret = input_add_tables(input, keymap == KBD_GER);
306	if (ret)
307		return ret;
308
309	i8042_kbd_update_leds(dev, NORMAL);
310	debug("%s: started\n", __func__);
311
312	return 0;
313}
314
315static int i8042_kbd_remove(struct udevice *dev)
316{
317	if (i8042_disable())
318		log_debug("i8042_disable() failed. fine, continue.\n");
319	i8042_flush();
320
321	return 0;
322}
323
324/**
325 * Set up the i8042 keyboard. This is called by the stdio device handler
326 *
327 * We want to do this init when the keyboard is actually used rather than
328 * at start-up, since keyboard input may not currently be selected.
329 *
330 * Once the keyboard starts there will be a period during which we must
331 * wait for the keyboard to init. We do this only when a key is first
332 * read - see kbd_wait_for_fifo_init().
333 *
334 * Return: 0 if ok, -ve on error
335 */
336static int i8042_kbd_probe(struct udevice *dev)
337{
338	struct keyboard_priv *uc_priv = dev_get_uclass_priv(dev);
339	struct i8042_kbd_priv *priv = dev_get_priv(dev);
340	struct stdio_dev *sdev = &uc_priv->sdev;
341	struct input_config *input = &uc_priv->input;
342	int ret;
343
344	if (fdtdec_get_bool(gd->fdt_blob, dev_of_offset(dev),
345			    "intel,duplicate-por"))
346		priv->quirks |= QUIRK_DUP_POR;
347
348	/* Register the device. i8042_start() will be called soon */
349	input->dev = dev;
350	input->read_keys = i8042_kbd_check;
351	input_allow_repeats(input, true);
352	strcpy(sdev->name, "i8042-kbd");
353	ret = input_stdio_register(sdev);
354	if (ret) {
355		debug("%s: input_stdio_register() failed\n", __func__);
356		return ret;
357	}
358	debug("%s: ready\n", __func__);
359
360	return 0;
361}
362
363static const struct keyboard_ops i8042_kbd_ops = {
364	.start	= i8042_start,
365	.update_leds	= i8042_kbd_update_leds,
366};
367
368static const struct udevice_id i8042_kbd_ids[] = {
369	{ .compatible = "intel,i8042-keyboard" },
370	{ }
371};
372
373U_BOOT_DRIVER(i8042_kbd) = {
374	.name	= "i8042_kbd",
375	.id	= UCLASS_KEYBOARD,
376	.of_match = i8042_kbd_ids,
377	.probe = i8042_kbd_probe,
378	.remove = i8042_kbd_remove,
379	.ops	= &i8042_kbd_ops,
380	.priv_auto	= sizeof(struct i8042_kbd_priv),
381};
382