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> |
18 | #include <linux/module.h> |
19 | #include <linux/slab.h> |
20 | |
21 | MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>" ); |
22 | MODULE_DESCRIPTION("Generic support for sparse keymaps" ); |
23 | MODULE_LICENSE("GPL v2" ); |
24 | |
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 | |
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 | |
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 | |
114 | static int sparse_keymap_getkeycode(struct input_dev *dev, |
115 | struct input_keymap_entry *ke) |
116 | { |
117 | const struct key_entry *key; |
118 | |
119 | if (dev->keycode) { |
120 | key = sparse_keymap_locate(dev, ke); |
121 | if (key && key->type == KE_KEY) { |
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)); |
128 | return 0; |
129 | } |
130 | } |
131 | |
132 | return -EINVAL; |
133 | } |
134 | |
135 | static int sparse_keymap_setkeycode(struct input_dev *dev, |
136 | const struct input_keymap_entry *ke, |
137 | unsigned int *old_keycode) |
138 | { |
139 | struct key_entry *key; |
140 | |
141 | if (dev->keycode) { |
142 | key = sparse_keymap_locate(dev, ke); |
143 | if (key && key->type == KE_KEY) { |
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); |
149 | return 0; |
150 | } |
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 |
162 | * depending on device's needs, may be %NULL |
163 | * |
164 | * The function calculates size and allocates copy of the original |
165 | * keymap after which sets up input device event bits appropriately. |
166 | * The allocated copy of the keymap is automatically freed when it |
167 | * is no longer needed. |
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 | |
182 | map = devm_kmemdup(&dev->dev, keymap, map_size * sizeof(*map), |
183 | GFP_KERNEL); |
184 | if (!map) |
185 | return -ENOMEM; |
186 | |
187 | for (i = 0; i < map_size; i++) { |
188 | entry = &map[i]; |
189 | |
190 | if (setup) { |
191 | error = setup(dev, entry); |
192 | if (error) |
193 | return error; |
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: |
203 | case KE_VSW: |
204 | __set_bit(EV_SW, dev->evbit); |
205 | __set_bit(entry->sw.code, dev->swbit); |
206 | break; |
207 | } |
208 | } |
209 | |
210 | if (test_bit(EV_KEY, dev->evbit)) { |
211 | __set_bit(KEY_UNKNOWN, dev->keybit); |
212 | __set_bit(EV_MSC, dev->evbit); |
213 | __set_bit(MSC_SCAN, dev->mscbit); |
214 | } |
215 | |
216 | dev->keycode = map; |
217 | dev->keycodemax = map_size; |
218 | dev->getkeycode = sparse_keymap_getkeycode; |
219 | dev->setkeycode = sparse_keymap_setkeycode; |
220 | |
221 | return 0; |
222 | } |
223 | EXPORT_SYMBOL(sparse_keymap_setup); |
224 | |
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: |
242 | input_event(dev, EV_MSC, MSC_SCAN, ke->code); |
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); |
257 | input_sync(dev); |
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); |
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 | } |
296 | EXPORT_SYMBOL(sparse_keymap_report_event); |
297 | |
298 | |