upgrade to natty (2.6.38-5)

7 files changed, 137 insertions, 90 deletions

diff --git a/usr/src/dkms_source_tree/KERNEL_SOURCE_VERSION b/usr/src/dkms_source_tree/KERNEL_SOURCE_VERSION
index ccb045a..3b97b43 100644
--- a/usr/src/dkms_source_tree/KERNEL_SOURCE_VERSION
+++ b/usr/src/dkms_source_tree/KERNEL_SOURCE_VERSION
@@ -1 +1 @@
-2.6.37-9-generic
+2.6.38-6-generic
diff --git a/usr/src/dkms_source_tree/dkms.conf b/usr/src/dkms_source_tree/dkms.conf
index 997bdc6..2bc2ab0 100644
--- a/usr/src/dkms_source_tree/dkms.conf
+++ b/usr/src/dkms_source_tree/dkms.conf
@@ -1,5 +1,5 @@
 NAME=hid
-VERSION=1.1.0
+VERSION=1.1.1
 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 5ba6dda..d678cf3 100644
--- a/usr/src/dkms_source_tree/hid-core.c
+++ b/usr/src/dkms_source_tree/hid-core.c
@@ -14,6 +14,8 @@
  * any later version.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/init.h>
@@ -59,7 +61,8 @@ struct hid_report *hid_register_report(struct hid_device *device, unsigned type,
         if (report_enum->report_id_hash[id])
                 return report_enum->report_id_hash[id];
 
-        if (!(report = kzalloc(sizeof(struct hid_report), GFP_KERNEL)))
+        report = kzalloc(sizeof(struct hid_report), GFP_KERNEL);
+        if (!report)
                 return NULL;
 
         if (id != 0)
@@ -90,8 +93,11 @@ static struct hid_field *hid_register_field(struct hid_report *report, unsigned
                 return NULL;
         }
 
-        if (!(field = kzalloc(sizeof(struct hid_field) + usages * sizeof(struct hid_usage)
-                + values * sizeof(unsigned), GFP_KERNEL))) return NULL;
+        field = kzalloc((sizeof(struct hid_field) +
+                         usages * sizeof(struct hid_usage) +
+                         values * sizeof(unsigned)), GFP_KERNEL);
+        if (!field)
+                return NULL;
 
         field->index = report->maxfield++;
         report->field[field->index] = field;
@@ -172,10 +178,14 @@ static int close_collection(struct hid_parser *parser)
 
 static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
 {
+        struct hid_collection *collection = parser->device->collection;
         int n;
-        for (n = parser->collection_stack_ptr - 1; n >= 0; n--)
-                if (parser->device->collection[parser->collection_stack[n]].type == type)
-                        return parser->device->collection[parser->collection_stack[n]].usage;
+
+        for (n = parser->collection_stack_ptr - 1; n >= 0; n--) {
+                unsigned index = parser->collection_stack[n];
+                if (collection[index].type == type)
+                        return collection[index].usage;
+        }
         return 0; /* we know nothing about this usage type */
 }
 
@@ -209,7 +219,8 @@ static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsign
         unsigned offset;
         int i;
 
-        if (!(report = hid_register_report(parser->device, report_type, parser->global.report_id))) {
+        report = hid_register_report(parser->device, report_type, parser->global.report_id);
+        if (!report) {
                 dbg_hid("hid_register_report failed\n");
                 return -1;
         }
@@ -227,7 +238,8 @@ static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsign
 
         usages = max_t(int, parser->local.usage_index, parser->global.report_count);
 
-        if ((field = hid_register_field(report, usages, parser->global.report_count)) == NULL)
+        field = hid_register_field(report, usages, parser->global.report_count);
+        if (!field)
                 return 0;
 
         field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
@@ -388,12 +400,6 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
         __u32 data;
         unsigned n;
 
-        /* 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;
-        }
-
         data = item_udata(item);
 
         switch (item->tag) {
@@ -658,13 +664,12 @@ int hid_parse_report(struct hid_device *device, __u8 *start,
                 return -ENOMEM;
         device->rsize = size;
 
-        parser = vmalloc(sizeof(struct hid_parser));
+        parser = vzalloc(sizeof(struct hid_parser));
         if (!parser) {
                 ret = -ENOMEM;
                 goto err;
         }
 
-        memset(parser, 0, sizeof(struct hid_parser));
         parser->device = device;
 
         end = start + size;
@@ -678,7 +683,8 @@ int hid_parse_report(struct hid_device *device, __u8 *start,
 
                 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);
+                                item.format, (unsigned)item.size,
+                                (unsigned)item.type, (unsigned)item.tag);
                         goto err;
                 }
 
@@ -743,13 +749,14 @@ static u32 s32ton(__s32 value, unsigned n)
  * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
  */
 
-static __inline__ __u32 extract(__u8 *report, unsigned offset, unsigned n)
+static __u32 extract(const struct hid_device *hid, __u8 *report,
+                     unsigned offset, unsigned n)
 {
         u64 x;
 
         if (n > 32)
-                printk(KERN_WARNING "HID: extract() called with n (%d) > 32! (%s)\n",
-                                n, current->comm);
+                hid_warn(hid, "extract() called with n (%d) > 32! (%s)\n",
+                         n, current->comm);
 
         report += offset >> 3;  /* adjust byte index */
         offset &= 7;            /* now only need bit offset into one byte */
@@ -766,18 +773,19 @@ static __inline__ __u32 extract(__u8 *report, unsigned offset, unsigned n)
  * endianness of register values by considering a register
  * a "cached" copy of the little endiad bit stream.
  */
-static __inline__ void implement(__u8 *report, unsigned offset, unsigned n, __u32 value)
+static void implement(const struct hid_device *hid, __u8 *report,
+                      unsigned offset, unsigned n, __u32 value)
 {
         u64 x;
         u64 m = (1ULL << n) - 1;
 
         if (n > 32)
-                printk(KERN_WARNING "HID: implement() called with n (%d) > 32! (%s)\n",
-                                n, current->comm);
+                hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n",
+                         __func__, n, current->comm);
 
         if (value > m)
-                printk(KERN_WARNING "HID: implement() called with too large value %d! (%s)\n",
-                                value, current->comm);
+                hid_warn(hid, "%s() called with too large value %d! (%s)\n",
+                         __func__, value, current->comm);
         WARN_ON(value > m);
         value &= m;
 
@@ -794,7 +802,7 @@ static __inline__ void implement(__u8 *report, unsigned offset, unsigned n, __u3
  * Search an array for a value.
  */
 
-static __inline__ int search(__s32 *array, __s32 value, unsigned n)
+static int search(__s32 *array, __s32 value, unsigned n)
 {
         while (n--) {
                 if (*array++ == value)
@@ -893,18 +901,22 @@ static void hid_input_field(struct hid_device *hid, struct hid_field *field,
         __s32 max = field->logical_maximum;
         __s32 *value;
 
-        if (!(value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC)))
+        value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC);
+        if (!value)
                 return;
 
         for (n = 0; n < count; n++) {
 
-                        value[n] = min < 0 ? snto32(extract(data, offset + n * size, size), size) :
-                                                    extract(data, offset + n * size, size);
+                value[n] = min < 0 ?
+                        snto32(extract(hid, data, offset + n * size, size),
+                               size) :
+                        extract(hid, data, offset + n * size, size);
 
-                        if (!(field->flags & HID_MAIN_ITEM_VARIABLE) /* Ignore report if ErrorRollOver */
-                            && value[n] >= min && value[n] <= max
-                            && field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
-                                goto exit;
+                /* Ignore report if ErrorRollOver */
+                if (!(field->flags & HID_MAIN_ITEM_VARIABLE) &&
+                    value[n] >= min && value[n] <= max &&
+                    field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
+                        goto exit;
         }
 
         for (n = 0; n < count; n++) {
@@ -934,7 +946,8 @@ exit:
  * Output the field into the report.
  */
 
-static void hid_output_field(struct hid_field *field, __u8 *data)
+static void hid_output_field(const struct hid_device *hid,
+                             struct hid_field *field, __u8 *data)
 {
         unsigned count = field->report_count;
         unsigned offset = field->report_offset;
@@ -943,9 +956,11 @@ static void hid_output_field(struct hid_field *field, __u8 *data)
 
         for (n = 0; n < count; n++) {
                 if (field->logical_minimum < 0) /* signed values */
-                        implement(data, offset + n * size, size, s32ton(field->value[n], size));
+                        implement(hid, data, offset + n * size, size,
+                                  s32ton(field->value[n], size));
                 else                            /* unsigned values */
-                        implement(data, offset + n * size, size, field->value[n]);
+                        implement(hid, data, offset + n * size, size,
+                                  field->value[n]);
         }
 }
 
@@ -962,7 +977,7 @@ void hid_output_report(struct hid_report *report, __u8 *data)
 
         memset(data, 0, ((report->size - 1) >> 3) + 1);
         for (n = 0; n < report->maxfield; n++)
-                hid_output_field(report->field[n], data);
+                hid_output_field(report->device, report->field[n], data);
 }
 EXPORT_SYMBOL_GPL(hid_output_report);
 
@@ -1175,8 +1190,7 @@ int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
                 hdev->claimed |= HID_CLAIMED_HIDRAW;
 
         if (!hdev->claimed) {
-                dev_err(&hdev->dev, "claimed by neither input, hiddev nor "
-                                "hidraw\n");
+                hid_err(hdev, "claimed by neither input, hiddev nor hidraw\n");
                 return -ENODEV;
         }
 
@@ -1216,9 +1230,9 @@ int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
                 bus = "<UNKNOWN>";
         }
 
-        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);
+        hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n",
+                 buf, bus, hdev->version >> 8, hdev->version & 0xff,
+                 type, hdev->name, hdev->phys);
 
         return 0;
 }
@@ -1236,7 +1250,7 @@ void hid_disconnect(struct hid_device *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[] = {
+static const struct hid_device_id hid_have_special_driver[] = {
         { 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) },
@@ -1298,30 +1312,39 @@ static const struct hid_device_id hid_blacklist[] = {
         { 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_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
         { 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_10_1) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_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_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS) },
         { 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_CYPRESS, USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
         { 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_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1) },
         { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH3) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH4) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
         { 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_GENERAL_TOUCH, USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
         { 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_HANVON, USB_DEVICE_ID_HANVON_MULTITOUCH) },
         { 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) },
@@ -1382,6 +1405,7 @@ static const struct hid_device_id hid_blacklist[] = {
         { 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_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },
         { 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) },
@@ -1401,16 +1425,15 @@ static const struct hid_device_id hid_blacklist[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
         { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb65a) },
         { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
         { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) },
         { HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },
         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },
         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },
         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U) },
         { 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_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },
         { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },
         { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },
