blob: 946a186a1ffaf2ad511cba5e0749efc53ddf8e16 [file] [log] [blame]
Bernie Thompson92c27c52012-04-17 09:01:31 +00001/*
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 * See file CREDITS for list of people who contributed to this
8 * project.
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of
13 * the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23 * MA 02111-1307 USA
24 */
25
Stephan Linzc20dbf62012-08-02 10:49:24 +000026#include <common.h>
Bernie Thompson92c27c52012-04-17 09:01:31 +000027#include <fdtdec.h>
28#include <key_matrix.h>
29#include <malloc.h>
30#include <linux/input.h>
31
32/**
33 * Determine if the current keypress configuration can cause key ghosting
34 *
35 * We figure this out by seeing if we have two or more keys in the same
36 * column, as well as two or more keys in the same row.
37 *
38 * @param config Keyboard matrix config
39 * @param keys List of keys to check
40 * @param valid Number of valid keypresses to check
41 * @return 0 if no ghosting is possible, 1 if it is
42 */
43static int has_ghosting(struct key_matrix *config, struct key_matrix_key *keys,
44 int valid)
45{
46 int key_in_same_col = 0, key_in_same_row = 0;
47 int i, j;
48
Simon Glass71dc6bc2012-09-27 15:18:42 +000049 if (!config->ghost_filter || valid < 3)
50 return 0;
51
Bernie Thompson92c27c52012-04-17 09:01:31 +000052 for (i = 0; i < valid; i++) {
53 /*
54 * Find 2 keys such that one key is in the same row
55 * and the other is in the same column as the i-th key.
56 */
57 for (j = i + 1; j < valid; j++) {
58 if (keys[j].col == keys[i].col)
59 key_in_same_col = 1;
60 if (keys[j].row == keys[i].row)
61 key_in_same_row = 1;
62 }
63 }
64
65 if (key_in_same_col && key_in_same_row)
66 return 1;
67 else
68 return 0;
69}
70
71int key_matrix_decode(struct key_matrix *config, struct key_matrix_key keys[],
72 int num_keys, int keycode[], int max_keycodes)
73{
74 const u8 *keymap;
75 int valid, upto;
76 int pos;
77
78 debug("%s: num_keys = %d\n", __func__, num_keys);
79 keymap = config->plain_keycode;
80 for (valid = upto = 0; upto < num_keys; upto++) {
81 struct key_matrix_key *key = &keys[upto];
82
83 debug(" valid=%d, row=%d, col=%d\n", key->valid, key->row,
84 key->col);
85 if (!key->valid)
86 continue;
87 pos = key->row * config->num_cols + key->col;
88 if (config->fn_keycode && pos == config->fn_pos)
89 keymap = config->fn_keycode;
90
91 /* Convert the (row, col) values into a keycode */
92 if (valid < max_keycodes)
93 keycode[valid++] = keymap[pos];
94 debug(" keycode=%d\n", keymap[pos]);
95 }
96
97 /* For a ghost key config, ignore the keypresses for this iteration. */
Simon Glass71dc6bc2012-09-27 15:18:42 +000098 if (has_ghosting(config, keys, valid)) {
Bernie Thompson92c27c52012-04-17 09:01:31 +000099 valid = 0;
100 debug(" ghosting detected!\n");
101 }
102 debug(" %d valid keycodes found\n", valid);
103
104 return valid;
105}
106
107/**
108 * Create a new keycode map from some provided data
109 *
110 * This decodes a keycode map in the format used by the fdt, which is one
111 * word per entry, with the row, col and keycode encoded in that word.
112 *
113 * We create a (row x col) size byte array with each entry containing the
114 * keycode for that (row, col). We also search for map_keycode and return
115 * its position if found (this is used for finding the Fn key).
116 *
117 * @param config Key matrix dimensions structure
118 * @param data Keycode data
119 * @param len Number of entries in keycode table
120 * @param map_keycode Key code to find in the map
121 * @param pos Returns position of map_keycode, if found, else -1
122 * @return map Pointer to allocated map
123 */
124static uchar *create_keymap(struct key_matrix *config, u32 *data, int len,
125 int map_keycode, int *pos)
126{
127 uchar *map;
128
129 if (pos)
130 *pos = -1;
131 map = (uchar *)calloc(1, config->key_count);
132 if (!map) {
133 debug("%s: failed to malloc %d bytes\n", __func__,
134 config->key_count);
135 return NULL;
136 }
137
138 for (; len >= sizeof(u32); data++, len -= 4) {
139 u32 tmp = fdt32_to_cpu(*data);
140 int key_code, row, col;
141 int entry;
142
143 row = (tmp >> 24) & 0xff;
144 col = (tmp >> 16) & 0xff;
145 key_code = tmp & 0xffff;
146 entry = row * config->num_cols + col;
147 map[entry] = key_code;
Simon Glass14813f12012-09-27 15:18:43 +0000148 debug(" map %d, %d: pos=%d, keycode=%d\n", row, col,
149 entry, key_code);
Bernie Thompson92c27c52012-04-17 09:01:31 +0000150 if (pos && map_keycode == key_code)
151 *pos = entry;
152 }
153
154 return map;
155}
156
157int key_matrix_decode_fdt(struct key_matrix *config, const void *blob,
158 int node)
159{
160 const struct fdt_property *prop;
Simon Glass00f10992012-09-27 15:18:40 +0000161 const char prefix[] = "linux,";
162 int plen = sizeof(prefix) - 1;
Bernie Thompson92c27c52012-04-17 09:01:31 +0000163 int offset;
164
165 /* Check each property name for ones that we understand */
166 for (offset = fdt_first_property_offset(blob, node);
167 offset > 0;
168 offset = fdt_next_property_offset(blob, offset)) {
169 const char *name;
170 int len;
171
172 prop = fdt_get_property_by_offset(blob, offset, NULL);
173 name = fdt_string(blob, fdt32_to_cpu(prop->nameoff));
174 len = strlen(name);
175
176 /* Name needs to match "1,<type>keymap" */
177 debug("%s: property '%s'\n", __func__, name);
Simon Glass00f10992012-09-27 15:18:40 +0000178 if (strncmp(name, prefix, plen) ||
179 len < plen + 6 ||
180 strcmp(name + len - 6, "keymap"))
Bernie Thompson92c27c52012-04-17 09:01:31 +0000181 continue;
182
Simon Glass00f10992012-09-27 15:18:40 +0000183 len -= plen + 6;
Bernie Thompson92c27c52012-04-17 09:01:31 +0000184 if (len == 0) {
185 config->plain_keycode = create_keymap(config,
186 (u32 *)prop->data, fdt32_to_cpu(prop->len),
187 KEY_FN, &config->fn_pos);
Simon Glass00f10992012-09-27 15:18:40 +0000188 } else if (0 == strncmp(name + plen, "fn-", len)) {
Bernie Thompson92c27c52012-04-17 09:01:31 +0000189 config->fn_keycode = create_keymap(config,
190 (u32 *)prop->data, fdt32_to_cpu(prop->len),
191 -1, NULL);
192 } else {
193 debug("%s: unrecognised property '%s'\n", __func__,
194 name);
195 }
196 }
197 debug("%s: Decoded key maps %p, %p from fdt\n", __func__,
198 config->plain_keycode, config->fn_keycode);
199
200 if (!config->plain_keycode) {
201 debug("%s: cannot find keycode-plain map\n", __func__);
202 return -1;
203 }
204
205 return 0;
206}
207
Simon Glass71dc6bc2012-09-27 15:18:42 +0000208int key_matrix_init(struct key_matrix *config, int rows, int cols,
209 int ghost_filter)
Bernie Thompson92c27c52012-04-17 09:01:31 +0000210{
211 memset(config, '\0', sizeof(*config));
212 config->num_rows = rows;
213 config->num_cols = cols;
214 config->key_count = rows * cols;
Simon Glass71dc6bc2012-09-27 15:18:42 +0000215 config->ghost_filter = ghost_filter;
Bernie Thompson92c27c52012-04-17 09:01:31 +0000216 assert(config->key_count > 0);
217
218 return 0;
219}