Root/
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/slab.h> |
19 | |
20 | MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>"); |
21 | MODULE_DESCRIPTION("Generic support for sparse keymaps"); |
22 | MODULE_LICENSE("GPL v2"); |
23 | MODULE_VERSION("0.1"); |
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 deeds, 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 | * Before destroying input device allocated keymap should be freed |
167 | * with a call to sparse_keymap_free(). |
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 = kcalloc(map_size, sizeof (struct key_entry), GFP_KERNEL); |
183 | if (!map) |
184 | return -ENOMEM; |
185 | |
186 | memcpy(map, keymap, map_size * sizeof (struct key_entry)); |
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 | goto err_out; |
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 | dev->keycode = map; |
212 | dev->keycodemax = map_size; |
213 | dev->getkeycode_new = sparse_keymap_getkeycode; |
214 | dev->setkeycode_new = sparse_keymap_setkeycode; |
215 | |
216 | return 0; |
217 | |
218 | err_out: |
219 | kfree(map); |
220 | return error; |
221 | } |
222 | EXPORT_SYMBOL(sparse_keymap_setup); |
223 | |
224 | /** |
225 | * sparse_keymap_free - free memory allocated for sparse keymap |
226 | * @dev: Input device using sparse keymap |
227 | * |
228 | * This function is used to free memory allocated by sparse keymap |
229 | * in an input device that was set up by sparse_keymap_setup(). |
230 | * NOTE: It is safe to cal this function while input device is |
231 | * still registered (however the drivers should care not to try to |
232 | * use freed keymap and thus have to shut off interrups/polling |
233 | * before freeing the keymap). |
234 | */ |
235 | void sparse_keymap_free(struct input_dev *dev) |
236 | { |
237 | unsigned long flags; |
238 | |
239 | /* |
240 | * Take event lock to prevent racing with input_get_keycode() |
241 | * and input_set_keycode() if we are called while input device |
242 | * is still registered. |
243 | */ |
244 | spin_lock_irqsave(&dev->event_lock, flags); |
245 | |
246 | kfree(dev->keycode); |
247 | dev->keycode = NULL; |
248 | dev->keycodemax = 0; |
249 | |
250 | spin_unlock_irqrestore(&dev->event_lock, flags); |
251 | } |
252 | EXPORT_SYMBOL(sparse_keymap_free); |
253 | |
254 | /** |
255 | * sparse_keymap_report_entry - report event corresponding to given key entry |
256 | * @dev: Input device for which event should be reported |
257 | * @ke: key entry describing event |
258 | * @value: Value that should be reported (ignored by %KE_SW entries) |
259 | * @autorelease: Signals whether release event should be emitted for %KE_KEY |
260 | * entries right after reporting press event, ignored by all other |
261 | * entries |
262 | * |
263 | * This function is used to report input event described by given |
264 | * &struct key_entry. |
265 | */ |
266 | void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke, |
267 | unsigned int value, bool autorelease) |
268 | { |
269 | switch (ke->type) { |
270 | case KE_KEY: |
271 | input_report_key(dev, ke->keycode, value); |
272 | input_sync(dev); |
273 | if (value && autorelease) { |
274 | input_report_key(dev, ke->keycode, 0); |
275 | input_sync(dev); |
276 | } |
277 | break; |
278 | |
279 | case KE_SW: |
280 | value = ke->sw.value; |
281 | /* fall through */ |
282 | |
283 | case KE_VSW: |
284 | input_report_switch(dev, ke->sw.code, value); |
285 | break; |
286 | } |
287 | } |
288 | EXPORT_SYMBOL(sparse_keymap_report_entry); |
289 | |
290 | /** |
291 | * sparse_keymap_report_event - report event corresponding to given scancode |
292 | * @dev: Input device using sparse keymap |
293 | * @code: Scan code |
294 | * @value: Value that should be reported (ignored by %KE_SW entries) |
295 | * @autorelease: Signals whether release event should be emitted for %KE_KEY |
296 | * entries right after reporting press event, ignored by all other |
297 | * entries |
298 | * |
299 | * This function is used to perform lookup in an input device using sparse |
300 | * keymap and report corresponding event. Returns %true if lookup was |
301 | * successful and %false otherwise. |
302 | */ |
303 | bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code, |
304 | unsigned int value, bool autorelease) |
305 | { |
306 | const struct key_entry *ke = |
307 | sparse_keymap_entry_from_scancode(dev, code); |
308 | |
309 | if (ke) { |
310 | sparse_keymap_report_entry(dev, ke, value, autorelease); |
311 | return true; |
312 | } |
313 | |
314 | return false; |
315 | } |
316 | EXPORT_SYMBOL(sparse_keymap_report_event); |
317 | |
318 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9