Eric Lee / smarc-fsl-linux-kernel

Commit 1f243e302cea1561ac881eb5d27041c5342beba4

Authored by Jiri Slaby 17 years ago

Committed by Jiri Kosina 17 years ago

Exists in master and in 39 other branches

HID: move ezkey quirks

Signed-off-by: Jiri Slaby <jirislaby@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>

Showing 8 changed files with 107 additions and 40 deletions Inline Diff

drivers/hid/Kconfig
drivers/hid/Makefile
drivers/hid/hid-core.c
drivers/hid/hid-dummy.c
drivers/hid/hid-ezkey.c
drivers/hid/hid-input-quirks.c
drivers/hid/usbhid/hid-quirks.c
include/linux/hid.h

drivers/hid/Kconfig

Diff comments View file @ 1f243e3

 #
 # HID driver configuration
 #
 menuconfig HID_SUPPORT
 	bool "HID Devices"
 	depends on INPUT
 	default y
 	---help---
 	  Say Y here to get to see options for various computer-human interface
 	  device drivers. This option alone does not add any kernel code.
 	  If you say N, all options in this submenu will be skipped and disabled.
 if HID_SUPPORT
 config HID
 	tristate "Generic HID support"
 	depends on INPUT
 	default y
 	---help---
 	  A human interface device (HID) is a type of computer device that
 	  interacts directly with and takes input from humans. The term "HID"
 	  most commonly used to refer to the USB-HID specification, but other
 	  devices (such as, but not strictly limited to, Bluetooth) are
 	  designed using HID specification (this involves certain keyboards,
 	  mice, tablets, etc). This option compiles into kernel the generic
 	  HID layer code (parser, usages, etc.), which can then be used by
 	  transport-specific HID implementation (like USB or Bluetooth).
 	  For docs and specs, see http://www.usb.org/developers/hidpage/
 	  If unsure, say Y
 config HID_DEBUG
 	bool "HID debugging support"
 	default y if !EMBEDDED
 	depends on HID
 	---help---
 	This option lets the HID layer output diagnostics about its internal
 	state, resolve HID usages, dump HID fields, etc. Individual HID drivers
 	use this debugging facility to output information about individual HID
 	devices, etc.
 	This feature is useful for those who are either debugging the HID parser
 	or any HID hardware device.
 	If unsure, say N
 config HIDRAW
 	bool "/dev/hidraw raw HID device support"
 	depends on HID
 	---help---
 	Say Y here if you want to support HID devices (from the USB
 	specification standpoint) that aren't strictly user interface
 	devices, like monitor controls and Uninterruptable Power Supplies.
 	This module supports these devices separately using a separate
 	event interface on /dev/hidraw.
 	There is also a /dev/hiddev configuration option in the USB HID
 	configuration menu. In comparison to hiddev, this device does not process
 	the hid events at all (no parsing, no lookups). This lets applications
 	to work on raw hid events when they want to, and avoid using transport-specific
 	userspace libhid/libusb libraries.
 	If unsure, say Y.
 source "drivers/hid/usbhid/Kconfig"
 menu "Special HID drivers"
 	depends on HID
 config HID_COMPAT
 	bool "Load all HID drivers on hid core load"
 	default y
 	---help---
 	Compatible option for older userspace. If you have system without udev
 	support of module loading through aliases and also old
 	module-init-tools which can't handle hid bus, choose Y here. Otherwise
 	say N. If you say N and your userspace is old enough, the only
 	functionality you loose is modules autoloading.
 	If unsure, say Y.
 config HID_A4TECH
 	tristate "A4 tech"
 	default m
 	depends on USB_HID
 	---help---
 	Support for A4 tech X5 and WOP-35 / Trust 450L mice.
 config HID_APPLE
 	tristate "Apple"
 	default m
 	depends on (USB_HID || BT_HIDP)
 	---help---
 	Support for some Apple devices which less or more break
 	HID specification.
 	Say Y here if you want support for the special keys (Fn, Numlock) on
 	Apple iBooks, PowerBooks, MacBooks, MacBook Pros and aluminum USB
 	keyboards.
 	If unsure, say M.
 config HID_CHERRY
 	tristate "Cherry"
 	default m
 	depends on USB_HID
 	---help---
 	Support for Cherry Cymotion.
 config HID_CYPRESS
 	tristate "Cypress"
 	default m
 	depends on USB_HID
 	---help---
 	Support for Cypress mouse and barcodes.
+config HID_EZKEY
+	tristate "Ezkey"
+	default m
+	depends on USB_HID
+	---help---
+	Support for Ezkey mouse and barcodes.
 config HID_LOGITECH
 	tristate "Logitech"
 	default m
 	depends on USB_HID
 	---help---
 	Support for some Logitech devices which breaks less or more
 	HID specification.
 config HID_MICROSOFT
 	tristate "Microsoft"
 	default m
 	depends on USB_HID
 	---help---
 	Support for some Microsoft devices which breaks less or more
 	HID specification.
 config HID_SUNPLUS
 	tristate "Sunplus"
 	default m
 	depends on USB_HID
 	---help---
 	Support for Sunplus WDesktop input device.
 endmenu
 endif # HID_SUPPORT

drivers/hid/Makefile

Diff comments View file @ 1f243e3

 #
 # Makefile for the HID driver
 #
 hid-objs			:= hid-core.o hid-input.o hid-input-quirks.o
 obj-$(CONFIG_HID)		+= hid.o
 hid-$(CONFIG_HID_DEBUG)		+= hid-debug.o
 hid-$(CONFIG_HIDRAW)		+= hidraw.o
 ifdef CONFIG_HID_COMPAT
 obj-m				+= hid-dummy.o
 endif
 obj-$(CONFIG_HID_A4TECH)	+= hid-a4tech.o
 obj-$(CONFIG_HID_APPLE)		+= hid-apple.o
 obj-$(CONFIG_HID_CHERRY)	+= hid-cherry.o
 obj-$(CONFIG_HID_CYPRESS)	+= hid-cypress.o
+obj-$(CONFIG_HID_EZKEY)		+= hid-ezkey.o
 obj-$(CONFIG_HID_LOGITECH)	+= hid-logitech.o
 obj-$(CONFIG_HID_MICROSOFT)	+= hid-microsoft.o
 obj-$(CONFIG_HID_SUNPLUS)	+= hid-sunplus.o
 obj-$(CONFIG_USB_HID)		+= usbhid/
 obj-$(CONFIG_USB_MOUSE)		+= usbhid/
 obj-$(CONFIG_USB_KBD)		+= usbhid/

drivers/hid/hid-core.c

