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