1 // SPDX-License-Identifier: GPL-2.0
2 // ISHTP interface for ChromeOS Embedded Controller
3 //
4 // Copyright (c) 2019, Intel Corporation.
5 //
6 // ISHTP client driver for talking to the Chrome OS EC firmware running
7 // on Intel Integrated Sensor Hub (ISH) using the ISH Transport protocol
8 // (ISH-TP).
9 
10 #include <linux/delay.h>
11 #include <linux/module.h>
12 #include <linux/pci.h>
13 #include <linux/platform_data/cros_ec_commands.h>
14 #include <linux/platform_data/cros_ec_proto.h>
15 #include <linux/intel-ish-client-if.h>
16 
17 #include "cros_ec.h"
18 
19 /*
20  * ISH TX/RX ring buffer pool size
21  *
22  * The AP->ISH messages and corresponding ISH->AP responses are
23  * serialized. We need 1 TX and 1 RX buffer for these.
24  *
25  * The MKBP ISH->AP events are serialized. We need one additional RX
26  * buffer for them.
27  */
28 #define CROS_ISH_CL_TX_RING_SIZE		8
29 #define CROS_ISH_CL_RX_RING_SIZE		8
30 
31 /* ISH CrOS EC Host Commands */
32 enum cros_ec_ish_channel {
33 	CROS_EC_COMMAND = 1,			/* AP->ISH message */
34 	CROS_MKBP_EVENT = 2,			/* ISH->AP events */
35 };
36 
37 /*
38  * ISH firmware timeout for 1 message send failure is 1Hz, and the
39  * firmware will retry 2 times, so 3Hz is used for timeout.
40  */
41 #define ISHTP_SEND_TIMEOUT			(3 * HZ)
42 
43 /* ISH Transport CrOS EC ISH client unique GUID */
44 static const struct ishtp_device_id cros_ec_ishtp_id_table[] = {
45 	{ .guid = GUID_INIT(0x7b7154d0, 0x56f4, 0x4bdc,
46 		  0xb0, 0xd8, 0x9e, 0x7c, 0xda,	0xe0, 0xd6, 0xa0), },
47 	{ }
48 };
49 MODULE_DEVICE_TABLE(ishtp, cros_ec_ishtp_id_table);
50 
51 struct header {
52 	u8 channel;
53 	u8 status;
54 	u8 token;
55 	u8 reserved;
56 } __packed;
57 
58 struct cros_ish_out_msg {
59 	struct header hdr;
60 	struct ec_host_request ec_request;
61 } __packed;
62 
63 struct cros_ish_in_msg {
64 	struct header hdr;
65 	struct ec_host_response ec_response;
66 } __packed;
67 
68 #define IN_MSG_EC_RESPONSE_PREAMBLE					\
69 	offsetof(struct cros_ish_in_msg, ec_response)
70 
71 #define OUT_MSG_EC_REQUEST_PREAMBLE					\
72 	offsetof(struct cros_ish_out_msg, ec_request)
73 
74 #define cl_data_to_dev(client_data) ishtp_device((client_data)->cl_device)
75 
76 /*
77  * The Read-Write Semaphore is used to prevent message TX or RX while
78  * the ishtp client is being initialized or undergoing reset.
79  *
80  * The readers are the kernel function calls responsible for IA->ISH
81  * and ISH->AP messaging.
82  *
83  * The writers are .reset() and .probe() function.
84  */
85 static DECLARE_RWSEM(init_lock);
86 
87 /**
88  * struct response_info - Encapsulate firmware response related
89  * information for passing between function ish_send() and
90  * process_recv() callback.
91  *
92  * @data: Copy the data received from firmware here.
93  * @max_size: Max size allocated for the @data buffer. If the received
94  * data exceeds this value, we log an error.
95  * @size: Actual size of data received from firmware.
96  * @error: 0 for success, negative error code for a failure in process_recv().
97  * @token: Expected token for response that we are waiting on.
98  * @received: Set to true on receiving a valid firmware	response to host command
99  * @wait_queue: Wait queue for host to wait for firmware response.
100  */
101 struct response_info {
102 	void *data;
103 	size_t max_size;
104 	size_t size;
105 	int error;
106 	u8 token;
107 	bool received;
108 	wait_queue_head_t wait_queue;
109 };
110 
111 /**
112  * struct ishtp_cl_data - Encapsulate per ISH TP Client.
113  *
114  * @cros_ish_cl: ISHTP firmware client instance.
115  * @cl_device: ISHTP client device instance.
116  * @response: Response info passing between ish_send() and process_recv().
117  * @work_ishtp_reset: Work queue reset handling.
118  * @work_ec_evt: Work queue for EC events.
119  * @ec_dev: CrOS EC MFD device.
120  *
121  * This structure is used to store per client data.
122  */
123 struct ishtp_cl_data {
124 	struct ishtp_cl *cros_ish_cl;
125 	struct ishtp_cl_device *cl_device;
126 
127 	/*
128 	 * Used for passing firmware response information between
129 	 * ish_send() and process_recv() callback.
130 	 */
131 	struct response_info response;
132 
133 	struct work_struct work_ishtp_reset;
134 	struct work_struct work_ec_evt;
135 	struct cros_ec_device *ec_dev;
136 };
137 
138 /**
139  * ish_evt_handler - ISH to AP event handler
140  * @work: Work struct
141  */
142 static void ish_evt_handler(struct work_struct *work)
143 {
144 	struct ishtp_cl_data *client_data =
145 		container_of(work, struct ishtp_cl_data, work_ec_evt);
146 
147 	cros_ec_irq_thread(0, client_data->ec_dev);
148 }
149 
150 /**
151  * ish_send() - Send message from host to firmware
152  *
153  * @client_data: Client data instance
154  * @out_msg: Message buffer to be sent to firmware
155  * @out_size: Size of out going message
156  * @in_msg: Message buffer where the incoming data is copied. This buffer
157  * is allocated by calling
158  * @in_size: Max size of incoming message
159  *
160  * Return: Number of bytes copied in the in_msg on success, negative
161  * error code on failure.
162  */
163 static int ish_send(struct ishtp_cl_data *client_data,
164 		    u8 *out_msg, size_t out_size,
165 		    u8 *in_msg, size_t in_size)
166 {
167 	static u8 next_token;
168 	int rv;
169 	struct header *out_hdr = (struct header *)out_msg;
170 	struct ishtp_cl *cros_ish_cl = client_data->cros_ish_cl;
171 
172 	dev_dbg(cl_data_to_dev(client_data),
173 		"%s: channel=%02u status=%02u\n",
174 		__func__, out_hdr->channel, out_hdr->status);
175 
176 	/* Setup for incoming response */
177 	client_data->response.data = in_msg;
178 	client_data->response.max_size = in_size;
179 	client_data->response.error = 0;
180 	client_data->response.token = next_token++;
181 	client_data->response.received = false;
182 
183 	out_hdr->token = client_data->response.token;
184 
185 	rv = ishtp_cl_send(cros_ish_cl, out_msg, out_size);
186 	if (rv) {
187 		dev_err(cl_data_to_dev(client_data),
188 			"ishtp_cl_send error %d\n", rv);
189 		return rv;
190 	}
191 
192 	wait_event_interruptible_timeout(client_data->response.wait_queue,
193 					 client_data->response.received,
194 					 ISHTP_SEND_TIMEOUT);
195 	if (!client_data->response.received) {
196 		dev_err(cl_data_to_dev(client_data),
197 			"Timed out for response to host message\n");
198 		return -ETIMEDOUT;
199 	}
200 
201 	if (client_data->response.error < 0)
202 		return client_data->response.error;
203 
204 	return client_data->response.size;
205 }
206 
207 /**
208  * process_recv() - Received and parse incoming packet
209  * @cros_ish_cl: Client instance to get stats
210  * @rb_in_proc: Host interface message buffer
211  * @timestamp: Timestamp of when parent callback started
212  *
213  * Parse the incoming packet. If it is a response packet then it will
214  * update per instance flags and wake up the caller waiting to for the
215  * response. If it is an event packet then it will schedule event work.
216  */
217 static void process_recv(struct ishtp_cl *cros_ish_cl,
218 			 struct ishtp_cl_rb *rb_in_proc, ktime_t timestamp)
219 {
220 	size_t data_len = rb_in_proc->buf_idx;
221 	struct ishtp_cl_data *client_data =
222 		ishtp_get_client_data(cros_ish_cl);
223 	struct device *dev = cl_data_to_dev(client_data);
224 	struct cros_ish_in_msg *in_msg =
225 		(struct cros_ish_in_msg *)rb_in_proc->buffer.data;
226 
227 	/* Proceed only if reset or init is not in progress */
228 	if (!down_read_trylock(&init_lock)) {
229 		/* Free the buffer */
230 		ishtp_cl_io_rb_recycle(rb_in_proc);
231 		dev_warn(dev,
232 			 "Host is not ready to receive incoming messages\n");
233 		return;
234 	}
235 
236 	/*
237 	 * All firmware messages contain a header. Check the buffer size
238 	 * before accessing elements inside.
239 	 */
240 	if (!rb_in_proc->buffer.data) {
241 		dev_warn(dev, "rb_in_proc->buffer.data returned null");
242 		client_data->response.error = -EBADMSG;
243 		goto end_error;
244 	}
245 
246 	if (data_len < sizeof(struct header)) {
247 		dev_err(dev, "data size %zu is less than header %zu\n",
248 			data_len, sizeof(struct header));
249 		client_data->response.error = -EMSGSIZE;
250 		goto end_error;
251 	}
252 
253 	dev_dbg(dev, "channel=%02u status=%02u\n",
254 		in_msg->hdr.channel, in_msg->hdr.status);
255 
256 	switch (in_msg->hdr.channel) {
257 	case CROS_EC_COMMAND:
258 		if (client_data->response.received) {
259 			dev_err(dev,
260 				"Previous firmware message not yet processed\n");
261 			goto end_error;
262 		}
263 
264 		if (client_data->response.token != in_msg->hdr.token) {
265 			dev_err_ratelimited(dev,
266 					    "Dropping old response token %d\n",
267 					    in_msg->hdr.token);
268 			goto end_error;
269 		}
270 
271 		/* Sanity check */
272 		if (!client_data->response.data) {
273 			dev_err(dev,
274 				"Receiving buffer is null. Should be allocated by calling function\n");
275 			client_data->response.error = -EINVAL;
276 			goto error_wake_up;
277 		}
278 
279 		if (data_len > client_data->response.max_size) {
280 			dev_err(dev,
281 				"Received buffer size %zu is larger than allocated buffer %zu\n",
282 				data_len, client_data->response.max_size);
283 			client_data->response.error = -EMSGSIZE;
284 			goto error_wake_up;
285 		}
286 
287 		if (in_msg->hdr.status) {
288 			dev_err(dev, "firmware returned status %d\n",
289 				in_msg->hdr.status);
290 			client_data->response.error = -EIO;
291 			goto error_wake_up;
292 		}
293 
294 		/* Update the actual received buffer size */
295 		client_data->response.size = data_len;
296 
297 		/*
298 		 * Copy the buffer received in firmware response for the
299 		 * calling thread.
300 		 */
301 		memcpy(client_data->response.data,
302 		       rb_in_proc->buffer.data, data_len);
303 
304 error_wake_up:
305 		/* Free the buffer since we copied data or didn't need it */
306 		ishtp_cl_io_rb_recycle(rb_in_proc);
307 		rb_in_proc = NULL;
308 
309 		/* Set flag before waking up the caller */
310 		client_data->response.received = true;
311 
312 		/* Wake the calling thread */
313 		wake_up_interruptible(&client_data->response.wait_queue);
314 
315 		break;
316 
317 	case CROS_MKBP_EVENT:
318 		/* Free the buffer. This is just an event without data */
319 		ishtp_cl_io_rb_recycle(rb_in_proc);
320 		rb_in_proc = NULL;
321 		/*
322 		 * Set timestamp from beginning of function since we actually
323 		 * got an incoming MKBP event
324 		 */
325 		client_data->ec_dev->last_event_time = timestamp;
326 		schedule_work(&client_data->work_ec_evt);
327 
328 		break;
329 
330 	default:
331 		dev_err(dev, "Invalid channel=%02d\n", in_msg->hdr.channel);
332 	}
333 
334 end_error:
335 	/* Free the buffer if we already haven't */
336 	if (rb_in_proc)
337 		ishtp_cl_io_rb_recycle(rb_in_proc);
338 
339 	up_read(&init_lock);
340 }
341 
342 /**
343  * ish_event_cb() - bus driver callback for incoming message
344  * @cl_device: ISHTP client device for which this message is targeted.
345  *
346  * Remove the packet from the list and process the message by calling
347  * process_recv.
348  */
349 static void ish_event_cb(struct ishtp_cl_device *cl_device)
350 {
351 	struct ishtp_cl_rb *rb_in_proc;
352 	struct ishtp_cl	*cros_ish_cl = ishtp_get_drvdata(cl_device);
353 	ktime_t timestamp;
354 
355 	/*
356 	 * Take timestamp as close to hardware interrupt as possible for sensor
357 	 * timestamps.
358 	 */
359 	timestamp = cros_ec_get_time_ns();
360 
361 	while ((rb_in_proc = ishtp_cl_rx_get_rb(cros_ish_cl)) != NULL) {
362 		/* Decide what to do with received data */
363 		process_recv(cros_ish_cl, rb_in_proc, timestamp);
364 	}
365 }
366 
367 /**
368  * cros_ish_init() - Init function for ISHTP client
369  * @cros_ish_cl: ISHTP client instance
370  *
371  * This function complete the initializtion of the client.
372  *
373  * Return: 0 for success, negative error code for failure.
374  */
375 static int cros_ish_init(struct ishtp_cl *cros_ish_cl)
376 {
377 	int rv;
378 	struct ishtp_device *dev;
379 	struct ishtp_fw_client *fw_client;
380 	struct ishtp_cl_data *client_data = ishtp_get_client_data(cros_ish_cl);
381 
382 	rv = ishtp_cl_link(cros_ish_cl);
383 	if (rv) {
384 		dev_err(cl_data_to_dev(client_data),
385 			"ishtp_cl_link failed\n");
386 		return rv;
387 	}
388 
389 	dev = ishtp_get_ishtp_device(cros_ish_cl);
390 
391 	/* Connect to firmware client */
392 	ishtp_set_tx_ring_size(cros_ish_cl, CROS_ISH_CL_TX_RING_SIZE);
393 	ishtp_set_rx_ring_size(cros_ish_cl, CROS_ISH_CL_RX_RING_SIZE);
394 
395 	fw_client = ishtp_fw_cl_get_client(dev, &cros_ec_ishtp_id_table[0].guid);
396 	if (!fw_client) {
397 		dev_err(cl_data_to_dev(client_data),
398 			"ish client uuid not found\n");
399 		rv = -ENOENT;
400 		goto err_cl_unlink;
401 	}
402 
403 	ishtp_cl_set_fw_client_id(cros_ish_cl,
404 				  ishtp_get_fw_client_id(fw_client));
405 	ishtp_set_connection_state(cros_ish_cl, ISHTP_CL_CONNECTING);
406 
407 	rv = ishtp_cl_connect(cros_ish_cl);
408 	if (rv) {
409 		dev_err(cl_data_to_dev(client_data),
410 			"client connect fail\n");
411 		goto err_cl_unlink;
412 	}
413 
414 	ishtp_register_event_cb(client_data->cl_device, ish_event_cb);
415 	return 0;
416 
417 err_cl_unlink:
418 	ishtp_cl_unlink(cros_ish_cl);
419 	return rv;
420 }
421 
422 /**
423  * cros_ish_deinit() - Deinit function for ISHTP client
424  * @cros_ish_cl: ISHTP client instance
425  *
426  * Unlink and free cros_ec client
427  */
428 static void cros_ish_deinit(struct ishtp_cl *cros_ish_cl)
429 {
430 	ishtp_set_connection_state(cros_ish_cl, ISHTP_CL_DISCONNECTING);
431 	ishtp_cl_disconnect(cros_ish_cl);
432 	ishtp_cl_unlink(cros_ish_cl);
433 	ishtp_cl_flush_queues(cros_ish_cl);
434 
435 	/* Disband and free all Tx and Rx client-level rings */
436 	ishtp_cl_free(cros_ish_cl);
437 }
438 
439 /**
440  * prepare_cros_ec_rx() - Check & prepare receive buffer
441  * @ec_dev: CrOS EC MFD device.
442  * @in_msg: Incoming message buffer
443  * @msg: cros_ec command used to send & receive data
444  *
445  * Return: 0 for success, negative error code for failure.
446  *
447  * Check the received buffer. Convert to cros_ec_command format.
448  */
449 static int prepare_cros_ec_rx(struct cros_ec_device *ec_dev,
450 			      const struct cros_ish_in_msg *in_msg,
451 			      struct cros_ec_command *msg)
452 {
453 	u8 sum = 0;
454 	int i, rv, offset;
455 
456 	/* Check response error code */
457 	msg->result = in_msg->ec_response.result;
458 	rv = cros_ec_check_result(ec_dev, msg);
459 	if (rv < 0)
460 		return rv;
461 
462 	if (in_msg->ec_response.data_len > msg->insize) {
463 		dev_err(ec_dev->dev, "Packet too long (%d bytes, expected %d)",
464 			in_msg->ec_response.data_len, msg->insize);
465 		return -ENOSPC;
466 	}
467 
468 	/* Copy response packet payload and compute checksum */
469 	for (i = 0; i < sizeof(struct ec_host_response); i++)
470 		sum += ((u8 *)in_msg)[IN_MSG_EC_RESPONSE_PREAMBLE + i];
471 
472 	offset = sizeof(struct cros_ish_in_msg);
473 	for (i = 0; i < in_msg->ec_response.data_len; i++)
474 		sum += msg->data[i] = ((u8 *)in_msg)[offset + i];
475 
476 	if (sum) {
477 		dev_dbg(ec_dev->dev, "Bad received packet checksum %d\n", sum);
478 		return -EBADMSG;
479 	}
480 
481 	return 0;
482 }
483 
484 static int cros_ec_pkt_xfer_ish(struct cros_ec_device *ec_dev,
485 				struct cros_ec_command *msg)
486 {
487 	int rv;
488 	struct ishtp_cl *cros_ish_cl = ec_dev->priv;
489 	struct ishtp_cl_data *client_data = ishtp_get_client_data(cros_ish_cl);
490 	struct device *dev = cl_data_to_dev(client_data);
491 	struct cros_ish_in_msg *in_msg = (struct cros_ish_in_msg *)ec_dev->din;
492 	struct cros_ish_out_msg *out_msg =
493 		(struct cros_ish_out_msg *)ec_dev->dout;
494 	size_t in_size = sizeof(struct cros_ish_in_msg) + msg->insize;
495 	size_t out_size = sizeof(struct cros_ish_out_msg) + msg->outsize;
496 
497 	/* Sanity checks */
498 	if (in_size > ec_dev->din_size) {
499 		dev_err(dev,
500 			"Incoming payload size %zu is too large for ec_dev->din_size %d\n",
501 			in_size, ec_dev->din_size);
502 		return -EMSGSIZE;
503 	}
504 
505 	if (out_size > ec_dev->dout_size) {
506 		dev_err(dev,
507 			"Outgoing payload size %zu is too large for ec_dev->dout_size %d\n",
508 			out_size, ec_dev->dout_size);
509 		return -EMSGSIZE;
510 	}
511 
512 	/* Proceed only if reset-init is not in progress */
513 	if (!down_read_trylock(&init_lock)) {
514 		dev_warn(dev,
515 			 "Host is not ready to send messages to ISH. Try again\n");
516 		return -EAGAIN;
517 	}
518 
519 	/* Prepare the package to be sent over ISH TP */
520 	out_msg->hdr.channel = CROS_EC_COMMAND;
521 	out_msg->hdr.status = 0;
522 
523 	ec_dev->dout += OUT_MSG_EC_REQUEST_PREAMBLE;
524 	cros_ec_prepare_tx(ec_dev, msg);
525 	ec_dev->dout -= OUT_MSG_EC_REQUEST_PREAMBLE;
526 
527 	dev_dbg(dev,
528 		"out_msg: struct_ver=0x%x checksum=0x%x command=0x%x command_ver=0x%x data_len=0x%x\n",
529 		out_msg->ec_request.struct_version,
530 		out_msg->ec_request.checksum,
531 		out_msg->ec_request.command,
532 		out_msg->ec_request.command_version,
533 		out_msg->ec_request.data_len);
534 
535 	/* Send command to ISH EC firmware and read response */
536 	rv = ish_send(client_data,
537 		      (u8 *)out_msg, out_size,
538 		      (u8 *)in_msg, in_size);
539 	if (rv < 0)
540 		goto end_error;
541 
542 	rv = prepare_cros_ec_rx(ec_dev, in_msg, msg);
543 	if (rv)
544 		goto end_error;
545 
546 	rv = in_msg->ec_response.data_len;
547 
548 	dev_dbg(dev,
549 		"in_msg: struct_ver=0x%x checksum=0x%x result=0x%x data_len=0x%x\n",
550 		in_msg->ec_response.struct_version,
551 		in_msg->ec_response.checksum,
552 		in_msg->ec_response.result,
553 		in_msg->ec_response.data_len);
554 
555 end_error:
556 	if (msg->command == EC_CMD_REBOOT_EC)
557 		msleep(EC_REBOOT_DELAY_MS);
558 
559 	up_read(&init_lock);
560 
561 	return rv;
562 }
563 
564 static int cros_ec_dev_init(struct ishtp_cl_data *client_data)
565 {
566 	struct cros_ec_device *ec_dev;
567 	struct device *dev = cl_data_to_dev(client_data);
568 
569 	ec_dev = devm_kzalloc(dev, sizeof(*ec_dev), GFP_KERNEL);
570 	if (!ec_dev)
571 		return -ENOMEM;
572 
573 	client_data->ec_dev = ec_dev;
574 	dev->driver_data = ec_dev;
575 
576 	ec_dev->dev = dev;
577 	ec_dev->priv = client_data->cros_ish_cl;
578 	ec_dev->cmd_xfer = NULL;
579 	ec_dev->pkt_xfer = cros_ec_pkt_xfer_ish;
580 	ec_dev->phys_name = dev_name(dev);
581 	ec_dev->din_size = sizeof(struct cros_ish_in_msg) +
582 			   sizeof(struct ec_response_get_protocol_info);
583 	ec_dev->dout_size = sizeof(struct cros_ish_out_msg);
584 
585 	return cros_ec_register(ec_dev);
586 }
587 
588 static void reset_handler(struct work_struct *work)
589 {
590 	int rv;
591 	struct device *dev;
592 	struct ishtp_cl *cros_ish_cl;
593 	struct ishtp_cl_device *cl_device;
594 	struct ishtp_cl_data *client_data =
595 		container_of(work, struct ishtp_cl_data, work_ishtp_reset);
596 
597 	/* Lock for reset to complete */
598 	down_write(&init_lock);
599 
600 	cros_ish_cl = client_data->cros_ish_cl;
601 	cl_device = client_data->cl_device;
602 
603 	/* Unlink, flush queues & start again */
604 	ishtp_cl_unlink(cros_ish_cl);
605 	ishtp_cl_flush_queues(cros_ish_cl);
606 	ishtp_cl_free(cros_ish_cl);
607 
608 	cros_ish_cl = ishtp_cl_allocate(cl_device);
609 	if (!cros_ish_cl) {
610 		up_write(&init_lock);
611 		return;
612 	}
613 
614 	ishtp_set_drvdata(cl_device, cros_ish_cl);
615 	ishtp_set_client_data(cros_ish_cl, client_data);
616 	client_data->cros_ish_cl = cros_ish_cl;
617 
618 	rv = cros_ish_init(cros_ish_cl);
619 	if (rv) {
620 		ishtp_cl_free(cros_ish_cl);
621 		dev_err(cl_data_to_dev(client_data), "Reset Failed\n");
622 		up_write(&init_lock);
623 		return;
624 	}
625 
626 	/* Refresh ec_dev device pointers */
627 	client_data->ec_dev->priv = client_data->cros_ish_cl;
628 	dev = cl_data_to_dev(client_data);
629 	dev->driver_data = client_data->ec_dev;
630 
631 	dev_info(cl_data_to_dev(client_data), "Chrome EC ISH reset done\n");
632 
633 	up_write(&init_lock);
634 }
635 
636 /**
637  * cros_ec_ishtp_probe() - ISHTP client driver probe callback
638  * @cl_device: ISHTP client device instance
639  *
640  * Return: 0 for success, negative error code for failure.
641  */
642 static int cros_ec_ishtp_probe(struct ishtp_cl_device *cl_device)
643 {
644 	int rv;
645 	struct ishtp_cl *cros_ish_cl;
646 	struct ishtp_cl_data *client_data =
647 		devm_kzalloc(ishtp_device(cl_device),
648 			     sizeof(*client_data), GFP_KERNEL);
649 	if (!client_data)
650 		return -ENOMEM;
651 
652 	/* Lock for initialization to complete */
653 	down_write(&init_lock);
654 
655 	cros_ish_cl = ishtp_cl_allocate(cl_device);
656 	if (!cros_ish_cl) {
657 		rv = -ENOMEM;
658 		goto end_ishtp_cl_alloc_error;
659 	}
660 
661 	ishtp_set_drvdata(cl_device, cros_ish_cl);
662 	ishtp_set_client_data(cros_ish_cl, client_data);
663 	client_data->cros_ish_cl = cros_ish_cl;
664 	client_data->cl_device = cl_device;
665 
666 	init_waitqueue_head(&client_data->response.wait_queue);
667 
668 	INIT_WORK(&client_data->work_ishtp_reset,
669 		  reset_handler);
670 	INIT_WORK(&client_data->work_ec_evt,
671 		  ish_evt_handler);
672 
673 	rv = cros_ish_init(cros_ish_cl);
674 	if (rv)
675 		goto end_ishtp_cl_init_error;
676 
677 	ishtp_get_device(cl_device);
678 
679 	up_write(&init_lock);
680 
681 	/* Register croc_ec_dev mfd */
682 	rv = cros_ec_dev_init(client_data);
683 	if (rv) {
684 		down_write(&init_lock);
685 		goto end_cros_ec_dev_init_error;
686 	}
687 
688 	return 0;
689 
690 end_cros_ec_dev_init_error:
691 	ishtp_set_connection_state(cros_ish_cl, ISHTP_CL_DISCONNECTING);
692 	ishtp_cl_disconnect(cros_ish_cl);
693 	ishtp_cl_unlink(cros_ish_cl);
694 	ishtp_cl_flush_queues(cros_ish_cl);
695 	ishtp_put_device(cl_device);
696 end_ishtp_cl_init_error:
697 	ishtp_cl_free(cros_ish_cl);
698 end_ishtp_cl_alloc_error:
699 	up_write(&init_lock);
700 	return rv;
701 }
702 
703 /**
704  * cros_ec_ishtp_remove() - ISHTP client driver remove callback
705  * @cl_device: ISHTP client device instance
706  *
707  * Return: 0
708  */
709 static void cros_ec_ishtp_remove(struct ishtp_cl_device *cl_device)
710 {
711 	struct ishtp_cl	*cros_ish_cl = ishtp_get_drvdata(cl_device);
712 	struct ishtp_cl_data *client_data = ishtp_get_client_data(cros_ish_cl);
713 
714 	cancel_work_sync(&client_data->work_ishtp_reset);
715 	cancel_work_sync(&client_data->work_ec_evt);
716 	cros_ish_deinit(cros_ish_cl);
717 	ishtp_put_device(cl_device);
718 }
719 
720 /**
721  * cros_ec_ishtp_reset() - ISHTP client driver reset callback
722  * @cl_device: ISHTP client device instance
723  *
724  * Return: 0
725  */
726 static int cros_ec_ishtp_reset(struct ishtp_cl_device *cl_device)
727 {
728 	struct ishtp_cl	*cros_ish_cl = ishtp_get_drvdata(cl_device);
729 	struct ishtp_cl_data *client_data = ishtp_get_client_data(cros_ish_cl);
730 
731 	schedule_work(&client_data->work_ishtp_reset);
732 
733 	return 0;
734 }
735 
736 /**
737  * cros_ec_ishtp_suspend() - ISHTP client driver suspend callback
738  * @device: device instance
739  *
740  * Return: 0 for success, negative error code for failure.
741  */
742 static int __maybe_unused cros_ec_ishtp_suspend(struct device *device)
743 {
744 	struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(device);
745 	struct ishtp_cl	*cros_ish_cl = ishtp_get_drvdata(cl_device);
746 	struct ishtp_cl_data *client_data = ishtp_get_client_data(cros_ish_cl);
747 
748 	return cros_ec_suspend(client_data->ec_dev);
749 }
750 
751 /**
752  * cros_ec_ishtp_resume() - ISHTP client driver resume callback
753  * @device: device instance
754  *
755  * Return: 0 for success, negative error code for failure.
756  */
757 static int __maybe_unused cros_ec_ishtp_resume(struct device *device)
758 {
759 	struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(device);
760 	struct ishtp_cl	*cros_ish_cl = ishtp_get_drvdata(cl_device);
761 	struct ishtp_cl_data *client_data = ishtp_get_client_data(cros_ish_cl);
762 
763 	return cros_ec_resume(client_data->ec_dev);
764 }
765 
766 static SIMPLE_DEV_PM_OPS(cros_ec_ishtp_pm_ops, cros_ec_ishtp_suspend,
767 			 cros_ec_ishtp_resume);
768 
769 static struct ishtp_cl_driver	cros_ec_ishtp_driver = {
770 	.name = "cros_ec_ishtp",
771 	.id = cros_ec_ishtp_id_table,
772 	.probe = cros_ec_ishtp_probe,
773 	.remove = cros_ec_ishtp_remove,
774 	.reset = cros_ec_ishtp_reset,
775 	.driver = {
776 		.pm = &cros_ec_ishtp_pm_ops,
777 	},
778 };
779 
780 static int __init cros_ec_ishtp_mod_init(void)
781 {
782 	return ishtp_cl_driver_register(&cros_ec_ishtp_driver, THIS_MODULE);
783 }
784 
785 static void __exit cros_ec_ishtp_mod_exit(void)
786 {
787 	ishtp_cl_driver_unregister(&cros_ec_ishtp_driver);
788 }
789 
790 module_init(cros_ec_ishtp_mod_init);
791 module_exit(cros_ec_ishtp_mod_exit);
792 
793 MODULE_DESCRIPTION("ChromeOS EC ISHTP Client Driver");
794 MODULE_AUTHOR("Rushikesh S Kadam <rushikesh.s.kadam@intel.com>");
795 
796 MODULE_LICENSE("GPL v2");
797