2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* The input core
|
|
|
|
*
|
|
|
|
* Copyright (c) 1999-2002 Vojtech Pavlik
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2010-11-30 14:33:07 +07:00
|
|
|
#define pr_fmt(fmt) KBUILD_BASENAME ": " fmt
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/init.h>
|
2009-09-16 15:06:43 +07:00
|
|
|
#include <linux/types.h>
|
2012-10-08 23:07:24 +07:00
|
|
|
#include <linux/idr.h>
|
2010-11-27 15:16:48 +07:00
|
|
|
#include <linux/input/mt.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/module.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/random.h>
|
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/proc_fs.h>
|
2009-10-04 19:11:37 +07:00
|
|
|
#include <linux/sched.h>
|
2006-04-02 12:09:34 +07:00
|
|
|
#include <linux/seq_file.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/poll.h>
|
|
|
|
#include <linux/device.h>
|
2006-02-19 12:21:46 +07:00
|
|
|
#include <linux/mutex.h>
|
2007-08-30 11:22:11 +07:00
|
|
|
#include <linux/rcupdate.h>
|
2010-01-11 15:05:43 +07:00
|
|
|
#include "input-compat.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
|
|
|
|
MODULE_DESCRIPTION("Input core");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2012-10-08 23:07:24 +07:00
|
|
|
#define INPUT_MAX_CHAR_DEVICES 1024
|
|
|
|
#define INPUT_FIRST_DYNAMIC_DEV 256
|
|
|
|
static DEFINE_IDA(input_ida);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static LIST_HEAD(input_dev_list);
|
|
|
|
static LIST_HEAD(input_handler_list);
|
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/*
|
|
|
|
* input_mutex protects access to both input_dev_list and input_handler_list.
|
|
|
|
* This also causes input_[un]register_device and input_[un]register_handler
|
|
|
|
* be mutually exclusive which simplifies locking in drivers implementing
|
|
|
|
* input handlers.
|
|
|
|
*/
|
|
|
|
static DEFINE_MUTEX(input_mutex);
|
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
static const struct input_value input_value_sync = { EV_SYN, SYN_REPORT, 1 };
|
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
static inline int is_event_supported(unsigned int code,
|
|
|
|
unsigned long *bm, unsigned int max)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-08-30 11:22:11 +07:00
|
|
|
return code <= max && test_bit(code, bm);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
static int input_defuzz_abs_event(int value, int old_val, int fuzz)
|
|
|
|
{
|
|
|
|
if (fuzz) {
|
|
|
|
if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
|
|
|
|
return old_val;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
if (value > old_val - fuzz && value < old_val + fuzz)
|
|
|
|
return (old_val * 3 + value) / 4;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
|
|
|
|
return (old_val + value) / 2;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
return value;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-08-11 02:36:15 +07:00
|
|
|
static void input_start_autorepeat(struct input_dev *dev, int code)
|
|
|
|
{
|
|
|
|
if (test_bit(EV_REP, dev->evbit) &&
|
|
|
|
dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
|
|
|
|
dev->timer.data) {
|
|
|
|
dev->repeat_key = code;
|
|
|
|
mod_timer(&dev->timer,
|
|
|
|
jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void input_stop_autorepeat(struct input_dev *dev)
|
|
|
|
{
|
|
|
|
del_timer(&dev->timer);
|
|
|
|
}
|
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/*
|
2010-01-30 14:59:12 +07:00
|
|
|
* Pass event first through all filters and then, if event has not been
|
|
|
|
* filtered out, through all open handles. This function is called with
|
2007-10-14 02:46:55 +07:00
|
|
|
* dev->event_lock held and interrupts disabled.
|
2007-08-30 11:22:11 +07:00
|
|
|
*/
|
2012-09-15 20:23:35 +07:00
|
|
|
static unsigned int input_to_handler(struct input_handle *handle,
|
|
|
|
struct input_value *vals, unsigned int count)
|
2007-08-30 11:22:11 +07:00
|
|
|
{
|
2012-09-15 20:23:35 +07:00
|
|
|
struct input_handler *handler = handle->handler;
|
|
|
|
struct input_value *end = vals;
|
|
|
|
struct input_value *v;
|
2007-10-14 02:46:55 +07:00
|
|
|
|
2015-01-09 04:47:37 +07:00
|
|
|
if (handler->filter) {
|
|
|
|
for (v = vals; v != vals + count; v++) {
|
|
|
|
if (handler->filter(handle, v->type, v->code, v->value))
|
|
|
|
continue;
|
|
|
|
if (end != v)
|
|
|
|
*end = *v;
|
|
|
|
end++;
|
|
|
|
}
|
|
|
|
count = end - vals;
|
2012-09-15 20:23:35 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
if (!count)
|
|
|
|
return 0;
|
2010-01-30 14:59:12 +07:00
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
if (handler->events)
|
|
|
|
handler->events(handle, vals, count);
|
|
|
|
else if (handler->event)
|
2015-01-09 04:47:37 +07:00
|
|
|
for (v = vals; v != vals + count; v++)
|
2012-09-15 20:23:35 +07:00
|
|
|
handler->event(handle, v->type, v->code, v->value);
|
2010-01-30 14:59:12 +07:00
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
return count;
|
|
|
|
}
|
2010-01-30 14:59:12 +07:00
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
/*
|
|
|
|
* Pass values first through all filters and then, if event has not been
|
|
|
|
* filtered out, through all open handles. This function is called with
|
|
|
|
* dev->event_lock held and interrupts disabled.
|
|
|
|
*/
|
|
|
|
static void input_pass_values(struct input_dev *dev,
|
|
|
|
struct input_value *vals, unsigned int count)
|
2007-08-30 11:22:11 +07:00
|
|
|
{
|
2007-10-14 02:46:55 +07:00
|
|
|
struct input_handle *handle;
|
2012-09-15 20:23:35 +07:00
|
|
|
struct input_value *v;
|
2010-01-30 14:59:12 +07:00
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
if (!count)
|
|
|
|
return;
|
2007-10-14 02:46:55 +07:00
|
|
|
|
|
|
|
rcu_read_lock();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-14 02:46:55 +07:00
|
|
|
handle = rcu_dereference(dev->grab);
|
2012-09-15 20:23:35 +07:00
|
|
|
if (handle) {
|
|
|
|
count = input_to_handler(handle, vals, count);
|
|
|
|
} else {
|
|
|
|
list_for_each_entry_rcu(handle, &dev->h_list, d_node)
|
2015-01-09 04:47:37 +07:00
|
|
|
if (handle->open) {
|
2012-09-15 20:23:35 +07:00
|
|
|
count = input_to_handler(handle, vals, count);
|
2015-01-09 04:47:37 +07:00
|
|
|
if (!count)
|
|
|
|
break;
|
|
|
|
}
|
2010-01-30 14:59:12 +07:00
|
|
|
}
|
|
|
|
|
2007-10-14 02:46:55 +07:00
|
|
|
rcu_read_unlock();
|
2010-01-30 14:59:12 +07:00
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
add_input_randomness(vals->type, vals->code, vals->value);
|
2010-01-30 14:59:12 +07:00
|
|
|
|
2012-08-11 02:36:15 +07:00
|
|
|
/* trigger auto repeat for key events */
|
2015-01-09 04:41:24 +07:00
|
|
|
if (test_bit(EV_REP, dev->evbit) && test_bit(EV_KEY, dev->evbit)) {
|
|
|
|
for (v = vals; v != vals + count; v++) {
|
|
|
|
if (v->type == EV_KEY && v->value != 2) {
|
|
|
|
if (v->value)
|
|
|
|
input_start_autorepeat(dev, v->code);
|
|
|
|
else
|
|
|
|
input_stop_autorepeat(dev);
|
|
|
|
}
|
2010-01-30 14:59:12 +07:00
|
|
|
}
|
|
|
|
}
|
2012-09-15 20:23:35 +07:00
|
|
|
}
|
2010-01-30 14:59:12 +07:00
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
static void input_pass_event(struct input_dev *dev,
|
|
|
|
unsigned int type, unsigned int code, int value)
|
|
|
|
{
|
|
|
|
struct input_value vals[] = { { type, code, value } };
|
|
|
|
|
|
|
|
input_pass_values(dev, vals, ARRAY_SIZE(vals));
|
2007-08-30 11:22:11 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/*
|
|
|
|
* Generate software autorepeat event. Note that we take
|
|
|
|
* dev->event_lock here to avoid racing with input_event
|
|
|
|
* which may cause keys get "stuck".
|
|
|
|
*/
|
|
|
|
static void input_repeat_key(unsigned long data)
|
|
|
|
{
|
|
|
|
struct input_dev *dev = (void *) data;
|
|
|
|
unsigned long flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
if (test_bit(dev->repeat_key, dev->key) &&
|
|
|
|
is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
|
2012-09-15 20:23:35 +07:00
|
|
|
struct input_value vals[] = {
|
|
|
|
{ EV_KEY, dev->repeat_key, 2 },
|
|
|
|
input_value_sync
|
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
input_pass_values(dev, vals, ARRAY_SIZE(vals));
|
2005-09-07 05:19:06 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
if (dev->rep[REP_PERIOD])
|
|
|
|
mod_timer(&dev->timer, jiffies +
|
|
|
|
msecs_to_jiffies(dev->rep[REP_PERIOD]));
|
|
|
|
}
|
2005-09-07 05:19:06 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
}
|
2005-09-07 05:19:06 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
#define INPUT_IGNORE_EVENT 0
|
|
|
|
#define INPUT_PASS_TO_HANDLERS 1
|
|
|
|
#define INPUT_PASS_TO_DEVICE 2
|
2012-09-15 20:23:35 +07:00
|
|
|
#define INPUT_SLOT 4
|
|
|
|
#define INPUT_FLUSH 8
|
2007-08-30 11:22:11 +07:00
|
|
|
#define INPUT_PASS_TO_ALL (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-07-16 13:10:10 +07:00
|
|
|
static int input_handle_abs_event(struct input_dev *dev,
|
|
|
|
unsigned int code, int *pval)
|
|
|
|
{
|
2012-09-15 20:15:58 +07:00
|
|
|
struct input_mt *mt = dev->mt;
|
2010-07-16 13:10:10 +07:00
|
|
|
bool is_mt_event;
|
|
|
|
int *pold;
|
|
|
|
|
|
|
|
if (code == ABS_MT_SLOT) {
|
|
|
|
/*
|
|
|
|
* "Stage" the event; we'll flush it later, when we
|
2010-09-04 00:31:05 +07:00
|
|
|
* get actual touch data.
|
2010-07-16 13:10:10 +07:00
|
|
|
*/
|
2012-09-15 20:15:58 +07:00
|
|
|
if (mt && *pval >= 0 && *pval < mt->num_slots)
|
|
|
|
mt->slot = *pval;
|
2010-07-16 13:10:10 +07:00
|
|
|
|
|
|
|
return INPUT_IGNORE_EVENT;
|
|
|
|
}
|
|
|
|
|
2012-01-13 01:40:34 +07:00
|
|
|
is_mt_event = input_is_mt_value(code);
|
2010-07-16 13:10:10 +07:00
|
|
|
|
|
|
|
if (!is_mt_event) {
|
2010-08-03 10:18:21 +07:00
|
|
|
pold = &dev->absinfo[code].value;
|
2012-09-15 20:15:58 +07:00
|
|
|
} else if (mt) {
|
|
|
|
pold = &mt->slots[mt->slot].abs[code - ABS_MT_FIRST];
|
2010-07-16 13:10:10 +07:00
|
|
|
} else {
|
|
|
|
/*
|
2010-09-04 00:31:05 +07:00
|
|
|
* Bypass filtering for multi-touch events when
|
2010-07-16 13:10:10 +07:00
|
|
|
* not employing slots.
|
|
|
|
*/
|
|
|
|
pold = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pold) {
|
|
|
|
*pval = input_defuzz_abs_event(*pval, *pold,
|
2010-08-03 10:18:21 +07:00
|
|
|
dev->absinfo[code].fuzz);
|
2010-07-16 13:10:10 +07:00
|
|
|
if (*pold == *pval)
|
|
|
|
return INPUT_IGNORE_EVENT;
|
|
|
|
|
|
|
|
*pold = *pval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Flush pending "slot" event */
|
2012-09-15 20:15:58 +07:00
|
|
|
if (is_mt_event && mt && mt->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
|
|
|
|
input_abs_set_val(dev, ABS_MT_SLOT, mt->slot);
|
2012-09-15 20:23:35 +07:00
|
|
|
return INPUT_PASS_TO_HANDLERS | INPUT_SLOT;
|
2010-07-16 13:10:10 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return INPUT_PASS_TO_HANDLERS;
|
|
|
|
}
|
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
static int input_get_disposition(struct input_dev *dev,
|
2014-07-20 06:30:31 +07:00
|
|
|
unsigned int type, unsigned int code, int *pval)
|
2007-08-30 11:22:11 +07:00
|
|
|
{
|
|
|
|
int disposition = INPUT_IGNORE_EVENT;
|
2014-07-20 06:30:31 +07:00
|
|
|
int value = *pval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
switch (type) {
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
case EV_SYN:
|
|
|
|
switch (code) {
|
|
|
|
case SYN_CONFIG:
|
|
|
|
disposition = INPUT_PASS_TO_ALL;
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
case SYN_REPORT:
|
2012-09-15 20:23:35 +07:00
|
|
|
disposition = INPUT_PASS_TO_HANDLERS | INPUT_FLUSH;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
Input: add detailed multi-touch finger data report protocol
In order to utilize the full power of the new multi-touch devices, a
way to report detailed finger data to user space is needed. This patch
adds a multi-touch (MT) protocol which allows drivers to report details
for an arbitrary number of fingers.
The driver sends a SYN_MT_REPORT event via the input_mt_sync() function
when a complete finger has been reported.
In order to stay compatible with existing applications, the data
reported in a finger packet must not be recognized as single-touch
events. In addition, all finger data must bypass input filtering,
since subsequent events of the same type refer to different fingers.
A set of ABS_MT events with the desired properties are defined. The
events are divided into categories, to allow for partial implementation.
The minimum set consists of ABS_MT_TOUCH_MAJOR, ABS_MT_POSITION_X and
ABS_MT_POSITION_Y, which allows for multiple fingers to be tracked.
If the device supports it, the ABS_MT_WIDTH_MAJOR may be used to provide
the size of the approaching finger. Anisotropy and direction may be
specified with ABS_MT_TOUCH_MINOR, ABS_MT_WIDTH_MINOR and
ABS_MT_ORIENTATION. Devices with more granular information may specify
general shapes as blobs, i.e., as a sequence of rectangular shapes
grouped together by a ABS_MT_BLOB_ID. Finally, the ABS_MT_TOOL_TYPE
may be used to specify whether the touching tool is a finger or a pen.
Signed-off-by: Henrik Rydberg <rydberg@euromail.se>
Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
2009-04-28 21:47:33 +07:00
|
|
|
case SYN_MT_REPORT:
|
|
|
|
disposition = INPUT_PASS_TO_HANDLERS;
|
|
|
|
break;
|
2007-08-30 11:22:11 +07:00
|
|
|
}
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
case EV_KEY:
|
2012-08-11 02:39:38 +07:00
|
|
|
if (is_event_supported(code, dev->keybit, KEY_MAX)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-08-11 02:39:38 +07:00
|
|
|
/* auto-repeat bypasses state updates */
|
|
|
|
if (value == 2) {
|
|
|
|
disposition = INPUT_PASS_TO_HANDLERS;
|
|
|
|
break;
|
2007-08-30 11:22:11 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-08-11 02:39:38 +07:00
|
|
|
if (!!test_bit(code, dev->key) != !!value) {
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
__change_bit(code, dev->key);
|
2012-08-11 02:39:38 +07:00
|
|
|
disposition = INPUT_PASS_TO_HANDLERS;
|
2007-08-30 11:22:11 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
case EV_SW:
|
|
|
|
if (is_event_supported(code, dev->swbit, SW_MAX) &&
|
2012-08-11 02:39:38 +07:00
|
|
|
!!test_bit(code, dev->sw) != !!value) {
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
__change_bit(code, dev->sw);
|
|
|
|
disposition = INPUT_PASS_TO_HANDLERS;
|
|
|
|
}
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
case EV_ABS:
|
2010-07-16 13:10:10 +07:00
|
|
|
if (is_event_supported(code, dev->absbit, ABS_MAX))
|
2011-02-03 14:04:27 +07:00
|
|
|
disposition = input_handle_abs_event(dev, code, &value);
|
2009-04-28 21:45:31 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
case EV_REL:
|
|
|
|
if (is_event_supported(code, dev->relbit, REL_MAX) && value)
|
|
|
|
disposition = INPUT_PASS_TO_HANDLERS;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
break;
|
2006-06-26 12:48:47 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
case EV_MSC:
|
|
|
|
if (is_event_supported(code, dev->mscbit, MSC_MAX))
|
|
|
|
disposition = INPUT_PASS_TO_ALL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
case EV_LED:
|
|
|
|
if (is_event_supported(code, dev->ledbit, LED_MAX) &&
|
2012-08-11 02:39:38 +07:00
|
|
|
!!test_bit(code, dev->led) != !!value) {
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
__change_bit(code, dev->led);
|
|
|
|
disposition = INPUT_PASS_TO_ALL;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EV_SND:
|
|
|
|
if (is_event_supported(code, dev->sndbit, SND_MAX)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-04-29 12:13:48 +07:00
|
|
|
if (!!test_bit(code, dev->snd) != !!value)
|
2007-08-30 11:22:11 +07:00
|
|
|
__change_bit(code, dev->snd);
|
|
|
|
disposition = INPUT_PASS_TO_ALL;
|
|
|
|
}
|
|
|
|
break;
|
2006-04-29 12:13:48 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
case EV_REP:
|
|
|
|
if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
|
|
|
|
dev->rep[code] = value;
|
|
|
|
disposition = INPUT_PASS_TO_ALL;
|
|
|
|
}
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
case EV_FF:
|
|
|
|
if (value >= 0)
|
|
|
|
disposition = INPUT_PASS_TO_ALL;
|
|
|
|
break;
|
2008-01-03 22:46:21 +07:00
|
|
|
|
|
|
|
case EV_PWR:
|
|
|
|
disposition = INPUT_PASS_TO_ALL;
|
|
|
|
break;
|
2007-08-30 11:22:11 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-07-20 06:30:31 +07:00
|
|
|
*pval = value;
|
2012-09-15 20:23:35 +07:00
|
|
|
return disposition;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void input_handle_event(struct input_dev *dev,
|
|
|
|
unsigned int type, unsigned int code, int value)
|
|
|
|
{
|
|
|
|
int disposition;
|
|
|
|
|
2014-07-20 06:30:31 +07:00
|
|
|
disposition = input_get_disposition(dev, type, code, &value);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
|
|
|
|
dev->event(dev, type, code, value);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
if (!dev->vals)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (disposition & INPUT_PASS_TO_HANDLERS) {
|
|
|
|
struct input_value *v;
|
|
|
|
|
|
|
|
if (disposition & INPUT_SLOT) {
|
|
|
|
v = &dev->vals[dev->num_vals++];
|
|
|
|
v->type = EV_ABS;
|
|
|
|
v->code = ABS_MT_SLOT;
|
|
|
|
v->value = dev->mt->slot;
|
|
|
|
}
|
|
|
|
|
|
|
|
v = &dev->vals[dev->num_vals++];
|
|
|
|
v->type = type;
|
|
|
|
v->code = code;
|
|
|
|
v->value = value;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (disposition & INPUT_FLUSH) {
|
|
|
|
if (dev->num_vals >= 2)
|
|
|
|
input_pass_values(dev, dev->vals, dev->num_vals);
|
|
|
|
dev->num_vals = 0;
|
|
|
|
} else if (dev->num_vals >= dev->max_vals - 2) {
|
|
|
|
dev->vals[dev->num_vals++] = input_value_sync;
|
|
|
|
input_pass_values(dev, dev->vals, dev->num_vals);
|
|
|
|
dev->num_vals = 0;
|
|
|
|
}
|
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/**
|
|
|
|
* input_event() - report new input event
|
|
|
|
* @dev: device that generated the event
|
|
|
|
* @type: type of the event
|
|
|
|
* @code: event code
|
|
|
|
* @value: value of the event
|
|
|
|
*
|
|
|
|
* This function should be used by drivers implementing various input
|
2009-12-12 12:57:31 +07:00
|
|
|
* devices to report input events. See also input_inject_event().
|
|
|
|
*
|
|
|
|
* NOTE: input_event() may be safely used right after input device was
|
|
|
|
* allocated with input_allocate_device(), even before it is registered
|
|
|
|
* with input_register_device(), but the event will not reach any of the
|
|
|
|
* input handlers. Such early invocation of input_event() may be used
|
|
|
|
* to 'seed' initial state of a switch or initial position of absolute
|
|
|
|
* axis, etc.
|
2007-08-30 11:22:11 +07:00
|
|
|
*/
|
|
|
|
void input_event(struct input_dev *dev,
|
|
|
|
unsigned int type, unsigned int code, int value)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
2006-07-19 12:40:22 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
if (is_event_supported(type, dev->evbit, EV_MAX)) {
|
2006-07-19 12:40:22 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
2011-02-03 14:04:27 +07:00
|
|
|
input_handle_event(dev, type, code, value);
|
2007-08-30 11:22:11 +07:00
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_event);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-07-06 11:22:43 +07:00
|
|
|
/**
|
|
|
|
* input_inject_event() - send input event from input handler
|
|
|
|
* @handle: input handle to send event through
|
|
|
|
* @type: type of the event
|
|
|
|
* @code: event code
|
|
|
|
* @value: value of the event
|
|
|
|
*
|
2007-08-30 11:22:11 +07:00
|
|
|
* Similar to input_event() but will ignore event if device is
|
|
|
|
* "grabbed" and handle injecting event is not the one that owns
|
|
|
|
* the device.
|
2006-07-06 11:22:43 +07:00
|
|
|
*/
|
2007-08-30 11:22:11 +07:00
|
|
|
void input_inject_event(struct input_handle *handle,
|
|
|
|
unsigned int type, unsigned int code, int value)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-08-30 11:22:11 +07:00
|
|
|
struct input_dev *dev = handle->dev;
|
|
|
|
struct input_handle *grab;
|
|
|
|
unsigned long flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
if (is_event_supported(type, dev->evbit, EV_MAX)) {
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-14 02:46:55 +07:00
|
|
|
rcu_read_lock();
|
2007-08-30 11:22:11 +07:00
|
|
|
grab = rcu_dereference(dev->grab);
|
|
|
|
if (!grab || grab == handle)
|
2011-02-03 14:04:27 +07:00
|
|
|
input_handle_event(dev, type, code, value);
|
2007-10-14 02:46:55 +07:00
|
|
|
rcu_read_unlock();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-08-30 11:22:11 +07:00
|
|
|
EXPORT_SYMBOL(input_inject_event);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-08-03 10:18:21 +07:00
|
|
|
/**
|
|
|
|
* input_alloc_absinfo - allocates array of input_absinfo structs
|
|
|
|
* @dev: the input device emitting absolute events
|
|
|
|
*
|
|
|
|
* If the absinfo struct the caller asked for is already allocated, this
|
|
|
|
* functions will not do anything.
|
|
|
|
*/
|
|
|
|
void input_alloc_absinfo(struct input_dev *dev)
|
|
|
|
{
|
|
|
|
if (!dev->absinfo)
|
|
|
|
dev->absinfo = kcalloc(ABS_CNT, sizeof(struct input_absinfo),
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
|
|
|
WARN(!dev->absinfo, "%s(): kcalloc() failed?\n", __func__);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_alloc_absinfo);
|
|
|
|
|
|
|
|
void input_set_abs_params(struct input_dev *dev, unsigned int axis,
|
|
|
|
int min, int max, int fuzz, int flat)
|
|
|
|
{
|
|
|
|
struct input_absinfo *absinfo;
|
|
|
|
|
|
|
|
input_alloc_absinfo(dev);
|
|
|
|
if (!dev->absinfo)
|
|
|
|
return;
|
|
|
|
|
|
|
|
absinfo = &dev->absinfo[axis];
|
|
|
|
absinfo->minimum = min;
|
|
|
|
absinfo->maximum = max;
|
|
|
|
absinfo->fuzz = fuzz;
|
|
|
|
absinfo->flat = flat;
|
|
|
|
|
2014-10-08 23:28:32 +07:00
|
|
|
__set_bit(EV_ABS, dev->evbit);
|
|
|
|
__set_bit(axis, dev->absbit);
|
2010-08-03 10:18:21 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_set_abs_params);
|
|
|
|
|
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/**
|
|
|
|
* input_grab_device - grabs device for exclusive use
|
|
|
|
* @handle: input handle that wants to own the device
|
|
|
|
*
|
|
|
|
* When a device is grabbed by an input handle all events generated by
|
|
|
|
* the device are delivered only to this handle. Also events injected
|
|
|
|
* by other input handles are ignored while device is grabbed.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
int input_grab_device(struct input_handle *handle)
|
|
|
|
{
|
2007-08-30 11:22:11 +07:00
|
|
|
struct input_dev *dev = handle->dev;
|
|
|
|
int retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
retval = mutex_lock_interruptible(&dev->mutex);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
if (dev->grab) {
|
|
|
|
retval = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
rcu_assign_pointer(dev->grab, handle);
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&dev->mutex);
|
|
|
|
return retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_grab_device);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
static void __input_release_device(struct input_handle *handle)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-15 12:17:38 +07:00
|
|
|
struct input_dev *dev = handle->dev;
|
2012-10-25 13:53:01 +07:00
|
|
|
struct input_handle *grabber;
|
2006-07-06 11:21:03 +07:00
|
|
|
|
2012-10-25 13:53:01 +07:00
|
|
|
grabber = rcu_dereference_protected(dev->grab,
|
|
|
|
lockdep_is_held(&dev->mutex));
|
|
|
|
if (grabber == handle) {
|
2007-08-30 11:22:11 +07:00
|
|
|
rcu_assign_pointer(dev->grab, NULL);
|
|
|
|
/* Make sure input_pass_event() notices that grab is gone */
|
2007-10-14 02:46:55 +07:00
|
|
|
synchronize_rcu();
|
2006-07-15 12:17:38 +07:00
|
|
|
|
|
|
|
list_for_each_entry(handle, &dev->h_list, d_node)
|
2007-08-30 11:22:11 +07:00
|
|
|
if (handle->open && handle->handler->start)
|
2006-07-06 11:21:03 +07:00
|
|
|
handle->handler->start(handle);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-08-30 11:22:11 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* input_release_device - release previously grabbed device
|
|
|
|
* @handle: input handle that owns the device
|
|
|
|
*
|
|
|
|
* Releases previously grabbed device so that other input handles can
|
|
|
|
* start receiving input events. Upon release all handlers attached
|
|
|
|
* to the device have their start() method called so they have a change
|
|
|
|
* to synchronize device state with the rest of the system.
|
|
|
|
*/
|
|
|
|
void input_release_device(struct input_handle *handle)
|
|
|
|
{
|
|
|
|
struct input_dev *dev = handle->dev;
|
|
|
|
|
|
|
|
mutex_lock(&dev->mutex);
|
|
|
|
__input_release_device(handle);
|
|
|
|
mutex_unlock(&dev->mutex);
|
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_release_device);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/**
|
|
|
|
* input_open_device - open input device
|
|
|
|
* @handle: handle through which device is being accessed
|
|
|
|
*
|
|
|
|
* This function should be called by input handlers when they
|
|
|
|
* want to start receive events from given input device.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
int input_open_device(struct input_handle *handle)
|
|
|
|
{
|
2005-05-29 14:29:25 +07:00
|
|
|
struct input_dev *dev = handle->dev;
|
2007-08-30 11:22:11 +07:00
|
|
|
int retval;
|
2005-05-29 14:29:25 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
retval = mutex_lock_interruptible(&dev->mutex);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
if (dev->going_away) {
|
|
|
|
retval = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-05-29 14:29:25 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
handle->open++;
|
2005-05-29 14:29:25 +07:00
|
|
|
|
|
|
|
if (!dev->users++ && dev->open)
|
2007-08-30 11:22:11 +07:00
|
|
|
retval = dev->open(dev);
|
|
|
|
|
|
|
|
if (retval) {
|
|
|
|
dev->users--;
|
|
|
|
if (!--handle->open) {
|
|
|
|
/*
|
|
|
|
* Make sure we are not delivering any more events
|
|
|
|
* through this handle
|
|
|
|
*/
|
2007-10-14 02:46:55 +07:00
|
|
|
synchronize_rcu();
|
2007-08-30 11:22:11 +07:00
|
|
|
}
|
|
|
|
}
|
2005-05-29 14:29:25 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
out:
|
2006-02-19 12:21:46 +07:00
|
|
|
mutex_unlock(&dev->mutex);
|
2007-08-30 11:22:11 +07:00
|
|
|
return retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_open_device);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
int input_flush_device(struct input_handle *handle, struct file *file)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-08-30 11:22:11 +07:00
|
|
|
struct input_dev *dev = handle->dev;
|
|
|
|
int retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
retval = mutex_lock_interruptible(&dev->mutex);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
if (dev->flush)
|
|
|
|
retval = dev->flush(dev, file);
|
|
|
|
|
|
|
|
mutex_unlock(&dev->mutex);
|
|
|
|
return retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_flush_device);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/**
|
|
|
|
* input_close_device - close input device
|
|
|
|
* @handle: handle through which device is being accessed
|
|
|
|
*
|
|
|
|
* This function should be called by input handlers when they
|
|
|
|
* want to stop receive events from given input device.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
void input_close_device(struct input_handle *handle)
|
|
|
|
{
|
2005-05-29 14:29:25 +07:00
|
|
|
struct input_dev *dev = handle->dev;
|
|
|
|
|
2006-02-19 12:21:46 +07:00
|
|
|
mutex_lock(&dev->mutex);
|
2005-05-29 14:29:25 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
__input_release_device(handle);
|
|
|
|
|
2005-05-29 14:29:25 +07:00
|
|
|
if (!--dev->users && dev->close)
|
|
|
|
dev->close(dev);
|
2007-08-30 11:22:11 +07:00
|
|
|
|
|
|
|
if (!--handle->open) {
|
|
|
|
/*
|
2007-10-14 02:46:55 +07:00
|
|
|
* synchronize_rcu() makes sure that input_pass_event()
|
2007-08-30 11:22:11 +07:00
|
|
|
* completed and that no more input events are delivered
|
|
|
|
* through this handle
|
|
|
|
*/
|
2007-10-14 02:46:55 +07:00
|
|
|
synchronize_rcu();
|
2007-08-30 11:22:11 +07:00
|
|
|
}
|
2005-05-29 14:29:25 +07:00
|
|
|
|
2006-02-19 12:21:46 +07:00
|
|
|
mutex_unlock(&dev->mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_close_device);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-07-01 23:01:50 +07:00
|
|
|
/*
|
|
|
|
* Simulate keyup events for all keys that are marked as pressed.
|
|
|
|
* The function must be called with dev->event_lock held.
|
|
|
|
*/
|
|
|
|
static void input_dev_release_keys(struct input_dev *dev)
|
|
|
|
{
|
2015-08-07 09:15:30 +07:00
|
|
|
bool need_sync = false;
|
2010-07-01 23:01:50 +07:00
|
|
|
int code;
|
|
|
|
|
|
|
|
if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
|
2015-08-07 09:15:30 +07:00
|
|
|
for_each_set_bit(code, dev->key, KEY_CNT) {
|
2015-06-26 03:33:12 +07:00
|
|
|
input_pass_event(dev, EV_KEY, code, 0);
|
2015-08-07 09:15:30 +07:00
|
|
|
need_sync = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (need_sync)
|
|
|
|
input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
|
|
|
|
|
2015-06-26 03:33:12 +07:00
|
|
|
memset(dev->key, 0, sizeof(dev->key));
|
2010-07-01 23:01:50 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/*
|
|
|
|
* Prepare device for unregistering
|
|
|
|
*/
|
|
|
|
static void input_disconnect_device(struct input_dev *dev)
|
|
|
|
{
|
|
|
|
struct input_handle *handle;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark device as going away. Note that we take dev->mutex here
|
|
|
|
* not to protect access to dev->going_away but rather to ensure
|
|
|
|
* that there are no threads in the middle of input_open_device()
|
|
|
|
*/
|
|
|
|
mutex_lock(&dev->mutex);
|
2009-09-16 15:06:43 +07:00
|
|
|
dev->going_away = true;
|
2007-08-30 11:22:11 +07:00
|
|
|
mutex_unlock(&dev->mutex);
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->event_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Simulate keyup events for all pressed keys so that handlers
|
|
|
|
* are not left with "stuck" keys. The driver may continue
|
|
|
|
* generate events even after we done here but they will not
|
|
|
|
* reach any handlers.
|
|
|
|
*/
|
2010-07-01 23:01:50 +07:00
|
|
|
input_dev_release_keys(dev);
|
2007-08-30 11:22:11 +07:00
|
|
|
|
|
|
|
list_for_each_entry(handle, &dev->h_list, d_node)
|
|
|
|
handle->open = 0;
|
|
|
|
|
|
|
|
spin_unlock_irq(&dev->event_lock);
|
|
|
|
}
|
|
|
|
|
2010-09-10 11:54:22 +07:00
|
|
|
/**
|
|
|
|
* input_scancode_to_scalar() - converts scancode in &struct input_keymap_entry
|
|
|
|
* @ke: keymap entry containing scancode to be converted.
|
|
|
|
* @scancode: pointer to the location where converted scancode should
|
|
|
|
* be stored.
|
|
|
|
*
|
|
|
|
* This function is used to convert scancode stored in &struct keymap_entry
|
|
|
|
* into scalar form understood by legacy keymap handling methods. These
|
|
|
|
* methods expect scancodes to be represented as 'unsigned int'.
|
|
|
|
*/
|
|
|
|
int input_scancode_to_scalar(const struct input_keymap_entry *ke,
|
|
|
|
unsigned int *scancode)
|
|
|
|
{
|
|
|
|
switch (ke->len) {
|
|
|
|
case 1:
|
|
|
|
*scancode = *((u8 *)ke->scancode);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
*scancode = *((u16 *)ke->scancode);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
|
|
|
*scancode = *((u32 *)ke->scancode);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_scancode_to_scalar);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Those routines handle the default case where no [gs]etkeycode() is
|
|
|
|
* defined. In this case, an array indexed by the scancode is used.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int input_fetch_keycode(struct input_dev *dev,
|
|
|
|
unsigned int index)
|
2007-03-15 09:50:42 +07:00
|
|
|
{
|
|
|
|
switch (dev->keycodesize) {
|
2010-09-10 11:54:22 +07:00
|
|
|
case 1:
|
|
|
|
return ((u8 *)dev->keycode)[index];
|
2007-03-15 09:50:42 +07:00
|
|
|
|
2010-09-10 11:54:22 +07:00
|
|
|
case 2:
|
|
|
|
return ((u16 *)dev->keycode)[index];
|
2007-03-15 09:50:42 +07:00
|
|
|
|
2010-09-10 11:54:22 +07:00
|
|
|
default:
|
|
|
|
return ((u32 *)dev->keycode)[index];
|
2007-03-15 09:50:42 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int input_default_getkeycode(struct input_dev *dev,
|
2010-09-10 11:54:22 +07:00
|
|
|
struct input_keymap_entry *ke)
|
2007-03-15 09:50:42 +07:00
|
|
|
{
|
2010-09-10 11:54:22 +07:00
|
|
|
unsigned int index;
|
|
|
|
int error;
|
|
|
|
|
2007-03-15 09:50:42 +07:00
|
|
|
if (!dev->keycodesize)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-09-10 11:54:22 +07:00
|
|
|
if (ke->flags & INPUT_KEYMAP_BY_INDEX)
|
|
|
|
index = ke->index;
|
|
|
|
else {
|
|
|
|
error = input_scancode_to_scalar(ke, &index);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (index >= dev->keycodemax)
|
2007-03-15 09:50:42 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-09-10 11:54:22 +07:00
|
|
|
ke->keycode = input_fetch_keycode(dev, index);
|
|
|
|
ke->index = index;
|
|
|
|
ke->len = sizeof(index);
|
|
|
|
memcpy(ke->scancode, &index, sizeof(index));
|
2007-03-15 09:50:42 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int input_default_setkeycode(struct input_dev *dev,
|
2010-09-10 11:54:22 +07:00
|
|
|
const struct input_keymap_entry *ke,
|
|
|
|
unsigned int *old_keycode)
|
2007-03-15 09:50:42 +07:00
|
|
|
{
|
2010-09-10 11:54:22 +07:00
|
|
|
unsigned int index;
|
|
|
|
int error;
|
2007-03-15 09:50:42 +07:00
|
|
|
int i;
|
|
|
|
|
2010-09-10 11:54:22 +07:00
|
|
|
if (!dev->keycodesize)
|
2007-03-15 09:50:42 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-09-10 11:54:22 +07:00
|
|
|
if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
|
|
|
|
index = ke->index;
|
|
|
|
} else {
|
|
|
|
error = input_scancode_to_scalar(ke, &index);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (index >= dev->keycodemax)
|
2007-03-15 09:50:42 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-11-19 00:06:43 +07:00
|
|
|
if (dev->keycodesize < sizeof(ke->keycode) &&
|
2010-09-10 11:54:22 +07:00
|
|
|
(ke->keycode >> (dev->keycodesize * 8)))
|
2007-03-15 09:50:42 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
switch (dev->keycodesize) {
|
|
|
|
case 1: {
|
|
|
|
u8 *k = (u8 *)dev->keycode;
|
2010-09-10 11:54:22 +07:00
|
|
|
*old_keycode = k[index];
|
|
|
|
k[index] = ke->keycode;
|
2007-03-15 09:50:42 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 2: {
|
|
|
|
u16 *k = (u16 *)dev->keycode;
|
2010-09-10 11:54:22 +07:00
|
|
|
*old_keycode = k[index];
|
|
|
|
k[index] = ke->keycode;
|
2007-03-15 09:50:42 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: {
|
|
|
|
u32 *k = (u32 *)dev->keycode;
|
2010-09-10 11:54:22 +07:00
|
|
|
*old_keycode = k[index];
|
|
|
|
k[index] = ke->keycode;
|
2007-03-15 09:50:42 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-10 11:54:22 +07:00
|
|
|
__clear_bit(*old_keycode, dev->keybit);
|
|
|
|
__set_bit(ke->keycode, dev->keybit);
|
2007-03-15 09:50:42 +07:00
|
|
|
|
|
|
|
for (i = 0; i < dev->keycodemax; i++) {
|
2010-09-10 11:54:22 +07:00
|
|
|
if (input_fetch_keycode(dev, i) == *old_keycode) {
|
|
|
|
__set_bit(*old_keycode, dev->keybit);
|
2007-03-15 09:50:42 +07:00
|
|
|
break; /* Setting the bit twice is useless, so break */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-11-04 11:41:12 +07:00
|
|
|
/**
|
|
|
|
* input_get_keycode - retrieve keycode currently mapped to a given scancode
|
|
|
|
* @dev: input device which keymap is being queried
|
2010-09-10 11:54:22 +07:00
|
|
|
* @ke: keymap entry
|
2007-11-04 11:41:12 +07:00
|
|
|
*
|
|
|
|
* This function should be called by anyone interested in retrieving current
|
2010-09-10 11:54:22 +07:00
|
|
|
* keymap. Presently evdev handlers use it.
|
2007-11-04 11:41:12 +07:00
|
|
|
*/
|
2010-09-10 11:54:22 +07:00
|
|
|
int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
|
2007-11-04 11:41:12 +07:00
|
|
|
{
|
2010-03-22 12:56:15 +07:00
|
|
|
unsigned long flags;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
2011-02-01 12:06:39 +07:00
|
|
|
retval = dev->getkeycode(dev, ke);
|
2010-09-10 11:54:22 +07:00
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
2011-02-01 12:06:39 +07:00
|
|
|
|
2010-03-22 12:56:15 +07:00
|
|
|
return retval;
|
2007-11-04 11:41:12 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_get_keycode);
|
|
|
|
|
|
|
|
/**
|
2010-09-10 11:54:22 +07:00
|
|
|
* input_set_keycode - attribute a keycode to a given scancode
|
2007-11-04 11:41:12 +07:00
|
|
|
* @dev: input device which keymap is being updated
|
2010-09-10 11:54:22 +07:00
|
|
|
* @ke: new keymap entry
|
2007-11-04 11:41:12 +07:00
|
|
|
*
|
|
|
|
* This function should be called by anyone needing to update current
|
|
|
|
* keymap. Presently keyboard and evdev handlers use it.
|
|
|
|
*/
|
2010-03-09 13:37:10 +07:00
|
|
|
int input_set_keycode(struct input_dev *dev,
|
2010-09-10 11:54:22 +07:00
|
|
|
const struct input_keymap_entry *ke)
|
2007-11-04 11:41:12 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2010-07-14 14:25:21 +07:00
|
|
|
unsigned int old_keycode;
|
2007-11-04 11:41:12 +07:00
|
|
|
int retval;
|
|
|
|
|
2010-09-10 11:54:22 +07:00
|
|
|
if (ke->keycode > KEY_MAX)
|
2007-11-04 11:41:12 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
|
|
|
|
2011-02-01 12:06:39 +07:00
|
|
|
retval = dev->setkeycode(dev, ke, &old_keycode);
|
2007-11-04 11:41:12 +07:00
|
|
|
if (retval)
|
|
|
|
goto out;
|
|
|
|
|
2010-01-06 08:56:00 +07:00
|
|
|
/* Make sure KEY_RESERVED did not get enabled. */
|
|
|
|
__clear_bit(KEY_RESERVED, dev->keybit);
|
|
|
|
|
2007-11-04 11:41:12 +07:00
|
|
|
/*
|
|
|
|
* Simulate keyup event if keycode is not present
|
|
|
|
* in the keymap anymore
|
|
|
|
*/
|
|
|
|
if (test_bit(EV_KEY, dev->evbit) &&
|
|
|
|
!is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
|
|
|
|
__test_and_clear_bit(old_keycode, dev->key)) {
|
2012-09-15 20:23:35 +07:00
|
|
|
struct input_value vals[] = {
|
|
|
|
{ EV_KEY, old_keycode, 0 },
|
|
|
|
input_value_sync
|
|
|
|
};
|
2007-11-04 11:41:12 +07:00
|
|
|
|
2012-09-15 20:23:35 +07:00
|
|
|
input_pass_values(dev, vals, ARRAY_SIZE(vals));
|
2007-11-04 11:41:12 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_set_keycode);
|
2007-03-15 09:50:42 +07:00
|
|
|
|
2010-02-03 12:08:26 +07:00
|
|
|
static const struct input_device_id *input_match_device(struct input_handler *handler,
|
2006-09-14 12:31:59 +07:00
|
|
|
struct input_dev *dev)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2010-02-03 12:08:26 +07:00
|
|
|
const struct input_device_id *id;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-02-03 12:08:26 +07:00
|
|
|
for (id = handler->id_table; id->flags || id->driver_info; id++) {
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
|
2006-04-26 11:14:19 +07:00
|
|
|
if (id->bustype != dev->id.bustype)
|
2005-04-17 05:20:36 +07:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
|
2006-04-26 11:14:19 +07:00
|
|
|
if (id->vendor != dev->id.vendor)
|
2005-04-17 05:20:36 +07:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
|
2006-04-26 11:14:19 +07:00
|
|
|
if (id->product != dev->id.product)
|
2005-04-17 05:20:36 +07:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
|
2006-04-26 11:14:19 +07:00
|
|
|
if (id->version != dev->id.version)
|
2005-04-17 05:20:36 +07:00
|
|
|
continue;
|
|
|
|
|
2012-08-01 12:08:55 +07:00
|
|
|
if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!bitmap_subset(id->keybit, dev->keybit, KEY_MAX))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!bitmap_subset(id->relbit, dev->relbit, REL_MAX))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!bitmap_subset(id->absbit, dev->absbit, ABS_MAX))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!bitmap_subset(id->ledbit, dev->ledbit, LED_MAX))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!bitmap_subset(id->sndbit, dev->sndbit, SND_MAX))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!bitmap_subset(id->ffbit, dev->ffbit, FF_MAX))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!bitmap_subset(id->swbit, dev->swbit, SW_MAX))
|
|
|
|
continue;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-02-03 12:08:26 +07:00
|
|
|
if (!handler->match || handler->match(handler, dev))
|
|
|
|
return id;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-04-12 12:29:46 +07:00
|
|
|
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
|
|
|
|
{
|
|
|
|
const struct input_device_id *id;
|
|
|
|
int error;
|
|
|
|
|
2010-02-03 12:08:26 +07:00
|
|
|
id = input_match_device(handler, dev);
|
2007-04-12 12:29:46 +07:00
|
|
|
if (!id)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
error = handler->connect(handler, dev, id);
|
|
|
|
if (error && error != -ENODEV)
|
2010-11-30 14:33:07 +07:00
|
|
|
pr_err("failed to attach handler %s to device %s, error: %d\n",
|
|
|
|
handler->name, kobject_name(&dev->dev.kobj), error);
|
2007-04-12 12:29:46 +07:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2010-01-11 15:05:43 +07:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
|
|
|
|
static int input_bits_to_string(char *buf, int buf_size,
|
|
|
|
unsigned long bits, bool skip_empty)
|
|
|
|
{
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
if (INPUT_COMPAT_TEST) {
|
|
|
|
u32 dword = bits >> 32;
|
|
|
|
if (dword || !skip_empty)
|
|
|
|
len += snprintf(buf, buf_size, "%x ", dword);
|
|
|
|
|
|
|
|
dword = bits & 0xffffffffUL;
|
|
|
|
if (dword || !skip_empty || len)
|
|
|
|
len += snprintf(buf + len, max(buf_size - len, 0),
|
|
|
|
"%x", dword);
|
|
|
|
} else {
|
|
|
|
if (bits || !skip_empty)
|
|
|
|
len += snprintf(buf, buf_size, "%lx", bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* !CONFIG_COMPAT */
|
|
|
|
|
|
|
|
static int input_bits_to_string(char *buf, int buf_size,
|
|
|
|
unsigned long bits, bool skip_empty)
|
|
|
|
{
|
|
|
|
return bits || !skip_empty ?
|
|
|
|
snprintf(buf, buf_size, "%lx", bits) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2007-04-12 12:29:46 +07:00
|
|
|
|
2005-06-30 12:50:29 +07:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
|
|
|
|
static struct proc_dir_entry *proc_bus_input_dir;
|
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
|
|
|
|
static int input_devices_state;
|
|
|
|
|
|
|
|
static inline void input_wakeup_procfs_readers(void)
|
|
|
|
{
|
|
|
|
input_devices_state++;
|
|
|
|
wake_up(&input_devices_poll_wait);
|
|
|
|
}
|
|
|
|
|
2006-04-02 12:09:34 +07:00
|
|
|
static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait)
|
2005-06-30 12:50:29 +07:00
|
|
|
{
|
|
|
|
poll_wait(file, &input_devices_poll_wait, wait);
|
2009-03-04 15:52:20 +07:00
|
|
|
if (file->f_version != input_devices_state) {
|
|
|
|
file->f_version = input_devices_state;
|
2005-06-30 12:50:29 +07:00
|
|
|
return POLLIN | POLLRDNORM;
|
2009-03-04 15:52:20 +07:00
|
|
|
}
|
2006-06-26 12:48:47 +07:00
|
|
|
|
2005-06-30 12:50:29 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-14 13:37:30 +07:00
|
|
|
union input_seq_state {
|
|
|
|
struct {
|
|
|
|
unsigned short pos;
|
|
|
|
bool mutex_acquired;
|
|
|
|
};
|
|
|
|
void *p;
|
|
|
|
};
|
|
|
|
|
2006-04-02 12:09:34 +07:00
|
|
|
static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
|
|
|
|
{
|
2009-10-14 13:37:30 +07:00
|
|
|
union input_seq_state *state = (union input_seq_state *)&seq->private;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* We need to fit into seq->private pointer */
|
|
|
|
BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
|
|
|
|
|
|
|
|
error = mutex_lock_interruptible(&input_mutex);
|
|
|
|
if (error) {
|
|
|
|
state->mutex_acquired = false;
|
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
state->mutex_acquired = true;
|
2005-06-30 12:50:29 +07:00
|
|
|
|
2007-07-18 11:38:32 +07:00
|
|
|
return seq_list_start(&input_dev_list, *pos);
|
2006-04-02 12:09:34 +07:00
|
|
|
}
|
2005-09-15 14:01:54 +07:00
|
|
|
|
2006-04-02 12:09:34 +07:00
|
|
|
static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
2007-07-18 11:38:32 +07:00
|
|
|
return seq_list_next(v, &input_dev_list, pos);
|
2006-04-02 12:09:34 +07:00
|
|
|
}
|
2005-06-30 12:50:29 +07:00
|
|
|
|
2009-10-14 13:37:30 +07:00
|
|
|
static void input_seq_stop(struct seq_file *seq, void *v)
|
2006-04-02 12:09:34 +07:00
|
|
|
{
|
2009-10-14 13:37:30 +07:00
|
|
|
union input_seq_state *state = (union input_seq_state *)&seq->private;
|
|
|
|
|
|
|
|
if (state->mutex_acquired)
|
|
|
|
mutex_unlock(&input_mutex);
|
2006-04-02 12:09:34 +07:00
|
|
|
}
|
2005-06-30 12:50:29 +07:00
|
|
|
|
2006-04-02 12:09:34 +07:00
|
|
|
static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
|
|
|
|
unsigned long *bitmap, int max)
|
|
|
|
{
|
|
|
|
int i;
|
2010-01-11 15:05:43 +07:00
|
|
|
bool skip_empty = true;
|
|
|
|
char buf[18];
|
2005-06-30 12:50:29 +07:00
|
|
|
|
2006-04-02 12:09:34 +07:00
|
|
|
seq_printf(seq, "B: %s=", name);
|
2010-01-11 15:05:43 +07:00
|
|
|
|
|
|
|
for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
|
|
|
|
if (input_bits_to_string(buf, sizeof(buf),
|
|
|
|
bitmap[i], skip_empty)) {
|
|
|
|
skip_empty = false;
|
|
|
|
seq_printf(seq, "%s%s", buf, i > 0 ? " " : "");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If no output was produced print a single 0.
|
|
|
|
*/
|
|
|
|
if (skip_empty)
|
|
|
|
seq_puts(seq, "0");
|
|
|
|
|
2006-04-02 12:09:34 +07:00
|
|
|
seq_putc(seq, '\n');
|
|
|
|
}
|
2005-06-30 12:50:29 +07:00
|
|
|
|
2006-04-02 12:09:34 +07:00
|
|
|
static int input_devices_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct input_dev *dev = container_of(v, struct input_dev, node);
|
2007-06-15 10:32:24 +07:00
|
|
|
const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
|
2006-04-02 12:09:34 +07:00
|
|
|
struct input_handle *handle;
|
|
|
|
|
|
|
|
seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
|
|
|
|
dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
|
|
|
|
|
|
|
|
seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
|
|
|
|
seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
|
|
|
|
seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
|
2007-03-08 11:20:17 +07:00
|
|
|
seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
|
2006-04-02 12:09:34 +07:00
|
|
|
seq_printf(seq, "H: Handlers=");
|
|
|
|
|
|
|
|
list_for_each_entry(handle, &dev->h_list, d_node)
|
|
|
|
seq_printf(seq, "%s ", handle->name);
|
|
|
|
seq_putc(seq, '\n');
|
|
|
|
|
2010-12-19 02:51:13 +07:00
|
|
|
input_seq_print_bitmap(seq, "PROP", dev->propbit, INPUT_PROP_MAX);
|
|
|
|
|
2006-04-02 12:09:34 +07:00
|
|
|
input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
|
|
|
|
if (test_bit(EV_KEY, dev->evbit))
|
|
|
|
input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
|
|
|
|
if (test_bit(EV_REL, dev->evbit))
|
|
|
|
input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
|
|
|
|
if (test_bit(EV_ABS, dev->evbit))
|
|
|
|
input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
|
|
|
|
if (test_bit(EV_MSC, dev->evbit))
|
|
|
|
input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
|
|
|
|
if (test_bit(EV_LED, dev->evbit))
|
|
|
|
input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
|
|
|
|
if (test_bit(EV_SND, dev->evbit))
|
|
|
|
input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
|
|
|
|
if (test_bit(EV_FF, dev->evbit))
|
|
|
|
input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
|
|
|
|
if (test_bit(EV_SW, dev->evbit))
|
|
|
|
input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
|
|
|
|
|
|
|
|
seq_putc(seq, '\n');
|
|
|
|
|
|
|
|
kfree(path);
|
|
|
|
return 0;
|
2005-06-30 12:50:29 +07:00
|
|
|
}
|
|
|
|
|
2008-01-31 12:43:32 +07:00
|
|
|
static const struct seq_operations input_devices_seq_ops = {
|
2006-04-02 12:09:34 +07:00
|
|
|
.start = input_devices_seq_start,
|
|
|
|
.next = input_devices_seq_next,
|
2009-10-14 13:37:30 +07:00
|
|
|
.stop = input_seq_stop,
|
2006-04-02 12:09:34 +07:00
|
|
|
.show = input_devices_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int input_proc_devices_open(struct inode *inode, struct file *file)
|
2005-06-30 12:50:29 +07:00
|
|
|
{
|
2006-04-02 12:09:34 +07:00
|
|
|
return seq_open(file, &input_devices_seq_ops);
|
|
|
|
}
|
|
|
|
|
2007-02-12 15:55:32 +07:00
|
|
|
static const struct file_operations input_devices_fileops = {
|
2006-04-02 12:09:34 +07:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = input_proc_devices_open,
|
|
|
|
.poll = input_proc_devices_poll,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
|
|
|
|
{
|
2009-10-14 13:37:30 +07:00
|
|
|
union input_seq_state *state = (union input_seq_state *)&seq->private;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* We need to fit into seq->private pointer */
|
|
|
|
BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
|
|
|
|
|
|
|
|
error = mutex_lock_interruptible(&input_mutex);
|
|
|
|
if (error) {
|
|
|
|
state->mutex_acquired = false;
|
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
state->mutex_acquired = true;
|
|
|
|
state->pos = *pos;
|
2007-08-30 11:22:11 +07:00
|
|
|
|
2007-07-18 11:38:32 +07:00
|
|
|
return seq_list_start(&input_handler_list, *pos);
|
2006-04-02 12:09:34 +07:00
|
|
|
}
|
2005-06-30 12:50:29 +07:00
|
|
|
|
2006-04-02 12:09:34 +07:00
|
|
|
static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
2009-10-14 13:37:30 +07:00
|
|
|
union input_seq_state *state = (union input_seq_state *)&seq->private;
|
2005-06-30 12:50:29 +07:00
|
|
|
|
2009-10-14 13:37:30 +07:00
|
|
|
state->pos = *pos + 1;
|
|
|
|
return seq_list_next(v, &input_handler_list, pos);
|
2006-04-02 12:09:34 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int input_handlers_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct input_handler *handler = container_of(v, struct input_handler, node);
|
2009-10-14 13:37:30 +07:00
|
|
|
union input_seq_state *state = (union input_seq_state *)&seq->private;
|
2006-04-02 12:09:34 +07:00
|
|
|
|
2009-10-14 13:37:30 +07:00
|
|
|
seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name);
|
2010-01-30 14:59:12 +07:00
|
|
|
if (handler->filter)
|
|
|
|
seq_puts(seq, " (filter)");
|
2012-10-08 23:07:24 +07:00
|
|
|
if (handler->legacy_minors)
|
2006-04-02 12:09:34 +07:00
|
|
|
seq_printf(seq, " Minor=%d", handler->minor);
|
|
|
|
seq_putc(seq, '\n');
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2009-10-14 13:37:30 +07:00
|
|
|
|
2008-01-31 12:43:32 +07:00
|
|
|
static const struct seq_operations input_handlers_seq_ops = {
|
2006-04-02 12:09:34 +07:00
|
|
|
.start = input_handlers_seq_start,
|
|
|
|
.next = input_handlers_seq_next,
|
2009-10-14 13:37:30 +07:00
|
|
|
.stop = input_seq_stop,
|
2006-04-02 12:09:34 +07:00
|
|
|
.show = input_handlers_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int input_proc_handlers_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return seq_open(file, &input_handlers_seq_ops);
|
|
|
|
}
|
|
|
|
|
2007-02-12 15:55:32 +07:00
|
|
|
static const struct file_operations input_handlers_fileops = {
|
2006-04-02 12:09:34 +07:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = input_proc_handlers_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
2005-06-30 12:50:29 +07:00
|
|
|
|
|
|
|
static int __init input_proc_init(void)
|
|
|
|
{
|
|
|
|
struct proc_dir_entry *entry;
|
|
|
|
|
2008-04-29 15:01:41 +07:00
|
|
|
proc_bus_input_dir = proc_mkdir("bus/input", NULL);
|
2005-06-30 12:50:29 +07:00
|
|
|
if (!proc_bus_input_dir)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-04-29 15:02:35 +07:00
|
|
|
entry = proc_create("devices", 0, proc_bus_input_dir,
|
|
|
|
&input_devices_fileops);
|
2005-06-30 12:50:29 +07:00
|
|
|
if (!entry)
|
|
|
|
goto fail1;
|
|
|
|
|
2008-04-29 15:02:35 +07:00
|
|
|
entry = proc_create("handlers", 0, proc_bus_input_dir,
|
|
|
|
&input_handlers_fileops);
|
2005-06-30 12:50:29 +07:00
|
|
|
if (!entry)
|
|
|
|
goto fail2;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail2: remove_proc_entry("devices", proc_bus_input_dir);
|
2008-04-29 15:01:41 +07:00
|
|
|
fail1: remove_proc_entry("bus/input", NULL);
|
2005-06-30 12:50:29 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2005-07-02 11:54:30 +07:00
|
|
|
static void input_proc_exit(void)
|
2005-06-30 12:50:29 +07:00
|
|
|
{
|
|
|
|
remove_proc_entry("devices", proc_bus_input_dir);
|
|
|
|
remove_proc_entry("handlers", proc_bus_input_dir);
|
2008-04-29 15:01:41 +07:00
|
|
|
remove_proc_entry("bus/input", NULL);
|
2005-06-30 12:50:29 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
#else /* !CONFIG_PROC_FS */
|
|
|
|
static inline void input_wakeup_procfs_readers(void) { }
|
|
|
|
static inline int input_proc_init(void) { return 0; }
|
|
|
|
static inline void input_proc_exit(void) { }
|
|
|
|
#endif
|
|
|
|
|
2007-06-15 10:32:24 +07:00
|
|
|
#define INPUT_DEV_STRING_ATTR_SHOW(name) \
|
|
|
|
static ssize_t input_dev_show_##name(struct device *dev, \
|
|
|
|
struct device_attribute *attr, \
|
|
|
|
char *buf) \
|
|
|
|
{ \
|
|
|
|
struct input_dev *input_dev = to_input_dev(dev); \
|
|
|
|
\
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "%s\n", \
|
|
|
|
input_dev->name ? input_dev->name : ""); \
|
|
|
|
} \
|
|
|
|
static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
|
2005-09-15 14:01:55 +07:00
|
|
|
|
|
|
|
INPUT_DEV_STRING_ATTR_SHOW(name);
|
|
|
|
INPUT_DEV_STRING_ATTR_SHOW(phys);
|
|
|
|
INPUT_DEV_STRING_ATTR_SHOW(uniq);
|
|
|
|
|
2006-04-02 12:09:51 +07:00
|
|
|
static int input_print_modalias_bits(char *buf, int size,
|
|
|
|
char name, unsigned long *bm,
|
|
|
|
unsigned int min_bit, unsigned int max_bit)
|
2005-12-08 03:40:34 +07:00
|
|
|
{
|
2006-04-02 12:09:51 +07:00
|
|
|
int len = 0, i;
|
2005-12-08 03:40:34 +07:00
|
|
|
|
2006-04-02 12:09:51 +07:00
|
|
|
len += snprintf(buf, max(size, 0), "%c", name);
|
|
|
|
for (i = min_bit; i < max_bit; i++)
|
2007-10-19 13:40:32 +07:00
|
|
|
if (bm[BIT_WORD(i)] & BIT_MASK(i))
|
2006-04-02 12:09:51 +07:00
|
|
|
len += snprintf(buf + len, max(size - len, 0), "%X,", i);
|
2005-12-08 03:40:34 +07:00
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2006-04-02 12:09:26 +07:00
|
|
|
static int input_print_modalias(char *buf, int size, struct input_dev *id,
|
|
|
|
int add_cr)
|
2005-12-08 03:40:34 +07:00
|
|
|
{
|
2006-01-05 19:19:55 +07:00
|
|
|
int len;
|
2005-12-08 03:40:34 +07:00
|
|
|
|
2006-04-02 12:09:51 +07:00
|
|
|
len = snprintf(buf, max(size, 0),
|
|
|
|
"input:b%04Xv%04Xp%04Xe%04X-",
|
|
|
|
id->id.bustype, id->id.vendor,
|
|
|
|
id->id.product, id->id.version);
|
|
|
|
|
|
|
|
len += input_print_modalias_bits(buf + len, size - len,
|
|
|
|
'e', id->evbit, 0, EV_MAX);
|
|
|
|
len += input_print_modalias_bits(buf + len, size - len,
|
|
|
|
'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
|
|
|
|
len += input_print_modalias_bits(buf + len, size - len,
|
|
|
|
'r', id->relbit, 0, REL_MAX);
|
|
|
|
len += input_print_modalias_bits(buf + len, size - len,
|
|
|
|
'a', id->absbit, 0, ABS_MAX);
|
|
|
|
len += input_print_modalias_bits(buf + len, size - len,
|
|
|
|
'm', id->mscbit, 0, MSC_MAX);
|
|
|
|
len += input_print_modalias_bits(buf + len, size - len,
|
|
|
|
'l', id->ledbit, 0, LED_MAX);
|
|
|
|
len += input_print_modalias_bits(buf + len, size - len,
|
|
|
|
's', id->sndbit, 0, SND_MAX);
|
|
|
|
len += input_print_modalias_bits(buf + len, size - len,
|
|
|
|
'f', id->ffbit, 0, FF_MAX);
|
|
|
|
len += input_print_modalias_bits(buf + len, size - len,
|
|
|
|
'w', id->swbit, 0, SW_MAX);
|
2006-04-02 12:09:26 +07:00
|
|
|
|
|
|
|
if (add_cr)
|
2006-04-02 12:09:51 +07:00
|
|
|
len += snprintf(buf + len, max(size - len, 0), "\n");
|
2006-04-02 12:09:26 +07:00
|
|
|
|
2006-01-05 19:19:55 +07:00
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2007-06-15 10:32:24 +07:00
|
|
|
static ssize_t input_dev_show_modalias(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
2006-01-05 19:19:55 +07:00
|
|
|
{
|
|
|
|
struct input_dev *id = to_input_dev(dev);
|
|
|
|
ssize_t len;
|
|
|
|
|
2006-04-02 12:09:26 +07:00
|
|
|
len = input_print_modalias(buf, PAGE_SIZE, id, 1);
|
|
|
|
|
2006-06-26 12:48:21 +07:00
|
|
|
return min_t(int, len, PAGE_SIZE);
|
2005-12-08 03:40:34 +07:00
|
|
|
}
|
2007-06-15 10:32:24 +07:00
|
|
|
static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
|
2005-12-08 03:40:34 +07:00
|
|
|
|
2010-12-19 02:51:13 +07:00
|
|
|
static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
|
|
|
|
int max, int add_cr);
|
|
|
|
|
|
|
|
static ssize_t input_dev_show_properties(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct input_dev *input_dev = to_input_dev(dev);
|
|
|
|
int len = input_print_bitmap(buf, PAGE_SIZE, input_dev->propbit,
|
|
|
|
INPUT_PROP_MAX, true);
|
|
|
|
return min_t(int, len, PAGE_SIZE);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR(properties, S_IRUGO, input_dev_show_properties, NULL);
|
|
|
|
|
2005-10-28 12:25:43 +07:00
|
|
|
static struct attribute *input_dev_attrs[] = {
|
2007-06-15 10:32:24 +07:00
|
|
|
&dev_attr_name.attr,
|
|
|
|
&dev_attr_phys.attr,
|
|
|
|
&dev_attr_uniq.attr,
|
|
|
|
&dev_attr_modalias.attr,
|
2010-12-19 02:51:13 +07:00
|
|
|
&dev_attr_properties.attr,
|
2005-10-28 12:25:43 +07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2005-11-20 12:56:31 +07:00
|
|
|
static struct attribute_group input_dev_attr_group = {
|
2005-10-28 12:25:43 +07:00
|
|
|
.attrs = input_dev_attrs,
|
2005-09-15 14:01:55 +07:00
|
|
|
};
|
|
|
|
|
2007-06-15 10:32:24 +07:00
|
|
|
#define INPUT_DEV_ID_ATTR(name) \
|
|
|
|
static ssize_t input_dev_show_id_##name(struct device *dev, \
|
|
|
|
struct device_attribute *attr, \
|
|
|
|
char *buf) \
|
|
|
|
{ \
|
|
|
|
struct input_dev *input_dev = to_input_dev(dev); \
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \
|
|
|
|
} \
|
|
|
|
static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
|
2005-09-15 14:01:55 +07:00
|
|
|
|
|
|
|
INPUT_DEV_ID_ATTR(bustype);
|
|
|
|
INPUT_DEV_ID_ATTR(vendor);
|
|
|
|
INPUT_DEV_ID_ATTR(product);
|
|
|
|
INPUT_DEV_ID_ATTR(version);
|
|
|
|
|
|
|
|
static struct attribute *input_dev_id_attrs[] = {
|
2007-06-15 10:32:24 +07:00
|
|
|
&dev_attr_bustype.attr,
|
|
|
|
&dev_attr_vendor.attr,
|
|
|
|
&dev_attr_product.attr,
|
|
|
|
&dev_attr_version.attr,
|
2005-09-15 14:01:55 +07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group input_dev_id_attr_group = {
|
|
|
|
.name = "id",
|
|
|
|
.attrs = input_dev_id_attrs,
|
|
|
|
};
|
|
|
|
|
2006-04-02 12:09:34 +07:00
|
|
|
static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
|
|
|
|
int max, int add_cr)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int len = 0;
|
2010-01-11 15:05:43 +07:00
|
|
|
bool skip_empty = true;
|
|
|
|
|
|
|
|
for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
|
|
|
|
len += input_bits_to_string(buf + len, max(buf_size - len, 0),
|
|
|
|
bitmap[i], skip_empty);
|
|
|
|
if (len) {
|
|
|
|
skip_empty = false;
|
|
|
|
if (i > 0)
|
|
|
|
len += snprintf(buf + len, max(buf_size - len, 0), " ");
|
|
|
|
}
|
|
|
|
}
|
2006-04-02 12:09:34 +07:00
|
|
|
|
2010-01-11 15:05:43 +07:00
|
|
|
/*
|
|
|
|
* If no output was produced print a single 0.
|
|
|
|
*/
|
|
|
|
if (len == 0)
|
|
|
|
len = snprintf(buf, buf_size, "%d", 0);
|
2006-04-02 12:09:34 +07:00
|
|
|
|
|
|
|
if (add_cr)
|
|
|
|
len += snprintf(buf + len, max(buf_size - len, 0), "\n");
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2007-06-15 10:32:24 +07:00
|
|
|
#define INPUT_DEV_CAP_ATTR(ev, bm) \
|
|
|
|
static ssize_t input_dev_show_cap_##bm(struct device *dev, \
|
|
|
|
struct device_attribute *attr, \
|
|
|
|
char *buf) \
|
|
|
|
{ \
|
|
|
|
struct input_dev *input_dev = to_input_dev(dev); \
|
|
|
|
int len = input_print_bitmap(buf, PAGE_SIZE, \
|
2010-01-11 15:05:43 +07:00
|
|
|
input_dev->bm##bit, ev##_MAX, \
|
|
|
|
true); \
|
2007-06-15 10:32:24 +07:00
|
|
|
return min_t(int, len, PAGE_SIZE); \
|
|
|
|
} \
|
|
|
|
static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
|
2005-09-15 14:01:55 +07:00
|
|
|
|
|
|
|
INPUT_DEV_CAP_ATTR(EV, ev);
|
|
|
|
INPUT_DEV_CAP_ATTR(KEY, key);
|
|
|
|
INPUT_DEV_CAP_ATTR(REL, rel);
|
|
|
|
INPUT_DEV_CAP_ATTR(ABS, abs);
|
|
|
|
INPUT_DEV_CAP_ATTR(MSC, msc);
|
|
|
|
INPUT_DEV_CAP_ATTR(LED, led);
|
|
|
|
INPUT_DEV_CAP_ATTR(SND, snd);
|
|
|
|
INPUT_DEV_CAP_ATTR(FF, ff);
|
|
|
|
INPUT_DEV_CAP_ATTR(SW, sw);
|
|
|
|
|
|
|
|
static struct attribute *input_dev_caps_attrs[] = {
|
2007-06-15 10:32:24 +07:00
|
|
|
&dev_attr_ev.attr,
|
|
|
|
&dev_attr_key.attr,
|
|
|
|
&dev_attr_rel.attr,
|
|
|
|
&dev_attr_abs.attr,
|
|
|
|
&dev_attr_msc.attr,
|
|
|
|
&dev_attr_led.attr,
|
|
|
|
&dev_attr_snd.attr,
|
|
|
|
&dev_attr_ff.attr,
|
|
|
|
&dev_attr_sw.attr,
|
2005-09-15 14:01:55 +07:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group input_dev_caps_attr_group = {
|
|
|
|
.name = "capabilities",
|
|
|
|
.attrs = input_dev_caps_attrs,
|
|
|
|
};
|
|
|
|
|
2009-06-25 00:06:31 +07:00
|
|
|
static const struct attribute_group *input_dev_attr_groups[] = {
|
2007-03-08 11:20:26 +07:00
|
|
|
&input_dev_attr_group,
|
|
|
|
&input_dev_id_attr_group,
|
|
|
|
&input_dev_caps_attr_group,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2007-06-15 10:32:24 +07:00
|
|
|
static void input_dev_release(struct device *device)
|
2005-09-15 14:01:39 +07:00
|
|
|
{
|
2007-06-15 10:32:24 +07:00
|
|
|
struct input_dev *dev = to_input_dev(device);
|
2005-09-15 14:01:39 +07:00
|
|
|
|
2006-07-19 12:40:22 +07:00
|
|
|
input_ff_destroy(dev);
|
2010-07-16 13:10:10 +07:00
|
|
|
input_mt_destroy_slots(dev);
|
2010-08-03 10:18:21 +07:00
|
|
|
kfree(dev->absinfo);
|
2012-09-15 20:23:35 +07:00
|
|
|
kfree(dev->vals);
|
2005-09-15 14:01:39 +07:00
|
|
|
kfree(dev);
|
2006-07-19 12:40:22 +07:00
|
|
|
|
2005-09-15 14:01:39 +07:00
|
|
|
module_put(THIS_MODULE);
|
|
|
|
}
|
|
|
|
|
2005-09-15 14:01:57 +07:00
|
|
|
/*
|
2005-11-16 15:00:00 +07:00
|
|
|
* Input uevent interface - loading event handlers based on
|
2005-09-15 14:01:57 +07:00
|
|
|
* device bitfields.
|
|
|
|
*/
|
2007-08-14 20:15:12 +07:00
|
|
|
static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
|
2006-04-02 12:09:51 +07:00
|
|
|
const char *name, unsigned long *bitmap, int max)
|
2005-09-15 14:01:57 +07:00
|
|
|
{
|
2007-08-14 20:15:12 +07:00
|
|
|
int len;
|
2005-09-15 14:01:57 +07:00
|
|
|
|
2010-12-19 02:28:26 +07:00
|
|
|
if (add_uevent_var(env, "%s", name))
|
2005-09-15 14:01:57 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-08-14 20:15:12 +07:00
|
|
|
len = input_print_bitmap(&env->buf[env->buflen - 1],
|
|
|
|
sizeof(env->buf) - env->buflen,
|
2010-01-11 15:05:43 +07:00
|
|
|
bitmap, max, false);
|
2007-08-14 20:15:12 +07:00
|
|
|
if (len >= (sizeof(env->buf) - env->buflen))
|
2005-09-15 14:01:57 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-08-14 20:15:12 +07:00
|
|
|
env->buflen += len;
|
2005-09-15 14:01:57 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-08-14 20:15:12 +07:00
|
|
|
static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
|
2006-04-02 12:09:51 +07:00
|
|
|
struct input_dev *dev)
|
|
|
|
{
|
2007-08-14 20:15:12 +07:00
|
|
|
int len;
|
2006-04-02 12:09:51 +07:00
|
|
|
|
2007-08-14 20:15:12 +07:00
|
|
|
if (add_uevent_var(env, "MODALIAS="))
|
2006-04-02 12:09:51 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-08-14 20:15:12 +07:00
|
|
|
len = input_print_modalias(&env->buf[env->buflen - 1],
|
|
|
|
sizeof(env->buf) - env->buflen,
|
|
|
|
dev, 0);
|
|
|
|
if (len >= (sizeof(env->buf) - env->buflen))
|
2006-04-02 12:09:51 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-08-14 20:15:12 +07:00
|
|
|
env->buflen += len;
|
2006-04-02 12:09:51 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-09-15 14:01:57 +07:00
|
|
|
#define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \
|
|
|
|
do { \
|
2007-08-14 20:15:12 +07:00
|
|
|
int err = add_uevent_var(env, fmt, val); \
|
2005-09-15 14:01:57 +07:00
|
|
|
if (err) \
|
|
|
|
return err; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \
|
|
|
|
do { \
|
2007-08-14 20:15:12 +07:00
|
|
|
int err = input_add_uevent_bm_var(env, name, bm, max); \
|
2005-09-15 14:01:57 +07:00
|
|
|
if (err) \
|
|
|
|
return err; \
|
|
|
|
} while (0)
|
|
|
|
|
2006-04-02 12:09:51 +07:00
|
|
|
#define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev) \
|
|
|
|
do { \
|
2007-08-14 20:15:12 +07:00
|
|
|
int err = input_add_uevent_modalias_var(env, dev); \
|
2006-04-02 12:09:51 +07:00
|
|
|
if (err) \
|
|
|
|
return err; \
|
|
|
|
} while (0)
|
|
|
|
|
2007-08-14 20:15:12 +07:00
|
|
|
static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
|
2005-09-15 14:01:57 +07:00
|
|
|
{
|
2007-06-15 10:32:24 +07:00
|
|
|
struct input_dev *dev = to_input_dev(device);
|
2005-09-15 14:01:57 +07:00
|
|
|
|
|
|
|
INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
|
|
|
|
dev->id.bustype, dev->id.vendor,
|
|
|
|
dev->id.product, dev->id.version);
|
|
|
|
if (dev->name)
|
|
|
|
INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
|
|
|
|
if (dev->phys)
|
|
|
|
INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
|
2005-11-09 12:34:29 +07:00
|
|
|
if (dev->uniq)
|
2005-09-15 14:01:57 +07:00
|
|
|
INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
|
|
|
|
|
2010-12-19 02:51:13 +07:00
|
|
|
INPUT_ADD_HOTPLUG_BM_VAR("PROP=", dev->propbit, INPUT_PROP_MAX);
|
|
|
|
|
2005-09-15 14:01:57 +07:00
|
|
|
INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
|
|
|
|
if (test_bit(EV_KEY, dev->evbit))
|
|
|
|
INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
|
|
|
|
if (test_bit(EV_REL, dev->evbit))
|
|
|
|
INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
|
|
|
|
if (test_bit(EV_ABS, dev->evbit))
|
|
|
|
INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
|
|
|
|
if (test_bit(EV_MSC, dev->evbit))
|
|
|
|
INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
|
|
|
|
if (test_bit(EV_LED, dev->evbit))
|
|
|
|
INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
|
|
|
|
if (test_bit(EV_SND, dev->evbit))
|
|
|
|
INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
|
|
|
|
if (test_bit(EV_FF, dev->evbit))
|
|
|
|
INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
|
|
|
|
if (test_bit(EV_SW, dev->evbit))
|
|
|
|
INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
|
|
|
|
|
2006-04-02 12:09:51 +07:00
|
|
|
INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
|
2005-09-15 14:01:57 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-13 14:19:05 +07:00
|
|
|
#define INPUT_DO_TOGGLE(dev, type, bits, on) \
|
|
|
|
do { \
|
|
|
|
int i; \
|
|
|
|
bool active; \
|
|
|
|
\
|
|
|
|
if (!test_bit(EV_##type, dev->evbit)) \
|
|
|
|
break; \
|
|
|
|
\
|
2015-06-26 03:33:12 +07:00
|
|
|
for_each_set_bit(i, dev->bits##bit, type##_CNT) { \
|
2009-11-13 14:19:05 +07:00
|
|
|
active = test_bit(i, dev->bits); \
|
|
|
|
if (!active && !on) \
|
|
|
|
continue; \
|
|
|
|
\
|
|
|
|
dev->event(dev, EV_##type, i, on ? active : 0); \
|
|
|
|
} \
|
2009-09-16 15:06:43 +07:00
|
|
|
} while (0)
|
|
|
|
|
2010-11-04 01:02:31 +07:00
|
|
|
static void input_dev_toggle(struct input_dev *dev, bool activate)
|
2009-09-16 15:06:43 +07:00
|
|
|
{
|
|
|
|
if (!dev->event)
|
|
|
|
return;
|
|
|
|
|
|
|
|
INPUT_DO_TOGGLE(dev, LED, led, activate);
|
|
|
|
INPUT_DO_TOGGLE(dev, SND, snd, activate);
|
|
|
|
|
|
|
|
if (activate && test_bit(EV_REP, dev->evbit)) {
|
|
|
|
dev->event(dev, EV_REP, REP_PERIOD, dev->rep[REP_PERIOD]);
|
|
|
|
dev->event(dev, EV_REP, REP_DELAY, dev->rep[REP_DELAY]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-04 01:02:31 +07:00
|
|
|
/**
|
|
|
|
* input_reset_device() - reset/restore the state of input device
|
|
|
|
* @dev: input device whose state needs to be reset
|
|
|
|
*
|
|
|
|
* This function tries to reset the state of an opened input device and
|
|
|
|
* bring internal state and state if the hardware in sync with each other.
|
|
|
|
* We mark all keys as released, restore LED state, repeat rate, etc.
|
|
|
|
*/
|
|
|
|
void input_reset_device(struct input_dev *dev)
|
|
|
|
{
|
2013-11-24 01:20:36 +07:00
|
|
|
unsigned long flags;
|
2010-11-04 01:02:31 +07:00
|
|
|
|
2013-11-24 01:20:36 +07:00
|
|
|
mutex_lock(&dev->mutex);
|
|
|
|
spin_lock_irqsave(&dev->event_lock, flags);
|
2010-11-04 01:02:31 +07:00
|
|
|
|
2013-11-24 01:20:36 +07:00
|
|
|
input_dev_toggle(dev, true);
|
|
|
|
input_dev_release_keys(dev);
|
2010-11-04 01:02:31 +07:00
|
|
|
|
2013-11-24 01:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&dev->event_lock, flags);
|
2010-11-04 01:02:31 +07:00
|
|
|
mutex_unlock(&dev->mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_reset_device);
|
|
|
|
|
2013-11-24 01:20:36 +07:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2009-09-16 15:06:43 +07:00
|
|
|
static int input_dev_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct input_dev *input_dev = to_input_dev(dev);
|
|
|
|
|
2013-11-24 01:20:36 +07:00
|
|
|
spin_lock_irq(&input_dev->event_lock);
|
2010-11-04 01:02:31 +07:00
|
|
|
|
2013-11-24 01:20:36 +07:00
|
|
|
/*
|
|
|
|
* Keys that are pressed now are unlikely to be
|
|
|
|
* still pressed when we resume.
|
|
|
|
*/
|
|
|
|
input_dev_release_keys(input_dev);
|
2010-11-04 01:02:31 +07:00
|
|
|
|
2013-11-24 01:20:36 +07:00
|
|
|
/* Turn off LEDs and sounds, if any are active. */
|
|
|
|
input_dev_toggle(input_dev, false);
|
|
|
|
|
|
|
|
spin_unlock_irq(&input_dev->event_lock);
|
2009-09-16 15:06:43 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int input_dev_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct input_dev *input_dev = to_input_dev(dev);
|
|
|
|
|
2013-11-24 01:20:36 +07:00
|
|
|
spin_lock_irq(&input_dev->event_lock);
|
|
|
|
|
|
|
|
/* Restore state of LEDs and sounds, if any were active. */
|
|
|
|
input_dev_toggle(input_dev, true);
|
|
|
|
|
|
|
|
spin_unlock_irq(&input_dev->event_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int input_dev_freeze(struct device *dev)
|
|
|
|
{
|
|
|
|
struct input_dev *input_dev = to_input_dev(dev);
|
|
|
|
|
|
|
|
spin_lock_irq(&input_dev->event_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Keys that are pressed now are unlikely to be
|
|
|
|
* still pressed when we resume.
|
|
|
|
*/
|
|
|
|
input_dev_release_keys(input_dev);
|
|
|
|
|
|
|
|
spin_unlock_irq(&input_dev->event_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int input_dev_poweroff(struct device *dev)
|
|
|
|
{
|
|
|
|
struct input_dev *input_dev = to_input_dev(dev);
|
|
|
|
|
|
|
|
spin_lock_irq(&input_dev->event_lock);
|
|
|
|
|
|
|
|
/* Turn off LEDs and sounds, if any are active. */
|
|
|
|
input_dev_toggle(input_dev, false);
|
|
|
|
|
|
|
|
spin_unlock_irq(&input_dev->event_lock);
|
2009-09-16 15:06:43 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct dev_pm_ops input_dev_pm_ops = {
|
|
|
|
.suspend = input_dev_suspend,
|
|
|
|
.resume = input_dev_resume,
|
2013-11-24 01:20:36 +07:00
|
|
|
.freeze = input_dev_freeze,
|
|
|
|
.poweroff = input_dev_poweroff,
|
2009-09-16 15:06:43 +07:00
|
|
|
.restore = input_dev_resume,
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
|
2007-06-15 10:32:24 +07:00
|
|
|
static struct device_type input_dev_type = {
|
|
|
|
.groups = input_dev_attr_groups,
|
|
|
|
.release = input_dev_release,
|
|
|
|
.uevent = input_dev_uevent,
|
2013-11-24 01:20:36 +07:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2009-09-16 15:06:43 +07:00
|
|
|
.pm = &input_dev_pm_ops,
|
|
|
|
#endif
|
2007-06-15 10:32:24 +07:00
|
|
|
};
|
|
|
|
|
2011-07-24 07:24:48 +07:00
|
|
|
static char *input_devnode(struct device *dev, umode_t *mode)
|
2009-04-30 20:23:42 +07:00
|
|
|
{
|
|
|
|
return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
|
|
|
|
}
|
|
|
|
|
2005-10-28 12:25:43 +07:00
|
|
|
struct class input_class = {
|
2007-06-15 10:32:24 +07:00
|
|
|
.name = "input",
|
2009-09-19 04:01:12 +07:00
|
|
|
.devnode = input_devnode,
|
2005-09-15 14:01:39 +07:00
|
|
|
};
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL_GPL(input_class);
|
2005-09-15 14:01:39 +07:00
|
|
|
|
2006-11-03 11:26:55 +07:00
|
|
|
/**
|
|
|
|
* input_allocate_device - allocate memory for new input device
|
|
|
|
*
|
2012-11-04 02:16:12 +07:00
|
|
|
* Returns prepared struct input_dev or %NULL.
|
2006-11-03 11:26:55 +07:00
|
|
|
*
|
|
|
|
* NOTE: Use input_free_device() to free devices that have not been
|
|
|
|
* registered; input_unregister_device() should be used for already
|
|
|
|
* registered devices.
|
|
|
|
*/
|
2005-09-15 14:01:39 +07:00
|
|
|
struct input_dev *input_allocate_device(void)
|
|
|
|
{
|
2014-12-03 06:22:28 +07:00
|
|
|
static atomic_t input_no = ATOMIC_INIT(-1);
|
2005-09-15 14:01:39 +07:00
|
|
|
struct input_dev *dev;
|
|
|
|
|
|
|
|
dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
|
|
|
|
if (dev) {
|
2007-06-15 10:32:24 +07:00
|
|
|
dev->dev.type = &input_dev_type;
|
|
|
|
dev->dev.class = &input_class;
|
|
|
|
device_initialize(&dev->dev);
|
2006-06-26 12:48:36 +07:00
|
|
|
mutex_init(&dev->mutex);
|
2007-08-30 11:22:11 +07:00
|
|
|
spin_lock_init(&dev->event_lock);
|
2013-10-06 15:15:08 +07:00
|
|
|
init_timer(&dev->timer);
|
2005-09-15 14:01:39 +07:00
|
|
|
INIT_LIST_HEAD(&dev->h_list);
|
|
|
|
INIT_LIST_HEAD(&dev->node);
|
2006-09-14 12:32:14 +07:00
|
|
|
|
2014-10-09 04:24:15 +07:00
|
|
|
dev_set_name(&dev->dev, "input%lu",
|
2014-12-03 06:22:28 +07:00
|
|
|
(unsigned long)atomic_inc_return(&input_no));
|
2013-10-06 15:15:08 +07:00
|
|
|
|
2006-09-14 12:32:14 +07:00
|
|
|
__module_get(THIS_MODULE);
|
2005-09-15 14:01:39 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return dev;
|
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_allocate_device);
|
2005-09-15 14:01:39 +07:00
|
|
|
|
2012-11-04 02:16:12 +07:00
|
|
|
struct input_devres {
|
|
|
|
struct input_dev *input;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int devm_input_device_match(struct device *dev, void *res, void *data)
|
|
|
|
{
|
|
|
|
struct input_devres *devres = res;
|
|
|
|
|
|
|
|
return devres->input == data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void devm_input_device_release(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
struct input_devres *devres = res;
|
|
|
|
struct input_dev *input = devres->input;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s: dropping reference to %s\n",
|
|
|
|
__func__, dev_name(&input->dev));
|
|
|
|
input_put_device(input);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_input_allocate_device - allocate managed input device
|
|
|
|
* @dev: device owning the input device being created
|
|
|
|
*
|
|
|
|
* Returns prepared struct input_dev or %NULL.
|
|
|
|
*
|
|
|
|
* Managed input devices do not need to be explicitly unregistered or
|
|
|
|
* freed as it will be done automatically when owner device unbinds from
|
|
|
|
* its driver (or binding fails). Once managed input device is allocated,
|
|
|
|
* it is ready to be set up and registered in the same fashion as regular
|
|
|
|
* input device. There are no special devm_input_device_[un]register()
|
2013-01-09 00:10:31 +07:00
|
|
|
* variants, regular ones work with both managed and unmanaged devices,
|
|
|
|
* should you need them. In most cases however, managed input device need
|
|
|
|
* not be explicitly unregistered or freed.
|
2012-11-04 02:16:12 +07:00
|
|
|
*
|
|
|
|
* NOTE: the owner device is set up as parent of input device and users
|
|
|
|
* should not override it.
|
|
|
|
*/
|
|
|
|
struct input_dev *devm_input_allocate_device(struct device *dev)
|
|
|
|
{
|
|
|
|
struct input_dev *input;
|
|
|
|
struct input_devres *devres;
|
|
|
|
|
|
|
|
devres = devres_alloc(devm_input_device_release,
|
|
|
|
sizeof(struct input_devres), GFP_KERNEL);
|
|
|
|
if (!devres)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
input = input_allocate_device();
|
|
|
|
if (!input) {
|
|
|
|
devres_free(devres);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
input->dev.parent = dev;
|
|
|
|
input->devres_managed = true;
|
|
|
|
|
|
|
|
devres->input = input;
|
|
|
|
devres_add(dev, devres);
|
|
|
|
|
|
|
|
return input;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(devm_input_allocate_device);
|
|
|
|
|
2006-11-03 11:26:55 +07:00
|
|
|
/**
|
|
|
|
* input_free_device - free memory occupied by input_dev structure
|
|
|
|
* @dev: input device to free
|
|
|
|
*
|
|
|
|
* This function should only be used if input_register_device()
|
|
|
|
* was not called yet or if it failed. Once device was registered
|
|
|
|
* use input_unregister_device() and memory will be freed once last
|
2007-08-30 11:22:11 +07:00
|
|
|
* reference to the device is dropped.
|
2006-11-03 11:26:55 +07:00
|
|
|
*
|
|
|
|
* Device should be allocated by input_allocate_device().
|
|
|
|
*
|
|
|
|
* NOTE: If there are references to the input device then memory
|
|
|
|
* will not be freed until last reference is dropped.
|
|
|
|
*/
|
2006-06-26 12:48:36 +07:00
|
|
|
void input_free_device(struct input_dev *dev)
|
|
|
|
{
|
2012-11-04 02:16:12 +07:00
|
|
|
if (dev) {
|
|
|
|
if (dev->devres_managed)
|
|
|
|
WARN_ON(devres_destroy(dev->dev.parent,
|
|
|
|
devm_input_device_release,
|
|
|
|
devm_input_device_match,
|
|
|
|
dev));
|
2006-06-26 12:48:36 +07:00
|
|
|
input_put_device(dev);
|
2012-11-04 02:16:12 +07:00
|
|
|
}
|
2006-06-26 12:48:36 +07:00
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_free_device);
|
2006-06-26 12:48:36 +07:00
|
|
|
|
2007-04-25 11:53:18 +07:00
|
|
|
/**
|
|
|
|
* input_set_capability - mark device as capable of a certain event
|
|
|
|
* @dev: device that is capable of emitting or accepting event
|
|
|
|
* @type: type of the event (EV_KEY, EV_REL, etc...)
|
|
|
|
* @code: event code
|
|
|
|
*
|
|
|
|
* In addition to setting up corresponding bit in appropriate capability
|
|
|
|
* bitmap the function also adjusts dev->evbit.
|
|
|
|
*/
|
|
|
|
void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case EV_KEY:
|
|
|
|
__set_bit(code, dev->keybit);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EV_REL:
|
|
|
|
__set_bit(code, dev->relbit);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EV_ABS:
|
2013-12-27 08:44:29 +07:00
|
|
|
input_alloc_absinfo(dev);
|
|
|
|
if (!dev->absinfo)
|
|
|
|
return;
|
|
|
|
|
2007-04-25 11:53:18 +07:00
|
|
|
__set_bit(code, dev->absbit);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EV_MSC:
|
|
|
|
__set_bit(code, dev->mscbit);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EV_SW:
|
|
|
|
__set_bit(code, dev->swbit);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EV_LED:
|
|
|
|
__set_bit(code, dev->ledbit);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EV_SND:
|
|
|
|
__set_bit(code, dev->sndbit);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EV_FF:
|
|
|
|
__set_bit(code, dev->ffbit);
|
|
|
|
break;
|
|
|
|
|
2007-12-14 13:21:03 +07:00
|
|
|
case EV_PWR:
|
|
|
|
/* do nothing */
|
|
|
|
break;
|
|
|
|
|
2007-04-25 11:53:18 +07:00
|
|
|
default:
|
2010-11-30 14:33:07 +07:00
|
|
|
pr_err("input_set_capability: unknown type %u (code %u)\n",
|
|
|
|
type, code);
|
2007-04-25 11:53:18 +07:00
|
|
|
dump_stack();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
__set_bit(type, dev->evbit);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_set_capability);
|
|
|
|
|
2011-04-19 00:08:02 +07:00
|
|
|
static unsigned int input_estimate_events_per_packet(struct input_dev *dev)
|
|
|
|
{
|
|
|
|
int mt_slots;
|
|
|
|
int i;
|
|
|
|
unsigned int events;
|
|
|
|
|
2012-09-15 20:15:58 +07:00
|
|
|
if (dev->mt) {
|
|
|
|
mt_slots = dev->mt->num_slots;
|
2011-04-19 00:08:02 +07:00
|
|
|
} else if (test_bit(ABS_MT_TRACKING_ID, dev->absbit)) {
|
|
|
|
mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum -
|
|
|
|
dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1,
|
2011-05-25 23:24:32 +07:00
|
|
|
mt_slots = clamp(mt_slots, 2, 32);
|
2011-04-19 00:08:02 +07:00
|
|
|
} else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
|
|
|
|
mt_slots = 2;
|
|
|
|
} else {
|
|
|
|
mt_slots = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
events = mt_slots + 1; /* count SYN_MT_REPORT and SYN_REPORT */
|
|
|
|
|
2015-06-26 03:33:12 +07:00
|
|
|
if (test_bit(EV_ABS, dev->evbit))
|
|
|
|
for_each_set_bit(i, dev->absbit, ABS_CNT)
|
|
|
|
events += input_is_mt_axis(i) ? mt_slots : 1;
|
2011-04-19 00:08:02 +07:00
|
|
|
|
2015-06-26 03:33:12 +07:00
|
|
|
if (test_bit(EV_REL, dev->evbit))
|
|
|
|
events += bitmap_weight(dev->relbit, REL_CNT);
|
2011-04-19 00:08:02 +07:00
|
|
|
|
2012-09-01 21:15:43 +07:00
|
|
|
/* Make room for KEY and MSC events */
|
|
|
|
events += 7;
|
|
|
|
|
2011-04-19 00:08:02 +07:00
|
|
|
return events;
|
|
|
|
}
|
|
|
|
|
2010-01-06 08:56:01 +07:00
|
|
|
#define INPUT_CLEANSE_BITMASK(dev, type, bits) \
|
|
|
|
do { \
|
|
|
|
if (!test_bit(EV_##type, dev->evbit)) \
|
|
|
|
memset(dev->bits##bit, 0, \
|
|
|
|
sizeof(dev->bits##bit)); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static void input_cleanse_bitmasks(struct input_dev *dev)
|
|
|
|
{
|
|
|
|
INPUT_CLEANSE_BITMASK(dev, KEY, key);
|
|
|
|
INPUT_CLEANSE_BITMASK(dev, REL, rel);
|
|
|
|
INPUT_CLEANSE_BITMASK(dev, ABS, abs);
|
|
|
|
INPUT_CLEANSE_BITMASK(dev, MSC, msc);
|
|
|
|
INPUT_CLEANSE_BITMASK(dev, LED, led);
|
|
|
|
INPUT_CLEANSE_BITMASK(dev, SND, snd);
|
|
|
|
INPUT_CLEANSE_BITMASK(dev, FF, ff);
|
|
|
|
INPUT_CLEANSE_BITMASK(dev, SW, sw);
|
|
|
|
}
|
|
|
|
|
2012-11-04 02:16:12 +07:00
|
|
|
static void __input_unregister_device(struct input_dev *dev)
|
|
|
|
{
|
|
|
|
struct input_handle *handle, *next;
|
|
|
|
|
|
|
|
input_disconnect_device(dev);
|
|
|
|
|
|
|
|
mutex_lock(&input_mutex);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
|
|
|
|
handle->handler->disconnect(handle);
|
|
|
|
WARN_ON(!list_empty(&dev->h_list));
|
|
|
|
|
|
|
|
del_timer_sync(&dev->timer);
|
|
|
|
list_del_init(&dev->node);
|
|
|
|
|
|
|
|
input_wakeup_procfs_readers();
|
|
|
|
|
|
|
|
mutex_unlock(&input_mutex);
|
|
|
|
|
|
|
|
device_del(&dev->dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void devm_input_device_unregister(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
struct input_devres *devres = res;
|
|
|
|
struct input_dev *input = devres->input;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s: unregistering device %s\n",
|
|
|
|
__func__, dev_name(&input->dev));
|
|
|
|
__input_unregister_device(input);
|
|
|
|
}
|
|
|
|
|
2015-10-14 13:13:55 +07:00
|
|
|
/**
|
|
|
|
* input_enable_softrepeat - enable software autorepeat
|
|
|
|
* @dev: input device
|
|
|
|
* @delay: repeat delay
|
|
|
|
* @period: repeat period
|
|
|
|
*
|
|
|
|
* Enable software autorepeat on the input device.
|
|
|
|
*/
|
|
|
|
void input_enable_softrepeat(struct input_dev *dev, int delay, int period)
|
|
|
|
{
|
|
|
|
dev->timer.data = (unsigned long) dev;
|
|
|
|
dev->timer.function = input_repeat_key;
|
|
|
|
dev->rep[REP_DELAY] = delay;
|
|
|
|
dev->rep[REP_PERIOD] = period;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_enable_softrepeat);
|
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/**
|
|
|
|
* input_register_device - register device with input core
|
|
|
|
* @dev: device to be registered
|
|
|
|
*
|
|
|
|
* This function registers device with input core. The device must be
|
|
|
|
* allocated with input_allocate_device() and all it's capabilities
|
|
|
|
* set up before registering.
|
|
|
|
* If function fails the device must be freed with input_free_device().
|
|
|
|
* Once device has been successfully registered it can be unregistered
|
|
|
|
* with input_unregister_device(); input_free_device() should not be
|
|
|
|
* called in this case.
|
2013-01-09 00:10:31 +07:00
|
|
|
*
|
|
|
|
* Note that this function is also used to register managed input devices
|
|
|
|
* (ones allocated with devm_input_allocate_device()). Such managed input
|
|
|
|
* devices need not be explicitly unregistered or freed, their tear down
|
|
|
|
* is controlled by the devres infrastructure. It is also worth noting
|
|
|
|
* that tear down of managed input devices is internally a 2-step process:
|
|
|
|
* registered managed input device is first unregistered, but stays in
|
|
|
|
* memory and can still handle input_event() calls (although events will
|
|
|
|
* not be delivered anywhere). The freeing of managed input device will
|
|
|
|
* happen later, when devres stack is unwound to the point where device
|
|
|
|
* allocation was made.
|
2007-08-30 11:22:11 +07:00
|
|
|
*/
|
2005-11-03 10:51:46 +07:00
|
|
|
int input_register_device(struct input_dev *dev)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2012-11-04 02:16:12 +07:00
|
|
|
struct input_devres *devres = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct input_handler *handler;
|
2012-09-01 21:15:43 +07:00
|
|
|
unsigned int packet_size;
|
2005-11-20 12:56:31 +07:00
|
|
|
const char *path;
|
|
|
|
int error;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-11-04 02:16:12 +07:00
|
|
|
if (dev->devres_managed) {
|
|
|
|
devres = devres_alloc(devm_input_device_unregister,
|
|
|
|
sizeof(struct input_devres), GFP_KERNEL);
|
|
|
|
if (!devres)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
devres->input = dev;
|
|
|
|
}
|
|
|
|
|
2010-01-06 08:56:00 +07:00
|
|
|
/* Every input device generates EV_SYN/SYN_REPORT events. */
|
2007-08-30 11:22:11 +07:00
|
|
|
__set_bit(EV_SYN, dev->evbit);
|
2005-05-29 14:29:25 +07:00
|
|
|
|
2010-01-06 08:56:00 +07:00
|
|
|
/* KEY_RESERVED is not supposed to be transmitted to userspace. */
|
|
|
|
__clear_bit(KEY_RESERVED, dev->keybit);
|
|
|
|
|
2010-01-06 08:56:01 +07:00
|
|
|
/* Make sure that bitmasks not mentioned in dev->evbit are clean. */
|
|
|
|
input_cleanse_bitmasks(dev);
|
|
|
|
|
2012-09-01 21:15:43 +07:00
|
|
|
packet_size = input_estimate_events_per_packet(dev);
|
|
|
|
if (dev->hint_events_per_packet < packet_size)
|
|
|
|
dev->hint_events_per_packet = packet_size;
|
2011-04-19 00:08:02 +07:00
|
|
|
|
2013-10-31 14:47:53 +07:00
|
|
|
dev->max_vals = dev->hint_events_per_packet + 2;
|
2012-09-15 20:23:35 +07:00
|
|
|
dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
|
2012-11-04 02:16:12 +07:00
|
|
|
if (!dev->vals) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto err_devres_free;
|
|
|
|
}
|
2011-04-19 00:08:02 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* If delay and period are pre-set by the driver, then autorepeating
|
|
|
|
* is handled by the driver itself and we don't do it in input.c.
|
|
|
|
*/
|
2015-10-14 13:13:55 +07:00
|
|
|
if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD])
|
|
|
|
input_enable_softrepeat(dev, 250, 33);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-02-01 12:06:39 +07:00
|
|
|
if (!dev->getkeycode)
|
|
|
|
dev->getkeycode = input_default_getkeycode;
|
2007-03-15 09:50:42 +07:00
|
|
|
|
2011-02-01 12:06:39 +07:00
|
|
|
if (!dev->setkeycode)
|
|
|
|
dev->setkeycode = input_default_setkeycode;
|
2007-03-15 09:50:42 +07:00
|
|
|
|
2007-06-15 10:32:24 +07:00
|
|
|
error = device_add(&dev->dev);
|
2005-11-20 12:56:31 +07:00
|
|
|
if (error)
|
2012-11-04 02:16:12 +07:00
|
|
|
goto err_free_vals;
|
2005-11-20 12:56:31 +07:00
|
|
|
|
2007-06-15 10:32:24 +07:00
|
|
|
path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
|
2010-11-30 14:33:07 +07:00
|
|
|
pr_info("%s as %s\n",
|
|
|
|
dev->name ? dev->name : "Unspecified device",
|
|
|
|
path ? path : "N/A");
|
2005-11-20 12:56:31 +07:00
|
|
|
kfree(path);
|
2005-10-28 12:25:43 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
error = mutex_lock_interruptible(&input_mutex);
|
2012-11-04 02:16:12 +07:00
|
|
|
if (error)
|
|
|
|
goto err_device_del;
|
2007-08-30 11:22:11 +07:00
|
|
|
|
|
|
|
list_add_tail(&dev->node, &input_dev_list);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
list_for_each_entry(handler, &input_handler_list, node)
|
2007-04-12 12:29:46 +07:00
|
|
|
input_attach_handler(dev, handler);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-06-30 12:50:29 +07:00
|
|
|
input_wakeup_procfs_readers();
|
2005-11-03 10:51:46 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
mutex_unlock(&input_mutex);
|
|
|
|
|
2012-11-04 02:16:12 +07:00
|
|
|
if (dev->devres_managed) {
|
|
|
|
dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
|
|
|
|
__func__, dev_name(&dev->dev));
|
|
|
|
devres_add(dev->dev.parent, devres);
|
|
|
|
}
|
2005-11-03 10:51:46 +07:00
|
|
|
return 0;
|
2012-11-04 02:16:12 +07:00
|
|
|
|
|
|
|
err_device_del:
|
|
|
|
device_del(&dev->dev);
|
|
|
|
err_free_vals:
|
|
|
|
kfree(dev->vals);
|
|
|
|
dev->vals = NULL;
|
|
|
|
err_devres_free:
|
|
|
|
devres_free(devres);
|
|
|
|
return error;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_register_device);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/**
|
|
|
|
* input_unregister_device - unregister previously registered device
|
|
|
|
* @dev: device to be unregistered
|
|
|
|
*
|
|
|
|
* This function unregisters an input device. Once device is unregistered
|
|
|
|
* the caller should not try to access it as it may get freed at any moment.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
void input_unregister_device(struct input_dev *dev)
|
|
|
|
{
|
2012-11-04 02:16:12 +07:00
|
|
|
if (dev->devres_managed) {
|
|
|
|
WARN_ON(devres_destroy(dev->dev.parent,
|
|
|
|
devm_input_device_unregister,
|
|
|
|
devm_input_device_match,
|
|
|
|
dev));
|
|
|
|
__input_unregister_device(dev);
|
|
|
|
/*
|
|
|
|
* We do not do input_put_device() here because it will be done
|
|
|
|
* when 2nd devres fires up.
|
|
|
|
*/
|
|
|
|
} else {
|
|
|
|
__input_unregister_device(dev);
|
|
|
|
input_put_device(dev);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_unregister_device);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/**
|
|
|
|
* input_register_handler - register a new input handler
|
|
|
|
* @handler: handler to be registered
|
|
|
|
*
|
|
|
|
* This function registers a new input handler (interface) for input
|
|
|
|
* devices in the system and attaches it to all input devices that
|
|
|
|
* are compatible with the handler.
|
|
|
|
*/
|
2006-09-14 12:32:39 +07:00
|
|
|
int input_register_handler(struct input_handler *handler)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct input_dev *dev;
|
2012-10-08 23:07:24 +07:00
|
|
|
int error;
|
2007-08-30 11:22:11 +07:00
|
|
|
|
2012-10-08 23:07:24 +07:00
|
|
|
error = mutex_lock_interruptible(&input_mutex);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&handler->h_list);
|
|
|
|
|
|
|
|
list_add_tail(&handler->node, &input_handler_list);
|
|
|
|
|
|
|
|
list_for_each_entry(dev, &input_dev_list, node)
|
2007-04-12 12:29:46 +07:00
|
|
|
input_attach_handler(dev, handler);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-06-30 12:50:29 +07:00
|
|
|
input_wakeup_procfs_readers();
|
2007-08-30 11:22:11 +07:00
|
|
|
|
|
|
|
mutex_unlock(&input_mutex);
|
2012-10-08 23:07:24 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_register_handler);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/**
|
|
|
|
* input_unregister_handler - unregisters an input handler
|
|
|
|
* @handler: handler to be unregistered
|
|
|
|
*
|
|
|
|
* This function disconnects a handler from its input devices and
|
|
|
|
* removes it from lists of known handlers.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
void input_unregister_handler(struct input_handler *handler)
|
|
|
|
{
|
2007-04-12 12:29:46 +07:00
|
|
|
struct input_handle *handle, *next;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
mutex_lock(&input_mutex);
|
|
|
|
|
2007-04-12 12:29:46 +07:00
|
|
|
list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
|
2005-04-17 05:20:36 +07:00
|
|
|
handler->disconnect(handle);
|
2007-04-12 12:29:46 +07:00
|
|
|
WARN_ON(!list_empty(&handler->h_list));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
list_del_init(&handler->node);
|
|
|
|
|
2005-06-30 12:50:29 +07:00
|
|
|
input_wakeup_procfs_readers();
|
2007-08-30 11:22:11 +07:00
|
|
|
|
|
|
|
mutex_unlock(&input_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-06-26 12:49:21 +07:00
|
|
|
EXPORT_SYMBOL(input_unregister_handler);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-12-02 12:54:35 +07:00
|
|
|
/**
|
|
|
|
* input_handler_for_each_handle - handle iterator
|
|
|
|
* @handler: input handler to iterate
|
|
|
|
* @data: data for the callback
|
|
|
|
* @fn: function to be called for each handle
|
|
|
|
*
|
|
|
|
* Iterate over @bus's list of devices, and call @fn for each, passing
|
|
|
|
* it @data and stop when @fn returns a non-zero value. The function is
|
2015-05-19 00:44:33 +07:00
|
|
|
* using RCU to traverse the list and therefore may be using in atomic
|
2009-12-02 12:54:35 +07:00
|
|
|
* contexts. The @fn callback is invoked from RCU critical section and
|
|
|
|
* thus must not sleep.
|
|
|
|
*/
|
|
|
|
int input_handler_for_each_handle(struct input_handler *handler, void *data,
|
|
|
|
int (*fn)(struct input_handle *, void *))
|
|
|
|
{
|
|
|
|
struct input_handle *handle;
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(handle, &handler->h_list, h_node) {
|
|
|
|
retval = fn(handle, data);
|
|
|
|
if (retval)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_handler_for_each_handle);
|
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/**
|
|
|
|
* input_register_handle - register a new input handle
|
|
|
|
* @handle: handle to register
|
|
|
|
*
|
|
|
|
* This function puts a new input handle onto device's
|
|
|
|
* and handler's lists so that events can flow through
|
|
|
|
* it once it is opened using input_open_device().
|
|
|
|
*
|
|
|
|
* This function is supposed to be called from handler's
|
|
|
|
* connect() method.
|
|
|
|
*/
|
2007-04-12 12:29:46 +07:00
|
|
|
int input_register_handle(struct input_handle *handle)
|
|
|
|
{
|
|
|
|
struct input_handler *handler = handle->handler;
|
2007-08-30 11:22:11 +07:00
|
|
|
struct input_dev *dev = handle->dev;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We take dev->mutex here to prevent race with
|
|
|
|
* input_release_device().
|
|
|
|
*/
|
|
|
|
error = mutex_lock_interruptible(&dev->mutex);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2010-01-30 14:59:12 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Filters go to the head of the list, normal handlers
|
|
|
|
* to the tail.
|
|
|
|
*/
|
|
|
|
if (handler->filter)
|
|
|
|
list_add_rcu(&handle->d_node, &dev->h_list);
|
|
|
|
else
|
|
|
|
list_add_tail_rcu(&handle->d_node, &dev->h_list);
|
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
mutex_unlock(&dev->mutex);
|
2007-04-12 12:29:46 +07:00
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/*
|
|
|
|
* Since we are supposed to be called from ->connect()
|
|
|
|
* which is mutually exclusive with ->disconnect()
|
|
|
|
* we can't be racing with input_unregister_handle()
|
|
|
|
* and so separate lock is not needed here.
|
|
|
|
*/
|
2009-12-02 12:54:35 +07:00
|
|
|
list_add_tail_rcu(&handle->h_node, &handler->h_list);
|
2007-04-12 12:29:46 +07:00
|
|
|
|
|
|
|
if (handler->start)
|
|
|
|
handler->start(handle);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_register_handle);
|
|
|
|
|
2007-08-30 11:22:11 +07:00
|
|
|
/**
|
|
|
|
* input_unregister_handle - unregister an input handle
|
|
|
|
* @handle: handle to unregister
|
|
|
|
*
|
|
|
|
* This function removes input handle from device's
|
|
|
|
* and handler's lists.
|
|
|
|
*
|
|
|
|
* This function is supposed to be called from handler's
|
|
|
|
* disconnect() method.
|
|
|
|
*/
|
2007-04-12 12:29:46 +07:00
|
|
|
void input_unregister_handle(struct input_handle *handle)
|
|
|
|
{
|
2007-08-30 11:22:11 +07:00
|
|
|
struct input_dev *dev = handle->dev;
|
|
|
|
|
2009-12-02 12:54:35 +07:00
|
|
|
list_del_rcu(&handle->h_node);
|
2007-08-30 11:22:11 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Take dev->mutex to prevent race with input_release_device().
|
|
|
|
*/
|
|
|
|
mutex_lock(&dev->mutex);
|
|
|
|
list_del_rcu(&handle->d_node);
|
|
|
|
mutex_unlock(&dev->mutex);
|
2009-12-02 12:54:35 +07:00
|
|
|
|
2007-10-14 02:46:55 +07:00
|
|
|
synchronize_rcu();
|
2007-04-12 12:29:46 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_unregister_handle);
|
|
|
|
|
2012-10-08 23:07:24 +07:00
|
|
|
/**
|
|
|
|
* input_get_new_minor - allocates a new input minor number
|
|
|
|
* @legacy_base: beginning or the legacy range to be searched
|
|
|
|
* @legacy_num: size of legacy range
|
|
|
|
* @allow_dynamic: whether we can also take ID from the dynamic range
|
|
|
|
*
|
|
|
|
* This function allocates a new device minor for from input major namespace.
|
|
|
|
* Caller can request legacy minor by specifying @legacy_base and @legacy_num
|
|
|
|
* parameters and whether ID can be allocated from dynamic range if there are
|
|
|
|
* no free IDs in legacy range.
|
|
|
|
*/
|
|
|
|
int input_get_new_minor(int legacy_base, unsigned int legacy_num,
|
|
|
|
bool allow_dynamic)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
/*
|
2012-10-08 23:07:24 +07:00
|
|
|
* This function should be called from input handler's ->connect()
|
|
|
|
* methods, which are serialized with input_mutex, so no additional
|
|
|
|
* locking is needed here.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2012-10-08 23:07:24 +07:00
|
|
|
if (legacy_base >= 0) {
|
|
|
|
int minor = ida_simple_get(&input_ida,
|
|
|
|
legacy_base,
|
|
|
|
legacy_base + legacy_num,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (minor >= 0 || !allow_dynamic)
|
|
|
|
return minor;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2010-03-10 11:38:48 +07:00
|
|
|
|
2012-10-08 23:07:24 +07:00
|
|
|
return ida_simple_get(&input_ida,
|
|
|
|
INPUT_FIRST_DYNAMIC_DEV, INPUT_MAX_CHAR_DEVICES,
|
|
|
|
GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2012-10-08 23:07:24 +07:00
|
|
|
EXPORT_SYMBOL(input_get_new_minor);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-10-08 23:07:24 +07:00
|
|
|
/**
|
|
|
|
* input_free_minor - release previously allocated minor
|
|
|
|
* @minor: minor to be released
|
|
|
|
*
|
|
|
|
* This function releases previously allocated input minor so that it can be
|
|
|
|
* reused later.
|
|
|
|
*/
|
|
|
|
void input_free_minor(unsigned int minor)
|
|
|
|
{
|
|
|
|
ida_simple_remove(&input_ida, minor);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(input_free_minor);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-06-30 12:50:29 +07:00
|
|
|
static int __init input_init(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-06-30 12:50:29 +07:00
|
|
|
int err;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-10-28 12:25:43 +07:00
|
|
|
err = class_register(&input_class);
|
2005-09-15 14:01:39 +07:00
|
|
|
if (err) {
|
2010-11-30 14:33:07 +07:00
|
|
|
pr_err("unable to register input_dev class\n");
|
2005-09-15 14:01:39 +07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-06-30 12:50:29 +07:00
|
|
|
err = input_proc_init();
|
|
|
|
if (err)
|
2005-10-28 12:25:43 +07:00
|
|
|
goto fail1;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-10-08 23:07:24 +07:00
|
|
|
err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
|
|
|
|
INPUT_MAX_CHAR_DEVICES, "input");
|
2005-06-30 12:50:29 +07:00
|
|
|
if (err) {
|
2010-11-30 14:33:07 +07:00
|
|
|
pr_err("unable to register char major %d", INPUT_MAJOR);
|
2005-10-28 12:25:43 +07:00
|
|
|
goto fail2;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-06-01 14:39:28 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
|
2005-10-28 12:25:43 +07:00
|
|
|
fail2: input_proc_exit();
|
2005-10-28 12:25:43 +07:00
|
|
|
fail1: class_unregister(&input_class);
|
2005-06-30 12:50:29 +07:00
|
|
|
return err;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit input_exit(void)
|
|
|
|
{
|
2005-06-30 12:50:29 +07:00
|
|
|
input_proc_exit();
|
2012-10-08 23:07:24 +07:00
|
|
|
unregister_chrdev_region(MKDEV(INPUT_MAJOR, 0),
|
|
|
|
INPUT_MAX_CHAR_DEVICES);
|
2005-10-28 12:25:43 +07:00
|
|
|
class_unregister(&input_class);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
subsys_initcall(input_init);
|
|
|
|
module_exit(input_exit);
|