5 files changed, 133 insertions, 49 deletions

diff --git a/drivers/hid/usbhid/Kconfig b/drivers/hid/usbhid/Kconfig
index 5d9aa95fc3ef..4edb3bef94a6 100644
--- a/drivers/hid/usbhid/Kconfig
+++ b/drivers/hid/usbhid/Kconfig
@@ -45,7 +45,7 @@ config USB_HIDDEV
           If unsure, say Y.
 
 menu "USB HID Boot Protocol drivers"
-        depends on USB!=n && USB_HID!=y
+        depends on USB!=n && USB_HID!=y && EMBEDDED
 
 config USB_KBD
         tristate "USB HIDBP Keyboard (simple Boot) support"
diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 606369ea24ca..03cb494af1c5 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/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-2008 Jiri Kosina
  */
 
 /*
@@ -641,9 +641,7 @@ static void hid_find_max_report(struct hid_device *hid, unsigned int type,
         unsigned int size;
 
         list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
-                size = ((report->size - 1) >> 3) + 1;
-                if (type == HID_INPUT_REPORT && hid->report_enum[type].numbered)
-                        size++;
+                size = ((report->size - 1) >> 3) + 1 + hid->report_enum[type].numbered;
                 if (*max < size)
                         *max = size;
         }
@@ -653,13 +651,16 @@ static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid)
 {
         struct usbhid_device *usbhid = hid->driver_data;
 
-        if (!(usbhid->inbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->inbuf_dma)))
-                return -1;
-        if (!(usbhid->outbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->outbuf_dma)))
-                return -1;
-        if (!(usbhid->cr = usb_buffer_alloc(dev, sizeof(*(usbhid->cr)), GFP_ATOMIC, &usbhid->cr_dma)))
-                return -1;
-        if (!(usbhid->ctrlbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->ctrlbuf_dma)))
+        usbhid->inbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL,
+                        &usbhid->inbuf_dma);
+        usbhid->outbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL,
+                        &usbhid->outbuf_dma);
+        usbhid->cr = usb_buffer_alloc(dev, sizeof(*usbhid->cr), GFP_KERNEL,
+                        &usbhid->cr_dma);
+        usbhid->ctrlbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL,
+                        &usbhid->ctrlbuf_dma);
+        if (!usbhid->inbuf || !usbhid->outbuf || !usbhid->cr ||
+                        !usbhid->ctrlbuf)
                 return -1;
 
         return 0;
@@ -807,7 +808,7 @@ static int usbhid_start(struct hid_device *hid)
                 int interval;
 
                 endpoint = &interface->endpoint[n].desc;
-                if ((endpoint->bmAttributes & 3) != 3)          /* Not an interrupt endpoint */
+                if (!usb_endpoint_xfer_int(endpoint))
                         continue;
 
                 interval = endpoint->bInterval;
@@ -876,6 +877,15 @@ static int usbhid_start(struct hid_device *hid)
 
         set_bit(HID_STARTED, &usbhid->iofl);
 
