11 files changed, 2578 insertions, 1600 deletions

diff --git a/usr/src/dkms_source_tree/KERNEL_SOURCE_VERSION b/usr/src/dkms_source_tree/KERNEL_SOURCE_VERSION
index 9cd2822..2c689b1 100644
--- a/usr/src/dkms_source_tree/KERNEL_SOURCE_VERSION
+++ b/usr/src/dkms_source_tree/KERNEL_SOURCE_VERSION
@@ -1 +1 @@
-2.6.27-7-generic
+2.6.35-19-generic
diff --git a/usr/src/dkms_source_tree/Makefile b/usr/src/dkms_source_tree/Makefile
index 2537695..2da5113 100644
--- a/usr/src/dkms_source_tree/Makefile
+++ b/usr/src/dkms_source_tree/Makefile
@@ -1,9 +1,12 @@
 #
 # Makefile for the HID driver
 #
-hid-objs                        := hid-core.o hid-input.o hid-input-quirks.o
+hid-objs                        := hid-core.o hid-input.o
+
+ifdef CONFIG_DEBUG_FS
+        hid-objs                += hid-debug.o
+endif
 
 obj-$(CONFIG_HID)               += hid.o
 
-hid-$(CONFIG_HID_DEBUG)         += hid-debug.o
 hid-$(CONFIG_HIDRAW)            += hidraw.o
diff --git a/usr/src/dkms_source_tree/dkms.conf b/usr/src/dkms_source_tree/dkms.conf
index 46a66a3..111cc05 100644
--- a/usr/src/dkms_source_tree/dkms.conf
+++ b/usr/src/dkms_source_tree/dkms.conf
@@ -1,5 +1,5 @@
 NAME=hid
-VERSION=0.11.1
+VERSION=1.0.0
 PACKAGE_NAME="$NAME"
 PACKAGE_VERSION="$VERSION"
 MAKE[0]="make -C ${kernel_source_dir}
diff --git a/usr/src/dkms_source_tree/hid-core.c b/usr/src/dkms_source_tree/hid-core.c
index 426ac5a..79fc152 100644
--- a/usr/src/dkms_source_tree/hid-core.c
+++ b/usr/src/dkms_source_tree/hid-core.c
@@ -4,7 +4,7 @@
  *  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) 2006-2010 Jiri Kosina
  */
 
 /*
@@ -33,27 +33,25 @@
 #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)");
+MODULE_PARM_DESC(debug, "toggle HID debugging messages");
 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 *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;
@@ -77,6 +75,7 @@ static struct hid_report *hid_register_report(struct hid_device *device, unsigne
 
         return report;
 }
+EXPORT_SYMBOL_GPL(hid_register_report);
 
 /*
  * Register a new field for this report.
@@ -268,9 +267,9 @@ static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsign
 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;
+        case 1: return item->data.u8;
+        case 2: return item->data.u16;
+        case 4: return item->data.u32;
         }
         return 0;
 }
@@ -278,9 +277,9 @@ static u32 item_udata(struct hid_item *item)
 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;
+        case 1: return item->data.s8;
+        case 2: return item->data.s16;
+        case 4: return item->data.s32;
         }
         return 0;
 }
@@ -292,87 +291,91 @@ static s32 item_sdata(struct hid_item *item)
 static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
 {
         switch (item->tag) {
+        case HID_GLOBAL_ITEM_TAG_PUSH:
 
-                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;
+                if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
+                        dbg_hid("global enviroment stack overflow\n");
+                        return -1;
+                }
 
-                case HID_GLOBAL_ITEM_TAG_POP:
+                memcpy(parser->global_stack + parser->global_stack_ptr++,
+                        &parser->global, sizeof(struct hid_global));
+                return 0;
 
-                        if (!parser->global_stack_ptr) {
-                                dbg_hid("global enviroment stack underflow\n");
-                                return -1;
-                        }
+        case HID_GLOBAL_ITEM_TAG_POP:
 
-                        memcpy(&parser->global, parser->global_stack + --parser->global_stack_ptr,
-                                sizeof(struct hid_global));
-                        return 0;
+                if (!parser->global_stack_ptr) {
+                        dbg_hid("global enviroment stack underflow\n");
+                        return -1;
+                }
 
-                case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
-                        parser->global.usage_page = item_udata(item);
-                        return 0;
+                memcpy(&parser->global, parser->global_stack +
+                        --parser->global_stack_ptr, sizeof(struct hid_global));
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
-                        parser->global.logical_minimum = item_sdata(item);
-                        return 0;
+        case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
+                parser->global.usage_page = item_udata(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_LOGICAL_MINIMUM:
+                parser->global.logical_minimum = item_sdata(item);
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
-                        parser->global.physical_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_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_PHYSICAL_MINIMUM:
+                parser->global.physical_minimum = item_sdata(item);
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
-                        parser->global.unit_exponent = 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:
-                        parser->global.unit = 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_REPORT_SIZE:
-                        if ((parser->global.report_size = item_udata(item)) > 32) {
-                                dbg_hid("invalid report_size %d\n", parser->global.report_size);
-                                return -1;
-                        }
-                        return 0;
+        case HID_GLOBAL_ITEM_TAG_UNIT:
+                parser->global.unit = item_udata(item);
+                return 0;
 
-                case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
-                        if ((parser->global.report_count = item_udata(item)) > HID_MAX_USAGES) {
-                                dbg_hid("invalid report_count %d\n", parser->global.report_count);
-                                return -1;
-                        }
-                        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_ID:
-                        if ((parser->global.report_id = item_udata(item)) == 0) {
-                                dbg_hid("report_id 0 is invalid\n");
-                                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;
 
-                default:
-                        dbg_hid("unknown global tag 0x%x\n", item->tag);
+        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;
         }
 }
 
@@ -385,7 +388,8 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
         __u32 data;
         unsigned n;
 
-        if (item->size == 0) {
+        /* Local delimiter could have value 0, which allows size to be 0 */
+        if (item->size == 0 && item->tag != HID_LOCAL_ITEM_TAG_DELIMITER) {
                 dbg_hid("item data expected for local item\n");
                 return -1;
         }
@@ -393,77 +397,76 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
         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--;
+        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;
                         }
-                        return 1;
-
-                case HID_LOCAL_ITEM_TAG_USAGE:
-
-                        if (parser->local.delimiter_branch > 1) {
-                                dbg_hid("alternative usage ignored\n");
-                                return 0;
+                        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;
 
-                        if (item->size <= 2)
-                                data = (parser->global.usage_page << 16) + data;
+        case HID_LOCAL_ITEM_TAG_USAGE:
 
-                        return hid_add_usage(parser, data);
+                if (parser->local.delimiter_branch > 1) {
+                        dbg_hid("alternative usage ignored\n");
+                        return 0;
+                }
 
-                case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
+                if (item->size <= 2)
+                        data = (parser->global.usage_page << 16) + data;
 
-                        if (parser->local.delimiter_branch > 1) {
-                                dbg_hid("alternative usage ignored\n");
-                                return 0;
-                        }
+                return hid_add_usage(parser, data);
 
-                        if (item->size <= 2)
-                                data = (parser->global.usage_page << 16) + data;
+        case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 
-                        parser->local.usage_minimum = data;
+                if (parser->local.delimiter_branch > 1) {
+                        dbg_hid("alternative usage ignored\n");
                         return 0;
+                }
 
-                case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
+                if (item->size <= 2)
+                        data = (parser->global.usage_page << 16) + data;
 
-                        if (parser->local.delimiter_branch > 1) {
-                                dbg_hid("alternative usage ignored\n");
-                                return 0;
-                        }
+                parser->local.usage_minimum = data;
+                return 0;
 
-                        if (item->size <= 2)
-                                data = (parser->global.usage_page << 16) + data;
+        case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 
-                        for (n = parser->local.usage_minimum; n <= data; n++)
-                                if (hid_add_usage(parser, n)) {
-                                        dbg_hid("hid_add_usage failed\n");
-                                        return -1;
-                                }
+                if (parser->local.delimiter_branch > 1) {
+                        dbg_hid("alternative usage ignored\n");
                         return 0;
+                }
 
-                default:
+                if (item->size <= 2)
+                        data = (parser->global.usage_page << 16) + data;
 
-                        dbg_hid("unknown local item tag 0x%x\n", item->tag);
-                        return 0;
+                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;
 }
@@ -480,24 +483,24 @@ static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
         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;
+        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 */
@@ -534,9 +537,10 @@ static void hid_free_report(struct hid_report *report)
  * Free a device structure, all reports, and all fields.
  */
 
-void hid_free_device(struct hid_device *device)
+static void hid_device_release(struct device *dev)
 {
-        unsigned i,j;
+        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;
@@ -552,7 +556,6 @@ void hid_free_device(struct hid_device *device)
         kfree(device->collection);
         kfree(device);
 }
-EXPORT_SYMBOL_GPL(hid_free_device);
 
 /*
  * Fetch a report description item from the data stream. We support long
@@ -593,47 +596,52 @@ static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
         item->size = b & 3;
 
         switch (item->size) {
+        case 0:
+                return start;
 
-                case 0:
-                        return start;
-
-                case 1:
-                        if ((end - start) < 1)
-                                return NULL;
-                        item->data.u8 = *start++;
-                        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 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;
+        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.
  */
-
-struct hid_device *hid_parse_report(__u8 *start, unsigned size)
+int hid_parse_report(struct hid_device *device, __u8 *start,
+                unsigned size)
 {
-        struct hid_device *device;
         struct hid_parser *parser;
         struct hid_item item;
         __u8 *end;
-        unsigned i;
+        int ret;
         static int (*dispatch_type[])(struct hid_parser *parser,
                                       struct hid_item *item) = {
                 hid_parser_main,
@@ -642,76 +650,56 @@ struct hid_device *hid_parse_report(__u8 *start, unsigned size)
                 hid_parser_reserved
         };
 
-        if (!(device = kzalloc(sizeof(struct hid_device), GFP_KERNEL)))
-                return NULL;
-
-        if (!(device->collection = kzalloc(sizeof(struct hid_collection) *
-                                   HID_DEFAULT_NUM_COLLECTIONS, GFP_KERNEL))) {
-                kfree(device);
-                return NULL;
-        }
-        device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
+        if (device->driver->report_fixup)
+                device->driver->report_fixup(device, start, size);
 
-        for (i = 0; i < HID_REPORT_TYPES; i++)
-                INIT_LIST_HEAD(&device->report_enum[i].report_list);
-
-        if (!(device->rdesc = kmalloc(size, GFP_KERNEL))) {
-                kfree(device->collection);
-                kfree(device);
-                return NULL;
-        }
-        memcpy(device->rdesc, start, size);
+        device->rdesc = kmemdup(start, size, GFP_KERNEL);
+        if (device->rdesc == NULL)
+                return -ENOMEM;
         device->rsize = size;
 
-        if (!(parser = vmalloc(sizeof(struct hid_parser)))) {
-                kfree(device->rdesc);
-                kfree(device->collection);
-                kfree(device);
-                return NULL;
+        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");
-                        hid_free_device(device);
-                        vfree(parser);
-                        return NULL;
+                        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);
-                        hid_free_device(device);
-                        vfree(parser);
-                        return NULL;
+                        goto err;
                 }
 
                 if (start == end) {
                         if (parser->collection_stack_ptr) {
                                 dbg_hid("unbalanced collection at end of report description\n");
-                                hid_free_device(device);
-                                vfree(parser);
-                                return NULL;
+                                goto err;
                         }
                         if (parser->local.delimiter_depth) {
                                 dbg_hid("unbalanced delimiter at end of report description\n");
-                                hid_free_device(device);
-                                vfree(parser);
-                                return NULL;
+                                goto err;
                         }
                         vfree(parser);
-                        return device;
+                        return 0;
                 }
         }
 
         dbg_hid("item fetching failed at offset %d\n", (int)(end - start));
-        hid_free_device(device);
+err:
         vfree(parser);
-        return NULL;
+        return ret;
 }
 EXPORT_SYMBOL_GPL(hid_parse_report);
 
@@ -724,9 +712,9 @@ EXPORT_SYMBOL_GPL(hid_parse_report);
 static s32 snto32(__u32 value, unsigned n)
 {
         switch (n) {
-                case 8:  return ((__s8)value);
-                case 16: return ((__s16)value);
-                case 32: return ((__s32)value);
+        case 8:  return ((__s8)value);
+        case 16: return ((__s16)value);
+        case 32: return ((__s32)value);
         }
         return value & (1 << (n - 1)) ? value | (-1 << n) : value;
 }
@@ -815,9 +803,73 @@ static __inline__ int search(__s32 *array, __s32 value, unsigned n)
         return -1;
 }
 
-static void hid_process_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value, int interrupt)
+/**
+ * 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)
 {
-        hid_dump_input(usage, value);
+        struct hid_driver *hdrv = hid->driver;
+        int ret;
+
+        hid_dump_input(hid, 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)
@@ -887,13 +939,8 @@ 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));
@@ -913,6 +960,7 @@ void hid_output_report(struct hid_report *report, __u8 *data)
         if (report->id > 0)
                 *data++ = report->id;
 
+        memset(data, 0, ((report->size - 1) >> 3) + 1);
         for (n = 0; n < report->maxfield; n++)
                 hid_output_field(report->field[n], data);
 }
@@ -928,11 +976,10 @@ int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
 {
         unsigned size = field->report_size;
 
-        hid_dump_input(field->usage + offset, value);
+        hid_dump_input(field->report->device, 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) {
@@ -946,78 +993,969 @@ int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
 }
 EXPORT_SYMBOL_GPL(hid_set_field);
 
-int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)
+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;
-        int n, rsize, i;
+        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)
+                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: distinguish between interrupt and control transfers
+ *
+ * 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;
+        struct hid_driver *hdrv;
+        struct hid_report *report;
+        char *buf;
+        unsigned int i;
+        int ret;
 
-        if (!hid)
+        if (!hid || !hid->driver)
                 return -ENODEV;
+        report_enum = hid->report_enum + type;
+        hdrv = hid->driver;
 
         if (!size) {
                 dbg_hid("empty report\n");
                 return -1;
         }
 
-        dbg_hid("report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
+        buf = kmalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);
 
-        n = 0;                          /* Normally report number is 0 */
-        if (report_enum->numbered) {    /* Device uses numbered reports, data[0] is report number */
-                n = *data++;
-                size--;
-        }
+        if (!buf)
+                goto nomem;
 
         /* dump the report */
-        dbg_hid("report %d (size %u) = ", n, size);
-        for (i = 0; i < size; i++)
-                dbg_hid_line(" %02x", data[i]);
-        dbg_hid_line("\n");
+        snprintf(buf, HID_DEBUG_BUFSIZE - 1,
+                        "\nreport (size %u) (%snumbered) = ", size, report_enum->numbered ? "" : "un");
+        hid_debug_event(hid, buf);
+
+        for (i = 0; i < size; i++) {
+                snprintf(buf, HID_DEBUG_BUFSIZE - 1,
+                                " %02x", data[i]);
+                hid_debug_event(hid, buf);
+        }
+        hid_debug_event(hid, "\n");
+        kfree(buf);
+
+nomem:
+        report = hid_get_report(report_enum, data);
 
-        if (!(report = report_enum->report_id_hash[n])) {
-                dbg_hid("undefined report_id %d received\n", n);
+        if (!report)
                 return -1;
+
+        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;
         }
 
-        rsize = ((report->size - 1) >> 3) + 1;
+        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_hiddev_list[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) },
+        { }
+};
+
+static bool hid_hiddev(struct hid_device *hdev)
+{
+        return !!hid_match_id(hdev, hid_hiddev_list);
+}
 
-        if (size < rsize) {
-                dbg_hid("report %d is too short, (%d < %d)\n", report->id, size, rsize);
-                memset(data + size, 0, rsize - size);
+int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
+{
+        static const char *types[] = { "Device", "Pointer", "Mouse", "Device",
+                "Joystick", "Gamepad", "Keyboard", "Keypad",
+                "Multi-Axis Controller"
+        };
+        const char *type, *bus;
+        char buf[64];
+        unsigned int i;
+        int len;
+
+        if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)
+                connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV);
+        if (hdev->bus != BUS_USB)
+                connect_mask &= ~HID_CONNECT_HIDDEV;
+        if (hid_hiddev(hdev))
+                connect_mask |= HID_CONNECT_HIDDEV_FORCE;
+
+        if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,
+                                connect_mask & HID_CONNECT_HIDINPUT_FORCE))
+                hdev->claimed |= HID_CLAIMED_INPUT;
+        if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&
+                        !hdev->hiddev_connect(hdev,
+                                connect_mask & HID_CONNECT_HIDDEV_FORCE))
+                hdev->claimed |= HID_CLAIMED_HIDDEV;
+        if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))
+                hdev->claimed |= HID_CLAIMED_HIDRAW;
+
+        if (!hdev->claimed) {
+                dev_err(&hdev->dev, "claimed by neither input, hiddev nor "
+                                "hidraw\n");
+                return -ENODEV;
         }
 
-        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);
+        if ((hdev->claimed & HID_CLAIMED_INPUT) &&
+                        (connect_mask & HID_CONNECT_FF) && hdev->ff_init)
+                hdev->ff_init(hdev);
+
+        len = 0;
+        if (hdev->claimed & HID_CLAIMED_INPUT)
+                len += sprintf(buf + len, "input");
+        if (hdev->claimed & HID_CLAIMED_HIDDEV)
+                len += sprintf(buf + len, "%shiddev%d", len ? "," : "",
+                                hdev->minor);
+        if (hdev->claimed & HID_CLAIMED_HIDRAW)
+                len += sprintf(buf + len, "%shidraw%d", len ? "," : "",
+                                ((struct hidraw *)hdev->hidraw)->minor);
+
+        type = "Device";
+        for (i = 0; i < hdev->maxcollection; i++) {
+                struct hid_collection *col = &hdev->collection[i];
+                if (col->type == HID_COLLECTION_APPLICATION &&
+                   (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
+                   (col->usage & 0xffff) < ARRAY_SIZE(types)) {
+                        type = types[col->usage & 0xffff];
+                        break;
+                }
         }
 
-        for (n = 0; n < report->maxfield; n++)
-                hid_input_field(hid, report->field[n], data, interrupt);
+        switch (hdev->bus) {
+        case BUS_USB:
+                bus = "USB";
+                break;
+        case BUS_BLUETOOTH:
+                bus = "BLUETOOTH";
+                break;
+        default:
+                bus = "<UNKNOWN>";
+        }
 
-        if (hid->claimed & HID_CLAIMED_INPUT)
-                hidinput_report_event(hid, report);
+        dev_info(&hdev->dev, "%s: %s HID v%x.%02x %s [%s] on %s\n",
+                        buf, bus, hdev->version >> 8, hdev->version & 0xff,
+                        type, hdev->name, hdev->phys);
 
         return 0;
 }
