drivers/input/key_matrix.c

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