[linux.git] / drivers / input / sparse-keymap.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Generic support for sparse keymaps
 *
 * Copyright (c) 2009 Dmitry Torokhov
 *
 * Derived from wistron button driver:
 * Copyright (C) 2005 Miloslav Trmac <[email protected]>
 * Copyright (C) 2005 Bernhard Rosenkraenzer <[email protected]>
 * Copyright (C) 2005 Dmitry Torokhov <[email protected]>
 */

#include <linux/input.h>
#include <linux/input/sparse-keymap.h>
#include <linux/module.h>
#include <linux/slab.h>

MODULE_AUTHOR("Dmitry Torokhov <[email protected]>");
MODULE_DESCRIPTION("Generic support for sparse keymaps");
MODULE_LICENSE("GPL v2");

static unsigned int sparse_keymap_get_key_index(struct input_dev *dev,
						const struct key_entry *k)
{
	struct key_entry *key;
	unsigned int idx = 0;

	for (key = dev->keycode; key->type != KE_END; key++) {
		if (key->type == KE_KEY) {
			if (key == k)
				break;
			idx++;
		}
	}

	return idx;
}

static struct key_entry *sparse_keymap_entry_by_index(struct input_dev *dev,
						      unsigned int index)
{
	struct key_entry *key;
	unsigned int key_cnt = 0;

	for (key = dev->keycode; key->type != KE_END; key++)
		if (key->type == KE_KEY)
			if (key_cnt++ == index)
				return key;

	return NULL;
}

/**
 * sparse_keymap_entry_from_scancode - perform sparse keymap lookup
 * @dev: Input device using sparse keymap
 * @code: Scan code
 *
 * This function is used to perform &struct key_entry lookup in an
 * input device using sparse keymap.
 */
struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev,
						    unsigned int code)
{
	struct key_entry *key;

	for (key = dev->keycode; key->type != KE_END; key++)
		if (code == key->code)
			return key;

	return NULL;
}
EXPORT_SYMBOL(sparse_keymap_entry_from_scancode);

/**
 * sparse_keymap_entry_from_keycode - perform sparse keymap lookup
 * @dev: Input device using sparse keymap
 * @keycode: Key code
 *
 * This function is used to perform &struct key_entry lookup in an
 * input device using sparse keymap.
 */
struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev,
						   unsigned int keycode)
{
	struct key_entry *key;

	for (key = dev->keycode; key->type != KE_END; key++)
		if (key->type == KE_KEY && keycode == key->keycode)
			return key;

	return NULL;
}
EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);

static struct key_entry *sparse_keymap_locate(struct input_dev *dev,
					const struct input_keymap_entry *ke)
{
	struct key_entry *key;
	unsigned int scancode;

	if (ke->flags & INPUT_KEYMAP_BY_INDEX)
		key = sparse_keymap_entry_by_index(dev, ke->index);
	else if (input_scancode_to_scalar(ke, &scancode) == 0)
		key = sparse_keymap_entry_from_scancode(dev, scancode);
	else
		key = NULL;

	return key;
}

static int sparse_keymap_getkeycode(struct input_dev *dev,
				    struct input_keymap_entry *ke)
{
	const struct key_entry *key;

	if (dev->keycode) {
		key = sparse_keymap_locate(dev, ke);
		if (key && key->type == KE_KEY) {
			ke->keycode = key->keycode;
			if (!(ke->flags & INPUT_KEYMAP_BY_INDEX))
				ke->index =
					sparse_keymap_get_key_index(dev, key);
			ke->len = sizeof(key->code);
			memcpy(ke->scancode, &key->code, sizeof(key->code));
			return 0;
		}
	}

	return -EINVAL;
}

static int sparse_keymap_setkeycode(struct input_dev *dev,
				    const struct input_keymap_entry *ke,
				    unsigned int *old_keycode)
{
	struct key_entry *key;

	if (dev->keycode) {
		key = sparse_keymap_locate(dev, ke);
		if (key && key->type == KE_KEY) {
			*old_keycode = key->keycode;
			key->keycode = ke->keycode;
			set_bit(ke->keycode, dev->keybit);
			if (!sparse_keymap_entry_from_keycode(dev, *old_keycode))
				clear_bit(*old_keycode, dev->keybit);
			return 0;
		}
	}

	return -EINVAL;
}

