2006-12-08 10:40:44 -07:00
|
|
|
/*
|
2006-12-08 10:40:53 -07:00
|
|
|
* HID support for Linux
|
2006-12-08 10:40:44 -07:00
|
|
|
*
|
|
|
|
* Copyright (c) 1999 Andreas Gal
|
|
|
|
* Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
|
|
|
|
* Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
|
2012-03-09 05:55:43 -07:00
|
|
|
* Copyright (c) 2006-2012 Jiri Kosina
|
2006-12-08 10:40:44 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License as published by the Free
|
|
|
|
* Software Foundation; either version 2 of the License, or (at your option)
|
|
|
|
* any later version.
|
|
|
|
*/
|
|
|
|
|
2010-12-09 20:29:03 -07:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2006-12-08 10:40:44 -07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
#include <asm/byteorder.h>
|
|
|
|
#include <linux/input.h>
|
|
|
|
#include <linux/wait.h>
|
2007-03-12 07:55:12 -06:00
|
|
|
#include <linux/vmalloc.h>
|
2007-11-30 03:12:58 -07:00
|
|
|
#include <linux/sched.h>
|
2011-08-10 06:02:07 -06:00
|
|
|
#include <linux/semaphore.h>
|
2006-12-08 10:40:44 -07:00
|
|
|
|
|
|
|
#include <linux/hid.h>
|
|
|
|
#include <linux/hiddev.h>
|
2007-01-25 03:43:31 -07:00
|
|
|
#include <linux/hid-debug.h>
|
2007-05-14 01:57:40 -06:00
|
|
|
#include <linux/hidraw.h>
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-05-16 03:49:19 -06:00
|
|
|
#include "hid-ids.h"
|
|
|
|
|
2006-12-08 10:40:44 -07:00
|
|
|
/*
|
|
|
|
* Version Information
|
|
|
|
*/
|
|
|
|
|
2007-01-09 05:24:25 -07:00
|
|
|
#define DRIVER_DESC "HID core driver"
|
2006-12-08 10:40:44 -07:00
|
|
|
#define DRIVER_LICENSE "GPL"
|
|
|
|
|
2007-05-30 07:07:13 -06:00
|
|
|
int hid_debug = 0;
|
2008-03-22 16:50:13 -06:00
|
|
|
module_param_named(debug, hid_debug, int, 0600);
|
2009-06-12 07:20:57 -06:00
|
|
|
MODULE_PARM_DESC(debug, "toggle HID debugging messages");
|
2007-05-30 07:07:13 -06:00
|
|
|
EXPORT_SYMBOL_GPL(hid_debug);
|
|
|
|
|
2012-03-09 05:55:43 -07:00
|
|
|
static int hid_ignore_special_drivers = 0;
|
|
|
|
module_param_named(ignore_special_drivers, hid_ignore_special_drivers, int, 0600);
|
2014-09-08 01:35:35 -06:00
|
|
|
MODULE_PARM_DESC(ignore_special_drivers, "Ignore any special drivers and handle all devices by generic driver");
|
2012-03-09 05:55:43 -07:00
|
|
|
|
2006-12-08 10:40:44 -07:00
|
|
|
/*
|
|
|
|
* Register a new report for a device.
|
|
|
|
*/
|
|
|
|
|
2010-01-24 20:32:29 -07:00
|
|
|
struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)
|
2006-12-08 10:40:44 -07:00
|
|
|
{
|
|
|
|
struct hid_report_enum *report_enum = device->report_enum + type;
|
|
|
|
struct hid_report *report;
|
|
|
|
|
2013-08-28 14:29:55 -06:00
|
|
|
if (id >= HID_MAX_IDS)
|
|
|
|
return NULL;
|
2006-12-08 10:40:44 -07:00
|
|
|
if (report_enum->report_id_hash[id])
|
|
|
|
return report_enum->report_id_hash[id];
|
|
|
|
|
2010-12-09 20:29:07 -07:00
|
|
|
report = kzalloc(sizeof(struct hid_report), GFP_KERNEL);
|
|
|
|
if (!report)
|
2006-12-08 10:40:44 -07:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (id != 0)
|
|
|
|
report_enum->numbered = 1;
|
|
|
|
|
|
|
|
report->id = id;
|
|
|
|
report->type = type;
|
|
|
|
report->size = 0;
|
|
|
|
report->device = device;
|
|
|
|
report_enum->report_id_hash[id] = report;
|
|
|
|
|
|
|
|
list_add_tail(&report->list, &report_enum->report_list);
|
|
|
|
|
|
|
|
return report;
|
|
|
|
}
|
2010-01-24 20:32:29 -07:00
|
|
|
EXPORT_SYMBOL_GPL(hid_register_report);
|
2006-12-08 10:40:44 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Register a new field for this report.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages, unsigned values)
|
|
|
|
{
|
|
|
|
struct hid_field *field;
|
|
|
|
|
|
|
|
if (report->maxfield == HID_MAX_FIELDS) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(report->device, "too many fields in report\n");
|
2006-12-08 10:40:44 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-12-09 20:29:07 -07:00
|
|
|
field = kzalloc((sizeof(struct hid_field) +
|
|
|
|
usages * sizeof(struct hid_usage) +
|
|
|
|
values * sizeof(unsigned)), GFP_KERNEL);
|
|
|
|
if (!field)
|
|
|
|
return NULL;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
|
|
|
field->index = report->maxfield++;
|
|
|
|
report->field[field->index] = field;
|
|
|
|
field->usage = (struct hid_usage *)(field + 1);
|
2008-03-28 10:06:41 -06:00
|
|
|
field->value = (s32 *)(field->usage + usages);
|
2006-12-08 10:40:44 -07:00
|
|
|
field->report = report;
|
|
|
|
|
|
|
|
return field;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Open a collection. The type/usage is pushed on the stack.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int open_collection(struct hid_parser *parser, unsigned type)
|
|
|
|
{
|
|
|
|
struct hid_collection *collection;
|
|
|
|
unsigned usage;
|
|
|
|
|
|
|
|
usage = parser->local.usage[0];
|
|
|
|
|
|
|
|
if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "collection stack overflow\n");
|
2012-09-17 05:11:56 -06:00
|
|
|
return -EINVAL;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (parser->device->maxcollection == parser->device->collection_size) {
|
|
|
|
collection = kmalloc(sizeof(struct hid_collection) *
|
|
|
|
parser->device->collection_size * 2, GFP_KERNEL);
|
|
|
|
if (collection == NULL) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "failed to reallocate collection array\n");
|
2012-09-17 05:11:56 -06:00
|
|
|
return -ENOMEM;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
memcpy(collection, parser->device->collection,
|
|
|
|
sizeof(struct hid_collection) *
|
|
|
|
parser->device->collection_size);
|
|
|
|
memset(collection + parser->device->collection_size, 0,
|
|
|
|
sizeof(struct hid_collection) *
|
|
|
|
parser->device->collection_size);
|
|
|
|
kfree(parser->device->collection);
|
|
|
|
parser->device->collection = collection;
|
|
|
|
parser->device->collection_size *= 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
parser->collection_stack[parser->collection_stack_ptr++] =
|
|
|
|
parser->device->maxcollection;
|
|
|
|
|
|
|
|
collection = parser->device->collection +
|
|
|
|
parser->device->maxcollection++;
|
|
|
|
collection->type = type;
|
|
|
|
collection->usage = usage;
|
|
|
|
collection->level = parser->collection_stack_ptr - 1;
|
|
|
|
|
|
|
|
if (type == HID_COLLECTION_APPLICATION)
|
|
|
|
parser->device->maxapplication++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Close a collection.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int close_collection(struct hid_parser *parser)
|
|
|
|
{
|
|
|
|
if (!parser->collection_stack_ptr) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "collection stack underflow\n");
|
2012-09-17 05:11:56 -06:00
|
|
|
return -EINVAL;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
parser->collection_stack_ptr--;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Climb up the stack, search for the specified collection type
|
|
|
|
* and return the usage.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
|
|
|
|
{
|
2010-12-09 20:29:08 -07:00
|
|
|
struct hid_collection *collection = parser->device->collection;
|
2006-12-08 10:40:44 -07:00
|
|
|
int n;
|
2010-12-09 20:29:08 -07:00
|
|
|
|
|
|
|
for (n = parser->collection_stack_ptr - 1; n >= 0; n--) {
|
|
|
|
unsigned index = parser->collection_stack[n];
|
|
|
|
if (collection[index].type == type)
|
|
|
|
return collection[index].usage;
|
|
|
|
}
|
2006-12-08 10:40:44 -07:00
|
|
|
return 0; /* we know nothing about this usage type */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a usage to the temporary parser table.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int hid_add_usage(struct hid_parser *parser, unsigned usage)
|
|
|
|
{
|
|
|
|
if (parser->local.usage_index >= HID_MAX_USAGES) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "usage index exceeded\n");
|
2006-12-08 10:40:44 -07:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
parser->local.usage[parser->local.usage_index] = usage;
|
|
|
|
parser->local.collection_index[parser->local.usage_index] =
|
|
|
|
parser->collection_stack_ptr ?
|
|
|
|
parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
|
|
|
|
parser->local.usage_index++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Register a new field for this report.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)
|
|
|
|
{
|
|
|
|
struct hid_report *report;
|
|
|
|
struct hid_field *field;
|
2013-09-11 13:56:57 -06:00
|
|
|
unsigned usages;
|
2006-12-08 10:40:44 -07:00
|
|
|
unsigned offset;
|
2013-09-11 13:56:57 -06:00
|
|
|
unsigned i;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2010-12-09 20:29:07 -07:00
|
|
|
report = hid_register_report(parser->device, report_type, parser->global.report_id);
|
|
|
|
if (!report) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "hid_register_report failed\n");
|
2006-12-08 10:40:44 -07:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-05-14 07:02:56 -06:00
|
|
|
/* Handle both signed and unsigned cases properly */
|
2012-05-10 17:45:31 -06:00
|
|
|
if ((parser->global.logical_minimum < 0 &&
|
|
|
|
parser->global.logical_maximum <
|
|
|
|
parser->global.logical_minimum) ||
|
|
|
|
(parser->global.logical_minimum >= 0 &&
|
|
|
|
(__u32)parser->global.logical_maximum <
|
|
|
|
(__u32)parser->global.logical_minimum)) {
|
|
|
|
dbg_hid("logical range invalid 0x%x 0x%x\n",
|
|
|
|
parser->global.logical_minimum,
|
|
|
|
parser->global.logical_maximum);
|
2006-12-08 10:40:44 -07:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
offset = report->size;
|
|
|
|
report->size += parser->global.report_size * parser->global.report_count;
|
|
|
|
|
|
|
|
if (!parser->local.usage_index) /* Ignore padding fields */
|
|
|
|
return 0;
|
|
|
|
|
2013-09-11 13:56:57 -06:00
|
|
|
usages = max_t(unsigned, parser->local.usage_index,
|
|
|
|
parser->global.report_count);
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2010-12-09 20:29:07 -07:00
|
|
|
field = hid_register_field(report, usages, parser->global.report_count);
|
|
|
|
if (!field)
|
2006-12-08 10:40:44 -07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
|
|
|
|
field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);
|
|
|
|
field->application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);
|
|
|
|
|
|
|
|
for (i = 0; i < usages; i++) {
|
2013-09-11 13:56:57 -06:00
|
|
|
unsigned j = i;
|
2006-12-08 10:40:44 -07:00
|
|
|
/* Duplicate the last usage we parsed if we have excess values */
|
|
|
|
if (i >= parser->local.usage_index)
|
|
|
|
j = parser->local.usage_index - 1;
|
|
|
|
field->usage[i].hid = parser->local.usage[j];
|
|
|
|
field->usage[i].collection_index =
|
|
|
|
parser->local.collection_index[j];
|
2013-09-11 13:56:57 -06:00
|
|
|
field->usage[i].usage_index = i;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
field->maxusage = usages;
|
|
|
|
field->flags = flags;
|
|
|
|
field->report_offset = offset;
|
|
|
|
field->report_type = report_type;
|
|
|
|
field->report_size = parser->global.report_size;
|
|
|
|
field->report_count = parser->global.report_count;
|
|
|
|
field->logical_minimum = parser->global.logical_minimum;
|
|
|
|
field->logical_maximum = parser->global.logical_maximum;
|
|
|
|
field->physical_minimum = parser->global.physical_minimum;
|
|
|
|
field->physical_maximum = parser->global.physical_maximum;
|
|
|
|
field->unit_exponent = parser->global.unit_exponent;
|
|
|
|
field->unit = parser->global.unit;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read data value from item.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static u32 item_udata(struct hid_item *item)
|
|
|
|
{
|
|
|
|
switch (item->size) {
|
2008-06-18 15:55:41 -06:00
|
|
|
case 1: return item->data.u8;
|
|
|
|
case 2: return item->data.u16;
|
|
|
|
case 4: return item->data.u32;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static s32 item_sdata(struct hid_item *item)
|
|
|
|
{
|
|
|
|
switch (item->size) {
|
2008-06-18 15:55:41 -06:00
|
|
|
case 1: return item->data.s8;
|
|
|
|
case 2: return item->data.s16;
|
|
|
|
case 4: return item->data.s32;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process a global item.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
|
|
|
|
{
|
HID: Fix unit exponent parsing again
Revert some changes done in 774638386826621c984ab6994439f474709cac5e.
Revert all changes done in hidinput_calc_abs_res as it mistakingly used
"Unit" item exponent nibbles to affect resolution value. This wasn't
breaking resolution calculation of relevant axes of any existing
devices, though, as they have only one dimension to their units and thus
1 in the corresponding nible.
Revert to reading "Unit Exponent" item value as a signed integer in
hid_parser_global to fix reading specification-complying values. This
fixes resolution calculation of devices complying to the HID standard,
including Huion, KYE, Waltop and UC-Logic graphics tablets which have
their report descriptors fixed by the drivers.
Explanations follow.
There are two "unit exponents" in HID specification and it is important
not to mix them. One is the global "Unit Exponent" item and another is
nibble values in the global "Unit" item. See 6.2.2.7 Global Items.
The "Unit Exponent" value is just a signed integer and is used to scale
the integer resolution unit values, so fractions can be expressed.
The nibbles of "Unit" value are used to select the unit system (nibble
0), and presence of a particular basic unit type in the unit formula and
its *exponent* (or power, nibbles 1-6). And yes, the latter is in two
complement and zero means absence of the unit type.
Taking the representation example of (integer) joules from the
specification:
[mass(grams)][length(centimeters)^2][time(seconds)^-2] * 10^-7
the "Unit Exponent" would be -7 (or 0xF9, if stored as a byte) and the
"Unit" value would be 0xE121, signifying:
Nibble Part Value Meaning
----- ---- ----- -------
0 System 1 SI Linear
1 Length 2 Centimeters^2
2 Mass 1 Grams
3 Time -2 Seconds^-2
To give the resolution in e.g. hundredth of joules the "Unit Exponent"
item value should have been -9.
See also the examples of "Unit" values for some common units in the same
chapter.
However, there is a common misunderstanding about the "Unit Exponent"
value encoding, where it is assumed to be stored the same as nibbles in
"Unit" item. This is most likely due to the specification being a bit
vague and overloading the term "unit exponent". This also was and still
is proliferated by the official "HID Descriptor Tool", which makes this
mistake and stores "Unit Exponent" as such. This format is also
mentioned in books such as "USB Complete" and in Microsoft's hardware
design guides.
As a result many devices currently on the market use this encoding and
so the driver should support them.
Signed-off-by: Nikolai Kondrashov <spbnick@gmail.com>
Acked-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-10-13 06:09:52 -06:00
|
|
|
__s32 raw_value;
|
2006-12-08 10:40:44 -07:00
|
|
|
switch (item->tag) {
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_PUSH:
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "global environment stack overflow\n");
|
2008-06-18 15:55:41 -06:00
|
|
|
return -1;
|
|
|
|
}
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
memcpy(parser->global_stack + parser->global_stack_ptr++,
|
|
|
|
&parser->global, sizeof(struct hid_global));
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_POP:
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
if (!parser->global_stack_ptr) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "global environment stack underflow\n");
|
2008-06-18 15:55:41 -06:00
|
|
|
return -1;
|
|
|
|
}
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
memcpy(&parser->global, parser->global_stack +
|
|
|
|
--parser->global_stack_ptr, sizeof(struct hid_global));
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
|
|
|
|
parser->global.usage_page = item_udata(item);
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
|
|
|
|
parser->global.logical_minimum = item_sdata(item);
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
|
|
|
|
if (parser->global.logical_minimum < 0)
|
|
|
|
parser->global.logical_maximum = item_sdata(item);
|
|
|
|
else
|
|
|
|
parser->global.logical_maximum = item_udata(item);
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
|
|
|
|
parser->global.physical_minimum = item_sdata(item);
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
|
|
|
|
if (parser->global.physical_minimum < 0)
|
|
|
|
parser->global.physical_maximum = item_sdata(item);
|
|
|
|
else
|
|
|
|
parser->global.physical_maximum = item_udata(item);
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
|
HID: Fix unit exponent parsing again
Revert some changes done in 774638386826621c984ab6994439f474709cac5e.
Revert all changes done in hidinput_calc_abs_res as it mistakingly used
"Unit" item exponent nibbles to affect resolution value. This wasn't
breaking resolution calculation of relevant axes of any existing
devices, though, as they have only one dimension to their units and thus
1 in the corresponding nible.
Revert to reading "Unit Exponent" item value as a signed integer in
hid_parser_global to fix reading specification-complying values. This
fixes resolution calculation of devices complying to the HID standard,
including Huion, KYE, Waltop and UC-Logic graphics tablets which have
their report descriptors fixed by the drivers.
Explanations follow.
There are two "unit exponents" in HID specification and it is important
not to mix them. One is the global "Unit Exponent" item and another is
nibble values in the global "Unit" item. See 6.2.2.7 Global Items.
The "Unit Exponent" value is just a signed integer and is used to scale
the integer resolution unit values, so fractions can be expressed.
The nibbles of "Unit" value are used to select the unit system (nibble
0), and presence of a particular basic unit type in the unit formula and
its *exponent* (or power, nibbles 1-6). And yes, the latter is in two
complement and zero means absence of the unit type.
Taking the representation example of (integer) joules from the
specification:
[mass(grams)][length(centimeters)^2][time(seconds)^-2] * 10^-7
the "Unit Exponent" would be -7 (or 0xF9, if stored as a byte) and the
"Unit" value would be 0xE121, signifying:
Nibble Part Value Meaning
----- ---- ----- -------
0 System 1 SI Linear
1 Length 2 Centimeters^2
2 Mass 1 Grams
3 Time -2 Seconds^-2
To give the resolution in e.g. hundredth of joules the "Unit Exponent"
item value should have been -9.
See also the examples of "Unit" values for some common units in the same
chapter.
However, there is a common misunderstanding about the "Unit Exponent"
value encoding, where it is assumed to be stored the same as nibbles in
"Unit" item. This is most likely due to the specification being a bit
vague and overloading the term "unit exponent". This also was and still
is proliferated by the official "HID Descriptor Tool", which makes this
mistake and stores "Unit Exponent" as such. This format is also
mentioned in books such as "USB Complete" and in Microsoft's hardware
design guides.
As a result many devices currently on the market use this encoding and
so the driver should support them.
Signed-off-by: Nikolai Kondrashov <spbnick@gmail.com>
Acked-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-10-13 06:09:52 -06:00
|
|
|
/* Many devices provide unit exponent as a two's complement
|
|
|
|
* nibble due to the common misunderstanding of HID
|
|
|
|
* specification 1.11, 6.2.2.7 Global Items. Attempt to handle
|
|
|
|
* both this and the standard encoding. */
|
|
|
|
raw_value = item_sdata(item);
|
2012-11-14 08:59:15 -07:00
|
|
|
if (!(raw_value & 0xfffffff0))
|
|
|
|
parser->global.unit_exponent = hid_snto32(raw_value, 4);
|
|
|
|
else
|
|
|
|
parser->global.unit_exponent = raw_value;
|
2008-06-18 15:55:41 -06:00
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_UNIT:
|
|
|
|
parser->global.unit = item_udata(item);
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
|
|
|
|
parser->global.report_size = item_udata(item);
|
2012-08-05 15:57:14 -06:00
|
|
|
if (parser->global.report_size > 128) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "invalid report_size %d\n",
|
2008-06-18 15:55:41 -06:00
|
|
|
parser->global.report_size);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
|
|
|
|
parser->global.report_count = item_udata(item);
|
|
|
|
if (parser->global.report_count > HID_MAX_USAGES) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "invalid report_count %d\n",
|
2008-06-18 15:55:41 -06:00
|
|
|
parser->global.report_count);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_GLOBAL_ITEM_TAG_REPORT_ID:
|
|
|
|
parser->global.report_id = item_udata(item);
|
2013-08-28 14:29:55 -06:00
|
|
|
if (parser->global.report_id == 0 ||
|
|
|
|
parser->global.report_id >= HID_MAX_IDS) {
|
|
|
|
hid_err(parser->device, "report_id %u is invalid\n",
|
|
|
|
parser->global.report_id);
|
2006-12-08 10:40:44 -07:00
|
|
|
return -1;
|
2008-06-18 15:55:41 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
default:
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "unknown global tag 0x%x\n", item->tag);
|
2008-06-18 15:55:41 -06:00
|
|
|
return -1;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process a local item.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
|
|
|
|
{
|
|
|
|
__u32 data;
|
|
|
|
unsigned n;
|
2015-07-24 10:02:22 -06:00
|
|
|
__u32 count;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
|
|
|
data = item_udata(item);
|
|
|
|
|
|
|
|
switch (item->tag) {
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_LOCAL_ITEM_TAG_DELIMITER:
|
|
|
|
|
|
|
|
if (data) {
|
|
|
|
/*
|
|
|
|
* We treat items before the first delimiter
|
|
|
|
* as global to all usage sets (branch 0).
|
|
|
|
* In the moment we process only these global
|
|
|
|
* items and the first delimiter set.
|
|
|
|
*/
|
|
|
|
if (parser->local.delimiter_depth != 0) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "nested delimiters\n");
|
2008-06-18 15:55:41 -06:00
|
|
|
return -1;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
2008-06-18 15:55:41 -06:00
|
|
|
parser->local.delimiter_depth++;
|
|
|
|
parser->local.delimiter_branch++;
|
|
|
|
} else {
|
|
|
|
if (parser->local.delimiter_depth < 1) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "bogus close delimiter\n");
|
2008-06-18 15:55:41 -06:00
|
|
|
return -1;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
2008-06-18 15:55:41 -06:00
|
|
|
parser->local.delimiter_depth--;
|
|
|
|
}
|
2013-07-07 09:43:56 -06:00
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_LOCAL_ITEM_TAG_USAGE:
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
if (parser->local.delimiter_branch > 1) {
|
|
|
|
dbg_hid("alternative usage ignored\n");
|
|
|
|
return 0;
|
|
|
|
}
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
if (item->size <= 2)
|
|
|
|
data = (parser->global.usage_page << 16) + data;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
return hid_add_usage(parser, data);
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
if (parser->local.delimiter_branch > 1) {
|
|
|
|
dbg_hid("alternative usage ignored\n");
|
2006-12-08 10:40:44 -07:00
|
|
|
return 0;
|
2008-06-18 15:55:41 -06:00
|
|
|
}
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
if (item->size <= 2)
|
|
|
|
data = (parser->global.usage_page << 16) + data;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
parser->local.usage_minimum = data;
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
if (parser->local.delimiter_branch > 1) {
|
|
|
|
dbg_hid("alternative usage ignored\n");
|
2006-12-08 10:40:44 -07:00
|
|
|
return 0;
|
2008-06-18 15:55:41 -06:00
|
|
|
}
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
if (item->size <= 2)
|
|
|
|
data = (parser->global.usage_page << 16) + data;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2015-07-24 10:02:22 -06:00
|
|
|
count = data - parser->local.usage_minimum;
|
|
|
|
if (count + parser->local.usage_index >= HID_MAX_USAGES) {
|
|
|
|
/*
|
|
|
|
* We do not warn if the name is not set, we are
|
|
|
|
* actually pre-scanning the device.
|
|
|
|
*/
|
|
|
|
if (dev_name(&parser->device->dev))
|
|
|
|
hid_warn(parser->device,
|
|
|
|
"ignoring exceeding usage max\n");
|
|
|
|
data = HID_MAX_USAGES - parser->local.usage_index +
|
|
|
|
parser->local.usage_minimum - 1;
|
|
|
|
if (data <= 0) {
|
|
|
|
hid_err(parser->device,
|
|
|
|
"no more usage index available\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
for (n = parser->local.usage_minimum; n <= data; n++)
|
|
|
|
if (hid_add_usage(parser, n)) {
|
|
|
|
dbg_hid("hid_add_usage failed\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
|
|
|
dbg_hid("unknown local item tag 0x%x\n", item->tag);
|
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process a main item.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
|
|
|
|
{
|
|
|
|
__u32 data;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
data = item_udata(item);
|
|
|
|
|
|
|
|
switch (item->tag) {
|
2008-06-18 15:55:41 -06:00
|
|
|
case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
|
|
|
|
ret = open_collection(parser, data & 0xff);
|
|
|
|
break;
|
|
|
|
case HID_MAIN_ITEM_TAG_END_COLLECTION:
|
|
|
|
ret = close_collection(parser);
|
|
|
|
break;
|
|
|
|
case HID_MAIN_ITEM_TAG_INPUT:
|
|
|
|
ret = hid_add_field(parser, HID_INPUT_REPORT, data);
|
|
|
|
break;
|
|
|
|
case HID_MAIN_ITEM_TAG_OUTPUT:
|
|
|
|
ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
|
|
|
|
break;
|
|
|
|
case HID_MAIN_ITEM_TAG_FEATURE:
|
|
|
|
ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
|
|
|
|
break;
|
|
|
|
default:
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(parser->device, "unknown main item tag 0x%x\n", item->tag);
|
2008-06-18 15:55:41 -06:00
|
|
|
ret = 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
memset(&parser->local, 0, sizeof(parser->local)); /* Reset the local parser environment */
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process a reserved item.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)
|
|
|
|
{
|
2007-05-30 07:07:13 -06:00
|
|
|
dbg_hid("reserved item type, tag 0x%x\n", item->tag);
|
2006-12-08 10:40:44 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free a report and all registered fields. The field->usage and
|
|
|
|
* field->value table's are allocated behind the field, so we need
|
|
|
|
* only to free(field) itself.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void hid_free_report(struct hid_report *report)
|
|
|
|
{
|
|
|
|
unsigned n;
|
|
|
|
|
|
|
|
for (n = 0; n < report->maxfield; n++)
|
|
|
|
kfree(report->field[n]);
|
|
|
|
kfree(report);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-04-22 06:21:40 -06:00
|
|
|
* Close report. This function returns the device
|
|
|
|
* state to the point prior to hid_open_report().
|
2006-12-08 10:40:44 -07:00
|
|
|
*/
|
2012-04-22 06:21:40 -06:00
|
|
|
static void hid_close_report(struct hid_device *device)
|
2006-12-08 10:40:44 -07:00
|
|
|
{
|
2008-05-16 03:49:15 -06:00
|
|
|
unsigned i, j;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
|
|
|
for (i = 0; i < HID_REPORT_TYPES; i++) {
|
|
|
|
struct hid_report_enum *report_enum = device->report_enum + i;
|
|
|
|
|
2013-08-28 14:29:55 -06:00
|
|
|
for (j = 0; j < HID_MAX_IDS; j++) {
|
2006-12-08 10:40:44 -07:00
|
|
|
struct hid_report *report = report_enum->report_id_hash[j];
|
|
|
|
if (report)
|
|
|
|
hid_free_report(report);
|
|
|
|
}
|
2012-04-22 06:21:40 -06:00
|
|
|
memset(report_enum, 0, sizeof(*report_enum));
|
|
|
|
INIT_LIST_HEAD(&report_enum->report_list);
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
kfree(device->rdesc);
|
2012-04-22 06:21:40 -06:00
|
|
|
device->rdesc = NULL;
|
|
|
|
device->rsize = 0;
|
|
|
|
|
2007-01-24 15:05:07 -07:00
|
|
|
kfree(device->collection);
|
2012-04-22 06:21:40 -06:00
|
|
|
device->collection = NULL;
|
|
|
|
device->collection_size = 0;
|
|
|
|
device->maxcollection = 0;
|
|
|
|
device->maxapplication = 0;
|
|
|
|
|
|
|
|
device->status &= ~HID_STAT_PARSED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free a device structure, all reports, and all fields.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void hid_device_release(struct device *dev)
|
|
|
|
{
|
|
|
|
struct hid_device *hid = container_of(dev, struct hid_device, dev);
|
|
|
|
|
|
|
|
hid_close_report(hid);
|
|
|
|
kfree(hid->dev_rdesc);
|
|
|
|
kfree(hid);
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fetch a report description item from the data stream. We support long
|
|
|
|
* items, though they are not used yet.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
|
|
|
|
{
|
|
|
|
u8 b;
|
|
|
|
|
|
|
|
if ((end - start) <= 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
b = *start++;
|
|
|
|
|
|
|
|
item->type = (b >> 2) & 3;
|
|
|
|
item->tag = (b >> 4) & 15;
|
|
|
|
|
|
|
|
if (item->tag == HID_ITEM_TAG_LONG) {
|
|
|
|
|
|
|
|
item->format = HID_ITEM_FORMAT_LONG;
|
|
|
|
|
|
|
|
if ((end - start) < 2)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
item->size = *start++;
|
|
|
|
item->tag = *start++;
|
|
|
|
|
|
|
|
if ((end - start) < item->size)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
item->data.longdata = start;
|
|
|
|
start += item->size;
|
|
|
|
return start;
|
|
|
|
}
|
|
|
|
|
|
|
|
item->format = HID_ITEM_FORMAT_SHORT;
|
|
|
|
item->size = b & 3;
|
|
|
|
|
|
|
|
switch (item->size) {
|
2008-06-18 15:55:41 -06:00
|
|
|
case 0:
|
|
|
|
return start;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-06-18 15:55:41 -06:00
|
|
|
case 1:
|
|
|
|
if ((end - start) < 1)
|
|
|
|
return NULL;
|
|
|
|
item->data.u8 = *start++;
|
|
|
|
return start;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
if ((end - start) < 2)
|
|
|
|
return NULL;
|
|
|
|
item->data.u16 = get_unaligned_le16(start);
|
|
|
|
start = (__u8 *)((__le16 *)start + 1);
|
|
|
|
return start;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
item->size++;
|
|
|
|
if ((end - start) < 4)
|
|
|
|
return NULL;
|
|
|
|
item->data.u32 = get_unaligned_le32(start);
|
|
|
|
start = (__u8 *)((__le32 *)start + 1);
|
|
|
|
return start;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-08-22 06:51:07 -06:00
|
|
|
static void hid_scan_input_usage(struct hid_parser *parser, u32 usage)
|
2012-04-23 04:07:03 -06:00
|
|
|
{
|
2013-08-22 06:51:07 -06:00
|
|
|
struct hid_device *hid = parser->device;
|
|
|
|
|
2012-05-01 00:40:01 -06:00
|
|
|
if (usage == HID_DG_CONTACTID)
|
|
|
|
hid->group = HID_GROUP_MULTITOUCH;
|
2012-04-23 04:07:03 -06:00
|
|
|
}
|
|
|
|
|
2013-08-22 06:51:08 -06:00
|
|
|
static void hid_scan_feature_usage(struct hid_parser *parser, u32 usage)
|
|
|
|
{
|
|
|
|
if (usage == 0xff0000c5 && parser->global.report_count == 256 &&
|
|
|
|
parser->global.report_size == 8)
|
|
|
|
parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8;
|
|
|
|
}
|
|
|
|
|
2013-08-22 06:51:07 -06:00
|
|
|
static void hid_scan_collection(struct hid_parser *parser, unsigned type)
|
|
|
|
{
|
|
|
|
struct hid_device *hid = parser->device;
|
2014-12-12 11:17:26 -07:00
|
|
|
int i;
|
2013-08-22 06:51:07 -06:00
|
|
|
|
|
|
|
if (((parser->global.usage_page << 16) == HID_UP_SENSOR) &&
|
|
|
|
type == HID_COLLECTION_PHYSICAL)
|
|
|
|
hid->group = HID_GROUP_SENSOR_HUB;
|
2014-11-03 19:26:12 -07:00
|
|
|
|
|
|
|
if (hid->vendor == USB_VENDOR_ID_MICROSOFT &&
|
2015-07-22 21:11:40 -06:00
|
|
|
(hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3 ||
|
|
|
|
hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP ||
|
|
|
|
hid->product == USB_DEVICE_ID_MS_TYPE_COVER_3 ||
|
2015-06-08 03:11:38 -06:00
|
|
|
hid->product == USB_DEVICE_ID_MS_POWER_COVER) &&
|
2014-11-03 19:26:12 -07:00
|
|
|
hid->group == HID_GROUP_MULTITOUCH)
|
|
|
|
hid->group = HID_GROUP_GENERIC;
|
2014-12-12 11:17:26 -07:00
|
|
|
|
|
|
|
if ((parser->global.usage_page << 16) == HID_UP_GENDESK)
|
|
|
|
for (i = 0; i < parser->local.usage_index; i++)
|
|
|
|
if (parser->local.usage[i] == HID_GD_POINTER)
|
|
|
|
parser->scan_flags |= HID_SCAN_FLAG_GD_POINTER;
|
|
|
|
|
|
|
|
if ((parser->global.usage_page << 16) >= HID_UP_MSVENDOR)
|
|
|
|
parser->scan_flags |= HID_SCAN_FLAG_VENDOR_SPECIFIC;
|
2013-08-22 06:51:07 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hid_scan_main(struct hid_parser *parser, struct hid_item *item)
|
|
|
|
{
|
|
|
|
__u32 data;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
data = item_udata(item);
|
|
|
|
|
|
|
|
switch (item->tag) {
|
|
|
|
case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
|
|
|
|
hid_scan_collection(parser, data & 0xff);
|
|
|
|
break;
|
|
|
|
case HID_MAIN_ITEM_TAG_END_COLLECTION:
|
|
|
|
break;
|
|
|
|
case HID_MAIN_ITEM_TAG_INPUT:
|
2014-03-31 11:27:10 -06:00
|
|
|
/* ignore constant inputs, they will be ignored by hid-input */
|
|
|
|
if (data & HID_MAIN_ITEM_CONSTANT)
|
|
|
|
break;
|
2013-08-22 06:51:07 -06:00
|
|
|
for (i = 0; i < parser->local.usage_index; i++)
|
|
|
|
hid_scan_input_usage(parser, parser->local.usage[i]);
|
|
|
|
break;
|
|
|
|
case HID_MAIN_ITEM_TAG_OUTPUT:
|
|
|
|
break;
|
|
|
|
case HID_MAIN_ITEM_TAG_FEATURE:
|
2013-08-22 06:51:08 -06:00
|
|
|
for (i = 0; i < parser->local.usage_index; i++)
|
|
|
|
hid_scan_feature_usage(parser, parser->local.usage[i]);
|
2013-08-22 06:51:07 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Reset the local parser environment */
|
|
|
|
memset(&parser->local, 0, sizeof(parser->local));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-23 04:07:03 -06:00
|
|
|
/*
|
|
|
|
* Scan a report descriptor before the device is added to the bus.
|
|
|
|
* Sets device groups and other properties that determine what driver
|
|
|
|
* to load.
|
|
|
|
*/
|
|
|
|
static int hid_scan_report(struct hid_device *hid)
|
|
|
|
{
|
2013-08-22 06:51:07 -06:00
|
|
|
struct hid_parser *parser;
|
|
|
|
struct hid_item item;
|
2012-04-23 04:07:03 -06:00
|
|
|
__u8 *start = hid->dev_rdesc;
|
|
|
|
__u8 *end = start + hid->dev_rsize;
|
2013-08-22 06:51:07 -06:00
|
|
|
static int (*dispatch_type[])(struct hid_parser *parser,
|
|
|
|
struct hid_item *item) = {
|
|
|
|
hid_scan_main,
|
|
|
|
hid_parser_global,
|
|
|
|
hid_parser_local,
|
|
|
|
hid_parser_reserved
|
|
|
|
};
|
|
|
|
|
|
|
|
parser = vzalloc(sizeof(struct hid_parser));
|
|
|
|
if (!parser)
|
|
|
|
return -ENOMEM;
|
2012-04-23 04:07:03 -06:00
|
|
|
|
2013-08-22 06:51:07 -06:00
|
|
|
parser->device = hid;
|
2012-04-23 04:07:03 -06:00
|
|
|
hid->group = HID_GROUP_GENERIC;
|
|
|
|
|
2013-08-22 06:51:07 -06:00
|
|
|
/*
|
|
|
|
* The parsing is simpler than the one in hid_open_report() as we should
|
|
|
|
* be robust against hid errors. Those errors will be raised by
|
|
|
|
* hid_open_report() anyway.
|
|
|
|
*/
|
|
|
|
while ((start = fetch_item(start, end, &item)) != NULL)
|
|
|
|
dispatch_type[item.type](parser, &item);
|
|
|
|
|
2013-08-22 06:51:08 -06:00
|
|
|
/*
|
|
|
|
* Handle special flags set during scanning.
|
|
|
|
*/
|
|
|
|
if ((parser->scan_flags & HID_SCAN_FLAG_MT_WIN_8) &&
|
|
|
|
(hid->group == HID_GROUP_MULTITOUCH))
|
|
|
|
hid->group = HID_GROUP_MULTITOUCH_WIN_8;
|
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
/*
|
|
|
|
* Vendor specific handlings
|
|
|
|
*/
|
|
|
|
switch (hid->vendor) {
|
|
|
|
case USB_VENDOR_ID_WACOM:
|
|
|
|
hid->group = HID_GROUP_WACOM;
|
|
|
|
break;
|
2014-09-30 11:18:23 -06:00
|
|
|
case USB_VENDOR_ID_SYNAPTICS:
|
2014-12-12 11:17:26 -07:00
|
|
|
if (hid->group == HID_GROUP_GENERIC)
|
|
|
|
if ((parser->scan_flags & HID_SCAN_FLAG_VENDOR_SPECIFIC)
|
|
|
|
&& (parser->scan_flags & HID_SCAN_FLAG_GD_POINTER))
|
|
|
|
/*
|
|
|
|
* hid-rmi should take care of them,
|
|
|
|
* not hid-generic
|
|
|
|
*/
|
|
|
|
hid->group = HID_GROUP_RMI;
|
2014-09-30 11:18:23 -06:00
|
|
|
break;
|
2014-07-24 13:52:23 -06:00
|
|
|
}
|
|
|
|
|
2013-08-22 06:51:07 -06:00
|
|
|
vfree(parser);
|
2012-04-23 04:07:03 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
/**
|
|
|
|
* hid_parse_report - parse device report
|
|
|
|
*
|
|
|
|
* @device: hid device
|
|
|
|
* @start: report start
|
|
|
|
* @size: report size
|
|
|
|
*
|
2012-04-22 06:21:40 -06:00
|
|
|
* Allocate the device report as read by the bus driver. This function should
|
|
|
|
* only be called from parse() in ll drivers.
|
|
|
|
*/
|
|
|
|
int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size)
|
|
|
|
{
|
|
|
|
hid->dev_rdesc = kmemdup(start, size, GFP_KERNEL);
|
|
|
|
if (!hid->dev_rdesc)
|
|
|
|
return -ENOMEM;
|
|
|
|
hid->dev_rsize = size;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_parse_report);
|
|
|
|
|
2013-09-11 13:56:50 -06:00
|
|
|
static const char * const hid_report_names[] = {
|
|
|
|
"HID_INPUT_REPORT",
|
|
|
|
"HID_OUTPUT_REPORT",
|
|
|
|
"HID_FEATURE_REPORT",
|
|
|
|
};
|
|
|
|
/**
|
|
|
|
* hid_validate_values - validate existing device report's value indexes
|
|
|
|
*
|
|
|
|
* @device: hid device
|
|
|
|
* @type: which report type to examine
|
|
|
|
* @id: which report ID to examine (0 for first)
|
|
|
|
* @field_index: which report field to examine
|
|
|
|
* @report_counts: expected number of values
|
|
|
|
*
|
|
|
|
* Validate the number of values in a given field of a given report, after
|
|
|
|
* parsing.
|
|
|
|
*/
|
|
|
|
struct hid_report *hid_validate_values(struct hid_device *hid,
|
|
|
|
unsigned int type, unsigned int id,
|
|
|
|
unsigned int field_index,
|
|
|
|
unsigned int report_counts)
|
|
|
|
{
|
|
|
|
struct hid_report *report;
|
|
|
|
|
|
|
|
if (type > HID_FEATURE_REPORT) {
|
|
|
|
hid_err(hid, "invalid HID report type %u\n", type);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (id >= HID_MAX_IDS) {
|
|
|
|
hid_err(hid, "invalid HID report id %u\n", id);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Explicitly not using hid_get_report() here since it depends on
|
|
|
|
* ->numbered being checked, which may not always be the case when
|
|
|
|
* drivers go to access report values.
|
|
|
|
*/
|
HID: core: fix validation of report id 0
Some drivers use the first HID report in the list instead of using an
index. In these cases, validation uses ID 0, which was supposed to mean
"first known report". This fixes the problem, which was causing at least
the lgff family of devices to stop working since hid_validate_values
was being called with ID 0, but the devices used single numbered IDs
for their reports:
0x05, 0x01, /* Usage Page (Desktop), */
0x09, 0x05, /* Usage (Gamepad), */
0xA1, 0x01, /* Collection (Application), */
0xA1, 0x02, /* Collection (Logical), */
0x85, 0x01, /* Report ID (1), */
...
Cc: stable@vger.kernel.org
Reported-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Kees Cook <keescook@chromium.org>
Reviewed-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2014-04-17 14:22:09 -06:00
|
|
|
if (id == 0) {
|
|
|
|
/*
|
|
|
|
* Validating on id 0 means we should examine the first
|
|
|
|
* report in the list.
|
|
|
|
*/
|
|
|
|
report = list_entry(
|
|
|
|
hid->report_enum[type].report_list.next,
|
|
|
|
struct hid_report, list);
|
|
|
|
} else {
|
|
|
|
report = hid->report_enum[type].report_id_hash[id];
|
|
|
|
}
|
2013-09-11 13:56:50 -06:00
|
|
|
if (!report) {
|
|
|
|
hid_err(hid, "missing %s %u\n", hid_report_names[type], id);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (report->maxfield <= field_index) {
|
|
|
|
hid_err(hid, "not enough fields in %s %u\n",
|
|
|
|
hid_report_names[type], id);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (report->field[field_index]->report_count < report_counts) {
|
|
|
|
hid_err(hid, "not enough values in %s %u field %u\n",
|
|
|
|
hid_report_names[type], id, field_index);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return report;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_validate_values);
|
|
|
|
|
2012-04-22 06:21:40 -06:00
|
|
|
/**
|
|
|
|
* hid_open_report - open a driver-specific device report
|
|
|
|
*
|
|
|
|
* @device: hid device
|
|
|
|
*
|
2006-12-08 10:40:44 -07:00
|
|
|
* Parse a report description into a hid_device structure. Reports are
|
|
|
|
* enumerated, fields are attached to these reports.
|
2008-05-16 03:49:15 -06:00
|
|
|
* 0 returned on success, otherwise nonzero error value.
|
2012-04-22 06:21:40 -06:00
|
|
|
*
|
|
|
|
* This function (or the equivalent hid_parse() macro) should only be
|
|
|
|
* called from probe() in drivers, before starting the device.
|
2006-12-08 10:40:44 -07:00
|
|
|
*/
|
2012-04-22 06:21:40 -06:00
|
|
|
int hid_open_report(struct hid_device *device)
|
2006-12-08 10:40:44 -07:00
|
|
|
{
|
|
|
|
struct hid_parser *parser;
|
|
|
|
struct hid_item item;
|
2012-04-22 06:21:40 -06:00
|
|
|
unsigned int size;
|
|
|
|
__u8 *start;
|
2012-09-20 13:00:32 -06:00
|
|
|
__u8 *buf;
|
2006-12-08 10:40:44 -07:00
|
|
|
__u8 *end;
|
2008-05-16 03:49:15 -06:00
|
|
|
int ret;
|
2006-12-08 10:40:44 -07:00
|
|
|
static int (*dispatch_type[])(struct hid_parser *parser,
|
|
|
|
struct hid_item *item) = {
|
|
|
|
hid_parser_main,
|
|
|
|
hid_parser_global,
|
|
|
|
hid_parser_local,
|
|
|
|
hid_parser_reserved
|
|
|
|
};
|
|
|
|
|
2012-04-22 06:21:40 -06:00
|
|
|
if (WARN_ON(device->status & HID_STAT_PARSED))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
start = device->dev_rdesc;
|
|
|
|
if (WARN_ON(!start))
|
|
|
|
return -ENODEV;
|
|
|
|
size = device->dev_rsize;
|
|
|
|
|
2012-09-20 13:00:32 -06:00
|
|
|
buf = kmemdup(start, size, GFP_KERNEL);
|
|
|
|
if (buf == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-05-16 03:49:16 -06:00
|
|
|
if (device->driver->report_fixup)
|
2012-09-20 13:00:32 -06:00
|
|
|
start = device->driver->report_fixup(device, buf, &size);
|
|
|
|
else
|
|
|
|
start = buf;
|
2008-05-16 03:49:16 -06:00
|
|
|
|
2012-09-20 13:00:32 -06:00
|
|
|
start = kmemdup(start, size, GFP_KERNEL);
|
|
|
|
kfree(buf);
|
|
|
|
if (start == NULL)
|
2008-05-16 03:49:15 -06:00
|
|
|
return -ENOMEM;
|
2012-09-20 13:00:32 -06:00
|
|
|
|
|
|
|
device->rdesc = start;
|
2006-12-08 10:40:44 -07:00
|
|
|
device->rsize = size;
|
|
|
|
|
2010-12-09 20:29:04 -07:00
|
|
|
parser = vzalloc(sizeof(struct hid_parser));
|
2008-05-16 03:49:15 -06:00
|
|
|
if (!parser) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
2008-05-16 03:49:15 -06:00
|
|
|
|
2006-12-08 10:40:44 -07:00
|
|
|
parser->device = device;
|
|
|
|
|
|
|
|
end = start + size;
|
2012-04-22 06:21:40 -06:00
|
|
|
|
|
|
|
device->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
|
|
|
|
sizeof(struct hid_collection), GFP_KERNEL);
|
|
|
|
if (!device->collection) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
|
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
ret = -EINVAL;
|
2006-12-08 10:40:44 -07:00
|
|
|
while ((start = fetch_item(start, end, &item)) != NULL) {
|
|
|
|
|
|
|
|
if (item.format != HID_ITEM_FORMAT_SHORT) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(device, "unexpected long global item\n");
|
2008-05-16 03:49:15 -06:00
|
|
|
goto err;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (dispatch_type[item.type](parser, &item)) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(device, "item %u %u %u %u parsing failed\n",
|
2010-12-09 20:29:03 -07:00
|
|
|
item.format, (unsigned)item.size,
|
|
|
|
(unsigned)item.type, (unsigned)item.tag);
|
2008-05-16 03:49:15 -06:00
|
|
|
goto err;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (start == end) {
|
|
|
|
if (parser->collection_stack_ptr) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(device, "unbalanced collection at end of report description\n");
|
2008-05-16 03:49:15 -06:00
|
|
|
goto err;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
if (parser->local.delimiter_depth) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(device, "unbalanced delimiter at end of report description\n");
|
2008-05-16 03:49:15 -06:00
|
|
|
goto err;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
2007-03-12 07:55:12 -06:00
|
|
|
vfree(parser);
|
2012-04-22 06:21:40 -06:00
|
|
|
device->status |= HID_STAT_PARSED;
|
2008-05-16 03:49:15 -06:00
|
|
|
return 0;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(device, "item fetching failed at offset %d\n", (int)(end - start));
|
2008-05-16 03:49:15 -06:00
|
|
|
err:
|
2007-03-12 07:55:12 -06:00
|
|
|
vfree(parser);
|
2012-04-22 06:21:40 -06:00
|
|
|
hid_close_report(device);
|
2008-05-16 03:49:15 -06:00
|
|
|
return ret;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
2012-04-22 06:21:40 -06:00
|
|
|
EXPORT_SYMBOL_GPL(hid_open_report);
|
2006-12-08 10:40:44 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert a signed n-bit integer to signed 32-bit integer. Common
|
|
|
|
* cases are done through the compiler, the screwed things has to be
|
|
|
|
* done by hand.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static s32 snto32(__u32 value, unsigned n)
|
|
|
|
{
|
|
|
|
switch (n) {
|
2008-06-18 15:55:41 -06:00
|
|
|
case 8: return ((__s8)value);
|
|
|
|
case 16: return ((__s16)value);
|
|
|
|
case 32: return ((__s32)value);
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
return value & (1 << (n - 1)) ? value | (-1 << n) : value;
|
|
|
|
}
|
|
|
|
|
2012-11-14 08:59:15 -07:00
|
|
|
s32 hid_snto32(__u32 value, unsigned n)
|
|
|
|
{
|
|
|
|
return snto32(value, n);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_snto32);
|
|
|
|
|
2006-12-08 10:40:44 -07:00
|
|
|
/*
|
|
|
|
* Convert a signed 32-bit integer to a signed n-bit integer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static u32 s32ton(__s32 value, unsigned n)
|
|
|
|
{
|
|
|
|
s32 a = value >> (n - 1);
|
|
|
|
if (a && a != -1)
|
|
|
|
return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1;
|
|
|
|
return value & ((1 << n) - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extract/implement a data field from/to a little endian report (bit array).
|
|
|
|
*
|
|
|
|
* Code sort-of follows HID spec:
|
|
|
|
* http://www.usb.org/developers/devclass_docs/HID1_11.pdf
|
|
|
|
*
|
|
|
|
* While the USB HID spec allows unlimited length bit fields in "report
|
|
|
|
* descriptors", most devices never use more than 16 bits.
|
|
|
|
* One model of UPS is claimed to report "LINEV" as a 32-bit field.
|
|
|
|
* Search linux-kernel and linux-usb-devel archives for "hid-core extract".
|
|
|
|
*/
|
|
|
|
|
2015-05-30 03:00:26 -06:00
|
|
|
__u32 hid_field_extract(const struct hid_device *hid, __u8 *report,
|
2010-12-09 20:29:05 -07:00
|
|
|
unsigned offset, unsigned n)
|
2006-12-08 10:40:44 -07:00
|
|
|
{
|
|
|
|
u64 x;
|
|
|
|
|
2007-11-30 03:12:58 -07:00
|
|
|
if (n > 32)
|
2015-05-30 03:00:26 -06:00
|
|
|
hid_warn(hid, "hid_field_extract() called with n (%d) > 32! (%s)\n",
|
2010-12-09 20:29:03 -07:00
|
|
|
n, current->comm);
|
2006-12-08 10:40:44 -07:00
|
|
|
|
|
|
|
report += offset >> 3; /* adjust byte index */
|
2006-12-08 10:40:53 -07:00
|
|
|
offset &= 7; /* now only need bit offset into one byte */
|
2008-04-29 02:03:31 -06:00
|
|
|
x = get_unaligned_le64(report);
|
2006-12-08 10:40:53 -07:00
|
|
|
x = (x >> offset) & ((1ULL << n) - 1); /* extract bit field */
|
2006-12-08 10:40:44 -07:00
|
|
|
return (u32) x;
|
|
|
|
}
|
2015-05-30 03:00:26 -06:00
|
|
|
EXPORT_SYMBOL_GPL(hid_field_extract);
|
2006-12-08 10:40:44 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* "implement" : set bits in a little endian bit stream.
|
|
|
|
* Same concepts as "extract" (see comments above).
|
|
|
|
* The data mangled in the bit stream remains in little endian
|
|
|
|
* order the whole time. It make more sense to talk about
|
|
|
|
* endianness of register values by considering a register
|
|
|
|
* a "cached" copy of the little endiad bit stream.
|
|
|
|
*/
|
2010-12-09 20:29:05 -07:00
|
|
|
static void implement(const struct hid_device *hid, __u8 *report,
|
|
|
|
unsigned offset, unsigned n, __u32 value)
|
2006-12-08 10:40:44 -07:00
|
|
|
{
|
2008-05-16 03:00:23 -06:00
|
|
|
u64 x;
|
2006-12-08 10:40:44 -07:00
|
|
|
u64 m = (1ULL << n) - 1;
|
|
|
|
|
2007-11-30 03:12:58 -07:00
|
|
|
if (n > 32)
|
2010-12-09 20:29:03 -07:00
|
|
|
hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n",
|
|
|
|
__func__, n, current->comm);
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2007-11-30 03:12:58 -07:00
|
|
|
if (value > m)
|
2010-12-09 20:29:03 -07:00
|
|
|
hid_warn(hid, "%s() called with too large value %d! (%s)\n",
|
|
|
|
__func__, value, current->comm);
|
2006-12-08 10:40:44 -07:00
|
|
|
WARN_ON(value > m);
|
|
|
|
value &= m;
|
|
|
|
|
|
|
|
report += offset >> 3;
|
|
|
|
offset &= 7;
|
|
|
|
|
2008-05-16 03:00:23 -06:00
|
|
|
x = get_unaligned_le64(report);
|
|
|
|
x &= ~(m << offset);
|
|
|
|
x |= ((u64)value) << offset;
|
|
|
|
put_unaligned_le64(x, report);
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Search an array for a value.
|
|
|
|
*/
|
|
|
|
|
2010-12-09 20:29:05 -07:00
|
|
|
static int search(__s32 *array, __s32 value, unsigned n)
|
2006-12-08 10:40:44 -07:00
|
|
|
{
|
|
|
|
while (n--) {
|
|
|
|
if (*array++ == value)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
/**
|
|
|
|
* hid_match_report - check if driver's raw_event should be called
|
|
|
|
*
|
|
|
|
* @hid: hid device
|
|
|
|
* @report_type: type to match against
|
|
|
|
*
|
|
|
|
* compare hid->driver->report_table->report_type to report->type
|
|
|
|
*/
|
|
|
|
static int hid_match_report(struct hid_device *hid, struct hid_report *report)
|
2006-12-08 10:40:44 -07:00
|
|
|
{
|
2008-05-16 03:49:15 -06:00
|
|
|
const struct hid_report_id *id = hid->driver->report_table;
|
|
|
|
|
|
|
|
if (!id) /* NULL means all */
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
for (; id->report_type != HID_TERMINATOR; id++)
|
|
|
|
if (id->report_type == HID_ANY_ID ||
|
|
|
|
id->report_type == report->type)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* hid_match_usage - check if driver's event should be called
|
|
|
|
*
|
|
|
|
* @hid: hid device
|
|
|
|
* @usage: usage to match against
|
|
|
|
*
|
|
|
|
* compare hid->driver->usage_table->usage_{type,code} to
|
|
|
|
* usage->usage_{type,code}
|
|
|
|
*/
|
|
|
|
static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage)
|
|
|
|
{
|
|
|
|
const struct hid_usage_id *id = hid->driver->usage_table;
|
|
|
|
|
|
|
|
if (!id) /* NULL means all */
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
for (; id->usage_type != HID_ANY_ID - 1; id++)
|
|
|
|
if ((id->usage_hid == HID_ANY_ID ||
|
|
|
|
id->usage_hid == usage->hid) &&
|
|
|
|
(id->usage_type == HID_ANY_ID ||
|
|
|
|
id->usage_type == usage->type) &&
|
|
|
|
(id->usage_code == HID_ANY_ID ||
|
|
|
|
id->usage_code == usage->code))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hid_process_event(struct hid_device *hid, struct hid_field *field,
|
|
|
|
struct hid_usage *usage, __s32 value, int interrupt)
|
|
|
|
{
|
|
|
|
struct hid_driver *hdrv = hid->driver;
|
|
|
|
int ret;
|
|
|
|
|
2012-09-01 13:47:11 -06:00
|
|
|
if (!list_empty(&hid->debug_list))
|
|
|
|
hid_dump_input(hid, usage, value);
|
2008-05-16 03:49:15 -06:00
|
|
|
|
|
|
|
if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
|
|
|
|
ret = hdrv->event(hid, field, usage, value);
|
|
|
|
if (ret != 0) {
|
|
|
|
if (ret < 0)
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(hid, "%s's event failed with %d\n",
|
2008-05-16 03:49:15 -06:00
|
|
|
hdrv->name, ret);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-08 10:40:44 -07:00
|
|
|
if (hid->claimed & HID_CLAIMED_INPUT)
|
|
|
|
hidinput_hid_event(hid, field, usage, value);
|
2006-12-08 10:41:10 -07:00
|
|
|
if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
|
|
|
|
hid->hiddev_hid_event(hid, field, usage, value);
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Analyse a received field, and fetch the data from it. The field
|
|
|
|
* content is stored for next report processing (we do differential
|
|
|
|
* reporting to the layer).
|
|
|
|
*/
|
|
|
|
|
2008-03-30 17:53:56 -06:00
|
|
|
static void hid_input_field(struct hid_device *hid, struct hid_field *field,
|
|
|
|
__u8 *data, int interrupt)
|
2006-12-08 10:40:44 -07:00
|
|
|
{
|
|
|
|
unsigned n;
|
|
|
|
unsigned count = field->report_count;
|
|
|
|
unsigned offset = field->report_offset;
|
|
|
|
unsigned size = field->report_size;
|
|
|
|
__s32 min = field->logical_minimum;
|
|
|
|
__s32 max = field->logical_maximum;
|
|
|
|
__s32 *value;
|
|
|
|
|
2010-12-09 20:29:07 -07:00
|
|
|
value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC);
|
|
|
|
if (!value)
|
2006-12-08 10:40:44 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
for (n = 0; n < count; n++) {
|
|
|
|
|
2010-12-09 20:29:03 -07:00
|
|
|
value[n] = min < 0 ?
|
2015-05-30 03:00:26 -06:00
|
|
|
snto32(hid_field_extract(hid, data, offset + n * size,
|
|
|
|
size), size) :
|
|
|
|
hid_field_extract(hid, data, offset + n * size, size);
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2010-12-09 20:29:03 -07:00
|
|
|
/* Ignore report if ErrorRollOver */
|
|
|
|
if (!(field->flags & HID_MAIN_ITEM_VARIABLE) &&
|
|
|
|
value[n] >= min && value[n] <= max &&
|
|
|
|
field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
|
|
|
|
goto exit;
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
for (n = 0; n < count; n++) {
|
|
|
|
|
|
|
|
if (HID_MAIN_ITEM_VARIABLE & field->flags) {
|
|
|
|
hid_process_event(hid, field, &field->usage[n], value[n], interrupt);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (field->value[n] >= min && field->value[n] <= max
|
|
|
|
&& field->usage[field->value[n] - min].hid
|
|
|
|
&& search(value, field->value[n], count))
|
|
|
|
hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt);
|
|
|
|
|
|
|
|
if (value[n] >= min && value[n] <= max
|
|
|
|
&& field->usage[value[n] - min].hid
|
|
|
|
&& search(field->value, value[n], count))
|
|
|
|
hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt);
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(field->value, value, count * sizeof(__s32));
|
|
|
|
exit:
|
|
|
|
kfree(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Output the field into the report.
|
|
|
|
*/
|
|
|
|
|
2010-12-09 20:29:03 -07:00
|
|
|
static void hid_output_field(const struct hid_device *hid,
|
|
|
|
struct hid_field *field, __u8 *data)
|
2006-12-08 10:40:44 -07:00
|
|
|
{
|
|
|
|
unsigned count = field->report_count;
|
|
|
|
unsigned offset = field->report_offset;
|
|
|
|
unsigned size = field->report_size;
|
|
|
|
unsigned n;
|
|
|
|
|
|
|
|
for (n = 0; n < count; n++) {
|
|
|
|
if (field->logical_minimum < 0) /* signed values */
|
2010-12-09 20:29:03 -07:00
|
|
|
implement(hid, data, offset + n * size, size,
|
|
|
|
s32ton(field->value[n], size));
|
2006-12-08 10:40:44 -07:00
|
|
|
else /* unsigned values */
|
2010-12-09 20:29:03 -07:00
|
|
|
implement(hid, data, offset + n * size, size,
|
|
|
|
field->value[n]);
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
HID: fix data access in implement()
implement() is setting bytes in LE data stream. In case the data is not
aligned to 64bits, it reads past the allocated buffer. It doesn't really
change any value there (it's properly bitmasked), but in case that this
read past the boundary hits a page boundary, pagefault happens when
accessing 64bits of 'x' in implement(), and kernel oopses.
This happens much more often when numbered reports are in use, as the
initial 8bit skip in the buffer makes the whole process work on values
which are not aligned to 64bits.
This problem dates back to attempts in 2005 and 2006 to make implement()
and extract() as generic as possible, and even back then the problem
was realized by Adam Kroperlin, but falsely assumed to be impossible
to cause any harm:
http://www.mail-archive.com/linux-usb-devel@lists.sourceforge.net/msg47690.html
I have made several attempts at fixing it "on the spot" directly in
implement(), but the results were horrible; the special casing for processing
last 64bit chunk and switching to different math makes it unreadable mess.
I therefore took a path to allocate a few bytes more which will never make
it into final report, but are there as a cushion for all the 64bit math
operations happening in implement() and extract().
All callers of hid_output_report() are converted at the same time to allocate
the buffer by newly introduced hid_alloc_report_buf() helper.
Bruno noticed that the whole raw_size test can be dropped as well, as
hid_alloc_report_buf() makes sure that the buffer is always of a proper
size.
Reviewed-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Acked-by: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-07-10 11:56:27 -06:00
|
|
|
* Create a report. 'data' has to be allocated using
|
|
|
|
* hid_alloc_report_buf() so that it has proper size.
|
2006-12-08 10:40:44 -07:00
|
|
|
*/
|
|
|
|
|
2006-12-08 10:40:53 -07:00
|
|
|
void hid_output_report(struct hid_report *report, __u8 *data)
|
2006-12-08 10:40:44 -07:00
|
|
|
{
|
|
|
|
unsigned n;
|
|
|
|
|
|
|
|
if (report->id > 0)
|
|
|
|
*data++ = report->id;
|
|
|
|
|
2010-04-12 12:16:11 -06:00
|
|
|
memset(data, 0, ((report->size - 1) >> 3) + 1);
|
2006-12-08 10:40:44 -07:00
|
|
|
for (n = 0; n < report->maxfield; n++)
|
2010-12-09 20:29:03 -07:00
|
|
|
hid_output_field(report->device, report->field[n], data);
|
2006-12-08 10:40:44 -07:00
|
|
|
}
|
2006-12-08 10:40:53 -07:00
|
|
|
EXPORT_SYMBOL_GPL(hid_output_report);
|
2006-12-08 10:40:44 -07:00
|
|
|
|
HID: fix data access in implement()
implement() is setting bytes in LE data stream. In case the data is not
aligned to 64bits, it reads past the allocated buffer. It doesn't really
change any value there (it's properly bitmasked), but in case that this
read past the boundary hits a page boundary, pagefault happens when
accessing 64bits of 'x' in implement(), and kernel oopses.
This happens much more often when numbered reports are in use, as the
initial 8bit skip in the buffer makes the whole process work on values
which are not aligned to 64bits.
This problem dates back to attempts in 2005 and 2006 to make implement()
and extract() as generic as possible, and even back then the problem
was realized by Adam Kroperlin, but falsely assumed to be impossible
to cause any harm:
http://www.mail-archive.com/linux-usb-devel@lists.sourceforge.net/msg47690.html
I have made several attempts at fixing it "on the spot" directly in
implement(), but the results were horrible; the special casing for processing
last 64bit chunk and switching to different math makes it unreadable mess.
I therefore took a path to allocate a few bytes more which will never make
it into final report, but are there as a cushion for all the 64bit math
operations happening in implement() and extract().
All callers of hid_output_report() are converted at the same time to allocate
the buffer by newly introduced hid_alloc_report_buf() helper.
Bruno noticed that the whole raw_size test can be dropped as well, as
hid_alloc_report_buf() makes sure that the buffer is always of a proper
size.
Reviewed-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Acked-by: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-07-10 11:56:27 -06:00
|
|
|
/*
|
|
|
|
* Allocator for buffer that is going to be passed to hid_output_report()
|
|
|
|
*/
|
|
|
|
u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* 7 extra bytes are necessary to achieve proper functionality
|
|
|
|
* of implement() working on 8 byte chunks
|
|
|
|
*/
|
|
|
|
|
2014-04-30 15:48:40 -06:00
|
|
|
int len = hid_report_len(report) + 7;
|
HID: fix data access in implement()
implement() is setting bytes in LE data stream. In case the data is not
aligned to 64bits, it reads past the allocated buffer. It doesn't really
change any value there (it's properly bitmasked), but in case that this
read past the boundary hits a page boundary, pagefault happens when
accessing 64bits of 'x' in implement(), and kernel oopses.
This happens much more often when numbered reports are in use, as the
initial 8bit skip in the buffer makes the whole process work on values
which are not aligned to 64bits.
This problem dates back to attempts in 2005 and 2006 to make implement()
and extract() as generic as possible, and even back then the problem
was realized by Adam Kroperlin, but falsely assumed to be impossible
to cause any harm:
http://www.mail-archive.com/linux-usb-devel@lists.sourceforge.net/msg47690.html
I have made several attempts at fixing it "on the spot" directly in
implement(), but the results were horrible; the special casing for processing
last 64bit chunk and switching to different math makes it unreadable mess.
I therefore took a path to allocate a few bytes more which will never make
it into final report, but are there as a cushion for all the 64bit math
operations happening in implement() and extract().
All callers of hid_output_report() are converted at the same time to allocate
the buffer by newly introduced hid_alloc_report_buf() helper.
Bruno noticed that the whole raw_size test can be dropped as well, as
hid_alloc_report_buf() makes sure that the buffer is always of a proper
size.
Reviewed-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Acked-by: Gustavo Padovan <gustavo.padovan@collabora.co.uk>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-07-10 11:56:27 -06:00
|
|
|
|
|
|
|
return kmalloc(len, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_alloc_report_buf);
|
|
|
|
|
2006-12-08 10:40:44 -07:00
|
|
|
/*
|
|
|
|
* Set a field value. The report this field belongs to has to be
|
|
|
|
* created and transferred to the device, to set this value in the
|
|
|
|
* device.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
|
|
|
|
{
|
2013-08-28 14:32:01 -06:00
|
|
|
unsigned size;
|
|
|
|
|
|
|
|
if (!field)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
size = field->report_size;
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2009-06-12 07:20:57 -06:00
|
|
|
hid_dump_input(field->report->device, field->usage + offset, value);
|
2006-12-08 10:40:44 -07:00
|
|
|
|
|
|
|
if (offset >= field->report_count) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n",
|
|
|
|
offset, field->report_count);
|
2006-12-08 10:40:44 -07:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (field->logical_minimum < 0) {
|
|
|
|
if (value != snto32(s32ton(value, size), size)) {
|
2011-12-15 03:00:38 -07:00
|
|
|
hid_err(field->report->device, "value %d is out of range\n", value);
|
2006-12-08 10:40:44 -07:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
field->value[offset] = value;
|
|
|
|
return 0;
|
|
|
|
}
|
2006-12-08 10:40:53 -07:00
|
|
|
EXPORT_SYMBOL_GPL(hid_set_field);
|
2006-12-08 10:40:44 -07:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,
|
|
|
|
const u8 *data)
|
2006-12-08 10:41:17 -07:00
|
|
|
{
|
|
|
|
struct hid_report *report;
|
2008-05-16 03:49:15 -06:00
|
|
|
unsigned int n = 0; /* Normally report number is 0 */
|
2006-12-08 10:41:17 -07:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
/* Device uses numbered reports, data[0] is report number */
|
|
|
|
if (report_enum->numbered)
|
|
|
|
n = *data;
|
2006-12-08 10:41:17 -07:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
report = report_enum->report_id_hash[n];
|
|
|
|
if (report == NULL)
|
|
|
|
dbg_hid("undefined report_id %u received\n", n);
|
2006-12-08 10:41:17 -07:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
return report;
|
|
|
|
}
|
2006-12-08 10:41:17 -07:00
|
|
|
|
2014-02-10 10:58:48 -07:00
|
|
|
/*
|
|
|
|
* Implement a generic .request() callback, using .raw_request()
|
|
|
|
* DO NOT USE in hid drivers directly, but through hid_hw_request instead.
|
|
|
|
*/
|
|
|
|
void __hid_request(struct hid_device *hid, struct hid_report *report,
|
|
|
|
int reqtype)
|
|
|
|
{
|
|
|
|
char *buf;
|
|
|
|
int ret;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
buf = hid_alloc_report_buf(report, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return;
|
|
|
|
|
|
|
|
len = hid_report_len(report);
|
|
|
|
|
|
|
|
if (reqtype == HID_REQ_SET_REPORT)
|
|
|
|
hid_output_report(report, buf);
|
|
|
|
|
|
|
|
ret = hid->ll_driver->raw_request(hid, report->id, buf, len,
|
|
|
|
report->type, reqtype);
|
|
|
|
if (ret < 0) {
|
|
|
|
dbg_hid("unable to complete request: %d\n", ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (reqtype == HID_REQ_GET_REPORT)
|
|
|
|
hid_input_report(hid, report->type, buf, ret, 0);
|
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(buf);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__hid_request);
|
|
|
|
|
2012-04-26 16:56:08 -06:00
|
|
|
int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
|
2008-05-16 03:49:15 -06:00
|
|
|
int interrupt)
|
|
|
|
{
|
|
|
|
struct hid_report_enum *report_enum = hid->report_enum + type;
|
|
|
|
struct hid_report *report;
|
2013-01-31 09:22:23 -07:00
|
|
|
struct hid_driver *hdrv;
|
2008-05-16 03:49:15 -06:00
|
|
|
unsigned int a;
|
|
|
|
int rsize, csize = size;
|
|
|
|
u8 *cdata = data;
|
2012-04-26 16:56:08 -06:00
|
|
|
int ret = 0;
|
2006-12-08 10:41:17 -07:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
report = hid_get_report(report_enum, data);
|
|
|
|
if (!report)
|
2012-04-26 16:56:08 -06:00
|
|
|
goto out;
|
2006-12-08 10:41:17 -07:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
if (report_enum->numbered) {
|
|
|
|
cdata++;
|
|
|
|
csize--;
|
2006-12-08 10:41:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
rsize = ((report->size - 1) >> 3) + 1;
|
|
|
|
|
2011-05-19 13:41:22 -06:00
|
|
|
if (rsize > HID_MAX_BUFFER_SIZE)
|
|
|
|
rsize = HID_MAX_BUFFER_SIZE;
|
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
if (csize < rsize) {
|
|
|
|
dbg_hid("report %d is too short, (%d < %d)\n", report->id,
|
|
|
|
csize, rsize);
|
|
|
|
memset(cdata + csize, 0, rsize - csize);
|
2006-12-08 10:41:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
|
|
|
|
hid->hiddev_report_event(hid, report);
|
2012-04-26 16:56:08 -06:00
|
|
|
if (hid->claimed & HID_CLAIMED_HIDRAW) {
|
|
|
|
ret = hidraw_report_event(hid, data, size);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
2006-12-08 10:41:17 -07:00
|
|
|
|
2013-09-11 13:56:57 -06:00
|
|
|
if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) {
|
2012-06-28 08:53:11 -06:00
|
|
|
for (a = 0; a < report->maxfield; a++)
|
|
|
|
hid_input_field(hid, report->field[a], cdata, interrupt);
|
2013-01-31 09:22:23 -07:00
|
|
|
hdrv = hid->driver;
|
|
|
|
if (hdrv && hdrv->report)
|
|
|
|
hdrv->report(hid, report);
|
2012-06-28 08:53:11 -06:00
|
|
|
}
|
2006-12-08 10:41:17 -07:00
|
|
|
|
|
|
|
if (hid->claimed & HID_CLAIMED_INPUT)
|
|
|
|
hidinput_report_event(hid, report);
|
2012-04-26 16:56:08 -06:00
|
|
|
out:
|
|
|
|
return ret;
|
2008-05-16 03:49:15 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_report_raw_event);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* hid_input_report - report data from lower layer (usb, bt...)
|
|
|
|
*
|
|
|
|
* @hid: hid device
|
|
|
|
* @type: HID report type (HID_*_REPORT)
|
|
|
|
* @data: report contents
|
|
|
|
* @size: size of data parameter
|
2009-10-01 08:03:13 -06:00
|
|
|
* @interrupt: distinguish between interrupt and control transfers
|
2008-05-16 03:49:15 -06:00
|
|
|
*
|
|
|
|
* This is data entry for lower layers.
|
|
|
|
*/
|
|
|
|
int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)
|
|
|
|
{
|
2009-07-19 09:26:13 -06:00
|
|
|
struct hid_report_enum *report_enum;
|
|
|
|
struct hid_driver *hdrv;
|
2008-05-16 03:49:15 -06:00
|
|
|
struct hid_report *report;
|
2011-08-10 06:02:59 -06:00
|
|
|
int ret = 0;
|
2008-05-16 03:49:15 -06:00
|
|
|
|
2011-08-10 06:02:07 -06:00
|
|
|
if (!hid)
|
2008-05-16 03:49:15 -06:00
|
|
|
return -ENODEV;
|
2011-08-10 06:02:07 -06:00
|
|
|
|
HID: Separate struct hid_device's driver_lock into two locks.
This patch separates struct hid_device's driver_lock into two. The
goal is to allow hid device drivers to receive input during their
probe() or remove() function calls. This is necessary because some
drivers need to communicate with the device to determine parameters
needed during probe (e.g., size of a multi-touch surface), and if
possible, may perfer to communicate with a device on host-initiated
disconnect (e.g., to put it into a low-power state).
Historically, three functions used driver_lock:
- hid_device_probe: blocks to acquire lock
- hid_device_remove: blocks to acquire lock
- hid_input_report: if locked returns -EBUSY, else acquires lock
This patch adds another lock (driver_input_lock) which is used to
block input from occurring. The lock behavior is now:
- hid_device_probe: blocks to acq. driver_lock, then driver_input_lock
- hid_device_remove: blocks to acq. driver_lock, then driver_input_lock
- hid_input_report: if driver_input_lock locked returns -EBUSY, else
acquires driver_input_lock
This patch also adds two helper functions to be called during probe()
or remove(): hid_device_io_start() and hid_device_io_stop(). These
functions lock and unlock, respectively, driver_input_lock; they also
make a note of whether they did so that hid-core knows if a driver has
changed the lock state.
This patch results in no behavior change for existing devices and
drivers. However, during a probe() or remove() function call in a
driver, that driver may now selectively call hid_device_io_start() to
let input events come through, then optionally call
hid_device_io_stop() to stop them.
Signed-off-by: Andrew de los Reyes <adlr@chromium.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-02-18 10:20:21 -07:00
|
|
|
if (down_trylock(&hid->driver_input_lock))
|
2011-08-10 06:02:07 -06:00
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
if (!hid->driver) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto unlock;
|
|
|
|
}
|
2009-07-19 09:26:13 -06:00
|
|
|
report_enum = hid->report_enum + type;
|
|
|
|
hdrv = hid->driver;
|
2008-05-16 03:49:15 -06:00
|
|
|
|
|
|
|
if (!size) {
|
|
|
|
dbg_hid("empty report\n");
|
2011-08-10 06:02:07 -06:00
|
|
|
ret = -1;
|
|
|
|
goto unlock;
|
2008-05-16 03:49:15 -06:00
|
|
|
}
|
|
|
|
|
2012-06-28 08:53:11 -06:00
|
|
|
/* Avoid unnecessary overhead if debugfs is disabled */
|
2013-04-17 11:38:13 -06:00
|
|
|
if (!list_empty(&hid->debug_list))
|
|
|
|
hid_dump_report(hid, type, data, size);
|
2008-05-16 03:49:15 -06:00
|
|
|
|
2010-03-18 05:09:53 -06:00
|
|
|
report = hid_get_report(report_enum, data);
|
|
|
|
|
2011-08-10 06:02:07 -06:00
|
|
|
if (!report) {
|
|
|
|
ret = -1;
|
|
|
|
goto unlock;
|
|
|
|
}
|
2008-05-16 03:49:15 -06:00
|
|
|
|
|
|
|
if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
|
|
|
|
ret = hdrv->raw_event(hid, report, data, size);
|
2013-10-08 11:33:47 -06:00
|
|
|
if (ret < 0)
|
2011-08-10 06:02:07 -06:00
|
|
|
goto unlock;
|
2008-05-16 03:49:15 -06:00
|
|
|
}
|
|
|
|
|
2012-04-26 16:56:08 -06:00
|
|
|
ret = hid_report_raw_event(hid, type, data, size, interrupt);
|
2006-12-08 10:41:17 -07:00
|
|
|
|
2011-08-10 06:02:07 -06:00
|
|
|
unlock:
|
HID: Separate struct hid_device's driver_lock into two locks.
This patch separates struct hid_device's driver_lock into two. The
goal is to allow hid device drivers to receive input during their
probe() or remove() function calls. This is necessary because some
drivers need to communicate with the device to determine parameters
needed during probe (e.g., size of a multi-touch surface), and if
possible, may perfer to communicate with a device on host-initiated
disconnect (e.g., to put it into a low-power state).
Historically, three functions used driver_lock:
- hid_device_probe: blocks to acquire lock
- hid_device_remove: blocks to acquire lock
- hid_input_report: if locked returns -EBUSY, else acquires lock
This patch adds another lock (driver_input_lock) which is used to
block input from occurring. The lock behavior is now:
- hid_device_probe: blocks to acq. driver_lock, then driver_input_lock
- hid_device_remove: blocks to acq. driver_lock, then driver_input_lock
- hid_input_report: if driver_input_lock locked returns -EBUSY, else
acquires driver_input_lock
This patch also adds two helper functions to be called during probe()
or remove(): hid_device_io_start() and hid_device_io_stop(). These
functions lock and unlock, respectively, driver_input_lock; they also
make a note of whether they did so that hid-core knows if a driver has
changed the lock state.
This patch results in no behavior change for existing devices and
drivers. However, during a probe() or remove() function call in a
driver, that driver may now selectively call hid_device_io_start() to
let input events come through, then optionally call
hid_device_io_stop() to stop them.
Signed-off-by: Andrew de los Reyes <adlr@chromium.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-02-18 10:20:21 -07:00
|
|
|
up(&hid->driver_input_lock);
|
2011-08-10 06:02:59 -06:00
|
|
|
return ret;
|
2006-12-08 10:41:17 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_input_report);
|
|
|
|
|
2008-08-20 11:13:52 -06:00
|
|
|
static bool hid_match_one_id(struct hid_device *hdev,
|
|
|
|
const struct hid_device_id *id)
|
|
|
|
{
|
2012-04-23 04:07:04 -06:00
|
|
|
return (id->bus == HID_BUS_ANY || id->bus == hdev->bus) &&
|
2012-04-23 04:07:02 -06:00
|
|
|
(id->group == HID_GROUP_ANY || id->group == hdev->group) &&
|
2008-08-20 11:13:52 -06:00
|
|
|
(id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
|
|
|
|
(id->product == HID_ANY_ID || id->product == hdev->product);
|
|
|
|
}
|
|
|
|
|
2011-12-02 12:12:36 -07:00
|
|
|
const struct hid_device_id *hid_match_id(struct hid_device *hdev,
|
2008-08-20 11:13:52 -06:00
|
|
|
const struct hid_device_id *id)
|
|
|
|
{
|
|
|
|
for (; id->bus; id++)
|
|
|
|
if (hid_match_one_id(hdev, id))
|
|
|
|
return id;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct hid_device_id hid_hiddev_list[] = {
|
2008-08-27 03:19:37 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) },
|
2008-08-20 11:13:52 -06:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
|
|
|
static bool hid_hiddev(struct hid_device *hdev)
|
|
|
|
{
|
|
|
|
return !!hid_match_id(hdev, hid_hiddev_list);
|
|
|
|
}
|
|
|
|
|
2011-01-23 20:50:18 -07:00
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
read_report_descriptor(struct file *filp, struct kobject *kobj,
|
|
|
|
struct bin_attribute *attr,
|
|
|
|
char *buf, loff_t off, size_t count)
|
|
|
|
{
|
|
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
|
|
|
|
|
|
|
if (off >= hdev->rsize)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (off + count > hdev->rsize)
|
|
|
|
count = hdev->rsize - off;
|
|
|
|
|
|
|
|
memcpy(buf, hdev->rdesc + off, count);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2015-02-17 06:00:03 -07:00
|
|
|
static ssize_t
|
|
|
|
show_country(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
|
|
|
|
|
|
|
return sprintf(buf, "%02x\n", hdev->country & 0xff);
|
|
|
|
}
|
|
|
|
|
2011-01-23 20:50:18 -07:00
|
|
|
static struct bin_attribute dev_bin_attr_report_desc = {
|
|
|
|
.attr = { .name = "report_descriptor", .mode = 0444 },
|
|
|
|
.read = read_report_descriptor,
|
|
|
|
.size = HID_MAX_DESCRIPTOR_SIZE,
|
|
|
|
};
|
|
|
|
|
2015-02-17 06:00:03 -07:00
|
|
|
static struct device_attribute dev_attr_country = {
|
|
|
|
.attr = { .name = "country", .mode = 0444 },
|
|
|
|
.show = show_country,
|
|
|
|
};
|
|
|
|
|
2008-06-26 16:04:24 -06:00
|
|
|
int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
|
|
|
|
{
|
|
|
|
static const char *types[] = { "Device", "Pointer", "Mouse", "Device",
|
|
|
|
"Joystick", "Gamepad", "Keyboard", "Keypad",
|
|
|
|
"Multi-Axis Controller"
|
|
|
|
};
|
|
|
|
const char *type, *bus;
|
|
|
|
char buf[64];
|
|
|
|
unsigned int i;
|
|
|
|
int len;
|
2011-01-23 20:50:18 -07:00
|
|
|
int ret;
|
2008-06-26 16:04:24 -06:00
|
|
|
|
2010-04-16 10:19:50 -06:00
|
|
|
if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)
|
|
|
|
connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV);
|
2010-07-12 11:28:27 -06:00
|
|
|
if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE)
|
|
|
|
connect_mask |= HID_CONNECT_HIDINPUT_FORCE;
|
2008-06-26 16:04:24 -06:00
|
|
|
if (hdev->bus != BUS_USB)
|
|
|
|
connect_mask &= ~HID_CONNECT_HIDDEV;
|
2008-08-20 11:13:52 -06:00
|
|
|
if (hid_hiddev(hdev))
|
|
|
|
connect_mask |= HID_CONNECT_HIDDEV_FORCE;
|
2008-06-26 16:04:24 -06:00
|
|
|
|
|
|
|
if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,
|
|
|
|
connect_mask & HID_CONNECT_HIDINPUT_FORCE))
|
|
|
|
hdev->claimed |= HID_CLAIMED_INPUT;
|
2011-09-21 08:56:54 -06:00
|
|
|
|
2008-06-26 16:04:24 -06:00
|
|
|
if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&
|
|
|
|
!hdev->hiddev_connect(hdev,
|
|
|
|
connect_mask & HID_CONNECT_HIDDEV_FORCE))
|
|
|
|
hdev->claimed |= HID_CLAIMED_HIDDEV;
|
|
|
|
if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))
|
|
|
|
hdev->claimed |= HID_CLAIMED_HIDRAW;
|
|
|
|
|
2014-09-23 10:08:08 -06:00
|
|
|
if (connect_mask & HID_CONNECT_DRIVER)
|
|
|
|
hdev->claimed |= HID_CLAIMED_DRIVER;
|
|
|
|
|
2012-07-20 03:49:09 -06:00
|
|
|
/* Drivers with the ->raw_event callback set are not required to connect
|
|
|
|
* to any other listener. */
|
|
|
|
if (!hdev->claimed && !hdev->driver->raw_event) {
|
|
|
|
hid_err(hdev, "device has no listeners, quitting\n");
|
2008-06-26 16:04:24 -06:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((hdev->claimed & HID_CLAIMED_INPUT) &&
|
|
|
|
(connect_mask & HID_CONNECT_FF) && hdev->ff_init)
|
|
|
|
hdev->ff_init(hdev);
|
|
|
|
|
|
|
|
len = 0;
|
|
|
|
if (hdev->claimed & HID_CLAIMED_INPUT)
|
|
|
|
len += sprintf(buf + len, "input");
|
|
|
|
if (hdev->claimed & HID_CLAIMED_HIDDEV)
|
|
|
|
len += sprintf(buf + len, "%shiddev%d", len ? "," : "",
|
|
|
|
hdev->minor);
|
|
|
|
if (hdev->claimed & HID_CLAIMED_HIDRAW)
|
|
|
|
len += sprintf(buf + len, "%shidraw%d", len ? "," : "",
|
|
|
|
((struct hidraw *)hdev->hidraw)->minor);
|
|
|
|
|
|
|
|
type = "Device";
|
|
|
|
for (i = 0; i < hdev->maxcollection; i++) {
|
|
|
|
struct hid_collection *col = &hdev->collection[i];
|
|
|
|
if (col->type == HID_COLLECTION_APPLICATION &&
|
|
|
|
(col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
|
|
|
|
(col->usage & 0xffff) < ARRAY_SIZE(types)) {
|
|
|
|
type = types[col->usage & 0xffff];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (hdev->bus) {
|
|
|
|
case BUS_USB:
|
|
|
|
bus = "USB";
|
|
|
|
break;
|
|
|
|
case BUS_BLUETOOTH:
|
|
|
|
bus = "BLUETOOTH";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
bus = "<UNKNOWN>";
|
|
|
|
}
|
|
|
|
|
2015-02-17 06:00:03 -07:00
|
|
|
ret = device_create_file(&hdev->dev, &dev_attr_country);
|
|
|
|
if (ret)
|
|
|
|
hid_warn(hdev,
|
|
|
|
"can't create sysfs country code attribute err: %d\n", ret);
|
|
|
|
|
2011-01-23 20:50:18 -07:00
|
|
|
ret = device_create_bin_file(&hdev->dev, &dev_bin_attr_report_desc);
|
|
|
|
if (ret)
|
|
|
|
hid_warn(hdev,
|
|
|
|
"can't create sysfs report descriptor attribute err: %d\n", ret);
|
|
|
|
|
2010-12-09 20:29:03 -07:00
|
|
|
hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n",
|
|
|
|
buf, bus, hdev->version >> 8, hdev->version & 0xff,
|
|
|
|
type, hdev->name, hdev->phys);
|
2008-06-26 16:04:24 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_connect);
|
|
|
|
|
2009-09-15 08:27:45 -06:00
|
|
|
void hid_disconnect(struct hid_device *hdev)
|
|
|
|
{
|
2015-02-17 06:00:03 -07:00
|
|
|
device_remove_file(&hdev->dev, &dev_attr_country);
|
2011-01-23 20:50:18 -07:00
|
|
|
device_remove_bin_file(&hdev->dev, &dev_bin_attr_report_desc);
|
2009-09-15 08:27:45 -06:00
|
|
|
if (hdev->claimed & HID_CLAIMED_INPUT)
|
|
|
|
hidinput_disconnect(hdev);
|
|
|
|
if (hdev->claimed & HID_CLAIMED_HIDDEV)
|
|
|
|
hdev->hiddev_disconnect(hdev);
|
|
|
|
if (hdev->claimed & HID_CLAIMED_HIDRAW)
|
|
|
|
hidraw_disconnect(hdev);
|
2014-11-03 13:33:32 -07:00
|
|
|
hdev->claimed = 0;
|
2009-09-15 08:27:45 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_disconnect);
|
|
|
|
|
2012-09-02 01:28:51 -06:00
|
|
|
/*
|
|
|
|
* A list of devices for which there is a specialized driver on HID bus.
|
|
|
|
*
|
|
|
|
* Please note that for multitouch devices (driven by hid-multitouch driver),
|
|
|
|
* there is a proper autodetection and autoloading in place (based on presence
|
|
|
|
* of HID_DG_CONTACTID), so those devices don't need to be added to this list,
|
|
|
|
* as we are doing the right thing in hid_scan_usage().
|
2012-12-09 04:44:30 -07:00
|
|
|
*
|
|
|
|
* Autodetection for (USB) HID sensor hubs exists too. If a collection of type
|
|
|
|
* physical is found inside a usage page of type sensor, hid-sensor-hub will be
|
|
|
|
* used as a driver. See hid_scan_report().
|
2012-09-02 01:28:51 -06:00
|
|
|
*/
|
2010-11-28 08:37:14 -07:00
|
|
|
static const struct hid_device_id hid_have_special_driver[] = {
|
2008-06-23 15:31:09 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },
|
2010-09-16 15:19:33 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) },
|
2010-07-19 04:13:23 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0x0802) },
|
2013-11-12 11:06:23 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0xf705) },
|
2008-06-18 15:36:49 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },
|
2010-02-06 10:24:36 -07:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },
|
2010-08-31 19:56:23 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICTRACKPAD) },
|
2008-06-18 15:36:49 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },
|
2009-03-05 02:18:01 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_JIS) },
|
2008-06-18 15:36:49 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },
|
2013-04-17 10:15:15 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL2) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL3) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL5) },
|
2008-11-26 07:33:45 -07:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },
|
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },
|
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },
|
2008-06-18 15:36:49 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },
|
2008-11-04 12:03:45 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },
|
2010-11-03 08:36:18 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },
|
2011-03-12 21:27:22 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
|
2011-10-22 13:39:06 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },
|
2011-07-31 05:40:49 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS) },
|
2011-08-10 06:12:52 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },
|
2011-10-25 01:59:04 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
|
2012-07-10 10:43:33 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
|
2012-10-30 12:11:48 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS) },
|
2013-07-01 12:46:27 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_JIS) },
|
2015-07-24 15:45:05 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_JIS) },
|
2010-01-06 06:49:57 -07:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
|
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
|
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },
|
2012-12-02 07:38:23 -07:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI) },
|
2011-10-28 10:50:39 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO) },
|
2014-02-06 02:40:34 -07:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_JIS) },
|
2008-06-18 15:36:49 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
|
2012-04-10 16:29:04 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_AUREAL, USB_DEVICE_ID_AUREAL_W01RN) },
|
2008-06-24 15:24:57 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },
|
2014-11-26 03:21:03 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185BFM, 0x2208) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185PC, 0x5506) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185V2PC, 0x1850) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185V2BFM, 0x5500) },
|
2010-04-28 16:45:01 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE) },
|
2010-08-30 07:43:25 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE_2) },
|
2008-06-24 12:42:25 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
|
2010-04-08 05:40:52 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) },
|
2008-06-24 14:48:52 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
|
2010-11-23 13:40:09 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS) },
|
2012-02-02 02:31:26 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },
|
2012-07-23 03:11:51 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_AK1D) },
|
2015-07-21 04:31:52 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_ACER_SWITCH12) },
|
2010-05-12 07:18:59 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },
|
2014-02-04 11:42:48 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_CP2112) },
|
2008-06-23 14:54:08 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },
|
2009-12-02 14:54:11 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_3) },
|
2012-07-22 03:32:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_4) },
|
2008-06-23 14:54:08 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },
|
2009-03-04 02:12:04 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },
|
2011-01-28 04:50:52 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },
|
2010-06-28 10:54:25 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },
|
2013-05-07 03:40:58 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030) },
|
2010-11-01 13:13:37 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
|
2008-06-24 13:11:21 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
|
2008-11-16 17:44:38 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
|
2008-11-20 07:55:38 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },
|
2015-08-13 09:11:27 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GEMBIRD, USB_DEVICE_ID_GEMBIRD_JPD_DUALFORCE2) },
|
2008-11-16 17:44:38 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
|
2008-12-11 14:07:59 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },
|
2008-07-24 15:35:13 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
|
2008-10-17 03:52:23 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
|
2010-05-22 14:00:28 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
|
2011-06-26 15:07:31 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },
|
2012-07-06 09:05:04 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD) },
|
2013-05-28 04:18:34 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067) },
|
2014-01-14 05:09:09 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A070) },
|
2013-10-21 15:42:22 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A072) },
|
2013-10-01 11:22:05 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A081) },
|
2014-09-05 09:13:17 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A0C2) },
|
2014-07-23 10:31:54 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_HUION, USB_DEVICE_ID_HUION_TABLET) },
|
2013-01-17 03:06:09 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_JESS2, USB_DEVICE_ID_JESS2_COLOR_RUMBLE_PAD) },
|
2012-10-31 05:10:10 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) },
|
2009-03-04 08:09:40 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
|
2011-02-17 07:12:45 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },
|
HID: kye: Add report fixup for Genius Gila Gaming mouse
Genius Gila Gaming Mouse presents an obviously wrong report descriptor.
the Consumer control (report ID 3) is the following:
0x05, 0x0c, // Usage Page (Consumer Devices) 105
0x09, 0x01, // Usage (Consumer Control) 107
0xa1, 0x01, // Collection (Application) 109
0x85, 0x03, // Report ID (3) 111
0x19, 0x00, // Usage Minimum (0) 113
0x2a, 0xff, 0x7f, // Usage Maximum (32767) 115
0x15, 0x00, // Logical Minimum (0) 118
0x26, 0xff, 0x7f, // Logical Maximum (32767) 120
0x75, 0x10, // Report Size (16) 123
0x95, 0x03, // Report Count (3) 125
0x81, 0x00, // Input (Data,Arr,Abs) 127
0x75, 0x08, // Report Size (8) 129
0x95, 0x01, // Report Count (1) 131
0x81, 0x01, // Input (Cnst,Arr,Abs) 133
0xc0, // End Collection 135
So the first input whithin this report has a count of 3 but a usage range
of 32768. So this value is obviously wrong as it should not be greater than
the report count.
Fixes:
https://bugzilla.redhat.com/show_bug.cgi?id=959721
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-07-02 10:10:09 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE) },
|
2013-11-20 07:49:41 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_MANTICORE) },
|
2013-07-15 02:12:18 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GX_IMPERATOR) },
|
2009-03-11 04:43:27 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
|
2012-02-28 04:01:46 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_I405X) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },
|
2014-12-26 15:28:30 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X_2) },
|
2012-02-28 04:01:46 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X) },
|
2015-02-14 01:48:44 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_PENSKETCH_M912) },
|
2008-06-24 15:24:57 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
|
2011-02-03 08:41:47 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) },
|
2014-07-23 16:30:45 -06:00
|
|
|
#if IS_ENABLED(CONFIG_HID_LENOVO)
|
2012-08-30 06:37:14 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },
|
2014-07-23 16:30:48 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) },
|
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) },
|
2015-05-01 14:22:45 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) },
|
2012-08-30 06:37:14 -06:00
|
|
|
#endif
|
2008-05-16 03:49:19 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER) },
|
2012-09-25 15:02:27 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3) },
|
2014-09-30 11:18:27 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_T651) },
|
2008-05-16 03:49:19 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL) },
|
2010-10-04 07:39:49 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD) },
|
2008-07-04 15:06:45 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D) },
|
2009-06-23 04:11:31 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ) },
|
2008-07-04 15:06:45 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },
|
2010-01-12 16:25:58 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940) },
|
2008-07-04 15:06:45 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2) },
|
2013-10-07 10:48:12 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_VIBRATION_WHEEL) },
|
2011-03-16 17:43:23 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL) },
|
2011-09-10 13:28:23 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL) },
|
HID: Add support for the G25 force feedback wheel in native mode
Add Product Id 0xc299 for the Logitech G25 force feedback wheel
The Logitech G25 force feedback wheel, is first recognize by the kernel
with the product id "0xc294". In this mode, we can't use all the axes
and buttons of the wheel.
Using a userland utility, it is possible to make the wheel switch to native
mode -- http://svn.vdrift.net/viewvc.cgi/trunk/tools/G25manage/?root=VDrift
In native mode, the wheel change its id number to "0xc299".
The packet that needs to be sent to the wheel to swtich to native mode and
change its PID is
{ 0xf8, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00 }
Signed-off-by: Christophe Borivant <christophe.borivant@wanadoo.fr>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2009-04-17 03:39:39 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },
|
2011-05-03 02:15:03 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) },
|
2012-02-13 03:13:03 -07:00
|
|
|
#if IS_ENABLED(CONFIG_HID_LOGITECH_DJ)
|
2011-09-15 03:34:49 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2) },
|
2012-02-13 03:13:03 -07:00
|
|
|
#endif
|
2010-09-22 05:19:42 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) },
|
2008-07-04 15:06:45 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },
|
2009-11-13 02:45:53 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR) },
|
2010-03-30 14:33:50 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },
|
2011-07-22 04:11:15 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500) },
|
2008-06-20 13:26:11 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K) },
|
2013-04-28 22:27:31 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K_JP) },
|
2015-02-21 12:51:08 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE7K) },
|
2008-06-20 13:26:11 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB) },
|
2011-06-13 14:08:18 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K) },
|
2008-06-20 13:26:11 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },
|
2014-01-29 09:57:43 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_OFFICE_KB) },
|
2015-07-22 21:11:40 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP) },
|
2014-11-03 19:26:12 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_3) },
|
2015-06-08 03:11:38 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER) },
|
2008-06-24 16:07:50 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
|
2014-06-18 10:05:02 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL) },
|
2008-11-19 07:54:46 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },
|
2010-06-19 02:37:29 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) },
|
2011-03-16 11:13:53 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) },
|
2010-01-21 07:36:52 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
|
2014-09-03 02:33:53 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_6000) },
|
2008-06-24 15:46:21 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
|
2014-10-31 18:34:42 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS, HID_ANY_ID) },
|
2011-10-14 18:18:54 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },
|
2012-09-17 08:04:19 -06:00
|
|
|
#if IS_ENABLED(CONFIG_HID_ROCCAT)
|
2011-01-06 01:00:34 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },
|
2011-11-24 09:46:24 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },
|
2013-11-08 06:12:00 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKUFX) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
|
2010-11-26 12:57:42 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) },
|
2013-03-10 05:32:44 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE) },
|
2013-08-30 06:10:07 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE_OPTICAL) },
|
2013-11-08 06:12:00 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEXTD) },
|
2011-01-30 05:38:24 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KOVAPLUS) },
|
2012-10-16 09:40:09 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_LUA) },
|
2010-08-29 04:30:18 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },
|
2011-03-23 11:11:36 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS) },
|
2013-10-28 11:52:07 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK_GLOW) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK_PRO) },
|
2012-05-20 14:44:54 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_SAVU) },
|
2012-09-17 08:04:19 -06:00
|
|
|
#endif
|
2014-05-20 12:28:00 -06:00
|
|
|
#if IS_ENABLED(CONFIG_HID_SAITEK)
|
2012-02-21 18:10:06 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000) },
|
2015-01-29 06:58:09 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7_OLD) },
|
2014-05-20 12:28:00 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_MMO7) },
|
2014-11-05 07:13:51 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT9) },
|
2014-05-20 12:28:00 -06:00
|
|
|
#endif
|
2008-06-25 14:31:48 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
|
2010-05-17 04:42:39 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },
|
2011-03-21 06:54:22 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },
|
2014-11-12 12:52:28 -07:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE) },
|
2013-05-27 15:41:05 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER) },
|
2015-05-05 18:47:29 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER) },
|
2015-06-03 09:45:19 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER) },
|
2011-04-28 07:43:13 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER) },
|
2015-06-17 00:08:51 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER) },
|
2012-09-25 15:02:27 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE) },
|
2008-06-25 15:47:04 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
|
2010-01-20 05:01:53 -07:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
|
2014-01-11 13:12:42 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER) },
|
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER) },
|
2008-10-23 04:58:38 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },
|
2013-04-30 18:26:23 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE) },
|
2013-01-31 08:07:07 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_SRWS1) },
|
2008-06-23 13:56:07 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
|
2013-01-22 10:01:21 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
|
2009-02-14 02:45:05 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
|
2009-06-29 01:41:29 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb323) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb324) },
|
2009-02-14 02:45:05 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },
|
2010-03-13 09:29:43 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb653) },
|
2009-02-14 02:45:05 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
|
2010-11-29 09:41:23 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb65a) },
|
2012-03-13 02:36:05 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_BT) },
|
HID: add support for tivo slide remote
This patch finishes off adding full support for the TiVo Slide remote,
which is a mostly pure HID device from the perspective of the kernel.
There are a few mappings that use a vendor-specific usage page, and a
few keys in the consumer usage page that I think make sense to remap
slightly, to better fit their key labels' intended use. Doing this in a
stand-alone hid-tivo.c makes the modifications only matter for this
specific device.
What's actually connected to the computer is a Broadcom-made usb dongle,
which has an embedded hub, bluetooth adapter, mouse and keyboard
devices. You pair with the dongle, then the remote sends data that its
converted into HID on the keyboard interface (the mouse interface
doesn't do anything interesting, so far as I can tell).
lsusb for this device:
Bus 004 Device 005: ID 0a5c:2190 Broadcom Corp.
Bus 004 Device 004: ID 0a5c:4503 Broadcom Corp.
Bus 004 Device 003: ID 150a:1201
Bus 004 Device 002: ID 0a5c:4500 Broadcom Corp. BCM2046B1 USB 2.0 Hub (part of BCM2046 Bluetooth)
Speaking of the keyboard interface, the remote actually does contain a
keyboard as well. The top slides away, revealing a reasonably functional
qwerty keyboard (not unlike many slide cell phones), thus the product
name.
CC: Jiri Kosina <jkosina@suse.cz>
Signed-off-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2011-10-14 14:57:42 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) },
|
2015-03-13 00:58:16 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_PRO) },
|
2009-01-03 16:36:56 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },
|
2010-07-13 14:50:51 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) },
|
2009-07-13 06:19:58 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },
|
2010-08-23 05:09:01 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },
|
2010-08-09 10:44:17 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U) },
|
2011-07-06 00:23:41 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP1062) },
|
2012-05-14 11:30:38 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_WIRELESS_TABLET_TWHL850) },
|
2012-08-26 11:55:08 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60) },
|
2009-05-13 02:54:38 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },
|
2012-02-18 05:53:44 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SUPER_JOY_BOX_3) },
|
2011-08-14 13:42:05 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD) },
|
2011-10-20 14:26:21 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },
|
2015-05-06 14:38:42 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII) },
|
2010-08-20 09:21:11 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },
|
2010-09-25 13:16:58 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },
|
2012-02-06 13:54:20 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) },
|
2012-03-06 00:54:24 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_PID_0038) },
|
2010-08-20 09:21:11 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },
|
2010-08-30 04:06:36 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },
|
2012-03-20 08:01:33 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET) },
|
2011-05-27 10:40:29 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE) },
|
2013-07-27 11:20:02 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_XIN_MO, USB_DEVICE_ID_XIN_MO_DUAL_ARCADE) },
|
2009-02-14 02:45:05 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
|
2010-05-14 10:30:59 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ZYDACRON, USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL) },
|
2008-06-18 15:36:49 -06:00
|
|
|
|
2008-06-20 13:26:11 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
|
2011-07-05 05:45:09 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE) },
|
2013-04-02 11:58:35 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
|
2015-01-08 15:51:35 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14) },
|
2008-05-16 03:49:15 -06:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2008-11-24 08:20:09 -07:00
|
|
|
struct hid_dynid {
|
|
|
|
struct list_head list;
|
|
|
|
struct hid_device_id id;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* store_new_id - add a new HID device ID to this driver and re-probe devices
|
|
|
|
* @driver: target device driver
|
|
|
|
* @buf: buffer for scanning device ID data
|
|
|
|
* @count: input size
|
|
|
|
*
|
|
|
|
* Adds a new dynamic hid device ID to this driver,
|
|
|
|
* and causes the driver to probe for all devices again.
|
|
|
|
*/
|
|
|
|
static ssize_t store_new_id(struct device_driver *drv, const char *buf,
|
|
|
|
size_t count)
|
|
|
|
{
|
|
|
|
struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);
|
|
|
|
struct hid_dynid *dynid;
|
|
|
|
__u32 bus, vendor, product;
|
|
|
|
unsigned long driver_data = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = sscanf(buf, "%x %x %x %lx",
|
|
|
|
&bus, &vendor, &product, &driver_data);
|
|
|
|
if (ret < 3)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
|
|
|
|
if (!dynid)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
dynid->id.bus = bus;
|
2012-04-23 04:07:02 -06:00
|
|
|
dynid->id.group = HID_GROUP_ANY;
|
2008-11-24 08:20:09 -07:00
|
|
|
dynid->id.vendor = vendor;
|
|
|
|
dynid->id.product = product;
|
|
|
|
dynid->id.driver_data = driver_data;
|
|
|
|
|
|
|
|
spin_lock(&hdrv->dyn_lock);
|
|
|
|
list_add_tail(&dynid->list, &hdrv->dyn_list);
|
|
|
|
spin_unlock(&hdrv->dyn_lock);
|
|
|
|
|
2012-01-24 11:34:41 -07:00
|
|
|
ret = driver_attach(&hdrv->driver);
|
2008-11-24 08:20:09 -07:00
|
|
|
|
|
|
|
return ret ? : count;
|
|
|
|
}
|
|
|
|
static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
|
|
|
|
|
|
|
|
static void hid_free_dynids(struct hid_driver *hdrv)
|
|
|
|
{
|
|
|
|
struct hid_dynid *dynid, *n;
|
|
|
|
|
|
|
|
spin_lock(&hdrv->dyn_lock);
|
|
|
|
list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) {
|
|
|
|
list_del(&dynid->list);
|
|
|
|
kfree(dynid);
|
|
|
|
}
|
|
|
|
spin_unlock(&hdrv->dyn_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct hid_device_id *hid_match_device(struct hid_device *hdev,
|
|
|
|
struct hid_driver *hdrv)
|
|
|
|
{
|
|
|
|
struct hid_dynid *dynid;
|
|
|
|
|
|
|
|
spin_lock(&hdrv->dyn_lock);
|
|
|
|
list_for_each_entry(dynid, &hdrv->dyn_list, list) {
|
|
|
|
if (hid_match_one_id(hdev, &dynid->id)) {
|
|
|
|
spin_unlock(&hdrv->dyn_lock);
|
|
|
|
return &dynid->id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&hdrv->dyn_lock);
|
|
|
|
|
|
|
|
return hid_match_id(hdev, hdrv->id_table);
|
|
|
|
}
|
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
static int hid_bus_match(struct device *dev, struct device_driver *drv)
|
|
|
|
{
|
|
|
|
struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);
|
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
|
|
|
|
2012-04-23 04:07:05 -06:00
|
|
|
return hid_match_device(hdev, hdrv) != NULL;
|
2008-05-16 03:49:15 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hid_device_probe(struct device *dev)
|
|
|
|
{
|
|
|
|
struct hid_driver *hdrv = container_of(dev->driver,
|
|
|
|
struct hid_driver, driver);
|
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
|
|
|
const struct hid_device_id *id;
|
|
|
|
int ret = 0;
|
|
|
|
|
2011-08-10 06:02:07 -06:00
|
|
|
if (down_interruptible(&hdev->driver_lock))
|
|
|
|
return -EINTR;
|
HID: Separate struct hid_device's driver_lock into two locks.
This patch separates struct hid_device's driver_lock into two. The
goal is to allow hid device drivers to receive input during their
probe() or remove() function calls. This is necessary because some
drivers need to communicate with the device to determine parameters
needed during probe (e.g., size of a multi-touch surface), and if
possible, may perfer to communicate with a device on host-initiated
disconnect (e.g., to put it into a low-power state).
Historically, three functions used driver_lock:
- hid_device_probe: blocks to acquire lock
- hid_device_remove: blocks to acquire lock
- hid_input_report: if locked returns -EBUSY, else acquires lock
This patch adds another lock (driver_input_lock) which is used to
block input from occurring. The lock behavior is now:
- hid_device_probe: blocks to acq. driver_lock, then driver_input_lock
- hid_device_remove: blocks to acq. driver_lock, then driver_input_lock
- hid_input_report: if driver_input_lock locked returns -EBUSY, else
acquires driver_input_lock
This patch also adds two helper functions to be called during probe()
or remove(): hid_device_io_start() and hid_device_io_stop(). These
functions lock and unlock, respectively, driver_input_lock; they also
make a note of whether they did so that hid-core knows if a driver has
changed the lock state.
This patch results in no behavior change for existing devices and
drivers. However, during a probe() or remove() function call in a
driver, that driver may now selectively call hid_device_io_start() to
let input events come through, then optionally call
hid_device_io_stop() to stop them.
Signed-off-by: Andrew de los Reyes <adlr@chromium.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-02-18 10:20:21 -07:00
|
|
|
if (down_interruptible(&hdev->driver_input_lock)) {
|
|
|
|
ret = -EINTR;
|
|
|
|
goto unlock_driver_lock;
|
|
|
|
}
|
|
|
|
hdev->io_started = false;
|
2011-08-10 06:02:07 -06:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
if (!hdev->driver) {
|
2008-11-24 08:20:09 -07:00
|
|
|
id = hid_match_device(hdev, hdrv);
|
2011-08-24 05:27:46 -06:00
|
|
|
if (id == NULL) {
|
2012-05-01 00:40:01 -06:00
|
|
|
ret = -ENODEV;
|
|
|
|
goto unlock;
|
2011-08-24 05:27:46 -06:00
|
|
|
}
|
2008-05-16 03:49:15 -06:00
|
|
|
|
2008-05-16 03:49:16 -06:00
|
|
|
hdev->driver = hdrv;
|
|
|
|
if (hdrv->probe) {
|
|
|
|
ret = hdrv->probe(hdev, id);
|
|
|
|
} else { /* default probe */
|
2012-04-22 06:21:40 -06:00
|
|
|
ret = hid_open_report(hdev);
|
2008-05-16 03:49:16 -06:00
|
|
|
if (!ret)
|
2008-06-26 16:04:24 -06:00
|
|
|
ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
|
2008-05-16 03:49:15 -06:00
|
|
|
}
|
2012-04-22 06:21:40 -06:00
|
|
|
if (ret) {
|
|
|
|
hid_close_report(hdev);
|
2008-05-16 03:49:16 -06:00
|
|
|
hdev->driver = NULL;
|
2012-04-22 06:21:40 -06:00
|
|
|
}
|
2008-05-16 03:49:15 -06:00
|
|
|
}
|
2011-08-24 05:27:46 -06:00
|
|
|
unlock:
|
HID: Separate struct hid_device's driver_lock into two locks.
This patch separates struct hid_device's driver_lock into two. The
goal is to allow hid device drivers to receive input during their
probe() or remove() function calls. This is necessary because some
drivers need to communicate with the device to determine parameters
needed during probe (e.g., size of a multi-touch surface), and if
possible, may perfer to communicate with a device on host-initiated
disconnect (e.g., to put it into a low-power state).
Historically, three functions used driver_lock:
- hid_device_probe: blocks to acquire lock
- hid_device_remove: blocks to acquire lock
- hid_input_report: if locked returns -EBUSY, else acquires lock
This patch adds another lock (driver_input_lock) which is used to
block input from occurring. The lock behavior is now:
- hid_device_probe: blocks to acq. driver_lock, then driver_input_lock
- hid_device_remove: blocks to acq. driver_lock, then driver_input_lock
- hid_input_report: if driver_input_lock locked returns -EBUSY, else
acquires driver_input_lock
This patch also adds two helper functions to be called during probe()
or remove(): hid_device_io_start() and hid_device_io_stop(). These
functions lock and unlock, respectively, driver_input_lock; they also
make a note of whether they did so that hid-core knows if a driver has
changed the lock state.
This patch results in no behavior change for existing devices and
drivers. However, during a probe() or remove() function call in a
driver, that driver may now selectively call hid_device_io_start() to
let input events come through, then optionally call
hid_device_io_stop() to stop them.
Signed-off-by: Andrew de los Reyes <adlr@chromium.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-02-18 10:20:21 -07:00
|
|
|
if (!hdev->io_started)
|
|
|
|
up(&hdev->driver_input_lock);
|
|
|
|
unlock_driver_lock:
|
2011-08-10 06:02:07 -06:00
|
|
|
up(&hdev->driver_lock);
|
2008-05-16 03:49:15 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hid_device_remove(struct device *dev)
|
|
|
|
{
|
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
2011-08-10 06:02:07 -06:00
|
|
|
struct hid_driver *hdrv;
|
HID: Separate struct hid_device's driver_lock into two locks.
This patch separates struct hid_device's driver_lock into two. The
goal is to allow hid device drivers to receive input during their
probe() or remove() function calls. This is necessary because some
drivers need to communicate with the device to determine parameters
needed during probe (e.g., size of a multi-touch surface), and if
possible, may perfer to communicate with a device on host-initiated
disconnect (e.g., to put it into a low-power state).
Historically, three functions used driver_lock:
- hid_device_probe: blocks to acquire lock
- hid_device_remove: blocks to acquire lock
- hid_input_report: if locked returns -EBUSY, else acquires lock
This patch adds another lock (driver_input_lock) which is used to
block input from occurring. The lock behavior is now:
- hid_device_probe: blocks to acq. driver_lock, then driver_input_lock
- hid_device_remove: blocks to acq. driver_lock, then driver_input_lock
- hid_input_report: if driver_input_lock locked returns -EBUSY, else
acquires driver_input_lock
This patch also adds two helper functions to be called during probe()
or remove(): hid_device_io_start() and hid_device_io_stop(). These
functions lock and unlock, respectively, driver_input_lock; they also
make a note of whether they did so that hid-core knows if a driver has
changed the lock state.
This patch results in no behavior change for existing devices and
drivers. However, during a probe() or remove() function call in a
driver, that driver may now selectively call hid_device_io_start() to
let input events come through, then optionally call
hid_device_io_stop() to stop them.
Signed-off-by: Andrew de los Reyes <adlr@chromium.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-02-18 10:20:21 -07:00
|
|
|
int ret = 0;
|
2011-08-10 06:02:07 -06:00
|
|
|
|
|
|
|
if (down_interruptible(&hdev->driver_lock))
|
|
|
|
return -EINTR;
|
HID: Separate struct hid_device's driver_lock into two locks.
This patch separates struct hid_device's driver_lock into two. The
goal is to allow hid device drivers to receive input during their
probe() or remove() function calls. This is necessary because some
drivers need to communicate with the device to determine parameters
needed during probe (e.g., size of a multi-touch surface), and if
possible, may perfer to communicate with a device on host-initiated
disconnect (e.g., to put it into a low-power state).
Historically, three functions used driver_lock:
- hid_device_probe: blocks to acquire lock
- hid_device_remove: blocks to acquire lock
- hid_input_report: if locked returns -EBUSY, else acquires lock
This patch adds another lock (driver_input_lock) which is used to
block input from occurring. The lock behavior is now:
- hid_device_probe: blocks to acq. driver_lock, then driver_input_lock
- hid_device_remove: blocks to acq. driver_lock, then driver_input_lock
- hid_input_report: if driver_input_lock locked returns -EBUSY, else
acquires driver_input_lock
This patch also adds two helper functions to be called during probe()
or remove(): hid_device_io_start() and hid_device_io_stop(). These
functions lock and unlock, respectively, driver_input_lock; they also
make a note of whether they did so that hid-core knows if a driver has
changed the lock state.
This patch results in no behavior change for existing devices and
drivers. However, during a probe() or remove() function call in a
driver, that driver may now selectively call hid_device_io_start() to
let input events come through, then optionally call
hid_device_io_stop() to stop them.
Signed-off-by: Andrew de los Reyes <adlr@chromium.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-02-18 10:20:21 -07:00
|
|
|
if (down_interruptible(&hdev->driver_input_lock)) {
|
|
|
|
ret = -EINTR;
|
|
|
|
goto unlock_driver_lock;
|
|
|
|
}
|
|
|
|
hdev->io_started = false;
|
2008-05-16 03:49:15 -06:00
|
|
|
|
2011-08-10 06:02:07 -06:00
|
|
|
hdrv = hdev->driver;
|
2008-05-16 03:49:15 -06:00
|
|
|
if (hdrv) {
|
|
|
|
if (hdrv->remove)
|
|
|
|
hdrv->remove(hdev);
|
2008-05-16 03:49:16 -06:00
|
|
|
else /* default remove */
|
|
|
|
hid_hw_stop(hdev);
|
2012-04-22 06:21:40 -06:00
|
|
|
hid_close_report(hdev);
|
2008-05-16 03:49:15 -06:00
|
|
|
hdev->driver = NULL;
|
|
|
|
}
|
|
|
|
|
HID: Separate struct hid_device's driver_lock into two locks.
This patch separates struct hid_device's driver_lock into two. The
goal is to allow hid device drivers to receive input during their
probe() or remove() function calls. This is necessary because some
drivers need to communicate with the device to determine parameters
needed during probe (e.g., size of a multi-touch surface), and if
possible, may perfer to communicate with a device on host-initiated
disconnect (e.g., to put it into a low-power state).
Historically, three functions used driver_lock:
- hid_device_probe: blocks to acquire lock
- hid_device_remove: blocks to acquire lock
- hid_input_report: if locked returns -EBUSY, else acquires lock
This patch adds another lock (driver_input_lock) which is used to
block input from occurring. The lock behavior is now:
- hid_device_probe: blocks to acq. driver_lock, then driver_input_lock
- hid_device_remove: blocks to acq. driver_lock, then driver_input_lock
- hid_input_report: if driver_input_lock locked returns -EBUSY, else
acquires driver_input_lock
This patch also adds two helper functions to be called during probe()
or remove(): hid_device_io_start() and hid_device_io_stop(). These
functions lock and unlock, respectively, driver_input_lock; they also
make a note of whether they did so that hid-core knows if a driver has
changed the lock state.
This patch results in no behavior change for existing devices and
drivers. However, during a probe() or remove() function call in a
driver, that driver may now selectively call hid_device_io_start() to
let input events come through, then optionally call
hid_device_io_stop() to stop them.
Signed-off-by: Andrew de los Reyes <adlr@chromium.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-02-18 10:20:21 -07:00
|
|
|
if (!hdev->io_started)
|
|
|
|
up(&hdev->driver_input_lock);
|
|
|
|
unlock_driver_lock:
|
2011-08-10 06:02:07 -06:00
|
|
|
up(&hdev->driver_lock);
|
HID: Separate struct hid_device's driver_lock into two locks.
This patch separates struct hid_device's driver_lock into two. The
goal is to allow hid device drivers to receive input during their
probe() or remove() function calls. This is necessary because some
drivers need to communicate with the device to determine parameters
needed during probe (e.g., size of a multi-touch surface), and if
possible, may perfer to communicate with a device on host-initiated
disconnect (e.g., to put it into a low-power state).
Historically, three functions used driver_lock:
- hid_device_probe: blocks to acquire lock
- hid_device_remove: blocks to acquire lock
- hid_input_report: if locked returns -EBUSY, else acquires lock
This patch adds another lock (driver_input_lock) which is used to
block input from occurring. The lock behavior is now:
- hid_device_probe: blocks to acq. driver_lock, then driver_input_lock
- hid_device_remove: blocks to acq. driver_lock, then driver_input_lock
- hid_input_report: if driver_input_lock locked returns -EBUSY, else
acquires driver_input_lock
This patch also adds two helper functions to be called during probe()
or remove(): hid_device_io_start() and hid_device_io_stop(). These
functions lock and unlock, respectively, driver_input_lock; they also
make a note of whether they did so that hid-core knows if a driver has
changed the lock state.
This patch results in no behavior change for existing devices and
drivers. However, during a probe() or remove() function call in a
driver, that driver may now selectively call hid_device_io_start() to
let input events come through, then optionally call
hid_device_io_stop() to stop them.
Signed-off-by: Andrew de los Reyes <adlr@chromium.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-02-18 10:20:21 -07:00
|
|
|
return ret;
|
2008-05-16 03:49:15 -06:00
|
|
|
}
|
|
|
|
|
2012-04-23 04:07:02 -06:00
|
|
|
static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
|
|
|
int len;
|
|
|
|
|
|
|
|
len = snprintf(buf, PAGE_SIZE, "hid:b%04Xg%04Xv%08Xp%08X\n",
|
|
|
|
hdev->bus, hdev->group, hdev->vendor, hdev->product);
|
|
|
|
|
|
|
|
return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
|
|
|
|
}
|
2013-08-23 15:24:38 -06:00
|
|
|
static DEVICE_ATTR_RO(modalias);
|
2012-04-23 04:07:02 -06:00
|
|
|
|
2013-08-23 15:24:38 -06:00
|
|
|
static struct attribute *hid_dev_attrs[] = {
|
|
|
|
&dev_attr_modalias.attr,
|
|
|
|
NULL,
|
2012-04-23 04:07:02 -06:00
|
|
|
};
|
2013-08-23 15:24:38 -06:00
|
|
|
ATTRIBUTE_GROUPS(hid_dev);
|
2012-04-23 04:07:02 -06:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
static int hid_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
|
|
{
|
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
|
|
|
|
|
|
|
if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X",
|
|
|
|
hdev->bus, hdev->vendor, hdev->product))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (add_uevent_var(env, "HID_NAME=%s", hdev->name))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2012-04-23 04:07:02 -06:00
|
|
|
if (add_uevent_var(env, "MODALIAS=hid:b%04Xg%04Xv%08Xp%08X",
|
|
|
|
hdev->bus, hdev->group, hdev->vendor, hdev->product))
|
2008-05-16 03:49:15 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct bus_type hid_bus_type = {
|
|
|
|
.name = "hid",
|
2013-08-23 15:24:38 -06:00
|
|
|
.dev_groups = hid_dev_groups,
|
2008-05-16 03:49:15 -06:00
|
|
|
.match = hid_bus_match,
|
|
|
|
.probe = hid_device_probe,
|
|
|
|
.remove = hid_device_remove,
|
|
|
|
.uevent = hid_uevent,
|
|
|
|
};
|
|
|
|
|
2009-01-28 15:06:37 -07:00
|
|
|
/* a list of devices that shouldn't be handled by HID core at all */
|
2008-05-16 03:49:20 -06:00
|
|
|
static const struct hid_device_id hid_ignore_list[] = {
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_FLAIR) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_302) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ADS_TECH, USB_DEVICE_ID_ADS_TECH_RADIO_SI470X) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_01) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_10) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_20) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_21) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_22) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_23) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_AIRCABLE, USB_DEVICE_ID_AIRCABLE1) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ALCOR, USB_DEVICE_ID_ALCOR_USBRS232) },
|
2010-02-06 07:17:13 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM)},
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM2)},
|
2008-11-12 19:44:50 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_AVERMEDIA, USB_DEVICE_ID_AVER_FM_MR800) },
|
2012-05-15 02:12:44 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_AXENTIA, USB_DEVICE_ID_AXENTIA_FM_RADIO) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CIDC, 0x0103) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI470X) },
|
2013-10-15 09:24:41 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI4713) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM109) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE) },
|
2008-12-08 04:40:14 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) },
|
USB: add support for Dream Cheeky DL100B Webmail Notifier (1d34:0004)
So far the USBLED driver only supports Delcom's "USB Visual Signal
Indicator" (http://www.delcomproducts.com/products_USBLMP.asp). The
driver generates virtual files "red", "green", and "blue" under the
device's /sys/ directory, where color values can be read from and
written to.
This patch adds support for Dream Cheeky's "DL100B Webmail Notifier"
(http://www.dreamcheeky.com/webmail-notifier -- available from several
shops, such as http://www.conrad.at/ce/de/product/777048/USB-WEBMAIL).
This device isn't as pretty as Delcom's, but it's *far* cheaper, and
its 3 LEDs can be set in 32 brightness steps each. The grey envelope
contour can easily be removed, leaving a rather neutral white box (with
a few small holes), which is useful for generic signalling purposes.
Of course, the small circuit board can easily be put into a prettier
case.
The DL100B device pretends to be a HID, but the HID descriptor shows
that it's not overly useful as such (see below). The patch therefore
removes the "HID-ness" (hid-core.c, hid-ids.h), and adds the necessary
commands to usbled.c. The protocol info comes from the developer's
manual that Dream Cheeky kindly provided (815DeveloperManual.pdf).
HID descriptor:
0: 05 01 Usage Page 'Generic Desktop Controls'
2: 09 10 Usage 'Reserved'
4: a1 01 Collection 'Application (mouse, keyboard)'
6: 05 00 Usage Page 'Undefined'
8: 19 10 Usage Minimum = 16
10: 29 11 Usage Maximum = 17
12: 15 00 Logical Minimum = 0
14: 25 0f Logical Maximum = 15
16: 75 08 Report Size = 8
18: 95 08 Report Count = 8
20: 91 02 Output data *var abs lin pref-state null-pos non-vol bit-field
22: 19 10 Usage Minimum = 16
24: 29 11 Usage Maximum = 17
26: 15 00 Logical Minimum = 0
28: 25 0f Logical Maximum = 15
30: 75 08 Report Size = 8
32: 95 08 Report Count = 8
34: 81 00 Input data array abs lin pref-state null-pos non-vol bit-field
36: c0 End Collection
Signed-off-by: Melchior FRANZ <mfranz@aon.at>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2010-12-21 18:04:33 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x0004) },
|
2011-11-20 02:21:30 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, 0x000a) },
|
2015-07-20 10:56:18 -06:00
|
|
|
{ HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, 0x0400) },
|
2015-08-24 11:49:29 -06:00
|
|
|
{ HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, 0x0401) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
|
2009-12-09 14:09:53 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) },
|
2010-06-28 10:38:54 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) },
|
2011-11-16 03:39:52 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0001) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0002) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0004) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_SUPER_Q2) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_GOGOPEN) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_PENPOWER) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GRETAGMACBETH, USB_DEVICE_ID_GRETAGMACBETH_HUEY) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB) },
|
2012-05-21 12:24:50 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_RADIOSHARK) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_90) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_100) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_101) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_103) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_104) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_105) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_106) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_107) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_108) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_200) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_201) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_202) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_203) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_204) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_205) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_206) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_207) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_300) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_301) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_302) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_303) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_304) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_305) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_306) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_307) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_308) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_309) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_400) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_401) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_402) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_403) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_405) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_500) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_501) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1003) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1007) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA) },
|
2013-05-22 15:39:50 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_SPEAK_410) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_SPEAK_510) },
|
2014-07-05 00:58:06 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_GN9350E) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO) },
|
2008-11-13 02:36:11 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KWORLD, USB_DEVICE_ID_KWORLD_RADIO_FM700) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },
|
2009-10-02 07:04:44 -06:00
|
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_KYE, 0x0058) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
|
2011-05-03 11:12:00 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY2) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
|
2011-05-03 11:12:00 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY2) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
|
2011-05-03 11:12:00 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY2) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYVOLTAGE) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYCURRENT) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTIME) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYPH) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP) },
|
2011-05-03 11:12:00 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIC) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIB) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },
|
2011-05-03 11:12:00 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOTOR) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST) },
|
2011-05-03 11:12:00 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER2) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_ABSESP) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_AUTODATABUS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },
|
2012-07-11 01:49:18 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_BEATPAD) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT2) },
|
2015-01-20 09:55:03 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICK16F1454) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR, USB_DEVICE_ID_N_S_HARMONY) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 20) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 30) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 100) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 108) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 118) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 200) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0001) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0002) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0003) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0004) },
|
2009-08-02 14:18:12 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_PHILIPS, USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE) },
|
2009-02-01 08:11:04 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_POWERCOM, USB_DEVICE_ID_POWERCOM_UPS) },
|
2012-02-03 01:21:31 -07:00
|
|
|
#if defined(CONFIG_MOUSE_SYNAPTICS_USB) || defined(CONFIG_MOUSE_SYNAPTICS_USB_MODULE)
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_INT_TP) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_CPAD) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_STICK) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WP) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_COMP_TP) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WTP) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DPAD) },
|
|
|
|
#endif
|
2008-05-16 03:49:20 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K) },
|
2014-02-12 12:56:00 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_RISO_KAGAKU, USB_DEVICE_ID_RI_KA_WEBMAIL) },
|
2008-05-16 03:49:20 -06:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2008-10-22 06:47:18 -06:00
|
|
|
/**
|
|
|
|
* hid_mouse_ignore_list - mouse devices which should not be handled by the hid layer
|
|
|
|
*
|
|
|
|
* There are composite devices for which we want to ignore only a certain
|
|
|
|
* interface. This is a list of devices for which only the mouse interface will
|
|
|
|
* be ignored. This allows a dedicated driver to take care of the interface.
|
|
|
|
*/
|
|
|
|
static const struct hid_device_id hid_mouse_ignore_list[] = {
|
|
|
|
/* appletouch driver */
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },
|
2008-11-20 03:27:02 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },
|
2010-11-03 08:36:18 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },
|
2011-03-12 21:27:22 -07:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
|
2011-10-22 13:39:06 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },
|
2011-10-04 06:01:12 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
|
2012-07-10 10:43:33 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
|
2012-10-30 12:11:48 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS) },
|
2013-07-01 12:46:27 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_JIS) },
|
2015-07-24 15:45:05 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ANSI) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ISO) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_JIS) },
|
2008-10-22 06:47:18 -06:00
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
|
|
|
|
{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2012-12-06 07:39:55 -07:00
|
|
|
bool hid_ignore(struct hid_device *hdev)
|
2008-05-16 03:49:20 -06:00
|
|
|
{
|
2012-12-06 07:39:55 -07:00
|
|
|
if (hdev->quirks & HID_QUIRK_NO_IGNORE)
|
|
|
|
return false;
|
|
|
|
if (hdev->quirks & HID_QUIRK_IGNORE)
|
|
|
|
return true;
|
|
|
|
|
2008-05-16 03:49:20 -06:00
|
|
|
switch (hdev->vendor) {
|
|
|
|
case USB_VENDOR_ID_CODEMERCS:
|
|
|
|
/* ignore all Code Mercenaries IOWarrior devices */
|
|
|
|
if (hdev->product >= USB_DEVICE_ID_CODEMERCS_IOW_FIRST &&
|
|
|
|
hdev->product <= USB_DEVICE_ID_CODEMERCS_IOW_LAST)
|
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
case USB_VENDOR_ID_LOGITECH:
|
|
|
|
if (hdev->product >= USB_DEVICE_ID_LOGITECH_HARMONY_FIRST &&
|
|
|
|
hdev->product <= USB_DEVICE_ID_LOGITECH_HARMONY_LAST)
|
|
|
|
return true;
|
2012-01-13 07:15:22 -07:00
|
|
|
/*
|
|
|
|
* The Keene FM transmitter USB device has the same USB ID as
|
|
|
|
* the Logitech AudioHub Speaker, but it should ignore the hid.
|
|
|
|
* Check if the name is that of the Keene device.
|
|
|
|
* For reference: the name of the AudioHub is
|
|
|
|
* "HOLTEK AudioHub Speaker".
|
|
|
|
*/
|
|
|
|
if (hdev->product == USB_DEVICE_ID_LOGITECH_AUDIOHUB &&
|
|
|
|
!strcmp(hdev->name, "HOLTEK B-LINK USB Audio "))
|
|
|
|
return true;
|
2008-05-16 03:49:20 -06:00
|
|
|
break;
|
2009-07-31 08:56:36 -06:00
|
|
|
case USB_VENDOR_ID_SOUNDGRAPH:
|
|
|
|
if (hdev->product >= USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST &&
|
|
|
|
hdev->product <= USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST)
|
|
|
|
return true;
|
|
|
|
break;
|
2010-09-02 00:25:35 -06:00
|
|
|
case USB_VENDOR_ID_HANWANG:
|
|
|
|
if (hdev->product >= USB_DEVICE_ID_HANWANG_TABLET_FIRST &&
|
|
|
|
hdev->product <= USB_DEVICE_ID_HANWANG_TABLET_LAST)
|
|
|
|
return true;
|
|
|
|
break;
|
2011-05-23 16:45:44 -06:00
|
|
|
case USB_VENDOR_ID_JESS:
|
|
|
|
if (hdev->product == USB_DEVICE_ID_JESS_YUREX &&
|
|
|
|
hdev->type == HID_TYPE_USBNONE)
|
|
|
|
return true;
|
2012-11-06 11:41:22 -07:00
|
|
|
break;
|
2013-02-13 06:22:45 -07:00
|
|
|
case USB_VENDOR_ID_VELLEMAN:
|
|
|
|
/* These are not HID devices. They are handled by comedi. */
|
|
|
|
if ((hdev->product >= USB_DEVICE_ID_VELLEMAN_K8055_FIRST &&
|
|
|
|
hdev->product <= USB_DEVICE_ID_VELLEMAN_K8055_LAST) ||
|
|
|
|
(hdev->product >= USB_DEVICE_ID_VELLEMAN_K8061_FIRST &&
|
|
|
|
hdev->product <= USB_DEVICE_ID_VELLEMAN_K8061_LAST))
|
|
|
|
return true;
|
|
|
|
break;
|
2013-03-27 14:07:29 -06:00
|
|
|
case USB_VENDOR_ID_ATMEL_V_USB:
|
|
|
|
/* Masterkit MA901 usb radio based on Atmel tiny85 chip and
|
|
|
|
* it has the same USB ID as many Atmel V-USB devices. This
|
|
|
|
* usb radio is handled by radio-ma901.c driver so we want
|
|
|
|
* ignore the hid. Check the name, bus, product and ignore
|
|
|
|
* if we have MA901 usb radio.
|
|
|
|
*/
|
|
|
|
if (hdev->product == USB_DEVICE_ID_ATMEL_V_USB &&
|
|
|
|
hdev->bus == BUS_USB &&
|
|
|
|
strncmp(hdev->name, "www.masterkit.ru MA901", 22) == 0)
|
|
|
|
return true;
|
|
|
|
break;
|
2008-05-16 03:49:20 -06:00
|
|
|
}
|
|
|
|
|
2008-10-22 06:47:18 -06:00
|
|
|
if (hdev->type == HID_TYPE_USBMOUSE &&
|
|
|
|
hid_match_id(hdev, hid_mouse_ignore_list))
|
|
|
|
return true;
|
|
|
|
|
2008-05-16 03:49:20 -06:00
|
|
|
return !!hid_match_id(hdev, hid_ignore_list);
|
|
|
|
}
|
2012-12-06 07:39:55 -07:00
|
|
|
EXPORT_SYMBOL_GPL(hid_ignore);
|
2008-05-16 03:49:20 -06:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
int hid_add_device(struct hid_device *hdev)
|
|
|
|
{
|
|
|
|
static atomic_t id = ATOMIC_INIT(0);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (WARN_ON(hdev->status & HID_STAT_ADDED))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2008-05-16 03:49:20 -06:00
|
|
|
/* we need to kill them here, otherwise they will stay allocated to
|
|
|
|
* wait for coming driver */
|
2012-12-06 07:39:55 -07:00
|
|
|
if (hid_ignore(hdev))
|
2008-05-16 03:49:20 -06:00
|
|
|
return -ENODEV;
|
|
|
|
|
2014-02-20 13:24:49 -07:00
|
|
|
/*
|
|
|
|
* Check for the mandatory transport channel.
|
|
|
|
*/
|
|
|
|
if (!hdev->ll_driver->raw_request) {
|
|
|
|
hid_err(hdev, "transport driver missing .raw_request()\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-04-22 06:21:40 -06:00
|
|
|
/*
|
|
|
|
* Read the device report descriptor once and use as template
|
|
|
|
* for the driver-specific modifications.
|
|
|
|
*/
|
|
|
|
ret = hdev->ll_driver->parse(hdev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (!hdev->dev_rdesc)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2012-04-23 04:07:03 -06:00
|
|
|
/*
|
|
|
|
* Scan generic devices for group information
|
|
|
|
*/
|
|
|
|
if (hid_ignore_special_drivers ||
|
2014-09-30 11:18:24 -06:00
|
|
|
(!hdev->group &&
|
|
|
|
!hid_match_id(hdev, hid_have_special_driver))) {
|
2012-04-23 04:07:03 -06:00
|
|
|
ret = hid_scan_report(hdev);
|
|
|
|
if (ret)
|
|
|
|
hid_warn(hdev, "bad device descriptor (%d)\n", ret);
|
|
|
|
}
|
|
|
|
|
HID: struct device - replace bus_id with dev_name(), dev_set_name()
This patch is part of a larger patch series which will remove
the "char bus_id[20]" name string from struct device. The device
name is managed in the kobject anyway, and without any size
limitation, and just needlessly copied into "struct device".
To set and read the device name dev_name(dev) and dev_set_name(dev)
must be used. If your code uses static kobjects, which it shouldn't
do, "const char *init_name" can be used to statically provide the
name the registered device should have. At registration time, the
init_name field is cleared, to enforce the use of dev_name(dev) to
access the device name at a later time.
We need to get rid of all occurrences of bus_id in the entire tree
to be able to enable the new interface. Please apply this patch,
and possibly convert any remaining remaining occurrences of bus_id.
We want to submit a patch to -next, which will remove bus_id from
"struct device", to find the remaining pieces to convert, and finally
switch over to the new api, which will remove the 20 bytes array
and does no longer have a size limitation.
CC: Jiri Kosina <jkosina@suse.cz>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2008-10-30 17:12:32 -06:00
|
|
|
/* XXX hack, any other cleaner solution after the driver core
|
|
|
|
* is converted to allow more than 20 bytes as the device name? */
|
|
|
|
dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,
|
|
|
|
hdev->vendor, hdev->product, atomic_inc_return(&id));
|
2008-05-16 03:49:15 -06:00
|
|
|
|
2010-03-15 07:55:40 -06:00
|
|
|
hid_debug_register(hdev, dev_name(&hdev->dev));
|
2008-05-16 03:49:15 -06:00
|
|
|
ret = device_add(&hdev->dev);
|
|
|
|
if (!ret)
|
|
|
|
hdev->status |= HID_STAT_ADDED;
|
2010-03-15 07:55:40 -06:00
|
|
|
else
|
|
|
|
hid_debug_unregister(hdev);
|
2009-06-12 07:20:55 -06:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_add_device);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* hid_allocate_device - allocate new hid device descriptor
|
|
|
|
*
|
|
|
|
* Allocate and initialize hid device, so that hid_destroy_device might be
|
|
|
|
* used to free it.
|
|
|
|
*
|
|
|
|
* New hid_device pointer is returned on success, otherwise ERR_PTR encoded
|
|
|
|
* error value.
|
|
|
|
*/
|
|
|
|
struct hid_device *hid_allocate_device(void)
|
|
|
|
{
|
|
|
|
struct hid_device *hdev;
|
|
|
|
int ret = -ENOMEM;
|
|
|
|
|
|
|
|
hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
|
|
|
|
if (hdev == NULL)
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
|
|
|
|
device_initialize(&hdev->dev);
|
|
|
|
hdev->dev.release = hid_device_release;
|
|
|
|
hdev->dev.bus = &hid_bus_type;
|
|
|
|
|
2012-04-22 06:21:40 -06:00
|
|
|
hid_close_report(hdev);
|
2008-05-16 03:49:15 -06:00
|
|
|
|
2009-06-12 07:20:57 -06:00
|
|
|
init_waitqueue_head(&hdev->debug_wait);
|
|
|
|
INIT_LIST_HEAD(&hdev->debug_list);
|
HID: debug: fix RCU preemption issue
Commit 2353f2bea ("HID: protect hid_debug_list") introduced mutex
locking around debug_list access to prevent SMP races when debugfs
nodes are being operated upon by multiple userspace processess.
mutex is not a proper synchronization primitive though, as the hid-debug
callbacks are being called from atomic contexts.
We also have to be careful about disabling IRQs when taking the lock
to prevent deadlock against IRQ handlers.
Benjamin reports this has also been reported in RH bugzilla as bug #958935.
===============================
[ INFO: suspicious RCU usage. ]
3.9.0+ #94 Not tainted
-------------------------------
include/linux/rcupdate.h:476 Illegal context switch in RCU read-side critical section!
other info that might help us debug this:
rcu_scheduler_active = 1, debug_locks = 0
4 locks held by Xorg/5502:
#0: (&evdev->mutex){+.+...}, at: [<ffffffff81512c3d>] evdev_write+0x6d/0x160
#1: (&(&dev->event_lock)->rlock#2){-.-...}, at: [<ffffffff8150dd9b>] input_inject_event+0x5b/0x230
#2: (rcu_read_lock){.+.+..}, at: [<ffffffff8150dd82>] input_inject_event+0x42/0x230
#3: (&(&usbhid->lock)->rlock){-.....}, at: [<ffffffff81565289>] usb_hidinput_input_event+0x89/0x120
stack backtrace:
CPU: 0 PID: 5502 Comm: Xorg Not tainted 3.9.0+ #94
Hardware name: Dell Inc. OptiPlex 390/0M5DCD, BIOS A09 07/24/2012
0000000000000001 ffff8800689c7c38 ffffffff816f249f ffff8800689c7c68
ffffffff810acb1d 0000000000000000 ffffffff81a03ac7 000000000000019d
0000000000000000 ffff8800689c7c90 ffffffff8107cda7 0000000000000000
Call Trace:
[<ffffffff816f249f>] dump_stack+0x19/0x1b
[<ffffffff810acb1d>] lockdep_rcu_suspicious+0xfd/0x130
[<ffffffff8107cda7>] __might_sleep+0xc7/0x230
[<ffffffff816f7770>] mutex_lock_nested+0x40/0x3a0
[<ffffffff81312ac4>] ? vsnprintf+0x354/0x640
[<ffffffff81553cc4>] hid_debug_event+0x34/0x100
[<ffffffff81554197>] hid_dump_input+0x67/0xa0
[<ffffffff81556430>] hid_set_field+0x50/0x120
[<ffffffff8156529a>] usb_hidinput_input_event+0x9a/0x120
[<ffffffff8150d89e>] input_handle_event+0x8e/0x530
[<ffffffff8150df10>] input_inject_event+0x1d0/0x230
[<ffffffff8150dd82>] ? input_inject_event+0x42/0x230
[<ffffffff81512cae>] evdev_write+0xde/0x160
[<ffffffff81185038>] vfs_write+0xc8/0x1f0
[<ffffffff81185535>] SyS_write+0x55/0xa0
[<ffffffff81704482>] system_call_fastpath+0x16/0x1b
BUG: sleeping function called from invalid context at kernel/mutex.c:413
in_atomic(): 1, irqs_disabled(): 1, pid: 5502, name: Xorg
INFO: lockdep is turned off.
irq event stamp: 1098574
hardirqs last enabled at (1098573): [<ffffffff816fb53f>] _raw_spin_unlock_irqrestore+0x3f/0x70
hardirqs last disabled at (1098574): [<ffffffff816faaf5>] _raw_spin_lock_irqsave+0x25/0xa0
softirqs last enabled at (1098306): [<ffffffff8104971f>] __do_softirq+0x18f/0x3c0
softirqs last disabled at (1097867): [<ffffffff81049ad5>] irq_exit+0xa5/0xb0
CPU: 0 PID: 5502 Comm: Xorg Not tainted 3.9.0+ #94
Hardware name: Dell Inc. OptiPlex 390/0M5DCD, BIOS A09 07/24/2012
ffffffff81a03ac7 ffff8800689c7c68 ffffffff816f249f ffff8800689c7c90
ffffffff8107ce60 0000000000000000 ffff8800689c7fd8 ffff88006a62c800
ffff8800689c7d10 ffffffff816f7770 ffff8800689c7d00 ffffffff81312ac4
Call Trace:
[<ffffffff816f249f>] dump_stack+0x19/0x1b
[<ffffffff8107ce60>] __might_sleep+0x180/0x230
[<ffffffff816f7770>] mutex_lock_nested+0x40/0x3a0
[<ffffffff81312ac4>] ? vsnprintf+0x354/0x640
[<ffffffff81553cc4>] hid_debug_event+0x34/0x100
[<ffffffff81554197>] hid_dump_input+0x67/0xa0
[<ffffffff81556430>] hid_set_field+0x50/0x120
[<ffffffff8156529a>] usb_hidinput_input_event+0x9a/0x120
[<ffffffff8150d89e>] input_handle_event+0x8e/0x530
[<ffffffff8150df10>] input_inject_event+0x1d0/0x230
[<ffffffff8150dd82>] ? input_inject_event+0x42/0x230
[<ffffffff81512cae>] evdev_write+0xde/0x160
[<ffffffff81185038>] vfs_write+0xc8/0x1f0
[<ffffffff81185535>] SyS_write+0x55/0xa0
[<ffffffff81704482>] system_call_fastpath+0x16/0x1b
Reported-by: majianpeng <majianpeng@gmail.com>
Reported-by: Benjamin Tissoires <benjamin.tissoires@gmail.com>
Reviewed-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-05-06 05:05:50 -06:00
|
|
|
spin_lock_init(&hdev->debug_list_lock);
|
2011-08-10 06:02:07 -06:00
|
|
|
sema_init(&hdev->driver_lock, 1);
|
HID: Separate struct hid_device's driver_lock into two locks.
This patch separates struct hid_device's driver_lock into two. The
goal is to allow hid device drivers to receive input during their
probe() or remove() function calls. This is necessary because some
drivers need to communicate with the device to determine parameters
needed during probe (e.g., size of a multi-touch surface), and if
possible, may perfer to communicate with a device on host-initiated
disconnect (e.g., to put it into a low-power state).
Historically, three functions used driver_lock:
- hid_device_probe: blocks to acquire lock
- hid_device_remove: blocks to acquire lock
- hid_input_report: if locked returns -EBUSY, else acquires lock
This patch adds another lock (driver_input_lock) which is used to
block input from occurring. The lock behavior is now:
- hid_device_probe: blocks to acq. driver_lock, then driver_input_lock
- hid_device_remove: blocks to acq. driver_lock, then driver_input_lock
- hid_input_report: if driver_input_lock locked returns -EBUSY, else
acquires driver_input_lock
This patch also adds two helper functions to be called during probe()
or remove(): hid_device_io_start() and hid_device_io_stop(). These
functions lock and unlock, respectively, driver_input_lock; they also
make a note of whether they did so that hid-core knows if a driver has
changed the lock state.
This patch results in no behavior change for existing devices and
drivers. However, during a probe() or remove() function call in a
driver, that driver may now selectively call hid_device_io_start() to
let input events come through, then optionally call
hid_device_io_stop() to stop them.
Signed-off-by: Andrew de los Reyes <adlr@chromium.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2013-02-18 10:20:21 -07:00
|
|
|
sema_init(&hdev->driver_input_lock, 1);
|
2009-06-12 07:20:57 -06:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
return hdev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_allocate_device);
|
|
|
|
|
|
|
|
static void hid_remove_device(struct hid_device *hdev)
|
|
|
|
{
|
|
|
|
if (hdev->status & HID_STAT_ADDED) {
|
|
|
|
device_del(&hdev->dev);
|
2009-06-12 07:20:55 -06:00
|
|
|
hid_debug_unregister(hdev);
|
2008-05-16 03:49:15 -06:00
|
|
|
hdev->status &= ~HID_STAT_ADDED;
|
|
|
|
}
|
2012-04-22 06:21:40 -06:00
|
|
|
kfree(hdev->dev_rdesc);
|
|
|
|
hdev->dev_rdesc = NULL;
|
|
|
|
hdev->dev_rsize = 0;
|
2008-05-16 03:49:15 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* hid_destroy_device - free previously allocated device
|
|
|
|
*
|
|
|
|
* @hdev: hid device
|
|
|
|
*
|
|
|
|
* If you allocate hid_device through hid_allocate_device, you should ever
|
|
|
|
* free by this function.
|
|
|
|
*/
|
|
|
|
void hid_destroy_device(struct hid_device *hdev)
|
|
|
|
{
|
|
|
|
hid_remove_device(hdev);
|
|
|
|
put_device(&hdev->dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_destroy_device);
|
|
|
|
|
|
|
|
int __hid_register_driver(struct hid_driver *hdrv, struct module *owner,
|
|
|
|
const char *mod_name)
|
|
|
|
{
|
2008-11-24 08:20:09 -07:00
|
|
|
int ret;
|
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
hdrv->driver.name = hdrv->name;
|
|
|
|
hdrv->driver.bus = &hid_bus_type;
|
|
|
|
hdrv->driver.owner = owner;
|
|
|
|
hdrv->driver.mod_name = mod_name;
|
|
|
|
|
2008-11-24 08:20:09 -07:00
|
|
|
INIT_LIST_HEAD(&hdrv->dyn_list);
|
|
|
|
spin_lock_init(&hdrv->dyn_lock);
|
|
|
|
|
|
|
|
ret = driver_register(&hdrv->driver);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = driver_create_file(&hdrv->driver, &driver_attr_new_id);
|
|
|
|
if (ret)
|
|
|
|
driver_unregister(&hdrv->driver);
|
|
|
|
|
|
|
|
return ret;
|
2008-05-16 03:49:15 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__hid_register_driver);
|
|
|
|
|
|
|
|
void hid_unregister_driver(struct hid_driver *hdrv)
|
|
|
|
{
|
2008-11-24 08:20:09 -07:00
|
|
|
driver_remove_file(&hdrv->driver, &driver_attr_new_id);
|
2008-05-16 03:49:15 -06:00
|
|
|
driver_unregister(&hdrv->driver);
|
2008-11-24 08:20:09 -07:00
|
|
|
hid_free_dynids(hdrv);
|
2008-05-16 03:49:15 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hid_unregister_driver);
|
|
|
|
|
2008-12-17 07:38:03 -07:00
|
|
|
int hid_check_keys_pressed(struct hid_device *hid)
|
|
|
|
{
|
|
|
|
struct hid_input *hidinput;
|
|
|
|
int i;
|
|
|
|
|
2009-05-01 16:02:57 -06:00
|
|
|
if (!(hid->claimed & HID_CLAIMED_INPUT))
|
|
|
|
return 0;
|
|
|
|
|
2008-12-17 07:38:03 -07:00
|
|
|
list_for_each_entry(hidinput, &hid->inputs, list) {
|
|
|
|
for (i = 0; i < BITS_TO_LONGS(KEY_MAX); i++)
|
|
|
|
if (hidinput->input->key[i])
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(hid_check_keys_pressed);
|
|
|
|
|
2007-05-14 01:57:40 -06:00
|
|
|
static int __init hid_init(void)
|
|
|
|
{
|
2008-05-16 03:49:15 -06:00
|
|
|
int ret;
|
|
|
|
|
2009-06-12 07:20:55 -06:00
|
|
|
if (hid_debug)
|
2010-12-09 20:29:03 -07:00
|
|
|
pr_warn("hid_debug is now used solely for parser and driver debugging.\n"
|
|
|
|
"debugfs is now used for inspecting the device (report descriptor, reports)\n");
|
2009-06-12 07:20:55 -06:00
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
ret = bus_register(&hid_bus_type);
|
|
|
|
if (ret) {
|
2010-12-09 20:29:03 -07:00
|
|
|
pr_err("can't register hid bus\n");
|
2008-05-16 03:49:15 -06:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = hidraw_init();
|
|
|
|
if (ret)
|
|
|
|
goto err_bus;
|
|
|
|
|
2009-06-12 07:20:55 -06:00
|
|
|
hid_debug_init();
|
|
|
|
|
2008-05-16 03:49:15 -06:00
|
|
|
return 0;
|
|
|
|
err_bus:
|
|
|
|
bus_unregister(&hid_bus_type);
|
|
|
|
err:
|
|
|
|
return ret;
|
2007-05-14 01:57:40 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit hid_exit(void)
|
|
|
|
{
|
2009-06-12 07:20:55 -06:00
|
|
|
hid_debug_exit();
|
2007-05-14 01:57:40 -06:00
|
|
|
hidraw_exit();
|
2008-05-16 03:49:15 -06:00
|
|
|
bus_unregister(&hid_bus_type);
|
2007-05-14 01:57:40 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(hid_init);
|
|
|
|
module_exit(hid_exit);
|
|
|
|
|
2009-10-02 10:29:34 -06:00
|
|
|
MODULE_AUTHOR("Andreas Gal");
|
|
|
|
MODULE_AUTHOR("Vojtech Pavlik");
|
|
|
|
MODULE_AUTHOR("Jiri Kosina");
|
2006-12-08 10:41:10 -07:00
|
|
|
MODULE_LICENSE(DRIVER_LICENSE);
|
|
|
|
|