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

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid: (68 commits)
  hid-input/battery: add FEATURE quirk
  hid-input/battery: remove battery_val
  hid-input/battery: power-supply type really *is* a battery
  hid-input/battery: make the battery setup common for INPUTs and FEATUREs
  hid-input/battery: deal with both FEATURE and INPUT report batteries
  hid-input/battery: add quirks for battery
  hid-input/battery: remove apparently redundant kmalloc
  hid-input: add support for HID devices reporting Battery Strength
  HID: hid-multitouch: add support 9 new Xiroku devices
  HID: multitouch: add support for 3M 32"
  HID: multitouch: add support of Atmel multitouch panels
  HID: usbhid: defer LED setting to a workqueue
  HID: usbhid: hid-core: submit queued urbs before suspend
  HID: usbhid: remove LED_ON
  HID: emsff: use symbolic name instead of hardcoded PID constant
  HID: Enable HID_QUIRK_MULTI_INPUT for Trio Linker Plus II
  HID: Kconfig: fix syntax
  HID: introduce proper dependency of HID_BATTERY on POWER_SUPPLY
  HID: multitouch: support PixArt optical touch screen
  HID: make parser more verbose about parsing errors by default
  ...

Fix up rename/delete conflict in drivers/hid/hid-hyperv.c (removed in
staging, moved in this branch) and similarly for the rules for same file
in drivers/staging/hv/{Kconfig,Makefile}.

4 files changed, 206 insertions, 106 deletions

diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index b403fcef0b86..5bf91dbad59d 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -197,16 +197,24 @@ static int usbhid_restart_out_queue(struct usbhid_device *usbhid)
 {
         struct hid_device *hid = usb_get_intfdata(usbhid->intf);
         int kicked;
+        int r;
 
         if (!hid)
                 return 0;
 
         if ((kicked = (usbhid->outhead != usbhid->outtail))) {
                 dbg("Kicking head %d tail %d", usbhid->outhead, usbhid->outtail);
+
+                r = usb_autopm_get_interface_async(usbhid->intf);
+                if (r < 0)
+                        return r;
+                /* Asynchronously flush queue. */
+                set_bit(HID_OUT_RUNNING, &usbhid->iofl);
                 if (hid_submit_out(hid)) {
                         clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
-                        wake_up(&usbhid->wait);
+                        usb_autopm_put_interface_async(usbhid->intf);
                 }
+                wake_up(&usbhid->wait);
         }
         return kicked;
 }
@@ -215,6 +223,7 @@ static int usbhid_restart_ctrl_queue(struct usbhid_device *usbhid)
 {
         struct hid_device *hid = usb_get_intfdata(usbhid->intf);
         int kicked;
+        int r;
 
         WARN_ON(hid == NULL);
         if (!hid)
@@ -222,10 +231,17 @@ static int usbhid_restart_ctrl_queue(struct usbhid_device *usbhid)
 
         if ((kicked = (usbhid->ctrlhead != usbhid->ctrltail))) {
                 dbg("Kicking head %d tail %d", usbhid->ctrlhead, usbhid->ctrltail);
+
+                r = usb_autopm_get_interface_async(usbhid->intf);
+                if (r < 0)
+                        return r;
+                /* Asynchronously flush queue. */
+                set_bit(HID_CTRL_RUNNING, &usbhid->iofl);
                 if (hid_submit_ctrl(hid)) {
                         clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
-                        wake_up(&usbhid->wait);
+                        usb_autopm_put_interface_async(usbhid->intf);
                 }
+                wake_up(&usbhid->wait);
         }
         return kicked;
 }
@@ -304,30 +320,21 @@ static int hid_submit_out(struct hid_device *hid)
         report = usbhid->out[usbhid->outtail].report;
         raw_report = usbhid->out[usbhid->outtail].raw_report;
 
