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