Merge branch 'for-3.8/upstream-fixes' of git://git.kernel.org/pub/scm/linux/kernel...

[firefly-linux-kernel-4.4.55.git] / drivers / hid / i2c-hid / i2c-hid.c

diff --git a/drivers/hid/i2c-hid/i2c-hid.c b/drivers/hid/i2c-hid/i2c-hid.c
index d00f1854cb8266bdc39358e46e88a6fe914c9d95..e766b5614ef59fcae45aaeff49a98df9de3e9693 100644 (file)
--- a/drivers/hid/i2c-hid/i2c-hid.c
+++ b/drivers/hid/i2c-hid/i2c-hid.c
@@ -33,6 +33,7 @@
 #include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/hid.h>
+#include <linux/mutex.h>
 
 #include <linux/i2c/i2c-hid.h>
 
@@ -117,6 +118,8 @@ static const struct i2c_hid_cmd hid_set_power_cmd = { I2C_HID_CMD(0x08) };
  * static const struct i2c_hid_cmd hid_set_protocol_cmd = { I2C_HID_CMD(0x07) };
  */
 
+static DEFINE_MUTEX(i2c_hid_open_mut);
+
 /* The main device structure */
 struct i2c_hid {
        struct i2c_client       *client;        /* i2c client */
@@ -135,8 +138,6 @@ struct i2c_hid {
 
        unsigned long           flags;          /* device flags */
 
-       int                     irq;            /* the interrupt line irq */
-
        wait_queue_head_t       wait;           /* For waiting the interrupt */
 };
 
@@ -504,23 +505,31 @@ static int i2c_hid_get_raw_report(struct hid_device *hid,
 {
        struct i2c_client *client = hid->driver_data;
        struct i2c_hid *ihid = i2c_get_clientdata(client);
+       size_t ret_count, ask_count;
        int ret;
 
        if (report_type == HID_OUTPUT_REPORT)
                return -EINVAL;
 
-       if (count > ihid->bufsize)
-               count = ihid->bufsize;
+       /* +2 bytes to include the size of the reply in the query buffer */
+       ask_count = min(count + 2, (size_t)ihid->bufsize);
 
        ret = i2c_hid_get_report(client,
                        report_type == HID_FEATURE_REPORT ? 0x03 : 0x01,
-                       report_number, ihid->inbuf, count);
+                       report_number, ihid->inbuf, ask_count);
 
        if (ret < 0)
                return ret;
 
-       count = ihid->inbuf[0] | (ihid->inbuf[1] << 8);
+       ret_count = ihid->inbuf[0] | (ihid->inbuf[1] << 8);
+
+       if (ret_count <= 2)
+               return 0;
 
+       ret_count = min(ret_count, ask_count);
+
+       /* The query buffer contains the size, dropping it in the reply */
+       count = min(count, ret_count - 2);
        memcpy(buf, ihid->inbuf + 2, count);
 
        return count;
@@ -531,13 +540,24 @@ static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
 {
        struct i2c_client *client = hid->driver_data;
        int report_id = buf[0];
+       int ret;
 
        if (report_type == HID_INPUT_REPORT)
                return -EINVAL;
 
-       return i2c_hid_set_report(client,
+       if (report_id) {
+               buf++;
+               count--;
+       }
+
+       ret = i2c_hid_set_report(client,
                                report_type == HID_FEATURE_REPORT ? 0x03 : 0x02,
                                report_id, buf, count);
+
+       if (report_id && ret >= 0)
+               ret++; /* add report_id to the number of transfered bytes */
+
+       return ret;
 }
 
 static int i2c_hid_parse(struct hid_device *hid)
@@ -635,17 +655,20 @@ static int i2c_hid_open(struct hid_device *hid)
 {
        struct i2c_client *client = hid->driver_data;
        struct i2c_hid *ihid = i2c_get_clientdata(client);
-       int ret;
+       int ret = 0;
 
+       mutex_lock(&i2c_hid_open_mut);
        if (!hid->open++) {
                ret = i2c_hid_set_power(client, I2C_HID_PWR_ON);
                if (ret) {
                        hid->open--;
-                       return -EIO;
+                       goto done;
                }
                set_bit(I2C_HID_STARTED, &ihid->flags);
        }
-       return 0;
+done:
+       mutex_unlock(&i2c_hid_open_mut);
+       return ret;
 }
 
 static void i2c_hid_close(struct hid_device *hid)
@@ -657,12 +680,14 @@ static void i2c_hid_close(struct hid_device *hid)
         * data acquistion due to a resumption we no longer
         * care about
         */
+       mutex_lock(&i2c_hid_open_mut);
        if (!--hid->open) {
                clear_bit(I2C_HID_STARTED, &ihid->flags);
 
                /* Save some power */
                i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
        }
+       mutex_unlock(&i2c_hid_open_mut);
 }
 
 static int i2c_hid_power(struct hid_device *hid, int lvl)
@@ -717,7 +742,7 @@ static struct hid_ll_driver i2c_hid_ll_driver = {
        .hidinput_input_event = i2c_hid_hidinput_input_event,
 };
 
-static int __devinit i2c_hid_init_irq(struct i2c_client *client)
+static int i2c_hid_init_irq(struct i2c_client *client)
 {
        struct i2c_hid *ihid = i2c_get_clientdata(client);
        int ret;
@@ -736,12 +761,10 @@ static int __devinit i2c_hid_init_irq(struct i2c_client *client)
                return ret;
        }
 
-       ihid->irq = client->irq;
-
        return 0;
 }
 
-static int __devinit i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid)
+static int i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid)
 {
        struct i2c_client *client = ihid->client;
        struct i2c_hid_desc *hdesc = &ihid->hdesc;
@@ -798,8 +821,8 @@ static int __devinit i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid)
        return 0;
 }
 
