Tom Rini | 83d290c | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 2 | /* |
| 3 | * (C) Copyright 2002 ELTEC Elektronik AG |
| 4 | * Frank Gottschling <fgottschling@eltec.de> |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 5 | */ |
| 6 | |
| 7 | /* i8042.c - Intel 8042 keyboard driver routines */ |
| 8 | |
Simon Glass | d8062e9 | 2023-05-04 16:54:56 -0600 | [diff] [blame] | 9 | #define LOG_CATEGORY UCLASS_KEYBOARD |
| 10 | |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 11 | #include <common.h> |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 12 | #include <dm.h> |
Simon Glass | 7b51b57 | 2019-08-01 09:46:52 -0600 | [diff] [blame] | 13 | #include <env.h> |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 14 | #include <errno.h> |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 15 | #include <i8042.h> |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 16 | #include <input.h> |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 17 | #include <keyboard.h> |
Simon Glass | f7ae49f | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 18 | #include <log.h> |
Simon Glass | 401d1c4 | 2020-10-30 21:38:53 -0600 | [diff] [blame] | 19 | #include <asm/global_data.h> |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 20 | #include <asm/io.h> |
Simon Glass | c05ed00 | 2020-05-10 11:40:11 -0600 | [diff] [blame] | 21 | #include <linux/delay.h> |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 22 | |
Simon Glass | 011d89d | 2015-11-11 10:05:46 -0700 | [diff] [blame] | 23 | DECLARE_GLOBAL_DATA_PTR; |
| 24 | |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 25 | /* defines */ |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 26 | #define in8(p) inb(p) |
| 27 | #define out8(p, v) outb(v, p) |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 28 | |
Simon Glass | 011d89d | 2015-11-11 10:05:46 -0700 | [diff] [blame] | 29 | enum { |
| 30 | QUIRK_DUP_POR = 1 << 0, |
| 31 | }; |
| 32 | |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 33 | /* locals */ |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 34 | struct i8042_kbd_priv { |
| 35 | bool extended; /* true if an extended keycode is expected next */ |
Simon Glass | 011d89d | 2015-11-11 10:05:46 -0700 | [diff] [blame] | 36 | int quirks; /* quirks that we support */ |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 37 | }; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 38 | |
Gabe Black | dd4a5b2 | 2011-11-14 19:24:14 +0000 | [diff] [blame] | 39 | static 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 | }; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 58 | |
Simon Glass | d8062e9 | 2023-05-04 16:54:56 -0600 | [diff] [blame] | 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 | */ |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 67 | static int kbd_input_empty(void) |
| 68 | { |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 69 | int kbd_timeout = KBD_TIMEOUT * 1000; |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 70 | |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 71 | while ((in8(I8042_STS_REG) & STATUS_IBF) && kbd_timeout--) |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 72 | udelay(1); |
| 73 | |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 74 | return kbd_timeout != -1; |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 75 | } |
| 76 | |
Simon Glass | d8062e9 | 2023-05-04 16:54:56 -0600 | [diff] [blame] | 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 | */ |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 83 | static int kbd_output_full(void) |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 84 | { |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 85 | int kbd_timeout = KBD_TIMEOUT * 1000; |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 86 | |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 87 | while (((in8(I8042_STS_REG) & STATUS_OBF) == 0) && kbd_timeout--) |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 88 | udelay(1); |
| 89 | |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 90 | return kbd_timeout != -1; |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 91 | } |
| 92 | |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 93 | /** |
| 94 | * check_leds() - Check the keyboard LEDs and update them it needed |
| 95 | * |
| 96 | * @ret: Value to return |
Heinrich Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 97 | * Return: value of @ret |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 98 | */ |
| 99 | static int i8042_kbd_update_leds(struct udevice *dev, int leds) |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 100 | { |
| 101 | kbd_input_empty(); |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 102 | out8(I8042_DATA_REG, CMD_SET_KBD_LED); |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 103 | kbd_input_empty(); |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 104 | out8(I8042_DATA_REG, leds & 0x7); |
| 105 | |
| 106 | return 0; |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 107 | } |
| 108 | |
Simon Glass | 31d38ee | 2015-10-18 21:17:19 -0600 | [diff] [blame] | 109 | static 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 | |
| 118 | static int kbd_read(int reg) |
| 119 | { |
| 120 | if (!kbd_output_full()) |
| 121 | return -1; |
| 122 | |
| 123 | return in8(reg); |
| 124 | } |
| 125 | |
| 126 | static 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 | |
| 134 | static 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 | |
Simon Glass | 011d89d | 2015-11-11 10:05:46 -0700 | [diff] [blame] | 142 | static int kbd_reset(int quirk) |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 143 | { |
Simon Glass | 31d38ee | 2015-10-18 21:17:19 -0600 | [diff] [blame] | 144 | int config; |
Bin Meng | 7d96166 | 2015-08-24 01:00:06 -0700 | [diff] [blame] | 145 | |
Simon Glass | d8062e9 | 2023-05-04 16:54:56 -0600 | [diff] [blame] | 146 | if (!kbd_input_empty()) |
| 147 | goto err; |
| 148 | |
Bin Meng | 7d96166 | 2015-08-24 01:00:06 -0700 | [diff] [blame] | 149 | /* controller self test */ |
Simon Glass | 31d38ee | 2015-10-18 21:17:19 -0600 | [diff] [blame] | 150 | if (kbd_cmd_read(CMD_SELF_TEST) != KBC_TEST_OK) |
Simon Glass | 4f087ba | 2015-10-18 21:17:20 -0600 | [diff] [blame] | 151 | goto err; |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 152 | |
Bin Meng | 7d96166 | 2015-08-24 01:00:06 -0700 | [diff] [blame] | 153 | /* keyboard reset */ |
Simon Glass | 31d38ee | 2015-10-18 21:17:19 -0600 | [diff] [blame] | 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) |
Simon Glass | 4f087ba | 2015-10-18 21:17:20 -0600 | [diff] [blame] | 157 | goto err; |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 158 | |
Simon Glass | 8226a3e | 2016-03-11 22:06:50 -0700 | [diff] [blame] | 159 | if (kbd_write(I8042_DATA_REG, CMD_DRAIN_OUTPUT) || |
| 160 | kbd_read(I8042_DATA_REG) != KBD_ACK) |
| 161 | goto err; |
| 162 | |
Bin Meng | 7d96166 | 2015-08-24 01:00:06 -0700 | [diff] [blame] | 163 | /* set AT translation and disable irq */ |
Simon Glass | 31d38ee | 2015-10-18 21:17:19 -0600 | [diff] [blame] | 164 | config = kbd_cmd_read(CMD_RD_CONFIG); |
| 165 | if (config == -1) |
Simon Glass | 4f087ba | 2015-10-18 21:17:20 -0600 | [diff] [blame] | 166 | goto err; |
Simon Glass | 31d38ee | 2015-10-18 21:17:19 -0600 | [diff] [blame] | 167 | |
Simon Glass | 011d89d | 2015-11-11 10:05:46 -0700 | [diff] [blame] | 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 | |
Tom Rini | b21f965 | 2021-08-19 14:58:00 -0400 | [diff] [blame] | 172 | config |= CFG_AT_TRANS; |
| 173 | config &= ~(CFG_KIRQ_EN | CFG_MIRQ_EN); |
Simon Glass | 31d38ee | 2015-10-18 21:17:19 -0600 | [diff] [blame] | 174 | if (kbd_cmd_write(CMD_WR_CONFIG, config)) |
Simon Glass | 4f087ba | 2015-10-18 21:17:20 -0600 | [diff] [blame] | 175 | goto err; |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 176 | |
Bin Meng | 7d96166 | 2015-08-24 01:00:06 -0700 | [diff] [blame] | 177 | /* enable keyboard */ |
Simon Glass | 31d38ee | 2015-10-18 21:17:19 -0600 | [diff] [blame] | 178 | if (kbd_write(I8042_CMD_REG, CMD_KBD_EN) || |
| 179 | !kbd_input_empty()) |
Simon Glass | 4f087ba | 2015-10-18 21:17:20 -0600 | [diff] [blame] | 180 | goto err; |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 181 | |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 182 | return 0; |
Simon Glass | 4f087ba | 2015-10-18 21:17:20 -0600 | [diff] [blame] | 183 | err: |
| 184 | debug("%s: Keyboard failure\n", __func__); |
| 185 | return -1; |
Bin Meng | 3928d66 | 2015-08-24 01:00:04 -0700 | [diff] [blame] | 186 | } |
| 187 | |
Gabe Black | 22e0f5a | 2011-11-14 20:18:12 +0000 | [diff] [blame] | 188 | static int kbd_controller_present(void) |
| 189 | { |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 190 | return in8(I8042_STS_REG) != 0xff; |
Gabe Black | 22e0f5a | 2011-11-14 20:18:12 +0000 | [diff] [blame] | 191 | } |
| 192 | |
Simon Glass | 165be50 | 2018-11-23 21:29:38 -0700 | [diff] [blame] | 193 | /** Flush all buffer from keyboard controller to host*/ |
| 194 | static void i8042_flush(void) |
Louis Yung-Chieh Lo | 45fe668 | 2012-10-11 15:15:51 +0000 | [diff] [blame] | 195 | { |
| 196 | int timeout; |
| 197 | |
| 198 | /* |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 199 | * The delay is to give the keyboard controller some time |
| 200 | * to fill the next byte. |
Louis Yung-Chieh Lo | 45fe668 | 2012-10-11 15:15:51 +0000 | [diff] [blame] | 201 | */ |
| 202 | while (1) { |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 203 | timeout = 100; /* wait for no longer than 100us */ |
| 204 | while (timeout > 0 && !(in8(I8042_STS_REG) & STATUS_OBF)) { |
Louis Yung-Chieh Lo | 45fe668 | 2012-10-11 15:15:51 +0000 | [diff] [blame] | 205 | udelay(1); |
| 206 | timeout--; |
| 207 | } |
| 208 | |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 209 | /* Try to pull next byte if not timeout */ |
| 210 | if (in8(I8042_STS_REG) & STATUS_OBF) |
Louis Yung-Chieh Lo | 45fe668 | 2012-10-11 15:15:51 +0000 | [diff] [blame] | 211 | in8(I8042_DATA_REG); |
| 212 | else |
| 213 | break; |
| 214 | } |
| 215 | } |
| 216 | |
Simon Glass | 165be50 | 2018-11-23 21:29:38 -0700 | [diff] [blame] | 217 | /** |
| 218 | * Disables the keyboard so that key strokes no longer generate scancodes to |
| 219 | * the host. |
| 220 | * |
Heinrich Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 221 | * Return: 0 if ok, -1 if keyboard input was found while disabling |
Simon Glass | 165be50 | 2018-11-23 21:29:38 -0700 | [diff] [blame] | 222 | */ |
| 223 | static int i8042_disable(void) |
Louis Yung-Chieh Lo | 45fe668 | 2012-10-11 15:15:51 +0000 | [diff] [blame] | 224 | { |
| 225 | if (kbd_input_empty() == 0) |
| 226 | return -1; |
| 227 | |
| 228 | /* Disable keyboard */ |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 229 | out8(I8042_CMD_REG, CMD_KBD_DIS); |
Louis Yung-Chieh Lo | 45fe668 | 2012-10-11 15:15:51 +0000 | [diff] [blame] | 230 | |
| 231 | if (kbd_input_empty() == 0) |
| 232 | return -1; |
| 233 | |
| 234 | return 0; |
| 235 | } |
| 236 | |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 237 | static int i8042_kbd_check(struct input_config *input) |
| 238 | { |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 239 | struct i8042_kbd_priv *priv = dev_get_priv(input->dev); |
| 240 | |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 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) { |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 252 | priv->extended = true; |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 253 | return 0; |
| 254 | } |
| 255 | if (scan_code & 0x80) { |
| 256 | scan_code &= 0x7f; |
| 257 | release = true; |
| 258 | } |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 259 | if (priv->extended) { |
| 260 | priv->extended = false; |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 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 | |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 272 | input_add_keycode(input, scan_code, release); |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 273 | return 1; |
| 274 | } |
| 275 | } |
| 276 | |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 277 | /* i8042_kbd_init - reset keyboard and init state flags */ |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 278 | static int i8042_start(struct udevice *dev) |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 279 | { |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 280 | struct keyboard_priv *uc_priv = dev_get_uclass_priv(dev); |
Simon Glass | 011d89d | 2015-11-11 10:05:46 -0700 | [diff] [blame] | 281 | struct i8042_kbd_priv *priv = dev_get_priv(dev); |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 282 | struct input_config *input = &uc_priv->input; |
Gabe Black | dd4a5b2 | 2011-11-14 19:24:14 +0000 | [diff] [blame] | 283 | int keymap, try; |
| 284 | char *penv; |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 285 | int ret; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 286 | |
Simon Glass | 165be50 | 2018-11-23 21:29:38 -0700 | [diff] [blame] | 287 | if (!kbd_controller_present()) { |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 288 | debug("i8042 keyboard controller is not present\n"); |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 289 | return -ENOENT; |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 290 | } |
Gabe Black | 22e0f5a | 2011-11-14 20:18:12 +0000 | [diff] [blame] | 291 | |
Gabe Black | dd4a5b2 | 2011-11-14 19:24:14 +0000 | [diff] [blame] | 292 | /* Init keyboard device (default US layout) */ |
| 293 | keymap = KBD_US; |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 294 | penv = env_get("keymap"); |
Gabe Black | dd4a5b2 | 2011-11-14 19:24:14 +0000 | [diff] [blame] | 295 | if (penv != NULL) { |
| 296 | if (strncmp(penv, "de", 3) == 0) |
| 297 | keymap = KBD_GER; |
| 298 | } |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 299 | |
Simon Glass | 011d89d | 2015-11-11 10:05:46 -0700 | [diff] [blame] | 300 | for (try = 0; kbd_reset(priv->quirks) != 0; try++) { |
Simon Glass | c5d257f | 2015-10-18 21:17:21 -0600 | [diff] [blame] | 301 | if (try >= KBD_RESET_TRIES) |
| 302 | return -1; |
Gabe Black | dd4a5b2 | 2011-11-14 19:24:14 +0000 | [diff] [blame] | 303 | } |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 304 | |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 305 | ret = input_add_tables(input, keymap == KBD_GER); |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 306 | if (ret) |
| 307 | return ret; |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 308 | |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 309 | i8042_kbd_update_leds(dev, NORMAL); |
| 310 | debug("%s: started\n", __func__); |
Simon Glass | c5d257f | 2015-10-18 21:17:21 -0600 | [diff] [blame] | 311 | |
| 312 | return 0; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 313 | } |
| 314 | |
Simon Glass | 165be50 | 2018-11-23 21:29:38 -0700 | [diff] [blame] | 315 | static 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 | |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 324 | /** |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 325 | * Set up the i8042 keyboard. This is called by the stdio device handler |
Bin Meng | 835dd00 | 2015-08-24 01:00:05 -0700 | [diff] [blame] | 326 | * |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 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 | * |
Heinrich Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 334 | * Return: 0 if ok, -ve on error |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 335 | */ |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 336 | static int i8042_kbd_probe(struct udevice *dev) |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 337 | { |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 338 | struct keyboard_priv *uc_priv = dev_get_uclass_priv(dev); |
Simon Glass | 011d89d | 2015-11-11 10:05:46 -0700 | [diff] [blame] | 339 | struct i8042_kbd_priv *priv = dev_get_priv(dev); |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 340 | struct stdio_dev *sdev = &uc_priv->sdev; |
| 341 | struct input_config *input = &uc_priv->input; |
| 342 | int ret; |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 343 | |
Simon Glass | e160f7d | 2017-01-17 16:52:55 -0700 | [diff] [blame] | 344 | if (fdtdec_get_bool(gd->fdt_blob, dev_of_offset(dev), |
Simon Glass | 011d89d | 2015-11-11 10:05:46 -0700 | [diff] [blame] | 345 | "intel,duplicate-por")) |
| 346 | priv->quirks |= QUIRK_DUP_POR; |
| 347 | |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 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__); |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 359 | |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 360 | return 0; |
Simon Glass | 2ec739d | 2015-11-11 10:05:41 -0700 | [diff] [blame] | 361 | } |
| 362 | |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 363 | static const struct keyboard_ops i8042_kbd_ops = { |
| 364 | .start = i8042_start, |
| 365 | .update_leds = i8042_kbd_update_leds, |
| 366 | }; |
wdenk | c609719 | 2002-11-03 00:24:07 +0000 | [diff] [blame] | 367 | |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 368 | static const struct udevice_id i8042_kbd_ids[] = { |
| 369 | { .compatible = "intel,i8042-keyboard" }, |
| 370 | { } |
| 371 | }; |
| 372 | |
| 373 | U_BOOT_DRIVER(i8042_kbd) = { |
| 374 | .name = "i8042_kbd", |
| 375 | .id = UCLASS_KEYBOARD, |
| 376 | .of_match = i8042_kbd_ids, |
| 377 | .probe = i8042_kbd_probe, |
Simon Glass | 165be50 | 2018-11-23 21:29:38 -0700 | [diff] [blame] | 378 | .remove = i8042_kbd_remove, |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 379 | .ops = &i8042_kbd_ops, |
Simon Glass | 41575d8 | 2020-12-03 16:55:17 -0700 | [diff] [blame] | 380 | .priv_auto = sizeof(struct i8042_kbd_priv), |
Simon Glass | dcbf825 | 2015-11-11 10:05:45 -0700 | [diff] [blame] | 381 | }; |