+        /* Some keyboards don't work until their LEDs have been set.
+         * Since BIOSes do set the LEDs, it must be safe for any device
+         * that supports the keyboard boot protocol.
+         */
+        if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT &&
+                        interface->desc.bInterfaceProtocol ==
+                                USB_INTERFACE_PROTOCOL_KEYBOARD)
+                usbhid_set_leds(hid);
+
         return 0;
 
 fail:
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 47ebe045f9b5..4391717d2519 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -54,6 +54,7 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_KEYBOARD, HID_QUIRK_NOGET },
+        { USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
         { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_QUAD_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT },
 
diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c
index 83e851a5ed30..6a98f9f572b0 100644
--- a/drivers/hid/usbhid/hiddev.c
+++ b/drivers/hid/usbhid/hiddev.c
@@ -49,6 +49,7 @@
 struct hiddev {
         int exist;
         int open;
+        struct mutex existancelock;
         wait_queue_head_t wait;
         struct hid_device *hid;
         struct list_head list;
@@ -63,6 +64,7 @@ struct hiddev_list {
         struct fasync_struct *fasync;
         struct hiddev *hiddev;
         struct list_head node;
+        struct mutex thread_lock;
 };
 
 static struct hiddev *hiddev_table[HIDDEV_MINORS];
@@ -264,29 +266,48 @@ static int hiddev_release(struct inode * inode, struct file * file)
 static int hiddev_open(struct inode *inode, struct file *file)
 {
         struct hiddev_list *list;
-        unsigned long flags;
+        int res;
 
         int i = iminor(inode) - HIDDEV_MINOR_BASE;
 
-        if (i >= HIDDEV_MINORS || !hiddev_table[i])
+        if (i >= HIDDEV_MINORS || i < 0 || !hiddev_table[i])
                 return -ENODEV;
 
         if (!(list = kzalloc(sizeof(struct hiddev_list), GFP_KERNEL)))
                 return -ENOMEM;
+        mutex_init(&list->thread_lock);
 
         list->hiddev = hiddev_table[i];
 
-        spin_lock_irqsave(&list->hiddev->list_lock, flags);
-        list_add_tail(&list->node, &hiddev_table[i]->list);
-        spin_unlock_irqrestore(&list->hiddev->list_lock, flags);
 
         file->private_data = list;
 
-        if (!list->hiddev->open++)
-                if (list->hiddev->exist)
-                        usbhid_open(hiddev_table[i]->hid);
+        /*
+         * no need for locking because the USB major number
+         * is shared which usbcore guards against disconnect
+         */
+        if (list->hiddev->exist) {
+                if (!list->hiddev->open++) {
+                        res = usbhid_open(hiddev_table[i]->hid);
+                        if (res < 0) {
+                                res = -EIO;
+                                goto bail;
+                        }
+                }
+        } else {
+                res = -ENODEV;
+                goto bail;
+        }
+
+        spin_lock_irq(&list->hiddev->list_lock);
+        list_add_tail(&list->node, &hiddev_table[i]->list);
+        spin_unlock_irq(&list->hiddev->list_lock);
 
         return 0;
+bail:
+        file->private_data = NULL;
+        kfree(list->hiddev);
+        return res;
 }
 
 /*
@@ -305,7 +326,7 @@ static ssize_t hiddev_read(struct file * file, char __user * buffer, size_t coun
         DECLARE_WAITQUEUE(wait, current);
         struct hiddev_list *list = file->private_data;
         int event_size;
-        int retval = 0;
+        int retval;
 
         event_size = ((list->flags & HIDDEV_FLAG_UREF) != 0) ?
                 sizeof(struct hiddev_usage_ref) : sizeof(struct hiddev_event);
@@ -313,10 +334,14 @@ static ssize_t hiddev_read(struct file * file, char __user * buffer, size_t coun
         if (count < event_size)
                 return 0;
 
+        /* lock against other threads */
+        retval = mutex_lock_interruptible(&list->thread_lock);
+        if (retval)
+                return -ERESTARTSYS;
+
         while (retval == 0) {
                 if (list->head == list->tail) {
-                        add_wait_queue(&list->hiddev->wait, &wait);
-                        set_current_state(TASK_INTERRUPTIBLE);
+                        prepare_to_wait(&list->hiddev->wait, &wait, TASK_INTERRUPTIBLE);
 
                         while (list->head == list->tail) {
                                 if (file->f_flags & O_NONBLOCK) {
@@ -332,35 +357,45 @@ static ssize_t hiddev_read(struct file * file, char __user * buffer, size_t coun
                                         break;
                                 }
 
+                                /* let O_NONBLOCK tasks run */
+                                mutex_unlock(&list->thread_lock);
                                 schedule();
+                                if (mutex_lock_interruptible(&list->thread_lock))
+                                        return -EINTR;
                                 set_current_state(TASK_INTERRUPTIBLE);
                         }
+                        finish_wait(&list->hiddev->wait, &wait);
 
-                        set_current_state(TASK_RUNNING);
-                        remove_wait_queue(&list->hiddev->wait, &wait);
                 }
 
-                if (retval)
+                if (retval) {
+                        mutex_unlock(&list->thread_lock);
                         return retval;
+                }
 
 
                 while (list->head != list->tail &&
                        retval + event_size <= count) {
                         if ((list->flags & HIDDEV_FLAG_UREF) == 0) {
-                                if (list->buffer[list->tail].field_index !=
-                                    HID_FIELD_INDEX_NONE) {
+                                if (list->buffer[list->tail].field_index != HID_FIELD_INDEX_NONE) {
                                         struct hiddev_event event;
+
                                         event.hid = list->buffer[list->tail].usage_code;
                                         event.value = list->buffer[list->tail].value;
-                                        if (copy_to_user(buffer + retval, &event, sizeof(struct hiddev_event)))
+                                        if (copy_to_user(buffer + retval, &event, sizeof(struct hiddev_event))) {
+                                                mutex_unlock(&list->thread_lock);
                                                 return -EFAULT;
+                                        }
                                         retval += sizeof(struct hiddev_event);
                                 }
                         } else {
                                 if (list->buffer[list->tail].field_index != HID_FIELD_INDEX_NONE ||
                                     (list->flags & HIDDEV_FLAG_REPORT) != 0) {
-                                        if (copy_to_user(buffer + retval, list->buffer + list->tail, sizeof(struct hiddev_usage_ref)))
+
+                                        if (copy_to_user(buffer + retval, list->buffer + list->tail, sizeof(struct hiddev_usage_ref))) {
+                                                mutex_unlock(&list->thread_lock);
                                                 return -EFAULT;
+                                        }
                                         retval += sizeof(struct hiddev_usage_ref);
                                 }
                         }
@@ -368,6 +403,7 @@ static ssize_t hiddev_read(struct file * file, char __user * buffer, size_t coun
                 }
 
         }
+        mutex_unlock(&list->thread_lock);
 
         return retval;
 }
@@ -555,7 +591,7 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         struct hid_field *field;
         struct usbhid_device *usbhid = hid->driver_data;
         void __user *user_arg = (void __user *)arg;
-        int i;
+        int i, r;
         
         /* Called without BKL by compat methods so no BKL taken */
 
@@ -619,10 +655,22 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 }
 
         case HIDIOCGSTRING:
-                return hiddev_ioctl_string(hiddev, cmd, user_arg);
+                mutex_lock(&hiddev->existancelock);
+                if (!hiddev->exist)
+                        r = hiddev_ioctl_string(hiddev, cmd, user_arg);
+                else
+                        r = -ENODEV;
+                mutex_unlock(&hiddev->existancelock);
+                return r;
 
         case HIDIOCINITREPORT:
+                mutex_lock(&hiddev->existancelock);
+                if (!hiddev->exist) {
+                        mutex_unlock(&hiddev->existancelock);
+                        return -ENODEV;
+                }
                 usbhid_init_reports(hid);
+                mutex_unlock(&hiddev->existancelock);
 
                 return 0;
 
@@ -636,8 +684,12 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
                         return -EINVAL;
 
-                usbhid_submit_report(hid, report, USB_DIR_IN);
-                usbhid_wait_io(hid);
+                mutex_lock(&hiddev->existancelock);
+                if (hiddev->exist) {
+                        usbhid_submit_report(hid, report, USB_DIR_IN);
+                        usbhid_wait_io(hid);
+                }
+                mutex_unlock(&hiddev->existancelock);
 
                 return 0;
 
@@ -651,8 +703,12 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
                         return -EINVAL;
 
-                usbhid_submit_report(hid, report, USB_DIR_OUT);
-                usbhid_wait_io(hid);
+                mutex_lock(&hiddev->existancelock);
+                if (hiddev->exist) {
+                        usbhid_submit_report(hid, report, USB_DIR_OUT);
+                        usbhid_wait_io(hid);
+                }
+                mutex_unlock(&hiddev->existancelock);
 
                 return 0;
 
@@ -710,7 +766,13 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         case HIDIOCGUSAGES:
         case HIDIOCSUSAGES:
         case HIDIOCGCOLLECTIONINDEX:
-                return hiddev_ioctl_usage(hiddev, cmd, user_arg);
+                mutex_lock(&hiddev->existancelock);
+                if (hiddev->exist)
+                        r = hiddev_ioctl_usage(hiddev, cmd, user_arg);
+                else
+                        r = -ENODEV;
+                mutex_unlock(&hiddev->existancelock);
+                return r;
 
         case HIDIOCGCOLLECTIONINFO:
                 if (copy_from_user(&cinfo, user_arg, sizeof(cinfo)))
@@ -808,23 +870,22 @@ int hiddev_connect(struct hid_device *hid, unsigned int force)
         if (!(hiddev = kzalloc(sizeof(struct hiddev), GFP_KERNEL)))
                 return -1;
 
-        retval = usb_register_dev(usbhid->intf, &hiddev_class);
-        if (retval) {
-                err_hid("Not able to get a minor for this device.");
-                kfree(hiddev);
-                return -1;
-        }
-
         init_waitqueue_head(&hiddev->wait);
         INIT_LIST_HEAD(&hiddev->list);
         spin_lock_init(&hiddev->list_lock);
+        mutex_init(&hiddev->existancelock);
         hiddev->hid = hid;
         hiddev->exist = 1;
 
-        hid->minor = usbhid->intf->minor;
-        hid->hiddev = hiddev;
-
-        hiddev_table[usbhid->intf->minor - HIDDEV_MINOR_BASE] = hiddev;
+        retval = usb_register_dev(usbhid->intf, &hiddev_class);
+        if (retval) {
+                err_hid("Not able to get a minor for this device.");
+                kfree(hiddev);
+                return -1;
+        } else {
+                hid->minor = usbhid->intf->minor;
+                hiddev_table[usbhid->intf->minor - HIDDEV_MINOR_BASE] = hiddev;
+        }
 
         return 0;
 }
@@ -839,7 +900,9 @@ void hiddev_disconnect(struct hid_device *hid)
         struct hiddev *hiddev = hid->hiddev;
         struct usbhid_device *usbhid = hid->driver_data;
 
+        mutex_lock(&hiddev->existancelock);
         hiddev->exist = 0;
+        mutex_unlock(&hiddev->existancelock);
 
         hiddev_table[hiddev->hid->minor - HIDDEV_MINOR_BASE] = NULL;
         usb_deregister_dev(usbhid->intf, &hiddev_class);
diff --git a/drivers/hid/usbhid/usbhid.h b/drivers/hid/usbhid/usbhid.h
index 332abcdf9956..9eb30564be9c 100644
--- a/drivers/hid/usbhid/usbhid.h
+++ b/drivers/hid/usbhid/usbhid.h
@@ -40,6 +40,16 @@ int usbhid_open(struct hid_device *hid);
 void usbhid_init_reports(struct hid_device *hid);
 void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir);
 
+/* iofl flags */
+#define HID_CTRL_RUNNING        1
+#define HID_OUT_RUNNING         2
+#define HID_IN_RUNNING          3
+#define HID_RESET_PENDING       4
+#define HID_SUSPENDED           5
+#define HID_CLEAR_HALT          6
+#define HID_DISCONNECTED        7
+#define HID_STARTED             8
+
 /*
  * USB-specific HID struct, to be pointed to
  * from struct hid_device->driver_data