xref: /linux/drivers/net/ethernet/brocade/bna/bfa_msgq.c (revision 6fdcba32711044c35c0e1b094cbd8f3f0b4472c9) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Linux network driver for QLogic BR-series Converged Network Adapter.
4  */
5 /*
6  * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
7  * Copyright (c) 2014-2015 QLogic Corporation
8  * All rights reserved
9  * www.qlogic.com
10  */
11 
12 /* MSGQ module source file. */
13 
14 #include "bfi.h"
15 #include "bfa_msgq.h"
16 #include "bfa_ioc.h"
17 
18 #define call_cmdq_ent_cbfn(_cmdq_ent, _status)				\
19 {									\
20 	bfa_msgq_cmdcbfn_t cbfn;					\
21 	void *cbarg;							\
22 	cbfn = (_cmdq_ent)->cbfn;					\
23 	cbarg = (_cmdq_ent)->cbarg;					\
24 	(_cmdq_ent)->cbfn = NULL;					\
25 	(_cmdq_ent)->cbarg = NULL;					\
26 	if (cbfn) {							\
27 		cbfn(cbarg, (_status));					\
28 	}								\
29 }
30 
31 static void bfa_msgq_cmdq_dbell(struct bfa_msgq_cmdq *cmdq);
32 static void bfa_msgq_cmdq_copy_rsp(struct bfa_msgq_cmdq *cmdq);
33 
34 enum cmdq_event {
35 	CMDQ_E_START			= 1,
36 	CMDQ_E_STOP			= 2,
37 	CMDQ_E_FAIL			= 3,
38 	CMDQ_E_POST			= 4,
39 	CMDQ_E_INIT_RESP		= 5,
40 	CMDQ_E_DB_READY			= 6,
41 };
42 
43 bfa_fsm_state_decl(cmdq, stopped, struct bfa_msgq_cmdq, enum cmdq_event);
44 bfa_fsm_state_decl(cmdq, init_wait, struct bfa_msgq_cmdq, enum cmdq_event);
45 bfa_fsm_state_decl(cmdq, ready, struct bfa_msgq_cmdq, enum cmdq_event);
46 bfa_fsm_state_decl(cmdq, dbell_wait, struct bfa_msgq_cmdq,
47 			enum cmdq_event);
48 
49 static void
50 cmdq_sm_stopped_entry(struct bfa_msgq_cmdq *cmdq)
51 {
52 	struct bfa_msgq_cmd_entry *cmdq_ent;
53 
54 	cmdq->producer_index = 0;
55 	cmdq->consumer_index = 0;
56 	cmdq->flags = 0;
57 	cmdq->token = 0;
58 	cmdq->offset = 0;
59 	cmdq->bytes_to_copy = 0;
60 	while (!list_empty(&cmdq->pending_q)) {
61 		cmdq_ent = list_first_entry(&cmdq->pending_q,
62 					    struct bfa_msgq_cmd_entry, qe);
63 		list_del(&cmdq_ent->qe);
64 		call_cmdq_ent_cbfn(cmdq_ent, BFA_STATUS_FAILED);
65 	}
66 }
67 
68 static void
69 cmdq_sm_stopped(struct bfa_msgq_cmdq *cmdq, enum cmdq_event event)
70 {
71 	switch (event) {
72 	case CMDQ_E_START:
73 		bfa_fsm_set_state(cmdq, cmdq_sm_init_wait);
74 		break;
75 
76 	case CMDQ_E_STOP:
77 	case CMDQ_E_FAIL:
78 		/* No-op */
79 		break;
80 
81 	case CMDQ_E_POST:
82 		cmdq->flags |= BFA_MSGQ_CMDQ_F_DB_UPDATE;
83 		break;
84 
85 	default:
86 		bfa_sm_fault(event);
87 	}
88 }
89 
90 static void
91 cmdq_sm_init_wait_entry(struct bfa_msgq_cmdq *cmdq)
92 {
93 	bfa_wc_down(&cmdq->msgq->init_wc);
94 }
95 
96 static void
97 cmdq_sm_init_wait(struct bfa_msgq_cmdq *cmdq, enum cmdq_event event)
98 {
99 	switch (event) {
100 	case CMDQ_E_STOP:
101 	case CMDQ_E_FAIL:
102 		bfa_fsm_set_state(cmdq, cmdq_sm_stopped);
103 		break;
104 
105 	case CMDQ_E_POST:
106 		cmdq->flags |= BFA_MSGQ_CMDQ_F_DB_UPDATE;
107 		break;
108 
109 	case CMDQ_E_INIT_RESP:
110 		if (cmdq->flags & BFA_MSGQ_CMDQ_F_DB_UPDATE) {
111 			cmdq->flags &= ~BFA_MSGQ_CMDQ_F_DB_UPDATE;
112 			bfa_fsm_set_state(cmdq, cmdq_sm_dbell_wait);
113 		} else
114 			bfa_fsm_set_state(cmdq, cmdq_sm_ready);
115 		break;
116 
117 	default:
118 		bfa_sm_fault(event);
119 	}
120 }
121 
122 static void
123 cmdq_sm_ready_entry(struct bfa_msgq_cmdq *cmdq)
124 {
125 }
126 
127 static void
128 cmdq_sm_ready(struct bfa_msgq_cmdq *cmdq, enum cmdq_event event)
129 {
130 	switch (event) {
131 	case CMDQ_E_STOP:
132 	case CMDQ_E_FAIL:
133 		bfa_fsm_set_state(cmdq, cmdq_sm_stopped);
134 		break;
135 
136 	case CMDQ_E_POST:
137 		bfa_fsm_set_state(cmdq, cmdq_sm_dbell_wait);
138 		break;
139 
140 	default:
141 		bfa_sm_fault(event);
142 	}
143 }
144 
145 static void
146 cmdq_sm_dbell_wait_entry(struct bfa_msgq_cmdq *cmdq)
147 {
148 	bfa_msgq_cmdq_dbell(cmdq);
149 }
150 
151 static void
152 cmdq_sm_dbell_wait(struct bfa_msgq_cmdq *cmdq, enum cmdq_event event)
153 {
154 	switch (event) {
155 	case CMDQ_E_STOP:
156 	case CMDQ_E_FAIL:
157 		bfa_fsm_set_state(cmdq, cmdq_sm_stopped);
158 		break;
159 
160 	case CMDQ_E_POST:
161 		cmdq->flags |= BFA_MSGQ_CMDQ_F_DB_UPDATE;
162 		break;
163 
164 	case CMDQ_E_DB_READY:
165 		if (cmdq->flags & BFA_MSGQ_CMDQ_F_DB_UPDATE) {
166 			cmdq->flags &= ~BFA_MSGQ_CMDQ_F_DB_UPDATE;
167 			bfa_fsm_set_state(cmdq, cmdq_sm_dbell_wait);
168 		} else
169 			bfa_fsm_set_state(cmdq, cmdq_sm_ready);
170 		break;
171 
172 	default:
173 		bfa_sm_fault(event);
174 	}
175 }
176 
177 static void
178 bfa_msgq_cmdq_dbell_ready(void *arg)
179 {
180 	struct bfa_msgq_cmdq *cmdq = (struct bfa_msgq_cmdq *)arg;
181 	bfa_fsm_send_event(cmdq, CMDQ_E_DB_READY);
182 }
183 
184 static void
185 bfa_msgq_cmdq_dbell(struct bfa_msgq_cmdq *cmdq)
186 {
187 	struct bfi_msgq_h2i_db *dbell =
188 		(struct bfi_msgq_h2i_db *)(&cmdq->dbell_mb.msg[0]);
189 
190 	memset(dbell, 0, sizeof(struct bfi_msgq_h2i_db));
191 	bfi_h2i_set(dbell->mh, BFI_MC_MSGQ, BFI_MSGQ_H2I_DOORBELL_PI, 0);
192 	dbell->mh.mtag.i2htok = 0;
193 	dbell->idx.cmdq_pi = htons(cmdq->producer_index);
194 
195 	if (!bfa_nw_ioc_mbox_queue(cmdq->msgq->ioc, &cmdq->dbell_mb,
196 				bfa_msgq_cmdq_dbell_ready, cmdq)) {
197 		bfa_msgq_cmdq_dbell_ready(cmdq);
198 	}
199 }
200 
201 static void
202 __cmd_copy(struct bfa_msgq_cmdq *cmdq, struct bfa_msgq_cmd_entry *cmd)
203 {
204 	size_t len = cmd->msg_size;
205 	int num_entries = 0;
206 	size_t to_copy;
207 	u8 *src, *dst;
208 
209 	src = (u8 *)cmd->msg_hdr;
210 	dst = (u8 *)cmdq->addr.kva;
211 	dst += (cmdq->producer_index * BFI_MSGQ_CMD_ENTRY_SIZE);
212 
213 	while (len) {
214 		to_copy = (len < BFI_MSGQ_CMD_ENTRY_SIZE) ?
215 				len : BFI_MSGQ_CMD_ENTRY_SIZE;
216 		memcpy(dst, src, to_copy);
217 		len -= to_copy;
218 		src += BFI_MSGQ_CMD_ENTRY_SIZE;
219 		BFA_MSGQ_INDX_ADD(cmdq->producer_index, 1, cmdq->depth);
220 		dst = (u8 *)cmdq->addr.kva;
221 		dst += (cmdq->producer_index * BFI_MSGQ_CMD_ENTRY_SIZE);
222 		num_entries++;
223 	}
224 
225 }
226 
227 static void
228 bfa_msgq_cmdq_ci_update(struct bfa_msgq_cmdq *cmdq, struct bfi_mbmsg *mb)
229 {
230 	struct bfi_msgq_i2h_db *dbell = (struct bfi_msgq_i2h_db *)mb;
231 	struct bfa_msgq_cmd_entry *cmd;
232 	int posted = 0;
233 
234 	cmdq->consumer_index = ntohs(dbell->idx.cmdq_ci);
235 
236 	/* Walk through pending list to see if the command can be posted */
237 	while (!list_empty(&cmdq->pending_q)) {
238 		cmd = list_first_entry(&cmdq->pending_q,
239 				       struct bfa_msgq_cmd_entry, qe);
240 		if (ntohs(cmd->msg_hdr->num_entries) <=
241 			BFA_MSGQ_FREE_CNT(cmdq)) {
242 			list_del(&cmd->qe);
243 			__cmd_copy(cmdq, cmd);
244 			posted = 1;
245 			call_cmdq_ent_cbfn(cmd, BFA_STATUS_OK);
246 		} else {
247 			break;
248 		}
249 	}
250 
251 	if (posted)
252 		bfa_fsm_send_event(cmdq, CMDQ_E_POST);
253 }
254 
255 static void
256 bfa_msgq_cmdq_copy_next(void *arg)
257 {
258 	struct bfa_msgq_cmdq *cmdq = (struct bfa_msgq_cmdq *)arg;
259 
260 	if (cmdq->bytes_to_copy)
261 		bfa_msgq_cmdq_copy_rsp(cmdq);
262 }
263 
264 static void
265 bfa_msgq_cmdq_copy_req(struct bfa_msgq_cmdq *cmdq, struct bfi_mbmsg *mb)
266 {
267 	struct bfi_msgq_i2h_cmdq_copy_req *req =
268 		(struct bfi_msgq_i2h_cmdq_copy_req *)mb;
269 
270 	cmdq->token = 0;
271 	cmdq->offset = ntohs(req->offset);
272 	cmdq->bytes_to_copy = ntohs(req->len);
273 	bfa_msgq_cmdq_copy_rsp(cmdq);
274 }
275 
276 static void
277 bfa_msgq_cmdq_copy_rsp(struct bfa_msgq_cmdq *cmdq)
278 {
279 	struct bfi_msgq_h2i_cmdq_copy_rsp *rsp =
280 		(struct bfi_msgq_h2i_cmdq_copy_rsp *)&cmdq->copy_mb.msg[0];
281 	int copied;
282 	u8 *addr = (u8 *)cmdq->addr.kva;
283 
284 	memset(rsp, 0, sizeof(struct bfi_msgq_h2i_cmdq_copy_rsp));
285 	bfi_h2i_set(rsp->mh, BFI_MC_MSGQ, BFI_MSGQ_H2I_CMDQ_COPY_RSP, 0);
286 	rsp->mh.mtag.i2htok = htons(cmdq->token);
287 	copied = (cmdq->bytes_to_copy >= BFI_CMD_COPY_SZ) ? BFI_CMD_COPY_SZ :
288 		cmdq->bytes_to_copy;
289 	addr += cmdq->offset;
290 	memcpy(rsp->data, addr, copied);
291 
292 	cmdq->token++;
293 	cmdq->offset += copied;
294 	cmdq->bytes_to_copy -= copied;
295 
296 	if (!bfa_nw_ioc_mbox_queue(cmdq->msgq->ioc, &cmdq->copy_mb,
297 				bfa_msgq_cmdq_copy_next, cmdq)) {
298 		bfa_msgq_cmdq_copy_next(cmdq);
299 	}
300 }
301 
302 static void
303 bfa_msgq_cmdq_attach(struct bfa_msgq_cmdq *cmdq, struct bfa_msgq *msgq)
304 {
305 	cmdq->depth = BFA_MSGQ_CMDQ_NUM_ENTRY;
306 	INIT_LIST_HEAD(&cmdq->pending_q);
307 	cmdq->msgq = msgq;
308 	bfa_fsm_set_state(cmdq, cmdq_sm_stopped);
309 }
310 
311 static void bfa_msgq_rspq_dbell(struct bfa_msgq_rspq *rspq);
312 
313 enum rspq_event {
314 	RSPQ_E_START			= 1,
315 	RSPQ_E_STOP			= 2,
316 	RSPQ_E_FAIL			= 3,
317 	RSPQ_E_RESP			= 4,
318 	RSPQ_E_INIT_RESP		= 5,
319 	RSPQ_E_DB_READY			= 6,
320 };
321 
322 bfa_fsm_state_decl(rspq, stopped, struct bfa_msgq_rspq, enum rspq_event);
323 bfa_fsm_state_decl(rspq, init_wait, struct bfa_msgq_rspq,
324 			enum rspq_event);
325 bfa_fsm_state_decl(rspq, ready, struct bfa_msgq_rspq, enum rspq_event);
326 bfa_fsm_state_decl(rspq, dbell_wait, struct bfa_msgq_rspq,
327 			enum rspq_event);
328 
329 static void
330 rspq_sm_stopped_entry(struct bfa_msgq_rspq *rspq)
331 {
332 	rspq->producer_index = 0;
333 	rspq->consumer_index = 0;
334 	rspq->flags = 0;
335 }
336 
337 static void
338 rspq_sm_stopped(struct bfa_msgq_rspq *rspq, enum rspq_event event)
339 {
340 	switch (event) {
341 	case RSPQ_E_START:
342 		bfa_fsm_set_state(rspq, rspq_sm_init_wait);
343 		break;
344 
345 	case RSPQ_E_STOP:
346 	case RSPQ_E_FAIL:
347 		/* No-op */
348 		break;
349 
350 	default:
351 		bfa_sm_fault(event);
352 	}
353 }
354 
355 static void
356 rspq_sm_init_wait_entry(struct bfa_msgq_rspq *rspq)
357 {
358 	bfa_wc_down(&rspq->msgq->init_wc);
359 }
360 
361 static void
362 rspq_sm_init_wait(struct bfa_msgq_rspq *rspq, enum rspq_event event)
363 {
364 	switch (event) {
365 	case RSPQ_E_FAIL:
366 	case RSPQ_E_STOP:
367 		bfa_fsm_set_state(rspq, rspq_sm_stopped);
368 		break;
369 
370 	case RSPQ_E_INIT_RESP:
371 		bfa_fsm_set_state(rspq, rspq_sm_ready);
372 		break;
373 
374 	default:
375 		bfa_sm_fault(event);
376 	}
377 }
378 
379 static void
380 rspq_sm_ready_entry(struct bfa_msgq_rspq *rspq)
381 {
382 }
383 
384 static void
385 rspq_sm_ready(struct bfa_msgq_rspq *rspq, enum rspq_event event)
386 {
387 	switch (event) {
388 	case RSPQ_E_STOP:
389 	case RSPQ_E_FAIL:
390 		bfa_fsm_set_state(rspq, rspq_sm_stopped);
391 		break;
392 
393 	case RSPQ_E_RESP:
394 		bfa_fsm_set_state(rspq, rspq_sm_dbell_wait);
395 		break;
396 
397 	default:
398 		bfa_sm_fault(event);
399 	}
400 }
401 
402 static void
403 rspq_sm_dbell_wait_entry(struct bfa_msgq_rspq *rspq)
404 {
405 	if (!bfa_nw_ioc_is_disabled(rspq->msgq->ioc))
406 		bfa_msgq_rspq_dbell(rspq);
407 }
408 
409 static void
410 rspq_sm_dbell_wait(struct bfa_msgq_rspq *rspq, enum rspq_event event)
411 {
412 	switch (event) {
413 	case RSPQ_E_STOP:
414 	case RSPQ_E_FAIL:
415 		bfa_fsm_set_state(rspq, rspq_sm_stopped);
416 		break;
417 
418 	case RSPQ_E_RESP:
419 		rspq->flags |= BFA_MSGQ_RSPQ_F_DB_UPDATE;
420 		break;
421 
422 	case RSPQ_E_DB_READY:
423 		if (rspq->flags & BFA_MSGQ_RSPQ_F_DB_UPDATE) {
424 			rspq->flags &= ~BFA_MSGQ_RSPQ_F_DB_UPDATE;
425 			bfa_fsm_set_state(rspq, rspq_sm_dbell_wait);
426 		} else
427 			bfa_fsm_set_state(rspq, rspq_sm_ready);
428 		break;
429 
430 	default:
431 		bfa_sm_fault(event);
432 	}
433 }
434 
435 static void
436 bfa_msgq_rspq_dbell_ready(void *arg)
437 {
438 	struct bfa_msgq_rspq *rspq = (struct bfa_msgq_rspq *)arg;
439 	bfa_fsm_send_event(rspq, RSPQ_E_DB_READY);
440 }
441 
442 static void
443 bfa_msgq_rspq_dbell(struct bfa_msgq_rspq *rspq)
444 {
445 	struct bfi_msgq_h2i_db *dbell =
446 		(struct bfi_msgq_h2i_db *)(&rspq->dbell_mb.msg[0]);
447 
448 	memset(dbell, 0, sizeof(struct bfi_msgq_h2i_db));
449 	bfi_h2i_set(dbell->mh, BFI_MC_MSGQ, BFI_MSGQ_H2I_DOORBELL_CI, 0);
450 	dbell->mh.mtag.i2htok = 0;
451 	dbell->idx.rspq_ci = htons(rspq->consumer_index);
452 
453 	if (!bfa_nw_ioc_mbox_queue(rspq->msgq->ioc, &rspq->dbell_mb,
454 				bfa_msgq_rspq_dbell_ready, rspq)) {
455 		bfa_msgq_rspq_dbell_ready(rspq);
456 	}
457 }
458 
459 static void
460 bfa_msgq_rspq_pi_update(struct bfa_msgq_rspq *rspq, struct bfi_mbmsg *mb)
461 {
462 	struct bfi_msgq_i2h_db *dbell = (struct bfi_msgq_i2h_db *)mb;
463 	struct bfi_msgq_mhdr *msghdr;
464 	int num_entries;
465 	int mc;
466 	u8 *rspq_qe;
467 
468 	rspq->producer_index = ntohs(dbell->idx.rspq_pi);
469 
470 	while (rspq->consumer_index != rspq->producer_index) {
471 		rspq_qe = (u8 *)rspq->addr.kva;
472 		rspq_qe += (rspq->consumer_index * BFI_MSGQ_RSP_ENTRY_SIZE);
473 		msghdr = (struct bfi_msgq_mhdr *)rspq_qe;
474 
475 		mc = msghdr->msg_class;
476 		num_entries = ntohs(msghdr->num_entries);
477 
478 		if ((mc >= BFI_MC_MAX) || (rspq->rsphdlr[mc].cbfn == NULL))
479 			break;
480 
481 		(rspq->rsphdlr[mc].cbfn)(rspq->rsphdlr[mc].cbarg, msghdr);
482 
483 		BFA_MSGQ_INDX_ADD(rspq->consumer_index, num_entries,
484 				rspq->depth);
485 	}
486 
487 	bfa_fsm_send_event(rspq, RSPQ_E_RESP);
488 }
489 
490 static void
491 bfa_msgq_rspq_attach(struct bfa_msgq_rspq *rspq, struct bfa_msgq *msgq)
492 {
493 	rspq->depth = BFA_MSGQ_RSPQ_NUM_ENTRY;
494 	rspq->msgq = msgq;
495 	bfa_fsm_set_state(rspq, rspq_sm_stopped);
496 }
497 
498 static void
499 bfa_msgq_init_rsp(struct bfa_msgq *msgq,
500 		 struct bfi_mbmsg *mb)
501 {
502 	bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_INIT_RESP);
503 	bfa_fsm_send_event(&msgq->rspq, RSPQ_E_INIT_RESP);
504 }
505 
506 static void
507 bfa_msgq_init(void *arg)
508 {
509 	struct bfa_msgq *msgq = (struct bfa_msgq *)arg;
510 	struct bfi_msgq_cfg_req *msgq_cfg =
511 		(struct bfi_msgq_cfg_req *)&msgq->init_mb.msg[0];
512 
513 	memset(msgq_cfg, 0, sizeof(struct bfi_msgq_cfg_req));
514 	bfi_h2i_set(msgq_cfg->mh, BFI_MC_MSGQ, BFI_MSGQ_H2I_INIT_REQ, 0);
515 	msgq_cfg->mh.mtag.i2htok = 0;
516 
517 	bfa_dma_be_addr_set(msgq_cfg->cmdq.addr, msgq->cmdq.addr.pa);
518 	msgq_cfg->cmdq.q_depth = htons(msgq->cmdq.depth);
519 	bfa_dma_be_addr_set(msgq_cfg->rspq.addr, msgq->rspq.addr.pa);
520 	msgq_cfg->rspq.q_depth = htons(msgq->rspq.depth);
521 
522 	bfa_nw_ioc_mbox_queue(msgq->ioc, &msgq->init_mb, NULL, NULL);
523 }
524 
525 static void
526 bfa_msgq_isr(void *cbarg, struct bfi_mbmsg *msg)
527 {
528 	struct bfa_msgq *msgq = (struct bfa_msgq *)cbarg;
529 
530 	switch (msg->mh.msg_id) {
531 	case BFI_MSGQ_I2H_INIT_RSP:
532 		bfa_msgq_init_rsp(msgq, msg);
533 		break;
534 
535 	case BFI_MSGQ_I2H_DOORBELL_PI:
536 		bfa_msgq_rspq_pi_update(&msgq->rspq, msg);
537 		break;
538 
539 	case BFI_MSGQ_I2H_DOORBELL_CI:
540 		bfa_msgq_cmdq_ci_update(&msgq->cmdq, msg);
541 		break;
542 
543 	case BFI_MSGQ_I2H_CMDQ_COPY_REQ:
544 		bfa_msgq_cmdq_copy_req(&msgq->cmdq, msg);
545 		break;
546 
547 	default:
548 		BUG_ON(1);
549 	}
550 }
551 
552 static void
553 bfa_msgq_notify(void *cbarg, enum bfa_ioc_event event)
554 {
555 	struct bfa_msgq *msgq = (struct bfa_msgq *)cbarg;
556 
557 	switch (event) {
558 	case BFA_IOC_E_ENABLED:
559 		bfa_wc_init(&msgq->init_wc, bfa_msgq_init, msgq);
560 		bfa_wc_up(&msgq->init_wc);
561 		bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_START);
562 		bfa_wc_up(&msgq->init_wc);
563 		bfa_fsm_send_event(&msgq->rspq, RSPQ_E_START);
564 		bfa_wc_wait(&msgq->init_wc);
565 		break;
566 
567 	case BFA_IOC_E_DISABLED:
568 		bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_STOP);
569 		bfa_fsm_send_event(&msgq->rspq, RSPQ_E_STOP);
570 		break;
571 
572 	case BFA_IOC_E_FAILED:
573 		bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_FAIL);
574 		bfa_fsm_send_event(&msgq->rspq, RSPQ_E_FAIL);
575 		break;
576 
577 	default:
578 		break;
579 	}
580 }
581 
582 u32
583 bfa_msgq_meminfo(void)
584 {
585 	return roundup(BFA_MSGQ_CMDQ_SIZE, BFA_DMA_ALIGN_SZ) +
586 		roundup(BFA_MSGQ_RSPQ_SIZE, BFA_DMA_ALIGN_SZ);
587 }
588 
589 void
590 bfa_msgq_memclaim(struct bfa_msgq *msgq, u8 *kva, u64 pa)
591 {
592 	msgq->cmdq.addr.kva = kva;
593 	msgq->cmdq.addr.pa  = pa;
594 
595 	kva += roundup(BFA_MSGQ_CMDQ_SIZE, BFA_DMA_ALIGN_SZ);
596 	pa += roundup(BFA_MSGQ_CMDQ_SIZE, BFA_DMA_ALIGN_SZ);
597 
598 	msgq->rspq.addr.kva = kva;
599 	msgq->rspq.addr.pa = pa;
600 }
601 
602 void
603 bfa_msgq_attach(struct bfa_msgq *msgq, struct bfa_ioc *ioc)
604 {
605 	msgq->ioc    = ioc;
606 
607 	bfa_msgq_cmdq_attach(&msgq->cmdq, msgq);
608 	bfa_msgq_rspq_attach(&msgq->rspq, msgq);
609 
610 	bfa_nw_ioc_mbox_regisr(msgq->ioc, BFI_MC_MSGQ, bfa_msgq_isr, msgq);
611 	bfa_ioc_notify_init(&msgq->ioc_notify, bfa_msgq_notify, msgq);
612 	bfa_nw_ioc_notify_register(msgq->ioc, &msgq->ioc_notify);
613 }
614 
615 void
616 bfa_msgq_regisr(struct bfa_msgq *msgq, enum bfi_mclass mc,
617 		bfa_msgq_mcfunc_t cbfn, void *cbarg)
618 {
619 	msgq->rspq.rsphdlr[mc].cbfn	= cbfn;
620 	msgq->rspq.rsphdlr[mc].cbarg	= cbarg;
621 }
622 
623 void
624 bfa_msgq_cmd_post(struct bfa_msgq *msgq,  struct bfa_msgq_cmd_entry *cmd)
625 {
626 	if (ntohs(cmd->msg_hdr->num_entries) <=
627 		BFA_MSGQ_FREE_CNT(&msgq->cmdq)) {
628 		__cmd_copy(&msgq->cmdq, cmd);
629 		call_cmdq_ent_cbfn(cmd, BFA_STATUS_OK);
630 		bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_POST);
631 	} else {
632 		list_add_tail(&cmd->qe, &msgq->cmdq.pending_q);
633 	}
634 }
635 
636 void
637 bfa_msgq_rsp_copy(struct bfa_msgq *msgq, u8 *buf, size_t buf_len)
638 {
639 	struct bfa_msgq_rspq *rspq = &msgq->rspq;
640 	size_t len = buf_len;
641 	size_t to_copy;
642 	int ci;
643 	u8 *src, *dst;
644 
645 	ci = rspq->consumer_index;
646 	src = (u8 *)rspq->addr.kva;
647 	src += (ci * BFI_MSGQ_RSP_ENTRY_SIZE);
648 	dst = buf;
649 
650 	while (len) {
651 		to_copy = (len < BFI_MSGQ_RSP_ENTRY_SIZE) ?
652 				len : BFI_MSGQ_RSP_ENTRY_SIZE;
653 		memcpy(dst, src, to_copy);
654 		len -= to_copy;
655 		dst += BFI_MSGQ_RSP_ENTRY_SIZE;
656 		BFA_MSGQ_INDX_ADD(ci, 1, rspq->depth);
657 		src = (u8 *)rspq->addr.kva;
658 		src += (ci * BFI_MSGQ_RSP_ENTRY_SIZE);
659 	}
660 }
661