1 /*
2  * HID over I2C protocol implementation
3  *
4  * Copyright (c) 2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
5  * Copyright (c) 2012 Ecole Nationale de l'Aviation Civile, France
6  * Copyright (c) 2012 Red Hat, Inc
7  *
8  * This code is partly based on "USB HID support for Linux":
9  *
10  *  Copyright (c) 1999 Andreas Gal
11  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
12  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
13  *  Copyright (c) 2007-2008 Oliver Neukum
14  *  Copyright (c) 2006-2010 Jiri Kosina
15  *
16  * This file is subject to the terms and conditions of the GNU General Public
17  * License.  See the file COPYING in the main directory of this archive for
18  * more details.
19  */
20 
21 #include <linux/module.h>
22 #include <linux/i2c.h>
23 #include <linux/interrupt.h>
24 #include <linux/input.h>
25 #include <linux/delay.h>
26 #include <linux/slab.h>
27 #include <linux/pm.h>
28 #include <linux/pm_runtime.h>
29 #include <linux/device.h>
30 #include <linux/wait.h>
31 #include <linux/err.h>
32 #include <linux/string.h>
33 #include <linux/list.h>
34 #include <linux/jiffies.h>
35 #include <linux/kernel.h>
36 #include <linux/hid.h>
37 #include <linux/mutex.h>
38 #include <linux/acpi.h>
39 #include <linux/of.h>
40 #include <linux/gpio/consumer.h>
41 
42 #include <linux/i2c/i2c-hid.h>
43 
44 /* flags */
45 #define I2C_HID_STARTED		(1 << 0)
46 #define I2C_HID_RESET_PENDING	(1 << 1)
47 #define I2C_HID_READ_PENDING	(1 << 2)
48 
49 #define I2C_HID_PWR_ON		0x00
50 #define I2C_HID_PWR_SLEEP	0x01
51 
52 /* debug option */
53 static bool debug;
54 module_param(debug, bool, 0444);
55 MODULE_PARM_DESC(debug, "print a lot of debug information");
56 
57 #define i2c_hid_dbg(ihid, fmt, arg...)					  \
58 do {									  \
59 	if (debug)							  \
60 		dev_printk(KERN_DEBUG, &(ihid)->client->dev, fmt, ##arg); \
61 } while (0)
62 
63 struct i2c_hid_desc {
64 	__le16 wHIDDescLength;
65 	__le16 bcdVersion;
66 	__le16 wReportDescLength;
67 	__le16 wReportDescRegister;
68 	__le16 wInputRegister;
69 	__le16 wMaxInputLength;
70 	__le16 wOutputRegister;
71 	__le16 wMaxOutputLength;
72 	__le16 wCommandRegister;
73 	__le16 wDataRegister;
74 	__le16 wVendorID;
75 	__le16 wProductID;
76 	__le16 wVersionID;
77 	__le32 reserved;
78 } __packed;
79 
80 struct i2c_hid_cmd {
81 	unsigned int registerIndex;
82 	__u8 opcode;
83 	unsigned int length;
84 	bool wait;
85 };
86 
87 union command {
88 	u8 data[0];
89 	struct cmd {
90 		__le16 reg;
91 		__u8 reportTypeID;
92 		__u8 opcode;
93 	} __packed c;
94 };
95 
96 #define I2C_HID_CMD(opcode_) \
97 	.opcode = opcode_, .length = 4, \
98 	.registerIndex = offsetof(struct i2c_hid_desc, wCommandRegister)
99 
100 /* fetch HID descriptor */
101 static const struct i2c_hid_cmd hid_descr_cmd = { .length = 2 };
102 /* fetch report descriptors */
103 static const struct i2c_hid_cmd hid_report_descr_cmd = {
104 		.registerIndex = offsetof(struct i2c_hid_desc,
105 			wReportDescRegister),
106 		.opcode = 0x00,
107 		.length = 2 };
108 /* commands */
109 static const struct i2c_hid_cmd hid_reset_cmd =		{ I2C_HID_CMD(0x01),
110 							  .wait = true };
111 static const struct i2c_hid_cmd hid_get_report_cmd =	{ I2C_HID_CMD(0x02) };
112 static const struct i2c_hid_cmd hid_set_report_cmd =	{ I2C_HID_CMD(0x03) };
113 static const struct i2c_hid_cmd hid_set_power_cmd =	{ I2C_HID_CMD(0x08) };
114 static const struct i2c_hid_cmd hid_no_cmd =		{ .length = 0 };
115 
116 /*
117  * These definitions are not used here, but are defined by the spec.
118  * Keeping them here for documentation purposes.
119  *
120  * static const struct i2c_hid_cmd hid_get_idle_cmd = { I2C_HID_CMD(0x04) };
121  * static const struct i2c_hid_cmd hid_set_idle_cmd = { I2C_HID_CMD(0x05) };
122  * static const struct i2c_hid_cmd hid_get_protocol_cmd = { I2C_HID_CMD(0x06) };
123  * static const struct i2c_hid_cmd hid_set_protocol_cmd = { I2C_HID_CMD(0x07) };
124  */
125 
126 static DEFINE_MUTEX(i2c_hid_open_mut);
127 
128 /* The main device structure */
129 struct i2c_hid {
130 	struct i2c_client	*client;	/* i2c client */
131 	struct hid_device	*hid;	/* pointer to corresponding HID dev */
132 	union {
133 		__u8 hdesc_buffer[sizeof(struct i2c_hid_desc)];
134 		struct i2c_hid_desc hdesc;	/* the HID Descriptor */
135 	};
136 	__le16			wHIDDescRegister; /* location of the i2c
137 						   * register of the HID
138 						   * descriptor. */
139 	unsigned int		bufsize;	/* i2c buffer size */
140 	char			*inbuf;		/* Input buffer */
141 	char			*rawbuf;	/* Raw Input buffer */
142 	char			*cmdbuf;	/* Command buffer */
143 	char			*argsbuf;	/* Command arguments buffer */
144 
145 	unsigned long		flags;		/* device flags */
146 
147 	wait_queue_head_t	wait;		/* For waiting the interrupt */
148 	struct gpio_desc	*desc;
149 	int			irq;
150 
151 	struct i2c_hid_platform_data pdata;
152 };
153 
__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)154 static int __i2c_hid_command(struct i2c_client *client,
155 		const struct i2c_hid_cmd *command, u8 reportID,
156 		u8 reportType, u8 *args, int args_len,
157 		unsigned char *buf_recv, int data_len)
158 {
159 	struct i2c_hid *ihid = i2c_get_clientdata(client);
160 	union command *cmd = (union command *)ihid->cmdbuf;
161 	int ret;
162 	struct i2c_msg msg[2];
163 	int msg_num = 1;
164 
165 	int length = command->length;
166 	bool wait = command->wait;
167 	unsigned int registerIndex = command->registerIndex;
168 
169 	/* special case for hid_descr_cmd */
170 	if (command == &hid_descr_cmd) {
171 		cmd->c.reg = ihid->wHIDDescRegister;
172 	} else {
173 		cmd->data[0] = ihid->hdesc_buffer[registerIndex];
174 		cmd->data[1] = ihid->hdesc_buffer[registerIndex + 1];
175 	}
176 
177 	if (length > 2) {
178 		cmd->c.opcode = command->opcode;
179 		cmd->c.reportTypeID = reportID | reportType << 4;
180 	}
181 
182 	memcpy(cmd->data + length, args, args_len);
183 	length += args_len;
184 
185 	i2c_hid_dbg(ihid, "%s: cmd=%*ph\n", __func__, length, cmd->data);
186 
187 	msg[0].addr = client->addr;
188 	msg[0].flags = client->flags & I2C_M_TEN;
189 	msg[0].len = length;
190 	msg[0].buf = cmd->data;
191 	if (data_len > 0) {
192 		msg[1].addr = client->addr;
193 		msg[1].flags = client->flags & I2C_M_TEN;
194 		msg[1].flags |= I2C_M_RD;
195 		msg[1].len = data_len;
196 		msg[1].buf = buf_recv;
197 		msg_num = 2;
198 		set_bit(I2C_HID_READ_PENDING, &ihid->flags);
199 	}
200 
201 	if (wait)
202 		set_bit(I2C_HID_RESET_PENDING, &ihid->flags);
203 
204 	ret = i2c_transfer(client->adapter, msg, msg_num);
205 
206 	if (data_len > 0)
207 		clear_bit(I2C_HID_READ_PENDING, &ihid->flags);
208 
209 	if (ret != msg_num)
210 		return ret < 0 ? ret : -EIO;
211 
212 	ret = 0;
213 
214 	if (wait) {
215 		i2c_hid_dbg(ihid, "%s: waiting...\n", __func__);
216 		if (!wait_event_timeout(ihid->wait,
217 				!test_bit(I2C_HID_RESET_PENDING, &ihid->flags),
218 				msecs_to_jiffies(5000)))
219 			ret = -ENODATA;
220 		i2c_hid_dbg(ihid, "%s: finished.\n", __func__);
221 	}
222 
223 	return ret;
224 }
225 
i2c_hid_command(struct i2c_client * client,const struct i2c_hid_cmd * command,unsigned char * buf_recv,int data_len)226 static int i2c_hid_command(struct i2c_client *client,
227 		const struct i2c_hid_cmd *command,
228 		unsigned char *buf_recv, int data_len)
229 {
230 	return __i2c_hid_command(client, command, 0, 0, NULL, 0,
231 				buf_recv, data_len);
232 }
233 
i2c_hid_get_report(struct i2c_client * client,u8 reportType,u8 reportID,unsigned char * buf_recv,int data_len)234 static int i2c_hid_get_report(struct i2c_client *client, u8 reportType,
235 		u8 reportID, unsigned char *buf_recv, int data_len)
236 {
237 	struct i2c_hid *ihid = i2c_get_clientdata(client);
238 	u8 args[3];
239 	int ret;
240 	int args_len = 0;
241 	u16 readRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
242 
243 	i2c_hid_dbg(ihid, "%s\n", __func__);
244 
245 	if (reportID >= 0x0F) {
246 		args[args_len++] = reportID;
247 		reportID = 0x0F;
248 	}
249 
250 	args[args_len++] = readRegister & 0xFF;
251 	args[args_len++] = readRegister >> 8;
252 
253 	ret = __i2c_hid_command(client, &hid_get_report_cmd, reportID,
254 		reportType, args, args_len, buf_recv, data_len);
255 	if (ret) {
256 		dev_err(&client->dev,
257 			"failed to retrieve report from device.\n");
258 		return ret;
259 	}
260 
261 	return 0;
262 }
263 
264 /**
265  * i2c_hid_set_or_send_report: forward an incoming report to the device
266  * @client: the i2c_client of the device
267  * @reportType: 0x03 for HID_FEATURE_REPORT ; 0x02 for HID_OUTPUT_REPORT
268  * @reportID: the report ID
269  * @buf: the actual data to transfer, without the report ID
270  * @len: size of buf
271  * @use_data: true: use SET_REPORT HID command, false: send plain OUTPUT report
272  */
i2c_hid_set_or_send_report(struct i2c_client * client,u8 reportType,u8 reportID,unsigned char * buf,size_t data_len,bool use_data)273 static int i2c_hid_set_or_send_report(struct i2c_client *client, u8 reportType,
274 		u8 reportID, unsigned char *buf, size_t data_len, bool use_data)
275 {
276 	struct i2c_hid *ihid = i2c_get_clientdata(client);
277 	u8 *args = ihid->argsbuf;
278 	const struct i2c_hid_cmd *hidcmd;
279 	int ret;
280 	u16 dataRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
281 	u16 outputRegister = le16_to_cpu(ihid->hdesc.wOutputRegister);
282 	u16 maxOutputLength = le16_to_cpu(ihid->hdesc.wMaxOutputLength);
283 	u16 size;
284 	int args_len;
285 	int index = 0;
286 
287 	i2c_hid_dbg(ihid, "%s\n", __func__);
288 
289 	if (data_len > ihid->bufsize)
290 		return -EINVAL;
291 
292 	size =		2			/* size */ +
293 			(reportID ? 1 : 0)	/* reportID */ +
294 			data_len		/* buf */;
295 	args_len =	(reportID >= 0x0F ? 1 : 0) /* optional third byte */ +
296 			2			/* dataRegister */ +
297 			size			/* args */;
298 
299 	if (!use_data && maxOutputLength == 0)
300 		return -ENOSYS;
301 
302 	if (reportID >= 0x0F) {
303 		args[index++] = reportID;
304 		reportID = 0x0F;
305 	}
306 
307 	/*
308 	 * use the data register for feature reports or if the device does not
309 	 * support the output register
310 	 */
311 	if (use_data) {
312 		args[index++] = dataRegister & 0xFF;
313 		args[index++] = dataRegister >> 8;
314 		hidcmd = &hid_set_report_cmd;
315 	} else {
316 		args[index++] = outputRegister & 0xFF;
317 		args[index++] = outputRegister >> 8;
318 		hidcmd = &hid_no_cmd;
319 	}
320 
321 	args[index++] = size & 0xFF;
322 	args[index++] = size >> 8;
323 
324 	if (reportID)
325 		args[index++] = reportID;
326 
327 	memcpy(&args[index], buf, data_len);
328 
329 	ret = __i2c_hid_command(client, hidcmd, reportID,
330 		reportType, args, args_len, NULL, 0);
331 	if (ret) {
332 		dev_err(&client->dev, "failed to set a report to device.\n");
333 		return ret;
334 	}
335 
336 	return data_len;
337 }
338 
i2c_hid_set_power(struct i2c_client * client,int power_state)339 static int i2c_hid_set_power(struct i2c_client *client, int power_state)
340 {
341 	struct i2c_hid *ihid = i2c_get_clientdata(client);
342 	int ret;
343 
344 	i2c_hid_dbg(ihid, "%s\n", __func__);
345 
346 	ret = __i2c_hid_command(client, &hid_set_power_cmd, power_state,
347 		0, NULL, 0, NULL, 0);
348 	if (ret)
349 		dev_err(&client->dev, "failed to change power setting.\n");
350 
351 	return ret;
352 }
353 
i2c_hid_hwreset(struct i2c_client * client)354 static int i2c_hid_hwreset(struct i2c_client *client)
355 {
356 	struct i2c_hid *ihid = i2c_get_clientdata(client);
357 	int ret;
358 
359 	i2c_hid_dbg(ihid, "%s\n", __func__);
360 
361 	ret = i2c_hid_set_power(client, I2C_HID_PWR_ON);
362 	if (ret)
363 		return ret;
364 
365 	i2c_hid_dbg(ihid, "resetting...\n");
366 
367 	ret = i2c_hid_command(client, &hid_reset_cmd, NULL, 0);
368 	if (ret) {
369 		dev_err(&client->dev, "failed to reset device.\n");
370 		i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
371 		return ret;
372 	}
373 
374 	return 0;
375 }
376 
i2c_hid_get_input(struct i2c_hid * ihid)377 static void i2c_hid_get_input(struct i2c_hid *ihid)
378 {
379 	int ret, ret_size;
380 	int size = le16_to_cpu(ihid->hdesc.wMaxInputLength);
381 
382 	if (size > ihid->bufsize)
383 		size = ihid->bufsize;
384 
385 	ret = i2c_master_recv(ihid->client, ihid->inbuf, size);
386 	if (ret != size) {
387 		if (ret < 0)
388 			return;
389 
390 		dev_err(&ihid->client->dev, "%s: got %d data instead of %d\n",
391 			__func__, ret, size);
392 		return;
393 	}
394 
395 	ret_size = ihid->inbuf[0] | ihid->inbuf[1] << 8;
396 
397 	if (!ret_size) {
398 		/* host or device initiated RESET completed */
399 		if (test_and_clear_bit(I2C_HID_RESET_PENDING, &ihid->flags))
400 			wake_up(&ihid->wait);
401 		return;
402 	}
403 
404 	if (ret_size > size) {
405 		dev_err(&ihid->client->dev, "%s: incomplete report (%d/%d)\n",
406 			__func__, size, ret_size);
407 		return;
408 	}
409 
410 	i2c_hid_dbg(ihid, "input: %*ph\n", ret_size, ihid->inbuf);
411 
412 	if (test_bit(I2C_HID_STARTED, &ihid->flags))
413 		hid_input_report(ihid->hid, HID_INPUT_REPORT, ihid->inbuf + 2,
414 				ret_size - 2, 1);
415 
416 	return;
417 }
418 
i2c_hid_irq(int irq,void * dev_id)419 static irqreturn_t i2c_hid_irq(int irq, void *dev_id)
420 {
421 	struct i2c_hid *ihid = dev_id;
422 
423 	if (test_bit(I2C_HID_READ_PENDING, &ihid->flags))
424 		return IRQ_HANDLED;
425 
426 	i2c_hid_get_input(ihid);
427 
428 	return IRQ_HANDLED;
429 }
430 
i2c_hid_get_report_length(struct hid_report * report)431 static int i2c_hid_get_report_length(struct hid_report *report)
432 {
433 	return ((report->size - 1) >> 3) + 1 +
434 		report->device->report_enum[report->type].numbered + 2;
435 }
436 
i2c_hid_init_report(struct hid_report * report,u8 * buffer,size_t bufsize)437 static void i2c_hid_init_report(struct hid_report *report, u8 *buffer,
438 	size_t bufsize)
439 {
440 	struct hid_device *hid = report->device;
441 	struct i2c_client *client = hid->driver_data;
442 	struct i2c_hid *ihid = i2c_get_clientdata(client);
443 	unsigned int size, ret_size;
444 
445 	size = i2c_hid_get_report_length(report);
446 	if (i2c_hid_get_report(client,
447 			report->type == HID_FEATURE_REPORT ? 0x03 : 0x01,
448 			report->id, buffer, size))
449 		return;
450 
451 	i2c_hid_dbg(ihid, "report (len=%d): %*ph\n", size, size, buffer);
452 
453 	ret_size = buffer[0] | (buffer[1] << 8);
454 
455 	if (ret_size != size) {
456 		dev_err(&client->dev, "error in %s size:%d / ret_size:%d\n",
457 			__func__, size, ret_size);
458 		return;
459 	}
460 
461 	/* hid->driver_lock is held as we are in probe function,
462 	 * we just need to setup the input fields, so using
463 	 * hid_report_raw_event is safe. */
464 	hid_report_raw_event(hid, report->type, buffer + 2, size - 2, 1);
465 }
466 
467 /*
468  * Initialize all reports
469  */
i2c_hid_init_reports(struct hid_device * hid)470 static void i2c_hid_init_reports(struct hid_device *hid)
471 {
472 	struct hid_report *report;
473 	struct i2c_client *client = hid->driver_data;
474 	struct i2c_hid *ihid = i2c_get_clientdata(client);
475 	u8 *inbuf = kzalloc(ihid->bufsize, GFP_KERNEL);
476 
477 	if (!inbuf) {
478 		dev_err(&client->dev, "can not retrieve initial reports\n");
479 		return;
480 	}
481 
482 	/*
483 	 * The device must be powered on while we fetch initial reports
484 	 * from it.
485 	 */
486 	pm_runtime_get_sync(&client->dev);
487 
488 	list_for_each_entry(report,
489 		&hid->report_enum[HID_FEATURE_REPORT].report_list, list)
490 		i2c_hid_init_report(report, inbuf, ihid->bufsize);
491 
492 	pm_runtime_put(&client->dev);
493 
494 	kfree(inbuf);
495 }
496 
497 /*
498  * Traverse the supplied list of reports and find the longest
499  */
i2c_hid_find_max_report(struct hid_device * hid,unsigned int type,unsigned int * max)500 static void i2c_hid_find_max_report(struct hid_device *hid, unsigned int type,
501 		unsigned int *max)
502 {
503 	struct hid_report *report;
504 	unsigned int size;
505 
506 	/* We should not rely on wMaxInputLength, as some devices may set it to
507 	 * a wrong length. */
508 	list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
509 		size = i2c_hid_get_report_length(report);
510 		if (*max < size)
511 			*max = size;
512 	}
513 }
514 
i2c_hid_free_buffers(struct i2c_hid * ihid)515 static void i2c_hid_free_buffers(struct i2c_hid *ihid)
516 {
517 	kfree(ihid->inbuf);
518 	kfree(ihid->rawbuf);
519 	kfree(ihid->argsbuf);
520 	kfree(ihid->cmdbuf);
521 	ihid->inbuf = NULL;
522 	ihid->rawbuf = NULL;
523 	ihid->cmdbuf = NULL;
524 	ihid->argsbuf = NULL;
525 	ihid->bufsize = 0;
526 }
527 
i2c_hid_alloc_buffers(struct i2c_hid * ihid,size_t report_size)528 static int i2c_hid_alloc_buffers(struct i2c_hid *ihid, size_t report_size)
529 {
530 	/* the worst case is computed from the set_report command with a
531 	 * reportID > 15 and the maximum report length */
532 	int args_len = sizeof(__u8) + /* optional ReportID byte */
533 		       sizeof(__u16) + /* data register */
534 		       sizeof(__u16) + /* size of the report */
535 		       report_size; /* report */
536 
537 	ihid->inbuf = kzalloc(report_size, GFP_KERNEL);
538 	ihid->rawbuf = kzalloc(report_size, GFP_KERNEL);
539 	ihid->argsbuf = kzalloc(args_len, GFP_KERNEL);
540 	ihid->cmdbuf = kzalloc(sizeof(union command) + args_len, GFP_KERNEL);
541 
542 	if (!ihid->inbuf || !ihid->rawbuf || !ihid->argsbuf || !ihid->cmdbuf) {
543 		i2c_hid_free_buffers(ihid);
544 		return -ENOMEM;
545 	}
546 
547 	ihid->bufsize = report_size;
548 
549 	return 0;
550 }
551 
i2c_hid_get_raw_report(struct hid_device * hid,unsigned char report_number,__u8 * buf,size_t count,unsigned char report_type)552 static int i2c_hid_get_raw_report(struct hid_device *hid,
553 		unsigned char report_number, __u8 *buf, size_t count,
554 		unsigned char report_type)
555 {
556 	struct i2c_client *client = hid->driver_data;
557 	struct i2c_hid *ihid = i2c_get_clientdata(client);
558 	size_t ret_count, ask_count;
559 	int ret;
560 
561 	if (report_type == HID_OUTPUT_REPORT)
562 		return -EINVAL;
563 
564 	/* +2 bytes to include the size of the reply in the query buffer */
565 	ask_count = min(count + 2, (size_t)ihid->bufsize);
566 
567 	ret = i2c_hid_get_report(client,
568 			report_type == HID_FEATURE_REPORT ? 0x03 : 0x01,
569 			report_number, ihid->rawbuf, ask_count);
570 
571 	if (ret < 0)
572 		return ret;
573 
574 	ret_count = ihid->rawbuf[0] | (ihid->rawbuf[1] << 8);
575 
576 	if (ret_count <= 2)
577 		return 0;
578 
579 	ret_count = min(ret_count, ask_count);
580 
581 	/* The query buffer contains the size, dropping it in the reply */
582 	count = min(count, ret_count - 2);
583 	memcpy(buf, ihid->rawbuf + 2, count);
584 
585 	return count;
586 }
587 
i2c_hid_output_raw_report(struct hid_device * hid,__u8 * buf,size_t count,unsigned char report_type,bool use_data)588 static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
589 		size_t count, unsigned char report_type, bool use_data)
590 {
591 	struct i2c_client *client = hid->driver_data;
592 	int report_id = buf[0];
593 	int ret;
594 
595 	if (report_type == HID_INPUT_REPORT)
596 		return -EINVAL;
597 
598 	if (report_id) {
599 		buf++;
600 		count--;
601 	}
602 
603 	ret = i2c_hid_set_or_send_report(client,
604 				report_type == HID_FEATURE_REPORT ? 0x03 : 0x02,
605 				report_id, buf, count, use_data);
606 
607 	if (report_id && ret >= 0)
608 		ret++; /* add report_id to the number of transfered bytes */
609 
610 	return ret;
611 }
612 
i2c_hid_output_report(struct hid_device * hid,__u8 * buf,size_t count)613 static int i2c_hid_output_report(struct hid_device *hid, __u8 *buf,
614 		size_t count)
615 {
616 	return i2c_hid_output_raw_report(hid, buf, count, HID_OUTPUT_REPORT,
617 			false);
618 }
619 
i2c_hid_raw_request(struct hid_device * hid,unsigned char reportnum,__u8 * buf,size_t len,unsigned char rtype,int reqtype)620 static int i2c_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
621 			       __u8 *buf, size_t len, unsigned char rtype,
622 			       int reqtype)
623 {
624 	switch (reqtype) {
625 	case HID_REQ_GET_REPORT:
626 		return i2c_hid_get_raw_report(hid, reportnum, buf, len, rtype);
627 	case HID_REQ_SET_REPORT:
628 		if (buf[0] != reportnum)
629 			return -EINVAL;
630 		return i2c_hid_output_raw_report(hid, buf, len, rtype, true);
631 	default:
632 		return -EIO;
633 	}
634 }
635 
i2c_hid_parse(struct hid_device * hid)636 static int i2c_hid_parse(struct hid_device *hid)
637 {
638 	struct i2c_client *client = hid->driver_data;
639 	struct i2c_hid *ihid = i2c_get_clientdata(client);
640 	struct i2c_hid_desc *hdesc = &ihid->hdesc;
641 	unsigned int rsize;
642 	char *rdesc;
643 	int ret;
644 	int tries = 3;
645 
646 	i2c_hid_dbg(ihid, "entering %s\n", __func__);
647 
648 	rsize = le16_to_cpu(hdesc->wReportDescLength);
649 	if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
650 		dbg_hid("weird size of report descriptor (%u)\n", rsize);
651 		return -EINVAL;
652 	}
653 
654 	do {
655 		ret = i2c_hid_hwreset(client);
656 		if (ret)
657 			msleep(1000);
658 	} while (tries-- > 0 && ret);
659 
660 	if (ret)
661 		return ret;
662 
663 	rdesc = kzalloc(rsize, GFP_KERNEL);
664 
665 	if (!rdesc) {
666 		dbg_hid("couldn't allocate rdesc memory\n");
667 		return -ENOMEM;
668 	}
669 
670 	i2c_hid_dbg(ihid, "asking HID report descriptor\n");
671 
672 	ret = i2c_hid_command(client, &hid_report_descr_cmd, rdesc, rsize);
673 	if (ret) {
674 		hid_err(hid, "reading report descriptor failed\n");
675 		kfree(rdesc);
676 		return -EIO;
677 	}
678 
679 	i2c_hid_dbg(ihid, "Report Descriptor: %*ph\n", rsize, rdesc);
680 
681 	ret = hid_parse_report(hid, rdesc, rsize);
682 	kfree(rdesc);
683 	if (ret) {
684 		dbg_hid("parsing report descriptor failed\n");
685 		return ret;
686 	}
687 
688 	return 0;
689 }
690 
i2c_hid_start(struct hid_device * hid)691 static int i2c_hid_start(struct hid_device *hid)
692 {
693 	struct i2c_client *client = hid->driver_data;
694 	struct i2c_hid *ihid = i2c_get_clientdata(client);
695 	int ret;
696 	unsigned int bufsize = HID_MIN_BUFFER_SIZE;
697 
698 	i2c_hid_find_max_report(hid, HID_INPUT_REPORT, &bufsize);
699 	i2c_hid_find_max_report(hid, HID_OUTPUT_REPORT, &bufsize);
700 	i2c_hid_find_max_report(hid, HID_FEATURE_REPORT, &bufsize);
701 
702 	if (bufsize > ihid->bufsize) {
703 		i2c_hid_free_buffers(ihid);
704 
705 		ret = i2c_hid_alloc_buffers(ihid, bufsize);
706 
707 		if (ret)
708 			return ret;
709 	}
710 
711 	if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS))
712 		i2c_hid_init_reports(hid);
713 
714 	return 0;
715 }
716 
i2c_hid_stop(struct hid_device * hid)717 static void i2c_hid_stop(struct hid_device *hid)
718 {
719 	hid->claimed = 0;
720 }
721 
i2c_hid_open(struct hid_device * hid)722 static int i2c_hid_open(struct hid_device *hid)
723 {
724 	struct i2c_client *client = hid->driver_data;
725 	struct i2c_hid *ihid = i2c_get_clientdata(client);
726 	int ret = 0;
727 
728 	mutex_lock(&i2c_hid_open_mut);
729 	if (!hid->open++) {
730 		ret = pm_runtime_get_sync(&client->dev);
731 		if (ret < 0) {
732 			hid->open--;
733 			goto done;
734 		}
735 		set_bit(I2C_HID_STARTED, &ihid->flags);
736 	}
737 done:
738 	mutex_unlock(&i2c_hid_open_mut);
739 	return ret < 0 ? ret : 0;
740 }
741 
i2c_hid_close(struct hid_device * hid)742 static void i2c_hid_close(struct hid_device *hid)
743 {
744 	struct i2c_client *client = hid->driver_data;
745 	struct i2c_hid *ihid = i2c_get_clientdata(client);
746 
747 	/* protecting hid->open to make sure we don't restart
748 	 * data acquistion due to a resumption we no longer
749 	 * care about
750 	 */
751 	mutex_lock(&i2c_hid_open_mut);
752 	if (!--hid->open) {
753 		clear_bit(I2C_HID_STARTED, &ihid->flags);
754 
755 		/* Save some power */
756 		pm_runtime_put(&client->dev);
757 	}
758 	mutex_unlock(&i2c_hid_open_mut);
759 }
760 
i2c_hid_power(struct hid_device * hid,int lvl)761 static int i2c_hid_power(struct hid_device *hid, int lvl)
762 {
763 	struct i2c_client *client = hid->driver_data;
764 	struct i2c_hid *ihid = i2c_get_clientdata(client);
765 
766 	i2c_hid_dbg(ihid, "%s lvl:%d\n", __func__, lvl);
767 
768 	switch (lvl) {
769 	case PM_HINT_FULLON:
770 		pm_runtime_get_sync(&client->dev);
771 		break;
772 	case PM_HINT_NORMAL:
773 		pm_runtime_put(&client->dev);
774 		break;
775 	}
776 	return 0;
777 }
778 
779 static struct hid_ll_driver i2c_hid_ll_driver = {
780 	.parse = i2c_hid_parse,
781 	.start = i2c_hid_start,
782 	.stop = i2c_hid_stop,
783 	.open = i2c_hid_open,
784 	.close = i2c_hid_close,
785 	.power = i2c_hid_power,
786 	.output_report = i2c_hid_output_report,
787 	.raw_request = i2c_hid_raw_request,
788 };
789 
i2c_hid_init_irq(struct i2c_client * client)790 static int i2c_hid_init_irq(struct i2c_client *client)
791 {
792 	struct i2c_hid *ihid = i2c_get_clientdata(client);
793 	int ret;
794 
795 	dev_dbg(&client->dev, "Requesting IRQ: %d\n", ihid->irq);
796 
797 	ret = request_threaded_irq(ihid->irq, NULL, i2c_hid_irq,
798 			IRQF_TRIGGER_LOW | IRQF_ONESHOT,
799 			client->name, ihid);
800 	if (ret < 0) {
801 		dev_warn(&client->dev,
802 			"Could not register for %s interrupt, irq = %d,"
803 			" ret = %d\n",
804 			client->name, ihid->irq, ret);
805 
806 		return ret;
807 	}
808 
809 	return 0;
810 }
811 
i2c_hid_fetch_hid_descriptor(struct i2c_hid * ihid)812 static int i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid)
813 {
814 	struct i2c_client *client = ihid->client;
815 	struct i2c_hid_desc *hdesc = &ihid->hdesc;
816 	unsigned int dsize;
817 	int ret;
818 
819 	/* i2c hid fetch using a fixed descriptor size (30 bytes) */
820 	i2c_hid_dbg(ihid, "Fetching the HID descriptor\n");
821 	ret = i2c_hid_command(client, &hid_descr_cmd, ihid->hdesc_buffer,
822 				sizeof(struct i2c_hid_desc));
823 	if (ret) {
824 		dev_err(&client->dev, "hid_descr_cmd failed\n");
825 		return -ENODEV;
826 	}
827 
828 	/* Validate the length of HID descriptor, the 4 first bytes:
829 	 * bytes 0-1 -> length
830 	 * bytes 2-3 -> bcdVersion (has to be 1.00) */
831 	/* check bcdVersion == 1.0 */
832 	if (le16_to_cpu(hdesc->bcdVersion) != 0x0100) {
833 		dev_err(&client->dev,
834 			"unexpected HID descriptor bcdVersion (0x%04hx)\n",
835 			le16_to_cpu(hdesc->bcdVersion));
836 		return -ENODEV;
837 	}
838 
839 	/* Descriptor length should be 30 bytes as per the specification */
840 	dsize = le16_to_cpu(hdesc->wHIDDescLength);
841 	if (dsize != sizeof(struct i2c_hid_desc)) {
842 		dev_err(&client->dev, "weird size of HID descriptor (%u)\n",
843 			dsize);
844 		return -ENODEV;
845 	}
846 	i2c_hid_dbg(ihid, "HID Descriptor: %*ph\n", dsize, ihid->hdesc_buffer);
847 	return 0;
848 }
849 
850 #ifdef CONFIG_ACPI
851 
852 /* Default GPIO mapping */
853 static const struct acpi_gpio_params i2c_hid_irq_gpio = { 0, 0, true };
854 static const struct acpi_gpio_mapping i2c_hid_acpi_gpios[] = {
855 	{ "gpios", &i2c_hid_irq_gpio, 1 },
856 	{ },
857 };
858 
i2c_hid_acpi_pdata(struct i2c_client * client,struct i2c_hid_platform_data * pdata)859 static int i2c_hid_acpi_pdata(struct i2c_client *client,
860 		struct i2c_hid_platform_data *pdata)
861 {
862 	static u8 i2c_hid_guid[] = {
863 		0xF7, 0xF6, 0xDF, 0x3C, 0x67, 0x42, 0x55, 0x45,
864 		0xAD, 0x05, 0xB3, 0x0A, 0x3D, 0x89, 0x38, 0xDE,
865 	};
866 	union acpi_object *obj;
867 	struct acpi_device *adev;
868 	acpi_handle handle;
869 	int ret;
870 
871 	handle = ACPI_HANDLE(&client->dev);
872 	if (!handle || acpi_bus_get_device(handle, &adev))
873 		return -ENODEV;
874 
875 	obj = acpi_evaluate_dsm_typed(handle, i2c_hid_guid, 1, 1, NULL,
876 				      ACPI_TYPE_INTEGER);
877 	if (!obj) {
878 		dev_err(&client->dev, "device _DSM execution failed\n");
879 		return -ENODEV;
880 	}
881 
882 	pdata->hid_descriptor_address = obj->integer.value;
883 	ACPI_FREE(obj);
884 
885 	/* GPIOs are optional */
886 	ret = acpi_dev_add_driver_gpios(adev, i2c_hid_acpi_gpios);
887 	return ret < 0 && ret != -ENXIO ? ret : 0;
888 }
889 
890 static const struct acpi_device_id i2c_hid_acpi_match[] = {
891 	{"ACPI0C50", 0 },
892 	{"PNP0C50", 0 },
893 	{ },
894 };
895 MODULE_DEVICE_TABLE(acpi, i2c_hid_acpi_match);
896 #else
i2c_hid_acpi_pdata(struct i2c_client * client,struct i2c_hid_platform_data * pdata)897 static inline int i2c_hid_acpi_pdata(struct i2c_client *client,
898 		struct i2c_hid_platform_data *pdata)
899 {
900 	return -ENODEV;
901 }
902 #endif
903 
904 #ifdef CONFIG_OF
i2c_hid_of_probe(struct i2c_client * client,struct i2c_hid_platform_data * pdata)905 static int i2c_hid_of_probe(struct i2c_client *client,
906 		struct i2c_hid_platform_data *pdata)
907 {
908 	struct device *dev = &client->dev;
909 	u32 val;
910 	int ret;
911 
912 	ret = of_property_read_u32(dev->of_node, "hid-descr-addr", &val);
913 	if (ret) {
914 		dev_err(&client->dev, "HID register address not provided\n");
915 		return -ENODEV;
916 	}
917 	if (val >> 16) {
918 		dev_err(&client->dev, "Bad HID register address: 0x%08x\n",
919 			val);
920 		return -EINVAL;
921 	}
922 	pdata->hid_descriptor_address = val;
923 
924 	return 0;
925 }
926 
927 static const struct of_device_id i2c_hid_of_match[] = {
928 	{ .compatible = "hid-over-i2c" },
929 	{},
930 };
931 MODULE_DEVICE_TABLE(of, i2c_hid_of_match);
932 #else
i2c_hid_of_probe(struct i2c_client * client,struct i2c_hid_platform_data * pdata)933 static inline int i2c_hid_of_probe(struct i2c_client *client,
934 		struct i2c_hid_platform_data *pdata)
935 {
936 	return -ENODEV;
937 }
938 #endif
939 
i2c_hid_probe(struct i2c_client * client,const struct i2c_device_id * dev_id)940 static int i2c_hid_probe(struct i2c_client *client,
941 			 const struct i2c_device_id *dev_id)
942 {
943 	int ret;
944 	struct i2c_hid *ihid;
945 	struct hid_device *hid;
946 	__u16 hidRegister;
947 	struct i2c_hid_platform_data *platform_data = client->dev.platform_data;
948 
949 	dbg_hid("HID probe called for i2c 0x%02x\n", client->addr);
950 
951 	ihid = kzalloc(sizeof(struct i2c_hid), GFP_KERNEL);
952 	if (!ihid)
953 		return -ENOMEM;
954 
955 	if (client->dev.of_node) {
956 		ret = i2c_hid_of_probe(client, &ihid->pdata);
957 		if (ret)
958 			goto err;
959 	} else if (!platform_data) {
960 		ret = i2c_hid_acpi_pdata(client, &ihid->pdata);
961 		if (ret) {
962 			dev_err(&client->dev,
963 				"HID register address not provided\n");
964 			goto err;
965 		}
966 	} else {
967 		ihid->pdata = *platform_data;
968 	}
969 
970 	if (client->irq > 0) {
971 		ihid->irq = client->irq;
972 	} else if (ACPI_COMPANION(&client->dev)) {
973 		ihid->desc = gpiod_get(&client->dev, NULL, GPIOD_IN);
974 		if (IS_ERR(ihid->desc)) {
975 			dev_err(&client->dev, "Failed to get GPIO interrupt\n");
976 			return PTR_ERR(ihid->desc);
977 		}
978 
979 		ihid->irq = gpiod_to_irq(ihid->desc);
980 		if (ihid->irq < 0) {
981 			gpiod_put(ihid->desc);
982 			dev_err(&client->dev, "Failed to convert GPIO to IRQ\n");
983 			return ihid->irq;
984 		}
985 	}
986 
987 	i2c_set_clientdata(client, ihid);
988 
989 	ihid->client = client;
990 
991 	hidRegister = ihid->pdata.hid_descriptor_address;
992 	ihid->wHIDDescRegister = cpu_to_le16(hidRegister);
993 
994 	init_waitqueue_head(&ihid->wait);
995 
996 	/* we need to allocate the command buffer without knowing the maximum
997 	 * size of the reports. Let's use HID_MIN_BUFFER_SIZE, then we do the
998 	 * real computation later. */
999 	ret = i2c_hid_alloc_buffers(ihid, HID_MIN_BUFFER_SIZE);
1000 	if (ret < 0)
1001 		goto err;
1002 
1003 	pm_runtime_get_noresume(&client->dev);
1004 	pm_runtime_set_active(&client->dev);
1005 	pm_runtime_enable(&client->dev);
1006 
1007 	ret = i2c_hid_fetch_hid_descriptor(ihid);
1008 	if (ret < 0)
1009 		goto err_pm;
1010 
1011 	ret = i2c_hid_init_irq(client);
1012 	if (ret < 0)
1013 		goto err_pm;
1014 
1015 	hid = hid_allocate_device();
1016 	if (IS_ERR(hid)) {
1017 		ret = PTR_ERR(hid);
1018 		goto err_irq;
1019 	}
1020 
1021 	ihid->hid = hid;
1022 
1023 	hid->driver_data = client;
1024 	hid->ll_driver = &i2c_hid_ll_driver;
1025 	hid->dev.parent = &client->dev;
1026 	ACPI_COMPANION_SET(&hid->dev, ACPI_COMPANION(&client->dev));
1027 	hid->bus = BUS_I2C;
1028 	hid->version = le16_to_cpu(ihid->hdesc.bcdVersion);
1029 	hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID);
1030 	hid->product = le16_to_cpu(ihid->hdesc.wProductID);
1031 
1032 	snprintf(hid->name, sizeof(hid->name), "%s %04hX:%04hX",
1033 		 client->name, hid->vendor, hid->product);
1034 
1035 	ret = hid_add_device(hid);
1036 	if (ret) {
1037 		if (ret != -ENODEV)
1038 			hid_err(client, "can't add hid device: %d\n", ret);
1039 		goto err_mem_free;
1040 	}
1041 
1042 	pm_runtime_put(&client->dev);
1043 	return 0;
1044 
1045 err_mem_free:
1046 	hid_destroy_device(hid);
1047 
1048 err_irq:
1049 	free_irq(ihid->irq, ihid);
1050 
1051 err_pm:
1052 	pm_runtime_put_noidle(&client->dev);
1053 	pm_runtime_disable(&client->dev);
1054 
1055 err:
1056 	if (ihid->desc)
1057 		gpiod_put(ihid->desc);
1058 
1059 	i2c_hid_free_buffers(ihid);
1060 	kfree(ihid);
1061 	return ret;
1062 }
1063 
i2c_hid_remove(struct i2c_client * client)1064 static int i2c_hid_remove(struct i2c_client *client)
1065 {
1066 	struct i2c_hid *ihid = i2c_get_clientdata(client);
1067 	struct hid_device *hid;
1068 
1069 	pm_runtime_get_sync(&client->dev);
1070 	pm_runtime_disable(&client->dev);
1071 	pm_runtime_set_suspended(&client->dev);
1072 	pm_runtime_put_noidle(&client->dev);
1073 
1074 	hid = ihid->hid;
1075 	hid_destroy_device(hid);
1076 
1077 	free_irq(ihid->irq, ihid);
1078 
1079 	if (ihid->bufsize)
1080 		i2c_hid_free_buffers(ihid);
1081 
1082 	if (ihid->desc)
1083 		gpiod_put(ihid->desc);
1084 
1085 	kfree(ihid);
1086 
1087 	acpi_dev_remove_driver_gpios(ACPI_COMPANION(&client->dev));
1088 
1089 	return 0;
1090 }
1091 
1092 #ifdef CONFIG_PM_SLEEP
i2c_hid_suspend(struct device * dev)1093 static int i2c_hid_suspend(struct device *dev)
1094 {
1095 	struct i2c_client *client = to_i2c_client(dev);
1096 	struct i2c_hid *ihid = i2c_get_clientdata(client);
1097 	struct hid_device *hid = ihid->hid;
1098 	int ret = 0;
1099 
1100 	disable_irq(ihid->irq);
1101 	if (device_may_wakeup(&client->dev))
1102 		enable_irq_wake(ihid->irq);
1103 
1104 	if (hid->driver && hid->driver->suspend)
1105 		ret = hid->driver->suspend(hid, PMSG_SUSPEND);
1106 
1107 	/* Save some power */
1108 	i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
1109 
1110 	return ret;
1111 }
1112 
i2c_hid_resume(struct device * dev)1113 static int i2c_hid_resume(struct device *dev)
1114 {
1115 	int ret;
1116 	struct i2c_client *client = to_i2c_client(dev);
1117 	struct i2c_hid *ihid = i2c_get_clientdata(client);
1118 	struct hid_device *hid = ihid->hid;
1119 
1120 	enable_irq(ihid->irq);
1121 	ret = i2c_hid_hwreset(client);
1122 	if (ret)
1123 		return ret;
1124 
1125 	if (device_may_wakeup(&client->dev))
1126 		disable_irq_wake(ihid->irq);
1127 
1128 	if (hid->driver && hid->driver->reset_resume) {
1129 		ret = hid->driver->reset_resume(hid);
1130 		return ret;
1131 	}
1132 
1133 	return 0;
1134 }
1135 #endif
1136 
1137 #ifdef CONFIG_PM
i2c_hid_runtime_suspend(struct device * dev)1138 static int i2c_hid_runtime_suspend(struct device *dev)
1139 {
1140 	struct i2c_client *client = to_i2c_client(dev);
1141 	struct i2c_hid *ihid = i2c_get_clientdata(client);
1142 
1143 	i2c_hid_set_power(client, I2C_HID_PWR_SLEEP);
1144 	disable_irq(ihid->irq);
1145 	return 0;
1146 }
1147 
i2c_hid_runtime_resume(struct device * dev)1148 static int i2c_hid_runtime_resume(struct device *dev)
1149 {
1150 	struct i2c_client *client = to_i2c_client(dev);
1151 	struct i2c_hid *ihid = i2c_get_clientdata(client);
1152 
1153 	enable_irq(ihid->irq);
1154 	i2c_hid_set_power(client, I2C_HID_PWR_ON);
1155 	return 0;
1156 }
1157 #endif
1158 
1159 static const struct dev_pm_ops i2c_hid_pm = {
1160 	SET_SYSTEM_SLEEP_PM_OPS(i2c_hid_suspend, i2c_hid_resume)
1161 	SET_RUNTIME_PM_OPS(i2c_hid_runtime_suspend, i2c_hid_runtime_resume,
1162 			   NULL)
1163 };
1164 
1165 static const struct i2c_device_id i2c_hid_id_table[] = {
1166 	{ "hid", 0 },
1167 	{ },
1168 };
1169 MODULE_DEVICE_TABLE(i2c, i2c_hid_id_table);
1170 
1171 
1172 static struct i2c_driver i2c_hid_driver = {
1173 	.driver = {
1174 		.name	= "i2c_hid",
1175 		.owner	= THIS_MODULE,
1176 		.pm	= &i2c_hid_pm,
1177 		.acpi_match_table = ACPI_PTR(i2c_hid_acpi_match),
1178 		.of_match_table = of_match_ptr(i2c_hid_of_match),
1179 	},
1180 
1181 	.probe		= i2c_hid_probe,
1182 	.remove		= i2c_hid_remove,
1183 
1184 	.id_table	= i2c_hid_id_table,
1185 };
1186 
1187 module_i2c_driver(i2c_hid_driver);
1188 
1189 MODULE_DESCRIPTION("HID over I2C core driver");
1190 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
1191 MODULE_LICENSE("GPL");
1192