Merge branch 'upstream' into for-linus

Conflicts:
	drivers/hid/hid-core.c

3 files changed, 61 insertions, 14 deletions

diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 9cba5006b5ed..df3789f5d9a5 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -28,6 +28,7 @@
 #include <linux/input.h>
 #include <linux/wait.h>
 #include <linux/workqueue.h>
+#include <linux/string.h>
 
 #include <linux/usb.h>
 
@@ -86,8 +87,13 @@ static int hid_start_in(struct hid_device *hid)
                         !test_bit(HID_REPORTED_IDLE, &usbhid->iofl) &&
                         !test_and_set_bit(HID_IN_RUNNING, &usbhid->iofl)) {
                 rc = usb_submit_urb(usbhid->urbin, GFP_ATOMIC);
-                if (rc != 0)
+                if (rc != 0) {
                         clear_bit(HID_IN_RUNNING, &usbhid->iofl);
+                        if (rc == -ENOSPC)
+                                set_bit(HID_NO_BANDWIDTH, &usbhid->iofl);
+                } else {
+                        clear_bit(HID_NO_BANDWIDTH, &usbhid->iofl);
+                }
         }
         spin_unlock_irqrestore(&usbhid->lock, flags);
         return rc;
@@ -173,8 +179,10 @@ static void hid_io_error(struct hid_device *hid)
 
         if (time_after(jiffies, usbhid->stop_retry)) {
 
-                /* Retries failed, so do a port reset */
-                if (!test_and_set_bit(HID_RESET_PENDING, &usbhid->iofl)) {
+                /* Retries failed, so do a port reset unless we lack bandwidth*/
+                if (test_bit(HID_NO_BANDWIDTH, &usbhid->iofl)
+                     && !test_and_set_bit(HID_RESET_PENDING, &usbhid->iofl)) {
+
                         schedule_work(&usbhid->reset_work);
                         goto done;
                 }
@@ -700,7 +708,7 @@ static int hid_get_class_descriptor(struct usb_device *dev, int ifnum,
 int usbhid_open(struct hid_device *hid)
 {
         struct usbhid_device *usbhid = hid->driver_data;
-        int res;
+        int res = 0;
 
         mutex_lock(&hid_open_mut);
         if (!hid->open++) {
@@ -708,17 +716,27 @@ int usbhid_open(struct hid_device *hid)
                 /* the device must be awake to reliably request remote wakeup */
                 if (res < 0) {
                         hid->open--;
-                        mutex_unlock(&hid_open_mut);
-                        return -EIO;
+                        res = -EIO;
+                        goto done;
                 }
                 usbhid->intf->needs_remote_wakeup = 1;
-                if (hid_start_in(hid))
-                        hid_io_error(hid);
- 
+                res = hid_start_in(hid);
+                if (res) {
+                        if (res != -ENOSPC) {
+                                hid_io_error(hid);
+                                res = 0;
+                        } else {
+                                /* no use opening if resources are insufficient */
+                                hid->open--;
+                                res = -EBUSY;
+                                usbhid->intf->needs_remote_wakeup = 0;
+                        }
+                }
                 usb_autopm_put_interface(usbhid->intf);
         }
+done:
         mutex_unlock(&hid_open_mut);
-        return 0;
+        return res;
 }
 
 void usbhid_close(struct hid_device *hid)
@@ -1347,7 +1365,34 @@ static int hid_post_reset(struct usb_interface *intf)
         struct usb_device *dev = interface_to_usbdev (intf);
         struct hid_device *hid = usb_get_intfdata(intf);
         struct usbhid_device *usbhid = hid->driver_data;
+        struct usb_host_interface *interface = intf->cur_altsetting;
         int status;
+        char *rdesc;
+
+        /* Fetch and examine the HID report descriptor. If this
+         * has changed, then rebind. Since usbcore's check of the
+         * configuration descriptors passed, we already know that
+         * the size of the HID report descriptor has not changed.
+         */
+        rdesc = kmalloc(hid->rsize, GFP_KERNEL);
+        if (!rdesc) {
+                dbg_hid("couldn't allocate rdesc memory (post_reset)\n");
+                return 1;
+        }
+        status = hid_get_class_descriptor(dev,
+                                interface->desc.bInterfaceNumber,
+                                HID_DT_REPORT, rdesc, hid->rsize);
+        if (status < 0) {
+                dbg_hid("reading report descriptor failed (post_reset)\n");
+                kfree(rdesc);
+                return 1;
+        }
+        status = memcmp(rdesc, hid->rdesc, hid->rsize);
+        kfree(rdesc);
+        if (status != 0) {
+                dbg_hid("report descriptor changed\n");
+                return 1;
+        }
 
         spin_lock_irq(&usbhid->lock);
         clear_bit(HID_RESET_PENDING, &usbhid->iofl);
diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c
index b1ec0e2aeb57..14599e256791 100644
--- a/drivers/hid/usbhid/hiddev.c
+++ b/drivers/hid/usbhid/hiddev.c
@@ -34,6 +34,7 @@
 #include <linux/hid.h>
 #include <linux/hiddev.h>
 #include <linux/compat.h>
+#include <linux/vmalloc.h>
 #include "usbhid.h"
 
 #ifdef CONFIG_USB_DYNAMIC_MINORS
@@ -250,13 +251,13 @@ static int hiddev_release(struct inode * inode, struct file * file)
                 } else {
                         mutex_unlock(&list->hiddev->existancelock);
                         kfree(list->hiddev);
-                        kfree(list);
+                        vfree(list);
                         return 0;
                 }
         }
 
         mutex_unlock(&list->hiddev->existancelock);
-        kfree(list);
+        vfree(list);
 
         return 0;
 }
@@ -278,7 +279,7 @@ static int hiddev_open(struct inode *inode, struct file *file)
         hid = usb_get_intfdata(intf);
         hiddev = hid->hiddev;
 
-        if (!(list = kzalloc(sizeof(struct hiddev_list), GFP_KERNEL)))
+        if (!(list = vzalloc(sizeof(struct hiddev_list))))
                 return -ENOMEM;
         mutex_init(&list->thread_lock);
         list->hiddev = hiddev;
@@ -322,7 +323,7 @@ bail_unlock:
         mutex_unlock(&hiddev->existancelock);
 bail:
         file->private_data = NULL;
-        kfree(list);
+        vfree(list);
         return res;
 }
 
diff --git a/drivers/hid/usbhid/usbhid.h b/drivers/hid/usbhid/usbhid.h
index cb8f703efde5..1883d7b94870 100644
--- a/drivers/hid/usbhid/usbhid.h
+++ b/drivers/hid/usbhid/usbhid.h
@@ -55,6 +55,7 @@ struct usb_interface *usbhid_find_interface(int minor);
 #define HID_STARTED             8
 #define HID_REPORTED_IDLE       9
 #define HID_KEYS_PRESSED        10
+#define HID_NO_BANDWIDTH        11
 
 /*
  * USB-specific HID struct, to be pointed to