drivers/input/sparse-keymap.c - android_kernel_htc_msm8960 - Gitiles

 /*
  * 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");

 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 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:
 		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;

  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_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;
 		/* 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);
 	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);
	/*
	* 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");

	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 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:
	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;

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