1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * ISHTP client driver for HID (ISH) |
4 | * |
5 | * Copyright (c) 2014-2016, Intel Corporation. |
6 | */ |
7 | |
8 | #include <linux/module.h> |
9 | #include <linux/hid.h> |
10 | #include <linux/intel-ish-client-if.h> |
11 | #include <linux/sched.h> |
12 | #include "ishtp-hid.h" |
13 | |
14 | /* ISH Transport protocol (ISHTP in short) GUID */ |
15 | static const struct ishtp_device_id hid_ishtp_id_table[] = { |
16 | { .guid = GUID_INIT(0x33AECD58, 0xB679, 0x4E54, |
17 | 0x9B, 0xD9, 0xA0, 0x4D, 0x34, 0xF0, 0xC2, 0x26), }, |
18 | { } |
19 | }; |
20 | MODULE_DEVICE_TABLE(ishtp, hid_ishtp_id_table); |
21 | |
22 | /* Rx ring buffer pool size */ |
23 | #define HID_CL_RX_RING_SIZE 32 |
24 | #define HID_CL_TX_RING_SIZE 16 |
25 | |
26 | #define cl_data_to_dev(client_data) ishtp_device(client_data->cl_device) |
27 | |
28 | /** |
29 | * report_bad_packet() - Report bad packets |
30 | * @hid_ishtp_cl: Client instance to get stats |
31 | * @recv_buf: Raw received host interface message |
32 | * @cur_pos: Current position index in payload |
33 | * @payload_len: Length of payload expected |
34 | * |
35 | * Dumps error in case bad packet is received |
36 | */ |
37 | static void report_bad_packet(struct ishtp_cl *hid_ishtp_cl, void *recv_buf, |
38 | size_t cur_pos, size_t payload_len) |
39 | { |
40 | struct hostif_msg *recv_msg = recv_buf; |
41 | struct ishtp_cl_data *client_data = ishtp_get_client_data(cl: hid_ishtp_cl); |
42 | |
43 | dev_err(cl_data_to_dev(client_data), "[hid-ish]: BAD packet %02X\n" |
44 | "total_bad=%u cur_pos=%u\n" |
45 | "[%02X %02X %02X %02X]\n" |
46 | "payload_len=%u\n" |
47 | "multi_packet_cnt=%u\n" |
48 | "is_response=%02X\n" , |
49 | recv_msg->hdr.command, client_data->bad_recv_cnt, |
50 | (unsigned int)cur_pos, |
51 | ((unsigned char *)recv_msg)[0], ((unsigned char *)recv_msg)[1], |
52 | ((unsigned char *)recv_msg)[2], ((unsigned char *)recv_msg)[3], |
53 | (unsigned int)payload_len, client_data->multi_packet_cnt, |
54 | recv_msg->hdr.command & ~CMD_MASK); |
55 | } |
56 | |
57 | /** |
58 | * process_recv() - Received and parse incoming packet |
59 | * @hid_ishtp_cl: Client instance to get stats |
60 | * @recv_buf: Raw received host interface message |
61 | * @data_len: length of the message |
62 | * |
63 | * Parse the incoming packet. If it is a response packet then it will update |
64 | * per instance flags and wake up the caller waiting to for the response. |
65 | */ |
66 | static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf, |
67 | size_t data_len) |
68 | { |
69 | struct hostif_msg *recv_msg; |
70 | unsigned char *payload; |
71 | struct device_info *dev_info; |
72 | int i, j; |
73 | size_t payload_len, total_len, cur_pos, raw_len; |
74 | int report_type; |
75 | struct report_list *reports_list; |
76 | char *reports; |
77 | size_t report_len; |
78 | struct ishtp_cl_data *client_data = ishtp_get_client_data(cl: hid_ishtp_cl); |
79 | int curr_hid_dev = client_data->cur_hid_dev; |
80 | struct ishtp_hid_data *hid_data = NULL; |
81 | struct hid_device *hid = NULL; |
82 | |
83 | payload = recv_buf + sizeof(struct hostif_msg_hdr); |
84 | total_len = data_len; |
85 | cur_pos = 0; |
86 | |
87 | do { |
88 | if (cur_pos + sizeof(struct hostif_msg) > total_len) { |
89 | dev_err(cl_data_to_dev(client_data), |
90 | "[hid-ish]: error, received %u which is less than data header %u\n" , |
91 | (unsigned int)data_len, |
92 | (unsigned int)sizeof(struct hostif_msg_hdr)); |
93 | ++client_data->bad_recv_cnt; |
94 | ish_hw_reset(dev: ishtp_get_ishtp_device(cl: hid_ishtp_cl)); |
95 | break; |
96 | } |
97 | |
98 | recv_msg = (struct hostif_msg *)(recv_buf + cur_pos); |
99 | payload_len = recv_msg->hdr.size; |
100 | |
101 | /* Sanity checks */ |
102 | if (cur_pos + payload_len + sizeof(struct hostif_msg) > |
103 | total_len) { |
104 | ++client_data->bad_recv_cnt; |
105 | report_bad_packet(hid_ishtp_cl, recv_buf: recv_msg, cur_pos, |
106 | payload_len); |
107 | ish_hw_reset(dev: ishtp_get_ishtp_device(cl: hid_ishtp_cl)); |
108 | break; |
109 | } |
110 | |
111 | hid_ishtp_trace(client_data, "%s %d\n" , |
112 | __func__, recv_msg->hdr.command & CMD_MASK); |
113 | |
114 | switch (recv_msg->hdr.command & CMD_MASK) { |
115 | case HOSTIF_DM_ENUM_DEVICES: |
116 | if ((!(recv_msg->hdr.command & ~CMD_MASK) || |
117 | client_data->init_done)) { |
118 | ++client_data->bad_recv_cnt; |
119 | report_bad_packet(hid_ishtp_cl, recv_buf: recv_msg, |
120 | cur_pos, |
121 | payload_len); |
122 | ish_hw_reset(dev: ishtp_get_ishtp_device(cl: hid_ishtp_cl)); |
123 | break; |
124 | } |
125 | client_data->hid_dev_count = (unsigned int)*payload; |
126 | if (!client_data->hid_devices) |
127 | client_data->hid_devices = devm_kcalloc( |
128 | cl_data_to_dev(client_data), |
129 | n: client_data->hid_dev_count, |
130 | size: sizeof(struct device_info), |
131 | GFP_KERNEL); |
132 | if (!client_data->hid_devices) { |
133 | dev_err(cl_data_to_dev(client_data), |
134 | "Mem alloc failed for hid device info\n" ); |
135 | wake_up_interruptible(&client_data->init_wait); |
136 | break; |
137 | } |
138 | for (i = 0; i < client_data->hid_dev_count; ++i) { |
139 | if (1 + sizeof(struct device_info) * i >= |
140 | payload_len) { |
141 | dev_err(cl_data_to_dev(client_data), |
142 | "[hid-ish]: [ENUM_DEVICES]: content size %zu is bigger than payload_len %zu\n" , |
143 | 1 + sizeof(struct device_info) |
144 | * i, payload_len); |
145 | } |
146 | |
147 | if (1 + sizeof(struct device_info) * i >= |
148 | data_len) |
149 | break; |
150 | |
151 | dev_info = (struct device_info *)(payload + 1 + |
152 | sizeof(struct device_info) * i); |
153 | if (client_data->hid_devices) |
154 | memcpy(client_data->hid_devices + i, |
155 | dev_info, |
156 | sizeof(struct device_info)); |
157 | } |
158 | |
159 | client_data->enum_devices_done = true; |
160 | wake_up_interruptible(&client_data->init_wait); |
161 | |
162 | break; |
163 | |
164 | case HOSTIF_GET_HID_DESCRIPTOR: |
165 | if ((!(recv_msg->hdr.command & ~CMD_MASK) || |
166 | client_data->init_done)) { |
167 | ++client_data->bad_recv_cnt; |
168 | report_bad_packet(hid_ishtp_cl, recv_buf: recv_msg, |
169 | cur_pos, |
170 | payload_len); |
171 | ish_hw_reset(dev: ishtp_get_ishtp_device(cl: hid_ishtp_cl)); |
172 | break; |
173 | } |
174 | if (!client_data->hid_descr[curr_hid_dev]) |
175 | client_data->hid_descr[curr_hid_dev] = |
176 | devm_kmalloc(cl_data_to_dev(client_data), |
177 | size: payload_len, GFP_KERNEL); |
178 | if (client_data->hid_descr[curr_hid_dev]) { |
179 | memcpy(client_data->hid_descr[curr_hid_dev], |
180 | payload, payload_len); |
181 | client_data->hid_descr_size[curr_hid_dev] = |
182 | payload_len; |
183 | client_data->hid_descr_done = true; |
184 | } |
185 | wake_up_interruptible(&client_data->init_wait); |
186 | |
187 | break; |
188 | |
189 | case HOSTIF_GET_REPORT_DESCRIPTOR: |
190 | if ((!(recv_msg->hdr.command & ~CMD_MASK) || |
191 | client_data->init_done)) { |
192 | ++client_data->bad_recv_cnt; |
193 | report_bad_packet(hid_ishtp_cl, recv_buf: recv_msg, |
194 | cur_pos, |
195 | payload_len); |
196 | ish_hw_reset(dev: ishtp_get_ishtp_device(cl: hid_ishtp_cl)); |
197 | break; |
198 | } |
199 | if (!client_data->report_descr[curr_hid_dev]) |
200 | client_data->report_descr[curr_hid_dev] = |
201 | devm_kmalloc(cl_data_to_dev(client_data), |
202 | size: payload_len, GFP_KERNEL); |
203 | if (client_data->report_descr[curr_hid_dev]) { |
204 | memcpy(client_data->report_descr[curr_hid_dev], |
205 | payload, |
206 | payload_len); |
207 | client_data->report_descr_size[curr_hid_dev] = |
208 | payload_len; |
209 | client_data->report_descr_done = true; |
210 | } |
211 | wake_up_interruptible(&client_data->init_wait); |
212 | |
213 | break; |
214 | |
215 | case HOSTIF_GET_FEATURE_REPORT: |
216 | report_type = HID_FEATURE_REPORT; |
217 | goto do_get_report; |
218 | |
219 | case HOSTIF_GET_INPUT_REPORT: |
220 | report_type = HID_INPUT_REPORT; |
221 | do_get_report: |
222 | /* Get index of device that matches this id */ |
223 | for (i = 0; i < client_data->num_hid_devices; ++i) { |
224 | if (recv_msg->hdr.device_id == |
225 | client_data->hid_devices[i].dev_id) { |
226 | hid = client_data->hid_sensor_hubs[i]; |
227 | if (!hid) |
228 | break; |
229 | |
230 | hid_data = hid->driver_data; |
231 | if (hid_data->raw_get_req) { |
232 | raw_len = |
233 | (hid_data->raw_buf_size < |
234 | payload_len) ? |
235 | hid_data->raw_buf_size : |
236 | payload_len; |
237 | |
238 | memcpy(hid_data->raw_buf, |
239 | payload, raw_len); |
240 | } else { |
241 | hid_input_report |
242 | (hid, type: report_type, |
243 | data: payload, size: payload_len, |
244 | interrupt: 0); |
245 | } |
246 | |
247 | ishtp_hid_wakeup(hid); |
248 | break; |
249 | } |
250 | } |
251 | break; |
252 | |
253 | case HOSTIF_SET_FEATURE_REPORT: |
254 | /* Get index of device that matches this id */ |
255 | for (i = 0; i < client_data->num_hid_devices; ++i) { |
256 | if (recv_msg->hdr.device_id == |
257 | client_data->hid_devices[i].dev_id) |
258 | if (client_data->hid_sensor_hubs[i]) { |
259 | ishtp_hid_wakeup( |
260 | hid: client_data->hid_sensor_hubs[ |
261 | i]); |
262 | break; |
263 | } |
264 | } |
265 | break; |
266 | |
267 | case HOSTIF_PUBLISH_INPUT_REPORT: |
268 | report_type = HID_INPUT_REPORT; |
269 | for (i = 0; i < client_data->num_hid_devices; ++i) |
270 | if (recv_msg->hdr.device_id == |
271 | client_data->hid_devices[i].dev_id) |
272 | if (client_data->hid_sensor_hubs[i]) |
273 | hid_input_report( |
274 | hid: client_data->hid_sensor_hubs[ |
275 | i], |
276 | type: report_type, data: payload, |
277 | size: payload_len, interrupt: 0); |
278 | break; |
279 | |
280 | case HOSTIF_PUBLISH_INPUT_REPORT_LIST: |
281 | report_type = HID_INPUT_REPORT; |
282 | reports_list = (struct report_list *)payload; |
283 | reports = (char *)reports_list->reports; |
284 | |
285 | for (j = 0; j < reports_list->num_of_reports; j++) { |
286 | recv_msg = (struct hostif_msg *)(reports + |
287 | sizeof(uint16_t)); |
288 | report_len = *(uint16_t *)reports; |
289 | payload = reports + sizeof(uint16_t) + |
290 | sizeof(struct hostif_msg_hdr); |
291 | payload_len = report_len - |
292 | sizeof(struct hostif_msg_hdr); |
293 | |
294 | for (i = 0; i < client_data->num_hid_devices; |
295 | ++i) |
296 | if (recv_msg->hdr.device_id == |
297 | client_data->hid_devices[i].dev_id && |
298 | client_data->hid_sensor_hubs[i]) { |
299 | hid_input_report( |
300 | hid: client_data->hid_sensor_hubs[ |
301 | i], |
302 | type: report_type, |
303 | data: payload, size: payload_len, |
304 | interrupt: 0); |
305 | } |
306 | |
307 | reports += sizeof(uint16_t) + report_len; |
308 | } |
309 | break; |
310 | default: |
311 | ++client_data->bad_recv_cnt; |
312 | report_bad_packet(hid_ishtp_cl, recv_buf: recv_msg, cur_pos, |
313 | payload_len); |
314 | ish_hw_reset(dev: ishtp_get_ishtp_device(cl: hid_ishtp_cl)); |
315 | break; |
316 | |
317 | } |
318 | |
319 | if (!cur_pos && cur_pos + payload_len + |
320 | sizeof(struct hostif_msg) < total_len) |
321 | ++client_data->multi_packet_cnt; |
322 | |
323 | cur_pos += payload_len + sizeof(struct hostif_msg); |
324 | payload += payload_len + sizeof(struct hostif_msg); |
325 | |
326 | } while (cur_pos < total_len); |
327 | } |
328 | |
329 | /** |
330 | * ish_cl_event_cb() - bus driver callback for incoming message/packet |
331 | * @device: Pointer to the ishtp client device for which this message |
332 | * is targeted |
333 | * |
334 | * Remove the packet from the list and process the message by calling |
335 | * process_recv |
336 | */ |
337 | static void ish_cl_event_cb(struct ishtp_cl_device *device) |
338 | { |
339 | struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device: device); |
340 | struct ishtp_cl_rb *rb_in_proc; |
341 | size_t r_length; |
342 | |
343 | if (!hid_ishtp_cl) |
344 | return; |
345 | |
346 | while ((rb_in_proc = ishtp_cl_rx_get_rb(cl: hid_ishtp_cl)) != NULL) { |
347 | if (!rb_in_proc->buffer.data) |
348 | return; |
349 | |
350 | r_length = rb_in_proc->buf_idx; |
351 | |
352 | /* decide what to do with received data */ |
353 | process_recv(hid_ishtp_cl, recv_buf: rb_in_proc->buffer.data, data_len: r_length); |
354 | |
355 | ishtp_cl_io_rb_recycle(rb: rb_in_proc); |
356 | } |
357 | } |
358 | |
359 | /** |
360 | * hid_ishtp_set_feature() - send request to ISH FW to set a feature request |
361 | * @hid: hid device instance for this request |
362 | * @buf: feature buffer |
363 | * @len: Length of feature buffer |
364 | * @report_id: Report id for the feature set request |
365 | * |
366 | * This is called from hid core .request() callback. This function doesn't wait |
367 | * for response. |
368 | */ |
369 | void hid_ishtp_set_feature(struct hid_device *hid, char *buf, unsigned int len, |
370 | int report_id) |
371 | { |
372 | struct ishtp_hid_data *hid_data = hid->driver_data; |
373 | struct ishtp_cl_data *client_data = hid_data->client_data; |
374 | struct hostif_msg *msg = (struct hostif_msg *)buf; |
375 | int rv; |
376 | int i; |
377 | |
378 | hid_ishtp_trace(client_data, "%s hid %p\n" , __func__, hid); |
379 | |
380 | rv = ishtp_hid_link_ready_wait(client_data); |
381 | if (rv) { |
382 | hid_ishtp_trace(client_data, "%s hid %p link not ready\n" , |
383 | __func__, hid); |
384 | return; |
385 | } |
386 | |
387 | memset(msg, 0, sizeof(struct hostif_msg)); |
388 | msg->hdr.command = HOSTIF_SET_FEATURE_REPORT; |
389 | for (i = 0; i < client_data->num_hid_devices; ++i) { |
390 | if (hid == client_data->hid_sensor_hubs[i]) { |
391 | msg->hdr.device_id = |
392 | client_data->hid_devices[i].dev_id; |
393 | break; |
394 | } |
395 | } |
396 | |
397 | if (i == client_data->num_hid_devices) |
398 | return; |
399 | |
400 | rv = ishtp_cl_send(cl: client_data->hid_ishtp_cl, buf, length: len); |
401 | if (rv) |
402 | hid_ishtp_trace(client_data, "%s hid %p send failed\n" , |
403 | __func__, hid); |
404 | } |
405 | |
406 | /** |
407 | * hid_ishtp_get_report() - request to get feature/input report |
408 | * @hid: hid device instance for this request |
409 | * @report_id: Report id for the get request |
410 | * @report_type: Report type for the this request |
411 | * |
412 | * This is called from hid core .request() callback. This function will send |
413 | * request to FW and return without waiting for response. |
414 | */ |
415 | void hid_ishtp_get_report(struct hid_device *hid, int report_id, |
416 | int report_type) |
417 | { |
418 | struct ishtp_hid_data *hid_data = hid->driver_data; |
419 | struct ishtp_cl_data *client_data = hid_data->client_data; |
420 | struct hostif_msg_to_sensor msg = {}; |
421 | int rv; |
422 | int i; |
423 | |
424 | hid_ishtp_trace(client_data, "%s hid %p\n" , __func__, hid); |
425 | rv = ishtp_hid_link_ready_wait(client_data); |
426 | if (rv) { |
427 | hid_ishtp_trace(client_data, "%s hid %p link not ready\n" , |
428 | __func__, hid); |
429 | return; |
430 | } |
431 | |
432 | msg.hdr.command = (report_type == HID_FEATURE_REPORT) ? |
433 | HOSTIF_GET_FEATURE_REPORT : HOSTIF_GET_INPUT_REPORT; |
434 | for (i = 0; i < client_data->num_hid_devices; ++i) { |
435 | if (hid == client_data->hid_sensor_hubs[i]) { |
436 | msg.hdr.device_id = |
437 | client_data->hid_devices[i].dev_id; |
438 | break; |
439 | } |
440 | } |
441 | |
442 | if (i == client_data->num_hid_devices) |
443 | return; |
444 | |
445 | msg.report_id = report_id; |
446 | rv = ishtp_cl_send(cl: client_data->hid_ishtp_cl, buf: (uint8_t *)&msg, |
447 | length: sizeof(msg)); |
448 | if (rv) |
449 | hid_ishtp_trace(client_data, "%s hid %p send failed\n" , |
450 | __func__, hid); |
451 | } |
452 | |
453 | /** |
454 | * ishtp_hid_link_ready_wait() - Wait for link ready |
455 | * @client_data: client data instance |
456 | * |
457 | * If the transport link started suspend process, then wait, till either |
458 | * resumed or timeout |
459 | * |
460 | * Return: 0 on success, non zero on error |
461 | */ |
462 | int ishtp_hid_link_ready_wait(struct ishtp_cl_data *client_data) |
463 | { |
464 | int rc; |
465 | |
466 | if (client_data->suspended) { |
467 | hid_ishtp_trace(client_data, "wait for link ready\n" ); |
468 | rc = wait_event_interruptible_timeout( |
469 | client_data->ishtp_resume_wait, |
470 | !client_data->suspended, |
471 | 5 * HZ); |
472 | |
473 | if (rc == 0) { |
474 | hid_ishtp_trace(client_data, "link not ready\n" ); |
475 | return -EIO; |
476 | } |
477 | hid_ishtp_trace(client_data, "link ready\n" ); |
478 | } |
479 | |
480 | return 0; |
481 | } |
482 | |
483 | /** |
484 | * ishtp_enum_enum_devices() - Enumerate hid devices |
485 | * @hid_ishtp_cl: client instance |
486 | * |
487 | * Helper function to send request to firmware to enumerate HID devices |
488 | * |
489 | * Return: 0 on success, non zero on error |
490 | */ |
491 | static int ishtp_enum_enum_devices(struct ishtp_cl *hid_ishtp_cl) |
492 | { |
493 | struct hostif_msg msg; |
494 | struct ishtp_cl_data *client_data = ishtp_get_client_data(cl: hid_ishtp_cl); |
495 | int retry_count; |
496 | int rv; |
497 | |
498 | /* Send HOSTIF_DM_ENUM_DEVICES */ |
499 | memset(&msg, 0, sizeof(struct hostif_msg)); |
500 | msg.hdr.command = HOSTIF_DM_ENUM_DEVICES; |
501 | rv = ishtp_cl_send(cl: hid_ishtp_cl, buf: (unsigned char *)&msg, |
502 | length: sizeof(struct hostif_msg)); |
503 | if (rv) |
504 | return rv; |
505 | |
506 | retry_count = 0; |
507 | while (!client_data->enum_devices_done && |
508 | retry_count < 10) { |
509 | wait_event_interruptible_timeout(client_data->init_wait, |
510 | client_data->enum_devices_done, |
511 | 3 * HZ); |
512 | ++retry_count; |
513 | if (!client_data->enum_devices_done) |
514 | /* Send HOSTIF_DM_ENUM_DEVICES */ |
515 | rv = ishtp_cl_send(cl: hid_ishtp_cl, |
516 | buf: (unsigned char *) &msg, |
517 | length: sizeof(struct hostif_msg)); |
518 | } |
519 | if (!client_data->enum_devices_done) { |
520 | dev_err(cl_data_to_dev(client_data), |
521 | "[hid-ish]: timed out waiting for enum_devices\n" ); |
522 | return -ETIMEDOUT; |
523 | } |
524 | if (!client_data->hid_devices) { |
525 | dev_err(cl_data_to_dev(client_data), |
526 | "[hid-ish]: failed to allocate HID dev structures\n" ); |
527 | return -ENOMEM; |
528 | } |
529 | |
530 | client_data->num_hid_devices = client_data->hid_dev_count; |
531 | dev_info(ishtp_device(client_data->cl_device), |
532 | "[hid-ish]: enum_devices_done OK, num_hid_devices=%d\n" , |
533 | client_data->num_hid_devices); |
534 | |
535 | return 0; |
536 | } |
537 | |
538 | /** |
539 | * ishtp_get_hid_descriptor() - Get hid descriptor |
540 | * @hid_ishtp_cl: client instance |
541 | * @index: Index into the hid_descr array |
542 | * |
543 | * Helper function to send request to firmware get HID descriptor of a device |
544 | * |
545 | * Return: 0 on success, non zero on error |
546 | */ |
547 | static int ishtp_get_hid_descriptor(struct ishtp_cl *hid_ishtp_cl, int index) |
548 | { |
549 | struct hostif_msg msg; |
550 | struct ishtp_cl_data *client_data = ishtp_get_client_data(cl: hid_ishtp_cl); |
551 | int rv; |
552 | |
553 | /* Get HID descriptor */ |
554 | client_data->hid_descr_done = false; |
555 | memset(&msg, 0, sizeof(struct hostif_msg)); |
556 | msg.hdr.command = HOSTIF_GET_HID_DESCRIPTOR; |
557 | msg.hdr.device_id = client_data->hid_devices[index].dev_id; |
558 | rv = ishtp_cl_send(cl: hid_ishtp_cl, buf: (unsigned char *) &msg, |
559 | length: sizeof(struct hostif_msg)); |
560 | if (rv) |
561 | return rv; |
562 | |
563 | if (!client_data->hid_descr_done) { |
564 | wait_event_interruptible_timeout(client_data->init_wait, |
565 | client_data->hid_descr_done, |
566 | 3 * HZ); |
567 | if (!client_data->hid_descr_done) { |
568 | dev_err(cl_data_to_dev(client_data), |
569 | "[hid-ish]: timed out for hid_descr_done\n" ); |
570 | return -EIO; |
571 | } |
572 | |
573 | if (!client_data->hid_descr[index]) { |
574 | dev_err(cl_data_to_dev(client_data), |
575 | "[hid-ish]: allocation HID desc fail\n" ); |
576 | return -ENOMEM; |
577 | } |
578 | } |
579 | |
580 | return 0; |
581 | } |
582 | |
583 | /** |
584 | * ishtp_get_report_descriptor() - Get report descriptor |
585 | * @hid_ishtp_cl: client instance |
586 | * @index: Index into the hid_descr array |
587 | * |
588 | * Helper function to send request to firmware get HID report descriptor of |
589 | * a device |
590 | * |
591 | * Return: 0 on success, non zero on error |
592 | */ |
593 | static int ishtp_get_report_descriptor(struct ishtp_cl *hid_ishtp_cl, |
594 | int index) |
595 | { |
596 | struct hostif_msg msg; |
597 | struct ishtp_cl_data *client_data = ishtp_get_client_data(cl: hid_ishtp_cl); |
598 | int rv; |
599 | |
600 | /* Get report descriptor */ |
601 | client_data->report_descr_done = false; |
602 | memset(&msg, 0, sizeof(struct hostif_msg)); |
603 | msg.hdr.command = HOSTIF_GET_REPORT_DESCRIPTOR; |
604 | msg.hdr.device_id = client_data->hid_devices[index].dev_id; |
605 | rv = ishtp_cl_send(cl: hid_ishtp_cl, buf: (unsigned char *) &msg, |
606 | length: sizeof(struct hostif_msg)); |
607 | if (rv) |
608 | return rv; |
609 | |
610 | if (!client_data->report_descr_done) |
611 | wait_event_interruptible_timeout(client_data->init_wait, |
612 | client_data->report_descr_done, |
613 | 3 * HZ); |
614 | if (!client_data->report_descr_done) { |
615 | dev_err(cl_data_to_dev(client_data), |
616 | "[hid-ish]: timed out for report descr\n" ); |
617 | return -EIO; |
618 | } |
619 | if (!client_data->report_descr[index]) { |
620 | dev_err(cl_data_to_dev(client_data), |
621 | "[hid-ish]: failed to alloc report descr\n" ); |
622 | return -ENOMEM; |
623 | } |
624 | |
625 | return 0; |
626 | } |
627 | |
628 | /** |
629 | * hid_ishtp_cl_init() - Init function for ISHTP client |
630 | * @hid_ishtp_cl: ISHTP client instance |
631 | * @reset: true if called for init after reset |
632 | * |
633 | * This function complete the initializtion of the client. The summary of |
634 | * processing: |
635 | * - Send request to enumerate the hid clients |
636 | * Get the HID descriptor for each enumearated device |
637 | * Get report description of each device |
638 | * Register each device wik hid core by calling ishtp_hid_probe |
639 | * |
640 | * Return: 0 on success, non zero on error |
641 | */ |
642 | static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset) |
643 | { |
644 | struct ishtp_device *dev; |
645 | struct ishtp_cl_data *client_data = ishtp_get_client_data(cl: hid_ishtp_cl); |
646 | struct ishtp_fw_client *fw_client; |
647 | int i; |
648 | int rv; |
649 | |
650 | dev_dbg(cl_data_to_dev(client_data), "%s\n" , __func__); |
651 | hid_ishtp_trace(client_data, "%s reset flag: %d\n" , __func__, reset); |
652 | |
653 | rv = ishtp_cl_link(cl: hid_ishtp_cl); |
654 | if (rv) { |
655 | dev_err(cl_data_to_dev(client_data), |
656 | "ishtp_cl_link failed\n" ); |
657 | return -ENOMEM; |
658 | } |
659 | |
660 | client_data->init_done = 0; |
661 | |
662 | dev = ishtp_get_ishtp_device(cl: hid_ishtp_cl); |
663 | |
664 | /* Connect to FW client */ |
665 | ishtp_set_tx_ring_size(cl: hid_ishtp_cl, HID_CL_TX_RING_SIZE); |
666 | ishtp_set_rx_ring_size(cl: hid_ishtp_cl, HID_CL_RX_RING_SIZE); |
667 | |
668 | fw_client = ishtp_fw_cl_get_client(dev, uuid: &hid_ishtp_id_table[0].guid); |
669 | if (!fw_client) { |
670 | dev_err(cl_data_to_dev(client_data), |
671 | "ish client uuid not found\n" ); |
672 | return -ENOENT; |
673 | } |
674 | ishtp_cl_set_fw_client_id(cl: hid_ishtp_cl, |
675 | fw_client_id: ishtp_get_fw_client_id(fw_client)); |
676 | ishtp_set_connection_state(cl: hid_ishtp_cl, state: ISHTP_CL_CONNECTING); |
677 | |
678 | rv = ishtp_cl_connect(cl: hid_ishtp_cl); |
679 | if (rv) { |
680 | dev_err(cl_data_to_dev(client_data), |
681 | "client connect fail\n" ); |
682 | goto err_cl_unlink; |
683 | } |
684 | |
685 | hid_ishtp_trace(client_data, "%s client connected\n" , __func__); |
686 | |
687 | /* Register read callback */ |
688 | ishtp_register_event_cb(device: client_data->cl_device, read_cb: ish_cl_event_cb); |
689 | |
690 | rv = ishtp_enum_enum_devices(hid_ishtp_cl); |
691 | if (rv) |
692 | goto err_cl_disconnect; |
693 | |
694 | hid_ishtp_trace(client_data, "%s enumerated device count %d\n" , |
695 | __func__, client_data->num_hid_devices); |
696 | |
697 | for (i = 0; i < client_data->num_hid_devices; ++i) { |
698 | client_data->cur_hid_dev = i; |
699 | |
700 | rv = ishtp_get_hid_descriptor(hid_ishtp_cl, index: i); |
701 | if (rv) |
702 | goto err_cl_disconnect; |
703 | |
704 | rv = ishtp_get_report_descriptor(hid_ishtp_cl, index: i); |
705 | if (rv) |
706 | goto err_cl_disconnect; |
707 | |
708 | if (!reset) { |
709 | rv = ishtp_hid_probe(cur_hid_dev: i, client_data); |
710 | if (rv) { |
711 | dev_err(cl_data_to_dev(client_data), |
712 | "[hid-ish]: HID probe for #%u failed: %d\n" , |
713 | i, rv); |
714 | goto err_cl_disconnect; |
715 | } |
716 | } |
717 | } /* for() on all hid devices */ |
718 | |
719 | client_data->init_done = 1; |
720 | client_data->suspended = false; |
721 | wake_up_interruptible(&client_data->ishtp_resume_wait); |
722 | hid_ishtp_trace(client_data, "%s successful init\n" , __func__); |
723 | return 0; |
724 | |
725 | err_cl_disconnect: |
726 | ishtp_set_connection_state(cl: hid_ishtp_cl, state: ISHTP_CL_DISCONNECTING); |
727 | ishtp_cl_disconnect(cl: hid_ishtp_cl); |
728 | err_cl_unlink: |
729 | ishtp_cl_unlink(cl: hid_ishtp_cl); |
730 | return rv; |
731 | } |
732 | |
733 | /** |
734 | * hid_ishtp_cl_deinit() - Deinit function for ISHTP client |
735 | * @hid_ishtp_cl: ISHTP client instance |
736 | * |
737 | * Unlink and free hid client |
738 | */ |
739 | static void hid_ishtp_cl_deinit(struct ishtp_cl *hid_ishtp_cl) |
740 | { |
741 | ishtp_cl_unlink(cl: hid_ishtp_cl); |
742 | ishtp_cl_flush_queues(cl: hid_ishtp_cl); |
743 | |
744 | /* disband and free all Tx and Rx client-level rings */ |
745 | ishtp_cl_free(cl: hid_ishtp_cl); |
746 | } |
747 | |
748 | static void hid_ishtp_cl_reset_handler(struct work_struct *work) |
749 | { |
750 | struct ishtp_cl_data *client_data; |
751 | struct ishtp_cl *hid_ishtp_cl; |
752 | struct ishtp_cl_device *cl_device; |
753 | int retry; |
754 | int rv; |
755 | |
756 | client_data = container_of(work, struct ishtp_cl_data, work); |
757 | |
758 | hid_ishtp_cl = client_data->hid_ishtp_cl; |
759 | cl_device = client_data->cl_device; |
760 | |
761 | hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n" , __func__, |
762 | hid_ishtp_cl); |
763 | dev_dbg(ishtp_device(client_data->cl_device), "%s\n" , __func__); |
764 | |
765 | hid_ishtp_cl_deinit(hid_ishtp_cl); |
766 | |
767 | hid_ishtp_cl = ishtp_cl_allocate(cl_device); |
768 | if (!hid_ishtp_cl) |
769 | return; |
770 | |
771 | ishtp_set_drvdata(cl_device, data: hid_ishtp_cl); |
772 | ishtp_set_client_data(cl: hid_ishtp_cl, data: client_data); |
773 | client_data->hid_ishtp_cl = hid_ishtp_cl; |
774 | |
775 | client_data->num_hid_devices = 0; |
776 | |
777 | for (retry = 0; retry < 3; ++retry) { |
778 | rv = hid_ishtp_cl_init(hid_ishtp_cl, reset: 1); |
779 | if (!rv) |
780 | break; |
781 | dev_err(cl_data_to_dev(client_data), "Retry reset init\n" ); |
782 | } |
783 | if (rv) { |
784 | dev_err(cl_data_to_dev(client_data), "Reset Failed\n" ); |
785 | hid_ishtp_trace(client_data, "%s Failed hid_ishtp_cl %p\n" , |
786 | __func__, hid_ishtp_cl); |
787 | } |
788 | } |
789 | |
790 | static void hid_ishtp_cl_resume_handler(struct work_struct *work) |
791 | { |
792 | struct ishtp_cl_data *client_data = container_of(work, struct ishtp_cl_data, resume_work); |
793 | struct ishtp_cl *hid_ishtp_cl = client_data->hid_ishtp_cl; |
794 | |
795 | if (ishtp_wait_resume(dev: ishtp_get_ishtp_device(cl: hid_ishtp_cl))) { |
796 | client_data->suspended = false; |
797 | wake_up_interruptible(&client_data->ishtp_resume_wait); |
798 | } |
799 | } |
800 | |
801 | ishtp_print_log ishtp_hid_print_trace; |
802 | |
803 | /** |
804 | * hid_ishtp_cl_probe() - ISHTP client driver probe |
805 | * @cl_device: ISHTP client device instance |
806 | * |
807 | * This function gets called on device create on ISHTP bus |
808 | * |
809 | * Return: 0 on success, non zero on error |
810 | */ |
811 | static int hid_ishtp_cl_probe(struct ishtp_cl_device *cl_device) |
812 | { |
813 | struct ishtp_cl *hid_ishtp_cl; |
814 | struct ishtp_cl_data *client_data; |
815 | int rv; |
816 | |
817 | if (!cl_device) |
818 | return -ENODEV; |
819 | |
820 | client_data = devm_kzalloc(dev: ishtp_device(cl_device), |
821 | size: sizeof(*client_data), |
822 | GFP_KERNEL); |
823 | if (!client_data) |
824 | return -ENOMEM; |
825 | |
826 | hid_ishtp_cl = ishtp_cl_allocate(cl_device); |
827 | if (!hid_ishtp_cl) |
828 | return -ENOMEM; |
829 | |
830 | ishtp_set_drvdata(cl_device, data: hid_ishtp_cl); |
831 | ishtp_set_client_data(cl: hid_ishtp_cl, data: client_data); |
832 | client_data->hid_ishtp_cl = hid_ishtp_cl; |
833 | client_data->cl_device = cl_device; |
834 | |
835 | init_waitqueue_head(&client_data->init_wait); |
836 | init_waitqueue_head(&client_data->ishtp_resume_wait); |
837 | |
838 | INIT_WORK(&client_data->work, hid_ishtp_cl_reset_handler); |
839 | INIT_WORK(&client_data->resume_work, hid_ishtp_cl_resume_handler); |
840 | |
841 | |
842 | ishtp_hid_print_trace = ishtp_trace_callback(cl_device); |
843 | |
844 | rv = hid_ishtp_cl_init(hid_ishtp_cl, reset: 0); |
845 | if (rv) { |
846 | ishtp_cl_free(cl: hid_ishtp_cl); |
847 | return rv; |
848 | } |
849 | ishtp_get_device(cl_dev: cl_device); |
850 | |
851 | return 0; |
852 | } |
853 | |
854 | /** |
855 | * hid_ishtp_cl_remove() - ISHTP client driver remove |
856 | * @cl_device: ISHTP client device instance |
857 | * |
858 | * This function gets called on device remove on ISHTP bus |
859 | * |
860 | * Return: 0 |
861 | */ |
862 | static void hid_ishtp_cl_remove(struct ishtp_cl_device *cl_device) |
863 | { |
864 | struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device); |
865 | struct ishtp_cl_data *client_data = ishtp_get_client_data(cl: hid_ishtp_cl); |
866 | |
867 | hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n" , __func__, |
868 | hid_ishtp_cl); |
869 | |
870 | dev_dbg(ishtp_device(cl_device), "%s\n" , __func__); |
871 | ishtp_set_connection_state(cl: hid_ishtp_cl, state: ISHTP_CL_DISCONNECTING); |
872 | ishtp_cl_disconnect(cl: hid_ishtp_cl); |
873 | ishtp_put_device(cl_dev: cl_device); |
874 | ishtp_hid_remove(client_data); |
875 | hid_ishtp_cl_deinit(hid_ishtp_cl); |
876 | |
877 | hid_ishtp_cl = NULL; |
878 | |
879 | client_data->num_hid_devices = 0; |
880 | } |
881 | |
882 | /** |
883 | * hid_ishtp_cl_reset() - ISHTP client driver reset |
884 | * @cl_device: ISHTP client device instance |
885 | * |
886 | * This function gets called on device reset on ISHTP bus |
887 | * |
888 | * Return: 0 |
889 | */ |
890 | static int hid_ishtp_cl_reset(struct ishtp_cl_device *cl_device) |
891 | { |
892 | struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device); |
893 | struct ishtp_cl_data *client_data = ishtp_get_client_data(cl: hid_ishtp_cl); |
894 | |
895 | hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n" , __func__, |
896 | hid_ishtp_cl); |
897 | |
898 | schedule_work(work: &client_data->work); |
899 | |
900 | return 0; |
901 | } |
902 | |
903 | /** |
904 | * hid_ishtp_cl_suspend() - ISHTP client driver suspend |
905 | * @device: device instance |
906 | * |
907 | * This function gets called on system suspend |
908 | * |
909 | * Return: 0 |
910 | */ |
911 | static int hid_ishtp_cl_suspend(struct device *device) |
912 | { |
913 | struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(dev: device); |
914 | struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device); |
915 | struct ishtp_cl_data *client_data = ishtp_get_client_data(cl: hid_ishtp_cl); |
916 | |
917 | hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n" , __func__, |
918 | hid_ishtp_cl); |
919 | client_data->suspended = true; |
920 | |
921 | return 0; |
922 | } |
923 | |
924 | /** |
925 | * hid_ishtp_cl_resume() - ISHTP client driver resume |
926 | * @device: device instance |
927 | * |
928 | * This function gets called on system resume |
929 | * |
930 | * Return: 0 |
931 | */ |
932 | static int hid_ishtp_cl_resume(struct device *device) |
933 | { |
934 | struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(dev: device); |
935 | struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device); |
936 | struct ishtp_cl_data *client_data = ishtp_get_client_data(cl: hid_ishtp_cl); |
937 | |
938 | hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n" , __func__, |
939 | hid_ishtp_cl); |
940 | schedule_work(work: &client_data->resume_work); |
941 | return 0; |
942 | } |
943 | |
944 | static const struct dev_pm_ops hid_ishtp_pm_ops = { |
945 | .suspend = hid_ishtp_cl_suspend, |
946 | .resume = hid_ishtp_cl_resume, |
947 | }; |
948 | |
949 | static struct ishtp_cl_driver hid_ishtp_cl_driver = { |
950 | .name = "ish-hid" , |
951 | .id = hid_ishtp_id_table, |
952 | .probe = hid_ishtp_cl_probe, |
953 | .remove = hid_ishtp_cl_remove, |
954 | .reset = hid_ishtp_cl_reset, |
955 | .driver.pm = &hid_ishtp_pm_ops, |
956 | }; |
957 | |
958 | static int __init ish_hid_init(void) |
959 | { |
960 | int rv; |
961 | |
962 | /* Register ISHTP client device driver with ISHTP Bus */ |
963 | rv = ishtp_cl_driver_register(driver: &hid_ishtp_cl_driver, THIS_MODULE); |
964 | |
965 | return rv; |
966 | |
967 | } |
968 | |
969 | static void __exit ish_hid_exit(void) |
970 | { |
971 | ishtp_cl_driver_unregister(driver: &hid_ishtp_cl_driver); |
972 | } |
973 | |
974 | late_initcall(ish_hid_init); |
975 | module_exit(ish_hid_exit); |
976 | |
977 | MODULE_DESCRIPTION("ISH ISHTP HID client driver" ); |
978 | /* Primary author */ |
979 | MODULE_AUTHOR("Daniel Drubin <daniel.drubin@intel.com>" ); |
980 | /* |
981 | * Several modification for multi instance support |
982 | * suspend/resume and clean up |
983 | */ |
984 | MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>" ); |
985 | |
986 | MODULE_LICENSE("GPL" ); |
987 | |