blob: fbd3987af57f7291ad12488567772f8f404b319f [file] [log] [blame]
Dmitry Torokhov36203c42009-12-04 10:22:23 -08001/*
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
19MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
20MODULE_DESCRIPTION("Generic support for sparse keymaps");
21MODULE_LICENSE("GPL v2");
22MODULE_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 */
32struct 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}
43EXPORT_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 */
53struct 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}
64EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);
65
66static 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
80static 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 */
115int 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}
168EXPORT_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 */
177void 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}
185EXPORT_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 */
199void 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}
221EXPORT_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 */
236bool 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}
249EXPORT_SYMBOL(sparse_keymap_report_event);
250