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>
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");
25 * sparse_keymap_entry_from_scancode - perform sparse keymap lookup
26 * @dev: Input device using sparse keymap
29 * This function is used to perform &struct key_entry lookup in an
30 * input device using sparse keymap.
32 struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev,
35 struct key_entry *key;
37 for (key = dev->keycode; key->type != KE_END; key++)
38 if (code == key->code)
43 EXPORT_SYMBOL(sparse_keymap_entry_from_scancode);
46 * sparse_keymap_entry_from_keycode - perform sparse keymap lookup
47 * @dev: Input device using sparse keymap
50 * This function is used to perform &struct key_entry lookup in an
51 * input device using sparse keymap.
53 struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev,
56 struct key_entry *key;
58 for (key = dev->keycode; key->type != KE_END; key++)
59 if (key->type == KE_KEY && keycode == key->keycode)
64 EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);
66 static int sparse_keymap_getkeycode(struct input_dev *dev,
67 unsigned int scancode,
68 unsigned int *keycode)
70 const struct key_entry *key =
71 sparse_keymap_entry_from_scancode(dev, scancode);
73 if (key && key->type == KE_KEY) {
74 *keycode = key->keycode;
81 static int sparse_keymap_setkeycode(struct input_dev *dev,
82 unsigned int scancode,
85 struct key_entry *key;
88 if (keycode < 0 || keycode > KEY_MAX)
91 key = sparse_keymap_entry_from_scancode(dev, scancode);
92 if (key && key->type == KE_KEY) {
93 old_keycode = key->keycode;
94 key->keycode = keycode;
95 set_bit(keycode, dev->keybit);
96 if (!sparse_keymap_entry_from_keycode(dev, old_keycode))
97 clear_bit(old_keycode, dev->keybit);
105 * sparse_keymap_setup - set up sparse keymap for an input device
107 * @keymap: Keymap in form of array of &key_entry structures ending
108 * with %KE_END type entry
109 * @setup: Function that can be used to adjust keymap entries
110 * depending on device's deeds, may be %NULL
112 * The function calculates size and allocates copy of the original
113 * keymap after which sets up input device event bits appropriately.
114 * Before destroying input device allocated keymap should be freed
115 * with a call to sparse_keymap_free().
117 int sparse_keymap_setup(struct input_dev *dev,
118 const struct key_entry *keymap,
119 int (*setup)(struct input_dev *, struct key_entry *))
121 size_t map_size = 1; /* to account for the last KE_END entry */
122 const struct key_entry *e;
123 struct key_entry *map, *entry;
127 for (e = keymap; e->type != KE_END; e++)
130 map = kcalloc(map_size, sizeof (struct key_entry), GFP_KERNEL);
134 memcpy(map, keymap, map_size * sizeof (struct key_entry));
136 for (i = 0; i < map_size; i++) {
140 error = setup(dev, entry);
145 switch (entry->type) {
147 __set_bit(EV_KEY, dev->evbit);
148 __set_bit(entry->keycode, dev->keybit);
152 __set_bit(EV_SW, dev->evbit);
153 __set_bit(entry->sw.code, dev->swbit);
159 dev->keycodemax = map_size;
160 dev->getkeycode = sparse_keymap_getkeycode;
161 dev->setkeycode = sparse_keymap_setkeycode;
170 EXPORT_SYMBOL(sparse_keymap_setup);
173 * sparse_keymap_free - free memory allocated for sparse keymap
174 * @dev: Input device using sparse keymap
176 * This function is used to free memory allocated by sparse keymap
177 * in an input device that was set up by sparse_keymap_setup().
179 void sparse_keymap_free(struct input_dev *dev)
184 dev->getkeycode = NULL;
185 dev->setkeycode = NULL;
187 EXPORT_SYMBOL(sparse_keymap_free);
190 * sparse_keymap_report_entry - report event corresponding to given key entry
191 * @dev: Input device for which event should be reported
192 * @ke: key entry describing event
193 * @value: Value that should be reported (ignored by %KE_SW entries)
194 * @autorelease: Signals whether release event should be emitted for %KE_KEY
195 * entries right after reporting press event, ignored by all other
198 * This function is used to report input event described by given
201 void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke,
202 unsigned int value, bool autorelease)
206 input_report_key(dev, ke->keycode, value);
208 if (value && autorelease) {
209 input_report_key(dev, ke->keycode, 0);
215 value = ke->sw.value;
219 input_report_switch(dev, ke->sw.code, value);
223 EXPORT_SYMBOL(sparse_keymap_report_entry);
226 * sparse_keymap_report_event - report event corresponding to given scancode
227 * @dev: Input device using sparse keymap
229 * @value: Value that should be reported (ignored by %KE_SW entries)
230 * @autorelease: Signals whether release event should be emitted for %KE_KEY
231 * entries right after reporting press event, ignored by all other
234 * This function is used to perform lookup in an input device using sparse
235 * keymap and report corresponding event. Returns %true if lookup was
236 * successful and %false otherwise.
238 bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code,
239 unsigned int value, bool autorelease)
241 const struct key_entry *ke =
242 sparse_keymap_entry_from_scancode(dev, code);
245 sparse_keymap_report_entry(dev, ke, value, autorelease);
251 EXPORT_SYMBOL(sparse_keymap_report_event);