1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * ISHTP bus layer messages handling
4  *
5  * Copyright (c) 2003-2016, Intel Corporation.
6  */
7 
8 #include <linux/export.h>
9 #include <linux/slab.h>
10 #include <linux/sched.h>
11 #include <linux/wait.h>
12 #include <linux/spinlock.h>
13 #include "ishtp-dev.h"
14 #include "hbm.h"
15 #include "client.h"
16 
17 /**
18  * ishtp_hbm_fw_cl_allocate() - Allocate FW clients
19  * @dev: ISHTP device instance
20  *
21  * Allocates storage for fw clients
22  */
23 static void ishtp_hbm_fw_cl_allocate(struct ishtp_device *dev)
24 {
25 	struct ishtp_fw_client *clients;
26 	int b;
27 
28 	/* count how many ISH clients we have */
29 	for_each_set_bit(b, dev->fw_clients_map, ISHTP_CLIENTS_MAX)
30 		dev->fw_clients_num++;
31 
32 	if (dev->fw_clients_num <= 0)
33 		return;
34 
35 	/* allocate storage for fw clients representation */
36 	clients = kcalloc(dev->fw_clients_num, sizeof(struct ishtp_fw_client),
37 			  GFP_KERNEL);
38 	if (!clients) {
39 		dev->dev_state = ISHTP_DEV_RESETTING;
40 		ish_hw_reset(dev);
41 		return;
42 	}
43 	dev->fw_clients = clients;
44 }
45 
46 /**
47  * ishtp_hbm_cl_hdr() - construct client hbm header
48  * @cl: client
49  * @hbm_cmd: host bus message command
50  * @buf: buffer for cl header
51  * @len: buffer length
52  *
53  * Initialize HBM buffer
54  */
55 static inline void ishtp_hbm_cl_hdr(struct ishtp_cl *cl, uint8_t hbm_cmd,
56 	void *buf, size_t len)
57 {
58 	struct ishtp_hbm_cl_cmd *cmd = buf;
59 
60 	memset(cmd, 0, len);
61 
62 	cmd->hbm_cmd = hbm_cmd;
63 	cmd->host_addr = cl->host_client_id;
64 	cmd->fw_addr = cl->fw_client_id;
65 }
66 
67 /**
68  * ishtp_hbm_cl_addr_equal() - Compare client address
69  * @cl: client
70  * @buf: Client command buffer
71  *
72  * Compare client address with the address in command buffer
73  *
74  * Return: True if they have the same address
75  */
76 static inline bool ishtp_hbm_cl_addr_equal(struct ishtp_cl *cl, void *buf)
77 {
78 	struct ishtp_hbm_cl_cmd *cmd = buf;
79 
80 	return cl->host_client_id == cmd->host_addr &&
81 		cl->fw_client_id == cmd->fw_addr;
82 }
83 
84 /**
85  * ishtp_hbm_start_wait() - Wait for HBM start message
86  * @dev: ISHTP device instance
87  *
88  * Wait for HBM start message from firmware
89  *
90  * Return: 0 if HBM start is/was received else timeout error
91  */
92 int ishtp_hbm_start_wait(struct ishtp_device *dev)
93 {
94 	int ret;
95 
96 	if (dev->hbm_state > ISHTP_HBM_START)
97 		return 0;
98 
99 	dev_dbg(dev->devc, "Going to wait for ishtp start. hbm_state=%08X\n",
100 		dev->hbm_state);
101 	ret = wait_event_interruptible_timeout(dev->wait_hbm_recvd_msg,
102 					dev->hbm_state >= ISHTP_HBM_STARTED,
103 					(ISHTP_INTEROP_TIMEOUT * HZ));
104 
105 	dev_dbg(dev->devc,
106 		"Woke up from waiting for ishtp start. hbm_state=%08X\n",
107 		dev->hbm_state);
108 
109 	if (ret <= 0 && (dev->hbm_state <= ISHTP_HBM_START)) {
110 		dev->hbm_state = ISHTP_HBM_IDLE;
111 		dev_err(dev->devc,
112 		"waiting for ishtp start failed. ret=%d hbm_state=%08X\n",
113 			ret, dev->hbm_state);
114 		return -ETIMEDOUT;
115 	}
116 	return 0;
117 }
118 
119 /**
120  * ishtp_hbm_start_req() - Send HBM start message
121  * @dev: ISHTP device instance
122  *
123  * Send HBM start message to firmware
124  *
125  * Return: 0 if success else error code
126  */
127 int ishtp_hbm_start_req(struct ishtp_device *dev)
128 {
129 	struct ishtp_msg_hdr hdr;
130 	struct hbm_host_version_request start_req = { 0 };
131 
132 	ishtp_hbm_hdr(&hdr, sizeof(start_req));
133 
134 	/* host start message */
135 	start_req.hbm_cmd = HOST_START_REQ_CMD;
136 	start_req.host_version.major_version = HBM_MAJOR_VERSION;
137 	start_req.host_version.minor_version = HBM_MINOR_VERSION;
138 
139 	/*
140 	 * (!) Response to HBM start may be so quick that this thread would get
141 	 * preempted BEFORE managing to set hbm_state = ISHTP_HBM_START.
142 	 * So set it at first, change back to ISHTP_HBM_IDLE upon failure
143 	 */
144 	dev->hbm_state = ISHTP_HBM_START;
145 	if (ishtp_write_message(dev, &hdr, &start_req)) {
146 		dev_err(dev->devc, "version message send failed\n");
147 		dev->dev_state = ISHTP_DEV_RESETTING;
148 		dev->hbm_state = ISHTP_HBM_IDLE;
149 		ish_hw_reset(dev);
150 		return -ENODEV;
151 	}
152 
153 	return 0;
154 }
155 
156 /**
157  * ishtp_hbm_enum_clients_req() - Send client enum req
158  * @dev: ISHTP device instance
159  *
160  * Send enumeration client request message
161  *
162  * Return: 0 if success else error code
163  */
164 void ishtp_hbm_enum_clients_req(struct ishtp_device *dev)
165 {
166 	struct ishtp_msg_hdr hdr;
167 	struct hbm_host_enum_request enum_req = { 0 };
168 
169 	/* enumerate clients */
170 	ishtp_hbm_hdr(&hdr, sizeof(enum_req));
171 	enum_req.hbm_cmd = HOST_ENUM_REQ_CMD;
172 
173 	if (ishtp_write_message(dev, &hdr, &enum_req)) {
174 		dev->dev_state = ISHTP_DEV_RESETTING;
175 		dev_err(dev->devc, "enumeration request send failed\n");
176 		ish_hw_reset(dev);
177 	}
178 	dev->hbm_state = ISHTP_HBM_ENUM_CLIENTS;
179 }
180 
181 /**
182  * ishtp_hbm_prop_req() - Request property
183  * @dev: ISHTP device instance
184  *
185  * Request property for a single client
186  *
187  * Return: 0 if success else error code
188  */
189 static int ishtp_hbm_prop_req(struct ishtp_device *dev)
190 {
191 	struct ishtp_msg_hdr hdr;
192 	struct hbm_props_request prop_req = { 0 };
193 	unsigned long next_client_index;
194 	uint8_t client_num;
195 
196 	client_num = dev->fw_client_presentation_num;
197 
198 	next_client_index = find_next_bit(dev->fw_clients_map,
199 		ISHTP_CLIENTS_MAX, dev->fw_client_index);
200 
201 	/* We got all client properties */
202 	if (next_client_index == ISHTP_CLIENTS_MAX) {
203 		dev->hbm_state = ISHTP_HBM_WORKING;
204 		dev->dev_state = ISHTP_DEV_ENABLED;
205 
206 		for (dev->fw_client_presentation_num = 1;
207 			dev->fw_client_presentation_num < client_num + 1;
208 				++dev->fw_client_presentation_num)
209 			/* Add new client device */
210 			ishtp_bus_new_client(dev);
211 		return 0;
212 	}
213 
214 	dev->fw_clients[client_num].client_id = next_client_index;
215 
216 	ishtp_hbm_hdr(&hdr, sizeof(prop_req));
217 
218 	prop_req.hbm_cmd = HOST_CLIENT_PROPERTIES_REQ_CMD;
219 	prop_req.address = next_client_index;
220 
221 	if (ishtp_write_message(dev, &hdr, &prop_req)) {
222 		dev->dev_state = ISHTP_DEV_RESETTING;
223 		dev_err(dev->devc, "properties request send failed\n");
224 		ish_hw_reset(dev);
225 		return -EIO;
226 	}
227 
228 	dev->fw_client_index = next_client_index;
229 
230 	return 0;
231 }
232 
233 /**
234  * ishtp_hbm_stop_req() - Send HBM stop
235  * @dev: ISHTP device instance
236  *
237  * Send stop request message
238  */
239 static void ishtp_hbm_stop_req(struct ishtp_device *dev)
240 {
241 	struct ishtp_msg_hdr hdr;
242 	struct hbm_host_stop_request stop_req = { 0 } ;
243 
244 	ishtp_hbm_hdr(&hdr, sizeof(stop_req));
245 
246 	stop_req.hbm_cmd = HOST_STOP_REQ_CMD;
247 	stop_req.reason = DRIVER_STOP_REQUEST;
248 
249 	ishtp_write_message(dev, &hdr, &stop_req);
250 }
251 
252 /**
253  * ishtp_hbm_cl_flow_control_req() - Send flow control request
254  * @dev: ISHTP device instance
255  * @cl: ISHTP client instance
256  *
257  * Send flow control request
258  *
259  * Return: 0 if success else error code
260  */
261 int ishtp_hbm_cl_flow_control_req(struct ishtp_device *dev,
262 				  struct ishtp_cl *cl)
263 {
264 	struct ishtp_msg_hdr hdr;
265 	struct hbm_flow_control flow_ctrl;
266 	const size_t len = sizeof(flow_ctrl);
267 	int	rv;
268 	unsigned long	flags;
269 
270 	spin_lock_irqsave(&cl->fc_spinlock, flags);
271 
272 	ishtp_hbm_hdr(&hdr, len);
273 	ishtp_hbm_cl_hdr(cl, ISHTP_FLOW_CONTROL_CMD, &flow_ctrl, len);
274 
275 	/*
276 	 * Sync possible race when RB recycle and packet receive paths
277 	 * both try to send an out FC
278 	 */
279 	if (cl->out_flow_ctrl_creds) {
280 		spin_unlock_irqrestore(&cl->fc_spinlock, flags);
281 		return	0;
282 	}
283 
284 	cl->recv_msg_num_frags = 0;
285 
286 	rv = ishtp_write_message(dev, &hdr, &flow_ctrl);
287 	if (!rv) {
288 		++cl->out_flow_ctrl_creds;
289 		++cl->out_flow_ctrl_cnt;
290 		cl->ts_out_fc = ktime_get();
291 		if (cl->ts_rx) {
292 			ktime_t ts_diff = ktime_sub(cl->ts_out_fc, cl->ts_rx);
293 			if (ktime_after(ts_diff, cl->ts_max_fc_delay))
294 				cl->ts_max_fc_delay = ts_diff;
295 		}
296 	} else {
297 		++cl->err_send_fc;
298 	}
299 
300 	spin_unlock_irqrestore(&cl->fc_spinlock, flags);
301 	return	rv;
302 }
303 
304 /**
305  * ishtp_hbm_cl_disconnect_req() - Send disconnect request
306  * @dev: ISHTP device instance
307  * @cl: ISHTP client instance
308  *
309  * Send disconnect message to fw
310  *
311  * Return: 0 if success else error code
312  */
313 int ishtp_hbm_cl_disconnect_req(struct ishtp_device *dev, struct ishtp_cl *cl)
314 {
315 	struct ishtp_msg_hdr hdr;
316 	struct hbm_client_connect_request disconn_req;
317 	const size_t len = sizeof(disconn_req);
318 
319 	ishtp_hbm_hdr(&hdr, len);
320 	ishtp_hbm_cl_hdr(cl, CLIENT_DISCONNECT_REQ_CMD, &disconn_req, len);
321 
322 	return ishtp_write_message(dev, &hdr, &disconn_req);
323 }
324 
325 /**
326  * ishtp_hbm_cl_disconnect_res() - Get disconnect response
327  * @dev: ISHTP device instance
328  * @rs: Response message
329  *
330  * Received disconnect response from fw
331  */
332 static void ishtp_hbm_cl_disconnect_res(struct ishtp_device *dev,
333 	struct hbm_client_connect_response *rs)
334 {
335 	struct ishtp_cl *cl = NULL;
336 	unsigned long	flags;
337 
338 	spin_lock_irqsave(&dev->cl_list_lock, flags);
339 	list_for_each_entry(cl, &dev->cl_list, link) {
340 		if (!rs->status && ishtp_hbm_cl_addr_equal(cl, rs)) {
341 			cl->state = ISHTP_CL_DISCONNECTED;
342 			wake_up_interruptible(&cl->wait_ctrl_res);
343 			break;
344 		}
345 	}
346 	spin_unlock_irqrestore(&dev->cl_list_lock, flags);
347 }
348 
349 /**
350  * ishtp_hbm_cl_connect_req() - Send connect request
351  * @dev: ISHTP device instance
352  * @cl: client device instance
353  *
354  * Send connection request to specific fw client
355  *
356  * Return: 0 if success else error code
357  */
358 int ishtp_hbm_cl_connect_req(struct ishtp_device *dev, struct ishtp_cl *cl)
359 {
360 	struct ishtp_msg_hdr hdr;
361 	struct hbm_client_connect_request conn_req;
362 	const size_t len = sizeof(conn_req);
363 
364 	ishtp_hbm_hdr(&hdr, len);
365 	ishtp_hbm_cl_hdr(cl, CLIENT_CONNECT_REQ_CMD, &conn_req, len);
366 
367 	return ishtp_write_message(dev, &hdr, &conn_req);
368 }
369 
370 /**
371  * ishtp_hbm_cl_connect_res() - Get connect response
372  * @dev: ISHTP device instance
373  * @rs: Response message
374  *
375  * Received connect response from fw
376  */
377 static void ishtp_hbm_cl_connect_res(struct ishtp_device *dev,
378 	struct hbm_client_connect_response *rs)
379 {
380 	struct ishtp_cl *cl = NULL;
381 	unsigned long	flags;
382 
383 	spin_lock_irqsave(&dev->cl_list_lock, flags);
384 	list_for_each_entry(cl, &dev->cl_list, link) {
385 		if (ishtp_hbm_cl_addr_equal(cl, rs)) {
386 			if (!rs->status) {
387 				cl->state = ISHTP_CL_CONNECTED;
388 				cl->status = 0;
389 			} else {
390 				cl->state = ISHTP_CL_DISCONNECTED;
391 				cl->status = -ENODEV;
392 			}
393 			wake_up_interruptible(&cl->wait_ctrl_res);
394 			break;
395 		}
396 	}
397 	spin_unlock_irqrestore(&dev->cl_list_lock, flags);
398 }
399 
400 /**
401  * ishtp_client_disconnect_request() - Receive disconnect request
402  * @dev: ISHTP device instance
403  * @disconnect_req: disconnect request structure
404  *
405  * Disconnect request bus message from the fw. Send diconnect response.
406  */
407 static void ishtp_hbm_fw_disconnect_req(struct ishtp_device *dev,
408 	struct hbm_client_connect_request *disconnect_req)
409 {
410 	struct ishtp_cl *cl;
411 	const size_t len = sizeof(struct hbm_client_connect_response);
412 	unsigned long	flags;
413 	struct ishtp_msg_hdr hdr;
414 	unsigned char data[4];	/* All HBM messages are 4 bytes */
415 
416 	spin_lock_irqsave(&dev->cl_list_lock, flags);
417 	list_for_each_entry(cl, &dev->cl_list, link) {
418 		if (ishtp_hbm_cl_addr_equal(cl, disconnect_req)) {
419 			cl->state = ISHTP_CL_DISCONNECTED;
420 
421 			/* send disconnect response */
422 			ishtp_hbm_hdr(&hdr, len);
423 			ishtp_hbm_cl_hdr(cl, CLIENT_DISCONNECT_RES_CMD, data,
424 				len);
425 			ishtp_write_message(dev, &hdr, data);
426 			break;
427 		}
428 	}
429 	spin_unlock_irqrestore(&dev->cl_list_lock, flags);
430 }
431 
432 /**
433  * ishtp_hbm_dma_xfer_ack(() - Receive transfer ACK
434  * @dev: ISHTP device instance
435  * @dma_xfer: HBM transfer message
436  *
437  * Receive ack for ISHTP-over-DMA client message
438  */
439 static void ishtp_hbm_dma_xfer_ack(struct ishtp_device *dev,
440 				   struct dma_xfer_hbm *dma_xfer)
441 {
442 	void	*msg;
443 	uint64_t	offs;
444 	struct ishtp_msg_hdr	*ishtp_hdr =
445 		(struct ishtp_msg_hdr *)&dev->ishtp_msg_hdr;
446 	unsigned int	msg_offs;
447 	struct ishtp_cl *cl;
448 
449 	for (msg_offs = 0; msg_offs < ishtp_hdr->length;
450 		msg_offs += sizeof(struct dma_xfer_hbm)) {
451 		offs = dma_xfer->msg_addr - dev->ishtp_host_dma_tx_buf_phys;
452 		if (offs > dev->ishtp_host_dma_tx_buf_size) {
453 			dev_err(dev->devc, "Bad DMA Tx ack message address\n");
454 			return;
455 		}
456 		if (dma_xfer->msg_length >
457 				dev->ishtp_host_dma_tx_buf_size - offs) {
458 			dev_err(dev->devc, "Bad DMA Tx ack message size\n");
459 			return;
460 		}
461 
462 		/* logical address of the acked mem */
463 		msg = (unsigned char *)dev->ishtp_host_dma_tx_buf + offs;
464 		ishtp_cl_release_dma_acked_mem(dev, msg, dma_xfer->msg_length);
465 
466 		list_for_each_entry(cl, &dev->cl_list, link) {
467 			if (cl->fw_client_id == dma_xfer->fw_client_id &&
468 			    cl->host_client_id == dma_xfer->host_client_id)
469 				/*
470 				 * in case that a single ack may be sent
471 				 * over several dma transfers, and the last msg
472 				 * addr was inside the acked memory, but not in
473 				 * its start
474 				 */
475 				if (cl->last_dma_addr >=
476 							(unsigned char *)msg &&
477 						cl->last_dma_addr <
478 						(unsigned char *)msg +
479 						dma_xfer->msg_length) {
480 					cl->last_dma_acked = 1;
481 
482 					if (!list_empty(&cl->tx_list.list) &&
483 						cl->ishtp_flow_ctrl_creds) {
484 						/*
485 						 * start sending the first msg
486 						 */
487 						ishtp_cl_send_msg(dev, cl);
488 					}
489 				}
490 		}
491 		++dma_xfer;
492 	}
493 }
494 
495 /**
496  * ishtp_hbm_dma_xfer() - Receive DMA transfer message
497  * @dev: ISHTP device instance
498  * @dma_xfer: HBM transfer message
499  *
500  * Receive ISHTP-over-DMA client message
501  */
502 static void ishtp_hbm_dma_xfer(struct ishtp_device *dev,
503 			       struct dma_xfer_hbm *dma_xfer)
504 {
505 	void	*msg;
506 	uint64_t	offs;
507 	struct ishtp_msg_hdr	hdr;
508 	struct ishtp_msg_hdr	*ishtp_hdr =
509 		(struct ishtp_msg_hdr *) &dev->ishtp_msg_hdr;
510 	struct dma_xfer_hbm	*prm = dma_xfer;
511 	unsigned int	msg_offs;
512 
513 	for (msg_offs = 0; msg_offs < ishtp_hdr->length;
514 		msg_offs += sizeof(struct dma_xfer_hbm)) {
515 
516 		offs = dma_xfer->msg_addr - dev->ishtp_host_dma_rx_buf_phys;
517 		if (offs > dev->ishtp_host_dma_rx_buf_size) {
518 			dev_err(dev->devc, "Bad DMA Rx message address\n");
519 			return;
520 		}
521 		if (dma_xfer->msg_length >
522 				dev->ishtp_host_dma_rx_buf_size - offs) {
523 			dev_err(dev->devc, "Bad DMA Rx message size\n");
524 			return;
525 		}
526 		msg = dev->ishtp_host_dma_rx_buf + offs;
527 		recv_ishtp_cl_msg_dma(dev, msg, dma_xfer);
528 		dma_xfer->hbm = DMA_XFER_ACK;	/* Prepare for response */
529 		++dma_xfer;
530 	}
531 
532 	/* Send DMA_XFER_ACK [...] */
533 	ishtp_hbm_hdr(&hdr, ishtp_hdr->length);
534 	ishtp_write_message(dev, &hdr, (unsigned char *)prm);
535 }
536 
537 /**
538  * ishtp_hbm_dispatch() - HBM dispatch function
539  * @dev: ISHTP device instance
540  * @hdr: bus message
541  *
542  * Bottom half read routine after ISR to handle the read bus message cmd
543  * processing
544  */
545 void ishtp_hbm_dispatch(struct ishtp_device *dev,
546 			struct ishtp_bus_message *hdr)
547 {
548 	struct ishtp_bus_message *ishtp_msg;
549 	struct ishtp_fw_client *fw_client;
550 	struct hbm_host_version_response *version_res;
551 	struct hbm_client_connect_response *connect_res;
552 	struct hbm_client_connect_response *disconnect_res;
553 	struct hbm_client_connect_request *disconnect_req;
554 	struct hbm_props_response *props_res;
555 	struct hbm_host_enum_response *enum_res;
556 	struct ishtp_msg_hdr ishtp_hdr;
557 	struct dma_alloc_notify	dma_alloc_notify;
558 	struct dma_xfer_hbm	*dma_xfer;
559 
560 	ishtp_msg = hdr;
561 
562 	switch (ishtp_msg->hbm_cmd) {
563 	case HOST_START_RES_CMD:
564 		version_res = (struct hbm_host_version_response *)ishtp_msg;
565 		if (!version_res->host_version_supported) {
566 			dev->version = version_res->fw_max_version;
567 
568 			dev->hbm_state = ISHTP_HBM_STOPPED;
569 			ishtp_hbm_stop_req(dev);
570 			return;
571 		}
572 
573 		dev->version.major_version = HBM_MAJOR_VERSION;
574 		dev->version.minor_version = HBM_MINOR_VERSION;
575 		if (dev->dev_state == ISHTP_DEV_INIT_CLIENTS &&
576 				dev->hbm_state == ISHTP_HBM_START) {
577 			dev->hbm_state = ISHTP_HBM_STARTED;
578 			ishtp_hbm_enum_clients_req(dev);
579 		} else {
580 			dev_err(dev->devc,
581 				"reset: wrong host start response\n");
582 			/* BUG: why do we arrive here? */
583 			ish_hw_reset(dev);
584 			return;
585 		}
586 
587 		wake_up_interruptible(&dev->wait_hbm_recvd_msg);
588 		break;
589 
590 	case CLIENT_CONNECT_RES_CMD:
591 		connect_res = (struct hbm_client_connect_response *)ishtp_msg;
592 		ishtp_hbm_cl_connect_res(dev, connect_res);
593 		break;
594 
595 	case CLIENT_DISCONNECT_RES_CMD:
596 		disconnect_res =
597 			(struct hbm_client_connect_response *)ishtp_msg;
598 		ishtp_hbm_cl_disconnect_res(dev, disconnect_res);
599 		break;
600 
601 	case HOST_CLIENT_PROPERTIES_RES_CMD:
602 		props_res = (struct hbm_props_response *)ishtp_msg;
603 		fw_client = &dev->fw_clients[dev->fw_client_presentation_num];
604 
605 		if (props_res->status || !dev->fw_clients) {
606 			dev_err(dev->devc,
607 			"reset: properties response hbm wrong status\n");
608 			ish_hw_reset(dev);
609 			return;
610 		}
611 
612 		if (fw_client->client_id != props_res->address) {
613 			dev_err(dev->devc,
614 				"reset: host properties response address mismatch [%02X %02X]\n",
615 				fw_client->client_id, props_res->address);
616 			ish_hw_reset(dev);
617 			return;
618 		}
619 
620 		if (dev->dev_state != ISHTP_DEV_INIT_CLIENTS ||
621 			dev->hbm_state != ISHTP_HBM_CLIENT_PROPERTIES) {
622 			dev_err(dev->devc,
623 				"reset: unexpected properties response\n");
624 			ish_hw_reset(dev);
625 			return;
626 		}
627 
628 		fw_client->props = props_res->client_properties;
629 		dev->fw_client_index++;
630 		dev->fw_client_presentation_num++;
631 
632 		/* request property for the next client */
633 		ishtp_hbm_prop_req(dev);
634 
635 		if (dev->dev_state != ISHTP_DEV_ENABLED)
636 			break;
637 
638 		if (!ishtp_use_dma_transfer())
639 			break;
640 
641 		dev_dbg(dev->devc, "Requesting to use DMA\n");
642 		ishtp_cl_alloc_dma_buf(dev);
643 		if (dev->ishtp_host_dma_rx_buf) {
644 			const size_t len = sizeof(dma_alloc_notify);
645 
646 			memset(&dma_alloc_notify, 0, sizeof(dma_alloc_notify));
647 			dma_alloc_notify.hbm = DMA_BUFFER_ALLOC_NOTIFY;
648 			dma_alloc_notify.buf_size =
649 					dev->ishtp_host_dma_rx_buf_size;
650 			dma_alloc_notify.buf_address =
651 					dev->ishtp_host_dma_rx_buf_phys;
652 			ishtp_hbm_hdr(&ishtp_hdr, len);
653 			ishtp_write_message(dev, &ishtp_hdr,
654 				(unsigned char *)&dma_alloc_notify);
655 		}
656 
657 		break;
658 
659 	case HOST_ENUM_RES_CMD:
660 		enum_res = (struct hbm_host_enum_response *) ishtp_msg;
661 		memcpy(dev->fw_clients_map, enum_res->valid_addresses, 32);
662 		if (dev->dev_state == ISHTP_DEV_INIT_CLIENTS &&
663 			dev->hbm_state == ISHTP_HBM_ENUM_CLIENTS) {
664 			dev->fw_client_presentation_num = 0;
665 			dev->fw_client_index = 0;
666 
667 			ishtp_hbm_fw_cl_allocate(dev);
668 			dev->hbm_state = ISHTP_HBM_CLIENT_PROPERTIES;
669 
670 			/* first property request */
671 			ishtp_hbm_prop_req(dev);
672 		} else {
673 			dev_err(dev->devc,
674 			      "reset: unexpected enumeration response hbm\n");
675 			ish_hw_reset(dev);
676 			return;
677 		}
678 		break;
679 
680 	case HOST_STOP_RES_CMD:
681 		if (dev->hbm_state != ISHTP_HBM_STOPPED)
682 			dev_err(dev->devc, "unexpected stop response\n");
683 
684 		dev->dev_state = ISHTP_DEV_DISABLED;
685 		dev_info(dev->devc, "reset: FW stop response\n");
686 		ish_hw_reset(dev);
687 		break;
688 
689 	case CLIENT_DISCONNECT_REQ_CMD:
690 		/* search for client */
691 		disconnect_req =
692 			(struct hbm_client_connect_request *)ishtp_msg;
693 		ishtp_hbm_fw_disconnect_req(dev, disconnect_req);
694 		break;
695 
696 	case FW_STOP_REQ_CMD:
697 		dev->hbm_state = ISHTP_HBM_STOPPED;
698 		break;
699 
700 	case DMA_BUFFER_ALLOC_RESPONSE:
701 		dev->ishtp_host_dma_enabled = 1;
702 		break;
703 
704 	case DMA_XFER:
705 		dma_xfer = (struct dma_xfer_hbm *)ishtp_msg;
706 		if (!dev->ishtp_host_dma_enabled) {
707 			dev_err(dev->devc,
708 				"DMA XFER requested but DMA is not enabled\n");
709 			break;
710 		}
711 		ishtp_hbm_dma_xfer(dev, dma_xfer);
712 		break;
713 
714 	case DMA_XFER_ACK:
715 		dma_xfer = (struct dma_xfer_hbm *)ishtp_msg;
716 		if (!dev->ishtp_host_dma_enabled ||
717 		    !dev->ishtp_host_dma_tx_buf) {
718 			dev_err(dev->devc,
719 				"DMA XFER acked but DMA Tx is not enabled\n");
720 			break;
721 		}
722 		ishtp_hbm_dma_xfer_ack(dev, dma_xfer);
723 		break;
724 
725 	default:
726 		dev_err(dev->devc, "unknown HBM: %u\n",
727 			(unsigned int)ishtp_msg->hbm_cmd);
728 
729 		break;
730 	}
731 }
732 
733 /**
734  * bh_hbm_work_fn() - HBM work function
735  * @work: work struct
736  *
737  * Bottom half processing work function (instead of thread handler)
738  * for processing hbm messages
739  */
740 void	bh_hbm_work_fn(struct work_struct *work)
741 {
742 	unsigned long	flags;
743 	struct ishtp_device	*dev;
744 	unsigned char	hbm[IPC_PAYLOAD_SIZE];
745 
746 	dev = container_of(work, struct ishtp_device, bh_hbm_work);
747 	spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
748 	if (dev->rd_msg_fifo_head != dev->rd_msg_fifo_tail) {
749 		memcpy(hbm, dev->rd_msg_fifo + dev->rd_msg_fifo_head,
750 			IPC_PAYLOAD_SIZE);
751 		dev->rd_msg_fifo_head =
752 			(dev->rd_msg_fifo_head + IPC_PAYLOAD_SIZE) %
753 			(RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE);
754 		spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
755 		ishtp_hbm_dispatch(dev, (struct ishtp_bus_message *)hbm);
756 	} else {
757 		spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
758 	}
759 }
760 
761 /**
762  * recv_hbm() - Receive HBM message
763  * @dev: ISHTP device instance
764  * @ishtp_hdr: received bus message
765  *
766  * Receive and process ISHTP bus messages in ISR context. This will schedule
767  * work function to process message
768  */
769 void	recv_hbm(struct ishtp_device *dev, struct ishtp_msg_hdr *ishtp_hdr)
770 {
771 	uint8_t	rd_msg_buf[ISHTP_RD_MSG_BUF_SIZE];
772 	struct ishtp_bus_message	*ishtp_msg =
773 		(struct ishtp_bus_message *)rd_msg_buf;
774 	unsigned long	flags;
775 
776 	dev->ops->ishtp_read(dev, rd_msg_buf, ishtp_hdr->length);
777 
778 	/* Flow control - handle in place */
779 	if (ishtp_msg->hbm_cmd == ISHTP_FLOW_CONTROL_CMD) {
780 		struct hbm_flow_control *flow_control =
781 			(struct hbm_flow_control *)ishtp_msg;
782 		struct ishtp_cl *cl = NULL;
783 		unsigned long	flags, tx_flags;
784 
785 		spin_lock_irqsave(&dev->cl_list_lock, flags);
786 		list_for_each_entry(cl, &dev->cl_list, link) {
787 			if (cl->host_client_id == flow_control->host_addr &&
788 					cl->fw_client_id ==
789 					flow_control->fw_addr) {
790 				/*
791 				 * NOTE: It's valid only for counting
792 				 * flow-control implementation to receive a
793 				 * FC in the middle of sending. Meanwhile not
794 				 * supported
795 				 */
796 				if (cl->ishtp_flow_ctrl_creds)
797 					dev_err(dev->devc,
798 					 "recv extra FC from FW client %u (host client %u) (FC count was %d)\n",
799 					 (unsigned int)cl->fw_client_id,
800 					 (unsigned int)cl->host_client_id,
801 					 cl->ishtp_flow_ctrl_creds);
802 				else {
803 					++cl->ishtp_flow_ctrl_creds;
804 					++cl->ishtp_flow_ctrl_cnt;
805 					cl->last_ipc_acked = 1;
806 					spin_lock_irqsave(
807 							&cl->tx_list_spinlock,
808 							tx_flags);
809 					if (!list_empty(&cl->tx_list.list)) {
810 						/*
811 						 * start sending the first msg
812 						 *	= the callback function
813 						 */
814 						spin_unlock_irqrestore(
815 							&cl->tx_list_spinlock,
816 							tx_flags);
817 						ishtp_cl_send_msg(dev, cl);
818 					} else {
819 						spin_unlock_irqrestore(
820 							&cl->tx_list_spinlock,
821 							tx_flags);
822 					}
823 				}
824 				break;
825 			}
826 		}
827 		spin_unlock_irqrestore(&dev->cl_list_lock, flags);
828 		goto	eoi;
829 	}
830 
831 	/*
832 	 * Some messages that are safe for ISR processing and important
833 	 * to be done "quickly" and in-order, go here
834 	 */
835 	if (ishtp_msg->hbm_cmd == CLIENT_CONNECT_RES_CMD ||
836 			ishtp_msg->hbm_cmd == CLIENT_DISCONNECT_RES_CMD ||
837 			ishtp_msg->hbm_cmd == CLIENT_DISCONNECT_REQ_CMD ||
838 			ishtp_msg->hbm_cmd == DMA_XFER) {
839 		ishtp_hbm_dispatch(dev, ishtp_msg);
840 		goto	eoi;
841 	}
842 
843 	/*
844 	 * All other HBMs go here.
845 	 * We schedule HBMs for processing serially by using system wq,
846 	 * possibly there will be multiple HBMs scheduled at the same time.
847 	 */
848 	spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
849 	if ((dev->rd_msg_fifo_tail + IPC_PAYLOAD_SIZE) %
850 			(RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE) ==
851 			dev->rd_msg_fifo_head) {
852 		spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
853 		dev_err(dev->devc, "BH buffer overflow, dropping HBM %u\n",
854 			(unsigned int)ishtp_msg->hbm_cmd);
855 		goto	eoi;
856 	}
857 	memcpy(dev->rd_msg_fifo + dev->rd_msg_fifo_tail, ishtp_msg,
858 		ishtp_hdr->length);
859 	dev->rd_msg_fifo_tail = (dev->rd_msg_fifo_tail + IPC_PAYLOAD_SIZE) %
860 		(RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE);
861 	spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
862 	schedule_work(&dev->bh_hbm_work);
863 eoi:
864 	return;
865 }
866 
867 /**
868  * recv_fixed_cl_msg() - Receive fixed client message
869  * @dev: ISHTP device instance
870  * @ishtp_hdr: received bus message
871  *
872  * Receive and process ISHTP fixed client messages (address == 0)
873  * in ISR context
874  */
875 void recv_fixed_cl_msg(struct ishtp_device *dev,
876 	struct ishtp_msg_hdr *ishtp_hdr)
877 {
878 	uint8_t rd_msg_buf[ISHTP_RD_MSG_BUF_SIZE];
879 
880 	dev->print_log(dev,
881 		"%s() got fixed client msg from client #%d\n",
882 		__func__, ishtp_hdr->fw_addr);
883 	dev->ops->ishtp_read(dev, rd_msg_buf, ishtp_hdr->length);
884 	if (ishtp_hdr->fw_addr == ISHTP_SYSTEM_STATE_CLIENT_ADDR) {
885 		struct ish_system_states_header *msg_hdr =
886 			(struct ish_system_states_header *)rd_msg_buf;
887 		if (msg_hdr->cmd == SYSTEM_STATE_SUBSCRIBE)
888 			ishtp_send_resume(dev);
889 		/* if FW request arrived here, the system is not suspended */
890 		else
891 			dev_err(dev->devc, "unknown fixed client msg [%02X]\n",
892 				msg_hdr->cmd);
893 	}
894 }
895 
896 /**
897  * fix_cl_hdr() - Initialize fixed client header
898  * @hdr: message header
899  * @length: length of message
900  * @cl_addr: Client address
901  *
902  * Initialize message header for fixed client
903  */
904 static inline void fix_cl_hdr(struct ishtp_msg_hdr *hdr, size_t length,
905 	uint8_t cl_addr)
906 {
907 	hdr->host_addr = 0;
908 	hdr->fw_addr = cl_addr;
909 	hdr->length = length;
910 	hdr->msg_complete = 1;
911 	hdr->reserved = 0;
912 }
913 
914 /*** Suspend and resume notification ***/
915 
916 static uint32_t current_state;
917 static uint32_t supported_states = 0 | SUSPEND_STATE_BIT;
918 
919 /**
920  * ishtp_send_suspend() - Send suspend message to FW
921  * @dev: ISHTP device instance
922  *
923  * Send suspend message to FW. This is useful for system freeze (non S3) case
924  */
925 void ishtp_send_suspend(struct ishtp_device *dev)
926 {
927 	struct ishtp_msg_hdr	ishtp_hdr;
928 	struct ish_system_states_status state_status_msg;
929 	const size_t len = sizeof(struct ish_system_states_status);
930 
931 	fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR);
932 
933 	memset(&state_status_msg, 0, len);
934 	state_status_msg.hdr.cmd = SYSTEM_STATE_STATUS;
935 	state_status_msg.supported_states = supported_states;
936 	current_state |= SUSPEND_STATE_BIT;
937 	dev->print_log(dev, "%s() sends SUSPEND notification\n", __func__);
938 	state_status_msg.states_status = current_state;
939 
940 	ishtp_write_message(dev, &ishtp_hdr,
941 		(unsigned char *)&state_status_msg);
942 }
943 EXPORT_SYMBOL(ishtp_send_suspend);
944 
945 /**
946  * ishtp_send_resume() - Send resume message to FW
947  * @dev: ISHTP device instance
948  *
949  * Send resume message to FW. This is useful for system freeze (non S3) case
950  */
951 void ishtp_send_resume(struct ishtp_device *dev)
952 {
953 	struct ishtp_msg_hdr	ishtp_hdr;
954 	struct ish_system_states_status state_status_msg;
955 	const size_t len = sizeof(struct ish_system_states_status);
956 
957 	fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR);
958 
959 	memset(&state_status_msg, 0, len);
960 	state_status_msg.hdr.cmd = SYSTEM_STATE_STATUS;
961 	state_status_msg.supported_states = supported_states;
962 	current_state &= ~SUSPEND_STATE_BIT;
963 	dev->print_log(dev, "%s() sends RESUME notification\n", __func__);
964 	state_status_msg.states_status = current_state;
965 
966 	ishtp_write_message(dev, &ishtp_hdr,
967 		(unsigned char *)&state_status_msg);
968 }
969 EXPORT_SYMBOL(ishtp_send_resume);
970 
971 /**
972  * ishtp_query_subscribers() - Send query subscribers message
973  * @dev: ISHTP device instance
974  *
975  * Send message to query subscribers
976  */
977 void ishtp_query_subscribers(struct ishtp_device *dev)
978 {
979 	struct ishtp_msg_hdr	ishtp_hdr;
980 	struct ish_system_states_query_subscribers query_subscribers_msg;
981 	const size_t len = sizeof(struct ish_system_states_query_subscribers);
982 
983 	fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR);
984 
985 	memset(&query_subscribers_msg, 0, len);
986 	query_subscribers_msg.hdr.cmd = SYSTEM_STATE_QUERY_SUBSCRIBERS;
987 
988 	ishtp_write_message(dev, &ishtp_hdr,
989 		(unsigned char *)&query_subscribers_msg);
990 }
991