]>
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> | |
5a0e3ad6 | 18 | #include <linux/slab.h> |
36203c4f DT |
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 | /** | |
26 | * sparse_keymap_entry_from_scancode - perform sparse keymap lookup | |
27 | * @dev: Input device using sparse keymap | |
28 | * @code: Scan code | |
29 | * | |
30 | * This function is used to perform &struct key_entry lookup in an | |
31 | * input device using sparse keymap. | |
32 | */ | |
33 | struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev, | |
34 | unsigned int code) | |
35 | { | |
36 | struct key_entry *key; | |
37 | ||
38 | for (key = dev->keycode; key->type != KE_END; key++) | |
39 | if (code == key->code) | |
40 | return key; | |
41 | ||
42 | return NULL; | |
43 | } | |
44 | EXPORT_SYMBOL(sparse_keymap_entry_from_scancode); | |
45 | ||
46 | /** | |
47 | * sparse_keymap_entry_from_keycode - perform sparse keymap lookup | |
48 | * @dev: Input device using sparse keymap | |
49 | * @keycode: Key code | |
50 | * | |
51 | * This function is used to perform &struct key_entry lookup in an | |
52 | * input device using sparse keymap. | |
53 | */ | |
54 | struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev, | |
55 | unsigned int keycode) | |
56 | { | |
57 | struct key_entry *key; | |
58 | ||
59 | for (key = dev->keycode; key->type != KE_END; key++) | |
60 | if (key->type == KE_KEY && keycode == key->keycode) | |
61 | return key; | |
62 | ||
63 | return NULL; | |
64 | } | |
65 | EXPORT_SYMBOL(sparse_keymap_entry_from_keycode); | |
66 | ||
67 | static int sparse_keymap_getkeycode(struct input_dev *dev, | |
58b93995 DT |
68 | unsigned int scancode, |
69 | unsigned int *keycode) | |
36203c4f DT |
70 | { |
71 | const struct key_entry *key = | |
72 | sparse_keymap_entry_from_scancode(dev, scancode); | |
73 | ||
74 | if (key && key->type == KE_KEY) { | |
75 | *keycode = key->keycode; | |
76 | return 0; | |
77 | } | |
78 | ||
79 | return -EINVAL; | |
80 | } | |
81 | ||
82 | static int sparse_keymap_setkeycode(struct input_dev *dev, | |
58b93995 DT |
83 | unsigned int scancode, |
84 | unsigned int keycode) | |
36203c4f DT |
85 | { |
86 | struct key_entry *key; | |
87 | int old_keycode; | |
88 | ||
89 | if (keycode < 0 || keycode > KEY_MAX) | |
90 | return -EINVAL; | |
91 | ||
92 | key = sparse_keymap_entry_from_scancode(dev, scancode); | |
93 | if (key && key->type == KE_KEY) { | |
94 | old_keycode = key->keycode; | |
95 | key->keycode = keycode; | |
96 | set_bit(keycode, dev->keybit); | |
97 | if (!sparse_keymap_entry_from_keycode(dev, old_keycode)) | |
98 | clear_bit(old_keycode, dev->keybit); | |
99 | return 0; | |
100 | } | |
101 | ||
102 | return -EINVAL; | |
103 | } | |
104 | ||
105 | /** | |
106 | * sparse_keymap_setup - set up sparse keymap for an input device | |
107 | * @dev: Input device | |
108 | * @keymap: Keymap in form of array of &key_entry structures ending | |
109 | * with %KE_END type entry | |
110 | * @setup: Function that can be used to adjust keymap entries | |
111 | * depending on device's deeds, may be %NULL | |
112 | * | |
113 | * The function calculates size and allocates copy of the original | |
114 | * keymap after which sets up input device event bits appropriately. | |
115 | * Before destroying input device allocated keymap should be freed | |
116 | * with a call to sparse_keymap_free(). | |
117 | */ | |
118 | int sparse_keymap_setup(struct input_dev *dev, | |
119 | const struct key_entry *keymap, | |
120 | int (*setup)(struct input_dev *, struct key_entry *)) | |
121 | { | |
122 | size_t map_size = 1; /* to account for the last KE_END entry */ | |
123 | const struct key_entry *e; | |
124 | struct key_entry *map, *entry; | |
125 | int i; | |
126 | int error; | |
127 | ||
128 | for (e = keymap; e->type != KE_END; e++) | |
129 | map_size++; | |
130 | ||
131 | map = kcalloc(map_size, sizeof (struct key_entry), GFP_KERNEL); | |
132 | if (!map) | |
133 | return -ENOMEM; | |
134 | ||
135 | memcpy(map, keymap, map_size * sizeof (struct key_entry)); | |
136 | ||
137 | for (i = 0; i < map_size; i++) { | |
138 | entry = &map[i]; | |
139 | ||
140 | if (setup) { | |
141 | error = setup(dev, entry); | |
142 | if (error) | |
143 | goto err_out; | |
144 | } | |
145 | ||
146 | switch (entry->type) { | |
147 | case KE_KEY: | |
148 | __set_bit(EV_KEY, dev->evbit); | |
149 | __set_bit(entry->keycode, dev->keybit); | |
150 | break; | |
151 | ||
152 | case KE_SW: | |
153 | __set_bit(EV_SW, dev->evbit); | |
154 | __set_bit(entry->sw.code, dev->swbit); | |
155 | break; | |
156 | } | |
157 | } | |
158 | ||
159 | dev->keycode = map; | |
160 | dev->keycodemax = map_size; | |
161 | dev->getkeycode = sparse_keymap_getkeycode; | |
162 | dev->setkeycode = sparse_keymap_setkeycode; | |
163 | ||
164 | return 0; | |
165 | ||
166 | err_out: | |
167 | kfree(keymap); | |
168 | return error; | |
169 | ||
170 | } | |
171 | EXPORT_SYMBOL(sparse_keymap_setup); | |
172 | ||
173 | /** | |
174 | * sparse_keymap_free - free memory allocated for sparse keymap | |
175 | * @dev: Input device using sparse keymap | |
176 | * | |
177 | * This function is used to free memory allocated by sparse keymap | |
178 | * in an input device that was set up by sparse_keymap_setup(). | |
179 | */ | |
180 | void sparse_keymap_free(struct input_dev *dev) | |
181 | { | |
182 | kfree(dev->keycode); | |
183 | dev->keycode = NULL; | |
184 | dev->keycodemax = 0; | |
185 | dev->getkeycode = NULL; | |
186 | dev->setkeycode = NULL; | |
187 | } | |
188 | EXPORT_SYMBOL(sparse_keymap_free); | |
189 | ||
190 | /** | |
191 | * sparse_keymap_report_entry - report event corresponding to given key entry | |
192 | * @dev: Input device for which event should be reported | |
193 | * @ke: key entry describing event | |
194 | * @value: Value that should be reported (ignored by %KE_SW entries) | |
195 | * @autorelease: Signals whether release event should be emitted for %KE_KEY | |
196 | * entries right after reporting press event, ignored by all other | |
197 | * entries | |
198 | * | |
199 | * This function is used to report input event described by given | |
200 | * &struct key_entry. | |
201 | */ | |
202 | void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke, | |
203 | unsigned int value, bool autorelease) | |
204 | { | |
205 | switch (ke->type) { | |
206 | case KE_KEY: | |
207 | input_report_key(dev, ke->keycode, value); | |
208 | input_sync(dev); | |
209 | if (value && autorelease) { | |
210 | input_report_key(dev, ke->keycode, 0); | |
211 | input_sync(dev); | |
212 | } | |
213 | break; | |
214 | ||
215 | case KE_SW: | |
216 | value = ke->sw.value; | |
217 | /* fall through */ | |
218 | ||
219 | case KE_VSW: | |
220 | input_report_switch(dev, ke->sw.code, value); | |
221 | break; | |
222 | } | |
223 | } | |
224 | EXPORT_SYMBOL(sparse_keymap_report_entry); | |
225 | ||
226 | /** | |
227 | * sparse_keymap_report_event - report event corresponding to given scancode | |
228 | * @dev: Input device using sparse keymap | |
229 | * @code: Scan code | |
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 perform lookup in an input device using sparse | |
236 | * keymap and report corresponding event. Returns %true if lookup was | |
237 | * successful and %false otherwise. | |
238 | */ | |
239 | bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code, | |
240 | unsigned int value, bool autorelease) | |
241 | { | |
242 | const struct key_entry *ke = | |
243 | sparse_keymap_entry_from_scancode(dev, code); | |
244 | ||
245 | if (ke) { | |
246 | sparse_keymap_report_entry(dev, ke, value, autorelease); | |
247 | return true; | |
248 | } | |
249 | ||
250 | return false; | |
251 | } | |
252 | EXPORT_SYMBOL(sparse_keymap_report_event); | |
253 |