xref: /linux/drivers/net/ethernet/brocade/bna/bfa_msgq.c (revision fd7d598270724cc787982ea48bbe17ad383a8b7f) 
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 	size_t to_copy;
206 	u8 *src, *dst;
207 
208 	src = (u8 *)cmd->msg_hdr;
209 	dst = (u8 *)cmdq->addr.kva;
210 	dst += (cmdq->producer_index * BFI_MSGQ_CMD_ENTRY_SIZE);
211 
212 	while (len) {
213 		to_copy = (len < BFI_MSGQ_CMD_ENTRY_SIZE) ?
214 				len : BFI_MSGQ_CMD_ENTRY_SIZE;
215 		memcpy(dst, src, to_copy);
216 		len -= to_copy;
217 		src += BFI_MSGQ_CMD_ENTRY_SIZE;
218 		BFA_MSGQ_INDX_ADD(cmdq->producer_index, 1, cmdq->depth);
219 		dst = (u8 *)cmdq->addr.kva;
220 		dst += (cmdq->producer_index * BFI_MSGQ_CMD_ENTRY_SIZE);
221 	}
222 
223 }
224 
225 static void
226 bfa_msgq_cmdq_ci_update(struct bfa_msgq_cmdq *cmdq, struct bfi_mbmsg *mb)
227 {
228 	struct bfi_msgq_i2h_db *dbell = (struct bfi_msgq_i2h_db *)mb;
229 	struct bfa_msgq_cmd_entry *cmd;
230 	int posted = 0;
231 
232 	cmdq->consumer_index = ntohs(dbell->idx.cmdq_ci);
233 
234 	/* Walk through pending list to see if the command can be posted */
235 	while (!list_empty(&cmdq->pending_q)) {
236 		cmd = list_first_entry(&cmdq->pending_q,
237 				       struct bfa_msgq_cmd_entry, qe);
238 		if (ntohs(cmd->msg_hdr->num_entries) <=
239 			BFA_MSGQ_FREE_CNT(cmdq)) {
240 			list_del(&cmd->qe);
241 			__cmd_copy(cmdq, cmd);
242 			posted = 1;
243 			call_cmdq_ent_cbfn(cmd, BFA_STATUS_OK);
244 		} else {
245 			break;
246 		}
247 	}
248 
249 	if (posted)
250 		bfa_fsm_send_event(cmdq, CMDQ_E_POST);
251 }
252 
253 static void
254 bfa_msgq_cmdq_copy_next(void *arg)
255 {
256 	struct bfa_msgq_cmdq *cmdq = (struct bfa_msgq_cmdq *)arg;
257 
258 	if (cmdq->bytes_to_copy)
259 		bfa_msgq_cmdq_copy_rsp(cmdq);
260 }
261 
262 static void
263 bfa_msgq_cmdq_copy_req(struct bfa_msgq_cmdq *cmdq, struct bfi_mbmsg *mb)
264 {
265 	struct bfi_msgq_i2h_cmdq_copy_req *req =
266 		(struct bfi_msgq_i2h_cmdq_copy_req *)mb;
267 
268 	cmdq->token = 0;
269 	cmdq->offset = ntohs(req->offset);
270 	cmdq->bytes_to_copy = ntohs(req->len);
271 	bfa_msgq_cmdq_copy_rsp(cmdq);
272 }
273 
274 static void
275 bfa_msgq_cmdq_copy_rsp(struct bfa_msgq_cmdq *cmdq)
276 {
277 	struct bfi_msgq_h2i_cmdq_copy_rsp *rsp =
278 		(struct bfi_msgq_h2i_cmdq_copy_rsp *)&cmdq->copy_mb.msg[0];
279 	int copied;
280 	u8 *addr = (u8 *)cmdq->addr.kva;
281 
282 	memset(rsp, 0, sizeof(struct bfi_msgq_h2i_cmdq_copy_rsp));
283 	bfi_h2i_set(rsp->mh, BFI_MC_MSGQ, BFI_MSGQ_H2I_CMDQ_COPY_RSP, 0);
284 	rsp->mh.mtag.i2htok = htons(cmdq->token);
285 	copied = (cmdq->bytes_to_copy >= BFI_CMD_COPY_SZ) ? BFI_CMD_COPY_SZ :
286 		cmdq->bytes_to_copy;
287 	addr += cmdq->offset;
288 	memcpy(rsp->data, addr, copied);
289 
290 	cmdq->token++;
291 	cmdq->offset += copied;
292 	cmdq->bytes_to_copy -= copied;
293 
294 	if (!bfa_nw_ioc_mbox_queue(cmdq->msgq->ioc, &cmdq->copy_mb,
295 				bfa_msgq_cmdq_copy_next, cmdq)) {
296 		bfa_msgq_cmdq_copy_next(cmdq);
297 	}
298 }
299 
300 static void
301 bfa_msgq_cmdq_attach(struct bfa_msgq_cmdq *cmdq, struct bfa_msgq *msgq)
302 {
303 	cmdq->depth = BFA_MSGQ_CMDQ_NUM_ENTRY;
304 	INIT_LIST_HEAD(&cmdq->pending_q);
305 	cmdq->msgq = msgq;
306 	bfa_fsm_set_state(cmdq, cmdq_sm_stopped);
307 }
308 
309 static void bfa_msgq_rspq_dbell(struct bfa_msgq_rspq *rspq);
310 
311 enum rspq_event {
312 	RSPQ_E_START			= 1,
313 	RSPQ_E_STOP			= 2,
314 	RSPQ_E_FAIL			= 3,
315 	RSPQ_E_RESP			= 4,
316 	RSPQ_E_INIT_RESP		= 5,
317 	RSPQ_E_DB_READY			= 6,
318 };
319 
320 bfa_fsm_state_decl(rspq, stopped, struct bfa_msgq_rspq, enum rspq_event);
321 bfa_fsm_state_decl(rspq, init_wait, struct bfa_msgq_rspq,
322 			enum rspq_event);
323 bfa_fsm_state_decl(rspq, ready, struct bfa_msgq_rspq, enum rspq_event);
324 bfa_fsm_state_decl(rspq, dbell_wait, struct bfa_msgq_rspq,
325 			enum rspq_event);
326 
327 static void
328 rspq_sm_stopped_entry(struct bfa_msgq_rspq *rspq)
329 {
330 	rspq->producer_index = 0;
331 	rspq->consumer_index = 0;
332 	rspq->flags = 0;
333 }
334 
335 static void
336 rspq_sm_stopped(struct bfa_msgq_rspq *rspq, enum rspq_event event)
337 {
338 	switch (event) {
339 	case RSPQ_E_START:
340 		bfa_fsm_set_state(rspq, rspq_sm_init_wait);
341 		break;
342 
343 	case RSPQ_E_STOP:
344 	case RSPQ_E_FAIL:
345 		/* No-op */
346 		break;
347 
348 	default:
349 		bfa_sm_fault(event);
350 	}
351 }
352 
353 static void
354 rspq_sm_init_wait_entry(struct bfa_msgq_rspq *rspq)
355 {
356 	bfa_wc_down(&rspq->msgq->init_wc);
357 }
358 
359 static void
360 rspq_sm_init_wait(struct bfa_msgq_rspq *rspq, enum rspq_event event)
361 {
362 	switch (event) {
363 	case RSPQ_E_FAIL:
364 	case RSPQ_E_STOP:
365 		bfa_fsm_set_state(rspq, rspq_sm_stopped);
366 		break;
367 
368 	case RSPQ_E_INIT_RESP:
369 		bfa_fsm_set_state(rspq, rspq_sm_ready);
370 		break;
371 
372 	default:
373 		bfa_sm_fault(event);
374 	}
375 }
376 
377 static void
378 rspq_sm_ready_entry(struct bfa_msgq_rspq *rspq)
379 {
380 }
381 
382 static void
383 rspq_sm_ready(struct bfa_msgq_rspq *rspq, enum rspq_event event)
384 {
385 	switch (event) {
386 	case RSPQ_E_STOP:
387 	case RSPQ_E_FAIL:
388 		bfa_fsm_set_state(rspq, rspq_sm_stopped);
389 		break;
390 
391 	case RSPQ_E_RESP:
392 		bfa_fsm_set_state(rspq, rspq_sm_dbell_wait);
393 		break;
394 
395 	default:
396 		bfa_sm_fault(event);
397 	}
398 }
399 
400 static void
401 rspq_sm_dbell_wait_entry(struct bfa_msgq_rspq *rspq)
402 {
403 	if (!bfa_nw_ioc_is_disabled(rspq->msgq->ioc))
404 		bfa_msgq_rspq_dbell(rspq);
405 }
406 
407 static void
408 rspq_sm_dbell_wait(struct bfa_msgq_rspq *rspq, enum rspq_event event)
409 {
410 	switch (event) {
411 	case RSPQ_E_STOP:
412 	case RSPQ_E_FAIL:
413 		bfa_fsm_set_state(rspq, rspq_sm_stopped);
414 		break;
415 
416 	case RSPQ_E_RESP:
417 		rspq->flags |= BFA_MSGQ_RSPQ_F_DB_UPDATE;
418 		break;
419 
420 	case RSPQ_E_DB_READY:
421 		if (rspq->flags & BFA_MSGQ_RSPQ_F_DB_UPDATE) {
422 			rspq->flags &= ~BFA_MSGQ_RSPQ_F_DB_UPDATE;
423 			bfa_fsm_set_state(rspq, rspq_sm_dbell_wait);
424 		} else
425 			bfa_fsm_set_state(rspq, rspq_sm_ready);
426 		break;
427 
428 	default:
429 		bfa_sm_fault(event);
430 	}
431 }
432 
433 static void
434 bfa_msgq_rspq_dbell_ready(void *arg)
435 {
436 	struct bfa_msgq_rspq *rspq = (struct bfa_msgq_rspq *)arg;
437 	bfa_fsm_send_event(rspq, RSPQ_E_DB_READY);
438 }
439 
440 static void
441 bfa_msgq_rspq_dbell(struct bfa_msgq_rspq *rspq)
442 {
443 	struct bfi_msgq_h2i_db *dbell =
444 		(struct bfi_msgq_h2i_db *)(&rspq->dbell_mb.msg[0]);
445 
446 	memset(dbell, 0, sizeof(struct bfi_msgq_h2i_db));
447 	bfi_h2i_set(dbell->mh, BFI_MC_MSGQ, BFI_MSGQ_H2I_DOORBELL_CI, 0);
448 	dbell->mh.mtag.i2htok = 0;
449 	dbell->idx.rspq_ci = htons(rspq->consumer_index);
450 
451 	if (!bfa_nw_ioc_mbox_queue(rspq->msgq->ioc, &rspq->dbell_mb,
452 				bfa_msgq_rspq_dbell_ready, rspq)) {
453 		bfa_msgq_rspq_dbell_ready(rspq);
454 	}
455 }
456 
457 static void
458 bfa_msgq_rspq_pi_update(struct bfa_msgq_rspq *rspq, struct bfi_mbmsg *mb)
459 {
460 	struct bfi_msgq_i2h_db *dbell = (struct bfi_msgq_i2h_db *)mb;
461 	struct bfi_msgq_mhdr *msghdr;
462 	int num_entries;
463 	int mc;
464 	u8 *rspq_qe;
465 
466 	rspq->producer_index = ntohs(dbell->idx.rspq_pi);
467 
468 	while (rspq->consumer_index != rspq->producer_index) {
469 		rspq_qe = (u8 *)rspq->addr.kva;
470 		rspq_qe += (rspq->consumer_index * BFI_MSGQ_RSP_ENTRY_SIZE);
471 		msghdr = (struct bfi_msgq_mhdr *)rspq_qe;
472 
473 		mc = msghdr->msg_class;
474 		num_entries = ntohs(msghdr->num_entries);
475 
476 		if ((mc >= BFI_MC_MAX) || (rspq->rsphdlr[mc].cbfn == NULL))
477 			break;
478 
479 		(rspq->rsphdlr[mc].cbfn)(rspq->rsphdlr[mc].cbarg, msghdr);
480 
481 		BFA_MSGQ_INDX_ADD(rspq->consumer_index, num_entries,
482 				rspq->depth);
483 	}
484 
485 	bfa_fsm_send_event(rspq, RSPQ_E_RESP);
486 }
487 
488 static void
489 bfa_msgq_rspq_attach(struct bfa_msgq_rspq *rspq, struct bfa_msgq *msgq)
490 {
491 	rspq->depth = BFA_MSGQ_RSPQ_NUM_ENTRY;
492 	rspq->msgq = msgq;
493 	bfa_fsm_set_state(rspq, rspq_sm_stopped);
494 }
495 
496 static void
497 bfa_msgq_init_rsp(struct bfa_msgq *msgq,
498 		 struct bfi_mbmsg *mb)
499 {
500 	bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_INIT_RESP);
501 	bfa_fsm_send_event(&msgq->rspq, RSPQ_E_INIT_RESP);
502 }
503 
504 static void
505 bfa_msgq_init(void *arg)
506 {
507 	struct bfa_msgq *msgq = (struct bfa_msgq *)arg;
508 	struct bfi_msgq_cfg_req *msgq_cfg =
509 		(struct bfi_msgq_cfg_req *)&msgq->init_mb.msg[0];
510 
511 	memset(msgq_cfg, 0, sizeof(struct bfi_msgq_cfg_req));
512 	bfi_h2i_set(msgq_cfg->mh, BFI_MC_MSGQ, BFI_MSGQ_H2I_INIT_REQ, 0);
513 	msgq_cfg->mh.mtag.i2htok = 0;
514 
515 	bfa_dma_be_addr_set(msgq_cfg->cmdq.addr, msgq->cmdq.addr.pa);
516 	msgq_cfg->cmdq.q_depth = htons(msgq->cmdq.depth);
517 	bfa_dma_be_addr_set(msgq_cfg->rspq.addr, msgq->rspq.addr.pa);
518 	msgq_cfg->rspq.q_depth = htons(msgq->rspq.depth);
519 
520 	bfa_nw_ioc_mbox_queue(msgq->ioc, &msgq->init_mb, NULL, NULL);
521 }
522 
523 static void
524 bfa_msgq_isr(void *cbarg, struct bfi_mbmsg *msg)
525 {
526 	struct bfa_msgq *msgq = (struct bfa_msgq *)cbarg;
527 
528 	switch (msg->mh.msg_id) {
529 	case BFI_MSGQ_I2H_INIT_RSP:
530 		bfa_msgq_init_rsp(msgq, msg);
531 		break;
532 
533 	case BFI_MSGQ_I2H_DOORBELL_PI:
534 		bfa_msgq_rspq_pi_update(&msgq->rspq, msg);
535 		break;
536 
537 	case BFI_MSGQ_I2H_DOORBELL_CI:
538 		bfa_msgq_cmdq_ci_update(&msgq->cmdq, msg);
539 		break;
540 
541 	case BFI_MSGQ_I2H_CMDQ_COPY_REQ:
542 		bfa_msgq_cmdq_copy_req(&msgq->cmdq, msg);
543 		break;
544 
545 	default:
546 		BUG_ON(1);
547 	}
548 }
549 
550 static void
551 bfa_msgq_notify(void *cbarg, enum bfa_ioc_event event)
552 {
553 	struct bfa_msgq *msgq = (struct bfa_msgq *)cbarg;
554 
555 	switch (event) {
556 	case BFA_IOC_E_ENABLED:
557 		bfa_wc_init(&msgq->init_wc, bfa_msgq_init, msgq);
558 		bfa_wc_up(&msgq->init_wc);
559 		bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_START);
560 		bfa_wc_up(&msgq->init_wc);
561 		bfa_fsm_send_event(&msgq->rspq, RSPQ_E_START);
562 		bfa_wc_wait(&msgq->init_wc);
563 		break;
564 
565 	case BFA_IOC_E_DISABLED:
566 		bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_STOP);
567 		bfa_fsm_send_event(&msgq->rspq, RSPQ_E_STOP);
568 		break;
569 
570 	case BFA_IOC_E_FAILED:
571 		bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_FAIL);
572 		bfa_fsm_send_event(&msgq->rspq, RSPQ_E_FAIL);
573 		break;
574 
575 	default:
576 		break;
577 	}
578 }
579 
580 u32
581 bfa_msgq_meminfo(void)
582 {
583 	return roundup(BFA_MSGQ_CMDQ_SIZE, BFA_DMA_ALIGN_SZ) +
584 		roundup(BFA_MSGQ_RSPQ_SIZE, BFA_DMA_ALIGN_SZ);
585 }
586 
587 void
588 bfa_msgq_memclaim(struct bfa_msgq *msgq, u8 *kva, u64 pa)
589 {
590 	msgq->cmdq.addr.kva = kva;
591 	msgq->cmdq.addr.pa  = pa;
592 
593 	kva += roundup(BFA_MSGQ_CMDQ_SIZE, BFA_DMA_ALIGN_SZ);
594 	pa += roundup(BFA_MSGQ_CMDQ_SIZE, BFA_DMA_ALIGN_SZ);
595 
596 	msgq->rspq.addr.kva = kva;
597 	msgq->rspq.addr.pa = pa;
598 }
599 
600 void
601 bfa_msgq_attach(struct bfa_msgq *msgq, struct bfa_ioc *ioc)
602 {
603 	msgq->ioc    = ioc;
604 
605 	bfa_msgq_cmdq_attach(&msgq->cmdq, msgq);
606 	bfa_msgq_rspq_attach(&msgq->rspq, msgq);
607 
608 	bfa_nw_ioc_mbox_regisr(msgq->ioc, BFI_MC_MSGQ, bfa_msgq_isr, msgq);
609 	bfa_ioc_notify_init(&msgq->ioc_notify, bfa_msgq_notify, msgq);
610 	bfa_nw_ioc_notify_register(msgq->ioc, &msgq->ioc_notify);
611 }
612 
613 void
614 bfa_msgq_regisr(struct bfa_msgq *msgq, enum bfi_mclass mc,
615 		bfa_msgq_mcfunc_t cbfn, void *cbarg)
616 {
617 	msgq->rspq.rsphdlr[mc].cbfn	= cbfn;
618 	msgq->rspq.rsphdlr[mc].cbarg	= cbarg;
619 }
620 
621 void
622 bfa_msgq_cmd_post(struct bfa_msgq *msgq,  struct bfa_msgq_cmd_entry *cmd)
623 {
624 	if (ntohs(cmd->msg_hdr->num_entries) <=
625 		BFA_MSGQ_FREE_CNT(&msgq->cmdq)) {
626 		__cmd_copy(&msgq->cmdq, cmd);
627 		call_cmdq_ent_cbfn(cmd, BFA_STATUS_OK);
628 		bfa_fsm_send_event(&msgq->cmdq, CMDQ_E_POST);
629 	} else {
630 		list_add_tail(&cmd->qe, &msgq->cmdq.pending_q);
631 	}
632 }
633 
634 void
635 bfa_msgq_rsp_copy(struct bfa_msgq *msgq, u8 *buf, size_t buf_len)
636 {
637 	struct bfa_msgq_rspq *rspq = &msgq->rspq;
638 	size_t len = buf_len;
639 	size_t to_copy;
640 	int ci;
641 	u8 *src, *dst;
642 
643 	ci = rspq->consumer_index;
644 	src = (u8 *)rspq->addr.kva;
645 	src += (ci * BFI_MSGQ_RSP_ENTRY_SIZE);
646 	dst = buf;
647 
648 	while (len) {
649 		to_copy = (len < BFI_MSGQ_RSP_ENTRY_SIZE) ?
650 				len : BFI_MSGQ_RSP_ENTRY_SIZE;
651 		memcpy(dst, src, to_copy);
652 		len -= to_copy;
653 		dst += BFI_MSGQ_RSP_ENTRY_SIZE;
654 		BFA_MSGQ_INDX_ADD(ci, 1, rspq->depth);
655 		src = (u8 *)rspq->addr.kva;
656 		src += (ci * BFI_MSGQ_RSP_ENTRY_SIZE);
657 	}
658 }
659