Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid

Pull HID updates from Jiri Kosina:
 "Highlights:

   - conversion of HID subsystem to use devm-based resource management,
     from Benjamin Tissoires

   - i2c-hid support for DT bindings, from Benjamin Tissoires

   - much improved support for Win8-multitouch devices, from Benjamin
     Tissoires

   - cleanup of core code using common hidinput_input_event(), from
     David Herrmann

   - fix for bug in implement() access to the bit stream (causing oops)
     that has been present in the code for ages, but devices that are
     able to trigger it have started to appear only now, from Jiri
     Kosina

   - fixes for CVE-2013-2899, CVE-2013-2898, CVE-2013-2896,
     CVE-2013-2892, CVE-2013-2888 (all triggerable only by specially
     crafted malicious HW devices plugged into the system), from Kees
     Cook

   - hidraw oops fix, from Manoj Chourasia

   - various smaller fixes here and there, support for a bunch of new
     devices by various contributors"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid: (53 commits)
  HID: MAINTAINERS: add roccat drivers
  HID: hid-sensor-hub: change kmalloc + memcpy by kmemdup
  HID: hid-sensor-hub: move to devm_kzalloc
  HID: hid-sensor-hub: fix indentation accross the code
  HID: move HID_REPORT_TYPES closer to the report-definitions
  HID: check for NULL field when setting values
  HID: picolcd_core: validate output report details
  HID: sensor-hub: validate feature report details
  HID: ntrig: validate feature report details
  HID: pantherlord: validate output report details
  HID: hid-wiimote: print small buffers via %*phC
  HID: uhid: improve uhid example client
  HID: Correct the USB IDs for the new Macbook Air 6
  HID: wiimote: add support for Guitar-Hero guitars
  HID: wiimote: add support for Guitar-Hero drums
  Input: introduce BTN/ABS bits for drums and guitars
  HID: battery: don't do DMA from stack
  HID: roccat: add support for KonePureOptical v2
  HID: picolcd: Prevent NULL pointer dereference on _remove()
  HID: usbhid: quirk for N-Trig DuoSense Touch Screen
  ...

1 files changed, 115 insertions, 44 deletions

diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index b8f1c77f2f77..ae88a97f976e 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -63,6 +63,8 @@ struct hid_report *hid_register_report(struct hid_device *device, unsigned type,
         struct hid_report_enum *report_enum = device->report_enum + type;
         struct hid_report *report;
 
+        if (id >= HID_MAX_IDS)
+                return NULL;
         if (report_enum->report_id_hash[id])
                 return report_enum->report_id_hash[id];
 
@@ -404,8 +406,10 @@ static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
 
         case HID_GLOBAL_ITEM_TAG_REPORT_ID:
                 parser->global.report_id = item_udata(item);
-                if (parser->global.report_id == 0) {
-                        hid_err(parser->device, "report_id 0 is invalid\n");
+                if (parser->global.report_id == 0 ||
+                    parser->global.report_id >= HID_MAX_IDS) {
+                        hid_err(parser->device, "report_id %u is invalid\n",
+                                parser->global.report_id);
                         return -1;
                 }
                 return 0;
@@ -450,7 +454,7 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
                         }
                         parser->local.delimiter_depth--;
                 }
-                return 1;
+                return 0;
 
         case HID_LOCAL_ITEM_TAG_USAGE:
 
