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