xref: /openbmc/linux/drivers/input/sparse-keymap.c (revision 6f49c4f5)
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 
18 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
19 MODULE_DESCRIPTION("Generic support for sparse keymaps");
20 MODULE_LICENSE("GPL v2");
21 
sparse_keymap_get_key_index(struct input_dev * dev,const struct key_entry * k)22 static 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 
sparse_keymap_entry_by_index(struct input_dev * dev,unsigned int index)39 static 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  */
sparse_keymap_entry_from_scancode(struct input_dev * dev,unsigned int code)61 struct 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 }
72 EXPORT_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  */
sparse_keymap_entry_from_keycode(struct input_dev * dev,unsigned int keycode)82 struct 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 }
93 EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);
94 
sparse_keymap_locate(struct input_dev * dev,const struct input_keymap_entry * ke)95 static 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 
sparse_keymap_getkeycode(struct input_dev * dev,struct input_keymap_entry * ke)111 static 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 
sparse_keymap_setkeycode(struct input_dev * dev,const struct input_keymap_entry * ke,unsigned int * old_keycode)132 static 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  */
sparse_keymap_setup(struct input_dev * dev,const struct key_entry * keymap,int (* setup)(struct input_dev *,struct key_entry *))166 int 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 }
220 EXPORT_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  */
sparse_keymap_report_entry(struct input_dev * dev,const struct key_entry * ke,unsigned int value,bool autorelease)234 void 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 }
258 EXPORT_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  */
sparse_keymap_report_event(struct input_dev * dev,unsigned int code,unsigned int value,bool autorelease)273 bool 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 }
293 EXPORT_SYMBOL(sparse_keymap_report_event);
294 
295