Diff comments View file @ 1f243e3

 /*
  *  HID support for Linux
  *
  *  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
  *  Copyright (c) 2006-2007 Jiri Kosina
  */
 /*
  * 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.
  */
 #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>
 #include <linux/vmalloc.h>
 #include <linux/sched.h>
 #include <linux/hid.h>
 #include <linux/hiddev.h>
 #include <linux/hid-debug.h>
 #include <linux/hidraw.h>
 #include "hid-ids.h"
 /*
  * Version Information
  */
 #define DRIVER_VERSION "v2.6"
 #define DRIVER_AUTHOR "Andreas Gal, Vojtech Pavlik, Jiri Kosina"
 #define DRIVER_DESC "HID core driver"
 #define DRIVER_LICENSE "GPL"
 #ifdef CONFIG_HID_DEBUG
 int hid_debug = 0;
 module_param_named(debug, hid_debug, int, 0600);
 MODULE_PARM_DESC(debug, "HID debugging (0=off, 1=probing info, 2=continuous data dumping)");
 EXPORT_SYMBOL_GPL(hid_debug);
 #endif
 /*
  * Register a new report for a device.
  */
 static struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)
 {
 	struct hid_report_enum *report_enum = device->report_enum + type;
 	struct hid_report *report;
 	if (report_enum->report_id_hash[id])
 		return report_enum->report_id_hash[id];
 	if (!(report = kzalloc(sizeof(struct hid_report), GFP_KERNEL)))
 		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;
 }
 /*
  * 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) {
 		dbg_hid("too many fields in report\n");
 		return NULL;
 	}
 	if (!(field = kzalloc(sizeof(struct hid_field) + usages * sizeof(struct hid_usage)
 		+ values * sizeof(unsigned), GFP_KERNEL))) return NULL;
 	field->index = report->maxfield++;
 	report->field[field->index] = field;
 	field->usage = (struct hid_usage *)(field + 1);
 	field->value = (s32 *)(field->usage + usages);
 	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) {
 		dbg_hid("collection stack overflow\n");
 		return -1;
 	}
 	if (parser->device->maxcollection == parser->device->collection_size) {
 		collection = kmalloc(sizeof(struct hid_collection) *
 				parser->device->collection_size * 2, GFP_KERNEL);
 		if (collection == NULL) {
 			dbg_hid("failed to reallocate collection array\n");
 			return -1;
 		}
 		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) {
 		dbg_hid("collection stack underflow\n");
 		return -1;
 	}
 	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)
 {
 	int n;
 	for (n = parser->collection_stack_ptr - 1; n >= 0; n--)
 		if (parser->device->collection[parser->collection_stack[n]].type == type)
 			return parser->device->collection[parser->collection_stack[n]].usage;
 	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) {
 		dbg_hid("usage index exceeded\n");
 		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;
 	int usages;
 	unsigned offset;
 	int i;
 	if (!(report = hid_register_report(parser->device, report_type, parser->global.report_id))) {
 		dbg_hid("hid_register_report failed\n");
 		return -1;
 	}
 	if (parser->global.logical_maximum < parser->global.logical_minimum) {
 		dbg_hid("logical range invalid %d %d\n", parser->global.logical_minimum, parser->global.logical_maximum);
 		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;
 	usages = max_t(int, parser->local.usage_index, parser->global.report_count);
 	if ((field = hid_register_field(report, usages, parser->global.report_count)) == NULL)
 		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++) {
 		int j = i;
 		/* 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];
 	}
 	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) {
 	case 1: return item->data.u8;
 	case 2: return item->data.u16;
 	case 4: return item->data.u32;
 	}
 	return 0;
 }
 static s32 item_sdata(struct hid_item *item)
 {
 	switch (item->size) {
 	case 1: return item->data.s8;
 	case 2: return item->data.s16;
 	case 4: return item->data.s32;
 	}
 	return 0;
 }
 /*
  * Process a global item.
  */
 static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
 {
 	switch (item->tag) {
 	case HID_GLOBAL_ITEM_TAG_PUSH:
 		if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
 			dbg_hid("global enviroment stack overflow\n");
 			return -1;
 		}
 		memcpy(parser->global_stack + parser->global_stack_ptr++,
 			&parser->global, sizeof(struct hid_global));
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_POP:
 		if (!parser->global_stack_ptr) {
 			dbg_hid("global enviroment stack underflow\n");
 			return -1;
 		}
 		memcpy(&parser->global, parser->global_stack +
 			--parser->global_stack_ptr, sizeof(struct hid_global));
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
 		parser->global.usage_page = item_udata(item);
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
 		parser->global.logical_minimum = item_sdata(item);
 		return 0;
 	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;
 	case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
 		parser->global.physical_minimum = item_sdata(item);
 		return 0;
 	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;
 	case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
 		parser->global.unit_exponent = item_sdata(item);
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_UNIT:
 		parser->global.unit = item_udata(item);
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
 		parser->global.report_size = item_udata(item);
 		if (parser->global.report_size > 32) {
 			dbg_hid("invalid report_size %d\n",
 					parser->global.report_size);
 			return -1;
 		}
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
 		parser->global.report_count = item_udata(item);
 		if (parser->global.report_count > HID_MAX_USAGES) {
 			dbg_hid("invalid report_count %d\n",
 					parser->global.report_count);
 			return -1;
 		}
 		return 0;
 	case HID_GLOBAL_ITEM_TAG_REPORT_ID:
 		parser->global.report_id = item_udata(item);
 		if (parser->global.report_id == 0) {
 			dbg_hid("report_id 0 is invalid\n");
 			return -1;
 		}
 		return 0;
 	default:
 		dbg_hid("unknown global tag 0x%x\n", item->tag);
 		return -1;
 	}
 }
 /*
  * Process a local item.
  */
 static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
 {
 	__u32 data;
 	unsigned n;
 	if (item->size == 0) {
 		dbg_hid("item data expected for local item\n");
 		return -1;
 	}
 	data = item_udata(item);
 	switch (item->tag) {
 	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) {
 				dbg_hid("nested delimiters\n");
 				return -1;
 			}
 			parser->local.delimiter_depth++;
 			parser->local.delimiter_branch++;
 		} else {
 			if (parser->local.delimiter_depth < 1) {
 				dbg_hid("bogus close delimiter\n");
 				return -1;
 			}
 			parser->local.delimiter_depth--;
 		}
 		return 1;
 	case HID_LOCAL_ITEM_TAG_USAGE:
 		if (parser->local.delimiter_branch > 1) {
 			dbg_hid("alternative usage ignored\n");
 			return 0;
 		}
 		if (item->size <= 2)
 			data = (parser->global.usage_page << 16) + data;
 		return hid_add_usage(parser, data);
 	case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 		if (parser->local.delimiter_branch > 1) {
 			dbg_hid("alternative usage ignored\n");
 			return 0;
 		}
 		if (item->size <= 2)
 			data = (parser->global.usage_page << 16) + data;
 		parser->local.usage_minimum = data;
 		return 0;
 	case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 		if (parser->local.delimiter_branch > 1) {
 			dbg_hid("alternative usage ignored\n");
 			return 0;
 		}
 		if (item->size <= 2)
 			data = (parser->global.usage_page << 16) + data;
 		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;
 	}
 	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) {
 	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:
 		dbg_hid("unknown main item tag 0x%x\n", item->tag);
 		ret = 0;
 	}
 	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)
 {
 	dbg_hid("reserved item type, tag 0x%x\n", item->tag);
 	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);
 }
 /*
  * Free a device structure, all reports, and all fields.
  */
 static void hid_device_release(struct device *dev)
 {
 	struct hid_device *device = container_of(dev, struct hid_device, dev);
 	unsigned i, j;
 	for (i = 0; i < HID_REPORT_TYPES; i++) {
 		struct hid_report_enum *report_enum = device->report_enum + i;
 		for (j = 0; j < 256; j++) {
 			struct hid_report *report = report_enum->report_id_hash[j];
 			if (report)
 				hid_free_report(report);
 		}
 	}
 	kfree(device->rdesc);
 	kfree(device->collection);
 	kfree(device);
 }
 /*
  * 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) {
 	case 0:
 		return start;
 	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;
 	}
 	return NULL;
 }
 /**
  * hid_parse_report - parse device report
  *
  * @device: hid device
  * @start: report start
  * @size: report size
  *
  * Parse a report description into a hid_device structure. Reports are
  * enumerated, fields are attached to these reports.
  * 0 returned on success, otherwise nonzero error value.
  */
 int hid_parse_report(struct hid_device *device, __u8 *start,
 		unsigned size)
 {
 	struct hid_parser *parser;
 	struct hid_item item;
 	__u8 *end;
 	int ret;
 	static int (*dispatch_type[])(struct hid_parser *parser,
 				      struct hid_item *item) = {
 		hid_parser_main,
 		hid_parser_global,
 		hid_parser_local,
 		hid_parser_reserved
 	};
 	if (device->driver->report_fixup)
 		device->driver->report_fixup(device, start, size);
 	device->rdesc = kmalloc(size, GFP_KERNEL);
 	if (device->rdesc == NULL)
 		return -ENOMEM;
 	memcpy(device->rdesc, start, size);
 	device->rsize = size;
 	parser = vmalloc(sizeof(struct hid_parser));
 	if (!parser) {
 		ret = -ENOMEM;
 		goto err;
 	}
 	memset(parser, 0, sizeof(struct hid_parser));
 	parser->device = device;
 	end = start + size;
 	ret = -EINVAL;
 	while ((start = fetch_item(start, end, &item)) != NULL) {
 		if (item.format != HID_ITEM_FORMAT_SHORT) {
 			dbg_hid("unexpected long global item\n");
 			goto err;
 		}
 		if (dispatch_type[item.type](parser, &item)) {
 			dbg_hid("item %u %u %u %u parsing failed\n",
 				item.format, (unsigned)item.size, (unsigned)item.type, (unsigned)item.tag);
 			goto err;
 		}
 		if (start == end) {
 			if (parser->collection_stack_ptr) {
 				dbg_hid("unbalanced collection at end of report description\n");
 				goto err;
 			}
 			if (parser->local.delimiter_depth) {
 				dbg_hid("unbalanced delimiter at end of report description\n");
 				goto err;
 			}
 			vfree(parser);
 			return 0;
 		}
 	}
 	dbg_hid("item fetching failed at offset %d\n", (int)(end - start));
 err:
 	vfree(parser);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(hid_parse_report);
 /*
  * 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) {
 	case 8:  return ((__s8)value);
 	case 16: return ((__s16)value);
 	case 32: return ((__s32)value);
 	}
 	return value & (1 << (n - 1)) ? value | (-1 << n) : value;
 }
 /*
  * 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".
  */
 static __inline__ __u32 extract(__u8 *report, unsigned offset, unsigned n)
 {
 	u64 x;
 	if (n > 32)
 		printk(KERN_WARNING "HID: extract() called with n (%d) > 32! (%s)\n",
 				n, current->comm);
 	report += offset >> 3;  /* adjust byte index */
 	offset &= 7;            /* now only need bit offset into one byte */
 	x = get_unaligned_le64(report);
 	x = (x >> offset) & ((1ULL << n) - 1);  /* extract bit field */
 	return (u32) x;
 }
 /*
  * "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.
  */
 static __inline__ void implement(__u8 *report, unsigned offset, unsigned n, __u32 value)
 {
 	u64 x;
 	u64 m = (1ULL << n) - 1;
 	if (n > 32)
 		printk(KERN_WARNING "HID: implement() called with n (%d) > 32! (%s)\n",
 				n, current->comm);
 	if (value > m)
 		printk(KERN_WARNING "HID: implement() called with too large value %d! (%s)\n",
 				value, current->comm);
 	WARN_ON(value > m);
 	value &= m;
 	report += offset >> 3;
 	offset &= 7;
 	x = get_unaligned_le64(report);
 	x &= ~(m << offset);
 	x |= ((u64)value) << offset;
 	put_unaligned_le64(x, report);
 }
 /*
  * Search an array for a value.
  */
 static __inline__ int search(__s32 *array, __s32 value, unsigned n)
 {
 	while (n--) {
 		if (*array++ == value)
 			return 0;
 	}
 	return -1;
 }
 /**
  * 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)
 {
 	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;
 	hid_dump_input(usage, value);
 	if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
 		ret = hdrv->event(hid, field, usage, value);
 		if (ret != 0) {
 			if (ret < 0)
 				dbg_hid("%s's event failed with %d\n",
 						hdrv->name, ret);
 			return;
 		}
 	}
 	if (hid->claimed & HID_CLAIMED_INPUT)
 		hidinput_hid_event(hid, field, usage, value);
 	if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
 		hid->hiddev_hid_event(hid, field, usage, value);
 }
 /*
  * 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).
  */
 static void hid_input_field(struct hid_device *hid, struct hid_field *field,
 			    __u8 *data, int interrupt)
 {
 	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;
 	if (!(value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC)))
 		return;
 	for (n = 0; n < count; n++) {
 			value[n] = min < 0 ? snto32(extract(data, offset + n * size, size), size) :
 						    extract(data, offset + n * size, size);
 			if (!(field->flags & HID_MAIN_ITEM_VARIABLE) /* Ignore report if ErrorRollOver */
 			    && value[n] >= min && value[n] <= max
 			    && field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
 				goto exit;
 	}
 	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.
  */
 static void hid_output_field(struct hid_field *field, __u8 *data)
 {
 	unsigned count = field->report_count;
 	unsigned offset = field->report_offset;
 	unsigned size = field->report_size;
 	unsigned bitsused = offset + count * size;
 	unsigned n;
 	/* make sure the unused bits in the last byte are zeros */
 	if (count > 0 && size > 0 && (bitsused % 8) != 0)
 		data[(bitsused-1)/8] &= (1 << (bitsused % 8)) - 1;
 	for (n = 0; n < count; n++) {
 		if (field->logical_minimum < 0)	/* signed values */
 			implement(data, offset + n * size, size, s32ton(field->value[n], size));
 		else				/* unsigned values */
 			implement(data, offset + n * size, size, field->value[n]);
 	}
 }
 /*
  * Create a report.
  */
 void hid_output_report(struct hid_report *report, __u8 *data)
 {
 	unsigned n;
 	if (report->id > 0)
 		*data++ = report->id;
 	for (n = 0; n < report->maxfield; n++)
 		hid_output_field(report->field[n], data);
 }
 EXPORT_SYMBOL_GPL(hid_output_report);
 /*
  * 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)
 {
 	unsigned size = field->report_size;
 	hid_dump_input(field->usage + offset, value);
 	if (offset >= field->report_count) {
 		dbg_hid("offset (%d) exceeds report_count (%d)\n", offset, field->report_count);
 		hid_dump_field(field, 8);
 		return -1;
 	}
 	if (field->logical_minimum < 0) {
 		if (value != snto32(s32ton(value, size), size)) {
 			dbg_hid("value %d is out of range\n", value);
 			return -1;
 		}
 	}
 	field->value[offset] = value;
 	return 0;
 }
 EXPORT_SYMBOL_GPL(hid_set_field);
 static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,
 		const u8 *data)
 {
 	struct hid_report *report;
 	unsigned int n = 0;	/* Normally report number is 0 */
 	/* Device uses numbered reports, data[0] is report number */
 	if (report_enum->numbered)
 		n = *data;
 	report = report_enum->report_id_hash[n];
 	if (report == NULL)
 		dbg_hid("undefined report_id %u received\n", n);
 	return report;
 }
 void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
 		int interrupt)
 {
 	struct hid_report_enum *report_enum = hid->report_enum + type;
 	struct hid_report *report;
 	unsigned int a;
 	int rsize, csize = size;
 	u8 *cdata = data;
 	report = hid_get_report(report_enum, data);
 	if (!report)
 		return;
 	if (report_enum->numbered) {
 		cdata++;
 		csize--;
 	}
 	rsize = ((report->size - 1) >> 3) + 1;
 	if (csize < rsize) {
 		dbg_hid("report %d is too short, (%d < %d)\n", report->id,
 				csize, rsize);
 		memset(cdata + csize, 0, rsize - csize);
 	}
 	if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
 		hid->hiddev_report_event(hid, report);
 	if (hid->claimed & HID_CLAIMED_HIDRAW) {
 		/* numbered reports need to be passed with the report num */
 		if (report_enum->numbered)
 			hidraw_report_event(hid, data - 1, size + 1);
 		else
 			hidraw_report_event(hid, data, size);
 	}
 	for (a = 0; a < report->maxfield; a++)
 		hid_input_field(hid, report->field[a], cdata, interrupt);
 	if (hid->claimed & HID_CLAIMED_INPUT)
 		hidinput_report_event(hid, report);
 }
 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
  * @interrupt: called from atomic?
  *
  * This is data entry for lower layers.
  */
 int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)
 {
 	struct hid_report_enum *report_enum = hid->report_enum + type;
 	struct hid_driver *hdrv = hid->driver;
 	struct hid_report *report;
 	unsigned int i;
 	int ret;
 	if (!hid || !hid->driver)
 		return -ENODEV;
 	if (!size) {
 		dbg_hid("empty report\n");
 		return -1;
 	}
 	dbg_hid("report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
 	report = hid_get_report(report_enum, data);
 	if (!report)
 		return -1;
 	/* dump the report */
 	dbg_hid("report %d (size %u) = ", report->id, size);
 	for (i = 0; i < size; i++)
 		dbg_hid_line(" %02x", data[i]);
 	dbg_hid_line("\n");
 	if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
 		ret = hdrv->raw_event(hid, report, data, size);
 		if (ret != 0)
 			return ret < 0 ? ret : 0;
 	}
 	hid_report_raw_event(hid, type, data, size, interrupt);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(hid_input_report);
 static bool hid_match_one_id(struct hid_device *hdev,
 		const struct hid_device_id *id)
 {
 	return id->bus == hdev->bus &&
 		(id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
 		(id->product == HID_ANY_ID || id->product == hdev->product);
 }
 static const struct hid_device_id *hid_match_id(struct hid_device *hdev,
 		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_blacklist[] = {
 	{ 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) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },
 	{ 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_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) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_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) },
 	{ 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) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
 	{ 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) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
 	{ 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) },
 	{ 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_KBD) },
 	{ 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_LX3) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_V150) },
 	{ 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) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K) },
 	{ 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) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, 0x030c) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
 	{ }
 };
 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);
 	if (!hid_match_id(hdev, hdrv->id_table))
 		return 0;
 	/* generic wants all non-blacklisted */
 	if (!strncmp(hdrv->name, "generic-", 8))
 		return !hid_match_id(hdev, hid_blacklist);
 	return 1;
 }
 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;
 	if (!hdev->driver) {
 		id = hid_match_id(hdev, hdrv->id_table);
 		if (id == NULL)
 			return -ENODEV;
 		hdev->driver = hdrv;
 		if (hdrv->probe) {
 			ret = hdrv->probe(hdev, id);
 		} else { /* default probe */
 			ret = hid_parse(hdev);
 			if (!ret)
 				ret = hid_hw_start(hdev);
 		}
 		if (ret)
 			hdev->driver = NULL;
 	}
 	return ret;
 }
 static int hid_device_remove(struct device *dev)
 {
 	struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 	struct hid_driver *hdrv = hdev->driver;
 	if (hdrv) {
 		if (hdrv->remove)
 			hdrv->remove(hdev);
 		else /* default remove */
 			hid_hw_stop(hdev);
 		hdev->driver = NULL;
 	}
 	return 0;
 }
 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;
 	if (add_uevent_var(env, "MODALIAS=hid:b%04Xv%08Xp%08X",
 			hdev->bus, hdev->vendor, hdev->product))
 		return -ENOMEM;
 	return 0;
 }
 static struct bus_type hid_bus_type = {
 	.name		= "hid",
 	.match		= hid_bus_match,
 	.probe		= hid_device_probe,
 	.remove		= hid_device_remove,
 	.uevent		= hid_uevent,
 };
 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) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_LCM)},
 	{ 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) },
 	{ 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) },
 	{ 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) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0001) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0002) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0003) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0004) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_0_4_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_16_16_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_8_8_8_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_7_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_8_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_GLAB, USB_DEVICE_ID_PHIDGET_MOTORCONTROL) },
 	{ 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) },
 	{ 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) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
 	{ 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) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },
 	{ 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) },
 	{ 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_MGE, USB_DEVICE_ID_MGE_UPS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT2) },
 	{ 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) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LCSPEC) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WACOM, HID_ANY_ID) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT) },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K) },
 	{ }
 };
 static bool hid_ignore(struct hid_device *hdev)
 {
 	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;
 		break;
 	}
 	return !!hid_match_id(hdev, hid_ignore_list);
 }
 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;
 	/* we need to kill them here, otherwise they will stay allocated to
 	 * wait for coming driver */
 	if (hid_ignore(hdev))
 		return -ENODEV;
 	/* XXX hack, any other cleaner solution < 20 bus_id bytes? */
 	sprintf(hdev->dev.bus_id, "%04X:%04X:%04X.%04X", hdev->bus,
 			hdev->vendor, hdev->product, atomic_inc_return(&id));
 	ret = device_add(&hdev->dev);
 	if (!ret)
 		hdev->status |= HID_STAT_ADDED;
 	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;
 	unsigned int i;
 	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;
 	hdev->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
 			sizeof(struct hid_collection), GFP_KERNEL);
 	if (hdev->collection == NULL)
 		goto err;
 	hdev->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
 	for (i = 0; i < HID_REPORT_TYPES; i++)
 		INIT_LIST_HEAD(&hdev->report_enum[i].report_list);
 	return hdev;
 err:
 	put_device(&hdev->dev);
 	return ERR_PTR(ret);
 }
 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);
 		hdev->status &= ~HID_STAT_ADDED;
 	}
 }
 /**
  * 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)
 {
 	hdrv->driver.name = hdrv->name;
 	hdrv->driver.bus = &hid_bus_type;
 	hdrv->driver.owner = owner;
 	hdrv->driver.mod_name = mod_name;
 	return driver_register(&hdrv->driver);
 }
 EXPORT_SYMBOL_GPL(__hid_register_driver);
 void hid_unregister_driver(struct hid_driver *hdrv)
 {
 	driver_unregister(&hdrv->driver);
 }
 EXPORT_SYMBOL_GPL(hid_unregister_driver);
 #ifdef CONFIG_HID_COMPAT
 static void hid_compat_load(struct work_struct *ws)
 {
 	request_module("hid-dummy");
 }
 static DECLARE_WORK(hid_compat_work, hid_compat_load);
 #endif
 static int __init hid_init(void)
 {
 	int ret;
 	ret = bus_register(&hid_bus_type);
 	if (ret) {
 		printk(KERN_ERR "HID: can't register hid bus\n");
 		goto err;
 	}
 	ret = hidraw_init();
 	if (ret)
 		goto err_bus;
 #ifdef CONFIG_HID_COMPAT
 	schedule_work(&hid_compat_work);
 #endif
 	return 0;
 err_bus:
 	bus_unregister(&hid_bus_type);
 err:
 	return ret;
 }
 static void __exit hid_exit(void)
 {
 	hidraw_exit();
 	bus_unregister(&hid_bus_type);
 }
 module_init(hid_init);
 module_exit(hid_exit);
 MODULE_LICENSE(DRIVER_LICENSE);

drivers/hid/hid-dummy.c

Diff comments View file @ 1f243e3

 #include <linux/autoconf.h>
 #include <linux/module.h>
 #include <linux/hid.h>
 static int __init hid_dummy_init(void)
 {
 #ifdef CONFIG_HID_A4TECH_MODULE
 	HID_COMPAT_CALL_DRIVER(a4tech);
 #endif
 #ifdef CONFIG_HID_APPLE_MODULE
 	HID_COMPAT_CALL_DRIVER(apple);
 #endif
 #ifdef CONFIG_HID_CHERRY_MODULE
 	HID_COMPAT_CALL_DRIVER(cherry);
 #endif
 #ifdef CONFIG_HID_CYPRESS_MODULE
 	HID_COMPAT_CALL_DRIVER(cypress);
 #endif
+#ifdef CONFIG_HID_EZKEY_MODULE
+	HID_COMPAT_CALL_DRIVER(ezkey);
+#endif
 #ifdef CONFIG_HID_LOGITECH_MODULE
 	HID_COMPAT_CALL_DRIVER(logitech);
 #endif
 #ifdef CONFIG_HID_MICROSOFT_MODULE
 	HID_COMPAT_CALL_DRIVER(microsoft);
 #endif
 #ifdef CONFIG_HID_SUNPLUS_MODULE
 	HID_COMPAT_CALL_DRIVER(sunplus);
 #endif
 	return -EIO;
 }
 module_init(hid_dummy_init);
 MODULE_LICENSE("GPL");

drivers/hid/hid-ezkey.c

Diff comments View file @ 1f243e3

File was created	1	/*
	2	* HID driver for some ezkey "special" devices
	3	*
	4	* Copyright (c) 1999 Andreas Gal
	5	* Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
	6	* Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
	7	* Copyright (c) 2006-2007 Jiri Kosina
	8	* Copyright (c) 2007 Paul Walmsley
	9	* Copyright (c) 2008 Jiri Slaby
	10	*/
	11
	12	/*
	13	* This program is free software; you can redistribute it and/or modify it
	14	* under the terms of the GNU General Public License as published by the Free
	15	* Software Foundation; either version 2 of the License, or (at your option)
	16	* any later version.
	17	*/
	18
	19	#include <linux/device.h>
	20	#include <linux/input.h>
	21	#include <linux/hid.h>
	22	#include <linux/module.h>
	23
	24	#include "hid-ids.h"
	25
	26	#define ez_map_rel(c) hid_map_usage(hi, usage, bit, max, EV_REL, (c))
	27	#define ez_map_key(c) hid_map_usage(hi, usage, bit, max, EV_KEY, (c))
	28
	29	static int ez_input_mapping(struct hid_device hdev, struct hid_input hi,
	30	struct hid_field field, struct hid_usage usage,
	31	unsigned long *bit, int max)
	32	{
	33	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
	34	return 0;
	35
	36	switch (usage->hid & HID_USAGE) {
	37	case 0x230: ez_map_key(BTN_MOUSE); break;
	38	case 0x231: ez_map_rel(REL_WHEEL); break;
	39	/*
	40	* this keyboard has a scrollwheel implemented in
	41	* totally broken way. We map this usage temporarily
	42	* to HWHEEL and handle it in the event quirk handler
	43	*/
	44	case 0x232: ez_map_rel(REL_HWHEEL); break;
	45	default:
	46	return 0;
	47	}
	48	return 1;
	49	}
	50
	51	static int ez_event(struct hid_device hdev, struct hid_field field,
	52	struct hid_usage *usage, __s32 value)
	53	{
	54	if (!(hdev->claimed & HID_CLAIMED_INPUT) \|\| !field->hidinput \|\|
	55	!usage->type)
	56	return 0;
	57
	58	/* handle the temporary quirky mapping to HWHEEL */
	59	if (usage->type == EV_REL && usage->code == REL_HWHEEL) {
	60	struct input_dev *input = field->hidinput->input;
	61	input_event(input, usage->type, REL_WHEEL, -value);
	62	return 1;
	63	}
	64
	65	return 0;
	66	}
	67
	68	static const struct hid_device_id ez_devices[] = {
	69	{ HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
	70	{ }
	71	};
	72	MODULE_DEVICE_TABLE(hid, ez_devices);
	73
	74	static struct hid_driver ez_driver = {
	75	.name = "ezkey",
	76	.id_table = ez_devices,
	77	.input_mapping = ez_input_mapping,
	78	.event = ez_event,
	79	};
	80
	81	static int ez_init(void)
	82	{
	83	return hid_register_driver(&ez_driver);
	84	}
	85
	86	static void ez_exit(void)
	87	{
	88	hid_unregister_driver(&ez_driver);
	89	}
	90
	91	module_init(ez_init);
	92	module_exit(ez_exit);
	93	MODULE_LICENSE("GPL");
	94
	95	HID_COMPAT_LOAD_DRIVER(ezkey);
	96

drivers/hid/hid-input-quirks.c

Diff comments View file @ 1f243e3

 /*
  *  HID-input usage mapping quirks
  *
  *  This is used to handle HID-input mappings for devices violating
  *  HUT 1.12 specification.
  *
  * Copyright (c) 2007-2008 Jiri Kosina
  */
 /*
  * 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
  */
 #include <linux/input.h>
 #include <linux/hid.h>
-#define map_rel(c)	hid_map_usage(hidinput, usage, bit, max, EV_REL, (c))
-#define map_key(c)	hid_map_usage(hidinput, usage, bit, max, EV_KEY, (c))
 #define map_key_clear(c)	hid_map_usage_clear(hidinput, usage, bit, \
 		max, EV_KEY, (c))
 static int quirk_belkin_wkbd(struct hid_usage *usage,
 		struct hid_input *hidinput, unsigned long **bit, int *max)
 {
 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
 		return 0;
 	switch (usage->hid & HID_USAGE) {
 		case 0x03a: map_key_clear(KEY_SOUND);		break;
 		case 0x03b: map_key_clear(KEY_CAMERA);		break;
 		case 0x03c: map_key_clear(KEY_DOCUMENTS);	break;
 		default:
 			return 0;
 	}
 	return 1;
 }
 static int quirk_gyration_remote(struct hid_usage *usage,
 		struct hid_input *hidinput, unsigned long **bit, int *max)
 {
 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
 		return 0;
 	set_bit(EV_REP, hidinput->input->evbit);
 	switch(usage->hid & HID_USAGE) {
 		/* Reported on Gyration MCE Remote */
 		case 0x00d: map_key_clear(KEY_HOME);		break;
 		case 0x024: map_key_clear(KEY_DVD);		break;
 		case 0x025: map_key_clear(KEY_PVR);		break;
 		case 0x046: map_key_clear(KEY_MEDIA);		break;
 		case 0x047: map_key_clear(KEY_MP3);		break;
 		case 0x049: map_key_clear(KEY_CAMERA);		break;
 		case 0x04a: map_key_clear(KEY_VIDEO);		break;
 		default:
 			return 0;
 	}
 	return 1;
 }
 static int quirk_chicony_tactical_pad(struct hid_usage *usage,
 		struct hid_input *hidinput, unsigned long **bit, int *max)
 {
 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
 		return 0;
 	set_bit(EV_REP, hidinput->input->evbit);
 	switch (usage->hid & HID_USAGE) {
 		case 0xff01: map_key_clear(BTN_1);		break;
 		case 0xff02: map_key_clear(BTN_2);		break;
 		case 0xff03: map_key_clear(BTN_3);		break;
 		case 0xff04: map_key_clear(BTN_4);		break;
 		case 0xff05: map_key_clear(BTN_5);		break;
 		case 0xff06: map_key_clear(BTN_6);		break;
 		case 0xff07: map_key_clear(BTN_7);		break;
 		case 0xff08: map_key_clear(BTN_8);		break;
 		case 0xff09: map_key_clear(BTN_9);		break;
 		case 0xff0a: map_key_clear(BTN_A);		break;
 		case 0xff0b: map_key_clear(BTN_B);		break;
 		default:
 			return 0;
 	}
 	return 1;
 }
 static int quirk_petalynx_remote(struct hid_usage *usage,
 		struct hid_input *hidinput, unsigned long **bit, int *max)
 {
 	if (((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) &&
 			((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER))
 		return 0;
 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_LOGIVENDOR)
 		switch(usage->hid & HID_USAGE) {
 			case 0x05a: map_key_clear(KEY_TEXT);		break;
 			case 0x05b: map_key_clear(KEY_RED);		break;
 			case 0x05c: map_key_clear(KEY_GREEN);		break;
 			case 0x05d: map_key_clear(KEY_YELLOW);		break;
 			case 0x05e: map_key_clear(KEY_BLUE);		break;
 			default:
 				return 0;
 		}
 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER)
 		switch(usage->hid & HID_USAGE) {
 			case 0x0f6: map_key_clear(KEY_NEXT);            break;
 			case 0x0fa: map_key_clear(KEY_BACK);            break;
 			default:
 				return 0;
 		}
 	return 1;
 }
 static int quirk_cherry_genius_29e(struct hid_usage *usage,
 		struct hid_input *hidinput, unsigned long **bit, int *max)
 {
 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
 		return 0;
 	switch (usage->hid & HID_USAGE) {
 		case 0x156: map_key_clear(KEY_WORDPROCESSOR);	break;
 		case 0x157: map_key_clear(KEY_SPREADSHEET);	break;
 		case 0x158: map_key_clear(KEY_PRESENTATION);	break;
 		case 0x15c: map_key_clear(KEY_STOP);		break;
 		default:
 			return 0;
 	}
 	return 1;
 }
