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