drivers/input/cros_ec_keyb.c

   1 /*
   2  * Chromium OS Matrix Keyboard
   3  *
   4  * Copyright (c) 2012 The Chromium OS Authors.
   5  *
   6  * SPDX-License-Identifier:     GPL-2.0+
   7  */
   8
   9 #include <common.h>
  10 #include <cros_ec.h>
  11 #include <fdtdec.h>
  12 #include <input.h>
  13 #include <key_matrix.h>
  14 #include <stdio_dev.h>
  15
  16 DECLARE_GLOBAL_DATA_PTR;
  17
  18 enum {
  19         KBC_MAX_KEYS            = 8,    /* Maximum keys held down at once */
  20 };
  21
  22 static struct keyb {
  23         struct cros_ec_dev *dev;                /* The CROS_EC device */
  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         unsigned int repeat_delay_ms;   /* Time before autorepeat starts */
  29         unsigned int repeat_rate_ms;    /* Autorepeat rate in ms */
  30         int ghost_filter;               /* 1 to enable ghost filter, else 0 */
  31         int inited;                     /* 1 if keyboard is ready */
  32 } config;
  33
  34
  35 /**
  36  * Check the keyboard controller and return a list of key matrix positions
  37  * for which a key is pressed
  38  *
  39  * @param config        Keyboard config
  40  * @param keys          List of keys that we have detected
  41  * @param max_count     Maximum number of keys to return
  42  * @return number of pressed keys, 0 for none
  43  */
  44 static int check_for_keys(struct keyb *config,
  45                            struct key_matrix_key *keys, int max_count)
  46 {
  47         struct key_matrix_key *key;
  48         struct mbkp_keyscan scan;
  49         unsigned int row, col, bit, data;
  50         int num_keys;
  51
  52         if (cros_ec_scan_keyboard(config->dev, &scan)) {
  53                 debug("%s: keyboard scan failed\n", __func__);
  54                 return -1;
  55         }
  56
  57         for (col = num_keys = bit = 0; col < config->matrix.num_cols;
  58                         col++) {
  59                 for (row = 0; row < config->matrix.num_rows; row++) {
  60                         unsigned int mask = 1 << (bit & 7);
  61
  62                         data = scan.data[bit / 8];
  63                         if ((data & mask) && num_keys < max_count) {
  64                                 key = keys + num_keys++;
  65                                 key->row = row;
  66                                 key->col = col;
  67                                 key->valid = 1;
  68                         }
  69                         bit++;
  70                 }
  71         }
  72
  73         return num_keys;
  74 }
  75
  76 /**
  77  * Test if keys are available to be read
  78  *
  79  * @return 0 if no keys available, 1 if keys are available
  80  */
  81 static int kbd_tstc(void)
  82 {
  83         /* Just get input to do this for us */
  84         return config.inited ? input_tstc(&config.input) : 0;
  85 }
  86
  87 /**
  88  * Read a key
  89  *
  90  * @return ASCII key code, or 0 if no key, or -1 if error
  91  */
  92 static int kbd_getc(void)
  93 {
  94         /* Just get input to do this for us */
  95         return config.inited ? input_getc(&config.input) : 0;
  96 }
  97
  98 /**
  99  * Check the keyboard, and send any keys that are pressed.
 100  *
 101  * This is called by input_tstc() and input_getc() when they need more
 102  * characters
 103  *
 104  * @param input         Input configuration
 105  * @return 1, to indicate that we have something to look at
 106  */
 107 int cros_ec_kbc_check(struct input_config *input)
 108 {
 109         static struct key_matrix_key last_keys[KBC_MAX_KEYS];
 110         static int last_num_keys;
 111         struct key_matrix_key keys[KBC_MAX_KEYS];
 112         int keycodes[KBC_MAX_KEYS];
 113         int num_keys, num_keycodes;
 114         int irq_pending, sent;
 115
 116         /*
 117          * Loop until the EC has no more keyscan records, or we have
 118          * received at least one character. This means we know that tstc()
 119          * will always return non-zero if keys have been pressed.
 120          *
 121          * Without this loop, a key release (which generates no new ascii
 122          * characters) will cause us to exit this function, and just tstc()
 123          * may return 0 before all keys have been read from the EC.
 124          */
 125         do {
 126                 irq_pending = cros_ec_interrupt_pending(config.dev);
 127                 if (irq_pending) {
 128                         num_keys = check_for_keys(&config, keys, KBC_MAX_KEYS);
 129                         last_num_keys = num_keys;
 130                         memcpy(last_keys, keys, sizeof(keys));
 131                 } else {
 132                         /*
 133                          * EC doesn't want to be asked, so use keys from last
 134                          * time.
 135                          */
 136                         num_keys = last_num_keys;
 137                         memcpy(keys, last_keys, sizeof(keys));
 138                 }
 139
 140                 if (num_keys < 0)
 141                         return -1;
 142                 num_keycodes = key_matrix_decode(&config.matrix, keys,
 143                                 num_keys, keycodes, KBC_MAX_KEYS);
 144                 sent = input_send_keycodes(input, keycodes, num_keycodes);
 145         } while (irq_pending && !sent);
 146
 147         return 1;
 148 }
 149
 150 /**
 151  * Decode MBKP keyboard details from the device tree
 152  *
 153  * @param blob          Device tree blob
 154  * @param node          Node to decode from
 155  * @param config        Configuration data read from fdt
 156  * @return 0 if ok, -1 on error
 157  */
 158 static int cros_ec_keyb_decode_fdt(const void *blob, int node,
 159                                 struct keyb *config)
 160 {
 161         /*
 162          * Get keyboard rows and columns - at present we are limited to
 163          * 8 columns by the protocol (one byte per row scan)
 164          */
 165         config->key_rows = fdtdec_get_int(blob, node, "google,key-rows", 0);
 166         config->key_cols = fdtdec_get_int(blob, node, "google,key-columns", 0);
 167         if (!config->key_rows || !config->key_cols ||
 168                         config->key_rows * config->key_cols / 8
 169                                 > CROS_EC_KEYSCAN_COLS) {
 170                 debug("%s: Invalid key matrix size %d x %d\n", __func__,
 171                       config->key_rows, config->key_cols);
 172                 return -1;
 173         }
 174         config->repeat_delay_ms = fdtdec_get_int(blob, node,
 175                                                  "google,repeat-delay-ms", 0);
 176         config->repeat_rate_ms = fdtdec_get_int(blob, node,
 177                                                 "google,repeat-rate-ms", 0);
 178         config->ghost_filter = fdtdec_get_bool(blob, node,
 179                                                "google,ghost-filter");
 180         return 0;
 181 }
 182
 183 /**
 184  * Set up the keyboard. This is called by the stdio device handler.
 185  *
 186  * We want to do this init when the keyboard is actually used rather than
 187  * at start-up, since keyboard input may not currently be selected.
 188  *
 189  * @return 0 if ok, -1 on error
 190  */
 191 static int cros_ec_init_keyboard(void)
 192 {
 193         const void *blob = gd->fdt_blob;
 194         int node;
 195
 196         config.dev = board_get_cros_ec_dev();
 197         if (!config.dev) {
 198                 debug("%s: no cros_ec device: cannot init keyboard\n",
 199                       __func__);
 200                 return -1;
 201         }
 202         node = fdtdec_next_compatible(blob, 0, COMPAT_GOOGLE_CROS_EC_KEYB);
 203         if (node < 0) {
 204                 debug("%s: Node not found\n", __func__);
 205                 return -1;
 206         }
 207         if (cros_ec_keyb_decode_fdt(blob, node, &config))
 208                 return -1;
 209         input_set_delays(&config.input, config.repeat_delay_ms,
 210                          config.repeat_rate_ms);
 211         if (key_matrix_init(&config.matrix, config.key_rows,
 212                         config.key_cols, config.ghost_filter)) {
 213                 debug("%s: cannot init key matrix\n", __func__);
 214                 return -1;
 215         }
 216         if (key_matrix_decode_fdt(&config.matrix, gd->fdt_blob, node)) {
 217                 debug("%s: Could not decode key matrix from fdt\n", __func__);
 218                 return -1;
 219         }
 220         config.inited = 1;
 221         debug("%s: Matrix keyboard %dx%d ready\n", __func__, config.key_rows,
 222               config.key_cols);
 223
 224         return 0;
 225 }
 226
 227 int drv_keyboard_init(void)
 228 {
 229         struct stdio_dev dev;
 230
 231         if (input_init(&config.input, 0)) {
 232                 debug("%s: Cannot set up input\n", __func__);
 233                 return -1;
 234         }
 235         config.input.read_keys = cros_ec_kbc_check;
 236
 237         memset(&dev, '\0', sizeof(dev));
 238         strcpy(dev.name, "cros-ec-keyb");
 239         dev.flags = DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
 240         dev.getc = kbd_getc;
 241         dev.tstc = kbd_tstc;
 242         dev.start = cros_ec_init_keyboard;
 243
 244         /* Register the device. cros_ec_init_keyboard() will be called soon */
 245         return input_stdio_register(&dev);
 246 }