drivers/input/key_matrix.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Manage Keyboard Matrices
   4  *
   5  * Copyright (c) 2012 The Chromium OS Authors.
   6  * (C) Copyright 2004 DENX Software Engineering, Wolfgang Denk, wd@denx.de
   7  */
   8
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <key_matrix.h>
  12 #include <malloc.h>
  13 #include <linux/input.h>
  14
  15 /**
  16  * Determine if the current keypress configuration can cause key ghosting
  17  *
  18  * We figure this out by seeing if we have two or more keys in the same
  19  * column, as well as two or more keys in the same row.
  20  *
  21  * @param config        Keyboard matrix config
  22  * @param keys          List of keys to check
  23  * @param valid         Number of valid keypresses to check
  24  * @return 0 if no ghosting is possible, 1 if it is
  25  */
  26 static int has_ghosting(struct key_matrix *config, struct key_matrix_key *keys,
  27                         int valid)
  28 {
  29         int key_in_same_col = 0, key_in_same_row = 0;
  30         int i, j;
  31
  32         if (!config->ghost_filter || valid < 3)
  33                 return 0;
  34
  35         for (i = 0; i < valid; i++) {
  36                 /*
  37                  * Find 2 keys such that one key is in the same row
  38                  * and the other is in the same column as the i-th key.
  39                  */
  40                 for (j = i + 1; j < valid; j++) {
  41                         if (keys[j].col == keys[i].col)
  42                                 key_in_same_col = 1;
  43                         if (keys[j].row == keys[i].row)
  44                                 key_in_same_row = 1;
  45                 }
  46         }
  47
  48         if (key_in_same_col && key_in_same_row)
  49                 return 1;
  50         else
  51                 return 0;
  52 }
  53
  54 int key_matrix_decode(struct key_matrix *config, struct key_matrix_key keys[],
  55                       int num_keys, int keycode[], int max_keycodes)
  56 {
  57         const u8 *keymap;
  58         int valid, upto;
  59         int pos;
  60
  61         debug("%s: num_keys = %d\n", __func__, num_keys);
  62         keymap = config->plain_keycode;
  63         for (valid = upto = 0; upto < num_keys; upto++) {
  64                 struct key_matrix_key *key = &keys[upto];
  65
  66                 debug("  valid=%d, row=%d, col=%d\n", key->valid, key->row,
  67                       key->col);
  68                 if (!key->valid)
  69                         continue;
  70                 pos = key->row * config->num_cols + key->col;
  71                 if (config->fn_keycode && pos == config->fn_pos)
  72                         keymap = config->fn_keycode;
  73
  74                 /* Convert the (row, col) values into a keycode */
  75                 if (valid < max_keycodes)
  76                         keycode[valid++] = keymap[pos];
  77                 debug("    keycode=%d\n", keymap[pos]);
  78         }
  79
  80         /* For a ghost key config, ignore the keypresses for this iteration. */
  81         if (has_ghosting(config, keys, valid)) {
  82                 valid = 0;
  83                 debug("    ghosting detected!\n");
  84         }
  85         debug("  %d valid keycodes found\n", valid);
  86
  87         return valid;
  88 }
  89
  90 /**
  91  * Create a new keycode map from some provided data
  92  *
  93  * This decodes a keycode map in the format used by the fdt, which is one
  94  * word per entry, with the row, col and keycode encoded in that word.
  95  *
  96  * We create a (row x col) size byte array with each entry containing the
  97  * keycode for that (row, col). We also search for map_keycode and return
  98  * its position if found (this is used for finding the Fn key).
  99  *
 100  * @param config        Key matrix dimensions structure
 101  * @param data          Keycode data
 102  * @param len           Number of entries in keycode table
 103  * @param map_keycode   Key code to find in the map
 104  * @param pos           Returns position of map_keycode, if found, else -1
 105  * @return map  Pointer to allocated map
 106  */
 107 static uchar *create_keymap(struct key_matrix *config, const u32 *data, int len,
 108                             int map_keycode, int *pos)
 109 {
 110         uchar *map;
 111
 112         if (pos)
 113                 *pos = -1;
 114         map = (uchar *)calloc(1, config->key_count);
 115         if (!map) {
 116                 debug("%s: failed to malloc %d bytes\n", __func__,
 117                         config->key_count);
 118                 return NULL;
 119         }
 120
 121         for (; len >= sizeof(u32); data++, len -= 4) {
 122                 u32 tmp = fdt32_to_cpu(*data);
 123                 int key_code, row, col;
 124                 int entry;
 125
 126                 row = (tmp >> 24) & 0xff;
 127                 col = (tmp >> 16) & 0xff;
 128                 key_code = tmp & 0xffff;
 129                 entry = row * config->num_cols + col;
 130                 map[entry] = key_code;
 131                 debug("   map %d, %d: pos=%d, keycode=%d\n", row, col,
 132                       entry, key_code);
 133                 if (pos && map_keycode == key_code)
 134                         *pos = entry;
 135         }
 136
 137         return map;
 138 }
 139
 140 int key_matrix_decode_fdt(struct udevice *dev, struct key_matrix *config)
 141 {
 142         const u32 *prop;
 143         int proplen;
 144         uchar *plain_keycode;
 145
 146         prop = dev_read_prop(dev, "linux,keymap", &proplen);
 147         /* Basic keymap is required */
 148         if (!prop) {
 149                 debug("%s: cannot find keycode-plain map\n", __func__);
 150                 return -1;
 151         }
 152
 153         plain_keycode = create_keymap(config, prop, proplen, KEY_FN,
 154                                       &config->fn_pos);
 155         config->plain_keycode = plain_keycode;
 156         /* Conversion error -> fail */
 157         if (!config->plain_keycode)
 158                 return -1;
 159
 160         prop = dev_read_prop(dev, "linux,fn-keymap", &proplen);
 161         /* fn keymap is optional */
 162         if (!prop)
 163                 goto done;
 164
 165         config->fn_keycode = create_keymap(config, prop, proplen, -1, NULL);
 166         /* Conversion error -> fail */
 167         if (!config->fn_keycode) {
 168                 free(plain_keycode);
 169                 return -1;
 170         }
 171
 172 done:
 173         debug("%s: Decoded key maps %p, %p from fdt\n", __func__,
 174               config->plain_keycode, config->fn_keycode);
 175         return 0;
 176 }
 177
 178 int key_matrix_init(struct key_matrix *config, int rows, int cols,
 179                     int ghost_filter)
 180 {
 181         memset(config, '\0', sizeof(*config));
 182         config->num_rows = rows;
 183         config->num_cols = cols;
 184         config->key_count = rows * cols;
 185         config->ghost_filter = ghost_filter;
 186         assert(config->key_count > 0);
 187
 188         return 0;
 189 }