drivers/input/i8042.c

   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 <common.h>
  12 #include <dm.h>
  13 #include <env.h>
  14 #include <errno.h>
  15 #include <i8042.h>
  16 #include <input.h>
  17 #include <keyboard.h>
  18 #include <log.h>
  19 #include <asm/global_data.h>
  20 #include <asm/io.h>
  21 #include <linux/delay.h>
  22
  23 DECLARE_GLOBAL_DATA_PTR;
  24
  25 /* defines */
  26 #define in8(p)          inb(p)
  27 #define out8(p, v)      outb(v, p)
  28
  29 enum {
  30         QUIRK_DUP_POR   = 1 << 0,
  31 };
  32
  33 /* locals */
  34 struct i8042_kbd_priv {
  35         bool extended;  /* true if an extended keycode is expected next */
  36         int quirks;     /* quirks that we support */
  37 };
  38
  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         };
  58
  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  */
  67 static int kbd_input_empty(void)
  68 {
  69         int kbd_timeout = KBD_TIMEOUT * 1000;
  70
  71         while ((in8(I8042_STS_REG) & STATUS_IBF) && kbd_timeout--)
  72                 udelay(1);
  73
  74         return kbd_timeout != -1;
  75 }
  76
  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  */
  83 static int kbd_output_full(void)
  84 {
  85         int kbd_timeout = KBD_TIMEOUT * 1000;
  86
  87         while (((in8(I8042_STS_REG) & STATUS_OBF) == 0) && kbd_timeout--)
  88                 udelay(1);
  89
  90         return kbd_timeout != -1;
  91 }
  92
  93 /**
  94  * check_leds() - Check the keyboard LEDs and update them it needed
  95  *
  96  * @ret:        Value to return
  97  * Return: value of @ret
  98  */
  99 static int i8042_kbd_update_leds(struct udevice *dev, int leds)
 100 {
 101         kbd_input_empty();
 102         out8(I8042_DATA_REG, CMD_SET_KBD_LED);
 103         kbd_input_empty();
 104         out8(I8042_DATA_REG, leds & 0x7);
 105
 106         return 0;
 107 }
 108
 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
 142 static int kbd_reset(int quirk)
 143 {
 144         int config;
 145
 146         if (!kbd_input_empty())
 147                 goto err;
 148
 149         /* controller self test */
 150         if (kbd_cmd_read(CMD_SELF_TEST) != KBC_TEST_OK)
 151                 goto err;
 152
 153         /* keyboard reset */
 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)
 157                 goto err;
 158
 159         if (kbd_write(I8042_DATA_REG, CMD_DRAIN_OUTPUT) ||
 160             kbd_read(I8042_DATA_REG) != KBD_ACK)
 161                 goto err;
 162
 163         /* set AT translation and disable irq */
 164         config = kbd_cmd_read(CMD_RD_CONFIG);
 165         if (config == -1)
 166                 goto err;
 167
 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
 172         config |= CFG_AT_TRANS;
 173         config &= ~(CFG_KIRQ_EN | CFG_MIRQ_EN);
 174         if (kbd_cmd_write(CMD_WR_CONFIG, config))
 175                 goto err;
 176
 177         /* enable keyboard */
 178         if (kbd_write(I8042_CMD_REG, CMD_KBD_EN) ||
 179             !kbd_input_empty())
 180                 goto err;
 181
 182         return 0;
 183 err:
 184         debug("%s: Keyboard failure\n", __func__);
 185         return -1;
 186 }
 187
 188 static int kbd_controller_present(void)
 189 {
 190         return in8(I8042_STS_REG) != 0xff;
 191 }
 192
 193 /** Flush all buffer from keyboard controller to host*/
 194 static void i8042_flush(void)
 195 {
 196         int timeout;
 197
 198         /*
 199          * The delay is to give the keyboard controller some time
 200          * to fill the next byte.
 201          */
 202         while (1) {
 203                 timeout = 100;  /* wait for no longer than 100us */
 204                 while (timeout > 0 && !(in8(I8042_STS_REG) & STATUS_OBF)) {
 205                         udelay(1);
 206                         timeout--;
 207                 }
 208
 209                 /* Try to pull next byte if not timeout */
 210                 if (in8(I8042_STS_REG) & STATUS_OBF)
 211                         in8(I8042_DATA_REG);
 212                 else
 213                         break;
 214         }
 215 }
 216
 217 /**
 218  * Disables the keyboard so that key strokes no longer generate scancodes to
 219  * the host.
 220  *
 221  * Return: 0 if ok, -1 if keyboard input was found while disabling
 222  */
 223 static int i8042_disable(void)
 224 {
 225         if (kbd_input_empty() == 0)
 226                 return -1;
 227
 228         /* Disable keyboard */
 229         out8(I8042_CMD_REG, CMD_KBD_DIS);
 230
 231         if (kbd_input_empty() == 0)
 232                 return -1;
 233
 234         return 0;
 235 }
 236
 237 static int i8042_kbd_check(struct input_config *input)
 238 {
 239         struct i8042_kbd_priv *priv = dev_get_priv(input->dev);
 240
 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) {
 252                         priv->extended = true;
 253                         return 0;
 254                 }
 255                 if (scan_code & 0x80) {
 256                         scan_code &= 0x7f;
 257                         release = true;
 258                 }
 259                 if (priv->extended) {
 260                         priv->extended = false;
 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
 272                 input_add_keycode(input, scan_code, release);
 273                 return 1;
 274         }
 275 }
 276
 277 /* i8042_kbd_init - reset keyboard and init state flags */
 278 static int i8042_start(struct udevice *dev)
 279 {
 280         struct keyboard_priv *uc_priv = dev_get_uclass_priv(dev);
 281         struct i8042_kbd_priv *priv = dev_get_priv(dev);
 282         struct input_config *input = &uc_priv->input;
 283         int keymap, try;
 284         char *penv;
 285         int ret;
 286
 287         if (!kbd_controller_present()) {
 288                 debug("i8042 keyboard controller is not present\n");
 289                 return -ENOENT;
 290         }
 291
 292         /* Init keyboard device (default US layout) */
 293         keymap = KBD_US;
 294         penv = env_get("keymap");
 295         if (penv != NULL) {
 296                 if (strncmp(penv, "de", 3) == 0)
 297                         keymap = KBD_GER;
 298         }
 299
 300         for (try = 0; kbd_reset(priv->quirks) != 0; try++) {
 301                 if (try >= KBD_RESET_TRIES)
 302                         return -1;
 303         }
 304
 305         ret = input_add_tables(input, keymap == KBD_GER);
 306         if (ret)
 307                 return ret;
 308
 309         i8042_kbd_update_leds(dev, NORMAL);
 310         debug("%s: started\n", __func__);
 311
 312         return 0;
 313 }
 314
 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
 324 /**
 325  * Set up the i8042 keyboard. This is called by the stdio device handler
 326  *
 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  *
 334  * Return: 0 if ok, -ve on error
 335  */
 336 static int i8042_kbd_probe(struct udevice *dev)
 337 {
 338         struct keyboard_priv *uc_priv = dev_get_uclass_priv(dev);
 339         struct i8042_kbd_priv *priv = dev_get_priv(dev);
 340         struct stdio_dev *sdev = &uc_priv->sdev;
 341         struct input_config *input = &uc_priv->input;
 342         int ret;
 343
 344         if (fdtdec_get_bool(gd->fdt_blob, dev_of_offset(dev),
 345                             "intel,duplicate-por"))
 346                 priv->quirks |= QUIRK_DUP_POR;
 347
 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__);
 359
 360         return 0;
 361 }
 362
 363 static const struct keyboard_ops i8042_kbd_ops = {
 364         .start  = i8042_start,
 365         .update_leds    = i8042_kbd_update_leds,
 366 };
 367
 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,
 378         .remove = i8042_kbd_remove,
 379         .ops    = &i8042_kbd_ops,
 380         .priv_auto      = sizeof(struct i8042_kbd_priv),
 381 };