/**
 * sparse_keymap_setup - set up sparse keymap for an input device
 * @dev: Input device
 * @keymap: Keymap in form of array of &key_entry structures ending
 *	with %KE_END type entry
 * @setup: Function that can be used to adjust keymap entries
 *	depending on device's needs, may be %NULL
 *
 * The function calculates size and allocates copy of the original
 * keymap after which sets up input device event bits appropriately.
 * The allocated copy of the keymap is automatically freed when it
 * is no longer needed.
 */
int sparse_keymap_setup(struct input_dev *dev,
			const struct key_entry *keymap,
			int (*setup)(struct input_dev *, struct key_entry *))
{
	size_t map_size = 1; /* to account for the last KE_END entry */
	const struct key_entry *e;
	struct key_entry *map, *entry;
	int i;
	int error;

	for (e = keymap; e->type != KE_END; e++)
		map_size++;

	map = devm_kmemdup(&dev->dev, keymap, map_size * sizeof(*map),
			   GFP_KERNEL);
	if (!map)
		return -ENOMEM;

	for (i = 0; i < map_size; i++) {
		entry = &map[i];

		if (setup) {
			error = setup(dev, entry);
			if (error)
				return error;
		}

		switch (entry->type) {
		case KE_KEY:
			__set_bit(EV_KEY, dev->evbit);
			__set_bit(entry->keycode, dev->keybit);
			break;

		case KE_SW:
		case KE_VSW:
			__set_bit(EV_SW, dev->evbit);
			__set_bit(entry->sw.code, dev->swbit);
			break;
		}
	}

	if (test_bit(EV_KEY, dev->evbit)) {
		__set_bit(KEY_UNKNOWN, dev->keybit);
		__set_bit(EV_MSC, dev->evbit);
		__set_bit(MSC_SCAN, dev->mscbit);
	}

	dev->keycode = map;
	dev->keycodemax = map_size;
	dev->getkeycode = sparse_keymap_getkeycode;
	dev->setkeycode = sparse_keymap_setkeycode;

	return 0;
}
EXPORT_SYMBOL(sparse_keymap_setup);

/**
 * sparse_keymap_report_entry - report event corresponding to given key entry
 * @dev: Input device for which event should be reported
 * @ke: key entry describing event
 * @value: Value that should be reported (ignored by %KE_SW entries)
 * @autorelease: Signals whether release event should be emitted for %KE_KEY
 *	entries right after reporting press event, ignored by all other
 *	entries
 *
 * This function is used to report input event described by given
 * &struct key_entry.
 */
void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke,
				unsigned int value, bool autorelease)
{
	switch (ke->type) {
	case KE_KEY:
		input_event(dev, EV_MSC, MSC_SCAN, ke->code);
		input_report_key(dev, ke->keycode, value);
		input_sync(dev);
		if (value && autorelease) {
			input_report_key(dev, ke->keycode, 0);
			input_sync(dev);
		}
		break;

	case KE_SW:
		value = ke->sw.value;
		fallthrough;

	case KE_VSW:
		input_report_switch(dev, ke->sw.code, value);
		input_sync(dev);
		break;
	}
}
EXPORT_SYMBOL(sparse_keymap_report_entry);

/**
 * sparse_keymap_report_event - report event corresponding to given scancode
 * @dev: Input device using sparse keymap
 * @code: Scan code
 * @value: Value that should be reported (ignored by %KE_SW entries)
 * @autorelease: Signals whether release event should be emitted for %KE_KEY
 *	entries right after reporting press event, ignored by all other
 *	entries
 *
 * This function is used to perform lookup in an input device using sparse
 * keymap and report corresponding event. Returns %true if lookup was
 * successful and %false otherwise.
 */
bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code,
				unsigned int value, bool autorelease)
{
	const struct key_entry *ke =
		sparse_keymap_entry_from_scancode(dev, code);
	struct key_entry unknown_ke;

	if (ke) {
		sparse_keymap_report_entry(dev, ke, value, autorelease);
		return true;
	}

	/* Report an unknown key event as a debugging aid */
	unknown_ke.type = KE_KEY;
	unknown_ke.code = code;
	unknown_ke.keycode = KEY_UNKNOWN;
	sparse_keymap_report_entry(dev, &unknown_ke, value, true);

	return false;
}
EXPORT_SYMBOL(sparse_keymap_report_event);
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
36203c4f DT	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 <[email protected]>
	9	* Copyright (C) 2005 Bernhard Rosenkraenzer <[email protected]>
	10	* Copyright (C) 2005 Dmitry Torokhov <[email protected]>
36203c4f DT	11	*/
	12
	13	#include <linux/input.h>
	14	#include <linux/input/sparse-keymap.h>
