Input: add generic support for sparse keymaps (36203c4f) · Commits · e / devices / android_kernel_teracube_emerald

Documentation/DocBook/device-drivers.tmpl

+4 −0

Original line number	Diff line number	Diff line
		@@ -306,6 +306,10 @@ X!Idrivers/video/console/fonts.c
		<sect1><title>Matrix keyboars/keypads</title>
		!Iinclude/linux/input/matrix_keypad.h
		</sect1>
		<sect1><title>Sparse keymap support</title>
		!Iinclude/linux/input/sparse-keymap.h
		!Edrivers/input/sparse-keymap.c
		</sect1>
		</chapter>

		<chapter id="spi">

drivers/input/Kconfig

+20 −8

Original line number	Diff line number	Diff line
		@@ -8,7 +8,7 @@ menu "Input device support"
		config INPUT
		tristate "Generic input layer (needed for keyboard, mouse, ...)" if EMBEDDED
		default y
		---help---
		help
		Say Y here if you have any input device (mouse, keyboard, tablet,
		joystick, steering wheel ...) connected to your system and want
		it to be available to applications. This includes standard PS/2
		@@ -27,8 +27,7 @@ if INPUT

		config INPUT_FF_MEMLESS
		tristate "Support for memoryless force-feedback devices"
		default n
		---help---
		help
		Say Y here if you have memoryless force-feedback input device
		such as Logitech WingMan Force 3D, ThrustMaster FireStorm Dual
		Power 2, or similar. You will also need to enable hardware-specific
		@@ -52,12 +51,25 @@ config INPUT_POLLDEV
		To compile this driver as a module, choose M here: the
		module will be called input-polldev.

		config INPUT_SPARSEKMAP
		tristate "Sparse keymap support library"
		help
		Say Y here if you are using a driver for an input
		device that uses sparse keymap. This option is only
		useful for out-of-tree drivers since in-tree drivers
		select it automatically.

		If unsure, say N.

		To compile this driver as a module, choose M here: the
		module will be called sparse-keymap.

		comment "Userland interfaces"

		config INPUT_MOUSEDEV
		tristate "Mouse interface" if EMBEDDED
		default y
		---help---
		help
		Say Y here if you want your mouse to be accessible as char devices
		13:32+ - /dev/input/mouseX and 13:63 - /dev/input/mice as an
		emulated IntelliMouse Explorer PS/2 mouse. That way, all user space
		@@ -73,7 +85,7 @@ config INPUT_MOUSEDEV_PSAUX
		bool "Provide legacy /dev/psaux device"
		default y
		depends on INPUT_MOUSEDEV
		---help---
		help
		Say Y here if you want your mouse also be accessible as char device
		10:1 - /dev/psaux. The data available through /dev/psaux is exactly
		the same as the data from /dev/input/mice.
		@@ -103,7 +115,7 @@ config INPUT_MOUSEDEV_SCREEN_Y

		config INPUT_JOYDEV
		tristate "Joystick interface"
		---help---
		help
		Say Y here if you want your joystick or gamepad to be
		accessible as char device 13:0+ - /dev/input/jsX device.

		@@ -125,7 +137,7 @@ config INPUT_EVDEV

		config INPUT_EVBUG
		tristate "Event debugging"
		---help---
		help
		Say Y here if you have a problem with the input subsystem and
		want all events (keypresses, mouse movements), to be output to
		the system log. While this is useful for debugging, it's also
		@@ -140,7 +152,7 @@ config INPUT_EVBUG
		config INPUT_APMPOWER
		tristate "Input Power Event -> APM Bridge" if EMBEDDED
		depends on INPUT && APM_EMULATION
		---help---
		help
		Say Y here if you want suspend key events to trigger a user
		requested suspend through APM. This is useful on embedded
		systems where such behaviour is desired without userspace

drivers/input/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -9,6 +9,7 @@ input-core-objs := input.o input-compat.o ff-core.o

		obj-$(CONFIG_INPUT_FF_MEMLESS) += ff-memless.o
		obj-$(CONFIG_INPUT_POLLDEV) += input-polldev.o
		obj-$(CONFIG_INPUT_SPARSEKMAP) += sparse-keymap.o

		obj-$(CONFIG_INPUT_MOUSEDEV) += mousedev.o
		obj-$(CONFIG_INPUT_JOYDEV) += joydev.o

drivers/input/input-polldev.c

+10 −4

Original line number	Diff line number	Diff line
		@@ -212,7 +212,7 @@ EXPORT_SYMBOL(input_allocate_polled_device);
		* @dev: device to free
		*
		* The function frees memory allocated for polling device and drops
		* reference to the associated input device (if present).
		* reference to the associated input device.
		*/
		void input_free_polled_device(struct input_polled_dev *dev)
		{
		@@ -258,6 +258,15 @@ int input_register_polled_device(struct input_polled_dev *dev)
		return error;
		}

		/*
		* Take extra reference to the underlying input device so
		* that it survives call to input_unregister_polled_device()
		* and is deleted only after input_free_polled_device()
		* has been invoked. This is needed to ease task of freeing
		* sparse keymaps.
		*/
		input_get_device(input);

		return 0;
		}
		EXPORT_SYMBOL(input_register_polled_device);
		@@ -269,8 +278,6 @@ EXPORT_SYMBOL(input_register_polled_device);
		* The function unregisters previously registered polled input
		* device from input layer. Polling is stopped and device is
		* ready to be freed with call to input_free_polled_device().
		* Callers should not attempt to access dev->input pointer
		* after calling this function.
		*/
		void input_unregister_polled_device(struct input_polled_dev *dev)
		{
		@@ -278,7 +285,6 @@ void input_unregister_polled_device(struct input_polled_dev *dev)
		&input_polldev_attribute_group);

		input_unregister_device(dev->input);
		dev->input = NULL;
		}
		EXPORT_SYMBOL(input_unregister_polled_device);

drivers/input/sparse-keymap.c

0 → 100644

+250 −0

Original line number	Diff line number	Diff line
		/*
		* 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>

		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,
		int scancode, int *keycode)
		{
		const struct key_entry *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,
		int scancode, int keycode)
		{
		struct key_entry *key;
		int old_keycode;

		if (keycode < 0 \|\| keycode > KEY_MAX)
		return -EINVAL;

		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(keymap);
		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().
		*/
		void sparse_keymap_free(struct input_dev *dev)
		{
		kfree(dev->keycode);
		dev->keycode = NULL;
		dev->keycodemax = 0;
		dev->getkeycode = NULL;
		dev->setkeycode = NULL;
		}
		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);