@@ -1511,9 +1534,9 @@ static int hid_bus_match(struct device *dev, struct device_driver *drv)
         if (!hid_match_device(hdev, hdrv))
                 return 0;
 
-        /* generic wants all non-blacklisted */
+        /* generic wants all that don't have specialized driver */
         if (!strncmp(hdrv->name, "generic-", 8))
-                return !hid_match_id(hdev, hid_blacklist);
+                return !hid_match_id(hdev, hid_have_special_driver);
 
         return 1;
 }
@@ -1619,10 +1642,10 @@ static const struct hid_device_id hid_ignore_list[] = {
         { 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_DREAM_CHEEKY, 0x0004) },
         { 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_ETT, USB_DEVICE_ID_TC4UM) },
-        { 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) },
@@ -1969,12 +1992,12 @@ static int __init hid_init(void)
         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");
+                pr_warn("hid_debug is now used solely for parser and driver debugging.\n"
+                        "debugfs is now used for inspecting the device (report descriptor, reports)\n");
 
         ret = bus_register(&hid_bus_type);
         if (ret) {
-                printk(KERN_ERR "HID: can't register hid bus\n");
+                pr_err("can't register hid bus\n");
                 goto err;
         }
 
diff --git a/usr/src/dkms_source_tree/hid-debug.c b/usr/src/dkms_source_tree/hid-debug.c
index 75c5e23..555382f 100644
--- a/usr/src/dkms_source_tree/hid-debug.c
+++ b/usr/src/dkms_source_tree/hid-debug.c
@@ -26,6 +26,8 @@
  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/sched.h>
