HID: i2c-hid: override HID descriptors for certain devices
authorJulian Sax <jsbc@gmx.de>
Wed, 19 Sep 2018 09:46:23 +0000 (11:46 +0200)
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Sat, 20 Apr 2019 07:15:05 +0000 (09:15 +0200)
[ Upstream commit 9ee3e06610fdb8a601cde59c92089fb6c1deb4aa ]

A particular touchpad (SIPODEV SP1064) refuses to supply the HID
descriptors. This patch provides the framework for overriding these
descriptors based on DMI data. It also includes the descriptors for
said touchpad, which were extracted by listening to the traffic of the
windows filter driver, as well as the DMI data for the laptops known
to use this device.

Relevant Bug: https://bugzilla.redhat.com/show_bug.cgi?id=1526312

Cc: Hans de Goede <hdegoede@redhat.com>
Reported-and-tested-by: ahormann@gmx.net
Reported-and-tested-by: Bruno Jesus <bruno.fl.jesus@gmail.com>
Reported-and-tested-by: Dietrich <enaut.w@googlemail.com>
Reported-and-tested-by: kloxdami@yahoo.com
Signed-off-by: Julian Sax <jsbc@gmx.de>
Reviewed-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
Signed-off-by: Sasha Levin <sashal@kernel.org>
drivers/hid/i2c-hid/Makefile
drivers/hid/i2c-hid/i2c-hid-core.c [new file with mode: 0644]
drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c [new file with mode: 0644]
drivers/hid/i2c-hid/i2c-hid.c [deleted file]
drivers/hid/i2c-hid/i2c-hid.h [new file with mode: 0644]

index 832d8f9aaba27fed7926177383f96ec1edaf9666..099e1ce2f2347592f8cf00cff8f620cc4d170301 100644 (file)
@@ -3,3 +3,6 @@
 #
 
 obj-$(CONFIG_I2C_HID)                          += i2c-hid.o