d2d8442d	15	#include <linux/module.h>
5a0e3ad6	16	#include <linux/slab.h>
36203c4f DT	17
	18	MODULE_AUTHOR("Dmitry Torokhov <[email protected]>");
	19	MODULE_DESCRIPTION("Generic support for sparse keymaps");
	20	MODULE_LICENSE("GPL v2");
36203c4f	21
67127f30 DT	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
	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
36203c4f DT	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	*/
	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	*/
	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
67127f30 DT	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
36203c4f	111	static int sparse_keymap_getkeycode(struct input_dev *dev,
67127f30	112	struct input_keymap_entry *ke)
36203c4f	113	{
2e2e3b96	114	const struct key_entry *key;
36203c4f	115
2e2e3b96	116	if (dev->keycode) {
67127f30	117	key = sparse_keymap_locate(dev, ke);
2e2e3b96	118	if (key && key->type == KE_KEY) {
67127f30 DT	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));
2e2e3b96 DT	125	return 0;
2e2e3b96 DT	126	}
36203c4f DT	127	}
	128
	129	return -EINVAL;
	130	}
	131
	132	static int sparse_keymap_setkeycode(struct input_dev *dev,
67127f30 DT	133	const struct input_keymap_entry *ke,
67127f30 DT	134	unsigned int *old_keycode)
36203c4f DT	135	{
36203c4f DT	136	struct key_entry *key;
36203c4f	137
2e2e3b96	138	if (dev->keycode) {
67127f30	139	key = sparse_keymap_locate(dev, ke);
2e2e3b96	140	if (key && key->type == KE_KEY) {
67127f30 DT	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);
2e2e3b96 DT	146	return 0;
2e2e3b96 DT	147	}
36203c4f DT	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
fabeb165	159	* depending on device's needs, may be %NULL
36203c4f DT	160	*
	161	* The function calculates size and allocates copy of the original
	162	* keymap after which sets up input device event bits appropriately.
fabeb165 MK	163	* The allocated copy of the keymap is automatically freed when it
fabeb165 MK	164	* is no longer needed.
36203c4f DT	165	*/
	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
fabeb165 MK	179	map = devm_kmemdup(&dev->dev, keymap, map_size * sizeof(*map),
fabeb165 MK	180	GFP_KERNEL);
36203c4f DT	181	if (!map)
	182	return -ENOMEM;
	183
36203c4f DT	184	for (i = 0; i < map_size; i++) {
	185	entry = &map[i];
	186
	187	if (setup) {
	188	error = setup(dev, entry);
	189	if (error)
fabeb165	190	return error;
36203c4f DT	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:
cb1b1459	200	case KE_VSW:
36203c4f DT	201	__set_bit(EV_SW, dev->evbit);
	202	__set_bit(entry->sw.code, dev->swbit);
	203	break;
	204	}
	205	}
	206
f3cf5c4f	207	if (test_bit(EV_KEY, dev->evbit)) {
170531ba	208	__set_bit(KEY_UNKNOWN, dev->keybit);
f3cf5c4f SF	209	__set_bit(EV_MSC, dev->evbit);
	210	__set_bit(MSC_SCAN, dev->mscbit);
	211	}
	212
36203c4f DT	213	dev->keycode = map;
36203c4f DT	214	dev->keycodemax = map_size;
aebd636b DT	215	dev->getkeycode = sparse_keymap_getkeycode;
aebd636b DT	216	dev->setkeycode = sparse_keymap_setkeycode;
36203c4f DT	217
36203c4f DT	218	return 0;
36203c4f DT	219	}
	220	EXPORT_SYMBOL(sparse_keymap_setup);
	221
36203c4f DT	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	*/
	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:
f3cf5c4f	239	input_event(dev, EV_MSC, MSC_SCAN, ke->code);
36203c4f DT	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;
6f49c4f5	250	fallthrough;
36203c4f DT	251
	252	case KE_VSW:
	253	input_report_switch(dev, ke->sw.code, value);
6f29c244	254	input_sync(dev);
36203c4f DT	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	*/
	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);
170531ba	278	struct key_entry unknown_ke;
36203c4f DT	279
	280	if (ke) {
	281	sparse_keymap_report_entry(dev, ke, value, autorelease);
	282	return true;
	283	}
	284
170531ba SF	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
36203c4f DT	291	return false;
	292	}
	293	EXPORT_SYMBOL(sparse_keymap_report_event);
	294