bb0349fa64bc349c130d4f77a96fd7f3a1d525ca
[sfrench/cifs-2.6.git] / drivers / input / sparse-keymap.c
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 MODULE_VERSION("0.1");
25
26 static unsigned int sparse_keymap_get_key_index(struct input_dev *dev,
27                                                 const struct key_entry *k)
28 {
29         struct key_entry *key;
30         unsigned int idx = 0;
31
32         for (key = dev->keycode; key->type != KE_END; key++) {
33                 if (key->type == KE_KEY) {
34                         if (key == k)
35                                 break;
36                         idx++;
37                 }
38         }
39
40         return idx;
41 }
42
43 static struct key_entry *sparse_keymap_entry_by_index(struct input_dev *dev,
44                                                       unsigned int index)
45 {
46         struct key_entry *key;
47         unsigned int key_cnt = 0;
48
49         for (key = dev->keycode; key->type != KE_END; key++)
50                 if (key->type == KE_KEY)
51                         if (key_cnt++ == index)
52                                 return key;
53
54         return NULL;
55 }
56
57 /**
58  * sparse_keymap_entry_from_scancode - perform sparse keymap lookup
59  * @dev: Input device using sparse keymap
60  * @code: Scan code
61  *
62  * This function is used to perform &struct key_entry lookup in an
63  * input device using sparse keymap.
64  */
65 struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev,
66                                                     unsigned int code)
67 {
68         struct key_entry *key;
69
70         for (key = dev->keycode; key->type != KE_END; key++)
71                 if (code == key->code)
72                         return key;
73
74         return NULL;
75 }
76 EXPORT_SYMBOL(sparse_keymap_entry_from_scancode);
77
78 /**
79  * sparse_keymap_entry_from_keycode - perform sparse keymap lookup
80  * @dev: Input device using sparse keymap
81  * @keycode: Key code
82  *
83  * This function is used to perform &struct key_entry lookup in an
84  * input device using sparse keymap.
85  */
86 struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev,
87                                                    unsigned int keycode)
88 {
89         struct key_entry *key;
90
91         for (key = dev->keycode; key->type != KE_END; key++)
92                 if (key->type == KE_KEY && keycode == key->keycode)
93                         return key;
94
95         return NULL;
96 }
97 EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);
98
99 static struct key_entry *sparse_keymap_locate(struct input_dev *dev,
100                                         const struct input_keymap_entry *ke)
101 {
102         struct key_entry *key;
103         unsigned int scancode;
104
105         if (ke->flags & INPUT_KEYMAP_BY_INDEX)
106                 key = sparse_keymap_entry_by_index(dev, ke->index);
107         else if (input_scancode_to_scalar(ke, &scancode) == 0)
108                 key = sparse_keymap_entry_from_scancode(dev, scancode);
109         else
110                 key = NULL;
111
112         return key;
113 }
114
115 static int sparse_keymap_getkeycode(struct input_dev *dev,
116                                     struct input_keymap_entry *ke)
117 {
118         const struct key_entry *key;
119
120         if (dev->keycode) {
121                 key = sparse_keymap_locate(dev, ke);
122                 if (key && key->type == KE_KEY) {
123                         ke->keycode = key->keycode;
124                         if (!(ke->flags & INPUT_KEYMAP_BY_INDEX))
125                                 ke->index =
126                                         sparse_keymap_get_key_index(dev, key);
127                         ke->len = sizeof(key->code);
128                         memcpy(ke->scancode, &key->code, sizeof(key->code));
129                         return 0;
130                 }
131         }
132
133         return -EINVAL;
134 }
135
136 static int sparse_keymap_setkeycode(struct input_dev *dev,
137                                     const struct input_keymap_entry *ke,
138                                     unsigned int *old_keycode)
139 {
140         struct key_entry *key;
141
142         if (dev->keycode) {
143                 key = sparse_keymap_locate(dev, ke);
144                 if (key && key->type == KE_KEY) {
145                         *old_keycode = key->keycode;
146                         key->keycode = ke->keycode;
147                         set_bit(ke->keycode, dev->keybit);
148                         if (!sparse_keymap_entry_from_keycode(dev, *old_keycode))
149                                 clear_bit(*old_keycode, dev->keybit);
150                         return 0;
151                 }
152         }
153
154         return -EINVAL;
155 }
156
157 /**
158  * sparse_keymap_setup - set up sparse keymap for an input device
159  * @dev: Input device
160  * @keymap: Keymap in form of array of &key_entry structures ending
161  *      with %KE_END type entry
162  * @setup: Function that can be used to adjust keymap entries
163  *      depending on device's needs, may be %NULL
164  *
165  * The function calculates size and allocates copy of the original
166  * keymap after which sets up input device event bits appropriately.
167  * The allocated copy of the keymap is automatically freed when it
168  * is no longer needed.
169  */
170 int sparse_keymap_setup(struct input_dev *dev,
171                         const struct key_entry *keymap,
172                         int (*setup)(struct input_dev *, struct key_entry *))
173 {
174         size_t map_size = 1; /* to account for the last KE_END entry */
175         const struct key_entry *e;
176         struct key_entry *map, *entry;
177         int i;
178         int error;
179
180         for (e = keymap; e->type != KE_END; e++)
181                 map_size++;
182
183         map = devm_kmemdup(&dev->dev, keymap, map_size * sizeof(*map),
184                            GFP_KERNEL);
185         if (!map)
186                 return -ENOMEM;
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                                 return error;
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         if (test_bit(EV_KEY, dev->evbit)) {
212                 __set_bit(KEY_UNKNOWN, dev->keybit);
213                 __set_bit(EV_MSC, dev->evbit);
214                 __set_bit(MSC_SCAN, dev->mscbit);
215         }
216
217         dev->keycode = map;
218         dev->keycodemax = map_size;
219         dev->getkeycode = sparse_keymap_getkeycode;
220         dev->setkeycode = sparse_keymap_setkeycode;
221
222         return 0;
223 }
224 EXPORT_SYMBOL(sparse_keymap_setup);
225
226 /**
227  * sparse_keymap_report_entry - report event corresponding to given key entry
228  * @dev: Input device for which event should be reported
229  * @ke: key entry describing event
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 report input event described by given
236  * &struct key_entry.
237  */
238 void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke,
239                                 unsigned int value, bool autorelease)
240 {
241         switch (ke->type) {
242         case KE_KEY:
243                 input_event(dev, EV_MSC, MSC_SCAN, ke->code);
244                 input_report_key(dev, ke->keycode, value);
245                 input_sync(dev);
246                 if (value && autorelease) {
247                         input_report_key(dev, ke->keycode, 0);
248                         input_sync(dev);
249                 }
250                 break;
251
252         case KE_SW:
253                 value = ke->sw.value;
254                 /* fall through */
255
256         case KE_VSW:
257                 input_report_switch(dev, ke->sw.code, value);
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