4 files changed, 435 insertions, 87 deletions

diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 426ac5add585..017fc20167d4 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -534,9 +534,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 +553,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
@@ -622,18 +622,24 @@ static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
         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 +648,54 @@ 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;
-
-        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;
-        }
+        device->rdesc = kmalloc(size, GFP_KERNEL);
+        if (device->rdesc == NULL)
+                return -ENOMEM;
         memcpy(device->rdesc, start, size);
         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);
 
@@ -815,9 +799,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)
+{
+        struct hid_driver *hdrv = hid->driver;
+        int ret;
+
         hid_dump_input(usage, value);
+
+        if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
+                ret = hdrv->event(hid, field, usage, value);
+                if (ret != 0) {
+                        if (ret < 0)
+                                dbg_hid("%s's event failed with %d\n",
+                                                hdrv->name, ret);
+                        return;
+                }
+        }
+
         if (hid->claimed & HID_CLAIMED_INPUT)
                 hidinput_hid_event(hid, field, usage, value);
         if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
@@ -946,44 +994,47 @@ 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_enum *report_enum = hid->report_enum + type;
         struct hid_report *report;
-        int n, rsize, i;
+        unsigned int n = 0;     /* Normally report number is 0 */
 
-        if (!hid)
-                return -ENODEV;
+        /* Device uses numbered reports, data[0] is report number */
+        if (report_enum->numbered)
+                n = *data;
 
-        if (!size) {
-                dbg_hid("empty report\n");
-                return -1;
-        }
+        report = report_enum->report_id_hash[n];
+        if (report == NULL)
+                dbg_hid("undefined report_id %u received\n", n);
 
-        dbg_hid("report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
+        return report;
+}
 
-        n = 0;                          /* Normally report number is 0 */
-        if (report_enum->numbered) {    /* Device uses numbered reports, data[0] is report number */
-                n = *data++;
-                size--;
-        }
+void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
+                int interrupt)
+{
+        struct hid_report_enum *report_enum = hid->report_enum + type;
+        struct hid_report *report;
+        unsigned int a;
+        int rsize, csize = size;
+        u8 *cdata = data;
 
-        /* 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");
+        report = hid_get_report(report_enum, data);
+        if (!report)
+                return;
 
-        if (!(report = report_enum->report_id_hash[n])) {
-                dbg_hid("undefined report_id %d received\n", n);
-                return -1;
+        if (report_enum->numbered) {
+                cdata++;
+                csize--;
         }
 
         rsize = ((report->size - 1) >> 3) + 1;
 
-        if (size < rsize) {
-                dbg_hid("report %d is too short, (%d < %d)\n", report->id, size, rsize);
-                memset(data + size, 0, rsize - size);
+        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)
@@ -996,24 +1047,295 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
                         hidraw_report_event(hid, data, size);
         }
 
-        for (n = 0; n < report->maxfield; n++)
-                hid_input_field(hid, report->field[n], data, interrupt);
+        for (a = 0; a < report->maxfield; a++)
+                hid_input_field(hid, report->field[a], cdata, interrupt);
 
         if (hid->claimed & HID_CLAIMED_INPUT)
                 hidinput_report_event(hid, report);
+}
+EXPORT_SYMBOL_GPL(hid_report_raw_event);
+
+/**
+ * hid_input_report - report data from lower layer (usb, bt...)
+ *
+ * @hid: hid device
+ * @type: HID report type (HID_*_REPORT)
+ * @data: report contents
+ * @size: size of data parameter
+ * @interrupt: called from atomic?
+ *
+ * This is data entry for lower layers.
+ */
+int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)
+{
+        struct hid_report_enum *report_enum = hid->report_enum + type;
+        struct hid_driver *hdrv = hid->driver;
+        struct hid_report *report;
+        unsigned int i;
+        int ret;
+
+        if (!hid || !hid->driver)
+                return -ENODEV;
+
+        if (!size) {
+                dbg_hid("empty report\n");
+                return -1;
+        }
+
+        dbg_hid("report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
+
+        report = hid_get_report(report_enum, data);
+        if (!report)
+                return -1;
+
+        /* dump the report */
+        dbg_hid("report %d (size %u) = ", report->id, size);
+        for (i = 0; i < size; i++)
+                dbg_hid_line(" %02x", data[i]);
+        dbg_hid_line("\n");
+
+        if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
+                ret = hdrv->raw_event(hid, report, data, size);
+                if (ret != 0)
+                        return ret < 0 ? ret : 0;
+        }
+
+        hid_report_raw_event(hid, type, data, size, interrupt);
 
         return 0;
 }
 EXPORT_SYMBOL_GPL(hid_input_report);
 
