[mirror_ubuntu-artful-kernel.git] / drivers / input / sparse-keymap.c

/*
 * Generic support for sparse keymaps
 *
 * Copyright (c) 2009 Dmitry Torokhov
 *
 * Derived from wistron button driver:
 * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
 * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
 * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */

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

MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
MODULE_DESCRIPTION("Generic support for sparse keymaps");
MODULE_LICENSE("GPL v2");
MODULE_VERSION("0.1");

/**
 * 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 int sparse_keymap_getkeycode(struct input_dev *dev,
				    unsigned int scancode,
				    unsigned int *keycode)
{
	const struct key_entry *key;

	if (dev->keycode) {
		key = sparse_keymap_entry_from_scancode(dev, scancode);
		if (key && key->type == KE_KEY) {
			*keycode = key->keycode;
			return 0;
		}
	}

	return -EINVAL;
}

static int sparse_keymap_setkeycode(struct input_dev *dev,
				    unsigned int scancode,
				    unsigned int keycode)
{
	struct key_entry *key;
	int old_keycode;

	if (dev->keycode) {
		key = sparse_keymap_entry_from_scancode(dev, scancode);
		if (key && key->type == KE_KEY) {
			old_keycode = key->keycode;
			key->keycode = keycode;
			set_bit(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 deeds, may be %NULL
 *
 * The function calculates size and allocates copy of the original
 * keymap after which sets up input device event bits appropriately.
 * Before destroying input device allocated keymap should be freed
 * with a call to sparse_keymap_free().
 */
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 = kcalloc(map_size, sizeof (struct key_entry), GFP_KERNEL);
	if (!map)
		return -ENOMEM;

	memcpy(map, keymap, map_size * sizeof (struct key_entry));

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

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

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

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

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

	return 0;

 err_out:
	kfree(map);
	return error;

}
EXPORT_SYMBOL(sparse_keymap_setup);

/**
 * sparse_keymap_free - free memory allocated for sparse keymap
 * @dev: Input device using sparse keymap
 *
 * This function is used to free memory allocated by sparse keymap
 * in an input device that was set up by sparse_keymap_setup().
 * NOTE: It is safe to cal this function while input device is
 * still registered (however the drivers should care not to try to
 * use freed keymap and thus have to shut off interrups/polling
 * before freeing the keymap).
 */
void sparse_keymap_free(struct input_dev *dev)
{
	unsigned long flags;

	/*
	 * Take event lock to prevent racing with input_get_keycode()
	 * and input_set_keycode() if we are called while input device
	 * is still registered.
	 */
	spin_lock_irqsave(&dev->event_lock, flags);

	kfree(dev->keycode);
	dev->keycode = NULL;
	dev->keycodemax = 0;

	spin_unlock_irqrestore(&dev->event_lock, flags);
}
EXPORT_SYMBOL(sparse_keymap_free);