@@ -393,7 +395,7 @@ char *hid_resolv_usage(unsigned usage, struct seq_file *f) {
 
         buf = resolv_usage_page(usage >> 16, f);
         if (IS_ERR(buf)) {
-                printk(KERN_ERR "error allocating HID debug buffer\n");
+                pr_err("error allocating HID debug buffer\n");
                 return NULL;
         }
 
diff --git a/usr/src/dkms_source_tree/hid-ids.h b/usr/src/dkms_source_tree/hid-ids.h
index e07a944..92a0d61 100644
--- a/usr/src/dkms_source_tree/hid-ids.h
+++ b/usr/src/dkms_source_tree/hid-ids.h
@@ -140,7 +140,9 @@
 #define USB_DEVICE_ID_BTC_EMPREX_REMOTE_2       0x5577
 
 #define USB_VENDOR_ID_CANDO             0x2087
+#define USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH 0x0703
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH 0x0a01
+#define USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1 0x0a02
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6 0x0b03
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6 0x0f01
 
@@ -162,6 +164,7 @@
 #define USB_VENDOR_ID_CHICONY           0x04f2
 #define USB_DEVICE_ID_CHICONY_TACTICAL_PAD      0x0418
 #define USB_DEVICE_ID_CHICONY_MULTI_TOUCH       0xb19d
+#define USB_DEVICE_ID_CHICONY_WIRELESS  0x0618
 
 #define USB_VENDOR_ID_CIDC              0x1677
 
@@ -185,6 +188,7 @@
 #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_DEVICE_ID_CYPRESS_TRUETOUCH 0xc001
 
 #define USB_VENDOR_ID_DEALEXTREAME      0x10c5
 #define USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701 0x819a
@@ -203,13 +207,20 @@
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH    0x480d
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1   0x720c
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH2   0x72a1
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH3   0x480e
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH4   0x726b
 
 #define USB_VENDOR_ID_ELECOM            0x056e
 #define USB_DEVICE_ID_ELECOM_BM084      0x0061
 
+#define USB_VENDOR_ID_DREAM_CHEEKY      0x1d34
+
 #define USB_VENDOR_ID_ELO               0x04E7
 #define USB_DEVICE_ID_ELO_TS2700        0x0020
 
+#define USB_VENDOR_ID_EMS               0x2006
+#define USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II 0x0118
+
 #define USB_VENDOR_ID_ESSENTIAL_REALITY 0x0d7f
 #define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100
 
@@ -228,6 +239,7 @@
 #define USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR  0x0002
 
 #define USB_VENDOR_ID_GENERAL_TOUCH     0x0dfc
+#define USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS 0x0001
 
 #define USB_VENDOR_ID_GLAB              0x06c2
 #define USB_DEVICE_ID_4_PHIDGETSERVO_30 0x0038
@@ -310,6 +322,9 @@
 #define USB_DEVICE_ID_HANWANG_TABLET_FIRST      0x5000
 #define USB_DEVICE_ID_HANWANG_TABLET_LAST       0x8fff
 
+#define USB_VENDOR_ID_HANVON            0x20b3
+#define USB_DEVICE_ID_HANVON_MULTITOUCH 0x0a18
+
 #define USB_VENDOR_ID_HAPP              0x078b
 #define USB_DEVICE_ID_UGCI_DRIVING      0x0010
 #define USB_DEVICE_ID_UGCI_FLYING       0x0020
@@ -482,6 +497,7 @@
 
 #define USB_VENDOR_ID_ROCCAT            0x1e7d
 #define USB_DEVICE_ID_ROCCAT_KONE       0x2ced
+#define USB_DEVICE_ID_ROCCAT_KONEPLUS   0x2d51
 #define USB_DEVICE_ID_ROCCAT_PYRA_WIRED 0x2c24
 #define USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS      0x2cf6
 
@@ -552,7 +568,6 @@
 
 #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_WALTOP                            0x172f
 #define USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH       0x0032
@@ -580,9 +595,4 @@
 #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.c b/usr/src/dkms_source_tree/hid-input.c
index d8d372b..05709e3 100644
--- a/usr/src/dkms_source_tree/hid-input.c
+++ b/usr/src/dkms_source_tree/hid-input.c
@@ -319,21 +319,21 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
 
                 switch (field->application) {
                 case HID_GD_MOUSE:
-                case HID_GD_POINTER:  code += 0x110; break;
+                case HID_GD_POINTER:  code += BTN_MOUSE; break;
                 case HID_GD_JOYSTICK:
                                 if (code <= 0xf)
                                         code += BTN_JOYSTICK;
                                 else
                                         code += BTN_TRIGGER_HAPPY;
                                 break;
-                case HID_GD_GAMEPAD:  code += 0x130; break;
+                case HID_GD_GAMEPAD:  code += BTN_GAMEPAD; 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;
+                        case HID_GD_POINTER:  code += BTN_MOUSE; break;
+                        case HID_GD_JOYSTICK: code += BTN_JOYSTICK; break;
+                        case HID_GD_GAMEPAD:  code += BTN_GAMEPAD; break;
+                        default:              code += BTN_MISC;
                         }
                 }
 
