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/irq.h> |
26 | #include <linux/delay.h> |
27 | #include <linux/slab.h> |
28 | #include <linux/pm.h> |
29 | #include <linux/pm_wakeirq.h> |
30 | #include <linux/device.h> |
31 | #include <linux/wait.h> |
32 | #include <linux/err.h> |
33 | #include <linux/string.h> |
34 | #include <linux/list.h> |
35 | #include <linux/jiffies.h> |
36 | #include <linux/kernel.h> |
37 | #include <linux/hid.h> |
38 | #include <linux/mutex.h> |
39 | #include <asm/unaligned.h> |
40 | |
41 | #include <drm/drm_panel.h> |
42 | |
43 | #include "../hid-ids.h" |
44 | #include "i2c-hid.h" |
45 | |
46 | /* quirks to control the device */ |
47 | #define I2C_HID_QUIRK_NO_IRQ_AFTER_RESET BIT(0) |
48 | #define I2C_HID_QUIRK_BOGUS_IRQ BIT(1) |
49 | #define I2C_HID_QUIRK_RESET_ON_RESUME BIT(2) |
50 | #define I2C_HID_QUIRK_BAD_INPUT_SIZE BIT(3) |
51 | #define I2C_HID_QUIRK_NO_WAKEUP_AFTER_RESET BIT(4) |
52 | #define I2C_HID_QUIRK_NO_SLEEP_ON_SUSPEND BIT(5) |
53 | |
54 | /* Command opcodes */ |
55 | #define I2C_HID_OPCODE_RESET 0x01 |
56 | #define I2C_HID_OPCODE_GET_REPORT 0x02 |
57 | #define I2C_HID_OPCODE_SET_REPORT 0x03 |
58 | #define I2C_HID_OPCODE_GET_IDLE 0x04 |
59 | #define I2C_HID_OPCODE_SET_IDLE 0x05 |
60 | #define I2C_HID_OPCODE_GET_PROTOCOL 0x06 |
61 | #define I2C_HID_OPCODE_SET_PROTOCOL 0x07 |
62 | #define I2C_HID_OPCODE_SET_POWER 0x08 |
63 | |
64 | /* flags */ |
65 | #define I2C_HID_STARTED 0 |
66 | #define I2C_HID_RESET_PENDING 1 |
67 | #define I2C_HID_READ_PENDING 2 |
68 | |
69 | #define I2C_HID_PWR_ON 0x00 |
70 | #define I2C_HID_PWR_SLEEP 0x01 |
71 | |
72 | #define i2c_hid_dbg(ihid, ...) dev_dbg(&(ihid)->client->dev, __VA_ARGS__) |
73 | |
74 | struct i2c_hid_desc { |
75 | __le16 wHIDDescLength; |
76 | __le16 bcdVersion; |
77 | __le16 wReportDescLength; |
78 | __le16 wReportDescRegister; |
79 | __le16 wInputRegister; |
80 | __le16 wMaxInputLength; |
81 | __le16 wOutputRegister; |
82 | __le16 wMaxOutputLength; |
83 | __le16 wCommandRegister; |
84 | __le16 wDataRegister; |
85 | __le16 wVendorID; |
86 | __le16 wProductID; |
87 | __le16 wVersionID; |
88 | __le32 reserved; |
89 | } __packed; |
90 | |
91 | /* The main device structure */ |
92 | struct i2c_hid { |
93 | struct i2c_client *client; /* i2c client */ |
94 | struct hid_device *hid; /* pointer to corresponding HID dev */ |
95 | struct i2c_hid_desc hdesc; /* the HID Descriptor */ |
96 | __le16 wHIDDescRegister; /* location of the i2c |
97 | * register of the HID |
98 | * descriptor. */ |
99 | unsigned int bufsize; /* i2c buffer size */ |
100 | u8 *inbuf; /* Input buffer */ |
101 | u8 *rawbuf; /* Raw Input buffer */ |
102 | u8 *cmdbuf; /* Command buffer */ |
103 | |
104 | unsigned long flags; /* device flags */ |
105 | unsigned long quirks; /* Various quirks */ |
106 | |
107 | wait_queue_head_t wait; /* For waiting the interrupt */ |
108 | |
109 | struct mutex reset_lock; |
110 | |
111 | struct i2chid_ops *ops; |
112 | struct drm_panel_follower panel_follower; |
113 | struct work_struct panel_follower_prepare_work; |
114 | bool is_panel_follower; |
115 | bool prepare_work_finished; |
116 | }; |
117 | |
118 | static const struct i2c_hid_quirks { |
119 | __u16 idVendor; |
120 | __u16 idProduct; |
121 | __u32 quirks; |
122 | } i2c_hid_quirks[] = { |
123 | { I2C_VENDOR_ID_HANTICK, I2C_PRODUCT_ID_HANTICK_5288, |
124 | I2C_HID_QUIRK_NO_IRQ_AFTER_RESET }, |
125 | { I2C_VENDOR_ID_ITE, I2C_DEVICE_ID_ITE_VOYO_WINPAD_A15, |
126 | I2C_HID_QUIRK_NO_IRQ_AFTER_RESET }, |
127 | { I2C_VENDOR_ID_RAYDIUM, I2C_PRODUCT_ID_RAYDIUM_3118, |
128 | I2C_HID_QUIRK_NO_IRQ_AFTER_RESET }, |
129 | { USB_VENDOR_ID_ALPS_JP, HID_ANY_ID, |
130 | I2C_HID_QUIRK_RESET_ON_RESUME }, |
131 | { I2C_VENDOR_ID_SYNAPTICS, I2C_PRODUCT_ID_SYNAPTICS_SYNA2393, |
132 | I2C_HID_QUIRK_RESET_ON_RESUME }, |
133 | { USB_VENDOR_ID_ITE, I2C_DEVICE_ID_ITE_LENOVO_LEGION_Y720, |
134 | I2C_HID_QUIRK_BAD_INPUT_SIZE }, |
135 | { I2C_VENDOR_ID_CIRQUE, I2C_PRODUCT_ID_CIRQUE_1063, |
136 | I2C_HID_QUIRK_NO_SLEEP_ON_SUSPEND }, |
137 | /* |
138 | * Sending the wakeup after reset actually break ELAN touchscreen controller |
139 | */ |
140 | { USB_VENDOR_ID_ELAN, HID_ANY_ID, |
141 | I2C_HID_QUIRK_NO_WAKEUP_AFTER_RESET | |
142 | I2C_HID_QUIRK_BOGUS_IRQ }, |
143 | { 0, 0 } |
144 | }; |
145 | |
146 | /* |
147 | * i2c_hid_lookup_quirk: return any quirks associated with a I2C HID device |
148 | * @idVendor: the 16-bit vendor ID |
149 | * @idProduct: the 16-bit product ID |
150 | * |
151 | * Returns: a u32 quirks value. |
152 | */ |
153 | static u32 i2c_hid_lookup_quirk(const u16 idVendor, const u16 idProduct) |
154 | { |
155 | u32 quirks = 0; |
156 | int n; |
157 | |
158 | for (n = 0; i2c_hid_quirks[n].idVendor; n++) |
159 | if (i2c_hid_quirks[n].idVendor == idVendor && |
160 | (i2c_hid_quirks[n].idProduct == (__u16)HID_ANY_ID || |
161 | i2c_hid_quirks[n].idProduct == idProduct)) |
162 | quirks = i2c_hid_quirks[n].quirks; |
163 | |
164 | return quirks; |
165 | } |
166 | |
167 | static int i2c_hid_xfer(struct i2c_hid *ihid, |
168 | u8 *send_buf, int send_len, u8 *recv_buf, int recv_len) |
169 | { |
170 | struct i2c_client *client = ihid->client; |
171 | struct i2c_msg msgs[2] = { 0 }; |
172 | int n = 0; |
173 | int ret; |
174 | |
175 | if (send_len) { |
176 | i2c_hid_dbg(ihid, "%s: cmd=%*ph\n" , |
177 | __func__, send_len, send_buf); |
178 | |
179 | msgs[n].addr = client->addr; |
180 | msgs[n].flags = (client->flags & I2C_M_TEN) | I2C_M_DMA_SAFE; |
181 | msgs[n].len = send_len; |
182 | msgs[n].buf = send_buf; |
183 | n++; |
184 | } |
185 | |
186 | if (recv_len) { |
187 | msgs[n].addr = client->addr; |
188 | msgs[n].flags = (client->flags & I2C_M_TEN) | |
189 | I2C_M_RD | I2C_M_DMA_SAFE; |
190 | msgs[n].len = recv_len; |
191 | msgs[n].buf = recv_buf; |
192 | n++; |
193 | |
194 | set_bit(I2C_HID_READ_PENDING, addr: &ihid->flags); |
195 | } |
196 | |
197 | ret = i2c_transfer(adap: client->adapter, msgs, num: n); |
198 | |
199 | if (recv_len) |
200 | clear_bit(I2C_HID_READ_PENDING, addr: &ihid->flags); |
201 | |
202 | if (ret != n) |
203 | return ret < 0 ? ret : -EIO; |
204 | |
205 | return 0; |
206 | } |
207 | |
208 | static int i2c_hid_read_register(struct i2c_hid *ihid, __le16 reg, |
209 | void *buf, size_t len) |
210 | { |
211 | *(__le16 *)ihid->cmdbuf = reg; |
212 | |
213 | return i2c_hid_xfer(ihid, send_buf: ihid->cmdbuf, send_len: sizeof(__le16), recv_buf: buf, recv_len: len); |
214 | } |
215 | |
216 | static size_t i2c_hid_encode_command(u8 *buf, u8 opcode, |
217 | int report_type, int report_id) |
218 | { |
219 | size_t length = 0; |
220 | |
221 | if (report_id < 0x0F) { |
222 | buf[length++] = report_type << 4 | report_id; |
223 | buf[length++] = opcode; |
224 | } else { |
225 | buf[length++] = report_type << 4 | 0x0F; |
226 | buf[length++] = opcode; |
227 | buf[length++] = report_id; |
228 | } |
229 | |
230 | return length; |
231 | } |
232 | |
233 | static int i2c_hid_get_report(struct i2c_hid *ihid, |
234 | u8 report_type, u8 report_id, |
235 | u8 *recv_buf, size_t recv_len) |
236 | { |
237 | size_t length = 0; |
238 | size_t ret_count; |
239 | int error; |
240 | |
241 | i2c_hid_dbg(ihid, "%s\n" , __func__); |
242 | |
243 | /* Command register goes first */ |
244 | *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister; |
245 | length += sizeof(__le16); |
246 | /* Next is GET_REPORT command */ |
247 | length += i2c_hid_encode_command(buf: ihid->cmdbuf + length, |
248 | I2C_HID_OPCODE_GET_REPORT, |
249 | report_type, report_id); |
250 | /* |
251 | * Device will send report data through data register. Because |
252 | * command can be either 2 or 3 bytes destination for the data |
253 | * register may be not aligned. |
254 | */ |
255 | put_unaligned_le16(le16_to_cpu(ihid->hdesc.wDataRegister), |
256 | p: ihid->cmdbuf + length); |
257 | length += sizeof(__le16); |
258 | |
259 | /* |
260 | * In addition to report data device will supply data length |
261 | * in the first 2 bytes of the response, so adjust . |
262 | */ |
263 | error = i2c_hid_xfer(ihid, send_buf: ihid->cmdbuf, send_len: length, |
264 | recv_buf: ihid->rawbuf, recv_len: recv_len + sizeof(__le16)); |
265 | if (error) { |
266 | dev_err(&ihid->client->dev, |
267 | "failed to set a report to device: %d\n" , error); |
268 | return error; |
269 | } |
270 | |
271 | /* The buffer is sufficiently aligned */ |
272 | ret_count = le16_to_cpup(p: (__le16 *)ihid->rawbuf); |
273 | |
274 | /* Check for empty report response */ |
275 | if (ret_count <= sizeof(__le16)) |
276 | return 0; |
277 | |
278 | recv_len = min(recv_len, ret_count - sizeof(__le16)); |
279 | memcpy(recv_buf, ihid->rawbuf + sizeof(__le16), recv_len); |
280 | |
281 | if (report_id && recv_len != 0 && recv_buf[0] != report_id) { |
282 | dev_err(&ihid->client->dev, |
283 | "device returned incorrect report (%d vs %d expected)\n" , |
284 | recv_buf[0], report_id); |
285 | return -EINVAL; |
286 | } |
287 | |
288 | return recv_len; |
289 | } |
290 | |
291 | static size_t i2c_hid_format_report(u8 *buf, int report_id, |
292 | const u8 *data, size_t size) |
293 | { |
294 | size_t length = sizeof(__le16); /* reserve space to store size */ |
295 | |
296 | if (report_id) |
297 | buf[length++] = report_id; |
298 | |
299 | memcpy(buf + length, data, size); |
300 | length += size; |
301 | |
302 | /* Store overall size in the beginning of the buffer */ |
303 | put_unaligned_le16(val: length, p: buf); |
304 | |
305 | return length; |
306 | } |
307 | |
308 | /** |
309 | * i2c_hid_set_or_send_report: forward an incoming report to the device |
310 | * @ihid: the i2c hid device |
311 | * @report_type: 0x03 for HID_FEATURE_REPORT ; 0x02 for HID_OUTPUT_REPORT |
312 | * @report_id: the report ID |
313 | * @buf: the actual data to transfer, without the report ID |
314 | * @data_len: size of buf |
315 | * @do_set: true: use SET_REPORT HID command, false: send plain OUTPUT report |
316 | */ |
317 | static int i2c_hid_set_or_send_report(struct i2c_hid *ihid, |
318 | u8 report_type, u8 report_id, |
319 | const u8 *buf, size_t data_len, |
320 | bool do_set) |
321 | { |
322 | size_t length = 0; |
323 | int error; |
324 | |
325 | i2c_hid_dbg(ihid, "%s\n" , __func__); |
326 | |
327 | if (data_len > ihid->bufsize) |
328 | return -EINVAL; |
329 | |
330 | if (!do_set && le16_to_cpu(ihid->hdesc.wMaxOutputLength) == 0) |
331 | return -ENOSYS; |
332 | |
333 | if (do_set) { |
334 | /* Command register goes first */ |
335 | *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister; |
336 | length += sizeof(__le16); |
337 | /* Next is SET_REPORT command */ |
338 | length += i2c_hid_encode_command(buf: ihid->cmdbuf + length, |
339 | I2C_HID_OPCODE_SET_REPORT, |
340 | report_type, report_id); |
341 | /* |
342 | * Report data will go into the data register. Because |
343 | * command can be either 2 or 3 bytes destination for |
344 | * the data register may be not aligned. |
345 | */ |
346 | put_unaligned_le16(le16_to_cpu(ihid->hdesc.wDataRegister), |
347 | p: ihid->cmdbuf + length); |
348 | length += sizeof(__le16); |
349 | } else { |
350 | /* |
351 | * With simple "send report" all data goes into the output |
352 | * register. |
353 | */ |
354 | *(__le16 *)ihid->cmdbuf = ihid->hdesc.wOutputRegister; |
355 | length += sizeof(__le16); |
356 | } |
357 | |
358 | length += i2c_hid_format_report(buf: ihid->cmdbuf + length, |
359 | report_id, data: buf, size: data_len); |
360 | |
361 | error = i2c_hid_xfer(ihid, send_buf: ihid->cmdbuf, send_len: length, NULL, recv_len: 0); |
362 | if (error) { |
363 | dev_err(&ihid->client->dev, |
364 | "failed to set a report to device: %d\n" , error); |
365 | return error; |
366 | } |
367 | |
368 | return data_len; |
369 | } |
370 | |
371 | static int i2c_hid_set_power_command(struct i2c_hid *ihid, int power_state) |
372 | { |
373 | size_t length; |
374 | |
375 | /* SET_POWER uses command register */ |
376 | *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister; |
377 | length = sizeof(__le16); |
378 | |
379 | /* Now the command itself */ |
380 | length += i2c_hid_encode_command(buf: ihid->cmdbuf + length, |
381 | I2C_HID_OPCODE_SET_POWER, |
382 | report_type: 0, report_id: power_state); |
383 | |
384 | return i2c_hid_xfer(ihid, send_buf: ihid->cmdbuf, send_len: length, NULL, recv_len: 0); |
385 | } |
386 | |
387 | static int i2c_hid_set_power(struct i2c_hid *ihid, int power_state) |
388 | { |
389 | int ret; |
390 | |
391 | i2c_hid_dbg(ihid, "%s\n" , __func__); |
392 | |
393 | /* |
394 | * Some devices require to send a command to wakeup before power on. |
395 | * The call will get a return value (EREMOTEIO) but device will be |
396 | * triggered and activated. After that, it goes like a normal device. |
397 | */ |
398 | if (power_state == I2C_HID_PWR_ON) { |
399 | ret = i2c_hid_set_power_command(ihid, I2C_HID_PWR_ON); |
400 | |
401 | /* Device was already activated */ |
402 | if (!ret) |
403 | goto set_pwr_exit; |
404 | } |
405 | |
406 | ret = i2c_hid_set_power_command(ihid, power_state); |
407 | if (ret) |
408 | dev_err(&ihid->client->dev, |
409 | "failed to change power setting.\n" ); |
410 | |
411 | set_pwr_exit: |
412 | |
413 | /* |
414 | * The HID over I2C specification states that if a DEVICE needs time |
415 | * after the PWR_ON request, it should utilise CLOCK stretching. |
416 | * However, it has been observered that the Windows driver provides a |
417 | * 1ms sleep between the PWR_ON and RESET requests. |
418 | * According to Goodix Windows even waits 60 ms after (other?) |
419 | * PWR_ON requests. Testing has confirmed that several devices |
420 | * will not work properly without a delay after a PWR_ON request. |
421 | */ |
422 | if (!ret && power_state == I2C_HID_PWR_ON) |
423 | msleep(msecs: 60); |
424 | |
425 | return ret; |
426 | } |
427 | |
428 | static int i2c_hid_start_hwreset(struct i2c_hid *ihid) |
429 | { |
430 | size_t length = 0; |
431 | int ret; |
432 | |
433 | i2c_hid_dbg(ihid, "%s\n" , __func__); |
434 | |
435 | /* |
436 | * This prevents sending feature reports while the device is |
437 | * being reset. Otherwise we may lose the reset complete |
438 | * interrupt. |
439 | */ |
440 | lockdep_assert_held(&ihid->reset_lock); |
441 | |
442 | ret = i2c_hid_set_power(ihid, I2C_HID_PWR_ON); |
443 | if (ret) |
444 | return ret; |
445 | |
446 | /* Prepare reset command. Command register goes first. */ |
447 | *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister; |
448 | length += sizeof(__le16); |
449 | /* Next is RESET command itself */ |
450 | length += i2c_hid_encode_command(buf: ihid->cmdbuf + length, |
451 | I2C_HID_OPCODE_RESET, report_type: 0, report_id: 0); |
452 | |
453 | set_bit(I2C_HID_RESET_PENDING, addr: &ihid->flags); |
454 | |
455 | ret = i2c_hid_xfer(ihid, send_buf: ihid->cmdbuf, send_len: length, NULL, recv_len: 0); |
456 | if (ret) { |
457 | dev_err(&ihid->client->dev, |
458 | "failed to reset device: %d\n" , ret); |
459 | goto err_clear_reset; |
460 | } |
461 | |
462 | return 0; |
463 | |
464 | err_clear_reset: |
465 | clear_bit(I2C_HID_RESET_PENDING, addr: &ihid->flags); |
466 | i2c_hid_set_power(ihid, I2C_HID_PWR_SLEEP); |
467 | return ret; |
468 | } |
469 | |
470 | static int i2c_hid_finish_hwreset(struct i2c_hid *ihid) |
471 | { |
472 | int ret = 0; |
473 | |
474 | i2c_hid_dbg(ihid, "%s: waiting...\n" , __func__); |
475 | |
476 | if (ihid->quirks & I2C_HID_QUIRK_NO_IRQ_AFTER_RESET) { |
477 | msleep(msecs: 100); |
478 | clear_bit(I2C_HID_RESET_PENDING, addr: &ihid->flags); |
479 | } else if (!wait_event_timeout(ihid->wait, |
480 | !test_bit(I2C_HID_RESET_PENDING, &ihid->flags), |
481 | msecs_to_jiffies(1000))) { |
482 | dev_warn(&ihid->client->dev, "device did not ack reset within 1000 ms\n" ); |
483 | clear_bit(I2C_HID_RESET_PENDING, addr: &ihid->flags); |
484 | } |
485 | i2c_hid_dbg(ihid, "%s: finished.\n" , __func__); |
486 | |
487 | /* At least some SIS devices need this after reset */ |
488 | if (!(ihid->quirks & I2C_HID_QUIRK_NO_WAKEUP_AFTER_RESET)) |
489 | ret = i2c_hid_set_power(ihid, I2C_HID_PWR_ON); |
490 | |
491 | return ret; |
492 | } |
493 | |
494 | static void i2c_hid_get_input(struct i2c_hid *ihid) |
495 | { |
496 | u16 size = le16_to_cpu(ihid->hdesc.wMaxInputLength); |
497 | u16 ret_size; |
498 | int ret; |
499 | |
500 | if (size > ihid->bufsize) |
501 | size = ihid->bufsize; |
502 | |
503 | ret = i2c_master_recv(client: ihid->client, buf: ihid->inbuf, count: size); |
504 | if (ret != size) { |
505 | if (ret < 0) |
506 | return; |
507 | |
508 | dev_err(&ihid->client->dev, "%s: got %d data instead of %d\n" , |
509 | __func__, ret, size); |
510 | return; |
511 | } |
512 | |
513 | /* Receiving buffer is properly aligned */ |
514 | ret_size = le16_to_cpup(p: (__le16 *)ihid->inbuf); |
515 | if (!ret_size) { |
516 | /* host or device initiated RESET completed */ |
517 | if (test_and_clear_bit(I2C_HID_RESET_PENDING, addr: &ihid->flags)) |
518 | wake_up(&ihid->wait); |
519 | return; |
520 | } |
521 | |
522 | if ((ihid->quirks & I2C_HID_QUIRK_BOGUS_IRQ) && ret_size == 0xffff) { |
523 | dev_warn_once(&ihid->client->dev, |
524 | "%s: IRQ triggered but there's no data\n" , |
525 | __func__); |
526 | return; |
527 | } |
528 | |
529 | if (ret_size > size || ret_size < sizeof(__le16)) { |
530 | if (ihid->quirks & I2C_HID_QUIRK_BAD_INPUT_SIZE) { |
531 | *(__le16 *)ihid->inbuf = cpu_to_le16(size); |
532 | ret_size = size; |
533 | } else { |
534 | dev_err(&ihid->client->dev, |
535 | "%s: incomplete report (%d/%d)\n" , |
536 | __func__, size, ret_size); |
537 | return; |
538 | } |
539 | } |
540 | |
541 | i2c_hid_dbg(ihid, "input: %*ph\n" , ret_size, ihid->inbuf); |
542 | |
543 | if (test_bit(I2C_HID_STARTED, &ihid->flags)) { |
544 | if (ihid->hid->group != HID_GROUP_RMI) |
545 | pm_wakeup_event(dev: &ihid->client->dev, msec: 0); |
546 | |
547 | hid_input_report(hid: ihid->hid, type: HID_INPUT_REPORT, |
548 | data: ihid->inbuf + sizeof(__le16), |
549 | size: ret_size - sizeof(__le16), interrupt: 1); |
550 | } |
551 | |
552 | return; |
553 | } |
554 | |
555 | static irqreturn_t i2c_hid_irq(int irq, void *dev_id) |
556 | { |
557 | struct i2c_hid *ihid = dev_id; |
558 | |
559 | if (test_bit(I2C_HID_READ_PENDING, &ihid->flags)) |
560 | return IRQ_HANDLED; |
561 | |
562 | i2c_hid_get_input(ihid); |
563 | |
564 | return IRQ_HANDLED; |
565 | } |
566 | |
567 | static int i2c_hid_get_report_length(struct hid_report *report) |
568 | { |
569 | return ((report->size - 1) >> 3) + 1 + |
570 | report->device->report_enum[report->type].numbered + 2; |
571 | } |
572 | |
573 | /* |
574 | * Traverse the supplied list of reports and find the longest |
575 | */ |
576 | static void i2c_hid_find_max_report(struct hid_device *hid, unsigned int type, |
577 | unsigned int *max) |
578 | { |
579 | struct hid_report *report; |
580 | unsigned int size; |
581 | |
582 | /* We should not rely on wMaxInputLength, as some devices may set it to |
583 | * a wrong length. */ |
584 | list_for_each_entry(report, &hid->report_enum[type].report_list, list) { |
585 | size = i2c_hid_get_report_length(report); |
586 | if (*max < size) |
587 | *max = size; |
588 | } |
589 | } |
590 | |
591 | static void i2c_hid_free_buffers(struct i2c_hid *ihid) |
592 | { |
593 | kfree(objp: ihid->inbuf); |
594 | kfree(objp: ihid->rawbuf); |
595 | kfree(objp: ihid->cmdbuf); |
596 | ihid->inbuf = NULL; |
597 | ihid->rawbuf = NULL; |
598 | ihid->cmdbuf = NULL; |
599 | ihid->bufsize = 0; |
600 | } |
601 | |
602 | static int i2c_hid_alloc_buffers(struct i2c_hid *ihid, size_t report_size) |
603 | { |
604 | /* |
605 | * The worst case is computed from the set_report command with a |
606 | * reportID > 15 and the maximum report length. |
607 | */ |
608 | int cmd_len = sizeof(__le16) + /* command register */ |
609 | sizeof(u8) + /* encoded report type/ID */ |
610 | sizeof(u8) + /* opcode */ |
611 | sizeof(u8) + /* optional 3rd byte report ID */ |
612 | sizeof(__le16) + /* data register */ |
613 | sizeof(__le16) + /* report data size */ |
614 | sizeof(u8) + /* report ID if numbered report */ |
615 | report_size; |
616 | |
617 | ihid->inbuf = kzalloc(size: report_size, GFP_KERNEL); |
618 | ihid->rawbuf = kzalloc(size: report_size, GFP_KERNEL); |
619 | ihid->cmdbuf = kzalloc(size: cmd_len, GFP_KERNEL); |
620 | |
621 | if (!ihid->inbuf || !ihid->rawbuf || !ihid->cmdbuf) { |
622 | i2c_hid_free_buffers(ihid); |
623 | return -ENOMEM; |
624 | } |
625 | |
626 | ihid->bufsize = report_size; |
627 | |
628 | return 0; |
629 | } |
630 | |
631 | static int i2c_hid_get_raw_report(struct hid_device *hid, |
632 | u8 report_type, u8 report_id, |
633 | u8 *buf, size_t count) |
634 | { |
635 | struct i2c_client *client = hid->driver_data; |
636 | struct i2c_hid *ihid = i2c_get_clientdata(client); |
637 | int ret_count; |
638 | |
639 | if (report_type == HID_OUTPUT_REPORT) |
640 | return -EINVAL; |
641 | |
642 | /* |
643 | * In case of unnumbered reports the response from the device will |
644 | * not have the report ID that the upper layers expect, so we need |
645 | * to stash it the buffer ourselves and adjust the data size. |
646 | */ |
647 | if (!report_id) { |
648 | buf[0] = 0; |
649 | buf++; |
650 | count--; |
651 | } |
652 | |
653 | ret_count = i2c_hid_get_report(ihid, |
654 | report_type: report_type == HID_FEATURE_REPORT ? 0x03 : 0x01, |
655 | report_id, recv_buf: buf, recv_len: count); |
656 | |
657 | if (ret_count > 0 && !report_id) |
658 | ret_count++; |
659 | |
660 | return ret_count; |
661 | } |
662 | |
663 | static int i2c_hid_output_raw_report(struct hid_device *hid, u8 report_type, |
664 | const u8 *buf, size_t count, bool do_set) |
665 | { |
666 | struct i2c_client *client = hid->driver_data; |
667 | struct i2c_hid *ihid = i2c_get_clientdata(client); |
668 | int report_id = buf[0]; |
669 | int ret; |
670 | |
671 | if (report_type == HID_INPUT_REPORT) |
672 | return -EINVAL; |
673 | |
674 | mutex_lock(&ihid->reset_lock); |
675 | |
676 | /* |
677 | * Note that both numbered and unnumbered reports passed here |
678 | * are supposed to have report ID stored in the 1st byte of the |
679 | * buffer, so we strip it off unconditionally before passing payload |
680 | * to i2c_hid_set_or_send_report which takes care of encoding |
681 | * everything properly. |
682 | */ |
683 | ret = i2c_hid_set_or_send_report(ihid, |
684 | report_type: report_type == HID_FEATURE_REPORT ? 0x03 : 0x02, |
685 | report_id, buf: buf + 1, data_len: count - 1, do_set); |
686 | |
687 | if (ret >= 0) |
688 | ret++; /* add report_id to the number of transferred bytes */ |
689 | |
690 | mutex_unlock(lock: &ihid->reset_lock); |
691 | |
692 | return ret; |
693 | } |
694 | |
695 | static int i2c_hid_output_report(struct hid_device *hid, u8 *buf, size_t count) |
696 | { |
697 | return i2c_hid_output_raw_report(hid, report_type: HID_OUTPUT_REPORT, buf, count, |
698 | do_set: false); |
699 | } |
700 | |
701 | static int i2c_hid_raw_request(struct hid_device *hid, unsigned char reportnum, |
702 | __u8 *buf, size_t len, unsigned char rtype, |
703 | int reqtype) |
704 | { |
705 | switch (reqtype) { |
706 | case HID_REQ_GET_REPORT: |
707 | return i2c_hid_get_raw_report(hid, report_type: rtype, report_id: reportnum, buf, count: len); |
708 | case HID_REQ_SET_REPORT: |
709 | if (buf[0] != reportnum) |
710 | return -EINVAL; |
711 | return i2c_hid_output_raw_report(hid, report_type: rtype, buf, count: len, do_set: true); |
712 | default: |
713 | return -EIO; |
714 | } |
715 | } |
716 | |
717 | static int i2c_hid_parse(struct hid_device *hid) |
718 | { |
719 | struct i2c_client *client = hid->driver_data; |
720 | struct i2c_hid *ihid = i2c_get_clientdata(client); |
721 | struct i2c_hid_desc *hdesc = &ihid->hdesc; |
722 | char *rdesc = NULL, *use_override = NULL; |
723 | unsigned int rsize; |
724 | int ret; |
725 | int tries = 3; |
726 | |
727 | i2c_hid_dbg(ihid, "entering %s\n" , __func__); |
728 | |
729 | rsize = le16_to_cpu(hdesc->wReportDescLength); |
730 | if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) { |
731 | dbg_hid("weird size of report descriptor (%u)\n" , rsize); |
732 | return -EINVAL; |
733 | } |
734 | |
735 | mutex_lock(&ihid->reset_lock); |
736 | do { |
737 | ret = i2c_hid_start_hwreset(ihid); |
738 | if (ret) |
739 | msleep(msecs: 1000); |
740 | } while (tries-- > 0 && ret); |
741 | |
742 | if (ret) |
743 | goto abort_reset; |
744 | |
745 | use_override = i2c_hid_get_dmi_hid_report_desc_override(i2c_name: client->name, |
746 | size: &rsize); |
747 | |
748 | if (use_override) { |
749 | rdesc = use_override; |
750 | i2c_hid_dbg(ihid, "Using a HID report descriptor override\n" ); |
751 | } else { |
752 | rdesc = kzalloc(size: rsize, GFP_KERNEL); |
753 | |
754 | if (!rdesc) { |
755 | ret = -ENOMEM; |
756 | goto abort_reset; |
757 | } |
758 | |
759 | i2c_hid_dbg(ihid, "asking HID report descriptor\n" ); |
760 | |
761 | ret = i2c_hid_read_register(ihid, |
762 | reg: ihid->hdesc.wReportDescRegister, |
763 | buf: rdesc, len: rsize); |
764 | if (ret) { |
765 | hid_err(hid, "reading report descriptor failed\n" ); |
766 | goto abort_reset; |
767 | } |
768 | } |
769 | |
770 | /* |
771 | * Windows directly reads the report-descriptor after sending reset |
772 | * and then waits for resets completion afterwards. Some touchpads |
773 | * actually wait for the report-descriptor to be read before signalling |
774 | * reset completion. |
775 | */ |
776 | ret = i2c_hid_finish_hwreset(ihid); |
777 | abort_reset: |
778 | clear_bit(I2C_HID_RESET_PENDING, addr: &ihid->flags); |
779 | mutex_unlock(lock: &ihid->reset_lock); |
780 | if (ret) |
781 | goto out; |
782 | |
783 | i2c_hid_dbg(ihid, "Report Descriptor: %*ph\n" , rsize, rdesc); |
784 | |
785 | ret = hid_parse_report(hid, start: rdesc, size: rsize); |
786 | if (ret) |
787 | dbg_hid("parsing report descriptor failed\n" ); |
788 | |
789 | out: |
790 | if (!use_override) |
791 | kfree(objp: rdesc); |
792 | |
793 | return ret; |
794 | } |
795 | |
796 | static int i2c_hid_start(struct hid_device *hid) |
797 | { |
798 | struct i2c_client *client = hid->driver_data; |
799 | struct i2c_hid *ihid = i2c_get_clientdata(client); |
800 | int ret; |
801 | unsigned int bufsize = HID_MIN_BUFFER_SIZE; |
802 | |
803 | i2c_hid_find_max_report(hid, type: HID_INPUT_REPORT, max: &bufsize); |
804 | i2c_hid_find_max_report(hid, type: HID_OUTPUT_REPORT, max: &bufsize); |
805 | i2c_hid_find_max_report(hid, type: HID_FEATURE_REPORT, max: &bufsize); |
806 | |
807 | if (bufsize > ihid->bufsize) { |
808 | disable_irq(irq: client->irq); |
809 | i2c_hid_free_buffers(ihid); |
810 | |
811 | ret = i2c_hid_alloc_buffers(ihid, report_size: bufsize); |
812 | enable_irq(irq: client->irq); |
813 | |
814 | if (ret) |
815 | return ret; |
816 | } |
817 | |
818 | return 0; |
819 | } |
820 | |
821 | static void i2c_hid_stop(struct hid_device *hid) |
822 | { |
823 | hid->claimed = 0; |
824 | } |
825 | |
826 | static int i2c_hid_open(struct hid_device *hid) |
827 | { |
828 | struct i2c_client *client = hid->driver_data; |
829 | struct i2c_hid *ihid = i2c_get_clientdata(client); |
830 | |
831 | set_bit(I2C_HID_STARTED, addr: &ihid->flags); |
832 | return 0; |
833 | } |
834 | |
835 | static void i2c_hid_close(struct hid_device *hid) |
836 | { |
837 | struct i2c_client *client = hid->driver_data; |
838 | struct i2c_hid *ihid = i2c_get_clientdata(client); |
839 | |
840 | clear_bit(I2C_HID_STARTED, addr: &ihid->flags); |
841 | } |
842 | |
843 | static const struct hid_ll_driver i2c_hid_ll_driver = { |
844 | .parse = i2c_hid_parse, |
845 | .start = i2c_hid_start, |
846 | .stop = i2c_hid_stop, |
847 | .open = i2c_hid_open, |
848 | .close = i2c_hid_close, |
849 | .output_report = i2c_hid_output_report, |
850 | .raw_request = i2c_hid_raw_request, |
851 | }; |
852 | |
853 | static int i2c_hid_init_irq(struct i2c_client *client) |
854 | { |
855 | struct i2c_hid *ihid = i2c_get_clientdata(client); |
856 | unsigned long irqflags = 0; |
857 | int ret; |
858 | |
859 | i2c_hid_dbg(ihid, "Requesting IRQ: %d\n" , client->irq); |
860 | |
861 | if (!irq_get_trigger_type(irq: client->irq)) |
862 | irqflags = IRQF_TRIGGER_LOW; |
863 | |
864 | ret = request_threaded_irq(irq: client->irq, NULL, thread_fn: i2c_hid_irq, |
865 | flags: irqflags | IRQF_ONESHOT | IRQF_NO_AUTOEN, |
866 | name: client->name, dev: ihid); |
867 | if (ret < 0) { |
868 | dev_warn(&client->dev, |
869 | "Could not register for %s interrupt, irq = %d," |
870 | " ret = %d\n" , |
871 | client->name, client->irq, ret); |
872 | |
873 | return ret; |
874 | } |
875 | |
876 | return 0; |
877 | } |
878 | |
879 | static int i2c_hid_fetch_hid_descriptor(struct i2c_hid *ihid) |
880 | { |
881 | struct i2c_client *client = ihid->client; |
882 | struct i2c_hid_desc *hdesc = &ihid->hdesc; |
883 | unsigned int dsize; |
884 | int error; |
885 | |
886 | /* i2c hid fetch using a fixed descriptor size (30 bytes) */ |
887 | if (i2c_hid_get_dmi_i2c_hid_desc_override(i2c_name: client->name)) { |
888 | i2c_hid_dbg(ihid, "Using a HID descriptor override\n" ); |
889 | ihid->hdesc = |
890 | *i2c_hid_get_dmi_i2c_hid_desc_override(i2c_name: client->name); |
891 | } else { |
892 | i2c_hid_dbg(ihid, "Fetching the HID descriptor\n" ); |
893 | error = i2c_hid_read_register(ihid, |
894 | reg: ihid->wHIDDescRegister, |
895 | buf: &ihid->hdesc, |
896 | len: sizeof(ihid->hdesc)); |
897 | if (error) { |
898 | dev_err(&ihid->client->dev, |
899 | "failed to fetch HID descriptor: %d\n" , |
900 | error); |
901 | return -ENODEV; |
902 | } |
903 | } |
904 | |
905 | /* Validate the length of HID descriptor, the 4 first bytes: |
906 | * bytes 0-1 -> length |
907 | * bytes 2-3 -> bcdVersion (has to be 1.00) */ |
908 | /* check bcdVersion == 1.0 */ |
909 | if (le16_to_cpu(hdesc->bcdVersion) != 0x0100) { |
910 | dev_err(&ihid->client->dev, |
911 | "unexpected HID descriptor bcdVersion (0x%04hx)\n" , |
912 | le16_to_cpu(hdesc->bcdVersion)); |
913 | return -ENODEV; |
914 | } |
915 | |
916 | /* Descriptor length should be 30 bytes as per the specification */ |
917 | dsize = le16_to_cpu(hdesc->wHIDDescLength); |
918 | if (dsize != sizeof(struct i2c_hid_desc)) { |
919 | dev_err(&ihid->client->dev, |
920 | "weird size of HID descriptor (%u)\n" , dsize); |
921 | return -ENODEV; |
922 | } |
923 | i2c_hid_dbg(ihid, "HID Descriptor: %*ph\n" , dsize, &ihid->hdesc); |
924 | return 0; |
925 | } |
926 | |
927 | static int i2c_hid_core_power_up(struct i2c_hid *ihid) |
928 | { |
929 | if (!ihid->ops->power_up) |
930 | return 0; |
931 | |
932 | return ihid->ops->power_up(ihid->ops); |
933 | } |
934 | |
935 | static void i2c_hid_core_power_down(struct i2c_hid *ihid) |
936 | { |
937 | if (!ihid->ops->power_down) |
938 | return; |
939 | |
940 | ihid->ops->power_down(ihid->ops); |
941 | } |
942 | |
943 | static void i2c_hid_core_shutdown_tail(struct i2c_hid *ihid) |
944 | { |
945 | if (!ihid->ops->shutdown_tail) |
946 | return; |
947 | |
948 | ihid->ops->shutdown_tail(ihid->ops); |
949 | } |
950 | |
951 | static int i2c_hid_core_suspend(struct i2c_hid *ihid, bool force_poweroff) |
952 | { |
953 | struct i2c_client *client = ihid->client; |
954 | struct hid_device *hid = ihid->hid; |
955 | int ret; |
956 | |
957 | ret = hid_driver_suspend(hdev: hid, PMSG_SUSPEND); |
958 | if (ret < 0) |
959 | return ret; |
960 | |
961 | /* Save some power */ |
962 | if (!(ihid->quirks & I2C_HID_QUIRK_NO_SLEEP_ON_SUSPEND)) |
963 | i2c_hid_set_power(ihid, I2C_HID_PWR_SLEEP); |
964 | |
965 | disable_irq(irq: client->irq); |
966 | |
967 | if (force_poweroff || !device_may_wakeup(dev: &client->dev)) |
968 | i2c_hid_core_power_down(ihid); |
969 | |
970 | return 0; |
971 | } |
972 | |
973 | static int i2c_hid_core_resume(struct i2c_hid *ihid) |
974 | { |
975 | struct i2c_client *client = ihid->client; |
976 | struct hid_device *hid = ihid->hid; |
977 | int ret; |
978 | |
979 | if (!device_may_wakeup(dev: &client->dev)) |
980 | i2c_hid_core_power_up(ihid); |
981 | |
982 | enable_irq(irq: client->irq); |
983 | |
984 | /* Instead of resetting device, simply powers the device on. This |
985 | * solves "incomplete reports" on Raydium devices 2386:3118 and |
986 | * 2386:4B33 and fixes various SIS touchscreens no longer sending |
987 | * data after a suspend/resume. |
988 | * |
989 | * However some ALPS touchpads generate IRQ storm without reset, so |
990 | * let's still reset them here. |
991 | */ |
992 | if (ihid->quirks & I2C_HID_QUIRK_RESET_ON_RESUME) { |
993 | mutex_lock(&ihid->reset_lock); |
994 | ret = i2c_hid_start_hwreset(ihid); |
995 | if (ret == 0) |
996 | ret = i2c_hid_finish_hwreset(ihid); |
997 | mutex_unlock(lock: &ihid->reset_lock); |
998 | } else { |
999 | ret = i2c_hid_set_power(ihid, I2C_HID_PWR_ON); |
1000 | } |
1001 | |
1002 | if (ret) |
1003 | return ret; |
1004 | |
1005 | return hid_driver_reset_resume(hdev: hid); |
1006 | } |
1007 | |
1008 | /* |
1009 | * Check that the device exists and parse the HID descriptor. |
1010 | */ |
1011 | static int __i2c_hid_core_probe(struct i2c_hid *ihid) |
1012 | { |
1013 | struct i2c_client *client = ihid->client; |
1014 | struct hid_device *hid = ihid->hid; |
1015 | int ret; |
1016 | |
1017 | /* Make sure there is something at this address */ |
1018 | ret = i2c_smbus_read_byte(client); |
1019 | if (ret < 0) { |
1020 | i2c_hid_dbg(ihid, "nothing at this address: %d\n" , ret); |
1021 | return -ENXIO; |
1022 | } |
1023 | |
1024 | ret = i2c_hid_fetch_hid_descriptor(ihid); |
1025 | if (ret < 0) { |
1026 | dev_err(&client->dev, |
1027 | "Failed to fetch the HID Descriptor\n" ); |
1028 | return ret; |
1029 | } |
1030 | |
1031 | hid->version = le16_to_cpu(ihid->hdesc.bcdVersion); |
1032 | hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID); |
1033 | hid->product = le16_to_cpu(ihid->hdesc.wProductID); |
1034 | |
1035 | hid->initial_quirks |= i2c_hid_get_dmi_quirks(vendor: hid->vendor, |
1036 | product: hid->product); |
1037 | |
1038 | snprintf(buf: hid->name, size: sizeof(hid->name), fmt: "%s %04X:%04X" , |
1039 | client->name, (u16)hid->vendor, (u16)hid->product); |
1040 | strscpy(hid->phys, dev_name(&client->dev), sizeof(hid->phys)); |
1041 | |
1042 | ihid->quirks = i2c_hid_lookup_quirk(idVendor: hid->vendor, idProduct: hid->product); |
1043 | |
1044 | return 0; |
1045 | } |
1046 | |
1047 | static int i2c_hid_core_register_hid(struct i2c_hid *ihid) |
1048 | { |
1049 | struct i2c_client *client = ihid->client; |
1050 | struct hid_device *hid = ihid->hid; |
1051 | int ret; |
1052 | |
1053 | enable_irq(irq: client->irq); |
1054 | |
1055 | ret = hid_add_device(hid); |
1056 | if (ret) { |
1057 | if (ret != -ENODEV) |
1058 | hid_err(client, "can't add hid device: %d\n" , ret); |
1059 | disable_irq(irq: client->irq); |
1060 | return ret; |
1061 | } |
1062 | |
1063 | return 0; |
1064 | } |
1065 | |
1066 | static int i2c_hid_core_probe_panel_follower(struct i2c_hid *ihid) |
1067 | { |
1068 | int ret; |
1069 | |
1070 | ret = i2c_hid_core_power_up(ihid); |
1071 | if (ret) |
1072 | return ret; |
1073 | |
1074 | ret = __i2c_hid_core_probe(ihid); |
1075 | if (ret) |
1076 | goto err_power_down; |
1077 | |
1078 | ret = i2c_hid_core_register_hid(ihid); |
1079 | if (ret) |
1080 | goto err_power_down; |
1081 | |
1082 | return 0; |
1083 | |
1084 | err_power_down: |
1085 | i2c_hid_core_power_down(ihid); |
1086 | |
1087 | return ret; |
1088 | } |
1089 | |
1090 | static void ihid_core_panel_prepare_work(struct work_struct *work) |
1091 | { |
1092 | struct i2c_hid *ihid = container_of(work, struct i2c_hid, |
1093 | panel_follower_prepare_work); |
1094 | struct hid_device *hid = ihid->hid; |
1095 | int ret; |
1096 | |
1097 | /* |
1098 | * hid->version is set on the first power up. If it's still zero then |
1099 | * this is the first power on so we should perform initial power up |
1100 | * steps. |
1101 | */ |
1102 | if (!hid->version) |
1103 | ret = i2c_hid_core_probe_panel_follower(ihid); |
1104 | else |
1105 | ret = i2c_hid_core_resume(ihid); |
1106 | |
1107 | if (ret) |
1108 | dev_warn(&ihid->client->dev, "Power on failed: %d\n" , ret); |
1109 | else |
1110 | WRITE_ONCE(ihid->prepare_work_finished, true); |
1111 | |
1112 | /* |
1113 | * The work APIs provide a number of memory ordering guarantees |
1114 | * including one that says that memory writes before schedule_work() |
1115 | * are always visible to the work function, but they don't appear to |
1116 | * guarantee that a write that happened in the work is visible after |
1117 | * cancel_work_sync(). We'll add a write memory barrier here to match |
1118 | * with i2c_hid_core_panel_unpreparing() to ensure that our write to |
1119 | * prepare_work_finished is visible there. |
1120 | */ |
1121 | smp_wmb(); |
1122 | } |
1123 | |
1124 | static int i2c_hid_core_panel_prepared(struct drm_panel_follower *follower) |
1125 | { |
1126 | struct i2c_hid *ihid = container_of(follower, struct i2c_hid, panel_follower); |
1127 | |
1128 | /* |
1129 | * Powering on a touchscreen can be a slow process. Queue the work to |
1130 | * the system workqueue so we don't block the panel's power up. |
1131 | */ |
1132 | WRITE_ONCE(ihid->prepare_work_finished, false); |
1133 | schedule_work(work: &ihid->panel_follower_prepare_work); |
1134 | |
1135 | return 0; |
1136 | } |
1137 | |
1138 | static int i2c_hid_core_panel_unpreparing(struct drm_panel_follower *follower) |
1139 | { |
1140 | struct i2c_hid *ihid = container_of(follower, struct i2c_hid, panel_follower); |
1141 | |
1142 | cancel_work_sync(work: &ihid->panel_follower_prepare_work); |
1143 | |
1144 | /* Match with ihid_core_panel_prepare_work() */ |
1145 | smp_rmb(); |
1146 | if (!READ_ONCE(ihid->prepare_work_finished)) |
1147 | return 0; |
1148 | |
1149 | return i2c_hid_core_suspend(ihid, force_poweroff: true); |
1150 | } |
1151 | |
1152 | static const struct drm_panel_follower_funcs i2c_hid_core_panel_follower_funcs = { |
1153 | .panel_prepared = i2c_hid_core_panel_prepared, |
1154 | .panel_unpreparing = i2c_hid_core_panel_unpreparing, |
1155 | }; |
1156 | |
1157 | static int i2c_hid_core_register_panel_follower(struct i2c_hid *ihid) |
1158 | { |
1159 | struct device *dev = &ihid->client->dev; |
1160 | int ret; |
1161 | |
1162 | ihid->panel_follower.funcs = &i2c_hid_core_panel_follower_funcs; |
1163 | |
1164 | /* |
1165 | * If we're not in control of our own power up/power down then we can't |
1166 | * do the logic to manage wakeups. Give a warning if a user thought |
1167 | * that was possible then force the capability off. |
1168 | */ |
1169 | if (device_can_wakeup(dev)) { |
1170 | dev_warn(dev, "Can't wakeup if following panel\n" ); |
1171 | device_set_wakeup_capable(dev, capable: false); |
1172 | } |
1173 | |
1174 | ret = drm_panel_add_follower(follower_dev: dev, follower: &ihid->panel_follower); |
1175 | if (ret) |
1176 | return ret; |
1177 | |
1178 | return 0; |
1179 | } |
1180 | |
1181 | int i2c_hid_core_probe(struct i2c_client *client, struct i2chid_ops *ops, |
1182 | u16 hid_descriptor_address, u32 quirks) |
1183 | { |
1184 | int ret; |
1185 | struct i2c_hid *ihid; |
1186 | struct hid_device *hid; |
1187 | |
1188 | dbg_hid("HID probe called for i2c 0x%02x\n" , client->addr); |
1189 | |
1190 | if (!client->irq) { |
1191 | dev_err(&client->dev, |
1192 | "HID over i2c has not been provided an Int IRQ\n" ); |
1193 | return -EINVAL; |
1194 | } |
1195 | |
1196 | if (client->irq < 0) { |
1197 | if (client->irq != -EPROBE_DEFER) |
1198 | dev_err(&client->dev, |
1199 | "HID over i2c doesn't have a valid IRQ\n" ); |
1200 | return client->irq; |
1201 | } |
1202 | |
1203 | ihid = devm_kzalloc(dev: &client->dev, size: sizeof(*ihid), GFP_KERNEL); |
1204 | if (!ihid) |
1205 | return -ENOMEM; |
1206 | |
1207 | i2c_set_clientdata(client, data: ihid); |
1208 | |
1209 | ihid->ops = ops; |
1210 | ihid->client = client; |
1211 | ihid->wHIDDescRegister = cpu_to_le16(hid_descriptor_address); |
1212 | ihid->is_panel_follower = drm_is_panel_follower(dev: &client->dev); |
1213 | |
1214 | init_waitqueue_head(&ihid->wait); |
1215 | mutex_init(&ihid->reset_lock); |
1216 | INIT_WORK(&ihid->panel_follower_prepare_work, ihid_core_panel_prepare_work); |
1217 | |
1218 | /* we need to allocate the command buffer without knowing the maximum |
1219 | * size of the reports. Let's use HID_MIN_BUFFER_SIZE, then we do the |
1220 | * real computation later. */ |
1221 | ret = i2c_hid_alloc_buffers(ihid, HID_MIN_BUFFER_SIZE); |
1222 | if (ret < 0) |
1223 | return ret; |
1224 | device_enable_async_suspend(dev: &client->dev); |
1225 | |
1226 | hid = hid_allocate_device(); |
1227 | if (IS_ERR(ptr: hid)) { |
1228 | ret = PTR_ERR(ptr: hid); |
1229 | goto err_free_buffers; |
1230 | } |
1231 | |
1232 | ihid->hid = hid; |
1233 | |
1234 | hid->driver_data = client; |
1235 | hid->ll_driver = &i2c_hid_ll_driver; |
1236 | hid->dev.parent = &client->dev; |
1237 | hid->bus = BUS_I2C; |
1238 | hid->initial_quirks = quirks; |
1239 | |
1240 | /* Power on and probe unless device is a panel follower. */ |
1241 | if (!ihid->is_panel_follower) { |
1242 | ret = i2c_hid_core_power_up(ihid); |
1243 | if (ret < 0) |
1244 | goto err_destroy_device; |
1245 | |
1246 | ret = __i2c_hid_core_probe(ihid); |
1247 | if (ret < 0) |
1248 | goto err_power_down; |
1249 | } |
1250 | |
1251 | ret = i2c_hid_init_irq(client); |
1252 | if (ret < 0) |
1253 | goto err_power_down; |
1254 | |
1255 | /* |
1256 | * If we're a panel follower, we'll register when the panel turns on; |
1257 | * otherwise we do it right away. |
1258 | */ |
1259 | if (ihid->is_panel_follower) |
1260 | ret = i2c_hid_core_register_panel_follower(ihid); |
1261 | else |
1262 | ret = i2c_hid_core_register_hid(ihid); |
1263 | if (ret) |
1264 | goto err_free_irq; |
1265 | |
1266 | return 0; |
1267 | |
1268 | err_free_irq: |
1269 | free_irq(client->irq, ihid); |
1270 | err_power_down: |
1271 | if (!ihid->is_panel_follower) |
1272 | i2c_hid_core_power_down(ihid); |
1273 | err_destroy_device: |
1274 | hid_destroy_device(hid); |
1275 | err_free_buffers: |
1276 | i2c_hid_free_buffers(ihid); |
1277 | |
1278 | return ret; |
1279 | } |
1280 | EXPORT_SYMBOL_GPL(i2c_hid_core_probe); |
1281 | |
1282 | void i2c_hid_core_remove(struct i2c_client *client) |
1283 | { |
1284 | struct i2c_hid *ihid = i2c_get_clientdata(client); |
1285 | struct hid_device *hid; |
1286 | |
1287 | /* |
1288 | * If we're a follower, the act of unfollowing will cause us to be |
1289 | * powered down. Otherwise we need to manually do it. |
1290 | */ |
1291 | if (ihid->is_panel_follower) |
1292 | drm_panel_remove_follower(follower: &ihid->panel_follower); |
1293 | else |
1294 | i2c_hid_core_suspend(ihid, force_poweroff: true); |
1295 | |
1296 | hid = ihid->hid; |
1297 | hid_destroy_device(hid); |
1298 | |
1299 | free_irq(client->irq, ihid); |
1300 | |
1301 | if (ihid->bufsize) |
1302 | i2c_hid_free_buffers(ihid); |
1303 | } |
1304 | EXPORT_SYMBOL_GPL(i2c_hid_core_remove); |
1305 | |
1306 | void i2c_hid_core_shutdown(struct i2c_client *client) |
1307 | { |
1308 | struct i2c_hid *ihid = i2c_get_clientdata(client); |
1309 | |
1310 | i2c_hid_set_power(ihid, I2C_HID_PWR_SLEEP); |
1311 | free_irq(client->irq, ihid); |
1312 | |
1313 | i2c_hid_core_shutdown_tail(ihid); |
1314 | } |
1315 | EXPORT_SYMBOL_GPL(i2c_hid_core_shutdown); |
1316 | |
1317 | static int i2c_hid_core_pm_suspend(struct device *dev) |
1318 | { |
1319 | struct i2c_client *client = to_i2c_client(dev); |
1320 | struct i2c_hid *ihid = i2c_get_clientdata(client); |
1321 | |
1322 | if (ihid->is_panel_follower) |
1323 | return 0; |
1324 | |
1325 | return i2c_hid_core_suspend(ihid, force_poweroff: false); |
1326 | } |
1327 | |
1328 | static int i2c_hid_core_pm_resume(struct device *dev) |
1329 | { |
1330 | struct i2c_client *client = to_i2c_client(dev); |
1331 | struct i2c_hid *ihid = i2c_get_clientdata(client); |
1332 | |
1333 | if (ihid->is_panel_follower) |
1334 | return 0; |
1335 | |
1336 | return i2c_hid_core_resume(ihid); |
1337 | } |
1338 | |
1339 | const struct dev_pm_ops i2c_hid_core_pm = { |
1340 | SYSTEM_SLEEP_PM_OPS(i2c_hid_core_pm_suspend, i2c_hid_core_pm_resume) |
1341 | }; |
1342 | EXPORT_SYMBOL_GPL(i2c_hid_core_pm); |
1343 | |
1344 | MODULE_DESCRIPTION("HID over I2C core driver" ); |
1345 | MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>" ); |
1346 | MODULE_LICENSE("GPL" ); |
1347 | |