2 * Generic support for sparse keymaps
4 * Copyright (c) 2009 Dmitry Torokhov
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>
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.
16 #include <linux/input.h>
17 #include <linux/input/sparse-keymap.h>
18 #include <linux/slab.h>
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");
25 static unsigned int sparse_keymap_get_key_index(struct input_dev *dev,
26 const struct key_entry *k)
28 struct key_entry *key;
31 for (key = dev->keycode; key->type != KE_END; key++) {
32 if (key->type == KE_KEY) {
42 static struct key_entry *sparse_keymap_entry_by_index(struct input_dev *dev,
45 struct key_entry *key;
46 unsigned int key_cnt = 0;
48 for (key = dev->keycode; key->type != KE_END; key++)
49 if (key->type == KE_KEY)
50 if (key_cnt++ == index)
57 * sparse_keymap_entry_from_scancode - perform sparse keymap lookup
58 * @dev: Input device using sparse keymap
61 * This function is used to perform &struct key_entry lookup in an
62 * input device using sparse keymap.
64 struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev,
67 struct key_entry *key;
69 for (key = dev->keycode; key->type != KE_END; key++)
70 if (code == key->code)
75 EXPORT_SYMBOL(sparse_keymap_entry_from_scancode);
78 * sparse_keymap_entry_from_keycode - perform sparse keymap lookup
79 * @dev: Input device using sparse keymap
82 * This function is used to perform &struct key_entry lookup in an
83 * input device using sparse keymap.
85 struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev,
88 struct key_entry *key;
90 for (key = dev->keycode; key->type != KE_END; key++)
91 if (key->type == KE_KEY && keycode == key->keycode)
96 EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);
98 static struct key_entry *sparse_keymap_locate(struct input_dev *dev,
99 const struct input_keymap_entry *ke)
101 struct key_entry *key;
102 unsigned int scancode;
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);
114 static int sparse_keymap_getkeycode(struct input_dev *dev,
115 struct input_keymap_entry *ke)
117 const struct key_entry *key;
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))
125 sparse_keymap_get_key_index(dev, key);
126 ke->len = sizeof(key->code);
127 memcpy(ke->scancode, &key->code, sizeof(key->code));
135 static int sparse_keymap_setkeycode(struct input_dev *dev,
136 const struct input_keymap_entry *ke,
137 unsigned int *old_keycode)
139 struct key_entry *key;
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);
157 * sparse_keymap_setup - set up sparse keymap for an 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
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().
169 int sparse_keymap_setup(struct input_dev *dev,
170 const struct key_entry *keymap,
171 int (*setup)(struct input_dev *, struct key_entry *))
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;
179 for (e = keymap; e->type != KE_END; e++)
182 map = kcalloc(map_size, sizeof (struct key_entry), GFP_KERNEL);
186 memcpy(map, keymap, map_size * sizeof (struct key_entry));
188 for (i = 0; i < map_size; i++) {
192 error = setup(dev, entry);
197 switch (entry->type) {
199 __set_bit(EV_KEY, dev->evbit);
200 __set_bit(entry->keycode, dev->keybit);
205 __set_bit(EV_SW, dev->evbit);
206 __set_bit(entry->sw.code, dev->swbit);
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);
218 dev->keycodemax = map_size;
219 dev->getkeycode = sparse_keymap_getkeycode;
220 dev->setkeycode = sparse_keymap_setkeycode;
228 EXPORT_SYMBOL(sparse_keymap_setup);
231 * sparse_keymap_free - free memory allocated for sparse keymap
232 * @dev: Input device using sparse keymap
234 * This function is used to free memory allocated by sparse keymap
235 * in an input device that was set up by sparse_keymap_setup().
236 * NOTE: It is safe to cal this function while input device is
237 * still registered (however the drivers should care not to try to
238 * use freed keymap and thus have to shut off interrups/polling
239 * before freeing the keymap).
241 void sparse_keymap_free(struct input_dev *dev)
246 * Take event lock to prevent racing with input_get_keycode()
247 * and input_set_keycode() if we are called while input device
248 * is still registered.
250 spin_lock_irqsave(&dev->event_lock, flags);
256 spin_unlock_irqrestore(&dev->event_lock, flags);
258 EXPORT_SYMBOL(sparse_keymap_free);
261 * sparse_keymap_report_entry - report event corresponding to given key entry
262 * @dev: Input device for which event should be reported
263 * @ke: key entry describing event
264 * @value: Value that should be reported (ignored by %KE_SW entries)
265 * @autorelease: Signals whether release event should be emitted for %KE_KEY
266 * entries right after reporting press event, ignored by all other
269 * This function is used to report input event described by given
272 void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke,
273 unsigned int value, bool autorelease)
277 input_event(dev, EV_MSC, MSC_SCAN, ke->code);
278 input_report_key(dev, ke->keycode, value);
280 if (value && autorelease) {
281 input_report_key(dev, ke->keycode, 0);
287 value = ke->sw.value;
291 input_report_switch(dev, ke->sw.code, value);
295 EXPORT_SYMBOL(sparse_keymap_report_entry);
298 * sparse_keymap_report_event - report event corresponding to given scancode
299 * @dev: Input device using sparse keymap
301 * @value: Value that should be reported (ignored by %KE_SW entries)
302 * @autorelease: Signals whether release event should be emitted for %KE_KEY
303 * entries right after reporting press event, ignored by all other
306 * This function is used to perform lookup in an input device using sparse
307 * keymap and report corresponding event. Returns %true if lookup was
308 * successful and %false otherwise.
310 bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code,
311 unsigned int value, bool autorelease)
313 const struct key_entry *ke =
314 sparse_keymap_entry_from_scancode(dev, code);
315 struct key_entry unknown_ke;
318 sparse_keymap_report_entry(dev, ke, value, autorelease);
322 /* Report an unknown key event as a debugging aid */
323 unknown_ke.type = KE_KEY;
324 unknown_ke.code = code;
325 unknown_ke.keycode = KEY_UNKNOWN;
326 sparse_keymap_report_entry(dev, &unknown_ke, value, true);
330 EXPORT_SYMBOL(sparse_keymap_report_event);