2 * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License (GPL) Version 2 as
10 * published by the Free Software Foundation
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
18 #include "bfa_os_inc.h"
21 #include "bfa_modules.h"
24 BFA_TRC_FILE(HAL, FCXP);
33 * LPS related definitions
35 #define BFA_LPS_MIN_LPORTS (1)
36 #define BFA_LPS_MAX_LPORTS (256)
39 * Maximum Vports supported per physical port or vf.
41 #define BFA_LPS_MAX_VPORTS_SUPP_CB 255
42 #define BFA_LPS_MAX_VPORTS_SUPP_CT 190
45 * lps_pvt BFA LPS private functions
49 BFA_LPS_SM_LOGIN = 1, /* login request from user */
50 BFA_LPS_SM_LOGOUT = 2, /* logout request from user */
51 BFA_LPS_SM_FWRSP = 3, /* f/w response to login/logout */
52 BFA_LPS_SM_RESUME = 4, /* space present in reqq queue */
53 BFA_LPS_SM_DELETE = 5, /* lps delete from user */
54 BFA_LPS_SM_OFFLINE = 6, /* Link is offline */
55 BFA_LPS_SM_RX_CVL = 7, /* Rx clear virtual link */
59 * FC PORT related definitions
62 * The port is considered disabled if corresponding physical port or IOC are
65 #define BFA_PORT_IS_DISABLED(bfa) \
66 ((bfa_fcport_is_disabled(bfa) == BFA_TRUE) || \
67 (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE))
71 * BFA port state machine events
73 enum bfa_fcport_sm_event {
74 BFA_FCPORT_SM_START = 1, /* start port state machine */
75 BFA_FCPORT_SM_STOP = 2, /* stop port state machine */
76 BFA_FCPORT_SM_ENABLE = 3, /* enable port */
77 BFA_FCPORT_SM_DISABLE = 4, /* disable port state machine */
78 BFA_FCPORT_SM_FWRSP = 5, /* firmware enable/disable rsp */
79 BFA_FCPORT_SM_LINKUP = 6, /* firmware linkup event */
80 BFA_FCPORT_SM_LINKDOWN = 7, /* firmware linkup down */
81 BFA_FCPORT_SM_QRESUME = 8, /* CQ space available */
82 BFA_FCPORT_SM_HWFAIL = 9, /* IOC h/w failure */
86 * BFA port link notification state machine events
89 enum bfa_fcport_ln_sm_event {
90 BFA_FCPORT_LN_SM_LINKUP = 1, /* linkup event */
91 BFA_FCPORT_LN_SM_LINKDOWN = 2, /* linkdown event */
92 BFA_FCPORT_LN_SM_NOTIFICATION = 3 /* done notification */
96 * RPORT related definitions
98 #define bfa_rport_offline_cb(__rp) do { \
99 if ((__rp)->bfa->fcs) \
100 bfa_cb_rport_offline((__rp)->rport_drv); \
102 bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe, \
103 __bfa_cb_rport_offline, (__rp)); \
107 #define bfa_rport_online_cb(__rp) do { \
108 if ((__rp)->bfa->fcs) \
109 bfa_cb_rport_online((__rp)->rport_drv); \
111 bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe, \
112 __bfa_cb_rport_online, (__rp)); \
117 enum bfa_rport_event {
118 BFA_RPORT_SM_CREATE = 1, /* rport create event */
119 BFA_RPORT_SM_DELETE = 2, /* deleting an existing rport */
120 BFA_RPORT_SM_ONLINE = 3, /* rport is online */
121 BFA_RPORT_SM_OFFLINE = 4, /* rport is offline */
122 BFA_RPORT_SM_FWRSP = 5, /* firmware response */
123 BFA_RPORT_SM_HWFAIL = 6, /* IOC h/w failure */
124 BFA_RPORT_SM_QOS_SCN = 7, /* QoS SCN from firmware */
125 BFA_RPORT_SM_SET_SPEED = 8, /* Set Rport Speed */
126 BFA_RPORT_SM_QRESUME = 9, /* space in requeue queue */
130 * forward declarations FCXP related functions
132 static void __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete);
133 static void hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
134 struct bfi_fcxp_send_rsp_s *fcxp_rsp);
135 static void hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen,
136 struct bfa_fcxp_s *fcxp, struct fchs_s *fchs);
137 static void bfa_fcxp_qresume(void *cbarg);
138 static void bfa_fcxp_queue(struct bfa_fcxp_s *fcxp,
139 struct bfi_fcxp_send_req_s *send_req);
142 * forward declarations for LPS functions
144 static void bfa_lps_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
146 static void bfa_lps_attach(struct bfa_s *bfa, void *bfad,
147 struct bfa_iocfc_cfg_s *cfg,
148 struct bfa_meminfo_s *meminfo,
149 struct bfa_pcidev_s *pcidev);
150 static void bfa_lps_detach(struct bfa_s *bfa);
151 static void bfa_lps_start(struct bfa_s *bfa);
152 static void bfa_lps_stop(struct bfa_s *bfa);
153 static void bfa_lps_iocdisable(struct bfa_s *bfa);
154 static void bfa_lps_login_rsp(struct bfa_s *bfa,
155 struct bfi_lps_login_rsp_s *rsp);
156 static void bfa_lps_logout_rsp(struct bfa_s *bfa,
157 struct bfi_lps_logout_rsp_s *rsp);
158 static void bfa_lps_reqq_resume(void *lps_arg);
159 static void bfa_lps_free(struct bfa_lps_s *lps);
160 static void bfa_lps_send_login(struct bfa_lps_s *lps);
161 static void bfa_lps_send_logout(struct bfa_lps_s *lps);
162 static void bfa_lps_login_comp(struct bfa_lps_s *lps);
163 static void bfa_lps_logout_comp(struct bfa_lps_s *lps);
164 static void bfa_lps_cvl_event(struct bfa_lps_s *lps);
167 * forward declaration for LPS state machine
169 static void bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event);
170 static void bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event);
171 static void bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event
173 static void bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event);
174 static void bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event);
175 static void bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event
179 * forward declaration for FC Port functions
181 static bfa_boolean_t bfa_fcport_send_enable(struct bfa_fcport_s *fcport);
182 static bfa_boolean_t bfa_fcport_send_disable(struct bfa_fcport_s *fcport);
183 static void bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport);
184 static void bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport);
185 static void bfa_fcport_set_wwns(struct bfa_fcport_s *fcport);
186 static void __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete);
187 static void bfa_fcport_scn(struct bfa_fcport_s *fcport,
188 enum bfa_port_linkstate event, bfa_boolean_t trunk);
189 static void bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln,
190 enum bfa_port_linkstate event);
191 static void __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete);
192 static void bfa_fcport_stats_get_timeout(void *cbarg);
193 static void bfa_fcport_stats_clr_timeout(void *cbarg);
194 static void bfa_trunk_iocdisable(struct bfa_s *bfa);
197 * forward declaration for FC PORT state machine
199 static void bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
200 enum bfa_fcport_sm_event event);
201 static void bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
202 enum bfa_fcport_sm_event event);
203 static void bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
204 enum bfa_fcport_sm_event event);
205 static void bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
206 enum bfa_fcport_sm_event event);
207 static void bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
208 enum bfa_fcport_sm_event event);
209 static void bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
210 enum bfa_fcport_sm_event event);
211 static void bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
212 enum bfa_fcport_sm_event event);
213 static void bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
214 enum bfa_fcport_sm_event event);
215 static void bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
216 enum bfa_fcport_sm_event event);
217 static void bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
218 enum bfa_fcport_sm_event event);
219 static void bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
220 enum bfa_fcport_sm_event event);
221 static void bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
222 enum bfa_fcport_sm_event event);
224 static void bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
225 enum bfa_fcport_ln_sm_event event);
226 static void bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
227 enum bfa_fcport_ln_sm_event event);
228 static void bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
229 enum bfa_fcport_ln_sm_event event);
230 static void bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
231 enum bfa_fcport_ln_sm_event event);
232 static void bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
233 enum bfa_fcport_ln_sm_event event);
234 static void bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
235 enum bfa_fcport_ln_sm_event event);
236 static void bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
237 enum bfa_fcport_ln_sm_event event);
239 static struct bfa_sm_table_s hal_port_sm_table[] = {
240 {BFA_SM(bfa_fcport_sm_uninit), BFA_PORT_ST_UNINIT},
241 {BFA_SM(bfa_fcport_sm_enabling_qwait), BFA_PORT_ST_ENABLING_QWAIT},
242 {BFA_SM(bfa_fcport_sm_enabling), BFA_PORT_ST_ENABLING},
243 {BFA_SM(bfa_fcport_sm_linkdown), BFA_PORT_ST_LINKDOWN},
244 {BFA_SM(bfa_fcport_sm_linkup), BFA_PORT_ST_LINKUP},
245 {BFA_SM(bfa_fcport_sm_disabling_qwait), BFA_PORT_ST_DISABLING_QWAIT},
246 {BFA_SM(bfa_fcport_sm_toggling_qwait), BFA_PORT_ST_TOGGLING_QWAIT},
247 {BFA_SM(bfa_fcport_sm_disabling), BFA_PORT_ST_DISABLING},
248 {BFA_SM(bfa_fcport_sm_disabled), BFA_PORT_ST_DISABLED},
249 {BFA_SM(bfa_fcport_sm_stopped), BFA_PORT_ST_STOPPED},
250 {BFA_SM(bfa_fcport_sm_iocdown), BFA_PORT_ST_IOCDOWN},
251 {BFA_SM(bfa_fcport_sm_iocfail), BFA_PORT_ST_IOCDOWN},
256 * forward declaration for RPORT related functions
258 static struct bfa_rport_s *bfa_rport_alloc(struct bfa_rport_mod_s *rp_mod);
259 static void bfa_rport_free(struct bfa_rport_s *rport);
260 static bfa_boolean_t bfa_rport_send_fwcreate(struct bfa_rport_s *rp);
261 static bfa_boolean_t bfa_rport_send_fwdelete(struct bfa_rport_s *rp);
262 static bfa_boolean_t bfa_rport_send_fwspeed(struct bfa_rport_s *rp);
263 static void __bfa_cb_rport_online(void *cbarg,
264 bfa_boolean_t complete);
265 static void __bfa_cb_rport_offline(void *cbarg,
266 bfa_boolean_t complete);
269 * forward declaration for RPORT state machine
271 static void bfa_rport_sm_uninit(struct bfa_rport_s *rp,
272 enum bfa_rport_event event);
273 static void bfa_rport_sm_created(struct bfa_rport_s *rp,
274 enum bfa_rport_event event);
275 static void bfa_rport_sm_fwcreate(struct bfa_rport_s *rp,
276 enum bfa_rport_event event);
277 static void bfa_rport_sm_online(struct bfa_rport_s *rp,
278 enum bfa_rport_event event);
279 static void bfa_rport_sm_fwdelete(struct bfa_rport_s *rp,
280 enum bfa_rport_event event);
281 static void bfa_rport_sm_offline(struct bfa_rport_s *rp,
282 enum bfa_rport_event event);
283 static void bfa_rport_sm_deleting(struct bfa_rport_s *rp,
284 enum bfa_rport_event event);
285 static void bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
286 enum bfa_rport_event event);
287 static void bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
288 enum bfa_rport_event event);
289 static void bfa_rport_sm_iocdisable(struct bfa_rport_s *rp,
290 enum bfa_rport_event event);
291 static void bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp,
292 enum bfa_rport_event event);
293 static void bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp,
294 enum bfa_rport_event event);
295 static void bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp,
296 enum bfa_rport_event event);
299 * PLOG related definitions
302 plkd_validate_logrec(struct bfa_plog_rec_s *pl_rec)
304 if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) &&
305 (pl_rec->log_type != BFA_PL_LOG_TYPE_STRING))
308 if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) &&
309 (pl_rec->log_num_ints > BFA_PL_INT_LOG_SZ))
316 bfa_plog_add(struct bfa_plog_s *plog, struct bfa_plog_rec_s *pl_rec)
319 struct bfa_plog_rec_s *pl_recp;
321 if (plog->plog_enabled == 0)
324 if (plkd_validate_logrec(pl_rec)) {
331 pl_recp = &(plog->plog_recs[tail]);
333 memcpy(pl_recp, pl_rec, sizeof(struct bfa_plog_rec_s));
335 pl_recp->tv = bfa_os_get_log_time();
336 BFA_PL_LOG_REC_INCR(plog->tail);
338 if (plog->head == plog->tail)
339 BFA_PL_LOG_REC_INCR(plog->head);
343 bfa_plog_init(struct bfa_plog_s *plog)
345 memset((char *)plog, 0, sizeof(struct bfa_plog_s));
347 memcpy(plog->plog_sig, BFA_PL_SIG_STR, BFA_PL_SIG_LEN);
348 plog->head = plog->tail = 0;
349 plog->plog_enabled = 1;
353 bfa_plog_str(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
354 enum bfa_plog_eid event,
355 u16 misc, char *log_str)
357 struct bfa_plog_rec_s lp;
359 if (plog->plog_enabled) {
360 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
363 lp.log_type = BFA_PL_LOG_TYPE_STRING;
365 strncpy(lp.log_entry.string_log, log_str,
366 BFA_PL_STRING_LOG_SZ - 1);
367 lp.log_entry.string_log[BFA_PL_STRING_LOG_SZ - 1] = '\0';
368 bfa_plog_add(plog, &lp);
373 bfa_plog_intarr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
374 enum bfa_plog_eid event,
375 u16 misc, u32 *intarr, u32 num_ints)
377 struct bfa_plog_rec_s lp;
380 if (num_ints > BFA_PL_INT_LOG_SZ)
381 num_ints = BFA_PL_INT_LOG_SZ;
383 if (plog->plog_enabled) {
384 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
387 lp.log_type = BFA_PL_LOG_TYPE_INT;
390 for (i = 0; i < num_ints; i++)
391 lp.log_entry.int_log[i] = intarr[i];
393 lp.log_num_ints = (u8) num_ints;
395 bfa_plog_add(plog, &lp);
400 bfa_plog_fchdr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
401 enum bfa_plog_eid event,
402 u16 misc, struct fchs_s *fchdr)
404 struct bfa_plog_rec_s lp;
405 u32 *tmp_int = (u32 *) fchdr;
406 u32 ints[BFA_PL_INT_LOG_SZ];
408 if (plog->plog_enabled) {
409 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
411 ints[0] = tmp_int[0];
412 ints[1] = tmp_int[1];
413 ints[2] = tmp_int[4];
415 bfa_plog_intarr(plog, mid, event, misc, ints, 3);
420 bfa_plog_fchdr_and_pl(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
421 enum bfa_plog_eid event, u16 misc, struct fchs_s *fchdr,
424 struct bfa_plog_rec_s lp;
425 u32 *tmp_int = (u32 *) fchdr;
426 u32 ints[BFA_PL_INT_LOG_SZ];
428 if (plog->plog_enabled) {
429 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
431 ints[0] = tmp_int[0];
432 ints[1] = tmp_int[1];
433 ints[2] = tmp_int[4];
436 bfa_plog_intarr(plog, mid, event, misc, ints, 4);
441 bfa_plog_clear(struct bfa_plog_s *plog)
443 plog->head = plog->tail = 0;
447 bfa_plog_enable(struct bfa_plog_s *plog)
449 plog->plog_enabled = 1;
453 bfa_plog_disable(struct bfa_plog_s *plog)
455 plog->plog_enabled = 0;
459 bfa_plog_get_setting(struct bfa_plog_s *plog)
461 return (bfa_boolean_t)plog->plog_enabled;
465 * fcxp_pvt BFA FCXP private functions
469 claim_fcxp_req_rsp_mem(struct bfa_fcxp_mod_s *mod, struct bfa_meminfo_s *mi)
475 dm_kva = bfa_meminfo_dma_virt(mi);
476 dm_pa = bfa_meminfo_dma_phys(mi);
478 buf_pool_sz = mod->req_pld_sz * mod->num_fcxps;
481 * Initialize the fcxp req payload list
483 mod->req_pld_list_kva = dm_kva;
484 mod->req_pld_list_pa = dm_pa;
485 dm_kva += buf_pool_sz;
486 dm_pa += buf_pool_sz;
487 memset(mod->req_pld_list_kva, 0, buf_pool_sz);
490 * Initialize the fcxp rsp payload list
492 buf_pool_sz = mod->rsp_pld_sz * mod->num_fcxps;
493 mod->rsp_pld_list_kva = dm_kva;
494 mod->rsp_pld_list_pa = dm_pa;
495 dm_kva += buf_pool_sz;
496 dm_pa += buf_pool_sz;
497 memset(mod->rsp_pld_list_kva, 0, buf_pool_sz);
499 bfa_meminfo_dma_virt(mi) = dm_kva;
500 bfa_meminfo_dma_phys(mi) = dm_pa;
504 claim_fcxps_mem(struct bfa_fcxp_mod_s *mod, struct bfa_meminfo_s *mi)
507 struct bfa_fcxp_s *fcxp;
509 fcxp = (struct bfa_fcxp_s *) bfa_meminfo_kva(mi);
510 memset(fcxp, 0, sizeof(struct bfa_fcxp_s) * mod->num_fcxps);
512 INIT_LIST_HEAD(&mod->fcxp_free_q);
513 INIT_LIST_HEAD(&mod->fcxp_active_q);
515 mod->fcxp_list = fcxp;
517 for (i = 0; i < mod->num_fcxps; i++) {
518 fcxp->fcxp_mod = mod;
521 list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
522 bfa_reqq_winit(&fcxp->reqq_wqe, bfa_fcxp_qresume, fcxp);
523 fcxp->reqq_waiting = BFA_FALSE;
528 bfa_meminfo_kva(mi) = (void *)fcxp;
532 bfa_fcxp_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
535 u16 num_fcxp_reqs = cfg->fwcfg.num_fcxp_reqs;
537 if (num_fcxp_reqs == 0)
541 * Account for req/rsp payload
543 *dm_len += BFA_FCXP_MAX_IBUF_SZ * num_fcxp_reqs;
544 if (cfg->drvcfg.min_cfg)
545 *dm_len += BFA_FCXP_MAX_IBUF_SZ * num_fcxp_reqs;
547 *dm_len += BFA_FCXP_MAX_LBUF_SZ * num_fcxp_reqs;
550 * Account for fcxp structs
552 *ndm_len += sizeof(struct bfa_fcxp_s) * num_fcxp_reqs;
556 bfa_fcxp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
557 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
559 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
561 memset(mod, 0, sizeof(struct bfa_fcxp_mod_s));
563 mod->num_fcxps = cfg->fwcfg.num_fcxp_reqs;
566 * Initialize FCXP request and response payload sizes.
568 mod->req_pld_sz = mod->rsp_pld_sz = BFA_FCXP_MAX_IBUF_SZ;
569 if (!cfg->drvcfg.min_cfg)
570 mod->rsp_pld_sz = BFA_FCXP_MAX_LBUF_SZ;
572 INIT_LIST_HEAD(&mod->wait_q);
574 claim_fcxp_req_rsp_mem(mod, meminfo);
575 claim_fcxps_mem(mod, meminfo);
579 bfa_fcxp_detach(struct bfa_s *bfa)
584 bfa_fcxp_start(struct bfa_s *bfa)
589 bfa_fcxp_stop(struct bfa_s *bfa)
594 bfa_fcxp_iocdisable(struct bfa_s *bfa)
596 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
597 struct bfa_fcxp_s *fcxp;
598 struct list_head *qe, *qen;
600 list_for_each_safe(qe, qen, &mod->fcxp_active_q) {
601 fcxp = (struct bfa_fcxp_s *) qe;
602 if (fcxp->caller == NULL) {
603 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
604 BFA_STATUS_IOC_FAILURE, 0, 0, NULL);
607 fcxp->rsp_status = BFA_STATUS_IOC_FAILURE;
608 bfa_cb_queue(bfa, &fcxp->hcb_qe,
609 __bfa_fcxp_send_cbfn, fcxp);
614 static struct bfa_fcxp_s *
615 bfa_fcxp_get(struct bfa_fcxp_mod_s *fm)
617 struct bfa_fcxp_s *fcxp;
619 bfa_q_deq(&fm->fcxp_free_q, &fcxp);
622 list_add_tail(&fcxp->qe, &fm->fcxp_active_q);
628 bfa_fcxp_init_reqrsp(struct bfa_fcxp_s *fcxp,
632 bfa_fcxp_get_sgaddr_t *r_sga_cbfn,
633 bfa_fcxp_get_sglen_t *r_sglen_cbfn,
634 struct list_head *r_sgpg_q,
636 bfa_fcxp_get_sgaddr_t sga_cbfn,
637 bfa_fcxp_get_sglen_t sglen_cbfn)
640 bfa_assert(bfa != NULL);
642 bfa_trc(bfa, fcxp->fcxp_tag);
647 bfa_assert(*sga_cbfn != NULL);
648 bfa_assert(*sglen_cbfn != NULL);
651 *r_sga_cbfn = sga_cbfn;
652 *r_sglen_cbfn = sglen_cbfn;
657 * alloc required sgpgs
659 if (n_sgles > BFI_SGE_INLINE)
666 bfa_fcxp_init(struct bfa_fcxp_s *fcxp,
667 void *caller, struct bfa_s *bfa, int nreq_sgles,
668 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
669 bfa_fcxp_get_sglen_t req_sglen_cbfn,
670 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
671 bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
674 bfa_assert(bfa != NULL);
676 bfa_trc(bfa, fcxp->fcxp_tag);
678 fcxp->caller = caller;
680 bfa_fcxp_init_reqrsp(fcxp, bfa,
681 &fcxp->use_ireqbuf, &fcxp->nreq_sgles, &fcxp->req_sga_cbfn,
682 &fcxp->req_sglen_cbfn, &fcxp->req_sgpg_q,
683 nreq_sgles, req_sga_cbfn, req_sglen_cbfn);
685 bfa_fcxp_init_reqrsp(fcxp, bfa,
686 &fcxp->use_irspbuf, &fcxp->nrsp_sgles, &fcxp->rsp_sga_cbfn,
687 &fcxp->rsp_sglen_cbfn, &fcxp->rsp_sgpg_q,
688 nrsp_sgles, rsp_sga_cbfn, rsp_sglen_cbfn);
693 bfa_fcxp_put(struct bfa_fcxp_s *fcxp)
695 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
696 struct bfa_fcxp_wqe_s *wqe;
698 bfa_q_deq(&mod->wait_q, &wqe);
700 bfa_trc(mod->bfa, fcxp->fcxp_tag);
702 bfa_fcxp_init(fcxp, wqe->caller, wqe->bfa, wqe->nreq_sgles,
703 wqe->nrsp_sgles, wqe->req_sga_cbfn,
704 wqe->req_sglen_cbfn, wqe->rsp_sga_cbfn,
705 wqe->rsp_sglen_cbfn);
707 wqe->alloc_cbfn(wqe->alloc_cbarg, fcxp);
711 bfa_assert(bfa_q_is_on_q(&mod->fcxp_active_q, fcxp));
713 list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
717 bfa_fcxp_null_comp(void *bfad_fcxp, struct bfa_fcxp_s *fcxp, void *cbarg,
718 bfa_status_t req_status, u32 rsp_len,
719 u32 resid_len, struct fchs_s *rsp_fchs)
721 /* discarded fcxp completion */
725 __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete)
727 struct bfa_fcxp_s *fcxp = cbarg;
730 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
731 fcxp->rsp_status, fcxp->rsp_len,
732 fcxp->residue_len, &fcxp->rsp_fchs);
739 hal_fcxp_send_comp(struct bfa_s *bfa, struct bfi_fcxp_send_rsp_s *fcxp_rsp)
741 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
742 struct bfa_fcxp_s *fcxp;
743 u16 fcxp_tag = be16_to_cpu(fcxp_rsp->fcxp_tag);
745 bfa_trc(bfa, fcxp_tag);
747 fcxp_rsp->rsp_len = be32_to_cpu(fcxp_rsp->rsp_len);
750 * @todo f/w should not set residue to non-0 when everything
753 if (fcxp_rsp->req_status == BFA_STATUS_OK)
754 fcxp_rsp->residue_len = 0;
756 fcxp_rsp->residue_len = be32_to_cpu(fcxp_rsp->residue_len);
758 fcxp = BFA_FCXP_FROM_TAG(mod, fcxp_tag);
760 bfa_assert(fcxp->send_cbfn != NULL);
762 hal_fcxp_rx_plog(mod->bfa, fcxp, fcxp_rsp);
764 if (fcxp->send_cbfn != NULL) {
765 bfa_trc(mod->bfa, (NULL == fcxp->caller));
766 if (fcxp->caller == NULL) {
767 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
768 fcxp_rsp->req_status, fcxp_rsp->rsp_len,
769 fcxp_rsp->residue_len, &fcxp_rsp->fchs);
771 * fcxp automatically freed on return from the callback
775 fcxp->rsp_status = fcxp_rsp->req_status;
776 fcxp->rsp_len = fcxp_rsp->rsp_len;
777 fcxp->residue_len = fcxp_rsp->residue_len;
778 fcxp->rsp_fchs = fcxp_rsp->fchs;
780 bfa_cb_queue(bfa, &fcxp->hcb_qe,
781 __bfa_fcxp_send_cbfn, fcxp);
784 bfa_trc(bfa, (NULL == fcxp->send_cbfn));
789 hal_fcxp_set_local_sges(struct bfi_sge_s *sge, u32 reqlen, u64 req_pa)
791 union bfi_addr_u sga_zero = { {0} };
793 sge->sg_len = reqlen;
794 sge->flags = BFI_SGE_DATA_LAST;
795 bfa_dma_addr_set(sge[0].sga, req_pa);
800 sge->sg_len = reqlen;
801 sge->flags = BFI_SGE_PGDLEN;
806 hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen, struct bfa_fcxp_s *fcxp,
813 if (fcxp->use_ireqbuf) {
815 *((u32 *) BFA_FCXP_REQ_PLD(fcxp));
817 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
819 reqlen + sizeof(struct fchs_s), fchs,
822 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
824 reqlen + sizeof(struct fchs_s),
828 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_TX,
829 reqlen + sizeof(struct fchs_s), fchs);
834 hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
835 struct bfi_fcxp_send_rsp_s *fcxp_rsp)
837 if (fcxp_rsp->rsp_len > 0) {
838 if (fcxp->use_irspbuf) {
840 *((u32 *) BFA_FCXP_RSP_PLD(fcxp));
842 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
844 (u16) fcxp_rsp->rsp_len,
845 &fcxp_rsp->fchs, pld_w0);
847 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
849 (u16) fcxp_rsp->rsp_len,
853 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_RX,
854 (u16) fcxp_rsp->rsp_len, &fcxp_rsp->fchs);
859 * Handler to resume sending fcxp when space in available in cpe queue.
862 bfa_fcxp_qresume(void *cbarg)
864 struct bfa_fcxp_s *fcxp = cbarg;
865 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
866 struct bfi_fcxp_send_req_s *send_req;
868 fcxp->reqq_waiting = BFA_FALSE;
869 send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
870 bfa_fcxp_queue(fcxp, send_req);
874 * Queue fcxp send request to foimrware.
877 bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req)
879 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
880 struct bfa_fcxp_req_info_s *reqi = &fcxp->req_info;
881 struct bfa_fcxp_rsp_info_s *rspi = &fcxp->rsp_info;
882 struct bfa_rport_s *rport = reqi->bfa_rport;
884 bfi_h2i_set(send_req->mh, BFI_MC_FCXP, BFI_FCXP_H2I_SEND_REQ,
887 send_req->fcxp_tag = cpu_to_be16(fcxp->fcxp_tag);
889 send_req->rport_fw_hndl = rport->fw_handle;
890 send_req->max_frmsz = cpu_to_be16(rport->rport_info.max_frmsz);
891 if (send_req->max_frmsz == 0)
892 send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
894 send_req->rport_fw_hndl = 0;
895 send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
898 send_req->vf_id = cpu_to_be16(reqi->vf_id);
899 send_req->lp_tag = reqi->lp_tag;
900 send_req->class = reqi->class;
901 send_req->rsp_timeout = rspi->rsp_timeout;
902 send_req->cts = reqi->cts;
903 send_req->fchs = reqi->fchs;
905 send_req->req_len = cpu_to_be32(reqi->req_tot_len);
906 send_req->rsp_maxlen = cpu_to_be32(rspi->rsp_maxlen);
911 if (fcxp->use_ireqbuf == 1) {
912 hal_fcxp_set_local_sges(send_req->req_sge, reqi->req_tot_len,
913 BFA_FCXP_REQ_PLD_PA(fcxp));
915 if (fcxp->nreq_sgles > 0) {
916 bfa_assert(fcxp->nreq_sgles == 1);
917 hal_fcxp_set_local_sges(send_req->req_sge,
919 fcxp->req_sga_cbfn(fcxp->caller,
922 bfa_assert(reqi->req_tot_len == 0);
923 hal_fcxp_set_local_sges(send_req->rsp_sge, 0, 0);
930 if (fcxp->use_irspbuf == 1) {
931 bfa_assert(rspi->rsp_maxlen <= BFA_FCXP_MAX_LBUF_SZ);
933 hal_fcxp_set_local_sges(send_req->rsp_sge, rspi->rsp_maxlen,
934 BFA_FCXP_RSP_PLD_PA(fcxp));
937 if (fcxp->nrsp_sgles > 0) {
938 bfa_assert(fcxp->nrsp_sgles == 1);
939 hal_fcxp_set_local_sges(send_req->rsp_sge,
941 fcxp->rsp_sga_cbfn(fcxp->caller,
944 bfa_assert(rspi->rsp_maxlen == 0);
945 hal_fcxp_set_local_sges(send_req->rsp_sge, 0, 0);
949 hal_fcxp_tx_plog(bfa, reqi->req_tot_len, fcxp, &reqi->fchs);
951 bfa_reqq_produce(bfa, BFA_REQQ_FCXP);
953 bfa_trc(bfa, bfa_reqq_pi(bfa, BFA_REQQ_FCXP));
954 bfa_trc(bfa, bfa_reqq_ci(bfa, BFA_REQQ_FCXP));
958 * hal_fcxp_api BFA FCXP API
962 * Allocate an FCXP instance to send a response or to send a request
963 * that has a response. Request/response buffers are allocated by caller.
965 * @param[in] bfa BFA bfa instance
966 * @param[in] nreq_sgles Number of SG elements required for request
967 * buffer. 0, if fcxp internal buffers are used.
968 * Use bfa_fcxp_get_reqbuf() to get the
969 * internal req buffer.
970 * @param[in] req_sgles SG elements describing request buffer. Will be
971 * copied in by BFA and hence can be freed on
972 * return from this function.
973 * @param[in] get_req_sga function ptr to be called to get a request SG
974 * Address (given the sge index).
975 * @param[in] get_req_sglen function ptr to be called to get a request SG
976 * len (given the sge index).
977 * @param[in] get_rsp_sga function ptr to be called to get a response SG
978 * Address (given the sge index).
979 * @param[in] get_rsp_sglen function ptr to be called to get a response SG
980 * len (given the sge index).
982 * @return FCXP instance. NULL on failure.
985 bfa_fcxp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
986 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
987 bfa_fcxp_get_sglen_t req_sglen_cbfn,
988 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
989 bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
991 struct bfa_fcxp_s *fcxp = NULL;
993 bfa_assert(bfa != NULL);
995 fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa));
999 bfa_trc(bfa, fcxp->fcxp_tag);
1001 bfa_fcxp_init(fcxp, caller, bfa, nreq_sgles, nrsp_sgles, req_sga_cbfn,
1002 req_sglen_cbfn, rsp_sga_cbfn, rsp_sglen_cbfn);
1008 * Get the internal request buffer pointer
1010 * @param[in] fcxp BFA fcxp pointer
1012 * @return pointer to the internal request buffer
1015 bfa_fcxp_get_reqbuf(struct bfa_fcxp_s *fcxp)
1017 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
1020 bfa_assert(fcxp->use_ireqbuf == 1);
1021 reqbuf = ((u8 *)mod->req_pld_list_kva) +
1022 fcxp->fcxp_tag * mod->req_pld_sz;
1027 bfa_fcxp_get_reqbufsz(struct bfa_fcxp_s *fcxp)
1029 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
1031 return mod->req_pld_sz;
1035 * Get the internal response buffer pointer
1037 * @param[in] fcxp BFA fcxp pointer
1039 * @return pointer to the internal request buffer
1042 bfa_fcxp_get_rspbuf(struct bfa_fcxp_s *fcxp)
1044 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
1047 bfa_assert(fcxp->use_irspbuf == 1);
1049 rspbuf = ((u8 *)mod->rsp_pld_list_kva) +
1050 fcxp->fcxp_tag * mod->rsp_pld_sz;
1057 * @param[in] fcxp BFA fcxp pointer
1062 bfa_fcxp_free(struct bfa_fcxp_s *fcxp)
1064 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
1066 bfa_assert(fcxp != NULL);
1067 bfa_trc(mod->bfa, fcxp->fcxp_tag);
1072 * Send a FCXP request
1074 * @param[in] fcxp BFA fcxp pointer
1075 * @param[in] rport BFA rport pointer. Could be left NULL for WKA rports
1076 * @param[in] vf_id virtual Fabric ID
1077 * @param[in] lp_tag lport tag
1078 * @param[in] cts use Continous sequence
1079 * @param[in] cos fc Class of Service
1080 * @param[in] reqlen request length, does not include FCHS length
1081 * @param[in] fchs fc Header Pointer. The header content will be copied
1084 * @param[in] cbfn call back function to be called on receiving
1086 * @param[in] cbarg arg for cbfn
1087 * @param[in] rsp_timeout
1090 * @return bfa_status_t
1093 bfa_fcxp_send(struct bfa_fcxp_s *fcxp, struct bfa_rport_s *rport,
1094 u16 vf_id, u8 lp_tag, bfa_boolean_t cts, enum fc_cos cos,
1095 u32 reqlen, struct fchs_s *fchs, bfa_cb_fcxp_send_t cbfn,
1096 void *cbarg, u32 rsp_maxlen, u8 rsp_timeout)
1098 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
1099 struct bfa_fcxp_req_info_s *reqi = &fcxp->req_info;
1100 struct bfa_fcxp_rsp_info_s *rspi = &fcxp->rsp_info;
1101 struct bfi_fcxp_send_req_s *send_req;
1103 bfa_trc(bfa, fcxp->fcxp_tag);
1106 * setup request/response info
1108 reqi->bfa_rport = rport;
1109 reqi->vf_id = vf_id;
1110 reqi->lp_tag = lp_tag;
1112 rspi->rsp_timeout = rsp_timeout;
1115 reqi->req_tot_len = reqlen;
1116 rspi->rsp_maxlen = rsp_maxlen;
1117 fcxp->send_cbfn = cbfn ? cbfn : bfa_fcxp_null_comp;
1118 fcxp->send_cbarg = cbarg;
1121 * If no room in CPE queue, wait for space in request queue
1123 send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
1125 bfa_trc(bfa, fcxp->fcxp_tag);
1126 fcxp->reqq_waiting = BFA_TRUE;
1127 bfa_reqq_wait(bfa, BFA_REQQ_FCXP, &fcxp->reqq_wqe);
1131 bfa_fcxp_queue(fcxp, send_req);
1137 * @param[in] fcxp BFA fcxp pointer
1142 bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
1144 bfa_trc(fcxp->fcxp_mod->bfa, fcxp->fcxp_tag);
1146 return BFA_STATUS_OK;
1150 bfa_fcxp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
1151 bfa_fcxp_alloc_cbfn_t alloc_cbfn, void *alloc_cbarg,
1152 void *caller, int nreq_sgles,
1153 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
1154 bfa_fcxp_get_sglen_t req_sglen_cbfn,
1155 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
1156 bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
1158 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1160 bfa_assert(list_empty(&mod->fcxp_free_q));
1162 wqe->alloc_cbfn = alloc_cbfn;
1163 wqe->alloc_cbarg = alloc_cbarg;
1164 wqe->caller = caller;
1166 wqe->nreq_sgles = nreq_sgles;
1167 wqe->nrsp_sgles = nrsp_sgles;
1168 wqe->req_sga_cbfn = req_sga_cbfn;
1169 wqe->req_sglen_cbfn = req_sglen_cbfn;
1170 wqe->rsp_sga_cbfn = rsp_sga_cbfn;
1171 wqe->rsp_sglen_cbfn = rsp_sglen_cbfn;
1173 list_add_tail(&wqe->qe, &mod->wait_q);
1177 bfa_fcxp_walloc_cancel(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe)
1179 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1181 bfa_assert(bfa_q_is_on_q(&mod->wait_q, wqe));
1186 bfa_fcxp_discard(struct bfa_fcxp_s *fcxp)
1189 * If waiting for room in request queue, cancel reqq wait
1192 if (fcxp->reqq_waiting) {
1193 fcxp->reqq_waiting = BFA_FALSE;
1194 bfa_reqq_wcancel(&fcxp->reqq_wqe);
1195 bfa_fcxp_free(fcxp);
1199 fcxp->send_cbfn = bfa_fcxp_null_comp;
1205 * hal_fcxp_public BFA FCXP public functions
1209 bfa_fcxp_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
1211 switch (msg->mhdr.msg_id) {
1212 case BFI_FCXP_I2H_SEND_RSP:
1213 hal_fcxp_send_comp(bfa, (struct bfi_fcxp_send_rsp_s *) msg);
1217 bfa_trc(bfa, msg->mhdr.msg_id);
1223 bfa_fcxp_get_maxrsp(struct bfa_s *bfa)
1225 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1227 return mod->rsp_pld_sz;
1232 * BFA LPS state machine functions
1236 * Init state -- no login
1239 bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event)
1241 bfa_trc(lps->bfa, lps->lp_tag);
1242 bfa_trc(lps->bfa, event);
1245 case BFA_LPS_SM_LOGIN:
1246 if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1247 bfa_sm_set_state(lps, bfa_lps_sm_loginwait);
1248 bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1250 bfa_sm_set_state(lps, bfa_lps_sm_login);
1251 bfa_lps_send_login(lps);
1255 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1256 BFA_PL_EID_LOGIN, 0, "FDISC Request");
1258 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1259 BFA_PL_EID_LOGIN, 0, "FLOGI Request");
1262 case BFA_LPS_SM_LOGOUT:
1263 bfa_lps_logout_comp(lps);
1266 case BFA_LPS_SM_DELETE:
1270 case BFA_LPS_SM_RX_CVL:
1271 case BFA_LPS_SM_OFFLINE:
1274 case BFA_LPS_SM_FWRSP:
1276 * Could happen when fabric detects loopback and discards
1277 * the lps request. Fw will eventually sent out the timeout
1283 bfa_sm_fault(lps->bfa, event);
1288 * login is in progress -- awaiting response from firmware
1291 bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
1293 bfa_trc(lps->bfa, lps->lp_tag);
1294 bfa_trc(lps->bfa, event);
1297 case BFA_LPS_SM_FWRSP:
1298 if (lps->status == BFA_STATUS_OK) {
1299 bfa_sm_set_state(lps, bfa_lps_sm_online);
1301 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1302 BFA_PL_EID_LOGIN, 0, "FDISC Accept");
1304 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1305 BFA_PL_EID_LOGIN, 0, "FLOGI Accept");
1307 bfa_sm_set_state(lps, bfa_lps_sm_init);
1309 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1310 BFA_PL_EID_LOGIN, 0,
1311 "FDISC Fail (RJT or timeout)");
1313 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1314 BFA_PL_EID_LOGIN, 0,
1315 "FLOGI Fail (RJT or timeout)");
1317 bfa_lps_login_comp(lps);
1320 case BFA_LPS_SM_OFFLINE:
1321 bfa_sm_set_state(lps, bfa_lps_sm_init);
1325 bfa_sm_fault(lps->bfa, event);
1330 * login pending - awaiting space in request queue
1333 bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1335 bfa_trc(lps->bfa, lps->lp_tag);
1336 bfa_trc(lps->bfa, event);
1339 case BFA_LPS_SM_RESUME:
1340 bfa_sm_set_state(lps, bfa_lps_sm_login);
1343 case BFA_LPS_SM_OFFLINE:
1344 bfa_sm_set_state(lps, bfa_lps_sm_init);
1345 bfa_reqq_wcancel(&lps->wqe);
1348 case BFA_LPS_SM_RX_CVL:
1350 * Login was not even sent out; so when getting out
1351 * of this state, it will appear like a login retry
1352 * after Clear virtual link
1357 bfa_sm_fault(lps->bfa, event);
1365 bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event)
1367 bfa_trc(lps->bfa, lps->lp_tag);
1368 bfa_trc(lps->bfa, event);
1371 case BFA_LPS_SM_LOGOUT:
1372 if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1373 bfa_sm_set_state(lps, bfa_lps_sm_logowait);
1374 bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1376 bfa_sm_set_state(lps, bfa_lps_sm_logout);
1377 bfa_lps_send_logout(lps);
1379 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1380 BFA_PL_EID_LOGO, 0, "Logout");
1383 case BFA_LPS_SM_RX_CVL:
1384 bfa_sm_set_state(lps, bfa_lps_sm_init);
1386 /* Let the vport module know about this event */
1387 bfa_lps_cvl_event(lps);
1388 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1389 BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx");
1392 case BFA_LPS_SM_OFFLINE:
1393 case BFA_LPS_SM_DELETE:
1394 bfa_sm_set_state(lps, bfa_lps_sm_init);
1398 bfa_sm_fault(lps->bfa, event);
1403 * logout in progress - awaiting firmware response
1406 bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event)
1408 bfa_trc(lps->bfa, lps->lp_tag);
1409 bfa_trc(lps->bfa, event);
1412 case BFA_LPS_SM_FWRSP:
1413 bfa_sm_set_state(lps, bfa_lps_sm_init);
1414 bfa_lps_logout_comp(lps);
1417 case BFA_LPS_SM_OFFLINE:
1418 bfa_sm_set_state(lps, bfa_lps_sm_init);
1422 bfa_sm_fault(lps->bfa, event);
1427 * logout pending -- awaiting space in request queue
1430 bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1432 bfa_trc(lps->bfa, lps->lp_tag);
1433 bfa_trc(lps->bfa, event);
1436 case BFA_LPS_SM_RESUME:
1437 bfa_sm_set_state(lps, bfa_lps_sm_logout);
1438 bfa_lps_send_logout(lps);
1441 case BFA_LPS_SM_OFFLINE:
1442 bfa_sm_set_state(lps, bfa_lps_sm_init);
1443 bfa_reqq_wcancel(&lps->wqe);
1447 bfa_sm_fault(lps->bfa, event);
1454 * lps_pvt BFA LPS private functions
1458 * return memory requirement
1461 bfa_lps_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
1464 if (cfg->drvcfg.min_cfg)
1465 *ndm_len += sizeof(struct bfa_lps_s) * BFA_LPS_MIN_LPORTS;
1467 *ndm_len += sizeof(struct bfa_lps_s) * BFA_LPS_MAX_LPORTS;
1471 * bfa module attach at initialization time
1474 bfa_lps_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1475 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
1477 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1478 struct bfa_lps_s *lps;
1481 memset(mod, 0, sizeof(struct bfa_lps_mod_s));
1482 mod->num_lps = BFA_LPS_MAX_LPORTS;
1483 if (cfg->drvcfg.min_cfg)
1484 mod->num_lps = BFA_LPS_MIN_LPORTS;
1486 mod->num_lps = BFA_LPS_MAX_LPORTS;
1487 mod->lps_arr = lps = (struct bfa_lps_s *) bfa_meminfo_kva(meminfo);
1489 bfa_meminfo_kva(meminfo) += mod->num_lps * sizeof(struct bfa_lps_s);
1491 INIT_LIST_HEAD(&mod->lps_free_q);
1492 INIT_LIST_HEAD(&mod->lps_active_q);
1494 for (i = 0; i < mod->num_lps; i++, lps++) {
1496 lps->lp_tag = (u8) i;
1497 lps->reqq = BFA_REQQ_LPS;
1498 bfa_reqq_winit(&lps->wqe, bfa_lps_reqq_resume, lps);
1499 list_add_tail(&lps->qe, &mod->lps_free_q);
1504 bfa_lps_detach(struct bfa_s *bfa)
1509 bfa_lps_start(struct bfa_s *bfa)
1514 bfa_lps_stop(struct bfa_s *bfa)
1519 * IOC in disabled state -- consider all lps offline
1522 bfa_lps_iocdisable(struct bfa_s *bfa)
1524 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1525 struct bfa_lps_s *lps;
1526 struct list_head *qe, *qen;
1528 list_for_each_safe(qe, qen, &mod->lps_active_q) {
1529 lps = (struct bfa_lps_s *) qe;
1530 bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE);
1535 * Firmware login response
1538 bfa_lps_login_rsp(struct bfa_s *bfa, struct bfi_lps_login_rsp_s *rsp)
1540 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1541 struct bfa_lps_s *lps;
1543 bfa_assert(rsp->lp_tag < mod->num_lps);
1544 lps = BFA_LPS_FROM_TAG(mod, rsp->lp_tag);
1546 lps->status = rsp->status;
1547 switch (rsp->status) {
1549 lps->fport = rsp->f_port;
1550 lps->npiv_en = rsp->npiv_en;
1551 lps->lp_pid = rsp->lp_pid;
1552 lps->pr_bbcred = be16_to_cpu(rsp->bb_credit);
1553 lps->pr_pwwn = rsp->port_name;
1554 lps->pr_nwwn = rsp->node_name;
1555 lps->auth_req = rsp->auth_req;
1556 lps->lp_mac = rsp->lp_mac;
1557 lps->brcd_switch = rsp->brcd_switch;
1558 lps->fcf_mac = rsp->fcf_mac;
1562 case BFA_STATUS_FABRIC_RJT:
1563 lps->lsrjt_rsn = rsp->lsrjt_rsn;
1564 lps->lsrjt_expl = rsp->lsrjt_expl;
1568 case BFA_STATUS_EPROTOCOL:
1569 lps->ext_status = rsp->ext_status;
1574 /* Nothing to do with other status */
1578 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1582 * Firmware logout response
1585 bfa_lps_logout_rsp(struct bfa_s *bfa, struct bfi_lps_logout_rsp_s *rsp)
1587 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1588 struct bfa_lps_s *lps;
1590 bfa_assert(rsp->lp_tag < mod->num_lps);
1591 lps = BFA_LPS_FROM_TAG(mod, rsp->lp_tag);
1593 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1597 * Firmware received a Clear virtual link request (for FCoE)
1600 bfa_lps_rx_cvl_event(struct bfa_s *bfa, struct bfi_lps_cvl_event_s *cvl)
1602 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1603 struct bfa_lps_s *lps;
1605 lps = BFA_LPS_FROM_TAG(mod, cvl->lp_tag);
1607 bfa_sm_send_event(lps, BFA_LPS_SM_RX_CVL);
1611 * Space is available in request queue, resume queueing request to firmware.
1614 bfa_lps_reqq_resume(void *lps_arg)
1616 struct bfa_lps_s *lps = lps_arg;
1618 bfa_sm_send_event(lps, BFA_LPS_SM_RESUME);
1622 * lps is freed -- triggered by vport delete
1625 bfa_lps_free(struct bfa_lps_s *lps)
1627 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(lps->bfa);
1631 list_add_tail(&lps->qe, &mod->lps_free_q);
1635 * send login request to firmware
1638 bfa_lps_send_login(struct bfa_lps_s *lps)
1640 struct bfi_lps_login_req_s *m;
1642 m = bfa_reqq_next(lps->bfa, lps->reqq);
1645 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGIN_REQ,
1646 bfa_lpuid(lps->bfa));
1648 m->lp_tag = lps->lp_tag;
1649 m->alpa = lps->alpa;
1650 m->pdu_size = cpu_to_be16(lps->pdusz);
1651 m->pwwn = lps->pwwn;
1652 m->nwwn = lps->nwwn;
1653 m->fdisc = lps->fdisc;
1654 m->auth_en = lps->auth_en;
1656 bfa_reqq_produce(lps->bfa, lps->reqq);
1660 * send logout request to firmware
1663 bfa_lps_send_logout(struct bfa_lps_s *lps)
1665 struct bfi_lps_logout_req_s *m;
1667 m = bfa_reqq_next(lps->bfa, lps->reqq);
1670 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGOUT_REQ,
1671 bfa_lpuid(lps->bfa));
1673 m->lp_tag = lps->lp_tag;
1674 m->port_name = lps->pwwn;
1675 bfa_reqq_produce(lps->bfa, lps->reqq);
1679 * Indirect login completion handler for non-fcs
1682 bfa_lps_login_comp_cb(void *arg, bfa_boolean_t complete)
1684 struct bfa_lps_s *lps = arg;
1690 bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status);
1692 bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1696 * Login completion handler -- direct call for fcs, queue for others
1699 bfa_lps_login_comp(struct bfa_lps_s *lps)
1701 if (!lps->bfa->fcs) {
1702 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_login_comp_cb,
1708 bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status);
1710 bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1714 * Indirect logout completion handler for non-fcs
1717 bfa_lps_logout_comp_cb(void *arg, bfa_boolean_t complete)
1719 struct bfa_lps_s *lps = arg;
1725 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
1729 * Logout completion handler -- direct call for fcs, queue for others
1732 bfa_lps_logout_comp(struct bfa_lps_s *lps)
1734 if (!lps->bfa->fcs) {
1735 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_logout_comp_cb,
1740 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
1744 * Clear virtual link completion handler for non-fcs
1747 bfa_lps_cvl_event_cb(void *arg, bfa_boolean_t complete)
1749 struct bfa_lps_s *lps = arg;
1754 /* Clear virtual link to base port will result in link down */
1756 bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
1760 * Received Clear virtual link event --direct call for fcs,
1764 bfa_lps_cvl_event(struct bfa_lps_s *lps)
1766 if (!lps->bfa->fcs) {
1767 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_cvl_event_cb,
1772 /* Clear virtual link to base port will result in link down */
1774 bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
1780 * lps_public BFA LPS public functions
1784 bfa_lps_get_max_vport(struct bfa_s *bfa)
1786 if (bfa_ioc_devid(&bfa->ioc) == BFA_PCI_DEVICE_ID_CT)
1787 return BFA_LPS_MAX_VPORTS_SUPP_CT;
1789 return BFA_LPS_MAX_VPORTS_SUPP_CB;
1793 * Allocate a lport srvice tag.
1796 bfa_lps_alloc(struct bfa_s *bfa)
1798 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1799 struct bfa_lps_s *lps = NULL;
1801 bfa_q_deq(&mod->lps_free_q, &lps);
1806 list_add_tail(&lps->qe, &mod->lps_active_q);
1808 bfa_sm_set_state(lps, bfa_lps_sm_init);
1813 * Free lport service tag. This can be called anytime after an alloc.
1814 * No need to wait for any pending login/logout completions.
1817 bfa_lps_delete(struct bfa_lps_s *lps)
1819 bfa_sm_send_event(lps, BFA_LPS_SM_DELETE);
1823 * Initiate a lport login.
1826 bfa_lps_flogi(struct bfa_lps_s *lps, void *uarg, u8 alpa, u16 pdusz,
1827 wwn_t pwwn, wwn_t nwwn, bfa_boolean_t auth_en)
1834 lps->fdisc = BFA_FALSE;
1835 lps->auth_en = auth_en;
1836 bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
1840 * Initiate a lport fdisc login.
1843 bfa_lps_fdisc(struct bfa_lps_s *lps, void *uarg, u16 pdusz, wwn_t pwwn,
1851 lps->fdisc = BFA_TRUE;
1852 lps->auth_en = BFA_FALSE;
1853 bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
1857 * Initiate a lport logout (flogi).
1860 bfa_lps_flogo(struct bfa_lps_s *lps)
1862 bfa_sm_send_event(lps, BFA_LPS_SM_LOGOUT);
1866 * Initiate a lport FDSIC logout.
1869 bfa_lps_fdisclogo(struct bfa_lps_s *lps)
1871 bfa_sm_send_event(lps, BFA_LPS_SM_LOGOUT);
1875 * Discard a pending login request -- should be called only for
1876 * link down handling.
1879 bfa_lps_discard(struct bfa_lps_s *lps)
1881 bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE);
1885 * Return lport services tag
1888 bfa_lps_get_tag(struct bfa_lps_s *lps)
1894 * Return lport services tag given the pid
1897 bfa_lps_get_tag_from_pid(struct bfa_s *bfa, u32 pid)
1899 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1900 struct bfa_lps_s *lps;
1903 for (i = 0, lps = mod->lps_arr; i < mod->num_lps; i++, lps++) {
1904 if (lps->lp_pid == pid)
1908 /* Return base port tag anyway */
1913 * return if fabric login indicates support for NPIV
1916 bfa_lps_is_npiv_en(struct bfa_lps_s *lps)
1918 return lps->npiv_en;
1922 * Return TRUE if attached to F-Port, else return FALSE
1925 bfa_lps_is_fport(struct bfa_lps_s *lps)
1931 * Return TRUE if attached to a Brocade Fabric
1934 bfa_lps_is_brcd_fabric(struct bfa_lps_s *lps)
1936 return lps->brcd_switch;
1939 * return TRUE if authentication is required
1942 bfa_lps_is_authreq(struct bfa_lps_s *lps)
1944 return lps->auth_req;
1948 bfa_lps_get_extstatus(struct bfa_lps_s *lps)
1950 return lps->ext_status;
1954 * return port id assigned to the lport
1957 bfa_lps_get_pid(struct bfa_lps_s *lps)
1963 * return port id assigned to the base lport
1966 bfa_lps_get_base_pid(struct bfa_s *bfa)
1968 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1970 return BFA_LPS_FROM_TAG(mod, 0)->lp_pid;
1974 * Return bb_credit assigned in FLOGI response
1977 bfa_lps_get_peer_bbcredit(struct bfa_lps_s *lps)
1979 return lps->pr_bbcred;
1983 * Return peer port name
1986 bfa_lps_get_peer_pwwn(struct bfa_lps_s *lps)
1988 return lps->pr_pwwn;
1992 * Return peer node name
1995 bfa_lps_get_peer_nwwn(struct bfa_lps_s *lps)
1997 return lps->pr_nwwn;
2001 * return reason code if login request is rejected
2004 bfa_lps_get_lsrjt_rsn(struct bfa_lps_s *lps)
2006 return lps->lsrjt_rsn;
2010 * return explanation code if login request is rejected
2013 bfa_lps_get_lsrjt_expl(struct bfa_lps_s *lps)
2015 return lps->lsrjt_expl;
2019 * Return fpma/spma MAC for lport
2022 bfa_lps_get_lp_mac(struct bfa_lps_s *lps)
2028 * LPS firmware message class handler.
2031 bfa_lps_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
2033 union bfi_lps_i2h_msg_u msg;
2035 bfa_trc(bfa, m->mhdr.msg_id);
2038 switch (m->mhdr.msg_id) {
2039 case BFI_LPS_H2I_LOGIN_RSP:
2040 bfa_lps_login_rsp(bfa, msg.login_rsp);
2043 case BFI_LPS_H2I_LOGOUT_RSP:
2044 bfa_lps_logout_rsp(bfa, msg.logout_rsp);
2047 case BFI_LPS_H2I_CVL_EVENT:
2048 bfa_lps_rx_cvl_event(bfa, msg.cvl_event);
2052 bfa_trc(bfa, m->mhdr.msg_id);
2058 * FC PORT state machine functions
2061 bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
2062 enum bfa_fcport_sm_event event)
2064 bfa_trc(fcport->bfa, event);
2067 case BFA_FCPORT_SM_START:
2069 * Start event after IOC is configured and BFA is started.
2071 if (bfa_fcport_send_enable(fcport)) {
2072 bfa_trc(fcport->bfa, BFA_TRUE);
2073 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2075 bfa_trc(fcport->bfa, BFA_FALSE);
2076 bfa_sm_set_state(fcport,
2077 bfa_fcport_sm_enabling_qwait);
2081 case BFA_FCPORT_SM_ENABLE:
2083 * Port is persistently configured to be in enabled state. Do
2084 * not change state. Port enabling is done when START event is
2089 case BFA_FCPORT_SM_DISABLE:
2091 * If a port is persistently configured to be disabled, the
2092 * first event will a port disable request.
2094 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2097 case BFA_FCPORT_SM_HWFAIL:
2098 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2102 bfa_sm_fault(fcport->bfa, event);
2107 bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
2108 enum bfa_fcport_sm_event event)
2110 char pwwn_buf[BFA_STRING_32];
2111 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2112 bfa_trc(fcport->bfa, event);
2115 case BFA_FCPORT_SM_QRESUME:
2116 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2117 bfa_fcport_send_enable(fcport);
2120 case BFA_FCPORT_SM_STOP:
2121 bfa_reqq_wcancel(&fcport->reqq_wait);
2122 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2125 case BFA_FCPORT_SM_ENABLE:
2127 * Already enable is in progress.
2131 case BFA_FCPORT_SM_DISABLE:
2133 * Just send disable request to firmware when room becomes
2134 * available in request queue.
2136 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2137 bfa_reqq_wcancel(&fcport->reqq_wait);
2138 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2139 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2140 wwn2str(pwwn_buf, fcport->pwwn);
2141 BFA_LOG(KERN_INFO, bfad, log_level,
2142 "Base port disabled: WWN = %s\n", pwwn_buf);
2145 case BFA_FCPORT_SM_LINKUP:
2146 case BFA_FCPORT_SM_LINKDOWN:
2148 * Possible to get link events when doing back-to-back
2153 case BFA_FCPORT_SM_HWFAIL:
2154 bfa_reqq_wcancel(&fcport->reqq_wait);
2155 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2159 bfa_sm_fault(fcport->bfa, event);
2164 bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
2165 enum bfa_fcport_sm_event event)
2167 char pwwn_buf[BFA_STRING_32];
2168 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2169 bfa_trc(fcport->bfa, event);
2172 case BFA_FCPORT_SM_FWRSP:
2173 case BFA_FCPORT_SM_LINKDOWN:
2174 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
2177 case BFA_FCPORT_SM_LINKUP:
2178 bfa_fcport_update_linkinfo(fcport);
2179 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
2181 bfa_assert(fcport->event_cbfn);
2182 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2185 case BFA_FCPORT_SM_ENABLE:
2187 * Already being enabled.
2191 case BFA_FCPORT_SM_DISABLE:
2192 if (bfa_fcport_send_disable(fcport))
2193 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2195 bfa_sm_set_state(fcport,
2196 bfa_fcport_sm_disabling_qwait);
2198 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2199 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2200 wwn2str(pwwn_buf, fcport->pwwn);
2201 BFA_LOG(KERN_INFO, bfad, log_level,
2202 "Base port disabled: WWN = %s\n", pwwn_buf);
2205 case BFA_FCPORT_SM_STOP:
2206 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2209 case BFA_FCPORT_SM_HWFAIL:
2210 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2214 bfa_sm_fault(fcport->bfa, event);
2219 bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
2220 enum bfa_fcport_sm_event event)
2222 struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
2223 char pwwn_buf[BFA_STRING_32];
2224 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2226 bfa_trc(fcport->bfa, event);
2229 case BFA_FCPORT_SM_LINKUP:
2230 bfa_fcport_update_linkinfo(fcport);
2231 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
2232 bfa_assert(fcport->event_cbfn);
2233 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2234 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup");
2235 if (!bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
2237 bfa_trc(fcport->bfa,
2238 pevent->link_state.vc_fcf.fcf.fipenabled);
2239 bfa_trc(fcport->bfa,
2240 pevent->link_state.vc_fcf.fcf.fipfailed);
2242 if (pevent->link_state.vc_fcf.fcf.fipfailed)
2243 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2244 BFA_PL_EID_FIP_FCF_DISC, 0,
2245 "FIP FCF Discovery Failed");
2247 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2248 BFA_PL_EID_FIP_FCF_DISC, 0,
2249 "FIP FCF Discovered");
2252 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2253 wwn2str(pwwn_buf, fcport->pwwn);
2254 BFA_LOG(KERN_INFO, bfad, log_level,
2255 "Base port online: WWN = %s\n", pwwn_buf);
2258 case BFA_FCPORT_SM_LINKDOWN:
2260 * Possible to get link down event.
2264 case BFA_FCPORT_SM_ENABLE:
2270 case BFA_FCPORT_SM_DISABLE:
2271 if (bfa_fcport_send_disable(fcport))
2272 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2274 bfa_sm_set_state(fcport,
2275 bfa_fcport_sm_disabling_qwait);
2277 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2278 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2279 wwn2str(pwwn_buf, fcport->pwwn);
2280 BFA_LOG(KERN_INFO, bfad, log_level,
2281 "Base port disabled: WWN = %s\n", pwwn_buf);
2284 case BFA_FCPORT_SM_STOP:
2285 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2288 case BFA_FCPORT_SM_HWFAIL:
2289 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2293 bfa_sm_fault(fcport->bfa, event);
2298 bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
2299 enum bfa_fcport_sm_event event)
2301 char pwwn_buf[BFA_STRING_32];
2302 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2304 bfa_trc(fcport->bfa, event);
2307 case BFA_FCPORT_SM_ENABLE:
2313 case BFA_FCPORT_SM_DISABLE:
2314 if (bfa_fcport_send_disable(fcport))
2315 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2317 bfa_sm_set_state(fcport,
2318 bfa_fcport_sm_disabling_qwait);
2320 bfa_fcport_reset_linkinfo(fcport);
2321 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2322 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2323 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2324 wwn2str(pwwn_buf, fcport->pwwn);
2325 BFA_LOG(KERN_INFO, bfad, log_level,
2326 "Base port offline: WWN = %s\n", pwwn_buf);
2327 BFA_LOG(KERN_INFO, bfad, log_level,
2328 "Base port disabled: WWN = %s\n", pwwn_buf);
2331 case BFA_FCPORT_SM_LINKDOWN:
2332 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
2333 bfa_fcport_reset_linkinfo(fcport);
2334 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2335 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2336 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
2337 wwn2str(pwwn_buf, fcport->pwwn);
2338 if (BFA_PORT_IS_DISABLED(fcport->bfa))
2339 BFA_LOG(KERN_INFO, bfad, log_level,
2340 "Base port offline: WWN = %s\n", pwwn_buf);
2342 BFA_LOG(KERN_ERR, bfad, log_level,
2343 "Base port (WWN = %s) "
2344 "lost fabric connectivity\n", pwwn_buf);
2347 case BFA_FCPORT_SM_STOP:
2348 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2349 bfa_fcport_reset_linkinfo(fcport);
2350 wwn2str(pwwn_buf, fcport->pwwn);
2351 if (BFA_PORT_IS_DISABLED(fcport->bfa))
2352 BFA_LOG(KERN_INFO, bfad, log_level,
2353 "Base port offline: WWN = %s\n", pwwn_buf);
2355 BFA_LOG(KERN_ERR, bfad, log_level,
2356 "Base port (WWN = %s) "
2357 "lost fabric connectivity\n", pwwn_buf);
2360 case BFA_FCPORT_SM_HWFAIL:
2361 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2362 bfa_fcport_reset_linkinfo(fcport);
2363 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2364 wwn2str(pwwn_buf, fcport->pwwn);
2365 if (BFA_PORT_IS_DISABLED(fcport->bfa))
2366 BFA_LOG(KERN_INFO, bfad, log_level,
2367 "Base port offline: WWN = %s\n", pwwn_buf);
2369 BFA_LOG(KERN_ERR, bfad, log_level,
2370 "Base port (WWN = %s) "
2371 "lost fabric connectivity\n", pwwn_buf);
2375 bfa_sm_fault(fcport->bfa, event);
2380 bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
2381 enum bfa_fcport_sm_event event)
2383 bfa_trc(fcport->bfa, event);
2386 case BFA_FCPORT_SM_QRESUME:
2387 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2388 bfa_fcport_send_disable(fcport);
2391 case BFA_FCPORT_SM_STOP:
2392 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2393 bfa_reqq_wcancel(&fcport->reqq_wait);
2396 case BFA_FCPORT_SM_ENABLE:
2397 bfa_sm_set_state(fcport, bfa_fcport_sm_toggling_qwait);
2400 case BFA_FCPORT_SM_DISABLE:
2402 * Already being disabled.
2406 case BFA_FCPORT_SM_LINKUP:
2407 case BFA_FCPORT_SM_LINKDOWN:
2409 * Possible to get link events when doing back-to-back
2414 case BFA_FCPORT_SM_HWFAIL:
2415 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2416 bfa_reqq_wcancel(&fcport->reqq_wait);
2420 bfa_sm_fault(fcport->bfa, event);
2425 bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
2426 enum bfa_fcport_sm_event event)
2428 bfa_trc(fcport->bfa, event);
2431 case BFA_FCPORT_SM_QRESUME:
2432 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2433 bfa_fcport_send_disable(fcport);
2434 if (bfa_fcport_send_enable(fcport))
2435 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2437 bfa_sm_set_state(fcport,
2438 bfa_fcport_sm_enabling_qwait);
2441 case BFA_FCPORT_SM_STOP:
2442 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2443 bfa_reqq_wcancel(&fcport->reqq_wait);
2446 case BFA_FCPORT_SM_ENABLE:
2449 case BFA_FCPORT_SM_DISABLE:
2450 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
2453 case BFA_FCPORT_SM_LINKUP:
2454 case BFA_FCPORT_SM_LINKDOWN:
2456 * Possible to get link events when doing back-to-back
2461 case BFA_FCPORT_SM_HWFAIL:
2462 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2463 bfa_reqq_wcancel(&fcport->reqq_wait);
2467 bfa_sm_fault(fcport->bfa, event);
2472 bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
2473 enum bfa_fcport_sm_event event)
2475 char pwwn_buf[BFA_STRING_32];
2476 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2477 bfa_trc(fcport->bfa, event);
2480 case BFA_FCPORT_SM_FWRSP:
2481 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2484 case BFA_FCPORT_SM_DISABLE:
2486 * Already being disabled.
2490 case BFA_FCPORT_SM_ENABLE:
2491 if (bfa_fcport_send_enable(fcport))
2492 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2494 bfa_sm_set_state(fcport,
2495 bfa_fcport_sm_enabling_qwait);
2497 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2498 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2499 wwn2str(pwwn_buf, fcport->pwwn);
2500 BFA_LOG(KERN_INFO, bfad, log_level,
2501 "Base port enabled: WWN = %s\n", pwwn_buf);
2504 case BFA_FCPORT_SM_STOP:
2505 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2508 case BFA_FCPORT_SM_LINKUP:
2509 case BFA_FCPORT_SM_LINKDOWN:
2511 * Possible to get link events when doing back-to-back
2516 case BFA_FCPORT_SM_HWFAIL:
2517 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2521 bfa_sm_fault(fcport->bfa, event);
2526 bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
2527 enum bfa_fcport_sm_event event)
2529 char pwwn_buf[BFA_STRING_32];
2530 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2531 bfa_trc(fcport->bfa, event);
2534 case BFA_FCPORT_SM_START:
2536 * Ignore start event for a port that is disabled.
2540 case BFA_FCPORT_SM_STOP:
2541 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2544 case BFA_FCPORT_SM_ENABLE:
2545 if (bfa_fcport_send_enable(fcport))
2546 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2548 bfa_sm_set_state(fcport,
2549 bfa_fcport_sm_enabling_qwait);
2551 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2552 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2553 wwn2str(pwwn_buf, fcport->pwwn);
2554 BFA_LOG(KERN_INFO, bfad, log_level,
2555 "Base port enabled: WWN = %s\n", pwwn_buf);
2558 case BFA_FCPORT_SM_DISABLE:
2564 case BFA_FCPORT_SM_HWFAIL:
2565 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2569 bfa_sm_fault(fcport->bfa, event);
2574 bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
2575 enum bfa_fcport_sm_event event)
2577 bfa_trc(fcport->bfa, event);
2580 case BFA_FCPORT_SM_START:
2581 if (bfa_fcport_send_enable(fcport))
2582 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2584 bfa_sm_set_state(fcport,
2585 bfa_fcport_sm_enabling_qwait);
2590 * Ignore all other events.
2597 * Port is enabled. IOC is down/failed.
2600 bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
2601 enum bfa_fcport_sm_event event)
2603 bfa_trc(fcport->bfa, event);
2606 case BFA_FCPORT_SM_START:
2607 if (bfa_fcport_send_enable(fcport))
2608 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2610 bfa_sm_set_state(fcport,
2611 bfa_fcport_sm_enabling_qwait);
2616 * Ignore all events.
2623 * Port is disabled. IOC is down/failed.
2626 bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
2627 enum bfa_fcport_sm_event event)
2629 bfa_trc(fcport->bfa, event);
2632 case BFA_FCPORT_SM_START:
2633 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2636 case BFA_FCPORT_SM_ENABLE:
2637 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2642 * Ignore all events.
2649 * Link state is down
2652 bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
2653 enum bfa_fcport_ln_sm_event event)
2655 bfa_trc(ln->fcport->bfa, event);
2658 case BFA_FCPORT_LN_SM_LINKUP:
2659 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2660 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2664 bfa_sm_fault(ln->fcport->bfa, event);
2669 * Link state is waiting for down notification
2672 bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
2673 enum bfa_fcport_ln_sm_event event)
2675 bfa_trc(ln->fcport->bfa, event);
2678 case BFA_FCPORT_LN_SM_LINKUP:
2679 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2682 case BFA_FCPORT_LN_SM_NOTIFICATION:
2683 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
2687 bfa_sm_fault(ln->fcport->bfa, event);
2692 * Link state is waiting for down notification and there is a pending up
2695 bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
2696 enum bfa_fcport_ln_sm_event event)
2698 bfa_trc(ln->fcport->bfa, event);
2701 case BFA_FCPORT_LN_SM_LINKDOWN:
2702 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2705 case BFA_FCPORT_LN_SM_NOTIFICATION:
2706 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2707 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2711 bfa_sm_fault(ln->fcport->bfa, event);
2719 bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
2720 enum bfa_fcport_ln_sm_event event)
2722 bfa_trc(ln->fcport->bfa, event);
2725 case BFA_FCPORT_LN_SM_LINKDOWN:
2726 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2727 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2731 bfa_sm_fault(ln->fcport->bfa, event);
2736 * Link state is waiting for up notification
2739 bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
2740 enum bfa_fcport_ln_sm_event event)
2742 bfa_trc(ln->fcport->bfa, event);
2745 case BFA_FCPORT_LN_SM_LINKDOWN:
2746 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2749 case BFA_FCPORT_LN_SM_NOTIFICATION:
2750 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up);
2754 bfa_sm_fault(ln->fcport->bfa, event);
2759 * Link state is waiting for up notification and there is a pending down
2762 bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
2763 enum bfa_fcport_ln_sm_event event)
2765 bfa_trc(ln->fcport->bfa, event);
2768 case BFA_FCPORT_LN_SM_LINKUP:
2769 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_up_nf);
2772 case BFA_FCPORT_LN_SM_NOTIFICATION:
2773 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2774 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2778 bfa_sm_fault(ln->fcport->bfa, event);
2783 * Link state is waiting for up notification and there are pending down and up
2786 bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
2787 enum bfa_fcport_ln_sm_event event)
2789 bfa_trc(ln->fcport->bfa, event);
2792 case BFA_FCPORT_LN_SM_LINKDOWN:
2793 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2796 case BFA_FCPORT_LN_SM_NOTIFICATION:
2797 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2798 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2802 bfa_sm_fault(ln->fcport->bfa, event);
2813 __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete)
2815 struct bfa_fcport_ln_s *ln = cbarg;
2818 ln->fcport->event_cbfn(ln->fcport->event_cbarg, ln->ln_event);
2820 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2824 * Send SCN notification to upper layers.
2825 * trunk - false if caller is fcport to ignore fcport event in trunked mode
2828 bfa_fcport_scn(struct bfa_fcport_s *fcport, enum bfa_port_linkstate event,
2829 bfa_boolean_t trunk)
2831 if (fcport->cfg.trunked && !trunk)
2835 case BFA_PORT_LINKUP:
2836 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP);
2838 case BFA_PORT_LINKDOWN:
2839 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
2847 bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_port_linkstate event)
2849 struct bfa_fcport_s *fcport = ln->fcport;
2851 if (fcport->bfa->fcs) {
2852 fcport->event_cbfn(fcport->event_cbarg, event);
2853 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2855 ln->ln_event = event;
2856 bfa_cb_queue(fcport->bfa, &ln->ln_qe,
2857 __bfa_cb_fcport_event, ln);
2861 #define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \
2865 bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
2868 *dm_len += FCPORT_STATS_DMA_SZ;
2872 bfa_fcport_qresume(void *cbarg)
2874 struct bfa_fcport_s *fcport = cbarg;
2876 bfa_sm_send_event(fcport, BFA_FCPORT_SM_QRESUME);
2880 bfa_fcport_mem_claim(struct bfa_fcport_s *fcport, struct bfa_meminfo_s *meminfo)
2885 dm_kva = bfa_meminfo_dma_virt(meminfo);
2886 dm_pa = bfa_meminfo_dma_phys(meminfo);
2888 fcport->stats_kva = dm_kva;
2889 fcport->stats_pa = dm_pa;
2890 fcport->stats = (union bfa_fcport_stats_u *) dm_kva;
2892 dm_kva += FCPORT_STATS_DMA_SZ;
2893 dm_pa += FCPORT_STATS_DMA_SZ;
2895 bfa_meminfo_dma_virt(meminfo) = dm_kva;
2896 bfa_meminfo_dma_phys(meminfo) = dm_pa;
2900 * Memory initialization.
2903 bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
2904 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
2906 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
2907 struct bfa_port_cfg_s *port_cfg = &fcport->cfg;
2908 struct bfa_fcport_ln_s *ln = &fcport->ln;
2909 struct bfa_timeval_s tv;
2911 memset(fcport, 0, sizeof(struct bfa_fcport_s));
2913 ln->fcport = fcport;
2915 bfa_fcport_mem_claim(fcport, meminfo);
2917 bfa_sm_set_state(fcport, bfa_fcport_sm_uninit);
2918 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
2921 * initialize time stamp for stats reset
2923 bfa_os_gettimeofday(&tv);
2924 fcport->stats_reset_time = tv.tv_sec;
2927 * initialize and set default configuration
2929 port_cfg->topology = BFA_PORT_TOPOLOGY_P2P;
2930 port_cfg->speed = BFA_PORT_SPEED_AUTO;
2931 port_cfg->trunked = BFA_FALSE;
2932 port_cfg->maxfrsize = 0;
2934 port_cfg->trl_def_speed = BFA_PORT_SPEED_1GBPS;
2936 bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport);
2940 bfa_fcport_detach(struct bfa_s *bfa)
2945 * Called when IOC is ready.
2948 bfa_fcport_start(struct bfa_s *bfa)
2950 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_START);
2954 * Called before IOC is stopped.
2957 bfa_fcport_stop(struct bfa_s *bfa)
2959 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_STOP);
2960 bfa_trunk_iocdisable(bfa);
2964 * Called when IOC failure is detected.
2967 bfa_fcport_iocdisable(struct bfa_s *bfa)
2969 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
2971 bfa_sm_send_event(fcport, BFA_FCPORT_SM_HWFAIL);
2972 bfa_trunk_iocdisable(bfa);
2976 bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
2978 struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
2979 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2981 fcport->speed = pevent->link_state.speed;
2982 fcport->topology = pevent->link_state.topology;
2984 if (fcport->topology == BFA_PORT_TOPOLOGY_LOOP)
2988 fcport->qos_attr = pevent->link_state.qos_attr;
2989 fcport->qos_vc_attr = pevent->link_state.vc_fcf.qos_vc_attr;
2992 * update trunk state if applicable
2994 if (!fcport->cfg.trunked)
2995 trunk->attr.state = BFA_TRUNK_DISABLED;
2997 /* update FCoE specific */
2998 fcport->fcoe_vlan = be16_to_cpu(pevent->link_state.vc_fcf.fcf.vlan);
3000 bfa_trc(fcport->bfa, fcport->speed);
3001 bfa_trc(fcport->bfa, fcport->topology);
3005 bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport)
3007 fcport->speed = BFA_PORT_SPEED_UNKNOWN;
3008 fcport->topology = BFA_PORT_TOPOLOGY_NONE;
3012 * Send port enable message to firmware.
3014 static bfa_boolean_t
3015 bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
3017 struct bfi_fcport_enable_req_s *m;
3020 * Increment message tag before queue check, so that responses to old
3021 * requests are discarded.
3026 * check for room in queue to send request now
3028 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3030 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3031 &fcport->reqq_wait);
3035 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_ENABLE_REQ,
3036 bfa_lpuid(fcport->bfa));
3037 m->nwwn = fcport->nwwn;
3038 m->pwwn = fcport->pwwn;
3039 m->port_cfg = fcport->cfg;
3040 m->msgtag = fcport->msgtag;
3041 m->port_cfg.maxfrsize = cpu_to_be16(fcport->cfg.maxfrsize);
3042 bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa);
3043 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo);
3044 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi);
3047 * queue I/O message to firmware
3049 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3054 * Send port disable message to firmware.
3056 static bfa_boolean_t
3057 bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
3059 struct bfi_fcport_req_s *m;
3062 * Increment message tag before queue check, so that responses to old
3063 * requests are discarded.
3068 * check for room in queue to send request now
3070 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3072 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3073 &fcport->reqq_wait);
3077 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_DISABLE_REQ,
3078 bfa_lpuid(fcport->bfa));
3079 m->msgtag = fcport->msgtag;
3082 * queue I/O message to firmware
3084 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3090 bfa_fcport_set_wwns(struct bfa_fcport_s *fcport)
3092 fcport->pwwn = bfa_ioc_get_pwwn(&fcport->bfa->ioc);
3093 fcport->nwwn = bfa_ioc_get_nwwn(&fcport->bfa->ioc);
3095 bfa_trc(fcport->bfa, fcport->pwwn);
3096 bfa_trc(fcport->bfa, fcport->nwwn);
3100 bfa_fcport_send_txcredit(void *port_cbarg)
3103 struct bfa_fcport_s *fcport = port_cbarg;
3104 struct bfi_fcport_set_svc_params_req_s *m;
3107 * check for room in queue to send request now
3109 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3111 bfa_trc(fcport->bfa, fcport->cfg.tx_bbcredit);
3115 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ,
3116 bfa_lpuid(fcport->bfa));
3117 m->tx_bbcredit = cpu_to_be16((u16)fcport->cfg.tx_bbcredit);
3120 * queue I/O message to firmware
3122 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3126 bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d,
3127 struct bfa_qos_stats_s *s)
3129 u32 *dip = (u32 *) d;
3130 u32 *sip = (u32 *) s;
3133 /* Now swap the 32 bit fields */
3134 for (i = 0; i < (sizeof(struct bfa_qos_stats_s)/sizeof(u32)); ++i)
3135 dip[i] = be32_to_cpu(sip[i]);
3139 bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d,
3140 struct bfa_fcoe_stats_s *s)
3142 u32 *dip = (u32 *) d;
3143 u32 *sip = (u32 *) s;
3146 for (i = 0; i < ((sizeof(struct bfa_fcoe_stats_s))/sizeof(u32));
3149 dip[i] = be32_to_cpu(sip[i]);
3150 dip[i + 1] = be32_to_cpu(sip[i + 1]);
3152 dip[i] = be32_to_cpu(sip[i + 1]);
3153 dip[i + 1] = be32_to_cpu(sip[i]);
3159 __bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
3161 struct bfa_fcport_s *fcport = cbarg;
3164 if (fcport->stats_status == BFA_STATUS_OK) {
3165 struct bfa_timeval_s tv;
3167 /* Swap FC QoS or FCoE stats */
3168 if (bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
3169 bfa_fcport_qos_stats_swap(
3170 &fcport->stats_ret->fcqos,
3171 &fcport->stats->fcqos);
3173 bfa_fcport_fcoe_stats_swap(
3174 &fcport->stats_ret->fcoe,
3175 &fcport->stats->fcoe);
3177 bfa_os_gettimeofday(&tv);
3178 fcport->stats_ret->fcoe.secs_reset =
3179 tv.tv_sec - fcport->stats_reset_time;
3182 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
3184 fcport->stats_busy = BFA_FALSE;
3185 fcport->stats_status = BFA_STATUS_OK;
3190 bfa_fcport_stats_get_timeout(void *cbarg)
3192 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3194 bfa_trc(fcport->bfa, fcport->stats_qfull);
3196 if (fcport->stats_qfull) {
3197 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3198 fcport->stats_qfull = BFA_FALSE;
3201 fcport->stats_status = BFA_STATUS_ETIMER;
3202 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_fcport_stats_get,
3207 bfa_fcport_send_stats_get(void *cbarg)
3209 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3210 struct bfi_fcport_req_s *msg;
3212 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3215 fcport->stats_qfull = BFA_TRUE;
3216 bfa_reqq_winit(&fcport->stats_reqq_wait,
3217 bfa_fcport_send_stats_get, fcport);
3218 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3219 &fcport->stats_reqq_wait);
3222 fcport->stats_qfull = BFA_FALSE;
3224 memset(msg, 0, sizeof(struct bfi_fcport_req_s));
3225 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_GET_REQ,
3226 bfa_lpuid(fcport->bfa));
3227 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3231 __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
3233 struct bfa_fcport_s *fcport = cbarg;
3236 struct bfa_timeval_s tv;
3239 * re-initialize time stamp for stats reset
3241 bfa_os_gettimeofday(&tv);
3242 fcport->stats_reset_time = tv.tv_sec;
3244 fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
3246 fcport->stats_busy = BFA_FALSE;
3247 fcport->stats_status = BFA_STATUS_OK;
3252 bfa_fcport_stats_clr_timeout(void *cbarg)
3254 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3256 bfa_trc(fcport->bfa, fcport->stats_qfull);
3258 if (fcport->stats_qfull) {
3259 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3260 fcport->stats_qfull = BFA_FALSE;
3263 fcport->stats_status = BFA_STATUS_ETIMER;
3264 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
3265 __bfa_cb_fcport_stats_clr, fcport);
3269 bfa_fcport_send_stats_clear(void *cbarg)
3271 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3272 struct bfi_fcport_req_s *msg;
3274 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3277 fcport->stats_qfull = BFA_TRUE;
3278 bfa_reqq_winit(&fcport->stats_reqq_wait,
3279 bfa_fcport_send_stats_clear, fcport);
3280 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3281 &fcport->stats_reqq_wait);
3284 fcport->stats_qfull = BFA_FALSE;
3286 memset(msg, 0, sizeof(struct bfi_fcport_req_s));
3287 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_CLEAR_REQ,
3288 bfa_lpuid(fcport->bfa));
3289 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
3293 * Handle trunk SCN event from firmware.
3296 bfa_trunk_scn(struct bfa_fcport_s *fcport, struct bfi_fcport_trunk_scn_s *scn)
3298 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
3299 struct bfi_fcport_trunk_link_s *tlink;
3300 struct bfa_trunk_link_attr_s *lattr;
3301 enum bfa_trunk_state state_prev;
3305 bfa_trc(fcport->bfa, fcport->cfg.trunked);
3306 bfa_assert(scn->trunk_state == BFA_TRUNK_ONLINE ||
3307 scn->trunk_state == BFA_TRUNK_OFFLINE);
3309 bfa_trc(fcport->bfa, trunk->attr.state);
3310 bfa_trc(fcport->bfa, scn->trunk_state);
3311 bfa_trc(fcport->bfa, scn->trunk_speed);
3314 * Save off new state for trunk attribute query
3316 state_prev = trunk->attr.state;
3317 if (fcport->cfg.trunked && (trunk->attr.state != BFA_TRUNK_DISABLED))
3318 trunk->attr.state = scn->trunk_state;
3319 trunk->attr.speed = scn->trunk_speed;
3320 for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3321 lattr = &trunk->attr.link_attr[i];
3322 tlink = &scn->tlink[i];
3324 lattr->link_state = tlink->state;
3325 lattr->trunk_wwn = tlink->trunk_wwn;
3326 lattr->fctl = tlink->fctl;
3327 lattr->speed = tlink->speed;
3328 lattr->deskew = be32_to_cpu(tlink->deskew);
3330 if (tlink->state == BFA_TRUNK_LINK_STATE_UP) {
3331 fcport->speed = tlink->speed;
3332 fcport->topology = BFA_PORT_TOPOLOGY_P2P;
3336 bfa_trc(fcport->bfa, lattr->link_state);
3337 bfa_trc(fcport->bfa, lattr->trunk_wwn);
3338 bfa_trc(fcport->bfa, lattr->fctl);
3339 bfa_trc(fcport->bfa, lattr->speed);
3340 bfa_trc(fcport->bfa, lattr->deskew);
3345 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3346 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,1)");
3349 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3350 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(-,1)");
3353 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3354 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,-)");
3357 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3358 BFA_PL_EID_TRUNK_SCN, 0, "Trunk down");
3362 * Notify upper layers if trunk state changed.
3364 if ((state_prev != trunk->attr.state) ||
3365 (scn->trunk_state == BFA_TRUNK_OFFLINE)) {
3366 bfa_fcport_scn(fcport, (scn->trunk_state == BFA_TRUNK_ONLINE) ?
3367 BFA_PORT_LINKUP : BFA_PORT_LINKDOWN, BFA_TRUE);
3372 bfa_trunk_iocdisable(struct bfa_s *bfa)
3374 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3378 * In trunked mode, notify upper layers that link is down
3380 if (fcport->cfg.trunked) {
3381 if (fcport->trunk.attr.state == BFA_TRUNK_ONLINE)
3382 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_TRUE);
3384 fcport->trunk.attr.state = BFA_TRUNK_OFFLINE;
3385 fcport->trunk.attr.speed = BFA_PORT_SPEED_UNKNOWN;
3386 for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3387 fcport->trunk.attr.link_attr[i].trunk_wwn = 0;
3388 fcport->trunk.attr.link_attr[i].fctl =
3389 BFA_TRUNK_LINK_FCTL_NORMAL;
3390 fcport->trunk.attr.link_attr[i].link_state =
3391 BFA_TRUNK_LINK_STATE_DN_LINKDN;
3392 fcport->trunk.attr.link_attr[i].speed =
3393 BFA_PORT_SPEED_UNKNOWN;
3394 fcport->trunk.attr.link_attr[i].deskew = 0;
3406 * Called to initialize port attributes
3409 bfa_fcport_init(struct bfa_s *bfa)
3411 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3414 * Initialize port attributes from IOC hardware data.
3416 bfa_fcport_set_wwns(fcport);
3417 if (fcport->cfg.maxfrsize == 0)
3418 fcport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc);
3419 fcport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
3420 fcport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
3422 bfa_assert(fcport->cfg.maxfrsize);
3423 bfa_assert(fcport->cfg.rx_bbcredit);
3424 bfa_assert(fcport->speed_sup);
3428 * Firmware message handler.
3431 bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
3433 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3434 union bfi_fcport_i2h_msg_u i2hmsg;
3437 fcport->event_arg.i2hmsg = i2hmsg;
3439 bfa_trc(bfa, msg->mhdr.msg_id);
3440 bfa_trc(bfa, bfa_sm_to_state(hal_port_sm_table, fcport->sm));
3442 switch (msg->mhdr.msg_id) {
3443 case BFI_FCPORT_I2H_ENABLE_RSP:
3444 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
3445 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3448 case BFI_FCPORT_I2H_DISABLE_RSP:
3449 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
3450 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3453 case BFI_FCPORT_I2H_EVENT:
3454 if (i2hmsg.event->link_state.linkstate == BFA_PORT_LINKUP)
3455 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
3457 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKDOWN);
3460 case BFI_FCPORT_I2H_TRUNK_SCN:
3461 bfa_trunk_scn(fcport, i2hmsg.trunk_scn);
3464 case BFI_FCPORT_I2H_STATS_GET_RSP:
3466 * check for timer pop before processing the rsp
3468 if (fcport->stats_busy == BFA_FALSE ||
3469 fcport->stats_status == BFA_STATUS_ETIMER)
3472 bfa_timer_stop(&fcport->timer);
3473 fcport->stats_status = i2hmsg.pstatsget_rsp->status;
3474 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
3475 __bfa_cb_fcport_stats_get, fcport);
3478 case BFI_FCPORT_I2H_STATS_CLEAR_RSP:
3480 * check for timer pop before processing the rsp
3482 if (fcport->stats_busy == BFA_FALSE ||
3483 fcport->stats_status == BFA_STATUS_ETIMER)
3486 bfa_timer_stop(&fcport->timer);
3487 fcport->stats_status = BFA_STATUS_OK;
3488 bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
3489 __bfa_cb_fcport_stats_clr, fcport);
3492 case BFI_FCPORT_I2H_ENABLE_AEN:
3493 bfa_sm_send_event(fcport, BFA_FCPORT_SM_ENABLE);
3496 case BFI_FCPORT_I2H_DISABLE_AEN:
3497 bfa_sm_send_event(fcport, BFA_FCPORT_SM_DISABLE);
3513 * Registered callback for port events.
3516 bfa_fcport_event_register(struct bfa_s *bfa,
3517 void (*cbfn) (void *cbarg,
3518 enum bfa_port_linkstate event),
3521 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3523 fcport->event_cbfn = cbfn;
3524 fcport->event_cbarg = cbarg;
3528 bfa_fcport_enable(struct bfa_s *bfa)
3530 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3532 if (bfa_ioc_is_disabled(&bfa->ioc))
3533 return BFA_STATUS_IOC_DISABLED;
3535 if (fcport->diag_busy)
3536 return BFA_STATUS_DIAG_BUSY;
3538 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_ENABLE);
3539 return BFA_STATUS_OK;
3543 bfa_fcport_disable(struct bfa_s *bfa)
3546 if (bfa_ioc_is_disabled(&bfa->ioc))
3547 return BFA_STATUS_IOC_DISABLED;
3549 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DISABLE);
3550 return BFA_STATUS_OK;
3554 * Configure port speed.
3557 bfa_fcport_cfg_speed(struct bfa_s *bfa, enum bfa_port_speed speed)
3559 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3561 bfa_trc(bfa, speed);
3563 if (fcport->cfg.trunked == BFA_TRUE)
3564 return BFA_STATUS_TRUNK_ENABLED;
3565 if ((speed != BFA_PORT_SPEED_AUTO) && (speed > fcport->speed_sup)) {
3566 bfa_trc(bfa, fcport->speed_sup);
3567 return BFA_STATUS_UNSUPP_SPEED;
3570 fcport->cfg.speed = speed;
3572 return BFA_STATUS_OK;
3576 * Get current speed.
3579 bfa_fcport_get_speed(struct bfa_s *bfa)
3581 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3583 return fcport->speed;
3587 * Configure port topology.
3590 bfa_fcport_cfg_topology(struct bfa_s *bfa, enum bfa_port_topology topology)
3592 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3594 bfa_trc(bfa, topology);
3595 bfa_trc(bfa, fcport->cfg.topology);
3598 case BFA_PORT_TOPOLOGY_P2P:
3599 case BFA_PORT_TOPOLOGY_LOOP:
3600 case BFA_PORT_TOPOLOGY_AUTO:
3604 return BFA_STATUS_EINVAL;
3607 fcport->cfg.topology = topology;
3608 return BFA_STATUS_OK;
3612 * Get current topology.
3614 enum bfa_port_topology
3615 bfa_fcport_get_topology(struct bfa_s *bfa)
3617 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3619 return fcport->topology;
3623 bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
3625 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3628 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3629 bfa_trc(bfa, fcport->cfg.hardalpa);
3631 fcport->cfg.cfg_hardalpa = BFA_TRUE;
3632 fcport->cfg.hardalpa = alpa;
3634 return BFA_STATUS_OK;
3638 bfa_fcport_clr_hardalpa(struct bfa_s *bfa)
3640 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3642 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3643 bfa_trc(bfa, fcport->cfg.hardalpa);
3645 fcport->cfg.cfg_hardalpa = BFA_FALSE;
3646 return BFA_STATUS_OK;
3650 bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa)
3652 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3654 *alpa = fcport->cfg.hardalpa;
3655 return fcport->cfg.cfg_hardalpa;
3659 bfa_fcport_get_myalpa(struct bfa_s *bfa)
3661 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3663 return fcport->myalpa;
3667 bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
3669 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3671 bfa_trc(bfa, maxfrsize);
3672 bfa_trc(bfa, fcport->cfg.maxfrsize);
3675 if ((maxfrsize > FC_MAX_PDUSZ) || (maxfrsize < FC_MIN_PDUSZ))
3676 return BFA_STATUS_INVLD_DFSZ;
3678 /* power of 2, if not the max frame size of 2112 */
3679 if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1)))
3680 return BFA_STATUS_INVLD_DFSZ;
3682 fcport->cfg.maxfrsize = maxfrsize;
3683 return BFA_STATUS_OK;
3687 bfa_fcport_get_maxfrsize(struct bfa_s *bfa)
3689 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3691 return fcport->cfg.maxfrsize;
3695 bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa)
3697 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3699 return fcport->cfg.rx_bbcredit;
3703 bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
3705 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3707 fcport->cfg.tx_bbcredit = (u8)tx_bbcredit;
3708 bfa_fcport_send_txcredit(fcport);
3712 * Get port attributes.
3716 bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node)
3718 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3720 return fcport->nwwn;
3722 return fcport->pwwn;
3726 bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr)
3728 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3730 memset(attr, 0, sizeof(struct bfa_port_attr_s));
3732 attr->nwwn = fcport->nwwn;
3733 attr->pwwn = fcport->pwwn;
3735 attr->factorypwwn = bfa_ioc_get_mfg_pwwn(&bfa->ioc);
3736 attr->factorynwwn = bfa_ioc_get_mfg_nwwn(&bfa->ioc);
3738 memcpy(&attr->pport_cfg, &fcport->cfg,
3739 sizeof(struct bfa_port_cfg_s));
3740 /* speed attributes */
3741 attr->pport_cfg.speed = fcport->cfg.speed;
3742 attr->speed_supported = fcport->speed_sup;
3743 attr->speed = fcport->speed;
3744 attr->cos_supported = FC_CLASS_3;
3746 /* topology attributes */
3747 attr->pport_cfg.topology = fcport->cfg.topology;
3748 attr->topology = fcport->topology;
3749 attr->pport_cfg.trunked = fcport->cfg.trunked;
3751 /* beacon attributes */
3752 attr->beacon = fcport->beacon;
3753 attr->link_e2e_beacon = fcport->link_e2e_beacon;
3754 attr->plog_enabled = bfa_plog_get_setting(fcport->bfa->plog);
3755 attr->io_profile = bfa_fcpim_get_io_profile(fcport->bfa);
3757 attr->pport_cfg.path_tov = bfa_fcpim_path_tov_get(bfa);
3758 attr->pport_cfg.q_depth = bfa_fcpim_qdepth_get(bfa);
3759 attr->port_state = bfa_sm_to_state(hal_port_sm_table, fcport->sm);
3760 if (bfa_ioc_is_disabled(&fcport->bfa->ioc))
3761 attr->port_state = BFA_PORT_ST_IOCDIS;
3762 else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc))
3763 attr->port_state = BFA_PORT_ST_FWMISMATCH;
3766 attr->fcoe_vlan = fcport->fcoe_vlan;
3769 #define BFA_FCPORT_STATS_TOV 1000
3772 * Fetch port statistics (FCQoS or FCoE).
3775 bfa_fcport_get_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
3776 bfa_cb_port_t cbfn, void *cbarg)
3778 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3780 if (fcport->stats_busy) {
3781 bfa_trc(bfa, fcport->stats_busy);
3782 return BFA_STATUS_DEVBUSY;
3785 fcport->stats_busy = BFA_TRUE;
3786 fcport->stats_ret = stats;
3787 fcport->stats_cbfn = cbfn;
3788 fcport->stats_cbarg = cbarg;
3790 bfa_fcport_send_stats_get(fcport);
3792 bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_get_timeout,
3793 fcport, BFA_FCPORT_STATS_TOV);
3794 return BFA_STATUS_OK;
3798 * Reset port statistics (FCQoS or FCoE).
3801 bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn, void *cbarg)
3803 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3805 if (fcport->stats_busy) {
3806 bfa_trc(bfa, fcport->stats_busy);
3807 return BFA_STATUS_DEVBUSY;
3810 fcport->stats_busy = BFA_TRUE;
3811 fcport->stats_cbfn = cbfn;
3812 fcport->stats_cbarg = cbarg;
3814 bfa_fcport_send_stats_clear(fcport);
3816 bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_clr_timeout,
3817 fcport, BFA_FCPORT_STATS_TOV);
3818 return BFA_STATUS_OK;
3822 * Fetch FCQoS port statistics
3825 bfa_fcport_get_qos_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
3826 bfa_cb_port_t cbfn, void *cbarg)
3828 /* Meaningful only for FC mode */
3829 bfa_assert(bfa_ioc_get_fcmode(&bfa->ioc));
3831 return bfa_fcport_get_stats(bfa, stats, cbfn, cbarg);
3835 * Reset FCoE port statistics
3838 bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn, void *cbarg)
3840 /* Meaningful only for FC mode */
3841 bfa_assert(bfa_ioc_get_fcmode(&bfa->ioc));
3843 return bfa_fcport_clear_stats(bfa, cbfn, cbarg);
3847 * Fetch FCQoS port statistics
3850 bfa_fcport_get_fcoe_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
3851 bfa_cb_port_t cbfn, void *cbarg)
3853 /* Meaningful only for FCoE mode */
3854 bfa_assert(!bfa_ioc_get_fcmode(&bfa->ioc));
3856 return bfa_fcport_get_stats(bfa, stats, cbfn, cbarg);
3860 * Reset FCoE port statistics
3863 bfa_fcport_clear_fcoe_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn, void *cbarg)
3865 /* Meaningful only for FCoE mode */
3866 bfa_assert(!bfa_ioc_get_fcmode(&bfa->ioc));
3868 return bfa_fcport_clear_stats(bfa, cbfn, cbarg);
3872 bfa_fcport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr)
3874 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3876 qos_attr->state = fcport->qos_attr.state;
3877 qos_attr->total_bb_cr = be32_to_cpu(fcport->qos_attr.total_bb_cr);
3881 bfa_fcport_qos_get_vc_attr(struct bfa_s *bfa,
3882 struct bfa_qos_vc_attr_s *qos_vc_attr)
3884 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3885 struct bfa_qos_vc_attr_s *bfa_vc_attr = &fcport->qos_vc_attr;
3888 qos_vc_attr->total_vc_count = be16_to_cpu(bfa_vc_attr->total_vc_count);
3889 qos_vc_attr->shared_credit = be16_to_cpu(bfa_vc_attr->shared_credit);
3890 qos_vc_attr->elp_opmode_flags =
3891 be32_to_cpu(bfa_vc_attr->elp_opmode_flags);
3893 /* Individual VC info */
3894 while (i < qos_vc_attr->total_vc_count) {
3895 qos_vc_attr->vc_info[i].vc_credit =
3896 bfa_vc_attr->vc_info[i].vc_credit;
3897 qos_vc_attr->vc_info[i].borrow_credit =
3898 bfa_vc_attr->vc_info[i].borrow_credit;
3899 qos_vc_attr->vc_info[i].priority =
3900 bfa_vc_attr->vc_info[i].priority;
3906 * Fetch port attributes.
3909 bfa_fcport_is_disabled(struct bfa_s *bfa)
3911 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3913 return bfa_sm_to_state(hal_port_sm_table, fcport->sm) ==
3914 BFA_PORT_ST_DISABLED;
3919 bfa_fcport_is_ratelim(struct bfa_s *bfa)
3921 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3923 return fcport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE;
3928 bfa_fcport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off)
3930 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3931 enum bfa_ioc_type_e ioc_type = bfa_get_type(bfa);
3933 bfa_trc(bfa, on_off);
3934 bfa_trc(bfa, fcport->cfg.qos_enabled);
3936 bfa_trc(bfa, ioc_type);
3938 if (ioc_type == BFA_IOC_TYPE_FC) {
3939 fcport->cfg.qos_enabled = on_off;
3941 * Notify fcpim of the change in QoS state
3943 bfa_fcpim_update_ioredirect(bfa);
3948 bfa_fcport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off)
3950 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3952 bfa_trc(bfa, on_off);
3953 bfa_trc(bfa, fcport->cfg.ratelimit);
3955 fcport->cfg.ratelimit = on_off;
3956 if (fcport->cfg.trl_def_speed == BFA_PORT_SPEED_UNKNOWN)
3957 fcport->cfg.trl_def_speed = BFA_PORT_SPEED_1GBPS;
3961 * Configure default minimum ratelim speed
3964 bfa_fcport_cfg_ratelim_speed(struct bfa_s *bfa, enum bfa_port_speed speed)
3966 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3968 bfa_trc(bfa, speed);
3970 /* Auto and speeds greater than the supported speed, are invalid */
3971 if ((speed == BFA_PORT_SPEED_AUTO) || (speed > fcport->speed_sup)) {
3972 bfa_trc(bfa, fcport->speed_sup);
3973 return BFA_STATUS_UNSUPP_SPEED;
3976 fcport->cfg.trl_def_speed = speed;
3978 return BFA_STATUS_OK;
3982 * Get default minimum ratelim speed
3985 bfa_fcport_get_ratelim_speed(struct bfa_s *bfa)
3987 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3989 bfa_trc(bfa, fcport->cfg.trl_def_speed);
3990 return fcport->cfg.trl_def_speed;
3994 bfa_fcport_busy(struct bfa_s *bfa, bfa_boolean_t status)
3996 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3998 bfa_trc(bfa, status);
3999 bfa_trc(bfa, fcport->diag_busy);
4001 fcport->diag_busy = status;
4005 bfa_fcport_beacon(void *dev, bfa_boolean_t beacon,
4006 bfa_boolean_t link_e2e_beacon)
4008 struct bfa_s *bfa = dev;
4009 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4011 bfa_trc(bfa, beacon);
4012 bfa_trc(bfa, link_e2e_beacon);
4013 bfa_trc(bfa, fcport->beacon);
4014 bfa_trc(bfa, fcport->link_e2e_beacon);
4016 fcport->beacon = beacon;
4017 fcport->link_e2e_beacon = link_e2e_beacon;
4021 bfa_fcport_is_linkup(struct bfa_s *bfa)
4023 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4025 return (!fcport->cfg.trunked &&
4026 bfa_sm_cmp_state(fcport, bfa_fcport_sm_linkup)) ||
4027 (fcport->cfg.trunked &&
4028 fcport->trunk.attr.state == BFA_TRUNK_ONLINE);
4032 bfa_fcport_is_qos_enabled(struct bfa_s *bfa)
4034 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4036 return fcport->cfg.qos_enabled;
4040 bfa_trunk_get_attr(struct bfa_s *bfa, struct bfa_trunk_attr_s *attr)
4043 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4044 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
4046 bfa_trc(bfa, fcport->cfg.trunked);
4047 bfa_trc(bfa, trunk->attr.state);
4048 *attr = trunk->attr;
4049 attr->port_id = bfa_lps_get_base_pid(bfa);
4051 return BFA_STATUS_OK;
4055 bfa_trunk_enable_cfg(struct bfa_s *bfa)
4057 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4058 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
4061 trunk->attr.state = BFA_TRUNK_OFFLINE;
4062 fcport->cfg.trunked = BFA_TRUE;
4066 bfa_trunk_enable(struct bfa_s *bfa)
4068 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4069 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
4073 trunk->attr.state = BFA_TRUNK_OFFLINE;
4074 bfa_fcport_disable(bfa);
4075 fcport->cfg.trunked = BFA_TRUE;
4076 bfa_fcport_enable(bfa);
4078 return BFA_STATUS_OK;
4082 bfa_trunk_disable(struct bfa_s *bfa)
4084 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4085 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
4088 trunk->attr.state = BFA_TRUNK_DISABLED;
4089 bfa_fcport_disable(bfa);
4090 fcport->cfg.trunked = BFA_FALSE;
4091 bfa_fcport_enable(bfa);
4092 return BFA_STATUS_OK;
4097 * Rport State machine functions
4100 * Beginning state, only online event expected.
4103 bfa_rport_sm_uninit(struct bfa_rport_s *rp, enum bfa_rport_event event)
4105 bfa_trc(rp->bfa, rp->rport_tag);
4106 bfa_trc(rp->bfa, event);
4109 case BFA_RPORT_SM_CREATE:
4110 bfa_stats(rp, sm_un_cr);
4111 bfa_sm_set_state(rp, bfa_rport_sm_created);
4115 bfa_stats(rp, sm_un_unexp);
4116 bfa_sm_fault(rp->bfa, event);
4121 bfa_rport_sm_created(struct bfa_rport_s *rp, enum bfa_rport_event event)
4123 bfa_trc(rp->bfa, rp->rport_tag);
4124 bfa_trc(rp->bfa, event);
4127 case BFA_RPORT_SM_ONLINE:
4128 bfa_stats(rp, sm_cr_on);
4129 if (bfa_rport_send_fwcreate(rp))
4130 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4132 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4135 case BFA_RPORT_SM_DELETE:
4136 bfa_stats(rp, sm_cr_del);
4137 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4141 case BFA_RPORT_SM_HWFAIL:
4142 bfa_stats(rp, sm_cr_hwf);
4143 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4147 bfa_stats(rp, sm_cr_unexp);
4148 bfa_sm_fault(rp->bfa, event);
4153 * Waiting for rport create response from firmware.
4156 bfa_rport_sm_fwcreate(struct bfa_rport_s *rp, enum bfa_rport_event event)
4158 bfa_trc(rp->bfa, rp->rport_tag);
4159 bfa_trc(rp->bfa, event);
4162 case BFA_RPORT_SM_FWRSP:
4163 bfa_stats(rp, sm_fwc_rsp);
4164 bfa_sm_set_state(rp, bfa_rport_sm_online);
4165 bfa_rport_online_cb(rp);
4168 case BFA_RPORT_SM_DELETE:
4169 bfa_stats(rp, sm_fwc_del);
4170 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
4173 case BFA_RPORT_SM_OFFLINE:
4174 bfa_stats(rp, sm_fwc_off);
4175 bfa_sm_set_state(rp, bfa_rport_sm_offline_pending);
4178 case BFA_RPORT_SM_HWFAIL:
4179 bfa_stats(rp, sm_fwc_hwf);
4180 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4184 bfa_stats(rp, sm_fwc_unexp);
4185 bfa_sm_fault(rp->bfa, event);
4190 * Request queue is full, awaiting queue resume to send create request.
4193 bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4195 bfa_trc(rp->bfa, rp->rport_tag);
4196 bfa_trc(rp->bfa, event);
4199 case BFA_RPORT_SM_QRESUME:
4200 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4201 bfa_rport_send_fwcreate(rp);
4204 case BFA_RPORT_SM_DELETE:
4205 bfa_stats(rp, sm_fwc_del);
4206 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4207 bfa_reqq_wcancel(&rp->reqq_wait);
4211 case BFA_RPORT_SM_OFFLINE:
4212 bfa_stats(rp, sm_fwc_off);
4213 bfa_sm_set_state(rp, bfa_rport_sm_offline);
4214 bfa_reqq_wcancel(&rp->reqq_wait);
4215 bfa_rport_offline_cb(rp);
4218 case BFA_RPORT_SM_HWFAIL:
4219 bfa_stats(rp, sm_fwc_hwf);
4220 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4221 bfa_reqq_wcancel(&rp->reqq_wait);
4225 bfa_stats(rp, sm_fwc_unexp);
4226 bfa_sm_fault(rp->bfa, event);
4231 * Online state - normal parking state.
4234 bfa_rport_sm_online(struct bfa_rport_s *rp, enum bfa_rport_event event)
4236 struct bfi_rport_qos_scn_s *qos_scn;
4238 bfa_trc(rp->bfa, rp->rport_tag);
4239 bfa_trc(rp->bfa, event);
4242 case BFA_RPORT_SM_OFFLINE:
4243 bfa_stats(rp, sm_on_off);
4244 if (bfa_rport_send_fwdelete(rp))
4245 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4247 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
4250 case BFA_RPORT_SM_DELETE:
4251 bfa_stats(rp, sm_on_del);
4252 if (bfa_rport_send_fwdelete(rp))
4253 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4255 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4258 case BFA_RPORT_SM_HWFAIL:
4259 bfa_stats(rp, sm_on_hwf);
4260 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4263 case BFA_RPORT_SM_SET_SPEED:
4264 bfa_rport_send_fwspeed(rp);
4267 case BFA_RPORT_SM_QOS_SCN:
4268 qos_scn = (struct bfi_rport_qos_scn_s *) rp->event_arg.fw_msg;
4269 rp->qos_attr = qos_scn->new_qos_attr;
4270 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_flow_id);
4271 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_flow_id);
4272 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_priority);
4273 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_priority);
4275 qos_scn->old_qos_attr.qos_flow_id =
4276 be32_to_cpu(qos_scn->old_qos_attr.qos_flow_id);
4277 qos_scn->new_qos_attr.qos_flow_id =
4278 be32_to_cpu(qos_scn->new_qos_attr.qos_flow_id);
4280 if (qos_scn->old_qos_attr.qos_flow_id !=
4281 qos_scn->new_qos_attr.qos_flow_id)
4282 bfa_cb_rport_qos_scn_flowid(rp->rport_drv,
4283 qos_scn->old_qos_attr,
4284 qos_scn->new_qos_attr);
4285 if (qos_scn->old_qos_attr.qos_priority !=
4286 qos_scn->new_qos_attr.qos_priority)
4287 bfa_cb_rport_qos_scn_prio(rp->rport_drv,
4288 qos_scn->old_qos_attr,
4289 qos_scn->new_qos_attr);
4293 bfa_stats(rp, sm_on_unexp);
4294 bfa_sm_fault(rp->bfa, event);
4299 * Firmware rport is being deleted - awaiting f/w response.
4302 bfa_rport_sm_fwdelete(struct bfa_rport_s *rp, enum bfa_rport_event event)
4304 bfa_trc(rp->bfa, rp->rport_tag);
4305 bfa_trc(rp->bfa, event);
4308 case BFA_RPORT_SM_FWRSP:
4309 bfa_stats(rp, sm_fwd_rsp);
4310 bfa_sm_set_state(rp, bfa_rport_sm_offline);
4311 bfa_rport_offline_cb(rp);
4314 case BFA_RPORT_SM_DELETE:
4315 bfa_stats(rp, sm_fwd_del);
4316 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4319 case BFA_RPORT_SM_HWFAIL:
4320 bfa_stats(rp, sm_fwd_hwf);
4321 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4322 bfa_rport_offline_cb(rp);
4326 bfa_stats(rp, sm_fwd_unexp);
4327 bfa_sm_fault(rp->bfa, event);
4332 bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4334 bfa_trc(rp->bfa, rp->rport_tag);
4335 bfa_trc(rp->bfa, event);
4338 case BFA_RPORT_SM_QRESUME:
4339 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4340 bfa_rport_send_fwdelete(rp);
4343 case BFA_RPORT_SM_DELETE:
4344 bfa_stats(rp, sm_fwd_del);
4345 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4348 case BFA_RPORT_SM_HWFAIL:
4349 bfa_stats(rp, sm_fwd_hwf);
4350 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4351 bfa_reqq_wcancel(&rp->reqq_wait);
4352 bfa_rport_offline_cb(rp);
4356 bfa_stats(rp, sm_fwd_unexp);
4357 bfa_sm_fault(rp->bfa, event);
4365 bfa_rport_sm_offline(struct bfa_rport_s *rp, enum bfa_rport_event event)
4367 bfa_trc(rp->bfa, rp->rport_tag);
4368 bfa_trc(rp->bfa, event);
4371 case BFA_RPORT_SM_DELETE:
4372 bfa_stats(rp, sm_off_del);
4373 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4377 case BFA_RPORT_SM_ONLINE:
4378 bfa_stats(rp, sm_off_on);
4379 if (bfa_rport_send_fwcreate(rp))
4380 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4382 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4385 case BFA_RPORT_SM_HWFAIL:
4386 bfa_stats(rp, sm_off_hwf);
4387 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4391 bfa_stats(rp, sm_off_unexp);
4392 bfa_sm_fault(rp->bfa, event);
4397 * Rport is deleted, waiting for firmware response to delete.
4400 bfa_rport_sm_deleting(struct bfa_rport_s *rp, enum bfa_rport_event event)
4402 bfa_trc(rp->bfa, rp->rport_tag);
4403 bfa_trc(rp->bfa, event);
4406 case BFA_RPORT_SM_FWRSP:
4407 bfa_stats(rp, sm_del_fwrsp);
4408 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4412 case BFA_RPORT_SM_HWFAIL:
4413 bfa_stats(rp, sm_del_hwf);
4414 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4419 bfa_sm_fault(rp->bfa, event);
4424 bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4426 bfa_trc(rp->bfa, rp->rport_tag);
4427 bfa_trc(rp->bfa, event);
4430 case BFA_RPORT_SM_QRESUME:
4431 bfa_stats(rp, sm_del_fwrsp);
4432 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4433 bfa_rport_send_fwdelete(rp);
4436 case BFA_RPORT_SM_HWFAIL:
4437 bfa_stats(rp, sm_del_hwf);
4438 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4439 bfa_reqq_wcancel(&rp->reqq_wait);
4444 bfa_sm_fault(rp->bfa, event);
4449 * Waiting for rport create response from firmware. A delete is pending.
4452 bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
4453 enum bfa_rport_event event)
4455 bfa_trc(rp->bfa, rp->rport_tag);
4456 bfa_trc(rp->bfa, event);
4459 case BFA_RPORT_SM_FWRSP:
4460 bfa_stats(rp, sm_delp_fwrsp);
4461 if (bfa_rport_send_fwdelete(rp))
4462 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4464 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4467 case BFA_RPORT_SM_HWFAIL:
4468 bfa_stats(rp, sm_delp_hwf);
4469 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4474 bfa_stats(rp, sm_delp_unexp);
4475 bfa_sm_fault(rp->bfa, event);
4480 * Waiting for rport create response from firmware. Rport offline is pending.
4483 bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
4484 enum bfa_rport_event event)
4486 bfa_trc(rp->bfa, rp->rport_tag);
4487 bfa_trc(rp->bfa, event);
4490 case BFA_RPORT_SM_FWRSP:
4491 bfa_stats(rp, sm_offp_fwrsp);
4492 if (bfa_rport_send_fwdelete(rp))
4493 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4495 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
4498 case BFA_RPORT_SM_DELETE:
4499 bfa_stats(rp, sm_offp_del);
4500 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
4503 case BFA_RPORT_SM_HWFAIL:
4504 bfa_stats(rp, sm_offp_hwf);
4505 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4509 bfa_stats(rp, sm_offp_unexp);
4510 bfa_sm_fault(rp->bfa, event);
4518 bfa_rport_sm_iocdisable(struct bfa_rport_s *rp, enum bfa_rport_event event)
4520 bfa_trc(rp->bfa, rp->rport_tag);
4521 bfa_trc(rp->bfa, event);
4524 case BFA_RPORT_SM_OFFLINE:
4525 bfa_stats(rp, sm_iocd_off);
4526 bfa_rport_offline_cb(rp);
4529 case BFA_RPORT_SM_DELETE:
4530 bfa_stats(rp, sm_iocd_del);
4531 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4535 case BFA_RPORT_SM_ONLINE:
4536 bfa_stats(rp, sm_iocd_on);
4537 if (bfa_rport_send_fwcreate(rp))
4538 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4540 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4543 case BFA_RPORT_SM_HWFAIL:
4547 bfa_stats(rp, sm_iocd_unexp);
4548 bfa_sm_fault(rp->bfa, event);
4555 * bfa_rport_private BFA rport private functions
4559 __bfa_cb_rport_online(void *cbarg, bfa_boolean_t complete)
4561 struct bfa_rport_s *rp = cbarg;
4564 bfa_cb_rport_online(rp->rport_drv);
4568 __bfa_cb_rport_offline(void *cbarg, bfa_boolean_t complete)
4570 struct bfa_rport_s *rp = cbarg;
4573 bfa_cb_rport_offline(rp->rport_drv);
4577 bfa_rport_qresume(void *cbarg)
4579 struct bfa_rport_s *rp = cbarg;
4581 bfa_sm_send_event(rp, BFA_RPORT_SM_QRESUME);
4585 bfa_rport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len,
4588 if (cfg->fwcfg.num_rports < BFA_RPORT_MIN)
4589 cfg->fwcfg.num_rports = BFA_RPORT_MIN;
4591 *km_len += cfg->fwcfg.num_rports * sizeof(struct bfa_rport_s);
4595 bfa_rport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4596 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
4598 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4599 struct bfa_rport_s *rp;
4602 INIT_LIST_HEAD(&mod->rp_free_q);
4603 INIT_LIST_HEAD(&mod->rp_active_q);
4605 rp = (struct bfa_rport_s *) bfa_meminfo_kva(meminfo);
4607 mod->num_rports = cfg->fwcfg.num_rports;
4609 bfa_assert(mod->num_rports &&
4610 !(mod->num_rports & (mod->num_rports - 1)));
4612 for (i = 0; i < mod->num_rports; i++, rp++) {
4613 memset(rp, 0, sizeof(struct bfa_rport_s));
4616 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4622 list_add_tail(&rp->qe, &mod->rp_free_q);
4624 bfa_reqq_winit(&rp->reqq_wait, bfa_rport_qresume, rp);
4630 bfa_meminfo_kva(meminfo) = (u8 *) rp;
4634 bfa_rport_detach(struct bfa_s *bfa)
4639 bfa_rport_start(struct bfa_s *bfa)
4644 bfa_rport_stop(struct bfa_s *bfa)
4649 bfa_rport_iocdisable(struct bfa_s *bfa)
4651 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4652 struct bfa_rport_s *rport;
4653 struct list_head *qe, *qen;
4655 list_for_each_safe(qe, qen, &mod->rp_active_q) {
4656 rport = (struct bfa_rport_s *) qe;
4657 bfa_sm_send_event(rport, BFA_RPORT_SM_HWFAIL);
4661 static struct bfa_rport_s *
4662 bfa_rport_alloc(struct bfa_rport_mod_s *mod)
4664 struct bfa_rport_s *rport;
4666 bfa_q_deq(&mod->rp_free_q, &rport);
4668 list_add_tail(&rport->qe, &mod->rp_active_q);
4674 bfa_rport_free(struct bfa_rport_s *rport)
4676 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(rport->bfa);
4678 bfa_assert(bfa_q_is_on_q(&mod->rp_active_q, rport));
4679 list_del(&rport->qe);
4680 list_add_tail(&rport->qe, &mod->rp_free_q);
4683 static bfa_boolean_t
4684 bfa_rport_send_fwcreate(struct bfa_rport_s *rp)
4686 struct bfi_rport_create_req_s *m;
4689 * check for room in queue to send request now
4691 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4693 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4697 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_CREATE_REQ,
4698 bfa_lpuid(rp->bfa));
4699 m->bfa_handle = rp->rport_tag;
4700 m->max_frmsz = cpu_to_be16(rp->rport_info.max_frmsz);
4701 m->pid = rp->rport_info.pid;
4702 m->lp_tag = rp->rport_info.lp_tag;
4703 m->local_pid = rp->rport_info.local_pid;
4704 m->fc_class = rp->rport_info.fc_class;
4705 m->vf_en = rp->rport_info.vf_en;
4706 m->vf_id = rp->rport_info.vf_id;
4707 m->cisc = rp->rport_info.cisc;
4710 * queue I/O message to firmware
4712 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT);
4716 static bfa_boolean_t
4717 bfa_rport_send_fwdelete(struct bfa_rport_s *rp)
4719 struct bfi_rport_delete_req_s *m;
4722 * check for room in queue to send request now
4724 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4726 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4730 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_DELETE_REQ,
4731 bfa_lpuid(rp->bfa));
4732 m->fw_handle = rp->fw_handle;
4735 * queue I/O message to firmware
4737 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT);
4741 static bfa_boolean_t
4742 bfa_rport_send_fwspeed(struct bfa_rport_s *rp)
4744 struct bfa_rport_speed_req_s *m;
4747 * check for room in queue to send request now
4749 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4751 bfa_trc(rp->bfa, rp->rport_info.speed);
4755 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_SET_SPEED_REQ,
4756 bfa_lpuid(rp->bfa));
4757 m->fw_handle = rp->fw_handle;
4758 m->speed = (u8)rp->rport_info.speed;
4761 * queue I/O message to firmware
4763 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT);
4774 * Rport interrupt processing.
4777 bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
4779 union bfi_rport_i2h_msg_u msg;
4780 struct bfa_rport_s *rp;
4782 bfa_trc(bfa, m->mhdr.msg_id);
4786 switch (m->mhdr.msg_id) {
4787 case BFI_RPORT_I2H_CREATE_RSP:
4788 rp = BFA_RPORT_FROM_TAG(bfa, msg.create_rsp->bfa_handle);
4789 rp->fw_handle = msg.create_rsp->fw_handle;
4790 rp->qos_attr = msg.create_rsp->qos_attr;
4791 bfa_assert(msg.create_rsp->status == BFA_STATUS_OK);
4792 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
4795 case BFI_RPORT_I2H_DELETE_RSP:
4796 rp = BFA_RPORT_FROM_TAG(bfa, msg.delete_rsp->bfa_handle);
4797 bfa_assert(msg.delete_rsp->status == BFA_STATUS_OK);
4798 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
4801 case BFI_RPORT_I2H_QOS_SCN:
4802 rp = BFA_RPORT_FROM_TAG(bfa, msg.qos_scn_evt->bfa_handle);
4803 rp->event_arg.fw_msg = msg.qos_scn_evt;
4804 bfa_sm_send_event(rp, BFA_RPORT_SM_QOS_SCN);
4808 bfa_trc(bfa, m->mhdr.msg_id);
4819 struct bfa_rport_s *
4820 bfa_rport_create(struct bfa_s *bfa, void *rport_drv)
4822 struct bfa_rport_s *rp;
4824 rp = bfa_rport_alloc(BFA_RPORT_MOD(bfa));
4830 rp->rport_drv = rport_drv;
4831 bfa_rport_clear_stats(rp);
4833 bfa_assert(bfa_sm_cmp_state(rp, bfa_rport_sm_uninit));
4834 bfa_sm_send_event(rp, BFA_RPORT_SM_CREATE);
4840 bfa_rport_delete(struct bfa_rport_s *rport)
4842 bfa_sm_send_event(rport, BFA_RPORT_SM_DELETE);
4846 bfa_rport_online(struct bfa_rport_s *rport, struct bfa_rport_info_s *rport_info)
4848 bfa_assert(rport_info->max_frmsz != 0);
4851 * Some JBODs are seen to be not setting PDU size correctly in PLOGI
4852 * responses. Default to minimum size.
4854 if (rport_info->max_frmsz == 0) {
4855 bfa_trc(rport->bfa, rport->rport_tag);
4856 rport_info->max_frmsz = FC_MIN_PDUSZ;
4859 rport->rport_info = *rport_info;
4860 bfa_sm_send_event(rport, BFA_RPORT_SM_ONLINE);
4864 bfa_rport_offline(struct bfa_rport_s *rport)
4866 bfa_sm_send_event(rport, BFA_RPORT_SM_OFFLINE);
4870 bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed)
4872 bfa_assert(speed != 0);
4873 bfa_assert(speed != BFA_PORT_SPEED_AUTO);
4875 rport->rport_info.speed = speed;
4876 bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
4880 bfa_rport_get_stats(struct bfa_rport_s *rport,
4881 struct bfa_rport_hal_stats_s *stats)
4883 *stats = rport->stats;
4887 bfa_rport_get_qos_attr(struct bfa_rport_s *rport,
4888 struct bfa_rport_qos_attr_s *qos_attr)
4890 qos_attr->qos_priority = rport->qos_attr.qos_priority;
4891 qos_attr->qos_flow_id = be32_to_cpu(rport->qos_attr.qos_flow_id);
4896 bfa_rport_clear_stats(struct bfa_rport_s *rport)
4898 memset(&rport->stats, 0, sizeof(rport->stats));
4903 * SGPG related functions
4907 * Compute and return memory needed by FCP(im) module.
4910 bfa_sgpg_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len,
4913 if (cfg->drvcfg.num_sgpgs < BFA_SGPG_MIN)
4914 cfg->drvcfg.num_sgpgs = BFA_SGPG_MIN;
4916 *km_len += (cfg->drvcfg.num_sgpgs + 1) * sizeof(struct bfa_sgpg_s);
4917 *dm_len += (cfg->drvcfg.num_sgpgs + 1) * sizeof(struct bfi_sgpg_s);
4922 bfa_sgpg_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4923 struct bfa_meminfo_s *minfo, struct bfa_pcidev_s *pcidev)
4925 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4927 struct bfa_sgpg_s *hsgpg;
4928 struct bfi_sgpg_s *sgpg;
4933 union bfi_addr_u addr;
4934 } sgpg_pa, sgpg_pa_tmp;
4936 INIT_LIST_HEAD(&mod->sgpg_q);
4937 INIT_LIST_HEAD(&mod->sgpg_wait_q);
4939 bfa_trc(bfa, cfg->drvcfg.num_sgpgs);
4941 mod->num_sgpgs = cfg->drvcfg.num_sgpgs;
4942 mod->sgpg_arr_pa = bfa_meminfo_dma_phys(minfo);
4943 align_len = (BFA_SGPG_ROUNDUP(mod->sgpg_arr_pa) - mod->sgpg_arr_pa);
4944 mod->sgpg_arr_pa += align_len;
4945 mod->hsgpg_arr = (struct bfa_sgpg_s *) (bfa_meminfo_kva(minfo) +
4947 mod->sgpg_arr = (struct bfi_sgpg_s *) (bfa_meminfo_dma_virt(minfo) +
4950 hsgpg = mod->hsgpg_arr;
4951 sgpg = mod->sgpg_arr;
4952 sgpg_pa.pa = mod->sgpg_arr_pa;
4953 mod->free_sgpgs = mod->num_sgpgs;
4955 bfa_assert(!(sgpg_pa.pa & (sizeof(struct bfi_sgpg_s) - 1)));
4957 for (i = 0; i < mod->num_sgpgs; i++) {
4958 memset(hsgpg, 0, sizeof(*hsgpg));
4959 memset(sgpg, 0, sizeof(*sgpg));
4962 sgpg_pa_tmp.pa = bfa_sgaddr_le(sgpg_pa.pa);
4963 hsgpg->sgpg_pa = sgpg_pa_tmp.addr;
4964 list_add_tail(&hsgpg->qe, &mod->sgpg_q);
4968 sgpg_pa.pa += sizeof(struct bfi_sgpg_s);
4971 bfa_meminfo_kva(minfo) = (u8 *) hsgpg;
4972 bfa_meminfo_dma_virt(minfo) = (u8 *) sgpg;
4973 bfa_meminfo_dma_phys(minfo) = sgpg_pa.pa;
4977 bfa_sgpg_detach(struct bfa_s *bfa)
4982 bfa_sgpg_start(struct bfa_s *bfa)
4987 bfa_sgpg_stop(struct bfa_s *bfa)
4992 bfa_sgpg_iocdisable(struct bfa_s *bfa)
4999 * hal_sgpg_public BFA SGPG public functions
5003 bfa_sgpg_malloc(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpgs)
5005 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5006 struct bfa_sgpg_s *hsgpg;
5009 bfa_trc_fp(bfa, nsgpgs);
5011 if (mod->free_sgpgs < nsgpgs)
5012 return BFA_STATUS_ENOMEM;
5014 for (i = 0; i < nsgpgs; i++) {
5015 bfa_q_deq(&mod->sgpg_q, &hsgpg);
5017 list_add_tail(&hsgpg->qe, sgpg_q);
5020 mod->free_sgpgs -= nsgpgs;
5021 return BFA_STATUS_OK;
5025 bfa_sgpg_mfree(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpg)
5027 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5028 struct bfa_sgpg_wqe_s *wqe;
5030 bfa_trc_fp(bfa, nsgpg);
5032 mod->free_sgpgs += nsgpg;
5033 bfa_assert(mod->free_sgpgs <= mod->num_sgpgs);
5035 list_splice_tail_init(sgpg_q, &mod->sgpg_q);
5037 if (list_empty(&mod->sgpg_wait_q))
5041 * satisfy as many waiting requests as possible
5044 wqe = bfa_q_first(&mod->sgpg_wait_q);
5045 if (mod->free_sgpgs < wqe->nsgpg)
5046 nsgpg = mod->free_sgpgs;
5049 bfa_sgpg_malloc(bfa, &wqe->sgpg_q, nsgpg);
5050 wqe->nsgpg -= nsgpg;
5051 if (wqe->nsgpg == 0) {
5053 wqe->cbfn(wqe->cbarg);
5055 } while (mod->free_sgpgs && !list_empty(&mod->sgpg_wait_q));
5059 bfa_sgpg_wait(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe, int nsgpg)
5061 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5063 bfa_assert(nsgpg > 0);
5064 bfa_assert(nsgpg > mod->free_sgpgs);
5066 wqe->nsgpg_total = wqe->nsgpg = nsgpg;
5069 * allocate any left to this one first
5071 if (mod->free_sgpgs) {
5073 * no one else is waiting for SGPG
5075 bfa_assert(list_empty(&mod->sgpg_wait_q));
5076 list_splice_tail_init(&mod->sgpg_q, &wqe->sgpg_q);
5077 wqe->nsgpg -= mod->free_sgpgs;
5078 mod->free_sgpgs = 0;
5081 list_add_tail(&wqe->qe, &mod->sgpg_wait_q);
5085 bfa_sgpg_wcancel(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe)
5087 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5089 bfa_assert(bfa_q_is_on_q(&mod->sgpg_wait_q, wqe));
5092 if (wqe->nsgpg_total != wqe->nsgpg)
5093 bfa_sgpg_mfree(bfa, &wqe->sgpg_q,
5094 wqe->nsgpg_total - wqe->nsgpg);
5098 bfa_sgpg_winit(struct bfa_sgpg_wqe_s *wqe, void (*cbfn) (void *cbarg),
5101 INIT_LIST_HEAD(&wqe->sgpg_q);
5107 * UF related functions
5110 *****************************************************************************
5111 * Internal functions
5112 *****************************************************************************
5115 __bfa_cb_uf_recv(void *cbarg, bfa_boolean_t complete)
5117 struct bfa_uf_s *uf = cbarg;
5118 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(uf->bfa);
5121 ufm->ufrecv(ufm->cbarg, uf);
5125 claim_uf_pbs(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
5129 ufm->uf_pbs_kva = (struct bfa_uf_buf_s *) bfa_meminfo_dma_virt(mi);
5130 ufm->uf_pbs_pa = bfa_meminfo_dma_phys(mi);
5131 uf_pb_tot_sz = BFA_ROUNDUP((sizeof(struct bfa_uf_buf_s) * ufm->num_ufs),
5134 bfa_meminfo_dma_virt(mi) += uf_pb_tot_sz;
5135 bfa_meminfo_dma_phys(mi) += uf_pb_tot_sz;
5137 memset((void *)ufm->uf_pbs_kva, 0, uf_pb_tot_sz);
5141 claim_uf_post_msgs(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
5143 struct bfi_uf_buf_post_s *uf_bp_msg;
5144 struct bfi_sge_s *sge;
5145 union bfi_addr_u sga_zero = { {0} };
5149 ufm->uf_buf_posts = (struct bfi_uf_buf_post_s *) bfa_meminfo_kva(mi);
5150 uf_bp_msg = ufm->uf_buf_posts;
5152 for (i = 0, uf_bp_msg = ufm->uf_buf_posts; i < ufm->num_ufs;
5154 memset(uf_bp_msg, 0, sizeof(struct bfi_uf_buf_post_s));
5156 uf_bp_msg->buf_tag = i;
5157 buf_len = sizeof(struct bfa_uf_buf_s);
5158 uf_bp_msg->buf_len = cpu_to_be16(buf_len);
5159 bfi_h2i_set(uf_bp_msg->mh, BFI_MC_UF, BFI_UF_H2I_BUF_POST,
5160 bfa_lpuid(ufm->bfa));
5162 sge = uf_bp_msg->sge;
5163 sge[0].sg_len = buf_len;
5164 sge[0].flags = BFI_SGE_DATA_LAST;
5165 bfa_dma_addr_set(sge[0].sga, ufm_pbs_pa(ufm, i));
5168 sge[1].sg_len = buf_len;
5169 sge[1].flags = BFI_SGE_PGDLEN;
5170 sge[1].sga = sga_zero;
5171 bfa_sge_to_be(&sge[1]);
5175 * advance pointer beyond consumed memory
5177 bfa_meminfo_kva(mi) = (u8 *) uf_bp_msg;
5181 claim_ufs(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
5184 struct bfa_uf_s *uf;
5187 * Claim block of memory for UF list
5189 ufm->uf_list = (struct bfa_uf_s *) bfa_meminfo_kva(mi);
5192 * Initialize UFs and queue it in UF free queue
5194 for (i = 0, uf = ufm->uf_list; i < ufm->num_ufs; i++, uf++) {
5195 memset(uf, 0, sizeof(struct bfa_uf_s));
5198 uf->pb_len = sizeof(struct bfa_uf_buf_s);
5199 uf->buf_kva = (void *)&ufm->uf_pbs_kva[i];
5200 uf->buf_pa = ufm_pbs_pa(ufm, i);
5201 list_add_tail(&uf->qe, &ufm->uf_free_q);
5205 * advance memory pointer
5207 bfa_meminfo_kva(mi) = (u8 *) uf;
5211 uf_mem_claim(struct bfa_uf_mod_s *ufm, struct bfa_meminfo_s *mi)
5213 claim_uf_pbs(ufm, mi);
5215 claim_uf_post_msgs(ufm, mi);
5219 bfa_uf_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len, u32 *dm_len)
5221 u32 num_ufs = cfg->fwcfg.num_uf_bufs;
5224 * dma-able memory for UF posted bufs
5226 *dm_len += BFA_ROUNDUP((sizeof(struct bfa_uf_buf_s) * num_ufs),
5230 * kernel Virtual memory for UFs and UF buf post msg copies
5232 *ndm_len += sizeof(struct bfa_uf_s) * num_ufs;
5233 *ndm_len += sizeof(struct bfi_uf_buf_post_s) * num_ufs;
5237 bfa_uf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
5238 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
5240 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5242 memset(ufm, 0, sizeof(struct bfa_uf_mod_s));
5244 ufm->num_ufs = cfg->fwcfg.num_uf_bufs;
5245 INIT_LIST_HEAD(&ufm->uf_free_q);
5246 INIT_LIST_HEAD(&ufm->uf_posted_q);
5248 uf_mem_claim(ufm, meminfo);
5252 bfa_uf_detach(struct bfa_s *bfa)
5256 static struct bfa_uf_s *
5257 bfa_uf_get(struct bfa_uf_mod_s *uf_mod)
5259 struct bfa_uf_s *uf;
5261 bfa_q_deq(&uf_mod->uf_free_q, &uf);
5266 bfa_uf_put(struct bfa_uf_mod_s *uf_mod, struct bfa_uf_s *uf)
5268 list_add_tail(&uf->qe, &uf_mod->uf_free_q);
5272 bfa_uf_post(struct bfa_uf_mod_s *ufm, struct bfa_uf_s *uf)
5274 struct bfi_uf_buf_post_s *uf_post_msg;
5276 uf_post_msg = bfa_reqq_next(ufm->bfa, BFA_REQQ_FCXP);
5278 return BFA_STATUS_FAILED;
5280 memcpy(uf_post_msg, &ufm->uf_buf_posts[uf->uf_tag],
5281 sizeof(struct bfi_uf_buf_post_s));
5282 bfa_reqq_produce(ufm->bfa, BFA_REQQ_FCXP);
5284 bfa_trc(ufm->bfa, uf->uf_tag);
5286 list_add_tail(&uf->qe, &ufm->uf_posted_q);
5287 return BFA_STATUS_OK;
5291 bfa_uf_post_all(struct bfa_uf_mod_s *uf_mod)
5293 struct bfa_uf_s *uf;
5295 while ((uf = bfa_uf_get(uf_mod)) != NULL) {
5296 if (bfa_uf_post(uf_mod, uf) != BFA_STATUS_OK)
5302 uf_recv(struct bfa_s *bfa, struct bfi_uf_frm_rcvd_s *m)
5304 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5305 u16 uf_tag = m->buf_tag;
5306 struct bfa_uf_buf_s *uf_buf = &ufm->uf_pbs_kva[uf_tag];
5307 struct bfa_uf_s *uf = &ufm->uf_list[uf_tag];
5308 u8 *buf = &uf_buf->d[0];
5309 struct fchs_s *fchs;
5311 m->frm_len = be16_to_cpu(m->frm_len);
5312 m->xfr_len = be16_to_cpu(m->xfr_len);
5314 fchs = (struct fchs_s *)uf_buf;
5316 list_del(&uf->qe); /* dequeue from posted queue */
5319 uf->data_len = m->xfr_len;
5321 bfa_assert(uf->data_len >= sizeof(struct fchs_s));
5323 if (uf->data_len == sizeof(struct fchs_s)) {
5324 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_UF, BFA_PL_EID_RX,
5325 uf->data_len, (struct fchs_s *)buf);
5327 u32 pld_w0 = *((u32 *) (buf + sizeof(struct fchs_s)));
5328 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_UF,
5329 BFA_PL_EID_RX, uf->data_len,
5330 (struct fchs_s *)buf, pld_w0);
5334 __bfa_cb_uf_recv(uf, BFA_TRUE);
5336 bfa_cb_queue(bfa, &uf->hcb_qe, __bfa_cb_uf_recv, uf);
5340 bfa_uf_stop(struct bfa_s *bfa)
5345 bfa_uf_iocdisable(struct bfa_s *bfa)
5347 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5348 struct bfa_uf_s *uf;
5349 struct list_head *qe, *qen;
5351 list_for_each_safe(qe, qen, &ufm->uf_posted_q) {
5352 uf = (struct bfa_uf_s *) qe;
5354 bfa_uf_put(ufm, uf);
5359 bfa_uf_start(struct bfa_s *bfa)
5361 bfa_uf_post_all(BFA_UF_MOD(bfa));
5371 * Register handler for all unsolicted recieve frames.
5373 * @param[in] bfa BFA instance
5374 * @param[in] ufrecv receive handler function
5375 * @param[in] cbarg receive handler arg
5378 bfa_uf_recv_register(struct bfa_s *bfa, bfa_cb_uf_recv_t ufrecv, void *cbarg)
5380 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5382 ufm->ufrecv = ufrecv;
5387 * Free an unsolicited frame back to BFA.
5389 * @param[in] uf unsolicited frame to be freed
5394 bfa_uf_free(struct bfa_uf_s *uf)
5396 bfa_uf_put(BFA_UF_MOD(uf->bfa), uf);
5397 bfa_uf_post_all(BFA_UF_MOD(uf->bfa));
5403 * uf_pub BFA uf module public functions
5406 bfa_uf_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
5408 bfa_trc(bfa, msg->mhdr.msg_id);
5410 switch (msg->mhdr.msg_id) {
5411 case BFI_UF_I2H_FRM_RCVD:
5412 uf_recv(bfa, (struct bfi_uf_frm_rcvd_s *) msg);
5416 bfa_trc(bfa, msg->mhdr.msg_id);