+static bool hid_match_one_id(struct hid_device *hdev,
+                const struct hid_device_id *id)
+{
+        return id->bus == hdev->bus &&
+                (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
+                (id->product == HID_ANY_ID || id->product == hdev->product);
+}
+
+static const struct hid_device_id *hid_match_id(struct hid_device *hdev,
+                const struct hid_device_id *id)
+{
+        for (; id->bus; id++)
+                if (hid_match_one_id(hdev, id))
+                        return id;
+
+        return NULL;
+}
+
+static const struct hid_device_id hid_blacklist[] = {
+        { }
+};
+
+static int hid_bus_match(struct device *dev, struct device_driver *drv)
+{
+        struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+
+        if (!hid_match_id(hdev, hdrv->id_table))
+                return 0;
+
+        /* generic wants all non-blacklisted */
+        if (!strncmp(hdrv->name, "generic-", 8))
+                return !hid_match_id(hdev, hid_blacklist);
+
+        return 1;
+}
+
+static int hid_device_probe(struct device *dev)
+{
+        struct hid_driver *hdrv = container_of(dev->driver,
+                        struct hid_driver, driver);
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+        const struct hid_device_id *id;
+        int ret = 0;
+
+        if (!hdev->driver) {
+                if (hdrv->probe) {
+                        ret = -ENODEV;
+
+                        id = hid_match_id(hdev, hdrv->id_table);
+                        if (id)
+                                ret = hdrv->probe(hdev, id);
+                }
+                if (!ret)
+                        hdev->driver = hdrv;
+        }
+        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);
+                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,
+};
+
+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;
+
+        /* XXX hack, any other cleaner solution < 20 bus_id bytes? */
+        sprintf(hdev->dev.bus_id, "%04X:%04X:%04X.%04X", hdev->bus,
+                        hdev->vendor, hdev->product, atomic_inc_return(&id));
+
+        ret = device_add(&hdev->dev);
+        if (!ret)
+                hdev->status |= HID_STAT_ADDED;
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(hid_add_device);
+
+/**
+ * hid_allocate_device - allocate new hid device descriptor
+ *
+ * Allocate and initialize hid device, so that hid_destroy_device might be
+ * used to free it.
+ *
+ * New hid_device pointer is returned on success, otherwise ERR_PTR encoded
+ * error value.
+ */
+struct hid_device *hid_allocate_device(void)
+{
+        struct hid_device *hdev;
+        unsigned int i;
+        int ret = -ENOMEM;
+
+        hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
+        if (hdev == NULL)
+                return ERR_PTR(ret);
+
+        device_initialize(&hdev->dev);
+        hdev->dev.release = hid_device_release;
+        hdev->dev.bus = &hid_bus_type;
+
+        hdev->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
+                        sizeof(struct hid_collection), GFP_KERNEL);
+        if (hdev->collection == NULL)
+                goto err;
+        hdev->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
+
+        for (i = 0; i < HID_REPORT_TYPES; i++)
+                INIT_LIST_HEAD(&hdev->report_enum[i].report_list);
+
+        return hdev;
+err:
+        put_device(&hdev->dev);
+        return ERR_PTR(ret);
+}
+EXPORT_SYMBOL_GPL(hid_allocate_device);
+
+static void hid_remove_device(struct hid_device *hdev)
+{
+        if (hdev->status & HID_STAT_ADDED) {
+                device_del(&hdev->dev);
+                hdev->status &= ~HID_STAT_ADDED;
+        }
+}
+
+/**
+ * hid_destroy_device - free previously allocated device
+ *
+ * @hdev: hid device
+ *
+ * If you allocate hid_device through hid_allocate_device, you should ever
+ * free by this function.
+ */
+void hid_destroy_device(struct hid_device *hdev)
+{
+        hid_remove_device(hdev);
+        put_device(&hdev->dev);
+}
+EXPORT_SYMBOL_GPL(hid_destroy_device);
+
+int __hid_register_driver(struct hid_driver *hdrv, struct module *owner,
+                const char *mod_name)
+{
+        hdrv->driver.name = hdrv->name;
+        hdrv->driver.bus = &hid_bus_type;
+        hdrv->driver.owner = owner;
+        hdrv->driver.mod_name = mod_name;
+
+        return driver_register(&hdrv->driver);
+}
+EXPORT_SYMBOL_GPL(__hid_register_driver);
+
+void hid_unregister_driver(struct hid_driver *hdrv)
+{
+        driver_unregister(&hdrv->driver);
+}
+EXPORT_SYMBOL_GPL(hid_unregister_driver);
+
 static int __init hid_init(void)
 {
-        return hidraw_init();
+        int ret;
+
+        ret = bus_register(&hid_bus_type);
+        if (ret) {
+                printk(KERN_ERR "HID: can't register hid bus\n");
+                goto err;
+        }
+
+        ret = hidraw_init();
+        if (ret)
+                goto err_bus;
+
+        return 0;
+err_bus:
+        bus_unregister(&hid_bus_type);
+err:
+        return ret;
 }
 
 static void __exit hid_exit(void)
 {
         hidraw_exit();
+        bus_unregister(&hid_bus_type);
 }
 
 module_init(hid_init);
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index 1b2e8dc3398d..4ae5603804e7 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -1032,7 +1032,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/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 27fe4d8912cb..5955d05ae542 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -770,8 +770,15 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                 dbg_hid_line(" %02x", (unsigned char) rdesc[n]);
         dbg_hid_line("\n");
 
