projects/linux·blob v4.13 · refs

297 lines · 7.6 KiB

1/*
2 * Generic support for sparse keymaps
3 *
4 * Copyright (c) 2009 Dmitry Torokhov
5 *
6 * Derived from wistron button driver:
7 * Copyright (C) 2005 Miloslav Trmac <[email protected]>
8 * Copyright (C) 2005 Bernhard Rosenkraenzer <[email protected]>
9 * Copyright (C) 2005 Dmitry Torokhov <[email protected]>
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License version 2 as published by
13 * the Free Software Foundation.
14 */
15
16#include <linux/input.h>
17#include <linux/input/sparse-keymap.h>
18#include <linux/module.h>
19#include <linux/slab.h>
20
21MODULE_AUTHOR("Dmitry Torokhov <[email protected]>");
22MODULE_DESCRIPTION("Generic support for sparse keymaps");
23MODULE_LICENSE("GPL v2");
24MODULE_VERSION("0.1");
25
26static unsigned int sparse_keymap_get_key_index(struct input_dev *dev,
27 const struct key_entry *k)
28{
29 struct key_entry *key;
30 unsigned int idx = 0;
31
32 for (key = dev->keycode; key->type != KE_END; key++) {
33 if (key->type == KE_KEY) {
34 if (key == k)
35 break;
36 idx++;
37 }
38 }
39
40 return idx;
41}
42
43static struct key_entry *sparse_keymap_entry_by_index(struct input_dev *dev,
44 unsigned int index)
45{
46 struct key_entry *key;
47 unsigned int key_cnt = 0;
48
49 for (key = dev->keycode; key->type != KE_END; key++)
50 if (key->type == KE_KEY)
51 if (key_cnt++ == index)
52 return key;
53
54 return NULL;
55}
56
57/**
58 * sparse_keymap_entry_from_scancode - perform sparse keymap lookup
59 * @dev: Input device using sparse keymap
60 * @code: Scan code
61 *
62 * This function is used to perform &struct key_entry lookup in an
63 * input device using sparse keymap.
64 */
65struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev,
66 unsigned int code)
67{
68 struct key_entry *key;
69
70 for (key = dev->keycode; key->type != KE_END; key++)
71 if (code == key->code)
72 return key;
73
74 return NULL;
75}
76EXPORT_SYMBOL(sparse_keymap_entry_from_scancode);
77
78/**
79 * sparse_keymap_entry_from_keycode - perform sparse keymap lookup
80 * @dev: Input device using sparse keymap
81 * @keycode: Key code
82 *
83 * This function is used to perform &struct key_entry lookup in an
84 * input device using sparse keymap.
85 */
86struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev,
87 unsigned int keycode)
88{
89 struct key_entry *key;
90
91 for (key = dev->keycode; key->type != KE_END; key++)
92 if (key->type == KE_KEY && keycode == key->keycode)
93 return key;
94
95 return NULL;
96}
97EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);
98
99static struct key_entry *sparse_keymap_locate(struct input_dev *dev,
100 const struct input_keymap_entry *ke)
101{
102 struct key_entry *key;
103 unsigned int scancode;
104
105 if (ke->flags & INPUT_KEYMAP_BY_INDEX)
106 key = sparse_keymap_entry_by_index(dev, ke->index);
107 else if (input_scancode_to_scalar(ke, &scancode) == 0)
108 key = sparse_keymap_entry_from_scancode(dev, scancode);
109 else
110 key = NULL;
111
112 return key;
113}
114
115static int sparse_keymap_getkeycode(struct input_dev *dev,
116 struct input_keymap_entry *ke)
117{
118 const struct key_entry *key;
119
120 if (dev->keycode) {
121 key = sparse_keymap_locate(dev, ke);
122 if (key && key->type == KE_KEY) {
123 ke->keycode = key->keycode;
124 if (!(ke->flags & INPUT_KEYMAP_BY_INDEX))
125 ke->index =
126 sparse_keymap_get_key_index(dev, key);
127 ke->len = sizeof(key->code);
128 memcpy(ke->scancode, &key->code, sizeof(key->code));
129 return 0;
130 }
131 }
132
133 return -EINVAL;
134}
135
136static int sparse_keymap_setkeycode(struct input_dev *dev,
137 const struct input_keymap_entry *ke,
138 unsigned int *old_keycode)
139{
140 struct key_entry *key;
141
142 if (dev->keycode) {
143 key = sparse_keymap_locate(dev, ke);
144 if (key && key->type == KE_KEY) {
145 *old_keycode = key->keycode;
146 key->keycode = ke->keycode;
147 set_bit(ke->keycode, dev->keybit);
148 if (!sparse_keymap_entry_from_keycode(dev, *old_keycode))
149 clear_bit(*old_keycode, dev->keybit);
150 return 0;
151 }
152 }
153
154 return -EINVAL;
155}
156
157/**
158 * sparse_keymap_setup - set up sparse keymap for an input device
159 * @dev: Input device
160 * @keymap: Keymap in form of array of &key_entry structures ending
161 * with %KE_END type entry
162 * @setup: Function that can be used to adjust keymap entries
163 * depending on device's needs, may be %NULL
164 *
165 * The function calculates size and allocates copy of the original
166 * keymap after which sets up input device event bits appropriately.
167 * The allocated copy of the keymap is automatically freed when it
168 * is no longer needed.
169 */
170int sparse_keymap_setup(struct input_dev *dev,
171 const struct key_entry *keymap,
172 int (*setup)(struct input_dev *, struct key_entry *))
173{
174 size_t map_size = 1; /* to account for the last KE_END entry */
175 const struct key_entry *e;
176 struct key_entry *map, *entry;
177 int i;
178 int error;
179
180 for (e = keymap; e->type != KE_END; e++)
181 map_size++;
182
183 map = devm_kmemdup(&dev->dev, keymap, map_size * sizeof(*map),
184 GFP_KERNEL);
185 if (!map)
186 return -ENOMEM;
187
188 for (i = 0; i < map_size; i++) {
189 entry = &map[i];
190
191 if (setup) {
192 error = setup(dev, entry);
193 if (error)
194 return error;
195 }
196
197 switch (entry->type) {
198 case KE_KEY:
199 __set_bit(EV_KEY, dev->evbit);
200 __set_bit(entry->keycode, dev->keybit);
201 break;
202
203 case KE_SW:
204 case KE_VSW:
205 __set_bit(EV_SW, dev->evbit);
206 __set_bit(entry->sw.code, dev->swbit);
207 break;
208 }
209 }
210
211 if (test_bit(EV_KEY, dev->evbit)) {
212 __set_bit(KEY_UNKNOWN, dev->keybit);
213 __set_bit(EV_MSC, dev->evbit);
214 __set_bit(MSC_SCAN, dev->mscbit);
215 }
216
217 dev->keycode = map;
218 dev->keycodemax = map_size;
219 dev->getkeycode = sparse_keymap_getkeycode;
220 dev->setkeycode = sparse_keymap_setkeycode;
221
222 return 0;
223}
224EXPORT_SYMBOL(sparse_keymap_setup);
225
226/**
227 * sparse_keymap_report_entry - report event corresponding to given key entry
228 * @dev: Input device for which event should be reported
229 * @ke: key entry describing event
230 * @value: Value that should be reported (ignored by %KE_SW entries)
231 * @autorelease: Signals whether release event should be emitted for %KE_KEY
232 * entries right after reporting press event, ignored by all other
233 * entries
234 *
235 * This function is used to report input event described by given
236 * &struct key_entry.
237 */
238void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke,
239 unsigned int value, bool autorelease)
240{
241 switch (ke->type) {
242 case KE_KEY:
243 input_event(dev, EV_MSC, MSC_SCAN, ke->code);
244 input_report_key(dev, ke->keycode, value);
245 input_sync(dev);
246 if (value && autorelease) {
247 input_report_key(dev, ke->keycode, 0);
248 input_sync(dev);
249 }
250 break;
251
252 case KE_SW:
253 value = ke->sw.value;
254 /* fall through */
255
256 case KE_VSW:
257 input_report_switch(dev, ke->sw.code, value);
258 break;
259 }
260}
261EXPORT_SYMBOL(sparse_keymap_report_entry);
262
263/**
264 * sparse_keymap_report_event - report event corresponding to given scancode
265 * @dev: Input device using sparse keymap
266 * @code: Scan code
267 * @value: Value that should be reported (ignored by %KE_SW entries)
268 * @autorelease: Signals whether release event should be emitted for %KE_KEY
269 * entries right after reporting press event, ignored by all other
270 * entries
271 *
272 * This function is used to perform lookup in an input device using sparse
273 * keymap and report corresponding event. Returns %true if lookup was
274 * successful and %false otherwise.
275 */
276bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code,
277 unsigned int value, bool autorelease)
278{
279 const struct key_entry *ke =
280 sparse_keymap_entry_from_scancode(dev, code);
281 struct key_entry unknown_ke;
282
283 if (ke) {
284 sparse_keymap_report_entry(dev, ke, value, autorelease);
285 return true;
286 }
287
288 /* Report an unknown key event as a debugging aid */
289 unknown_ke.type = KE_KEY;
290 unknown_ke.code = code;
291 unknown_ke.keycode = KEY_UNKNOWN;
292 sparse_keymap_report_entry(dev, &unknown_ke, value, true);
293
294 return false;
295}
296EXPORT_SYMBOL(sparse_keymap_report_event);
297