/**
 * 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_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;
		/* fall through */

	case KE_VSW:
		input_report_switch(dev, ke->sw.code, value);
		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);

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

	return false;
}
EXPORT_SYMBOL(sparse_keymap_report_event);
Commit	Line	Data
36203c4f DT	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>
5a0e3ad6	18	#include <linux/slab.h>
36203c4f DT	19
	20	MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
	21	MODULE_DESCRIPTION("Generic support for sparse keymaps");
	22	MODULE_LICENSE("GPL v2");
	23	MODULE_VERSION("0.1");
	24
	25	/**
	26	* sparse_keymap_entry_from_scancode - perform sparse keymap lookup
	27	* @dev: Input device using sparse keymap
	28	* @code: Scan code
	29	*
	30	* This function is used to perform &struct key_entry lookup in an
	31	* input device using sparse keymap.
	32	*/
	33	struct key_entry sparse_keymap_entry_from_scancode(struct input_dev dev,
	34	unsigned int code)
	35	{
	36	struct key_entry *key;
	37
	38	for (key = dev->keycode; key->type != KE_END; key++)
	39	if (code == key->code)
	40	return key;
	41
	42	return NULL;
	43	}
	44	EXPORT_SYMBOL(sparse_keymap_entry_from_scancode);
	45
	46	/**
	47	* sparse_keymap_entry_from_keycode - perform sparse keymap lookup
	48	* @dev: Input device using sparse keymap
	49	* @keycode: Key code
	50	*
	51	* This function is used to perform &struct key_entry lookup in an
	52	* input device using sparse keymap.
	53	*/
	54	struct key_entry sparse_keymap_entry_from_keycode(struct input_dev dev,
	55	unsigned int keycode)
	56	{
	57	struct key_entry *key;
	58
	59	for (key = dev->keycode; key->type != KE_END; key++)
	60	if (key->type == KE_KEY && keycode == key->keycode)
	61	return key;
	62
	63	return NULL;
	64	}
	65	EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);
	66
	67	static int sparse_keymap_getkeycode(struct input_dev *dev,
58b93995 DT	68	unsigned int scancode,
58b93995 DT	69	unsigned int *keycode)
36203c4f	70	{
2e2e3b96	71	const struct key_entry *key;
36203c4f	72
2e2e3b96 DT	73	if (dev->keycode) {
	74	key = sparse_keymap_entry_from_scancode(dev, scancode);
	75	if (key && key->type == KE_KEY) {
	76	*keycode = key->keycode;
	77	return 0;
	78	}
36203c4f DT	79	}
	80
	81	return -EINVAL;
	82	}
	83
	84	static int sparse_keymap_setkeycode(struct input_dev *dev,
58b93995 DT	85	unsigned int scancode,
58b93995 DT	86	unsigned int keycode)
36203c4f DT	87	{
	88	struct key_entry *key;
	89	int old_keycode;
	90
2e2e3b96 DT	91	if (dev->keycode) {
	92	key = sparse_keymap_entry_from_scancode(dev, scancode);
	93	if (key && key->type == KE_KEY) {
	94	old_keycode = key->keycode;
	95	key->keycode = keycode;
	96	set_bit(keycode, dev->keybit);
	97	if (!sparse_keymap_entry_from_keycode(dev, old_keycode))
	98	clear_bit(old_keycode, dev->keybit);
	99	return 0;
	100	}
36203c4f DT	101	}
	102
	103	return -EINVAL;
	104	}
	105
	106	/**
	107	* sparse_keymap_setup - set up sparse keymap for an input device
	108	* @dev: Input device
	109	* @keymap: Keymap in form of array of &key_entry structures ending
	110	* with %KE_END type entry
	111	* @setup: Function that can be used to adjust keymap entries
	112	* depending on device's deeds, may be %NULL
	113	*
	114	* The function calculates size and allocates copy of the original
	115	* keymap after which sets up input device event bits appropriately.
	116	* Before destroying input device allocated keymap should be freed
	117	* with a call to sparse_keymap_free().
	118	*/
	119	int sparse_keymap_setup(struct input_dev *dev,
	120	const struct key_entry *keymap,
	121	int (setup)(struct input_dev , struct key_entry *))
	122	{
	123	size_t map_size = 1; /* to account for the last KE_END entry */
	124	const struct key_entry *e;
	125	struct key_entry map, entry;
	126	int i;
	127	int error;
	128
	129	for (e = keymap; e->type != KE_END; e++)
	130	map_size++;
	131
	132	map = kcalloc(map_size, sizeof (struct key_entry), GFP_KERNEL);
	133	if (!map)
	134	return -ENOMEM;
	135
	136	memcpy(map, keymap, map_size * sizeof (struct key_entry));
	137
	138	for (i = 0; i < map_size; i++) {
	139	entry = &map[i];
	140
	141	if (setup) {
	142	error = setup(dev, entry);
	143	if (error)
	144	goto err_out;
	145	}
	146
	147	switch (entry->type) {
	148	case KE_KEY:
	149	__set_bit(EV_KEY, dev->evbit);
	150	__set_bit(entry->keycode, dev->keybit);
	151	break;
	152
	153	case KE_SW:
	154	__set_bit(EV_SW, dev->evbit);
	155	__set_bit(entry->sw.code, dev->swbit);
	156	break;
	157	}
	158	}
	159
	160	dev->keycode = map;
	161	dev->keycodemax = map_size;
	162	dev->getkeycode = sparse_keymap_getkeycode;
	163	dev->setkeycode = sparse_keymap_setkeycode;
	164
165	return 0;
166
167	err_out:
88fcf710	168	kfree(map);
36203c4f DT	169	return error;
	170
	171	}
	172	EXPORT_SYMBOL(sparse_keymap_setup);
	173
	174	/**
	175	* sparse_keymap_free - free memory allocated for sparse keymap
	176	* @dev: Input device using sparse keymap
	177	*
	178	* This function is used to free memory allocated by sparse keymap
	179	* in an input device that was set up by sparse_keymap_setup().
2e2e3b96 DT	180	* NOTE: It is safe to cal this function while input device is
	181	* still registered (however the drivers should care not to try to
	182	* use freed keymap and thus have to shut off interrups/polling
	183	* before freeing the keymap).
36203c4f DT	184	*/
	185	void sparse_keymap_free(struct input_dev *dev)
	186	{
2e2e3b96 DT	187	unsigned long flags;
	188
	189	/*
	190	* Take event lock to prevent racing with input_get_keycode()
	191	* and input_set_keycode() if we are called while input device
	192	* is still registered.
	193	*/
	194	spin_lock_irqsave(&dev->event_lock, flags);
	195
36203c4f DT	196	kfree(dev->keycode);
	197	dev->keycode = NULL;
	198	dev->keycodemax = 0;
2e2e3b96 DT	199
2e2e3b96 DT	200	spin_unlock_irqrestore(&dev->event_lock, flags);
36203c4f DT	201	}
	202	EXPORT_SYMBOL(sparse_keymap_free);
	203
	204	/**
	205	* sparse_keymap_report_entry - report event corresponding to given key entry
	206	* @dev: Input device for which event should be reported
	207	* @ke: key entry describing event
	208	* @value: Value that should be reported (ignored by %KE_SW entries)
	209	* @autorelease: Signals whether release event should be emitted for %KE_KEY
	210	* entries right after reporting press event, ignored by all other
	211	* entries
	212	*
	213	* This function is used to report input event described by given
	214	* &struct key_entry.
	215	*/
	216	void sparse_keymap_report_entry(struct input_dev dev, const struct key_entry ke,
	217	unsigned int value, bool autorelease)
	218	{
	219	switch (ke->type) {
	220	case KE_KEY:
	221	input_report_key(dev, ke->keycode, value);
	222	input_sync(dev);
	223	if (value && autorelease) {
	224	input_report_key(dev, ke->keycode, 0);
	225	input_sync(dev);
	226	}
	227	break;
	228
	229	case KE_SW:
	230	value = ke->sw.value;
	231	/* fall through */
	232
	233	case KE_VSW:
	234	input_report_switch(dev, ke->sw.code, value);
	235	break;
	236	}
	237	}
	238	EXPORT_SYMBOL(sparse_keymap_report_entry);
	239
	240	/**
	241	* sparse_keymap_report_event - report event corresponding to given scancode
	242	* @dev: Input device using sparse keymap
	243	* @code: Scan code
	244	* @value: Value that should be reported (ignored by %KE_SW entries)
	245	* @autorelease: Signals whether release event should be emitted for %KE_KEY
	246	* entries right after reporting press event, ignored by all other
	247	* entries
	248	*
	249	* This function is used to perform lookup in an input device using sparse
	250	* keymap and report corresponding event. Returns %true if lookup was
	251	* successful and %false otherwise.
	252	*/
	253	bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code,
	254	unsigned int value, bool autorelease)
	255	{
	256	const struct key_entry *ke =
	257	sparse_keymap_entry_from_scancode(dev, code);
	258
	259	if (ke) {
	260	sparse_keymap_report_entry(dev, ke, value, autorelease);
	261	return true;
	262	}
	263
	264	return false;
265	}
266	EXPORT_SYMBOL(sparse_keymap_report_event);
267