]> git.sur5r.net Git - u-boot/blob - drivers/input/key_matrix.c
sunxi: Enable eMMC on Libre Computer Board ALL-H3-CC boards
[u-boot] / 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 }