@@ -817,14 +817,21 @@ static int hidinput_open(struct input_dev *dev)
 {
         struct hid_device *hid = input_get_drvdata(dev);
 
-        return hid->ll_driver->open(hid);
+        return hid_hw_open(hid);
 }
 
 static void hidinput_close(struct input_dev *dev)
 {
         struct hid_device *hid = input_get_drvdata(dev);
 
-        hid->ll_driver->close(hid);
+        hid_hw_close(hid);
+}
+
+static void report_features(struct hid_device *hid)
+{
+        /* no feature report support in this test, since it is in flux */
+
+        return;
 }
 
 /*
@@ -839,7 +846,6 @@ int hidinput_connect(struct hid_device *hid, unsigned int force)
         struct hid_input *hidinput = NULL;
         struct input_dev *input_dev;
         int i, j, k;
-        int max_report_type = HID_OUTPUT_REPORT;
 
         INIT_LIST_HEAD(&hid->inputs);
 
@@ -856,10 +862,13 @@ int hidinput_connect(struct hid_device *hid, unsigned int force)
                         return -1;
         }
 
-        if (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
-                max_report_type = HID_INPUT_REPORT;
+        report_features(hid);
+
+        for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
+                if (k == HID_OUTPUT_REPORT &&
+                        hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
+                        continue;
 
-        for (k = HID_INPUT_REPORT; k <= max_report_type; k++)
                 list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
 
                         if (!report->maxfield)
@@ -871,7 +880,7 @@ int hidinput_connect(struct hid_device *hid, unsigned int force)
                                 if (!hidinput || !input_dev) {
                                         kfree(hidinput);
                                         input_free_device(input_dev);
-                                        err_hid("Out of memory during hid input probe");
+                                        hid_err(hid, "Out of memory during hid input probe\n");
                                         goto out_unwind;
                                 }
 
@@ -912,6 +921,7 @@ int hidinput_connect(struct hid_device *hid, unsigned int force)
                                 hidinput = NULL;
                         }
                 }
+        }
 
         if (hidinput && input_register_device(hidinput->input))
                 goto out_cleanup;
diff --git a/usr/src/dkms_source_tree/hidraw.c b/usr/src/dkms_source_tree/hidraw.c
index e1f0748..468e87b 100644
--- a/usr/src/dkms_source_tree/hidraw.c
+++ b/usr/src/dkms_source_tree/hidraw.c
@@ -19,6 +19,8 @@
  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/errno.h>
@@ -122,15 +124,15 @@ static ssize_t hidraw_write(struct file *file, const char __user *buffer, size_t
         }
 
         if (count > HID_MAX_BUFFER_SIZE) {
-                printk(KERN_WARNING "hidraw: pid %d passed too large report\n",
-                                task_pid_nr(current));
+                hid_warn(dev, "pid %d passed too large report\n",
+                         task_pid_nr(current));
                 ret = -EINVAL;
                 goto out;
         }
 
         if (count < 2) {
-                printk(KERN_WARNING "hidraw: pid %d passed too short report\n",
-                                task_pid_nr(current));
+                hid_warn(dev, "pid %d passed too short report\n",
+                         task_pid_nr(current));
                 ret = -EINVAL;
                 goto out;
         }
@@ -192,15 +194,13 @@ static int hidraw_open(struct inode *inode, struct file *file)
 
         dev = hidraw_table[minor];
         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);
+                err = hid_hw_power(dev->hid, PM_HINT_FULLON);
+                if (err < 0)
+                        goto out_unlock;
+
+                err = hid_hw_open(dev->hid);
                 if (err < 0) {
-                        if (dev->hid->ll_driver->power)
-                                dev->hid->ll_driver->power(dev->hid, PM_HINT_NORMAL);
+                        hid_hw_power(dev->hid, PM_HINT_NORMAL);
                         dev->open--;
                 }
         }
@@ -229,9 +229,8 @@ static int hidraw_release(struct inode * inode, struct file * file)
         dev = hidraw_table[minor];
         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);
+                        hid_hw_power(dev->hid, PM_HINT_NORMAL);
+                        hid_hw_close(dev->hid);
                 } else {
                         kfree(list->hidraw);
                 }
@@ -345,6 +344,9 @@ static const struct file_operations hidraw_ops = {
         .open =         hidraw_open,
         .release =      hidraw_release,
         .unlocked_ioctl = hidraw_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl   = hidraw_ioctl,
+#endif
         .llseek =       noop_llseek,
 };
 
@@ -433,7 +435,7 @@ void hidraw_disconnect(struct hid_device *hid)
         device_destroy(hidraw_class, MKDEV(hidraw_major, hidraw->minor));
 
         if (hidraw->open) {
-                hid->ll_driver->close(hid);
+                hid_hw_close(hid);
                 wake_up_interruptible(&hidraw->wait);
         } else {
                 kfree(hidraw);
@@ -452,7 +454,7 @@ int __init hidraw_init(void)
         hidraw_major = MAJOR(dev_id);
 
         if (result < 0) {
-                printk(KERN_WARNING "hidraw: can't get major number\n");
+                pr_warn("can't get major number\n");
                 result = 0;
                 goto out;
         }