-        if (!(hid = hid_parse_report(rdesc, n))) {
+        hid = hid_allocate_device();
+        if (IS_ERR(hid)) {
+                kfree(rdesc);
+                return NULL;
+        }
+
+        if (hid_parse_report(hid, rdesc, n)) {
                 dbg_hid("parsing report descriptor failed\n");
+                hid_destroy_device(hid);
                 kfree(rdesc);
                 return NULL;
         }
@@ -798,10 +805,8 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
         if (insize > HID_MAX_BUFFER_SIZE)
                 insize = HID_MAX_BUFFER_SIZE;
 
-        if (hid_alloc_buffers(dev, hid)) {
-                hid_free_buffers(dev, hid);
+        if (hid_alloc_buffers(dev, hid))
                 goto fail;
-        }
 
         hid->name[0] = 0;
 
@@ -881,7 +886,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
 
         hid->version = le16_to_cpu(hdesc->bcdHID);
         hid->country = hdesc->bCountryCode;
-        hid->dev = &intf->dev;
+        hid->dev.parent = &intf->dev;
         usbhid->intf = intf;
         usbhid->ifnum = interface->desc.bInterfaceNumber;
 
@@ -925,7 +930,7 @@ fail:
         hid_free_buffers(dev, hid);
         kfree(usbhid);
 fail_no_usbhid:
-        hid_free_device(hid);
+        hid_destroy_device(hid);
 
         return NULL;
 }
@@ -964,14 +969,14 @@ static void hid_disconnect(struct usb_interface *intf)
 
         hid_free_buffers(hid_to_usb_dev(hid), hid);
         kfree(usbhid);
-        hid_free_device(hid);
+        hid_destroy_device(hid);
 }
 
 static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
         struct hid_device *hid;
         char path[64];
-        int i;
+        int i, ret;
         char *c;
 
         dbg_hid("HID probe called for ifnum %d\n",
@@ -1037,7 +1042,12 @@ static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
         printk(": USB HID v%x.%02x %s [%s] on %s\n",
                 hid->version >> 8, hid->version & 0xff, c, hid->name, path);
 
-        return 0;
+        ret = hid_add_device(hid);
+        if (ret) {
+                dev_err(&intf->dev, "can't add hid device: %d\n", ret);
+                hid_disconnect(intf);
+        }
+        return ret;
 }
 
 static int hid_suspend(struct usb_interface *intf, pm_message_t message)
@@ -1107,9 +1117,22 @@ static struct usb_driver hid_driver = {
         .supports_autosuspend = 1,
 };
 
+static const struct hid_device_id hid_usb_table[] = {
+        { HID_USB_DEVICE(HID_ANY_ID, HID_ANY_ID) },
+        { }
+};
+
+static struct hid_driver hid_usb_driver = {
+        .name = "generic-usb",
+        .id_table = hid_usb_table,
+};
+
 static int __init hid_init(void)
 {
         int retval;
+        retval = hid_register_driver(&hid_usb_driver);
+        if (retval)
+                goto hid_register_fail;
         retval = usbhid_quirks_init(quirks_param);
         if (retval)
                 goto usbhid_quirks_init_fail;
@@ -1127,6 +1150,8 @@ usb_register_fail:
 hiddev_init_fail:
         usbhid_quirks_exit();
 usbhid_quirks_init_fail:
+        hid_unregister_driver(&hid_usb_driver);
+hid_register_fail:
         return retval;
 }
 
@@ -1135,6 +1160,7 @@ static void __exit hid_exit(void)
         usb_deregister(&hid_driver);
         hiddev_exit();
         usbhid_quirks_exit();
+        hid_unregister_driver(&hid_usb_driver);
 }
 
 module_init(hid_init);
diff --git a/drivers/hid/usbhid/usbhid.h b/drivers/hid/usbhid/usbhid.h
index 62d2d7c925bd..b47f991867e9 100644
--- a/drivers/hid/usbhid/usbhid.h
+++ b/drivers/hid/usbhid/usbhid.h
@@ -82,7 +82,7 @@ struct usbhid_device {
 };
 
 #define hid_to_usb_dev(hid_dev) \
-        container_of(hid_dev->dev->parent, struct usb_device, dev)
+        container_of(hid_dev->dev.parent->parent, struct usb_device, dev)
 
 #endif