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 #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
  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
  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  */
  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
  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
  99 static int kbd_read(int reg)
 100 {
 101         if (!kbd_output_full())
 102                 return -1;
 103
 104         return in8(reg);
 105 }
 106
 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
 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
 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
 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*/
 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  */
 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
 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 */
 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
 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  */
 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 };