+
+i2c-hid-objs                                   =  i2c-hid-core.o
+i2c-hid-$(CONFIG_DMI)                          += i2c-hid-dmi-quirks.o
diff --git a/drivers/hid/i2c-hid/i2c-hid-core.c b/drivers/hid/i2c-hid/i2c-hid-core.c
new file mode 100644 (file)
index 0000000..7842d76
--- /dev/null
@@ -0,0 +1,1299 @@
+/*
+ * HID over I2C protocol implementation
+ *
+ * Copyright (c) 2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
+ * Copyright (c) 2012 Ecole Nationale de l'Aviation Civile, France
+ * Copyright (c) 2012 Red Hat, Inc
+ *
+ * This code is partly based on "USB HID support for Linux":
+ *
+ *  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) 2007-2008 Oliver Neukum
+ *  Copyright (c) 2006-2010 Jiri Kosina
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file COPYING in the main directory of this archive for
+ * more details.
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/irq.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
+#include <linux/device.h>
+#include <linux/wait.h>
+#include <linux/err.h>
+#include <linux/string.h>
+#include <linux/list.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/hid.h>
+#include <linux/mutex.h>
+#include <linux/acpi.h>
+#include <linux/of.h>
+#include <linux/regulator/consumer.h>
+
+#include <linux/platform_data/i2c-hid.h>
+
+#include "../hid-ids.h"
+#include "i2c-hid.h"
+
+/* quirks to control the device */
+#define I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV       BIT(0)
+
+/* flags */
+#define I2C_HID_STARTED                0
+#define I2C_HID_RESET_PENDING  1
+#define I2C_HID_READ_PENDING   2
+
+#define I2C_HID_PWR_ON         0x00
+#define I2C_HID_PWR_SLEEP      0x01
+
+/* debug option */
+static bool debug;
+module_param(debug, bool, 0444);
+MODULE_PARM_DESC(debug, "print a lot of debug information");
+
+#define i2c_hid_dbg(ihid, fmt, arg...)                                   \
+do {                                                                     \
+       if (debug)                                                        \
+               dev_printk(KERN_DEBUG, &(ihid)->client->dev, fmt, ##arg); \
+} while (0)
+
+struct i2c_hid_desc {
+       __le16 wHIDDescLength;
+       __le16 bcdVersion;
+       __le16 wReportDescLength;
+       __le16 wReportDescRegister;
+       __le16 wInputRegister;
+       __le16 wMaxInputLength;
+       __le16 wOutputRegister;
+       __le16 wMaxOutputLength;
+       __le16 wCommandRegister;
+       __le16 wDataRegister;
+       __le16 wVendorID;
+       __le16 wProductID;
+       __le16 wVersionID;
+       __le32 reserved;
+} __packed;
+
+struct i2c_hid_cmd {
+       unsigned int registerIndex;
+       __u8 opcode;
+       unsigned int length;
+       bool wait;
+};
+
+union command {
+       u8 data[0];
+       struct cmd {
+               __le16 reg;
+               __u8 reportTypeID;
+               __u8 opcode;
+       } __packed c;
+};
+
+#define I2C_HID_CMD(opcode_) \
+       .opcode = opcode_, .length = 4, \
+       .registerIndex = offsetof(struct i2c_hid_desc, wCommandRegister)
+
+/* fetch HID descriptor */
+static const struct i2c_hid_cmd hid_descr_cmd = { .length = 2 };
+/* fetch report descriptors */
+static const struct i2c_hid_cmd hid_report_descr_cmd = {
+               .registerIndex = offsetof(struct i2c_hid_desc,
+                       wReportDescRegister),
+               .opcode = 0x00,
+               .length = 2 };
+/* commands */
+static const struct i2c_hid_cmd hid_reset_cmd =                { I2C_HID_CMD(0x01),
+                                                         .wait = true };
+static const struct i2c_hid_cmd hid_get_report_cmd =   { I2C_HID_CMD(0x02) };
+static const struct i2c_hid_cmd hid_set_report_cmd =   { I2C_HID_CMD(0x03) };
+static const struct i2c_hid_cmd hid_set_power_cmd =    { I2C_HID_CMD(0x08) };
+static const struct i2c_hid_cmd hid_no_cmd =           { .length = 0 };
+
+/*
+ * These definitions are not used here, but are defined by the spec.
+ * Keeping them here for documentation purposes.
+ *
+ * static const struct i2c_hid_cmd hid_get_idle_cmd = { I2C_HID_CMD(0x04) };
+ * static const struct i2c_hid_cmd hid_set_idle_cmd = { I2C_HID_CMD(0x05) };
+ * static const struct i2c_hid_cmd hid_get_protocol_cmd = { I2C_HID_CMD(0x06) };
+ * 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 */
+       struct hid_device       *hid;   /* pointer to corresponding HID dev */
+       union {
+               __u8 hdesc_buffer[sizeof(struct i2c_hid_desc)];
+               struct i2c_hid_desc hdesc;      /* the HID Descriptor */
+       };
+       __le16                  wHIDDescRegister; /* location of the i2c
+                                                  * register of the HID
+                                                  * descriptor. */
+       unsigned int            bufsize;        /* i2c buffer size */
+       u8                      *inbuf;         /* Input buffer */
+       u8                      *rawbuf;        /* Raw Input buffer */
+       u8                      *cmdbuf;        /* Command buffer */
+       u8                      *argsbuf;       /* Command arguments buffer */
+
+       unsigned long           flags;          /* device flags */
+       unsigned long           quirks;         /* Various quirks */
+
+       wait_queue_head_t       wait;           /* For waiting the interrupt */
+
+       struct i2c_hid_platform_data pdata;
+
+       bool                    irq_wake_enabled;
+       struct mutex            reset_lock;
+};
+
+static const struct i2c_hid_quirks {
+       __u16 idVendor;
+       __u16 idProduct;
+       __u32 quirks;
+} i2c_hid_quirks[] = {
+       { USB_VENDOR_ID_WEIDA, USB_DEVICE_ID_WEIDA_8752,
+               I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV },
+       { USB_VENDOR_ID_WEIDA, USB_DEVICE_ID_WEIDA_8755,
+               I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV },
+       { 0, 0 }
+};
+
+/*
+ * i2c_hid_lookup_quirk: return any quirks associated with a I2C HID device
+ * @idVendor: the 16-bit vendor ID
+ * @idProduct: the 16-bit product ID
+ *
+ * Returns: a u32 quirks value.
+ */
+static u32 i2c_hid_lookup_quirk(const u16 idVendor, const u16 idProduct)
+{
+       u32 quirks = 0;
+       int n;
+
+       for (n = 0; i2c_hid_quirks[n].idVendor; n++)
+               if (i2c_hid_quirks[n].idVendor == idVendor &&
+                   (i2c_hid_quirks[n].idProduct == (__u16)HID_ANY_ID ||
+                    i2c_hid_quirks[n].idProduct == idProduct))
+                       quirks = i2c_hid_quirks[n].quirks;
+
+       return quirks;
+}
+
+static int __i2c_hid_command(struct i2c_client *client,
+               const struct i2c_hid_cmd *command, u8 reportID,
+               u8 reportType, u8 *args, int args_len,
+               unsigned char *buf_recv, int data_len)
+{
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       union command *cmd = (union command *)ihid->cmdbuf;
+       int ret;
+       struct i2c_msg msg[2];
+       int msg_num = 1;
+
+       int length = command->length;
+       bool wait = command->wait;
+       unsigned int registerIndex = command->registerIndex;
+
+       /* special case for hid_descr_cmd */
+       if (command == &hid_descr_cmd) {
+               cmd->c.reg = ihid->wHIDDescRegister;
+       } else {
+               cmd->data[0] = ihid->hdesc_buffer[registerIndex];
+               cmd->data[1] = ihid->hdesc_buffer[registerIndex + 1];
+       }
+
+       if (length > 2) {
+               cmd->c.opcode = command->opcode;
+               cmd->c.reportTypeID = reportID | reportType << 4;
+       }
+
+       memcpy(cmd->data + length, args, args_len);
+       length += args_len;
+
+       i2c_hid_dbg(ihid, "%s: cmd=%*ph\n", __func__, length, cmd->data);
+
+       msg[0].addr = client->addr;
+       msg[0].flags = client->flags & I2C_M_TEN;
+       msg[0].len = length;
+       msg[0].buf = cmd->data;
+       if (data_len > 0) {
+               msg[1].addr = client->addr;
+               msg[1].flags = client->flags & I2C_M_TEN;
+               msg[1].flags |= I2C_M_RD;
+               msg[1].len = data_len;
+               msg[1].buf = buf_recv;
+               msg_num = 2;
+               set_bit(I2C_HID_READ_PENDING, &ihid->flags);
+       }
+
+       if (wait)
+               set_bit(I2C_HID_RESET_PENDING, &ihid->flags);
+
+       ret = i2c_transfer(client->adapter, msg, msg_num);
+
+       if (data_len > 0)
+               clear_bit(I2C_HID_READ_PENDING, &ihid->flags);
+
+       if (ret != msg_num)
+               return ret < 0 ? ret : -EIO;
+
+       ret = 0;
+
+       if (wait) {
+               i2c_hid_dbg(ihid, "%s: waiting...\n", __func__);
+               if (!wait_event_timeout(ihid->wait,
+                               !test_bit(I2C_HID_RESET_PENDING, &ihid->flags),
+                               msecs_to_jiffies(5000)))
+                       ret = -ENODATA;
+               i2c_hid_dbg(ihid, "%s: finished.\n", __func__);
+       }
+
+       return ret;
+}
+
+static int i2c_hid_command(struct i2c_client *client,
+               const struct i2c_hid_cmd *command,
+               unsigned char *buf_recv, int data_len)
+{
+       return __i2c_hid_command(client, command, 0, 0, NULL, 0,
+                               buf_recv, data_len);
+}
+
+static int i2c_hid_get_report(struct i2c_client *client, u8 reportType,
+               u8 reportID, unsigned char *buf_recv, int data_len)
+{
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       u8 args[3];
+       int ret;
+       int args_len = 0;
+       u16 readRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
+
+       i2c_hid_dbg(ihid, "%s\n", __func__);
+
+       if (reportID >= 0x0F) {
+               args[args_len++] = reportID;
+               reportID = 0x0F;
+       }
+
+       args[args_len++] = readRegister & 0xFF;
+       args[args_len++] = readRegister >> 8;
+
+       ret = __i2c_hid_command(client, &hid_get_report_cmd, reportID,
+               reportType, args, args_len, buf_recv, data_len);
+       if (ret) {
+               dev_err(&client->dev,
+                       "failed to retrieve report from device.\n");
+               return ret;
+       }
+
+       return 0;
+}
+
+/**
+ * i2c_hid_set_or_send_report: forward an incoming report to the device
+ * @client: the i2c_client of the device
+ * @reportType: 0x03 for HID_FEATURE_REPORT ; 0x02 for HID_OUTPUT_REPORT
+ * @reportID: the report ID
+ * @buf: the actual data to transfer, without the report ID
+ * @len: size of buf
+ * @use_data: true: use SET_REPORT HID command, false: send plain OUTPUT report
+ */
+static int i2c_hid_set_or_send_report(struct i2c_client *client, u8 reportType,
+               u8 reportID, unsigned char *buf, size_t data_len, bool use_data)
+{
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       u8 *args = ihid->argsbuf;
+       const struct i2c_hid_cmd *hidcmd;
+       int ret;
+       u16 dataRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
+       u16 outputRegister = le16_to_cpu(ihid->hdesc.wOutputRegister);
+       u16 maxOutputLength = le16_to_cpu(ihid->hdesc.wMaxOutputLength);
+       u16 size;
+       int args_len;
+       int index = 0;
+
+       i2c_hid_dbg(ihid, "%s\n", __func__);
+
+       if (data_len > ihid->bufsize)
+               return -EINVAL;
+
+       size =          2                       /* size */ +
+                       (reportID ? 1 : 0)      /* reportID */ +
+                       data_len                /* buf */;
+       args_len =      (reportID >= 0x0F ? 1 : 0) /* optional third byte */ +
+                       2                       /* dataRegister */ +
+                       size                    /* args */;
+
+       if (!use_data && maxOutputLength == 0)
+               return -ENOSYS;
+
+       if (reportID >= 0x0F) {
+               args[index++] = reportID;
+               reportID = 0x0F;
+       }
+
+       /*
+        * use the data register for feature reports or if the device does not
+        * support the output register
+        */
+       if (use_data) {
+               args[index++] = dataRegister & 0xFF;
+               args[index++] = dataRegister >> 8;
+               hidcmd = &hid_set_report_cmd;
+       } else {
+               args[index++] = outputRegister & 0xFF;
+               args[index++] = outputRegister >> 8;
+               hidcmd = &hid_no_cmd;
+       }
+
+       args[index++] = size & 0xFF;
+       args[index++] = size >> 8;
+
+       if (reportID)
+               args[index++] = reportID;
+
+       memcpy(&args[index], buf, data_len);
+
+       ret = __i2c_hid_command(client, hidcmd, reportID,
+               reportType, args, args_len, NULL, 0);
+       if (ret) {
+               dev_err(&client->dev, "failed to set a report to device.\n");
+               return ret;
+       }
+
+       return data_len;
+}
+
+static int i2c_hid_set_power(struct i2c_client *client, int power_state)
+{
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       int ret;
+
+       i2c_hid_dbg(ihid, "%s\n", __func__);
+
+       /*
+        * Some devices require to send a command to wakeup before power on.
+        * The call will get a return value (EREMOTEIO) but device will be
+        * triggered and activated. After that, it goes like a normal device.
+        */
+       if (power_state == I2C_HID_PWR_ON &&
+           ihid->quirks & I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV) {
+               ret = i2c_hid_command(client, &hid_set_power_cmd, NULL, 0);
+
+               /* Device was already activated */
+               if (!ret)
+                       goto set_pwr_exit;
+       }
+
+       ret = __i2c_hid_command(client, &hid_set_power_cmd, power_state,
+               0, NULL, 0, NULL, 0);
+
+       if (ret)
+               dev_err(&client->dev, "failed to change power setting.\n");
+
+set_pwr_exit:
+       return ret;
+}
+
+static int i2c_hid_hwreset(struct i2c_client *client)
+{
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       int ret;
+
+       i2c_hid_dbg(ihid, "%s\n", __func__);
+
+       /*
+        * This prevents sending feature reports while the device is
+        * being reset. Otherwise we may lose the reset complete
+        * interrupt.
+        */
+       mutex_lock(&ihid->reset_lock);
+
+       ret = i2c_hid_set_power(client, I2C_HID_PWR_ON);
+       if (ret)
+               goto out_unlock;
+
+       /*
+        * The HID over I2C specification states that if a DEVICE needs time
+        * after the PWR_ON request, it should utilise CLOCK stretching.
+        * However, it has been observered that the Windows driver provides a
+        * 1ms sleep between the PWR_ON and RESET requests and that some devices
+        * rely on this.
+        */
+       usleep_range(1000, 5000);
+
+       i2c_hid_dbg(ihid, "resetting...\n");
+
+       ret = i2c_hid_command(client, &hid_reset_cmd, NULL, 0);
+       if (ret) {
+               dev_err(&client->dev, "failed to reset device.\n");
+               i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
+       }
+
+out_unlock:
+       mutex_unlock(&ihid->reset_lock);
+       return ret;
+}
+
+static void i2c_hid_get_input(struct i2c_hid *ihid)
+{
+       int ret;
+       u32 ret_size;
+       int size = le16_to_cpu(ihid->hdesc.wMaxInputLength);
+
+       if (size > ihid->bufsize)
+               size = ihid->bufsize;
+
+       ret = i2c_master_recv(ihid->client, ihid->inbuf, size);
+       if (ret != size) {
+               if (ret < 0)
+                       return;
+
+               dev_err(&ihid->client->dev, "%s: got %d data instead of %d\n",
+                       __func__, ret, size);
+               return;
+       }
+
+       ret_size = ihid->inbuf[0] | ihid->inbuf[1] << 8;
+
+       if (!ret_size) {
+               /* host or device initiated RESET completed */
+               if (test_and_clear_bit(I2C_HID_RESET_PENDING, &ihid->flags))
+                       wake_up(&ihid->wait);
+               return;
+       }
+
+       if ((ret_size > size) || (ret_size < 2)) {
+               dev_err(&ihid->client->dev, "%s: incomplete report (%d/%d)\n",
+                       __func__, size, ret_size);
+               return;
+       }
+
+       i2c_hid_dbg(ihid, "input: %*ph\n", ret_size, ihid->inbuf);
+
+       if (test_bit(I2C_HID_STARTED, &ihid->flags))
+               hid_input_report(ihid->hid, HID_INPUT_REPORT, ihid->inbuf + 2,
+                               ret_size - 2, 1);
+
+       return;
+}
+
+static irqreturn_t i2c_hid_irq(int irq, void *dev_id)
+{
+       struct i2c_hid *ihid = dev_id;
+
+       if (test_bit(I2C_HID_READ_PENDING, &ihid->flags))
+               return IRQ_HANDLED;
+
+       i2c_hid_get_input(ihid);
+
+       return IRQ_HANDLED;
+}
+
+static int i2c_hid_get_report_length(struct hid_report *report)
+{
+       return ((report->size - 1) >> 3) + 1 +
+               report->device->report_enum[report->type].numbered + 2;
+}
+
+/*
+ * Traverse the supplied list of reports and find the longest
+ */
+static void i2c_hid_find_max_report(struct hid_device *hid, unsigned int type,
+               unsigned int *max)
+{
+       struct hid_report *report;
+       unsigned int size;
+
+       /* We should not rely on wMaxInputLength, as some devices may set it to
+        * a wrong length. */
+       list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
+               size = i2c_hid_get_report_length(report);
+               if (*max < size)
+                       *max = size;
+       }
+}
+
+static void i2c_hid_free_buffers(struct i2c_hid *ihid)
+{
+       kfree(ihid->inbuf);
+       kfree(ihid->rawbuf);
+       kfree(ihid->argsbuf);
+       kfree(ihid->cmdbuf);
+       ihid->inbuf = NULL;
+       ihid->rawbuf = NULL;
+       ihid->cmdbuf = NULL;
+       ihid->argsbuf = NULL;
+       ihid->bufsize = 0;
+}
+
+static int i2c_hid_alloc_buffers(struct i2c_hid *ihid, size_t report_size)
+{
+       /* the worst case is computed from the set_report command with a
+        * reportID > 15 and the maximum report length */
+       int args_len = sizeof(__u8) + /* ReportID */
+                      sizeof(__u8) + /* optional ReportID byte */
+                      sizeof(__u16) + /* data register */
+                      sizeof(__u16) + /* size of the report */
+                      report_size; /* report */
+
+       ihid->inbuf = kzalloc(report_size, GFP_KERNEL);
+       ihid->rawbuf = kzalloc(report_size, GFP_KERNEL);
+       ihid->argsbuf = kzalloc(args_len, GFP_KERNEL);
+       ihid->cmdbuf = kzalloc(sizeof(union command) + args_len, GFP_KERNEL);
+
+       if (!ihid->inbuf || !ihid->rawbuf || !ihid->argsbuf || !ihid->cmdbuf) {
+               i2c_hid_free_buffers(ihid);
+               return -ENOMEM;
+       }
+
+       ihid->bufsize = report_size;
+
+       return 0;
+}
+
+static int i2c_hid_get_raw_report(struct hid_device *hid,
+               unsigned char report_number, __u8 *buf, size_t count,
+               unsigned char report_type)
+{
+       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;
+
+       /* +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->rawbuf, ask_count);
+
+       if (ret < 0)
+               return ret;
+
+       ret_count = ihid->rawbuf[0] | (ihid->rawbuf[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->rawbuf + 2, count);
+
+       return count;
+}
+
+static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
+               size_t count, unsigned char report_type, bool use_data)
+{
+       struct i2c_client *client = hid->driver_data;
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       int report_id = buf[0];
+       int ret;
+
+       if (report_type == HID_INPUT_REPORT)
+               return -EINVAL;
+
+       mutex_lock(&ihid->reset_lock);
+
+       if (report_id) {
+               buf++;
+               count--;
+       }
+
+       ret = i2c_hid_set_or_send_report(client,
+                               report_type == HID_FEATURE_REPORT ? 0x03 : 0x02,
+                               report_id, buf, count, use_data);
+
+       if (report_id && ret >= 0)
+               ret++; /* add report_id to the number of transfered bytes */
+
+       mutex_unlock(&ihid->reset_lock);
+
+       return ret;
+}
+
+static int i2c_hid_output_report(struct hid_device *hid, __u8 *buf,
+               size_t count)
+{
+       return i2c_hid_output_raw_report(hid, buf, count, HID_OUTPUT_REPORT,
+                       false);
+}
+
+static int i2c_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
+                              __u8 *buf, size_t len, unsigned char rtype,
+                              int reqtype)
+{
+       switch (reqtype) {
+       case HID_REQ_GET_REPORT:
+               return i2c_hid_get_raw_report(hid, reportnum, buf, len, rtype);
+       case HID_REQ_SET_REPORT:
+               if (buf[0] != reportnum)
+                       return -EINVAL;
+               return i2c_hid_output_raw_report(hid, buf, len, rtype, true);
+       default:
+               return -EIO;
+       }
+}
+
+static int i2c_hid_parse(struct hid_device *hid)
+{
+       struct i2c_client *client = hid->driver_data;
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       struct i2c_hid_desc *hdesc = &ihid->hdesc;
+       unsigned int rsize;
+       char *rdesc;
+       int ret;
+       int tries = 3;
+       char *use_override;
+
+       i2c_hid_dbg(ihid, "entering %s\n", __func__);
+
+       rsize = le16_to_cpu(hdesc->wReportDescLength);
+       if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
+               dbg_hid("weird size of report descriptor (%u)\n", rsize);
+               return -EINVAL;
+       }
+
+       do {
+               ret = i2c_hid_hwreset(client);
+               if (ret)
+                       msleep(1000);
+       } while (tries-- > 0 && ret);
+
+       if (ret)
+               return ret;
+
+       use_override = i2c_hid_get_dmi_hid_report_desc_override(client->name,
+                                                               &rsize);
+
+       if (use_override) {
+               rdesc = use_override;
+               i2c_hid_dbg(ihid, "Using a HID report descriptor override\n");
+       } else {
+               rdesc = kzalloc(rsize, GFP_KERNEL);
+
+               if (!rdesc) {
+                       dbg_hid("couldn't allocate rdesc memory\n");
+                       return -ENOMEM;
+               }
+
+               i2c_hid_dbg(ihid, "asking HID report descriptor\n");
+
+               ret = i2c_hid_command(client, &hid_report_descr_cmd,
+                                     rdesc, rsize);
+               if (ret) {
+                       hid_err(hid, "reading report descriptor failed\n");
+                       kfree(rdesc);
+                       return -EIO;
+               }
+       }
+
+       i2c_hid_dbg(ihid, "Report Descriptor: %*ph\n", rsize, rdesc);
+
+       ret = hid_parse_report(hid, rdesc, rsize);
+       if (!use_override)
+               kfree(rdesc);
+
+       if (ret) {
+               dbg_hid("parsing report descriptor failed\n");
+               return ret;
+       }
+
+       return 0;
+}
+
+static int i2c_hid_start(struct hid_device *hid)
+{
+       struct i2c_client *client = hid->driver_data;
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       int ret;
+       unsigned int bufsize = HID_MIN_BUFFER_SIZE;
+
+       i2c_hid_find_max_report(hid, HID_INPUT_REPORT, &bufsize);
+       i2c_hid_find_max_report(hid, HID_OUTPUT_REPORT, &bufsize);
+       i2c_hid_find_max_report(hid, HID_FEATURE_REPORT, &bufsize);
+
+       if (bufsize > ihid->bufsize) {
+               disable_irq(client->irq);
+               i2c_hid_free_buffers(ihid);
+
+               ret = i2c_hid_alloc_buffers(ihid, bufsize);
+               enable_irq(client->irq);
+
+               if (ret)
+                       return ret;
+       }
+
+       return 0;
+}
+
+static void i2c_hid_stop(struct hid_device *hid)
+{
+       hid->claimed = 0;
+}
+
+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 = 0;
+
+       ret = pm_runtime_get_sync(&client->dev);
+       if (ret < 0)
+               return ret;
+
+       set_bit(I2C_HID_STARTED, &ihid->flags);
+       return 0;
+}
+
+static void i2c_hid_close(struct hid_device *hid)
+{
+       struct i2c_client *client = hid->driver_data;
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+
+       clear_bit(I2C_HID_STARTED, &ihid->flags);
+
+       /* Save some power */
+       pm_runtime_put(&client->dev);
+}
+
+static int i2c_hid_power(struct hid_device *hid, int lvl)
+{
+       struct i2c_client *client = hid->driver_data;
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+
+       i2c_hid_dbg(ihid, "%s lvl:%d\n", __func__, lvl);
+
+       switch (lvl) {
+       case PM_HINT_FULLON:
+               pm_runtime_get_sync(&client->dev);
+               break;
+       case PM_HINT_NORMAL:
+               pm_runtime_put(&client->dev);
+               break;
+       }
+       return 0;
+}
+
+struct hid_ll_driver i2c_hid_ll_driver = {
+       .parse = i2c_hid_parse,
+       .start = i2c_hid_start,
+       .stop = i2c_hid_stop,
+       .open = i2c_hid_open,
+       .close = i2c_hid_close,
+       .power = i2c_hid_power,
+       .output_report = i2c_hid_output_report,
+       .raw_request = i2c_hid_raw_request,
+};
+EXPORT_SYMBOL_GPL(i2c_hid_ll_driver);
+
+static int i2c_hid_init_irq(struct i2c_client *client)
+{
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       unsigned long irqflags = 0;
+       int ret;
+
+       dev_dbg(&client->dev, "Requesting IRQ: %d\n", client->irq);
+
+       if (!irq_get_trigger_type(client->irq))
+               irqflags = IRQF_TRIGGER_LOW;
+
+       ret = request_threaded_irq(client->irq, NULL, i2c_hid_irq,
+                                  irqflags | IRQF_ONESHOT, client->name, ihid);
+       if (ret < 0) {
+               dev_warn(&client->dev,
+                       "Could not register for %s interrupt, irq = %d,"
+                       " ret = %d\n",
+                       client->name, client->irq, ret);
+
+               return ret;
+       }
+
+       return 0;
+}
+
+static int i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid)
+{
+       struct i2c_client *client = ihid->client;
+       struct i2c_hid_desc *hdesc = &ihid->hdesc;
+       unsigned int dsize;
+       int ret;
+
+       /* i2c hid fetch using a fixed descriptor size (30 bytes) */
+       if (i2c_hid_get_dmi_i2c_hid_desc_override(client->name)) {
+               i2c_hid_dbg(ihid, "Using a HID descriptor override\n");
+               ihid->hdesc =
+                       *i2c_hid_get_dmi_i2c_hid_desc_override(client->name);
+       } else {
+               i2c_hid_dbg(ihid, "Fetching the HID descriptor\n");
+               ret = i2c_hid_command(client, &hid_descr_cmd,
+                                     ihid->hdesc_buffer,
+                                     sizeof(struct i2c_hid_desc));
+               if (ret) {
+                       dev_err(&client->dev, "hid_descr_cmd failed\n");
+                       return -ENODEV;
+               }
+       }
+
+       /* Validate the length of HID descriptor, the 4 first bytes:
+        * bytes 0-1 -> length
+        * bytes 2-3 -> bcdVersion (has to be 1.00) */
+       /* check bcdVersion == 1.0 */
+       if (le16_to_cpu(hdesc->bcdVersion) != 0x0100) {
+               dev_err(&client->dev,
+                       "unexpected HID descriptor bcdVersion (0x%04hx)\n",
+                       le16_to_cpu(hdesc->bcdVersion));
+               return -ENODEV;
+       }
+
+       /* Descriptor length should be 30 bytes as per the specification */
+       dsize = le16_to_cpu(hdesc->wHIDDescLength);
+       if (dsize != sizeof(struct i2c_hid_desc)) {
+               dev_err(&client->dev, "weird size of HID descriptor (%u)\n",
+                       dsize);
+               return -ENODEV;
+       }
+       i2c_hid_dbg(ihid, "HID Descriptor: %*ph\n", dsize, ihid->hdesc_buffer);
+       return 0;
+}
+
+#ifdef CONFIG_ACPI
+static int i2c_hid_acpi_pdata(struct i2c_client *client,
+               struct i2c_hid_platform_data *pdata)
+{
+       static guid_t i2c_hid_guid =
+               GUID_INIT(0x3CDFF6F7, 0x4267, 0x4555,
+                         0xAD, 0x05, 0xB3, 0x0A, 0x3D, 0x89, 0x38, 0xDE);
+       union acpi_object *obj;
+       struct acpi_device *adev;
+       acpi_handle handle;
+
+       handle = ACPI_HANDLE(&client->dev);
+       if (!handle || acpi_bus_get_device(handle, &adev))
+               return -ENODEV;
+
+       obj = acpi_evaluate_dsm_typed(handle, &i2c_hid_guid, 1, 1, NULL,
+                                     ACPI_TYPE_INTEGER);
+       if (!obj) {
+               dev_err(&client->dev, "device _DSM execution failed\n");
+               return -ENODEV;
+       }
+
+       pdata->hid_descriptor_address = obj->integer.value;
+       ACPI_FREE(obj);
+
+       return 0;
+}
+
+static void i2c_hid_acpi_fix_up_power(struct device *dev)
+{
+       acpi_handle handle = ACPI_HANDLE(dev);
+       struct acpi_device *adev;
+
+       if (handle && acpi_bus_get_device(handle, &adev) == 0)
+               acpi_device_fix_up_power(adev);
+}
+
+static const struct acpi_device_id i2c_hid_acpi_match[] = {
+       {"ACPI0C50", 0 },
+       {"PNP0C50", 0 },
+       { },
+};
+MODULE_DEVICE_TABLE(acpi, i2c_hid_acpi_match);
+#else
+static inline int i2c_hid_acpi_pdata(struct i2c_client *client,
+               struct i2c_hid_platform_data *pdata)
+{
+       return -ENODEV;
+}
+
+static inline void i2c_hid_acpi_fix_up_power(struct device *dev) {}
+#endif
+
+#ifdef CONFIG_OF
+static int i2c_hid_of_probe(struct i2c_client *client,
+               struct i2c_hid_platform_data *pdata)
+{
+       struct device *dev = &client->dev;
+       u32 val;
+       int ret;
+
+       ret = of_property_read_u32(dev->of_node, "hid-descr-addr", &val);
+       if (ret) {
+               dev_err(&client->dev, "HID register address not provided\n");
+               return -ENODEV;
+       }
+       if (val >> 16) {
+               dev_err(&client->dev, "Bad HID register address: 0x%08x\n",
+                       val);
+               return -EINVAL;
+       }
+       pdata->hid_descriptor_address = val;
+
+       ret = of_property_read_u32(dev->of_node, "post-power-on-delay-ms",
+                                  &val);
+       if (!ret)
+               pdata->post_power_delay_ms = val;
+
+       return 0;
+}
+
+static const struct of_device_id i2c_hid_of_match[] = {
+       { .compatible = "hid-over-i2c" },
+       {},
+};
+MODULE_DEVICE_TABLE(of, i2c_hid_of_match);
+#else
+static inline int i2c_hid_of_probe(struct i2c_client *client,
+               struct i2c_hid_platform_data *pdata)
+{
+       return -ENODEV;
+}
+#endif
+
+static int i2c_hid_probe(struct i2c_client *client,
+                        const struct i2c_device_id *dev_id)
+{
+       int ret;
+       struct i2c_hid *ihid;
+       struct hid_device *hid;
+       __u16 hidRegister;
+       struct i2c_hid_platform_data *platform_data = client->dev.platform_data;
+
+       dbg_hid("HID probe called for i2c 0x%02x\n", client->addr);
+
+       if (!client->irq) {
+               dev_err(&client->dev,
+                       "HID over i2c has not been provided an Int IRQ\n");
+               return -EINVAL;
+       }
+
+       if (client->irq < 0) {
+               if (client->irq != -EPROBE_DEFER)
+                       dev_err(&client->dev,
+                               "HID over i2c doesn't have a valid IRQ\n");
+               return client->irq;
+       }
+
+       ihid = kzalloc(sizeof(struct i2c_hid), GFP_KERNEL);
+       if (!ihid)
+               return -ENOMEM;
+
+       if (client->dev.of_node) {
+               ret = i2c_hid_of_probe(client, &ihid->pdata);
+               if (ret)
+                       goto err;
+       } else if (!platform_data) {
+               ret = i2c_hid_acpi_pdata(client, &ihid->pdata);
+               if (ret) {
+                       dev_err(&client->dev,
+                               "HID register address not provided\n");
+                       goto err;
+               }
+       } else {
+               ihid->pdata = *platform_data;
+       }
+
+       ihid->pdata.supply = devm_regulator_get(&client->dev, "vdd");
+       if (IS_ERR(ihid->pdata.supply)) {
+               ret = PTR_ERR(ihid->pdata.supply);
+               if (ret != -EPROBE_DEFER)
+                       dev_err(&client->dev, "Failed to get regulator: %d\n",
+                               ret);
+               goto err;
+       }
+
+       ret = regulator_enable(ihid->pdata.supply);
+       if (ret < 0) {
+               dev_err(&client->dev, "Failed to enable regulator: %d\n",
+                       ret);
+               goto err;
+       }
+       if (ihid->pdata.post_power_delay_ms)
+               msleep(ihid->pdata.post_power_delay_ms);
+
+       i2c_set_clientdata(client, ihid);
+
+       ihid->client = client;
+
+       hidRegister = ihid->pdata.hid_descriptor_address;
+       ihid->wHIDDescRegister = cpu_to_le16(hidRegister);
+
+       init_waitqueue_head(&ihid->wait);
+       mutex_init(&ihid->reset_lock);
+
+       /* we need to allocate the command buffer without knowing the maximum
+        * size of the reports. Let's use HID_MIN_BUFFER_SIZE, then we do the
+        * real computation later. */
+       ret = i2c_hid_alloc_buffers(ihid, HID_MIN_BUFFER_SIZE);
+       if (ret < 0)
+               goto err_regulator;
+
+       i2c_hid_acpi_fix_up_power(&client->dev);
+
+       pm_runtime_get_noresume(&client->dev);
+       pm_runtime_set_active(&client->dev);
+       pm_runtime_enable(&client->dev);
+       device_enable_async_suspend(&client->dev);
+
+       /* Make sure there is something at this address */
+       ret = i2c_smbus_read_byte(client);
+       if (ret < 0) {
+               dev_dbg(&client->dev, "nothing at this address: %d\n", ret);
+               ret = -ENXIO;
+               goto err_pm;
+       }
+
+       ret = i2c_hid_fetch_hid_descriptor(ihid);
+       if (ret < 0)
+               goto err_pm;
+
+       ret = i2c_hid_init_irq(client);
+       if (ret < 0)
+               goto err_pm;
+
+       hid = hid_allocate_device();
+       if (IS_ERR(hid)) {
+               ret = PTR_ERR(hid);
+               goto err_irq;
+       }
+
+       ihid->hid = hid;
+
+       hid->driver_data = client;
+       hid->ll_driver = &i2c_hid_ll_driver;
+       hid->dev.parent = &client->dev;
+       hid->bus = BUS_I2C;
+       hid->version = le16_to_cpu(ihid->hdesc.bcdVersion);
+       hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID);
+       hid->product = le16_to_cpu(ihid->hdesc.wProductID);
+
+       snprintf(hid->name, sizeof(hid->name), "%s %04hX:%04hX",
+                client->name, hid->vendor, hid->product);
+       strlcpy(hid->phys, dev_name(&client->dev), sizeof(hid->phys));
+
+       ihid->quirks = i2c_hid_lookup_quirk(hid->vendor, hid->product);
+
+       ret = hid_add_device(hid);
+       if (ret) {
+               if (ret != -ENODEV)
+                       hid_err(client, "can't add hid device: %d\n", ret);
+               goto err_mem_free;
+       }
+
+       pm_runtime_put(&client->dev);
+       return 0;
+
+err_mem_free:
+       hid_destroy_device(hid);
+
+err_irq:
+       free_irq(client->irq, ihid);
+
+err_pm:
+       pm_runtime_put_noidle(&client->dev);
+       pm_runtime_disable(&client->dev);
+
+err_regulator:
+       regulator_disable(ihid->pdata.supply);
+
+err:
+       i2c_hid_free_buffers(ihid);
+       kfree(ihid);
+       return ret;
+}
+
+static int i2c_hid_remove(struct i2c_client *client)
+{
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       struct hid_device *hid;
+
+       pm_runtime_get_sync(&client->dev);
+       pm_runtime_disable(&client->dev);
+       pm_runtime_set_suspended(&client->dev);
+       pm_runtime_put_noidle(&client->dev);
+
+       hid = ihid->hid;
+       hid_destroy_device(hid);
+
+       free_irq(client->irq, ihid);
+
+       if (ihid->bufsize)
+               i2c_hid_free_buffers(ihid);
+
+       regulator_disable(ihid->pdata.supply);
+
+       kfree(ihid);
+
+       return 0;
+}
+
+static void i2c_hid_shutdown(struct i2c_client *client)
+{
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+
+       i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
+       free_irq(client->irq, ihid);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int i2c_hid_suspend(struct device *dev)
+{
+       struct i2c_client *client = to_i2c_client(dev);
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       struct hid_device *hid = ihid->hid;
+       int ret;
+       int wake_status;
+
+       if (hid->driver && hid->driver->suspend) {
+               /*
+                * Wake up the device so that IO issues in
+                * HID driver's suspend code can succeed.
+                */
+               ret = pm_runtime_resume(dev);
+               if (ret < 0)
+                       return ret;
+
+               ret = hid->driver->suspend(hid, PMSG_SUSPEND);
+               if (ret < 0)
+                       return ret;
+       }
+
+       if (!pm_runtime_suspended(dev)) {
+               /* Save some power */
+               i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
+
+               disable_irq(client->irq);
+       }
+
+       if (device_may_wakeup(&client->dev)) {
+               wake_status = enable_irq_wake(client->irq);
+               if (!wake_status)
+                       ihid->irq_wake_enabled = true;
+               else
+                       hid_warn(hid, "Failed to enable irq wake: %d\n",
+                               wake_status);
+       } else {
+               ret = regulator_disable(ihid->pdata.supply);
+               if (ret < 0)
+                       hid_warn(hid, "Failed to disable supply: %d\n", ret);
+       }
+
+       return 0;
+}
+
+static int i2c_hid_resume(struct device *dev)
+{
+       int ret;
+       struct i2c_client *client = to_i2c_client(dev);
+       struct i2c_hid *ihid = i2c_get_clientdata(client);
+       struct hid_device *hid = ihid->hid;
+       int wake_status;
+
+       if (!device_may_wakeup(&client->dev)) {
+               ret = regulator_enable(ihid->pdata.supply);
+               if (ret < 0)
+                       hid_warn(hid, "Failed to enable supply: %d\n", ret);
+               if (ihid->pdata.post_power_delay_ms)
+                       msleep(ihid->pdata.post_power_delay_ms);
+       } else if (ihid->irq_wake_enabled) {
+               wake_status = disable_irq_wake(client->irq);
+               if (!wake_status)
+                       ihid->irq_wake_enabled = false;
+               else
+                       hid_warn(hid, "Failed to disable irq wake: %d\n",
+                               wake_status);
+       }
+
+       /* We'll resume to full power */
+       pm_runtime_disable(dev);
+       pm_runtime_set_active(dev);
+       pm_runtime_enable(dev);
+
+       enable_irq(client->irq);
+       ret = i2c_hid_hwreset(client);
+       if (ret)
+               return ret;
+
+       if (hid->driver && hid->driver->reset_resume) {
+               ret = hid->driver->reset_resume(hid);
+               return ret;
+       }
+
+       return 0;
+}
+#endif
+
+#ifdef CONFIG_PM
+static int i2c_hid_runtime_suspend(struct device *dev)
+{
+       struct i2c_client *client = to_i2c_client(dev);
+
+       i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
+       disable_irq(client->irq);
+       return 0;
+}
+
+static int i2c_hid_runtime_resume(struct device *dev)
+{
+       struct i2c_client *client = to_i2c_client(dev);
+
+       enable_irq(client->irq);
+       i2c_hid_set_power(client, I2C_HID_PWR_ON);
+       return 0;
+}
+#endif
+
+static const struct dev_pm_ops i2c_hid_pm = {
+       SET_SYSTEM_SLEEP_PM_OPS(i2c_hid_suspend, i2c_hid_resume)
+       SET_RUNTIME_PM_OPS(i2c_hid_runtime_suspend, i2c_hid_runtime_resume,
+                          NULL)
+};
+
+static const struct i2c_device_id i2c_hid_id_table[] = {
+       { "hid", 0 },
+       { "hid-over-i2c", 0 },
+       { },
+};
+MODULE_DEVICE_TABLE(i2c, i2c_hid_id_table);
+
+
+static struct i2c_driver i2c_hid_driver = {
+       .driver = {
+               .name   = "i2c_hid",
+               .pm     = &i2c_hid_pm,
+               .acpi_match_table = ACPI_PTR(i2c_hid_acpi_match),
+               .of_match_table = of_match_ptr(i2c_hid_of_match),
+       },
+
+       .probe          = i2c_hid_probe,
+       .remove         = i2c_hid_remove,
+       .shutdown       = i2c_hid_shutdown,
+       .id_table       = i2c_hid_id_table,
+};
+
+module_i2c_driver(i2c_hid_driver);
+
+MODULE_DESCRIPTION("HID over I2C core driver");
+MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c b/drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c
new file mode 100644 (file)
index 0000000..1d645c9
--- /dev/null
@@ -0,0 +1,376 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+/*
+ * Quirks for I2C-HID devices that do not supply proper descriptors
+ *
+ * Copyright (c) 2018 Julian Sax <jsbc@gmx.de>
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/dmi.h>
+#include <linux/mod_devicetable.h>
+
+#include "i2c-hid.h"
+
+
+struct i2c_hid_desc_override {
+       union {
+               struct i2c_hid_desc *i2c_hid_desc;
+               uint8_t             *i2c_hid_desc_buffer;
+       };
+       uint8_t              *hid_report_desc;
+       unsigned int          hid_report_desc_size;
+       uint8_t              *i2c_name;
+};
+
+
+/*
+ * descriptors for the SIPODEV SP1064 touchpad
+ *
+ * This device does not supply any descriptors and on windows a filter
+ * driver operates between the i2c-hid layer and the device and injects
+ * these descriptors when the device is prompted. The descriptors were
+ * extracted by listening to the i2c-hid traffic that occurs between the
+ * windows filter driver and the windows i2c-hid driver.
+ */
+
+static const struct i2c_hid_desc_override sipodev_desc = {
+       .i2c_hid_desc_buffer = (uint8_t [])
+       {0x1e, 0x00,                  /* Length of descriptor                 */
+        0x00, 0x01,                  /* Version of descriptor                */
+        0xdb, 0x01,                  /* Length of report descriptor          */
+        0x21, 0x00,                  /* Location of report descriptor        */
+        0x24, 0x00,                  /* Location of input report             */
+        0x1b, 0x00,                  /* Max input report length              */
+        0x25, 0x00,                  /* Location of output report            */
+        0x11, 0x00,                  /* Max output report length             */
+        0x22, 0x00,                  /* Location of command register         */
+        0x23, 0x00,                  /* Location of data register            */
+        0x11, 0x09,                  /* Vendor ID                            */
+        0x88, 0x52,                  /* Product ID                           */
+        0x06, 0x00,                  /* Version ID                           */
+        0x00, 0x00, 0x00, 0x00       /* Reserved                             */
+       },
+
+       .hid_report_desc = (uint8_t [])
+       {0x05, 0x01,                  /* Usage Page (Desktop),                */
+        0x09, 0x02,                  /* Usage (Mouse),                       */
+        0xA1, 0x01,                  /* Collection (Application),            */
+        0x85, 0x01,                  /*     Report ID (1),                   */
+        0x09, 0x01,                  /*     Usage (Pointer),                 */
+        0xA1, 0x00,                  /*     Collection (Physical),           */
+        0x05, 0x09,                  /*         Usage Page (Button),         */
+        0x19, 0x01,                  /*         Usage Minimum (01h),         */
+        0x29, 0x02,                  /*         Usage Maximum (02h),         */
+        0x25, 0x01,                  /*         Logical Maximum (1),         */
+        0x75, 0x01,                  /*         Report Size (1),             */
+        0x95, 0x02,                  /*         Report Count (2),            */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x95, 0x06,                  /*         Report Count (6),            */
+        0x81, 0x01,                  /*         Input (Constant),            */
+        0x05, 0x01,                  /*         Usage Page (Desktop),        */
+        0x09, 0x30,                  /*         Usage (X),                   */
+        0x09, 0x31,                  /*         Usage (Y),                   */
+        0x15, 0x81,                  /*         Logical Minimum (-127),      */
+        0x25, 0x7F,                  /*         Logical Maximum (127),       */
+        0x75, 0x08,                  /*         Report Size (8),             */
+        0x95, 0x02,                  /*         Report Count (2),            */
+        0x81, 0x06,                  /*         Input (Variable, Relative),  */
+        0xC0,                        /*     End Collection,                  */
+        0xC0,                        /* End Collection,                      */
+        0x05, 0x0D,                  /* Usage Page (Digitizer),              */
+        0x09, 0x05,                  /* Usage (Touchpad),                    */
+        0xA1, 0x01,                  /* Collection (Application),            */
+        0x85, 0x04,                  /*     Report ID (4),                   */
+        0x05, 0x0D,                  /*     Usage Page (Digitizer),          */
+        0x09, 0x22,                  /*     Usage (Finger),                  */
+        0xA1, 0x02,                  /*     Collection (Logical),            */
+        0x15, 0x00,                  /*         Logical Minimum (0),         */
+        0x25, 0x01,                  /*         Logical Maximum (1),         */
+        0x09, 0x47,                  /*         Usage (Touch Valid),         */
+        0x09, 0x42,                  /*         Usage (Tip Switch),          */
+        0x95, 0x02,                  /*         Report Count (2),            */
+        0x75, 0x01,                  /*         Report Size (1),             */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x95, 0x01,                  /*         Report Count (1),            */
+        0x75, 0x03,                  /*         Report Size (3),             */
+        0x25, 0x05,                  /*         Logical Maximum (5),         */
+        0x09, 0x51,                  /*         Usage (Contact Identifier),  */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x75, 0x01,                  /*         Report Size (1),             */
+        0x95, 0x03,                  /*         Report Count (3),            */
+        0x81, 0x03,                  /*         Input (Constant, Variable),  */
+        0x05, 0x01,                  /*         Usage Page (Desktop),        */
+        0x26, 0x44, 0x0A,            /*         Logical Maximum (2628),      */
+        0x75, 0x10,                  /*         Report Size (16),            */
+        0x55, 0x0E,                  /*         Unit Exponent (14),          */
+        0x65, 0x11,                  /*         Unit (Centimeter),           */
+        0x09, 0x30,                  /*         Usage (X),                   */
+        0x46, 0x1A, 0x04,            /*         Physical Maximum (1050),     */
+        0x95, 0x01,                  /*         Report Count (1),            */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x46, 0xBC, 0x02,            /*         Physical Maximum (700),      */
+        0x26, 0x34, 0x05,            /*         Logical Maximum (1332),      */
+        0x09, 0x31,                  /*         Usage (Y),                   */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0xC0,                        /*     End Collection,                  */
+        0x05, 0x0D,                  /*     Usage Page (Digitizer),          */
+        0x09, 0x22,                  /*     Usage (Finger),                  */
+        0xA1, 0x02,                  /*     Collection (Logical),            */
+        0x25, 0x01,                  /*         Logical Maximum (1),         */
+        0x09, 0x47,                  /*         Usage (Touch Valid),         */
+        0x09, 0x42,                  /*         Usage (Tip Switch),          */
+        0x95, 0x02,                  /*         Report Count (2),            */
+        0x75, 0x01,                  /*         Report Size (1),             */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x95, 0x01,                  /*         Report Count (1),            */
+        0x75, 0x03,                  /*         Report Size (3),             */
+        0x25, 0x05,                  /*         Logical Maximum (5),         */
+        0x09, 0x51,                  /*         Usage (Contact Identifier),  */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x75, 0x01,                  /*         Report Size (1),             */
+        0x95, 0x03,                  /*         Report Count (3),            */
+        0x81, 0x03,                  /*         Input (Constant, Variable),  */
+        0x05, 0x01,                  /*         Usage Page (Desktop),        */
+        0x26, 0x44, 0x0A,            /*         Logical Maximum (2628),      */
+        0x75, 0x10,                  /*         Report Size (16),            */
+        0x09, 0x30,                  /*         Usage (X),                   */
+        0x46, 0x1A, 0x04,            /*         Physical Maximum (1050),     */
+        0x95, 0x01,                  /*         Report Count (1),            */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x46, 0xBC, 0x02,            /*         Physical Maximum (700),      */
+        0x26, 0x34, 0x05,            /*         Logical Maximum (1332),      */
+        0x09, 0x31,                  /*         Usage (Y),                   */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0xC0,                        /*     End Collection,                  */
+        0x05, 0x0D,                  /*     Usage Page (Digitizer),          */
+        0x09, 0x22,                  /*     Usage (Finger),                  */
+        0xA1, 0x02,                  /*     Collection (Logical),            */
+        0x25, 0x01,                  /*         Logical Maximum (1),         */
+        0x09, 0x47,                  /*         Usage (Touch Valid),         */
+        0x09, 0x42,                  /*         Usage (Tip Switch),          */
+        0x95, 0x02,                  /*         Report Count (2),            */
+        0x75, 0x01,                  /*         Report Size (1),             */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x95, 0x01,                  /*         Report Count (1),            */
+        0x75, 0x03,                  /*         Report Size (3),             */
+        0x25, 0x05,                  /*         Logical Maximum (5),         */
+        0x09, 0x51,                  /*         Usage (Contact Identifier),  */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x75, 0x01,                  /*         Report Size (1),             */
+        0x95, 0x03,                  /*         Report Count (3),            */
+        0x81, 0x03,                  /*         Input (Constant, Variable),  */
+        0x05, 0x01,                  /*         Usage Page (Desktop),        */
+        0x26, 0x44, 0x0A,            /*         Logical Maximum (2628),      */
+        0x75, 0x10,                  /*         Report Size (16),            */
+        0x09, 0x30,                  /*         Usage (X),                   */
+        0x46, 0x1A, 0x04,            /*         Physical Maximum (1050),     */
+        0x95, 0x01,                  /*         Report Count (1),            */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x46, 0xBC, 0x02,            /*         Physical Maximum (700),      */
+        0x26, 0x34, 0x05,            /*         Logical Maximum (1332),      */
+        0x09, 0x31,                  /*         Usage (Y),                   */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0xC0,                        /*     End Collection,                  */
+        0x05, 0x0D,                  /*     Usage Page (Digitizer),          */
+        0x09, 0x22,                  /*     Usage (Finger),                  */
+        0xA1, 0x02,                  /*     Collection (Logical),            */
+        0x25, 0x01,                  /*         Logical Maximum (1),         */
+        0x09, 0x47,                  /*         Usage (Touch Valid),         */
+        0x09, 0x42,                  /*         Usage (Tip Switch),          */
+        0x95, 0x02,                  /*         Report Count (2),            */
+        0x75, 0x01,                  /*         Report Size (1),             */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x95, 0x01,                  /*         Report Count (1),            */
+        0x75, 0x03,                  /*         Report Size (3),             */
+        0x25, 0x05,                  /*         Logical Maximum (5),         */
+        0x09, 0x51,                  /*         Usage (Contact Identifier),  */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x75, 0x01,                  /*         Report Size (1),             */
+        0x95, 0x03,                  /*         Report Count (3),            */
+        0x81, 0x03,                  /*         Input (Constant, Variable),  */
+        0x05, 0x01,                  /*         Usage Page (Desktop),        */
+        0x26, 0x44, 0x0A,            /*         Logical Maximum (2628),      */
+        0x75, 0x10,                  /*         Report Size (16),            */
+        0x09, 0x30,                  /*         Usage (X),                   */
+        0x46, 0x1A, 0x04,            /*         Physical Maximum (1050),     */
+        0x95, 0x01,                  /*         Report Count (1),            */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0x46, 0xBC, 0x02,            /*         Physical Maximum (700),      */
+        0x26, 0x34, 0x05,            /*         Logical Maximum (1332),      */
+        0x09, 0x31,                  /*         Usage (Y),                   */
+        0x81, 0x02,                  /*         Input (Variable),            */
+        0xC0,                        /*     End Collection,                  */
+        0x05, 0x0D,                  /*     Usage Page (Digitizer),          */
+        0x55, 0x0C,                  /*     Unit Exponent (12),              */
+        0x66, 0x01, 0x10,            /*     Unit (Seconds),                  */
+        0x47, 0xFF, 0xFF, 0x00, 0x00,/*     Physical Maximum (65535),        */
+        0x27, 0xFF, 0xFF, 0x00, 0x00,/*     Logical Maximum (65535),         */
+        0x75, 0x10,                  /*     Report Size (16),                */
+        0x95, 0x01,                  /*     Report Count (1),                */
+        0x09, 0x56,                  /*     Usage (Scan Time),               */
+        0x81, 0x02,                  /*     Input (Variable),                */
+        0x09, 0x54,                  /*     Usage (Contact Count),           */
+        0x25, 0x7F,                  /*     Logical Maximum (127),           */
+        0x75, 0x08,                  /*     Report Size (8),                 */
+        0x81, 0x02,                  /*     Input (Variable),                */
+        0x05, 0x09,                  /*     Usage Page (Button),             */
+        0x09, 0x01,                  /*     Usage (01h),                     */
+        0x25, 0x01,                  /*     Logical Maximum (1),             */
+        0x75, 0x01,                  /*     Report Size (1),                 */
+        0x95, 0x01,                  /*     Report Count (1),                */
+        0x81, 0x02,                  /*     Input (Variable),                */
+        0x95, 0x07,                  /*     Report Count (7),                */
+        0x81, 0x03,                  /*     Input (Constant, Variable),      */
+        0x05, 0x0D,                  /*     Usage Page (Digitizer),          */
+        0x85, 0x02,                  /*     Report ID (2),                   */
+        0x09, 0x55,                  /*     Usage (Contact Count Maximum),   */
+        0x09, 0x59,                  /*     Usage (59h),                     */
+        0x75, 0x04,                  /*     Report Size (4),                 */
+        0x95, 0x02,                  /*     Report Count (2),                */
+        0x25, 0x0F,                  /*     Logical Maximum (15),            */
+        0xB1, 0x02,                  /*     Feature (Variable),              */
+        0x05, 0x0D,                  /*     Usage Page (Digitizer),          */
+        0x85, 0x07,                  /*     Report ID (7),                   */
+        0x09, 0x60,                  /*     Usage (60h),                     */
+        0x75, 0x01,                  /*     Report Size (1),                 */
+        0x95, 0x01,                  /*     Report Count (1),                */
+        0x25, 0x01,                  /*     Logical Maximum (1),             */
+        0xB1, 0x02,                  /*     Feature (Variable),              */
+        0x95, 0x07,                  /*     Report Count (7),                */
+        0xB1, 0x03,                  /*     Feature (Constant, Variable),    */
+        0x85, 0x06,                  /*     Report ID (6),                   */
+        0x06, 0x00, 0xFF,            /*     Usage Page (FF00h),              */
+        0x09, 0xC5,                  /*     Usage (C5h),                     */
+        0x26, 0xFF, 0x00,            /*     Logical Maximum (255),           */
+        0x75, 0x08,                  /*     Report Size (8),                 */
+        0x96, 0x00, 0x01,            /*     Report Count (256),              */
+        0xB1, 0x02,                  /*     Feature (Variable),              */
+        0xC0,                        /* End Collection,                      */
+        0x06, 0x00, 0xFF,            /* Usage Page (FF00h),                  */
+        0x09, 0x01,                  /* Usage (01h),                         */
+        0xA1, 0x01,                  /* Collection (Application),            */
+        0x85, 0x0D,                  /*     Report ID (13),                  */
+        0x26, 0xFF, 0x00,            /*     Logical Maximum (255),           */
+        0x19, 0x01,                  /*     Usage Minimum (01h),             */
+        0x29, 0x02,                  /*     Usage Maximum (02h),             */
+        0x75, 0x08,                  /*     Report Size (8),                 */
+        0x95, 0x02,                  /*     Report Count (2),                */
+        0xB1, 0x02,                  /*     Feature (Variable),              */
+        0xC0,                        /* End Collection,                      */
+        0x05, 0x0D,                  /* Usage Page (Digitizer),              */
+        0x09, 0x0E,                  /* Usage (Configuration),               */
+        0xA1, 0x01,                  /* Collection (Application),            */
+        0x85, 0x03,                  /*     Report ID (3),                   */
+        0x09, 0x22,                  /*     Usage (Finger),                  */
+        0xA1, 0x02,                  /*     Collection (Logical),            */
+        0x09, 0x52,                  /*         Usage (Device Mode),         */
+        0x25, 0x0A,                  /*         Logical Maximum (10),        */
+        0x95, 0x01,                  /*         Report Count (1),            */
+        0xB1, 0x02,                  /*         Feature (Variable),          */
+        0xC0,                        /*     End Collection,                  */
+        0x09, 0x22,                  /*     Usage (Finger),                  */
+        0xA1, 0x00,                  /*     Collection (Physical),           */
+        0x85, 0x05,                  /*         Report ID (5),               */
+        0x09, 0x57,                  /*         Usage (57h),                 */
+        0x09, 0x58,                  /*         Usage (58h),                 */
+        0x75, 0x01,                  /*         Report Size (1),             */
+        0x95, 0x02,                  /*         Report Count (2),            */
+        0x25, 0x01,                  /*         Logical Maximum (1),         */
+        0xB1, 0x02,                  /*         Feature (Variable),          */
+        0x95, 0x06,                  /*         Report Count (6),            */
+        0xB1, 0x03,                  /*         Feature (Constant, Variable),*/
+        0xC0,                        /*     End Collection,                  */
+        0xC0                         /* End Collection                       */
+       },
+       .hid_report_desc_size = 475,
+       .i2c_name = "SYNA3602:00"
+};
+
+
+static const struct dmi_system_id i2c_hid_dmi_desc_override_table[] = {
+       {
+               .ident = "Teclast F6 Pro",
+               .matches = {
+                       DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TECLAST"),
+                       DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "F6 Pro"),
+               },
+               .driver_data = (void *)&sipodev_desc
+       },
+       {
+               .ident = "Teclast F7",
+               .matches = {
+                       DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TECLAST"),
+                       DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "F7"),
+               },
+               .driver_data = (void *)&sipodev_desc
+       },
+       {
+               .ident = "Trekstor Primebook C13",
+               .matches = {
+                       DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TREKSTOR"),
+                       DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Primebook C13"),
+               },
+               .driver_data = (void *)&sipodev_desc
+       },
+       {
+               .ident = "Trekstor Primebook C11",
+               .matches = {
+                       DMI_EXACT_MATCH(DMI_SYS_VENDOR, "TREKSTOR"),
+                       DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Primebook C11"),
+               },
+               .driver_data = (void *)&sipodev_desc
+       },
+       {
+               .ident = "Direkt-Tek DTLAPY116-2",
+               .matches = {
+                       DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Direkt-Tek"),
+                       DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "DTLAPY116-2"),
+               },
+               .driver_data = (void *)&sipodev_desc
+       },
+       {
+               .ident = "Mediacom Flexbook Edge 11",
+               .matches = {
+                       DMI_EXACT_MATCH(DMI_SYS_VENDOR, "MEDIACOM"),
+                       DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "FlexBook edge11 - M-FBE11"),
+               },
+               .driver_data = (void *)&sipodev_desc
+       }
+};
+
+
+struct i2c_hid_desc *i2c_hid_get_dmi_i2c_hid_desc_override(uint8_t *i2c_name)
+{
+       struct i2c_hid_desc_override *override;
+       const struct dmi_system_id *system_id;
+
+       system_id = dmi_first_match(i2c_hid_dmi_desc_override_table);
+       if (!system_id)
+               return NULL;
+
+       override = system_id->driver_data;
+       if (strcmp(override->i2c_name, i2c_name))
+               return NULL;
+
+       return override->i2c_hid_desc;
+}
+
+char *i2c_hid_get_dmi_hid_report_desc_override(uint8_t *i2c_name,
+                                              unsigned int *size)
+{
+       struct i2c_hid_desc_override *override;
+       const struct dmi_system_id *system_id;
+
+       system_id = dmi_first_match(i2c_hid_dmi_desc_override_table);
+       if (!system_id)
+               return NULL;
+
+       override = system_id->driver_data;
+       if (strcmp(override->i2c_name, i2c_name))
+               return NULL;
+
+       *size = override->hid_report_desc_size;
+       return override->hid_report_desc;
+}
diff --git a/drivers/hid/i2c-hid/i2c-hid.c b/drivers/hid/i2c-hid/i2c-hid.c
deleted file mode 100644 (file)
index 136a34d..0000000
+++ /dev/null
@@ -1,1279 +0,0 @@
-/*
- * HID over I2C protocol implementation
- *
- * Copyright (c) 2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
- * Copyright (c) 2012 Ecole Nationale de l'Aviation Civile, France
- * Copyright (c) 2012 Red Hat, Inc
- *
- * This code is partly based on "USB HID support for Linux":
- *
- *  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) 2007-2008 Oliver Neukum
- *  Copyright (c) 2006-2010 Jiri Kosina
- *
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file COPYING in the main directory of this archive for
- * more details.
- */
-
-#include <linux/module.h>
-#include <linux/i2c.h>
-#include <linux/interrupt.h>
-#include <linux/input.h>
-#include <linux/irq.h>
-#include <linux/delay.h>
-#include <linux/slab.h>
-#include <linux/pm.h>
-#include <linux/pm_runtime.h>
-#include <linux/device.h>
-#include <linux/wait.h>
-#include <linux/err.h>
-#include <linux/string.h>
-#include <linux/list.h>
-#include <linux/jiffies.h>
-#include <linux/kernel.h>
-#include <linux/hid.h>
-#include <linux/mutex.h>
-#include <linux/acpi.h>
-#include <linux/of.h>
-#include <linux/regulator/consumer.h>
-
-#include <linux/platform_data/i2c-hid.h>
-
-#include "../hid-ids.h"
-
-/* quirks to control the device */
-#define I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV       BIT(0)
-
-/* flags */
-#define I2C_HID_STARTED                0
-#define I2C_HID_RESET_PENDING  1
-#define I2C_HID_READ_PENDING   2
-
-#define I2C_HID_PWR_ON         0x00
-#define I2C_HID_PWR_SLEEP      0x01
-
-/* debug option */
-static bool debug;
-module_param(debug, bool, 0444);
-MODULE_PARM_DESC(debug, "print a lot of debug information");
-
-#define i2c_hid_dbg(ihid, fmt, arg...)                                   \
-do {                                                                     \
-       if (debug)                                                        \
-               dev_printk(KERN_DEBUG, &(ihid)->client->dev, fmt, ##arg); \
-} while (0)
-
-struct i2c_hid_desc {
-       __le16 wHIDDescLength;
-       __le16 bcdVersion;
-       __le16 wReportDescLength;
-       __le16 wReportDescRegister;
-       __le16 wInputRegister;
-       __le16 wMaxInputLength;
-       __le16 wOutputRegister;
-       __le16 wMaxOutputLength;
-       __le16 wCommandRegister;
-       __le16 wDataRegister;
-       __le16 wVendorID;
-       __le16 wProductID;
-       __le16 wVersionID;
-       __le32 reserved;
-} __packed;
-
-struct i2c_hid_cmd {
-       unsigned int registerIndex;
-       __u8 opcode;
-       unsigned int length;
-       bool wait;
-};
-
-union command {
-       u8 data[0];
-       struct cmd {
-               __le16 reg;
-               __u8 reportTypeID;
-               __u8 opcode;
-       } __packed c;
-};
-
-#define I2C_HID_CMD(opcode_) \
-       .opcode = opcode_, .length = 4, \
-       .registerIndex = offsetof(struct i2c_hid_desc, wCommandRegister)
-
-/* fetch HID descriptor */
-static const struct i2c_hid_cmd hid_descr_cmd = { .length = 2 };
-/* fetch report descriptors */
-static const struct i2c_hid_cmd hid_report_descr_cmd = {
-               .registerIndex = offsetof(struct i2c_hid_desc,
-                       wReportDescRegister),
-               .opcode = 0x00,
-               .length = 2 };
-/* commands */
-static const struct i2c_hid_cmd hid_reset_cmd =                { I2C_HID_CMD(0x01),
-                                                         .wait = true };
-static const struct i2c_hid_cmd hid_get_report_cmd =   { I2C_HID_CMD(0x02) };
-static const struct i2c_hid_cmd hid_set_report_cmd =   { I2C_HID_CMD(0x03) };
-static const struct i2c_hid_cmd hid_set_power_cmd =    { I2C_HID_CMD(0x08) };
-static const struct i2c_hid_cmd hid_no_cmd =           { .length = 0 };
-
-/*
- * These definitions are not used here, but are defined by the spec.
- * Keeping them here for documentation purposes.
- *
- * static const struct i2c_hid_cmd hid_get_idle_cmd = { I2C_HID_CMD(0x04) };
- * static const struct i2c_hid_cmd hid_set_idle_cmd = { I2C_HID_CMD(0x05) };
- * static const struct i2c_hid_cmd hid_get_protocol_cmd = { I2C_HID_CMD(0x06) };
- * 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 */
-       struct hid_device       *hid;   /* pointer to corresponding HID dev */
-       union {
-               __u8 hdesc_buffer[sizeof(struct i2c_hid_desc)];
-               struct i2c_hid_desc hdesc;      /* the HID Descriptor */
-       };
-       __le16                  wHIDDescRegister; /* location of the i2c
-                                                  * register of the HID
-                                                  * descriptor. */
-       unsigned int            bufsize;        /* i2c buffer size */
-       u8                      *inbuf;         /* Input buffer */
-       u8                      *rawbuf;        /* Raw Input buffer */
-       u8                      *cmdbuf;        /* Command buffer */
-       u8                      *argsbuf;       /* Command arguments buffer */
-
-       unsigned long           flags;          /* device flags */
-       unsigned long           quirks;         /* Various quirks */
-
-       wait_queue_head_t       wait;           /* For waiting the interrupt */
-
-       struct i2c_hid_platform_data pdata;
-
-       bool                    irq_wake_enabled;
-       struct mutex            reset_lock;
-};
-
-static const struct i2c_hid_quirks {
-       __u16 idVendor;
-       __u16 idProduct;
-       __u32 quirks;
-} i2c_hid_quirks[] = {
-       { USB_VENDOR_ID_WEIDA, USB_DEVICE_ID_WEIDA_8752,
-               I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV },
-       { USB_VENDOR_ID_WEIDA, USB_DEVICE_ID_WEIDA_8755,
-               I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV },
-       { 0, 0 }
-};
-
-/*
- * i2c_hid_lookup_quirk: return any quirks associated with a I2C HID device
- * @idVendor: the 16-bit vendor ID
- * @idProduct: the 16-bit product ID
- *
- * Returns: a u32 quirks value.
- */
-static u32 i2c_hid_lookup_quirk(const u16 idVendor, const u16 idProduct)
-{
-       u32 quirks = 0;
-       int n;
-
-       for (n = 0; i2c_hid_quirks[n].idVendor; n++)
-               if (i2c_hid_quirks[n].idVendor == idVendor &&
-                   (i2c_hid_quirks[n].idProduct == (__u16)HID_ANY_ID ||
-                    i2c_hid_quirks[n].idProduct == idProduct))
-                       quirks = i2c_hid_quirks[n].quirks;
-
-       return quirks;
-}
-
-static int __i2c_hid_command(struct i2c_client *client,
-               const struct i2c_hid_cmd *command, u8 reportID,
-               u8 reportType, u8 *args, int args_len,
-               unsigned char *buf_recv, int data_len)
-{
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       union command *cmd = (union command *)ihid->cmdbuf;
-       int ret;
-       struct i2c_msg msg[2];
-       int msg_num = 1;
-
-       int length = command->length;
-       bool wait = command->wait;
-       unsigned int registerIndex = command->registerIndex;
-
-       /* special case for hid_descr_cmd */
-       if (command == &hid_descr_cmd) {
-               cmd->c.reg = ihid->wHIDDescRegister;
-       } else {
-               cmd->data[0] = ihid->hdesc_buffer[registerIndex];
-               cmd->data[1] = ihid->hdesc_buffer[registerIndex + 1];
-       }
-
-       if (length > 2) {
-               cmd->c.opcode = command->opcode;
-               cmd->c.reportTypeID = reportID | reportType << 4;
-       }
-
-       memcpy(cmd->data + length, args, args_len);
-       length += args_len;
-
-       i2c_hid_dbg(ihid, "%s: cmd=%*ph\n", __func__, length, cmd->data);
-
-       msg[0].addr = client->addr;
-       msg[0].flags = client->flags & I2C_M_TEN;
-       msg[0].len = length;
-       msg[0].buf = cmd->data;
-       if (data_len > 0) {
-               msg[1].addr = client->addr;
-               msg[1].flags = client->flags & I2C_M_TEN;
-               msg[1].flags |= I2C_M_RD;
-               msg[1].len = data_len;
-               msg[1].buf = buf_recv;
-               msg_num = 2;
-               set_bit(I2C_HID_READ_PENDING, &ihid->flags);
-       }
-
-       if (wait)
-               set_bit(I2C_HID_RESET_PENDING, &ihid->flags);
-
-       ret = i2c_transfer(client->adapter, msg, msg_num);
-
-       if (data_len > 0)
-               clear_bit(I2C_HID_READ_PENDING, &ihid->flags);
-
-       if (ret != msg_num)
-               return ret < 0 ? ret : -EIO;
-
-       ret = 0;
-
-       if (wait) {
-               i2c_hid_dbg(ihid, "%s: waiting...\n", __func__);
-               if (!wait_event_timeout(ihid->wait,
-                               !test_bit(I2C_HID_RESET_PENDING, &ihid->flags),
-                               msecs_to_jiffies(5000)))
-                       ret = -ENODATA;
-               i2c_hid_dbg(ihid, "%s: finished.\n", __func__);
-       }
-
-       return ret;
-}
-
-static int i2c_hid_command(struct i2c_client *client,
-               const struct i2c_hid_cmd *command,
-               unsigned char *buf_recv, int data_len)
-{
-       return __i2c_hid_command(client, command, 0, 0, NULL, 0,
-                               buf_recv, data_len);
-}
-
-static int i2c_hid_get_report(struct i2c_client *client, u8 reportType,
-               u8 reportID, unsigned char *buf_recv, int data_len)
-{
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       u8 args[3];
-       int ret;
-       int args_len = 0;
-       u16 readRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
-
-       i2c_hid_dbg(ihid, "%s\n", __func__);
-
-       if (reportID >= 0x0F) {
-               args[args_len++] = reportID;
-               reportID = 0x0F;
-       }
-
-       args[args_len++] = readRegister & 0xFF;
-       args[args_len++] = readRegister >> 8;
-
-       ret = __i2c_hid_command(client, &hid_get_report_cmd, reportID,
-               reportType, args, args_len, buf_recv, data_len);
-       if (ret) {
-               dev_err(&client->dev,
-                       "failed to retrieve report from device.\n");
-               return ret;
-       }
-
-       return 0;
-}
-
-/**
- * i2c_hid_set_or_send_report: forward an incoming report to the device
- * @client: the i2c_client of the device
- * @reportType: 0x03 for HID_FEATURE_REPORT ; 0x02 for HID_OUTPUT_REPORT
- * @reportID: the report ID
- * @buf: the actual data to transfer, without the report ID
- * @len: size of buf
- * @use_data: true: use SET_REPORT HID command, false: send plain OUTPUT report
- */
-static int i2c_hid_set_or_send_report(struct i2c_client *client, u8 reportType,
-               u8 reportID, unsigned char *buf, size_t data_len, bool use_data)
-{
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       u8 *args = ihid->argsbuf;
-       const struct i2c_hid_cmd *hidcmd;
-       int ret;
-       u16 dataRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
-       u16 outputRegister = le16_to_cpu(ihid->hdesc.wOutputRegister);
-       u16 maxOutputLength = le16_to_cpu(ihid->hdesc.wMaxOutputLength);
-       u16 size;
-       int args_len;
-       int index = 0;
-
-       i2c_hid_dbg(ihid, "%s\n", __func__);
-
-       if (data_len > ihid->bufsize)
-               return -EINVAL;
-
-       size =          2                       /* size */ +
-                       (reportID ? 1 : 0)      /* reportID */ +
-                       data_len                /* buf */;
-       args_len =      (reportID >= 0x0F ? 1 : 0) /* optional third byte */ +
-                       2                       /* dataRegister */ +
-                       size                    /* args */;
-
-       if (!use_data && maxOutputLength == 0)
-               return -ENOSYS;
-
-       if (reportID >= 0x0F) {
-               args[index++] = reportID;
-               reportID = 0x0F;
-       }
-
-       /*
-        * use the data register for feature reports or if the device does not
-        * support the output register
-        */
-       if (use_data) {
-               args[index++] = dataRegister & 0xFF;
-               args[index++] = dataRegister >> 8;
-               hidcmd = &hid_set_report_cmd;
-       } else {
-               args[index++] = outputRegister & 0xFF;
-               args[index++] = outputRegister >> 8;
-               hidcmd = &hid_no_cmd;
-       }
-
-       args[index++] = size & 0xFF;
-       args[index++] = size >> 8;
-
-       if (reportID)
-               args[index++] = reportID;
-
-       memcpy(&args[index], buf, data_len);
-
-       ret = __i2c_hid_command(client, hidcmd, reportID,
-               reportType, args, args_len, NULL, 0);
-       if (ret) {
-               dev_err(&client->dev, "failed to set a report to device.\n");
-               return ret;
-       }
-
-       return data_len;
-}
-
-static int i2c_hid_set_power(struct i2c_client *client, int power_state)
-{
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       int ret;
-
-       i2c_hid_dbg(ihid, "%s\n", __func__);
-
-       /*
-        * Some devices require to send a command to wakeup before power on.
-        * The call will get a return value (EREMOTEIO) but device will be
-        * triggered and activated. After that, it goes like a normal device.
-        */
-       if (power_state == I2C_HID_PWR_ON &&
-           ihid->quirks & I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV) {
-               ret = i2c_hid_command(client, &hid_set_power_cmd, NULL, 0);
-
-               /* Device was already activated */
-               if (!ret)
-                       goto set_pwr_exit;
-       }
-
-       ret = __i2c_hid_command(client, &hid_set_power_cmd, power_state,
-               0, NULL, 0, NULL, 0);
-
-       if (ret)
-               dev_err(&client->dev, "failed to change power setting.\n");
-
-set_pwr_exit:
-       return ret;
-}
-
-static int i2c_hid_hwreset(struct i2c_client *client)
-{
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       int ret;
-
-       i2c_hid_dbg(ihid, "%s\n", __func__);
-
-       /*
-        * This prevents sending feature reports while the device is
-        * being reset. Otherwise we may lose the reset complete
-        * interrupt.
-        */
-       mutex_lock(&ihid->reset_lock);
-
-       ret = i2c_hid_set_power(client, I2C_HID_PWR_ON);
-       if (ret)
-               goto out_unlock;
-
-       /*
-        * The HID over I2C specification states that if a DEVICE needs time
-        * after the PWR_ON request, it should utilise CLOCK stretching.
-        * However, it has been observered that the Windows driver provides a
-        * 1ms sleep between the PWR_ON and RESET requests and that some devices
-        * rely on this.
-        */
-       usleep_range(1000, 5000);
-
-       i2c_hid_dbg(ihid, "resetting...\n");
-
-       ret = i2c_hid_command(client, &hid_reset_cmd, NULL, 0);
-       if (ret) {
-               dev_err(&client->dev, "failed to reset device.\n");
-               i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
-       }
-
-out_unlock:
-       mutex_unlock(&ihid->reset_lock);
-       return ret;
-}
-
-static void i2c_hid_get_input(struct i2c_hid *ihid)
-{
-       int ret;
-       u32 ret_size;
-       int size = le16_to_cpu(ihid->hdesc.wMaxInputLength);
-
-       if (size > ihid->bufsize)
-               size = ihid->bufsize;
-
-       ret = i2c_master_recv(ihid->client, ihid->inbuf, size);
-       if (ret != size) {
-               if (ret < 0)
-                       return;
-
-               dev_err(&ihid->client->dev, "%s: got %d data instead of %d\n",
-                       __func__, ret, size);
-               return;
-       }
-
-       ret_size = ihid->inbuf[0] | ihid->inbuf[1] << 8;
-
-       if (!ret_size) {
-               /* host or device initiated RESET completed */
-               if (test_and_clear_bit(I2C_HID_RESET_PENDING, &ihid->flags))
-                       wake_up(&ihid->wait);
-               return;
-       }
-
-       if ((ret_size > size) || (ret_size < 2)) {
-               dev_err(&ihid->client->dev, "%s: incomplete report (%d/%d)\n",
-                       __func__, size, ret_size);
-               return;
-       }
-
-       i2c_hid_dbg(ihid, "input: %*ph\n", ret_size, ihid->inbuf);
-
-       if (test_bit(I2C_HID_STARTED, &ihid->flags))
-               hid_input_report(ihid->hid, HID_INPUT_REPORT, ihid->inbuf + 2,
-                               ret_size - 2, 1);
-
-       return;
-}
-
-static irqreturn_t i2c_hid_irq(int irq, void *dev_id)
-{
-       struct i2c_hid *ihid = dev_id;
-
-       if (test_bit(I2C_HID_READ_PENDING, &ihid->flags))
-               return IRQ_HANDLED;
-
-       i2c_hid_get_input(ihid);
-
-       return IRQ_HANDLED;
-}
-
-static int i2c_hid_get_report_length(struct hid_report *report)
-{
-       return ((report->size - 1) >> 3) + 1 +
-               report->device->report_enum[report->type].numbered + 2;
-}
-
-/*
- * Traverse the supplied list of reports and find the longest
- */
-static void i2c_hid_find_max_report(struct hid_device *hid, unsigned int type,
-               unsigned int *max)
-{
-       struct hid_report *report;
-       unsigned int size;
-
-       /* We should not rely on wMaxInputLength, as some devices may set it to
-        * a wrong length. */
-       list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
-               size = i2c_hid_get_report_length(report);
-               if (*max < size)
-                       *max = size;
-       }
-}
-
-static void i2c_hid_free_buffers(struct i2c_hid *ihid)
-{
-       kfree(ihid->inbuf);
-       kfree(ihid->rawbuf);
-       kfree(ihid->argsbuf);
-       kfree(ihid->cmdbuf);
-       ihid->inbuf = NULL;
-       ihid->rawbuf = NULL;
-       ihid->cmdbuf = NULL;
-       ihid->argsbuf = NULL;
-       ihid->bufsize = 0;
-}
-
-static int i2c_hid_alloc_buffers(struct i2c_hid *ihid, size_t report_size)
-{
-       /* the worst case is computed from the set_report command with a
-        * reportID > 15 and the maximum report length */
-       int args_len = sizeof(__u8) + /* ReportID */
-                      sizeof(__u8) + /* optional ReportID byte */
-                      sizeof(__u16) + /* data register */
-                      sizeof(__u16) + /* size of the report */
-                      report_size; /* report */
-
-       ihid->inbuf = kzalloc(report_size, GFP_KERNEL);
-       ihid->rawbuf = kzalloc(report_size, GFP_KERNEL);
-       ihid->argsbuf = kzalloc(args_len, GFP_KERNEL);
-       ihid->cmdbuf = kzalloc(sizeof(union command) + args_len, GFP_KERNEL);
-
-       if (!ihid->inbuf || !ihid->rawbuf || !ihid->argsbuf || !ihid->cmdbuf) {
-               i2c_hid_free_buffers(ihid);
-               return -ENOMEM;
-       }
-
-       ihid->bufsize = report_size;
-
-       return 0;
-}
-
-static int i2c_hid_get_raw_report(struct hid_device *hid,
-               unsigned char report_number, __u8 *buf, size_t count,
-               unsigned char report_type)
-{
-       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;
-
-       /* +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->rawbuf, ask_count);
-
-       if (ret < 0)
-               return ret;
-
-       ret_count = ihid->rawbuf[0] | (ihid->rawbuf[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->rawbuf + 2, count);
-
-       return count;
-}
-
-static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
-               size_t count, unsigned char report_type, bool use_data)
-{
-       struct i2c_client *client = hid->driver_data;
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       int report_id = buf[0];
-       int ret;
-
-       if (report_type == HID_INPUT_REPORT)
-               return -EINVAL;
-
-       mutex_lock(&ihid->reset_lock);
-
-       if (report_id) {
-               buf++;
-               count--;
-       }
-
-       ret = i2c_hid_set_or_send_report(client,
-                               report_type == HID_FEATURE_REPORT ? 0x03 : 0x02,
-                               report_id, buf, count, use_data);
-
-       if (report_id && ret >= 0)
-               ret++; /* add report_id to the number of transfered bytes */
-
-       mutex_unlock(&ihid->reset_lock);
-
-       return ret;
-}
-
-static int i2c_hid_output_report(struct hid_device *hid, __u8 *buf,
-               size_t count)
-{
-       return i2c_hid_output_raw_report(hid, buf, count, HID_OUTPUT_REPORT,
-                       false);
-}
-
-static int i2c_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
-                              __u8 *buf, size_t len, unsigned char rtype,
-                              int reqtype)
-{
-       switch (reqtype) {
-       case HID_REQ_GET_REPORT:
-               return i2c_hid_get_raw_report(hid, reportnum, buf, len, rtype);
-       case HID_REQ_SET_REPORT:
-               if (buf[0] != reportnum)
-                       return -EINVAL;
-               return i2c_hid_output_raw_report(hid, buf, len, rtype, true);
-       default:
-               return -EIO;
-       }
-}
-
-static int i2c_hid_parse(struct hid_device *hid)
-{
-       struct i2c_client *client = hid->driver_data;
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       struct i2c_hid_desc *hdesc = &ihid->hdesc;
-       unsigned int rsize;
-       char *rdesc;
-       int ret;
-       int tries = 3;
-
-       i2c_hid_dbg(ihid, "entering %s\n", __func__);
-
-       rsize = le16_to_cpu(hdesc->wReportDescLength);
-       if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
-               dbg_hid("weird size of report descriptor (%u)\n", rsize);
-               return -EINVAL;
-       }
-
-       do {
-               ret = i2c_hid_hwreset(client);
-               if (ret)
-                       msleep(1000);
-       } while (tries-- > 0 && ret);
-
-       if (ret)
-               return ret;
-
-       rdesc = kzalloc(rsize, GFP_KERNEL);
-
-       if (!rdesc) {
-               dbg_hid("couldn't allocate rdesc memory\n");
-               return -ENOMEM;
-       }
-
-       i2c_hid_dbg(ihid, "asking HID report descriptor\n");
-
-       ret = i2c_hid_command(client, &hid_report_descr_cmd, rdesc, rsize);
-       if (ret) {
-               hid_err(hid, "reading report descriptor failed\n");
-               kfree(rdesc);
-               return -EIO;
-       }
-
-       i2c_hid_dbg(ihid, "Report Descriptor: %*ph\n", rsize, rdesc);
-
-       ret = hid_parse_report(hid, rdesc, rsize);
-       kfree(rdesc);
-       if (ret) {
-               dbg_hid("parsing report descriptor failed\n");
-               return ret;
-       }
-
-       return 0;
-}
-
-static int i2c_hid_start(struct hid_device *hid)
-{
-       struct i2c_client *client = hid->driver_data;
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       int ret;
-       unsigned int bufsize = HID_MIN_BUFFER_SIZE;
-
-       i2c_hid_find_max_report(hid, HID_INPUT_REPORT, &bufsize);
-       i2c_hid_find_max_report(hid, HID_OUTPUT_REPORT, &bufsize);
-       i2c_hid_find_max_report(hid, HID_FEATURE_REPORT, &bufsize);
-
-       if (bufsize > ihid->bufsize) {
-               disable_irq(client->irq);
-               i2c_hid_free_buffers(ihid);
-
-               ret = i2c_hid_alloc_buffers(ihid, bufsize);
-               enable_irq(client->irq);
-
-               if (ret)
-                       return ret;
-       }
-
-       return 0;
-}
-
-static void i2c_hid_stop(struct hid_device *hid)
-{
-       hid->claimed = 0;
-}
-
-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 = 0;
-
-       ret = pm_runtime_get_sync(&client->dev);
-       if (ret < 0)
-               return ret;
-
-       set_bit(I2C_HID_STARTED, &ihid->flags);
-       return 0;
-}
-
-static void i2c_hid_close(struct hid_device *hid)
-{
-       struct i2c_client *client = hid->driver_data;
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-
-       clear_bit(I2C_HID_STARTED, &ihid->flags);
-
-       /* Save some power */
-       pm_runtime_put(&client->dev);
-}
-
-static int i2c_hid_power(struct hid_device *hid, int lvl)
-{
-       struct i2c_client *client = hid->driver_data;
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-
-       i2c_hid_dbg(ihid, "%s lvl:%d\n", __func__, lvl);
-
-       switch (lvl) {
-       case PM_HINT_FULLON:
-               pm_runtime_get_sync(&client->dev);
-               break;
-       case PM_HINT_NORMAL:
-               pm_runtime_put(&client->dev);
-               break;
-       }
-       return 0;
-}
-
-struct hid_ll_driver i2c_hid_ll_driver = {
-       .parse = i2c_hid_parse,
-       .start = i2c_hid_start,
-       .stop = i2c_hid_stop,
-       .open = i2c_hid_open,
-       .close = i2c_hid_close,
-       .power = i2c_hid_power,
-       .output_report = i2c_hid_output_report,
-       .raw_request = i2c_hid_raw_request,
-};
-EXPORT_SYMBOL_GPL(i2c_hid_ll_driver);
-
-static int i2c_hid_init_irq(struct i2c_client *client)
-{
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       unsigned long irqflags = 0;
-       int ret;
-
-       dev_dbg(&client->dev, "Requesting IRQ: %d\n", client->irq);
-
-       if (!irq_get_trigger_type(client->irq))
-               irqflags = IRQF_TRIGGER_LOW;
-
-       ret = request_threaded_irq(client->irq, NULL, i2c_hid_irq,
-                                  irqflags | IRQF_ONESHOT, client->name, ihid);
-       if (ret < 0) {
-               dev_warn(&client->dev,
-                       "Could not register for %s interrupt, irq = %d,"
-                       " ret = %d\n",
-                       client->name, client->irq, ret);
-
-               return ret;
-       }
-
-       return 0;
-}
-
-static int i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid)
-{
-       struct i2c_client *client = ihid->client;
-       struct i2c_hid_desc *hdesc = &ihid->hdesc;
-       unsigned int dsize;
-       int ret;
-
-       /* i2c hid fetch using a fixed descriptor size (30 bytes) */
-       i2c_hid_dbg(ihid, "Fetching the HID descriptor\n");
-       ret = i2c_hid_command(client, &hid_descr_cmd, ihid->hdesc_buffer,
-                               sizeof(struct i2c_hid_desc));
-       if (ret) {
-               dev_err(&client->dev, "hid_descr_cmd failed\n");
-               return -ENODEV;
-       }
-
-       /* Validate the length of HID descriptor, the 4 first bytes:
-        * bytes 0-1 -> length
-        * bytes 2-3 -> bcdVersion (has to be 1.00) */
-       /* check bcdVersion == 1.0 */
-       if (le16_to_cpu(hdesc->bcdVersion) != 0x0100) {
-               dev_err(&client->dev,
-                       "unexpected HID descriptor bcdVersion (0x%04hx)\n",
-                       le16_to_cpu(hdesc->bcdVersion));
-               return -ENODEV;
-       }
-
-       /* Descriptor length should be 30 bytes as per the specification */
-       dsize = le16_to_cpu(hdesc->wHIDDescLength);
-       if (dsize != sizeof(struct i2c_hid_desc)) {
-               dev_err(&client->dev, "weird size of HID descriptor (%u)\n",
-                       dsize);
-               return -ENODEV;
-       }
-       i2c_hid_dbg(ihid, "HID Descriptor: %*ph\n", dsize, ihid->hdesc_buffer);
-       return 0;
-}
-
-#ifdef CONFIG_ACPI
-static int i2c_hid_acpi_pdata(struct i2c_client *client,
-               struct i2c_hid_platform_data *pdata)
-{
-       static guid_t i2c_hid_guid =
-               GUID_INIT(0x3CDFF6F7, 0x4267, 0x4555,
-                         0xAD, 0x05, 0xB3, 0x0A, 0x3D, 0x89, 0x38, 0xDE);
-       union acpi_object *obj;
-       struct acpi_device *adev;
-       acpi_handle handle;
-
-       handle = ACPI_HANDLE(&client->dev);
-       if (!handle || acpi_bus_get_device(handle, &adev))
-               return -ENODEV;
-
-       obj = acpi_evaluate_dsm_typed(handle, &i2c_hid_guid, 1, 1, NULL,
-                                     ACPI_TYPE_INTEGER);
-       if (!obj) {
-               dev_err(&client->dev, "device _DSM execution failed\n");
-               return -ENODEV;
-       }
-
-       pdata->hid_descriptor_address = obj->integer.value;
-       ACPI_FREE(obj);
-
-       return 0;
-}
-
-static void i2c_hid_acpi_fix_up_power(struct device *dev)
-{
-       acpi_handle handle = ACPI_HANDLE(dev);
-       struct acpi_device *adev;
-
-       if (handle && acpi_bus_get_device(handle, &adev) == 0)
-               acpi_device_fix_up_power(adev);
-}
-
-static const struct acpi_device_id i2c_hid_acpi_match[] = {
-       {"ACPI0C50", 0 },
-       {"PNP0C50", 0 },
-       { },
-};
-MODULE_DEVICE_TABLE(acpi, i2c_hid_acpi_match);
-#else
-static inline int i2c_hid_acpi_pdata(struct i2c_client *client,
-               struct i2c_hid_platform_data *pdata)
-{
-       return -ENODEV;
-}
-
-static inline void i2c_hid_acpi_fix_up_power(struct device *dev) {}
-#endif
-
-#ifdef CONFIG_OF
-static int i2c_hid_of_probe(struct i2c_client *client,
-               struct i2c_hid_platform_data *pdata)
-{
-       struct device *dev = &client->dev;
-       u32 val;
-       int ret;
-
-       ret = of_property_read_u32(dev->of_node, "hid-descr-addr", &val);
-       if (ret) {
-               dev_err(&client->dev, "HID register address not provided\n");
-               return -ENODEV;
-       }
-       if (val >> 16) {
-               dev_err(&client->dev, "Bad HID register address: 0x%08x\n",
-                       val);
-               return -EINVAL;
-       }
-       pdata->hid_descriptor_address = val;
-
-       ret = of_property_read_u32(dev->of_node, "post-power-on-delay-ms",
-                                  &val);
-       if (!ret)
-               pdata->post_power_delay_ms = val;
-
-       return 0;
-}
-
-static const struct of_device_id i2c_hid_of_match[] = {
-       { .compatible = "hid-over-i2c" },
-       {},
-};
-MODULE_DEVICE_TABLE(of, i2c_hid_of_match);
-#else
-static inline int i2c_hid_of_probe(struct i2c_client *client,
-               struct i2c_hid_platform_data *pdata)
-{
-       return -ENODEV;
-}
-#endif
-
-static int i2c_hid_probe(struct i2c_client *client,
-                        const struct i2c_device_id *dev_id)
-{
-       int ret;
-       struct i2c_hid *ihid;
-       struct hid_device *hid;
-       __u16 hidRegister;
-       struct i2c_hid_platform_data *platform_data = client->dev.platform_data;
-
-       dbg_hid("HID probe called for i2c 0x%02x\n", client->addr);
-
-       if (!client->irq) {
-               dev_err(&client->dev,
-                       "HID over i2c has not been provided an Int IRQ\n");
-               return -EINVAL;
-       }
-
-       if (client->irq < 0) {
-               if (client->irq != -EPROBE_DEFER)
-                       dev_err(&client->dev,
-                               "HID over i2c doesn't have a valid IRQ\n");
-               return client->irq;
-       }
-
-       ihid = kzalloc(sizeof(struct i2c_hid), GFP_KERNEL);
-       if (!ihid)
-               return -ENOMEM;
-
-       if (client->dev.of_node) {
-               ret = i2c_hid_of_probe(client, &ihid->pdata);
-               if (ret)
-                       goto err;
-       } else if (!platform_data) {
-               ret = i2c_hid_acpi_pdata(client, &ihid->pdata);
-               if (ret) {
-                       dev_err(&client->dev,
-                               "HID register address not provided\n");
-                       goto err;
-               }
-       } else {
-               ihid->pdata = *platform_data;
-       }
-
-       ihid->pdata.supply = devm_regulator_get(&client->dev, "vdd");
-       if (IS_ERR(ihid->pdata.supply)) {
-               ret = PTR_ERR(ihid->pdata.supply);
-               if (ret != -EPROBE_DEFER)
-                       dev_err(&client->dev, "Failed to get regulator: %d\n",
-                               ret);
-               goto err;
-       }
-
-       ret = regulator_enable(ihid->pdata.supply);
-       if (ret < 0) {
-               dev_err(&client->dev, "Failed to enable regulator: %d\n",
-                       ret);
-               goto err;
-       }
-       if (ihid->pdata.post_power_delay_ms)
-               msleep(ihid->pdata.post_power_delay_ms);
-
-       i2c_set_clientdata(client, ihid);
-
-       ihid->client = client;
-
-       hidRegister = ihid->pdata.hid_descriptor_address;
-       ihid->wHIDDescRegister = cpu_to_le16(hidRegister);
-
-       init_waitqueue_head(&ihid->wait);
-       mutex_init(&ihid->reset_lock);
-
-       /* we need to allocate the command buffer without knowing the maximum
-        * size of the reports. Let's use HID_MIN_BUFFER_SIZE, then we do the
-        * real computation later. */
-       ret = i2c_hid_alloc_buffers(ihid, HID_MIN_BUFFER_SIZE);
-       if (ret < 0)
-               goto err_regulator;
-
-       i2c_hid_acpi_fix_up_power(&client->dev);
-
-       pm_runtime_get_noresume(&client->dev);
-       pm_runtime_set_active(&client->dev);
-       pm_runtime_enable(&client->dev);
-       device_enable_async_suspend(&client->dev);
-
-       /* Make sure there is something at this address */
-       ret = i2c_smbus_read_byte(client);
-       if (ret < 0) {
-               dev_dbg(&client->dev, "nothing at this address: %d\n", ret);
-               ret = -ENXIO;
-               goto err_pm;
-       }
-
-       ret = i2c_hid_fetch_hid_descriptor(ihid);
-       if (ret < 0)
-               goto err_pm;
-
-       ret = i2c_hid_init_irq(client);
-       if (ret < 0)
-               goto err_pm;
-
-       hid = hid_allocate_device();
-       if (IS_ERR(hid)) {
-               ret = PTR_ERR(hid);
-               goto err_irq;
-       }
-
-       ihid->hid = hid;
-
-       hid->driver_data = client;
-       hid->ll_driver = &i2c_hid_ll_driver;
-       hid->dev.parent = &client->dev;
-       hid->bus = BUS_I2C;
-       hid->version = le16_to_cpu(ihid->hdesc.bcdVersion);
-       hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID);
-       hid->product = le16_to_cpu(ihid->hdesc.wProductID);
-
-       snprintf(hid->name, sizeof(hid->name), "%s %04hX:%04hX",
-                client->name, hid->vendor, hid->product);
-       strlcpy(hid->phys, dev_name(&client->dev), sizeof(hid->phys));
-
-       ihid->quirks = i2c_hid_lookup_quirk(hid->vendor, hid->product);
-
-       ret = hid_add_device(hid);
-       if (ret) {
-               if (ret != -ENODEV)
-                       hid_err(client, "can't add hid device: %d\n", ret);
-               goto err_mem_free;
-       }
-
-       pm_runtime_put(&client->dev);
-       return 0;
-
-err_mem_free:
-       hid_destroy_device(hid);
-
-err_irq:
-       free_irq(client->irq, ihid);
-
-err_pm:
-       pm_runtime_put_noidle(&client->dev);
-       pm_runtime_disable(&client->dev);
-
-err_regulator:
-       regulator_disable(ihid->pdata.supply);
-
-err:
-       i2c_hid_free_buffers(ihid);
-       kfree(ihid);
-       return ret;
-}
-
-static int i2c_hid_remove(struct i2c_client *client)
-{
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       struct hid_device *hid;
-
-       pm_runtime_get_sync(&client->dev);
-       pm_runtime_disable(&client->dev);
-       pm_runtime_set_suspended(&client->dev);
-       pm_runtime_put_noidle(&client->dev);
-
-       hid = ihid->hid;
-       hid_destroy_device(hid);
-
-       free_irq(client->irq, ihid);
-
-       if (ihid->bufsize)
-               i2c_hid_free_buffers(ihid);
-
-       regulator_disable(ihid->pdata.supply);
-
-       kfree(ihid);
-
-       return 0;
-}
-
-static void i2c_hid_shutdown(struct i2c_client *client)
-{
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-
-       i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
-       free_irq(client->irq, ihid);
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int i2c_hid_suspend(struct device *dev)
-{
-       struct i2c_client *client = to_i2c_client(dev);
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       struct hid_device *hid = ihid->hid;
-       int ret;
-       int wake_status;
-
-       if (hid->driver && hid->driver->suspend) {
-               /*
-                * Wake up the device so that IO issues in
-                * HID driver's suspend code can succeed.
-                */
-               ret = pm_runtime_resume(dev);
-               if (ret < 0)
-                       return ret;
-
-               ret = hid->driver->suspend(hid, PMSG_SUSPEND);
-               if (ret < 0)
-                       return ret;
-       }
-
-       if (!pm_runtime_suspended(dev)) {
-               /* Save some power */
-               i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
-
-               disable_irq(client->irq);
-       }
-
-       if (device_may_wakeup(&client->dev)) {
-               wake_status = enable_irq_wake(client->irq);
-               if (!wake_status)
-                       ihid->irq_wake_enabled = true;
-               else
-                       hid_warn(hid, "Failed to enable irq wake: %d\n",
-                               wake_status);
-       } else {
-               ret = regulator_disable(ihid->pdata.supply);
-               if (ret < 0)
-                       hid_warn(hid, "Failed to disable supply: %d\n", ret);
-       }
-
-       return 0;
-}
-
-static int i2c_hid_resume(struct device *dev)
-{
-       int ret;
-       struct i2c_client *client = to_i2c_client(dev);
-       struct i2c_hid *ihid = i2c_get_clientdata(client);
-       struct hid_device *hid = ihid->hid;
-       int wake_status;
-
-       if (!device_may_wakeup(&client->dev)) {
-               ret = regulator_enable(ihid->pdata.supply);
-               if (ret < 0)
-                       hid_warn(hid, "Failed to enable supply: %d\n", ret);
-               if (ihid->pdata.post_power_delay_ms)
-                       msleep(ihid->pdata.post_power_delay_ms);
-       } else if (ihid->irq_wake_enabled) {
-               wake_status = disable_irq_wake(client->irq);
-               if (!wake_status)
-                       ihid->irq_wake_enabled = false;
-               else
-                       hid_warn(hid, "Failed to disable irq wake: %d\n",
-                               wake_status);
-       }
-
-       /* We'll resume to full power */
-       pm_runtime_disable(dev);
-       pm_runtime_set_active(dev);
-       pm_runtime_enable(dev);
-
-       enable_irq(client->irq);
-       ret = i2c_hid_hwreset(client);
-       if (ret)
-               return ret;
-
-       if (hid->driver && hid->driver->reset_resume) {
-               ret = hid->driver->reset_resume(hid);
-               return ret;
-       }
-
-       return 0;
-}
-#endif
-
-#ifdef CONFIG_PM
-static int i2c_hid_runtime_suspend(struct device *dev)
-{
-       struct i2c_client *client = to_i2c_client(dev);
-
-       i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
-       disable_irq(client->irq);
-       return 0;
-}
-
-static int i2c_hid_runtime_resume(struct device *dev)
-{
-       struct i2c_client *client = to_i2c_client(dev);
-
-       enable_irq(client->irq);
-       i2c_hid_set_power(client, I2C_HID_PWR_ON);
-       return 0;
-}
-#endif
-
-static const struct dev_pm_ops i2c_hid_pm = {
-       SET_SYSTEM_SLEEP_PM_OPS(i2c_hid_suspend, i2c_hid_resume)
-       SET_RUNTIME_PM_OPS(i2c_hid_runtime_suspend, i2c_hid_runtime_resume,
-                          NULL)
-};
-
-static const struct i2c_device_id i2c_hid_id_table[] = {
-       { "hid", 0 },
-       { "hid-over-i2c", 0 },
-       { },
-};
-MODULE_DEVICE_TABLE(i2c, i2c_hid_id_table);
-
-
-static struct i2c_driver i2c_hid_driver = {
-       .driver = {
-               .name   = "i2c_hid",
-               .pm     = &i2c_hid_pm,
-               .acpi_match_table = ACPI_PTR(i2c_hid_acpi_match),
-               .of_match_table = of_match_ptr(i2c_hid_of_match),
-       },
-
-       .probe          = i2c_hid_probe,
-       .remove         = i2c_hid_remove,
-       .shutdown       = i2c_hid_shutdown,
-       .id_table       = i2c_hid_id_table,
-};
-
-module_i2c_driver(i2c_hid_driver);
-
-MODULE_DESCRIPTION("HID over I2C core driver");
-MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/hid/i2c-hid/i2c-hid.h b/drivers/hid/i2c-hid/i2c-hid.h
new file mode 100644 (file)
index 0000000..a8c19ae
--- /dev/null
@@ -0,0 +1,20 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+
+#ifndef I2C_HID_H
+#define I2C_HID_H
+
+
+#ifdef CONFIG_DMI
+struct i2c_hid_desc *i2c_hid_get_dmi_i2c_hid_desc_override(uint8_t *i2c_name);
+char *i2c_hid_get_dmi_hid_report_desc_override(uint8_t *i2c_name,
+                                              unsigned int *size);
+#else
+static inline struct i2c_hid_desc
+                  *i2c_hid_get_dmi_i2c_hid_desc_override(uint8_t *i2c_name)
+{ return NULL; }
+static inline char *i2c_hid_get_dmi_hid_report_desc_override(uint8_t *i2c_name,
+                                                            unsigned int *size)
+{ return NULL; }
+#endif
+
+#endif