1 /*
2  * Linux network driver for QLogic BR-series Converged Network Adapter.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License (GPL) Version 2 as
6  * published by the Free Software Foundation
7  *
8  * This program is distributed in the hope that it will be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  */
13 /*
14  * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
15  * Copyright (c) 2014-2015 QLogic Corporation
16  * All rights reserved
17  * www.qlogic.com
18  */
19 #include "bna.h"
20 
21 static inline int
22 ethport_can_be_up(struct bna_ethport *ethport)
23 {
24 	int ready = 0;
25 	if (ethport->bna->enet.type == BNA_ENET_T_REGULAR)
26 		ready = ((ethport->flags & BNA_ETHPORT_F_ADMIN_UP) &&
27 			 (ethport->flags & BNA_ETHPORT_F_RX_STARTED) &&
28 			 (ethport->flags & BNA_ETHPORT_F_PORT_ENABLED));
29 	else
30 		ready = ((ethport->flags & BNA_ETHPORT_F_ADMIN_UP) &&
31 			 (ethport->flags & BNA_ETHPORT_F_RX_STARTED) &&
32 			 !(ethport->flags & BNA_ETHPORT_F_PORT_ENABLED));
33 	return ready;
34 }
35 
36 #define ethport_is_up ethport_can_be_up
37 
38 enum bna_ethport_event {
39 	ETHPORT_E_START			= 1,
40 	ETHPORT_E_STOP			= 2,
41 	ETHPORT_E_FAIL			= 3,
42 	ETHPORT_E_UP			= 4,
43 	ETHPORT_E_DOWN			= 5,
44 	ETHPORT_E_FWRESP_UP_OK		= 6,
45 	ETHPORT_E_FWRESP_DOWN		= 7,
46 	ETHPORT_E_FWRESP_UP_FAIL	= 8,
47 };
48 
49 enum bna_enet_event {
50 	ENET_E_START			= 1,
51 	ENET_E_STOP			= 2,
52 	ENET_E_FAIL			= 3,
53 	ENET_E_PAUSE_CFG		= 4,
54 	ENET_E_MTU_CFG			= 5,
55 	ENET_E_FWRESP_PAUSE		= 6,
56 	ENET_E_CHLD_STOPPED		= 7,
57 };
58 
59 enum bna_ioceth_event {
60 	IOCETH_E_ENABLE			= 1,
61 	IOCETH_E_DISABLE		= 2,
62 	IOCETH_E_IOC_RESET		= 3,
63 	IOCETH_E_IOC_FAILED		= 4,
64 	IOCETH_E_IOC_READY		= 5,
65 	IOCETH_E_ENET_ATTR_RESP		= 6,
66 	IOCETH_E_ENET_STOPPED		= 7,
67 	IOCETH_E_IOC_DISABLED		= 8,
68 };
69 
70 #define bna_stats_copy(_name, _type)					\
71 do {									\
72 	count = sizeof(struct bfi_enet_stats_ ## _type) / sizeof(u64);	\
73 	stats_src = (u64 *)&bna->stats.hw_stats_kva->_name ## _stats;	\
74 	stats_dst = (u64 *)&bna->stats.hw_stats._name ## _stats;	\
75 	for (i = 0; i < count; i++)					\
76 		stats_dst[i] = be64_to_cpu(stats_src[i]);		\
77 } while (0)								\
78 
79 /*
80  * FW response handlers
81  */
82 
83 static void
84 bna_bfi_ethport_enable_aen(struct bna_ethport *ethport,
85 				struct bfi_msgq_mhdr *msghdr)
86 {
87 	ethport->flags |= BNA_ETHPORT_F_PORT_ENABLED;
88 
89 	if (ethport_can_be_up(ethport))
90 		bfa_fsm_send_event(ethport, ETHPORT_E_UP);
91 }
92 
93 static void
94 bna_bfi_ethport_disable_aen(struct bna_ethport *ethport,
95 				struct bfi_msgq_mhdr *msghdr)
96 {
97 	int ethport_up = ethport_is_up(ethport);
98 
99 	ethport->flags &= ~BNA_ETHPORT_F_PORT_ENABLED;
100 
101 	if (ethport_up)
102 		bfa_fsm_send_event(ethport, ETHPORT_E_DOWN);
103 }
104 
105 static void
106 bna_bfi_ethport_admin_rsp(struct bna_ethport *ethport,
107 				struct bfi_msgq_mhdr *msghdr)
108 {
109 	struct bfi_enet_enable_req *admin_req =
110 		&ethport->bfi_enet_cmd.admin_req;
111 	struct bfi_enet_rsp *rsp =
112 		container_of(msghdr, struct bfi_enet_rsp, mh);
113 
114 	switch (admin_req->enable) {
115 	case BNA_STATUS_T_ENABLED:
116 		if (rsp->error == BFI_ENET_CMD_OK)
117 			bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_UP_OK);
118 		else {
119 			ethport->flags &= ~BNA_ETHPORT_F_PORT_ENABLED;
120 			bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_UP_FAIL);
121 		}
122 		break;
123 
124 	case BNA_STATUS_T_DISABLED:
125 		bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_DOWN);
126 		ethport->link_status = BNA_LINK_DOWN;
127 		ethport->link_cbfn(ethport->bna->bnad, BNA_LINK_DOWN);
128 		break;
129 	}
130 }
131 
132 static void
133 bna_bfi_ethport_lpbk_rsp(struct bna_ethport *ethport,
134 				struct bfi_msgq_mhdr *msghdr)
135 {
136 	struct bfi_enet_diag_lb_req *diag_lb_req =
137 		&ethport->bfi_enet_cmd.lpbk_req;
138 	struct bfi_enet_rsp *rsp =
139 		container_of(msghdr, struct bfi_enet_rsp, mh);
140 
141 	switch (diag_lb_req->enable) {
142 	case BNA_STATUS_T_ENABLED:
143 		if (rsp->error == BFI_ENET_CMD_OK)
144 			bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_UP_OK);
145 		else {
146 			ethport->flags &= ~BNA_ETHPORT_F_ADMIN_UP;
147 			bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_UP_FAIL);
148 		}
149 		break;
150 
151 	case BNA_STATUS_T_DISABLED:
152 		bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_DOWN);
153 		break;
154 	}
155 }
156 
157 static void
158 bna_bfi_pause_set_rsp(struct bna_enet *enet, struct bfi_msgq_mhdr *msghdr)
159 {
160 	bfa_fsm_send_event(enet, ENET_E_FWRESP_PAUSE);
161 }
162 
163 static void
164 bna_bfi_attr_get_rsp(struct bna_ioceth *ioceth,
165 			struct bfi_msgq_mhdr *msghdr)
166 {
167 	struct bfi_enet_attr_rsp *rsp =
168 		container_of(msghdr, struct bfi_enet_attr_rsp, mh);
169 
170 	/**
171 	 * Store only if not set earlier, since BNAD can override the HW
172 	 * attributes
173 	 */
174 	if (!ioceth->attr.fw_query_complete) {
175 		ioceth->attr.num_txq = ntohl(rsp->max_cfg);
176 		ioceth->attr.num_rxp = ntohl(rsp->max_cfg);
177 		ioceth->attr.num_ucmac = ntohl(rsp->max_ucmac);
178 		ioceth->attr.num_mcmac = BFI_ENET_MAX_MCAM;
179 		ioceth->attr.max_rit_size = ntohl(rsp->rit_size);
180 		ioceth->attr.fw_query_complete = true;
181 	}
182 
183 	bfa_fsm_send_event(ioceth, IOCETH_E_ENET_ATTR_RESP);
184 }
185 
186 static void
187 bna_bfi_stats_get_rsp(struct bna *bna, struct bfi_msgq_mhdr *msghdr)
188 {
189 	struct bfi_enet_stats_req *stats_req = &bna->stats_mod.stats_get;
190 	u64 *stats_src;
191 	u64 *stats_dst;
192 	u32 tx_enet_mask = ntohl(stats_req->tx_enet_mask);
193 	u32 rx_enet_mask = ntohl(stats_req->rx_enet_mask);
194 	int count;
195 	int i;
196 
197 	bna_stats_copy(mac, mac);
198 	bna_stats_copy(bpc, bpc);
199 	bna_stats_copy(rad, rad);
200 	bna_stats_copy(rlb, rad);
201 	bna_stats_copy(fc_rx, fc_rx);
202 	bna_stats_copy(fc_tx, fc_tx);
203 
204 	stats_src = (u64 *)&(bna->stats.hw_stats_kva->rxf_stats[0]);
205 
206 	/* Copy Rxf stats to SW area, scatter them while copying */
207 	for (i = 0; i < BFI_ENET_CFG_MAX; i++) {
208 		stats_dst = (u64 *)&(bna->stats.hw_stats.rxf_stats[i]);
209 		memset(stats_dst, 0, sizeof(struct bfi_enet_stats_rxf));
210 		if (rx_enet_mask & BIT(i)) {
211 			int k;
212 			count = sizeof(struct bfi_enet_stats_rxf) /
213 				sizeof(u64);
214 			for (k = 0; k < count; k++) {
215 				stats_dst[k] = be64_to_cpu(*stats_src);
216 				stats_src++;
217 			}
218 		}
219 	}
220 
221 	/* Copy Txf stats to SW area, scatter them while copying */
222 	for (i = 0; i < BFI_ENET_CFG_MAX; i++) {
223 		stats_dst = (u64 *)&(bna->stats.hw_stats.txf_stats[i]);
224 		memset(stats_dst, 0, sizeof(struct bfi_enet_stats_txf));
225 		if (tx_enet_mask & BIT(i)) {
226 			int k;
227 			count = sizeof(struct bfi_enet_stats_txf) /
228 				sizeof(u64);
229 			for (k = 0; k < count; k++) {
230 				stats_dst[k] = be64_to_cpu(*stats_src);
231 				stats_src++;
232 			}
233 		}
234 	}
235 
236 	bna->stats_mod.stats_get_busy = false;
237 	bnad_cb_stats_get(bna->bnad, BNA_CB_SUCCESS, &bna->stats);
238 }
239 
240 static void
241 bna_bfi_ethport_linkup_aen(struct bna_ethport *ethport,
242 			struct bfi_msgq_mhdr *msghdr)
243 {
244 	ethport->link_status = BNA_LINK_UP;
245 
246 	/* Dispatch events */
247 	ethport->link_cbfn(ethport->bna->bnad, ethport->link_status);
248 }
249 
250 static void
251 bna_bfi_ethport_linkdown_aen(struct bna_ethport *ethport,
252 				struct bfi_msgq_mhdr *msghdr)
253 {
254 	ethport->link_status = BNA_LINK_DOWN;
255 
256 	/* Dispatch events */
257 	ethport->link_cbfn(ethport->bna->bnad, BNA_LINK_DOWN);
258 }
259 
260 static void
261 bna_err_handler(struct bna *bna, u32 intr_status)
262 {
263 	if (BNA_IS_HALT_INTR(bna, intr_status))
264 		bna_halt_clear(bna);
265 
266 	bfa_nw_ioc_error_isr(&bna->ioceth.ioc);
267 }
268 
269 void
270 bna_mbox_handler(struct bna *bna, u32 intr_status)
271 {
272 	if (BNA_IS_ERR_INTR(bna, intr_status)) {
273 		bna_err_handler(bna, intr_status);
274 		return;
275 	}
276 	if (BNA_IS_MBOX_INTR(bna, intr_status))
277 		bfa_nw_ioc_mbox_isr(&bna->ioceth.ioc);
278 }
279 
280 static void
281 bna_msgq_rsp_handler(void *arg, struct bfi_msgq_mhdr *msghdr)
282 {
283 	struct bna *bna = (struct bna *)arg;
284 	struct bna_tx *tx;
285 	struct bna_rx *rx;
286 
287 	switch (msghdr->msg_id) {
288 	case BFI_ENET_I2H_RX_CFG_SET_RSP:
289 		bna_rx_from_rid(bna, msghdr->enet_id, rx);
290 		if (rx)
291 			bna_bfi_rx_enet_start_rsp(rx, msghdr);
292 		break;
293 
294 	case BFI_ENET_I2H_RX_CFG_CLR_RSP:
295 		bna_rx_from_rid(bna, msghdr->enet_id, rx);
296 		if (rx)
297 			bna_bfi_rx_enet_stop_rsp(rx, msghdr);
298 		break;
299 
300 	case BFI_ENET_I2H_RIT_CFG_RSP:
301 	case BFI_ENET_I2H_RSS_CFG_RSP:
302 	case BFI_ENET_I2H_RSS_ENABLE_RSP:
303 	case BFI_ENET_I2H_RX_PROMISCUOUS_RSP:
304 	case BFI_ENET_I2H_RX_DEFAULT_RSP:
305 	case BFI_ENET_I2H_MAC_UCAST_CLR_RSP:
306 	case BFI_ENET_I2H_MAC_UCAST_ADD_RSP:
307 	case BFI_ENET_I2H_MAC_UCAST_DEL_RSP:
308 	case BFI_ENET_I2H_MAC_MCAST_DEL_RSP:
309 	case BFI_ENET_I2H_MAC_MCAST_FILTER_RSP:
310 	case BFI_ENET_I2H_RX_VLAN_SET_RSP:
311 	case BFI_ENET_I2H_RX_VLAN_STRIP_ENABLE_RSP:
312 		bna_rx_from_rid(bna, msghdr->enet_id, rx);
313 		if (rx)
314 			bna_bfi_rxf_cfg_rsp(&rx->rxf, msghdr);
315 		break;
316 
317 	case BFI_ENET_I2H_MAC_UCAST_SET_RSP:
318 		bna_rx_from_rid(bna, msghdr->enet_id, rx);
319 		if (rx)
320 			bna_bfi_rxf_ucast_set_rsp(&rx->rxf, msghdr);
321 		break;
322 
323 	case BFI_ENET_I2H_MAC_MCAST_ADD_RSP:
324 		bna_rx_from_rid(bna, msghdr->enet_id, rx);
325 		if (rx)
326 			bna_bfi_rxf_mcast_add_rsp(&rx->rxf, msghdr);
327 		break;
328 
329 	case BFI_ENET_I2H_TX_CFG_SET_RSP:
330 		bna_tx_from_rid(bna, msghdr->enet_id, tx);
331 		if (tx)
332 			bna_bfi_tx_enet_start_rsp(tx, msghdr);
333 		break;
334 
335 	case BFI_ENET_I2H_TX_CFG_CLR_RSP:
336 		bna_tx_from_rid(bna, msghdr->enet_id, tx);
337 		if (tx)
338 			bna_bfi_tx_enet_stop_rsp(tx, msghdr);
339 		break;
340 
341 	case BFI_ENET_I2H_PORT_ADMIN_RSP:
342 		bna_bfi_ethport_admin_rsp(&bna->ethport, msghdr);
343 		break;
344 
345 	case BFI_ENET_I2H_DIAG_LOOPBACK_RSP:
346 		bna_bfi_ethport_lpbk_rsp(&bna->ethport, msghdr);
347 		break;
348 
349 	case BFI_ENET_I2H_SET_PAUSE_RSP:
350 		bna_bfi_pause_set_rsp(&bna->enet, msghdr);
351 		break;
352 
353 	case BFI_ENET_I2H_GET_ATTR_RSP:
354 		bna_bfi_attr_get_rsp(&bna->ioceth, msghdr);
355 		break;
356 
357 	case BFI_ENET_I2H_STATS_GET_RSP:
358 		bna_bfi_stats_get_rsp(bna, msghdr);
359 		break;
360 
361 	case BFI_ENET_I2H_STATS_CLR_RSP:
362 		/* No-op */
363 		break;
364 
365 	case BFI_ENET_I2H_LINK_UP_AEN:
366 		bna_bfi_ethport_linkup_aen(&bna->ethport, msghdr);
367 		break;
368 
369 	case BFI_ENET_I2H_LINK_DOWN_AEN:
370 		bna_bfi_ethport_linkdown_aen(&bna->ethport, msghdr);
371 		break;
372 
373 	case BFI_ENET_I2H_PORT_ENABLE_AEN:
374 		bna_bfi_ethport_enable_aen(&bna->ethport, msghdr);
375 		break;
376 
377 	case BFI_ENET_I2H_PORT_DISABLE_AEN:
378 		bna_bfi_ethport_disable_aen(&bna->ethport, msghdr);
379 		break;
380 
381 	case BFI_ENET_I2H_BW_UPDATE_AEN:
382 		bna_bfi_bw_update_aen(&bna->tx_mod);
383 		break;
384 
385 	default:
386 		break;
387 	}
388 }
389 
390 /* ETHPORT */
391 
392 #define call_ethport_stop_cbfn(_ethport)				\
393 do {									\
394 	if ((_ethport)->stop_cbfn) {					\
395 		void (*cbfn)(struct bna_enet *);			\
396 		cbfn = (_ethport)->stop_cbfn;				\
397 		(_ethport)->stop_cbfn = NULL;				\
398 		cbfn(&(_ethport)->bna->enet);				\
399 	}								\
400 } while (0)
401 
402 #define call_ethport_adminup_cbfn(ethport, status)			\
403 do {									\
404 	if ((ethport)->adminup_cbfn) {					\
405 		void (*cbfn)(struct bnad *, enum bna_cb_status);	\
406 		cbfn = (ethport)->adminup_cbfn;				\
407 		(ethport)->adminup_cbfn = NULL;				\
408 		cbfn((ethport)->bna->bnad, status);			\
409 	}								\
410 } while (0)
411 
412 static void
413 bna_bfi_ethport_admin_up(struct bna_ethport *ethport)
414 {
415 	struct bfi_enet_enable_req *admin_up_req =
416 		&ethport->bfi_enet_cmd.admin_req;
417 
418 	bfi_msgq_mhdr_set(admin_up_req->mh, BFI_MC_ENET,
419 		BFI_ENET_H2I_PORT_ADMIN_UP_REQ, 0, 0);
420 	admin_up_req->mh.num_entries = htons(
421 		bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_enable_req)));
422 	admin_up_req->enable = BNA_STATUS_T_ENABLED;
423 
424 	bfa_msgq_cmd_set(&ethport->msgq_cmd, NULL, NULL,
425 		sizeof(struct bfi_enet_enable_req), &admin_up_req->mh);
426 	bfa_msgq_cmd_post(&ethport->bna->msgq, &ethport->msgq_cmd);
427 }
428 
429 static void
430 bna_bfi_ethport_admin_down(struct bna_ethport *ethport)
431 {
432 	struct bfi_enet_enable_req *admin_down_req =
433 		&ethport->bfi_enet_cmd.admin_req;
434 
435 	bfi_msgq_mhdr_set(admin_down_req->mh, BFI_MC_ENET,
436 		BFI_ENET_H2I_PORT_ADMIN_UP_REQ, 0, 0);
437 	admin_down_req->mh.num_entries = htons(
438 		bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_enable_req)));
439 	admin_down_req->enable = BNA_STATUS_T_DISABLED;
440 
441 	bfa_msgq_cmd_set(&ethport->msgq_cmd, NULL, NULL,
442 		sizeof(struct bfi_enet_enable_req), &admin_down_req->mh);
443 	bfa_msgq_cmd_post(&ethport->bna->msgq, &ethport->msgq_cmd);
444 }
445 
446 static void
447 bna_bfi_ethport_lpbk_up(struct bna_ethport *ethport)
448 {
449 	struct bfi_enet_diag_lb_req *lpbk_up_req =
450 		&ethport->bfi_enet_cmd.lpbk_req;
451 
452 	bfi_msgq_mhdr_set(lpbk_up_req->mh, BFI_MC_ENET,
453 		BFI_ENET_H2I_DIAG_LOOPBACK_REQ, 0, 0);
454 	lpbk_up_req->mh.num_entries = htons(
455 		bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_diag_lb_req)));
456 	lpbk_up_req->mode = (ethport->bna->enet.type ==
457 				BNA_ENET_T_LOOPBACK_INTERNAL) ?
458 				BFI_ENET_DIAG_LB_OPMODE_EXT :
459 				BFI_ENET_DIAG_LB_OPMODE_CBL;
460 	lpbk_up_req->enable = BNA_STATUS_T_ENABLED;
461 
462 	bfa_msgq_cmd_set(&ethport->msgq_cmd, NULL, NULL,
463 		sizeof(struct bfi_enet_diag_lb_req), &lpbk_up_req->mh);
464 	bfa_msgq_cmd_post(&ethport->bna->msgq, &ethport->msgq_cmd);
465 }
466 
467 static void
468 bna_bfi_ethport_lpbk_down(struct bna_ethport *ethport)
469 {
470 	struct bfi_enet_diag_lb_req *lpbk_down_req =
471 		&ethport->bfi_enet_cmd.lpbk_req;
472 
473 	bfi_msgq_mhdr_set(lpbk_down_req->mh, BFI_MC_ENET,
474 		BFI_ENET_H2I_DIAG_LOOPBACK_REQ, 0, 0);
475 	lpbk_down_req->mh.num_entries = htons(
476 		bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_diag_lb_req)));
477 	lpbk_down_req->enable = BNA_STATUS_T_DISABLED;
478 
479 	bfa_msgq_cmd_set(&ethport->msgq_cmd, NULL, NULL,
480 		sizeof(struct bfi_enet_diag_lb_req), &lpbk_down_req->mh);
481 	bfa_msgq_cmd_post(&ethport->bna->msgq, &ethport->msgq_cmd);
482 }
483 
484 static void
485 bna_bfi_ethport_up(struct bna_ethport *ethport)
486 {
487 	if (ethport->bna->enet.type == BNA_ENET_T_REGULAR)
488 		bna_bfi_ethport_admin_up(ethport);
489 	else
490 		bna_bfi_ethport_lpbk_up(ethport);
491 }
492 
493 static void
494 bna_bfi_ethport_down(struct bna_ethport *ethport)
495 {
496 	if (ethport->bna->enet.type == BNA_ENET_T_REGULAR)
497 		bna_bfi_ethport_admin_down(ethport);
498 	else
499 		bna_bfi_ethport_lpbk_down(ethport);
500 }
501 
502 bfa_fsm_state_decl(bna_ethport, stopped, struct bna_ethport,
503 			enum bna_ethport_event);
504 bfa_fsm_state_decl(bna_ethport, down, struct bna_ethport,
505 			enum bna_ethport_event);
506 bfa_fsm_state_decl(bna_ethport, up_resp_wait, struct bna_ethport,
507 			enum bna_ethport_event);
508 bfa_fsm_state_decl(bna_ethport, down_resp_wait, struct bna_ethport,
509 			enum bna_ethport_event);
510 bfa_fsm_state_decl(bna_ethport, up, struct bna_ethport,
511 			enum bna_ethport_event);
512 bfa_fsm_state_decl(bna_ethport, last_resp_wait, struct bna_ethport,
513 			enum bna_ethport_event);
514 
515 static void
516 bna_ethport_sm_stopped_entry(struct bna_ethport *ethport)
517 {
518 	call_ethport_stop_cbfn(ethport);
519 }
520 
521 static void
522 bna_ethport_sm_stopped(struct bna_ethport *ethport,
523 			enum bna_ethport_event event)
524 {
525 	switch (event) {
526 	case ETHPORT_E_START:
527 		bfa_fsm_set_state(ethport, bna_ethport_sm_down);
528 		break;
529 
530 	case ETHPORT_E_STOP:
531 		call_ethport_stop_cbfn(ethport);
532 		break;
533 
534 	case ETHPORT_E_FAIL:
535 		/* No-op */
536 		break;
537 
538 	case ETHPORT_E_DOWN:
539 		/* This event is received due to Rx objects failing */
540 		/* No-op */
541 		break;
542 
543 	default:
544 		bfa_sm_fault(event);
545 	}
546 }
547 
548 static void
549 bna_ethport_sm_down_entry(struct bna_ethport *ethport)
550 {
551 }
552 
553 static void
554 bna_ethport_sm_down(struct bna_ethport *ethport,
555 			enum bna_ethport_event event)
556 {
557 	switch (event) {
558 	case ETHPORT_E_STOP:
559 		bfa_fsm_set_state(ethport, bna_ethport_sm_stopped);
560 		break;
561 
562 	case ETHPORT_E_FAIL:
563 		bfa_fsm_set_state(ethport, bna_ethport_sm_stopped);
564 		break;
565 
566 	case ETHPORT_E_UP:
567 		bfa_fsm_set_state(ethport, bna_ethport_sm_up_resp_wait);
568 		bna_bfi_ethport_up(ethport);
569 		break;
570 
571 	default:
572 		bfa_sm_fault(event);
573 	}
574 }
575 
576 static void
577 bna_ethport_sm_up_resp_wait_entry(struct bna_ethport *ethport)
578 {
579 }
580 
581 static void
582 bna_ethport_sm_up_resp_wait(struct bna_ethport *ethport,
583 			enum bna_ethport_event event)
584 {
585 	switch (event) {
586 	case ETHPORT_E_STOP:
587 		bfa_fsm_set_state(ethport, bna_ethport_sm_last_resp_wait);
588 		break;
589 
590 	case ETHPORT_E_FAIL:
591 		call_ethport_adminup_cbfn(ethport, BNA_CB_FAIL);
592 		bfa_fsm_set_state(ethport, bna_ethport_sm_stopped);
593 		break;
594 
595 	case ETHPORT_E_DOWN:
596 		call_ethport_adminup_cbfn(ethport, BNA_CB_INTERRUPT);
597 		bfa_fsm_set_state(ethport, bna_ethport_sm_down_resp_wait);
598 		break;
599 
600 	case ETHPORT_E_FWRESP_UP_OK:
601 		call_ethport_adminup_cbfn(ethport, BNA_CB_SUCCESS);
602 		bfa_fsm_set_state(ethport, bna_ethport_sm_up);
603 		break;
604 
605 	case ETHPORT_E_FWRESP_UP_FAIL:
606 		call_ethport_adminup_cbfn(ethport, BNA_CB_FAIL);
607 		bfa_fsm_set_state(ethport, bna_ethport_sm_down);
608 		break;
609 
610 	case ETHPORT_E_FWRESP_DOWN:
611 		/* down_resp_wait -> up_resp_wait transition on ETHPORT_E_UP */
612 		bna_bfi_ethport_up(ethport);
613 		break;
614 
615 	default:
616 		bfa_sm_fault(event);
617 	}
618 }
619 
620 static void
621 bna_ethport_sm_down_resp_wait_entry(struct bna_ethport *ethport)
622 {
623 	/**
624 	 * NOTE: Do not call bna_bfi_ethport_down() here. That will over step
625 	 * mbox due to up_resp_wait -> down_resp_wait transition on event
626 	 * ETHPORT_E_DOWN
627 	 */
628 }
629 
630 static void
631 bna_ethport_sm_down_resp_wait(struct bna_ethport *ethport,
632 			enum bna_ethport_event event)
633 {
634 	switch (event) {
635 	case ETHPORT_E_STOP:
636 		bfa_fsm_set_state(ethport, bna_ethport_sm_last_resp_wait);
637 		break;
638 
639 	case ETHPORT_E_FAIL:
640 		bfa_fsm_set_state(ethport, bna_ethport_sm_stopped);
641 		break;
642 
643 	case ETHPORT_E_UP:
644 		bfa_fsm_set_state(ethport, bna_ethport_sm_up_resp_wait);
645 		break;
646 
647 	case ETHPORT_E_FWRESP_UP_OK:
648 		/* up_resp_wait->down_resp_wait transition on ETHPORT_E_DOWN */
649 		bna_bfi_ethport_down(ethport);
650 		break;
651 
652 	case ETHPORT_E_FWRESP_UP_FAIL:
653 	case ETHPORT_E_FWRESP_DOWN:
654 		bfa_fsm_set_state(ethport, bna_ethport_sm_down);
655 		break;
656 
657 	default:
658 		bfa_sm_fault(event);
659 	}
660 }
661 
662 static void
663 bna_ethport_sm_up_entry(struct bna_ethport *ethport)
664 {
665 }
666 
667 static void
668 bna_ethport_sm_up(struct bna_ethport *ethport,
669 			enum bna_ethport_event event)
670 {
671 	switch (event) {
672 	case ETHPORT_E_STOP:
673 		bfa_fsm_set_state(ethport, bna_ethport_sm_last_resp_wait);
674 		bna_bfi_ethport_down(ethport);
675 		break;
676 
677 	case ETHPORT_E_FAIL:
678 		bfa_fsm_set_state(ethport, bna_ethport_sm_stopped);
679 		break;
680 
681 	case ETHPORT_E_DOWN:
682 		bfa_fsm_set_state(ethport, bna_ethport_sm_down_resp_wait);
683 		bna_bfi_ethport_down(ethport);
684 		break;
685 
686 	default:
687 		bfa_sm_fault(event);
688 	}
689 }
690 
691 static void
692 bna_ethport_sm_last_resp_wait_entry(struct bna_ethport *ethport)
693 {
694 }
695 
696 static void
697 bna_ethport_sm_last_resp_wait(struct bna_ethport *ethport,
698 			enum bna_ethport_event event)
699 {
700 	switch (event) {
701 	case ETHPORT_E_FAIL:
702 		bfa_fsm_set_state(ethport, bna_ethport_sm_stopped);
703 		break;
704 
705 	case ETHPORT_E_DOWN:
706 		/**
707 		 * This event is received due to Rx objects stopping in
708 		 * parallel to ethport
709 		 */
710 		/* No-op */
711 		break;
712 
713 	case ETHPORT_E_FWRESP_UP_OK:
714 		/* up_resp_wait->last_resp_wait transition on ETHPORT_T_STOP */
715 		bna_bfi_ethport_down(ethport);
716 		break;
717 
718 	case ETHPORT_E_FWRESP_UP_FAIL:
719 	case ETHPORT_E_FWRESP_DOWN:
720 		bfa_fsm_set_state(ethport, bna_ethport_sm_stopped);
721 		break;
722 
723 	default:
724 		bfa_sm_fault(event);
725 	}
726 }
727 
728 static void
729 bna_ethport_init(struct bna_ethport *ethport, struct bna *bna)
730 {
731 	ethport->flags |= (BNA_ETHPORT_F_ADMIN_UP | BNA_ETHPORT_F_PORT_ENABLED);
732 	ethport->bna = bna;
733 
734 	ethport->link_status = BNA_LINK_DOWN;
735 	ethport->link_cbfn = bnad_cb_ethport_link_status;
736 
737 	ethport->rx_started_count = 0;
738 
739 	ethport->stop_cbfn = NULL;
740 	ethport->adminup_cbfn = NULL;
741 
742 	bfa_fsm_set_state(ethport, bna_ethport_sm_stopped);
743 }
744 
745 static void
746 bna_ethport_uninit(struct bna_ethport *ethport)
747 {
748 	ethport->flags &= ~BNA_ETHPORT_F_ADMIN_UP;
749 	ethport->flags &= ~BNA_ETHPORT_F_PORT_ENABLED;
750 
751 	ethport->bna = NULL;
752 }
753 
754 static void
755 bna_ethport_start(struct bna_ethport *ethport)
756 {
757 	bfa_fsm_send_event(ethport, ETHPORT_E_START);
758 }
759 
760 static void
761 bna_enet_cb_ethport_stopped(struct bna_enet *enet)
762 {
763 	bfa_wc_down(&enet->chld_stop_wc);
764 }
765 
766 static void
767 bna_ethport_stop(struct bna_ethport *ethport)
768 {
769 	ethport->stop_cbfn = bna_enet_cb_ethport_stopped;
770 	bfa_fsm_send_event(ethport, ETHPORT_E_STOP);
771 }
772 
773 static void
774 bna_ethport_fail(struct bna_ethport *ethport)
775 {
776 	/* Reset the physical port status to enabled */
777 	ethport->flags |= BNA_ETHPORT_F_PORT_ENABLED;
778 
779 	if (ethport->link_status != BNA_LINK_DOWN) {
780 		ethport->link_status = BNA_LINK_DOWN;
781 		ethport->link_cbfn(ethport->bna->bnad, BNA_LINK_DOWN);
782 	}
783 	bfa_fsm_send_event(ethport, ETHPORT_E_FAIL);
784 }
785 
786 /* Should be called only when ethport is disabled */
787 void
788 bna_ethport_cb_rx_started(struct bna_ethport *ethport)
789 {
790 	ethport->rx_started_count++;
791 
792 	if (ethport->rx_started_count == 1) {
793 		ethport->flags |= BNA_ETHPORT_F_RX_STARTED;
794 
795 		if (ethport_can_be_up(ethport))
796 			bfa_fsm_send_event(ethport, ETHPORT_E_UP);
797 	}
798 }
799 
800 void
801 bna_ethport_cb_rx_stopped(struct bna_ethport *ethport)
802 {
803 	int ethport_up = ethport_is_up(ethport);
804 
805 	ethport->rx_started_count--;
806 
807 	if (ethport->rx_started_count == 0) {
808 		ethport->flags &= ~BNA_ETHPORT_F_RX_STARTED;
809 
810 		if (ethport_up)
811 			bfa_fsm_send_event(ethport, ETHPORT_E_DOWN);
812 	}
813 }
814 
815 /* ENET */
816 
817 #define bna_enet_chld_start(enet)					\
818 do {									\
819 	enum bna_tx_type tx_type =					\
820 		((enet)->type == BNA_ENET_T_REGULAR) ?			\
821 		BNA_TX_T_REGULAR : BNA_TX_T_LOOPBACK;			\
822 	enum bna_rx_type rx_type =					\
823 		((enet)->type == BNA_ENET_T_REGULAR) ?			\
824 		BNA_RX_T_REGULAR : BNA_RX_T_LOOPBACK;			\
825 	bna_ethport_start(&(enet)->bna->ethport);			\
826 	bna_tx_mod_start(&(enet)->bna->tx_mod, tx_type);		\
827 	bna_rx_mod_start(&(enet)->bna->rx_mod, rx_type);		\
828 } while (0)
829 
830 #define bna_enet_chld_stop(enet)					\
831 do {									\
832 	enum bna_tx_type tx_type =					\
833 		((enet)->type == BNA_ENET_T_REGULAR) ?			\
834 		BNA_TX_T_REGULAR : BNA_TX_T_LOOPBACK;			\
835 	enum bna_rx_type rx_type =					\
836 		((enet)->type == BNA_ENET_T_REGULAR) ?			\
837 		BNA_RX_T_REGULAR : BNA_RX_T_LOOPBACK;			\
838 	bfa_wc_init(&(enet)->chld_stop_wc, bna_enet_cb_chld_stopped, (enet));\
839 	bfa_wc_up(&(enet)->chld_stop_wc);				\
840 	bna_ethport_stop(&(enet)->bna->ethport);			\
841 	bfa_wc_up(&(enet)->chld_stop_wc);				\
842 	bna_tx_mod_stop(&(enet)->bna->tx_mod, tx_type);			\
843 	bfa_wc_up(&(enet)->chld_stop_wc);				\
844 	bna_rx_mod_stop(&(enet)->bna->rx_mod, rx_type);			\
845 	bfa_wc_wait(&(enet)->chld_stop_wc);				\
846 } while (0)
847 
848 #define bna_enet_chld_fail(enet)					\
849 do {									\
850 	bna_ethport_fail(&(enet)->bna->ethport);			\
851 	bna_tx_mod_fail(&(enet)->bna->tx_mod);				\
852 	bna_rx_mod_fail(&(enet)->bna->rx_mod);				\
853 } while (0)
854 
855 #define bna_enet_rx_start(enet)						\
856 do {									\
857 	enum bna_rx_type rx_type =					\
858 		((enet)->type == BNA_ENET_T_REGULAR) ?			\
859 		BNA_RX_T_REGULAR : BNA_RX_T_LOOPBACK;			\
860 	bna_rx_mod_start(&(enet)->bna->rx_mod, rx_type);		\
861 } while (0)
862 
863 #define bna_enet_rx_stop(enet)						\
864 do {									\
865 	enum bna_rx_type rx_type =					\
866 		((enet)->type == BNA_ENET_T_REGULAR) ?			\
867 		BNA_RX_T_REGULAR : BNA_RX_T_LOOPBACK;			\
868 	bfa_wc_init(&(enet)->chld_stop_wc, bna_enet_cb_chld_stopped, (enet));\
869 	bfa_wc_up(&(enet)->chld_stop_wc);				\
870 	bna_rx_mod_stop(&(enet)->bna->rx_mod, rx_type);			\
871 	bfa_wc_wait(&(enet)->chld_stop_wc);				\
872 } while (0)
873 
874 #define call_enet_stop_cbfn(enet)					\
875 do {									\
876 	if ((enet)->stop_cbfn) {					\
877 		void (*cbfn)(void *);					\
878 		void *cbarg;						\
879 		cbfn = (enet)->stop_cbfn;				\
880 		cbarg = (enet)->stop_cbarg;				\
881 		(enet)->stop_cbfn = NULL;				\
882 		(enet)->stop_cbarg = NULL;				\
883 		cbfn(cbarg);						\
884 	}								\
885 } while (0)
886 
887 #define call_enet_mtu_cbfn(enet)					\
888 do {									\
889 	if ((enet)->mtu_cbfn) {						\
890 		void (*cbfn)(struct bnad *);				\
891 		cbfn = (enet)->mtu_cbfn;				\
892 		(enet)->mtu_cbfn = NULL;				\
893 		cbfn((enet)->bna->bnad);				\
894 	}								\
895 } while (0)
896 
897 static void bna_enet_cb_chld_stopped(void *arg);
898 static void bna_bfi_pause_set(struct bna_enet *enet);
899 
900 bfa_fsm_state_decl(bna_enet, stopped, struct bna_enet,
901 			enum bna_enet_event);
902 bfa_fsm_state_decl(bna_enet, pause_init_wait, struct bna_enet,
903 			enum bna_enet_event);
904 bfa_fsm_state_decl(bna_enet, last_resp_wait, struct bna_enet,
905 			enum bna_enet_event);
906 bfa_fsm_state_decl(bna_enet, started, struct bna_enet,
907 			enum bna_enet_event);
908 bfa_fsm_state_decl(bna_enet, cfg_wait, struct bna_enet,
909 			enum bna_enet_event);
910 bfa_fsm_state_decl(bna_enet, cfg_stop_wait, struct bna_enet,
911 			enum bna_enet_event);
912 bfa_fsm_state_decl(bna_enet, chld_stop_wait, struct bna_enet,
913 			enum bna_enet_event);
914 
915 static void
916 bna_enet_sm_stopped_entry(struct bna_enet *enet)
917 {
918 	call_enet_mtu_cbfn(enet);
919 	call_enet_stop_cbfn(enet);
920 }
921 
922 static void
923 bna_enet_sm_stopped(struct bna_enet *enet, enum bna_enet_event event)
924 {
925 	switch (event) {
926 	case ENET_E_START:
927 		bfa_fsm_set_state(enet, bna_enet_sm_pause_init_wait);
928 		break;
929 
930 	case ENET_E_STOP:
931 		call_enet_stop_cbfn(enet);
932 		break;
933 
934 	case ENET_E_FAIL:
935 		/* No-op */
936 		break;
937 
938 	case ENET_E_PAUSE_CFG:
939 		break;
940 
941 	case ENET_E_MTU_CFG:
942 		call_enet_mtu_cbfn(enet);
943 		break;
944 
945 	case ENET_E_CHLD_STOPPED:
946 		/**
947 		 * This event is received due to Ethport, Tx and Rx objects
948 		 * failing
949 		 */
950 		/* No-op */
951 		break;
952 
953 	default:
954 		bfa_sm_fault(event);
955 	}
956 }
957 
958 static void
959 bna_enet_sm_pause_init_wait_entry(struct bna_enet *enet)
960 {
961 	bna_bfi_pause_set(enet);
962 }
963 
964 static void
965 bna_enet_sm_pause_init_wait(struct bna_enet *enet,
966 				enum bna_enet_event event)
967 {
968 	switch (event) {
969 	case ENET_E_STOP:
970 		enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED;
971 		bfa_fsm_set_state(enet, bna_enet_sm_last_resp_wait);
972 		break;
973 
974 	case ENET_E_FAIL:
975 		enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED;
976 		bfa_fsm_set_state(enet, bna_enet_sm_stopped);
977 		break;
978 
979 	case ENET_E_PAUSE_CFG:
980 		enet->flags |= BNA_ENET_F_PAUSE_CHANGED;
981 		break;
982 
983 	case ENET_E_MTU_CFG:
984 		/* No-op */
985 		break;
986 
987 	case ENET_E_FWRESP_PAUSE:
988 		if (enet->flags & BNA_ENET_F_PAUSE_CHANGED) {
989 			enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED;
990 			bna_bfi_pause_set(enet);
991 		} else {
992 			bfa_fsm_set_state(enet, bna_enet_sm_started);
993 			bna_enet_chld_start(enet);
994 		}
995 		break;
996 
997 	default:
998 		bfa_sm_fault(event);
999 	}
1000 }
1001 
1002 static void
1003 bna_enet_sm_last_resp_wait_entry(struct bna_enet *enet)
1004 {
1005 	enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED;
1006 }
1007 
1008 static void
1009 bna_enet_sm_last_resp_wait(struct bna_enet *enet,
1010 				enum bna_enet_event event)
1011 {
1012 	switch (event) {
1013 	case ENET_E_FAIL:
1014 	case ENET_E_FWRESP_PAUSE:
1015 		bfa_fsm_set_state(enet, bna_enet_sm_stopped);
1016 		break;
1017 
1018 	default:
1019 		bfa_sm_fault(event);
1020 	}
1021 }
1022 
1023 static void
1024 bna_enet_sm_started_entry(struct bna_enet *enet)
1025 {
1026 	/**
1027 	 * NOTE: Do not call bna_enet_chld_start() here, since it will be
1028 	 * inadvertently called during cfg_wait->started transition as well
1029 	 */
1030 	call_enet_mtu_cbfn(enet);
1031 }
1032 
1033 static void
1034 bna_enet_sm_started(struct bna_enet *enet,
1035 			enum bna_enet_event event)
1036 {
1037 	switch (event) {
1038 	case ENET_E_STOP:
1039 		bfa_fsm_set_state(enet, bna_enet_sm_chld_stop_wait);
1040 		break;
1041 
1042 	case ENET_E_FAIL:
1043 		bfa_fsm_set_state(enet, bna_enet_sm_stopped);
1044 		bna_enet_chld_fail(enet);
1045 		break;
1046 
1047 	case ENET_E_PAUSE_CFG:
1048 		bfa_fsm_set_state(enet, bna_enet_sm_cfg_wait);
1049 		bna_bfi_pause_set(enet);
1050 		break;
1051 
1052 	case ENET_E_MTU_CFG:
1053 		bfa_fsm_set_state(enet, bna_enet_sm_cfg_wait);
1054 		bna_enet_rx_stop(enet);
1055 		break;
1056 
1057 	default:
1058 		bfa_sm_fault(event);
1059 	}
1060 }
1061 
1062 static void
1063 bna_enet_sm_cfg_wait_entry(struct bna_enet *enet)
1064 {
1065 }
1066 
1067 static void
1068 bna_enet_sm_cfg_wait(struct bna_enet *enet,
1069 			enum bna_enet_event event)
1070 {
1071 	switch (event) {
1072 	case ENET_E_STOP:
1073 		enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED;
1074 		enet->flags &= ~BNA_ENET_F_MTU_CHANGED;
1075 		bfa_fsm_set_state(enet, bna_enet_sm_cfg_stop_wait);
1076 		break;
1077 
1078 	case ENET_E_FAIL:
1079 		enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED;
1080 		enet->flags &= ~BNA_ENET_F_MTU_CHANGED;
1081 		bfa_fsm_set_state(enet, bna_enet_sm_stopped);
1082 		bna_enet_chld_fail(enet);
1083 		break;
1084 
1085 	case ENET_E_PAUSE_CFG:
1086 		enet->flags |= BNA_ENET_F_PAUSE_CHANGED;
1087 		break;
1088 
1089 	case ENET_E_MTU_CFG:
1090 		enet->flags |= BNA_ENET_F_MTU_CHANGED;
1091 		break;
1092 
1093 	case ENET_E_CHLD_STOPPED:
1094 		bna_enet_rx_start(enet);
1095 		/* Fall through */
1096 	case ENET_E_FWRESP_PAUSE:
1097 		if (enet->flags & BNA_ENET_F_PAUSE_CHANGED) {
1098 			enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED;
1099 			bna_bfi_pause_set(enet);
1100 		} else if (enet->flags & BNA_ENET_F_MTU_CHANGED) {
1101 			enet->flags &= ~BNA_ENET_F_MTU_CHANGED;
1102 			bna_enet_rx_stop(enet);
1103 		} else {
1104 			bfa_fsm_set_state(enet, bna_enet_sm_started);
1105 		}
1106 		break;
1107 
1108 	default:
1109 		bfa_sm_fault(event);
1110 	}
1111 }
1112 
1113 static void
1114 bna_enet_sm_cfg_stop_wait_entry(struct bna_enet *enet)
1115 {
1116 	enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED;
1117 	enet->flags &= ~BNA_ENET_F_MTU_CHANGED;
1118 }
1119 
1120 static void
1121 bna_enet_sm_cfg_stop_wait(struct bna_enet *enet,
1122 				enum bna_enet_event event)
1123 {
1124 	switch (event) {
1125 	case ENET_E_FAIL:
1126 		bfa_fsm_set_state(enet, bna_enet_sm_stopped);
1127 		bna_enet_chld_fail(enet);
1128 		break;
1129 
1130 	case ENET_E_FWRESP_PAUSE:
1131 	case ENET_E_CHLD_STOPPED:
1132 		bfa_fsm_set_state(enet, bna_enet_sm_chld_stop_wait);
1133 		break;
1134 
1135 	default:
1136 		bfa_sm_fault(event);
1137 	}
1138 }
1139 
1140 static void
1141 bna_enet_sm_chld_stop_wait_entry(struct bna_enet *enet)
1142 {
1143 	bna_enet_chld_stop(enet);
1144 }
1145 
1146 static void
1147 bna_enet_sm_chld_stop_wait(struct bna_enet *enet,
1148 				enum bna_enet_event event)
1149 {
1150 	switch (event) {
1151 	case ENET_E_FAIL:
1152 		bfa_fsm_set_state(enet, bna_enet_sm_stopped);
1153 		bna_enet_chld_fail(enet);
1154 		break;
1155 
1156 	case ENET_E_CHLD_STOPPED:
1157 		bfa_fsm_set_state(enet, bna_enet_sm_stopped);
1158 		break;
1159 
1160 	default:
1161 		bfa_sm_fault(event);
1162 	}
1163 }
1164 
1165 static void
1166 bna_bfi_pause_set(struct bna_enet *enet)
1167 {
1168 	struct bfi_enet_set_pause_req *pause_req = &enet->pause_req;
1169 
1170 	bfi_msgq_mhdr_set(pause_req->mh, BFI_MC_ENET,
1171 		BFI_ENET_H2I_SET_PAUSE_REQ, 0, 0);
1172 	pause_req->mh.num_entries = htons(
1173 	bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_set_pause_req)));
1174 	pause_req->tx_pause = enet->pause_config.tx_pause;
1175 	pause_req->rx_pause = enet->pause_config.rx_pause;
1176 
1177 	bfa_msgq_cmd_set(&enet->msgq_cmd, NULL, NULL,
1178 		sizeof(struct bfi_enet_set_pause_req), &pause_req->mh);
1179 	bfa_msgq_cmd_post(&enet->bna->msgq, &enet->msgq_cmd);
1180 }
1181 
1182 static void
1183 bna_enet_cb_chld_stopped(void *arg)
1184 {
1185 	struct bna_enet *enet = (struct bna_enet *)arg;
1186 
1187 	bfa_fsm_send_event(enet, ENET_E_CHLD_STOPPED);
1188 }
1189 
1190 static void
1191 bna_enet_init(struct bna_enet *enet, struct bna *bna)
1192 {
1193 	enet->bna = bna;
1194 	enet->flags = 0;
1195 	enet->mtu = 0;
1196 	enet->type = BNA_ENET_T_REGULAR;
1197 
1198 	enet->stop_cbfn = NULL;
1199 	enet->stop_cbarg = NULL;
1200 
1201 	enet->mtu_cbfn = NULL;
1202 
1203 	bfa_fsm_set_state(enet, bna_enet_sm_stopped);
1204 }
1205 
1206 static void
1207 bna_enet_uninit(struct bna_enet *enet)
1208 {
1209 	enet->flags = 0;
1210 
1211 	enet->bna = NULL;
1212 }
1213 
1214 static void
1215 bna_enet_start(struct bna_enet *enet)
1216 {
1217 	enet->flags |= BNA_ENET_F_IOCETH_READY;
1218 	if (enet->flags & BNA_ENET_F_ENABLED)
1219 		bfa_fsm_send_event(enet, ENET_E_START);
1220 }
1221 
1222 static void
1223 bna_ioceth_cb_enet_stopped(void *arg)
1224 {
1225 	struct bna_ioceth *ioceth = (struct bna_ioceth *)arg;
1226 
1227 	bfa_fsm_send_event(ioceth, IOCETH_E_ENET_STOPPED);
1228 }
1229 
1230 static void
1231 bna_enet_stop(struct bna_enet *enet)
1232 {
1233 	enet->stop_cbfn = bna_ioceth_cb_enet_stopped;
1234 	enet->stop_cbarg = &enet->bna->ioceth;
1235 
1236 	enet->flags &= ~BNA_ENET_F_IOCETH_READY;
1237 	bfa_fsm_send_event(enet, ENET_E_STOP);
1238 }
1239 
1240 static void
1241 bna_enet_fail(struct bna_enet *enet)
1242 {
1243 	enet->flags &= ~BNA_ENET_F_IOCETH_READY;
1244 	bfa_fsm_send_event(enet, ENET_E_FAIL);
1245 }
1246 
1247 void
1248 bna_enet_cb_tx_stopped(struct bna_enet *enet)
1249 {
1250 	bfa_wc_down(&enet->chld_stop_wc);
1251 }
1252 
1253 void
1254 bna_enet_cb_rx_stopped(struct bna_enet *enet)
1255 {
1256 	bfa_wc_down(&enet->chld_stop_wc);
1257 }
1258 
1259 int
1260 bna_enet_mtu_get(struct bna_enet *enet)
1261 {
1262 	return enet->mtu;
1263 }
1264 
1265 void
1266 bna_enet_enable(struct bna_enet *enet)
1267 {
1268 	if (enet->fsm != (bfa_sm_t)bna_enet_sm_stopped)
1269 		return;
1270 
1271 	enet->flags |= BNA_ENET_F_ENABLED;
1272 
1273 	if (enet->flags & BNA_ENET_F_IOCETH_READY)
1274 		bfa_fsm_send_event(enet, ENET_E_START);
1275 }
1276 
1277 void
1278 bna_enet_disable(struct bna_enet *enet, enum bna_cleanup_type type,
1279 		 void (*cbfn)(void *))
1280 {
1281 	if (type == BNA_SOFT_CLEANUP) {
1282 		(*cbfn)(enet->bna->bnad);
1283 		return;
1284 	}
1285 
1286 	enet->stop_cbfn = cbfn;
1287 	enet->stop_cbarg = enet->bna->bnad;
1288 
1289 	enet->flags &= ~BNA_ENET_F_ENABLED;
1290 
1291 	bfa_fsm_send_event(enet, ENET_E_STOP);
1292 }
1293 
1294 void
1295 bna_enet_pause_config(struct bna_enet *enet,
1296 		      struct bna_pause_config *pause_config)
1297 {
1298 	enet->pause_config = *pause_config;
1299 
1300 	bfa_fsm_send_event(enet, ENET_E_PAUSE_CFG);
1301 }
1302 
1303 void
1304 bna_enet_mtu_set(struct bna_enet *enet, int mtu,
1305 		 void (*cbfn)(struct bnad *))
1306 {
1307 	enet->mtu = mtu;
1308 
1309 	enet->mtu_cbfn = cbfn;
1310 
1311 	bfa_fsm_send_event(enet, ENET_E_MTU_CFG);
1312 }
1313 
1314 void
1315 bna_enet_perm_mac_get(struct bna_enet *enet, u8 *mac)
1316 {
1317 	bfa_nw_ioc_get_mac(&enet->bna->ioceth.ioc, mac);
1318 }
1319 
1320 /* IOCETH */
1321 
1322 #define enable_mbox_intr(_ioceth)					\
1323 do {									\
1324 	u32 intr_status;						\
1325 	bna_intr_status_get((_ioceth)->bna, intr_status);		\
1326 	bnad_cb_mbox_intr_enable((_ioceth)->bna->bnad);			\
1327 	bna_mbox_intr_enable((_ioceth)->bna);				\
1328 } while (0)
1329 
1330 #define disable_mbox_intr(_ioceth)					\
1331 do {									\
1332 	bna_mbox_intr_disable((_ioceth)->bna);				\
1333 	bnad_cb_mbox_intr_disable((_ioceth)->bna->bnad);		\
1334 } while (0)
1335 
1336 #define call_ioceth_stop_cbfn(_ioceth)					\
1337 do {									\
1338 	if ((_ioceth)->stop_cbfn) {					\
1339 		void (*cbfn)(struct bnad *);				\
1340 		struct bnad *cbarg;					\
1341 		cbfn = (_ioceth)->stop_cbfn;				\
1342 		cbarg = (_ioceth)->stop_cbarg;				\
1343 		(_ioceth)->stop_cbfn = NULL;				\
1344 		(_ioceth)->stop_cbarg = NULL;				\
1345 		cbfn(cbarg);						\
1346 	}								\
1347 } while (0)
1348 
1349 #define bna_stats_mod_uninit(_stats_mod)				\
1350 do {									\
1351 } while (0)
1352 
1353 #define bna_stats_mod_start(_stats_mod)					\
1354 do {									\
1355 	(_stats_mod)->ioc_ready = true;					\
1356 } while (0)
1357 
1358 #define bna_stats_mod_stop(_stats_mod)					\
1359 do {									\
1360 	(_stats_mod)->ioc_ready = false;				\
1361 } while (0)
1362 
1363 #define bna_stats_mod_fail(_stats_mod)					\
1364 do {									\
1365 	(_stats_mod)->ioc_ready = false;				\
1366 	(_stats_mod)->stats_get_busy = false;				\
1367 	(_stats_mod)->stats_clr_busy = false;				\
1368 } while (0)
1369 
1370 static void bna_bfi_attr_get(struct bna_ioceth *ioceth);
1371 
1372 bfa_fsm_state_decl(bna_ioceth, stopped, struct bna_ioceth,
1373 			enum bna_ioceth_event);
1374 bfa_fsm_state_decl(bna_ioceth, ioc_ready_wait, struct bna_ioceth,
1375 			enum bna_ioceth_event);
1376 bfa_fsm_state_decl(bna_ioceth, enet_attr_wait, struct bna_ioceth,
1377 			enum bna_ioceth_event);
1378 bfa_fsm_state_decl(bna_ioceth, ready, struct bna_ioceth,
1379 			enum bna_ioceth_event);
1380 bfa_fsm_state_decl(bna_ioceth, last_resp_wait, struct bna_ioceth,
1381 			enum bna_ioceth_event);
1382 bfa_fsm_state_decl(bna_ioceth, enet_stop_wait, struct bna_ioceth,
1383 			enum bna_ioceth_event);
1384 bfa_fsm_state_decl(bna_ioceth, ioc_disable_wait, struct bna_ioceth,
1385 			enum bna_ioceth_event);
1386 bfa_fsm_state_decl(bna_ioceth, failed, struct bna_ioceth,
1387 			enum bna_ioceth_event);
1388 
1389 static void
1390 bna_ioceth_sm_stopped_entry(struct bna_ioceth *ioceth)
1391 {
1392 	call_ioceth_stop_cbfn(ioceth);
1393 }
1394 
1395 static void
1396 bna_ioceth_sm_stopped(struct bna_ioceth *ioceth,
1397 			enum bna_ioceth_event event)
1398 {
1399 	switch (event) {
1400 	case IOCETH_E_ENABLE:
1401 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_ready_wait);
1402 		bfa_nw_ioc_enable(&ioceth->ioc);
1403 		break;
1404 
1405 	case IOCETH_E_DISABLE:
1406 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_stopped);
1407 		break;
1408 
1409 	case IOCETH_E_IOC_RESET:
1410 		enable_mbox_intr(ioceth);
1411 		break;
1412 
1413 	case IOCETH_E_IOC_FAILED:
1414 		disable_mbox_intr(ioceth);
1415 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_failed);
1416 		break;
1417 
1418 	default:
1419 		bfa_sm_fault(event);
1420 	}
1421 }
1422 
1423 static void
1424 bna_ioceth_sm_ioc_ready_wait_entry(struct bna_ioceth *ioceth)
1425 {
1426 	/**
1427 	 * Do not call bfa_nw_ioc_enable() here. It must be called in the
1428 	 * previous state due to failed -> ioc_ready_wait transition.
1429 	 */
1430 }
1431 
1432 static void
1433 bna_ioceth_sm_ioc_ready_wait(struct bna_ioceth *ioceth,
1434 				enum bna_ioceth_event event)
1435 {
1436 	switch (event) {
1437 	case IOCETH_E_DISABLE:
1438 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait);
1439 		bfa_nw_ioc_disable(&ioceth->ioc);
1440 		break;
1441 
1442 	case IOCETH_E_IOC_RESET:
1443 		enable_mbox_intr(ioceth);
1444 		break;
1445 
1446 	case IOCETH_E_IOC_FAILED:
1447 		disable_mbox_intr(ioceth);
1448 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_failed);
1449 		break;
1450 
1451 	case IOCETH_E_IOC_READY:
1452 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_enet_attr_wait);
1453 		break;
1454 
1455 	default:
1456 		bfa_sm_fault(event);
1457 	}
1458 }
1459 
1460 static void
1461 bna_ioceth_sm_enet_attr_wait_entry(struct bna_ioceth *ioceth)
1462 {
1463 	bna_bfi_attr_get(ioceth);
1464 }
1465 
1466 static void
1467 bna_ioceth_sm_enet_attr_wait(struct bna_ioceth *ioceth,
1468 				enum bna_ioceth_event event)
1469 {
1470 	switch (event) {
1471 	case IOCETH_E_DISABLE:
1472 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_last_resp_wait);
1473 		break;
1474 
1475 	case IOCETH_E_IOC_FAILED:
1476 		disable_mbox_intr(ioceth);
1477 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_failed);
1478 		break;
1479 
1480 	case IOCETH_E_ENET_ATTR_RESP:
1481 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_ready);
1482 		break;
1483 
1484 	default:
1485 		bfa_sm_fault(event);
1486 	}
1487 }
1488 
1489 static void
1490 bna_ioceth_sm_ready_entry(struct bna_ioceth *ioceth)
1491 {
1492 	bna_enet_start(&ioceth->bna->enet);
1493 	bna_stats_mod_start(&ioceth->bna->stats_mod);
1494 	bnad_cb_ioceth_ready(ioceth->bna->bnad);
1495 }
1496 
1497 static void
1498 bna_ioceth_sm_ready(struct bna_ioceth *ioceth, enum bna_ioceth_event event)
1499 {
1500 	switch (event) {
1501 	case IOCETH_E_DISABLE:
1502 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_enet_stop_wait);
1503 		break;
1504 
1505 	case IOCETH_E_IOC_FAILED:
1506 		disable_mbox_intr(ioceth);
1507 		bna_enet_fail(&ioceth->bna->enet);
1508 		bna_stats_mod_fail(&ioceth->bna->stats_mod);
1509 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_failed);
1510 		break;
1511 
1512 	default:
1513 		bfa_sm_fault(event);
1514 	}
1515 }
1516 
1517 static void
1518 bna_ioceth_sm_last_resp_wait_entry(struct bna_ioceth *ioceth)
1519 {
1520 }
1521 
1522 static void
1523 bna_ioceth_sm_last_resp_wait(struct bna_ioceth *ioceth,
1524 				enum bna_ioceth_event event)
1525 {
1526 	switch (event) {
1527 	case IOCETH_E_IOC_FAILED:
1528 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait);
1529 		disable_mbox_intr(ioceth);
1530 		bfa_nw_ioc_disable(&ioceth->ioc);
1531 		break;
1532 
1533 	case IOCETH_E_ENET_ATTR_RESP:
1534 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait);
1535 		bfa_nw_ioc_disable(&ioceth->ioc);
1536 		break;
1537 
1538 	default:
1539 		bfa_sm_fault(event);
1540 	}
1541 }
1542 
1543 static void
1544 bna_ioceth_sm_enet_stop_wait_entry(struct bna_ioceth *ioceth)
1545 {
1546 	bna_stats_mod_stop(&ioceth->bna->stats_mod);
1547 	bna_enet_stop(&ioceth->bna->enet);
1548 }
1549 
1550 static void
1551 bna_ioceth_sm_enet_stop_wait(struct bna_ioceth *ioceth,
1552 				enum bna_ioceth_event event)
1553 {
1554 	switch (event) {
1555 	case IOCETH_E_IOC_FAILED:
1556 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait);
1557 		disable_mbox_intr(ioceth);
1558 		bna_enet_fail(&ioceth->bna->enet);
1559 		bna_stats_mod_fail(&ioceth->bna->stats_mod);
1560 		bfa_nw_ioc_disable(&ioceth->ioc);
1561 		break;
1562 
1563 	case IOCETH_E_ENET_STOPPED:
1564 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait);
1565 		bfa_nw_ioc_disable(&ioceth->ioc);
1566 		break;
1567 
1568 	default:
1569 		bfa_sm_fault(event);
1570 	}
1571 }
1572 
1573 static void
1574 bna_ioceth_sm_ioc_disable_wait_entry(struct bna_ioceth *ioceth)
1575 {
1576 }
1577 
1578 static void
1579 bna_ioceth_sm_ioc_disable_wait(struct bna_ioceth *ioceth,
1580 				enum bna_ioceth_event event)
1581 {
1582 	switch (event) {
1583 	case IOCETH_E_IOC_DISABLED:
1584 		disable_mbox_intr(ioceth);
1585 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_stopped);
1586 		break;
1587 
1588 	case IOCETH_E_ENET_STOPPED:
1589 		/* This event is received due to enet failing */
1590 		/* No-op */
1591 		break;
1592 
1593 	default:
1594 		bfa_sm_fault(event);
1595 	}
1596 }
1597 
1598 static void
1599 bna_ioceth_sm_failed_entry(struct bna_ioceth *ioceth)
1600 {
1601 	bnad_cb_ioceth_failed(ioceth->bna->bnad);
1602 }
1603 
1604 static void
1605 bna_ioceth_sm_failed(struct bna_ioceth *ioceth,
1606 			enum bna_ioceth_event event)
1607 {
1608 	switch (event) {
1609 	case IOCETH_E_DISABLE:
1610 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait);
1611 		bfa_nw_ioc_disable(&ioceth->ioc);
1612 		break;
1613 
1614 	case IOCETH_E_IOC_RESET:
1615 		enable_mbox_intr(ioceth);
1616 		bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_ready_wait);
1617 		break;
1618 
1619 	case IOCETH_E_IOC_FAILED:
1620 		break;
1621 
1622 	default:
1623 		bfa_sm_fault(event);
1624 	}
1625 }
1626 
1627 static void
1628 bna_bfi_attr_get(struct bna_ioceth *ioceth)
1629 {
1630 	struct bfi_enet_attr_req *attr_req = &ioceth->attr_req;
1631 
1632 	bfi_msgq_mhdr_set(attr_req->mh, BFI_MC_ENET,
1633 		BFI_ENET_H2I_GET_ATTR_REQ, 0, 0);
1634 	attr_req->mh.num_entries = htons(
1635 	bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_attr_req)));
1636 	bfa_msgq_cmd_set(&ioceth->msgq_cmd, NULL, NULL,
1637 		sizeof(struct bfi_enet_attr_req), &attr_req->mh);
1638 	bfa_msgq_cmd_post(&ioceth->bna->msgq, &ioceth->msgq_cmd);
1639 }
1640 
1641 /* IOC callback functions */
1642 
1643 static void
1644 bna_cb_ioceth_enable(void *arg, enum bfa_status error)
1645 {
1646 	struct bna_ioceth *ioceth = (struct bna_ioceth *)arg;
1647 
1648 	if (error)
1649 		bfa_fsm_send_event(ioceth, IOCETH_E_IOC_FAILED);
1650 	else
1651 		bfa_fsm_send_event(ioceth, IOCETH_E_IOC_READY);
1652 }
1653 
1654 static void
1655 bna_cb_ioceth_disable(void *arg)
1656 {
1657 	struct bna_ioceth *ioceth = (struct bna_ioceth *)arg;
1658 
1659 	bfa_fsm_send_event(ioceth, IOCETH_E_IOC_DISABLED);
1660 }
1661 
1662 static void
1663 bna_cb_ioceth_hbfail(void *arg)
1664 {
1665 	struct bna_ioceth *ioceth = (struct bna_ioceth *)arg;
1666 
1667 	bfa_fsm_send_event(ioceth, IOCETH_E_IOC_FAILED);
1668 }
1669 
1670 static void
1671 bna_cb_ioceth_reset(void *arg)
1672 {
1673 	struct bna_ioceth *ioceth = (struct bna_ioceth *)arg;
1674 
1675 	bfa_fsm_send_event(ioceth, IOCETH_E_IOC_RESET);
1676 }
1677 
1678 static struct bfa_ioc_cbfn bna_ioceth_cbfn = {
1679 	.enable_cbfn = bna_cb_ioceth_enable,
1680 	.disable_cbfn = bna_cb_ioceth_disable,
1681 	.hbfail_cbfn = bna_cb_ioceth_hbfail,
1682 	.reset_cbfn = bna_cb_ioceth_reset
1683 };
1684 
1685 static void bna_attr_init(struct bna_ioceth *ioceth)
1686 {
1687 	ioceth->attr.num_txq = BFI_ENET_DEF_TXQ;
1688 	ioceth->attr.num_rxp = BFI_ENET_DEF_RXP;
1689 	ioceth->attr.num_ucmac = BFI_ENET_DEF_UCAM;
1690 	ioceth->attr.num_mcmac = BFI_ENET_MAX_MCAM;
1691 	ioceth->attr.max_rit_size = BFI_ENET_DEF_RITSZ;
1692 	ioceth->attr.fw_query_complete = false;
1693 }
1694 
1695 static void
1696 bna_ioceth_init(struct bna_ioceth *ioceth, struct bna *bna,
1697 		struct bna_res_info *res_info)
1698 {
1699 	u64 dma;
1700 	u8 *kva;
1701 
1702 	ioceth->bna = bna;
1703 
1704 	/**
1705 	 * Attach IOC and claim:
1706 	 *	1. DMA memory for IOC attributes
1707 	 *	2. Kernel memory for FW trace
1708 	 */
1709 	bfa_nw_ioc_attach(&ioceth->ioc, ioceth, &bna_ioceth_cbfn);
1710 	bfa_nw_ioc_pci_init(&ioceth->ioc, &bna->pcidev, BFI_PCIFN_CLASS_ETH);
1711 
1712 	BNA_GET_DMA_ADDR(
1713 		&res_info[BNA_RES_MEM_T_ATTR].res_u.mem_info.mdl[0].dma, dma);
1714 	kva = res_info[BNA_RES_MEM_T_ATTR].res_u.mem_info.mdl[0].kva;
1715 	bfa_nw_ioc_mem_claim(&ioceth->ioc, kva, dma);
1716 
1717 	kva = res_info[BNA_RES_MEM_T_FWTRC].res_u.mem_info.mdl[0].kva;
1718 	bfa_nw_ioc_debug_memclaim(&ioceth->ioc, kva);
1719 
1720 	/**
1721 	 * Attach common modules (Diag, SFP, CEE, Port) and claim respective
1722 	 * DMA memory.
1723 	 */
1724 	BNA_GET_DMA_ADDR(
1725 		&res_info[BNA_RES_MEM_T_COM].res_u.mem_info.mdl[0].dma, dma);
1726 	kva = res_info[BNA_RES_MEM_T_COM].res_u.mem_info.mdl[0].kva;
1727 	bfa_nw_cee_attach(&bna->cee, &ioceth->ioc, bna);
1728 	bfa_nw_cee_mem_claim(&bna->cee, kva, dma);
1729 	kva += bfa_nw_cee_meminfo();
1730 	dma += bfa_nw_cee_meminfo();
1731 
1732 	bfa_nw_flash_attach(&bna->flash, &ioceth->ioc, bna);
1733 	bfa_nw_flash_memclaim(&bna->flash, kva, dma);
1734 	kva += bfa_nw_flash_meminfo();
1735 	dma += bfa_nw_flash_meminfo();
1736 
1737 	bfa_msgq_attach(&bna->msgq, &ioceth->ioc);
1738 	bfa_msgq_memclaim(&bna->msgq, kva, dma);
1739 	bfa_msgq_regisr(&bna->msgq, BFI_MC_ENET, bna_msgq_rsp_handler, bna);
1740 	kva += bfa_msgq_meminfo();
1741 	dma += bfa_msgq_meminfo();
1742 
1743 	ioceth->stop_cbfn = NULL;
1744 	ioceth->stop_cbarg = NULL;
1745 
1746 	bna_attr_init(ioceth);
1747 
1748 	bfa_fsm_set_state(ioceth, bna_ioceth_sm_stopped);
1749 }
1750 
1751 static void
1752 bna_ioceth_uninit(struct bna_ioceth *ioceth)
1753 {
1754 	bfa_nw_ioc_detach(&ioceth->ioc);
1755 
1756 	ioceth->bna = NULL;
1757 }
1758 
1759 void
1760 bna_ioceth_enable(struct bna_ioceth *ioceth)
1761 {
1762 	if (ioceth->fsm == (bfa_fsm_t)bna_ioceth_sm_ready) {
1763 		bnad_cb_ioceth_ready(ioceth->bna->bnad);
1764 		return;
1765 	}
1766 
1767 	if (ioceth->fsm == (bfa_fsm_t)bna_ioceth_sm_stopped)
1768 		bfa_fsm_send_event(ioceth, IOCETH_E_ENABLE);
1769 }
1770 
1771 void
1772 bna_ioceth_disable(struct bna_ioceth *ioceth, enum bna_cleanup_type type)
1773 {
1774 	if (type == BNA_SOFT_CLEANUP) {
1775 		bnad_cb_ioceth_disabled(ioceth->bna->bnad);
1776 		return;
1777 	}
1778 
1779 	ioceth->stop_cbfn = bnad_cb_ioceth_disabled;
1780 	ioceth->stop_cbarg = ioceth->bna->bnad;
1781 
1782 	bfa_fsm_send_event(ioceth, IOCETH_E_DISABLE);
1783 }
1784 
1785 static void
1786 bna_ucam_mod_init(struct bna_ucam_mod *ucam_mod, struct bna *bna,
1787 		  struct bna_res_info *res_info)
1788 {
1789 	int i;
1790 
1791 	ucam_mod->ucmac = (struct bna_mac *)
1792 	res_info[BNA_MOD_RES_MEM_T_UCMAC_ARRAY].res_u.mem_info.mdl[0].kva;
1793 
1794 	INIT_LIST_HEAD(&ucam_mod->free_q);
1795 	for (i = 0; i < bna->ioceth.attr.num_ucmac; i++)
1796 		list_add_tail(&ucam_mod->ucmac[i].qe, &ucam_mod->free_q);
1797 
1798 	/* A separate queue to allow synchronous setting of a list of MACs */
1799 	INIT_LIST_HEAD(&ucam_mod->del_q);
1800 	for (i = i; i < (bna->ioceth.attr.num_ucmac * 2); i++)
1801 		list_add_tail(&ucam_mod->ucmac[i].qe, &ucam_mod->del_q);
1802 
1803 	ucam_mod->bna = bna;
1804 }
1805 
1806 static void
1807 bna_ucam_mod_uninit(struct bna_ucam_mod *ucam_mod)
1808 {
1809 	ucam_mod->bna = NULL;
1810 }
1811 
1812 static void
1813 bna_mcam_mod_init(struct bna_mcam_mod *mcam_mod, struct bna *bna,
1814 		  struct bna_res_info *res_info)
1815 {
1816 	int i;
1817 
1818 	mcam_mod->mcmac = (struct bna_mac *)
1819 	res_info[BNA_MOD_RES_MEM_T_MCMAC_ARRAY].res_u.mem_info.mdl[0].kva;
1820 
1821 	INIT_LIST_HEAD(&mcam_mod->free_q);
1822 	for (i = 0; i < bna->ioceth.attr.num_mcmac; i++)
1823 		list_add_tail(&mcam_mod->mcmac[i].qe, &mcam_mod->free_q);
1824 
1825 	mcam_mod->mchandle = (struct bna_mcam_handle *)
1826 	res_info[BNA_MOD_RES_MEM_T_MCHANDLE_ARRAY].res_u.mem_info.mdl[0].kva;
1827 
1828 	INIT_LIST_HEAD(&mcam_mod->free_handle_q);
1829 	for (i = 0; i < bna->ioceth.attr.num_mcmac; i++)
1830 		list_add_tail(&mcam_mod->mchandle[i].qe,
1831 			      &mcam_mod->free_handle_q);
1832 
1833 	/* A separate queue to allow synchronous setting of a list of MACs */
1834 	INIT_LIST_HEAD(&mcam_mod->del_q);
1835 	for (i = i; i < (bna->ioceth.attr.num_mcmac * 2); i++)
1836 		list_add_tail(&mcam_mod->mcmac[i].qe, &mcam_mod->del_q);
1837 
1838 	mcam_mod->bna = bna;
1839 }
1840 
1841 static void
1842 bna_mcam_mod_uninit(struct bna_mcam_mod *mcam_mod)
1843 {
1844 	mcam_mod->bna = NULL;
1845 }
1846 
1847 static void
1848 bna_bfi_stats_get(struct bna *bna)
1849 {
1850 	struct bfi_enet_stats_req *stats_req = &bna->stats_mod.stats_get;
1851 
1852 	bna->stats_mod.stats_get_busy = true;
1853 
1854 	bfi_msgq_mhdr_set(stats_req->mh, BFI_MC_ENET,
1855 		BFI_ENET_H2I_STATS_GET_REQ, 0, 0);
1856 	stats_req->mh.num_entries = htons(
1857 		bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_stats_req)));
1858 	stats_req->stats_mask = htons(BFI_ENET_STATS_ALL);
1859 	stats_req->tx_enet_mask = htonl(bna->tx_mod.rid_mask);
1860 	stats_req->rx_enet_mask = htonl(bna->rx_mod.rid_mask);
1861 	stats_req->host_buffer.a32.addr_hi = bna->stats.hw_stats_dma.msb;
1862 	stats_req->host_buffer.a32.addr_lo = bna->stats.hw_stats_dma.lsb;
1863 
1864 	bfa_msgq_cmd_set(&bna->stats_mod.stats_get_cmd, NULL, NULL,
1865 		sizeof(struct bfi_enet_stats_req), &stats_req->mh);
1866 	bfa_msgq_cmd_post(&bna->msgq, &bna->stats_mod.stats_get_cmd);
1867 }
1868 
1869 void
1870 bna_res_req(struct bna_res_info *res_info)
1871 {
1872 	/* DMA memory for COMMON_MODULE */
1873 	res_info[BNA_RES_MEM_T_COM].res_type = BNA_RES_T_MEM;
1874 	res_info[BNA_RES_MEM_T_COM].res_u.mem_info.mem_type = BNA_MEM_T_DMA;
1875 	res_info[BNA_RES_MEM_T_COM].res_u.mem_info.num = 1;
1876 	res_info[BNA_RES_MEM_T_COM].res_u.mem_info.len = ALIGN(
1877 				(bfa_nw_cee_meminfo() +
1878 				 bfa_nw_flash_meminfo() +
1879 				 bfa_msgq_meminfo()), PAGE_SIZE);
1880 
1881 	/* DMA memory for retrieving IOC attributes */
1882 	res_info[BNA_RES_MEM_T_ATTR].res_type = BNA_RES_T_MEM;
1883 	res_info[BNA_RES_MEM_T_ATTR].res_u.mem_info.mem_type = BNA_MEM_T_DMA;
1884 	res_info[BNA_RES_MEM_T_ATTR].res_u.mem_info.num = 1;
1885 	res_info[BNA_RES_MEM_T_ATTR].res_u.mem_info.len =
1886 				ALIGN(bfa_nw_ioc_meminfo(), PAGE_SIZE);
1887 
1888 	/* Virtual memory for retreiving fw_trc */
1889 	res_info[BNA_RES_MEM_T_FWTRC].res_type = BNA_RES_T_MEM;
1890 	res_info[BNA_RES_MEM_T_FWTRC].res_u.mem_info.mem_type = BNA_MEM_T_KVA;
1891 	res_info[BNA_RES_MEM_T_FWTRC].res_u.mem_info.num = 1;
1892 	res_info[BNA_RES_MEM_T_FWTRC].res_u.mem_info.len = BNA_DBG_FWTRC_LEN;
1893 
1894 	/* DMA memory for retreiving stats */
1895 	res_info[BNA_RES_MEM_T_STATS].res_type = BNA_RES_T_MEM;
1896 	res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.mem_type = BNA_MEM_T_DMA;
1897 	res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.num = 1;
1898 	res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.len =
1899 				ALIGN(sizeof(struct bfi_enet_stats),
1900 					PAGE_SIZE);
1901 }
1902 
1903 void
1904 bna_mod_res_req(struct bna *bna, struct bna_res_info *res_info)
1905 {
1906 	struct bna_attr *attr = &bna->ioceth.attr;
1907 
1908 	/* Virtual memory for Tx objects - stored by Tx module */
1909 	res_info[BNA_MOD_RES_MEM_T_TX_ARRAY].res_type = BNA_RES_T_MEM;
1910 	res_info[BNA_MOD_RES_MEM_T_TX_ARRAY].res_u.mem_info.mem_type =
1911 		BNA_MEM_T_KVA;
1912 	res_info[BNA_MOD_RES_MEM_T_TX_ARRAY].res_u.mem_info.num = 1;
1913 	res_info[BNA_MOD_RES_MEM_T_TX_ARRAY].res_u.mem_info.len =
1914 		attr->num_txq * sizeof(struct bna_tx);
1915 
1916 	/* Virtual memory for TxQ - stored by Tx module */
1917 	res_info[BNA_MOD_RES_MEM_T_TXQ_ARRAY].res_type = BNA_RES_T_MEM;
1918 	res_info[BNA_MOD_RES_MEM_T_TXQ_ARRAY].res_u.mem_info.mem_type =
1919 		BNA_MEM_T_KVA;
1920 	res_info[BNA_MOD_RES_MEM_T_TXQ_ARRAY].res_u.mem_info.num = 1;
1921 	res_info[BNA_MOD_RES_MEM_T_TXQ_ARRAY].res_u.mem_info.len =
1922 		attr->num_txq * sizeof(struct bna_txq);
1923 
1924 	/* Virtual memory for Rx objects - stored by Rx module */
1925 	res_info[BNA_MOD_RES_MEM_T_RX_ARRAY].res_type = BNA_RES_T_MEM;
1926 	res_info[BNA_MOD_RES_MEM_T_RX_ARRAY].res_u.mem_info.mem_type =
1927 		BNA_MEM_T_KVA;
1928 	res_info[BNA_MOD_RES_MEM_T_RX_ARRAY].res_u.mem_info.num = 1;
1929 	res_info[BNA_MOD_RES_MEM_T_RX_ARRAY].res_u.mem_info.len =
1930 		attr->num_rxp * sizeof(struct bna_rx);
1931 
1932 	/* Virtual memory for RxPath - stored by Rx module */
1933 	res_info[BNA_MOD_RES_MEM_T_RXP_ARRAY].res_type = BNA_RES_T_MEM;
1934 	res_info[BNA_MOD_RES_MEM_T_RXP_ARRAY].res_u.mem_info.mem_type =
1935 		BNA_MEM_T_KVA;
1936 	res_info[BNA_MOD_RES_MEM_T_RXP_ARRAY].res_u.mem_info.num = 1;
1937 	res_info[BNA_MOD_RES_MEM_T_RXP_ARRAY].res_u.mem_info.len =
1938 		attr->num_rxp * sizeof(struct bna_rxp);
1939 
1940 	/* Virtual memory for RxQ - stored by Rx module */
1941 	res_info[BNA_MOD_RES_MEM_T_RXQ_ARRAY].res_type = BNA_RES_T_MEM;
1942 	res_info[BNA_MOD_RES_MEM_T_RXQ_ARRAY].res_u.mem_info.mem_type =
1943 		BNA_MEM_T_KVA;
1944 	res_info[BNA_MOD_RES_MEM_T_RXQ_ARRAY].res_u.mem_info.num = 1;
1945 	res_info[BNA_MOD_RES_MEM_T_RXQ_ARRAY].res_u.mem_info.len =
1946 		(attr->num_rxp * 2) * sizeof(struct bna_rxq);
1947 
1948 	/* Virtual memory for Unicast MAC address - stored by ucam module */
1949 	res_info[BNA_MOD_RES_MEM_T_UCMAC_ARRAY].res_type = BNA_RES_T_MEM;
1950 	res_info[BNA_MOD_RES_MEM_T_UCMAC_ARRAY].res_u.mem_info.mem_type =
1951 		BNA_MEM_T_KVA;
1952 	res_info[BNA_MOD_RES_MEM_T_UCMAC_ARRAY].res_u.mem_info.num = 1;
1953 	res_info[BNA_MOD_RES_MEM_T_UCMAC_ARRAY].res_u.mem_info.len =
1954 		(attr->num_ucmac * 2) * sizeof(struct bna_mac);
1955 
1956 	/* Virtual memory for Multicast MAC address - stored by mcam module */
1957 	res_info[BNA_MOD_RES_MEM_T_MCMAC_ARRAY].res_type = BNA_RES_T_MEM;
1958 	res_info[BNA_MOD_RES_MEM_T_MCMAC_ARRAY].res_u.mem_info.mem_type =
1959 		BNA_MEM_T_KVA;
1960 	res_info[BNA_MOD_RES_MEM_T_MCMAC_ARRAY].res_u.mem_info.num = 1;
1961 	res_info[BNA_MOD_RES_MEM_T_MCMAC_ARRAY].res_u.mem_info.len =
1962 		(attr->num_mcmac * 2) * sizeof(struct bna_mac);
1963 
1964 	/* Virtual memory for Multicast handle - stored by mcam module */
1965 	res_info[BNA_MOD_RES_MEM_T_MCHANDLE_ARRAY].res_type = BNA_RES_T_MEM;
1966 	res_info[BNA_MOD_RES_MEM_T_MCHANDLE_ARRAY].res_u.mem_info.mem_type =
1967 		BNA_MEM_T_KVA;
1968 	res_info[BNA_MOD_RES_MEM_T_MCHANDLE_ARRAY].res_u.mem_info.num = 1;
1969 	res_info[BNA_MOD_RES_MEM_T_MCHANDLE_ARRAY].res_u.mem_info.len =
1970 		attr->num_mcmac * sizeof(struct bna_mcam_handle);
1971 }
1972 
1973 void
1974 bna_init(struct bna *bna, struct bnad *bnad,
1975 		struct bfa_pcidev *pcidev, struct bna_res_info *res_info)
1976 {
1977 	bna->bnad = bnad;
1978 	bna->pcidev = *pcidev;
1979 
1980 	bna->stats.hw_stats_kva = (struct bfi_enet_stats *)
1981 		res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.mdl[0].kva;
1982 	bna->stats.hw_stats_dma.msb =
1983 		res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.mdl[0].dma.msb;
1984 	bna->stats.hw_stats_dma.lsb =
1985 		res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.mdl[0].dma.lsb;
1986 
1987 	bna_reg_addr_init(bna, &bna->pcidev);
1988 
1989 	/* Also initializes diag, cee, sfp, phy_port, msgq */
1990 	bna_ioceth_init(&bna->ioceth, bna, res_info);
1991 
1992 	bna_enet_init(&bna->enet, bna);
1993 	bna_ethport_init(&bna->ethport, bna);
1994 }
1995 
1996 void
1997 bna_mod_init(struct bna *bna, struct bna_res_info *res_info)
1998 {
1999 	bna_tx_mod_init(&bna->tx_mod, bna, res_info);
2000 
2001 	bna_rx_mod_init(&bna->rx_mod, bna, res_info);
2002 
2003 	bna_ucam_mod_init(&bna->ucam_mod, bna, res_info);
2004 
2005 	bna_mcam_mod_init(&bna->mcam_mod, bna, res_info);
2006 
2007 	bna->default_mode_rid = BFI_INVALID_RID;
2008 	bna->promisc_rid = BFI_INVALID_RID;
2009 
2010 	bna->mod_flags |= BNA_MOD_F_INIT_DONE;
2011 }
2012 
2013 void
2014 bna_uninit(struct bna *bna)
2015 {
2016 	if (bna->mod_flags & BNA_MOD_F_INIT_DONE) {
2017 		bna_mcam_mod_uninit(&bna->mcam_mod);
2018 		bna_ucam_mod_uninit(&bna->ucam_mod);
2019 		bna_rx_mod_uninit(&bna->rx_mod);
2020 		bna_tx_mod_uninit(&bna->tx_mod);
2021 		bna->mod_flags &= ~BNA_MOD_F_INIT_DONE;
2022 	}
2023 
2024 	bna_stats_mod_uninit(&bna->stats_mod);
2025 	bna_ethport_uninit(&bna->ethport);
2026 	bna_enet_uninit(&bna->enet);
2027 
2028 	bna_ioceth_uninit(&bna->ioceth);
2029 
2030 	bna->bnad = NULL;
2031 }
2032 
2033 int
2034 bna_num_txq_set(struct bna *bna, int num_txq)
2035 {
2036 	if (bna->ioceth.attr.fw_query_complete &&
2037 		(num_txq <= bna->ioceth.attr.num_txq)) {
2038 		bna->ioceth.attr.num_txq = num_txq;
2039 		return BNA_CB_SUCCESS;
2040 	}
2041 
2042 	return BNA_CB_FAIL;
2043 }
2044 
2045 int
2046 bna_num_rxp_set(struct bna *bna, int num_rxp)
2047 {
2048 	if (bna->ioceth.attr.fw_query_complete &&
2049 		(num_rxp <= bna->ioceth.attr.num_rxp)) {
2050 		bna->ioceth.attr.num_rxp = num_rxp;
2051 		return BNA_CB_SUCCESS;
2052 	}
2053 
2054 	return BNA_CB_FAIL;
2055 }
2056 
2057 struct bna_mac *
2058 bna_cam_mod_mac_get(struct list_head *head)
2059 {
2060 	struct bna_mac *mac;
2061 
2062 	mac = list_first_entry_or_null(head, struct bna_mac, qe);
2063 	if (mac)
2064 		list_del(&mac->qe);
2065 
2066 	return mac;
2067 }
2068 
2069 struct bna_mcam_handle *
2070 bna_mcam_mod_handle_get(struct bna_mcam_mod *mcam_mod)
2071 {
2072 	struct bna_mcam_handle *handle;
2073 
2074 	handle = list_first_entry_or_null(&mcam_mod->free_handle_q,
2075 					  struct bna_mcam_handle, qe);
2076 	if (handle)
2077 		list_del(&handle->qe);
2078 
2079 	return handle;
2080 }
2081 
2082 void
2083 bna_mcam_mod_handle_put(struct bna_mcam_mod *mcam_mod,
2084 			struct bna_mcam_handle *handle)
2085 {
2086 	list_add_tail(&handle->qe, &mcam_mod->free_handle_q);
2087 }
2088 
2089 void
2090 bna_hw_stats_get(struct bna *bna)
2091 {
2092 	if (!bna->stats_mod.ioc_ready) {
2093 		bnad_cb_stats_get(bna->bnad, BNA_CB_FAIL, &bna->stats);
2094 		return;
2095 	}
2096 	if (bna->stats_mod.stats_get_busy) {
2097 		bnad_cb_stats_get(bna->bnad, BNA_CB_BUSY, &bna->stats);
2098 		return;
2099 	}
2100 
2101 	bna_bfi_stats_get(bna);
2102 }
2103