]>
git.ipfire.org Git - people/ms/u-boot.git/blob - drivers/input/key_matrix.c
2 * Manage Keyboard Matrices
4 * Copyright (c) 2012 The Chromium OS Authors.
5 * (C) Copyright 2004 DENX Software Engineering, Wolfgang Denk, wd@denx.de
7 * See file CREDITS for list of people who contributed to this
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.
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.
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,
28 #include <key_matrix.h>
30 #include <linux/input.h>
33 * Determine if the current keypress configuration can cause key ghosting
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.
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
43 static int has_ghosting(struct key_matrix
*config
, struct key_matrix_key
*keys
,
46 int key_in_same_col
= 0, key_in_same_row
= 0;
49 if (!config
->ghost_filter
|| valid
< 3)
52 for (i
= 0; i
< valid
; i
++) {
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.
57 for (j
= i
+ 1; j
< valid
; j
++) {
58 if (keys
[j
].col
== keys
[i
].col
)
60 if (keys
[j
].row
== keys
[i
].row
)
65 if (key_in_same_col
&& key_in_same_row
)
71 int key_matrix_decode(struct key_matrix
*config
, struct key_matrix_key keys
[],
72 int num_keys
, int keycode
[], int max_keycodes
)
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
];
83 debug(" valid=%d, row=%d, col=%d\n", key
->valid
, key
->row
,
87 pos
= key
->row
* config
->num_cols
+ key
->col
;
88 if (config
->fn_keycode
&& pos
== config
->fn_pos
)
89 keymap
= config
->fn_keycode
;
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
]);
97 /* For a ghost key config, ignore the keypresses for this iteration. */
98 if (has_ghosting(config
, keys
, valid
)) {
100 debug(" ghosting detected!\n");
102 debug(" %d valid keycodes found\n", valid
);
108 * Create a new keycode map from some provided data
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.
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).
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
124 static uchar
*create_keymap(struct key_matrix
*config
, u32
*data
, int len
,
125 int map_keycode
, int *pos
)
131 map
= (uchar
*)calloc(1, config
->key_count
);
133 debug("%s: failed to malloc %d bytes\n", __func__
,
138 for (; len
>= sizeof(u32
); data
++, len
-= 4) {
139 u32 tmp
= fdt32_to_cpu(*data
);
140 int key_code
, row
, col
;
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
;
148 if (pos
&& map_keycode
== key_code
)
155 int key_matrix_decode_fdt(struct key_matrix
*config
, const void *blob
,
158 const struct fdt_property
*prop
;
159 const char prefix
[] = "linux,";
160 int plen
= sizeof(prefix
) - 1;
163 /* Check each property name for ones that we understand */
164 for (offset
= fdt_first_property_offset(blob
, node
);
166 offset
= fdt_next_property_offset(blob
, offset
)) {
170 prop
= fdt_get_property_by_offset(blob
, offset
, NULL
);
171 name
= fdt_string(blob
, fdt32_to_cpu(prop
->nameoff
));
174 /* Name needs to match "1,<type>keymap" */
175 debug("%s: property '%s'\n", __func__
, name
);
176 if (strncmp(name
, prefix
, plen
) ||
178 strcmp(name
+ len
- 6, "keymap"))
183 config
->plain_keycode
= create_keymap(config
,
184 (u32
*)prop
->data
, fdt32_to_cpu(prop
->len
),
185 KEY_FN
, &config
->fn_pos
);
186 } else if (0 == strncmp(name
+ plen
, "fn-", len
)) {
187 config
->fn_keycode
= create_keymap(config
,
188 (u32
*)prop
->data
, fdt32_to_cpu(prop
->len
),
191 debug("%s: unrecognised property '%s'\n", __func__
,
195 debug("%s: Decoded key maps %p, %p from fdt\n", __func__
,
196 config
->plain_keycode
, config
->fn_keycode
);
198 if (!config
->plain_keycode
) {
199 debug("%s: cannot find keycode-plain map\n", __func__
);
206 int key_matrix_init(struct key_matrix
*config
, int rows
, int cols
,
209 memset(config
, '\0', sizeof(*config
));
210 config
->num_rows
= rows
;
211 config
->num_cols
= cols
;
212 config
->key_count
= rows
* cols
;
213 config
->ghost_filter
= ghost_filter
;
214 assert(config
->key_count
> 0);