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