-static int __devinit i2c_hid_probe(struct i2c_client *client,
-               const struct i2c_device_id *dev_id)
+static int i2c_hid_probe(struct i2c_client *client,
+                        const struct i2c_device_id *dev_id)
 {
        int ret;
        struct i2c_hid *ihid;
@@ -851,7 +874,7 @@ static int __devinit i2c_hid_probe(struct i2c_client *client,
        hid = hid_allocate_device();
        if (IS_ERR(hid)) {
                ret = PTR_ERR(hid);
-               goto err;
+               goto err_irq;
        }
 
        ihid->hid = hid;
@@ -881,16 +904,16 @@ static int __devinit i2c_hid_probe(struct i2c_client *client,
 err_mem_free:
        hid_destroy_device(hid);
 
-err:
-       if (ihid->irq)
-               free_irq(ihid->irq, ihid);
+err_irq:
+       free_irq(client->irq, ihid);
 
+err:
        i2c_hid_free_buffers(ihid);
        kfree(ihid);
        return ret;
 }
 
-static int __devexit i2c_hid_remove(struct i2c_client *client)
+static int i2c_hid_remove(struct i2c_client *client)
 {
        struct i2c_hid *ihid = i2c_get_clientdata(client);
        struct hid_device *hid;
@@ -912,10 +935,9 @@ static int __devexit i2c_hid_remove(struct i2c_client *client)
 static int i2c_hid_suspend(struct device *dev)
 {
        struct i2c_client *client = to_i2c_client(dev);
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
 
        if (device_may_wakeup(&client->dev))
-               enable_irq_wake(ihid->irq);
+               enable_irq_wake(client->irq);
 
        /* Save some power */
        i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
@@ -956,7 +978,7 @@ static struct i2c_driver i2c_hid_driver = {
        },
 
        .probe          = i2c_hid_probe,
-       .remove         = __devexit_p(i2c_hid_remove),
+       .remove         = i2c_hid_remove,
 
        .id_table       = i2c_hid_id_table,
 };