19ee3e066SJulian Sax /*
29ee3e066SJulian Sax * HID over I2C protocol implementation
39ee3e066SJulian Sax *
49ee3e066SJulian Sax * Copyright (c) 2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
59ee3e066SJulian Sax * Copyright (c) 2012 Ecole Nationale de l'Aviation Civile, France
69ee3e066SJulian Sax * Copyright (c) 2012 Red Hat, Inc
79ee3e066SJulian Sax *
89ee3e066SJulian Sax * This code is partly based on "USB HID support for Linux":
99ee3e066SJulian Sax *
109ee3e066SJulian Sax * Copyright (c) 1999 Andreas Gal
119ee3e066SJulian Sax * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
129ee3e066SJulian Sax * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
139ee3e066SJulian Sax * Copyright (c) 2007-2008 Oliver Neukum
149ee3e066SJulian Sax * Copyright (c) 2006-2010 Jiri Kosina
159ee3e066SJulian Sax *
169ee3e066SJulian Sax * This file is subject to the terms and conditions of the GNU General Public
179ee3e066SJulian Sax * License. See the file COPYING in the main directory of this archive for
189ee3e066SJulian Sax * more details.
199ee3e066SJulian Sax */
209ee3e066SJulian Sax
219ee3e066SJulian Sax #include <linux/module.h>
229ee3e066SJulian Sax #include <linux/i2c.h>
239ee3e066SJulian Sax #include <linux/interrupt.h>
249ee3e066SJulian Sax #include <linux/input.h>
259ee3e066SJulian Sax #include <linux/irq.h>
269ee3e066SJulian Sax #include <linux/delay.h>
279ee3e066SJulian Sax #include <linux/slab.h>
289ee3e066SJulian Sax #include <linux/pm.h>
29d08999ccSRaul E Rangel #include <linux/pm_wakeirq.h>
309ee3e066SJulian Sax #include <linux/device.h>
319ee3e066SJulian Sax #include <linux/wait.h>
329ee3e066SJulian Sax #include <linux/err.h>
339ee3e066SJulian Sax #include <linux/string.h>
349ee3e066SJulian Sax #include <linux/list.h>
359ee3e066SJulian Sax #include <linux/jiffies.h>
369ee3e066SJulian Sax #include <linux/kernel.h>
379ee3e066SJulian Sax #include <linux/hid.h>
389ee3e066SJulian Sax #include <linux/mutex.h>
39dbe0dd5fSDmitry Torokhov #include <asm/unaligned.h>
409ee3e066SJulian Sax
4196a37bfdSDouglas Anderson #include <drm/drm_panel.h>
4296a37bfdSDouglas Anderson
439ee3e066SJulian Sax #include "../hid-ids.h"
449ee3e066SJulian Sax #include "i2c-hid.h"
459ee3e066SJulian Sax
469ee3e066SJulian Sax /* quirks to control the device */
479ee3e066SJulian Sax #define I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV BIT(0)
489ee3e066SJulian Sax #define I2C_HID_QUIRK_NO_IRQ_AFTER_RESET BIT(1)
491475af25SKai-Heng Feng #define I2C_HID_QUIRK_BOGUS_IRQ BIT(4)
50fd70466dSKai-Heng Feng #define I2C_HID_QUIRK_RESET_ON_RESUME BIT(5)
51fd091376SPavel Balan #define I2C_HID_QUIRK_BAD_INPUT_SIZE BIT(6)
52ca66a677SJohnny Chuang #define I2C_HID_QUIRK_NO_WAKEUP_AFTER_RESET BIT(7)
53fd091376SPavel Balan
54dbe0dd5fSDmitry Torokhov /* Command opcodes */
55dbe0dd5fSDmitry Torokhov #define I2C_HID_OPCODE_RESET 0x01
56dbe0dd5fSDmitry Torokhov #define I2C_HID_OPCODE_GET_REPORT 0x02
57dbe0dd5fSDmitry Torokhov #define I2C_HID_OPCODE_SET_REPORT 0x03
58dbe0dd5fSDmitry Torokhov #define I2C_HID_OPCODE_GET_IDLE 0x04
59dbe0dd5fSDmitry Torokhov #define I2C_HID_OPCODE_SET_IDLE 0x05
60dbe0dd5fSDmitry Torokhov #define I2C_HID_OPCODE_GET_PROTOCOL 0x06
61dbe0dd5fSDmitry Torokhov #define I2C_HID_OPCODE_SET_PROTOCOL 0x07
62dbe0dd5fSDmitry Torokhov #define I2C_HID_OPCODE_SET_POWER 0x08
639ee3e066SJulian Sax
649ee3e066SJulian Sax /* flags */
659ee3e066SJulian Sax #define I2C_HID_STARTED 0
669ee3e066SJulian Sax #define I2C_HID_RESET_PENDING 1
679ee3e066SJulian Sax
689ee3e066SJulian Sax #define I2C_HID_PWR_ON 0x00
699ee3e066SJulian Sax #define I2C_HID_PWR_SLEEP 0x01
709ee3e066SJulian Sax
7134ba3657SThomas Weißschuh #define i2c_hid_dbg(ihid, ...) dev_dbg(&(ihid)->client->dev, __VA_ARGS__)
729ee3e066SJulian Sax
739ee3e066SJulian Sax struct i2c_hid_desc {
749ee3e066SJulian Sax __le16 wHIDDescLength;
759ee3e066SJulian Sax __le16 bcdVersion;
769ee3e066SJulian Sax __le16 wReportDescLength;
779ee3e066SJulian Sax __le16 wReportDescRegister;
789ee3e066SJulian Sax __le16 wInputRegister;
799ee3e066SJulian Sax __le16 wMaxInputLength;
809ee3e066SJulian Sax __le16 wOutputRegister;
819ee3e066SJulian Sax __le16 wMaxOutputLength;
829ee3e066SJulian Sax __le16 wCommandRegister;
839ee3e066SJulian Sax __le16 wDataRegister;
849ee3e066SJulian Sax __le16 wVendorID;
859ee3e066SJulian Sax __le16 wProductID;
869ee3e066SJulian Sax __le16 wVersionID;
879ee3e066SJulian Sax __le32 reserved;
889ee3e066SJulian Sax } __packed;
899ee3e066SJulian Sax
909ee3e066SJulian Sax /* The main device structure */
919ee3e066SJulian Sax struct i2c_hid {
929ee3e066SJulian Sax struct i2c_client *client; /* i2c client */
939ee3e066SJulian Sax struct hid_device *hid; /* pointer to corresponding HID dev */
949ee3e066SJulian Sax struct i2c_hid_desc hdesc; /* the HID Descriptor */
959ee3e066SJulian Sax __le16 wHIDDescRegister; /* location of the i2c
969ee3e066SJulian Sax * register of the HID
979ee3e066SJulian Sax * descriptor. */
989ee3e066SJulian Sax unsigned int bufsize; /* i2c buffer size */
999ee3e066SJulian Sax u8 *inbuf; /* Input buffer */
1009ee3e066SJulian Sax u8 *rawbuf; /* Raw Input buffer */
1019ee3e066SJulian Sax u8 *cmdbuf; /* Command buffer */
1029ee3e066SJulian Sax
1039ee3e066SJulian Sax unsigned long flags; /* device flags */
1049ee3e066SJulian Sax unsigned long quirks; /* Various quirks */
1059ee3e066SJulian Sax
1069ee3e066SJulian Sax wait_queue_head_t wait; /* For waiting the interrupt */
1079ee3e066SJulian Sax
1089ee3e066SJulian Sax struct mutex reset_lock;
109b33752c3SDouglas Anderson
110b33752c3SDouglas Anderson struct i2chid_ops *ops;
11196a37bfdSDouglas Anderson struct drm_panel_follower panel_follower;
11276edfcf4SDouglas Anderson struct work_struct panel_follower_prepare_work;
11396a37bfdSDouglas Anderson bool is_panel_follower;
11476edfcf4SDouglas Anderson bool prepare_work_finished;
1159ee3e066SJulian Sax };
1169ee3e066SJulian Sax
1179ee3e066SJulian Sax static const struct i2c_hid_quirks {
1189ee3e066SJulian Sax __u16 idVendor;
1199ee3e066SJulian Sax __u16 idProduct;
1209ee3e066SJulian Sax __u32 quirks;
1219ee3e066SJulian Sax } i2c_hid_quirks[] = {
122b20bef4bSHungNien Chen { USB_VENDOR_ID_WEIDA, HID_ANY_ID,
1239ee3e066SJulian Sax I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV },
1249ee3e066SJulian Sax { I2C_VENDOR_ID_HANTICK, I2C_PRODUCT_ID_HANTICK_5288,
12567b18dfbSKai-Heng Feng I2C_HID_QUIRK_NO_IRQ_AFTER_RESET },
126fc6a31b0SHans de Goede { I2C_VENDOR_ID_ITE, I2C_DEVICE_ID_ITE_VOYO_WINPAD_A15,
127fc6a31b0SHans de Goede I2C_HID_QUIRK_NO_IRQ_AFTER_RESET },
1280c843223SAaron Ma { I2C_VENDOR_ID_RAYDIUM, I2C_PRODUCT_ID_RAYDIUM_3118,
1290c843223SAaron Ma I2C_HID_QUIRK_NO_IRQ_AFTER_RESET },
130fd70466dSKai-Heng Feng { USB_VENDOR_ID_ALPS_JP, HID_ANY_ID,
131fd70466dSKai-Heng Feng I2C_HID_QUIRK_RESET_ON_RESUME },
132538f6740SDaniel Playfair Cal { I2C_VENDOR_ID_SYNAPTICS, I2C_PRODUCT_ID_SYNAPTICS_SYNA2393,
133538f6740SDaniel Playfair Cal I2C_HID_QUIRK_RESET_ON_RESUME },
134fd091376SPavel Balan { USB_VENDOR_ID_ITE, I2C_DEVICE_ID_ITE_LENOVO_LEGION_Y720,
135fd091376SPavel Balan I2C_HID_QUIRK_BAD_INPUT_SIZE },
136ca66a677SJohnny Chuang /*
137ca66a677SJohnny Chuang * Sending the wakeup after reset actually break ELAN touchscreen controller
138ca66a677SJohnny Chuang */
139ca66a677SJohnny Chuang { USB_VENDOR_ID_ELAN, HID_ANY_ID,
14078653706SJim Broadus I2C_HID_QUIRK_NO_WAKEUP_AFTER_RESET |
14178653706SJim Broadus I2C_HID_QUIRK_BOGUS_IRQ },
1429ee3e066SJulian Sax { 0, 0 }
1439ee3e066SJulian Sax };
1449ee3e066SJulian Sax
1459ee3e066SJulian Sax /*
1469ee3e066SJulian Sax * i2c_hid_lookup_quirk: return any quirks associated with a I2C HID device
1479ee3e066SJulian Sax * @idVendor: the 16-bit vendor ID
1489ee3e066SJulian Sax * @idProduct: the 16-bit product ID
1499ee3e066SJulian Sax *
1509ee3e066SJulian Sax * Returns: a u32 quirks value.
1519ee3e066SJulian Sax */
i2c_hid_lookup_quirk(const u16 idVendor,const u16 idProduct)1529ee3e066SJulian Sax static u32 i2c_hid_lookup_quirk(const u16 idVendor, const u16 idProduct)
1539ee3e066SJulian Sax {
1549ee3e066SJulian Sax u32 quirks = 0;
1559ee3e066SJulian Sax int n;
1569ee3e066SJulian Sax
1579ee3e066SJulian Sax for (n = 0; i2c_hid_quirks[n].idVendor; n++)
1589ee3e066SJulian Sax if (i2c_hid_quirks[n].idVendor == idVendor &&
1599ee3e066SJulian Sax (i2c_hid_quirks[n].idProduct == (__u16)HID_ANY_ID ||
1609ee3e066SJulian Sax i2c_hid_quirks[n].idProduct == idProduct))
1619ee3e066SJulian Sax quirks = i2c_hid_quirks[n].quirks;
1629ee3e066SJulian Sax
1639ee3e066SJulian Sax return quirks;
1649ee3e066SJulian Sax }
1659ee3e066SJulian Sax
i2c_hid_xfer(struct i2c_hid * ihid,u8 * send_buf,int send_len,u8 * recv_buf,int recv_len)166dbe0dd5fSDmitry Torokhov static int i2c_hid_xfer(struct i2c_hid *ihid,
167dbe0dd5fSDmitry Torokhov u8 *send_buf, int send_len, u8 *recv_buf, int recv_len)
168dbe0dd5fSDmitry Torokhov {
169dbe0dd5fSDmitry Torokhov struct i2c_client *client = ihid->client;
170dbe0dd5fSDmitry Torokhov struct i2c_msg msgs[2] = { 0 };
171dbe0dd5fSDmitry Torokhov int n = 0;
172dbe0dd5fSDmitry Torokhov int ret;
173dbe0dd5fSDmitry Torokhov
174dbe0dd5fSDmitry Torokhov if (send_len) {
175dbe0dd5fSDmitry Torokhov i2c_hid_dbg(ihid, "%s: cmd=%*ph\n",
176dbe0dd5fSDmitry Torokhov __func__, send_len, send_buf);
177dbe0dd5fSDmitry Torokhov
178dbe0dd5fSDmitry Torokhov msgs[n].addr = client->addr;
1791c4d6cd4SDmitry Torokhov msgs[n].flags = (client->flags & I2C_M_TEN) | I2C_M_DMA_SAFE;
180dbe0dd5fSDmitry Torokhov msgs[n].len = send_len;
181dbe0dd5fSDmitry Torokhov msgs[n].buf = send_buf;
182dbe0dd5fSDmitry Torokhov n++;
183dbe0dd5fSDmitry Torokhov }
184dbe0dd5fSDmitry Torokhov
185dbe0dd5fSDmitry Torokhov if (recv_len) {
186dbe0dd5fSDmitry Torokhov msgs[n].addr = client->addr;
1871c4d6cd4SDmitry Torokhov msgs[n].flags = (client->flags & I2C_M_TEN) |
1881c4d6cd4SDmitry Torokhov I2C_M_RD | I2C_M_DMA_SAFE;
189dbe0dd5fSDmitry Torokhov msgs[n].len = recv_len;
190dbe0dd5fSDmitry Torokhov msgs[n].buf = recv_buf;
191dbe0dd5fSDmitry Torokhov n++;
192dbe0dd5fSDmitry Torokhov }
193dbe0dd5fSDmitry Torokhov
194dbe0dd5fSDmitry Torokhov ret = i2c_transfer(client->adapter, msgs, n);
195dbe0dd5fSDmitry Torokhov
196dbe0dd5fSDmitry Torokhov if (ret != n)
197dbe0dd5fSDmitry Torokhov return ret < 0 ? ret : -EIO;
198dbe0dd5fSDmitry Torokhov
199dbe0dd5fSDmitry Torokhov return 0;
200dbe0dd5fSDmitry Torokhov }
201dbe0dd5fSDmitry Torokhov
i2c_hid_read_register(struct i2c_hid * ihid,__le16 reg,void * buf,size_t len)2028399bd01SDmitry Torokhov static int i2c_hid_read_register(struct i2c_hid *ihid, __le16 reg,
2038399bd01SDmitry Torokhov void *buf, size_t len)
2048399bd01SDmitry Torokhov {
2058399bd01SDmitry Torokhov *(__le16 *)ihid->cmdbuf = reg;
2068399bd01SDmitry Torokhov
2078399bd01SDmitry Torokhov return i2c_hid_xfer(ihid, ihid->cmdbuf, sizeof(__le16), buf, len);
2088399bd01SDmitry Torokhov }
2098399bd01SDmitry Torokhov
i2c_hid_encode_command(u8 * buf,u8 opcode,int report_type,int report_id)210dbe0dd5fSDmitry Torokhov static size_t i2c_hid_encode_command(u8 *buf, u8 opcode,
211dbe0dd5fSDmitry Torokhov int report_type, int report_id)
212dbe0dd5fSDmitry Torokhov {
213dbe0dd5fSDmitry Torokhov size_t length = 0;
214dbe0dd5fSDmitry Torokhov
215dbe0dd5fSDmitry Torokhov if (report_id < 0x0F) {
216dbe0dd5fSDmitry Torokhov buf[length++] = report_type << 4 | report_id;
217dbe0dd5fSDmitry Torokhov buf[length++] = opcode;
218dbe0dd5fSDmitry Torokhov } else {
219dbe0dd5fSDmitry Torokhov buf[length++] = report_type << 4 | 0x0F;
220dbe0dd5fSDmitry Torokhov buf[length++] = opcode;
221dbe0dd5fSDmitry Torokhov buf[length++] = report_id;
222dbe0dd5fSDmitry Torokhov }
223dbe0dd5fSDmitry Torokhov
224dbe0dd5fSDmitry Torokhov return length;
225dbe0dd5fSDmitry Torokhov }
226dbe0dd5fSDmitry Torokhov
i2c_hid_get_report(struct i2c_hid * ihid,u8 report_type,u8 report_id,u8 * recv_buf,size_t recv_len)22785df7133SDmitry Torokhov static int i2c_hid_get_report(struct i2c_hid *ihid,
22885df7133SDmitry Torokhov u8 report_type, u8 report_id,
22985df7133SDmitry Torokhov u8 *recv_buf, size_t recv_len)
2309ee3e066SJulian Sax {
23185df7133SDmitry Torokhov size_t length = 0;
23285df7133SDmitry Torokhov size_t ret_count;
23385df7133SDmitry Torokhov int error;
2349ee3e066SJulian Sax
2359ee3e066SJulian Sax i2c_hid_dbg(ihid, "%s\n", __func__);
2369ee3e066SJulian Sax
23785df7133SDmitry Torokhov /* Command register goes first */
23885df7133SDmitry Torokhov *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister;
23985df7133SDmitry Torokhov length += sizeof(__le16);
24085df7133SDmitry Torokhov /* Next is GET_REPORT command */
24185df7133SDmitry Torokhov length += i2c_hid_encode_command(ihid->cmdbuf + length,
24285df7133SDmitry Torokhov I2C_HID_OPCODE_GET_REPORT,
24385df7133SDmitry Torokhov report_type, report_id);
24485df7133SDmitry Torokhov /*
24585df7133SDmitry Torokhov * Device will send report data through data register. Because
24685df7133SDmitry Torokhov * command can be either 2 or 3 bytes destination for the data
24785df7133SDmitry Torokhov * register may be not aligned.
24885df7133SDmitry Torokhov */
24985df7133SDmitry Torokhov put_unaligned_le16(le16_to_cpu(ihid->hdesc.wDataRegister),
25085df7133SDmitry Torokhov ihid->cmdbuf + length);
25185df7133SDmitry Torokhov length += sizeof(__le16);
2529ee3e066SJulian Sax
25385df7133SDmitry Torokhov /*
25485df7133SDmitry Torokhov * In addition to report data device will supply data length
25585df7133SDmitry Torokhov * in the first 2 bytes of the response, so adjust .
25685df7133SDmitry Torokhov */
25785df7133SDmitry Torokhov error = i2c_hid_xfer(ihid, ihid->cmdbuf, length,
25885df7133SDmitry Torokhov ihid->rawbuf, recv_len + sizeof(__le16));
25985df7133SDmitry Torokhov if (error) {
260d34c6105SDmitry Torokhov dev_err(&ihid->client->dev,
26185df7133SDmitry Torokhov "failed to set a report to device: %d\n", error);
26285df7133SDmitry Torokhov return error;
2639ee3e066SJulian Sax }
2649ee3e066SJulian Sax
26585df7133SDmitry Torokhov /* The buffer is sufficiently aligned */
26685df7133SDmitry Torokhov ret_count = le16_to_cpup((__le16 *)ihid->rawbuf);
26785df7133SDmitry Torokhov
26885df7133SDmitry Torokhov /* Check for empty report response */
26985df7133SDmitry Torokhov if (ret_count <= sizeof(__le16))
2709ee3e066SJulian Sax return 0;
27185df7133SDmitry Torokhov
27285df7133SDmitry Torokhov recv_len = min(recv_len, ret_count - sizeof(__le16));
27385df7133SDmitry Torokhov memcpy(recv_buf, ihid->rawbuf + sizeof(__le16), recv_len);
27485df7133SDmitry Torokhov
27585df7133SDmitry Torokhov if (report_id && recv_len != 0 && recv_buf[0] != report_id) {
27685df7133SDmitry Torokhov dev_err(&ihid->client->dev,
27785df7133SDmitry Torokhov "device returned incorrect report (%d vs %d expected)\n",
27885df7133SDmitry Torokhov recv_buf[0], report_id);
27985df7133SDmitry Torokhov return -EINVAL;
28085df7133SDmitry Torokhov }
28185df7133SDmitry Torokhov
28285df7133SDmitry Torokhov return recv_len;
2839ee3e066SJulian Sax }
2849ee3e066SJulian Sax
i2c_hid_format_report(u8 * buf,int report_id,const u8 * data,size_t size)285dbe0dd5fSDmitry Torokhov static size_t i2c_hid_format_report(u8 *buf, int report_id,
286dbe0dd5fSDmitry Torokhov const u8 *data, size_t size)
287dbe0dd5fSDmitry Torokhov {
288dbe0dd5fSDmitry Torokhov size_t length = sizeof(__le16); /* reserve space to store size */
289dbe0dd5fSDmitry Torokhov
290dbe0dd5fSDmitry Torokhov if (report_id)
291dbe0dd5fSDmitry Torokhov buf[length++] = report_id;
292dbe0dd5fSDmitry Torokhov
293dbe0dd5fSDmitry Torokhov memcpy(buf + length, data, size);
294dbe0dd5fSDmitry Torokhov length += size;
295dbe0dd5fSDmitry Torokhov
296dbe0dd5fSDmitry Torokhov /* Store overall size in the beginning of the buffer */
297dbe0dd5fSDmitry Torokhov put_unaligned_le16(length, buf);
298dbe0dd5fSDmitry Torokhov
299dbe0dd5fSDmitry Torokhov return length;
300dbe0dd5fSDmitry Torokhov }
301dbe0dd5fSDmitry Torokhov
3029ee3e066SJulian Sax /**
3039ee3e066SJulian Sax * i2c_hid_set_or_send_report: forward an incoming report to the device
304d34c6105SDmitry Torokhov * @ihid: the i2c hid device
305dbe0dd5fSDmitry Torokhov * @report_type: 0x03 for HID_FEATURE_REPORT ; 0x02 for HID_OUTPUT_REPORT
306dbe0dd5fSDmitry Torokhov * @report_id: the report ID
3079ee3e066SJulian Sax * @buf: the actual data to transfer, without the report ID
308ca43ab1eSXiaofei Tan * @data_len: size of buf
309dbe0dd5fSDmitry Torokhov * @do_set: true: use SET_REPORT HID command, false: send plain OUTPUT report
3109ee3e066SJulian Sax */
i2c_hid_set_or_send_report(struct i2c_hid * ihid,u8 report_type,u8 report_id,const u8 * buf,size_t data_len,bool do_set)311dbe0dd5fSDmitry Torokhov static int i2c_hid_set_or_send_report(struct i2c_hid *ihid,
312dbe0dd5fSDmitry Torokhov u8 report_type, u8 report_id,
313dbe0dd5fSDmitry Torokhov const u8 *buf, size_t data_len,
314dbe0dd5fSDmitry Torokhov bool do_set)
3159ee3e066SJulian Sax {
316dbe0dd5fSDmitry Torokhov size_t length = 0;
317dbe0dd5fSDmitry Torokhov int error;
3189ee3e066SJulian Sax
3199ee3e066SJulian Sax i2c_hid_dbg(ihid, "%s\n", __func__);
3209ee3e066SJulian Sax
3219ee3e066SJulian Sax if (data_len > ihid->bufsize)
3229ee3e066SJulian Sax return -EINVAL;
3239ee3e066SJulian Sax
324dbe0dd5fSDmitry Torokhov if (!do_set && le16_to_cpu(ihid->hdesc.wMaxOutputLength) == 0)
3259ee3e066SJulian Sax return -ENOSYS;
3269ee3e066SJulian Sax
327dbe0dd5fSDmitry Torokhov if (do_set) {
328dbe0dd5fSDmitry Torokhov /* Command register goes first */
329dbe0dd5fSDmitry Torokhov *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister;
330dbe0dd5fSDmitry Torokhov length += sizeof(__le16);
331dbe0dd5fSDmitry Torokhov /* Next is SET_REPORT command */
332dbe0dd5fSDmitry Torokhov length += i2c_hid_encode_command(ihid->cmdbuf + length,
333dbe0dd5fSDmitry Torokhov I2C_HID_OPCODE_SET_REPORT,
334dbe0dd5fSDmitry Torokhov report_type, report_id);
3359ee3e066SJulian Sax /*
336dbe0dd5fSDmitry Torokhov * Report data will go into the data register. Because
337dbe0dd5fSDmitry Torokhov * command can be either 2 or 3 bytes destination for
338dbe0dd5fSDmitry Torokhov * the data register may be not aligned.
3399ee3e066SJulian Sax */
340dbe0dd5fSDmitry Torokhov put_unaligned_le16(le16_to_cpu(ihid->hdesc.wDataRegister),
341dbe0dd5fSDmitry Torokhov ihid->cmdbuf + length);
342dbe0dd5fSDmitry Torokhov length += sizeof(__le16);
3439ee3e066SJulian Sax } else {
344dbe0dd5fSDmitry Torokhov /*
345dbe0dd5fSDmitry Torokhov * With simple "send report" all data goes into the output
346dbe0dd5fSDmitry Torokhov * register.
347dbe0dd5fSDmitry Torokhov */
348269ecc0cSYang Li *(__le16 *)ihid->cmdbuf = ihid->hdesc.wOutputRegister;
349dbe0dd5fSDmitry Torokhov length += sizeof(__le16);
3509ee3e066SJulian Sax }
3519ee3e066SJulian Sax
352dbe0dd5fSDmitry Torokhov length += i2c_hid_format_report(ihid->cmdbuf + length,
353dbe0dd5fSDmitry Torokhov report_id, buf, data_len);
3549ee3e066SJulian Sax
355dbe0dd5fSDmitry Torokhov error = i2c_hid_xfer(ihid, ihid->cmdbuf, length, NULL, 0);
356dbe0dd5fSDmitry Torokhov if (error) {
357d34c6105SDmitry Torokhov dev_err(&ihid->client->dev,
358dbe0dd5fSDmitry Torokhov "failed to set a report to device: %d\n", error);
359dbe0dd5fSDmitry Torokhov return error;
3609ee3e066SJulian Sax }
3619ee3e066SJulian Sax
3629ee3e066SJulian Sax return data_len;
3639ee3e066SJulian Sax }
3649ee3e066SJulian Sax
i2c_hid_set_power_command(struct i2c_hid * ihid,int power_state)365acb8dd95SDmitry Torokhov static int i2c_hid_set_power_command(struct i2c_hid *ihid, int power_state)
366acb8dd95SDmitry Torokhov {
367acb8dd95SDmitry Torokhov size_t length;
368acb8dd95SDmitry Torokhov
369acb8dd95SDmitry Torokhov /* SET_POWER uses command register */
370acb8dd95SDmitry Torokhov *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister;
371acb8dd95SDmitry Torokhov length = sizeof(__le16);
372acb8dd95SDmitry Torokhov
373acb8dd95SDmitry Torokhov /* Now the command itself */
374acb8dd95SDmitry Torokhov length += i2c_hid_encode_command(ihid->cmdbuf + length,
375acb8dd95SDmitry Torokhov I2C_HID_OPCODE_SET_POWER,
376acb8dd95SDmitry Torokhov 0, power_state);
377acb8dd95SDmitry Torokhov
378acb8dd95SDmitry Torokhov return i2c_hid_xfer(ihid, ihid->cmdbuf, length, NULL, 0);
379acb8dd95SDmitry Torokhov }
380acb8dd95SDmitry Torokhov
i2c_hid_set_power(struct i2c_hid * ihid,int power_state)381d34c6105SDmitry Torokhov static int i2c_hid_set_power(struct i2c_hid *ihid, int power_state)
3829ee3e066SJulian Sax {
3839ee3e066SJulian Sax int ret;
3849ee3e066SJulian Sax
3859ee3e066SJulian Sax i2c_hid_dbg(ihid, "%s\n", __func__);
3869ee3e066SJulian Sax
3879ee3e066SJulian Sax /*
3889ee3e066SJulian Sax * Some devices require to send a command to wakeup before power on.
3899ee3e066SJulian Sax * The call will get a return value (EREMOTEIO) but device will be
3909ee3e066SJulian Sax * triggered and activated. After that, it goes like a normal device.
3919ee3e066SJulian Sax */
3929ee3e066SJulian Sax if (power_state == I2C_HID_PWR_ON &&
3939ee3e066SJulian Sax ihid->quirks & I2C_HID_QUIRK_SET_PWR_WAKEUP_DEV) {
394acb8dd95SDmitry Torokhov ret = i2c_hid_set_power_command(ihid, I2C_HID_PWR_ON);
3959ee3e066SJulian Sax
3969ee3e066SJulian Sax /* Device was already activated */
3979ee3e066SJulian Sax if (!ret)
3989ee3e066SJulian Sax goto set_pwr_exit;
3999ee3e066SJulian Sax }
4009ee3e066SJulian Sax
401acb8dd95SDmitry Torokhov ret = i2c_hid_set_power_command(ihid, power_state);
4029ee3e066SJulian Sax if (ret)
403d34c6105SDmitry Torokhov dev_err(&ihid->client->dev,
404d34c6105SDmitry Torokhov "failed to change power setting.\n");
4059ee3e066SJulian Sax
4069ee3e066SJulian Sax set_pwr_exit:
407eef40162SHans de Goede
408eef40162SHans de Goede /*
409eef40162SHans de Goede * The HID over I2C specification states that if a DEVICE needs time
410eef40162SHans de Goede * after the PWR_ON request, it should utilise CLOCK stretching.
411eef40162SHans de Goede * However, it has been observered that the Windows driver provides a
412eef40162SHans de Goede * 1ms sleep between the PWR_ON and RESET requests.
413eef40162SHans de Goede * According to Goodix Windows even waits 60 ms after (other?)
414eef40162SHans de Goede * PWR_ON requests. Testing has confirmed that several devices
415eef40162SHans de Goede * will not work properly without a delay after a PWR_ON request.
416eef40162SHans de Goede */
417eef40162SHans de Goede if (!ret && power_state == I2C_HID_PWR_ON)
418eef40162SHans de Goede msleep(60);
419eef40162SHans de Goede
4209ee3e066SJulian Sax return ret;
4219ee3e066SJulian Sax }
4229ee3e066SJulian Sax
i2c_hid_execute_reset(struct i2c_hid * ihid)423b26fc316SDmitry Torokhov static int i2c_hid_execute_reset(struct i2c_hid *ihid)
424b26fc316SDmitry Torokhov {
42550c5249fSDmitry Torokhov size_t length = 0;
426b26fc316SDmitry Torokhov int ret;
427b26fc316SDmitry Torokhov
428b26fc316SDmitry Torokhov i2c_hid_dbg(ihid, "resetting...\n");
429b26fc316SDmitry Torokhov
43050c5249fSDmitry Torokhov /* Prepare reset command. Command register goes first. */
43150c5249fSDmitry Torokhov *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister;
43250c5249fSDmitry Torokhov length += sizeof(__le16);
43350c5249fSDmitry Torokhov /* Next is RESET command itself */
43450c5249fSDmitry Torokhov length += i2c_hid_encode_command(ihid->cmdbuf + length,
43550c5249fSDmitry Torokhov I2C_HID_OPCODE_RESET, 0, 0);
43650c5249fSDmitry Torokhov
437b26fc316SDmitry Torokhov set_bit(I2C_HID_RESET_PENDING, &ihid->flags);
438b26fc316SDmitry Torokhov
43950c5249fSDmitry Torokhov ret = i2c_hid_xfer(ihid, ihid->cmdbuf, length, NULL, 0);
440b26fc316SDmitry Torokhov if (ret) {
441b26fc316SDmitry Torokhov dev_err(&ihid->client->dev, "failed to reset device.\n");
442b26fc316SDmitry Torokhov goto out;
443b26fc316SDmitry Torokhov }
444b26fc316SDmitry Torokhov
445b26fc316SDmitry Torokhov if (ihid->quirks & I2C_HID_QUIRK_NO_IRQ_AFTER_RESET) {
446b26fc316SDmitry Torokhov msleep(100);
447b26fc316SDmitry Torokhov goto out;
448b26fc316SDmitry Torokhov }
449b26fc316SDmitry Torokhov
450b26fc316SDmitry Torokhov i2c_hid_dbg(ihid, "%s: waiting...\n", __func__);
451b26fc316SDmitry Torokhov if (!wait_event_timeout(ihid->wait,
452b26fc316SDmitry Torokhov !test_bit(I2C_HID_RESET_PENDING, &ihid->flags),
453b26fc316SDmitry Torokhov msecs_to_jiffies(5000))) {
454b26fc316SDmitry Torokhov ret = -ENODATA;
455b26fc316SDmitry Torokhov goto out;
456b26fc316SDmitry Torokhov }
457b26fc316SDmitry Torokhov i2c_hid_dbg(ihid, "%s: finished.\n", __func__);
458b26fc316SDmitry Torokhov
459b26fc316SDmitry Torokhov out:
460b26fc316SDmitry Torokhov clear_bit(I2C_HID_RESET_PENDING, &ihid->flags);
461b26fc316SDmitry Torokhov return ret;
462b26fc316SDmitry Torokhov }
463b26fc316SDmitry Torokhov
i2c_hid_hwreset(struct i2c_hid * ihid)464d34c6105SDmitry Torokhov static int i2c_hid_hwreset(struct i2c_hid *ihid)
4659ee3e066SJulian Sax {
4669ee3e066SJulian Sax int ret;
4679ee3e066SJulian Sax
4689ee3e066SJulian Sax i2c_hid_dbg(ihid, "%s\n", __func__);
4699ee3e066SJulian Sax
4709ee3e066SJulian Sax /*
4719ee3e066SJulian Sax * This prevents sending feature reports while the device is
4729ee3e066SJulian Sax * being reset. Otherwise we may lose the reset complete
4739ee3e066SJulian Sax * interrupt.
4749ee3e066SJulian Sax */
4759ee3e066SJulian Sax mutex_lock(&ihid->reset_lock);
4769ee3e066SJulian Sax
477d34c6105SDmitry Torokhov ret = i2c_hid_set_power(ihid, I2C_HID_PWR_ON);
4789ee3e066SJulian Sax if (ret)
4799ee3e066SJulian Sax goto out_unlock;
4809ee3e066SJulian Sax
481b26fc316SDmitry Torokhov ret = i2c_hid_execute_reset(ihid);
4829ee3e066SJulian Sax if (ret) {
483b26fc316SDmitry Torokhov dev_err(&ihid->client->dev,
484b26fc316SDmitry Torokhov "failed to reset device: %d\n", ret);
485d34c6105SDmitry Torokhov i2c_hid_set_power(ihid, I2C_HID_PWR_SLEEP);
48643b7029fSHans de Goede goto out_unlock;
4879ee3e066SJulian Sax }
4889ee3e066SJulian Sax
48943b7029fSHans de Goede /* At least some SIS devices need this after reset */
490ca66a677SJohnny Chuang if (!(ihid->quirks & I2C_HID_QUIRK_NO_WAKEUP_AFTER_RESET))
491d34c6105SDmitry Torokhov ret = i2c_hid_set_power(ihid, I2C_HID_PWR_ON);
49243b7029fSHans de Goede
4939ee3e066SJulian Sax out_unlock:
4949ee3e066SJulian Sax mutex_unlock(&ihid->reset_lock);
4959ee3e066SJulian Sax return ret;
4969ee3e066SJulian Sax }
4979ee3e066SJulian Sax
i2c_hid_get_input(struct i2c_hid * ihid)4989ee3e066SJulian Sax static void i2c_hid_get_input(struct i2c_hid *ihid)
4999ee3e066SJulian Sax {
50086fc3fd2SDmitry Torokhov u16 size = le16_to_cpu(ihid->hdesc.wMaxInputLength);
50186fc3fd2SDmitry Torokhov u16 ret_size;
5029ee3e066SJulian Sax int ret;
5039ee3e066SJulian Sax
5049ee3e066SJulian Sax if (size > ihid->bufsize)
5059ee3e066SJulian Sax size = ihid->bufsize;
5069ee3e066SJulian Sax
5079ee3e066SJulian Sax ret = i2c_master_recv(ihid->client, ihid->inbuf, size);
5089ee3e066SJulian Sax if (ret != size) {
5099ee3e066SJulian Sax if (ret < 0)
5109ee3e066SJulian Sax return;
5119ee3e066SJulian Sax
5129ee3e066SJulian Sax dev_err(&ihid->client->dev, "%s: got %d data instead of %d\n",
5139ee3e066SJulian Sax __func__, ret, size);
5149ee3e066SJulian Sax return;
5159ee3e066SJulian Sax }
5169ee3e066SJulian Sax
51786fc3fd2SDmitry Torokhov /* Receiving buffer is properly aligned */
51886fc3fd2SDmitry Torokhov ret_size = le16_to_cpup((__le16 *)ihid->inbuf);
5199ee3e066SJulian Sax if (!ret_size) {
5209ee3e066SJulian Sax /* host or device initiated RESET completed */
5219ee3e066SJulian Sax if (test_and_clear_bit(I2C_HID_RESET_PENDING, &ihid->flags))
5229ee3e066SJulian Sax wake_up(&ihid->wait);
5239ee3e066SJulian Sax return;
5249ee3e066SJulian Sax }
5259ee3e066SJulian Sax
52686fc3fd2SDmitry Torokhov if ((ihid->quirks & I2C_HID_QUIRK_BOGUS_IRQ) && ret_size == 0xffff) {
52786fc3fd2SDmitry Torokhov dev_warn_once(&ihid->client->dev,
52886fc3fd2SDmitry Torokhov "%s: IRQ triggered but there's no data\n",
52986fc3fd2SDmitry Torokhov __func__);
5301475af25SKai-Heng Feng return;
5311475af25SKai-Heng Feng }
5321475af25SKai-Heng Feng
53386fc3fd2SDmitry Torokhov if (ret_size > size || ret_size < sizeof(__le16)) {
534fd091376SPavel Balan if (ihid->quirks & I2C_HID_QUIRK_BAD_INPUT_SIZE) {
53586fc3fd2SDmitry Torokhov *(__le16 *)ihid->inbuf = cpu_to_le16(size);
536fd091376SPavel Balan ret_size = size;
537fd091376SPavel Balan } else {
53886fc3fd2SDmitry Torokhov dev_err(&ihid->client->dev,
53986fc3fd2SDmitry Torokhov "%s: incomplete report (%d/%d)\n",
5409ee3e066SJulian Sax __func__, size, ret_size);
5419ee3e066SJulian Sax return;
5429ee3e066SJulian Sax }
543fd091376SPavel Balan }
5449ee3e066SJulian Sax
5459ee3e066SJulian Sax i2c_hid_dbg(ihid, "input: %*ph\n", ret_size, ihid->inbuf);
5469ee3e066SJulian Sax
547d951ae1cSMatthias Kaehlcke if (test_bit(I2C_HID_STARTED, &ihid->flags)) {
5489984fbf5SDmitry Torokhov if (ihid->hid->group != HID_GROUP_RMI)
549d951ae1cSMatthias Kaehlcke pm_wakeup_event(&ihid->client->dev, 0);
550d951ae1cSMatthias Kaehlcke
55186fc3fd2SDmitry Torokhov hid_input_report(ihid->hid, HID_INPUT_REPORT,
55286fc3fd2SDmitry Torokhov ihid->inbuf + sizeof(__le16),
55386fc3fd2SDmitry Torokhov ret_size - sizeof(__le16), 1);
554d951ae1cSMatthias Kaehlcke }
5559ee3e066SJulian Sax
5569ee3e066SJulian Sax return;
5579ee3e066SJulian Sax }
5589ee3e066SJulian Sax
i2c_hid_irq(int irq,void * dev_id)5599ee3e066SJulian Sax static irqreturn_t i2c_hid_irq(int irq, void *dev_id)
5609ee3e066SJulian Sax {
5619ee3e066SJulian Sax struct i2c_hid *ihid = dev_id;
5629ee3e066SJulian Sax
5639ee3e066SJulian Sax i2c_hid_get_input(ihid);
5649ee3e066SJulian Sax
5659ee3e066SJulian Sax return IRQ_HANDLED;
5669ee3e066SJulian Sax }
5679ee3e066SJulian Sax
i2c_hid_get_report_length(struct hid_report * report)5689ee3e066SJulian Sax static int i2c_hid_get_report_length(struct hid_report *report)
5699ee3e066SJulian Sax {
5709ee3e066SJulian Sax return ((report->size - 1) >> 3) + 1 +
5719ee3e066SJulian Sax report->device->report_enum[report->type].numbered + 2;
5729ee3e066SJulian Sax }
5739ee3e066SJulian Sax
5749ee3e066SJulian Sax /*
5759ee3e066SJulian Sax * Traverse the supplied list of reports and find the longest
5769ee3e066SJulian Sax */
i2c_hid_find_max_report(struct hid_device * hid,unsigned int type,unsigned int * max)5779ee3e066SJulian Sax static void i2c_hid_find_max_report(struct hid_device *hid, unsigned int type,
5789ee3e066SJulian Sax unsigned int *max)
5799ee3e066SJulian Sax {
5809ee3e066SJulian Sax struct hid_report *report;
5819ee3e066SJulian Sax unsigned int size;
5829ee3e066SJulian Sax
5839ee3e066SJulian Sax /* We should not rely on wMaxInputLength, as some devices may set it to
5849ee3e066SJulian Sax * a wrong length. */
5859ee3e066SJulian Sax list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
5869ee3e066SJulian Sax size = i2c_hid_get_report_length(report);
5879ee3e066SJulian Sax if (*max < size)
5889ee3e066SJulian Sax *max = size;
5899ee3e066SJulian Sax }
5909ee3e066SJulian Sax }
5919ee3e066SJulian Sax
i2c_hid_free_buffers(struct i2c_hid * ihid)5929ee3e066SJulian Sax static void i2c_hid_free_buffers(struct i2c_hid *ihid)
5939ee3e066SJulian Sax {
5949ee3e066SJulian Sax kfree(ihid->inbuf);
5959ee3e066SJulian Sax kfree(ihid->rawbuf);
5969ee3e066SJulian Sax kfree(ihid->cmdbuf);
5979ee3e066SJulian Sax ihid->inbuf = NULL;
5989ee3e066SJulian Sax ihid->rawbuf = NULL;
5999ee3e066SJulian Sax ihid->cmdbuf = NULL;
6009ee3e066SJulian Sax ihid->bufsize = 0;
6019ee3e066SJulian Sax }
6029ee3e066SJulian Sax
i2c_hid_alloc_buffers(struct i2c_hid * ihid,size_t report_size)6039ee3e066SJulian Sax static int i2c_hid_alloc_buffers(struct i2c_hid *ihid, size_t report_size)
6049ee3e066SJulian Sax {
605dbe0dd5fSDmitry Torokhov /*
606dbe0dd5fSDmitry Torokhov * The worst case is computed from the set_report command with a
607dbe0dd5fSDmitry Torokhov * reportID > 15 and the maximum report length.
608dbe0dd5fSDmitry Torokhov */
609dbe0dd5fSDmitry Torokhov int cmd_len = sizeof(__le16) + /* command register */
610dbe0dd5fSDmitry Torokhov sizeof(u8) + /* encoded report type/ID */
611dbe0dd5fSDmitry Torokhov sizeof(u8) + /* opcode */
612dbe0dd5fSDmitry Torokhov sizeof(u8) + /* optional 3rd byte report ID */
613dbe0dd5fSDmitry Torokhov sizeof(__le16) + /* data register */
614dbe0dd5fSDmitry Torokhov sizeof(__le16) + /* report data size */
615dbe0dd5fSDmitry Torokhov sizeof(u8) + /* report ID if numbered report */
616dbe0dd5fSDmitry Torokhov report_size;
6179ee3e066SJulian Sax
6189ee3e066SJulian Sax ihid->inbuf = kzalloc(report_size, GFP_KERNEL);
6199ee3e066SJulian Sax ihid->rawbuf = kzalloc(report_size, GFP_KERNEL);
620dbe0dd5fSDmitry Torokhov ihid->cmdbuf = kzalloc(cmd_len, GFP_KERNEL);
6219ee3e066SJulian Sax
622dbe0dd5fSDmitry Torokhov if (!ihid->inbuf || !ihid->rawbuf || !ihid->cmdbuf) {
6239ee3e066SJulian Sax i2c_hid_free_buffers(ihid);
6249ee3e066SJulian Sax return -ENOMEM;
6259ee3e066SJulian Sax }
6269ee3e066SJulian Sax
6279ee3e066SJulian Sax ihid->bufsize = report_size;
6289ee3e066SJulian Sax
6299ee3e066SJulian Sax return 0;
6309ee3e066SJulian Sax }
6319ee3e066SJulian Sax
i2c_hid_get_raw_report(struct hid_device * hid,u8 report_type,u8 report_id,u8 * buf,size_t count)6329ee3e066SJulian Sax static int i2c_hid_get_raw_report(struct hid_device *hid,
63385df7133SDmitry Torokhov u8 report_type, u8 report_id,
63485df7133SDmitry Torokhov u8 *buf, size_t count)
6359ee3e066SJulian Sax {
6369ee3e066SJulian Sax struct i2c_client *client = hid->driver_data;
6379ee3e066SJulian Sax struct i2c_hid *ihid = i2c_get_clientdata(client);
63885df7133SDmitry Torokhov int ret_count;
6399ee3e066SJulian Sax
6409ee3e066SJulian Sax if (report_type == HID_OUTPUT_REPORT)
6419ee3e066SJulian Sax return -EINVAL;
6429ee3e066SJulian Sax
643a5e5e03eSDmitry Torokhov /*
644a5e5e03eSDmitry Torokhov * In case of unnumbered reports the response from the device will
645a5e5e03eSDmitry Torokhov * not have the report ID that the upper layers expect, so we need
646a5e5e03eSDmitry Torokhov * to stash it the buffer ourselves and adjust the data size.
647a5e5e03eSDmitry Torokhov */
64885df7133SDmitry Torokhov if (!report_id) {
649a5e5e03eSDmitry Torokhov buf[0] = 0;
650a5e5e03eSDmitry Torokhov buf++;
651a5e5e03eSDmitry Torokhov count--;
652a5e5e03eSDmitry Torokhov }
653a5e5e03eSDmitry Torokhov
65485df7133SDmitry Torokhov ret_count = i2c_hid_get_report(ihid,
6559ee3e066SJulian Sax report_type == HID_FEATURE_REPORT ? 0x03 : 0x01,
65685df7133SDmitry Torokhov report_id, buf, count);
6579ee3e066SJulian Sax
65885df7133SDmitry Torokhov if (ret_count > 0 && !report_id)
65985df7133SDmitry Torokhov ret_count++;
6609ee3e066SJulian Sax
66185df7133SDmitry Torokhov return ret_count;
6629ee3e066SJulian Sax }
6639ee3e066SJulian Sax
i2c_hid_output_raw_report(struct hid_device * hid,u8 report_type,const u8 * buf,size_t count,bool do_set)66485df7133SDmitry Torokhov static int i2c_hid_output_raw_report(struct hid_device *hid, u8 report_type,
66585df7133SDmitry Torokhov const u8 *buf, size_t count, bool do_set)
6669ee3e066SJulian Sax {
6679ee3e066SJulian Sax struct i2c_client *client = hid->driver_data;
6689ee3e066SJulian Sax struct i2c_hid *ihid = i2c_get_clientdata(client);
6699ee3e066SJulian Sax int report_id = buf[0];
6709ee3e066SJulian Sax int ret;
6719ee3e066SJulian Sax
6729ee3e066SJulian Sax if (report_type == HID_INPUT_REPORT)
6739ee3e066SJulian Sax return -EINVAL;
6749ee3e066SJulian Sax
6759ee3e066SJulian Sax mutex_lock(&ihid->reset_lock);
6769ee3e066SJulian Sax
677a5e5e03eSDmitry Torokhov /*
678a5e5e03eSDmitry Torokhov * Note that both numbered and unnumbered reports passed here
679a5e5e03eSDmitry Torokhov * are supposed to have report ID stored in the 1st byte of the
680a5e5e03eSDmitry Torokhov * buffer, so we strip it off unconditionally before passing payload
681a5e5e03eSDmitry Torokhov * to i2c_hid_set_or_send_report which takes care of encoding
682a5e5e03eSDmitry Torokhov * everything properly.
683a5e5e03eSDmitry Torokhov */
684d34c6105SDmitry Torokhov ret = i2c_hid_set_or_send_report(ihid,
6859ee3e066SJulian Sax report_type == HID_FEATURE_REPORT ? 0x03 : 0x02,
686dbe0dd5fSDmitry Torokhov report_id, buf + 1, count - 1, do_set);
6879ee3e066SJulian Sax
688a5e5e03eSDmitry Torokhov if (ret >= 0)
689a5e5e03eSDmitry Torokhov ret++; /* add report_id to the number of transferred bytes */
6909ee3e066SJulian Sax
6919ee3e066SJulian Sax mutex_unlock(&ihid->reset_lock);
6929ee3e066SJulian Sax
6939ee3e066SJulian Sax return ret;
6949ee3e066SJulian Sax }
6959ee3e066SJulian Sax
i2c_hid_output_report(struct hid_device * hid,u8 * buf,size_t count)696dbe0dd5fSDmitry Torokhov static int i2c_hid_output_report(struct hid_device *hid, u8 *buf, size_t count)
6979ee3e066SJulian Sax {
69885df7133SDmitry Torokhov return i2c_hid_output_raw_report(hid, HID_OUTPUT_REPORT, buf, count,
6999ee3e066SJulian Sax false);
7009ee3e066SJulian Sax }
7019ee3e066SJulian Sax
i2c_hid_raw_request(struct hid_device * hid,unsigned char reportnum,__u8 * buf,size_t len,unsigned char rtype,int reqtype)7029ee3e066SJulian Sax static int i2c_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
7039ee3e066SJulian Sax __u8 *buf, size_t len, unsigned char rtype,
7049ee3e066SJulian Sax int reqtype)
7059ee3e066SJulian Sax {
7069ee3e066SJulian Sax switch (reqtype) {
7079ee3e066SJulian Sax case HID_REQ_GET_REPORT:
70885df7133SDmitry Torokhov return i2c_hid_get_raw_report(hid, rtype, reportnum, buf, len);
7099ee3e066SJulian Sax case HID_REQ_SET_REPORT:
7109ee3e066SJulian Sax if (buf[0] != reportnum)
7119ee3e066SJulian Sax return -EINVAL;
71285df7133SDmitry Torokhov return i2c_hid_output_raw_report(hid, rtype, buf, len, true);
7139ee3e066SJulian Sax default:
7149ee3e066SJulian Sax return -EIO;
7159ee3e066SJulian Sax }
7169ee3e066SJulian Sax }
7179ee3e066SJulian Sax
i2c_hid_parse(struct hid_device * hid)7189ee3e066SJulian Sax static int i2c_hid_parse(struct hid_device *hid)
7199ee3e066SJulian Sax {
7209ee3e066SJulian Sax struct i2c_client *client = hid->driver_data;
7219ee3e066SJulian Sax struct i2c_hid *ihid = i2c_get_clientdata(client);
7229ee3e066SJulian Sax struct i2c_hid_desc *hdesc = &ihid->hdesc;
7239ee3e066SJulian Sax unsigned int rsize;
7249ee3e066SJulian Sax char *rdesc;
7259ee3e066SJulian Sax int ret;
7269ee3e066SJulian Sax int tries = 3;
7279ee3e066SJulian Sax char *use_override;
7289ee3e066SJulian Sax
7299ee3e066SJulian Sax i2c_hid_dbg(ihid, "entering %s\n", __func__);
7309ee3e066SJulian Sax
7319ee3e066SJulian Sax rsize = le16_to_cpu(hdesc->wReportDescLength);
7329ee3e066SJulian Sax if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
7339ee3e066SJulian Sax dbg_hid("weird size of report descriptor (%u)\n", rsize);
7349ee3e066SJulian Sax return -EINVAL;
7359ee3e066SJulian Sax }
7369ee3e066SJulian Sax
7379ee3e066SJulian Sax do {
738d34c6105SDmitry Torokhov ret = i2c_hid_hwreset(ihid);
7399ee3e066SJulian Sax if (ret)
7409ee3e066SJulian Sax msleep(1000);
7419ee3e066SJulian Sax } while (tries-- > 0 && ret);
7429ee3e066SJulian Sax
7439ee3e066SJulian Sax if (ret)
7449ee3e066SJulian Sax return ret;
7459ee3e066SJulian Sax
7469ee3e066SJulian Sax use_override = i2c_hid_get_dmi_hid_report_desc_override(client->name,
7479ee3e066SJulian Sax &rsize);
7489ee3e066SJulian Sax
7499ee3e066SJulian Sax if (use_override) {
7509ee3e066SJulian Sax rdesc = use_override;
7519ee3e066SJulian Sax i2c_hid_dbg(ihid, "Using a HID report descriptor override\n");
7529ee3e066SJulian Sax } else {
7539ee3e066SJulian Sax rdesc = kzalloc(rsize, GFP_KERNEL);
7549ee3e066SJulian Sax
7559ee3e066SJulian Sax if (!rdesc) {
7569ee3e066SJulian Sax dbg_hid("couldn't allocate rdesc memory\n");
7579ee3e066SJulian Sax return -ENOMEM;
7589ee3e066SJulian Sax }
7599ee3e066SJulian Sax
7609ee3e066SJulian Sax i2c_hid_dbg(ihid, "asking HID report descriptor\n");
7619ee3e066SJulian Sax
7628399bd01SDmitry Torokhov ret = i2c_hid_read_register(ihid,
7638399bd01SDmitry Torokhov ihid->hdesc.wReportDescRegister,
7649ee3e066SJulian Sax rdesc, rsize);
7659ee3e066SJulian Sax if (ret) {
7669ee3e066SJulian Sax hid_err(hid, "reading report descriptor failed\n");
7679ee3e066SJulian Sax kfree(rdesc);
7689ee3e066SJulian Sax return -EIO;
7699ee3e066SJulian Sax }
7709ee3e066SJulian Sax }
7719ee3e066SJulian Sax
7729ee3e066SJulian Sax i2c_hid_dbg(ihid, "Report Descriptor: %*ph\n", rsize, rdesc);
7739ee3e066SJulian Sax
7749ee3e066SJulian Sax ret = hid_parse_report(hid, rdesc, rsize);
7759ee3e066SJulian Sax if (!use_override)
7769ee3e066SJulian Sax kfree(rdesc);
7779ee3e066SJulian Sax
7789ee3e066SJulian Sax if (ret) {
7799ee3e066SJulian Sax dbg_hid("parsing report descriptor failed\n");
7809ee3e066SJulian Sax return ret;
7819ee3e066SJulian Sax }
7829ee3e066SJulian Sax
7839ee3e066SJulian Sax return 0;
7849ee3e066SJulian Sax }
7859ee3e066SJulian Sax
i2c_hid_start(struct hid_device * hid)7869ee3e066SJulian Sax static int i2c_hid_start(struct hid_device *hid)
7879ee3e066SJulian Sax {
7889ee3e066SJulian Sax struct i2c_client *client = hid->driver_data;
7899ee3e066SJulian Sax struct i2c_hid *ihid = i2c_get_clientdata(client);
7909ee3e066SJulian Sax int ret;
7919ee3e066SJulian Sax unsigned int bufsize = HID_MIN_BUFFER_SIZE;
7929ee3e066SJulian Sax
7939ee3e066SJulian Sax i2c_hid_find_max_report(hid, HID_INPUT_REPORT, &bufsize);
7949ee3e066SJulian Sax i2c_hid_find_max_report(hid, HID_OUTPUT_REPORT, &bufsize);
7959ee3e066SJulian Sax i2c_hid_find_max_report(hid, HID_FEATURE_REPORT, &bufsize);
7969ee3e066SJulian Sax
7979ee3e066SJulian Sax if (bufsize > ihid->bufsize) {
7989ee3e066SJulian Sax disable_irq(client->irq);
7999ee3e066SJulian Sax i2c_hid_free_buffers(ihid);
8009ee3e066SJulian Sax
8019ee3e066SJulian Sax ret = i2c_hid_alloc_buffers(ihid, bufsize);
8029ee3e066SJulian Sax enable_irq(client->irq);
8039ee3e066SJulian Sax
8049ee3e066SJulian Sax if (ret)
8059ee3e066SJulian Sax return ret;
8069ee3e066SJulian Sax }
8079ee3e066SJulian Sax
8089ee3e066SJulian Sax return 0;
8099ee3e066SJulian Sax }
8109ee3e066SJulian Sax
i2c_hid_stop(struct hid_device * hid)8119ee3e066SJulian Sax static void i2c_hid_stop(struct hid_device *hid)
8129ee3e066SJulian Sax {
8139ee3e066SJulian Sax hid->claimed = 0;
8149ee3e066SJulian Sax }
8159ee3e066SJulian Sax
i2c_hid_open(struct hid_device * hid)8169ee3e066SJulian Sax static int i2c_hid_open(struct hid_device *hid)
8179ee3e066SJulian Sax {
8189ee3e066SJulian Sax struct i2c_client *client = hid->driver_data;
8199ee3e066SJulian Sax struct i2c_hid *ihid = i2c_get_clientdata(client);
8209ee3e066SJulian Sax
8219ee3e066SJulian Sax set_bit(I2C_HID_STARTED, &ihid->flags);
8229ee3e066SJulian Sax return 0;
8239ee3e066SJulian Sax }
8249ee3e066SJulian Sax
i2c_hid_close(struct hid_device * hid)8259ee3e066SJulian Sax static void i2c_hid_close(struct hid_device *hid)
8269ee3e066SJulian Sax {
8279ee3e066SJulian Sax struct i2c_client *client = hid->driver_data;
8289ee3e066SJulian Sax struct i2c_hid *ihid = i2c_get_clientdata(client);
8299ee3e066SJulian Sax
8309ee3e066SJulian Sax clear_bit(I2C_HID_STARTED, &ihid->flags);
8319ee3e066SJulian Sax }
8329ee3e066SJulian Sax
83352d22534SThomas Weißschuh static const struct hid_ll_driver i2c_hid_ll_driver = {
8349ee3e066SJulian Sax .parse = i2c_hid_parse,
8359ee3e066SJulian Sax .start = i2c_hid_start,
8369ee3e066SJulian Sax .stop = i2c_hid_stop,
8379ee3e066SJulian Sax .open = i2c_hid_open,
8389ee3e066SJulian Sax .close = i2c_hid_close,
8399ee3e066SJulian Sax .output_report = i2c_hid_output_report,
8409ee3e066SJulian Sax .raw_request = i2c_hid_raw_request,
8419ee3e066SJulian Sax };
8429ee3e066SJulian Sax
i2c_hid_init_irq(struct i2c_client * client)8439ee3e066SJulian Sax static int i2c_hid_init_irq(struct i2c_client *client)
8449ee3e066SJulian Sax {
8459ee3e066SJulian Sax struct i2c_hid *ihid = i2c_get_clientdata(client);
8469ee3e066SJulian Sax unsigned long irqflags = 0;
8479ee3e066SJulian Sax int ret;
8489ee3e066SJulian Sax
849f639e0b6SThomas Weißschuh i2c_hid_dbg(ihid, "Requesting IRQ: %d\n", client->irq);
8509ee3e066SJulian Sax
8519ee3e066SJulian Sax if (!irq_get_trigger_type(client->irq))
8529ee3e066SJulian Sax irqflags = IRQF_TRIGGER_LOW;
8539ee3e066SJulian Sax
8549ee3e066SJulian Sax ret = request_threaded_irq(client->irq, NULL, i2c_hid_irq,
855675cd877SDouglas Anderson irqflags | IRQF_ONESHOT | IRQF_NO_AUTOEN,
856675cd877SDouglas Anderson client->name, ihid);
8579ee3e066SJulian Sax if (ret < 0) {
8589ee3e066SJulian Sax dev_warn(&client->dev,
8599ee3e066SJulian Sax "Could not register for %s interrupt, irq = %d,"
8609ee3e066SJulian Sax " ret = %d\n",
8619ee3e066SJulian Sax client->name, client->irq, ret);
8629ee3e066SJulian Sax
8639ee3e066SJulian Sax return ret;
8649ee3e066SJulian Sax }
8659ee3e066SJulian Sax
8669ee3e066SJulian Sax return 0;
8679ee3e066SJulian Sax }
8689ee3e066SJulian Sax
i2c_hid_fetch_hid_descriptor(struct i2c_hid * ihid)8699ee3e066SJulian Sax static int i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid)
8709ee3e066SJulian Sax {
8719ee3e066SJulian Sax struct i2c_client *client = ihid->client;
8729ee3e066SJulian Sax struct i2c_hid_desc *hdesc = &ihid->hdesc;
8739ee3e066SJulian Sax unsigned int dsize;
8748399bd01SDmitry Torokhov int error;
8759ee3e066SJulian Sax
8769ee3e066SJulian Sax /* i2c hid fetch using a fixed descriptor size (30 bytes) */
8779ee3e066SJulian Sax if (i2c_hid_get_dmi_i2c_hid_desc_override(client->name)) {
8789ee3e066SJulian Sax i2c_hid_dbg(ihid, "Using a HID descriptor override\n");
8799ee3e066SJulian Sax ihid->hdesc =
8809ee3e066SJulian Sax *i2c_hid_get_dmi_i2c_hid_desc_override(client->name);
8819ee3e066SJulian Sax } else {
8829ee3e066SJulian Sax i2c_hid_dbg(ihid, "Fetching the HID descriptor\n");
8838399bd01SDmitry Torokhov error = i2c_hid_read_register(ihid,
8848399bd01SDmitry Torokhov ihid->wHIDDescRegister,
8858399bd01SDmitry Torokhov &ihid->hdesc,
8868399bd01SDmitry Torokhov sizeof(ihid->hdesc));
8878399bd01SDmitry Torokhov if (error) {
8888399bd01SDmitry Torokhov dev_err(&ihid->client->dev,
8898399bd01SDmitry Torokhov "failed to fetch HID descriptor: %d\n",
8908399bd01SDmitry Torokhov error);
8919ee3e066SJulian Sax return -ENODEV;
8929ee3e066SJulian Sax }
8939ee3e066SJulian Sax }
8949ee3e066SJulian Sax
8959ee3e066SJulian Sax /* Validate the length of HID descriptor, the 4 first bytes:
8969ee3e066SJulian Sax * bytes 0-1 -> length
8979ee3e066SJulian Sax * bytes 2-3 -> bcdVersion (has to be 1.00) */
8989ee3e066SJulian Sax /* check bcdVersion == 1.0 */
8999ee3e066SJulian Sax if (le16_to_cpu(hdesc->bcdVersion) != 0x0100) {
900d34c6105SDmitry Torokhov dev_err(&ihid->client->dev,
9019ee3e066SJulian Sax "unexpected HID descriptor bcdVersion (0x%04hx)\n",
9029ee3e066SJulian Sax le16_to_cpu(hdesc->bcdVersion));
9039ee3e066SJulian Sax return -ENODEV;
9049ee3e066SJulian Sax }
9059ee3e066SJulian Sax
9069ee3e066SJulian Sax /* Descriptor length should be 30 bytes as per the specification */
9079ee3e066SJulian Sax dsize = le16_to_cpu(hdesc->wHIDDescLength);
9089ee3e066SJulian Sax if (dsize != sizeof(struct i2c_hid_desc)) {
909d34c6105SDmitry Torokhov dev_err(&ihid->client->dev,
910d34c6105SDmitry Torokhov "weird size of HID descriptor (%u)\n", dsize);
9119ee3e066SJulian Sax return -ENODEV;
9129ee3e066SJulian Sax }
913551117c5SDmitry Torokhov i2c_hid_dbg(ihid, "HID Descriptor: %*ph\n", dsize, &ihid->hdesc);
9149ee3e066SJulian Sax return 0;
9159ee3e066SJulian Sax }
9169ee3e066SJulian Sax
i2c_hid_core_power_up(struct i2c_hid * ihid)917b33752c3SDouglas Anderson static int i2c_hid_core_power_up(struct i2c_hid *ihid)
9189ee3e066SJulian Sax {
919b33752c3SDouglas Anderson if (!ihid->ops->power_up)
9209ee3e066SJulian Sax return 0;
921b33752c3SDouglas Anderson
922b33752c3SDouglas Anderson return ihid->ops->power_up(ihid->ops);
9239ee3e066SJulian Sax }
9249ee3e066SJulian Sax
i2c_hid_core_power_down(struct i2c_hid * ihid)925b33752c3SDouglas Anderson static void i2c_hid_core_power_down(struct i2c_hid *ihid)
9269ee3e066SJulian Sax {
927b33752c3SDouglas Anderson if (!ihid->ops->power_down)
928b33752c3SDouglas Anderson return;
9299ee3e066SJulian Sax
930b33752c3SDouglas Anderson ihid->ops->power_down(ihid->ops);
9319ee3e066SJulian Sax }
9329ee3e066SJulian Sax
i2c_hid_core_shutdown_tail(struct i2c_hid * ihid)933b33752c3SDouglas Anderson static void i2c_hid_core_shutdown_tail(struct i2c_hid *ihid)
934203c38fbSKai-Heng Feng {
935b33752c3SDouglas Anderson if (!ihid->ops->shutdown_tail)
936b33752c3SDouglas Anderson return;
937b33752c3SDouglas Anderson
938b33752c3SDouglas Anderson ihid->ops->shutdown_tail(ihid->ops);
939203c38fbSKai-Heng Feng }
940203c38fbSKai-Heng Feng
i2c_hid_core_suspend(struct i2c_hid * ihid,bool force_poweroff)9415f8838e9SDouglas Anderson static int i2c_hid_core_suspend(struct i2c_hid *ihid, bool force_poweroff)
942d93d2847SDouglas Anderson {
943d93d2847SDouglas Anderson struct i2c_client *client = ihid->client;
944d93d2847SDouglas Anderson struct hid_device *hid = ihid->hid;
945d93d2847SDouglas Anderson int ret;
946d93d2847SDouglas Anderson
947d93d2847SDouglas Anderson ret = hid_driver_suspend(hid, PMSG_SUSPEND);
948d93d2847SDouglas Anderson if (ret < 0)
949d93d2847SDouglas Anderson return ret;
950d93d2847SDouglas Anderson
951d93d2847SDouglas Anderson /* Save some power */
952d93d2847SDouglas Anderson i2c_hid_set_power(ihid, I2C_HID_PWR_SLEEP);
953d93d2847SDouglas Anderson
954d93d2847SDouglas Anderson disable_irq(client->irq);
955d93d2847SDouglas Anderson
9565f8838e9SDouglas Anderson if (force_poweroff || !device_may_wakeup(&client->dev))
957d93d2847SDouglas Anderson i2c_hid_core_power_down(ihid);
958d93d2847SDouglas Anderson
959d93d2847SDouglas Anderson return 0;
960d93d2847SDouglas Anderson }
961d93d2847SDouglas Anderson
i2c_hid_core_resume(struct i2c_hid * ihid)962d93d2847SDouglas Anderson static int i2c_hid_core_resume(struct i2c_hid *ihid)
963d93d2847SDouglas Anderson {
964d93d2847SDouglas Anderson struct i2c_client *client = ihid->client;
965d93d2847SDouglas Anderson struct hid_device *hid = ihid->hid;
966d93d2847SDouglas Anderson int ret;
967d93d2847SDouglas Anderson
968d93d2847SDouglas Anderson if (!device_may_wakeup(&client->dev))
969d93d2847SDouglas Anderson i2c_hid_core_power_up(ihid);
970d93d2847SDouglas Anderson
971d93d2847SDouglas Anderson enable_irq(client->irq);
972d93d2847SDouglas Anderson
973d93d2847SDouglas Anderson /* Instead of resetting device, simply powers the device on. This
974d93d2847SDouglas Anderson * solves "incomplete reports" on Raydium devices 2386:3118 and
975d93d2847SDouglas Anderson * 2386:4B33 and fixes various SIS touchscreens no longer sending
976d93d2847SDouglas Anderson * data after a suspend/resume.
977d93d2847SDouglas Anderson *
978d93d2847SDouglas Anderson * However some ALPS touchpads generate IRQ storm without reset, so
979d93d2847SDouglas Anderson * let's still reset them here.
980d93d2847SDouglas Anderson */
981d93d2847SDouglas Anderson if (ihid->quirks & I2C_HID_QUIRK_RESET_ON_RESUME)
982d93d2847SDouglas Anderson ret = i2c_hid_hwreset(ihid);
983d93d2847SDouglas Anderson else
984d93d2847SDouglas Anderson ret = i2c_hid_set_power(ihid, I2C_HID_PWR_ON);
985d93d2847SDouglas Anderson
986d93d2847SDouglas Anderson if (ret)
987d93d2847SDouglas Anderson return ret;
988d93d2847SDouglas Anderson
989d93d2847SDouglas Anderson return hid_driver_reset_resume(hid);
990d93d2847SDouglas Anderson }
991d93d2847SDouglas Anderson
992*9af867c0SJohan Hovold /*
993*9af867c0SJohan Hovold * Check that the device exists and parse the HID descriptor.
994675cd877SDouglas Anderson */
__i2c_hid_core_probe(struct i2c_hid * ihid)995*9af867c0SJohan Hovold static int __i2c_hid_core_probe(struct i2c_hid *ihid)
996675cd877SDouglas Anderson {
997675cd877SDouglas Anderson struct i2c_client *client = ihid->client;
998675cd877SDouglas Anderson struct hid_device *hid = ihid->hid;
999675cd877SDouglas Anderson int ret;
1000675cd877SDouglas Anderson
1001675cd877SDouglas Anderson /* Make sure there is something at this address */
1002675cd877SDouglas Anderson ret = i2c_smbus_read_byte(client);
1003675cd877SDouglas Anderson if (ret < 0) {
1004675cd877SDouglas Anderson i2c_hid_dbg(ihid, "nothing at this address: %d\n", ret);
1005*9af867c0SJohan Hovold return -ENXIO;
1006675cd877SDouglas Anderson }
1007675cd877SDouglas Anderson
1008675cd877SDouglas Anderson ret = i2c_hid_fetch_hid_descriptor(ihid);
1009675cd877SDouglas Anderson if (ret < 0) {
1010675cd877SDouglas Anderson dev_err(&client->dev,
1011675cd877SDouglas Anderson "Failed to fetch the HID Descriptor\n");
1012*9af867c0SJohan Hovold return ret;
1013675cd877SDouglas Anderson }
1014675cd877SDouglas Anderson
1015675cd877SDouglas Anderson hid->version = le16_to_cpu(ihid->hdesc.bcdVersion);
1016675cd877SDouglas Anderson hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID);
1017675cd877SDouglas Anderson hid->product = le16_to_cpu(ihid->hdesc.wProductID);
1018675cd877SDouglas Anderson
1019675cd877SDouglas Anderson hid->initial_quirks |= i2c_hid_get_dmi_quirks(hid->vendor,
1020675cd877SDouglas Anderson hid->product);
1021675cd877SDouglas Anderson
1022675cd877SDouglas Anderson snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X",
1023675cd877SDouglas Anderson client->name, (u16)hid->vendor, (u16)hid->product);
1024675cd877SDouglas Anderson strscpy(hid->phys, dev_name(&client->dev), sizeof(hid->phys));
1025675cd877SDouglas Anderson
1026675cd877SDouglas Anderson ihid->quirks = i2c_hid_lookup_quirk(hid->vendor, hid->product);
1027675cd877SDouglas Anderson
1028*9af867c0SJohan Hovold return 0;
1029*9af867c0SJohan Hovold }
1030*9af867c0SJohan Hovold
i2c_hid_core_register_hid(struct i2c_hid * ihid)1031*9af867c0SJohan Hovold static int i2c_hid_core_register_hid(struct i2c_hid *ihid)
1032*9af867c0SJohan Hovold {
1033*9af867c0SJohan Hovold struct i2c_client *client = ihid->client;
1034*9af867c0SJohan Hovold struct hid_device *hid = ihid->hid;
1035*9af867c0SJohan Hovold int ret;
1036*9af867c0SJohan Hovold
1037*9af867c0SJohan Hovold enable_irq(client->irq);
1038*9af867c0SJohan Hovold
1039675cd877SDouglas Anderson ret = hid_add_device(hid);
1040675cd877SDouglas Anderson if (ret) {
1041675cd877SDouglas Anderson if (ret != -ENODEV)
1042675cd877SDouglas Anderson hid_err(client, "can't add hid device: %d\n", ret);
1043*9af867c0SJohan Hovold disable_irq(client->irq);
1044*9af867c0SJohan Hovold return ret;
1045675cd877SDouglas Anderson }
1046675cd877SDouglas Anderson
1047675cd877SDouglas Anderson return 0;
1048*9af867c0SJohan Hovold }
1049675cd877SDouglas Anderson
i2c_hid_core_probe_panel_follower(struct i2c_hid * ihid)1050*9af867c0SJohan Hovold static int i2c_hid_core_probe_panel_follower(struct i2c_hid *ihid)
1051*9af867c0SJohan Hovold {
1052*9af867c0SJohan Hovold int ret;
1053*9af867c0SJohan Hovold
1054*9af867c0SJohan Hovold ret = i2c_hid_core_power_up(ihid);
1055*9af867c0SJohan Hovold if (ret)
1056*9af867c0SJohan Hovold return ret;
1057*9af867c0SJohan Hovold
1058*9af867c0SJohan Hovold ret = __i2c_hid_core_probe(ihid);
1059*9af867c0SJohan Hovold if (ret)
1060*9af867c0SJohan Hovold goto err_power_down;
1061*9af867c0SJohan Hovold
1062*9af867c0SJohan Hovold ret = i2c_hid_core_register_hid(ihid);
1063*9af867c0SJohan Hovold if (ret)
1064*9af867c0SJohan Hovold goto err_power_down;
1065*9af867c0SJohan Hovold
1066*9af867c0SJohan Hovold return 0;
1067*9af867c0SJohan Hovold
1068*9af867c0SJohan Hovold err_power_down:
1069675cd877SDouglas Anderson i2c_hid_core_power_down(ihid);
1070*9af867c0SJohan Hovold
1071675cd877SDouglas Anderson return ret;
1072675cd877SDouglas Anderson }
1073675cd877SDouglas Anderson
ihid_core_panel_prepare_work(struct work_struct * work)107476edfcf4SDouglas Anderson static void ihid_core_panel_prepare_work(struct work_struct *work)
107596a37bfdSDouglas Anderson {
107676edfcf4SDouglas Anderson struct i2c_hid *ihid = container_of(work, struct i2c_hid,
107776edfcf4SDouglas Anderson panel_follower_prepare_work);
107896a37bfdSDouglas Anderson struct hid_device *hid = ihid->hid;
107976edfcf4SDouglas Anderson int ret;
108096a37bfdSDouglas Anderson
108196a37bfdSDouglas Anderson /*
108296a37bfdSDouglas Anderson * hid->version is set on the first power up. If it's still zero then
108396a37bfdSDouglas Anderson * this is the first power on so we should perform initial power up
108496a37bfdSDouglas Anderson * steps.
108596a37bfdSDouglas Anderson */
108696a37bfdSDouglas Anderson if (!hid->version)
1087*9af867c0SJohan Hovold ret = i2c_hid_core_probe_panel_follower(ihid);
108876edfcf4SDouglas Anderson else
108976edfcf4SDouglas Anderson ret = i2c_hid_core_resume(ihid);
109096a37bfdSDouglas Anderson
109176edfcf4SDouglas Anderson if (ret)
109276edfcf4SDouglas Anderson dev_warn(&ihid->client->dev, "Power on failed: %d\n", ret);
109376edfcf4SDouglas Anderson else
109476edfcf4SDouglas Anderson WRITE_ONCE(ihid->prepare_work_finished, true);
109576edfcf4SDouglas Anderson
109676edfcf4SDouglas Anderson /*
109776edfcf4SDouglas Anderson * The work APIs provide a number of memory ordering guarantees
109876edfcf4SDouglas Anderson * including one that says that memory writes before schedule_work()
109976edfcf4SDouglas Anderson * are always visible to the work function, but they don't appear to
110076edfcf4SDouglas Anderson * guarantee that a write that happened in the work is visible after
110176edfcf4SDouglas Anderson * cancel_work_sync(). We'll add a write memory barrier here to match
110276edfcf4SDouglas Anderson * with i2c_hid_core_panel_unpreparing() to ensure that our write to
110376edfcf4SDouglas Anderson * prepare_work_finished is visible there.
110476edfcf4SDouglas Anderson */
110576edfcf4SDouglas Anderson smp_wmb();
110676edfcf4SDouglas Anderson }
110776edfcf4SDouglas Anderson
i2c_hid_core_panel_prepared(struct drm_panel_follower * follower)110876edfcf4SDouglas Anderson static int i2c_hid_core_panel_prepared(struct drm_panel_follower *follower)
110976edfcf4SDouglas Anderson {
111076edfcf4SDouglas Anderson struct i2c_hid *ihid = container_of(follower, struct i2c_hid, panel_follower);
111176edfcf4SDouglas Anderson
111276edfcf4SDouglas Anderson /*
111376edfcf4SDouglas Anderson * Powering on a touchscreen can be a slow process. Queue the work to
111476edfcf4SDouglas Anderson * the system workqueue so we don't block the panel's power up.
111576edfcf4SDouglas Anderson */
111676edfcf4SDouglas Anderson WRITE_ONCE(ihid->prepare_work_finished, false);
111776edfcf4SDouglas Anderson schedule_work(&ihid->panel_follower_prepare_work);
111876edfcf4SDouglas Anderson
111976edfcf4SDouglas Anderson return 0;
112096a37bfdSDouglas Anderson }
112196a37bfdSDouglas Anderson
i2c_hid_core_panel_unpreparing(struct drm_panel_follower * follower)112296a37bfdSDouglas Anderson static int i2c_hid_core_panel_unpreparing(struct drm_panel_follower *follower)
112396a37bfdSDouglas Anderson {
112496a37bfdSDouglas Anderson struct i2c_hid *ihid = container_of(follower, struct i2c_hid, panel_follower);
112596a37bfdSDouglas Anderson
112676edfcf4SDouglas Anderson cancel_work_sync(&ihid->panel_follower_prepare_work);
112776edfcf4SDouglas Anderson
112876edfcf4SDouglas Anderson /* Match with ihid_core_panel_prepare_work() */
112976edfcf4SDouglas Anderson smp_rmb();
113076edfcf4SDouglas Anderson if (!READ_ONCE(ihid->prepare_work_finished))
113176edfcf4SDouglas Anderson return 0;
113276edfcf4SDouglas Anderson
113396a37bfdSDouglas Anderson return i2c_hid_core_suspend(ihid, true);
113496a37bfdSDouglas Anderson }
113596a37bfdSDouglas Anderson
113696a37bfdSDouglas Anderson static const struct drm_panel_follower_funcs i2c_hid_core_panel_follower_funcs = {
113796a37bfdSDouglas Anderson .panel_prepared = i2c_hid_core_panel_prepared,
113896a37bfdSDouglas Anderson .panel_unpreparing = i2c_hid_core_panel_unpreparing,
113996a37bfdSDouglas Anderson };
114096a37bfdSDouglas Anderson
i2c_hid_core_register_panel_follower(struct i2c_hid * ihid)114196a37bfdSDouglas Anderson static int i2c_hid_core_register_panel_follower(struct i2c_hid *ihid)
114296a37bfdSDouglas Anderson {
114396a37bfdSDouglas Anderson struct device *dev = &ihid->client->dev;
114496a37bfdSDouglas Anderson int ret;
114596a37bfdSDouglas Anderson
114696a37bfdSDouglas Anderson ihid->panel_follower.funcs = &i2c_hid_core_panel_follower_funcs;
114796a37bfdSDouglas Anderson
114896a37bfdSDouglas Anderson /*
114996a37bfdSDouglas Anderson * If we're not in control of our own power up/power down then we can't
115096a37bfdSDouglas Anderson * do the logic to manage wakeups. Give a warning if a user thought
115196a37bfdSDouglas Anderson * that was possible then force the capability off.
115296a37bfdSDouglas Anderson */
115396a37bfdSDouglas Anderson if (device_can_wakeup(dev)) {
115496a37bfdSDouglas Anderson dev_warn(dev, "Can't wakeup if following panel\n");
115596a37bfdSDouglas Anderson device_set_wakeup_capable(dev, false);
115696a37bfdSDouglas Anderson }
115796a37bfdSDouglas Anderson
115896a37bfdSDouglas Anderson ret = drm_panel_add_follower(dev, &ihid->panel_follower);
115996a37bfdSDouglas Anderson if (ret)
116096a37bfdSDouglas Anderson return ret;
116196a37bfdSDouglas Anderson
116296a37bfdSDouglas Anderson return 0;
116396a37bfdSDouglas Anderson }
116496a37bfdSDouglas Anderson
i2c_hid_core_probe(struct i2c_client * client,struct i2chid_ops * ops,u16 hid_descriptor_address,u32 quirks)1165b33752c3SDouglas Anderson int i2c_hid_core_probe(struct i2c_client *client, struct i2chid_ops *ops,
1166b60d3c80SAlistair Francis u16 hid_descriptor_address, u32 quirks)
11679ee3e066SJulian Sax {
11689ee3e066SJulian Sax int ret;
11699ee3e066SJulian Sax struct i2c_hid *ihid;
11709ee3e066SJulian Sax struct hid_device *hid;
11719ee3e066SJulian Sax
11729ee3e066SJulian Sax dbg_hid("HID probe called for i2c 0x%02x\n", client->addr);
11739ee3e066SJulian Sax
11749ee3e066SJulian Sax if (!client->irq) {
11759ee3e066SJulian Sax dev_err(&client->dev,
11769ee3e066SJulian Sax "HID over i2c has not been provided an Int IRQ\n");
11779ee3e066SJulian Sax return -EINVAL;
11789ee3e066SJulian Sax }
11799ee3e066SJulian Sax
11809ee3e066SJulian Sax if (client->irq < 0) {
11819ee3e066SJulian Sax if (client->irq != -EPROBE_DEFER)
11829ee3e066SJulian Sax dev_err(&client->dev,
11839ee3e066SJulian Sax "HID over i2c doesn't have a valid IRQ\n");
11849ee3e066SJulian Sax return client->irq;
11859ee3e066SJulian Sax }
11869ee3e066SJulian Sax
11879ee3e066SJulian Sax ihid = devm_kzalloc(&client->dev, sizeof(*ihid), GFP_KERNEL);
11889ee3e066SJulian Sax if (!ihid)
11899ee3e066SJulian Sax return -ENOMEM;
11909ee3e066SJulian Sax
11919ee3e066SJulian Sax i2c_set_clientdata(client, ihid);
11929ee3e066SJulian Sax
1193675cd877SDouglas Anderson ihid->ops = ops;
11949ee3e066SJulian Sax ihid->client = client;
1195b33752c3SDouglas Anderson ihid->wHIDDescRegister = cpu_to_le16(hid_descriptor_address);
1196*9af867c0SJohan Hovold ihid->is_panel_follower = drm_is_panel_follower(&client->dev);
11979ee3e066SJulian Sax
11989ee3e066SJulian Sax init_waitqueue_head(&ihid->wait);
11999ee3e066SJulian Sax mutex_init(&ihid->reset_lock);
120076edfcf4SDouglas Anderson INIT_WORK(&ihid->panel_follower_prepare_work, ihid_core_panel_prepare_work);
12019ee3e066SJulian Sax
12029ee3e066SJulian Sax /* we need to allocate the command buffer without knowing the maximum
12039ee3e066SJulian Sax * size of the reports. Let's use HID_MIN_BUFFER_SIZE, then we do the
12049ee3e066SJulian Sax * real computation later. */
12059ee3e066SJulian Sax ret = i2c_hid_alloc_buffers(ihid, HID_MIN_BUFFER_SIZE);
12069ee3e066SJulian Sax if (ret < 0)
1207675cd877SDouglas Anderson return ret;
12089ee3e066SJulian Sax device_enable_async_suspend(&client->dev);
12099ee3e066SJulian Sax
12109ee3e066SJulian Sax hid = hid_allocate_device();
12119ee3e066SJulian Sax if (IS_ERR(hid)) {
12129ee3e066SJulian Sax ret = PTR_ERR(hid);
1213*9af867c0SJohan Hovold goto err_free_buffers;
12149ee3e066SJulian Sax }
12159ee3e066SJulian Sax
12169ee3e066SJulian Sax ihid->hid = hid;
12179ee3e066SJulian Sax
12189ee3e066SJulian Sax hid->driver_data = client;
12199ee3e066SJulian Sax hid->ll_driver = &i2c_hid_ll_driver;
12209ee3e066SJulian Sax hid->dev.parent = &client->dev;
12219ee3e066SJulian Sax hid->bus = BUS_I2C;
122203a86105SDmitry Torokhov hid->initial_quirks = quirks;
122303a86105SDmitry Torokhov
1224*9af867c0SJohan Hovold /* Power on and probe unless device is a panel follower. */
1225*9af867c0SJohan Hovold if (!ihid->is_panel_follower) {
1226*9af867c0SJohan Hovold ret = i2c_hid_core_power_up(ihid);
1227*9af867c0SJohan Hovold if (ret < 0)
1228*9af867c0SJohan Hovold goto err_destroy_device;
1229*9af867c0SJohan Hovold
1230*9af867c0SJohan Hovold ret = __i2c_hid_core_probe(ihid);
1231*9af867c0SJohan Hovold if (ret < 0)
1232*9af867c0SJohan Hovold goto err_power_down;
1233*9af867c0SJohan Hovold }
1234*9af867c0SJohan Hovold
1235*9af867c0SJohan Hovold ret = i2c_hid_init_irq(client);
1236*9af867c0SJohan Hovold if (ret < 0)
1237*9af867c0SJohan Hovold goto err_power_down;
1238*9af867c0SJohan Hovold
1239*9af867c0SJohan Hovold /*
1240*9af867c0SJohan Hovold * If we're a panel follower, we'll register when the panel turns on;
1241*9af867c0SJohan Hovold * otherwise we do it right away.
1242*9af867c0SJohan Hovold */
1243*9af867c0SJohan Hovold if (ihid->is_panel_follower)
1244*9af867c0SJohan Hovold ret = i2c_hid_core_register_panel_follower(ihid);
1245*9af867c0SJohan Hovold else
1246*9af867c0SJohan Hovold ret = i2c_hid_core_register_hid(ihid);
1247675cd877SDouglas Anderson if (ret)
1248*9af867c0SJohan Hovold goto err_free_irq;
12499ee3e066SJulian Sax
12509ee3e066SJulian Sax return 0;
12519ee3e066SJulian Sax
1252*9af867c0SJohan Hovold err_free_irq:
12539ee3e066SJulian Sax free_irq(client->irq, ihid);
1254*9af867c0SJohan Hovold err_power_down:
1255*9af867c0SJohan Hovold if (!ihid->is_panel_follower)
1256*9af867c0SJohan Hovold i2c_hid_core_power_down(ihid);
1257*9af867c0SJohan Hovold err_destroy_device:
1258*9af867c0SJohan Hovold hid_destroy_device(hid);
1259*9af867c0SJohan Hovold err_free_buffers:
12609ee3e066SJulian Sax i2c_hid_free_buffers(ihid);
1261675cd877SDouglas Anderson
12629ee3e066SJulian Sax return ret;
12639ee3e066SJulian Sax }
1264b33752c3SDouglas Anderson EXPORT_SYMBOL_GPL(i2c_hid_core_probe);
12659ee3e066SJulian Sax
i2c_hid_core_remove(struct i2c_client * client)1266ed5c2f5fSUwe Kleine-König void i2c_hid_core_remove(struct i2c_client *client)
12679ee3e066SJulian Sax {
12689ee3e066SJulian Sax struct i2c_hid *ihid = i2c_get_clientdata(client);
12699ee3e066SJulian Sax struct hid_device *hid;
12709ee3e066SJulian Sax
1271*9af867c0SJohan Hovold /*
1272*9af867c0SJohan Hovold * If we're a follower, the act of unfollowing will cause us to be
1273*9af867c0SJohan Hovold * powered down. Otherwise we need to manually do it.
1274*9af867c0SJohan Hovold */
1275*9af867c0SJohan Hovold if (ihid->is_panel_follower)
1276*9af867c0SJohan Hovold drm_panel_remove_follower(&ihid->panel_follower);
1277*9af867c0SJohan Hovold else
1278*9af867c0SJohan Hovold i2c_hid_core_suspend(ihid, true);
1279675cd877SDouglas Anderson
12809ee3e066SJulian Sax hid = ihid->hid;
12819ee3e066SJulian Sax hid_destroy_device(hid);
12829ee3e066SJulian Sax
12839ee3e066SJulian Sax free_irq(client->irq, ihid);
12849ee3e066SJulian Sax
12859ee3e066SJulian Sax if (ihid->bufsize)
12869ee3e066SJulian Sax i2c_hid_free_buffers(ihid);
12879ee3e066SJulian Sax }
1288b33752c3SDouglas Anderson EXPORT_SYMBOL_GPL(i2c_hid_core_remove);
12899ee3e066SJulian Sax
i2c_hid_core_shutdown(struct i2c_client * client)1290b33752c3SDouglas Anderson void i2c_hid_core_shutdown(struct i2c_client *client)
12919ee3e066SJulian Sax {
12929ee3e066SJulian Sax struct i2c_hid *ihid = i2c_get_clientdata(client);
12939ee3e066SJulian Sax
1294d34c6105SDmitry Torokhov i2c_hid_set_power(ihid, I2C_HID_PWR_SLEEP);
12959ee3e066SJulian Sax free_irq(client->irq, ihid);
12965c7e02a8SHans de Goede
1297b33752c3SDouglas Anderson i2c_hid_core_shutdown_tail(ihid);
12989ee3e066SJulian Sax }
1299b33752c3SDouglas Anderson EXPORT_SYMBOL_GPL(i2c_hid_core_shutdown);
13009ee3e066SJulian Sax
i2c_hid_core_pm_suspend(struct device * dev)1301d93d2847SDouglas Anderson static int i2c_hid_core_pm_suspend(struct device *dev)
13029ee3e066SJulian Sax {
13039ee3e066SJulian Sax struct i2c_client *client = to_i2c_client(dev);
13049ee3e066SJulian Sax struct i2c_hid *ihid = i2c_get_clientdata(client);
13059ee3e066SJulian Sax
130696a37bfdSDouglas Anderson if (ihid->is_panel_follower)
130796a37bfdSDouglas Anderson return 0;
130896a37bfdSDouglas Anderson
13095f8838e9SDouglas Anderson return i2c_hid_core_suspend(ihid, false);
13109ee3e066SJulian Sax }
13119ee3e066SJulian Sax
i2c_hid_core_pm_resume(struct device * dev)1312d93d2847SDouglas Anderson static int i2c_hid_core_pm_resume(struct device *dev)
13139ee3e066SJulian Sax {
13149ee3e066SJulian Sax struct i2c_client *client = to_i2c_client(dev);
13159ee3e066SJulian Sax struct i2c_hid *ihid = i2c_get_clientdata(client);
13169ee3e066SJulian Sax
131796a37bfdSDouglas Anderson if (ihid->is_panel_follower)
131896a37bfdSDouglas Anderson return 0;
131996a37bfdSDouglas Anderson
1320d93d2847SDouglas Anderson return i2c_hid_core_resume(ihid);
13219ee3e066SJulian Sax }
13229ee3e066SJulian Sax
1323b33752c3SDouglas Anderson const struct dev_pm_ops i2c_hid_core_pm = {
1324d93d2847SDouglas Anderson SYSTEM_SLEEP_PM_OPS(i2c_hid_core_pm_suspend, i2c_hid_core_pm_resume)
13259ee3e066SJulian Sax };
1326b33752c3SDouglas Anderson EXPORT_SYMBOL_GPL(i2c_hid_core_pm);
13279ee3e066SJulian Sax
13289ee3e066SJulian Sax MODULE_DESCRIPTION("HID over I2C core driver");
13299ee3e066SJulian Sax MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
13309ee3e066SJulian Sax MODULE_LICENSE("GPL");
1331