-        r = usb_autopm_get_interface_async(usbhid->intf);
-        if (r < 0)
-                return -1;
-
-        /*
-         * if the device hasn't been woken, we leave the output
-         * to resume()
-         */
-        if (!test_bit(HID_REPORTED_IDLE, &usbhid->iofl)) {
-                usbhid->urbout->transfer_buffer_length = ((report->size - 1) >> 3) + 1 + (report->id > 0);
-                usbhid->urbout->dev = hid_to_usb_dev(hid);
-                memcpy(usbhid->outbuf, raw_report, usbhid->urbout->transfer_buffer_length);
-                kfree(raw_report);
+        usbhid->urbout->transfer_buffer_length = ((report->size - 1) >> 3) +
+                                                 1 + (report->id > 0);
+        usbhid->urbout->dev = hid_to_usb_dev(hid);
+        memcpy(usbhid->outbuf, raw_report,
+               usbhid->urbout->transfer_buffer_length);
+        kfree(raw_report);
 
-                dbg_hid("submitting out urb\n");
+        dbg_hid("submitting out urb\n");
 
-                if (usb_submit_urb(usbhid->urbout, GFP_ATOMIC)) {
-                        hid_err(hid, "usb_submit_urb(out) failed\n");
-                        usb_autopm_put_interface_async(usbhid->intf);
-                        return -1;
-                }
-                usbhid->last_out = jiffies;
+        r = usb_submit_urb(usbhid->urbout, GFP_ATOMIC);
+        if (r < 0) {
+                hid_err(hid, "usb_submit_urb(out) failed: %d\n", r);
+                return r;
         }
-
+        usbhid->last_out = jiffies;
         return 0;
 }
 
@@ -343,50 +350,48 @@ static int hid_submit_ctrl(struct hid_device *hid)
         raw_report = usbhid->ctrl[usbhid->ctrltail].raw_report;
         dir = usbhid->ctrl[usbhid->ctrltail].dir;
 
-        r = usb_autopm_get_interface_async(usbhid->intf);
-        if (r < 0)
-                return -1;
-        if (!test_bit(HID_REPORTED_IDLE, &usbhid->iofl)) {
-                len = ((report->size - 1) >> 3) + 1 + (report->id > 0);
-                if (dir == USB_DIR_OUT) {
-                        usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0);
-                        usbhid->urbctrl->transfer_buffer_length = len;
-                        memcpy(usbhid->ctrlbuf, raw_report, len);
-                        kfree(raw_report);
-                } else {
-                        int maxpacket, padlen;
-
-                        usbhid->urbctrl->pipe = usb_rcvctrlpipe(hid_to_usb_dev(hid), 0);
-                        maxpacket = usb_maxpacket(hid_to_usb_dev(hid), usbhid->urbctrl->pipe, 0);
-                        if (maxpacket > 0) {
-                                padlen = DIV_ROUND_UP(len, maxpacket);
-                                padlen *= maxpacket;
-                                if (padlen > usbhid->bufsize)
-                                        padlen = usbhid->bufsize;
-                        } else
-                                padlen = 0;
-                        usbhid->urbctrl->transfer_buffer_length = padlen;
-                }
-                usbhid->urbctrl->dev = hid_to_usb_dev(hid);
-
-                usbhid->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE | dir;
-                usbhid->cr->bRequest = (dir == USB_DIR_OUT) ? HID_REQ_SET_REPORT : HID_REQ_GET_REPORT;
-                usbhid->cr->wValue = cpu_to_le16(((report->type + 1) << 8) | report->id);
-                usbhid->cr->wIndex = cpu_to_le16(usbhid->ifnum);
-                usbhid->cr->wLength = cpu_to_le16(len);
-
-                dbg_hid("submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u\n",
-                        usbhid->cr->bRequest == HID_REQ_SET_REPORT ? "Set_Report" : "Get_Report",
-                        usbhid->cr->wValue, usbhid->cr->wIndex, usbhid->cr->wLength);
-
-                if (usb_submit_urb(usbhid->urbctrl, GFP_ATOMIC)) {
-                        usb_autopm_put_interface_async(usbhid->intf);
-                        hid_err(hid, "usb_submit_urb(ctrl) failed\n");
-                        return -1;
-                }
-                usbhid->last_ctrl = jiffies;
+        len = ((report->size - 1) >> 3) + 1 + (report->id > 0);
+        if (dir == USB_DIR_OUT) {
+                usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0);
+                usbhid->urbctrl->transfer_buffer_length = len;
+                memcpy(usbhid->ctrlbuf, raw_report, len);
+                kfree(raw_report);
+        } else {
+                int maxpacket, padlen;
+
+                usbhid->urbctrl->pipe = usb_rcvctrlpipe(hid_to_usb_dev(hid), 0);
+                maxpacket = usb_maxpacket(hid_to_usb_dev(hid),
+                                          usbhid->urbctrl->pipe, 0);
+                if (maxpacket > 0) {
+                        padlen = DIV_ROUND_UP(len, maxpacket);
+                        padlen *= maxpacket;
+                        if (padlen > usbhid->bufsize)
+                                padlen = usbhid->bufsize;
+                } else
+                        padlen = 0;
+                usbhid->urbctrl->transfer_buffer_length = padlen;
         }
