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