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 
sparse_keymap_get_key_index(struct input_dev * dev,const struct key_entry * k)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 
sparse_keymap_entry_by_index(struct input_dev * dev,unsigned int index)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  */
sparse_keymap_entry_from_scancode(struct input_dev * dev,unsigned int code)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  */
sparse_keymap_entry_from_keycode(struct input_dev * dev,unsigned int keycode)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 
sparse_keymap_locate(struct input_dev * dev,const struct input_keymap_entry * ke)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 
sparse_keymap_getkeycode(struct input_dev * dev,struct input_keymap_entry * ke)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 
sparse_keymap_setkeycode(struct input_dev * dev,const struct input_keymap_entry * ke,unsigned int * old_keycode)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 deeds, 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  * Before destroying input device allocated keymap should be freed
168  * with a call to sparse_keymap_free().
169  */
sparse_keymap_setup(struct input_dev * dev,const struct key_entry * keymap,int (* setup)(struct input_dev *,struct key_entry *))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 = kcalloc(map_size, sizeof (struct key_entry), GFP_KERNEL);
184 	if (!map)
185 		return -ENOMEM;
186 
187 	memcpy(map, keymap, map_size * sizeof (struct key_entry));
188 
189 	for (i = 0; i < map_size; i++) {
190 		entry = &map[i];
191 
192 		if (setup) {
193 			error = setup(dev, entry);
194 			if (error)
195 				goto err_out;
196 		}
197 
198 		switch (entry->type) {
199 		case KE_KEY:
200 			__set_bit(EV_KEY, dev->evbit);
201 			__set_bit(entry->keycode, dev->keybit);
202 			break;
203 
204 		case KE_SW:
205 		case KE_VSW:
206 			__set_bit(EV_SW, dev->evbit);
207 			__set_bit(entry->sw.code, dev->swbit);
208 			break;
209 		}
210 	}
211 
212 	if (test_bit(EV_KEY, dev->evbit)) {
213 		__set_bit(KEY_UNKNOWN, dev->keybit);
214 		__set_bit(EV_MSC, dev->evbit);
215 		__set_bit(MSC_SCAN, dev->mscbit);
216 	}
217 
218 	dev->keycode = map;
219 	dev->keycodemax = map_size;
220 	dev->getkeycode = sparse_keymap_getkeycode;
221 	dev->setkeycode = sparse_keymap_setkeycode;
222 
223 	return 0;
224 
225  err_out:
226 	kfree(map);
227 	return error;
228 }
229 EXPORT_SYMBOL(sparse_keymap_setup);
230 
231 /**
232  * sparse_keymap_free - free memory allocated for sparse keymap
233  * @dev: Input device using sparse keymap
234  *
235  * This function is used to free memory allocated by sparse keymap
236  * in an input device that was set up by sparse_keymap_setup().
237  * NOTE: It is safe to cal this function while input device is
238  * still registered (however the drivers should care not to try to
239  * use freed keymap and thus have to shut off interrups/polling
240  * before freeing the keymap).
241  */
sparse_keymap_free(struct input_dev * dev)242 void sparse_keymap_free(struct input_dev *dev)
243 {
244 	unsigned long flags;
245 
246 	/*
247 	 * Take event lock to prevent racing with input_get_keycode()
248 	 * and input_set_keycode() if we are called while input device
249 	 * is still registered.
250 	 */
251 	spin_lock_irqsave(&dev->event_lock, flags);
252 
253 	kfree(dev->keycode);
254 	dev->keycode = NULL;
255 	dev->keycodemax = 0;
256 
257 	spin_unlock_irqrestore(&dev->event_lock, flags);
258 }
259 EXPORT_SYMBOL(sparse_keymap_free);
260 
261 /**
262  * sparse_keymap_report_entry - report event corresponding to given key entry
263  * @dev: Input device for which event should be reported
264  * @ke: key entry describing event
265  * @value: Value that should be reported (ignored by %KE_SW entries)
266  * @autorelease: Signals whether release event should be emitted for %KE_KEY
267  *	entries right after reporting press event, ignored by all other
268  *	entries
269  *
270  * This function is used to report input event described by given
271  * &struct key_entry.
272  */
sparse_keymap_report_entry(struct input_dev * dev,const struct key_entry * ke,unsigned int value,bool autorelease)273 void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke,
274 				unsigned int value, bool autorelease)
275 {
276 	switch (ke->type) {
277 	case KE_KEY:
278 		input_event(dev, EV_MSC, MSC_SCAN, ke->code);
279 		input_report_key(dev, ke->keycode, value);
280 		input_sync(dev);
281 		if (value && autorelease) {
282 			input_report_key(dev, ke->keycode, 0);
283 			input_sync(dev);
284 		}
285 		break;
286 
287 	case KE_SW:
288 		value = ke->sw.value;
289 		/* fall through */
290 
291 	case KE_VSW:
292 		input_report_switch(dev, ke->sw.code, value);
293 		break;
294 	}
295 }
296 EXPORT_SYMBOL(sparse_keymap_report_entry);
297 
298 /**
299  * sparse_keymap_report_event - report event corresponding to given scancode
300  * @dev: Input device using sparse keymap
301  * @code: Scan code
302  * @value: Value that should be reported (ignored by %KE_SW entries)
303  * @autorelease: Signals whether release event should be emitted for %KE_KEY
304  *	entries right after reporting press event, ignored by all other
305  *	entries
306  *
307  * This function is used to perform lookup in an input device using sparse
308  * keymap and report corresponding event. Returns %true if lookup was
309  * successful and %false otherwise.
310  */
sparse_keymap_report_event(struct input_dev * dev,unsigned int code,unsigned int value,bool autorelease)311 bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code,
312 				unsigned int value, bool autorelease)
313 {
314 	const struct key_entry *ke =
315 		sparse_keymap_entry_from_scancode(dev, code);
316 	struct key_entry unknown_ke;
317 
318 	if (ke) {
319 		sparse_keymap_report_entry(dev, ke, value, autorelease);
320 		return true;
321 	}
322 
323 	/* Report an unknown key event as a debugging aid */
324 	unknown_ke.type = KE_KEY;
325 	unknown_ke.code = code;
326 	unknown_ke.keycode = KEY_UNKNOWN;
327 	sparse_keymap_report_entry(dev, &unknown_ke, value, true);
328 
329 	return false;
330 }
331 EXPORT_SYMBOL(sparse_keymap_report_event);
332 
333