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