-
+        usbhid->urbctrl->dev = hid_to_usb_dev(hid);
+
+        usbhid->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE | dir;
+        usbhid->cr->bRequest = (dir == USB_DIR_OUT) ? HID_REQ_SET_REPORT :
+                                                      HID_REQ_GET_REPORT;
+        usbhid->cr->wValue = cpu_to_le16(((report->type + 1) << 8) |
+                                         report->id);
+        usbhid->cr->wIndex = cpu_to_le16(usbhid->ifnum);
+        usbhid->cr->wLength = cpu_to_le16(len);
+
+        dbg_hid("submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u\n",
+                usbhid->cr->bRequest == HID_REQ_SET_REPORT ? "Set_Report" :
+                                                             "Get_Report",
+                usbhid->cr->wValue, usbhid->cr->wIndex, usbhid->cr->wLength);
+
+        r = usb_submit_urb(usbhid->urbctrl, GFP_ATOMIC);
+        if (r < 0) {
+                hid_err(hid, "usb_submit_urb(ctrl) failed: %d\n", r);
+                return r;
+        }
+        usbhid->last_ctrl = jiffies;
         return 0;
 }
 
@@ -423,11 +428,8 @@ static void hid_irq_out(struct urb *urb)
         else
                 usbhid->outtail = (usbhid->outtail + 1) & (HID_OUTPUT_FIFO_SIZE - 1);
 