@@ -575,7 +579,7 @@ static void hid_close_report(struct hid_device *device)
         for (i = 0; i < HID_REPORT_TYPES; i++) {
                 struct hid_report_enum *report_enum = device->report_enum + i;
 
-                for (j = 0; j < 256; j++) {
+                for (j = 0; j < HID_MAX_IDS; j++) {
                         struct hid_report *report = report_enum->report_id_hash[j];
                         if (report)
                                 hid_free_report(report);
@@ -677,12 +681,61 @@ static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
         return NULL;
 }
 
-static void hid_scan_usage(struct hid_device *hid, u32 usage)
+static void hid_scan_input_usage(struct hid_parser *parser, u32 usage)
 {
+        struct hid_device *hid = parser->device;
+
         if (usage == HID_DG_CONTACTID)
                 hid->group = HID_GROUP_MULTITOUCH;
 }
 
+static void hid_scan_feature_usage(struct hid_parser *parser, u32 usage)
+{
+        if (usage == 0xff0000c5 && parser->global.report_count == 256 &&
+            parser->global.report_size == 8)
+                parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8;
+}
+
+static void hid_scan_collection(struct hid_parser *parser, unsigned type)
+{
+        struct hid_device *hid = parser->device;
+
+        if (((parser->global.usage_page << 16) == HID_UP_SENSOR) &&
+            type == HID_COLLECTION_PHYSICAL)
+                hid->group = HID_GROUP_SENSOR_HUB;
+}
+
+static int hid_scan_main(struct hid_parser *parser, struct hid_item *item)
+{
+        __u32 data;
+        int i;
+
+        data = item_udata(item);
+
+        switch (item->tag) {
+        case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
+                hid_scan_collection(parser, data & 0xff);
+                break;
+        case HID_MAIN_ITEM_TAG_END_COLLECTION:
+                break;
+        case HID_MAIN_ITEM_TAG_INPUT:
+                for (i = 0; i < parser->local.usage_index; i++)
+                        hid_scan_input_usage(parser, parser->local.usage[i]);
+                break;
+        case HID_MAIN_ITEM_TAG_OUTPUT:
+                break;
+        case HID_MAIN_ITEM_TAG_FEATURE:
+                for (i = 0; i < parser->local.usage_index; i++)
+                        hid_scan_feature_usage(parser, parser->local.usage[i]);
+                break;
+        }
+
+        /* Reset the local parser environment */
+        memset(&parser->local, 0, sizeof(parser->local));
+
+        return 0;
+}
+
 /*
  * Scan a report descriptor before the device is added to the bus.
  * Sets device groups and other properties that determine what driver
@@ -690,48 +743,41 @@ static void hid_scan_usage(struct hid_device *hid, u32 usage)
  */
 static int hid_scan_report(struct hid_device *hid)
 {
-        unsigned int page = 0, delim = 0;
+        struct hid_parser *parser;
+        struct hid_item item;
         __u8 *start = hid->dev_rdesc;
         __u8 *end = start + hid->dev_rsize;
-        unsigned int u, u_min = 0, u_max = 0;
-        struct hid_item item;
+        static int (*dispatch_type[])(struct hid_parser *parser,
+                                      struct hid_item *item) = {
+                hid_scan_main,
+                hid_parser_global,
+                hid_parser_local,
+                hid_parser_reserved
+        };
+
+        parser = vzalloc(sizeof(struct hid_parser));
+        if (!parser)
+                return -ENOMEM;
 
+        parser->device = hid;
         hid->group = HID_GROUP_GENERIC;
-        while ((start = fetch_item(start, end, &item)) != NULL) {
-                if (item.format != HID_ITEM_FORMAT_SHORT)
-                        return -EINVAL;
-                if (item.type == HID_ITEM_TYPE_GLOBAL) {
-                        if (item.tag == HID_GLOBAL_ITEM_TAG_USAGE_PAGE)
-                                page = item_udata(&item) << 16;
-                } else if (item.type == HID_ITEM_TYPE_LOCAL) {
-                        if (delim > 1)
-                                break;
-                        u = item_udata(&item);
-                        if (item.size <= 2)
-                                u += page;
-                        switch (item.tag) {
-                        case HID_LOCAL_ITEM_TAG_DELIMITER:
-                                delim += !!u;
-                                break;
-                        case HID_LOCAL_ITEM_TAG_USAGE:
-                                hid_scan_usage(hid, u);
-                                break;
-                        case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
-                                u_min = u;
-                                break;
-                        case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
-                                u_max = u;
-                                for (u = u_min; u <= u_max; u++)
-                                        hid_scan_usage(hid, u);
-                                break;
-                        }
-                } else if (page == HID_UP_SENSOR &&
-                        item.type == HID_ITEM_TYPE_MAIN &&
-                        item.tag == HID_MAIN_ITEM_TAG_BEGIN_COLLECTION &&
-                        (item_udata(&item) & 0xff) == HID_COLLECTION_PHYSICAL)
-                        hid->group = HID_GROUP_SENSOR_HUB;
-        }
 
+        /*
+         * The parsing is simpler than the one in hid_open_report() as we should
+         * be robust against hid errors. Those errors will be raised by
+         * hid_open_report() anyway.
+         */
+        while ((start = fetch_item(start, end, &item)) != NULL)
+                dispatch_type[item.type](parser, &item);
+
+        /*
+         * Handle special flags set during scanning.
+         */
+        if ((parser->scan_flags & HID_SCAN_FLAG_MT_WIN_8) &&
+            (hid->group == HID_GROUP_MULTITOUCH))
+                hid->group = HID_GROUP_MULTITOUCH_WIN_8;
+
+        vfree(parser);
         return 0;
 }
 
@@ -1128,7 +1174,8 @@ static void hid_output_field(const struct hid_device *hid,
 }
 
 /*
- * Create a report.
+ * Create a report. 'data' has to be allocated using
+ * hid_alloc_report_buf() so that it has proper size.
  */
 
 void hid_output_report(struct hid_report *report, __u8 *data)
@@ -1145,6 +1192,22 @@ void hid_output_report(struct hid_report *report, __u8 *data)
 EXPORT_SYMBOL_GPL(hid_output_report);
 
 /*
+ * Allocator for buffer that is going to be passed to hid_output_report()
+ */
+u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags)
+{
+        /*
+         * 7 extra bytes are necessary to achieve proper functionality
+         * of implement() working on 8 byte chunks
+         */
+
+        int len = ((report->size - 1) >> 3) + 1 + (report->id > 0) + 7;
+
+        return kmalloc(len, flags);
+}
+EXPORT_SYMBOL_GPL(hid_alloc_report_buf);
+
+/*
  * Set a field value. The report this field belongs to has to be
  * created and transferred to the device, to set this value in the
  * device.
@@ -1152,7 +1215,12 @@ EXPORT_SYMBOL_GPL(hid_output_report);
 
 int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
 {
-        unsigned size = field->report_size;
+        unsigned size;
+
+        if (!field)
+                return -1;
+
+        size = field->report_size;
 
         hid_dump_input(field->report->device, field->usage + offset, value);
 
@@ -1597,6 +1665,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GX_IMPERATOR) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_I405X) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },
@@ -1679,6 +1748,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE_OPTICAL) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KOVAPLUS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_LUA) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },
@@ -1736,6 +1806,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },
         { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET) },
         { HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_XIN_MO, USB_DEVICE_ID_XIN_MO_DUAL_ARCADE) },
         { 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) },