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