1
2
3
4
5
6
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
17
18
19
20
21
22
23
24
25
26static 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
38
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
54int 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
75 if (valid < max_keycodes)
76 keycode[valid++] = keymap[pos];
77 debug(" keycode=%d\n", keymap[pos]);
78 }
79
80
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107static 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
140int 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
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
157 if (!config->plain_keycode)
158 return -1;
159
160 prop = dev_read_prop(dev, "linux,fn-keymap", &proplen);
161
162 if (!prop)
163 goto done;
164
165 config->fn_keycode = create_keymap(config, prop, proplen, -1, NULL);
166
167 if (!config->fn_keycode) {
168 free(plain_keycode);
169 return -1;
170 }
171
172done:
173 debug("%s: Decoded key maps %p, %p from fdt\n", __func__,
174 config->plain_keycode, config->fn_keycode);
175 return 0;
176}
177
178int 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}
190