-EXPORT_SYMBOL_GPL(hid_input_report);
+EXPORT_SYMBOL_GPL(hid_connect);
+
+void hid_disconnect(struct hid_device *hdev)
+{
+        if (hdev->claimed & HID_CLAIMED_INPUT)
+                hidinput_disconnect(hdev);
+        if (hdev->claimed & HID_CLAIMED_HIDDEV)
+                hdev->hiddev_disconnect(hdev);
+        if (hdev->claimed & HID_CLAIMED_HIDRAW)
+                hidraw_disconnect(hdev);
+}
+EXPORT_SYMBOL_GPL(hid_disconnect);
+
+/* a list of devices for which there is a specialized driver on HID bus */
+static const struct hid_device_id hid_blacklist[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M1968) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M2256) },
+        { 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_ATV_IRCONTROL) },
+        { 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_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICTRACKPAD) },
+        { 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_MINI_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_JIS) },
+        { 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_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },
+        { 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_WELLSPRING3_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },
+        { 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_BELKIN, USB_DEVICE_ID_FLIP_KVM) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },
+        { 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_BARCODE_3) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
+        { 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_ELITE_KBD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },
+        { 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_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_STANTUM, USB_DEVICE_ID_MTP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb323) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb324) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb653) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ZYDACRON, USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL) },
+
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
+        { }
+};
+
+struct hid_dynid {
+        struct list_head list;
+        struct hid_device_id id;
+};
+
+/**
+ * store_new_id - add a new HID device ID to this driver and re-probe devices
+ * @driver: target device driver
+ * @buf: buffer for scanning device ID data
+ * @count: input size
+ *
+ * Adds a new dynamic hid device ID to this driver,
+ * and causes the driver to probe for all devices again.
+ */
+static ssize_t store_new_id(struct device_driver *drv, const char *buf,
+                size_t count)
+{
+        struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);
+        struct hid_dynid *dynid;
+        __u32 bus, vendor, product;
+        unsigned long driver_data = 0;
+        int ret;
+
+        ret = sscanf(buf, "%x %x %x %lx",
+                        &bus, &vendor, &product, &driver_data);
+        if (ret < 3)
+                return -EINVAL;
+
+        dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
+        if (!dynid)
+                return -ENOMEM;
+
+        dynid->id.bus = bus;
+        dynid->id.vendor = vendor;
+        dynid->id.product = product;
+        dynid->id.driver_data = driver_data;
+
+        spin_lock(&hdrv->dyn_lock);
+        list_add_tail(&dynid->list, &hdrv->dyn_list);
+        spin_unlock(&hdrv->dyn_lock);
+
+        ret = 0;
+        if (get_driver(&hdrv->driver)) {
+                ret = driver_attach(&hdrv->driver);
+                put_driver(&hdrv->driver);
+        }
+
+        return ret ? : count;
+}
+static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
+
+static void hid_free_dynids(struct hid_driver *hdrv)
+{
+        struct hid_dynid *dynid, *n;
+
+        spin_lock(&hdrv->dyn_lock);
+        list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) {
+                list_del(&dynid->list);
+                kfree(dynid);
+        }
+        spin_unlock(&hdrv->dyn_lock);
+}
+
+static const struct hid_device_id *hid_match_device(struct hid_device *hdev,
+                struct hid_driver *hdrv)
+{
+        struct hid_dynid *dynid;
+
+        spin_lock(&hdrv->dyn_lock);
+        list_for_each_entry(dynid, &hdrv->dyn_list, list) {
+                if (hid_match_one_id(hdev, &dynid->id)) {
+                        spin_unlock(&hdrv->dyn_lock);
+                        return &dynid->id;
+                }
+        }
+        spin_unlock(&hdrv->dyn_lock);
+
+        return hid_match_id(hdev, hdrv->id_table);
+}
+
+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_device(hdev, hdrv))
+                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_device(hdev, hdrv);
+                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, HID_CONNECT_DEFAULT);
+                }
+                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,
+};
+
+/* a list of devices that shouldn't be handled by HID core at all */
+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_T91MT)},
+        { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM)},
+        { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM2)},
+        { HID_USB_DEVICE(USB_VENDOR_ID_AVERMEDIA, USB_DEVICE_ID_AVER_FM_MR800) },
+        { 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_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) },
+        { 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_ETT, USB_DEVICE_ID_TC5UH) },
+        { 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_KWORLD, USB_DEVICE_ID_KWORLD_RADIO_FM700) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_KYE, 0x0058) },
+        { 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_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_PHILIPS, USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_POWERCOM, USB_DEVICE_ID_POWERCOM_UPS) },
+        { 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) },
+        { }
+};
+
+/**
+ * hid_mouse_ignore_list - mouse devices which should not be handled by the hid layer
+ *
+ * There are composite devices for which we want to ignore only a certain
+ * interface. This is a list of devices for which only the mouse interface will
+ * be ignored. This allows a dedicated driver to take care of the interface.
+ */
+static const struct hid_device_id hid_mouse_ignore_list[] = {
+        /* appletouch driver */
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },
+        { 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) },
+        { }
+};
+
+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;
+        case USB_VENDOR_ID_SOUNDGRAPH:
+                if (hdev->product >= USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST &&
+                    hdev->product <= USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST)
+                        return true;
+                break;
+        }
+
+        if (hdev->type == HID_TYPE_USBMOUSE &&
+                        hid_match_id(hdev, hid_mouse_ignore_list))
+                return true;
+
+        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 (!(hdev->quirks & HID_QUIRK_NO_IGNORE)
+            && (hid_ignore(hdev) || (hdev->quirks & HID_QUIRK_IGNORE)))
+                return -ENODEV;
+
+        /* XXX hack, any other cleaner solution after the driver core
+         * is converted to allow more than 20 bytes as the device name? */
+        dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,
+                     hdev->vendor, hdev->product, atomic_inc_return(&id));
+
+        hid_debug_register(hdev, dev_name(&hdev->dev));
+        ret = device_add(&hdev->dev);
+        if (!ret)
+                hdev->status |= HID_STAT_ADDED;
+        else
+                hid_debug_unregister(hdev);
+
+        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);
+
+        init_waitqueue_head(&hdev->debug_wait);
+        INIT_LIST_HEAD(&hdev->debug_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);
+                hid_debug_unregister(hdev);
+                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)
+{
+        int ret;
+
+        hdrv->driver.name = hdrv->name;
+        hdrv->driver.bus = &hid_bus_type;
+        hdrv->driver.owner = owner;
+        hdrv->driver.mod_name = mod_name;
+
+        INIT_LIST_HEAD(&hdrv->dyn_list);
+        spin_lock_init(&hdrv->dyn_lock);
+
+        ret = driver_register(&hdrv->driver);
+        if (ret)
+                return ret;
+
+        ret = driver_create_file(&hdrv->driver, &driver_attr_new_id);
+        if (ret)
+                driver_unregister(&hdrv->driver);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(__hid_register_driver);
+
+void hid_unregister_driver(struct hid_driver *hdrv)
+{
+        driver_remove_file(&hdrv->driver, &driver_attr_new_id);
+        driver_unregister(&hdrv->driver);
+        hid_free_dynids(hdrv);
+}
+EXPORT_SYMBOL_GPL(hid_unregister_driver);
+
+int hid_check_keys_pressed(struct hid_device *hid)
+{
+        struct hid_input *hidinput;
+        int i;
+
+        if (!(hid->claimed & HID_CLAIMED_INPUT))
+                return 0;
+
+        list_for_each_entry(hidinput, &hid->inputs, list) {
+                for (i = 0; i < BITS_TO_LONGS(KEY_MAX); i++)
+                        if (hidinput->input->key[i])
+                                return 1;
+        }
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(hid_check_keys_pressed);
 
 static int __init hid_init(void)
 {
-        return hidraw_init();
+        int ret;
+
+        if (hid_debug)
+                printk(KERN_WARNING "HID: hid_debug is now used solely for parser and driver debugging.\n"
+                                "HID: debugfs is now used for inspecting the device (report descriptor, reports)\n");
+
+        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;
+
+        hid_debug_init();
+
+        return 0;
+err_bus:
+        bus_unregister(&hid_bus_type);
+err:
+        return ret;
 }
 
 static void __exit hid_exit(void)
 {
+        hid_debug_exit();
         hidraw_exit();
+        bus_unregister(&hid_bus_type);
 }
 
 module_init(hid_init);
 module_exit(hid_exit);
 
+MODULE_AUTHOR("Andreas Gal");
+MODULE_AUTHOR("Vojtech Pavlik");
+MODULE_AUTHOR("Jiri Kosina");
 MODULE_LICENSE(DRIVER_LICENSE);
 
diff --git a/usr/src/dkms_source_tree/hid-debug.c b/usr/src/dkms_source_tree/hid-debug.c
index 47ac1a7..850d02a 100644
--- a/usr/src/dkms_source_tree/hid-debug.c
+++ b/usr/src/dkms_source_tree/hid-debug.c
@@ -1,9 +1,9 @@
 /*
  *  (c) 1999 Andreas Gal                <gal@cs.uni-magdeburg.de>
  *  (c) 2000-2001 Vojtech Pavlik        <vojtech@ucw.cz>
- *  (c) 2007 Jiri Kosina
+ *  (c) 2007-2009 Jiri Kosina
  *
- *  Some debug stuff for the HID parser.
+ *  HID debugging support
  */
 
 /*
@@ -26,9 +26,18 @@
  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  */
 
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/poll.h>
+
 #include <linux/hid.h>
 #include <linux/hid-debug.h>
 
+static struct dentry *hid_debug_root;
+
 struct hid_usage_entry {
         unsigned  page;
         unsigned  usage;
@@ -137,6 +146,14 @@ static const struct hid_usage_entry hid_usage_table[] = {
     {0, 0x44, "BarrelSwitch"},
     {0, 0x45, "Eraser"},
     {0, 0x46, "TabletPick"},
+    {0, 0x47, "Confidence"},
+    {0, 0x48, "Width"},
+    {0, 0x49, "Height"},
+    {0, 0x51, "ContactID"},
+    {0, 0x52, "InputMode"},
+    {0, 0x53, "DeviceIndex"},
+    {0, 0x54, "ContactCount"},
+    {0, 0x55, "ContactMaximumNumber"},
   { 15, 0, "PhysicalInterfaceDevice" },
     {0, 0x00, "Undefined"},
     {0, 0x01, "Physical_Interface_Device"},
@@ -331,72 +348,120 @@ static const struct hid_usage_entry hid_usage_table[] = {
   { 0, 0, NULL }
 };
 
-static void resolv_usage_page(unsigned page) {
+/* Either output directly into simple seq_file, or (if f == NULL)
+ * allocate a separate buffer that will then be passed to the 'events'
+ * ringbuffer.
+ *
+ * This is because these functions can be called both for "one-shot"
+ * "rdesc" while resolving, or for blocking "events".
+ *
+ * This holds both for resolv_usage_page() and hid_resolv_usage().
+ */
+static char *resolv_usage_page(unsigned page, struct seq_file *f) {
         const struct hid_usage_entry *p;
+        char *buf = NULL;
+
+        if (!f) {
+                buf = kzalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_ATOMIC);
+                if (!buf)
+                        return ERR_PTR(-ENOMEM);
+        }
 
         for (p = hid_usage_table; p->description; p++)
                 if (p->page == page) {
-                        printk("%s", p->description);
-                        return;
+                        if (!f) {
+                                snprintf(buf, HID_DEBUG_BUFSIZE, "%s",
+                                                p->description);
+                                return buf;
+                        }
+                        else {
+                                seq_printf(f, "%s", p->description);
+                                return NULL;
+                        }
                 }
-        printk("%04x", page);
+        if (!f)
+                snprintf(buf, HID_DEBUG_BUFSIZE, "%04x", page);
+        else
+                seq_printf(f, "%04x", page);
+        return buf;
 }
 
-void hid_resolv_usage(unsigned usage) {
+char *hid_resolv_usage(unsigned usage, struct seq_file *f) {
         const struct hid_usage_entry *p;
+        char *buf = NULL;
+        int len = 0;
+
+        buf = resolv_usage_page(usage >> 16, f);
+        if (IS_ERR(buf)) {
+                printk(KERN_ERR "error allocating HID debug buffer\n");
+                return NULL;
+        }
 
-        if (!hid_debug)
-                return;
 
-        resolv_usage_page(usage >> 16);
-        printk(".");
+        if (!f) {
+                len = strlen(buf);
+                snprintf(buf+len, max(0, HID_DEBUG_BUFSIZE - len), ".");
+                len++;
+        }
+        else {
+                seq_printf(f, ".");
+        }
         for (p = hid_usage_table; p->description; p++)
                 if (p->page == (usage >> 16)) {
                         for(++p; p->description && p->usage != 0; p++)
                                 if (p->usage == (usage & 0xffff)) {
-                                        printk("%s", p->description);
-                                        return;
+                                        if (!f)
+                                                snprintf(buf + len,
+                                                        max(0,HID_DEBUG_BUFSIZE - len - 1),
+                                                        "%s", p->description);
+                                        else
+                                                seq_printf(f,
+                                                        "%s",
+                                                        p->description);
+                                        return buf;
                                 }
                         break;
                 }
-        printk("%04x", usage & 0xffff);
+        if (!f)
+                snprintf(buf + len, max(0, HID_DEBUG_BUFSIZE - len - 1),
+                                "%04x", usage & 0xffff);
+        else
+                seq_printf(f, "%04x", usage & 0xffff);
+        return buf;
 }
 EXPORT_SYMBOL_GPL(hid_resolv_usage);
 
-static void tab(int n) {
-        printk(KERN_DEBUG "%*s", n, "");
+static void tab(int n, struct seq_file *f) {
+        seq_printf(f, "%*s", n, "");
 }
 
-void hid_dump_field(struct hid_field *field, int n) {
+void hid_dump_field(struct hid_field *field, int n, struct seq_file *f) {
         int j;
 
-        if (!hid_debug)
-                return;
-
         if (field->physical) {
-                tab(n);
-                printk("Physical(");
-                hid_resolv_usage(field->physical); printk(")\n");
+                tab(n, f);
+                seq_printf(f, "Physical(");
+                hid_resolv_usage(field->physical, f); seq_printf(f, ")\n");
         }
         if (field->logical) {
-                tab(n);
-                printk("Logical(");
-                hid_resolv_usage(field->logical); printk(")\n");
+                tab(n, f);
+                seq_printf(f, "Logical(");
+                hid_resolv_usage(field->logical, f); seq_printf(f, ")\n");
         }
-        tab(n); printk("Usage(%d)\n", field->maxusage);
+        tab(n, f); seq_printf(f, "Usage(%d)\n", field->maxusage);
         for (j = 0; j < field->maxusage; j++) {
-                tab(n+2); hid_resolv_usage(field->usage[j].hid); printk("\n");
+                tab(n+2, f); hid_resolv_usage(field->usage[j].hid, f); seq_printf(f, "\n");
         }
         if (field->logical_minimum != field->logical_maximum) {
-                tab(n); printk("Logical Minimum(%d)\n", field->logical_minimum);
-                tab(n); printk("Logical Maximum(%d)\n", field->logical_maximum);
+                tab(n, f); seq_printf(f, "Logical Minimum(%d)\n", field->logical_minimum);
+                tab(n, f); seq_printf(f, "Logical Maximum(%d)\n", field->logical_maximum);
         }
         if (field->physical_minimum != field->physical_maximum) {
-                tab(n); printk("Physical Minimum(%d)\n", field->physical_minimum);
-                tab(n); printk("Physical Maximum(%d)\n", field->physical_maximum);
+                tab(n, f); seq_printf(f, "Physical Minimum(%d)\n", field->physical_minimum);
+                tab(n, f); seq_printf(f, "Physical Maximum(%d)\n", field->physical_maximum);
         }
         if (field->unit_exponent) {
-                tab(n); printk("Unit Exponent(%d)\n", field->unit_exponent);
+                tab(n, f); seq_printf(f, "Unit Exponent(%d)\n", field->unit_exponent);
         }
         if (field->unit) {
                 static const char *systems[5] = { "None", "SI Linear", "SI Rotation", "English Linear", "English Rotation" };
@@ -417,77 +482,75 @@ void hid_dump_field(struct hid_field *field, int n) {
                 data >>= 4;
 
                 if(sys > 4) {
-                        tab(n); printk("Unit(Invalid)\n");
+                        tab(n, f); seq_printf(f, "Unit(Invalid)\n");
                 }
                 else {
                         int earlier_unit = 0;
 
-                        tab(n); printk("Unit(%s : ", systems[sys]);
+                        tab(n, f); seq_printf(f, "Unit(%s : ", systems[sys]);
 
                         for (i=1 ; i<sizeof(__u32)*2 ; i++) {
                                 char nibble = data & 0xf;
                                 data >>= 4;
                                 if (nibble != 0) {
                                         if(earlier_unit++ > 0)
-                                                printk("*");
-                                        printk("%s", units[sys][i]);
+                                                seq_printf(f, "*");
+                                        seq_printf(f, "%s", units[sys][i]);
                                         if(nibble != 1) {
                                                 /* This is a _signed_ nibble(!) */
 
                                                 int val = nibble & 0x7;
                                                 if(nibble & 0x08)
                                                         val = -((0x7 & ~val) +1);
-                                                printk("^%d", val);
+                                                seq_printf(f, "^%d", val);
                                         }
                                 }
                         }
-                        printk(")\n");
+                        seq_printf(f, ")\n");
                 }
         }
-        tab(n); printk("Report Size(%u)\n", field->report_size);
-        tab(n); printk("Report Count(%u)\n", field->report_count);
-        tab(n); printk("Report Offset(%u)\n", field->report_offset);
+        tab(n, f); seq_printf(f, "Report Size(%u)\n", field->report_size);
+        tab(n, f); seq_printf(f, "Report Count(%u)\n", field->report_count);
+        tab(n, f); seq_printf(f, "Report Offset(%u)\n", field->report_offset);
 
-        tab(n); printk("Flags( ");
+        tab(n, f); seq_printf(f, "Flags( ");
         j = field->flags;
-        printk("%s", HID_MAIN_ITEM_CONSTANT & j ? "Constant " : "");
-        printk("%s", HID_MAIN_ITEM_VARIABLE & j ? "Variable " : "Array ");
-        printk("%s", HID_MAIN_ITEM_RELATIVE & j ? "Relative " : "Absolute ");
-        printk("%s", HID_MAIN_ITEM_WRAP & j ? "Wrap " : "");
-        printk("%s", HID_MAIN_ITEM_NONLINEAR & j ? "NonLinear " : "");
-        printk("%s", HID_MAIN_ITEM_NO_PREFERRED & j ? "NoPreferredState " : "");
-        printk("%s", HID_MAIN_ITEM_NULL_STATE & j ? "NullState " : "");
-        printk("%s", HID_MAIN_ITEM_VOLATILE & j ? "Volatile " : "");
-        printk("%s", HID_MAIN_ITEM_BUFFERED_BYTE & j ? "BufferedByte " : "");
-        printk(")\n");
+        seq_printf(f, "%s", HID_MAIN_ITEM_CONSTANT & j ? "Constant " : "");
+        seq_printf(f, "%s", HID_MAIN_ITEM_VARIABLE & j ? "Variable " : "Array ");
+        seq_printf(f, "%s", HID_MAIN_ITEM_RELATIVE & j ? "Relative " : "Absolute ");
+        seq_printf(f, "%s", HID_MAIN_ITEM_WRAP & j ? "Wrap " : "");
+        seq_printf(f, "%s", HID_MAIN_ITEM_NONLINEAR & j ? "NonLinear " : "");
+        seq_printf(f, "%s", HID_MAIN_ITEM_NO_PREFERRED & j ? "NoPreferredState " : "");
+        seq_printf(f, "%s", HID_MAIN_ITEM_NULL_STATE & j ? "NullState " : "");
+        seq_printf(f, "%s", HID_MAIN_ITEM_VOLATILE & j ? "Volatile " : "");
+        seq_printf(f, "%s", HID_MAIN_ITEM_BUFFERED_BYTE & j ? "BufferedByte " : "");
+        seq_printf(f, ")\n");
 }
 EXPORT_SYMBOL_GPL(hid_dump_field);
 
-void hid_dump_device(struct hid_device *device) {
+void hid_dump_device(struct hid_device *device, struct seq_file *f)
+{
         struct hid_report_enum *report_enum;
         struct hid_report *report;
         struct list_head *list;
         unsigned i,k;
         static const char *table[] = {"INPUT", "OUTPUT", "FEATURE"};
 
-        if (!hid_debug)
-                return;
-
         for (i = 0; i < HID_REPORT_TYPES; i++) {
                 report_enum = device->report_enum + i;
                 list = report_enum->report_list.next;
                 while (list != &report_enum->report_list) {
                         report = (struct hid_report *) list;
-                        tab(2);
-                        printk("%s", table[i]);
+                        tab(2, f);
+                        seq_printf(f, "%s", table[i]);
                         if (report->id)
-                                printk("(%d)", report->id);
-                        printk("[%s]", table[report->type]);
-                        printk("\n");
+                                seq_printf(f, "(%d)", report->id);
+                        seq_printf(f, "[%s]", table[report->type]);
+                        seq_printf(f, "\n");
                         for (k = 0; k < report->maxfield; k++) {
-                                tab(4);
-                                printk("Field(%d)\n", k);
-                                hid_dump_field(report->field[k], 6);
+                                tab(4, f);
+                                seq_printf(f, "Field(%d)\n", k);
+                                hid_dump_field(report->field[k], 6, f);
                         }
                         list = list->next;
                 }
@@ -495,13 +558,37 @@ void hid_dump_device(struct hid_device *device) {
 }
 EXPORT_SYMBOL_GPL(hid_dump_device);
 
-void hid_dump_input(struct hid_usage *usage, __s32 value) {
-        if (hid_debug < 2)
+/* enqueue string to 'events' ring buffer */
+void hid_debug_event(struct hid_device *hdev, char *buf)
+{
+        int i;
+        struct hid_debug_list *list;
+
+        list_for_each_entry(list, &hdev->debug_list, node) {
+                for (i = 0; i < strlen(buf); i++)
+                        list->hid_debug_buf[(list->tail + i) % HID_DEBUG_BUFSIZE] =
+                                buf[i];
+                list->tail = (list->tail + i) % HID_DEBUG_BUFSIZE;
+        }
+}
+EXPORT_SYMBOL_GPL(hid_debug_event);
+
+void hid_dump_input(struct hid_device *hdev, struct hid_usage *usage, __s32 value)
+{
+        char *buf;
+        int len;
+
+        buf = hid_resolv_usage(usage->hid, NULL);
+        if (!buf)
                 return;
+        len = strlen(buf);
+        snprintf(buf + len, HID_DEBUG_BUFSIZE - len - 1, " = %d\n", value);
+
+        hid_debug_event(hdev, buf);
+
+        kfree(buf);
+        wake_up_interruptible(&hdev->debug_wait);
 
-        printk(KERN_DEBUG "hid-debug: input ");
-        hid_resolv_usage(usage->hid);
-        printk(" = %d\n", value);
 }
 EXPORT_SYMBOL_GPL(hid_dump_input);
 
@@ -514,9 +601,11 @@ static const char *events[EV_MAX + 1] = {
         [EV_FF_STATUS] = "ForceFeedbackStatus",
 };
 
-static const char *syncs[2] = {
+static const char *syncs[3] = {
         [SYN_REPORT] = "Report",                [SYN_CONFIG] = "Config",
+        [SYN_MT_REPORT] = "MT Report",
 };
+
 static const char *keys[KEY_MAX + 1] = {
         [KEY_RESERVED] = "Reserved",            [KEY_ESC] = "Esc",
         [KEY_1] = "1",                          [KEY_2] = "2",
@@ -722,7 +811,7 @@ static const char *relatives[REL_MAX + 1] = {
         [REL_WHEEL] = "Wheel",          [REL_MISC] = "Misc",
 };
 
-static const char *absolutes[ABS_MAX + 1] = {
+static const char *absolutes[ABS_CNT] = {
         [ABS_X] = "X",                  [ABS_Y] = "Y",
         [ABS_Z] = "Z",                  [ABS_RX] = "Rx",
         [ABS_RY] = "Ry",                [ABS_RZ] = "Rz",
@@ -734,8 +823,17 @@ static const char *absolutes[ABS_MAX + 1] = {
         [ABS_HAT2Y] = "Hat2Y",          [ABS_HAT3X] = "Hat3X",
         [ABS_HAT3Y] = "Hat 3Y",         [ABS_PRESSURE] = "Pressure",
         [ABS_DISTANCE] = "Distance",    [ABS_TILT_X] = "XTilt",
-        [ABS_TILT_Y] = "YTilt",         [ABS_TOOL_WIDTH] = "Tool Width",
+        [ABS_TILT_Y] = "YTilt",         [ABS_TOOL_WIDTH] = "ToolWidth",
         [ABS_VOLUME] = "Volume",        [ABS_MISC] = "Misc",
+        [ABS_MT_TOUCH_MAJOR] = "MTMajor",
+        [ABS_MT_TOUCH_MINOR] = "MTMinor",
+        [ABS_MT_WIDTH_MAJOR] = "MTMajorW",
+        [ABS_MT_WIDTH_MINOR] = "MTMinorW",
+        [ABS_MT_ORIENTATION] = "MTOrientation",
+        [ABS_MT_POSITION_X] = "MTPositionX",
+        [ABS_MT_POSITION_Y] = "MTPositionY",
+        [ABS_MT_TOOL_TYPE] = "MTToolType",
+        [ABS_MT_BLOB_ID] = "MTBlobID",
 };
 
 static const char *misc[MSC_MAX + 1] = {
@@ -767,12 +865,221 @@ static const char **names[EV_MAX + 1] = {
         [EV_SND] = sounds,                      [EV_REP] = repeats,
 };
 
-void hid_resolv_event(__u8 type, __u16 code) {
+static void hid_resolv_event(__u8 type, __u16 code, struct seq_file *f)
+{
+        seq_printf(f, "%s.%s", events[type] ? events[type] : "?",
+                names[type] ? (names[type][code] ? names[type][code] : "?") : "?");
+}
 
-        if (!hid_debug)
-                return;
+static void hid_dump_input_mapping(struct hid_device *hid, struct seq_file *f)
+{
+        int i, j, k;
+        struct hid_report *report;
+        struct hid_usage *usage;
+
+        for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
+                list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
+                        for (i = 0; i < report->maxfield; i++) {
+                                for ( j = 0; j < report->field[i]->maxusage; j++) {
+                                        usage = report->field[i]->usage + j;
+                                        hid_resolv_usage(usage->hid, f);
+                                        seq_printf(f, " ---> ");
+                                        hid_resolv_event(usage->type, usage->code, f);
+                                        seq_printf(f, "\n");
+                                }
+                        }
+                }
+        }
 
-        printk("%s.%s", events[type] ? events[type] : "?",
-                names[type] ? (names[type][code] ? names[type][code] : "?") : "?");
 }
-EXPORT_SYMBOL_GPL(hid_resolv_event);
+
+
+static int hid_debug_rdesc_show(struct seq_file *f, void *p)
+{
+        struct hid_device *hdev = f->private;
+        int i;
+
+        /* dump HID report descriptor */
+        for (i = 0; i < hdev->rsize; i++)
+                seq_printf(f, "%02x ", hdev->rdesc[i]);
+        seq_printf(f, "\n\n");
+
+        /* dump parsed data and input mappings */
+        hid_dump_device(hdev, f);
+        seq_printf(f, "\n");
+        hid_dump_input_mapping(hdev, f);
+
+        return 0;
+}
+
+static int hid_debug_rdesc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, hid_debug_rdesc_show, inode->i_private);
+}
+
+static int hid_debug_events_open(struct inode *inode, struct file *file)
+{
+        int err = 0;
+        struct hid_debug_list *list;
+
+        if (!(list = kzalloc(sizeof(struct hid_debug_list), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto out;
+        }
+
+        if (!(list->hid_debug_buf = kzalloc(sizeof(char) * HID_DEBUG_BUFSIZE, GFP_KERNEL))) {
+                err = -ENOMEM;
+                kfree(list);
+                goto out;
+        }
+        list->hdev = (struct hid_device *) inode->i_private;
+        file->private_data = list;
+        mutex_init(&list->read_mutex);
+
+        list_add_tail(&list->node, &list->hdev->debug_list);
+
+out:
+        return err;
+}
+
+static ssize_t hid_debug_events_read(struct file *file, char __user *buffer,
+                size_t count, loff_t *ppos)
+{
+        struct hid_debug_list *list = file->private_data;
+        int ret = 0, len;
+        DECLARE_WAITQUEUE(wait, current);
+
+        mutex_lock(&list->read_mutex);
+        while (ret == 0) {
+                if (list->head == list->tail) {
+                        add_wait_queue(&list->hdev->debug_wait, &wait);
+                        set_current_state(TASK_INTERRUPTIBLE);
+
+                        while (list->head == list->tail) {
+                                if (file->f_flags & O_NONBLOCK) {
+                                        ret = -EAGAIN;
+                                        break;
+                                }
+                                if (signal_pending(current)) {
+                                        ret = -ERESTARTSYS;
+                                        break;
+                                }
+
+                                if (!list->hdev || !list->hdev->debug) {
+                                        ret = -EIO;
+                                        break;
+                                }
+
+                                /* allow O_NONBLOCK from other threads */
+                                mutex_unlock(&list->read_mutex);
+                                schedule();
+                                mutex_lock(&list->read_mutex);
+                                set_current_state(TASK_INTERRUPTIBLE);
+                        }
+
+                        set_current_state(TASK_RUNNING);
+                        remove_wait_queue(&list->hdev->debug_wait, &wait);
+                }
+
+                if (ret)
+                        goto out;
+
+                /* pass the ringbuffer contents to userspace */
+copy_rest:
+                if (list->tail == list->head)
+                        goto out;
+                if (list->tail > list->head) {
+                        len = list->tail - list->head;
+
+                        if (copy_to_user(buffer + ret, &list->hid_debug_buf[list->head], len)) {
+                                ret = -EFAULT;
+                                goto out;
+                        }
+                        ret += len;
+                        list->head += len;
+                } else {
+                        len = HID_DEBUG_BUFSIZE - list->head;
+
+                        if (copy_to_user(buffer, &list->hid_debug_buf[list->head], len)) {
+                                ret = -EFAULT;
+                                goto out;
+                        }
+                        list->head = 0;
+                        ret += len;
+                        goto copy_rest;
+                }
+
+        }
+out:
+        mutex_unlock(&list->read_mutex);
+        return ret;
+}
+
+static unsigned int hid_debug_events_poll(struct file *file, poll_table *wait)
+{
+        struct hid_debug_list *list = file->private_data;
+
+        poll_wait(file, &list->hdev->debug_wait, wait);
+        if (list->head != list->tail)
+                return POLLIN | POLLRDNORM;
+        if (!list->hdev->debug)
+                return POLLERR | POLLHUP;
+        return 0;
+}
+
+static int hid_debug_events_release(struct inode *inode, struct file *file)
+{
+        struct hid_debug_list *list = file->private_data;
+
+        list_del(&list->node);
+        kfree(list->hid_debug_buf);
+        kfree(list);
+
+        return 0;
+}
+
+static const struct file_operations hid_debug_rdesc_fops = {
+        .open           = hid_debug_rdesc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static const struct file_operations hid_debug_events_fops = {
+        .owner =        THIS_MODULE,
+        .open           = hid_debug_events_open,
+        .read           = hid_debug_events_read,
+        .poll           = hid_debug_events_poll,
+        .release        = hid_debug_events_release,
+};
+
+
+void hid_debug_register(struct hid_device *hdev, const char *name)
+{
+        hdev->debug_dir = debugfs_create_dir(name, hid_debug_root);
+        hdev->debug_rdesc = debugfs_create_file("rdesc", 0400,
+                        hdev->debug_dir, hdev, &hid_debug_rdesc_fops);
+        hdev->debug_events = debugfs_create_file("events", 0400,
+                        hdev->debug_dir, hdev, &hid_debug_events_fops);
+        hdev->debug = 1;
+}
+
+void hid_debug_unregister(struct hid_device *hdev)
+{
+        hdev->debug = 0;
+        wake_up_interruptible(&hdev->debug_wait);
+        debugfs_remove(hdev->debug_rdesc);
+        debugfs_remove(hdev->debug_events);
+        debugfs_remove(hdev->debug_dir);
+}
+
+void hid_debug_init(void)
+{
+        hid_debug_root = debugfs_create_dir("hid", NULL);
+}
+
+void hid_debug_exit(void)
+{
+        debugfs_remove_recursive(hid_debug_root);
+}
+
diff --git a/usr/src/dkms_source_tree/hid-ids.h b/usr/src/dkms_source_tree/hid-ids.h
new file mode 100644
index 0000000..631d902
--- /dev/null
+++ b/usr/src/dkms_source_tree/hid-ids.h
@@ -0,0 +1,531 @@
+/*
+ *  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.
+ */
+
+#ifndef HID_IDS_H_FILE
+#define HID_IDS_H_FILE
+
+#define USB_VENDOR_ID_3M                0x0596
+#define USB_DEVICE_ID_3M1968            0x0500
+#define USB_DEVICE_ID_3M2256            0x0502
+
+#define USB_VENDOR_ID_A4TECH            0x09da
+#define USB_DEVICE_ID_A4TECH_WCP32PU    0x0006
+#define USB_DEVICE_ID_A4TECH_X5_005D    0x000a
+
+#define USB_VENDOR_ID_AASHIMA           0x06d6
+#define USB_DEVICE_ID_AASHIMA_GAMEPAD   0x0025
+#define USB_DEVICE_ID_AASHIMA_PREDATOR  0x0026
+
+#define USB_VENDOR_ID_ACECAD            0x0460
+#define USB_DEVICE_ID_ACECAD_FLAIR      0x0004
+#define USB_DEVICE_ID_ACECAD_302        0x0008
+
+#define USB_VENDOR_ID_ADS_TECH          0x06e1
+#define USB_DEVICE_ID_ADS_TECH_RADIO_SI470X     0xa155
+
+#define USB_VENDOR_ID_AFATECH           0x15a4
+#define USB_DEVICE_ID_AFATECH_AF9016    0x9016
+
+#define USB_VENDOR_ID_AIPTEK            0x08ca
+#define USB_DEVICE_ID_AIPTEK_01         0x0001
+#define USB_DEVICE_ID_AIPTEK_10         0x0010
+#define USB_DEVICE_ID_AIPTEK_20         0x0020
+#define USB_DEVICE_ID_AIPTEK_21         0x0021
+#define USB_DEVICE_ID_AIPTEK_22         0x0022
+#define USB_DEVICE_ID_AIPTEK_23         0x0023
+#define USB_DEVICE_ID_AIPTEK_24         0x0024
+
+#define USB_VENDOR_ID_AIRCABLE          0x16CA
+#define USB_DEVICE_ID_AIRCABLE1         0x1502
+
+#define USB_VENDOR_ID_ALCOR             0x058f
+#define USB_DEVICE_ID_ALCOR_USBRS232    0x9720
+
+#define USB_VENDOR_ID_ALPS              0x0433
+#define USB_DEVICE_ID_IBM_GAMEPAD       0x1101
+
+#define USB_VENDOR_ID_APPLE             0x05ac
+#define USB_DEVICE_ID_APPLE_MIGHTYMOUSE 0x0304
+#define USB_DEVICE_ID_APPLE_MAGICMOUSE  0x030d
+#define USB_DEVICE_ID_APPLE_MAGICTRACKPAD       0x030e
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI       0x020e
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_ISO        0x020f
+#define USB_DEVICE_ID_APPLE_GEYSER_ANSI 0x0214
+#define USB_DEVICE_ID_APPLE_GEYSER_ISO  0x0215
+#define USB_DEVICE_ID_APPLE_GEYSER_JIS  0x0216
+#define USB_DEVICE_ID_APPLE_GEYSER3_ANSI        0x0217
+#define USB_DEVICE_ID_APPLE_GEYSER3_ISO 0x0218
+#define USB_DEVICE_ID_APPLE_GEYSER3_JIS 0x0219
+#define USB_DEVICE_ID_APPLE_GEYSER4_ANSI        0x021a
+#define USB_DEVICE_ID_APPLE_GEYSER4_ISO 0x021b
+#define USB_DEVICE_ID_APPLE_GEYSER4_JIS 0x021c
+#define USB_DEVICE_ID_APPLE_ALU_MINI_ANSI       0x021d
+#define USB_DEVICE_ID_APPLE_ALU_MINI_ISO        0x021e
+#define USB_DEVICE_ID_APPLE_ALU_MINI_JIS        0x021f
+#define USB_DEVICE_ID_APPLE_ALU_ANSI    0x0220
+#define USB_DEVICE_ID_APPLE_ALU_ISO     0x0221
+#define USB_DEVICE_ID_APPLE_ALU_JIS     0x0222
+#define USB_DEVICE_ID_APPLE_WELLSPRING_ANSI     0x0223
+#define USB_DEVICE_ID_APPLE_WELLSPRING_ISO      0x0224
+#define USB_DEVICE_ID_APPLE_WELLSPRING_JIS      0x0225
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI    0x0229
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO     0x022a
+#define USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS     0x022b
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI  0x022c
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO   0x022d
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS   0x022e
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI    0x0230
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_ISO     0x0231
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_JIS     0x0232
+#define USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI    0x0236
+#define USB_DEVICE_ID_APPLE_WELLSPRING3_ISO     0x0237
+#define USB_DEVICE_ID_APPLE_WELLSPRING3_JIS     0x0238
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI  0x0239
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO   0x023a
+#define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS   0x023b
+#define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY    0x030a
+#define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY     0x030b
+#define USB_DEVICE_ID_APPLE_ATV_IRCONTROL       0x8241
+#define USB_DEVICE_ID_APPLE_IRCONTROL4  0x8242
+
+#define USB_VENDOR_ID_ASUS              0x0486
+#define USB_DEVICE_ID_ASUS_T91MT        0x0185
+
+#define USB_VENDOR_ID_ASUSTEK           0x0b05
+#define USB_DEVICE_ID_ASUSTEK_LCM       0x1726
+#define USB_DEVICE_ID_ASUSTEK_LCM2      0x175b
+
+#define USB_VENDOR_ID_ATEN              0x0557
+#define USB_DEVICE_ID_ATEN_UC100KM      0x2004
+#define USB_DEVICE_ID_ATEN_CS124U       0x2202
+#define USB_DEVICE_ID_ATEN_2PORTKVM     0x2204
+#define USB_DEVICE_ID_ATEN_4PORTKVM     0x2205
+#define USB_DEVICE_ID_ATEN_4PORTKVMC    0x2208
+
+#define USB_VENDOR_ID_AVERMEDIA         0x07ca
+#define USB_DEVICE_ID_AVER_FM_MR800     0xb800
+
+#define USB_VENDOR_ID_BELKIN           0x050d
+#define USB_DEVICE_ID_FLIP_KVM         0x3201
+
+#define USB_VENDOR_ID_BERKSHIRE         0x0c98
+#define USB_DEVICE_ID_BERKSHIRE_PCWD    0x1140
+
+#define USB_VENDOR_ID_BTC               0x046e
+#define USB_DEVICE_ID_BTC_EMPREX_REMOTE 0x5578
+
+#define USB_VENDOR_ID_CANDO             0x2087
+#define USB_DEVICE_ID_CANDO_MULTI_TOUCH 0x0a01
+#define USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6 0x0b03
+
+#define USB_VENDOR_ID_CH                0x068e
+#define USB_DEVICE_ID_CH_PRO_PEDALS     0x00f2
+#define USB_DEVICE_ID_CH_COMBATSTICK    0x00f4
+#define USB_DEVICE_ID_CH_FLIGHT_SIM_ECLIPSE_YOKE       0x0051
+#define USB_DEVICE_ID_CH_FLIGHT_SIM_YOKE        0x00ff
+#define USB_DEVICE_ID_CH_3AXIS_5BUTTON_STICK    0x00d3
+
+#define USB_VENDOR_ID_CHERRY            0x046a
+#define USB_DEVICE_ID_CHERRY_CYMOTION   0x0023
+#define USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR     0x0027
+
+#define USB_VENDOR_ID_CHIC              0x05fe
+#define USB_DEVICE_ID_CHIC_GAMEPAD      0x0014
+
+#define USB_VENDOR_ID_CHICONY           0x04f2
+#define USB_DEVICE_ID_CHICONY_TACTICAL_PAD      0x0418
+
+#define USB_VENDOR_ID_CIDC              0x1677
+
+#define USB_VENDOR_ID_CMEDIA            0x0d8c
+#define USB_DEVICE_ID_CM109             0x000e
+
+#define USB_VENDOR_ID_CODEMERCS         0x07c0
+#define USB_DEVICE_ID_CODEMERCS_IOW_FIRST       0x1500
+#define USB_DEVICE_ID_CODEMERCS_IOW_LAST        0x15ff
+
+#define USB_VENDOR_ID_CREATIVELABS      0x041e
+#define USB_DEVICE_ID_PRODIKEYS_PCMIDI  0x2801
+
+#define USB_VENDOR_ID_CYGNAL            0x10c4
+#define USB_DEVICE_ID_CYGNAL_RADIO_SI470X       0x818a
+
+#define USB_VENDOR_ID_CYPRESS           0x04b4
+#define USB_DEVICE_ID_CYPRESS_MOUSE     0x0001
+#define USB_DEVICE_ID_CYPRESS_HIDCOM    0x5500
+#define USB_DEVICE_ID_CYPRESS_ULTRAMOUSE        0x7417
+#define USB_DEVICE_ID_CYPRESS_BARCODE_1 0xde61
+#define USB_DEVICE_ID_CYPRESS_BARCODE_2 0xde64
+#define USB_DEVICE_ID_CYPRESS_BARCODE_3 0xbca1
+
+#define USB_VENDOR_ID_DEALEXTREAME      0x10c5
+#define USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701 0x819a
+
+#define USB_VENDOR_ID_DELORME           0x1163
+#define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100
+#define USB_DEVICE_ID_DELORME_EM_LT20   0x0200
+
+#define USB_VENDOR_ID_DMI               0x0c0b
+#define USB_DEVICE_ID_DMI_ENC           0x5fab
+
+#define USB_VENDOR_ID_DRAGONRISE        0x0079
+
+#define USB_VENDOR_ID_DWAV              0x0eef
+#define USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER    0x0001
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH    0x480d
+
+#define USB_VENDOR_ID_ELO               0x04E7
+#define USB_DEVICE_ID_ELO_TS2700        0x0020
+
+#define USB_VENDOR_ID_ESSENTIAL_REALITY 0x0d7f
+#define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100
+
+#define USB_VENDOR_ID_ETURBOTOUCH       0x22b9
+#define USB_DEVICE_ID_ETURBOTOUCH       0x0006
+
+#define USB_VENDOR_ID_ETT               0x0664
+#define USB_DEVICE_ID_TC5UH             0x0309
+
+#define USB_VENDOR_ID_EZKEY             0x0518
+#define USB_DEVICE_ID_BTC_8193          0x0002
+
+#define USB_VENDOR_ID_GAMERON           0x0810
+#define USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR  0x0001
+#define USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR  0x0002
+
+#define USB_VENDOR_ID_GENERAL_TOUCH     0x0dfc
+
+#define USB_VENDOR_ID_GLAB              0x06c2
+#define USB_DEVICE_ID_4_PHIDGETSERVO_30 0x0038
+#define USB_DEVICE_ID_1_PHIDGETSERVO_30 0x0039
+#define USB_DEVICE_ID_0_0_4_IF_KIT      0x0040
+#define USB_DEVICE_ID_0_16_16_IF_KIT    0x0044
+#define USB_DEVICE_ID_8_8_8_IF_KIT      0x0045
+#define USB_DEVICE_ID_0_8_7_IF_KIT      0x0051
+#define USB_DEVICE_ID_0_8_8_IF_KIT      0x0053
+#define USB_DEVICE_ID_PHIDGET_MOTORCONTROL      0x0058
+
+#define USB_VENDOR_ID_GOTOP             0x08f2
+#define USB_DEVICE_ID_SUPER_Q2          0x007f
+#define USB_DEVICE_ID_GOGOPEN           0x00ce
+#define USB_DEVICE_ID_PENPOWER          0x00f4
+
+#define USB_VENDOR_ID_GREENASIA         0x0e8f
+
+#define USB_VENDOR_ID_GRETAGMACBETH     0x0971
+#define USB_DEVICE_ID_GRETAGMACBETH_HUEY        0x2005
+
+#define USB_VENDOR_ID_GRIFFIN           0x077d
+#define USB_DEVICE_ID_POWERMATE         0x0410
+#define USB_DEVICE_ID_SOUNDKNOB         0x04AA
+
+#define USB_VENDOR_ID_GTCO              0x078c
+#define USB_DEVICE_ID_GTCO_90           0x0090
+#define USB_DEVICE_ID_GTCO_100          0x0100
+#define USB_DEVICE_ID_GTCO_101          0x0101
+#define USB_DEVICE_ID_GTCO_103          0x0103
+#define USB_DEVICE_ID_GTCO_104          0x0104
+#define USB_DEVICE_ID_GTCO_105          0x0105
+#define USB_DEVICE_ID_GTCO_106          0x0106
+#define USB_DEVICE_ID_GTCO_107          0x0107
+#define USB_DEVICE_ID_GTCO_108          0x0108
+#define USB_DEVICE_ID_GTCO_200          0x0200
+#define USB_DEVICE_ID_GTCO_201          0x0201
+#define USB_DEVICE_ID_GTCO_202          0x0202
+#define USB_DEVICE_ID_GTCO_203          0x0203
+#define USB_DEVICE_ID_GTCO_204          0x0204
+#define USB_DEVICE_ID_GTCO_205          0x0205
+#define USB_DEVICE_ID_GTCO_206          0x0206
+#define USB_DEVICE_ID_GTCO_207          0x0207
+#define USB_DEVICE_ID_GTCO_300          0x0300
+#define USB_DEVICE_ID_GTCO_301          0x0301
+#define USB_DEVICE_ID_GTCO_302          0x0302
+#define USB_DEVICE_ID_GTCO_303          0x0303
+#define USB_DEVICE_ID_GTCO_304          0x0304
+#define USB_DEVICE_ID_GTCO_305          0x0305
+#define USB_DEVICE_ID_GTCO_306          0x0306
+#define USB_DEVICE_ID_GTCO_307          0x0307
+#define USB_DEVICE_ID_GTCO_308          0x0308
+#define USB_DEVICE_ID_GTCO_309          0x0309
+#define USB_DEVICE_ID_GTCO_400          0x0400
+#define USB_DEVICE_ID_GTCO_401          0x0401
+#define USB_DEVICE_ID_GTCO_402          0x0402
+#define USB_DEVICE_ID_GTCO_403          0x0403
+#define USB_DEVICE_ID_GTCO_404          0x0404
+#define USB_DEVICE_ID_GTCO_405          0x0405
+#define USB_DEVICE_ID_GTCO_500          0x0500
+#define USB_DEVICE_ID_GTCO_501          0x0501
+#define USB_DEVICE_ID_GTCO_502          0x0502
+#define USB_DEVICE_ID_GTCO_503          0x0503
+#define USB_DEVICE_ID_GTCO_504          0x0504
+#define USB_DEVICE_ID_GTCO_1000         0x1000
+#define USB_DEVICE_ID_GTCO_1001         0x1001
+#define USB_DEVICE_ID_GTCO_1002         0x1002
+#define USB_DEVICE_ID_GTCO_1003         0x1003
+#define USB_DEVICE_ID_GTCO_1004         0x1004
+#define USB_DEVICE_ID_GTCO_1005         0x1005
+#define USB_DEVICE_ID_GTCO_1006         0x1006
+#define USB_DEVICE_ID_GTCO_1007         0x1007
+
+#define USB_VENDOR_ID_GYRATION          0x0c16
+#define USB_DEVICE_ID_GYRATION_REMOTE   0x0002
+#define USB_DEVICE_ID_GYRATION_REMOTE_2 0x0003
+#define USB_DEVICE_ID_GYRATION_REMOTE_3 0x0008
+
+#define USB_VENDOR_ID_HAPP              0x078b
+#define USB_DEVICE_ID_UGCI_DRIVING      0x0010
+#define USB_DEVICE_ID_UGCI_FLYING       0x0020
+#define USB_DEVICE_ID_UGCI_FIGHTING     0x0030
+
+#define USB_VENDOR_ID_IMATION           0x0718
+#define USB_DEVICE_ID_DISC_STAKKA       0xd000
+
+#define USB_VENDOR_ID_KBGEAR            0x084e
+#define USB_DEVICE_ID_KBGEAR_JAMSTUDIO  0x1001
+
+#define USB_VENDOR_ID_KWORLD            0x1b80
+#define USB_DEVICE_ID_KWORLD_RADIO_FM700        0xd700
+
+#define USB_VENDOR_ID_LABTEC            0x1020
+#define USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD  0x0006
+
+#define USB_VENDOR_ID_LD                0x0f11
+#define USB_DEVICE_ID_LD_CASSY          0x1000
+#define USB_DEVICE_ID_LD_POCKETCASSY    0x1010
+#define USB_DEVICE_ID_LD_MOBILECASSY    0x1020
+#define USB_DEVICE_ID_LD_JWM            0x1080
+#define USB_DEVICE_ID_LD_DMMP           0x1081
+#define USB_DEVICE_ID_LD_UMIP           0x1090
+#define USB_DEVICE_ID_LD_XRAY1          0x1100
+#define USB_DEVICE_ID_LD_XRAY2          0x1101
+#define USB_DEVICE_ID_LD_VIDEOCOM       0x1200
+#define USB_DEVICE_ID_LD_COM3LAB        0x2000
+#define USB_DEVICE_ID_LD_TELEPORT       0x2010
+#define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020
+#define USB_DEVICE_ID_LD_POWERCONTROL   0x2030
+#define USB_DEVICE_ID_LD_MACHINETEST    0x2040
+
+#define USB_VENDOR_ID_KENSINGTON        0x047d
+#define USB_DEVICE_ID_KS_SLIMBLADE      0x2041
+
+#define USB_VENDOR_ID_LOGITECH          0x046d
+#define USB_DEVICE_ID_LOGITECH_RECEIVER 0xc101
+#define USB_DEVICE_ID_LOGITECH_HARMONY_FIRST  0xc110
+#define USB_DEVICE_ID_LOGITECH_HARMONY_LAST 0xc14f
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD        0xc211
+#define USB_DEVICE_ID_LOGITECH_EXTREME_3D       0xc215
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2       0xc218
+#define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2     0xc219
+#define USB_DEVICE_ID_LOGITECH_WINGMAN_F3D      0xc283
+#define USB_DEVICE_ID_LOGITECH_FORCE3D_PRO      0xc286
+#define USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940       0xc287
+#define USB_DEVICE_ID_LOGITECH_WHEEL    0xc294
+#define USB_DEVICE_ID_LOGITECH_WINGMAN_FFG      0xc293
+#define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL       0xc295
+#define USB_DEVICE_ID_LOGITECH_G25_WHEEL        0xc299
+#define USB_DEVICE_ID_LOGITECH_ELITE_KBD        0xc30a
+#define USB_DEVICE_ID_S510_RECEIVER     0xc50c
+#define USB_DEVICE_ID_S510_RECEIVER_2   0xc517
+#define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500   0xc512
+#define USB_DEVICE_ID_MX3000_RECEIVER   0xc513
+#define USB_DEVICE_ID_SPACETRAVELLER    0xc623
+#define USB_DEVICE_ID_SPACENAVIGATOR    0xc626
+#define USB_DEVICE_ID_DINOVO_DESKTOP    0xc704
+#define USB_DEVICE_ID_DINOVO_EDGE       0xc714
+#define USB_DEVICE_ID_DINOVO_MINI       0xc71f
+#define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2      0xca03
+
+#define USB_VENDOR_ID_MCC               0x09db
+#define USB_DEVICE_ID_MCC_PMD1024LS     0x0076
+#define USB_DEVICE_ID_MCC_PMD1208LS     0x007a
+
+#define USB_VENDOR_ID_MGE               0x0463
+#define USB_DEVICE_ID_MGE_UPS           0xffff
+#define USB_DEVICE_ID_MGE_UPS1          0x0001
+
+#define USB_VENDOR_ID_MICROCHIP         0x04d8
+#define USB_DEVICE_ID_PICKIT1           0x0032
+#define USB_DEVICE_ID_PICKIT2           0x0033
+#define USB_DEVICE_ID_PICOLCD           0xc002
+#define USB_DEVICE_ID_PICOLCD_BOOTLOADER        0xf002
+
+#define USB_VENDOR_ID_MICROSOFT         0x045e
+#define USB_DEVICE_ID_SIDEWINDER_GV     0x003b
+#define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d
+#define USB_DEVICE_ID_MS_NE4K           0x00db
+#define USB_DEVICE_ID_MS_LK6K           0x00f9
+#define USB_DEVICE_ID_MS_PRESENTER_8K_BT        0x0701
+#define USB_DEVICE_ID_MS_PRESENTER_8K_USB       0x0713
+
+#define USB_VENDOR_ID_MOJO              0x8282
+#define USB_DEVICE_ID_RETRO_ADAPTER     0x3201
+
+#define USB_VENDOR_ID_MONTEREY          0x0566
+#define USB_DEVICE_ID_GENIUS_KB29E      0x3004
+
+#define USB_VENDOR_ID_NCR               0x0404
+#define USB_DEVICE_ID_NCR_FIRST         0x0300
+#define USB_DEVICE_ID_NCR_LAST          0x03ff
+
+#define USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR 0x0400
+#define USB_DEVICE_ID_N_S_HARMONY       0xc359
+
+#define USB_VENDOR_ID_NATSU             0x08b7
+#define USB_DEVICE_ID_NATSU_GAMEPAD     0x0001
+
+#define USB_VENDOR_ID_NEC               0x073e
+#define USB_DEVICE_ID_NEC_USB_GAME_PAD  0x0301
+
+#define USB_VENDOR_ID_NEXTWINDOW        0x1926
+#define USB_DEVICE_ID_NEXTWINDOW_TOUCHSCREEN    0x0003
+
+#define USB_VENDOR_ID_NTRIG                0x1b96
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN   0x0001
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1   0x0003
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2   0x0004
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3   0x0005
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4   0x0006
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5   0x0007
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6   0x0008
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7   0x0009
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8   0x000A
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9   0x000B
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10   0x000C
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11   0x000D
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12   0x000E
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13   0x000F
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14   0x0010
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15   0x0011
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16   0x0012
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17   0x0013
+#define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18   0x0014
+
+#define USB_VENDOR_ID_ONTRAK            0x0a07
+#define USB_DEVICE_ID_ONTRAK_ADU100     0x0064
+
+#define USB_VENDOR_ID_ORTEK             0x05a4
+#define USB_DEVICE_ID_ORTEK_WKB2000     0x2000
+
+#define USB_VENDOR_ID_PANJIT            0x134c
+
+#define USB_VENDOR_ID_PANTHERLORD       0x0810
+#define USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK     0x0001
+
+#define USB_VENDOR_ID_PETALYNX          0x18b1
+#define USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE    0x0037
+
+#define USB_VENDOR_ID_PHILIPS       0x0471
+#define USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE 0x0617
+
+#define USB_VENDOR_ID_PLAYDOTCOM        0x0b43
+#define USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII      0x0003
+
+#define USB_VENDOR_ID_POWERCOM          0x0d9f
+#define USB_DEVICE_ID_POWERCOM_UPS      0x0002
+
+#define USB_VENDOR_ID_PRODIGE           0x05af
+#define USB_DEVICE_ID_PRODIGE_CORDLESS  0x3062
+
+#define USB_VENDOR_ID_ROCCAT            0x1e7d
+#define USB_DEVICE_ID_ROCCAT_KONE       0x2ced
+
+#define USB_VENDOR_ID_SAITEK            0x06a3
+#define USB_DEVICE_ID_SAITEK_RUMBLEPAD  0xff17
+
+#define USB_VENDOR_ID_QUANTA            0x0408
+#define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH      0x3000
+#define USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN   0x3001
+
+#define USB_VENDOR_ID_SAMSUNG           0x0419
+#define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
+#define USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE        0x0600
+
+#define USB_VENDOR_ID_SONY                      0x054c
+#define USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE       0x024b
+#define USB_DEVICE_ID_SONY_PS3_CONTROLLER       0x0268
+
+#define USB_VENDOR_ID_SOUNDGRAPH        0x15c2
+#define USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST     0x0034
+#define USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST      0x0046
+
+#define USB_VENDOR_ID_STANTUM           0x1f87
+#define USB_DEVICE_ID_MTP               0x0002
+
+#define USB_VENDOR_ID_SUN               0x0430
+#define USB_DEVICE_ID_RARITAN_KVM_DONGLE        0xcdab
+
+#define USB_VENDOR_ID_SUNPLUS           0x04fc
+#define USB_DEVICE_ID_SUNPLUS_WDESKTOP  0x05d8
+
+#define USB_VENDOR_ID_THRUSTMASTER      0x044f
+
+#define USB_VENDOR_ID_TOUCHPACK         0x1bfd
+#define USB_DEVICE_ID_TOUCHPACK_RTS     0x1688
+
+#define USB_VENDOR_ID_TOPMAX            0x0663
+#define USB_DEVICE_ID_TOPMAX_COBRAPAD   0x0103
+
+#define USB_VENDOR_ID_TOPSEED           0x0766
+#define USB_DEVICE_ID_TOPSEED_CYBERLINK 0x0204
+
+#define USB_VENDOR_ID_TURBOX            0x062a
+#define USB_DEVICE_ID_TURBOX_KEYBOARD   0x0201
+
+#define USB_VENDOR_ID_TWINHAN           0x6253
+#define USB_DEVICE_ID_TWINHAN_IR_REMOTE 0x0100
+
+#define USB_VENDOR_ID_UCLOGIC           0x5543
+#define USB_DEVICE_ID_UCLOGIC_TABLET_PF1209     0x0042
+#define USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U    0x0003
+
+#define USB_VENDOR_ID_VERNIER           0x08f7
+#define USB_DEVICE_ID_VERNIER_LABPRO    0x0001
+#define USB_DEVICE_ID_VERNIER_GOTEMP    0x0002
+#define USB_DEVICE_ID_VERNIER_SKIP      0x0003
+#define USB_DEVICE_ID_VERNIER_CYCLOPS   0x0004
+#define USB_DEVICE_ID_VERNIER_LCSPEC    0x0006
+
+#define USB_VENDOR_ID_WACOM             0x056a
+#define USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH  0x81
+#define USB_DEVICE_ID_WACOM_INTUOS4_BLUETOOTH   0xbd
+
+#define USB_VENDOR_ID_WISEGROUP         0x0925
+#define USB_DEVICE_ID_SMARTJOY_PLUS     0x0005
+#define USB_DEVICE_ID_1_PHIDGETSERVO_20 0x8101
+#define USB_DEVICE_ID_4_PHIDGETSERVO_20 0x8104
+#define USB_DEVICE_ID_8_8_4_IF_KIT      0x8201
+#define USB_DEVICE_ID_QUAD_USB_JOYPAD   0x8800
+#define USB_DEVICE_ID_DUAL_USB_JOYPAD   0x8866
+
+#define USB_VENDOR_ID_WISEGROUP_LTD     0x6666
+#define USB_VENDOR_ID_WISEGROUP_LTD2    0x6677
+#define USB_DEVICE_ID_SMARTJOY_DUAL_PLUS 0x8802
+
+#define USB_VENDOR_ID_YEALINK           0x6993
+#define USB_DEVICE_ID_YEALINK_P1K_P4K_B2K       0xb001
+
+#define USB_VENDOR_ID_ZEROPLUS          0x0c12
+
+#define USB_VENDOR_ID_ZYDACRON  0x13EC
+#define USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL   0x0006
+
+#define USB_VENDOR_ID_KYE               0x0458
+#define USB_DEVICE_ID_KYE_ERGO_525V     0x0087
+#define USB_DEVICE_ID_KYE_GPEN_560      0x5003
+
+
+#endif
diff --git a/usr/src/dkms_source_tree/hid-input-quirks.c b/usr/src/dkms_source_tree/hid-input-quirks.c
deleted file mode 100644
index 16feea0..0000000
--- a/usr/src/dkms_source_tree/hid-input-quirks.c
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
- *  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_abs(c)      do { usage->code = c; usage->type = EV_ABS; *bit = input->absbit; *max = ABS_MAX; } while (0)
-#define map_rel(c)      do { usage->code = c; usage->type = EV_REL; *bit = input->relbit; *max = REL_MAX; } while (0)
-#define map_key(c)      do { usage->code = c; usage->type = EV_KEY; *bit = input->keybit; *max = KEY_MAX; } while (0)
-#define map_led(c)      do { usage->code = c; usage->type = EV_LED; *bit = input->ledbit; *max = LED_MAX; } while (0)
-
-#define map_abs_clear(c)        do { map_abs(c); clear_bit(c, *bit); } while (0)
-#define map_key_clear(c)        do { map_key(c); clear_bit(c, *bit); } while (0)
-
-static int quirk_belkin_wkbd(struct hid_usage *usage, struct input_dev *input,
-                              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_cherry_cymotion(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-
-        switch (usage->hid & HID_USAGE) {
-                case 0x301: map_key_clear(KEY_PROG1);           break;
-                case 0x302: map_key_clear(KEY_PROG2);           break;
-                case 0x303: map_key_clear(KEY_PROG3);           break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_logitech_ultrax_remote(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
-                return 0;
-
-        set_bit(EV_REP, input->evbit);
-        switch(usage->hid & HID_USAGE) {
-                /* Reported on Logitech Ultra X Media Remote */
-                case 0x004: map_key_clear(KEY_AGAIN);           break;
-                case 0x00d: map_key_clear(KEY_HOME);            break;
-                case 0x024: map_key_clear(KEY_SHUFFLE);         break;
-                case 0x025: map_key_clear(KEY_TV);              break;
-                case 0x026: map_key_clear(KEY_MENU);            break;
-                case 0x031: map_key_clear(KEY_AUDIO);           break;
-                case 0x032: map_key_clear(KEY_TEXT);            break;
-                case 0x033: map_key_clear(KEY_LAST);            break;
-                case 0x047: map_key_clear(KEY_MP3);             break;
-                case 0x048: map_key_clear(KEY_DVD);             break;
-                case 0x049: map_key_clear(KEY_MEDIA);           break;
-                case 0x04a: map_key_clear(KEY_VIDEO);           break;
-                case 0x04b: map_key_clear(KEY_ANGLE);           break;
-                case 0x04c: map_key_clear(KEY_LANGUAGE);        break;
-                case 0x04d: map_key_clear(KEY_SUBTITLE);        break;
-                case 0x051: map_key_clear(KEY_RED);             break;
-                case 0x052: map_key_clear(KEY_CLOSE);           break;
-
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_gyration_remote(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
-                return 0;
-
-        set_bit(EV_REP, 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 input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
-                return 0;
-
-        set_bit(EV_REP, 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_microsoft_ergonomy_kb(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
-                return 0;
-
-        switch(usage->hid & HID_USAGE) {
-                case 0xfd06: map_key_clear(KEY_CHAT);           break;
-                case 0xfd07: map_key_clear(KEY_PHONE);          break;
-                case 0xff05:
-                        set_bit(EV_REP, input->evbit);
-                        map_key_clear(KEY_F13);
-                        set_bit(KEY_F14, input->keybit);
-                        set_bit(KEY_F15, input->keybit);
-                        set_bit(KEY_F16, input->keybit);
-                        set_bit(KEY_F17, input->keybit);
-                        set_bit(KEY_F18, input->keybit);
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_microsoft_presenter_8k(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
-                return 0;
-
-        set_bit(EV_REP, input->evbit);
-        switch(usage->hid & HID_USAGE) {
-                case 0xfd08: map_key_clear(KEY_FORWARD);        break;
-                case 0xfd09: map_key_clear(KEY_BACK);           break;
-                case 0xfd0b: map_key_clear(KEY_PLAYPAUSE);      break;
-                case 0xfd0e: map_key_clear(KEY_CLOSE);          break;
-                case 0xfd0f: map_key_clear(KEY_PLAY);           break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_petalynx_remote(struct hid_usage *usage, struct input_dev *input,
-                              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_logitech_wireless(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-
-        switch (usage->hid & HID_USAGE) {
-                case 0x1001: map_key_clear(KEY_MESSENGER);      break;
-                case 0x1003: map_key_clear(KEY_SOUND);          break;
-                case 0x1004: map_key_clear(KEY_VIDEO);          break;
-                case 0x1005: map_key_clear(KEY_AUDIO);          break;
-                case 0x100a: map_key_clear(KEY_DOCUMENTS);      break;
-                case 0x1011: map_key_clear(KEY_PREVIOUSSONG);   break;
-                case 0x1012: map_key_clear(KEY_NEXTSONG);       break;
-                case 0x1013: map_key_clear(KEY_CAMERA);         break;
-                case 0x1014: map_key_clear(KEY_MESSENGER);      break;
-                case 0x1015: map_key_clear(KEY_RECORD);         break;
-                case 0x1016: map_key_clear(KEY_PLAYER);         break;
-                case 0x1017: map_key_clear(KEY_EJECTCD);        break;
-                case 0x1018: map_key_clear(KEY_MEDIA);          break;
-                case 0x1019: map_key_clear(KEY_PROG1);          break;
-                case 0x101a: map_key_clear(KEY_PROG2);          break;
-                case 0x101b: map_key_clear(KEY_PROG3);          break;
-                case 0x101f: map_key_clear(KEY_ZOOMIN);         break;
-                case 0x1020: map_key_clear(KEY_ZOOMOUT);        break;
-                case 0x1021: map_key_clear(KEY_ZOOMRESET);      break;
-                case 0x1023: map_key_clear(KEY_CLOSE);          break;
-                case 0x1027: map_key_clear(KEY_MENU);           break;
-                /* this one is marked as 'Rotate' */
-                case 0x1028: map_key_clear(KEY_ANGLE);          break;
-                case 0x1029: map_key_clear(KEY_SHUFFLE);        break;
-                case 0x102a: map_key_clear(KEY_BACK);           break;
-                case 0x102b: map_key_clear(KEY_CYCLEWINDOWS);   break;
-                case 0x1041: map_key_clear(KEY_BATTERY);        break;
-                case 0x1042: map_key_clear(KEY_WORDPROCESSOR);  break;
-                case 0x1043: map_key_clear(KEY_SPREADSHEET);    break;
-                case 0x1044: map_key_clear(KEY_PRESENTATION);   break;
-                case 0x1045: map_key_clear(KEY_UNDO);           break;
-                case 0x1046: map_key_clear(KEY_REDO);           break;
-                case 0x1047: map_key_clear(KEY_PRINT);          break;
-                case 0x1048: map_key_clear(KEY_SAVE);           break;
-                case 0x1049: map_key_clear(KEY_PROG1);          break;
-                case 0x104a: map_key_clear(KEY_PROG2);          break;
-                case 0x104b: map_key_clear(KEY_PROG3);          break;
-                case 0x104c: map_key_clear(KEY_PROG4);          break;
-
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-static int quirk_cherry_genius_29e(struct hid_usage *usage, struct input_dev *input,
-                              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 input_dev *input,
-                              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;
-}
-
-static int quirk_sunplus_wdesktop(struct hid_usage *usage, struct input_dev *input,
-                              unsigned long **bit, int *max)
-{
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
-                return 0;
-
-        switch (usage->hid & HID_USAGE) {
-                case 0x2003: map_key_clear(KEY_ZOOMIN);         break;
-                case 0x2103: map_key_clear(KEY_ZOOMOUT);        break;
-                default:
-                        return 0;
-        }
-        return 1;
-}
-
-#define VENDOR_ID_BELKIN                        0x1020
-#define DEVICE_ID_BELKIN_WIRELESS_KEYBOARD      0x0006
-
-#define VENDOR_ID_CHERRY                        0x046a
-#define DEVICE_ID_CHERRY_CYMOTION               0x0023
-
-#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_LOGITECH                      0x046d
-#define DEVICE_ID_LOGITECH_RECEIVER             0xc101
-#define DEVICE_ID_S510_RECEIVER                 0xc50c
-#define DEVICE_ID_S510_RECEIVER_2               0xc517
-#define DEVICE_ID_MX3000_RECEIVER               0xc513
-
-#define VENDOR_ID_MICROSOFT                     0x045e
-#define DEVICE_ID_MS4K                          0x00db
-#define DEVICE_ID_MS6K                          0x00f9
-#define DEVICE_IS_MS_PRESENTER_8K_BT            0x0701
-#define DEVICE_ID_MS_PRESENTER_8K_USB           0x0713
-
-#define VENDOR_ID_MONTEREY                      0x0566
-#define DEVICE_ID_GENIUS_KB29E                  0x3004
-
-#define VENDOR_ID_PETALYNX                      0x18b1
-#define DEVICE_ID_PETALYNX_MAXTER_REMOTE        0x0037
-
-#define VENDOR_ID_SUNPLUS                       0x04fc
-#define DEVICE_ID_SUNPLUS_WDESKTOP              0x05d8
-
-static const struct hid_input_blacklist {
-        __u16 idVendor;
-        __u16 idProduct;
-        int (*quirk)(struct hid_usage *, struct input_dev *, unsigned long **, int *);
-} hid_input_blacklist[] = {
-        { VENDOR_ID_BELKIN, DEVICE_ID_BELKIN_WIRELESS_KEYBOARD, quirk_belkin_wkbd },
-
-        { VENDOR_ID_CHERRY, DEVICE_ID_CHERRY_CYMOTION, quirk_cherry_cymotion },
-
-        { 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_LOGITECH, DEVICE_ID_LOGITECH_RECEIVER, quirk_logitech_ultrax_remote },
-        { VENDOR_ID_LOGITECH, DEVICE_ID_S510_RECEIVER, quirk_logitech_wireless },
-        { VENDOR_ID_LOGITECH, DEVICE_ID_S510_RECEIVER_2, quirk_logitech_wireless },
-        { VENDOR_ID_LOGITECH, DEVICE_ID_MX3000_RECEIVER, quirk_logitech_wireless },
-
-        { VENDOR_ID_MICROSOFT, DEVICE_ID_MS4K, quirk_microsoft_ergonomy_kb },
-        { VENDOR_ID_MICROSOFT, DEVICE_ID_MS6K, quirk_microsoft_ergonomy_kb },
-        { VENDOR_ID_MICROSOFT, DEVICE_IS_MS_PRESENTER_8K_BT, quirk_microsoft_presenter_8k },
-        { VENDOR_ID_MICROSOFT, DEVICE_ID_MS_PRESENTER_8K_USB, quirk_microsoft_presenter_8k },
-
-        { VENDOR_ID_MONTEREY, DEVICE_ID_GENIUS_KB29E, quirk_cherry_genius_29e },
-
-        { VENDOR_ID_PETALYNX, DEVICE_ID_PETALYNX_MAXTER_REMOTE, quirk_petalynx_remote },
-
-        { VENDOR_ID_SUNPLUS, DEVICE_ID_SUNPLUS_WDESKTOP, quirk_sunplus_wdesktop },
-
-        { 0, 0, NULL }
-};
-
-int hidinput_mapping_quirks(struct hid_usage *usage, 
-                                   struct input_dev *input, 
-                                   unsigned long **bit, int *max)
-{
-        struct hid_device *device = input_get_drvdata(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, input, 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;
-
-        if (((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
-                || ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007))) {
-                if (value) hid->quirks |=  HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
-                else       hid->quirks &= ~HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
-                return 1;
-        }
-
-        if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_B8) &&
-                        (usage->type == EV_REL) &&
-                        (usage->code == REL_WHEEL)) {
-                hid->delayed_value = value;
-                return 1;
-        }
-
-        if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_B8) &&
-                        (usage->hid == 0x000100b8)) {
-                input_event(input, EV_REL, value ? REL_HWHEEL : REL_WHEEL, hid->delayed_value);
-                return 1;
-        }
-
-        if ((hid->quirks & HID_QUIRK_INVERT_HWHEEL) && (usage->code == REL_HWHEEL)) {
-                input_event(input, usage->type, usage->code, -value);
-                return 1;
-        }
-
-        if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_ON) && (usage->code == REL_WHEEL)) {
-                input_event(input, usage->type, REL_HWHEEL, value);
-                return 1;
-        }
-
-        if ((hid->quirks & HID_QUIRK_APPLE_HAS_FN) && hidinput_apple_event(hid, input, usage, value))
-                return 1;
-
-        /* Handling MS keyboards special buttons */
-        if (hid->quirks & HID_QUIRK_MICROSOFT_KEYS && 
-                        usage->hid == (HID_UP_MSVENDOR | 0xff05)) {
-                int key = 0;
-                static int last_key = 0;
-                switch (value) {
-                        case 0x01: key = KEY_F14; break;
-                        case 0x02: key = KEY_F15; break;
-                        case 0x04: key = KEY_F16; break;
-                        case 0x08: key = KEY_F17; break;
-                        case 0x10: key = KEY_F18; break;
-                        default: break;
-                }
-                if (key) {
-                        input_event(input, usage->type, key, 1);
-                        last_key = key;
-                } else {
-                        input_event(input, usage->type, last_key, 0);
-                }
-        }
-
-        /* 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;
-}
-
-
diff --git a/usr/src/dkms_source_tree/hid-input.c b/usr/src/dkms_source_tree/hid-input.c
index 782048d..9d97934 100644
--- a/usr/src/dkms_source_tree/hid-input.c
+++ b/usr/src/dkms_source_tree/hid-input.c
@@ -1,6 +1,6 @@
 /*
  *  Copyright (c) 2000-2001 Vojtech Pavlik
- *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2006-2010 Jiri Kosina
  *
  *  HID to Linux Input mapping
  */
@@ -32,11 +32,6 @@
 #include <linux/hid.h>
 #include <linux/hid-debug.h>
 
-static int hid_apple_fnmode = 1;
-module_param_named(pb_fnmode, hid_apple_fnmode, int, 0644);
-MODULE_PARM_DESC(pb_fnmode,
-                "Mode of fn key on Apple keyboards (0 = disabled, 1 = fkeyslast, 2 = fkeysfirst)");
-
 #define unk     KEY_UNKNOWN
 
 static const unsigned char hid_keyboard[256] = {
@@ -58,245 +53,40 @@ static const unsigned char hid_keyboard[256] = {
         150,158,159,128,136,177,178,176,142,152,173,140,unk,unk,unk,unk
 };
 
-/* extended mapping for certain Logitech hardware (Logitech cordless desktop LX500) */
-#define LOGITECH_EXPANDED_KEYMAP_SIZE 80
-static int logitech_expanded_keymap[LOGITECH_EXPANDED_KEYMAP_SIZE] = {
-          0,216,  0,213,175,156,  0,  0,  0,  0,
-        144,  0,  0,  0,  0,  0,  0,  0,  0,212,
-        174,167,152,161,112,  0,  0,  0,154,  0,
-          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-          0,  0,  0,  0,  0,183,184,185,186,187,
-        188,189,190,191,192,193,194,  0,  0,  0
-};
-
 static const struct {
         __s32 x;
         __s32 y;
 }  hid_hat_to_axis[] = {{ 0, 0}, { 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
 
-#define map_abs(c)      do { usage->code = c; usage->type = EV_ABS; bit = input->absbit; max = ABS_MAX; } while (0)
-#define map_rel(c)      do { usage->code = c; usage->type = EV_REL; bit = input->relbit; max = REL_MAX; } while (0)
-#define map_key(c)      do { usage->code = c; usage->type = EV_KEY; bit = input->keybit; max = KEY_MAX; } while (0)
-#define map_led(c)      do { usage->code = c; usage->type = EV_LED; bit = input->ledbit; max = LED_MAX; } while (0)
-
-#define map_abs_clear(c)        do { map_abs(c); clear_bit(c, bit); } while (0)
-#define map_key_clear(c)        do { map_key(c); clear_bit(c, bit); } while (0)
-
-#ifdef CONFIG_USB_HIDINPUT_POWERBOOK
-
-struct hidinput_key_translation {
-        u16 from;
-        u16 to;
-        u8 flags;
-};
-
-#define APPLE_FLAG_FKEY 0x01
-
-static struct hidinput_key_translation apple_fn_keys[] = {
-        { KEY_BACKSPACE, KEY_DELETE },
-        { KEY_ENTER,    KEY_INSERT },
-        { KEY_F1,       KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
-        { KEY_F2,       KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
-        { KEY_F3,       KEY_CYCLEWINDOWS,   APPLE_FLAG_FKEY }, /* Exposé */
-        { KEY_F4,       KEY_CALC,           APPLE_FLAG_FKEY }, /* Dashboard */
-        { KEY_F5,       KEY_KBDILLUMDOWN,   APPLE_FLAG_FKEY },
-        { KEY_F6,       KEY_KBDILLUMUP,     APPLE_FLAG_FKEY },
-        { KEY_F7,       KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
-        { KEY_F8,       KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
-        { KEY_F9,       KEY_NEXTSONG,       APPLE_FLAG_FKEY },
-        { KEY_F10,      KEY_MUTE,           APPLE_FLAG_FKEY },
-        { KEY_F11,      KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
-        { KEY_F12,      KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
-        { KEY_UP,       KEY_PAGEUP },
-        { KEY_DOWN,     KEY_PAGEDOWN },
-        { KEY_LEFT,     KEY_HOME },
-        { KEY_RIGHT,    KEY_END },
-        { }
-};
-
-static struct hidinput_key_translation powerbook_fn_keys[] = {
-        { KEY_BACKSPACE, KEY_DELETE },
-        { KEY_F1,       KEY_BRIGHTNESSDOWN,     APPLE_FLAG_FKEY },
-        { KEY_F2,       KEY_BRIGHTNESSUP,       APPLE_FLAG_FKEY },
-        { KEY_F3,       KEY_MUTE,               APPLE_FLAG_FKEY },
-        { KEY_F4,       KEY_VOLUMEDOWN,         APPLE_FLAG_FKEY },
-        { KEY_F5,       KEY_VOLUMEUP,           APPLE_FLAG_FKEY },
-        { KEY_F6,       KEY_NUMLOCK,            APPLE_FLAG_FKEY },
-        { KEY_F7,       KEY_SWITCHVIDEOMODE,    APPLE_FLAG_FKEY },
-        { KEY_F8,       KEY_KBDILLUMTOGGLE,     APPLE_FLAG_FKEY },
-        { KEY_F9,       KEY_KBDILLUMDOWN,       APPLE_FLAG_FKEY },
-        { KEY_F10,      KEY_KBDILLUMUP,         APPLE_FLAG_FKEY },
-        { KEY_UP,       KEY_PAGEUP },
-        { KEY_DOWN,     KEY_PAGEDOWN },
-        { KEY_LEFT,     KEY_HOME },
-        { KEY_RIGHT,    KEY_END },
-        { }
-};
-
-static struct hidinput_key_translation powerbook_numlock_keys[] = {
-        { KEY_J,        KEY_KP1 },
-        { KEY_K,        KEY_KP2 },
-        { KEY_L,        KEY_KP3 },
-        { KEY_U,        KEY_KP4 },
-        { KEY_I,        KEY_KP5 },
-        { KEY_O,        KEY_KP6 },
-        { KEY_7,        KEY_KP7 },
-        { KEY_8,        KEY_KP8 },
-        { KEY_9,        KEY_KP9 },
-        { KEY_M,        KEY_KP0 },
-        { KEY_DOT,      KEY_KPDOT },
-        { KEY_SLASH,    KEY_KPPLUS },
-        { KEY_SEMICOLON, KEY_KPMINUS },
-        { KEY_P,        KEY_KPASTERISK },
-        { KEY_MINUS,    KEY_KPEQUAL },
-        { KEY_0,        KEY_KPSLASH },
-        { KEY_F6,       KEY_NUMLOCK },
-        { KEY_KPENTER,  KEY_KPENTER },
-        { KEY_BACKSPACE, KEY_BACKSPACE },
-        { }
-};
-
-static struct hidinput_key_translation apple_iso_keyboard[] = {
-        { KEY_GRAVE,    KEY_102ND },
-        { KEY_102ND,    KEY_GRAVE },
-        { }
-};
-
-static struct hidinput_key_translation *find_translation(struct hidinput_key_translation *table, u16 from)
-{
-        struct hidinput_key_translation *trans;
-
-        /* Look for the translation */
-        for (trans = table; trans->from; trans++)
-                if (trans->from == from)
-                        return trans;
-
-        return NULL;
-}
-
-int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
-                struct hid_usage *usage, __s32 value)
-{
-        struct hidinput_key_translation *trans;
-
-        if (usage->code == KEY_FN) {
-                if (value) hid->quirks |=  HID_QUIRK_APPLE_FN_ON;
-                else       hid->quirks &= ~HID_QUIRK_APPLE_FN_ON;
-
-                input_event(input, usage->type, usage->code, value);
-
-                return 1;
-        }
-
-        if (hid_apple_fnmode) {
-                int do_translate;
-
-                trans = find_translation((hid->product < 0x220 ||
-                                          hid->product >= 0x300) ?
-                                         powerbook_fn_keys : apple_fn_keys,
-                                         usage->code);
-                if (trans) {
-                        if (test_bit(usage->code, hid->apple_pressed_fn))
-                                do_translate = 1;
-                        else if (trans->flags & APPLE_FLAG_FKEY)
-                                do_translate =
-                                        (hid_apple_fnmode == 2 &&  (hid->quirks & HID_QUIRK_APPLE_FN_ON)) ||
-                                        (hid_apple_fnmode == 1 && !(hid->quirks & HID_QUIRK_APPLE_FN_ON));
-                        else
-                                do_translate = (hid->quirks & HID_QUIRK_APPLE_FN_ON);
-
-                        if (do_translate) {
-                                if (value)
-                                        set_bit(usage->code, hid->apple_pressed_fn);
-                                else
-                                        clear_bit(usage->code, hid->apple_pressed_fn);
-
-                                input_event(input, usage->type, trans->to, value);
-
-                                return 1;
-                        }
-                }
-
-                if (hid->quirks & HID_QUIRK_APPLE_NUMLOCK_EMULATION && (
-                                test_bit(usage->code, hid->pb_pressed_numlock) ||
-                                test_bit(LED_NUML, input->led))) {
-                        trans = find_translation(powerbook_numlock_keys, usage->code);
-
-                        if (trans) {
-                                if (value)
-                                        set_bit(usage->code, hid->pb_pressed_numlock);
-                                else
-                                        clear_bit(usage->code, hid->pb_pressed_numlock);
-
-                                input_event(input, usage->type, trans->to, value);
-                        }
-
-                        return 1;
-                }
-        }
-
-        if (hid->quirks & HID_QUIRK_APPLE_ISO_KEYBOARD) {
-                trans = find_translation(apple_iso_keyboard, usage->code);
-                if (trans) {
-                        input_event(input, usage->type, trans->to, value);
-                        return 1;
-                }
-        }
+#define map_abs(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_ABS, (c))
+#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_led(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_LED, (c))
 
-        return 0;
-}
+#define map_abs_clear(c)        hid_map_usage_clear(hidinput, usage, &bit, \
+                &max, EV_ABS, (c))
+#define map_key_clear(c)        hid_map_usage_clear(hidinput, usage, &bit, \
+                &max, EV_KEY, (c))
 
-static void hidinput_apple_setup(struct input_dev *input)
-{
-        struct hidinput_key_translation *trans;
-
-        set_bit(KEY_NUMLOCK, input->keybit);
-
-        /* Enable all needed keys */
-        for (trans = apple_fn_keys; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-
-        for (trans = powerbook_fn_keys; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-
-        for (trans = powerbook_numlock_keys; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-
-        for (trans = apple_iso_keyboard; trans->from; trans++)
-                set_bit(trans->to, input->keybit);
-
-}
-#else
-inline int hidinput_apple_event(struct hid_device *hid,
-                                       struct input_dev *input,
-                                       struct hid_usage *usage, __s32 value)
-{
-        return 0;
-}
-
-static inline void hidinput_apple_setup(struct input_dev *input)
-{
-}
-#endif
-
-static inline int match_scancode(int code, int scancode)
+static inline int match_scancode(unsigned int code, unsigned int scancode)
 {
         if (scancode == 0)
                 return 1;
-        return ((code & (HID_USAGE_PAGE | HID_USAGE)) == scancode);
+
+        return (code & (HID_USAGE_PAGE | HID_USAGE)) == scancode;
 }
 
-static inline int match_keycode(int code, int keycode)
+static inline int match_keycode(unsigned int code, unsigned int keycode)
 {
         if (keycode == 0)
                 return 1;
-        return (code == keycode);
+
+        return code == keycode;
 }
 
 static struct hid_usage *hidinput_find_key(struct hid_device *hid,
-                int scancode, int keycode)
+                                           unsigned int scancode,
+                                           unsigned int keycode)
 {
         int i, j, k;
         struct hid_report *report;
@@ -318,8 +108,8 @@ static struct hid_usage *hidinput_find_key(struct hid_device *hid,
         return NULL;
 }
 
-static int hidinput_getkeycode(struct input_dev *dev, int scancode,
-                                int *keycode)
+static int hidinput_getkeycode(struct input_dev *dev,
+                               unsigned int scancode, unsigned int *keycode)
 {
         struct hid_device *hid = input_get_drvdata(dev);
         struct hid_usage *usage;
@@ -332,16 +122,13 @@ static int hidinput_getkeycode(struct input_dev *dev, int scancode,
         return -EINVAL;
 }
 
-static int hidinput_setkeycode(struct input_dev *dev, int scancode,
-                                int keycode)
+static int hidinput_setkeycode(struct input_dev *dev,
+                               unsigned int scancode, unsigned int keycode)
 {
         struct hid_device *hid = input_get_drvdata(dev);
         struct hid_usage *usage;
         int old_keycode;
 
-        if (keycode < 0 || keycode > KEY_MAX)
-                return -EINVAL;
-
         usage = hidinput_find_key(hid, scancode, 0);
         if (usage) {
                 old_keycode = usage->code;
@@ -367,425 +154,365 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
 {
         struct input_dev *input = hidinput->input;
         struct hid_device *device = input_get_drvdata(input);
-        int max = 0, code, ret;
+        int max = 0, code;
         unsigned long *bit = NULL;
 
         field->hidinput = hidinput;
 
-        dbg_hid("Mapping: ");
-        hid_resolv_usage(usage->hid);
-        dbg_hid_line(" ---> ");
-
         if (field->flags & HID_MAIN_ITEM_CONSTANT)
                 goto ignore;
 
         /* only LED usages are supported in output fields */
         if (field->report_type == HID_OUTPUT_REPORT &&
                         (usage->hid & HID_USAGE_PAGE) != HID_UP_LED) {
-                dbg_hid_line(" [non-LED output field] ");
                 goto ignore;
         }
 
-        /* handle input mappings for quirky devices */
-        ret = hidinput_mapping_quirks(usage, input, &bit, &max);
-        if (ret)
-                goto mapped;
-
-        switch (usage->hid & HID_USAGE_PAGE) {
-
-                case HID_UP_UNDEFINED:
+        if (device->driver->input_mapping) {
+                int ret = device->driver->input_mapping(device, hidinput, field,
+                                usage, &bit, &max);
+                if (ret > 0)
+                        goto mapped;
+                if (ret < 0)
                         goto ignore;
+        }
 
-                case HID_UP_KEYBOARD:
-
-                        set_bit(EV_REP, input->evbit);
-
-                        if ((usage->hid & HID_USAGE) < 256) {
-                                if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
-                                map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
-                        } else
-                                map_key(KEY_UNKNOWN);
-
-                        break;
-
-                case HID_UP_BUTTON:
-
-                        code = ((usage->hid - 1) & 0xf);
-
-                        switch (field->application) {
-                                case HID_GD_MOUSE:
-                                case HID_GD_POINTER:  code += 0x110; break;
-                                case HID_GD_JOYSTICK: code += 0x120; break;
-                                case HID_GD_GAMEPAD:  code += 0x130; break;
-                                default:
-                                        switch (field->physical) {
-                                                case HID_GD_MOUSE:
-                                                case HID_GD_POINTER:  code += 0x110; break;
-                                                case HID_GD_JOYSTICK: code += 0x120; break;
-                                                case HID_GD_GAMEPAD:  code += 0x130; break;
-                                                default:              code += 0x100;
-                                        }
-                        }
+        switch (usage->hid & HID_USAGE_PAGE) {
+        case HID_UP_UNDEFINED:
+                goto ignore;
 
-                        /* Special handling for Logitech Cordless Desktop */
-                        if (field->application != HID_GD_MOUSE) {
-                                if (device->quirks & HID_QUIRK_LOGITECH_EXPANDED_KEYMAP) {
-                                        int hid = usage->hid & HID_USAGE;
-                                        if (hid < LOGITECH_EXPANDED_KEYMAP_SIZE && logitech_expanded_keymap[hid] != 0)
-                                                code = logitech_expanded_keymap[hid];
-                                }
-                        } else {
-                                if (device->quirks & HID_QUIRK_LOGITECH_IGNORE_DOUBLED_WHEEL) {
-                                        int hid = usage->hid & HID_USAGE;
-                                        if (hid == 7 || hid == 8)
-                                                goto ignore;
-                                }
+        case HID_UP_KEYBOARD:
+                set_bit(EV_REP, input->evbit);
+
+                if ((usage->hid & HID_USAGE) < 256) {
+                        if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
+                        map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
+                } else
+                        map_key(KEY_UNKNOWN);
+
+                break;
+
+        case HID_UP_BUTTON:
+                code = ((usage->hid - 1) & HID_USAGE);
+
+                switch (field->application) {
+                case HID_GD_MOUSE:
+                case HID_GD_POINTER:  code += 0x110; break;
+                case HID_GD_JOYSTICK:
+                                      if (code <= 0xf)
+                                              code += BTN_JOYSTICK;
+                                      else
+                                              code += BTN_TRIGGER_HAPPY;
+                                      break;
+                case HID_GD_GAMEPAD:  code += 0x130; break;
+                default:
+                        switch (field->physical) {
+                        case HID_GD_MOUSE:
+                        case HID_GD_POINTER:  code += 0x110; break;
+                        case HID_GD_JOYSTICK: code += 0x120; break;
+                        case HID_GD_GAMEPAD:  code += 0x130; break;
+                        default:              code += 0x100;
                         }
+                }
 
-                        map_key(code);
-                        break;
-
-
-                case HID_UP_SIMULATION:
-
-                        switch (usage->hid & 0xffff) {
-                                case 0xba: map_abs(ABS_RUDDER);   break;
-                                case 0xbb: map_abs(ABS_THROTTLE); break;
-                                case 0xc4: map_abs(ABS_GAS);      break;
-                                case 0xc5: map_abs(ABS_BRAKE);    break;
-                                case 0xc8: map_abs(ABS_WHEEL);    break;
-                                default:   goto ignore;
+                map_key(code);
+                break;
+
+        case HID_UP_SIMULATION:
+                switch (usage->hid & 0xffff) {
+                case 0xba: map_abs(ABS_RUDDER);   break;
+                case 0xbb: map_abs(ABS_THROTTLE); break;
+                case 0xc4: map_abs(ABS_GAS);      break;
+                case 0xc5: map_abs(ABS_BRAKE);    break;
+                case 0xc8: map_abs(ABS_WHEEL);    break;
+                default:   goto ignore;
+                }
+                break;
+
+        case HID_UP_GENDESK:
+                if ((usage->hid & 0xf0) == 0x80) {      /* SystemControl */
+                        switch (usage->hid & 0xf) {
+                        case 0x1: map_key_clear(KEY_POWER);  break;
+                        case 0x2: map_key_clear(KEY_SLEEP);  break;
+                        case 0x3: map_key_clear(KEY_WAKEUP); break;
+                        default: goto unknown;
                         }
                         break;
+                }
 
-                case HID_UP_GENDESK:
-
-                        if ((usage->hid & 0xf0) == 0x80) {      /* SystemControl */
-                                switch (usage->hid & 0xf) {
-                                        case 0x1: map_key_clear(KEY_POWER);  break;
-                                        case 0x2: map_key_clear(KEY_SLEEP);  break;
-                                        case 0x3: map_key_clear(KEY_WAKEUP); break;
-                                        default: goto unknown;
-                                }
-                                break;
-                        }
-
-                        if ((usage->hid & 0xf0) == 0x90) {      /* D-pad */
-                                switch (usage->hid) {
-                                        case HID_GD_UP:    usage->hat_dir = 1; break;
-                                        case HID_GD_DOWN:  usage->hat_dir = 5; break;
-                                        case HID_GD_RIGHT: usage->hat_dir = 3; break;
-                                        case HID_GD_LEFT:  usage->hat_dir = 7; break;
-                                        default: goto unknown;
-                                }
-                                if (field->dpad) {
-                                        map_abs(field->dpad);
-                                        goto ignore;
-                                }
-                                map_abs(ABS_HAT0X);
-                                break;
-                        }
-
+                if ((usage->hid & 0xf0) == 0x90) {      /* D-pad */
                         switch (usage->hid) {
-
-                                /* These usage IDs map directly to the usage codes. */
-                                case HID_GD_X: case HID_GD_Y: case HID_GD_Z:
-                                case HID_GD_RX: case HID_GD_RY: case HID_GD_RZ:
-                                case HID_GD_SLIDER: case HID_GD_DIAL: case HID_GD_WHEEL:
-                                        if (field->flags & HID_MAIN_ITEM_RELATIVE)
-                                                map_rel(usage->hid & 0xf);
-                                        else
-                                                map_abs(usage->hid & 0xf);
-                                        break;
-
-                                case HID_GD_HATSWITCH:
-                                        usage->hat_min = field->logical_minimum;
-                                        usage->hat_max = field->logical_maximum;
-                                        map_abs(ABS_HAT0X);
-                                        break;
-
-                                case HID_GD_START:      map_key_clear(BTN_START);       break;
-                                case HID_GD_SELECT:     map_key_clear(BTN_SELECT);      break;
-
-                                default: goto unknown;
+                        case HID_GD_UP:    usage->hat_dir = 1; break;
+                        case HID_GD_DOWN:  usage->hat_dir = 5; break;
+                        case HID_GD_RIGHT: usage->hat_dir = 3; break;
+                        case HID_GD_LEFT:  usage->hat_dir = 7; break;
+                        default: goto unknown;
                         }
-
-                        break;
-
-                case HID_UP_LED:
-
-                        switch (usage->hid & 0xffff) {                        /* HID-Value:                   */
-                                case 0x01:  map_led (LED_NUML);     break;    /*   "Num Lock"                 */
-                                case 0x02:  map_led (LED_CAPSL);    break;    /*   "Caps Lock"                */
-                                case 0x03:  map_led (LED_SCROLLL);  break;    /*   "Scroll Lock"              */
-                                case 0x04:  map_led (LED_COMPOSE);  break;    /*   "Compose"                  */
-                                case 0x05:  map_led (LED_KANA);     break;    /*   "Kana"                     */
-                                case 0x27:  map_led (LED_SLEEP);    break;    /*   "Stand-By"                 */
-                                case 0x4c:  map_led (LED_SUSPEND);  break;    /*   "System Suspend"           */
-                                case 0x09:  map_led (LED_MUTE);     break;    /*   "Mute"                     */
-                                case 0x4b:  map_led (LED_MISC);     break;    /*   "Generic Indicator"        */
-                                case 0x19:  map_led (LED_MAIL);     break;    /*   "Message Waiting"          */
-                                case 0x4d:  map_led (LED_CHARGING); break;    /*   "External Power Connected" */
-
-                                default: goto ignore;
+                        if (field->dpad) {
+                                map_abs(field->dpad);
+                                goto ignore;
                         }
+                        map_abs(ABS_HAT0X);
                         break;
+                }
 
-                case HID_UP_DIGITIZER:
-
-                        switch (usage->hid & 0xff) {
-
-                                case 0x30: /* TipPressure */
-                                        if (!test_bit(BTN_TOUCH, input->keybit)) {
-                                                device->quirks |= HID_QUIRK_NOTOUCH;
-                                                set_bit(EV_KEY, input->evbit);
-                                                set_bit(BTN_TOUCH, input->keybit);
-                                        }
-
-                                        map_abs_clear(ABS_PRESSURE);
-                                        break;
-
-                                case 0x32: /* InRange */
-                                        switch (field->physical & 0xff) {
-                                                case 0x21: map_key(BTN_TOOL_MOUSE); break;
-                                                case 0x22: map_key(BTN_TOOL_FINGER); break;
-                                                default: map_key(BTN_TOOL_PEN); break;
-                                        }
-                                        break;
+                switch (usage->hid) {
+                /* These usage IDs map directly to the usage codes. */
+                case HID_GD_X: case HID_GD_Y: case HID_GD_Z:
+                case HID_GD_RX: case HID_GD_RY: case HID_GD_RZ:
+                case HID_GD_SLIDER: case HID_GD_DIAL: case HID_GD_WHEEL:
+                        if (field->flags & HID_MAIN_ITEM_RELATIVE)
+                                map_rel(usage->hid & 0xf);
+                        else
+                                map_abs(usage->hid & 0xf);
+                        break;
 
-                                case 0x3c: /* Invert */
-                                        map_key_clear(BTN_TOOL_RUBBER);
-                                        break;
+                case HID_GD_HATSWITCH:
+                        usage->hat_min = field->logical_minimum;
+                        usage->hat_max = field->logical_maximum;
+                        map_abs(ABS_HAT0X);
+                        break;
 
-                                case 0x33: /* Touch */
-                                case 0x42: /* TipSwitch */
-                                case 0x43: /* TipSwitch2 */
-                                        device->quirks &= ~HID_QUIRK_NOTOUCH;
-                                        map_key_clear(BTN_TOUCH);
-                                        break;
+                case HID_GD_START:      map_key_clear(BTN_START);       break;
+                case HID_GD_SELECT:     map_key_clear(BTN_SELECT);      break;
 
-                                case 0x44: /* BarrelSwitch */
-                                        map_key_clear(BTN_STYLUS);
-                                        break;
+                default: goto unknown;
+                }
 
-                                default:  goto unknown;
+                break;
+
+        case HID_UP_LED:
+                switch (usage->hid & 0xffff) {                /* HID-Value:                   */
+                case 0x01:  map_led (LED_NUML);     break;    /*   "Num Lock"                 */
+                case 0x02:  map_led (LED_CAPSL);    break;    /*   "Caps Lock"                */
+                case 0x03:  map_led (LED_SCROLLL);  break;    /*   "Scroll Lock"              */
+                case 0x04:  map_led (LED_COMPOSE);  break;    /*   "Compose"                  */
+                case 0x05:  map_led (LED_KANA);     break;    /*   "Kana"                     */
+                case 0x27:  map_led (LED_SLEEP);    break;    /*   "Stand-By"                 */
+                case 0x4c:  map_led (LED_SUSPEND);  break;    /*   "System Suspend"           */
+                case 0x09:  map_led (LED_MUTE);     break;    /*   "Mute"                     */
+                case 0x4b:  map_led (LED_MISC);     break;    /*   "Generic Indicator"        */
+                case 0x19:  map_led (LED_MAIL);     break;    /*   "Message Waiting"          */
+                case 0x4d:  map_led (LED_CHARGING); break;    /*   "External Power Connected" */
+
+                default: goto ignore;
+                }
+                break;
+
+        case HID_UP_DIGITIZER:
+                switch (usage->hid & 0xff) {
+                case 0x30: /* TipPressure */
+                        if (!test_bit(BTN_TOUCH, input->keybit)) {
+                                device->quirks |= HID_QUIRK_NOTOUCH;
+                                set_bit(EV_KEY, input->evbit);
+                                set_bit(BTN_TOUCH, input->keybit);
                         }
+                        map_abs_clear(ABS_PRESSURE);
                         break;
 
-                case HID_UP_CONSUMER:   /* USB HUT v1.1, pages 56-62 */
-
-                        switch (usage->hid & HID_USAGE) {
-                                case 0x000: goto ignore;
-                                case 0x034: map_key_clear(KEY_SLEEP);           break;
-                                case 0x036: map_key_clear(BTN_MISC);            break;
-
-                                case 0x040: map_key_clear(KEY_MENU);            break;
-                                case 0x045: map_key_clear(KEY_RADIO);           break;
-
-                                case 0x083: map_key_clear(KEY_LAST);            break;
-                                case 0x088: map_key_clear(KEY_PC);              break;
-                                case 0x089: map_key_clear(KEY_TV);              break;
-                                case 0x08a: map_key_clear(KEY_WWW);             break;
-                                case 0x08b: map_key_clear(KEY_DVD);             break;
-                                case 0x08c: map_key_clear(KEY_PHONE);           break;
-                                case 0x08d: map_key_clear(KEY_PROGRAM);         break;
-                                case 0x08e: map_key_clear(KEY_VIDEOPHONE);      break;
-                                case 0x08f: map_key_clear(KEY_GAMES);           break;
-                                case 0x090: map_key_clear(KEY_MEMO);            break;
-                                case 0x091: map_key_clear(KEY_CD);              break;
-                                case 0x092: map_key_clear(KEY_VCR);             break;
-                                case 0x093: map_key_clear(KEY_TUNER);           break;
-                                case 0x094: map_key_clear(KEY_EXIT);            break;
-                                case 0x095: map_key_clear(KEY_HELP);            break;
-                                case 0x096: map_key_clear(KEY_TAPE);            break;
-                                case 0x097: map_key_clear(KEY_TV2);             break;
-                                case 0x098: map_key_clear(KEY_SAT);             break;
-                                case 0x09a: map_key_clear(KEY_PVR);             break;
-
-                                case 0x09c: map_key_clear(KEY_CHANNELUP);       break;
-                                case 0x09d: map_key_clear(KEY_CHANNELDOWN);     break;
-                                case 0x0a0: map_key_clear(KEY_VCR2);            break;
-
-                                case 0x0b0: map_key_clear(KEY_PLAY);            break;
-                                case 0x0b1: map_key_clear(KEY_PAUSE);           break;
-                                case 0x0b2: map_key_clear(KEY_RECORD);          break;
-                                case 0x0b3: map_key_clear(KEY_FASTFORWARD);     break;
-                                case 0x0b4: map_key_clear(KEY_REWIND);          break;
-                                case 0x0b5: map_key_clear(KEY_NEXTSONG);        break;
-                                case 0x0b6: map_key_clear(KEY_PREVIOUSSONG);    break;
-                                case 0x0b7: map_key_clear(KEY_STOPCD);          break;
-                                case 0x0b8: map_key_clear(KEY_EJECTCD);         break;
-                                case 0x0bc: map_key_clear(KEY_MEDIA_REPEAT);    break;
-
-                                case 0x0cd: map_key_clear(KEY_PLAYPAUSE);       break;
-                                case 0x0e0: map_abs_clear(ABS_VOLUME);          break;
-                                case 0x0e2: map_key_clear(KEY_MUTE);            break;
-                                case 0x0e5: map_key_clear(KEY_BASSBOOST);       break;
-                                case 0x0e9: map_key_clear(KEY_VOLUMEUP);        break;
-                                case 0x0ea: map_key_clear(KEY_VOLUMEDOWN);      break;
-
-                                case 0x182: map_key_clear(KEY_BOOKMARKS);       break;
-                                case 0x183: map_key_clear(KEY_CONFIG);          break;
-                                case 0x184: map_key_clear(KEY_WORDPROCESSOR);   break;
-                                case 0x185: map_key_clear(KEY_EDITOR);          break;
-                                case 0x186: map_key_clear(KEY_SPREADSHEET);     break;
-                                case 0x187: map_key_clear(KEY_GRAPHICSEDITOR);  break;
-                                case 0x188: map_key_clear(KEY_PRESENTATION);    break;
-                                case 0x189: map_key_clear(KEY_DATABASE);        break;
-                                case 0x18a: map_key_clear(KEY_MAIL);            break;
-                                case 0x18b: map_key_clear(KEY_NEWS);            break;
-                                case 0x18c: map_key_clear(KEY_VOICEMAIL);       break;
-                                case 0x18d: map_key_clear(KEY_ADDRESSBOOK);     break;
-                                case 0x18e: map_key_clear(KEY_CALENDAR);        break;
-                                case 0x191: map_key_clear(KEY_FINANCE);         break;
-                                case 0x192: map_key_clear(KEY_CALC);            break;
-                                case 0x194: map_key_clear(KEY_FILE);            break;
-                                case 0x196: map_key_clear(KEY_WWW);             break;
-                                case 0x19c: map_key_clear(KEY_LOGOFF);          break;
-                                case 0x19e: map_key_clear(KEY_COFFEE);          break;
-                                case 0x1a6: map_key_clear(KEY_HELP);            break;
-                                case 0x1a7: map_key_clear(KEY_DOCUMENTS);       break;
-                                case 0x1ab: map_key_clear(KEY_SPELLCHECK);      break;
-                                case 0x1b6: map_key_clear(KEY_MEDIA);           break;
-                                case 0x1b7: map_key_clear(KEY_SOUND);           break;
-                                case 0x1bc: map_key_clear(KEY_MESSENGER);       break;
-                                case 0x1bd: map_key_clear(KEY_INFO);            break;
-                                case 0x201: map_key_clear(KEY_NEW);             break;
-                                case 0x202: map_key_clear(KEY_OPEN);            break;
-                                case 0x203: map_key_clear(KEY_CLOSE);           break;
-                                case 0x204: map_key_clear(KEY_EXIT);            break;
-                                case 0x207: map_key_clear(KEY_SAVE);            break;
-                                case 0x208: map_key_clear(KEY_PRINT);           break;
-                                case 0x209: map_key_clear(KEY_PROPS);           break;
-                                case 0x21a: map_key_clear(KEY_UNDO);            break;
-                                case 0x21b: map_key_clear(KEY_COPY);            break;
-                                case 0x21c: map_key_clear(KEY_CUT);             break;
-                                case 0x21d: map_key_clear(KEY_PASTE);           break;
-                                case 0x21f: map_key_clear(KEY_FIND);            break;
-                                case 0x221: map_key_clear(KEY_SEARCH);          break;
-                                case 0x222: map_key_clear(KEY_GOTO);            break;
-                                case 0x223: map_key_clear(KEY_HOMEPAGE);        break;
-                                case 0x224: map_key_clear(KEY_BACK);            break;
-                                case 0x225: map_key_clear(KEY_FORWARD);         break;
-                                case 0x226: map_key_clear(KEY_STOP);            break;
-                                case 0x227: map_key_clear(KEY_REFRESH);         break;
-                                case 0x22a: map_key_clear(KEY_BOOKMARKS);       break;
-                                case 0x22d: map_key_clear(KEY_ZOOMIN);          break;
-                                case 0x22e: map_key_clear(KEY_ZOOMOUT);         break;
-                                case 0x22f: map_key_clear(KEY_ZOOMRESET);       break;
-                                case 0x233: map_key_clear(KEY_SCROLLUP);        break;
-                                case 0x234: map_key_clear(KEY_SCROLLDOWN);      break;
-                                case 0x238: map_rel(REL_HWHEEL);                break;
-                                case 0x25f: map_key_clear(KEY_CANCEL);          break;
-                                case 0x279: map_key_clear(KEY_REDO);            break;
-
-                                case 0x289: map_key_clear(KEY_REPLY);           break;
-                                case 0x28b: map_key_clear(KEY_FORWARDMAIL);     break;
-                                case 0x28c: map_key_clear(KEY_SEND);            break;
-
-                                default:    goto ignore;
+                case 0x32: /* InRange */
+                        switch (field->physical & 0xff) {
+                        case 0x21: map_key(BTN_TOOL_MOUSE); break;
+                        case 0x22: map_key(BTN_TOOL_FINGER); break;
+                        default: map_key(BTN_TOOL_PEN); break;
                         }
                         break;
 
-                case HID_UP_HPVENDOR:   /* Reported on a Dutch layout HP5308 */
-
-                        set_bit(EV_REP, input->evbit);
-                        switch (usage->hid & HID_USAGE) {
-                                case 0x021: map_key_clear(KEY_PRINT);           break;
-                                case 0x070: map_key_clear(KEY_HP);              break;
-                                case 0x071: map_key_clear(KEY_CAMERA);          break;
-                                case 0x072: map_key_clear(KEY_SOUND);           break;
-                                case 0x073: map_key_clear(KEY_QUESTION);        break;
-                                case 0x080: map_key_clear(KEY_EMAIL);           break;
-                                case 0x081: map_key_clear(KEY_CHAT);            break;
-                                case 0x082: map_key_clear(KEY_SEARCH);          break;
-                                case 0x083: map_key_clear(KEY_CONNECT);         break;
-                                case 0x084: map_key_clear(KEY_FINANCE);         break;
-                                case 0x085: map_key_clear(KEY_SPORT);           break;
-                                case 0x086: map_key_clear(KEY_SHOP);            break;
-                                default:    goto ignore;
-                        }
+                case 0x3c: /* Invert */
+                        map_key_clear(BTN_TOOL_RUBBER);
                         break;
 
-                case HID_UP_MSVENDOR:
-
-                        goto ignore;
-
-                case HID_UP_CUSTOM: /* Reported on Logitech and Apple USB keyboards */
-
-                        set_bit(EV_REP, input->evbit);
-                        switch(usage->hid & HID_USAGE) {
-                                case 0x003:
-                                        /* The fn key on Apple USB keyboards */
-                                        map_key_clear(KEY_FN);
-                                        hidinput_apple_setup(input);
-                                        break;
+                case 0x33: /* Touch */
+                case 0x42: /* TipSwitch */
+                case 0x43: /* TipSwitch2 */
+                        device->quirks &= ~HID_QUIRK_NOTOUCH;
+                        map_key_clear(BTN_TOUCH);
+                        break;
 
-                                default:    goto ignore;
-                        }
+                case 0x44: /* BarrelSwitch */
+                        map_key_clear(BTN_STYLUS);
                         break;
 
-                case HID_UP_LOGIVENDOR:
+                default:  goto unknown;
+                }
+                break;
+
+        case HID_UP_CONSUMER:   /* USB HUT v1.1, pages 56-62 */
+                switch (usage->hid & HID_USAGE) {
+                case 0x000: goto ignore;
+                case 0x034: map_key_clear(KEY_SLEEP);           break;
+                case 0x036: map_key_clear(BTN_MISC);            break;
+
+                case 0x040: map_key_clear(KEY_MENU);            break;
+                case 0x045: map_key_clear(KEY_RADIO);           break;
+
+                case 0x083: map_key_clear(KEY_LAST);            break;
+                case 0x088: map_key_clear(KEY_PC);              break;
+                case 0x089: map_key_clear(KEY_TV);              break;
+                case 0x08a: map_key_clear(KEY_WWW);             break;
+                case 0x08b: map_key_clear(KEY_DVD);             break;
+                case 0x08c: map_key_clear(KEY_PHONE);           break;
+                case 0x08d: map_key_clear(KEY_PROGRAM);         break;
+                case 0x08e: map_key_clear(KEY_VIDEOPHONE);      break;
+                case 0x08f: map_key_clear(KEY_GAMES);           break;
+                case 0x090: map_key_clear(KEY_MEMO);            break;
+                case 0x091: map_key_clear(KEY_CD);              break;
+                case 0x092: map_key_clear(KEY_VCR);             break;
+                case 0x093: map_key_clear(KEY_TUNER);           break;
+                case 0x094: map_key_clear(KEY_EXIT);            break;
+                case 0x095: map_key_clear(KEY_HELP);            break;
+                case 0x096: map_key_clear(KEY_TAPE);            break;
+                case 0x097: map_key_clear(KEY_TV2);             break;
+                case 0x098: map_key_clear(KEY_SAT);             break;
+                case 0x09a: map_key_clear(KEY_PVR);             break;
+
+                case 0x09c: map_key_clear(KEY_CHANNELUP);       break;
+                case 0x09d: map_key_clear(KEY_CHANNELDOWN);     break;
+                case 0x0a0: map_key_clear(KEY_VCR2);            break;
+
+                case 0x0b0: map_key_clear(KEY_PLAY);            break;
+                case 0x0b1: map_key_clear(KEY_PAUSE);           break;
+                case 0x0b2: map_key_clear(KEY_RECORD);          break;
+                case 0x0b3: map_key_clear(KEY_FASTFORWARD);     break;
+                case 0x0b4: map_key_clear(KEY_REWIND);          break;
+                case 0x0b5: map_key_clear(KEY_NEXTSONG);        break;
+                case 0x0b6: map_key_clear(KEY_PREVIOUSSONG);    break;
+                case 0x0b7: map_key_clear(KEY_STOPCD);          break;
+                case 0x0b8: map_key_clear(KEY_EJECTCD);         break;
+                case 0x0bc: map_key_clear(KEY_MEDIA_REPEAT);    break;
+
+                case 0x0cd: map_key_clear(KEY_PLAYPAUSE);       break;
+                case 0x0e0: map_abs_clear(ABS_VOLUME);          break;
+                case 0x0e2: map_key_clear(KEY_MUTE);            break;
+                case 0x0e5: map_key_clear(KEY_BASSBOOST);       break;
+                case 0x0e9: map_key_clear(KEY_VOLUMEUP);        break;
+                case 0x0ea: map_key_clear(KEY_VOLUMEDOWN);      break;
+
+                case 0x182: map_key_clear(KEY_BOOKMARKS);       break;
+                case 0x183: map_key_clear(KEY_CONFIG);          break;
+                case 0x184: map_key_clear(KEY_WORDPROCESSOR);   break;
+                case 0x185: map_key_clear(KEY_EDITOR);          break;
+                case 0x186: map_key_clear(KEY_SPREADSHEET);     break;
+                case 0x187: map_key_clear(KEY_GRAPHICSEDITOR);  break;
+                case 0x188: map_key_clear(KEY_PRESENTATION);    break;
+                case 0x189: map_key_clear(KEY_DATABASE);        break;
+                case 0x18a: map_key_clear(KEY_MAIL);            break;
+                case 0x18b: map_key_clear(KEY_NEWS);            break;
+                case 0x18c: map_key_clear(KEY_VOICEMAIL);       break;
+                case 0x18d: map_key_clear(KEY_ADDRESSBOOK);     break;
+                case 0x18e: map_key_clear(KEY_CALENDAR);        break;
+                case 0x191: map_key_clear(KEY_FINANCE);         break;
+                case 0x192: map_key_clear(KEY_CALC);            break;
+                case 0x194: map_key_clear(KEY_FILE);            break;
+                case 0x196: map_key_clear(KEY_WWW);             break;
+                case 0x199: map_key_clear(KEY_CHAT);            break;
+                case 0x19c: map_key_clear(KEY_LOGOFF);          break;
+                case 0x19e: map_key_clear(KEY_COFFEE);          break;
+                case 0x1a6: map_key_clear(KEY_HELP);            break;
+                case 0x1a7: map_key_clear(KEY_DOCUMENTS);       break;
+                case 0x1ab: map_key_clear(KEY_SPELLCHECK);      break;
+                case 0x1b6: map_key_clear(KEY_MEDIA);           break;
+                case 0x1b7: map_key_clear(KEY_SOUND);           break;
+                case 0x1bc: map_key_clear(KEY_MESSENGER);       break;
+                case 0x1bd: map_key_clear(KEY_INFO);            break;
+                case 0x201: map_key_clear(KEY_NEW);             break;
+                case 0x202: map_key_clear(KEY_OPEN);            break;
+                case 0x203: map_key_clear(KEY_CLOSE);           break;
+                case 0x204: map_key_clear(KEY_EXIT);            break;
+                case 0x207: map_key_clear(KEY_SAVE);            break;
+                case 0x208: map_key_clear(KEY_PRINT);           break;
+                case 0x209: map_key_clear(KEY_PROPS);           break;
+                case 0x21a: map_key_clear(KEY_UNDO);            break;
+                case 0x21b: map_key_clear(KEY_COPY);            break;
+                case 0x21c: map_key_clear(KEY_CUT);             break;
+                case 0x21d: map_key_clear(KEY_PASTE);           break;
+                case 0x21f: map_key_clear(KEY_FIND);            break;
+                case 0x221: map_key_clear(KEY_SEARCH);          break;
+                case 0x222: map_key_clear(KEY_GOTO);            break;
+                case 0x223: map_key_clear(KEY_HOMEPAGE);        break;
+                case 0x224: map_key_clear(KEY_BACK);            break;
+                case 0x225: map_key_clear(KEY_FORWARD);         break;
+                case 0x226: map_key_clear(KEY_STOP);            break;
+                case 0x227: map_key_clear(KEY_REFRESH);         break;
+                case 0x22a: map_key_clear(KEY_BOOKMARKS);       break;
+                case 0x22d: map_key_clear(KEY_ZOOMIN);          break;
+                case 0x22e: map_key_clear(KEY_ZOOMOUT);         break;
+                case 0x22f: map_key_clear(KEY_ZOOMRESET);       break;
+                case 0x233: map_key_clear(KEY_SCROLLUP);        break;
+                case 0x234: map_key_clear(KEY_SCROLLDOWN);      break;
+                case 0x238: map_rel(REL_HWHEEL);                break;
+                case 0x25f: map_key_clear(KEY_CANCEL);          break;
+                case 0x279: map_key_clear(KEY_REDO);            break;
+
+                case 0x289: map_key_clear(KEY_REPLY);           break;
+                case 0x28b: map_key_clear(KEY_FORWARDMAIL);     break;
+                case 0x28c: map_key_clear(KEY_SEND);            break;
+
+                default:    goto ignore;
+                }
+                break;
+
+        case HID_UP_HPVENDOR:   /* Reported on a Dutch layout HP5308 */
+                set_bit(EV_REP, input->evbit);
+                switch (usage->hid & HID_USAGE) {
+                case 0x021: map_key_clear(KEY_PRINT);           break;
+                case 0x070: map_key_clear(KEY_HP);              break;
+                case 0x071: map_key_clear(KEY_CAMERA);          break;
+                case 0x072: map_key_clear(KEY_SOUND);           break;
+                case 0x073: map_key_clear(KEY_QUESTION);        break;
+                case 0x080: map_key_clear(KEY_EMAIL);           break;
+                case 0x081: map_key_clear(KEY_CHAT);            break;
+                case 0x082: map_key_clear(KEY_SEARCH);          break;
+                case 0x083: map_key_clear(KEY_CONNECT);         break;
+                case 0x084: map_key_clear(KEY_FINANCE);         break;
+                case 0x085: map_key_clear(KEY_SPORT);           break;
+                case 0x086: map_key_clear(KEY_SHOP);            break;
+                default:    goto ignore;
+                }
+                break;
 
-                        goto ignore;
-                
-                case HID_UP_PID:
+        case HID_UP_MSVENDOR:
+                goto ignore;
 
-                        switch(usage->hid & HID_USAGE) {
-                                case 0xa4: map_key_clear(BTN_DEAD);     break;
-                                default: goto ignore;
-                        }
-                        break;
+        case HID_UP_CUSTOM: /* Reported on Logitech and Apple USB keyboards */
+                set_bit(EV_REP, input->evbit);
+                goto ignore;
 
-                default:
-                unknown:
-                        if (field->report_size == 1) {
-                                if (field->report->type == HID_OUTPUT_REPORT) {
-                                        map_led(LED_MISC);
-                                        break;
-                                }
-                                map_key(BTN_MISC);
-                                break;
-                        }
-                        if (field->flags & HID_MAIN_ITEM_RELATIVE) {
-                                map_rel(REL_MISC);
+        case HID_UP_LOGIVENDOR:
+                goto ignore;
+        
+        case HID_UP_PID:
+                switch (usage->hid & HID_USAGE) {
+                case 0xa4: map_key_clear(BTN_DEAD);     break;
+                default: goto ignore;
+                }
+                break;
+
+        default:
+        unknown:
+                if (field->report_size == 1) {
+                        if (field->report->type == HID_OUTPUT_REPORT) {
+                                map_led(LED_MISC);
                                 break;
                         }
-                        map_abs(ABS_MISC);
+                        map_key(BTN_MISC);
+                        break;
+                }
+                if (field->flags & HID_MAIN_ITEM_RELATIVE) {
+                        map_rel(REL_MISC);
                         break;
+                }
+                map_abs(ABS_MISC);
+                break;
         }
 
 mapped:
-        if (device->quirks & HID_QUIRK_MIGHTYMOUSE) {
-                if (usage->hid == HID_GD_Z)
-                        map_rel(REL_HWHEEL);
-                else if (usage->code == BTN_1)
-                        map_key(BTN_2);
-                else if (usage->code == BTN_2)
-                        map_key(BTN_1);
-        }
-
-        if ((device->quirks & (HID_QUIRK_2WHEEL_MOUSE_HACK_7 | HID_QUIRK_2WHEEL_MOUSE_HACK_5 |
-                        HID_QUIRK_2WHEEL_MOUSE_HACK_B8)) && (usage->type == EV_REL) &&
-                        (usage->code == REL_WHEEL))
-                set_bit(REL_HWHEEL, bit);
-
-        if (((device->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
-                || ((device->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007)))
+        if (device->driver->input_mapped && device->driver->input_mapped(device,
+                                hidinput, field, usage, &bit, &max) < 0)
                 goto ignore;
 
-        if ((device->quirks & HID_QUIRK_BAD_RELATIVE_KEYS) &&
-                usage->type == EV_KEY && (field->flags & HID_MAIN_ITEM_RELATIVE))
-                field->flags &= ~HID_MAIN_ITEM_RELATIVE;
-
         set_bit(usage->type, input->evbit);
 
-        if (device->quirks & HID_QUIRK_DUPLICATE_USAGES &&
-                        (usage->type == EV_KEY ||
-                         usage->type == EV_REL ||
-                         usage->type == EV_ABS))
-                clear_bit(usage->code, bit);
-
         while (usage->code <= max && test_and_set_bit(usage->code, bit))
                 usage->code = find_next_zero_bit(bit, max + 1, usage->code);
 
@@ -807,6 +534,9 @@ mapped:
                         input_set_abs_params(input, usage->code, a, b, (b - a) >> 8, (b - a) >> 4);
                 else    input_set_abs_params(input, usage->code, a, b, 0, 0);
 
+                /* use a larger default input buffer for MT devices */
+                if (usage->code == ABS_MT_POSITION_X && input->hint_events_per_packet == 0)
+                        input_set_events_per_packet(input, 60);
         }
 
         if (usage->type == EV_ABS &&
@@ -835,15 +565,9 @@ mapped:
                 set_bit(MSC_SCAN, input->mscbit);
         }
 
-        hid_resolv_event(usage->type, usage->code);
-
-        dbg_hid_line("\n");
-
-        return;
-
 ignore:
-        dbg_hid_line("IGNORED\n");
         return;
+
 }
 
 void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
@@ -859,10 +583,6 @@ void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct
         if (!usage->type)
                 return;
 
-        /* handle input events for quirky devices */
-        if (hidinput_event_quirks(hid, field, usage, value))
-                return;
-
         if (usage->hat_min < usage->hat_max || usage->hat_dir) {
                 int hat_dir = usage->hat_dir;
                 if (!hat_dir)
@@ -936,6 +656,9 @@ void hidinput_report_event(struct hid_device *hid, struct hid_report *report)
 {
         struct hid_input *hidinput;
 
+        if (hid->quirks & HID_QUIRK_NO_INPUT_SYNC)
+                return;
+
         list_for_each_entry(hidinput, &hid->inputs, list)
                 input_sync(hidinput->input);
 }
@@ -962,14 +685,14 @@ static int hidinput_open(struct input_dev *dev)
 {
         struct hid_device *hid = input_get_drvdata(dev);
 
-        return hid->hid_open(hid);
+        return hid->ll_driver->open(hid);
 }
 
 static void hidinput_close(struct input_dev *dev)
 {
         struct hid_device *hid = input_get_drvdata(dev);
 
-        hid->hid_close(hid);
+        hid->ll_driver->close(hid);
 }
 
 /*
@@ -978,7 +701,7 @@ static void hidinput_close(struct input_dev *dev)
  * Read all reports and initialize the absolute field values.
  */
 
-int hidinput_connect(struct hid_device *hid)
+int hidinput_connect(struct hid_device *hid, unsigned int force)
 {
         struct hid_report *report;
         struct hid_input *hidinput = NULL;
@@ -986,19 +709,20 @@ int hidinput_connect(struct hid_device *hid)
         int i, j, k;
         int max_report_type = HID_OUTPUT_REPORT;
 
-        if (hid->quirks & HID_QUIRK_IGNORE_HIDINPUT)
-                return -1;
-
         INIT_LIST_HEAD(&hid->inputs);
 
-        for (i = 0; i < hid->maxcollection; i++)
-                if (hid->collection[i].type == HID_COLLECTION_APPLICATION ||
-                    hid->collection[i].type == HID_COLLECTION_PHYSICAL)
-                        if (IS_INPUT_APPLICATION(hid->collection[i].usage))
-                                break;
+        if (!force) {
+                for (i = 0; i < hid->maxcollection; i++) {
+                        struct hid_collection *col = &hid->collection[i];
+                        if (col->type == HID_COLLECTION_APPLICATION ||
+                                        col->type == HID_COLLECTION_PHYSICAL)
+                                if (IS_INPUT_APPLICATION(col->usage))
+                                        break;
+                }
 
-        if (i == hid->maxcollection && (hid->quirks & HID_QUIRK_HIDINPUT) == 0)
-                return -1;
+                if (i == hid->maxcollection)
+                        return -1;
+        }
 
         if (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
                 max_report_type = HID_INPUT_REPORT;
@@ -1020,7 +744,8 @@ int hidinput_connect(struct hid_device *hid)
                                 }
 
                                 input_set_drvdata(input_dev, hid);
-                                input_dev->event = hid->hidinput_input_event;
+                                input_dev->event =
+                                        hid->ll_driver->hidinput_input_event;
                                 input_dev->open = hidinput_open;
                                 input_dev->close = hidinput_close;
                                 input_dev->setkeycode = hidinput_setkeycode;
@@ -1033,7 +758,7 @@ int hidinput_connect(struct hid_device *hid)
                                 input_dev->id.vendor  = hid->vendor;
                                 input_dev->id.product = hid->product;
                                 input_dev->id.version = hid->version;
-                                input_dev->dev.parent = hid->dev;
+                                input_dev->dev.parent = hid->dev.parent;
                                 hidinput->input = input_dev;
                                 list_add_tail(&hidinput->list, &hid->inputs);
                         }
diff --git a/usr/src/dkms_source_tree/hid.mod.c b/usr/src/dkms_source_tree/hid.mod.c
deleted file mode 100644
index 03190d8..0000000
--- a/usr/src/dkms_source_tree/hid.mod.c
+++ /dev/null
@@ -1,76 +0,0 @@
-#include <linux/module.h>
-#include <linux/vermagic.h>
-#include <linux/compiler.h>
-
-MODULE_INFO(vermagic, VERMAGIC_STRING);
-
-struct module __this_module
-__attribute__((section(".gnu.linkonce.this_module"))) = {
- .name = KBUILD_MODNAME,
- .init = init_module,
-#ifdef CONFIG_MODULE_UNLOAD
- .exit = cleanup_module,
-#endif
- .arch = MODULE_ARCH_INIT,
-};
-
-static const struct modversion_info ____versions[]
-__used
-__attribute__((section("__versions"))) = {
-        { 0xa257c5a3, "struct_module" },
-        { 0x6b9a06f4, "cdev_del" },
-        { 0x24b84de1, "per_cpu__current_task" },
-        { 0xafcac6fe, "kmalloc_caches" },
-        { 0x12da5bb2, "__kmalloc" },
-        { 0x73ffd178, "cdev_init" },
-        { 0x608c2831, "warn_on_slowpath" },
-        { 0xd6ee688f, "vmalloc" },
-        { 0x60400b7f, "pv_lock_ops" },
-        { 0xa5423cc4, "param_get_int" },
-        { 0x71356fba, "remove_wait_queue" },
-        { 0x973873ab, "_spin_lock" },
-        { 0x25e6a7c5, "device_destroy" },
-        { 0x6729d3df, "__get_user_4" },
-        { 0xe2fae716, "kmemdup" },
-        { 0x577cc638, "mutex_unlock" },
-        { 0x7485e15e, "unregister_chrdev_region" },
-        { 0x999e8297, "vfree" },
-        { 0xcb32da10, "param_set_int" },
-        { 0x805a8fd8, "input_event" },
-        { 0xffd5a395, "default_wake_function" },
-        { 0x67e71b77, "__mutex_init" },
-        { 0xb72397d5, "printk" },
-        { 0x3656bf5a, "lock_kernel" },
-        { 0x479c3c86, "find_next_zero_bit" },
-        { 0x2f287f0d, "copy_to_user" },
-        { 0xb4390f9a, "mcount" },
-        { 0x8aaf8654, "mutex_lock" },
-        { 0x9eae490d, "device_create" },
-        { 0x9b355194, "cdev_add" },
-        { 0xb1f975aa, "unlock_kernel" },
-        { 0xa36a1add, "kmem_cache_alloc" },
-        { 0xb2fd5ceb, "__put_user_4" },
-        { 0xbc9fe26a, "input_register_device" },
-        { 0x4292364c, "schedule" },
-        { 0x98578ea8, "input_free_device" },
-        { 0x64cd5d16, "init_waitqueue_head" },
-        { 0x642e54ac, "__wake_up" },
-        { 0x650fb346, "add_wait_queue" },
-        { 0x37a0cba, "kfree" },
-        { 0xab1d8e96, "input_unregister_device" },
-        { 0x9ef749e2, "unregister_chrdev" },
-        { 0xba9b3a6f, "class_destroy" },
-        { 0xb0412d, "kill_fasync" },
-        { 0x3ea9f1de, "__class_create" },
-        { 0xd6c963c, "copy_from_user" },
-        { 0x29537c9e, "alloc_chrdev_region" },
-        { 0xa51d5c08, "input_allocate_device" },
-};
-
-static const char __module_depends[]
-__used
-__attribute__((section(".modinfo"))) =
-"depends=";
-
-
-MODULE_INFO(srcversion, "B7CBC60F230650415B31999");
diff --git a/usr/src/dkms_source_tree/hidraw.c b/usr/src/dkms_source_tree/hidraw.c
index 8c030d9..3ccd478 100644
--- a/usr/src/dkms_source_tree/hidraw.c
+++ b/usr/src/dkms_source_tree/hidraw.c
@@ -28,8 +28,10 @@
 #include <linux/poll.h>
 #include <linux/device.h>
 #include <linux/major.h>
+#include <linux/slab.h>
 #include <linux/hid.h>
 #include <linux/mutex.h>
+#include <linux/sched.h>
 #include <linux/smp_lock.h>
 
 #include <linux/hidraw.h>
@@ -38,7 +40,7 @@ static int hidraw_major;
 static struct cdev hidraw_cdev;
 static struct class *hidraw_class;
 static struct hidraw *hidraw_table[HIDRAW_MAX_DEVICES];
-static DEFINE_SPINLOCK(minors_lock);
+static DEFINE_MUTEX(minors_lock);
 
 static ssize_t hidraw_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 {
@@ -47,10 +49,9 @@ static ssize_t hidraw_read(struct file *file, char __user *buffer, size_t count,
         char *report;
         DECLARE_WAITQUEUE(wait, current);
 
-        while (ret == 0) {
-
-                mutex_lock(&list->read_mutex);
+        mutex_lock(&list->read_mutex);
 
+        while (ret == 0) {
                 if (list->head == list->tail) {
                         add_wait_queue(&list->hidraw->wait, &wait);
                         set_current_state(TASK_INTERRUPTIBLE);
@@ -105,38 +106,48 @@ out:
 static ssize_t hidraw_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
         unsigned int minor = iminor(file->f_path.dentry->d_inode);
-        /* FIXME: What stops hidraw_table going NULL */
-        struct hid_device *dev = hidraw_table[minor]->hid;
+        struct hid_device *dev;
         __u8 *buf;
         int ret = 0;
 
-        if (!dev->hid_output_raw_report)
-                return -ENODEV;
+        mutex_lock(&minors_lock);
+        dev = hidraw_table[minor]->hid;
+
+        if (!dev->hid_output_raw_report) {
+                ret = -ENODEV;
+                goto out;
+        }
 
         if (count > HID_MAX_BUFFER_SIZE) {
                 printk(KERN_WARNING "hidraw: pid %d passed too large report\n",
                                 task_pid_nr(current));
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
         }
 
         if (count < 2) {
                 printk(KERN_WARNING "hidraw: pid %d passed too short report\n",
                                 task_pid_nr(current));
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
         }
 
         buf = kmalloc(count * sizeof(__u8), GFP_KERNEL);
-        if (!buf)
-                return -ENOMEM;
+        if (!buf) {
+                ret = -ENOMEM;
+                goto out;
+        }
 
         if (copy_from_user(buf, buffer, count)) {
                 ret = -EFAULT;
-                goto out;
+                goto out_free;
         }
 
-        ret = dev->hid_output_raw_report(dev, buf, count);
-out:
+        ret = dev->hid_output_raw_report(dev, buf, count, HID_OUTPUT_REPORT);
+out_free:
         kfree(buf);
+out:
+        mutex_unlock(&minors_lock);
         return ret;
 }
 
@@ -159,16 +170,13 @@ static int hidraw_open(struct inode *inode, struct file *file)
         struct hidraw_list *list;
         int err = 0;
 
-        lock_kernel();
         if (!(list = kzalloc(sizeof(struct hidraw_list), GFP_KERNEL))) {
                 err = -ENOMEM;
                 goto out;
         }
 
-        spin_lock(&minors_lock);
+        mutex_lock(&minors_lock);
         if (!hidraw_table[minor]) {
-                printk(KERN_EMERG "hidraw device with minor %d doesn't exist\n",
-                                minor);
                 kfree(list);
                 err = -ENODEV;
                 goto out_unlock;
@@ -180,13 +188,23 @@ static int hidraw_open(struct inode *inode, struct file *file)
         file->private_data = list;
 
         dev = hidraw_table[minor];
-        if (!dev->open++)
-                dev->hid->hid_open(dev->hid);
+        if (!dev->open++) {
+                if (dev->hid->ll_driver->power) {
+                        err = dev->hid->ll_driver->power(dev->hid, PM_HINT_FULLON);
+                        if (err < 0)
+                                goto out_unlock;
+                }
+                err = dev->hid->ll_driver->open(dev->hid);
+                if (err < 0) {
+                        if (dev->hid->ll_driver->power)
+                                dev->hid->ll_driver->power(dev->hid, PM_HINT_NORMAL);
+                        dev->open--;
+                }
+        }
 
 out_unlock:
-        spin_unlock(&minors_lock);
+        mutex_unlock(&minors_lock);
 out:
-        unlock_kernel();
         return err;
 
 }
@@ -197,19 +215,19 @@ static int hidraw_release(struct inode * inode, struct file * file)
         struct hidraw *dev;
         struct hidraw_list *list = file->private_data;
 
-        if (!hidraw_table[minor]) {
-                printk(KERN_EMERG "hidraw device with minor %d doesn't exist\n",
-                                minor);
+        if (!hidraw_table[minor])
                 return -ENODEV;
-        }
 
         list_del(&list->node);
         dev = hidraw_table[minor];
-        if (!dev->open--) {
-                if (list->hidraw->exist)
-                        dev->hid->hid_close(dev->hid);
-                else
+        if (!--dev->open) {
+                if (list->hidraw->exist) {
+                        if (dev->hid->ll_driver->power)
+                                dev->hid->ll_driver->power(dev->hid, PM_HINT_NORMAL);
+                        dev->hid->ll_driver->close(dev->hid);
+                } else {
                         kfree(list->hidraw);
+                }
         }
 
         kfree(list);
@@ -223,11 +241,12 @@ static long hidraw_ioctl(struct file *file, unsigned int cmd,
         struct inode *inode = file->f_path.dentry->d_inode;
         unsigned int minor = iminor(inode);
         long ret = 0;
-        /* FIXME: What stops hidraw_table going NULL */
-        struct hidraw *dev = hidraw_table[minor];
+        struct hidraw *dev;
         void __user *user_arg = (void __user*) arg;
 
-        lock_kernel();
+        mutex_lock(&minors_lock);
+        dev = hidraw_table[minor];
+
         switch (cmd) {
                 case HIDIOCGRDESCSIZE:
                         if (put_user(dev->hid->rsize, (int __user *)arg))
@@ -262,8 +281,45 @@ static long hidraw_ioctl(struct file *file, unsigned int cmd,
                                 break;
                         }
                 default:
-                        ret = -ENOTTY;
+                        {
+                                struct hid_device *hid = dev->hid;
+                                if (_IOC_TYPE(cmd) != 'H' || _IOC_DIR(cmd) != _IOC_READ) {
+                                        ret = -EINVAL;
+                                        break;
+                                }
+
+                                if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGRAWNAME(0))) {
+                                        int len;
+                                        if (!hid->name) {
+                                                ret = 0;
+                                                break;
+                                        }
+                                        len = strlen(hid->name) + 1;
+                                        if (len > _IOC_SIZE(cmd))
+                                                len = _IOC_SIZE(cmd);
+                                        ret = copy_to_user(user_arg, hid->name, len) ?
+                                                -EFAULT : len;
+                                        break;
+                                }
+
+                                if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGRAWPHYS(0))) {
+                                        int len;
+                                        if (!hid->phys) {
+                                                ret = 0;
+                                                break;
+                                        }
+                                        len = strlen(hid->phys) + 1;
+                                        if (len > _IOC_SIZE(cmd))
+                                                len = _IOC_SIZE(cmd);
+                                        ret = copy_to_user(user_arg, hid->phys, len) ?
+                                                -EFAULT : len;
+                                        break;
+                                }
+                }
+
+                ret = -ENOTTY;
         }
+        mutex_unlock(&minors_lock);
         return ret;
 }
 
@@ -298,10 +354,7 @@ int hidraw_connect(struct hid_device *hid)
         int minor, result;
         struct hidraw *dev;
 
-        /* TODO currently we accept any HID device. This should later
-         * probably be fixed to accept only those devices which provide
-         * non-input applications
-         */
+        /* we accept any HID device, no matter the applications */
 
         dev = kzalloc(sizeof(struct hidraw), GFP_KERNEL);
         if (!dev)
@@ -309,7 +362,7 @@ int hidraw_connect(struct hid_device *hid)
 
         result = -EINVAL;
 
-        spin_lock(&minors_lock);
+        mutex_lock(&minors_lock);
 
         for (minor = 0; minor < HIDRAW_MAX_DEVICES; minor++) {
                 if (hidraw_table[minor])
@@ -319,26 +372,24 @@ int hidraw_connect(struct hid_device *hid)
                 break;
         }
 
-        spin_unlock(&minors_lock);
-
         if (result) {
+                mutex_unlock(&minors_lock);
                 kfree(dev);
                 goto out;
         }
 
-        dev->dev = device_create_drvdata(hidraw_class, NULL,
-                                         MKDEV(hidraw_major, minor), NULL,
-                                         "%s%d", "hidraw", minor);
+        dev->dev = device_create(hidraw_class, &hid->dev, MKDEV(hidraw_major, minor),
+                                 NULL, "%s%d", "hidraw", minor);
 
         if (IS_ERR(dev->dev)) {
-                spin_lock(&minors_lock);
                 hidraw_table[minor] = NULL;
-                spin_unlock(&minors_lock);
+                mutex_unlock(&minors_lock);
                 result = PTR_ERR(dev->dev);
                 kfree(dev);
                 goto out;
         }
 
+        mutex_unlock(&minors_lock);
         init_waitqueue_head(&dev->wait);
         INIT_LIST_HEAD(&dev->list);
 
@@ -360,14 +411,14 @@ void hidraw_disconnect(struct hid_device *hid)
 
         hidraw->exist = 0;
 
-        spin_lock(&minors_lock);
+        mutex_lock(&minors_lock);
         hidraw_table[hidraw->minor] = NULL;
-        spin_unlock(&minors_lock);
+        mutex_unlock(&minors_lock);
 
         device_destroy(hidraw_class, MKDEV(hidraw_major, hidraw->minor));
 
         if (hidraw->open) {
-                hid->hid_close(hid);
+                hid->ll_driver->close(hid);
                 wake_up_interruptible(&hidraw->wait);
         } else {
                 kfree(hidraw);
@@ -404,7 +455,7 @@ out:
         return result;
 }
 
-void __exit hidraw_exit(void)
+void hidraw_exit(void)
 {
         dev_t dev_id = MKDEV(hidraw_major, 0);
 
diff --git a/usr/src/dkms_source_tree/patches/10-expose-and-dashboard.patch b/usr/src/dkms_source_tree/patches/10-expose-and-dashboard.patch
deleted file mode 100644
index de64ac1..0000000
--- a/usr/src/dkms_source_tree/patches/10-expose-and-dashboard.patch
+++ /dev/null
@@ -1,17 +0,0 @@
-diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
---- a/drivers/hid/hid-input.c
-+++ b/drivers/hid/hid-input.c
-@@ -98,10 +98,11 @@ static struct hidinput_key_translation apple_fn_keys[] = {
- 
- static struct hidinput_key_translation apple_fn_keys[] = {
-        { KEY_BACKSPACE, KEY_DELETE },
-+       { KEY_ENTER,    KEY_INSERT },
-        { KEY_F1,       KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
-        { KEY_F2,       KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
--       { KEY_F3,       KEY_FN_F5,          APPLE_FLAG_FKEY }, /* Exposé */
--       { KEY_F4,       KEY_FN_F4,          APPLE_FLAG_FKEY }, /* Dashboard */
-+       { KEY_F3,       KEY_CYCLEWINDOWS,   APPLE_FLAG_FKEY }, /* Exposé */
-+       { KEY_F4,       KEY_CALC,           APPLE_FLAG_FKEY }, /* Dashboard */
-        { KEY_F5,       KEY_KBDILLUMDOWN,   APPLE_FLAG_FKEY },
-        { KEY_F6,       KEY_KBDILLUMUP,     APPLE_FLAG_FKEY },
-        { KEY_F7,       KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },