git.sur5r.net Git - u-boot/blob - drivers/input/cros_ec_keyb.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Chromium OS Matrix Keyboard
   4  *
   5  * Copyright (c) 2012 The Chromium OS Authors.
   6  */
   7
   8 #include <common.h>
   9 #include <cros_ec.h>
  10 #include <dm.h>
  11 #include <errno.h>
  12 #include <input.h>
  13 #include <keyboard.h>
  14 #include <key_matrix.h>
  15 #include <stdio_dev.h>
  16
  17 enum {
  18         KBC_MAX_KEYS            = 8,    /* Maximum keys held down at once */
  19         KBC_REPEAT_RATE_MS      = 30,
  20         KBC_REPEAT_DELAY_MS     = 240,
  21 };
  22
  23 struct cros_ec_keyb_priv {
  24         struct input_config *input;     /* The input layer */
  25         struct key_matrix matrix;       /* The key matrix layer */
  26         int key_rows;                   /* Number of keyboard rows */
  27         int key_cols;                   /* Number of keyboard columns */
  28         int ghost_filter;               /* 1 to enable ghost filter, else 0 */
  29 };
  30
  31
  32 /**
  33  * Check the keyboard controller and return a list of key matrix positions
  34  * for which a key is pressed
  35  *
  36  * @param dev           Keyboard device
  37  * @param keys          List of keys that we have detected
  38  * @param max_count     Maximum number of keys to return
  39  * @param samep         Set to true if this scan repeats the last, else false
  40  * @return number of pressed keys, 0 for none, -EIO on error
  41  */
  42 static int check_for_keys(struct udevice *dev, struct key_matrix_key *keys,
  43                           int max_count, bool *samep)
  44 {
  45         struct cros_ec_keyb_priv *priv = dev_get_priv(dev);
  46         struct key_matrix_key *key;
  47         static struct mbkp_keyscan last_scan;
  48         static bool last_scan_valid;
  49         struct mbkp_keyscan scan;
  50         unsigned int row, col, bit, data;
  51         int num_keys;
  52
  53         if (cros_ec_scan_keyboard(dev->parent, &scan)) {
  54                 debug("%s: keyboard scan failed\n", __func__);
  55                 return -EIO;
  56         }
  57         *samep = last_scan_valid && !memcmp(&last_scan, &scan, sizeof(scan));
  58
  59         /*
  60          * This is a bit odd. The EC has no way to tell us that it has run
  61          * out of key scans. It just returns the same scan over and over
  62          * again. So the only way to detect that we have run out is to detect
  63          * that this scan is the same as the last.
  64          */
  65         last_scan_valid = true;
  66         memcpy(&last_scan, &scan, sizeof(last_scan));
  67
  68         for (col = num_keys = bit = 0; col < priv->matrix.num_cols;
  69                         col++) {
  70                 for (row = 0; row < priv->matrix.num_rows; row++) {
  71                         unsigned int mask = 1 << (bit & 7);
  72
  73                         data = scan.data[bit / 8];
  74                         if ((data & mask) && num_keys < max_count) {
  75                                 key = keys + num_keys++;
  76                                 key->row = row;
  77                                 key->col = col;
  78                                 key->valid = 1;
  79                         }
  80                         bit++;
  81                 }
  82         }
  83
  84         return num_keys;
  85 }
  86
  87 /**
  88  * Check the keyboard, and send any keys that are pressed.
  89  *
  90  * This is called by input_tstc() and input_getc() when they need more
  91  * characters
  92  *
  93  * @param input         Input configuration
  94  * @return 1, to indicate that we have something to look at
  95  */
  96 int cros_ec_kbc_check(struct input_config *input)
  97 {
  98         struct udevice *dev = input->dev;
  99         struct cros_ec_keyb_priv *priv = dev_get_priv(dev);
 100         static struct key_matrix_key last_keys[KBC_MAX_KEYS];
 101         static int last_num_keys;
 102         struct key_matrix_key keys[KBC_MAX_KEYS];
 103         int keycodes[KBC_MAX_KEYS];
 104         int num_keys, num_keycodes;
 105         int irq_pending, sent;
 106         bool same = false;
 107
 108         /*
 109          * Loop until the EC has no more keyscan records, or we have
 110          * received at least one character. This means we know that tstc()
 111          * will always return non-zero if keys have been pressed.
 112          *
 113          * Without this loop, a key release (which generates no new ascii
 114          * characters) will cause us to exit this function, and just tstc()
 115          * may return 0 before all keys have been read from the EC.
 116          */
 117         do {
 118                 irq_pending = cros_ec_interrupt_pending(dev->parent);
 119                 if (irq_pending) {
 120                         num_keys = check_for_keys(dev, keys, KBC_MAX_KEYS,
 121                                                   &same);
 122                         if (num_keys < 0)
 123                                 return 0;
 124                         last_num_keys = num_keys;
 125                         memcpy(last_keys, keys, sizeof(keys));
 126                 } else {
 127                         /*
 128                          * EC doesn't want to be asked, so use keys from last
 129                          * time.
 130                          */
 131                         num_keys = last_num_keys;
 132                         memcpy(keys, last_keys, sizeof(keys));
 133                 }
 134
 135                 if (num_keys < 0)
 136                         return -1;
 137                 num_keycodes = key_matrix_decode(&priv->matrix, keys,
 138                                 num_keys, keycodes, KBC_MAX_KEYS);
 139                 sent = input_send_keycodes(input, keycodes, num_keycodes);
 140
 141                 /*
 142                  * For those ECs without an interrupt, stop scanning when we
 143                  * see that the scan is the same as last time.
 144                  */
 145                 if ((irq_pending < 0) && same)
 146                         break;
 147         } while (irq_pending && !sent);
 148
 149         return 1;
 150 }
 151
 152 /**
 153  * Decode MBKP keyboard details from the device tree
 154  *
 155  * @param blob          Device tree blob
 156  * @param node          Node to decode from
 157  * @param config        Configuration data read from fdt
 158  * @return 0 if ok, -1 on error
 159  */
 160 static int cros_ec_keyb_decode_fdt(struct udevice *dev,
 161                                    struct cros_ec_keyb_priv *config)
 162 {
 163         /*
 164          * Get keyboard rows and columns - at present we are limited to
 165          * 8 columns by the protocol (one byte per row scan)
 166          */
 167         config->key_rows = dev_read_u32_default(dev, "keypad,num-rows", 0);
 168         config->key_cols = dev_read_u32_default(dev, "keypad,num-columns", 0);
 169         if (!config->key_rows || !config->key_cols ||
 170                         config->key_rows * config->key_cols / 8
 171                                 > CROS_EC_KEYSCAN_COLS) {
 172                 debug("%s: Invalid key matrix size %d x %d\n", __func__,
 173                       config->key_rows, config->key_cols);
 174                 return -1;
 175         }
 176         config->ghost_filter = dev_read_bool(dev, "google,needs-ghost-filter");
 177
 178         return 0;
 179 }
 180
 181 static int cros_ec_kbd_probe(struct udevice *dev)
 182 {
 183         struct cros_ec_keyb_priv *priv = dev_get_priv(dev);
 184         struct keyboard_priv *uc_priv = dev_get_uclass_priv(dev);
 185         struct stdio_dev *sdev = &uc_priv->sdev;
 186         struct input_config *input = &uc_priv->input;
 187         int ret;
 188
 189         ret = cros_ec_keyb_decode_fdt(dev, priv);
 190         if (ret) {
 191                 debug("%s: Cannot decode node (ret=%d)\n", __func__, ret);
 192                 return -EINVAL;
 193         }
 194         input_set_delays(input, KBC_REPEAT_DELAY_MS, KBC_REPEAT_RATE_MS);
 195         ret = key_matrix_init(&priv->matrix, priv->key_rows, priv->key_cols,
 196                               priv->ghost_filter);
 197         if (ret) {
 198                 debug("%s: cannot init key matrix\n", __func__);
 199                 return ret;
 200         }
 201         ret = key_matrix_decode_fdt(dev, &priv->matrix);
 202         if (ret) {
 203                 debug("%s: Could not decode key matrix from fdt\n", __func__);
 204                 return ret;
 205         }
 206         debug("%s: Matrix keyboard %dx%d ready\n", __func__, priv->key_rows,
 207               priv->key_cols);
 208
 209         priv->input = input;
 210         input->dev = dev;
 211         input_add_tables(input, false);
 212         input->read_keys = cros_ec_kbc_check;
 213         strcpy(sdev->name, "cros-ec-keyb");
 214
 215         /* Register the device. cros_ec_init_keyboard() will be called soon */
 216         return input_stdio_register(sdev);
 217 }
 218
 219 static const struct keyboard_ops cros_ec_kbd_ops = {
 220 };
 221
 222 static const struct udevice_id cros_ec_kbd_ids[] = {
 223         { .compatible = "google,cros-ec-keyb" },
 224         { }
 225 };
 226
 227 U_BOOT_DRIVER(cros_ec_kbd) = {
 228         .name   = "cros_ec_kbd",
 229         .id     = UCLASS_KEYBOARD,
 230         .of_match = cros_ec_kbd_ids,
 231         .probe = cros_ec_kbd_probe,
 232         .ops    = &cros_ec_kbd_ops,
 233         .priv_auto_alloc_size = sizeof(struct cros_ec_keyb_priv),
 234 };