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