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