-static int quirk_btc_8193(struct hid_usage *usage, struct hid_input *hidinput,
-			      unsigned long **bit, int *max)
-{
-	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-		return 0;
-	switch (usage->hid & HID_USAGE) {
-		case 0x230: map_key(BTN_MOUSE);			break;
-		case 0x231: map_rel(REL_WHEEL);			break;
-		/*
-		 * this keyboard has a scrollwheel implemented in
-		 * totally broken way. We map this usage temporarily
-		 * to HWHEEL and handle it in the event quirk handler
-		 */
-		case 0x232: map_rel(REL_HWHEEL);		break;
-		default:
-			return 0;
-	}
-	return 1;
-}
 #define VENDOR_ID_BELKIN			0x1020
 #define DEVICE_ID_BELKIN_WIRELESS_KEYBOARD	0x0006
 #define VENDOR_ID_CHICONY			0x04f2
 #define DEVICE_ID_CHICONY_TACTICAL_PAD		0x0418
-#define VENDOR_ID_EZKEY				0x0518
-#define DEVICE_ID_BTC_8193			0x0002
 #define VENDOR_ID_GYRATION			0x0c16
 #define DEVICE_ID_GYRATION_REMOTE		0x0002
 #define VENDOR_ID_MONTEREY			0x0566
 #define DEVICE_ID_GENIUS_KB29E			0x3004
 #define VENDOR_ID_PETALYNX			0x18b1
 #define DEVICE_ID_PETALYNX_MAXTER_REMOTE	0x0037
 static const struct hid_input_blacklist {
 	__u16 idVendor;
 	__u16 idProduct;
 	int (*quirk)(struct hid_usage *, struct hid_input *, unsigned long **,
 			int *);
 } hid_input_blacklist[] = {
 	{ VENDOR_ID_BELKIN, DEVICE_ID_BELKIN_WIRELESS_KEYBOARD, quirk_belkin_wkbd },
 	{ VENDOR_ID_CHICONY, DEVICE_ID_CHICONY_TACTICAL_PAD, quirk_chicony_tactical_pad },
-	{ VENDOR_ID_EZKEY, DEVICE_ID_BTC_8193, quirk_btc_8193 },
 	{ VENDOR_ID_GYRATION, DEVICE_ID_GYRATION_REMOTE, quirk_gyration_remote },
 	{ VENDOR_ID_MONTEREY, DEVICE_ID_GENIUS_KB29E, quirk_cherry_genius_29e },
 	{ VENDOR_ID_PETALYNX, DEVICE_ID_PETALYNX_MAXTER_REMOTE, quirk_petalynx_remote },
 	{ 0, 0, NULL }
 };
 int hidinput_mapping_quirks(struct hid_usage *usage,
 		struct hid_input *hi, unsigned long **bit, int *max)
 {
 	struct hid_device *device = input_get_drvdata(hi->input);
 	int i = 0;
 	while (hid_input_blacklist[i].quirk) {
 		if (hid_input_blacklist[i].idVendor == device->vendor &&
 				hid_input_blacklist[i].idProduct == device->product)
 			return hid_input_blacklist[i].quirk(usage, hi, bit,
 					max);
 		i++;
 	}
 	return 0;
 }
 int hidinput_event_quirks(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
 {
 	struct input_dev *input;
 	input = field->hidinput->input;
-	/* handle the temporary quirky mapping to HWHEEL */
-	if (hid->quirks & HID_QUIRK_HWHEEL_WHEEL_INVERT &&
-			usage->type == EV_REL && usage->code == REL_HWHEEL) {
-		input_event(input, usage->type, REL_WHEEL, -value);
-		return 1;
-	}
 	/* Gyration MCE remote "Sleep" key */
 	if (hid->vendor == VENDOR_ID_GYRATION &&
 	    hid->product == DEVICE_ID_GYRATION_REMOTE &&
 	    (usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK &&
 	    (usage->hid & 0xff) == 0x82) {
 		input_event(input, usage->type, usage->code, 1);
 		input_sync(input);
 		input_event(input, usage->type, usage->code, 0);
 		input_sync(input);
 		return 1;
 	}
 	return 0;
 }

drivers/hid/usbhid/hid-quirks.c

Diff comments View file @ 1f243e3

 /*
  *  USB HID quirks support for Linux
  *
  *  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
  *  Copyright (c) 2006-2007 Jiri Kosina
  *  Copyright (c) 2007 Paul Walmsley
  */
 /*
  * 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.
  */
 #include <linux/hid.h>
 #include "../hid-ids.h"
 /*
  * Alphabetically sorted blacklist by quirk type.
  */
 static const struct hid_blacklist {
 	__u16 idVendor;
 	__u16 idProduct;
 	__u32 quirks;
 } hid_blacklist[] = {
 	{ USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_GAMEPAD, HID_QUIRK_BADPAD },
 	{ USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_PREDATOR, HID_QUIRK_BADPAD },
 	{ USB_VENDOR_ID_ALPS, USB_DEVICE_ID_IBM_GAMEPAD, HID_QUIRK_BADPAD },
 	{ USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD, HID_QUIRK_BADPAD },
 	{ USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_DRIVING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FLYING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FIGHTING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_NATSU, USB_DEVICE_ID_NATSU_GAMEPAD, HID_QUIRK_BADPAD },
 	{ USB_VENDOR_ID_NEC, USB_DEVICE_ID_NEC_USB_GAME_PAD, HID_QUIRK_BADPAD },
 	{ USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RUMBLEPAD, HID_QUIRK_BADPAD },
 	{ USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD, HID_QUIRK_BADPAD },
 	{ USB_VENDOR_ID_AFATECH, USB_DEVICE_ID_AFATECH_AF9016, HID_QUIRK_FULLSPEED_INTERVAL },
 	{ USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM, HID_QUIRK_HIDDEV },
 	{ USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE, HID_QUIRK_HIDDEV | HID_QUIRK_IGNORE_HIDINPUT },
-	{ USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193, HID_QUIRK_HWHEEL_WHEEL_INVERT },
 	{ USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
 	{ USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII, HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER, HID_QUIRK_SONY_PS3_CONTROLLER | HID_QUIRK_HIDDEV },
 	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_CS124U, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVM, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVMC, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_DMI, USB_DEVICE_ID_DMI_ENC, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_KEYBOARD, HID_QUIRK_NOGET },
 	{ USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
 	{ USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
 	{ USB_VENDOR_ID_DELL, USB_DEVICE_ID_DELL_W7658, HID_QUIRK_RESET_LEDS },
 	{ 0, 0 }
 };
 /* Quirks for devices which require report descriptor fixup go here */
 static const struct hid_rdesc_blacklist {
 	__u16 idVendor;
 	__u16 idProduct;
 	__u32 quirks;
 } hid_rdesc_blacklist[] = {
 	{ USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E, HID_QUIRK_RDESC_BUTTON_CONSUMER },
 	{ USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE, HID_QUIRK_RDESC_PETALYNX },
 	{ USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE, HID_QUIRK_RDESC_SAMSUNG_REMOTE },
 	{ 0, 0 }
 };
 /* Dynamic HID quirks list - specified at runtime */
 struct quirks_list_struct {
 	struct hid_blacklist hid_bl_item;
 	struct list_head node;
 };
 static LIST_HEAD(dquirks_list);
 static DECLARE_RWSEM(dquirks_rwsem);
 /* Runtime ("dynamic") quirks manipulation functions */
 /**
  * usbhid_exists_dquirk: find any dynamic quirks for a USB HID device
  * @idVendor: the 16-bit USB vendor ID, in native byteorder
  * @idProduct: the 16-bit USB product ID, in native byteorder
  *
  * Description:
  *         Scans dquirks_list for a matching dynamic quirk and returns
  *         the pointer to the relevant struct hid_blacklist if found.
  *         Must be called with a read lock held on dquirks_rwsem.
  *
  * Returns: NULL if no quirk found, struct hid_blacklist * if found.
  */
 static struct hid_blacklist *usbhid_exists_dquirk(const u16 idVendor,
 		const u16 idProduct)
 {
 	struct quirks_list_struct *q;
 	struct hid_blacklist *bl_entry = NULL;
 	list_for_each_entry(q, &dquirks_list, node) {
 		if (q->hid_bl_item.idVendor == idVendor &&
 				q->hid_bl_item.idProduct == idProduct) {
 			bl_entry = &q->hid_bl_item;
 			break;
 		}
 	}
 	if (bl_entry != NULL)
 		dbg_hid("Found dynamic quirk 0x%x for USB HID vendor 0x%hx prod 0x%hx\n",
 				bl_entry->quirks, bl_entry->idVendor,
 				bl_entry->idProduct);
 	return bl_entry;
 }
 /**
  * usbhid_modify_dquirk: add/replace a HID quirk
  * @idVendor: the 16-bit USB vendor ID, in native byteorder
  * @idProduct: the 16-bit USB product ID, in native byteorder
  * @quirks: the u32 quirks value to add/replace
  *
  * Description:
  *         If an dynamic quirk exists in memory for this (idVendor,
  *         idProduct) pair, replace its quirks value with what was
  *         provided.  Otherwise, add the quirk to the dynamic quirks list.
  *
  * Returns: 0 OK, -error on failure.
  */
 static int usbhid_modify_dquirk(const u16 idVendor, const u16 idProduct,
 				const u32 quirks)
 {
 	struct quirks_list_struct *q_new, *q;
 	int list_edited = 0;
 	if (!idVendor) {
 		dbg_hid("Cannot add a quirk with idVendor = 0\n");
 		return -EINVAL;
 	}
 	q_new = kmalloc(sizeof(struct quirks_list_struct), GFP_KERNEL);
 	if (!q_new) {
 		dbg_hid("Could not allocate quirks_list_struct\n");
 		return -ENOMEM;
 	}
 	q_new->hid_bl_item.idVendor = idVendor;
 	q_new->hid_bl_item.idProduct = idProduct;
 	q_new->hid_bl_item.quirks = quirks;
 	down_write(&dquirks_rwsem);
 	list_for_each_entry(q, &dquirks_list, node) {
 		if (q->hid_bl_item.idVendor == idVendor &&
 				q->hid_bl_item.idProduct == idProduct) {
 			list_replace(&q->node, &q_new->node);
 			kfree(q);
 			list_edited = 1;
 			break;
 		}
 	}
 	if (!list_edited)
 		list_add_tail(&q_new->node, &dquirks_list);
 	up_write(&dquirks_rwsem);
 	return 0;
 }
 /**
  * usbhid_remove_all_dquirks: remove all runtime HID quirks from memory
  *
  * Description:
  *         Free all memory associated with dynamic quirks - called before
  *         module unload.
  *
  */
 static void usbhid_remove_all_dquirks(void)
 {
 	struct quirks_list_struct *q, *temp;
 	down_write(&dquirks_rwsem);
 	list_for_each_entry_safe(q, temp, &dquirks_list, node) {
 		list_del(&q->node);
 		kfree(q);
 	}
 	up_write(&dquirks_rwsem);
 }
 /**
  * usbhid_quirks_init: apply USB HID quirks specified at module load time
  */
 int usbhid_quirks_init(char **quirks_param)
 {
 	u16 idVendor, idProduct;
 	u32 quirks;
 	int n = 0, m;
 	for (; quirks_param[n] && n < MAX_USBHID_BOOT_QUIRKS; n++) {
 		m = sscanf(quirks_param[n], "0x%hx:0x%hx:0x%x",
 				&idVendor, &idProduct, &quirks);
 		if (m != 3 ||
 				usbhid_modify_dquirk(idVendor, idProduct, quirks) != 0) {
 			printk(KERN_WARNING
 					"Could not parse HID quirk module param %s\n",
 					quirks_param[n]);
 		}
 	}
 	return 0;
 }
 /**
  * usbhid_quirks_exit: release memory associated with dynamic_quirks
  *
  * Description:
  *     Release all memory associated with dynamic quirks.  Called upon
  *     module unload.
  *
  * Returns: nothing
  */
 void usbhid_quirks_exit(void)
 {
 	usbhid_remove_all_dquirks();
 }
 /**
  * usbhid_exists_squirk: return any static quirks for a USB HID device
  * @idVendor: the 16-bit USB vendor ID, in native byteorder
  * @idProduct: the 16-bit USB product ID, in native byteorder
  *
  * Description:
  *     Given a USB vendor ID and product ID, return a pointer to
  *     the hid_blacklist entry associated with that device.
  *
  * Returns: pointer if quirk found, or NULL if no quirks found.
  */
 static const struct hid_blacklist *usbhid_exists_squirk(const u16 idVendor,
 		const u16 idProduct)
 {
 	const struct hid_blacklist *bl_entry = NULL;
 	int n = 0;
 	for (; hid_blacklist[n].idVendor; n++)
 		if (hid_blacklist[n].idVendor == idVendor &&
 				hid_blacklist[n].idProduct == idProduct)
 			bl_entry = &hid_blacklist[n];
 	if (bl_entry != NULL)
 		dbg_hid("Found squirk 0x%x for USB HID vendor 0x%hx prod 0x%hx\n",
 				bl_entry->quirks, bl_entry->idVendor,
 				bl_entry->idProduct);
 	return bl_entry;
 }
 /**
  * usbhid_lookup_quirk: return any quirks associated with a USB HID device
  * @idVendor: the 16-bit USB vendor ID, in native byteorder
  * @idProduct: the 16-bit USB product ID, in native byteorder
  *
  * Description:
  *     Given a USB vendor ID and product ID, return any quirks associated
  *     with that device.
  *
  * Returns: a u32 quirks value.
  */
 u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct)
 {
 	u32 quirks = 0;
 	const struct hid_blacklist *bl_entry = NULL;
 	/* NCR devices must not be queried for reports */
 	if (idVendor == USB_VENDOR_ID_NCR &&
 			idProduct >= USB_DEVICE_ID_NCR_FIRST &&
 			idProduct <= USB_DEVICE_ID_NCR_LAST)
 			return HID_QUIRK_NOGET;
 	down_read(&dquirks_rwsem);
 	bl_entry = usbhid_exists_dquirk(idVendor, idProduct);
 	if (!bl_entry)
 		bl_entry = usbhid_exists_squirk(idVendor, idProduct);
 	if (bl_entry)
 		quirks = bl_entry->quirks;
 	up_read(&dquirks_rwsem);
 	return quirks;
 }
 EXPORT_SYMBOL_GPL(usbhid_lookup_quirk);
 /*
  * Samsung IrDA remote controller (reports as Cypress USB Mouse).
  *
  * Vendor specific report #4 has a size of 48 bit,
  * and therefore is not accepted when inspecting the descriptors.
  * As a workaround we reinterpret the report as:
  *   Variable type, count 6, size 8 bit, log. maximum 255
  * The burden to reconstruct the data is moved into user space.
  */
 static void usbhid_fixup_samsung_irda_descriptor(unsigned char *rdesc,
 						  int rsize)
 {
 	if (rsize >= 182 && rdesc[175] == 0x25
 			 && rdesc[176] == 0x40
 			 && rdesc[177] == 0x75
 			 && rdesc[178] == 0x30
 			 && rdesc[179] == 0x95
 			 && rdesc[180] == 0x01
 			 && rdesc[182] == 0x40) {
 		printk(KERN_INFO "Fixing up Samsung IrDA report descriptor\n");
 		rdesc[176] = 0xff;
 		rdesc[178] = 0x08;
 		rdesc[180] = 0x06;
 		rdesc[182] = 0x42;
 	}
 }
 /* Petalynx Maxter Remote has maximum for consumer page set too low */
 static void usbhid_fixup_petalynx_descriptor(unsigned char *rdesc, int rsize)
 {
 	if (rsize >= 60 && rdesc[39] == 0x2a
 			&& rdesc[40] == 0xf5
 			&& rdesc[41] == 0x00
 			&& rdesc[59] == 0x26
 			&& rdesc[60] == 0xf9
 			&& rdesc[61] == 0x00) {
 		printk(KERN_INFO "Fixing up Petalynx Maxter Remote report descriptor\n");
 		rdesc[60] = 0xfa;
 		rdesc[40] = 0xfa;
 	}
 }
 static void usbhid_fixup_button_consumer_descriptor(unsigned char *rdesc, int rsize)
 {
 	if (rsize >= 30 && rdesc[29] == 0x05
 			&& rdesc[30] == 0x09) {
 		printk(KERN_INFO "Fixing up button/consumer in HID report descriptor\n");
 		rdesc[30] = 0x0c;
 	}
 }
 static void __usbhid_fixup_report_descriptor(__u32 quirks, char *rdesc, unsigned rsize)
 {
 	if (quirks & HID_QUIRK_RDESC_PETALYNX)
 		usbhid_fixup_petalynx_descriptor(rdesc, rsize);
 	if (quirks & HID_QUIRK_RDESC_BUTTON_CONSUMER)
 		usbhid_fixup_button_consumer_descriptor(rdesc, rsize);
 	if (quirks & HID_QUIRK_RDESC_SAMSUNG_REMOTE)
 		usbhid_fixup_samsung_irda_descriptor(rdesc, rsize);
 }
 /**
  * usbhid_fixup_report_descriptor: check if report descriptor needs fixup
  *
  * Description:
  *	Walks the hid_rdesc_blacklist[] array and checks whether the device
  *	is known to have broken report descriptor that needs to be fixed up
  *	prior to entering the HID parser
  *
  * Returns: nothing
  */
 void usbhid_fixup_report_descriptor(const u16 idVendor, const u16 idProduct,
 				    char *rdesc, unsigned rsize, char **quirks_param)
 {
 	int n, m;
 	u16 paramVendor, paramProduct;
 	u32 quirks;
 	/* static rdesc quirk entries */
 	for (n = 0; hid_rdesc_blacklist[n].idVendor; n++)
 		if (hid_rdesc_blacklist[n].idVendor == idVendor &&
 				hid_rdesc_blacklist[n].idProduct == idProduct)
 			__usbhid_fixup_report_descriptor(hid_rdesc_blacklist[n].quirks,
 					rdesc, rsize);
 	/* runtime rdesc quirk entries handling */
 	for (n = 0; quirks_param[n] && n < MAX_USBHID_BOOT_QUIRKS; n++) {
 		m = sscanf(quirks_param[n], "0x%hx:0x%hx:0x%x",
 				&paramVendor, &paramProduct, &quirks);
 		if (m != 3)
 			printk(KERN_WARNING
 				"Could not parse HID quirk module param %s\n",
 				quirks_param[n]);
 		else if (paramVendor == idVendor && paramProduct == idProduct)
 			__usbhid_fixup_report_descriptor(quirks, rdesc, rsize);
 	}
 }

include/linux/hid.h

Diff comments View file @ 1f243e3

 #ifndef __HID_H
 #define __HID_H
 /*
  *  Copyright (c) 1999 Andreas Gal
  *  Copyright (c) 2000-2001 Vojtech Pavlik
  *  Copyright (c) 2006-2007 Jiri Kosina
  */
 /*
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
  * Should you need to contact me, the author, you can do so either by
  * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  */
 /*
  * USB HID (Human Interface Device) interface class code
  */
 #define USB_INTERFACE_CLASS_HID		3
 /*
  * USB HID interface subclass and protocol codes
  */
 #define USB_INTERFACE_SUBCLASS_BOOT	1
 #define USB_INTERFACE_PROTOCOL_KEYBOARD	1
 #define USB_INTERFACE_PROTOCOL_MOUSE	2
 /*
  * HID class requests
  */
 #define HID_REQ_GET_REPORT		0x01
 #define HID_REQ_GET_IDLE		0x02
 #define HID_REQ_GET_PROTOCOL		0x03
 #define HID_REQ_SET_REPORT		0x09
 #define HID_REQ_SET_IDLE		0x0A
 #define HID_REQ_SET_PROTOCOL		0x0B
 /*
  * HID class descriptor types
  */
 #define HID_DT_HID			(USB_TYPE_CLASS | 0x01)
 #define HID_DT_REPORT			(USB_TYPE_CLASS | 0x02)
 #define HID_DT_PHYSICAL			(USB_TYPE_CLASS | 0x03)
 #define HID_MAX_DESCRIPTOR_SIZE		4096
 #ifdef __KERNEL__
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/mod_devicetable.h> /* hid_device_id */
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 #include <linux/input.h>
 /*
  * We parse each description item into this structure. Short items data
  * values are expanded to 32-bit signed int, long items contain a pointer
  * into the data area.
  */
 struct hid_item {
 	unsigned  format;
 	__u8      size;
 	__u8      type;
 	__u8      tag;
 	union {
 	    __u8   u8;
 	    __s8   s8;
 	    __u16  u16;
 	    __s16  s16;
 	    __u32  u32;
 	    __s32  s32;
 	    __u8  *longdata;
 	} data;
 };
 /*
  * HID report item format
  */
 #define HID_ITEM_FORMAT_SHORT	0
 #define HID_ITEM_FORMAT_LONG	1
 /*
  * Special tag indicating long items
  */
 #define HID_ITEM_TAG_LONG	15
 /*
  * HID report descriptor item type (prefix bit 2,3)
  */
 #define HID_ITEM_TYPE_MAIN		0
 #define HID_ITEM_TYPE_GLOBAL		1
 #define HID_ITEM_TYPE_LOCAL		2
 #define HID_ITEM_TYPE_RESERVED		3
 /*
  * HID report descriptor main item tags
  */
 #define HID_MAIN_ITEM_TAG_INPUT			8
 #define HID_MAIN_ITEM_TAG_OUTPUT		9
 #define HID_MAIN_ITEM_TAG_FEATURE		11
 #define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION	10
 #define HID_MAIN_ITEM_TAG_END_COLLECTION	12
 /*
  * HID report descriptor main item contents
  */
 #define HID_MAIN_ITEM_CONSTANT		0x001
 #define HID_MAIN_ITEM_VARIABLE		0x002
 #define HID_MAIN_ITEM_RELATIVE		0x004
 #define HID_MAIN_ITEM_WRAP		0x008
 #define HID_MAIN_ITEM_NONLINEAR		0x010
 #define HID_MAIN_ITEM_NO_PREFERRED	0x020
 #define HID_MAIN_ITEM_NULL_STATE	0x040
 #define HID_MAIN_ITEM_VOLATILE		0x080
 #define HID_MAIN_ITEM_BUFFERED_BYTE	0x100
 /*
  * HID report descriptor collection item types
  */
 #define HID_COLLECTION_PHYSICAL		0
 #define HID_COLLECTION_APPLICATION	1
 #define HID_COLLECTION_LOGICAL		2
 /*
  * HID report descriptor global item tags
  */
 #define HID_GLOBAL_ITEM_TAG_USAGE_PAGE		0
 #define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM	1
 #define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM	2
 #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM	3
 #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM	4
 #define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT	5
 #define HID_GLOBAL_ITEM_TAG_UNIT		6
 #define HID_GLOBAL_ITEM_TAG_REPORT_SIZE		7
 #define HID_GLOBAL_ITEM_TAG_REPORT_ID		8
 #define HID_GLOBAL_ITEM_TAG_REPORT_COUNT	9
 #define HID_GLOBAL_ITEM_TAG_PUSH		10
 #define HID_GLOBAL_ITEM_TAG_POP			11
 /*
  * HID report descriptor local item tags
  */
 #define HID_LOCAL_ITEM_TAG_USAGE		0
 #define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM	1
 #define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM	2
 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX	3
 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM	4
 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM	5
 #define HID_LOCAL_ITEM_TAG_STRING_INDEX		7
 #define HID_LOCAL_ITEM_TAG_STRING_MINIMUM	8
 #define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM	9
 #define HID_LOCAL_ITEM_TAG_DELIMITER		10
 /*
  * HID usage tables
  */
 #define HID_USAGE_PAGE		0xffff0000
 #define HID_UP_UNDEFINED	0x00000000
 #define HID_UP_GENDESK		0x00010000
 #define HID_UP_SIMULATION	0x00020000
 #define HID_UP_KEYBOARD		0x00070000
 #define HID_UP_LED		0x00080000
 #define HID_UP_BUTTON		0x00090000
 #define HID_UP_ORDINAL		0x000a0000
 #define HID_UP_CONSUMER		0x000c0000
 #define HID_UP_DIGITIZER	0x000d0000
 #define HID_UP_PID		0x000f0000
 #define HID_UP_HPVENDOR         0xff7f0000
 #define HID_UP_MSVENDOR		0xff000000
 #define HID_UP_CUSTOM		0x00ff0000
 #define HID_UP_LOGIVENDOR	0xffbc0000
 #define HID_USAGE		0x0000ffff
 #define HID_GD_POINTER		0x00010001
 #define HID_GD_MOUSE		0x00010002
 #define HID_GD_JOYSTICK		0x00010004
 #define HID_GD_GAMEPAD		0x00010005
 #define HID_GD_KEYBOARD		0x00010006
 #define HID_GD_KEYPAD		0x00010007
 #define HID_GD_MULTIAXIS	0x00010008
 #define HID_GD_X		0x00010030
 #define HID_GD_Y		0x00010031
 #define HID_GD_Z		0x00010032
 #define HID_GD_RX		0x00010033
 #define HID_GD_RY		0x00010034
 #define HID_GD_RZ		0x00010035
 #define HID_GD_SLIDER		0x00010036
 #define HID_GD_DIAL		0x00010037
 #define HID_GD_WHEEL		0x00010038
 #define HID_GD_HATSWITCH	0x00010039
 #define HID_GD_BUFFER		0x0001003a
 #define HID_GD_BYTECOUNT	0x0001003b
 #define HID_GD_MOTION		0x0001003c
 #define HID_GD_START		0x0001003d
 #define HID_GD_SELECT		0x0001003e
 #define HID_GD_VX		0x00010040
 #define HID_GD_VY		0x00010041
 #define HID_GD_VZ		0x00010042
 #define HID_GD_VBRX		0x00010043
 #define HID_GD_VBRY		0x00010044
 #define HID_GD_VBRZ		0x00010045
 #define HID_GD_VNO		0x00010046
 #define HID_GD_FEATURE		0x00010047
 #define HID_GD_UP		0x00010090
 #define HID_GD_DOWN		0x00010091
 #define HID_GD_RIGHT		0x00010092
 #define HID_GD_LEFT		0x00010093
 /*
  * HID report types --- Ouch! HID spec says 1 2 3!
  */
 #define HID_INPUT_REPORT	0
 #define HID_OUTPUT_REPORT	1
 #define HID_FEATURE_REPORT	2
 /*
  * HID device quirks.
  */
 /*
  * Increase this if you need to configure more HID quirks at module load time
  */
 #define MAX_USBHID_BOOT_QUIRKS 4
 #define HID_QUIRK_INVERT			0x00000001
 #define HID_QUIRK_NOTOUCH			0x00000002
 #define HID_QUIRK_NOGET				0x00000008
 #define HID_QUIRK_HIDDEV			0x00000010
 #define HID_QUIRK_BADPAD			0x00000020
 #define HID_QUIRK_MULTI_INPUT			0x00000040
 #define HID_QUIRK_SKIP_OUTPUT_REPORTS		0x00010000
 #define HID_QUIRK_SONY_PS3_CONTROLLER		0x00040000
 #define HID_QUIRK_RESET_LEDS			0x00100000
 #define HID_QUIRK_HIDINPUT			0x00200000
 #define HID_QUIRK_IGNORE_HIDINPUT		0x01000000
-#define HID_QUIRK_HWHEEL_WHEEL_INVERT		0x04000000
 #define HID_QUIRK_FULLSPEED_INTERVAL		0x10000000
 /*
  * Separate quirks for runtime report descriptor fixup
  */
 #define HID_QUIRK_RDESC_PETALYNX		0x00000008
 #define HID_QUIRK_RDESC_BUTTON_CONSUMER		0x00000020
 #define HID_QUIRK_RDESC_SAMSUNG_REMOTE		0x00000040
 /*
  * This is the global environment of the parser. This information is
  * persistent for main-items. The global environment can be saved and
  * restored with PUSH/POP statements.
  */
 struct hid_global {
 	unsigned usage_page;
 	__s32    logical_minimum;
 	__s32    logical_maximum;
 	__s32    physical_minimum;
 	__s32    physical_maximum;
 	__s32    unit_exponent;
 	unsigned unit;
 	unsigned report_id;
 	unsigned report_size;
 	unsigned report_count;
 };
 /*
  * This is the local environment. It is persistent up the next main-item.
  */
 #define HID_MAX_USAGES			12288
 #define HID_DEFAULT_NUM_COLLECTIONS	16
 struct hid_local {
 	unsigned usage[HID_MAX_USAGES]; /* usage array */
 	unsigned collection_index[HID_MAX_USAGES]; /* collection index array */
 	unsigned usage_index;
 	unsigned usage_minimum;
 	unsigned delimiter_depth;
 	unsigned delimiter_branch;
 };
 /*
  * This is the collection stack. We climb up the stack to determine
  * application and function of each field.
  */
 struct hid_collection {
 	unsigned type;
 	unsigned usage;
 	unsigned level;
 };
 struct hid_usage {
 	unsigned  hid;			/* hid usage code */
 	unsigned  collection_index;	/* index into collection array */
 	/* hidinput data */
 	__u16     code;			/* input driver code */
 	__u8      type;			/* input driver type */
 	__s8	  hat_min;		/* hat switch fun */
 	__s8	  hat_max;		/* ditto */
 	__s8	  hat_dir;		/* ditto */
 };
 struct hid_input;
 struct hid_field {
 	unsigned  physical;		/* physical usage for this field */
 	unsigned  logical;		/* logical usage for this field */
 	unsigned  application;		/* application usage for this field */
 	struct hid_usage *usage;	/* usage table for this function */
 	unsigned  maxusage;		/* maximum usage index */
 	unsigned  flags;		/* main-item flags (i.e. volatile,array,constant) */
 	unsigned  report_offset;	/* bit offset in the report */
 	unsigned  report_size;		/* size of this field in the report */
 	unsigned  report_count;		/* number of this field in the report */
 	unsigned  report_type;		/* (input,output,feature) */
 	__s32    *value;		/* last known value(s) */
 	__s32     logical_minimum;
 	__s32     logical_maximum;
 	__s32     physical_minimum;
 	__s32     physical_maximum;
 	__s32     unit_exponent;
 	unsigned  unit;
 	struct hid_report *report;	/* associated report */
 	unsigned index;			/* index into report->field[] */
 	/* hidinput data */
 	struct hid_input *hidinput;	/* associated input structure */
 	__u16 dpad;			/* dpad input code */
 };
 #define HID_MAX_FIELDS 64
 struct hid_report {
 	struct list_head list;
 	unsigned id;					/* id of this report */
 	unsigned type;					/* report type */
 	struct hid_field *field[HID_MAX_FIELDS];	/* fields of the report */
 	unsigned maxfield;				/* maximum valid field index */
 	unsigned size;					/* size of the report (bits) */
 	struct hid_device *device;			/* associated device */
 };
 struct hid_report_enum {
 	unsigned numbered;
 	struct list_head report_list;
 	struct hid_report *report_id_hash[256];
 };
 #define HID_REPORT_TYPES 3
 #define HID_MIN_BUFFER_SIZE	64		/* make sure there is at least a packet size of space */
 #define HID_MAX_BUFFER_SIZE	4096		/* 4kb */
 #define HID_CONTROL_FIFO_SIZE	256		/* to init devices with >100 reports */
 #define HID_OUTPUT_FIFO_SIZE	64
 struct hid_control_fifo {
 	unsigned char dir;
 	struct hid_report *report;
 };
 #define HID_CLAIMED_INPUT	1
 #define HID_CLAIMED_HIDDEV	2
 #define HID_CLAIMED_HIDRAW	4
 #define HID_STAT_ADDED		1
 #define HID_STAT_PARSED		2
 #define HID_CTRL_RUNNING	1
 #define HID_OUT_RUNNING		2
 #define HID_IN_RUNNING		3
 #define HID_RESET_PENDING	4
 #define HID_SUSPENDED		5
 #define HID_CLEAR_HALT		6
 #define HID_DISCONNECTED	7
 struct hid_input {
 	struct list_head list;
 	struct hid_report *report;
 	struct input_dev *input;
 };
 struct hid_driver;
 struct hid_ll_driver;
 struct hid_device {							/* device report descriptor */
 	__u8 *rdesc;
 	unsigned rsize;
 	struct hid_collection *collection;				/* List of HID collections */
 	unsigned collection_size;					/* Number of allocated hid_collections */
 	unsigned maxcollection;						/* Number of parsed collections */
 	unsigned maxapplication;					/* Number of applications */
 	__u16 bus;							/* BUS ID */
 	__u32 vendor;							/* Vendor ID */
 	__u32 product;							/* Product ID */
 	__u32 version;							/* HID version */
 	unsigned country;						/* HID country */
 	struct hid_report_enum report_enum[HID_REPORT_TYPES];
 	struct device dev;						/* device */
 	struct hid_driver *driver;
 	struct hid_ll_driver *ll_driver;
 	unsigned int status;						/* see STAT flags above */
 	unsigned claimed;						/* Claimed by hidinput, hiddev? */
 	unsigned quirks;						/* Various quirks the device can pull on us */
 	struct list_head inputs;					/* The list of inputs */
 	void *hiddev;							/* The hiddev structure */
 	void *hidraw;
 	int minor;							/* Hiddev minor number */
 	int open;							/* is the device open by anyone? */
 	char name[128];							/* Device name */
 	char phys[64];							/* Device physical location */
 	char uniq[64];							/* Device unique identifier (serial #) */
 	void *driver_data;
 	/* hiddev event handler */
 	void (*hiddev_hid_event) (struct hid_device *, struct hid_field *field,
 				  struct hid_usage *, __s32);
 	void (*hiddev_report_event) (struct hid_device *, struct hid_report *);
 	/* handler for raw output data, used by hidraw */
 	int (*hid_output_raw_report) (struct hid_device *, __u8 *, size_t);
 };
 static inline void *hid_get_drvdata(struct hid_device *hdev)
 {
 	return dev_get_drvdata(&hdev->dev);
 }
 static inline void hid_set_drvdata(struct hid_device *hdev, void *data)
 {
 	dev_set_drvdata(&hdev->dev, data);
 }
 #define HID_GLOBAL_STACK_SIZE 4
 #define HID_COLLECTION_STACK_SIZE 4
 struct hid_parser {
 	struct hid_global     global;
 	struct hid_global     global_stack[HID_GLOBAL_STACK_SIZE];
 	unsigned              global_stack_ptr;
 	struct hid_local      local;
 	unsigned              collection_stack[HID_COLLECTION_STACK_SIZE];
 	unsigned              collection_stack_ptr;
 	struct hid_device    *device;
 };
 struct hid_class_descriptor {
 	__u8  bDescriptorType;
 	__le16 wDescriptorLength;
 } __attribute__ ((packed));
 struct hid_descriptor {
 	__u8  bLength;
 	__u8  bDescriptorType;
 	__le16 bcdHID;
 	__u8  bCountryCode;
 	__u8  bNumDescriptors;
 	struct hid_class_descriptor desc[1];
 } __attribute__ ((packed));
 #define HID_DEVICE(b, ven, prod) \
 	.bus = (b), \
 	.vendor = (ven), .product = (prod)
 #define HID_USB_DEVICE(ven, prod)	HID_DEVICE(BUS_USB, ven, prod)
 #define HID_BLUETOOTH_DEVICE(ven, prod)	HID_DEVICE(BUS_BLUETOOTH, ven, prod)
 #define HID_REPORT_ID(rep) \
 	.report_type = (rep)
 #define HID_USAGE_ID(uhid, utype, ucode) \
 	.usage_hid = (uhid), .usage_type = (utype), .usage_code = (ucode)
 /* we don't want to catch types and codes equal to 0 */
 #define HID_TERMINATOR		(HID_ANY_ID - 1)
 struct hid_report_id {
 	__u32 report_type;
 };
 struct hid_usage_id {
 	__u32 usage_hid;
 	__u32 usage_type;
 	__u32 usage_code;
 };
 /**
  * struct hid_driver
  * @name: driver name (e.g. "Footech_bar-wheel")
  * @id_table: which devices is this driver for (must be non-NULL for probe
  * 	      to be called)
  * @probe: new device inserted
  * @remove: device removed (NULL if not a hot-plug capable driver)
  * @report_table: on which reports to call raw_event (NULL means all)
  * @raw_event: if report in report_table, this hook is called (NULL means nop)
  * @usage_table: on which events to call event (NULL means all)
  * @event: if usage in usage_table, this hook is called (NULL means nop)
  * @report_fixup: called before report descriptor parsing (NULL means nop)
  * @input_mapping: invoked on input registering before mapping an usage
  * @input_mapped: invoked on input registering after mapping an usage
  *
  * raw_event and event should return 0 on no action performed, 1 when no
  * further processing should be done and negative on error
  *
  * input_mapping shall return a negative value to completely ignore this usage
  * (e.g. doubled or invalid usage), zero to continue with parsing of this
  * usage by generic code (no special handling needed) or positive to skip
  * generic parsing (needed special handling which was done in the hook already)
  * input_mapped shall return negative to inform the layer that this usage
  * should not be considered for further processing or zero to notify that
  * no processing was performed and should be done in a generic manner
  * Both these functions may be NULL which means the same behavior as returning
  * zero from them.
  */
 struct hid_driver {
 	char *name;
 	const struct hid_device_id *id_table;
 	int (*probe)(struct hid_device *dev, const struct hid_device_id *id);
 	void (*remove)(struct hid_device *dev);
 	const struct hid_report_id *report_table;
 	int (*raw_event)(struct hid_device *hdev, struct hid_report *report,
 			u8 *data, int size);
 	const struct hid_usage_id *usage_table;
 	int (*event)(struct hid_device *hdev, struct hid_field *field,
 			struct hid_usage *usage, __s32 value);
 	void (*report_fixup)(struct hid_device *hdev, __u8 *buf,
 			unsigned int size);
 	int (*input_mapping)(struct hid_device *hdev,
 			struct hid_input *hidinput, struct hid_field *field,
 			struct hid_usage *usage, unsigned long **bit, int *max);
 	int (*input_mapped)(struct hid_device *hdev,
 			struct hid_input *hidinput, struct hid_field *field,
 			struct hid_usage *usage, unsigned long **bit, int *max);
 /* private: */
 	struct device_driver driver;
 };
 /**
  * hid_ll_driver - low level driver callbacks
  * @start: called on probe to start the device
  * @stop: called on remove
  * @open: called by input layer on open
  * @close: called by input layer on close
  * @hidinput_input_event: event input event (e.g. ff or leds)
  * @parse: this method is called only once to parse the device data,
  *	   shouldn't allocate anything to not leak memory
  */
 struct hid_ll_driver {
 	int (*start)(struct hid_device *hdev);
 	void (*stop)(struct hid_device *hdev);
 	int (*open)(struct hid_device *hdev);
 	void (*close)(struct hid_device *hdev);
 	int (*hidinput_input_event) (struct input_dev *idev, unsigned int type,
 			unsigned int code, int value);
 	int (*parse)(struct hid_device *hdev);
 };
 /* Applications from HID Usage Tables 4/8/99 Version 1.1 */
 /* We ignore a few input applications that are not widely used */
 #define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001) || (a == 0x000d0002))
 /* HID core API */
 #ifdef CONFIG_HID_DEBUG
 extern int hid_debug;
 #endif
 extern int hid_add_device(struct hid_device *);
 extern void hid_destroy_device(struct hid_device *);
 extern int __must_check __hid_register_driver(struct hid_driver *,
 		struct module *, const char *mod_name);
 static inline int __must_check hid_register_driver(struct hid_driver *driver)
 {
 	return __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME);
 }
 extern void hid_unregister_driver(struct hid_driver *);
 extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
 extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
 extern int hidinput_connect(struct hid_device *);
 extern void hidinput_disconnect(struct hid_device *);
 int hid_set_field(struct hid_field *, unsigned, __s32);
 int hid_input_report(struct hid_device *, int type, u8 *, int, int);
 int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field);
 int hidinput_mapping_quirks(struct hid_usage *, struct hid_input *,
 		unsigned long **, int *);
 int hidinput_event_quirks(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
 void hid_output_report(struct hid_report *report, __u8 *data);
 struct hid_device *hid_allocate_device(void);
 int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size);
 /**
  * hid_map_usage - map usage input bits
  *
  * @hidinput: hidinput which we are interested in
  * @usage: usage to fill in
  * @bit: pointer to input->{}bit (out parameter)
  * @max: maximal valid usage->code to consider later (out parameter)
  * @type: input event type (EV_KEY, EV_REL, ...)
  * @c: code which corresponds to this usage and type
  */
 static inline void hid_map_usage(struct hid_input *hidinput,
 		struct hid_usage *usage, unsigned long **bit, int *max,
 		__u8 type, __u16 c)
 {
 	struct input_dev *input = hidinput->input;
 	usage->type = type;
 	usage->code = c;
 	switch (type) {
 	case EV_ABS:
 		*bit = input->absbit;
 		*max = ABS_MAX;
 		break;
 	case EV_REL:
 		*bit = input->relbit;
 		*max = REL_MAX;
 		break;
 	case EV_KEY:
 		*bit = input->keybit;
 		*max = KEY_MAX;
 		break;
 	case EV_LED:
 		*bit = input->ledbit;
 		*max = LED_MAX;
 		break;
 	}
 }
 /**
  * hid_map_usage_clear - map usage input bits and clear the input bit
  *
  * The same as hid_map_usage, except the @c bit is also cleared in supported
  * bits (@bit).
  */
 static inline void hid_map_usage_clear(struct hid_input *hidinput,
 		struct hid_usage *usage, unsigned long **bit, int *max,
 		__u8 type, __u16 c)
 {
 	hid_map_usage(hidinput, usage, bit, max, type, c);
 	clear_bit(c, *bit);
 }
 /**
  * hid_parse - parse HW reports
  *
  * @hdev: hid device
  *
  * Call this from probe after you set up the device (if needed). Your
  * report_fixup will be called (if non-NULL) after reading raw report from
  * device before passing it to hid layer for real parsing.
  */
 static inline int __must_check hid_parse(struct hid_device *hdev)
 {
 	int ret;
 	if (hdev->status & HID_STAT_PARSED)
 		return 0;
 	ret = hdev->ll_driver->parse(hdev);
 	if (!ret)
 		hdev->status |= HID_STAT_PARSED;
 	return ret;
 }
 /**
  * hid_hw_start - start underlaying HW
  *
  * @hdev: hid device
  *
  * Call this in probe function *after* hid_parse. This will setup HW buffers
  * and start the device (if not deffered to device open). hid_hw_stop must be
  * called if this was successfull.
  */
 static inline int __must_check hid_hw_start(struct hid_device *hdev)
 {
 	return hdev->ll_driver->start(hdev);
 }
 /**
  * hid_hw_stop - stop underlaying HW
  *
  * @hdev: hid device
  *
  * This is usually called from remove function or from probe when something
  * failed and hid_hw_start was called already.
  */
 static inline void hid_hw_stop(struct hid_device *hdev)
 {
 	hdev->ll_driver->stop(hdev);
 }
 void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
 		int interrupt);
 extern int hid_generic_init(void);
 extern void hid_generic_exit(void);
 /* HID quirks API */
 u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct);
 int usbhid_quirks_init(char **quirks_param);
 void usbhid_quirks_exit(void);
 void usbhid_fixup_report_descriptor(const u16, const u16, char *, unsigned, char **);
 #ifdef CONFIG_HID_FF
 int hid_ff_init(struct hid_device *hid);
 int hid_lgff_init(struct hid_device *hid);
 int hid_lg2ff_init(struct hid_device *hid);
 int hid_plff_init(struct hid_device *hid);
 int hid_tmff_init(struct hid_device *hid);
 int hid_zpff_init(struct hid_device *hid);
 #ifdef CONFIG_HID_PID
 int hid_pidff_init(struct hid_device *hid);
 #else
 static inline int hid_pidff_init(struct hid_device *hid) { return -ENODEV; }
 #endif
 #else
 static inline int hid_ff_init(struct hid_device *hid) { return -1; }
 #endif
 #ifdef CONFIG_HID_DEBUG
 #define dbg_hid(format, arg...) if (hid_debug) \
 				printk(KERN_DEBUG "%s: " format ,\
 				__FILE__ , ## arg)
 #define dbg_hid_line(format, arg...) if (hid_debug) \
 				printk(format, ## arg)
 #else
 static inline int __attribute__((format(printf, 1, 2)))
 dbg_hid(const char *fmt, ...)
 {
 	return 0;
 }
 #define dbg_hid_line dbg_hid
 #endif /* HID_DEBUG */
 #define err_hid(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
 		__FILE__ , ## arg)
 #endif /* HID_FF */
 #ifdef CONFIG_HID_COMPAT
 #define HID_COMPAT_LOAD_DRIVER(name)	\
 void hid_compat_##name(void) { }	\
 EXPORT_SYMBOL(hid_compat_##name)
 #else
 #define HID_COMPAT_LOAD_DRIVER(name)
 #endif /* HID_COMPAT */
 #define HID_COMPAT_CALL_DRIVER(name)	do {	\
 	extern void hid_compat_##name(void);	\
 	hid_compat_##name();			\
 } while (0)
 #endif