This source file includes following definitions.
- sparse_keymap_get_key_index
- sparse_keymap_entry_by_index
- sparse_keymap_entry_from_scancode
- sparse_keymap_entry_from_keycode
- sparse_keymap_locate
- sparse_keymap_getkeycode
- sparse_keymap_setkeycode
- sparse_keymap_setup
- sparse_keymap_report_entry
- sparse_keymap_report_event
1
2
3
4
5
6
7
8
9
10
11
12
13 #include <linux/input.h>
14 #include <linux/input/sparse-keymap.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17
18 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
19 MODULE_DESCRIPTION("Generic support for sparse keymaps");
20 MODULE_LICENSE("GPL v2");
21
22 static unsigned int sparse_keymap_get_key_index(struct input_dev *dev,
23 const struct key_entry *k)
24 {
25 struct key_entry *key;
26 unsigned int idx = 0;
27
28 for (key = dev->keycode; key->type != KE_END; key++) {
29 if (key->type == KE_KEY) {
30 if (key == k)
31 break;
32 idx++;
33 }
34 }
35
36 return idx;
37 }
38
39 static struct key_entry *sparse_keymap_entry_by_index(struct input_dev *dev,
40 unsigned int index)
41 {
42 struct key_entry *key;
43 unsigned int key_cnt = 0;
44
45 for (key = dev->keycode; key->type != KE_END; key++)
46 if (key->type == KE_KEY)
47 if (key_cnt++ == index)
48 return key;
49
50 return NULL;
51 }
52
53
54
55
56
57
58
59
60
61 struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev,
62 unsigned int code)
63 {
64 struct key_entry *key;
65
66 for (key = dev->keycode; key->type != KE_END; key++)
67 if (code == key->code)
68 return key;
69
70 return NULL;
71 }
72 EXPORT_SYMBOL(sparse_keymap_entry_from_scancode);
73
74
75
76
77
78
79
80
81
82 struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev,
83 unsigned int keycode)
84 {
85 struct key_entry *key;
86
87 for (key = dev->keycode; key->type != KE_END; key++)
88 if (key->type == KE_KEY && keycode == key->keycode)
89 return key;
90
91 return NULL;
92 }
93 EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);
94
95 static struct key_entry *sparse_keymap_locate(struct input_dev *dev,
96 const struct input_keymap_entry *ke)
97 {
98 struct key_entry *key;
99 unsigned int scancode;
100
101 if (ke->flags & INPUT_KEYMAP_BY_INDEX)
102 key = sparse_keymap_entry_by_index(dev, ke->index);
103 else if (input_scancode_to_scalar(ke, &scancode) == 0)
104 key = sparse_keymap_entry_from_scancode(dev, scancode);
105 else
106 key = NULL;
107
108 return key;
109 }
110
111 static int sparse_keymap_getkeycode(struct input_dev *dev,
112 struct input_keymap_entry *ke)
113 {
114 const struct key_entry *key;
115
116 if (dev->keycode) {
117 key = sparse_keymap_locate(dev, ke);
118 if (key && key->type == KE_KEY) {
119 ke->keycode = key->keycode;
120 if (!(ke->flags & INPUT_KEYMAP_BY_INDEX))
121 ke->index =
122 sparse_keymap_get_key_index(dev, key);
123 ke->len = sizeof(key->code);
124 memcpy(ke->scancode, &key->code, sizeof(key->code));
125 return 0;
126 }
127 }
128
129 return -EINVAL;
130 }
131
132 static int sparse_keymap_setkeycode(struct input_dev *dev,
133 const struct input_keymap_entry *ke,
134 unsigned int *old_keycode)
135 {
136 struct key_entry *key;
137
138 if (dev->keycode) {
139 key = sparse_keymap_locate(dev, ke);
140 if (key && key->type == KE_KEY) {
141 *old_keycode = key->keycode;
142 key->keycode = ke->keycode;
143 set_bit(ke->keycode, dev->keybit);
144 if (!sparse_keymap_entry_from_keycode(dev, *old_keycode))
145 clear_bit(*old_keycode, dev->keybit);
146 return 0;
147 }
148 }
149
150 return -EINVAL;
151 }
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166 int sparse_keymap_setup(struct input_dev *dev,
167 const struct key_entry *keymap,
168 int (*setup)(struct input_dev *, struct key_entry *))
169 {
170 size_t map_size = 1;
171 const struct key_entry *e;
172 struct key_entry *map, *entry;
173 int i;
174 int error;
175
176 for (e = keymap; e->type != KE_END; e++)
177 map_size++;
178
179 map = devm_kmemdup(&dev->dev, keymap, map_size * sizeof(*map),
180 GFP_KERNEL);
181 if (!map)
182 return -ENOMEM;
183
184 for (i = 0; i < map_size; i++) {
185 entry = &map[i];
186
187 if (setup) {
188 error = setup(dev, entry);
189 if (error)
190 return error;
191 }
192
193 switch (entry->type) {
194 case KE_KEY:
195 __set_bit(EV_KEY, dev->evbit);
196 __set_bit(entry->keycode, dev->keybit);
197 break;
198
199 case KE_SW:
200 case KE_VSW:
201 __set_bit(EV_SW, dev->evbit);
202 __set_bit(entry->sw.code, dev->swbit);
203 break;
204 }
205 }
206
207 if (test_bit(EV_KEY, dev->evbit)) {
208 __set_bit(KEY_UNKNOWN, dev->keybit);
209 __set_bit(EV_MSC, dev->evbit);
210 __set_bit(MSC_SCAN, dev->mscbit);
211 }
212
213 dev->keycode = map;
214 dev->keycodemax = map_size;
215 dev->getkeycode = sparse_keymap_getkeycode;
216 dev->setkeycode = sparse_keymap_setkeycode;
217
218 return 0;
219 }
220 EXPORT_SYMBOL(sparse_keymap_setup);
221
222
223
224
225
226
227
228
229
230
231
232
233
234 void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke,
235 unsigned int value, bool autorelease)
236 {
237 switch (ke->type) {
238 case KE_KEY:
239 input_event(dev, EV_MSC, MSC_SCAN, ke->code);
240 input_report_key(dev, ke->keycode, value);
241 input_sync(dev);
242 if (value && autorelease) {
243 input_report_key(dev, ke->keycode, 0);
244 input_sync(dev);
245 }
246 break;
247
248 case KE_SW:
249 value = ke->sw.value;
250
251
252 case KE_VSW:
253 input_report_switch(dev, ke->sw.code, value);
254 input_sync(dev);
255 break;
256 }
257 }
258 EXPORT_SYMBOL(sparse_keymap_report_entry);
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273 bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code,
274 unsigned int value, bool autorelease)
275 {
276 const struct key_entry *ke =
277 sparse_keymap_entry_from_scancode(dev, code);
278 struct key_entry unknown_ke;
279
280 if (ke) {
281 sparse_keymap_report_entry(dev, ke, value, autorelease);
282 return true;
283 }
284
285
286 unknown_ke.type = KE_KEY;
287 unknown_ke.code = code;
288 unknown_ke.keycode = KEY_UNKNOWN;
289 sparse_keymap_report_entry(dev, &unknown_ke, value, true);
290
291 return false;
292 }
293 EXPORT_SYMBOL(sparse_keymap_report_event);
294