-        if (usbhid->outhead != usbhid->outtail) {
-                if (hid_submit_out(hid)) {
-                        clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
-                        wake_up(&usbhid->wait);
-                }
+        if (usbhid->outhead != usbhid->outtail && !hid_submit_out(hid)) {
+                /* Successfully submitted next urb in queue */
                 spin_unlock_irqrestore(&usbhid->lock, flags);
                 return;
         }
@@ -474,13 +476,9 @@ static void hid_ctrl(struct urb *urb)
         else
                 usbhid->ctrltail = (usbhid->ctrltail + 1) & (HID_CONTROL_FIFO_SIZE - 1);
 
-        if (usbhid->ctrlhead != usbhid->ctrltail) {
-                if (hid_submit_ctrl(hid)) {
-                        clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
-                        wake_up(&usbhid->wait);
-                }
+        if (usbhid->ctrlhead != usbhid->ctrltail && !hid_submit_ctrl(hid)) {
+                /* Successfully submitted next urb in queue */
                 spin_unlock(&usbhid->lock);
-                usb_autopm_put_interface_async(usbhid->intf);
                 return;
         }
 
@@ -515,9 +513,23 @@ static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *re
                 usbhid->out[usbhid->outhead].report = report;
                 usbhid->outhead = head;
 
+                /* Try to awake from autosuspend... */
+                if (usb_autopm_get_interface_async(usbhid->intf) < 0)
+                        return;
+
+                /*
+                 * But if still suspended, leave urb enqueued, don't submit.
+                 * Submission will occur if/when resume() drains the queue.
+                 */
+                if (test_bit(HID_REPORTED_IDLE, &usbhid->iofl))
+                        return;
+
                 if (!test_and_set_bit(HID_OUT_RUNNING, &usbhid->iofl)) {
-                        if (hid_submit_out(hid))
+                        if (hid_submit_out(hid)) {
                                 clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
+                                usb_autopm_put_interface_async(usbhid->intf);
+                        }
+                        wake_up(&usbhid->wait);
                 } else {
                         /*
                          * the queue is known to run
@@ -549,9 +561,23 @@ static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *re
         usbhid->ctrl[usbhid->ctrlhead].dir = dir;
         usbhid->ctrlhead = head;
 
+        /* Try to awake from autosuspend... */
+        if (usb_autopm_get_interface_async(usbhid->intf) < 0)
+                return;
+
+        /*
+         * If already suspended, leave urb enqueued, but don't submit.
+         * Submission will occur if/when resume() drains the queue.
+         */
+        if (test_bit(HID_REPORTED_IDLE, &usbhid->iofl))
+                return;
+
         if (!test_and_set_bit(HID_CTRL_RUNNING, &usbhid->iofl)) {
-                if (hid_submit_ctrl(hid))
+                if (hid_submit_ctrl(hid)) {
                         clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
+                        usb_autopm_put_interface_async(usbhid->intf);
+                }
+                wake_up(&usbhid->wait);
         } else {
                 /*
                  * the queue is known to run
@@ -576,6 +602,30 @@ void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, uns
 }
 EXPORT_SYMBOL_GPL(usbhid_submit_report);
 
+/* Workqueue routine to send requests to change LEDs */
+static void hid_led(struct work_struct *work)
+{
+        struct usbhid_device *usbhid =
+                container_of(work, struct usbhid_device, led_work);
+        struct hid_device *hid = usbhid->hid;
+        struct hid_field *field;
+        unsigned long flags;
+
+        field = hidinput_get_led_field(hid);
+        if (!field) {
+                hid_warn(hid, "LED event field not found\n");
+                return;
+        }
+
+        spin_lock_irqsave(&usbhid->lock, flags);
+        if (!test_bit(HID_DISCONNECTED, &usbhid->iofl)) {
+                usbhid->ledcount = hidinput_count_leds(hid);
+                hid_dbg(usbhid->hid, "New ledcount = %u\n", usbhid->ledcount);
+                __usbhid_submit_report(hid, field->report, USB_DIR_OUT);
+        }
+        spin_unlock_irqrestore(&usbhid->lock, flags);
+}
+
 static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
 {
         struct hid_device *hid = input_get_drvdata(dev);
@@ -595,17 +645,15 @@ static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, un
                 return -1;
         }
 
+        spin_lock_irqsave(&usbhid->lock, flags);
         hid_set_field(field, offset, value);
-        if (value) {
-                spin_lock_irqsave(&usbhid->lock, flags);
-                usbhid->ledcount++;
-                spin_unlock_irqrestore(&usbhid->lock, flags);
-        } else {
-                spin_lock_irqsave(&usbhid->lock, flags);
-                usbhid->ledcount--;
-                spin_unlock_irqrestore(&usbhid->lock, flags);
-        }
-        usbhid_submit_report(hid, field->report, USB_DIR_OUT);
+        spin_unlock_irqrestore(&usbhid->lock, flags);
+
+        /*
+         * Defer performing requested LED action.
+         * This is more likely gather all LED changes into a single URB.
+         */
+        schedule_work(&usbhid->led_work);
 
         return 0;
 }
@@ -1100,7 +1148,7 @@ static void usbhid_stop(struct hid_device *hid)
                 return;
 
         clear_bit(HID_STARTED, &usbhid->iofl);
-        spin_lock_irq(&usbhid->lock);   /* Sync with error handler */
+        spin_lock_irq(&usbhid->lock);   /* Sync with error and led handlers */
         set_bit(HID_DISCONNECTED, &usbhid->iofl);
         spin_unlock_irq(&usbhid->lock);
         usb_kill_urb(usbhid->urbin);
@@ -1234,6 +1282,8 @@ static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *
         setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid);
         spin_lock_init(&usbhid->lock);
 
+        INIT_WORK(&usbhid->led_work, hid_led);
+
         ret = hid_add_device(hid);
         if (ret) {
                 if (ret != -ENODEV)
@@ -1266,6 +1316,7 @@ static void hid_cancel_delayed_stuff(struct usbhid_device *usbhid)
 {
         del_timer_sync(&usbhid->io_retry);
         cancel_work_sync(&usbhid->reset_work);
+        cancel_work_sync(&usbhid->led_work);
 }
 
 static void hid_cease_io(struct usbhid_device *usbhid)
@@ -1367,16 +1418,6 @@ static int hid_suspend(struct usb_interface *intf, pm_message_t message)
                         return -EIO;
         }
 
-        if (!ignoreled && PMSG_IS_AUTO(message)) {
-                spin_lock_irq(&usbhid->lock);
-                if (test_bit(HID_LED_ON, &usbhid->iofl)) {
-                        spin_unlock_irq(&usbhid->lock);
-                        usbhid_mark_busy(usbhid);
-                        return -EBUSY;
-                }
-                spin_unlock_irq(&usbhid->lock);
-        }
-
         hid_cancel_delayed_stuff(usbhid);
         hid_cease_io(usbhid);
 
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 5028d60a22a1..c831af937481 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -47,6 +47,7 @@ static const struct hid_blacklist {
 
         { USB_VENDOR_ID_AFATECH, USB_DEVICE_ID_AFATECH_AF9016, HID_QUIRK_FULLSPEED_INTERVAL },
 
+        { USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_ETURBOTOUCH, USB_DEVICE_ID_ETURBOTOUCH, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_GREENASIA, USB_DEVICE_ID_GREENASIA_DUAL_USB_JOYPAD, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
@@ -67,6 +68,9 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_AXIS_295, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_DMI, USB_DEVICE_ID_DMI_ENC, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET },
+        { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN, HID_QUIRK_NO_INIT_REPORTS },
+        { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1, HID_QUIRK_NO_INIT_REPORTS },
+        { USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2, HID_QUIRK_NO_INIT_REPORTS },
         { USB_VENDOR_ID_PRODIGE, USB_DEVICE_ID_PRODIGE_CORDLESS, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET },
diff --git a/drivers/hid/usbhid/usbhid.h b/drivers/hid/usbhid/usbhid.h
index 1673cac93d77..cb8f703efde5 100644
--- a/drivers/hid/usbhid/usbhid.h
+++ b/drivers/hid/usbhid/usbhid.h
@@ -55,7 +55,6 @@ struct usb_interface *usbhid_find_interface(int minor);
 #define HID_STARTED             8
 #define HID_REPORTED_IDLE       9
 #define HID_KEYS_PRESSED        10
-#define HID_LED_ON              11
 
 /*
  * USB-specific HID struct, to be pointed to
@@ -97,6 +96,8 @@ struct usbhid_device {
         struct work_struct reset_work;                                  /* Task context for resets */
         wait_queue_head_t wait;                                         /* For sleeping */
         int ledcount;                                                   /* counting the number of active leds */
+
+        struct work_struct led_work;                                    /* Task context for setting LEDs */
 };
 
 #define hid_to_usb_dev(hid_dev) \
diff --git a/drivers/hid/usbhid/usbkbd.c b/drivers/hid/usbhid/usbkbd.c
index bc445d7e3bf5..796086980f4a 100644
--- a/drivers/hid/usbhid/usbkbd.c
+++ b/drivers/hid/usbhid/usbkbd.c
@@ -64,6 +64,32 @@ static const unsigned char usb_kbd_keycode[256] = {
         150,158,159,128,136,177,178,176,142,152,173,140
 };
 
+
+/**
+ * struct usb_kbd - state of each attached keyboard
+ * @dev:        input device associated with this keyboard
+ * @usbdev:     usb device associated with this keyboard
+ * @old:        data received in the past from the @irq URB representing which
+ *              keys were pressed. By comparing with the current list of keys
+ *              that are pressed, we are able to see key releases.
+ * @irq:        URB for receiving a list of keys that are pressed when a
+ *              new key is pressed or a key that was pressed is released.
+ * @led:        URB for sending LEDs (e.g. numlock, ...)
+ * @newleds:    data that will be sent with the @led URB representing which LEDs
+                should be on
+ * @name:       Name of the keyboard. @dev's name field points to this buffer
+ * @phys:       Physical path of the keyboard. @dev's phys field points to this
+ *              buffer
+ * @new:        Buffer for the @irq URB
+ * @cr:         Control request for @led URB
+ * @leds:       Buffer for the @led URB
+ * @new_dma:    DMA address for @irq URB
+ * @leds_dma:   DMA address for @led URB
+ * @leds_lock:  spinlock that protects @leds, @newleds, and @led_urb_submitted
+ * @led_urb_submitted: indicates whether @led is in progress, i.e. it has been
+ *              submitted and its completion handler has not returned yet
+ *              without resubmitting @led
+ */
 struct usb_kbd {
         struct input_dev *dev;
         struct usb_device *usbdev;
@@ -78,6 +104,10 @@ struct usb_kbd {
         unsigned char *leds;
         dma_addr_t new_dma;
         dma_addr_t leds_dma;
+        
+        spinlock_t leds_lock;
+        bool led_urb_submitted;
+
 };
 
 static void usb_kbd_irq(struct urb *urb)
@@ -136,44 +166,66 @@ resubmit:
 static int usb_kbd_event(struct input_dev *dev, unsigned int type,
                          unsigned int code, int value)
 {
+        unsigned long flags;
         struct usb_kbd *kbd = input_get_drvdata(dev);
 
         if (type != EV_LED)
                 return -1;
 
+        spin_lock_irqsave(&kbd->leds_lock, flags);
         kbd->newleds = (!!test_bit(LED_KANA,    dev->led) << 3) | (!!test_bit(LED_COMPOSE, dev->led) << 3) |
                        (!!test_bit(LED_SCROLLL, dev->led) << 2) | (!!test_bit(LED_CAPSL,   dev->led) << 1) |
                        (!!test_bit(LED_NUML,    dev->led));
 
-        if (kbd->led->status == -EINPROGRESS)
+        if (kbd->led_urb_submitted){
+                spin_unlock_irqrestore(&kbd->leds_lock, flags);
                 return 0;
+        }
 
-        if (*(kbd->leds) == kbd->newleds)
+        if (*(kbd->leds) == kbd->newleds){
+                spin_unlock_irqrestore(&kbd->leds_lock, flags);
                 return 0;
+        }
 
         *(kbd->leds) = kbd->newleds;
+        
         kbd->led->dev = kbd->usbdev;
         if (usb_submit_urb(kbd->led, GFP_ATOMIC))
                 pr_err("usb_submit_urb(leds) failed\n");
-
+        else
+                kbd->led_urb_submitted = true;
+        
+        spin_unlock_irqrestore(&kbd->leds_lock, flags);
+        
         return 0;
 }
 
 static void usb_kbd_led(struct urb *urb)
 {
+        unsigned long flags;
         struct usb_kbd *kbd = urb->context;
 
         if (urb->status)
                 hid_warn(urb->dev, "led urb status %d received\n",
                          urb->status);
 
-        if (*(kbd->leds) == kbd->newleds)
+        spin_lock_irqsave(&kbd->leds_lock, flags);
+
+        if (*(kbd->leds) == kbd->newleds){
+                kbd->led_urb_submitted = false;
+                spin_unlock_irqrestore(&kbd->leds_lock, flags);
                 return;
+        }
 
         *(kbd->leds) = kbd->newleds;
+        
         kbd->led->dev = kbd->usbdev;
-        if (usb_submit_urb(kbd->led, GFP_ATOMIC))
+        if (usb_submit_urb(kbd->led, GFP_ATOMIC)){
                 hid_err(urb->dev, "usb_submit_urb(leds) failed\n");
+                kbd->led_urb_submitted = false;
+        }
+        spin_unlock_irqrestore(&kbd->leds_lock, flags);
+        
 }
 
 static int usb_kbd_open(struct input_dev *dev)
@@ -252,6 +304,7 @@ static int usb_kbd_probe(struct usb_interface *iface,
 
         kbd->usbdev = dev;
         kbd->dev = input_dev;
+        spin_lock_init(&kbd->leds_lock);
 
         if (dev->manufacturer)
                 strlcpy(kbd->name, dev->manufacturer, sizeof(kbd->name));
@@ -334,6 +387,7 @@ static void usb_kbd_disconnect(struct usb_interface *intf)
         if (kbd) {
                 usb_kill_urb(kbd->irq);
                 input_unregister_device(kbd->dev);
+                usb_kill_urb(kbd->led);
                 usb_kbd_free_mem(interface_to_usbdev(intf), kbd);
                 kfree(kbd);
         }