1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Generic support for sparse keymaps
4 *
5 * Copyright (c) 2009 Dmitry Torokhov
6 *
7 * Derived from wistron button driver:
8 * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
9 * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
10 * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
11 */
12
13#include <linux/input.h>
14#include <linux/input/sparse-keymap.h>
15#include <linux/module.h>
16#include <linux/slab.h>
17
18MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
19MODULE_DESCRIPTION("Generic support for sparse keymaps");
20MODULE_LICENSE("GPL v2");
21
22static unsigned int sparse_keymap_get_key_index(struct input_dev *dev,
23						const struct key_entry *k)
24{
25	struct key_entry *key;
26	unsigned int idx = 0;
27
28	for (key = dev->keycode; key->type != KE_END; key++) {
29		if (key->type == KE_KEY) {
30			if (key == k)
31				break;
32			idx++;
33		}
34	}
35
36	return idx;
37}
38
39static struct key_entry *sparse_keymap_entry_by_index(struct input_dev *dev,
40						      unsigned int index)
41{
42	struct key_entry *key;
43	unsigned int key_cnt = 0;
44
45	for (key = dev->keycode; key->type != KE_END; key++)
46		if (key->type == KE_KEY)
47			if (key_cnt++ == index)
48				return key;
49
50	return NULL;
51}
52
53/**
54 * sparse_keymap_entry_from_scancode - perform sparse keymap lookup
55 * @dev: Input device using sparse keymap
56 * @code: Scan code
57 *
58 * This function is used to perform &struct key_entry lookup in an
59 * input device using sparse keymap.
60 */
61struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev,
62						    unsigned int code)
63{
64	struct key_entry *key;
65
66	for (key = dev->keycode; key->type != KE_END; key++)
67		if (code == key->code)
68			return key;
69
70	return NULL;
71}
72EXPORT_SYMBOL(sparse_keymap_entry_from_scancode);
73
74/**
75 * sparse_keymap_entry_from_keycode - perform sparse keymap lookup
76 * @dev: Input device using sparse keymap
77 * @keycode: Key code
78 *
79 * This function is used to perform &struct key_entry lookup in an
80 * input device using sparse keymap.
81 */
82struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev,
83						   unsigned int keycode)
84{
85	struct key_entry *key;
86
87	for (key = dev->keycode; key->type != KE_END; key++)
88		if (key->type == KE_KEY && keycode == key->keycode)
89			return key;
90
91	return NULL;
92}
93EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);
94
95static struct key_entry *sparse_keymap_locate(struct input_dev *dev,
96					const struct input_keymap_entry *ke)
97{
98	struct key_entry *key;
99	unsigned int scancode;
100
101	if (ke->flags & INPUT_KEYMAP_BY_INDEX)
102		key = sparse_keymap_entry_by_index(dev, ke->index);
103	else if (input_scancode_to_scalar(ke, &scancode) == 0)
104		key = sparse_keymap_entry_from_scancode(dev, scancode);
105	else
106		key = NULL;
107
108	return key;
109}
110
111static int sparse_keymap_getkeycode(struct input_dev *dev,
112				    struct input_keymap_entry *ke)
113{
114	const struct key_entry *key;
115
116	if (dev->keycode) {
117		key = sparse_keymap_locate(dev, ke);
118		if (key && key->type == KE_KEY) {
119			ke->keycode = key->keycode;
120			if (!(ke->flags & INPUT_KEYMAP_BY_INDEX))
121				ke->index =
122					sparse_keymap_get_key_index(dev, key);
123			ke->len = sizeof(key->code);
124			memcpy(ke->scancode, &key->code, sizeof(key->code));
125			return 0;
126		}
127	}
128
129	return -EINVAL;
130}
131
132static int sparse_keymap_setkeycode(struct input_dev *dev,
133				    const struct input_keymap_entry *ke,
134				    unsigned int *old_keycode)
135{
136	struct key_entry *key;
137
138	if (dev->keycode) {
139		key = sparse_keymap_locate(dev, ke);
140		if (key && key->type == KE_KEY) {
141			*old_keycode = key->keycode;
142			key->keycode = ke->keycode;
143			set_bit(ke->keycode, dev->keybit);
144			if (!sparse_keymap_entry_from_keycode(dev, *old_keycode))
145				clear_bit(*old_keycode, dev->keybit);
146			return 0;
147		}
148	}
149
150	return -EINVAL;
151}
152
153/**
154 * sparse_keymap_setup - set up sparse keymap for an input device
155 * @dev: Input device
156 * @keymap: Keymap in form of array of &key_entry structures ending
157 *	with %KE_END type entry
158 * @setup: Function that can be used to adjust keymap entries
159 *	depending on device's needs, may be %NULL
160 *
161 * The function calculates size and allocates copy of the original
162 * keymap after which sets up input device event bits appropriately.
163 * The allocated copy of the keymap is automatically freed when it
164 * is no longer needed.
165 */
166int sparse_keymap_setup(struct input_dev *dev,
167			const struct key_entry *keymap,
168			int (*setup)(struct input_dev *, struct key_entry *))
169{
170	size_t map_size = 1; /* to account for the last KE_END entry */
171	const struct key_entry *e;
172	struct key_entry *map, *entry;
173	int i;
174	int error;
175
176	for (e = keymap; e->type != KE_END; e++)
177		map_size++;
178
179	map = devm_kmemdup(&dev->dev, keymap, map_size * sizeof(*map),
180			   GFP_KERNEL);
181	if (!map)
182		return -ENOMEM;
183
184	for (i = 0; i < map_size; i++) {
185		entry = &map[i];
186
187		if (setup) {
188			error = setup(dev, entry);
189			if (error)
190				return error;
191		}
192
193		switch (entry->type) {
194		case KE_KEY:
195			__set_bit(EV_KEY, dev->evbit);
196			__set_bit(entry->keycode, dev->keybit);
197			break;
198
199		case KE_SW:
200		case KE_VSW:
201			__set_bit(EV_SW, dev->evbit);
202			__set_bit(entry->sw.code, dev->swbit);
203			break;
204		}
205	}
206
207	if (test_bit(EV_KEY, dev->evbit)) {
208		__set_bit(KEY_UNKNOWN, dev->keybit);
209		__set_bit(EV_MSC, dev->evbit);
210		__set_bit(MSC_SCAN, dev->mscbit);
211	}
212
213	dev->keycode = map;
214	dev->keycodemax = map_size;
215	dev->getkeycode = sparse_keymap_getkeycode;
216	dev->setkeycode = sparse_keymap_setkeycode;
217
218	return 0;
219}
220EXPORT_SYMBOL(sparse_keymap_setup);
221
222/**
223 * sparse_keymap_report_entry - report event corresponding to given key entry
224 * @dev: Input device for which event should be reported
225 * @ke: key entry describing event
226 * @value: Value that should be reported (ignored by %KE_SW entries)
227 * @autorelease: Signals whether release event should be emitted for %KE_KEY
228 *	entries right after reporting press event, ignored by all other
229 *	entries
230 *
231 * This function is used to report input event described by given
232 * &struct key_entry.
233 */
234void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke,
235				unsigned int value, bool autorelease)
236{
237	switch (ke->type) {
238	case KE_KEY:
239		input_event(dev, EV_MSC, MSC_SCAN, ke->code);
240		input_report_key(dev, ke->keycode, value);
241		input_sync(dev);
242		if (value && autorelease) {
243			input_report_key(dev, ke->keycode, 0);
244			input_sync(dev);
245		}
246		break;
247
248	case KE_SW:
249		value = ke->sw.value;
250		fallthrough;
251
252	case KE_VSW:
253		input_report_switch(dev, ke->sw.code, value);
254		input_sync(dev);
255		break;
256	}
257}
258EXPORT_SYMBOL(sparse_keymap_report_entry);
259
260/**
261 * sparse_keymap_report_event - report event corresponding to given scancode
262 * @dev: Input device using sparse keymap
263 * @code: Scan code
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
267 *	entries
268 *
269 * This function is used to perform lookup in an input device using sparse
270 * keymap and report corresponding event. Returns %true if lookup was
271 * successful and %false otherwise.
272 */
273bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code,
274				unsigned int value, bool autorelease)
275{
276	const struct key_entry *ke =
277		sparse_keymap_entry_from_scancode(dev, code);
278	struct key_entry unknown_ke;
279
280	if (ke) {
281		sparse_keymap_report_entry(dev, ke, value, autorelease);
282		return true;
283	}
284
285	/* Report an unknown key event as a debugging aid */
286	unknown_ke.type = KE_KEY;
287	unknown_ke.code = code;
288	unknown_ke.keycode = KEY_UNKNOWN;
289	sparse_keymap_report_entry(dev, &unknown_ke, value, true);
290
291	return false;
292}
293EXPORT_SYMBOL(sparse_keymap_report_event);
294
295