projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'mmc-uh/next'
[deliverable/linux.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 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 %lu is bigger than payload_len %u\n",
140 1 + sizeof(struct device_info)
141 * i,
142 (unsigned int)payload_len);
143 }
144
145 if (1 + sizeof(struct device_info) * i >=
146 data_len)
147 break;
148
149 dev_info = (struct device_info *)(payload + 1 +
150 sizeof(struct device_info) * i);
151 if (client_data->hid_devices)
152 memcpy(client_data->hid_devices + i,
153 dev_info,
154 sizeof(struct device_info));
155 }
156
157 client_data->enum_devices_done = true;
158 wake_up_interruptible(&client_data->init_wait);
159
160 break;
161
162 case HOSTIF_GET_HID_DESCRIPTOR:
163 if ((!(recv_msg->hdr.command & ~CMD_MASK) ||
164 client_data->init_done)) {
165 ++client_data->bad_recv_cnt;
166 report_bad_packet(hid_ishtp_cl, recv_msg,
167 cur_pos,
168 payload_len);
169 ish_hw_reset(hid_ishtp_cl->dev);
170 break;
171 }
172 if (!client_data->hid_descr[curr_hid_dev])
173 client_data->hid_descr[curr_hid_dev] =
174 devm_kmalloc(&client_data->cl_device->dev,
175 payload_len, GFP_KERNEL);
176 if (client_data->hid_descr[curr_hid_dev]) {
177 memcpy(client_data->hid_descr[curr_hid_dev],
178 payload, payload_len);
179 client_data->hid_descr_size[curr_hid_dev] =
180 payload_len;
181 client_data->hid_descr_done = true;
182 }
183 wake_up_interruptible(&client_data->init_wait);
184
185 break;
186
187 case HOSTIF_GET_REPORT_DESCRIPTOR:
188 if ((!(recv_msg->hdr.command & ~CMD_MASK) ||
189 client_data->init_done)) {
190 ++client_data->bad_recv_cnt;
191 report_bad_packet(hid_ishtp_cl, recv_msg,
192 cur_pos,
193 payload_len);
194 ish_hw_reset(hid_ishtp_cl->dev);
195 break;
196 }
197 if (!client_data->report_descr[curr_hid_dev])
198 client_data->report_descr[curr_hid_dev] =
199 devm_kmalloc(&client_data->cl_device->dev,
200 payload_len, GFP_KERNEL);
201 if (client_data->report_descr[curr_hid_dev]) {
202 memcpy(client_data->report_descr[curr_hid_dev],
203 payload,
204 payload_len);
205 client_data->report_descr_size[curr_hid_dev] =
206 payload_len;
207 client_data->report_descr_done = true;
208 }
209 wake_up_interruptible(&client_data->init_wait);
210
211 break;
212
213 case HOSTIF_GET_FEATURE_REPORT:
214 report_type = HID_FEATURE_REPORT;
215 goto do_get_report;
216
217 case HOSTIF_GET_INPUT_REPORT:
218 report_type = HID_INPUT_REPORT;
219 do_get_report:
220 /* Get index of device that matches this id */
221 for (i = 0; i < client_data->num_hid_devices; ++i) {
222 if (recv_msg->hdr.device_id ==
223 client_data->hid_devices[i].dev_id)
224 if (client_data->hid_sensor_hubs[i]) {
225 hid_input_report(
226 client_data->hid_sensor_hubs[
227 i],
228 report_type, payload,
229 payload_len, 0);
230 ishtp_hid_wakeup(
231 client_data->hid_sensor_hubs[
232 i]);
233 break;
234 }
235 }
236 break;
237
238 case HOSTIF_SET_FEATURE_REPORT:
239 /* Get index of device that matches this id */
240 for (i = 0; i < client_data->num_hid_devices; ++i) {
241 if (recv_msg->hdr.device_id ==
242 client_data->hid_devices[i].dev_id)
243 if (client_data->hid_sensor_hubs[i]) {
244 ishtp_hid_wakeup(
245 client_data->hid_sensor_hubs[
246 i]);
247 break;
248 }
249 }
250 break;
251
252 case HOSTIF_PUBLISH_INPUT_REPORT:
253 report_type = HID_INPUT_REPORT;
254 for (i = 0; i < client_data->num_hid_devices; ++i)
255 if (recv_msg->hdr.device_id ==
256 client_data->hid_devices[i].dev_id)
257 if (client_data->hid_sensor_hubs[i])
258 hid_input_report(
259 client_data->hid_sensor_hubs[
260 i],
261 report_type, payload,
262 payload_len, 0);
263 break;
264
265 case HOSTIF_PUBLISH_INPUT_REPORT_LIST:
266 report_type = HID_INPUT_REPORT;
267 reports_list = (struct report_list *)payload;
268 reports = (char *)reports_list->reports;
269
270 for (j = 0; j < reports_list->num_of_reports; j++) {
271 recv_msg = (struct hostif_msg *)(reports +
272 sizeof(uint16_t));
273 report_len = *(uint16_t *)reports;
274 payload = reports + sizeof(uint16_t) +
275 sizeof(struct hostif_msg_hdr);
276 payload_len = report_len -
277 sizeof(struct hostif_msg_hdr);
278
279 for (i = 0; i < client_data->num_hid_devices;
280 ++i)
281 if (recv_msg->hdr.device_id ==
282 client_data->hid_devices[i].dev_id &&
283 client_data->hid_sensor_hubs[i]) {
284 hid_input_report(
285 client_data->hid_sensor_hubs[
286 i],
287 report_type,
288 payload, payload_len,
289 0);
290 }
291
292 reports += sizeof(uint16_t) + report_len;
293 }
294 break;
295 default:
296 ++client_data->bad_recv_cnt;
297 report_bad_packet(hid_ishtp_cl, recv_msg, cur_pos,
298 payload_len);
299 ish_hw_reset(hid_ishtp_cl->dev);
300 break;
301
302 }
303
304 if (!cur_pos && cur_pos + payload_len +
305 sizeof(struct hostif_msg) < total_len)
306 ++client_data->multi_packet_cnt;
307
308 cur_pos += payload_len + sizeof(struct hostif_msg);
309 payload += payload_len + sizeof(struct hostif_msg);
310
311 } while (cur_pos < total_len);
312 }
313
314 /**
315 * ish_cl_event_cb() - bus driver callback for incoming message/packet
316 * @device: Pointer to the the ishtp client device for which this message
317 * is targeted
318 *
319 * Remove the packet from the list and process the message by calling
320 * process_recv
321 */
322 static void ish_cl_event_cb(struct ishtp_cl_device *device)
323 {
324 struct ishtp_cl *hid_ishtp_cl = device->driver_data;
325 struct ishtp_cl_rb *rb_in_proc;
326 size_t r_length;
327 unsigned long flags;
328
329 if (!hid_ishtp_cl)
330 return;
331
332 spin_lock_irqsave(&hid_ishtp_cl->in_process_spinlock, flags);
333 while (!list_empty(&hid_ishtp_cl->in_process_list.list)) {
334 rb_in_proc = list_entry(
335 hid_ishtp_cl->in_process_list.list.next,
336 struct ishtp_cl_rb, list);
337 list_del_init(&rb_in_proc->list);
338 spin_unlock_irqrestore(&hid_ishtp_cl->in_process_spinlock,
339 flags);
340
341 if (!rb_in_proc->buffer.data)
342 return;
343
344 r_length = rb_in_proc->buf_idx;
345
346 /* decide what to do with received data */
347 process_recv(hid_ishtp_cl, rb_in_proc->buffer.data, r_length);
348
349 ishtp_cl_io_rb_recycle(rb_in_proc);
350 spin_lock_irqsave(&hid_ishtp_cl->in_process_spinlock, flags);
351 }
352 spin_unlock_irqrestore(&hid_ishtp_cl->in_process_spinlock, flags);
353 }
354
355 /**
356 * hid_ishtp_set_feature() - send request to ISH FW to set a feature request
357 * @hid: hid device instance for this request
358 * @buf: feature buffer
359 * @len: Length of feature buffer
360 * @report_id: Report id for the feature set request
361 *
362 * This is called from hid core .request() callback. This function doesn't wait
363 * for response.
364 */
365 void hid_ishtp_set_feature(struct hid_device *hid, char *buf, unsigned int len,
366 int report_id)
367 {
368 struct ishtp_hid_data *hid_data = hid->driver_data;
369 struct ishtp_cl_data *client_data = hid_data->client_data;
370 struct hostif_msg *msg = (struct hostif_msg *)buf;
371 int rv;
372 int i;
373
374 hid_ishtp_trace(client_data, "%s hid %p\n", __func__, hid);
375
376 rv = ishtp_hid_link_ready_wait(client_data);
377 if (rv) {
378 hid_ishtp_trace(client_data, "%s hid %p link not ready\n",
379 __func__, hid);
380 return;
381 }
382
383 memset(msg, 0, sizeof(struct hostif_msg));
384 msg->hdr.command = HOSTIF_SET_FEATURE_REPORT;
385 for (i = 0; i < client_data->num_hid_devices; ++i) {
386 if (hid == client_data->hid_sensor_hubs[i]) {
387 msg->hdr.device_id =
388 client_data->hid_devices[i].dev_id;
389 break;
390 }
391 }
392
393 if (i == client_data->num_hid_devices)
394 return;
395
396 rv = ishtp_cl_send(client_data->hid_ishtp_cl, buf, len);
397 if (rv)
398 hid_ishtp_trace(client_data, "%s hid %p send failed\n",
399 __func__, hid);
400 }
401
402 /**
403 * hid_ishtp_get_report() - request to get feature/input report
404 * @hid: hid device instance for this request
405 * @report_id: Report id for the get request
406 * @report_type: Report type for the this request
407 *
408 * This is called from hid core .request() callback. This function will send
409 * request to FW and return without waiting for response.
410 */
411 void hid_ishtp_get_report(struct hid_device *hid, int report_id,
412 int report_type)
413 {
414 struct ishtp_hid_data *hid_data = hid->driver_data;
415 struct ishtp_cl_data *client_data = hid_data->client_data;
416 static unsigned char buf[10];
417 unsigned int len;
418 struct hostif_msg_to_sensor *msg = (struct hostif_msg_to_sensor *)buf;
419 int rv;
420 int i;
421
422 hid_ishtp_trace(client_data, "%s hid %p\n", __func__, hid);
423 rv = ishtp_hid_link_ready_wait(client_data);
424 if (rv) {
425 hid_ishtp_trace(client_data, "%s hid %p link not ready\n",
426 __func__, hid);
427 return;
428 }
429
430 len = sizeof(struct hostif_msg_to_sensor);
431
432 memset(msg, 0, sizeof(struct hostif_msg_to_sensor));
433 msg->hdr.command = (report_type == HID_FEATURE_REPORT) ?
434 HOSTIF_GET_FEATURE_REPORT : HOSTIF_GET_INPUT_REPORT;
435 for (i = 0; i < client_data->num_hid_devices; ++i) {
436 if (hid == client_data->hid_sensor_hubs[i]) {
437 msg->hdr.device_id =
438 client_data->hid_devices[i].dev_id;
439 break;
440 }
441 }
442
443 if (i == client_data->num_hid_devices)
444 return;
445
446 msg->report_id = report_id;
447 rv = ishtp_cl_send(client_data->hid_ishtp_cl, buf, len);
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 = hid_ishtp_cl->client_data;
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(hid_ishtp_cl, (unsigned char *)&msg,
502 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(hid_ishtp_cl,
516 (unsigned char *) &msg,
517 sizeof(struct hostif_msg));
518 }
519 if (!client_data->enum_devices_done) {
520 dev_err(&client_data->cl_device->dev,
521 "[hid-ish]: timed out waiting for enum_devices\n");
522 return -ETIMEDOUT;
523 }
524 if (!client_data->hid_devices) {
525 dev_err(&client_data->cl_device->dev,
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(&hid_ishtp_cl->device->dev,
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 = hid_ishtp_cl->client_data;
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(hid_ishtp_cl, (unsigned char *) &msg,
559 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(&client_data->cl_device->dev,
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(&client_data->cl_device->dev,
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 = hid_ishtp_cl->client_data;
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(hid_ishtp_cl, (unsigned char *) &msg,
606 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(&client_data->cl_device->dev,
616 "[hid-ish]: timed out for report descr\n");
617 return -EIO;
618 }
619 if (!client_data->report_descr[index]) {
620 dev_err(&client_data->cl_device->dev,
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 unsigned long flags;
646 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
647 int i;
648 int rv;
649
650 dev_dbg(&client_data->cl_device->dev, "%s\n", __func__);
651 hid_ishtp_trace(client_data, "%s reset flag: %d\n", __func__, reset);
652
653 rv = ishtp_cl_link(hid_ishtp_cl, ISHTP_HOST_CLIENT_ID_ANY);
654 if (rv) {
655 dev_err(&client_data->cl_device->dev,
656 "ishtp_cl_link failed\n");
657 return -ENOMEM;
658 }
659
660 client_data->init_done = 0;
661
662 dev = hid_ishtp_cl->dev;
663
664 /* Connect to FW client */
665 hid_ishtp_cl->rx_ring_size = HID_CL_RX_RING_SIZE;
666 hid_ishtp_cl->tx_ring_size = HID_CL_TX_RING_SIZE;
667
668 spin_lock_irqsave(&dev->fw_clients_lock, flags);
669 i = ishtp_fw_cl_by_uuid(dev, &hid_ishtp_guid);
670 if (i < 0) {
671 spin_unlock_irqrestore(&dev->fw_clients_lock, flags);
672 dev_err(&client_data->cl_device->dev,
673 "ish client uuid not found\n");
674 return i;
675 }
676 hid_ishtp_cl->fw_client_id = dev->fw_clients[i].client_id;
677 spin_unlock_irqrestore(&dev->fw_clients_lock, flags);
678 hid_ishtp_cl->state = ISHTP_CL_CONNECTING;
679
680 rv = ishtp_cl_connect(hid_ishtp_cl);
681 if (rv) {
682 dev_err(&client_data->cl_device->dev,
683 "client connect fail\n");
684 goto err_cl_unlink;
685 }
686
687 hid_ishtp_trace(client_data, "%s client connected\n", __func__);
688
689 /* Register read callback */
690 ishtp_register_event_cb(hid_ishtp_cl->device, ish_cl_event_cb);
691
692 rv = ishtp_enum_enum_devices(hid_ishtp_cl);
693 if (rv)
694 goto err_cl_disconnect;
695
696 hid_ishtp_trace(client_data, "%s enumerated device count %d\n",
697 __func__, client_data->num_hid_devices);
698
699 for (i = 0; i < client_data->num_hid_devices; ++i) {
700 client_data->cur_hid_dev = i;
701
702 rv = ishtp_get_hid_descriptor(hid_ishtp_cl, i);
703 if (rv)
704 goto err_cl_disconnect;
705
706 rv = ishtp_get_report_descriptor(hid_ishtp_cl, i);
707 if (rv)
708 goto err_cl_disconnect;
709
710 if (!reset) {
711 rv = ishtp_hid_probe(i, client_data);
712 if (rv) {
713 dev_err(&client_data->cl_device->dev,
714 "[hid-ish]: HID probe for #%u failed: %d\n",
715 i, rv);
716 goto err_cl_disconnect;
717 }
718 }
719 } /* for() on all hid devices */
720
721 client_data->init_done = 1;
722 client_data->suspended = false;
723 wake_up_interruptible(&client_data->ishtp_resume_wait);
724 hid_ishtp_trace(client_data, "%s successful init\n", __func__);
725 return 0;
726
727 err_cl_disconnect:
728 hid_ishtp_cl->state = ISHTP_CL_DISCONNECTING;
729 ishtp_cl_disconnect(hid_ishtp_cl);
730 err_cl_unlink:
731 ishtp_cl_unlink(hid_ishtp_cl);
732 return rv;
733 }
734
735 /**
736 * hid_ishtp_cl_deinit() - Deinit function for ISHTP client
737 * @hid_ishtp_cl: ISHTP client instance
738 *
739 * Unlink and free hid client
740 */
741 static void hid_ishtp_cl_deinit(struct ishtp_cl *hid_ishtp_cl)
742 {
743 ishtp_cl_unlink(hid_ishtp_cl);
744 ishtp_cl_flush_queues(hid_ishtp_cl);
745
746 /* disband and free all Tx and Rx client-level rings */
747 ishtp_cl_free(hid_ishtp_cl);
748 }
749
750 static void hid_ishtp_cl_reset_handler(struct work_struct *work)
751 {
752 struct ishtp_cl_data *client_data;
753 struct ishtp_cl *hid_ishtp_cl;
754 struct ishtp_cl_device *cl_device;
755 int retry;
756 int rv;
757
758 client_data = container_of(work, struct ishtp_cl_data, work);
759
760 hid_ishtp_cl = client_data->hid_ishtp_cl;
761 cl_device = client_data->cl_device;
762
763 hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
764 hid_ishtp_cl);
765 dev_dbg(&cl_device->dev, "%s\n", __func__);
766
767 hid_ishtp_cl_deinit(hid_ishtp_cl);
768
769 hid_ishtp_cl = ishtp_cl_allocate(cl_device->ishtp_dev);
770 if (!hid_ishtp_cl)
771 return;
772
773 cl_device->driver_data = hid_ishtp_cl;
774 hid_ishtp_cl->client_data = client_data;
775 client_data->hid_ishtp_cl = hid_ishtp_cl;
776
777 client_data->num_hid_devices = 0;
778
779 for (retry = 0; retry < 3; ++retry) {
780 rv = hid_ishtp_cl_init(hid_ishtp_cl, 1);
781 if (!rv)
782 break;
783 dev_err(&client_data->cl_device->dev, "Retry reset init\n");
784 }
785 if (rv) {
786 dev_err(&client_data->cl_device->dev, "Reset Failed\n");
787 hid_ishtp_trace(client_data, "%s Failed hid_ishtp_cl %p\n",
788 __func__, hid_ishtp_cl);
789 }
790 }
791
792 /**
793 * hid_ishtp_cl_probe() - ISHTP client driver probe
794 * @cl_device: ISHTP client device instance
795 *
796 * This function gets called on device create on ISHTP bus
797 *
798 * Return: 0 on success, non zero on error
799 */
800 static int hid_ishtp_cl_probe(struct ishtp_cl_device *cl_device)
801 {
802 struct ishtp_cl *hid_ishtp_cl;
803 struct ishtp_cl_data *client_data;
804 int rv;
805
806 if (!cl_device)
807 return -ENODEV;
808
809 if (uuid_le_cmp(hid_ishtp_guid,
810 cl_device->fw_client->props.protocol_name) != 0)
811 return -ENODEV;
812
813 client_data = devm_kzalloc(&cl_device->dev, sizeof(*client_data),
814 GFP_KERNEL);
815 if (!client_data)
816 return -ENOMEM;
817
818 hid_ishtp_cl = ishtp_cl_allocate(cl_device->ishtp_dev);
819 if (!hid_ishtp_cl)
820 return -ENOMEM;
821
822 cl_device->driver_data = hid_ishtp_cl;
823 hid_ishtp_cl->client_data = client_data;
824 client_data->hid_ishtp_cl = hid_ishtp_cl;
825 client_data->cl_device = cl_device;
826
827 init_waitqueue_head(&client_data->init_wait);
828 init_waitqueue_head(&client_data->ishtp_resume_wait);
829
830 INIT_WORK(&client_data->work, hid_ishtp_cl_reset_handler);
831
832 rv = hid_ishtp_cl_init(hid_ishtp_cl, 0);
833 if (rv) {
834 ishtp_cl_free(hid_ishtp_cl);
835 return rv;
836 }
837 ishtp_get_device(cl_device);
838
839 return 0;
840 }
841
842 /**
843 * hid_ishtp_cl_remove() - ISHTP client driver remove
844 * @cl_device: ISHTP client device instance
845 *
846 * This function gets called on device remove on ISHTP bus
847 *
848 * Return: 0
849 */
850 static int hid_ishtp_cl_remove(struct ishtp_cl_device *cl_device)
851 {
852 struct ishtp_cl *hid_ishtp_cl = cl_device->driver_data;
853 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
854
855 hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
856 hid_ishtp_cl);
857
858 dev_dbg(&cl_device->dev, "%s\n", __func__);
859 hid_ishtp_cl->state = ISHTP_CL_DISCONNECTING;
860 ishtp_cl_disconnect(hid_ishtp_cl);
861 ishtp_put_device(cl_device);
862 ishtp_hid_remove(client_data);
863 hid_ishtp_cl_deinit(hid_ishtp_cl);
864
865 hid_ishtp_cl = NULL;
866
867 client_data->num_hid_devices = 0;
868
869 return 0;
870 }
871
872 /**
873 * hid_ishtp_cl_reset() - ISHTP client driver reset
874 * @cl_device: ISHTP client device instance
875 *
876 * This function gets called on device reset on ISHTP bus
877 *
878 * Return: 0
879 */
880 static int hid_ishtp_cl_reset(struct ishtp_cl_device *cl_device)
881 {
882 struct ishtp_cl *hid_ishtp_cl = cl_device->driver_data;
883 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
884
885 hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
886 hid_ishtp_cl);
887
888 schedule_work(&client_data->work);
889
890 return 0;
891 }
892
893 #define to_ishtp_cl_device(d) container_of(d, struct ishtp_cl_device, dev)
894
895 /**
896 * hid_ishtp_cl_suspend() - ISHTP client driver suspend
897 * @device: device instance
898 *
899 * This function gets called on system suspend
900 *
901 * Return: 0
902 */
903 static int hid_ishtp_cl_suspend(struct device *device)
904 {
905 struct ishtp_cl_device *cl_device = to_ishtp_cl_device(device);
906 struct ishtp_cl *hid_ishtp_cl = cl_device->driver_data;
907 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
908
909 hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
910 hid_ishtp_cl);
911 client_data->suspended = true;
912
913 return 0;
914 }
915
916 /**
917 * hid_ishtp_cl_resume() - ISHTP client driver resume
918 * @device: device instance
919 *
920 * This function gets called on system resume
921 *
922 * Return: 0
923 */
924 static int hid_ishtp_cl_resume(struct device *device)
925 {
926 struct ishtp_cl_device *cl_device = to_ishtp_cl_device(device);
927 struct ishtp_cl *hid_ishtp_cl = cl_device->driver_data;
928 struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
929
930 hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
931 hid_ishtp_cl);
932 client_data->suspended = false;
933 return 0;
934 }
935
936 static const struct dev_pm_ops hid_ishtp_pm_ops = {
937 .suspend = hid_ishtp_cl_suspend,
938 .resume = hid_ishtp_cl_resume,
939 };
940
941 static struct ishtp_cl_driver hid_ishtp_cl_driver = {
942 .name = "ish-hid",
943 .probe = hid_ishtp_cl_probe,
944 .remove = hid_ishtp_cl_remove,
945 .reset = hid_ishtp_cl_reset,
946 .driver.pm = &hid_ishtp_pm_ops,
947 };
948
949 static int __init ish_hid_init(void)
950 {
951 int rv;
952
953 /* Register ISHTP client device driver with ISHTP Bus */
954 rv = ishtp_cl_driver_register(&hid_ishtp_cl_driver);
955
956 return rv;
957
958 }
959
960 static void __exit ish_hid_exit(void)
961 {
962 ishtp_cl_driver_unregister(&hid_ishtp_cl_driver);
963 }
964
965 late_initcall(ish_hid_init);
966 module_exit(ish_hid_exit);
967
968 MODULE_DESCRIPTION("ISH ISHTP HID client driver");
969 /* Primary author */
970 MODULE_AUTHOR("Daniel Drubin <daniel.drubin@intel.com>");
971 /*
972 * Several modification for multi instance support
973 * suspend/resume and clean up
974 */
975 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
976
977 MODULE_LICENSE("GPL");
978 MODULE_ALIAS("ishtp:*");
Linux kernel - Deliverables
This page took 0.081144 seconds and 5 git commands to generate.