?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/unwinder: Handle stack overflows more gracefully
[linux/fpc-iii.git] / drivers / hid / intel-ish-hid / ishtp-hid-client.c
blob157b44aacdffb60203cb154680f9d02a94115fdc
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 if (data_len < sizeof(struct hostif_msg_hdr)) {
81 dev_err(&client_data->cl_device->dev,
82 "[hid-ish]: error, received %u which is less than data header %u\n",
83 (unsigned int)data_len,
84 (unsigned int)sizeof(struct hostif_msg_hdr));
85 ++client_data->bad_recv_cnt;
86 ish_hw_reset(hid_ishtp_cl->dev);
87 return;
88 }
89
90 payload = recv_buf + sizeof(struct hostif_msg_hdr);
91 total_len = data_len;
92 cur_pos = 0;
93
94 do {
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 static unsigned char buf[10];
416 unsigned int len;
417 struct hostif_msg_to_sensor *msg = (struct hostif_msg_to_sensor *)buf;
418 int rv;
419 int i;
420
421 hid_ishtp_trace(client_data, "%s hid %p\n", __func__, hid);
422 rv = ishtp_hid_link_ready_wait(client_data);
423 if (rv) {
424 hid_ishtp_trace(client_data, "%s hid %p link not ready\n",
425 __func__, hid);
426 return;
427 }
428
429 len = sizeof(struct hostif_msg_to_sensor);
430
431 memset(msg, 0, sizeof(struct hostif_msg_to_sensor));
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(client_data->hid_ishtp_cl, buf, len);
447 if (rv)
448 hid_ishtp_trace(client_data, "%s hid %p send failed\n",
449 __func__, hid);
450 }
451
452 /**
453 * ishtp_hid_link_ready_wait() - Wait for link ready
454 * @client_data: client data instance
455 *
456 * If the transport link started suspend process, then wait, till either
457 * resumed or timeout
458 *
459 * Return: 0 on success, non zero on error
460 */
461 int ishtp_hid_link_ready_wait(struct ishtp_cl_data *client_data)
462 {
463 int rc;
464
465 if (client_data->suspended) {
466 hid_ishtp_trace(client_data, "wait for link ready\n");
467 rc = wait_event_interruptible_timeout(
468 client_data->ishtp_resume_wait,
469 !client_data->suspended,
470 5 * HZ);
471
472 if (rc == 0) {
473 hid_ishtp_trace(client_data, "link not ready\n");
474 return -EIO;
475 }
476 hid_ishtp_trace(client_data, "link ready\n");
477 }
478
479 return 0;
480 }
481
482 /**
483 * ishtp_enum_enum_devices() - Enumerate hid devices
484 * @hid_ishtp_cl: client instance
485 *
486 * Helper function to send request to firmware to enumerate HID devices
487 *
488 * Return: 0 on success, non zero on error
489 */
490 static int ishtp_enum_enum_devices(struct ishtp_cl *hid_ishtp_cl)
491 {
492 struct hostif_msg msg;
493 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
494 int retry_count;
495 int rv;
496
497 /* Send HOSTIF_DM_ENUM_DEVICES */
498 memset(&msg, 0, sizeof(struct hostif_msg));
499 msg.hdr.command = HOSTIF_DM_ENUM_DEVICES;
500 rv = ishtp_cl_send(hid_ishtp_cl, (unsigned char *)&msg,
501 sizeof(struct hostif_msg));
502 if (rv)
503 return rv;
504
505 retry_count = 0;
506 while (!client_data->enum_devices_done &&
507 retry_count < 10) {
508 wait_event_interruptible_timeout(client_data->init_wait,
509 client_data->enum_devices_done,
510 3 * HZ);
511 ++retry_count;
512 if (!client_data->enum_devices_done)
513 /* Send HOSTIF_DM_ENUM_DEVICES */
514 rv = ishtp_cl_send(hid_ishtp_cl,
515 (unsigned char *) &msg,
516 sizeof(struct hostif_msg));
517 }
518 if (!client_data->enum_devices_done) {
519 dev_err(&client_data->cl_device->dev,
520 "[hid-ish]: timed out waiting for enum_devices\n");
521 return -ETIMEDOUT;
522 }
523 if (!client_data->hid_devices) {
524 dev_err(&client_data->cl_device->dev,
525 "[hid-ish]: failed to allocate HID dev structures\n");
526 return -ENOMEM;
527 }
528
529 client_data->num_hid_devices = client_data->hid_dev_count;
530 dev_info(&hid_ishtp_cl->device->dev,
531 "[hid-ish]: enum_devices_done OK, num_hid_devices=%d\n",
532 client_data->num_hid_devices);
533
534 return 0;
535 }
536
537 /**
538 * ishtp_get_hid_descriptor() - Get hid descriptor
539 * @hid_ishtp_cl: client instance
540 * @index: Index into the hid_descr array
541 *
542 * Helper function to send request to firmware get HID descriptor of a device
543 *
544 * Return: 0 on success, non zero on error
545 */
546 static int ishtp_get_hid_descriptor(struct ishtp_cl *hid_ishtp_cl, int index)
547 {
548 struct hostif_msg msg;
549 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
550 int rv;
551
552 /* Get HID descriptor */
553 client_data->hid_descr_done = false;
554 memset(&msg, 0, sizeof(struct hostif_msg));
555 msg.hdr.command = HOSTIF_GET_HID_DESCRIPTOR;
556 msg.hdr.device_id = client_data->hid_devices[index].dev_id;
557 rv = ishtp_cl_send(hid_ishtp_cl, (unsigned char *) &msg,
558 sizeof(struct hostif_msg));
559 if (rv)
560 return rv;
561
562 if (!client_data->hid_descr_done) {
563 wait_event_interruptible_timeout(client_data->init_wait,
564 client_data->hid_descr_done,
565 3 * HZ);
566 if (!client_data->hid_descr_done) {
567 dev_err(&client_data->cl_device->dev,
568 "[hid-ish]: timed out for hid_descr_done\n");
569 return -EIO;
570 }
571
572 if (!client_data->hid_descr[index]) {
573 dev_err(&client_data->cl_device->dev,
574 "[hid-ish]: allocation HID desc fail\n");
575 return -ENOMEM;
576 }
577 }
578
579 return 0;
580 }
581
582 /**
583 * ishtp_get_report_descriptor() - Get report descriptor
584 * @hid_ishtp_cl: client instance
585 * @index: Index into the hid_descr array
586 *
587 * Helper function to send request to firmware get HID report descriptor of
588 * a device
589 *
590 * Return: 0 on success, non zero on error
591 */
592 static int ishtp_get_report_descriptor(struct ishtp_cl *hid_ishtp_cl,
593 int index)
594 {
595 struct hostif_msg msg;
596 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
597 int rv;
598
599 /* Get report descriptor */
600 client_data->report_descr_done = false;
601 memset(&msg, 0, sizeof(struct hostif_msg));
602 msg.hdr.command = HOSTIF_GET_REPORT_DESCRIPTOR;
603 msg.hdr.device_id = client_data->hid_devices[index].dev_id;
604 rv = ishtp_cl_send(hid_ishtp_cl, (unsigned char *) &msg,
605 sizeof(struct hostif_msg));
606 if (rv)
607 return rv;
608
609 if (!client_data->report_descr_done)
610 wait_event_interruptible_timeout(client_data->init_wait,
611 client_data->report_descr_done,
612 3 * HZ);
613 if (!client_data->report_descr_done) {
614 dev_err(&client_data->cl_device->dev,
615 "[hid-ish]: timed out for report descr\n");
616 return -EIO;
617 }
618 if (!client_data->report_descr[index]) {
619 dev_err(&client_data->cl_device->dev,
620 "[hid-ish]: failed to alloc report descr\n");
621 return -ENOMEM;
622 }
623
624 return 0;
625 }
626
627 /**
628 * hid_ishtp_cl_init() - Init function for ISHTP client
629 * @hid_ishtp_cl: ISHTP client instance
630 * @reset: true if called for init after reset
631 *
632 * This function complete the initializtion of the client. The summary of
633 * processing:
634 * - Send request to enumerate the hid clients
635 * Get the HID descriptor for each enumearated device
636 * Get report description of each device
637 * Register each device wik hid core by calling ishtp_hid_probe
638 *
639 * Return: 0 on success, non zero on error
640 */
641 static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
642 {
643 struct ishtp_device *dev;
644 unsigned long flags;
645 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
646 int i;
647 int rv;
648
649 dev_dbg(&client_data->cl_device->dev, "%s\n", __func__);
650 hid_ishtp_trace(client_data, "%s reset flag: %d\n", __func__, reset);
651
652 rv = ishtp_cl_link(hid_ishtp_cl, ISHTP_HOST_CLIENT_ID_ANY);
653 if (rv) {
654 dev_err(&client_data->cl_device->dev,
655 "ishtp_cl_link failed\n");
656 return -ENOMEM;
657 }
658
659 client_data->init_done = 0;
660
661 dev = hid_ishtp_cl->dev;
662
663 /* Connect to FW client */
664 hid_ishtp_cl->rx_ring_size = HID_CL_RX_RING_SIZE;
665 hid_ishtp_cl->tx_ring_size = HID_CL_TX_RING_SIZE;
666
667 spin_lock_irqsave(&dev->fw_clients_lock, flags);
668 i = ishtp_fw_cl_by_uuid(dev, &hid_ishtp_guid);
669 if (i < 0) {
670 spin_unlock_irqrestore(&dev->fw_clients_lock, flags);
671 dev_err(&client_data->cl_device->dev,
672 "ish client uuid not found\n");
673 return i;
674 }
675 hid_ishtp_cl->fw_client_id = dev->fw_clients[i].client_id;
676 spin_unlock_irqrestore(&dev->fw_clients_lock, flags);
677 hid_ishtp_cl->state = ISHTP_CL_CONNECTING;
678
679 rv = ishtp_cl_connect(hid_ishtp_cl);
680 if (rv) {
681 dev_err(&client_data->cl_device->dev,
682 "client connect fail\n");
683 goto err_cl_unlink;
684 }
685
686 hid_ishtp_trace(client_data, "%s client connected\n", __func__);
687
688 /* Register read callback */
689 ishtp_register_event_cb(hid_ishtp_cl->device, ish_cl_event_cb);
690
691 rv = ishtp_enum_enum_devices(hid_ishtp_cl);
692 if (rv)
693 goto err_cl_disconnect;
694
695 hid_ishtp_trace(client_data, "%s enumerated device count %d\n",
696 __func__, client_data->num_hid_devices);
697
698 for (i = 0; i < client_data->num_hid_devices; ++i) {
699 client_data->cur_hid_dev = i;
700
701 rv = ishtp_get_hid_descriptor(hid_ishtp_cl, i);
702 if (rv)
703 goto err_cl_disconnect;
704
705 rv = ishtp_get_report_descriptor(hid_ishtp_cl, i);
706 if (rv)
707 goto err_cl_disconnect;
708
709 if (!reset) {
710 rv = ishtp_hid_probe(i, client_data);
711 if (rv) {
712 dev_err(&client_data->cl_device->dev,
713 "[hid-ish]: HID probe for #%u failed: %d\n",
714 i, rv);
715 goto err_cl_disconnect;
716 }
717 }
718 } /* for() on all hid devices */
719
720 client_data->init_done = 1;
721 client_data->suspended = false;
722 wake_up_interruptible(&client_data->ishtp_resume_wait);
723 hid_ishtp_trace(client_data, "%s successful init\n", __func__);
724 return 0;
725
726 err_cl_disconnect:
727 hid_ishtp_cl->state = ISHTP_CL_DISCONNECTING;
728 ishtp_cl_disconnect(hid_ishtp_cl);
729 err_cl_unlink:
730 ishtp_cl_unlink(hid_ishtp_cl);
731 return rv;
732 }
733
734 /**
735 * hid_ishtp_cl_deinit() - Deinit function for ISHTP client
736 * @hid_ishtp_cl: ISHTP client instance
737 *
738 * Unlink and free hid client
739 */
740 static void hid_ishtp_cl_deinit(struct ishtp_cl *hid_ishtp_cl)
741 {
742 ishtp_cl_unlink(hid_ishtp_cl);
743 ishtp_cl_flush_queues(hid_ishtp_cl);
744
745 /* disband and free all Tx and Rx client-level rings */
746 ishtp_cl_free(hid_ishtp_cl);
747 }
748
749 static void hid_ishtp_cl_reset_handler(struct work_struct *work)
750 {
751 struct ishtp_cl_data *client_data;
752 struct ishtp_cl *hid_ishtp_cl;
753 struct ishtp_cl_device *cl_device;
754 int retry;
755 int rv;
756
757 client_data = container_of(work, struct ishtp_cl_data, work);
758
759 hid_ishtp_cl = client_data->hid_ishtp_cl;
760 cl_device = client_data->cl_device;
761
762 hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
763 hid_ishtp_cl);
764 dev_dbg(&cl_device->dev, "%s\n", __func__);
765
766 hid_ishtp_cl_deinit(hid_ishtp_cl);
767
768 hid_ishtp_cl = ishtp_cl_allocate(cl_device->ishtp_dev);
769 if (!hid_ishtp_cl)
770 return;
771
772 cl_device->driver_data = hid_ishtp_cl;
773 hid_ishtp_cl->client_data = client_data;
774 client_data->hid_ishtp_cl = hid_ishtp_cl;
775
776 client_data->num_hid_devices = 0;
777
778 for (retry = 0; retry < 3; ++retry) {
779 rv = hid_ishtp_cl_init(hid_ishtp_cl, 1);
780 if (!rv)
781 break;
782 dev_err(&client_data->cl_device->dev, "Retry reset init\n");
783 }
784 if (rv) {
785 dev_err(&client_data->cl_device->dev, "Reset Failed\n");
786 hid_ishtp_trace(client_data, "%s Failed hid_ishtp_cl %p\n",
787 __func__, hid_ishtp_cl);
788 }
789 }
790
791 /**
792 * hid_ishtp_cl_probe() - ISHTP client driver probe
793 * @cl_device: ISHTP client device instance
794 *
795 * This function gets called on device create on ISHTP bus
796 *
797 * Return: 0 on success, non zero on error
798 */
799 static int hid_ishtp_cl_probe(struct ishtp_cl_device *cl_device)
800 {
801 struct ishtp_cl *hid_ishtp_cl;
802 struct ishtp_cl_data *client_data;
803 int rv;
804
805 if (!cl_device)
806 return -ENODEV;
807
808 if (uuid_le_cmp(hid_ishtp_guid,
809 cl_device->fw_client->props.protocol_name) != 0)
810 return -ENODEV;
811
812 client_data = devm_kzalloc(&cl_device->dev, sizeof(*client_data),
813 GFP_KERNEL);
814 if (!client_data)
815 return -ENOMEM;
816
817 hid_ishtp_cl = ishtp_cl_allocate(cl_device->ishtp_dev);
818 if (!hid_ishtp_cl)
819 return -ENOMEM;
820
821 cl_device->driver_data = hid_ishtp_cl;
822 hid_ishtp_cl->client_data = client_data;
823 client_data->hid_ishtp_cl = hid_ishtp_cl;
824 client_data->cl_device = cl_device;
825
826 init_waitqueue_head(&client_data->init_wait);
827 init_waitqueue_head(&client_data->ishtp_resume_wait);
828
829 INIT_WORK(&client_data->work, hid_ishtp_cl_reset_handler);
830
831 rv = hid_ishtp_cl_init(hid_ishtp_cl, 0);
832 if (rv) {
833 ishtp_cl_free(hid_ishtp_cl);
834 return rv;
835 }
836 ishtp_get_device(cl_device);
837
838 return 0;
839 }
840
841 /**
842 * hid_ishtp_cl_remove() - ISHTP client driver remove
843 * @cl_device: ISHTP client device instance
844 *
845 * This function gets called on device remove on ISHTP bus
846 *
847 * Return: 0
848 */
849 static int hid_ishtp_cl_remove(struct ishtp_cl_device *cl_device)
850 {
851 struct ishtp_cl *hid_ishtp_cl = cl_device->driver_data;
852 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
853
854 hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
855 hid_ishtp_cl);
856
857 dev_dbg(&cl_device->dev, "%s\n", __func__);
858 hid_ishtp_cl->state = ISHTP_CL_DISCONNECTING;
859 ishtp_cl_disconnect(hid_ishtp_cl);
860 ishtp_put_device(cl_device);
861 ishtp_hid_remove(client_data);
862 hid_ishtp_cl_deinit(hid_ishtp_cl);
863
864 hid_ishtp_cl = NULL;
865
866 client_data->num_hid_devices = 0;
867
868 return 0;
869 }
870
871 /**
872 * hid_ishtp_cl_reset() - ISHTP client driver reset
873 * @cl_device: ISHTP client device instance
874 *
875 * This function gets called on device reset on ISHTP bus
876 *
877 * Return: 0
878 */
879 static int hid_ishtp_cl_reset(struct ishtp_cl_device *cl_device)
880 {
881 struct ishtp_cl *hid_ishtp_cl = cl_device->driver_data;
882 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
883
884 hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
885 hid_ishtp_cl);
886
887 schedule_work(&client_data->work);
888
889 return 0;
890 }
891
892 #define to_ishtp_cl_device(d) container_of(d, struct ishtp_cl_device, dev)
893
894 /**
895 * hid_ishtp_cl_suspend() - ISHTP client driver suspend
896 * @device: device instance
897 *
898 * This function gets called on system suspend
899 *
900 * Return: 0
901 */
902 static int hid_ishtp_cl_suspend(struct device *device)
903 {
904 struct ishtp_cl_device *cl_device = to_ishtp_cl_device(device);
905 struct ishtp_cl *hid_ishtp_cl = cl_device->driver_data;
906 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
907
908 hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
909 hid_ishtp_cl);
910 client_data->suspended = true;
911
912 return 0;
913 }
914
915 /**
916 * hid_ishtp_cl_resume() - ISHTP client driver resume
917 * @device: device instance
918 *
919 * This function gets called on system resume
920 *
921 * Return: 0
922 */
923 static int hid_ishtp_cl_resume(struct device *device)
924 {
925 struct ishtp_cl_device *cl_device = to_ishtp_cl_device(device);
926 struct ishtp_cl *hid_ishtp_cl = cl_device->driver_data;
927 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
928
929 hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
930 hid_ishtp_cl);
931 client_data->suspended = false;
932 return 0;
933 }
934
935 static const struct dev_pm_ops hid_ishtp_pm_ops = {
936 .suspend = hid_ishtp_cl_suspend,
937 .resume = hid_ishtp_cl_resume,
938 };
939
940 static struct ishtp_cl_driver hid_ishtp_cl_driver = {
941 .name = "ish-hid",
942 .probe = hid_ishtp_cl_probe,
943 .remove = hid_ishtp_cl_remove,
944 .reset = hid_ishtp_cl_reset,
945 .driver.pm = &hid_ishtp_pm_ops,
946 };
947
948 static int __init ish_hid_init(void)
949 {
950 int rv;
951
952 /* Register ISHTP client device driver with ISHTP Bus */
953 rv = ishtp_cl_driver_register(&hid_ishtp_cl_driver);
954
955 return rv;
956
957 }
958
959 static void __exit ish_hid_exit(void)
960 {
961 ishtp_cl_driver_unregister(&hid_ishtp_cl_driver);
962 }
963
964 late_initcall(ish_hid_init);
965 module_exit(ish_hid_exit);
966
967 MODULE_DESCRIPTION("ISH ISHTP HID client driver");
968 /* Primary author */
969 MODULE_AUTHOR("Daniel Drubin <daniel.drubin@intel.com>");
970 /*
971 * Several modification for multi instance support
972 * suspend/resume and clean up
973 */
974 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
975
976 MODULE_LICENSE("GPL");
977 MODULE_ALIAS("ishtp:*");
Linux with added FPC-III support