1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
4 * Copyright (c) 2014- QLogic Corporation.
5 * All rights reserved
6 * www.qlogic.com
7 *
8 * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
9 */
10
11 #include "bfad_drv.h"
12 #include "bfad_im.h"
13 #include "bfa_plog.h"
14 #include "bfa_cs.h"
15 #include "bfa_modules.h"
16
17 BFA_TRC_FILE(HAL, FCXP);
18
19 /*
20 * LPS related definitions
21 */
22 #define BFA_LPS_MIN_LPORTS (1)
23 #define BFA_LPS_MAX_LPORTS (256)
24
25 /*
26 * Maximum Vports supported per physical port or vf.
27 */
28 #define BFA_LPS_MAX_VPORTS_SUPP_CB 255
29 #define BFA_LPS_MAX_VPORTS_SUPP_CT 190
30
31
32 /*
33 * FC PORT related definitions
34 */
35 /*
36 * The port is considered disabled if corresponding physical port or IOC are
37 * disabled explicitly
38 */
39 #define BFA_PORT_IS_DISABLED(bfa) \
40 ((bfa_fcport_is_disabled(bfa) == BFA_TRUE) || \
41 (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE))
42
43 /*
44 * RPORT related definitions
45 */
46 #define bfa_rport_offline_cb(__rp) do { \
47 if ((__rp)->bfa->fcs) \
48 bfa_cb_rport_offline((__rp)->rport_drv); \
49 else { \
50 bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe, \
51 __bfa_cb_rport_offline, (__rp)); \
52 } \
53 } while (0)
54
55 #define bfa_rport_online_cb(__rp) do { \
56 if ((__rp)->bfa->fcs) \
57 bfa_cb_rport_online((__rp)->rport_drv); \
58 else { \
59 bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe, \
60 __bfa_cb_rport_online, (__rp)); \
61 } \
62 } while (0)
63
64 /*
65 * forward declarations FCXP related functions
66 */
67 static void __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete);
68 static void hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
69 struct bfi_fcxp_send_rsp_s *fcxp_rsp);
70 static void hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen,
71 struct bfa_fcxp_s *fcxp, struct fchs_s *fchs);
72 static void bfa_fcxp_qresume(void *cbarg);
73 static void bfa_fcxp_queue(struct bfa_fcxp_s *fcxp,
74 struct bfi_fcxp_send_req_s *send_req);
75
76 /*
77 * forward declarations for LPS functions
78 */
79 static void bfa_lps_login_rsp(struct bfa_s *bfa,
80 struct bfi_lps_login_rsp_s *rsp);
81 static void bfa_lps_no_res(struct bfa_lps_s *first_lps, u8 count);
82 static void bfa_lps_logout_rsp(struct bfa_s *bfa,
83 struct bfi_lps_logout_rsp_s *rsp);
84 static void bfa_lps_reqq_resume(void *lps_arg);
85 static void bfa_lps_free(struct bfa_lps_s *lps);
86 static void bfa_lps_send_login(struct bfa_lps_s *lps);
87 static void bfa_lps_send_logout(struct bfa_lps_s *lps);
88 static void bfa_lps_send_set_n2n_pid(struct bfa_lps_s *lps);
89 static void bfa_lps_login_comp(struct bfa_lps_s *lps);
90 static void bfa_lps_logout_comp(struct bfa_lps_s *lps);
91 static void bfa_lps_cvl_event(struct bfa_lps_s *lps);
92
93 /*
94 * forward declaration for LPS state machine
95 */
96 static void bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event);
97 static void bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event);
98 static void bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event
99 event);
100 static void bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event);
101 static void bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps,
102 enum bfa_lps_event event);
103 static void bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event);
104 static void bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event
105 event);
106
107 /*
108 * forward declaration for FC Port functions
109 */
110 static bfa_boolean_t bfa_fcport_send_enable(struct bfa_fcport_s *fcport);
111 static bfa_boolean_t bfa_fcport_send_disable(struct bfa_fcport_s *fcport);
112 static void bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport);
113 static void bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport);
114 static void bfa_fcport_set_wwns(struct bfa_fcport_s *fcport);
115 static void __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete);
116 static void bfa_fcport_scn(struct bfa_fcport_s *fcport,
117 enum bfa_port_linkstate event, bfa_boolean_t trunk);
118 static void bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln,
119 enum bfa_port_linkstate event);
120 static void __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete);
121 static void bfa_fcport_stats_get_timeout(void *cbarg);
122 static void bfa_fcport_stats_clr_timeout(void *cbarg);
123 static void bfa_trunk_iocdisable(struct bfa_s *bfa);
124
125 /*
126 * forward declaration for FC PORT state machine
127 */
128 static void bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
129 enum bfa_fcport_sm_event event);
130 static void bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
131 enum bfa_fcport_sm_event event);
132 static void bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
133 enum bfa_fcport_sm_event event);
134 static void bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
135 enum bfa_fcport_sm_event event);
136 static void bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
137 enum bfa_fcport_sm_event event);
138 static void bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
139 enum bfa_fcport_sm_event event);
140 static void bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
141 enum bfa_fcport_sm_event event);
142 static void bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
143 enum bfa_fcport_sm_event event);
144 static void bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
145 enum bfa_fcport_sm_event event);
146 static void bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
147 enum bfa_fcport_sm_event event);
148 static void bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
149 enum bfa_fcport_sm_event event);
150 static void bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
151 enum bfa_fcport_sm_event event);
152 static void bfa_fcport_sm_dport(struct bfa_fcport_s *fcport,
153 enum bfa_fcport_sm_event event);
154 static void bfa_fcport_sm_ddport(struct bfa_fcport_s *fcport,
155 enum bfa_fcport_sm_event event);
156 static void bfa_fcport_sm_faa_misconfig(struct bfa_fcport_s *fcport,
157 enum bfa_fcport_sm_event event);
158
159 static void bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
160 enum bfa_fcport_ln_sm_event event);
161 static void bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
162 enum bfa_fcport_ln_sm_event event);
163 static void bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
164 enum bfa_fcport_ln_sm_event event);
165 static void bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
166 enum bfa_fcport_ln_sm_event event);
167 static void bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
168 enum bfa_fcport_ln_sm_event event);
169 static void bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
170 enum bfa_fcport_ln_sm_event event);
171 static void bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
172 enum bfa_fcport_ln_sm_event event);
173
174 struct bfa_fcport_sm_table_s {
175 bfa_fcport_sm_t sm; /* state machine function */
176 enum bfa_port_states state; /* state machine encoding */
177 char *name; /* state name for display */
178 };
179
180 static inline enum bfa_port_states
bfa_fcport_sm_to_state(struct bfa_fcport_sm_table_s * smt,bfa_fcport_sm_t sm)181 bfa_fcport_sm_to_state(struct bfa_fcport_sm_table_s *smt, bfa_fcport_sm_t sm)
182 {
183 int i = 0;
184
185 while (smt[i].sm && smt[i].sm != sm)
186 i++;
187 return smt[i].state;
188 }
189
190 static struct bfa_fcport_sm_table_s hal_port_sm_table[] = {
191 {BFA_SM(bfa_fcport_sm_uninit), BFA_PORT_ST_UNINIT},
192 {BFA_SM(bfa_fcport_sm_enabling_qwait), BFA_PORT_ST_ENABLING_QWAIT},
193 {BFA_SM(bfa_fcport_sm_enabling), BFA_PORT_ST_ENABLING},
194 {BFA_SM(bfa_fcport_sm_linkdown), BFA_PORT_ST_LINKDOWN},
195 {BFA_SM(bfa_fcport_sm_linkup), BFA_PORT_ST_LINKUP},
196 {BFA_SM(bfa_fcport_sm_disabling_qwait), BFA_PORT_ST_DISABLING_QWAIT},
197 {BFA_SM(bfa_fcport_sm_toggling_qwait), BFA_PORT_ST_TOGGLING_QWAIT},
198 {BFA_SM(bfa_fcport_sm_disabling), BFA_PORT_ST_DISABLING},
199 {BFA_SM(bfa_fcport_sm_disabled), BFA_PORT_ST_DISABLED},
200 {BFA_SM(bfa_fcport_sm_stopped), BFA_PORT_ST_STOPPED},
201 {BFA_SM(bfa_fcport_sm_iocdown), BFA_PORT_ST_IOCDOWN},
202 {BFA_SM(bfa_fcport_sm_iocfail), BFA_PORT_ST_IOCDOWN},
203 {BFA_SM(bfa_fcport_sm_dport), BFA_PORT_ST_DPORT},
204 {BFA_SM(bfa_fcport_sm_ddport), BFA_PORT_ST_DDPORT},
205 {BFA_SM(bfa_fcport_sm_faa_misconfig), BFA_PORT_ST_FAA_MISCONFIG},
206 };
207
208
209 /*
210 * forward declaration for RPORT related functions
211 */
212 static struct bfa_rport_s *bfa_rport_alloc(struct bfa_rport_mod_s *rp_mod);
213 static void bfa_rport_free(struct bfa_rport_s *rport);
214 static bfa_boolean_t bfa_rport_send_fwcreate(struct bfa_rport_s *rp);
215 static bfa_boolean_t bfa_rport_send_fwdelete(struct bfa_rport_s *rp);
216 static bfa_boolean_t bfa_rport_send_fwspeed(struct bfa_rport_s *rp);
217 static void __bfa_cb_rport_online(void *cbarg,
218 bfa_boolean_t complete);
219 static void __bfa_cb_rport_offline(void *cbarg,
220 bfa_boolean_t complete);
221
222 /*
223 * forward declaration for RPORT state machine
224 */
225 static void bfa_rport_sm_uninit(struct bfa_rport_s *rp,
226 enum bfa_rport_event event);
227 static void bfa_rport_sm_created(struct bfa_rport_s *rp,
228 enum bfa_rport_event event);
229 static void bfa_rport_sm_fwcreate(struct bfa_rport_s *rp,
230 enum bfa_rport_event event);
231 static void bfa_rport_sm_online(struct bfa_rport_s *rp,
232 enum bfa_rport_event event);
233 static void bfa_rport_sm_fwdelete(struct bfa_rport_s *rp,
234 enum bfa_rport_event event);
235 static void bfa_rport_sm_offline(struct bfa_rport_s *rp,
236 enum bfa_rport_event event);
237 static void bfa_rport_sm_deleting(struct bfa_rport_s *rp,
238 enum bfa_rport_event event);
239 static void bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
240 enum bfa_rport_event event);
241 static void bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
242 enum bfa_rport_event event);
243 static void bfa_rport_sm_iocdisable(struct bfa_rport_s *rp,
244 enum bfa_rport_event event);
245 static void bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp,
246 enum bfa_rport_event event);
247 static void bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp,
248 enum bfa_rport_event event);
249 static void bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp,
250 enum bfa_rport_event event);
251
252 /*
253 * PLOG related definitions
254 */
255 static int
plkd_validate_logrec(struct bfa_plog_rec_s * pl_rec)256 plkd_validate_logrec(struct bfa_plog_rec_s *pl_rec)
257 {
258 if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) &&
259 (pl_rec->log_type != BFA_PL_LOG_TYPE_STRING))
260 return 1;
261
262 if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) &&
263 (pl_rec->log_num_ints > BFA_PL_INT_LOG_SZ))
264 return 1;
265
266 return 0;
267 }
268
269 static void
bfa_plog_add(struct bfa_plog_s * plog,struct bfa_plog_rec_s * pl_rec)270 bfa_plog_add(struct bfa_plog_s *plog, struct bfa_plog_rec_s *pl_rec)
271 {
272 u16 tail;
273 struct bfa_plog_rec_s *pl_recp;
274
275 if (plog->plog_enabled == 0)
276 return;
277
278 if (plkd_validate_logrec(pl_rec)) {
279 WARN_ON(1);
280 return;
281 }
282
283 tail = plog->tail;
284
285 pl_recp = &(plog->plog_recs[tail]);
286
287 memcpy(pl_recp, pl_rec, sizeof(struct bfa_plog_rec_s));
288
289 pl_recp->tv = ktime_get_real_seconds();
290 BFA_PL_LOG_REC_INCR(plog->tail);
291
292 if (plog->head == plog->tail)
293 BFA_PL_LOG_REC_INCR(plog->head);
294 }
295
296 void
bfa_plog_init(struct bfa_plog_s * plog)297 bfa_plog_init(struct bfa_plog_s *plog)
298 {
299 memset((char *)plog, 0, sizeof(struct bfa_plog_s));
300
301 memcpy(plog->plog_sig, BFA_PL_SIG_STR, BFA_PL_SIG_LEN);
302 plog->head = plog->tail = 0;
303 plog->plog_enabled = 1;
304 }
305
306 void
bfa_plog_str(struct bfa_plog_s * plog,enum bfa_plog_mid mid,enum bfa_plog_eid event,u16 misc,char * log_str)307 bfa_plog_str(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
308 enum bfa_plog_eid event,
309 u16 misc, char *log_str)
310 {
311 struct bfa_plog_rec_s lp;
312
313 if (plog->plog_enabled) {
314 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
315 lp.mid = mid;
316 lp.eid = event;
317 lp.log_type = BFA_PL_LOG_TYPE_STRING;
318 lp.misc = misc;
319 strscpy(lp.log_entry.string_log, log_str,
320 BFA_PL_STRING_LOG_SZ);
321 lp.log_entry.string_log[BFA_PL_STRING_LOG_SZ - 1] = '\0';
322 bfa_plog_add(plog, &lp);
323 }
324 }
325
326 void
bfa_plog_intarr(struct bfa_plog_s * plog,enum bfa_plog_mid mid,enum bfa_plog_eid event,u16 misc,u32 * intarr,u32 num_ints)327 bfa_plog_intarr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
328 enum bfa_plog_eid event,
329 u16 misc, u32 *intarr, u32 num_ints)
330 {
331 struct bfa_plog_rec_s lp;
332 u32 i;
333
334 if (num_ints > BFA_PL_INT_LOG_SZ)
335 num_ints = BFA_PL_INT_LOG_SZ;
336
337 if (plog->plog_enabled) {
338 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
339 lp.mid = mid;
340 lp.eid = event;
341 lp.log_type = BFA_PL_LOG_TYPE_INT;
342 lp.misc = misc;
343
344 for (i = 0; i < num_ints; i++)
345 lp.log_entry.int_log[i] = intarr[i];
346
347 lp.log_num_ints = (u8) num_ints;
348
349 bfa_plog_add(plog, &lp);
350 }
351 }
352
353 void
bfa_plog_fchdr(struct bfa_plog_s * plog,enum bfa_plog_mid mid,enum bfa_plog_eid event,u16 misc,struct fchs_s * fchdr)354 bfa_plog_fchdr(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
355 enum bfa_plog_eid event,
356 u16 misc, struct fchs_s *fchdr)
357 {
358 u32 *tmp_int = (u32 *) fchdr;
359 u32 ints[BFA_PL_INT_LOG_SZ];
360
361 if (plog->plog_enabled) {
362 ints[0] = tmp_int[0];
363 ints[1] = tmp_int[1];
364 ints[2] = tmp_int[4];
365
366 bfa_plog_intarr(plog, mid, event, misc, ints, 3);
367 }
368 }
369
370 void
bfa_plog_fchdr_and_pl(struct bfa_plog_s * plog,enum bfa_plog_mid mid,enum bfa_plog_eid event,u16 misc,struct fchs_s * fchdr,u32 pld_w0)371 bfa_plog_fchdr_and_pl(struct bfa_plog_s *plog, enum bfa_plog_mid mid,
372 enum bfa_plog_eid event, u16 misc, struct fchs_s *fchdr,
373 u32 pld_w0)
374 {
375 u32 *tmp_int = (u32 *) fchdr;
376 u32 ints[BFA_PL_INT_LOG_SZ];
377
378 if (plog->plog_enabled) {
379 ints[0] = tmp_int[0];
380 ints[1] = tmp_int[1];
381 ints[2] = tmp_int[4];
382 ints[3] = pld_w0;
383
384 bfa_plog_intarr(plog, mid, event, misc, ints, 4);
385 }
386 }
387
388
389 /*
390 * fcxp_pvt BFA FCXP private functions
391 */
392
393 static void
claim_fcxps_mem(struct bfa_fcxp_mod_s * mod)394 claim_fcxps_mem(struct bfa_fcxp_mod_s *mod)
395 {
396 u16 i;
397 struct bfa_fcxp_s *fcxp;
398
399 fcxp = (struct bfa_fcxp_s *) bfa_mem_kva_curp(mod);
400 memset(fcxp, 0, sizeof(struct bfa_fcxp_s) * mod->num_fcxps);
401
402 INIT_LIST_HEAD(&mod->fcxp_req_free_q);
403 INIT_LIST_HEAD(&mod->fcxp_rsp_free_q);
404 INIT_LIST_HEAD(&mod->fcxp_active_q);
405 INIT_LIST_HEAD(&mod->fcxp_req_unused_q);
406 INIT_LIST_HEAD(&mod->fcxp_rsp_unused_q);
407
408 mod->fcxp_list = fcxp;
409
410 for (i = 0; i < mod->num_fcxps; i++) {
411 fcxp->fcxp_mod = mod;
412 fcxp->fcxp_tag = i;
413
414 if (i < (mod->num_fcxps / 2)) {
415 list_add_tail(&fcxp->qe, &mod->fcxp_req_free_q);
416 fcxp->req_rsp = BFA_TRUE;
417 } else {
418 list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q);
419 fcxp->req_rsp = BFA_FALSE;
420 }
421
422 bfa_reqq_winit(&fcxp->reqq_wqe, bfa_fcxp_qresume, fcxp);
423 fcxp->reqq_waiting = BFA_FALSE;
424
425 fcxp = fcxp + 1;
426 }
427
428 bfa_mem_kva_curp(mod) = (void *)fcxp;
429 }
430
431 void
bfa_fcxp_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)432 bfa_fcxp_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
433 struct bfa_s *bfa)
434 {
435 struct bfa_fcxp_mod_s *fcxp_mod = BFA_FCXP_MOD(bfa);
436 struct bfa_mem_kva_s *fcxp_kva = BFA_MEM_FCXP_KVA(bfa);
437 struct bfa_mem_dma_s *seg_ptr;
438 u16 nsegs, idx, per_seg_fcxp;
439 u16 num_fcxps = cfg->fwcfg.num_fcxp_reqs;
440 u32 per_fcxp_sz;
441
442 if (num_fcxps == 0)
443 return;
444
445 if (cfg->drvcfg.min_cfg)
446 per_fcxp_sz = 2 * BFA_FCXP_MAX_IBUF_SZ;
447 else
448 per_fcxp_sz = BFA_FCXP_MAX_IBUF_SZ + BFA_FCXP_MAX_LBUF_SZ;
449
450 /* dma memory */
451 nsegs = BFI_MEM_DMA_NSEGS(num_fcxps, per_fcxp_sz);
452 per_seg_fcxp = BFI_MEM_NREQS_SEG(per_fcxp_sz);
453
454 bfa_mem_dma_seg_iter(fcxp_mod, seg_ptr, nsegs, idx) {
455 if (num_fcxps >= per_seg_fcxp) {
456 num_fcxps -= per_seg_fcxp;
457 bfa_mem_dma_setup(minfo, seg_ptr,
458 per_seg_fcxp * per_fcxp_sz);
459 } else
460 bfa_mem_dma_setup(minfo, seg_ptr,
461 num_fcxps * per_fcxp_sz);
462 }
463
464 /* kva memory */
465 bfa_mem_kva_setup(minfo, fcxp_kva,
466 cfg->fwcfg.num_fcxp_reqs * sizeof(struct bfa_fcxp_s));
467 }
468
469 void
bfa_fcxp_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)470 bfa_fcxp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
471 struct bfa_pcidev_s *pcidev)
472 {
473 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
474
475 mod->bfa = bfa;
476 mod->num_fcxps = cfg->fwcfg.num_fcxp_reqs;
477
478 /*
479 * Initialize FCXP request and response payload sizes.
480 */
481 mod->req_pld_sz = mod->rsp_pld_sz = BFA_FCXP_MAX_IBUF_SZ;
482 if (!cfg->drvcfg.min_cfg)
483 mod->rsp_pld_sz = BFA_FCXP_MAX_LBUF_SZ;
484
485 INIT_LIST_HEAD(&mod->req_wait_q);
486 INIT_LIST_HEAD(&mod->rsp_wait_q);
487
488 claim_fcxps_mem(mod);
489 }
490
491 void
bfa_fcxp_iocdisable(struct bfa_s * bfa)492 bfa_fcxp_iocdisable(struct bfa_s *bfa)
493 {
494 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
495 struct bfa_fcxp_s *fcxp;
496 struct list_head *qe, *qen;
497
498 /* Enqueue unused fcxp resources to free_q */
499 list_splice_tail_init(&mod->fcxp_req_unused_q, &mod->fcxp_req_free_q);
500 list_splice_tail_init(&mod->fcxp_rsp_unused_q, &mod->fcxp_rsp_free_q);
501
502 list_for_each_safe(qe, qen, &mod->fcxp_active_q) {
503 fcxp = (struct bfa_fcxp_s *) qe;
504 if (fcxp->caller == NULL) {
505 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
506 BFA_STATUS_IOC_FAILURE, 0, 0, NULL);
507 bfa_fcxp_free(fcxp);
508 } else {
509 fcxp->rsp_status = BFA_STATUS_IOC_FAILURE;
510 bfa_cb_queue(bfa, &fcxp->hcb_qe,
511 __bfa_fcxp_send_cbfn, fcxp);
512 }
513 }
514 }
515
516 static struct bfa_fcxp_s *
bfa_fcxp_get(struct bfa_fcxp_mod_s * fm,bfa_boolean_t req)517 bfa_fcxp_get(struct bfa_fcxp_mod_s *fm, bfa_boolean_t req)
518 {
519 struct bfa_fcxp_s *fcxp;
520
521 if (req)
522 bfa_q_deq(&fm->fcxp_req_free_q, &fcxp);
523 else
524 bfa_q_deq(&fm->fcxp_rsp_free_q, &fcxp);
525
526 if (fcxp)
527 list_add_tail(&fcxp->qe, &fm->fcxp_active_q);
528
529 return fcxp;
530 }
531
532 static void
bfa_fcxp_init_reqrsp(struct bfa_fcxp_s * fcxp,struct bfa_s * bfa,u8 * use_ibuf,u32 * nr_sgles,bfa_fcxp_get_sgaddr_t * r_sga_cbfn,bfa_fcxp_get_sglen_t * r_sglen_cbfn,struct list_head * r_sgpg_q,int n_sgles,bfa_fcxp_get_sgaddr_t sga_cbfn,bfa_fcxp_get_sglen_t sglen_cbfn)533 bfa_fcxp_init_reqrsp(struct bfa_fcxp_s *fcxp,
534 struct bfa_s *bfa,
535 u8 *use_ibuf,
536 u32 *nr_sgles,
537 bfa_fcxp_get_sgaddr_t *r_sga_cbfn,
538 bfa_fcxp_get_sglen_t *r_sglen_cbfn,
539 struct list_head *r_sgpg_q,
540 int n_sgles,
541 bfa_fcxp_get_sgaddr_t sga_cbfn,
542 bfa_fcxp_get_sglen_t sglen_cbfn)
543 {
544
545 WARN_ON(bfa == NULL);
546
547 bfa_trc(bfa, fcxp->fcxp_tag);
548
549 if (n_sgles == 0) {
550 *use_ibuf = 1;
551 } else {
552 WARN_ON(*sga_cbfn == NULL);
553 WARN_ON(*sglen_cbfn == NULL);
554
555 *use_ibuf = 0;
556 *r_sga_cbfn = sga_cbfn;
557 *r_sglen_cbfn = sglen_cbfn;
558
559 *nr_sgles = n_sgles;
560
561 /*
562 * alloc required sgpgs
563 */
564 if (n_sgles > BFI_SGE_INLINE)
565 WARN_ON(1);
566 }
567
568 }
569
570 static void
bfa_fcxp_init(struct bfa_fcxp_s * fcxp,void * caller,struct bfa_s * bfa,int nreq_sgles,int nrsp_sgles,bfa_fcxp_get_sgaddr_t req_sga_cbfn,bfa_fcxp_get_sglen_t req_sglen_cbfn,bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,bfa_fcxp_get_sglen_t rsp_sglen_cbfn)571 bfa_fcxp_init(struct bfa_fcxp_s *fcxp,
572 void *caller, struct bfa_s *bfa, int nreq_sgles,
573 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
574 bfa_fcxp_get_sglen_t req_sglen_cbfn,
575 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
576 bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
577 {
578
579 WARN_ON(bfa == NULL);
580
581 bfa_trc(bfa, fcxp->fcxp_tag);
582
583 fcxp->caller = caller;
584
585 bfa_fcxp_init_reqrsp(fcxp, bfa,
586 &fcxp->use_ireqbuf, &fcxp->nreq_sgles, &fcxp->req_sga_cbfn,
587 &fcxp->req_sglen_cbfn, &fcxp->req_sgpg_q,
588 nreq_sgles, req_sga_cbfn, req_sglen_cbfn);
589
590 bfa_fcxp_init_reqrsp(fcxp, bfa,
591 &fcxp->use_irspbuf, &fcxp->nrsp_sgles, &fcxp->rsp_sga_cbfn,
592 &fcxp->rsp_sglen_cbfn, &fcxp->rsp_sgpg_q,
593 nrsp_sgles, rsp_sga_cbfn, rsp_sglen_cbfn);
594
595 }
596
597 static void
bfa_fcxp_put(struct bfa_fcxp_s * fcxp)598 bfa_fcxp_put(struct bfa_fcxp_s *fcxp)
599 {
600 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
601 struct bfa_fcxp_wqe_s *wqe;
602
603 if (fcxp->req_rsp)
604 bfa_q_deq(&mod->req_wait_q, &wqe);
605 else
606 bfa_q_deq(&mod->rsp_wait_q, &wqe);
607
608 if (wqe) {
609 bfa_trc(mod->bfa, fcxp->fcxp_tag);
610
611 bfa_fcxp_init(fcxp, wqe->caller, wqe->bfa, wqe->nreq_sgles,
612 wqe->nrsp_sgles, wqe->req_sga_cbfn,
613 wqe->req_sglen_cbfn, wqe->rsp_sga_cbfn,
614 wqe->rsp_sglen_cbfn);
615
616 wqe->alloc_cbfn(wqe->alloc_cbarg, fcxp);
617 return;
618 }
619
620 WARN_ON(!bfa_q_is_on_q(&mod->fcxp_active_q, fcxp));
621 list_del(&fcxp->qe);
622
623 if (fcxp->req_rsp)
624 list_add_tail(&fcxp->qe, &mod->fcxp_req_free_q);
625 else
626 list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q);
627 }
628
629 static void
bfa_fcxp_null_comp(void * bfad_fcxp,struct bfa_fcxp_s * fcxp,void * cbarg,bfa_status_t req_status,u32 rsp_len,u32 resid_len,struct fchs_s * rsp_fchs)630 bfa_fcxp_null_comp(void *bfad_fcxp, struct bfa_fcxp_s *fcxp, void *cbarg,
631 bfa_status_t req_status, u32 rsp_len,
632 u32 resid_len, struct fchs_s *rsp_fchs)
633 {
634 /* discarded fcxp completion */
635 }
636
637 static void
__bfa_fcxp_send_cbfn(void * cbarg,bfa_boolean_t complete)638 __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete)
639 {
640 struct bfa_fcxp_s *fcxp = cbarg;
641
642 if (complete) {
643 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
644 fcxp->rsp_status, fcxp->rsp_len,
645 fcxp->residue_len, &fcxp->rsp_fchs);
646 } else {
647 bfa_fcxp_free(fcxp);
648 }
649 }
650
651 static void
hal_fcxp_send_comp(struct bfa_s * bfa,struct bfi_fcxp_send_rsp_s * fcxp_rsp)652 hal_fcxp_send_comp(struct bfa_s *bfa, struct bfi_fcxp_send_rsp_s *fcxp_rsp)
653 {
654 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
655 struct bfa_fcxp_s *fcxp;
656 u16 fcxp_tag = be16_to_cpu(fcxp_rsp->fcxp_tag);
657
658 bfa_trc(bfa, fcxp_tag);
659
660 fcxp_rsp->rsp_len = be32_to_cpu(fcxp_rsp->rsp_len);
661
662 /*
663 * @todo f/w should not set residue to non-0 when everything
664 * is received.
665 */
666 if (fcxp_rsp->req_status == BFA_STATUS_OK)
667 fcxp_rsp->residue_len = 0;
668 else
669 fcxp_rsp->residue_len = be32_to_cpu(fcxp_rsp->residue_len);
670
671 fcxp = BFA_FCXP_FROM_TAG(mod, fcxp_tag);
672
673 WARN_ON(fcxp->send_cbfn == NULL);
674
675 hal_fcxp_rx_plog(mod->bfa, fcxp, fcxp_rsp);
676
677 if (fcxp->send_cbfn != NULL) {
678 bfa_trc(mod->bfa, (NULL == fcxp->caller));
679 if (fcxp->caller == NULL) {
680 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg,
681 fcxp_rsp->req_status, fcxp_rsp->rsp_len,
682 fcxp_rsp->residue_len, &fcxp_rsp->fchs);
683 /*
684 * fcxp automatically freed on return from the callback
685 */
686 bfa_fcxp_free(fcxp);
687 } else {
688 fcxp->rsp_status = fcxp_rsp->req_status;
689 fcxp->rsp_len = fcxp_rsp->rsp_len;
690 fcxp->residue_len = fcxp_rsp->residue_len;
691 fcxp->rsp_fchs = fcxp_rsp->fchs;
692
693 bfa_cb_queue(bfa, &fcxp->hcb_qe,
694 __bfa_fcxp_send_cbfn, fcxp);
695 }
696 } else {
697 bfa_trc(bfa, (NULL == fcxp->send_cbfn));
698 }
699 }
700
701 static void
hal_fcxp_tx_plog(struct bfa_s * bfa,u32 reqlen,struct bfa_fcxp_s * fcxp,struct fchs_s * fchs)702 hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen, struct bfa_fcxp_s *fcxp,
703 struct fchs_s *fchs)
704 {
705 /*
706 * TODO: TX ox_id
707 */
708 if (reqlen > 0) {
709 if (fcxp->use_ireqbuf) {
710 u32 pld_w0 =
711 *((u32 *) BFA_FCXP_REQ_PLD(fcxp));
712
713 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
714 BFA_PL_EID_TX,
715 reqlen + sizeof(struct fchs_s), fchs,
716 pld_w0);
717 } else {
718 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
719 BFA_PL_EID_TX,
720 reqlen + sizeof(struct fchs_s),
721 fchs);
722 }
723 } else {
724 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_TX,
725 reqlen + sizeof(struct fchs_s), fchs);
726 }
727 }
728
729 static void
hal_fcxp_rx_plog(struct bfa_s * bfa,struct bfa_fcxp_s * fcxp,struct bfi_fcxp_send_rsp_s * fcxp_rsp)730 hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
731 struct bfi_fcxp_send_rsp_s *fcxp_rsp)
732 {
733 if (fcxp_rsp->rsp_len > 0) {
734 if (fcxp->use_irspbuf) {
735 u32 pld_w0 =
736 *((u32 *) BFA_FCXP_RSP_PLD(fcxp));
737
738 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP,
739 BFA_PL_EID_RX,
740 (u16) fcxp_rsp->rsp_len,
741 &fcxp_rsp->fchs, pld_w0);
742 } else {
743 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
744 BFA_PL_EID_RX,
745 (u16) fcxp_rsp->rsp_len,
746 &fcxp_rsp->fchs);
747 }
748 } else {
749 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_RX,
750 (u16) fcxp_rsp->rsp_len, &fcxp_rsp->fchs);
751 }
752 }
753
754 /*
755 * Handler to resume sending fcxp when space in available in cpe queue.
756 */
757 static void
bfa_fcxp_qresume(void * cbarg)758 bfa_fcxp_qresume(void *cbarg)
759 {
760 struct bfa_fcxp_s *fcxp = cbarg;
761 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
762 struct bfi_fcxp_send_req_s *send_req;
763
764 fcxp->reqq_waiting = BFA_FALSE;
765 send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
766 bfa_fcxp_queue(fcxp, send_req);
767 }
768
769 /*
770 * Queue fcxp send request to foimrware.
771 */
772 static void
bfa_fcxp_queue(struct bfa_fcxp_s * fcxp,struct bfi_fcxp_send_req_s * send_req)773 bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req)
774 {
775 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
776 struct bfa_fcxp_req_info_s *reqi = &fcxp->req_info;
777 struct bfa_fcxp_rsp_info_s *rspi = &fcxp->rsp_info;
778 struct bfa_rport_s *rport = reqi->bfa_rport;
779
780 bfi_h2i_set(send_req->mh, BFI_MC_FCXP, BFI_FCXP_H2I_SEND_REQ,
781 bfa_fn_lpu(bfa));
782
783 send_req->fcxp_tag = cpu_to_be16(fcxp->fcxp_tag);
784 if (rport) {
785 send_req->rport_fw_hndl = rport->fw_handle;
786 send_req->max_frmsz = cpu_to_be16(rport->rport_info.max_frmsz);
787 if (send_req->max_frmsz == 0)
788 send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
789 } else {
790 send_req->rport_fw_hndl = 0;
791 send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
792 }
793
794 send_req->vf_id = cpu_to_be16(reqi->vf_id);
795 send_req->lp_fwtag = bfa_lps_get_fwtag(bfa, reqi->lp_tag);
796 send_req->class = reqi->class;
797 send_req->rsp_timeout = rspi->rsp_timeout;
798 send_req->cts = reqi->cts;
799 send_req->fchs = reqi->fchs;
800
801 send_req->req_len = cpu_to_be32(reqi->req_tot_len);
802 send_req->rsp_maxlen = cpu_to_be32(rspi->rsp_maxlen);
803
804 /*
805 * setup req sgles
806 */
807 if (fcxp->use_ireqbuf == 1) {
808 bfa_alen_set(&send_req->req_alen, reqi->req_tot_len,
809 BFA_FCXP_REQ_PLD_PA(fcxp));
810 } else {
811 if (fcxp->nreq_sgles > 0) {
812 WARN_ON(fcxp->nreq_sgles != 1);
813 bfa_alen_set(&send_req->req_alen, reqi->req_tot_len,
814 fcxp->req_sga_cbfn(fcxp->caller, 0));
815 } else {
816 WARN_ON(reqi->req_tot_len != 0);
817 bfa_alen_set(&send_req->rsp_alen, 0, 0);
818 }
819 }
820
821 /*
822 * setup rsp sgles
823 */
824 if (fcxp->use_irspbuf == 1) {
825 WARN_ON(rspi->rsp_maxlen > BFA_FCXP_MAX_LBUF_SZ);
826
827 bfa_alen_set(&send_req->rsp_alen, rspi->rsp_maxlen,
828 BFA_FCXP_RSP_PLD_PA(fcxp));
829 } else {
830 if (fcxp->nrsp_sgles > 0) {
831 WARN_ON(fcxp->nrsp_sgles != 1);
832 bfa_alen_set(&send_req->rsp_alen, rspi->rsp_maxlen,
833 fcxp->rsp_sga_cbfn(fcxp->caller, 0));
834
835 } else {
836 WARN_ON(rspi->rsp_maxlen != 0);
837 bfa_alen_set(&send_req->rsp_alen, 0, 0);
838 }
839 }
840
841 hal_fcxp_tx_plog(bfa, reqi->req_tot_len, fcxp, &reqi->fchs);
842
843 bfa_reqq_produce(bfa, BFA_REQQ_FCXP, send_req->mh);
844
845 bfa_trc(bfa, bfa_reqq_pi(bfa, BFA_REQQ_FCXP));
846 bfa_trc(bfa, bfa_reqq_ci(bfa, BFA_REQQ_FCXP));
847 }
848
849 /*
850 * Allocate an FCXP instance to send a response or to send a request
851 * that has a response. Request/response buffers are allocated by caller.
852 *
853 * @param[in] bfa BFA bfa instance
854 * @param[in] nreq_sgles Number of SG elements required for request
855 * buffer. 0, if fcxp internal buffers are used.
856 * Use bfa_fcxp_get_reqbuf() to get the
857 * internal req buffer.
858 * @param[in] req_sgles SG elements describing request buffer. Will be
859 * copied in by BFA and hence can be freed on
860 * return from this function.
861 * @param[in] get_req_sga function ptr to be called to get a request SG
862 * Address (given the sge index).
863 * @param[in] get_req_sglen function ptr to be called to get a request SG
864 * len (given the sge index).
865 * @param[in] get_rsp_sga function ptr to be called to get a response SG
866 * Address (given the sge index).
867 * @param[in] get_rsp_sglen function ptr to be called to get a response SG
868 * len (given the sge index).
869 * @param[in] req Allocated FCXP is used to send req or rsp?
870 * request - BFA_TRUE, response - BFA_FALSE
871 *
872 * @return FCXP instance. NULL on failure.
873 */
874 struct bfa_fcxp_s *
bfa_fcxp_req_rsp_alloc(void * caller,struct bfa_s * bfa,int nreq_sgles,int nrsp_sgles,bfa_fcxp_get_sgaddr_t req_sga_cbfn,bfa_fcxp_get_sglen_t req_sglen_cbfn,bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,bfa_fcxp_get_sglen_t rsp_sglen_cbfn,bfa_boolean_t req)875 bfa_fcxp_req_rsp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
876 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
877 bfa_fcxp_get_sglen_t req_sglen_cbfn,
878 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
879 bfa_fcxp_get_sglen_t rsp_sglen_cbfn, bfa_boolean_t req)
880 {
881 struct bfa_fcxp_s *fcxp = NULL;
882
883 WARN_ON(bfa == NULL);
884
885 fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa), req);
886 if (fcxp == NULL)
887 return NULL;
888
889 bfa_trc(bfa, fcxp->fcxp_tag);
890
891 bfa_fcxp_init(fcxp, caller, bfa, nreq_sgles, nrsp_sgles, req_sga_cbfn,
892 req_sglen_cbfn, rsp_sga_cbfn, rsp_sglen_cbfn);
893
894 return fcxp;
895 }
896
897 /*
898 * Get the internal request buffer pointer
899 *
900 * @param[in] fcxp BFA fcxp pointer
901 *
902 * @return pointer to the internal request buffer
903 */
904 void *
bfa_fcxp_get_reqbuf(struct bfa_fcxp_s * fcxp)905 bfa_fcxp_get_reqbuf(struct bfa_fcxp_s *fcxp)
906 {
907 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
908 void *reqbuf;
909
910 WARN_ON(fcxp->use_ireqbuf != 1);
911 reqbuf = bfa_mem_get_dmabuf_kva(mod, fcxp->fcxp_tag,
912 mod->req_pld_sz + mod->rsp_pld_sz);
913 return reqbuf;
914 }
915
916 u32
bfa_fcxp_get_reqbufsz(struct bfa_fcxp_s * fcxp)917 bfa_fcxp_get_reqbufsz(struct bfa_fcxp_s *fcxp)
918 {
919 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
920
921 return mod->req_pld_sz;
922 }
923
924 /*
925 * Get the internal response buffer pointer
926 *
927 * @param[in] fcxp BFA fcxp pointer
928 *
929 * @return pointer to the internal request buffer
930 */
931 void *
bfa_fcxp_get_rspbuf(struct bfa_fcxp_s * fcxp)932 bfa_fcxp_get_rspbuf(struct bfa_fcxp_s *fcxp)
933 {
934 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
935 void *fcxp_buf;
936
937 WARN_ON(fcxp->use_irspbuf != 1);
938
939 fcxp_buf = bfa_mem_get_dmabuf_kva(mod, fcxp->fcxp_tag,
940 mod->req_pld_sz + mod->rsp_pld_sz);
941
942 /* fcxp_buf = req_buf + rsp_buf :- add req_buf_sz to get to rsp_buf */
943 return ((u8 *) fcxp_buf) + mod->req_pld_sz;
944 }
945
946 /*
947 * Free the BFA FCXP
948 *
949 * @param[in] fcxp BFA fcxp pointer
950 *
951 * @return void
952 */
953 void
bfa_fcxp_free(struct bfa_fcxp_s * fcxp)954 bfa_fcxp_free(struct bfa_fcxp_s *fcxp)
955 {
956 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
957
958 WARN_ON(fcxp == NULL);
959 bfa_trc(mod->bfa, fcxp->fcxp_tag);
960 bfa_fcxp_put(fcxp);
961 }
962
963 /*
964 * Send a FCXP request
965 *
966 * @param[in] fcxp BFA fcxp pointer
967 * @param[in] rport BFA rport pointer. Could be left NULL for WKA rports
968 * @param[in] vf_id virtual Fabric ID
969 * @param[in] lp_tag lport tag
970 * @param[in] cts use Continuous sequence
971 * @param[in] cos fc Class of Service
972 * @param[in] reqlen request length, does not include FCHS length
973 * @param[in] fchs fc Header Pointer. The header content will be copied
974 * in by BFA.
975 *
976 * @param[in] cbfn call back function to be called on receiving
977 * the response
978 * @param[in] cbarg arg for cbfn
979 * @param[in] rsp_timeout
980 * response timeout
981 *
982 * @return bfa_status_t
983 */
984 void
bfa_fcxp_send(struct bfa_fcxp_s * fcxp,struct bfa_rport_s * rport,u16 vf_id,u8 lp_tag,bfa_boolean_t cts,enum fc_cos cos,u32 reqlen,struct fchs_s * fchs,bfa_cb_fcxp_send_t cbfn,void * cbarg,u32 rsp_maxlen,u8 rsp_timeout)985 bfa_fcxp_send(struct bfa_fcxp_s *fcxp, struct bfa_rport_s *rport,
986 u16 vf_id, u8 lp_tag, bfa_boolean_t cts, enum fc_cos cos,
987 u32 reqlen, struct fchs_s *fchs, bfa_cb_fcxp_send_t cbfn,
988 void *cbarg, u32 rsp_maxlen, u8 rsp_timeout)
989 {
990 struct bfa_s *bfa = fcxp->fcxp_mod->bfa;
991 struct bfa_fcxp_req_info_s *reqi = &fcxp->req_info;
992 struct bfa_fcxp_rsp_info_s *rspi = &fcxp->rsp_info;
993 struct bfi_fcxp_send_req_s *send_req;
994
995 bfa_trc(bfa, fcxp->fcxp_tag);
996
997 /*
998 * setup request/response info
999 */
1000 reqi->bfa_rport = rport;
1001 reqi->vf_id = vf_id;
1002 reqi->lp_tag = lp_tag;
1003 reqi->class = cos;
1004 rspi->rsp_timeout = rsp_timeout;
1005 reqi->cts = cts;
1006 reqi->fchs = *fchs;
1007 reqi->req_tot_len = reqlen;
1008 rspi->rsp_maxlen = rsp_maxlen;
1009 fcxp->send_cbfn = cbfn ? cbfn : bfa_fcxp_null_comp;
1010 fcxp->send_cbarg = cbarg;
1011
1012 /*
1013 * If no room in CPE queue, wait for space in request queue
1014 */
1015 send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP);
1016 if (!send_req) {
1017 bfa_trc(bfa, fcxp->fcxp_tag);
1018 fcxp->reqq_waiting = BFA_TRUE;
1019 bfa_reqq_wait(bfa, BFA_REQQ_FCXP, &fcxp->reqq_wqe);
1020 return;
1021 }
1022
1023 bfa_fcxp_queue(fcxp, send_req);
1024 }
1025
1026 /*
1027 * Abort a BFA FCXP
1028 *
1029 * @param[in] fcxp BFA fcxp pointer
1030 *
1031 * @return void
1032 */
1033 bfa_status_t
bfa_fcxp_abort(struct bfa_fcxp_s * fcxp)1034 bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
1035 {
1036 bfa_trc(fcxp->fcxp_mod->bfa, fcxp->fcxp_tag);
1037 WARN_ON(1);
1038 return BFA_STATUS_OK;
1039 }
1040
1041 void
bfa_fcxp_req_rsp_alloc_wait(struct bfa_s * bfa,struct bfa_fcxp_wqe_s * wqe,bfa_fcxp_alloc_cbfn_t alloc_cbfn,void * alloc_cbarg,void * caller,int nreq_sgles,int nrsp_sgles,bfa_fcxp_get_sgaddr_t req_sga_cbfn,bfa_fcxp_get_sglen_t req_sglen_cbfn,bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,bfa_fcxp_get_sglen_t rsp_sglen_cbfn,bfa_boolean_t req)1042 bfa_fcxp_req_rsp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
1043 bfa_fcxp_alloc_cbfn_t alloc_cbfn, void *alloc_cbarg,
1044 void *caller, int nreq_sgles,
1045 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
1046 bfa_fcxp_get_sglen_t req_sglen_cbfn,
1047 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
1048 bfa_fcxp_get_sglen_t rsp_sglen_cbfn, bfa_boolean_t req)
1049 {
1050 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1051
1052 if (req)
1053 WARN_ON(!list_empty(&mod->fcxp_req_free_q));
1054 else
1055 WARN_ON(!list_empty(&mod->fcxp_rsp_free_q));
1056
1057 wqe->alloc_cbfn = alloc_cbfn;
1058 wqe->alloc_cbarg = alloc_cbarg;
1059 wqe->caller = caller;
1060 wqe->bfa = bfa;
1061 wqe->nreq_sgles = nreq_sgles;
1062 wqe->nrsp_sgles = nrsp_sgles;
1063 wqe->req_sga_cbfn = req_sga_cbfn;
1064 wqe->req_sglen_cbfn = req_sglen_cbfn;
1065 wqe->rsp_sga_cbfn = rsp_sga_cbfn;
1066 wqe->rsp_sglen_cbfn = rsp_sglen_cbfn;
1067
1068 if (req)
1069 list_add_tail(&wqe->qe, &mod->req_wait_q);
1070 else
1071 list_add_tail(&wqe->qe, &mod->rsp_wait_q);
1072 }
1073
1074 void
bfa_fcxp_walloc_cancel(struct bfa_s * bfa,struct bfa_fcxp_wqe_s * wqe)1075 bfa_fcxp_walloc_cancel(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe)
1076 {
1077 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1078
1079 WARN_ON(!bfa_q_is_on_q(&mod->req_wait_q, wqe) ||
1080 !bfa_q_is_on_q(&mod->rsp_wait_q, wqe));
1081 list_del(&wqe->qe);
1082 }
1083
1084 void
bfa_fcxp_discard(struct bfa_fcxp_s * fcxp)1085 bfa_fcxp_discard(struct bfa_fcxp_s *fcxp)
1086 {
1087 /*
1088 * If waiting for room in request queue, cancel reqq wait
1089 * and free fcxp.
1090 */
1091 if (fcxp->reqq_waiting) {
1092 fcxp->reqq_waiting = BFA_FALSE;
1093 bfa_reqq_wcancel(&fcxp->reqq_wqe);
1094 bfa_fcxp_free(fcxp);
1095 return;
1096 }
1097
1098 fcxp->send_cbfn = bfa_fcxp_null_comp;
1099 }
1100
1101 void
bfa_fcxp_isr(struct bfa_s * bfa,struct bfi_msg_s * msg)1102 bfa_fcxp_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
1103 {
1104 switch (msg->mhdr.msg_id) {
1105 case BFI_FCXP_I2H_SEND_RSP:
1106 hal_fcxp_send_comp(bfa, (struct bfi_fcxp_send_rsp_s *) msg);
1107 break;
1108
1109 default:
1110 bfa_trc(bfa, msg->mhdr.msg_id);
1111 WARN_ON(1);
1112 }
1113 }
1114
1115 u32
bfa_fcxp_get_maxrsp(struct bfa_s * bfa)1116 bfa_fcxp_get_maxrsp(struct bfa_s *bfa)
1117 {
1118 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1119
1120 return mod->rsp_pld_sz;
1121 }
1122
1123 void
bfa_fcxp_res_recfg(struct bfa_s * bfa,u16 num_fcxp_fw)1124 bfa_fcxp_res_recfg(struct bfa_s *bfa, u16 num_fcxp_fw)
1125 {
1126 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
1127 struct list_head *qe;
1128 int i;
1129
1130 for (i = 0; i < (mod->num_fcxps - num_fcxp_fw); i++) {
1131 if (i < ((mod->num_fcxps - num_fcxp_fw) / 2)) {
1132 bfa_q_deq_tail(&mod->fcxp_req_free_q, &qe);
1133 list_add_tail(qe, &mod->fcxp_req_unused_q);
1134 } else {
1135 bfa_q_deq_tail(&mod->fcxp_rsp_free_q, &qe);
1136 list_add_tail(qe, &mod->fcxp_rsp_unused_q);
1137 }
1138 }
1139 }
1140
1141 /*
1142 * BFA LPS state machine functions
1143 */
1144
1145 /*
1146 * Init state -- no login
1147 */
1148 static void
bfa_lps_sm_init(struct bfa_lps_s * lps,enum bfa_lps_event event)1149 bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event)
1150 {
1151 bfa_trc(lps->bfa, lps->bfa_tag);
1152 bfa_trc(lps->bfa, event);
1153
1154 switch (event) {
1155 case BFA_LPS_SM_LOGIN:
1156 if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1157 bfa_sm_set_state(lps, bfa_lps_sm_loginwait);
1158 bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1159 } else {
1160 bfa_sm_set_state(lps, bfa_lps_sm_login);
1161 bfa_lps_send_login(lps);
1162 }
1163
1164 if (lps->fdisc)
1165 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1166 BFA_PL_EID_LOGIN, 0, "FDISC Request");
1167 else
1168 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1169 BFA_PL_EID_LOGIN, 0, "FLOGI Request");
1170 break;
1171
1172 case BFA_LPS_SM_LOGOUT:
1173 bfa_lps_logout_comp(lps);
1174 break;
1175
1176 case BFA_LPS_SM_DELETE:
1177 bfa_lps_free(lps);
1178 break;
1179
1180 case BFA_LPS_SM_RX_CVL:
1181 case BFA_LPS_SM_OFFLINE:
1182 break;
1183
1184 case BFA_LPS_SM_FWRSP:
1185 /*
1186 * Could happen when fabric detects loopback and discards
1187 * the lps request. Fw will eventually sent out the timeout
1188 * Just ignore
1189 */
1190 break;
1191 case BFA_LPS_SM_SET_N2N_PID:
1192 /*
1193 * When topology is set to loop, bfa_lps_set_n2n_pid() sends
1194 * this event. Ignore this event.
1195 */
1196 break;
1197
1198 default:
1199 bfa_sm_fault(lps->bfa, event);
1200 }
1201 }
1202
1203 /*
1204 * login is in progress -- awaiting response from firmware
1205 */
1206 static void
bfa_lps_sm_login(struct bfa_lps_s * lps,enum bfa_lps_event event)1207 bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
1208 {
1209 bfa_trc(lps->bfa, lps->bfa_tag);
1210 bfa_trc(lps->bfa, event);
1211
1212 switch (event) {
1213 case BFA_LPS_SM_FWRSP:
1214 if (lps->status == BFA_STATUS_OK) {
1215 bfa_sm_set_state(lps, bfa_lps_sm_online);
1216 if (lps->fdisc)
1217 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1218 BFA_PL_EID_LOGIN, 0, "FDISC Accept");
1219 else
1220 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1221 BFA_PL_EID_LOGIN, 0, "FLOGI Accept");
1222 /* If N2N, send the assigned PID to FW */
1223 bfa_trc(lps->bfa, lps->fport);
1224 bfa_trc(lps->bfa, lps->lp_pid);
1225
1226 if (!lps->fport && lps->lp_pid)
1227 bfa_sm_send_event(lps, BFA_LPS_SM_SET_N2N_PID);
1228 } else {
1229 bfa_sm_set_state(lps, bfa_lps_sm_init);
1230 if (lps->fdisc)
1231 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1232 BFA_PL_EID_LOGIN, 0,
1233 "FDISC Fail (RJT or timeout)");
1234 else
1235 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1236 BFA_PL_EID_LOGIN, 0,
1237 "FLOGI Fail (RJT or timeout)");
1238 }
1239 bfa_lps_login_comp(lps);
1240 break;
1241
1242 case BFA_LPS_SM_OFFLINE:
1243 case BFA_LPS_SM_DELETE:
1244 bfa_sm_set_state(lps, bfa_lps_sm_init);
1245 break;
1246
1247 case BFA_LPS_SM_SET_N2N_PID:
1248 bfa_trc(lps->bfa, lps->fport);
1249 bfa_trc(lps->bfa, lps->lp_pid);
1250 break;
1251
1252 default:
1253 bfa_sm_fault(lps->bfa, event);
1254 }
1255 }
1256
1257 /*
1258 * login pending - awaiting space in request queue
1259 */
1260 static void
bfa_lps_sm_loginwait(struct bfa_lps_s * lps,enum bfa_lps_event event)1261 bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1262 {
1263 bfa_trc(lps->bfa, lps->bfa_tag);
1264 bfa_trc(lps->bfa, event);
1265
1266 switch (event) {
1267 case BFA_LPS_SM_RESUME:
1268 bfa_sm_set_state(lps, bfa_lps_sm_login);
1269 bfa_lps_send_login(lps);
1270 break;
1271
1272 case BFA_LPS_SM_OFFLINE:
1273 case BFA_LPS_SM_DELETE:
1274 bfa_sm_set_state(lps, bfa_lps_sm_init);
1275 bfa_reqq_wcancel(&lps->wqe);
1276 break;
1277
1278 case BFA_LPS_SM_RX_CVL:
1279 /*
1280 * Login was not even sent out; so when getting out
1281 * of this state, it will appear like a login retry
1282 * after Clear virtual link
1283 */
1284 break;
1285
1286 default:
1287 bfa_sm_fault(lps->bfa, event);
1288 }
1289 }
1290
1291 /*
1292 * login complete
1293 */
1294 static void
bfa_lps_sm_online(struct bfa_lps_s * lps,enum bfa_lps_event event)1295 bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event)
1296 {
1297 bfa_trc(lps->bfa, lps->bfa_tag);
1298 bfa_trc(lps->bfa, event);
1299
1300 switch (event) {
1301 case BFA_LPS_SM_LOGOUT:
1302 if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1303 bfa_sm_set_state(lps, bfa_lps_sm_logowait);
1304 bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1305 } else {
1306 bfa_sm_set_state(lps, bfa_lps_sm_logout);
1307 bfa_lps_send_logout(lps);
1308 }
1309 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1310 BFA_PL_EID_LOGO, 0, "Logout");
1311 break;
1312
1313 case BFA_LPS_SM_RX_CVL:
1314 bfa_sm_set_state(lps, bfa_lps_sm_init);
1315
1316 /* Let the vport module know about this event */
1317 bfa_lps_cvl_event(lps);
1318 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1319 BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx");
1320 break;
1321
1322 case BFA_LPS_SM_SET_N2N_PID:
1323 if (bfa_reqq_full(lps->bfa, lps->reqq)) {
1324 bfa_sm_set_state(lps, bfa_lps_sm_online_n2n_pid_wait);
1325 bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe);
1326 } else
1327 bfa_lps_send_set_n2n_pid(lps);
1328 break;
1329
1330 case BFA_LPS_SM_OFFLINE:
1331 case BFA_LPS_SM_DELETE:
1332 bfa_sm_set_state(lps, bfa_lps_sm_init);
1333 break;
1334
1335 default:
1336 bfa_sm_fault(lps->bfa, event);
1337 }
1338 }
1339
1340 /*
1341 * login complete
1342 */
1343 static void
bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s * lps,enum bfa_lps_event event)1344 bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1345 {
1346 bfa_trc(lps->bfa, lps->bfa_tag);
1347 bfa_trc(lps->bfa, event);
1348
1349 switch (event) {
1350 case BFA_LPS_SM_RESUME:
1351 bfa_sm_set_state(lps, bfa_lps_sm_online);
1352 bfa_lps_send_set_n2n_pid(lps);
1353 break;
1354
1355 case BFA_LPS_SM_LOGOUT:
1356 bfa_sm_set_state(lps, bfa_lps_sm_logowait);
1357 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1358 BFA_PL_EID_LOGO, 0, "Logout");
1359 break;
1360
1361 case BFA_LPS_SM_RX_CVL:
1362 bfa_sm_set_state(lps, bfa_lps_sm_init);
1363 bfa_reqq_wcancel(&lps->wqe);
1364
1365 /* Let the vport module know about this event */
1366 bfa_lps_cvl_event(lps);
1367 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1368 BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx");
1369 break;
1370
1371 case BFA_LPS_SM_OFFLINE:
1372 case BFA_LPS_SM_DELETE:
1373 bfa_sm_set_state(lps, bfa_lps_sm_init);
1374 bfa_reqq_wcancel(&lps->wqe);
1375 break;
1376
1377 default:
1378 bfa_sm_fault(lps->bfa, event);
1379 }
1380 }
1381
1382 /*
1383 * logout in progress - awaiting firmware response
1384 */
1385 static void
bfa_lps_sm_logout(struct bfa_lps_s * lps,enum bfa_lps_event event)1386 bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event)
1387 {
1388 bfa_trc(lps->bfa, lps->bfa_tag);
1389 bfa_trc(lps->bfa, event);
1390
1391 switch (event) {
1392 case BFA_LPS_SM_FWRSP:
1393 case BFA_LPS_SM_OFFLINE:
1394 bfa_sm_set_state(lps, bfa_lps_sm_init);
1395 bfa_lps_logout_comp(lps);
1396 break;
1397
1398 case BFA_LPS_SM_DELETE:
1399 bfa_sm_set_state(lps, bfa_lps_sm_init);
1400 break;
1401
1402 default:
1403 bfa_sm_fault(lps->bfa, event);
1404 }
1405 }
1406
1407 /*
1408 * logout pending -- awaiting space in request queue
1409 */
1410 static void
bfa_lps_sm_logowait(struct bfa_lps_s * lps,enum bfa_lps_event event)1411 bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1412 {
1413 bfa_trc(lps->bfa, lps->bfa_tag);
1414 bfa_trc(lps->bfa, event);
1415
1416 switch (event) {
1417 case BFA_LPS_SM_RESUME:
1418 bfa_sm_set_state(lps, bfa_lps_sm_logout);
1419 bfa_lps_send_logout(lps);
1420 break;
1421
1422 case BFA_LPS_SM_OFFLINE:
1423 case BFA_LPS_SM_DELETE:
1424 bfa_sm_set_state(lps, bfa_lps_sm_init);
1425 bfa_reqq_wcancel(&lps->wqe);
1426 break;
1427
1428 default:
1429 bfa_sm_fault(lps->bfa, event);
1430 }
1431 }
1432
1433
1434
1435 /*
1436 * lps_pvt BFA LPS private functions
1437 */
1438
1439 /*
1440 * return memory requirement
1441 */
1442 void
bfa_lps_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)1443 bfa_lps_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
1444 struct bfa_s *bfa)
1445 {
1446 struct bfa_mem_kva_s *lps_kva = BFA_MEM_LPS_KVA(bfa);
1447
1448 if (cfg->drvcfg.min_cfg)
1449 bfa_mem_kva_setup(minfo, lps_kva,
1450 sizeof(struct bfa_lps_s) * BFA_LPS_MIN_LPORTS);
1451 else
1452 bfa_mem_kva_setup(minfo, lps_kva,
1453 sizeof(struct bfa_lps_s) * BFA_LPS_MAX_LPORTS);
1454 }
1455
1456 /*
1457 * bfa module attach at initialization time
1458 */
1459 void
bfa_lps_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)1460 bfa_lps_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1461 struct bfa_pcidev_s *pcidev)
1462 {
1463 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1464 struct bfa_lps_s *lps;
1465 int i;
1466
1467 mod->num_lps = BFA_LPS_MAX_LPORTS;
1468 if (cfg->drvcfg.min_cfg)
1469 mod->num_lps = BFA_LPS_MIN_LPORTS;
1470 else
1471 mod->num_lps = BFA_LPS_MAX_LPORTS;
1472 mod->lps_arr = lps = (struct bfa_lps_s *) bfa_mem_kva_curp(mod);
1473
1474 bfa_mem_kva_curp(mod) += mod->num_lps * sizeof(struct bfa_lps_s);
1475
1476 INIT_LIST_HEAD(&mod->lps_free_q);
1477 INIT_LIST_HEAD(&mod->lps_active_q);
1478 INIT_LIST_HEAD(&mod->lps_login_q);
1479
1480 for (i = 0; i < mod->num_lps; i++, lps++) {
1481 lps->bfa = bfa;
1482 lps->bfa_tag = (u8) i;
1483 lps->reqq = BFA_REQQ_LPS;
1484 bfa_reqq_winit(&lps->wqe, bfa_lps_reqq_resume, lps);
1485 list_add_tail(&lps->qe, &mod->lps_free_q);
1486 }
1487 }
1488
1489 /*
1490 * IOC in disabled state -- consider all lps offline
1491 */
1492 void
bfa_lps_iocdisable(struct bfa_s * bfa)1493 bfa_lps_iocdisable(struct bfa_s *bfa)
1494 {
1495 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1496 struct bfa_lps_s *lps;
1497 struct list_head *qe, *qen;
1498
1499 list_for_each_safe(qe, qen, &mod->lps_active_q) {
1500 lps = (struct bfa_lps_s *) qe;
1501 bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE);
1502 }
1503 list_for_each_safe(qe, qen, &mod->lps_login_q) {
1504 lps = (struct bfa_lps_s *) qe;
1505 bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE);
1506 }
1507 list_splice_tail_init(&mod->lps_login_q, &mod->lps_active_q);
1508 }
1509
1510 /*
1511 * Firmware login response
1512 */
1513 static void
bfa_lps_login_rsp(struct bfa_s * bfa,struct bfi_lps_login_rsp_s * rsp)1514 bfa_lps_login_rsp(struct bfa_s *bfa, struct bfi_lps_login_rsp_s *rsp)
1515 {
1516 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1517 struct bfa_lps_s *lps;
1518
1519 WARN_ON(rsp->bfa_tag >= mod->num_lps);
1520 lps = BFA_LPS_FROM_TAG(mod, rsp->bfa_tag);
1521
1522 lps->status = rsp->status;
1523 switch (rsp->status) {
1524 case BFA_STATUS_OK:
1525 lps->fw_tag = rsp->fw_tag;
1526 lps->fport = rsp->f_port;
1527 if (lps->fport)
1528 lps->lp_pid = rsp->lp_pid;
1529 lps->npiv_en = rsp->npiv_en;
1530 lps->pr_bbcred = be16_to_cpu(rsp->bb_credit);
1531 lps->pr_pwwn = rsp->port_name;
1532 lps->pr_nwwn = rsp->node_name;
1533 lps->auth_req = rsp->auth_req;
1534 lps->lp_mac = rsp->lp_mac;
1535 lps->brcd_switch = rsp->brcd_switch;
1536 lps->fcf_mac = rsp->fcf_mac;
1537
1538 break;
1539
1540 case BFA_STATUS_FABRIC_RJT:
1541 lps->lsrjt_rsn = rsp->lsrjt_rsn;
1542 lps->lsrjt_expl = rsp->lsrjt_expl;
1543
1544 break;
1545
1546 case BFA_STATUS_EPROTOCOL:
1547 lps->ext_status = rsp->ext_status;
1548
1549 break;
1550
1551 case BFA_STATUS_VPORT_MAX:
1552 if (rsp->ext_status)
1553 bfa_lps_no_res(lps, rsp->ext_status);
1554 break;
1555
1556 default:
1557 /* Nothing to do with other status */
1558 break;
1559 }
1560
1561 list_del(&lps->qe);
1562 list_add_tail(&lps->qe, &mod->lps_active_q);
1563 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1564 }
1565
1566 static void
bfa_lps_no_res(struct bfa_lps_s * first_lps,u8 count)1567 bfa_lps_no_res(struct bfa_lps_s *first_lps, u8 count)
1568 {
1569 struct bfa_s *bfa = first_lps->bfa;
1570 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1571 struct list_head *qe, *qe_next;
1572 struct bfa_lps_s *lps;
1573
1574 bfa_trc(bfa, count);
1575
1576 qe = bfa_q_next(first_lps);
1577
1578 while (count && qe) {
1579 qe_next = bfa_q_next(qe);
1580 lps = (struct bfa_lps_s *)qe;
1581 bfa_trc(bfa, lps->bfa_tag);
1582 lps->status = first_lps->status;
1583 list_del(&lps->qe);
1584 list_add_tail(&lps->qe, &mod->lps_active_q);
1585 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1586 qe = qe_next;
1587 count--;
1588 }
1589 }
1590
1591 /*
1592 * Firmware logout response
1593 */
1594 static void
bfa_lps_logout_rsp(struct bfa_s * bfa,struct bfi_lps_logout_rsp_s * rsp)1595 bfa_lps_logout_rsp(struct bfa_s *bfa, struct bfi_lps_logout_rsp_s *rsp)
1596 {
1597 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1598 struct bfa_lps_s *lps;
1599
1600 WARN_ON(rsp->bfa_tag >= mod->num_lps);
1601 lps = BFA_LPS_FROM_TAG(mod, rsp->bfa_tag);
1602
1603 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1604 }
1605
1606 /*
1607 * Firmware received a Clear virtual link request (for FCoE)
1608 */
1609 static void
bfa_lps_rx_cvl_event(struct bfa_s * bfa,struct bfi_lps_cvl_event_s * cvl)1610 bfa_lps_rx_cvl_event(struct bfa_s *bfa, struct bfi_lps_cvl_event_s *cvl)
1611 {
1612 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1613 struct bfa_lps_s *lps;
1614
1615 lps = BFA_LPS_FROM_TAG(mod, cvl->bfa_tag);
1616
1617 bfa_sm_send_event(lps, BFA_LPS_SM_RX_CVL);
1618 }
1619
1620 /*
1621 * Space is available in request queue, resume queueing request to firmware.
1622 */
1623 static void
bfa_lps_reqq_resume(void * lps_arg)1624 bfa_lps_reqq_resume(void *lps_arg)
1625 {
1626 struct bfa_lps_s *lps = lps_arg;
1627
1628 bfa_sm_send_event(lps, BFA_LPS_SM_RESUME);
1629 }
1630
1631 /*
1632 * lps is freed -- triggered by vport delete
1633 */
1634 static void
bfa_lps_free(struct bfa_lps_s * lps)1635 bfa_lps_free(struct bfa_lps_s *lps)
1636 {
1637 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(lps->bfa);
1638
1639 lps->lp_pid = 0;
1640 list_del(&lps->qe);
1641 list_add_tail(&lps->qe, &mod->lps_free_q);
1642 }
1643
1644 /*
1645 * send login request to firmware
1646 */
1647 static void
bfa_lps_send_login(struct bfa_lps_s * lps)1648 bfa_lps_send_login(struct bfa_lps_s *lps)
1649 {
1650 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(lps->bfa);
1651 struct bfi_lps_login_req_s *m;
1652
1653 m = bfa_reqq_next(lps->bfa, lps->reqq);
1654 WARN_ON(!m);
1655
1656 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGIN_REQ,
1657 bfa_fn_lpu(lps->bfa));
1658
1659 m->bfa_tag = lps->bfa_tag;
1660 m->alpa = lps->alpa;
1661 m->pdu_size = cpu_to_be16(lps->pdusz);
1662 m->pwwn = lps->pwwn;
1663 m->nwwn = lps->nwwn;
1664 m->fdisc = lps->fdisc;
1665 m->auth_en = lps->auth_en;
1666
1667 bfa_reqq_produce(lps->bfa, lps->reqq, m->mh);
1668 list_del(&lps->qe);
1669 list_add_tail(&lps->qe, &mod->lps_login_q);
1670 }
1671
1672 /*
1673 * send logout request to firmware
1674 */
1675 static void
bfa_lps_send_logout(struct bfa_lps_s * lps)1676 bfa_lps_send_logout(struct bfa_lps_s *lps)
1677 {
1678 struct bfi_lps_logout_req_s *m;
1679
1680 m = bfa_reqq_next(lps->bfa, lps->reqq);
1681 WARN_ON(!m);
1682
1683 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGOUT_REQ,
1684 bfa_fn_lpu(lps->bfa));
1685
1686 m->fw_tag = lps->fw_tag;
1687 m->port_name = lps->pwwn;
1688 bfa_reqq_produce(lps->bfa, lps->reqq, m->mh);
1689 }
1690
1691 /*
1692 * send n2n pid set request to firmware
1693 */
1694 static void
bfa_lps_send_set_n2n_pid(struct bfa_lps_s * lps)1695 bfa_lps_send_set_n2n_pid(struct bfa_lps_s *lps)
1696 {
1697 struct bfi_lps_n2n_pid_req_s *m;
1698
1699 m = bfa_reqq_next(lps->bfa, lps->reqq);
1700 WARN_ON(!m);
1701
1702 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_N2N_PID_REQ,
1703 bfa_fn_lpu(lps->bfa));
1704
1705 m->fw_tag = lps->fw_tag;
1706 m->lp_pid = lps->lp_pid;
1707 bfa_reqq_produce(lps->bfa, lps->reqq, m->mh);
1708 }
1709
1710 /*
1711 * Indirect login completion handler for non-fcs
1712 */
1713 static void
bfa_lps_login_comp_cb(void * arg,bfa_boolean_t complete)1714 bfa_lps_login_comp_cb(void *arg, bfa_boolean_t complete)
1715 {
1716 struct bfa_lps_s *lps = arg;
1717
1718 if (!complete)
1719 return;
1720
1721 if (lps->fdisc)
1722 bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status);
1723 else
1724 bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1725 }
1726
1727 /*
1728 * Login completion handler -- direct call for fcs, queue for others
1729 */
1730 static void
bfa_lps_login_comp(struct bfa_lps_s * lps)1731 bfa_lps_login_comp(struct bfa_lps_s *lps)
1732 {
1733 if (!lps->bfa->fcs) {
1734 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_login_comp_cb,
1735 lps);
1736 return;
1737 }
1738
1739 if (lps->fdisc)
1740 bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status);
1741 else
1742 bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1743 }
1744
1745 /*
1746 * Indirect logout completion handler for non-fcs
1747 */
1748 static void
bfa_lps_logout_comp_cb(void * arg,bfa_boolean_t complete)1749 bfa_lps_logout_comp_cb(void *arg, bfa_boolean_t complete)
1750 {
1751 struct bfa_lps_s *lps = arg;
1752
1753 if (!complete)
1754 return;
1755
1756 if (lps->fdisc)
1757 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
1758 else
1759 bfa_cb_lps_flogo_comp(lps->bfa->bfad, lps->uarg);
1760 }
1761
1762 /*
1763 * Logout completion handler -- direct call for fcs, queue for others
1764 */
1765 static void
bfa_lps_logout_comp(struct bfa_lps_s * lps)1766 bfa_lps_logout_comp(struct bfa_lps_s *lps)
1767 {
1768 if (!lps->bfa->fcs) {
1769 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_logout_comp_cb,
1770 lps);
1771 return;
1772 }
1773 if (lps->fdisc)
1774 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
1775 }
1776
1777 /*
1778 * Clear virtual link completion handler for non-fcs
1779 */
1780 static void
bfa_lps_cvl_event_cb(void * arg,bfa_boolean_t complete)1781 bfa_lps_cvl_event_cb(void *arg, bfa_boolean_t complete)
1782 {
1783 struct bfa_lps_s *lps = arg;
1784
1785 if (!complete)
1786 return;
1787
1788 /* Clear virtual link to base port will result in link down */
1789 if (lps->fdisc)
1790 bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
1791 }
1792
1793 /*
1794 * Received Clear virtual link event --direct call for fcs,
1795 * queue for others
1796 */
1797 static void
bfa_lps_cvl_event(struct bfa_lps_s * lps)1798 bfa_lps_cvl_event(struct bfa_lps_s *lps)
1799 {
1800 if (!lps->bfa->fcs) {
1801 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_cvl_event_cb,
1802 lps);
1803 return;
1804 }
1805
1806 /* Clear virtual link to base port will result in link down */
1807 if (lps->fdisc)
1808 bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
1809 }
1810
1811
1812
1813 /*
1814 * lps_public BFA LPS public functions
1815 */
1816
1817 u32
bfa_lps_get_max_vport(struct bfa_s * bfa)1818 bfa_lps_get_max_vport(struct bfa_s *bfa)
1819 {
1820 if (bfa_ioc_devid(&bfa->ioc) == BFA_PCI_DEVICE_ID_CT)
1821 return BFA_LPS_MAX_VPORTS_SUPP_CT;
1822 else
1823 return BFA_LPS_MAX_VPORTS_SUPP_CB;
1824 }
1825
1826 /*
1827 * Allocate a lport srvice tag.
1828 */
1829 struct bfa_lps_s *
bfa_lps_alloc(struct bfa_s * bfa)1830 bfa_lps_alloc(struct bfa_s *bfa)
1831 {
1832 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1833 struct bfa_lps_s *lps = NULL;
1834
1835 bfa_q_deq(&mod->lps_free_q, &lps);
1836
1837 if (lps == NULL)
1838 return NULL;
1839
1840 list_add_tail(&lps->qe, &mod->lps_active_q);
1841
1842 bfa_sm_set_state(lps, bfa_lps_sm_init);
1843 return lps;
1844 }
1845
1846 /*
1847 * Free lport service tag. This can be called anytime after an alloc.
1848 * No need to wait for any pending login/logout completions.
1849 */
1850 void
bfa_lps_delete(struct bfa_lps_s * lps)1851 bfa_lps_delete(struct bfa_lps_s *lps)
1852 {
1853 bfa_sm_send_event(lps, BFA_LPS_SM_DELETE);
1854 }
1855
1856 /*
1857 * Initiate a lport login.
1858 */
1859 void
bfa_lps_flogi(struct bfa_lps_s * lps,void * uarg,u8 alpa,u16 pdusz,wwn_t pwwn,wwn_t nwwn,bfa_boolean_t auth_en)1860 bfa_lps_flogi(struct bfa_lps_s *lps, void *uarg, u8 alpa, u16 pdusz,
1861 wwn_t pwwn, wwn_t nwwn, bfa_boolean_t auth_en)
1862 {
1863 lps->uarg = uarg;
1864 lps->alpa = alpa;
1865 lps->pdusz = pdusz;
1866 lps->pwwn = pwwn;
1867 lps->nwwn = nwwn;
1868 lps->fdisc = BFA_FALSE;
1869 lps->auth_en = auth_en;
1870 bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
1871 }
1872
1873 /*
1874 * Initiate a lport fdisc login.
1875 */
1876 void
bfa_lps_fdisc(struct bfa_lps_s * lps,void * uarg,u16 pdusz,wwn_t pwwn,wwn_t nwwn)1877 bfa_lps_fdisc(struct bfa_lps_s *lps, void *uarg, u16 pdusz, wwn_t pwwn,
1878 wwn_t nwwn)
1879 {
1880 lps->uarg = uarg;
1881 lps->alpa = 0;
1882 lps->pdusz = pdusz;
1883 lps->pwwn = pwwn;
1884 lps->nwwn = nwwn;
1885 lps->fdisc = BFA_TRUE;
1886 lps->auth_en = BFA_FALSE;
1887 bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
1888 }
1889
1890
1891 /*
1892 * Initiate a lport FDSIC logout.
1893 */
1894 void
bfa_lps_fdisclogo(struct bfa_lps_s * lps)1895 bfa_lps_fdisclogo(struct bfa_lps_s *lps)
1896 {
1897 bfa_sm_send_event(lps, BFA_LPS_SM_LOGOUT);
1898 }
1899
1900 u8
bfa_lps_get_fwtag(struct bfa_s * bfa,u8 lp_tag)1901 bfa_lps_get_fwtag(struct bfa_s *bfa, u8 lp_tag)
1902 {
1903 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1904
1905 return BFA_LPS_FROM_TAG(mod, lp_tag)->fw_tag;
1906 }
1907
1908 /*
1909 * Return lport services tag given the pid
1910 */
1911 u8
bfa_lps_get_tag_from_pid(struct bfa_s * bfa,u32 pid)1912 bfa_lps_get_tag_from_pid(struct bfa_s *bfa, u32 pid)
1913 {
1914 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1915 struct bfa_lps_s *lps;
1916 int i;
1917
1918 for (i = 0, lps = mod->lps_arr; i < mod->num_lps; i++, lps++) {
1919 if (lps->lp_pid == pid)
1920 return lps->bfa_tag;
1921 }
1922
1923 /* Return base port tag anyway */
1924 return 0;
1925 }
1926
1927
1928 /*
1929 * return port id assigned to the base lport
1930 */
1931 u32
bfa_lps_get_base_pid(struct bfa_s * bfa)1932 bfa_lps_get_base_pid(struct bfa_s *bfa)
1933 {
1934 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1935
1936 return BFA_LPS_FROM_TAG(mod, 0)->lp_pid;
1937 }
1938
1939 /*
1940 * Set PID in case of n2n (which is assigned during PLOGI)
1941 */
1942 void
bfa_lps_set_n2n_pid(struct bfa_lps_s * lps,uint32_t n2n_pid)1943 bfa_lps_set_n2n_pid(struct bfa_lps_s *lps, uint32_t n2n_pid)
1944 {
1945 bfa_trc(lps->bfa, lps->bfa_tag);
1946 bfa_trc(lps->bfa, n2n_pid);
1947
1948 lps->lp_pid = n2n_pid;
1949 bfa_sm_send_event(lps, BFA_LPS_SM_SET_N2N_PID);
1950 }
1951
1952 /*
1953 * LPS firmware message class handler.
1954 */
1955 void
bfa_lps_isr(struct bfa_s * bfa,struct bfi_msg_s * m)1956 bfa_lps_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
1957 {
1958 union bfi_lps_i2h_msg_u msg;
1959
1960 bfa_trc(bfa, m->mhdr.msg_id);
1961 msg.msg = m;
1962
1963 switch (m->mhdr.msg_id) {
1964 case BFI_LPS_I2H_LOGIN_RSP:
1965 bfa_lps_login_rsp(bfa, msg.login_rsp);
1966 break;
1967
1968 case BFI_LPS_I2H_LOGOUT_RSP:
1969 bfa_lps_logout_rsp(bfa, msg.logout_rsp);
1970 break;
1971
1972 case BFI_LPS_I2H_CVL_EVENT:
1973 bfa_lps_rx_cvl_event(bfa, msg.cvl_event);
1974 break;
1975
1976 default:
1977 bfa_trc(bfa, m->mhdr.msg_id);
1978 WARN_ON(1);
1979 }
1980 }
1981
1982 static void
bfa_fcport_aen_post(struct bfa_fcport_s * fcport,enum bfa_port_aen_event event)1983 bfa_fcport_aen_post(struct bfa_fcport_s *fcport, enum bfa_port_aen_event event)
1984 {
1985 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
1986 struct bfa_aen_entry_s *aen_entry;
1987
1988 bfad_get_aen_entry(bfad, aen_entry);
1989 if (!aen_entry)
1990 return;
1991
1992 aen_entry->aen_data.port.ioc_type = bfa_get_type(fcport->bfa);
1993 aen_entry->aen_data.port.pwwn = fcport->pwwn;
1994
1995 /* Send the AEN notification */
1996 bfad_im_post_vendor_event(aen_entry, bfad, ++fcport->bfa->bfa_aen_seq,
1997 BFA_AEN_CAT_PORT, event);
1998 }
1999
2000 /*
2001 * FC PORT state machine functions
2002 */
2003 static void
bfa_fcport_sm_uninit(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2004 bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
2005 enum bfa_fcport_sm_event event)
2006 {
2007 bfa_trc(fcport->bfa, event);
2008
2009 switch (event) {
2010 case BFA_FCPORT_SM_START:
2011 /*
2012 * Start event after IOC is configured and BFA is started.
2013 */
2014 fcport->use_flash_cfg = BFA_TRUE;
2015
2016 if (bfa_fcport_send_enable(fcport)) {
2017 bfa_trc(fcport->bfa, BFA_TRUE);
2018 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2019 } else {
2020 bfa_trc(fcport->bfa, BFA_FALSE);
2021 bfa_sm_set_state(fcport,
2022 bfa_fcport_sm_enabling_qwait);
2023 }
2024 break;
2025
2026 case BFA_FCPORT_SM_ENABLE:
2027 /*
2028 * Port is persistently configured to be in enabled state. Do
2029 * not change state. Port enabling is done when START event is
2030 * received.
2031 */
2032 break;
2033
2034 case BFA_FCPORT_SM_DISABLE:
2035 /*
2036 * If a port is persistently configured to be disabled, the
2037 * first event will a port disable request.
2038 */
2039 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2040 break;
2041
2042 case BFA_FCPORT_SM_HWFAIL:
2043 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2044 break;
2045
2046 default:
2047 bfa_sm_fault(fcport->bfa, event);
2048 }
2049 }
2050
2051 static void
bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2052 bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
2053 enum bfa_fcport_sm_event event)
2054 {
2055 char pwwn_buf[BFA_STRING_32];
2056 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2057 bfa_trc(fcport->bfa, event);
2058
2059 switch (event) {
2060 case BFA_FCPORT_SM_QRESUME:
2061 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2062 bfa_fcport_send_enable(fcport);
2063 break;
2064
2065 case BFA_FCPORT_SM_STOP:
2066 bfa_reqq_wcancel(&fcport->reqq_wait);
2067 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2068 break;
2069
2070 case BFA_FCPORT_SM_ENABLE:
2071 /*
2072 * Already enable is in progress.
2073 */
2074 break;
2075
2076 case BFA_FCPORT_SM_DISABLE:
2077 /*
2078 * Just send disable request to firmware when room becomes
2079 * available in request queue.
2080 */
2081 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2082 bfa_reqq_wcancel(&fcport->reqq_wait);
2083 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2084 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2085 wwn2str(pwwn_buf, fcport->pwwn);
2086 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2087 "Base port disabled: WWN = %s\n", pwwn_buf);
2088 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
2089 break;
2090
2091 case BFA_FCPORT_SM_LINKUP:
2092 case BFA_FCPORT_SM_LINKDOWN:
2093 /*
2094 * Possible to get link events when doing back-to-back
2095 * enable/disables.
2096 */
2097 break;
2098
2099 case BFA_FCPORT_SM_HWFAIL:
2100 bfa_reqq_wcancel(&fcport->reqq_wait);
2101 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2102 break;
2103
2104 case BFA_FCPORT_SM_FAA_MISCONFIG:
2105 bfa_fcport_reset_linkinfo(fcport);
2106 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2107 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2108 break;
2109
2110 default:
2111 bfa_sm_fault(fcport->bfa, event);
2112 }
2113 }
2114
2115 static void
bfa_fcport_sm_enabling(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2116 bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
2117 enum bfa_fcport_sm_event event)
2118 {
2119 char pwwn_buf[BFA_STRING_32];
2120 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2121 bfa_trc(fcport->bfa, event);
2122
2123 switch (event) {
2124 case BFA_FCPORT_SM_FWRSP:
2125 case BFA_FCPORT_SM_LINKDOWN:
2126 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
2127 break;
2128
2129 case BFA_FCPORT_SM_LINKUP:
2130 bfa_fcport_update_linkinfo(fcport);
2131 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
2132
2133 WARN_ON(!fcport->event_cbfn);
2134 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2135 break;
2136
2137 case BFA_FCPORT_SM_ENABLE:
2138 /*
2139 * Already being enabled.
2140 */
2141 break;
2142
2143 case BFA_FCPORT_SM_DISABLE:
2144 if (bfa_fcport_send_disable(fcport))
2145 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2146 else
2147 bfa_sm_set_state(fcport,
2148 bfa_fcport_sm_disabling_qwait);
2149
2150 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2151 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2152 wwn2str(pwwn_buf, fcport->pwwn);
2153 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2154 "Base port disabled: WWN = %s\n", pwwn_buf);
2155 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
2156 break;
2157
2158 case BFA_FCPORT_SM_STOP:
2159 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2160 break;
2161
2162 case BFA_FCPORT_SM_HWFAIL:
2163 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2164 break;
2165
2166 case BFA_FCPORT_SM_FAA_MISCONFIG:
2167 bfa_fcport_reset_linkinfo(fcport);
2168 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2169 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2170 break;
2171
2172 default:
2173 bfa_sm_fault(fcport->bfa, event);
2174 }
2175 }
2176
2177 static void
bfa_fcport_sm_linkdown(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2178 bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
2179 enum bfa_fcport_sm_event event)
2180 {
2181 struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
2182 char pwwn_buf[BFA_STRING_32];
2183 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2184
2185 bfa_trc(fcport->bfa, event);
2186
2187 switch (event) {
2188 case BFA_FCPORT_SM_LINKUP:
2189 bfa_fcport_update_linkinfo(fcport);
2190 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
2191 WARN_ON(!fcport->event_cbfn);
2192 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2193 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup");
2194 if (!bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
2195
2196 bfa_trc(fcport->bfa,
2197 pevent->link_state.attr.vc_fcf.fcf.fipenabled);
2198 bfa_trc(fcport->bfa,
2199 pevent->link_state.attr.vc_fcf.fcf.fipfailed);
2200
2201 if (pevent->link_state.attr.vc_fcf.fcf.fipfailed)
2202 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2203 BFA_PL_EID_FIP_FCF_DISC, 0,
2204 "FIP FCF Discovery Failed");
2205 else
2206 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2207 BFA_PL_EID_FIP_FCF_DISC, 0,
2208 "FIP FCF Discovered");
2209 }
2210
2211 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2212 wwn2str(pwwn_buf, fcport->pwwn);
2213 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2214 "Base port online: WWN = %s\n", pwwn_buf);
2215 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ONLINE);
2216
2217 /* If QoS is enabled and it is not online, send AEN */
2218 if (fcport->cfg.qos_enabled &&
2219 fcport->qos_attr.state != BFA_QOS_ONLINE)
2220 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_QOS_NEG);
2221 break;
2222
2223 case BFA_FCPORT_SM_LINKDOWN:
2224 /*
2225 * Possible to get link down event.
2226 */
2227 break;
2228
2229 case BFA_FCPORT_SM_ENABLE:
2230 /*
2231 * Already enabled.
2232 */
2233 break;
2234
2235 case BFA_FCPORT_SM_DISABLE:
2236 if (bfa_fcport_send_disable(fcport))
2237 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2238 else
2239 bfa_sm_set_state(fcport,
2240 bfa_fcport_sm_disabling_qwait);
2241
2242 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2243 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2244 wwn2str(pwwn_buf, fcport->pwwn);
2245 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2246 "Base port disabled: WWN = %s\n", pwwn_buf);
2247 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
2248 break;
2249
2250 case BFA_FCPORT_SM_STOP:
2251 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2252 break;
2253
2254 case BFA_FCPORT_SM_HWFAIL:
2255 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2256 break;
2257
2258 case BFA_FCPORT_SM_FAA_MISCONFIG:
2259 bfa_fcport_reset_linkinfo(fcport);
2260 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2261 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2262 break;
2263
2264 default:
2265 bfa_sm_fault(fcport->bfa, event);
2266 }
2267 }
2268
2269 static void
bfa_fcport_sm_linkup(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2270 bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
2271 enum bfa_fcport_sm_event event)
2272 {
2273 char pwwn_buf[BFA_STRING_32];
2274 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2275
2276 bfa_trc(fcport->bfa, event);
2277
2278 switch (event) {
2279 case BFA_FCPORT_SM_ENABLE:
2280 /*
2281 * Already enabled.
2282 */
2283 break;
2284
2285 case BFA_FCPORT_SM_DISABLE:
2286 if (bfa_fcport_send_disable(fcport))
2287 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2288 else
2289 bfa_sm_set_state(fcport,
2290 bfa_fcport_sm_disabling_qwait);
2291
2292 bfa_fcport_reset_linkinfo(fcport);
2293 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2294 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2295 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2296 wwn2str(pwwn_buf, fcport->pwwn);
2297 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2298 "Base port offline: WWN = %s\n", pwwn_buf);
2299 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
2300 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2301 "Base port disabled: WWN = %s\n", pwwn_buf);
2302 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
2303 break;
2304
2305 case BFA_FCPORT_SM_LINKDOWN:
2306 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
2307 bfa_fcport_reset_linkinfo(fcport);
2308 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2309 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2310 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
2311 wwn2str(pwwn_buf, fcport->pwwn);
2312 if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
2313 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2314 "Base port offline: WWN = %s\n", pwwn_buf);
2315 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
2316 } else {
2317 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2318 "Base port (WWN = %s) "
2319 "lost fabric connectivity\n", pwwn_buf);
2320 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2321 }
2322 break;
2323
2324 case BFA_FCPORT_SM_STOP:
2325 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2326 bfa_fcport_reset_linkinfo(fcport);
2327 wwn2str(pwwn_buf, fcport->pwwn);
2328 if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
2329 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2330 "Base port offline: WWN = %s\n", pwwn_buf);
2331 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
2332 } else {
2333 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2334 "Base port (WWN = %s) "
2335 "lost fabric connectivity\n", pwwn_buf);
2336 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2337 }
2338 break;
2339
2340 case BFA_FCPORT_SM_HWFAIL:
2341 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2342 bfa_fcport_reset_linkinfo(fcport);
2343 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2344 wwn2str(pwwn_buf, fcport->pwwn);
2345 if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
2346 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2347 "Base port offline: WWN = %s\n", pwwn_buf);
2348 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
2349 } else {
2350 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
2351 "Base port (WWN = %s) "
2352 "lost fabric connectivity\n", pwwn_buf);
2353 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2354 }
2355 break;
2356
2357 case BFA_FCPORT_SM_FAA_MISCONFIG:
2358 bfa_fcport_reset_linkinfo(fcport);
2359 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2360 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2361 break;
2362
2363 default:
2364 bfa_sm_fault(fcport->bfa, event);
2365 }
2366 }
2367
2368 static void
bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2369 bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
2370 enum bfa_fcport_sm_event event)
2371 {
2372 bfa_trc(fcport->bfa, event);
2373
2374 switch (event) {
2375 case BFA_FCPORT_SM_QRESUME:
2376 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2377 bfa_fcport_send_disable(fcport);
2378 break;
2379
2380 case BFA_FCPORT_SM_STOP:
2381 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2382 bfa_reqq_wcancel(&fcport->reqq_wait);
2383 break;
2384
2385 case BFA_FCPORT_SM_ENABLE:
2386 bfa_sm_set_state(fcport, bfa_fcport_sm_toggling_qwait);
2387 break;
2388
2389 case BFA_FCPORT_SM_DISABLE:
2390 /*
2391 * Already being disabled.
2392 */
2393 break;
2394
2395 case BFA_FCPORT_SM_LINKUP:
2396 case BFA_FCPORT_SM_LINKDOWN:
2397 /*
2398 * Possible to get link events when doing back-to-back
2399 * enable/disables.
2400 */
2401 break;
2402
2403 case BFA_FCPORT_SM_HWFAIL:
2404 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2405 bfa_reqq_wcancel(&fcport->reqq_wait);
2406 break;
2407
2408 case BFA_FCPORT_SM_FAA_MISCONFIG:
2409 bfa_fcport_reset_linkinfo(fcport);
2410 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2411 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig);
2412 break;
2413
2414 default:
2415 bfa_sm_fault(fcport->bfa, event);
2416 }
2417 }
2418
2419 static void
bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2420 bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
2421 enum bfa_fcport_sm_event event)
2422 {
2423 bfa_trc(fcport->bfa, event);
2424
2425 switch (event) {
2426 case BFA_FCPORT_SM_QRESUME:
2427 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2428 bfa_fcport_send_disable(fcport);
2429 if (bfa_fcport_send_enable(fcport))
2430 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2431 else
2432 bfa_sm_set_state(fcport,
2433 bfa_fcport_sm_enabling_qwait);
2434 break;
2435
2436 case BFA_FCPORT_SM_STOP:
2437 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2438 bfa_reqq_wcancel(&fcport->reqq_wait);
2439 break;
2440
2441 case BFA_FCPORT_SM_ENABLE:
2442 break;
2443
2444 case BFA_FCPORT_SM_DISABLE:
2445 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
2446 break;
2447
2448 case BFA_FCPORT_SM_LINKUP:
2449 case BFA_FCPORT_SM_LINKDOWN:
2450 /*
2451 * Possible to get link events when doing back-to-back
2452 * enable/disables.
2453 */
2454 break;
2455
2456 case BFA_FCPORT_SM_HWFAIL:
2457 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2458 bfa_reqq_wcancel(&fcport->reqq_wait);
2459 break;
2460
2461 default:
2462 bfa_sm_fault(fcport->bfa, event);
2463 }
2464 }
2465
2466 static void
bfa_fcport_sm_disabling(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2467 bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
2468 enum bfa_fcport_sm_event event)
2469 {
2470 char pwwn_buf[BFA_STRING_32];
2471 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2472 bfa_trc(fcport->bfa, event);
2473
2474 switch (event) {
2475 case BFA_FCPORT_SM_FWRSP:
2476 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2477 break;
2478
2479 case BFA_FCPORT_SM_DISABLE:
2480 /*
2481 * Already being disabled.
2482 */
2483 break;
2484
2485 case BFA_FCPORT_SM_ENABLE:
2486 if (bfa_fcport_send_enable(fcport))
2487 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2488 else
2489 bfa_sm_set_state(fcport,
2490 bfa_fcport_sm_enabling_qwait);
2491
2492 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2493 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2494 wwn2str(pwwn_buf, fcport->pwwn);
2495 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2496 "Base port enabled: WWN = %s\n", pwwn_buf);
2497 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
2498 break;
2499
2500 case BFA_FCPORT_SM_STOP:
2501 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2502 break;
2503
2504 case BFA_FCPORT_SM_LINKUP:
2505 case BFA_FCPORT_SM_LINKDOWN:
2506 /*
2507 * Possible to get link events when doing back-to-back
2508 * enable/disables.
2509 */
2510 break;
2511
2512 case BFA_FCPORT_SM_HWFAIL:
2513 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2514 break;
2515
2516 default:
2517 bfa_sm_fault(fcport->bfa, event);
2518 }
2519 }
2520
2521 static void
bfa_fcport_sm_disabled(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2522 bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
2523 enum bfa_fcport_sm_event event)
2524 {
2525 char pwwn_buf[BFA_STRING_32];
2526 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2527 bfa_trc(fcport->bfa, event);
2528
2529 switch (event) {
2530 case BFA_FCPORT_SM_START:
2531 /*
2532 * Ignore start event for a port that is disabled.
2533 */
2534 break;
2535
2536 case BFA_FCPORT_SM_STOP:
2537 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2538 break;
2539
2540 case BFA_FCPORT_SM_ENABLE:
2541 if (bfa_fcport_send_enable(fcport))
2542 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2543 else
2544 bfa_sm_set_state(fcport,
2545 bfa_fcport_sm_enabling_qwait);
2546
2547 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2548 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2549 wwn2str(pwwn_buf, fcport->pwwn);
2550 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
2551 "Base port enabled: WWN = %s\n", pwwn_buf);
2552 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
2553 break;
2554
2555 case BFA_FCPORT_SM_DISABLE:
2556 /*
2557 * Already disabled.
2558 */
2559 break;
2560
2561 case BFA_FCPORT_SM_HWFAIL:
2562 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2563 break;
2564
2565 case BFA_FCPORT_SM_DPORTENABLE:
2566 bfa_sm_set_state(fcport, bfa_fcport_sm_dport);
2567 break;
2568
2569 case BFA_FCPORT_SM_DDPORTENABLE:
2570 bfa_sm_set_state(fcport, bfa_fcport_sm_ddport);
2571 break;
2572
2573 default:
2574 bfa_sm_fault(fcport->bfa, event);
2575 }
2576 }
2577
2578 static void
bfa_fcport_sm_stopped(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2579 bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
2580 enum bfa_fcport_sm_event event)
2581 {
2582 bfa_trc(fcport->bfa, event);
2583
2584 switch (event) {
2585 case BFA_FCPORT_SM_START:
2586 if (bfa_fcport_send_enable(fcport))
2587 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2588 else
2589 bfa_sm_set_state(fcport,
2590 bfa_fcport_sm_enabling_qwait);
2591 break;
2592
2593 default:
2594 /*
2595 * Ignore all other events.
2596 */
2597 ;
2598 }
2599 }
2600
2601 /*
2602 * Port is enabled. IOC is down/failed.
2603 */
2604 static void
bfa_fcport_sm_iocdown(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2605 bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
2606 enum bfa_fcport_sm_event event)
2607 {
2608 bfa_trc(fcport->bfa, event);
2609
2610 switch (event) {
2611 case BFA_FCPORT_SM_START:
2612 if (bfa_fcport_send_enable(fcport))
2613 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2614 else
2615 bfa_sm_set_state(fcport,
2616 bfa_fcport_sm_enabling_qwait);
2617 break;
2618
2619 default:
2620 /*
2621 * Ignore all events.
2622 */
2623 ;
2624 }
2625 }
2626
2627 /*
2628 * Port is disabled. IOC is down/failed.
2629 */
2630 static void
bfa_fcport_sm_iocfail(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2631 bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
2632 enum bfa_fcport_sm_event event)
2633 {
2634 bfa_trc(fcport->bfa, event);
2635
2636 switch (event) {
2637 case BFA_FCPORT_SM_START:
2638 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2639 break;
2640
2641 case BFA_FCPORT_SM_ENABLE:
2642 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2643 break;
2644
2645 default:
2646 /*
2647 * Ignore all events.
2648 */
2649 ;
2650 }
2651 }
2652
2653 static void
bfa_fcport_sm_dport(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2654 bfa_fcport_sm_dport(struct bfa_fcport_s *fcport, enum bfa_fcport_sm_event event)
2655 {
2656 bfa_trc(fcport->bfa, event);
2657
2658 switch (event) {
2659 case BFA_FCPORT_SM_DPORTENABLE:
2660 case BFA_FCPORT_SM_DISABLE:
2661 case BFA_FCPORT_SM_ENABLE:
2662 case BFA_FCPORT_SM_START:
2663 /*
2664 * Ignore event for a port that is dport
2665 */
2666 break;
2667
2668 case BFA_FCPORT_SM_STOP:
2669 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2670 break;
2671
2672 case BFA_FCPORT_SM_HWFAIL:
2673 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2674 break;
2675
2676 case BFA_FCPORT_SM_DPORTDISABLE:
2677 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2678 break;
2679
2680 default:
2681 bfa_sm_fault(fcport->bfa, event);
2682 }
2683 }
2684
2685 static void
bfa_fcport_sm_ddport(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2686 bfa_fcport_sm_ddport(struct bfa_fcport_s *fcport,
2687 enum bfa_fcport_sm_event event)
2688 {
2689 bfa_trc(fcport->bfa, event);
2690
2691 switch (event) {
2692 case BFA_FCPORT_SM_DISABLE:
2693 case BFA_FCPORT_SM_DDPORTDISABLE:
2694 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2695 break;
2696
2697 case BFA_FCPORT_SM_DPORTENABLE:
2698 case BFA_FCPORT_SM_DPORTDISABLE:
2699 case BFA_FCPORT_SM_ENABLE:
2700 case BFA_FCPORT_SM_START:
2701 /*
2702 * Ignore event for a port that is ddport
2703 */
2704 break;
2705
2706 case BFA_FCPORT_SM_STOP:
2707 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2708 break;
2709
2710 case BFA_FCPORT_SM_HWFAIL:
2711 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2712 break;
2713
2714 default:
2715 bfa_sm_fault(fcport->bfa, event);
2716 }
2717 }
2718
2719 static void
bfa_fcport_sm_faa_misconfig(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)2720 bfa_fcport_sm_faa_misconfig(struct bfa_fcport_s *fcport,
2721 enum bfa_fcport_sm_event event)
2722 {
2723 bfa_trc(fcport->bfa, event);
2724
2725 switch (event) {
2726 case BFA_FCPORT_SM_DPORTENABLE:
2727 case BFA_FCPORT_SM_ENABLE:
2728 case BFA_FCPORT_SM_START:
2729 /*
2730 * Ignore event for a port as there is FAA misconfig
2731 */
2732 break;
2733
2734 case BFA_FCPORT_SM_DISABLE:
2735 if (bfa_fcport_send_disable(fcport))
2736 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2737 else
2738 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
2739
2740 bfa_fcport_reset_linkinfo(fcport);
2741 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2742 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2743 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2744 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
2745 break;
2746
2747 case BFA_FCPORT_SM_STOP:
2748 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2749 break;
2750
2751 case BFA_FCPORT_SM_HWFAIL:
2752 bfa_fcport_reset_linkinfo(fcport);
2753 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2754 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2755 break;
2756
2757 default:
2758 bfa_sm_fault(fcport->bfa, event);
2759 }
2760 }
2761
2762 /*
2763 * Link state is down
2764 */
2765 static void
bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)2766 bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
2767 enum bfa_fcport_ln_sm_event event)
2768 {
2769 bfa_trc(ln->fcport->bfa, event);
2770
2771 switch (event) {
2772 case BFA_FCPORT_LN_SM_LINKUP:
2773 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2774 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2775 break;
2776
2777 default:
2778 bfa_sm_fault(ln->fcport->bfa, event);
2779 }
2780 }
2781
2782 /*
2783 * Link state is waiting for down notification
2784 */
2785 static void
bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)2786 bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
2787 enum bfa_fcport_ln_sm_event event)
2788 {
2789 bfa_trc(ln->fcport->bfa, event);
2790
2791 switch (event) {
2792 case BFA_FCPORT_LN_SM_LINKUP:
2793 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2794 break;
2795
2796 case BFA_FCPORT_LN_SM_NOTIFICATION:
2797 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
2798 break;
2799
2800 default:
2801 bfa_sm_fault(ln->fcport->bfa, event);
2802 }
2803 }
2804
2805 /*
2806 * Link state is waiting for down notification and there is a pending up
2807 */
2808 static void
bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)2809 bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
2810 enum bfa_fcport_ln_sm_event event)
2811 {
2812 bfa_trc(ln->fcport->bfa, event);
2813
2814 switch (event) {
2815 case BFA_FCPORT_LN_SM_LINKDOWN:
2816 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2817 break;
2818
2819 case BFA_FCPORT_LN_SM_NOTIFICATION:
2820 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2821 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2822 break;
2823
2824 default:
2825 bfa_sm_fault(ln->fcport->bfa, event);
2826 }
2827 }
2828
2829 /*
2830 * Link state is up
2831 */
2832 static void
bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)2833 bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
2834 enum bfa_fcport_ln_sm_event event)
2835 {
2836 bfa_trc(ln->fcport->bfa, event);
2837
2838 switch (event) {
2839 case BFA_FCPORT_LN_SM_LINKDOWN:
2840 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2841 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2842 break;
2843
2844 default:
2845 bfa_sm_fault(ln->fcport->bfa, event);
2846 }
2847 }
2848
2849 /*
2850 * Link state is waiting for up notification
2851 */
2852 static void
bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)2853 bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
2854 enum bfa_fcport_ln_sm_event event)
2855 {
2856 bfa_trc(ln->fcport->bfa, event);
2857
2858 switch (event) {
2859 case BFA_FCPORT_LN_SM_LINKDOWN:
2860 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2861 break;
2862
2863 case BFA_FCPORT_LN_SM_NOTIFICATION:
2864 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up);
2865 break;
2866
2867 default:
2868 bfa_sm_fault(ln->fcport->bfa, event);
2869 }
2870 }
2871
2872 /*
2873 * Link state is waiting for up notification and there is a pending down
2874 */
2875 static void
bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)2876 bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
2877 enum bfa_fcport_ln_sm_event event)
2878 {
2879 bfa_trc(ln->fcport->bfa, event);
2880
2881 switch (event) {
2882 case BFA_FCPORT_LN_SM_LINKUP:
2883 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_up_nf);
2884 break;
2885
2886 case BFA_FCPORT_LN_SM_NOTIFICATION:
2887 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2888 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2889 break;
2890
2891 default:
2892 bfa_sm_fault(ln->fcport->bfa, event);
2893 }
2894 }
2895
2896 /*
2897 * Link state is waiting for up notification and there are pending down and up
2898 */
2899 static void
bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)2900 bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
2901 enum bfa_fcport_ln_sm_event event)
2902 {
2903 bfa_trc(ln->fcport->bfa, event);
2904
2905 switch (event) {
2906 case BFA_FCPORT_LN_SM_LINKDOWN:
2907 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2908 break;
2909
2910 case BFA_FCPORT_LN_SM_NOTIFICATION:
2911 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2912 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2913 break;
2914
2915 default:
2916 bfa_sm_fault(ln->fcport->bfa, event);
2917 }
2918 }
2919
2920 static void
__bfa_cb_fcport_event(void * cbarg,bfa_boolean_t complete)2921 __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete)
2922 {
2923 struct bfa_fcport_ln_s *ln = cbarg;
2924
2925 if (complete)
2926 ln->fcport->event_cbfn(ln->fcport->event_cbarg, ln->ln_event);
2927 else
2928 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2929 }
2930
2931 /*
2932 * Send SCN notification to upper layers.
2933 * trunk - false if caller is fcport to ignore fcport event in trunked mode
2934 */
2935 static void
bfa_fcport_scn(struct bfa_fcport_s * fcport,enum bfa_port_linkstate event,bfa_boolean_t trunk)2936 bfa_fcport_scn(struct bfa_fcport_s *fcport, enum bfa_port_linkstate event,
2937 bfa_boolean_t trunk)
2938 {
2939 if (fcport->cfg.trunked && !trunk)
2940 return;
2941
2942 switch (event) {
2943 case BFA_PORT_LINKUP:
2944 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP);
2945 break;
2946 case BFA_PORT_LINKDOWN:
2947 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
2948 break;
2949 default:
2950 WARN_ON(1);
2951 }
2952 }
2953
2954 static void
bfa_fcport_queue_cb(struct bfa_fcport_ln_s * ln,enum bfa_port_linkstate event)2955 bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_port_linkstate event)
2956 {
2957 struct bfa_fcport_s *fcport = ln->fcport;
2958
2959 if (fcport->bfa->fcs) {
2960 fcport->event_cbfn(fcport->event_cbarg, event);
2961 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2962 } else {
2963 ln->ln_event = event;
2964 bfa_cb_queue(fcport->bfa, &ln->ln_qe,
2965 __bfa_cb_fcport_event, ln);
2966 }
2967 }
2968
2969 #define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \
2970 BFA_CACHELINE_SZ))
2971
2972 void
bfa_fcport_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)2973 bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
2974 struct bfa_s *bfa)
2975 {
2976 struct bfa_mem_dma_s *fcport_dma = BFA_MEM_FCPORT_DMA(bfa);
2977
2978 bfa_mem_dma_setup(minfo, fcport_dma, FCPORT_STATS_DMA_SZ);
2979 }
2980
2981 static void
bfa_fcport_qresume(void * cbarg)2982 bfa_fcport_qresume(void *cbarg)
2983 {
2984 struct bfa_fcport_s *fcport = cbarg;
2985
2986 bfa_sm_send_event(fcport, BFA_FCPORT_SM_QRESUME);
2987 }
2988
2989 static void
bfa_fcport_mem_claim(struct bfa_fcport_s * fcport)2990 bfa_fcport_mem_claim(struct bfa_fcport_s *fcport)
2991 {
2992 struct bfa_mem_dma_s *fcport_dma = &fcport->fcport_dma;
2993
2994 fcport->stats_kva = bfa_mem_dma_virt(fcport_dma);
2995 fcport->stats_pa = bfa_mem_dma_phys(fcport_dma);
2996 fcport->stats = (union bfa_fcport_stats_u *)
2997 bfa_mem_dma_virt(fcport_dma);
2998 }
2999
3000 /*
3001 * Memory initialization.
3002 */
3003 void
bfa_fcport_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)3004 bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
3005 struct bfa_pcidev_s *pcidev)
3006 {
3007 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3008 struct bfa_port_cfg_s *port_cfg = &fcport->cfg;
3009 struct bfa_fcport_ln_s *ln = &fcport->ln;
3010
3011 fcport->bfa = bfa;
3012 ln->fcport = fcport;
3013
3014 bfa_fcport_mem_claim(fcport);
3015
3016 bfa_sm_set_state(fcport, bfa_fcport_sm_uninit);
3017 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
3018
3019 /*
3020 * initialize time stamp for stats reset
3021 */
3022 fcport->stats_reset_time = ktime_get_seconds();
3023 fcport->stats_dma_ready = BFA_FALSE;
3024
3025 /*
3026 * initialize and set default configuration
3027 */
3028 port_cfg->topology = BFA_PORT_TOPOLOGY_P2P;
3029 port_cfg->speed = BFA_PORT_SPEED_AUTO;
3030 port_cfg->trunked = BFA_FALSE;
3031 port_cfg->maxfrsize = 0;
3032
3033 port_cfg->trl_def_speed = BFA_PORT_SPEED_1GBPS;
3034 port_cfg->qos_bw.high = BFA_QOS_BW_HIGH;
3035 port_cfg->qos_bw.med = BFA_QOS_BW_MED;
3036 port_cfg->qos_bw.low = BFA_QOS_BW_LOW;
3037
3038 fcport->fec_state = BFA_FEC_OFFLINE;
3039
3040 INIT_LIST_HEAD(&fcport->stats_pending_q);
3041 INIT_LIST_HEAD(&fcport->statsclr_pending_q);
3042
3043 bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport);
3044 }
3045
3046 void
bfa_fcport_start(struct bfa_s * bfa)3047 bfa_fcport_start(struct bfa_s *bfa)
3048 {
3049 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_START);
3050 }
3051
3052 /*
3053 * Called when IOC failure is detected.
3054 */
3055 void
bfa_fcport_iocdisable(struct bfa_s * bfa)3056 bfa_fcport_iocdisable(struct bfa_s *bfa)
3057 {
3058 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3059
3060 bfa_sm_send_event(fcport, BFA_FCPORT_SM_HWFAIL);
3061 bfa_trunk_iocdisable(bfa);
3062 }
3063
3064 /*
3065 * Update loop info in fcport for SCN online
3066 */
3067 static void
bfa_fcport_update_loop_info(struct bfa_fcport_s * fcport,struct bfa_fcport_loop_info_s * loop_info)3068 bfa_fcport_update_loop_info(struct bfa_fcport_s *fcport,
3069 struct bfa_fcport_loop_info_s *loop_info)
3070 {
3071 fcport->myalpa = loop_info->myalpa;
3072 fcport->alpabm_valid =
3073 loop_info->alpabm_val;
3074 memcpy(fcport->alpabm.alpa_bm,
3075 loop_info->alpabm.alpa_bm,
3076 sizeof(struct fc_alpabm_s));
3077 }
3078
3079 static void
bfa_fcport_update_linkinfo(struct bfa_fcport_s * fcport)3080 bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
3081 {
3082 struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
3083 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
3084
3085 fcport->speed = pevent->link_state.speed;
3086 fcport->topology = pevent->link_state.topology;
3087
3088 if (fcport->topology == BFA_PORT_TOPOLOGY_LOOP) {
3089 bfa_fcport_update_loop_info(fcport,
3090 &pevent->link_state.attr.loop_info);
3091 return;
3092 }
3093
3094 /* QoS Details */
3095 fcport->qos_attr = pevent->link_state.qos_attr;
3096 fcport->qos_vc_attr = pevent->link_state.attr.vc_fcf.qos_vc_attr;
3097
3098 if (fcport->cfg.bb_cr_enabled)
3099 fcport->bbcr_attr = pevent->link_state.attr.bbcr_attr;
3100
3101 fcport->fec_state = pevent->link_state.fec_state;
3102
3103 /*
3104 * update trunk state if applicable
3105 */
3106 if (!fcport->cfg.trunked)
3107 trunk->attr.state = BFA_TRUNK_DISABLED;
3108
3109 /* update FCoE specific */
3110 fcport->fcoe_vlan =
3111 be16_to_cpu(pevent->link_state.attr.vc_fcf.fcf.vlan);
3112
3113 bfa_trc(fcport->bfa, fcport->speed);
3114 bfa_trc(fcport->bfa, fcport->topology);
3115 }
3116
3117 static void
bfa_fcport_reset_linkinfo(struct bfa_fcport_s * fcport)3118 bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport)
3119 {
3120 fcport->speed = BFA_PORT_SPEED_UNKNOWN;
3121 fcport->topology = BFA_PORT_TOPOLOGY_NONE;
3122 fcport->fec_state = BFA_FEC_OFFLINE;
3123 }
3124
3125 /*
3126 * Send port enable message to firmware.
3127 */
3128 static bfa_boolean_t
bfa_fcport_send_enable(struct bfa_fcport_s * fcport)3129 bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
3130 {
3131 struct bfi_fcport_enable_req_s *m;
3132
3133 /*
3134 * Increment message tag before queue check, so that responses to old
3135 * requests are discarded.
3136 */
3137 fcport->msgtag++;
3138
3139 /*
3140 * check for room in queue to send request now
3141 */
3142 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3143 if (!m) {
3144 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3145 &fcport->reqq_wait);
3146 return BFA_FALSE;
3147 }
3148
3149 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_ENABLE_REQ,
3150 bfa_fn_lpu(fcport->bfa));
3151 m->nwwn = fcport->nwwn;
3152 m->pwwn = fcport->pwwn;
3153 m->port_cfg = fcport->cfg;
3154 m->msgtag = fcport->msgtag;
3155 m->port_cfg.maxfrsize = cpu_to_be16(fcport->cfg.maxfrsize);
3156 m->use_flash_cfg = fcport->use_flash_cfg;
3157 bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa);
3158 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo);
3159 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi);
3160
3161 /*
3162 * queue I/O message to firmware
3163 */
3164 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, m->mh);
3165 return BFA_TRUE;
3166 }
3167
3168 /*
3169 * Send port disable message to firmware.
3170 */
3171 static bfa_boolean_t
bfa_fcport_send_disable(struct bfa_fcport_s * fcport)3172 bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
3173 {
3174 struct bfi_fcport_req_s *m;
3175
3176 /*
3177 * Increment message tag before queue check, so that responses to old
3178 * requests are discarded.
3179 */
3180 fcport->msgtag++;
3181
3182 /*
3183 * check for room in queue to send request now
3184 */
3185 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3186 if (!m) {
3187 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3188 &fcport->reqq_wait);
3189 return BFA_FALSE;
3190 }
3191
3192 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_DISABLE_REQ,
3193 bfa_fn_lpu(fcport->bfa));
3194 m->msgtag = fcport->msgtag;
3195
3196 /*
3197 * queue I/O message to firmware
3198 */
3199 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, m->mh);
3200
3201 return BFA_TRUE;
3202 }
3203
3204 static void
bfa_fcport_set_wwns(struct bfa_fcport_s * fcport)3205 bfa_fcport_set_wwns(struct bfa_fcport_s *fcport)
3206 {
3207 fcport->pwwn = fcport->bfa->ioc.attr->pwwn;
3208 fcport->nwwn = fcport->bfa->ioc.attr->nwwn;
3209
3210 bfa_trc(fcport->bfa, fcport->pwwn);
3211 bfa_trc(fcport->bfa, fcport->nwwn);
3212 }
3213
3214 static void
bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s * d,struct bfa_qos_stats_s * s)3215 bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d,
3216 struct bfa_qos_stats_s *s)
3217 {
3218 u32 *dip = (u32 *) d;
3219 __be32 *sip = (__be32 *) s;
3220 int i;
3221
3222 /* Now swap the 32 bit fields */
3223 for (i = 0; i < (sizeof(struct bfa_qos_stats_s)/sizeof(u32)); ++i)
3224 dip[i] = be32_to_cpu(sip[i]);
3225 }
3226
3227 static void
bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s * d,struct bfa_fcoe_stats_s * s)3228 bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d,
3229 struct bfa_fcoe_stats_s *s)
3230 {
3231 u32 *dip = (u32 *) d;
3232 __be32 *sip = (__be32 *) s;
3233 int i;
3234
3235 for (i = 0; i < ((sizeof(struct bfa_fcoe_stats_s))/sizeof(u32));
3236 i = i + 2) {
3237 #ifdef __BIG_ENDIAN
3238 dip[i] = be32_to_cpu(sip[i]);
3239 dip[i + 1] = be32_to_cpu(sip[i + 1]);
3240 #else
3241 dip[i] = be32_to_cpu(sip[i + 1]);
3242 dip[i + 1] = be32_to_cpu(sip[i]);
3243 #endif
3244 }
3245 }
3246
3247 static void
__bfa_cb_fcport_stats_get(void * cbarg,bfa_boolean_t complete)3248 __bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
3249 {
3250 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
3251 struct bfa_cb_pending_q_s *cb;
3252 struct list_head *qe, *qen;
3253 union bfa_fcport_stats_u *ret;
3254
3255 if (complete) {
3256 time64_t time = ktime_get_seconds();
3257
3258 list_for_each_safe(qe, qen, &fcport->stats_pending_q) {
3259 bfa_q_deq(&fcport->stats_pending_q, &qe);
3260 cb = (struct bfa_cb_pending_q_s *)qe;
3261 if (fcport->stats_status == BFA_STATUS_OK) {
3262 ret = (union bfa_fcport_stats_u *)cb->data;
3263 /* Swap FC QoS or FCoE stats */
3264 if (bfa_ioc_get_fcmode(&fcport->bfa->ioc))
3265 bfa_fcport_qos_stats_swap(&ret->fcqos,
3266 &fcport->stats->fcqos);
3267 else {
3268 bfa_fcport_fcoe_stats_swap(&ret->fcoe,
3269 &fcport->stats->fcoe);
3270 ret->fcoe.secs_reset =
3271 time - fcport->stats_reset_time;
3272 }
3273 }
3274 bfa_cb_queue_status(fcport->bfa, &cb->hcb_qe,
3275 fcport->stats_status);
3276 }
3277 fcport->stats_status = BFA_STATUS_OK;
3278 } else {
3279 INIT_LIST_HEAD(&fcport->stats_pending_q);
3280 fcport->stats_status = BFA_STATUS_OK;
3281 }
3282 }
3283
3284 static void
bfa_fcport_stats_get_timeout(void * cbarg)3285 bfa_fcport_stats_get_timeout(void *cbarg)
3286 {
3287 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3288
3289 bfa_trc(fcport->bfa, fcport->stats_qfull);
3290
3291 if (fcport->stats_qfull) {
3292 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3293 fcport->stats_qfull = BFA_FALSE;
3294 }
3295
3296 fcport->stats_status = BFA_STATUS_ETIMER;
3297 __bfa_cb_fcport_stats_get(fcport, BFA_TRUE);
3298 }
3299
3300 static void
bfa_fcport_send_stats_get(void * cbarg)3301 bfa_fcport_send_stats_get(void *cbarg)
3302 {
3303 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3304 struct bfi_fcport_req_s *msg;
3305
3306 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3307
3308 if (!msg) {
3309 fcport->stats_qfull = BFA_TRUE;
3310 bfa_reqq_winit(&fcport->stats_reqq_wait,
3311 bfa_fcport_send_stats_get, fcport);
3312 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3313 &fcport->stats_reqq_wait);
3314 return;
3315 }
3316 fcport->stats_qfull = BFA_FALSE;
3317
3318 memset(msg, 0, sizeof(struct bfi_fcport_req_s));
3319 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_GET_REQ,
3320 bfa_fn_lpu(fcport->bfa));
3321 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, msg->mh);
3322 }
3323
3324 static void
__bfa_cb_fcport_stats_clr(void * cbarg,bfa_boolean_t complete)3325 __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
3326 {
3327 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3328 struct bfa_cb_pending_q_s *cb;
3329 struct list_head *qe, *qen;
3330
3331 if (complete) {
3332 /*
3333 * re-initialize time stamp for stats reset
3334 */
3335 fcport->stats_reset_time = ktime_get_seconds();
3336 list_for_each_safe(qe, qen, &fcport->statsclr_pending_q) {
3337 bfa_q_deq(&fcport->statsclr_pending_q, &qe);
3338 cb = (struct bfa_cb_pending_q_s *)qe;
3339 bfa_cb_queue_status(fcport->bfa, &cb->hcb_qe,
3340 fcport->stats_status);
3341 }
3342 fcport->stats_status = BFA_STATUS_OK;
3343 } else {
3344 INIT_LIST_HEAD(&fcport->statsclr_pending_q);
3345 fcport->stats_status = BFA_STATUS_OK;
3346 }
3347 }
3348
3349 static void
bfa_fcport_stats_clr_timeout(void * cbarg)3350 bfa_fcport_stats_clr_timeout(void *cbarg)
3351 {
3352 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3353
3354 bfa_trc(fcport->bfa, fcport->stats_qfull);
3355
3356 if (fcport->stats_qfull) {
3357 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3358 fcport->stats_qfull = BFA_FALSE;
3359 }
3360
3361 fcport->stats_status = BFA_STATUS_ETIMER;
3362 __bfa_cb_fcport_stats_clr(fcport, BFA_TRUE);
3363 }
3364
3365 static void
bfa_fcport_send_stats_clear(void * cbarg)3366 bfa_fcport_send_stats_clear(void *cbarg)
3367 {
3368 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3369 struct bfi_fcport_req_s *msg;
3370
3371 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3372
3373 if (!msg) {
3374 fcport->stats_qfull = BFA_TRUE;
3375 bfa_reqq_winit(&fcport->stats_reqq_wait,
3376 bfa_fcport_send_stats_clear, fcport);
3377 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3378 &fcport->stats_reqq_wait);
3379 return;
3380 }
3381 fcport->stats_qfull = BFA_FALSE;
3382
3383 memset(msg, 0, sizeof(struct bfi_fcport_req_s));
3384 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_CLEAR_REQ,
3385 bfa_fn_lpu(fcport->bfa));
3386 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, msg->mh);
3387 }
3388
3389 /*
3390 * Handle trunk SCN event from firmware.
3391 */
3392 static void
bfa_trunk_scn(struct bfa_fcport_s * fcport,struct bfi_fcport_trunk_scn_s * scn)3393 bfa_trunk_scn(struct bfa_fcport_s *fcport, struct bfi_fcport_trunk_scn_s *scn)
3394 {
3395 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
3396 struct bfi_fcport_trunk_link_s *tlink;
3397 struct bfa_trunk_link_attr_s *lattr;
3398 enum bfa_trunk_state state_prev;
3399 int i;
3400 int link_bm = 0;
3401
3402 bfa_trc(fcport->bfa, fcport->cfg.trunked);
3403 WARN_ON(scn->trunk_state != BFA_TRUNK_ONLINE &&
3404 scn->trunk_state != BFA_TRUNK_OFFLINE);
3405
3406 bfa_trc(fcport->bfa, trunk->attr.state);
3407 bfa_trc(fcport->bfa, scn->trunk_state);
3408 bfa_trc(fcport->bfa, scn->trunk_speed);
3409
3410 /*
3411 * Save off new state for trunk attribute query
3412 */
3413 state_prev = trunk->attr.state;
3414 if (fcport->cfg.trunked && (trunk->attr.state != BFA_TRUNK_DISABLED))
3415 trunk->attr.state = scn->trunk_state;
3416 trunk->attr.speed = scn->trunk_speed;
3417 for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3418 lattr = &trunk->attr.link_attr[i];
3419 tlink = &scn->tlink[i];
3420
3421 lattr->link_state = tlink->state;
3422 lattr->trunk_wwn = tlink->trunk_wwn;
3423 lattr->fctl = tlink->fctl;
3424 lattr->speed = tlink->speed;
3425 lattr->deskew = be32_to_cpu(tlink->deskew);
3426
3427 if (tlink->state == BFA_TRUNK_LINK_STATE_UP) {
3428 fcport->speed = tlink->speed;
3429 fcport->topology = BFA_PORT_TOPOLOGY_P2P;
3430 link_bm |= 1 << i;
3431 }
3432
3433 bfa_trc(fcport->bfa, lattr->link_state);
3434 bfa_trc(fcport->bfa, lattr->trunk_wwn);
3435 bfa_trc(fcport->bfa, lattr->fctl);
3436 bfa_trc(fcport->bfa, lattr->speed);
3437 bfa_trc(fcport->bfa, lattr->deskew);
3438 }
3439
3440 switch (link_bm) {
3441 case 3:
3442 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3443 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,1)");
3444 break;
3445 case 2:
3446 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3447 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(-,1)");
3448 break;
3449 case 1:
3450 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3451 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,-)");
3452 break;
3453 default:
3454 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3455 BFA_PL_EID_TRUNK_SCN, 0, "Trunk down");
3456 }
3457
3458 /*
3459 * Notify upper layers if trunk state changed.
3460 */
3461 if ((state_prev != trunk->attr.state) ||
3462 (scn->trunk_state == BFA_TRUNK_OFFLINE)) {
3463 bfa_fcport_scn(fcport, (scn->trunk_state == BFA_TRUNK_ONLINE) ?
3464 BFA_PORT_LINKUP : BFA_PORT_LINKDOWN, BFA_TRUE);
3465 }
3466 }
3467
3468 static void
bfa_trunk_iocdisable(struct bfa_s * bfa)3469 bfa_trunk_iocdisable(struct bfa_s *bfa)
3470 {
3471 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3472 int i = 0;
3473
3474 /*
3475 * In trunked mode, notify upper layers that link is down
3476 */
3477 if (fcport->cfg.trunked) {
3478 if (fcport->trunk.attr.state == BFA_TRUNK_ONLINE)
3479 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_TRUE);
3480
3481 fcport->trunk.attr.state = BFA_TRUNK_OFFLINE;
3482 fcport->trunk.attr.speed = BFA_PORT_SPEED_UNKNOWN;
3483 for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3484 fcport->trunk.attr.link_attr[i].trunk_wwn = 0;
3485 fcport->trunk.attr.link_attr[i].fctl =
3486 BFA_TRUNK_LINK_FCTL_NORMAL;
3487 fcport->trunk.attr.link_attr[i].link_state =
3488 BFA_TRUNK_LINK_STATE_DN_LINKDN;
3489 fcport->trunk.attr.link_attr[i].speed =
3490 BFA_PORT_SPEED_UNKNOWN;
3491 fcport->trunk.attr.link_attr[i].deskew = 0;
3492 }
3493 }
3494 }
3495
3496 /*
3497 * Called to initialize port attributes
3498 */
3499 void
bfa_fcport_init(struct bfa_s * bfa)3500 bfa_fcport_init(struct bfa_s *bfa)
3501 {
3502 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3503
3504 /*
3505 * Initialize port attributes from IOC hardware data.
3506 */
3507 bfa_fcport_set_wwns(fcport);
3508 if (fcport->cfg.maxfrsize == 0)
3509 fcport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc);
3510 fcport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
3511 fcport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
3512
3513 if (bfa_fcport_is_pbcdisabled(bfa))
3514 bfa->modules.port.pbc_disabled = BFA_TRUE;
3515
3516 WARN_ON(!fcport->cfg.maxfrsize);
3517 WARN_ON(!fcport->cfg.rx_bbcredit);
3518 WARN_ON(!fcport->speed_sup);
3519 }
3520
3521 /*
3522 * Firmware message handler.
3523 */
3524 void
bfa_fcport_isr(struct bfa_s * bfa,struct bfi_msg_s * msg)3525 bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
3526 {
3527 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3528 union bfi_fcport_i2h_msg_u i2hmsg;
3529
3530 i2hmsg.msg = msg;
3531 fcport->event_arg.i2hmsg = i2hmsg;
3532
3533 bfa_trc(bfa, msg->mhdr.msg_id);
3534 bfa_trc(bfa, bfa_fcport_sm_to_state(hal_port_sm_table, fcport->sm));
3535
3536 switch (msg->mhdr.msg_id) {
3537 case BFI_FCPORT_I2H_ENABLE_RSP:
3538 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag) {
3539
3540 fcport->stats_dma_ready = BFA_TRUE;
3541 if (fcport->use_flash_cfg) {
3542 fcport->cfg = i2hmsg.penable_rsp->port_cfg;
3543 fcport->cfg.maxfrsize =
3544 cpu_to_be16(fcport->cfg.maxfrsize);
3545 fcport->cfg.path_tov =
3546 cpu_to_be16(fcport->cfg.path_tov);
3547 fcport->cfg.q_depth =
3548 cpu_to_be16(fcport->cfg.q_depth);
3549
3550 if (fcport->cfg.trunked)
3551 fcport->trunk.attr.state =
3552 BFA_TRUNK_OFFLINE;
3553 else
3554 fcport->trunk.attr.state =
3555 BFA_TRUNK_DISABLED;
3556 fcport->qos_attr.qos_bw =
3557 i2hmsg.penable_rsp->port_cfg.qos_bw;
3558 fcport->use_flash_cfg = BFA_FALSE;
3559 }
3560
3561 if (fcport->cfg.qos_enabled)
3562 fcport->qos_attr.state = BFA_QOS_OFFLINE;
3563 else
3564 fcport->qos_attr.state = BFA_QOS_DISABLED;
3565
3566 fcport->qos_attr.qos_bw_op =
3567 i2hmsg.penable_rsp->port_cfg.qos_bw;
3568
3569 if (fcport->cfg.bb_cr_enabled)
3570 fcport->bbcr_attr.state = BFA_BBCR_OFFLINE;
3571 else
3572 fcport->bbcr_attr.state = BFA_BBCR_DISABLED;
3573
3574 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3575 }
3576 break;
3577
3578 case BFI_FCPORT_I2H_DISABLE_RSP:
3579 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
3580 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3581 break;
3582
3583 case BFI_FCPORT_I2H_EVENT:
3584 if (fcport->cfg.bb_cr_enabled)
3585 fcport->bbcr_attr.state = BFA_BBCR_OFFLINE;
3586 else
3587 fcport->bbcr_attr.state = BFA_BBCR_DISABLED;
3588
3589 if (i2hmsg.event->link_state.linkstate == BFA_PORT_LINKUP)
3590 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
3591 else {
3592 if (i2hmsg.event->link_state.linkstate_rsn ==
3593 BFA_PORT_LINKSTATE_RSN_FAA_MISCONFIG)
3594 bfa_sm_send_event(fcport,
3595 BFA_FCPORT_SM_FAA_MISCONFIG);
3596 else
3597 bfa_sm_send_event(fcport,
3598 BFA_FCPORT_SM_LINKDOWN);
3599 }
3600 fcport->qos_attr.qos_bw_op =
3601 i2hmsg.event->link_state.qos_attr.qos_bw_op;
3602 break;
3603
3604 case BFI_FCPORT_I2H_TRUNK_SCN:
3605 bfa_trunk_scn(fcport, i2hmsg.trunk_scn);
3606 break;
3607
3608 case BFI_FCPORT_I2H_STATS_GET_RSP:
3609 /*
3610 * check for timer pop before processing the rsp
3611 */
3612 if (list_empty(&fcport->stats_pending_q) ||
3613 (fcport->stats_status == BFA_STATUS_ETIMER))
3614 break;
3615
3616 bfa_timer_stop(&fcport->timer);
3617 fcport->stats_status = i2hmsg.pstatsget_rsp->status;
3618 __bfa_cb_fcport_stats_get(fcport, BFA_TRUE);
3619 break;
3620
3621 case BFI_FCPORT_I2H_STATS_CLEAR_RSP:
3622 /*
3623 * check for timer pop before processing the rsp
3624 */
3625 if (list_empty(&fcport->statsclr_pending_q) ||
3626 (fcport->stats_status == BFA_STATUS_ETIMER))
3627 break;
3628
3629 bfa_timer_stop(&fcport->timer);
3630 fcport->stats_status = BFA_STATUS_OK;
3631 __bfa_cb_fcport_stats_clr(fcport, BFA_TRUE);
3632 break;
3633
3634 case BFI_FCPORT_I2H_ENABLE_AEN:
3635 bfa_sm_send_event(fcport, BFA_FCPORT_SM_ENABLE);
3636 break;
3637
3638 case BFI_FCPORT_I2H_DISABLE_AEN:
3639 bfa_sm_send_event(fcport, BFA_FCPORT_SM_DISABLE);
3640 break;
3641
3642 default:
3643 WARN_ON(1);
3644 break;
3645 }
3646 }
3647
3648 /*
3649 * Registered callback for port events.
3650 */
3651 void
bfa_fcport_event_register(struct bfa_s * bfa,void (* cbfn)(void * cbarg,enum bfa_port_linkstate event),void * cbarg)3652 bfa_fcport_event_register(struct bfa_s *bfa,
3653 void (*cbfn) (void *cbarg,
3654 enum bfa_port_linkstate event),
3655 void *cbarg)
3656 {
3657 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3658
3659 fcport->event_cbfn = cbfn;
3660 fcport->event_cbarg = cbarg;
3661 }
3662
3663 bfa_status_t
bfa_fcport_enable(struct bfa_s * bfa)3664 bfa_fcport_enable(struct bfa_s *bfa)
3665 {
3666 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3667
3668 if (bfa_fcport_is_pbcdisabled(bfa))
3669 return BFA_STATUS_PBC;
3670
3671 if (bfa_ioc_is_disabled(&bfa->ioc))
3672 return BFA_STATUS_IOC_DISABLED;
3673
3674 if (fcport->diag_busy)
3675 return BFA_STATUS_DIAG_BUSY;
3676
3677 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_ENABLE);
3678 return BFA_STATUS_OK;
3679 }
3680
3681 bfa_status_t
bfa_fcport_disable(struct bfa_s * bfa)3682 bfa_fcport_disable(struct bfa_s *bfa)
3683 {
3684 if (bfa_fcport_is_pbcdisabled(bfa))
3685 return BFA_STATUS_PBC;
3686
3687 if (bfa_ioc_is_disabled(&bfa->ioc))
3688 return BFA_STATUS_IOC_DISABLED;
3689
3690 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DISABLE);
3691 return BFA_STATUS_OK;
3692 }
3693
3694 /* If PBC is disabled on port, return error */
3695 bfa_status_t
bfa_fcport_is_pbcdisabled(struct bfa_s * bfa)3696 bfa_fcport_is_pbcdisabled(struct bfa_s *bfa)
3697 {
3698 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3699 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
3700 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
3701
3702 if (cfgrsp->pbc_cfg.port_enabled == BFI_PBC_PORT_DISABLED) {
3703 bfa_trc(bfa, fcport->pwwn);
3704 return BFA_STATUS_PBC;
3705 }
3706 return BFA_STATUS_OK;
3707 }
3708
3709 /*
3710 * Configure port speed.
3711 */
3712 bfa_status_t
bfa_fcport_cfg_speed(struct bfa_s * bfa,enum bfa_port_speed speed)3713 bfa_fcport_cfg_speed(struct bfa_s *bfa, enum bfa_port_speed speed)
3714 {
3715 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3716
3717 bfa_trc(bfa, speed);
3718
3719 if (fcport->cfg.trunked == BFA_TRUE)
3720 return BFA_STATUS_TRUNK_ENABLED;
3721 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) &&
3722 (speed == BFA_PORT_SPEED_16GBPS))
3723 return BFA_STATUS_UNSUPP_SPEED;
3724 if ((speed != BFA_PORT_SPEED_AUTO) && (speed > fcport->speed_sup)) {
3725 bfa_trc(bfa, fcport->speed_sup);
3726 return BFA_STATUS_UNSUPP_SPEED;
3727 }
3728
3729 /* Port speed entered needs to be checked */
3730 if (bfa_ioc_get_type(&fcport->bfa->ioc) == BFA_IOC_TYPE_FC) {
3731 /* For CT2, 1G is not supported */
3732 if ((speed == BFA_PORT_SPEED_1GBPS) &&
3733 (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)))
3734 return BFA_STATUS_UNSUPP_SPEED;
3735
3736 /* Already checked for Auto Speed and Max Speed supp */
3737 if (!(speed == BFA_PORT_SPEED_1GBPS ||
3738 speed == BFA_PORT_SPEED_2GBPS ||
3739 speed == BFA_PORT_SPEED_4GBPS ||
3740 speed == BFA_PORT_SPEED_8GBPS ||
3741 speed == BFA_PORT_SPEED_16GBPS ||
3742 speed == BFA_PORT_SPEED_AUTO))
3743 return BFA_STATUS_UNSUPP_SPEED;
3744 } else {
3745 if (speed != BFA_PORT_SPEED_10GBPS)
3746 return BFA_STATUS_UNSUPP_SPEED;
3747 }
3748
3749 fcport->cfg.speed = speed;
3750
3751 return BFA_STATUS_OK;
3752 }
3753
3754 /*
3755 * Get current speed.
3756 */
3757 enum bfa_port_speed
bfa_fcport_get_speed(struct bfa_s * bfa)3758 bfa_fcport_get_speed(struct bfa_s *bfa)
3759 {
3760 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3761
3762 return fcport->speed;
3763 }
3764
3765 /*
3766 * Configure port topology.
3767 */
3768 bfa_status_t
bfa_fcport_cfg_topology(struct bfa_s * bfa,enum bfa_port_topology topology)3769 bfa_fcport_cfg_topology(struct bfa_s *bfa, enum bfa_port_topology topology)
3770 {
3771 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3772
3773 bfa_trc(bfa, topology);
3774 bfa_trc(bfa, fcport->cfg.topology);
3775
3776 switch (topology) {
3777 case BFA_PORT_TOPOLOGY_P2P:
3778 break;
3779
3780 case BFA_PORT_TOPOLOGY_LOOP:
3781 if ((bfa_fcport_is_qos_enabled(bfa) != BFA_FALSE) ||
3782 (fcport->qos_attr.state != BFA_QOS_DISABLED))
3783 return BFA_STATUS_ERROR_QOS_ENABLED;
3784 if (fcport->cfg.ratelimit != BFA_FALSE)
3785 return BFA_STATUS_ERROR_TRL_ENABLED;
3786 if ((bfa_fcport_is_trunk_enabled(bfa) != BFA_FALSE) ||
3787 (fcport->trunk.attr.state != BFA_TRUNK_DISABLED))
3788 return BFA_STATUS_ERROR_TRUNK_ENABLED;
3789 if ((bfa_fcport_get_speed(bfa) == BFA_PORT_SPEED_16GBPS) ||
3790 (fcport->cfg.speed == BFA_PORT_SPEED_16GBPS))
3791 return BFA_STATUS_UNSUPP_SPEED;
3792 if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type))
3793 return BFA_STATUS_LOOP_UNSUPP_MEZZ;
3794 if (bfa_fcport_is_dport(bfa) != BFA_FALSE)
3795 return BFA_STATUS_DPORT_ERR;
3796 if (bfa_fcport_is_ddport(bfa) != BFA_FALSE)
3797 return BFA_STATUS_DPORT_ERR;
3798 break;
3799
3800 case BFA_PORT_TOPOLOGY_AUTO:
3801 break;
3802
3803 default:
3804 return BFA_STATUS_EINVAL;
3805 }
3806
3807 fcport->cfg.topology = topology;
3808 return BFA_STATUS_OK;
3809 }
3810
3811 /*
3812 * Get current topology.
3813 */
3814 enum bfa_port_topology
bfa_fcport_get_topology(struct bfa_s * bfa)3815 bfa_fcport_get_topology(struct bfa_s *bfa)
3816 {
3817 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3818
3819 return fcport->topology;
3820 }
3821
3822 /*
3823 * Get config topology.
3824 */
3825 enum bfa_port_topology
bfa_fcport_get_cfg_topology(struct bfa_s * bfa)3826 bfa_fcport_get_cfg_topology(struct bfa_s *bfa)
3827 {
3828 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3829
3830 return fcport->cfg.topology;
3831 }
3832
3833 bfa_status_t
bfa_fcport_cfg_hardalpa(struct bfa_s * bfa,u8 alpa)3834 bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
3835 {
3836 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3837
3838 bfa_trc(bfa, alpa);
3839 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3840 bfa_trc(bfa, fcport->cfg.hardalpa);
3841
3842 fcport->cfg.cfg_hardalpa = BFA_TRUE;
3843 fcport->cfg.hardalpa = alpa;
3844
3845 return BFA_STATUS_OK;
3846 }
3847
3848 bfa_status_t
bfa_fcport_clr_hardalpa(struct bfa_s * bfa)3849 bfa_fcport_clr_hardalpa(struct bfa_s *bfa)
3850 {
3851 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3852
3853 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3854 bfa_trc(bfa, fcport->cfg.hardalpa);
3855
3856 fcport->cfg.cfg_hardalpa = BFA_FALSE;
3857 return BFA_STATUS_OK;
3858 }
3859
3860 bfa_boolean_t
bfa_fcport_get_hardalpa(struct bfa_s * bfa,u8 * alpa)3861 bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa)
3862 {
3863 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3864
3865 *alpa = fcport->cfg.hardalpa;
3866 return fcport->cfg.cfg_hardalpa;
3867 }
3868
3869 u8
bfa_fcport_get_myalpa(struct bfa_s * bfa)3870 bfa_fcport_get_myalpa(struct bfa_s *bfa)
3871 {
3872 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3873
3874 return fcport->myalpa;
3875 }
3876
3877 bfa_status_t
bfa_fcport_cfg_maxfrsize(struct bfa_s * bfa,u16 maxfrsize)3878 bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
3879 {
3880 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3881
3882 bfa_trc(bfa, maxfrsize);
3883 bfa_trc(bfa, fcport->cfg.maxfrsize);
3884
3885 /* with in range */
3886 if ((maxfrsize > FC_MAX_PDUSZ) || (maxfrsize < FC_MIN_PDUSZ))
3887 return BFA_STATUS_INVLD_DFSZ;
3888
3889 /* power of 2, if not the max frame size of 2112 */
3890 if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1)))
3891 return BFA_STATUS_INVLD_DFSZ;
3892
3893 fcport->cfg.maxfrsize = maxfrsize;
3894 return BFA_STATUS_OK;
3895 }
3896
3897 u16
bfa_fcport_get_maxfrsize(struct bfa_s * bfa)3898 bfa_fcport_get_maxfrsize(struct bfa_s *bfa)
3899 {
3900 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3901
3902 return fcport->cfg.maxfrsize;
3903 }
3904
3905 u8
bfa_fcport_get_rx_bbcredit(struct bfa_s * bfa)3906 bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa)
3907 {
3908 if (bfa_fcport_get_topology(bfa) != BFA_PORT_TOPOLOGY_LOOP)
3909 return (BFA_FCPORT_MOD(bfa))->cfg.rx_bbcredit;
3910
3911 else
3912 return 0;
3913 }
3914
3915 void
bfa_fcport_set_tx_bbcredit(struct bfa_s * bfa,u16 tx_bbcredit)3916 bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
3917 {
3918 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3919
3920 fcport->cfg.tx_bbcredit = (u8)tx_bbcredit;
3921 }
3922
3923 /*
3924 * Get port attributes.
3925 */
3926
3927 wwn_t
bfa_fcport_get_wwn(struct bfa_s * bfa,bfa_boolean_t node)3928 bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node)
3929 {
3930 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3931 if (node)
3932 return fcport->nwwn;
3933 else
3934 return fcport->pwwn;
3935 }
3936
3937 void
bfa_fcport_get_attr(struct bfa_s * bfa,struct bfa_port_attr_s * attr)3938 bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr)
3939 {
3940 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3941
3942 memset(attr, 0, sizeof(struct bfa_port_attr_s));
3943
3944 attr->nwwn = fcport->nwwn;
3945 attr->pwwn = fcport->pwwn;
3946
3947 attr->factorypwwn = bfa->ioc.attr->mfg_pwwn;
3948 attr->factorynwwn = bfa->ioc.attr->mfg_nwwn;
3949
3950 memcpy(&attr->pport_cfg, &fcport->cfg,
3951 sizeof(struct bfa_port_cfg_s));
3952 /* speed attributes */
3953 attr->pport_cfg.speed = fcport->cfg.speed;
3954 attr->speed_supported = fcport->speed_sup;
3955 attr->speed = fcport->speed;
3956 attr->cos_supported = FC_CLASS_3;
3957
3958 /* topology attributes */
3959 attr->pport_cfg.topology = fcport->cfg.topology;
3960 attr->topology = fcport->topology;
3961 attr->pport_cfg.trunked = fcport->cfg.trunked;
3962
3963 /* beacon attributes */
3964 attr->beacon = fcport->beacon;
3965 attr->link_e2e_beacon = fcport->link_e2e_beacon;
3966
3967 attr->pport_cfg.path_tov = bfa_fcpim_path_tov_get(bfa);
3968 attr->pport_cfg.q_depth = bfa_fcpim_qdepth_get(bfa);
3969 attr->port_state = bfa_fcport_sm_to_state(hal_port_sm_table, fcport->sm);
3970
3971 attr->fec_state = fcport->fec_state;
3972
3973 /* PBC Disabled State */
3974 if (bfa_fcport_is_pbcdisabled(bfa))
3975 attr->port_state = BFA_PORT_ST_PREBOOT_DISABLED;
3976 else {
3977 if (bfa_ioc_is_disabled(&fcport->bfa->ioc))
3978 attr->port_state = BFA_PORT_ST_IOCDIS;
3979 else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc))
3980 attr->port_state = BFA_PORT_ST_FWMISMATCH;
3981 }
3982
3983 /* FCoE vlan */
3984 attr->fcoe_vlan = fcport->fcoe_vlan;
3985 }
3986
3987 #define BFA_FCPORT_STATS_TOV 1000
3988
3989 /*
3990 * Fetch port statistics (FCQoS or FCoE).
3991 */
3992 bfa_status_t
bfa_fcport_get_stats(struct bfa_s * bfa,struct bfa_cb_pending_q_s * cb)3993 bfa_fcport_get_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb)
3994 {
3995 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3996
3997 if (!bfa_iocfc_is_operational(bfa) ||
3998 !fcport->stats_dma_ready)
3999 return BFA_STATUS_IOC_NON_OP;
4000
4001 if (!list_empty(&fcport->statsclr_pending_q))
4002 return BFA_STATUS_DEVBUSY;
4003
4004 if (list_empty(&fcport->stats_pending_q)) {
4005 list_add_tail(&cb->hcb_qe.qe, &fcport->stats_pending_q);
4006 bfa_fcport_send_stats_get(fcport);
4007 bfa_timer_start(bfa, &fcport->timer,
4008 bfa_fcport_stats_get_timeout,
4009 fcport, BFA_FCPORT_STATS_TOV);
4010 } else
4011 list_add_tail(&cb->hcb_qe.qe, &fcport->stats_pending_q);
4012
4013 return BFA_STATUS_OK;
4014 }
4015
4016 /*
4017 * Reset port statistics (FCQoS or FCoE).
4018 */
4019 bfa_status_t
bfa_fcport_clear_stats(struct bfa_s * bfa,struct bfa_cb_pending_q_s * cb)4020 bfa_fcport_clear_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb)
4021 {
4022 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4023
4024 if (!bfa_iocfc_is_operational(bfa) ||
4025 !fcport->stats_dma_ready)
4026 return BFA_STATUS_IOC_NON_OP;
4027
4028 if (!list_empty(&fcport->stats_pending_q))
4029 return BFA_STATUS_DEVBUSY;
4030
4031 if (list_empty(&fcport->statsclr_pending_q)) {
4032 list_add_tail(&cb->hcb_qe.qe, &fcport->statsclr_pending_q);
4033 bfa_fcport_send_stats_clear(fcport);
4034 bfa_timer_start(bfa, &fcport->timer,
4035 bfa_fcport_stats_clr_timeout,
4036 fcport, BFA_FCPORT_STATS_TOV);
4037 } else
4038 list_add_tail(&cb->hcb_qe.qe, &fcport->statsclr_pending_q);
4039
4040 return BFA_STATUS_OK;
4041 }
4042
4043 /*
4044 * Fetch port attributes.
4045 */
4046 bfa_boolean_t
bfa_fcport_is_disabled(struct bfa_s * bfa)4047 bfa_fcport_is_disabled(struct bfa_s *bfa)
4048 {
4049 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4050
4051 return bfa_fcport_sm_to_state(hal_port_sm_table, fcport->sm) ==
4052 BFA_PORT_ST_DISABLED;
4053
4054 }
4055
4056 bfa_boolean_t
bfa_fcport_is_dport(struct bfa_s * bfa)4057 bfa_fcport_is_dport(struct bfa_s *bfa)
4058 {
4059 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4060
4061 return (bfa_fcport_sm_to_state(hal_port_sm_table, fcport->sm) ==
4062 BFA_PORT_ST_DPORT);
4063 }
4064
4065 bfa_boolean_t
bfa_fcport_is_ddport(struct bfa_s * bfa)4066 bfa_fcport_is_ddport(struct bfa_s *bfa)
4067 {
4068 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4069
4070 return (bfa_fcport_sm_to_state(hal_port_sm_table, fcport->sm) ==
4071 BFA_PORT_ST_DDPORT);
4072 }
4073
4074 bfa_status_t
bfa_fcport_set_qos_bw(struct bfa_s * bfa,struct bfa_qos_bw_s * qos_bw)4075 bfa_fcport_set_qos_bw(struct bfa_s *bfa, struct bfa_qos_bw_s *qos_bw)
4076 {
4077 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4078 enum bfa_ioc_type_e ioc_type = bfa_get_type(bfa);
4079
4080 bfa_trc(bfa, ioc_type);
4081
4082 if ((qos_bw->high == 0) || (qos_bw->med == 0) || (qos_bw->low == 0))
4083 return BFA_STATUS_QOS_BW_INVALID;
4084
4085 if ((qos_bw->high + qos_bw->med + qos_bw->low) != 100)
4086 return BFA_STATUS_QOS_BW_INVALID;
4087
4088 if ((qos_bw->med > qos_bw->high) || (qos_bw->low > qos_bw->med) ||
4089 (qos_bw->low > qos_bw->high))
4090 return BFA_STATUS_QOS_BW_INVALID;
4091
4092 if ((ioc_type == BFA_IOC_TYPE_FC) &&
4093 (fcport->cfg.topology != BFA_PORT_TOPOLOGY_LOOP))
4094 fcport->cfg.qos_bw = *qos_bw;
4095
4096 return BFA_STATUS_OK;
4097 }
4098
4099 bfa_boolean_t
bfa_fcport_is_ratelim(struct bfa_s * bfa)4100 bfa_fcport_is_ratelim(struct bfa_s *bfa)
4101 {
4102 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4103
4104 return fcport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE;
4105
4106 }
4107
4108 /*
4109 * Enable/Disable FAA feature in port config
4110 */
4111 void
bfa_fcport_cfg_faa(struct bfa_s * bfa,u8 state)4112 bfa_fcport_cfg_faa(struct bfa_s *bfa, u8 state)
4113 {
4114 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4115
4116 bfa_trc(bfa, state);
4117 fcport->cfg.faa_state = state;
4118 }
4119
4120 /*
4121 * Get default minimum ratelim speed
4122 */
4123 enum bfa_port_speed
bfa_fcport_get_ratelim_speed(struct bfa_s * bfa)4124 bfa_fcport_get_ratelim_speed(struct bfa_s *bfa)
4125 {
4126 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4127
4128 bfa_trc(bfa, fcport->cfg.trl_def_speed);
4129 return fcport->cfg.trl_def_speed;
4130
4131 }
4132
4133 void
bfa_fcport_beacon(void * dev,bfa_boolean_t beacon,bfa_boolean_t link_e2e_beacon)4134 bfa_fcport_beacon(void *dev, bfa_boolean_t beacon,
4135 bfa_boolean_t link_e2e_beacon)
4136 {
4137 struct bfa_s *bfa = dev;
4138 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4139
4140 bfa_trc(bfa, beacon);
4141 bfa_trc(bfa, link_e2e_beacon);
4142 bfa_trc(bfa, fcport->beacon);
4143 bfa_trc(bfa, fcport->link_e2e_beacon);
4144
4145 fcport->beacon = beacon;
4146 fcport->link_e2e_beacon = link_e2e_beacon;
4147 }
4148
4149 bfa_boolean_t
bfa_fcport_is_linkup(struct bfa_s * bfa)4150 bfa_fcport_is_linkup(struct bfa_s *bfa)
4151 {
4152 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4153
4154 return (!fcport->cfg.trunked &&
4155 bfa_sm_cmp_state(fcport, bfa_fcport_sm_linkup)) ||
4156 (fcport->cfg.trunked &&
4157 fcport->trunk.attr.state == BFA_TRUNK_ONLINE);
4158 }
4159
4160 bfa_boolean_t
bfa_fcport_is_qos_enabled(struct bfa_s * bfa)4161 bfa_fcport_is_qos_enabled(struct bfa_s *bfa)
4162 {
4163 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4164
4165 return fcport->cfg.qos_enabled;
4166 }
4167
4168 bfa_boolean_t
bfa_fcport_is_trunk_enabled(struct bfa_s * bfa)4169 bfa_fcport_is_trunk_enabled(struct bfa_s *bfa)
4170 {
4171 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4172
4173 return fcport->cfg.trunked;
4174 }
4175
4176 bfa_status_t
bfa_fcport_cfg_bbcr(struct bfa_s * bfa,bfa_boolean_t on_off,u8 bb_scn)4177 bfa_fcport_cfg_bbcr(struct bfa_s *bfa, bfa_boolean_t on_off, u8 bb_scn)
4178 {
4179 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4180
4181 bfa_trc(bfa, on_off);
4182
4183 if (bfa_ioc_get_type(&fcport->bfa->ioc) != BFA_IOC_TYPE_FC)
4184 return BFA_STATUS_BBCR_FC_ONLY;
4185
4186 if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type) &&
4187 (bfa->ioc.attr->card_type != BFA_MFG_TYPE_CHINOOK))
4188 return BFA_STATUS_CMD_NOTSUPP_MEZZ;
4189
4190 if (on_off) {
4191 if (fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP)
4192 return BFA_STATUS_TOPOLOGY_LOOP;
4193
4194 if (fcport->cfg.qos_enabled)
4195 return BFA_STATUS_ERROR_QOS_ENABLED;
4196
4197 if (fcport->cfg.trunked)
4198 return BFA_STATUS_TRUNK_ENABLED;
4199
4200 if ((fcport->cfg.speed != BFA_PORT_SPEED_AUTO) &&
4201 (fcport->cfg.speed < bfa_ioc_speed_sup(&bfa->ioc)))
4202 return BFA_STATUS_ERR_BBCR_SPEED_UNSUPPORT;
4203
4204 if (bfa_ioc_speed_sup(&bfa->ioc) < BFA_PORT_SPEED_8GBPS)
4205 return BFA_STATUS_FEATURE_NOT_SUPPORTED;
4206
4207 if (fcport->cfg.bb_cr_enabled) {
4208 if (bb_scn != fcport->cfg.bb_scn)
4209 return BFA_STATUS_BBCR_CFG_NO_CHANGE;
4210 else
4211 return BFA_STATUS_NO_CHANGE;
4212 }
4213
4214 if ((bb_scn == 0) || (bb_scn > BFA_BB_SCN_MAX))
4215 bb_scn = BFA_BB_SCN_DEF;
4216
4217 fcport->cfg.bb_cr_enabled = on_off;
4218 fcport->cfg.bb_scn = bb_scn;
4219 } else {
4220 if (!fcport->cfg.bb_cr_enabled)
4221 return BFA_STATUS_NO_CHANGE;
4222
4223 fcport->cfg.bb_cr_enabled = on_off;
4224 fcport->cfg.bb_scn = 0;
4225 }
4226
4227 return BFA_STATUS_OK;
4228 }
4229
4230 bfa_status_t
bfa_fcport_get_bbcr_attr(struct bfa_s * bfa,struct bfa_bbcr_attr_s * bbcr_attr)4231 bfa_fcport_get_bbcr_attr(struct bfa_s *bfa,
4232 struct bfa_bbcr_attr_s *bbcr_attr)
4233 {
4234 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
4235
4236 if (bfa_ioc_get_type(&fcport->bfa->ioc) != BFA_IOC_TYPE_FC)
4237 return BFA_STATUS_BBCR_FC_ONLY;
4238
4239 if (fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP)
4240 return BFA_STATUS_TOPOLOGY_LOOP;
4241
4242 *bbcr_attr = fcport->bbcr_attr;
4243
4244 return BFA_STATUS_OK;
4245 }
4246
4247 void
bfa_fcport_dportenable(struct bfa_s * bfa)4248 bfa_fcport_dportenable(struct bfa_s *bfa)
4249 {
4250 /*
4251 * Assume caller check for port is in disable state
4252 */
4253 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DPORTENABLE);
4254 bfa_port_set_dportenabled(&bfa->modules.port, BFA_TRUE);
4255 }
4256
4257 void
bfa_fcport_dportdisable(struct bfa_s * bfa)4258 bfa_fcport_dportdisable(struct bfa_s *bfa)
4259 {
4260 /*
4261 * Assume caller check for port is in disable state
4262 */
4263 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DPORTDISABLE);
4264 bfa_port_set_dportenabled(&bfa->modules.port, BFA_FALSE);
4265 }
4266
4267 static void
bfa_fcport_ddportenable(struct bfa_s * bfa)4268 bfa_fcport_ddportenable(struct bfa_s *bfa)
4269 {
4270 /*
4271 * Assume caller check for port is in disable state
4272 */
4273 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DDPORTENABLE);
4274 }
4275
4276 static void
bfa_fcport_ddportdisable(struct bfa_s * bfa)4277 bfa_fcport_ddportdisable(struct bfa_s *bfa)
4278 {
4279 /*
4280 * Assume caller check for port is in disable state
4281 */
4282 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DDPORTDISABLE);
4283 }
4284
4285 /*
4286 * Rport State machine functions
4287 */
4288 /*
4289 * Beginning state, only online event expected.
4290 */
4291 static void
bfa_rport_sm_uninit(struct bfa_rport_s * rp,enum bfa_rport_event event)4292 bfa_rport_sm_uninit(struct bfa_rport_s *rp, enum bfa_rport_event event)
4293 {
4294 bfa_trc(rp->bfa, rp->rport_tag);
4295 bfa_trc(rp->bfa, event);
4296
4297 switch (event) {
4298 case BFA_RPORT_SM_CREATE:
4299 bfa_stats(rp, sm_un_cr);
4300 bfa_sm_set_state(rp, bfa_rport_sm_created);
4301 break;
4302
4303 default:
4304 bfa_stats(rp, sm_un_unexp);
4305 bfa_sm_fault(rp->bfa, event);
4306 }
4307 }
4308
4309 static void
bfa_rport_sm_created(struct bfa_rport_s * rp,enum bfa_rport_event event)4310 bfa_rport_sm_created(struct bfa_rport_s *rp, enum bfa_rport_event event)
4311 {
4312 bfa_trc(rp->bfa, rp->rport_tag);
4313 bfa_trc(rp->bfa, event);
4314
4315 switch (event) {
4316 case BFA_RPORT_SM_ONLINE:
4317 bfa_stats(rp, sm_cr_on);
4318 if (bfa_rport_send_fwcreate(rp))
4319 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4320 else
4321 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4322 break;
4323
4324 case BFA_RPORT_SM_DELETE:
4325 bfa_stats(rp, sm_cr_del);
4326 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4327 bfa_rport_free(rp);
4328 break;
4329
4330 case BFA_RPORT_SM_HWFAIL:
4331 bfa_stats(rp, sm_cr_hwf);
4332 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4333 break;
4334
4335 default:
4336 bfa_stats(rp, sm_cr_unexp);
4337 bfa_sm_fault(rp->bfa, event);
4338 }
4339 }
4340
4341 /*
4342 * Waiting for rport create response from firmware.
4343 */
4344 static void
bfa_rport_sm_fwcreate(struct bfa_rport_s * rp,enum bfa_rport_event event)4345 bfa_rport_sm_fwcreate(struct bfa_rport_s *rp, enum bfa_rport_event event)
4346 {
4347 bfa_trc(rp->bfa, rp->rport_tag);
4348 bfa_trc(rp->bfa, event);
4349
4350 switch (event) {
4351 case BFA_RPORT_SM_FWRSP:
4352 bfa_stats(rp, sm_fwc_rsp);
4353 bfa_sm_set_state(rp, bfa_rport_sm_online);
4354 bfa_rport_online_cb(rp);
4355 break;
4356
4357 case BFA_RPORT_SM_DELETE:
4358 bfa_stats(rp, sm_fwc_del);
4359 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
4360 break;
4361
4362 case BFA_RPORT_SM_OFFLINE:
4363 bfa_stats(rp, sm_fwc_off);
4364 bfa_sm_set_state(rp, bfa_rport_sm_offline_pending);
4365 break;
4366
4367 case BFA_RPORT_SM_HWFAIL:
4368 bfa_stats(rp, sm_fwc_hwf);
4369 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4370 break;
4371
4372 default:
4373 bfa_stats(rp, sm_fwc_unexp);
4374 bfa_sm_fault(rp->bfa, event);
4375 }
4376 }
4377
4378 /*
4379 * Request queue is full, awaiting queue resume to send create request.
4380 */
4381 static void
bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s * rp,enum bfa_rport_event event)4382 bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4383 {
4384 bfa_trc(rp->bfa, rp->rport_tag);
4385 bfa_trc(rp->bfa, event);
4386
4387 switch (event) {
4388 case BFA_RPORT_SM_QRESUME:
4389 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4390 bfa_rport_send_fwcreate(rp);
4391 break;
4392
4393 case BFA_RPORT_SM_DELETE:
4394 bfa_stats(rp, sm_fwc_del);
4395 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4396 bfa_reqq_wcancel(&rp->reqq_wait);
4397 bfa_rport_free(rp);
4398 break;
4399
4400 case BFA_RPORT_SM_OFFLINE:
4401 bfa_stats(rp, sm_fwc_off);
4402 bfa_sm_set_state(rp, bfa_rport_sm_offline);
4403 bfa_reqq_wcancel(&rp->reqq_wait);
4404 bfa_rport_offline_cb(rp);
4405 break;
4406
4407 case BFA_RPORT_SM_HWFAIL:
4408 bfa_stats(rp, sm_fwc_hwf);
4409 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4410 bfa_reqq_wcancel(&rp->reqq_wait);
4411 break;
4412
4413 default:
4414 bfa_stats(rp, sm_fwc_unexp);
4415 bfa_sm_fault(rp->bfa, event);
4416 }
4417 }
4418
4419 /*
4420 * Online state - normal parking state.
4421 */
4422 static void
bfa_rport_sm_online(struct bfa_rport_s * rp,enum bfa_rport_event event)4423 bfa_rport_sm_online(struct bfa_rport_s *rp, enum bfa_rport_event event)
4424 {
4425 struct bfi_rport_qos_scn_s *qos_scn;
4426
4427 bfa_trc(rp->bfa, rp->rport_tag);
4428 bfa_trc(rp->bfa, event);
4429
4430 switch (event) {
4431 case BFA_RPORT_SM_OFFLINE:
4432 bfa_stats(rp, sm_on_off);
4433 if (bfa_rport_send_fwdelete(rp))
4434 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4435 else
4436 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
4437 break;
4438
4439 case BFA_RPORT_SM_DELETE:
4440 bfa_stats(rp, sm_on_del);
4441 if (bfa_rport_send_fwdelete(rp))
4442 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4443 else
4444 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4445 break;
4446
4447 case BFA_RPORT_SM_HWFAIL:
4448 bfa_stats(rp, sm_on_hwf);
4449 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4450 break;
4451
4452 case BFA_RPORT_SM_SET_SPEED:
4453 bfa_rport_send_fwspeed(rp);
4454 break;
4455
4456 case BFA_RPORT_SM_QOS_SCN:
4457 qos_scn = (struct bfi_rport_qos_scn_s *) rp->event_arg.fw_msg;
4458 rp->qos_attr = qos_scn->new_qos_attr;
4459 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_flow_id);
4460 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_flow_id);
4461 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_priority);
4462 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_priority);
4463
4464 qos_scn->old_qos_attr.qos_flow_id =
4465 be32_to_cpu(qos_scn->old_qos_attr.qos_flow_id);
4466 qos_scn->new_qos_attr.qos_flow_id =
4467 be32_to_cpu(qos_scn->new_qos_attr.qos_flow_id);
4468
4469 if (qos_scn->old_qos_attr.qos_flow_id !=
4470 qos_scn->new_qos_attr.qos_flow_id)
4471 bfa_cb_rport_qos_scn_flowid(rp->rport_drv,
4472 qos_scn->old_qos_attr,
4473 qos_scn->new_qos_attr);
4474 if (qos_scn->old_qos_attr.qos_priority !=
4475 qos_scn->new_qos_attr.qos_priority)
4476 bfa_cb_rport_qos_scn_prio(rp->rport_drv,
4477 qos_scn->old_qos_attr,
4478 qos_scn->new_qos_attr);
4479 break;
4480
4481 default:
4482 bfa_stats(rp, sm_on_unexp);
4483 bfa_sm_fault(rp->bfa, event);
4484 }
4485 }
4486
4487 /*
4488 * Firmware rport is being deleted - awaiting f/w response.
4489 */
4490 static void
bfa_rport_sm_fwdelete(struct bfa_rport_s * rp,enum bfa_rport_event event)4491 bfa_rport_sm_fwdelete(struct bfa_rport_s *rp, enum bfa_rport_event event)
4492 {
4493 bfa_trc(rp->bfa, rp->rport_tag);
4494 bfa_trc(rp->bfa, event);
4495
4496 switch (event) {
4497 case BFA_RPORT_SM_FWRSP:
4498 bfa_stats(rp, sm_fwd_rsp);
4499 bfa_sm_set_state(rp, bfa_rport_sm_offline);
4500 bfa_rport_offline_cb(rp);
4501 break;
4502
4503 case BFA_RPORT_SM_DELETE:
4504 bfa_stats(rp, sm_fwd_del);
4505 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4506 break;
4507
4508 case BFA_RPORT_SM_HWFAIL:
4509 bfa_stats(rp, sm_fwd_hwf);
4510 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4511 bfa_rport_offline_cb(rp);
4512 break;
4513
4514 default:
4515 bfa_stats(rp, sm_fwd_unexp);
4516 bfa_sm_fault(rp->bfa, event);
4517 }
4518 }
4519
4520 static void
bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s * rp,enum bfa_rport_event event)4521 bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4522 {
4523 bfa_trc(rp->bfa, rp->rport_tag);
4524 bfa_trc(rp->bfa, event);
4525
4526 switch (event) {
4527 case BFA_RPORT_SM_QRESUME:
4528 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4529 bfa_rport_send_fwdelete(rp);
4530 break;
4531
4532 case BFA_RPORT_SM_DELETE:
4533 bfa_stats(rp, sm_fwd_del);
4534 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4535 break;
4536
4537 case BFA_RPORT_SM_HWFAIL:
4538 bfa_stats(rp, sm_fwd_hwf);
4539 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4540 bfa_reqq_wcancel(&rp->reqq_wait);
4541 bfa_rport_offline_cb(rp);
4542 break;
4543
4544 default:
4545 bfa_stats(rp, sm_fwd_unexp);
4546 bfa_sm_fault(rp->bfa, event);
4547 }
4548 }
4549
4550 /*
4551 * Offline state.
4552 */
4553 static void
bfa_rport_sm_offline(struct bfa_rport_s * rp,enum bfa_rport_event event)4554 bfa_rport_sm_offline(struct bfa_rport_s *rp, enum bfa_rport_event event)
4555 {
4556 bfa_trc(rp->bfa, rp->rport_tag);
4557 bfa_trc(rp->bfa, event);
4558
4559 switch (event) {
4560 case BFA_RPORT_SM_DELETE:
4561 bfa_stats(rp, sm_off_del);
4562 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4563 bfa_rport_free(rp);
4564 break;
4565
4566 case BFA_RPORT_SM_ONLINE:
4567 bfa_stats(rp, sm_off_on);
4568 if (bfa_rport_send_fwcreate(rp))
4569 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4570 else
4571 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4572 break;
4573
4574 case BFA_RPORT_SM_HWFAIL:
4575 bfa_stats(rp, sm_off_hwf);
4576 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4577 break;
4578
4579 case BFA_RPORT_SM_OFFLINE:
4580 bfa_rport_offline_cb(rp);
4581 break;
4582
4583 default:
4584 bfa_stats(rp, sm_off_unexp);
4585 bfa_sm_fault(rp->bfa, event);
4586 }
4587 }
4588
4589 /*
4590 * Rport is deleted, waiting for firmware response to delete.
4591 */
4592 static void
bfa_rport_sm_deleting(struct bfa_rport_s * rp,enum bfa_rport_event event)4593 bfa_rport_sm_deleting(struct bfa_rport_s *rp, enum bfa_rport_event event)
4594 {
4595 bfa_trc(rp->bfa, rp->rport_tag);
4596 bfa_trc(rp->bfa, event);
4597
4598 switch (event) {
4599 case BFA_RPORT_SM_FWRSP:
4600 bfa_stats(rp, sm_del_fwrsp);
4601 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4602 bfa_rport_free(rp);
4603 break;
4604
4605 case BFA_RPORT_SM_HWFAIL:
4606 bfa_stats(rp, sm_del_hwf);
4607 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4608 bfa_rport_free(rp);
4609 break;
4610
4611 default:
4612 bfa_sm_fault(rp->bfa, event);
4613 }
4614 }
4615
4616 static void
bfa_rport_sm_deleting_qfull(struct bfa_rport_s * rp,enum bfa_rport_event event)4617 bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4618 {
4619 bfa_trc(rp->bfa, rp->rport_tag);
4620 bfa_trc(rp->bfa, event);
4621
4622 switch (event) {
4623 case BFA_RPORT_SM_QRESUME:
4624 bfa_stats(rp, sm_del_fwrsp);
4625 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4626 bfa_rport_send_fwdelete(rp);
4627 break;
4628
4629 case BFA_RPORT_SM_HWFAIL:
4630 bfa_stats(rp, sm_del_hwf);
4631 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4632 bfa_reqq_wcancel(&rp->reqq_wait);
4633 bfa_rport_free(rp);
4634 break;
4635
4636 default:
4637 bfa_sm_fault(rp->bfa, event);
4638 }
4639 }
4640
4641 /*
4642 * Waiting for rport create response from firmware. A delete is pending.
4643 */
4644 static void
bfa_rport_sm_delete_pending(struct bfa_rport_s * rp,enum bfa_rport_event event)4645 bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
4646 enum bfa_rport_event event)
4647 {
4648 bfa_trc(rp->bfa, rp->rport_tag);
4649 bfa_trc(rp->bfa, event);
4650
4651 switch (event) {
4652 case BFA_RPORT_SM_FWRSP:
4653 bfa_stats(rp, sm_delp_fwrsp);
4654 if (bfa_rport_send_fwdelete(rp))
4655 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4656 else
4657 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4658 break;
4659
4660 case BFA_RPORT_SM_HWFAIL:
4661 bfa_stats(rp, sm_delp_hwf);
4662 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4663 bfa_rport_free(rp);
4664 break;
4665
4666 default:
4667 bfa_stats(rp, sm_delp_unexp);
4668 bfa_sm_fault(rp->bfa, event);
4669 }
4670 }
4671
4672 /*
4673 * Waiting for rport create response from firmware. Rport offline is pending.
4674 */
4675 static void
bfa_rport_sm_offline_pending(struct bfa_rport_s * rp,enum bfa_rport_event event)4676 bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
4677 enum bfa_rport_event event)
4678 {
4679 bfa_trc(rp->bfa, rp->rport_tag);
4680 bfa_trc(rp->bfa, event);
4681
4682 switch (event) {
4683 case BFA_RPORT_SM_FWRSP:
4684 bfa_stats(rp, sm_offp_fwrsp);
4685 if (bfa_rport_send_fwdelete(rp))
4686 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4687 else
4688 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
4689 break;
4690
4691 case BFA_RPORT_SM_DELETE:
4692 bfa_stats(rp, sm_offp_del);
4693 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
4694 break;
4695
4696 case BFA_RPORT_SM_HWFAIL:
4697 bfa_stats(rp, sm_offp_hwf);
4698 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4699 bfa_rport_offline_cb(rp);
4700 break;
4701
4702 default:
4703 bfa_stats(rp, sm_offp_unexp);
4704 bfa_sm_fault(rp->bfa, event);
4705 }
4706 }
4707
4708 /*
4709 * IOC h/w failed.
4710 */
4711 static void
bfa_rport_sm_iocdisable(struct bfa_rport_s * rp,enum bfa_rport_event event)4712 bfa_rport_sm_iocdisable(struct bfa_rport_s *rp, enum bfa_rport_event event)
4713 {
4714 bfa_trc(rp->bfa, rp->rport_tag);
4715 bfa_trc(rp->bfa, event);
4716
4717 switch (event) {
4718 case BFA_RPORT_SM_OFFLINE:
4719 bfa_stats(rp, sm_iocd_off);
4720 bfa_rport_offline_cb(rp);
4721 break;
4722
4723 case BFA_RPORT_SM_DELETE:
4724 bfa_stats(rp, sm_iocd_del);
4725 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4726 bfa_rport_free(rp);
4727 break;
4728
4729 case BFA_RPORT_SM_ONLINE:
4730 bfa_stats(rp, sm_iocd_on);
4731 if (bfa_rport_send_fwcreate(rp))
4732 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4733 else
4734 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4735 break;
4736
4737 case BFA_RPORT_SM_HWFAIL:
4738 break;
4739
4740 default:
4741 bfa_stats(rp, sm_iocd_unexp);
4742 bfa_sm_fault(rp->bfa, event);
4743 }
4744 }
4745
4746
4747
4748 /*
4749 * bfa_rport_private BFA rport private functions
4750 */
4751
4752 static void
__bfa_cb_rport_online(void * cbarg,bfa_boolean_t complete)4753 __bfa_cb_rport_online(void *cbarg, bfa_boolean_t complete)
4754 {
4755 struct bfa_rport_s *rp = cbarg;
4756
4757 if (complete)
4758 bfa_cb_rport_online(rp->rport_drv);
4759 }
4760
4761 static void
__bfa_cb_rport_offline(void * cbarg,bfa_boolean_t complete)4762 __bfa_cb_rport_offline(void *cbarg, bfa_boolean_t complete)
4763 {
4764 struct bfa_rport_s *rp = cbarg;
4765
4766 if (complete)
4767 bfa_cb_rport_offline(rp->rport_drv);
4768 }
4769
4770 static void
bfa_rport_qresume(void * cbarg)4771 bfa_rport_qresume(void *cbarg)
4772 {
4773 struct bfa_rport_s *rp = cbarg;
4774
4775 bfa_sm_send_event(rp, BFA_RPORT_SM_QRESUME);
4776 }
4777
4778 void
bfa_rport_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)4779 bfa_rport_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
4780 struct bfa_s *bfa)
4781 {
4782 struct bfa_mem_kva_s *rport_kva = BFA_MEM_RPORT_KVA(bfa);
4783
4784 if (cfg->fwcfg.num_rports < BFA_RPORT_MIN)
4785 cfg->fwcfg.num_rports = BFA_RPORT_MIN;
4786
4787 /* kva memory */
4788 bfa_mem_kva_setup(minfo, rport_kva,
4789 cfg->fwcfg.num_rports * sizeof(struct bfa_rport_s));
4790 }
4791
4792 void
bfa_rport_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)4793 bfa_rport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4794 struct bfa_pcidev_s *pcidev)
4795 {
4796 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4797 struct bfa_rport_s *rp;
4798 u16 i;
4799
4800 INIT_LIST_HEAD(&mod->rp_free_q);
4801 INIT_LIST_HEAD(&mod->rp_active_q);
4802 INIT_LIST_HEAD(&mod->rp_unused_q);
4803
4804 rp = (struct bfa_rport_s *) bfa_mem_kva_curp(mod);
4805 mod->rps_list = rp;
4806 mod->num_rports = cfg->fwcfg.num_rports;
4807
4808 WARN_ON(!mod->num_rports ||
4809 (mod->num_rports & (mod->num_rports - 1)));
4810
4811 for (i = 0; i < mod->num_rports; i++, rp++) {
4812 memset(rp, 0, sizeof(struct bfa_rport_s));
4813 rp->bfa = bfa;
4814 rp->rport_tag = i;
4815 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4816
4817 /*
4818 * - is unused
4819 */
4820 if (i)
4821 list_add_tail(&rp->qe, &mod->rp_free_q);
4822
4823 bfa_reqq_winit(&rp->reqq_wait, bfa_rport_qresume, rp);
4824 }
4825
4826 /*
4827 * consume memory
4828 */
4829 bfa_mem_kva_curp(mod) = (u8 *) rp;
4830 }
4831
4832 void
bfa_rport_iocdisable(struct bfa_s * bfa)4833 bfa_rport_iocdisable(struct bfa_s *bfa)
4834 {
4835 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4836 struct bfa_rport_s *rport;
4837 struct list_head *qe, *qen;
4838
4839 /* Enqueue unused rport resources to free_q */
4840 list_splice_tail_init(&mod->rp_unused_q, &mod->rp_free_q);
4841
4842 list_for_each_safe(qe, qen, &mod->rp_active_q) {
4843 rport = (struct bfa_rport_s *) qe;
4844 bfa_sm_send_event(rport, BFA_RPORT_SM_HWFAIL);
4845 }
4846 }
4847
4848 static struct bfa_rport_s *
bfa_rport_alloc(struct bfa_rport_mod_s * mod)4849 bfa_rport_alloc(struct bfa_rport_mod_s *mod)
4850 {
4851 struct bfa_rport_s *rport;
4852
4853 bfa_q_deq(&mod->rp_free_q, &rport);
4854 if (rport)
4855 list_add_tail(&rport->qe, &mod->rp_active_q);
4856
4857 return rport;
4858 }
4859
4860 static void
bfa_rport_free(struct bfa_rport_s * rport)4861 bfa_rport_free(struct bfa_rport_s *rport)
4862 {
4863 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(rport->bfa);
4864
4865 WARN_ON(!bfa_q_is_on_q(&mod->rp_active_q, rport));
4866 list_del(&rport->qe);
4867 list_add_tail(&rport->qe, &mod->rp_free_q);
4868 }
4869
4870 static bfa_boolean_t
bfa_rport_send_fwcreate(struct bfa_rport_s * rp)4871 bfa_rport_send_fwcreate(struct bfa_rport_s *rp)
4872 {
4873 struct bfi_rport_create_req_s *m;
4874
4875 /*
4876 * check for room in queue to send request now
4877 */
4878 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4879 if (!m) {
4880 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4881 return BFA_FALSE;
4882 }
4883
4884 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_CREATE_REQ,
4885 bfa_fn_lpu(rp->bfa));
4886 m->bfa_handle = rp->rport_tag;
4887 m->max_frmsz = cpu_to_be16(rp->rport_info.max_frmsz);
4888 m->pid = rp->rport_info.pid;
4889 m->lp_fwtag = bfa_lps_get_fwtag(rp->bfa, (u8)rp->rport_info.lp_tag);
4890 m->local_pid = rp->rport_info.local_pid;
4891 m->fc_class = rp->rport_info.fc_class;
4892 m->vf_en = rp->rport_info.vf_en;
4893 m->vf_id = rp->rport_info.vf_id;
4894 m->cisc = rp->rport_info.cisc;
4895
4896 /*
4897 * queue I/O message to firmware
4898 */
4899 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh);
4900 return BFA_TRUE;
4901 }
4902
4903 static bfa_boolean_t
bfa_rport_send_fwdelete(struct bfa_rport_s * rp)4904 bfa_rport_send_fwdelete(struct bfa_rport_s *rp)
4905 {
4906 struct bfi_rport_delete_req_s *m;
4907
4908 /*
4909 * check for room in queue to send request now
4910 */
4911 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4912 if (!m) {
4913 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4914 return BFA_FALSE;
4915 }
4916
4917 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_DELETE_REQ,
4918 bfa_fn_lpu(rp->bfa));
4919 m->fw_handle = rp->fw_handle;
4920
4921 /*
4922 * queue I/O message to firmware
4923 */
4924 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh);
4925 return BFA_TRUE;
4926 }
4927
4928 static bfa_boolean_t
bfa_rport_send_fwspeed(struct bfa_rport_s * rp)4929 bfa_rport_send_fwspeed(struct bfa_rport_s *rp)
4930 {
4931 struct bfa_rport_speed_req_s *m;
4932
4933 /*
4934 * check for room in queue to send request now
4935 */
4936 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4937 if (!m) {
4938 bfa_trc(rp->bfa, rp->rport_info.speed);
4939 return BFA_FALSE;
4940 }
4941
4942 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_SET_SPEED_REQ,
4943 bfa_fn_lpu(rp->bfa));
4944 m->fw_handle = rp->fw_handle;
4945 m->speed = (u8)rp->rport_info.speed;
4946
4947 /*
4948 * queue I/O message to firmware
4949 */
4950 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh);
4951 return BFA_TRUE;
4952 }
4953
4954
4955
4956 /*
4957 * bfa_rport_public
4958 */
4959
4960 /*
4961 * Rport interrupt processing.
4962 */
4963 void
bfa_rport_isr(struct bfa_s * bfa,struct bfi_msg_s * m)4964 bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
4965 {
4966 union bfi_rport_i2h_msg_u msg;
4967 struct bfa_rport_s *rp;
4968
4969 bfa_trc(bfa, m->mhdr.msg_id);
4970
4971 msg.msg = m;
4972
4973 switch (m->mhdr.msg_id) {
4974 case BFI_RPORT_I2H_CREATE_RSP:
4975 rp = BFA_RPORT_FROM_TAG(bfa, msg.create_rsp->bfa_handle);
4976 rp->fw_handle = msg.create_rsp->fw_handle;
4977 rp->qos_attr = msg.create_rsp->qos_attr;
4978 bfa_rport_set_lunmask(bfa, rp);
4979 WARN_ON(msg.create_rsp->status != BFA_STATUS_OK);
4980 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
4981 break;
4982
4983 case BFI_RPORT_I2H_DELETE_RSP:
4984 rp = BFA_RPORT_FROM_TAG(bfa, msg.delete_rsp->bfa_handle);
4985 WARN_ON(msg.delete_rsp->status != BFA_STATUS_OK);
4986 bfa_rport_unset_lunmask(bfa, rp);
4987 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
4988 break;
4989
4990 case BFI_RPORT_I2H_QOS_SCN:
4991 rp = BFA_RPORT_FROM_TAG(bfa, msg.qos_scn_evt->bfa_handle);
4992 rp->event_arg.fw_msg = msg.qos_scn_evt;
4993 bfa_sm_send_event(rp, BFA_RPORT_SM_QOS_SCN);
4994 break;
4995
4996 case BFI_RPORT_I2H_LIP_SCN_ONLINE:
4997 bfa_fcport_update_loop_info(BFA_FCPORT_MOD(bfa),
4998 &msg.lip_scn->loop_info);
4999 bfa_cb_rport_scn_online(bfa);
5000 break;
5001
5002 case BFI_RPORT_I2H_LIP_SCN_OFFLINE:
5003 bfa_cb_rport_scn_offline(bfa);
5004 break;
5005
5006 case BFI_RPORT_I2H_NO_DEV:
5007 rp = BFA_RPORT_FROM_TAG(bfa, msg.lip_scn->bfa_handle);
5008 bfa_cb_rport_scn_no_dev(rp->rport_drv);
5009 break;
5010
5011 default:
5012 bfa_trc(bfa, m->mhdr.msg_id);
5013 WARN_ON(1);
5014 }
5015 }
5016
5017 void
bfa_rport_res_recfg(struct bfa_s * bfa,u16 num_rport_fw)5018 bfa_rport_res_recfg(struct bfa_s *bfa, u16 num_rport_fw)
5019 {
5020 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
5021 struct list_head *qe;
5022 int i;
5023
5024 for (i = 0; i < (mod->num_rports - num_rport_fw); i++) {
5025 bfa_q_deq_tail(&mod->rp_free_q, &qe);
5026 list_add_tail(qe, &mod->rp_unused_q);
5027 }
5028 }
5029
5030 /*
5031 * bfa_rport_api
5032 */
5033
5034 struct bfa_rport_s *
bfa_rport_create(struct bfa_s * bfa,void * rport_drv)5035 bfa_rport_create(struct bfa_s *bfa, void *rport_drv)
5036 {
5037 struct bfa_rport_s *rp;
5038
5039 rp = bfa_rport_alloc(BFA_RPORT_MOD(bfa));
5040
5041 if (rp == NULL)
5042 return NULL;
5043
5044 rp->bfa = bfa;
5045 rp->rport_drv = rport_drv;
5046 memset(&rp->stats, 0, sizeof(rp->stats));
5047
5048 WARN_ON(!bfa_sm_cmp_state(rp, bfa_rport_sm_uninit));
5049 bfa_sm_send_event(rp, BFA_RPORT_SM_CREATE);
5050
5051 return rp;
5052 }
5053
5054 void
bfa_rport_online(struct bfa_rport_s * rport,struct bfa_rport_info_s * rport_info)5055 bfa_rport_online(struct bfa_rport_s *rport, struct bfa_rport_info_s *rport_info)
5056 {
5057 WARN_ON(rport_info->max_frmsz == 0);
5058
5059 /*
5060 * Some JBODs are seen to be not setting PDU size correctly in PLOGI
5061 * responses. Default to minimum size.
5062 */
5063 if (rport_info->max_frmsz == 0) {
5064 bfa_trc(rport->bfa, rport->rport_tag);
5065 rport_info->max_frmsz = FC_MIN_PDUSZ;
5066 }
5067
5068 rport->rport_info = *rport_info;
5069 bfa_sm_send_event(rport, BFA_RPORT_SM_ONLINE);
5070 }
5071
5072 void
bfa_rport_speed(struct bfa_rport_s * rport,enum bfa_port_speed speed)5073 bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed)
5074 {
5075 WARN_ON(speed == 0);
5076 WARN_ON(speed == BFA_PORT_SPEED_AUTO);
5077
5078 if (rport) {
5079 rport->rport_info.speed = speed;
5080 bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
5081 }
5082 }
5083
5084 /* Set Rport LUN Mask */
5085 void
bfa_rport_set_lunmask(struct bfa_s * bfa,struct bfa_rport_s * rp)5086 bfa_rport_set_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp)
5087 {
5088 struct bfa_lps_mod_s *lps_mod = BFA_LPS_MOD(bfa);
5089 wwn_t lp_wwn, rp_wwn;
5090 u8 lp_tag = (u8)rp->rport_info.lp_tag;
5091
5092 rp_wwn = ((struct bfa_fcs_rport_s *)rp->rport_drv)->pwwn;
5093 lp_wwn = (BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag))->pwwn;
5094
5095 BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag)->lun_mask =
5096 rp->lun_mask = BFA_TRUE;
5097 bfa_fcpim_lunmask_rp_update(bfa, lp_wwn, rp_wwn, rp->rport_tag, lp_tag);
5098 }
5099
5100 /* Unset Rport LUN mask */
5101 void
bfa_rport_unset_lunmask(struct bfa_s * bfa,struct bfa_rport_s * rp)5102 bfa_rport_unset_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp)
5103 {
5104 struct bfa_lps_mod_s *lps_mod = BFA_LPS_MOD(bfa);
5105 wwn_t lp_wwn, rp_wwn;
5106
5107 rp_wwn = ((struct bfa_fcs_rport_s *)rp->rport_drv)->pwwn;
5108 lp_wwn = (BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag))->pwwn;
5109
5110 BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag)->lun_mask =
5111 rp->lun_mask = BFA_FALSE;
5112 bfa_fcpim_lunmask_rp_update(bfa, lp_wwn, rp_wwn,
5113 BFA_RPORT_TAG_INVALID, BFA_LP_TAG_INVALID);
5114 }
5115
5116 /*
5117 * SGPG related functions
5118 */
5119
5120 /*
5121 * Compute and return memory needed by FCP(im) module.
5122 */
5123 void
bfa_sgpg_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)5124 bfa_sgpg_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
5125 struct bfa_s *bfa)
5126 {
5127 struct bfa_sgpg_mod_s *sgpg_mod = BFA_SGPG_MOD(bfa);
5128 struct bfa_mem_kva_s *sgpg_kva = BFA_MEM_SGPG_KVA(bfa);
5129 struct bfa_mem_dma_s *seg_ptr;
5130 u16 nsegs, idx, per_seg_sgpg, num_sgpg;
5131 u32 sgpg_sz = sizeof(struct bfi_sgpg_s);
5132
5133 if (cfg->drvcfg.num_sgpgs < BFA_SGPG_MIN)
5134 cfg->drvcfg.num_sgpgs = BFA_SGPG_MIN;
5135 else if (cfg->drvcfg.num_sgpgs > BFA_SGPG_MAX)
5136 cfg->drvcfg.num_sgpgs = BFA_SGPG_MAX;
5137
5138 num_sgpg = cfg->drvcfg.num_sgpgs;
5139
5140 nsegs = BFI_MEM_DMA_NSEGS(num_sgpg, sgpg_sz);
5141 per_seg_sgpg = BFI_MEM_NREQS_SEG(sgpg_sz);
5142
5143 bfa_mem_dma_seg_iter(sgpg_mod, seg_ptr, nsegs, idx) {
5144 if (num_sgpg >= per_seg_sgpg) {
5145 num_sgpg -= per_seg_sgpg;
5146 bfa_mem_dma_setup(minfo, seg_ptr,
5147 per_seg_sgpg * sgpg_sz);
5148 } else
5149 bfa_mem_dma_setup(minfo, seg_ptr,
5150 num_sgpg * sgpg_sz);
5151 }
5152
5153 /* kva memory */
5154 bfa_mem_kva_setup(minfo, sgpg_kva,
5155 cfg->drvcfg.num_sgpgs * sizeof(struct bfa_sgpg_s));
5156 }
5157
5158 void
bfa_sgpg_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)5159 bfa_sgpg_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
5160 struct bfa_pcidev_s *pcidev)
5161 {
5162 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5163 struct bfa_sgpg_s *hsgpg;
5164 struct bfi_sgpg_s *sgpg;
5165 u64 align_len;
5166 struct bfa_mem_dma_s *seg_ptr;
5167 u32 sgpg_sz = sizeof(struct bfi_sgpg_s);
5168 u16 i, idx, nsegs, per_seg_sgpg, num_sgpg;
5169
5170 union {
5171 u64 pa;
5172 union bfi_addr_u addr;
5173 } sgpg_pa, sgpg_pa_tmp;
5174
5175 INIT_LIST_HEAD(&mod->sgpg_q);
5176 INIT_LIST_HEAD(&mod->sgpg_wait_q);
5177
5178 bfa_trc(bfa, cfg->drvcfg.num_sgpgs);
5179
5180 mod->free_sgpgs = mod->num_sgpgs = cfg->drvcfg.num_sgpgs;
5181
5182 num_sgpg = cfg->drvcfg.num_sgpgs;
5183 nsegs = BFI_MEM_DMA_NSEGS(num_sgpg, sgpg_sz);
5184
5185 /* dma/kva mem claim */
5186 hsgpg = (struct bfa_sgpg_s *) bfa_mem_kva_curp(mod);
5187
5188 bfa_mem_dma_seg_iter(mod, seg_ptr, nsegs, idx) {
5189
5190 if (!bfa_mem_dma_virt(seg_ptr))
5191 break;
5192
5193 align_len = BFA_SGPG_ROUNDUP(bfa_mem_dma_phys(seg_ptr)) -
5194 bfa_mem_dma_phys(seg_ptr);
5195
5196 sgpg = (struct bfi_sgpg_s *)
5197 (((u8 *) bfa_mem_dma_virt(seg_ptr)) + align_len);
5198 sgpg_pa.pa = bfa_mem_dma_phys(seg_ptr) + align_len;
5199 WARN_ON(sgpg_pa.pa & (sgpg_sz - 1));
5200
5201 per_seg_sgpg = (seg_ptr->mem_len - (u32)align_len) / sgpg_sz;
5202
5203 for (i = 0; num_sgpg > 0 && i < per_seg_sgpg; i++, num_sgpg--) {
5204 memset(hsgpg, 0, sizeof(*hsgpg));
5205 memset(sgpg, 0, sizeof(*sgpg));
5206
5207 hsgpg->sgpg = sgpg;
5208 sgpg_pa_tmp.pa = bfa_sgaddr_le(sgpg_pa.pa);
5209 hsgpg->sgpg_pa = sgpg_pa_tmp.addr;
5210 list_add_tail(&hsgpg->qe, &mod->sgpg_q);
5211
5212 sgpg++;
5213 hsgpg++;
5214 sgpg_pa.pa += sgpg_sz;
5215 }
5216 }
5217
5218 bfa_mem_kva_curp(mod) = (u8 *) hsgpg;
5219 }
5220
5221 bfa_status_t
bfa_sgpg_malloc(struct bfa_s * bfa,struct list_head * sgpg_q,int nsgpgs)5222 bfa_sgpg_malloc(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpgs)
5223 {
5224 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5225 struct bfa_sgpg_s *hsgpg;
5226 int i;
5227
5228 if (mod->free_sgpgs < nsgpgs)
5229 return BFA_STATUS_ENOMEM;
5230
5231 for (i = 0; i < nsgpgs; i++) {
5232 bfa_q_deq(&mod->sgpg_q, &hsgpg);
5233 WARN_ON(!hsgpg);
5234 list_add_tail(&hsgpg->qe, sgpg_q);
5235 }
5236
5237 mod->free_sgpgs -= nsgpgs;
5238 return BFA_STATUS_OK;
5239 }
5240
5241 void
bfa_sgpg_mfree(struct bfa_s * bfa,struct list_head * sgpg_q,int nsgpg)5242 bfa_sgpg_mfree(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpg)
5243 {
5244 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5245 struct bfa_sgpg_wqe_s *wqe;
5246
5247 mod->free_sgpgs += nsgpg;
5248 WARN_ON(mod->free_sgpgs > mod->num_sgpgs);
5249
5250 list_splice_tail_init(sgpg_q, &mod->sgpg_q);
5251
5252 if (list_empty(&mod->sgpg_wait_q))
5253 return;
5254
5255 /*
5256 * satisfy as many waiting requests as possible
5257 */
5258 do {
5259 wqe = bfa_q_first(&mod->sgpg_wait_q);
5260 if (mod->free_sgpgs < wqe->nsgpg)
5261 nsgpg = mod->free_sgpgs;
5262 else
5263 nsgpg = wqe->nsgpg;
5264 bfa_sgpg_malloc(bfa, &wqe->sgpg_q, nsgpg);
5265 wqe->nsgpg -= nsgpg;
5266 if (wqe->nsgpg == 0) {
5267 list_del(&wqe->qe);
5268 wqe->cbfn(wqe->cbarg);
5269 }
5270 } while (mod->free_sgpgs && !list_empty(&mod->sgpg_wait_q));
5271 }
5272
5273 void
bfa_sgpg_wait(struct bfa_s * bfa,struct bfa_sgpg_wqe_s * wqe,int nsgpg)5274 bfa_sgpg_wait(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe, int nsgpg)
5275 {
5276 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5277
5278 WARN_ON(nsgpg <= 0);
5279 WARN_ON(nsgpg <= mod->free_sgpgs);
5280
5281 wqe->nsgpg_total = wqe->nsgpg = nsgpg;
5282
5283 /*
5284 * allocate any left to this one first
5285 */
5286 if (mod->free_sgpgs) {
5287 /*
5288 * no one else is waiting for SGPG
5289 */
5290 WARN_ON(!list_empty(&mod->sgpg_wait_q));
5291 list_splice_tail_init(&mod->sgpg_q, &wqe->sgpg_q);
5292 wqe->nsgpg -= mod->free_sgpgs;
5293 mod->free_sgpgs = 0;
5294 }
5295
5296 list_add_tail(&wqe->qe, &mod->sgpg_wait_q);
5297 }
5298
5299 void
bfa_sgpg_wcancel(struct bfa_s * bfa,struct bfa_sgpg_wqe_s * wqe)5300 bfa_sgpg_wcancel(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe)
5301 {
5302 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
5303
5304 WARN_ON(!bfa_q_is_on_q(&mod->sgpg_wait_q, wqe));
5305 list_del(&wqe->qe);
5306
5307 if (wqe->nsgpg_total != wqe->nsgpg)
5308 bfa_sgpg_mfree(bfa, &wqe->sgpg_q,
5309 wqe->nsgpg_total - wqe->nsgpg);
5310 }
5311
5312 void
bfa_sgpg_winit(struct bfa_sgpg_wqe_s * wqe,void (* cbfn)(void * cbarg),void * cbarg)5313 bfa_sgpg_winit(struct bfa_sgpg_wqe_s *wqe, void (*cbfn) (void *cbarg),
5314 void *cbarg)
5315 {
5316 INIT_LIST_HEAD(&wqe->sgpg_q);
5317 wqe->cbfn = cbfn;
5318 wqe->cbarg = cbarg;
5319 }
5320
5321 /*
5322 * UF related functions
5323 */
5324 /*
5325 *****************************************************************************
5326 * Internal functions
5327 *****************************************************************************
5328 */
5329 static void
__bfa_cb_uf_recv(void * cbarg,bfa_boolean_t complete)5330 __bfa_cb_uf_recv(void *cbarg, bfa_boolean_t complete)
5331 {
5332 struct bfa_uf_s *uf = cbarg;
5333 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(uf->bfa);
5334
5335 if (complete)
5336 ufm->ufrecv(ufm->cbarg, uf);
5337 }
5338
5339 static void
claim_uf_post_msgs(struct bfa_uf_mod_s * ufm)5340 claim_uf_post_msgs(struct bfa_uf_mod_s *ufm)
5341 {
5342 struct bfi_uf_buf_post_s *uf_bp_msg;
5343 u16 i;
5344 u16 buf_len;
5345
5346 ufm->uf_buf_posts = (struct bfi_uf_buf_post_s *) bfa_mem_kva_curp(ufm);
5347 uf_bp_msg = ufm->uf_buf_posts;
5348
5349 for (i = 0, uf_bp_msg = ufm->uf_buf_posts; i < ufm->num_ufs;
5350 i++, uf_bp_msg++) {
5351 memset(uf_bp_msg, 0, sizeof(struct bfi_uf_buf_post_s));
5352
5353 uf_bp_msg->buf_tag = i;
5354 buf_len = sizeof(struct bfa_uf_buf_s);
5355 uf_bp_msg->buf_len = cpu_to_be16(buf_len);
5356 bfi_h2i_set(uf_bp_msg->mh, BFI_MC_UF, BFI_UF_H2I_BUF_POST,
5357 bfa_fn_lpu(ufm->bfa));
5358 bfa_alen_set(&uf_bp_msg->alen, buf_len, ufm_pbs_pa(ufm, i));
5359 }
5360
5361 /*
5362 * advance pointer beyond consumed memory
5363 */
5364 bfa_mem_kva_curp(ufm) = (u8 *) uf_bp_msg;
5365 }
5366
5367 static void
claim_ufs(struct bfa_uf_mod_s * ufm)5368 claim_ufs(struct bfa_uf_mod_s *ufm)
5369 {
5370 u16 i;
5371 struct bfa_uf_s *uf;
5372
5373 /*
5374 * Claim block of memory for UF list
5375 */
5376 ufm->uf_list = (struct bfa_uf_s *) bfa_mem_kva_curp(ufm);
5377
5378 /*
5379 * Initialize UFs and queue it in UF free queue
5380 */
5381 for (i = 0, uf = ufm->uf_list; i < ufm->num_ufs; i++, uf++) {
5382 memset(uf, 0, sizeof(struct bfa_uf_s));
5383 uf->bfa = ufm->bfa;
5384 uf->uf_tag = i;
5385 uf->pb_len = BFA_PER_UF_DMA_SZ;
5386 uf->buf_kva = bfa_mem_get_dmabuf_kva(ufm, i, BFA_PER_UF_DMA_SZ);
5387 uf->buf_pa = ufm_pbs_pa(ufm, i);
5388 list_add_tail(&uf->qe, &ufm->uf_free_q);
5389 }
5390
5391 /*
5392 * advance memory pointer
5393 */
5394 bfa_mem_kva_curp(ufm) = (u8 *) uf;
5395 }
5396
5397 static void
uf_mem_claim(struct bfa_uf_mod_s * ufm)5398 uf_mem_claim(struct bfa_uf_mod_s *ufm)
5399 {
5400 claim_ufs(ufm);
5401 claim_uf_post_msgs(ufm);
5402 }
5403
5404 void
bfa_uf_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)5405 bfa_uf_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
5406 struct bfa_s *bfa)
5407 {
5408 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5409 struct bfa_mem_kva_s *uf_kva = BFA_MEM_UF_KVA(bfa);
5410 u32 num_ufs = cfg->fwcfg.num_uf_bufs;
5411 struct bfa_mem_dma_s *seg_ptr;
5412 u16 nsegs, idx, per_seg_uf = 0;
5413
5414 nsegs = BFI_MEM_DMA_NSEGS(num_ufs, BFA_PER_UF_DMA_SZ);
5415 per_seg_uf = BFI_MEM_NREQS_SEG(BFA_PER_UF_DMA_SZ);
5416
5417 bfa_mem_dma_seg_iter(ufm, seg_ptr, nsegs, idx) {
5418 if (num_ufs >= per_seg_uf) {
5419 num_ufs -= per_seg_uf;
5420 bfa_mem_dma_setup(minfo, seg_ptr,
5421 per_seg_uf * BFA_PER_UF_DMA_SZ);
5422 } else
5423 bfa_mem_dma_setup(minfo, seg_ptr,
5424 num_ufs * BFA_PER_UF_DMA_SZ);
5425 }
5426
5427 /* kva memory */
5428 bfa_mem_kva_setup(minfo, uf_kva, cfg->fwcfg.num_uf_bufs *
5429 (sizeof(struct bfa_uf_s) + sizeof(struct bfi_uf_buf_post_s)));
5430 }
5431
5432 void
bfa_uf_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)5433 bfa_uf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
5434 struct bfa_pcidev_s *pcidev)
5435 {
5436 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5437
5438 ufm->bfa = bfa;
5439 ufm->num_ufs = cfg->fwcfg.num_uf_bufs;
5440 INIT_LIST_HEAD(&ufm->uf_free_q);
5441 INIT_LIST_HEAD(&ufm->uf_posted_q);
5442 INIT_LIST_HEAD(&ufm->uf_unused_q);
5443
5444 uf_mem_claim(ufm);
5445 }
5446
5447 static struct bfa_uf_s *
bfa_uf_get(struct bfa_uf_mod_s * uf_mod)5448 bfa_uf_get(struct bfa_uf_mod_s *uf_mod)
5449 {
5450 struct bfa_uf_s *uf;
5451
5452 bfa_q_deq(&uf_mod->uf_free_q, &uf);
5453 return uf;
5454 }
5455
5456 static void
bfa_uf_put(struct bfa_uf_mod_s * uf_mod,struct bfa_uf_s * uf)5457 bfa_uf_put(struct bfa_uf_mod_s *uf_mod, struct bfa_uf_s *uf)
5458 {
5459 list_add_tail(&uf->qe, &uf_mod->uf_free_q);
5460 }
5461
5462 static bfa_status_t
bfa_uf_post(struct bfa_uf_mod_s * ufm,struct bfa_uf_s * uf)5463 bfa_uf_post(struct bfa_uf_mod_s *ufm, struct bfa_uf_s *uf)
5464 {
5465 struct bfi_uf_buf_post_s *uf_post_msg;
5466
5467 uf_post_msg = bfa_reqq_next(ufm->bfa, BFA_REQQ_FCXP);
5468 if (!uf_post_msg)
5469 return BFA_STATUS_FAILED;
5470
5471 memcpy(uf_post_msg, &ufm->uf_buf_posts[uf->uf_tag],
5472 sizeof(struct bfi_uf_buf_post_s));
5473 bfa_reqq_produce(ufm->bfa, BFA_REQQ_FCXP, uf_post_msg->mh);
5474
5475 bfa_trc(ufm->bfa, uf->uf_tag);
5476
5477 list_add_tail(&uf->qe, &ufm->uf_posted_q);
5478 return BFA_STATUS_OK;
5479 }
5480
5481 static void
bfa_uf_post_all(struct bfa_uf_mod_s * uf_mod)5482 bfa_uf_post_all(struct bfa_uf_mod_s *uf_mod)
5483 {
5484 struct bfa_uf_s *uf;
5485
5486 while ((uf = bfa_uf_get(uf_mod)) != NULL) {
5487 if (bfa_uf_post(uf_mod, uf) != BFA_STATUS_OK)
5488 break;
5489 }
5490 }
5491
5492 static void
uf_recv(struct bfa_s * bfa,struct bfi_uf_frm_rcvd_s * m)5493 uf_recv(struct bfa_s *bfa, struct bfi_uf_frm_rcvd_s *m)
5494 {
5495 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5496 u16 uf_tag = m->buf_tag;
5497 struct bfa_uf_s *uf = &ufm->uf_list[uf_tag];
5498 struct bfa_uf_buf_s *uf_buf;
5499 uint8_t *buf;
5500
5501 uf_buf = (struct bfa_uf_buf_s *)
5502 bfa_mem_get_dmabuf_kva(ufm, uf_tag, uf->pb_len);
5503 buf = &uf_buf->d[0];
5504
5505 m->frm_len = be16_to_cpu(m->frm_len);
5506 m->xfr_len = be16_to_cpu(m->xfr_len);
5507
5508 list_del(&uf->qe); /* dequeue from posted queue */
5509
5510 uf->data_ptr = buf;
5511 uf->data_len = m->xfr_len;
5512
5513 WARN_ON(uf->data_len < sizeof(struct fchs_s));
5514
5515 if (uf->data_len == sizeof(struct fchs_s)) {
5516 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_UF, BFA_PL_EID_RX,
5517 uf->data_len, (struct fchs_s *)buf);
5518 } else {
5519 u32 pld_w0 = *((u32 *) (buf + sizeof(struct fchs_s)));
5520 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_UF,
5521 BFA_PL_EID_RX, uf->data_len,
5522 (struct fchs_s *)buf, pld_w0);
5523 }
5524
5525 if (bfa->fcs)
5526 __bfa_cb_uf_recv(uf, BFA_TRUE);
5527 else
5528 bfa_cb_queue(bfa, &uf->hcb_qe, __bfa_cb_uf_recv, uf);
5529 }
5530
5531 void
bfa_uf_iocdisable(struct bfa_s * bfa)5532 bfa_uf_iocdisable(struct bfa_s *bfa)
5533 {
5534 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5535 struct bfa_uf_s *uf;
5536 struct list_head *qe, *qen;
5537
5538 /* Enqueue unused uf resources to free_q */
5539 list_splice_tail_init(&ufm->uf_unused_q, &ufm->uf_free_q);
5540
5541 list_for_each_safe(qe, qen, &ufm->uf_posted_q) {
5542 uf = (struct bfa_uf_s *) qe;
5543 list_del(&uf->qe);
5544 bfa_uf_put(ufm, uf);
5545 }
5546 }
5547
5548 void
bfa_uf_start(struct bfa_s * bfa)5549 bfa_uf_start(struct bfa_s *bfa)
5550 {
5551 bfa_uf_post_all(BFA_UF_MOD(bfa));
5552 }
5553
5554 /*
5555 * Register handler for all unsolicted receive frames.
5556 *
5557 * @param[in] bfa BFA instance
5558 * @param[in] ufrecv receive handler function
5559 * @param[in] cbarg receive handler arg
5560 */
5561 void
bfa_uf_recv_register(struct bfa_s * bfa,bfa_cb_uf_recv_t ufrecv,void * cbarg)5562 bfa_uf_recv_register(struct bfa_s *bfa, bfa_cb_uf_recv_t ufrecv, void *cbarg)
5563 {
5564 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5565
5566 ufm->ufrecv = ufrecv;
5567 ufm->cbarg = cbarg;
5568 }
5569
5570 /*
5571 * Free an unsolicited frame back to BFA.
5572 *
5573 * @param[in] uf unsolicited frame to be freed
5574 *
5575 * @return None
5576 */
5577 void
bfa_uf_free(struct bfa_uf_s * uf)5578 bfa_uf_free(struct bfa_uf_s *uf)
5579 {
5580 bfa_uf_put(BFA_UF_MOD(uf->bfa), uf);
5581 bfa_uf_post_all(BFA_UF_MOD(uf->bfa));
5582 }
5583
5584
5585
5586 /*
5587 * uf_pub BFA uf module public functions
5588 */
5589 void
bfa_uf_isr(struct bfa_s * bfa,struct bfi_msg_s * msg)5590 bfa_uf_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
5591 {
5592 bfa_trc(bfa, msg->mhdr.msg_id);
5593
5594 switch (msg->mhdr.msg_id) {
5595 case BFI_UF_I2H_FRM_RCVD:
5596 uf_recv(bfa, (struct bfi_uf_frm_rcvd_s *) msg);
5597 break;
5598
5599 default:
5600 bfa_trc(bfa, msg->mhdr.msg_id);
5601 WARN_ON(1);
5602 }
5603 }
5604
5605 void
bfa_uf_res_recfg(struct bfa_s * bfa,u16 num_uf_fw)5606 bfa_uf_res_recfg(struct bfa_s *bfa, u16 num_uf_fw)
5607 {
5608 struct bfa_uf_mod_s *mod = BFA_UF_MOD(bfa);
5609 struct list_head *qe;
5610 int i;
5611
5612 for (i = 0; i < (mod->num_ufs - num_uf_fw); i++) {
5613 bfa_q_deq_tail(&mod->uf_free_q, &qe);
5614 list_add_tail(qe, &mod->uf_unused_q);
5615 }
5616 }
5617
5618 /*
5619 * Dport forward declaration
5620 */
5621
5622 enum bfa_dport_test_state_e {
5623 BFA_DPORT_ST_DISABLED = 0, /*!< dport is disabled */
5624 BFA_DPORT_ST_INP = 1, /*!< test in progress */
5625 BFA_DPORT_ST_COMP = 2, /*!< test complete successfully */
5626 BFA_DPORT_ST_NO_SFP = 3, /*!< sfp is not present */
5627 BFA_DPORT_ST_NOTSTART = 4, /*!< test not start dport is enabled */
5628 };
5629
5630 static void bfa_dport_sm_disabled(struct bfa_dport_s *dport,
5631 enum bfa_dport_sm_event event);
5632 static void bfa_dport_sm_enabling_qwait(struct bfa_dport_s *dport,
5633 enum bfa_dport_sm_event event);
5634 static void bfa_dport_sm_enabling(struct bfa_dport_s *dport,
5635 enum bfa_dport_sm_event event);
5636 static void bfa_dport_sm_enabled(struct bfa_dport_s *dport,
5637 enum bfa_dport_sm_event event);
5638 static void bfa_dport_sm_disabling_qwait(struct bfa_dport_s *dport,
5639 enum bfa_dport_sm_event event);
5640 static void bfa_dport_sm_disabling(struct bfa_dport_s *dport,
5641 enum bfa_dport_sm_event event);
5642 static void bfa_dport_sm_starting_qwait(struct bfa_dport_s *dport,
5643 enum bfa_dport_sm_event event);
5644 static void bfa_dport_sm_starting(struct bfa_dport_s *dport,
5645 enum bfa_dport_sm_event event);
5646 static void bfa_dport_sm_dynamic_disabling(struct bfa_dport_s *dport,
5647 enum bfa_dport_sm_event event);
5648 static void bfa_dport_sm_dynamic_disabling_qwait(struct bfa_dport_s *dport,
5649 enum bfa_dport_sm_event event);
5650 static void bfa_dport_qresume(void *cbarg);
5651 static void bfa_dport_req_comp(struct bfa_dport_s *dport,
5652 struct bfi_diag_dport_rsp_s *msg);
5653 static void bfa_dport_scn(struct bfa_dport_s *dport,
5654 struct bfi_diag_dport_scn_s *msg);
5655
5656 /*
5657 * BFA fcdiag module
5658 */
5659 #define BFA_DIAG_QTEST_TOV 1000 /* msec */
5660
5661 /*
5662 * Set port status to busy
5663 */
5664 static void
bfa_fcdiag_set_busy_status(struct bfa_fcdiag_s * fcdiag)5665 bfa_fcdiag_set_busy_status(struct bfa_fcdiag_s *fcdiag)
5666 {
5667 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(fcdiag->bfa);
5668
5669 if (fcdiag->lb.lock)
5670 fcport->diag_busy = BFA_TRUE;
5671 else
5672 fcport->diag_busy = BFA_FALSE;
5673 }
5674
5675 void
bfa_fcdiag_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)5676 bfa_fcdiag_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
5677 struct bfa_pcidev_s *pcidev)
5678 {
5679 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5680 struct bfa_dport_s *dport = &fcdiag->dport;
5681
5682 fcdiag->bfa = bfa;
5683 fcdiag->trcmod = bfa->trcmod;
5684 /* The common DIAG attach bfa_diag_attach() will do all memory claim */
5685 dport->bfa = bfa;
5686 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
5687 bfa_reqq_winit(&dport->reqq_wait, bfa_dport_qresume, dport);
5688 dport->cbfn = NULL;
5689 dport->cbarg = NULL;
5690 dport->test_state = BFA_DPORT_ST_DISABLED;
5691 memset(&dport->result, 0, sizeof(struct bfa_diag_dport_result_s));
5692 }
5693
5694 void
bfa_fcdiag_iocdisable(struct bfa_s * bfa)5695 bfa_fcdiag_iocdisable(struct bfa_s *bfa)
5696 {
5697 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5698 struct bfa_dport_s *dport = &fcdiag->dport;
5699
5700 bfa_trc(fcdiag, fcdiag->lb.lock);
5701 if (fcdiag->lb.lock) {
5702 fcdiag->lb.status = BFA_STATUS_IOC_FAILURE;
5703 fcdiag->lb.cbfn(fcdiag->lb.cbarg, fcdiag->lb.status);
5704 fcdiag->lb.lock = 0;
5705 bfa_fcdiag_set_busy_status(fcdiag);
5706 }
5707
5708 bfa_sm_send_event(dport, BFA_DPORT_SM_HWFAIL);
5709 }
5710
5711 static void
bfa_fcdiag_queuetest_timeout(void * cbarg)5712 bfa_fcdiag_queuetest_timeout(void *cbarg)
5713 {
5714 struct bfa_fcdiag_s *fcdiag = cbarg;
5715 struct bfa_diag_qtest_result_s *res = fcdiag->qtest.result;
5716
5717 bfa_trc(fcdiag, fcdiag->qtest.all);
5718 bfa_trc(fcdiag, fcdiag->qtest.count);
5719
5720 fcdiag->qtest.timer_active = 0;
5721
5722 res->status = BFA_STATUS_ETIMER;
5723 res->count = QTEST_CNT_DEFAULT - fcdiag->qtest.count;
5724 if (fcdiag->qtest.all)
5725 res->queue = fcdiag->qtest.all;
5726
5727 bfa_trc(fcdiag, BFA_STATUS_ETIMER);
5728 fcdiag->qtest.status = BFA_STATUS_ETIMER;
5729 fcdiag->qtest.cbfn(fcdiag->qtest.cbarg, fcdiag->qtest.status);
5730 fcdiag->qtest.lock = 0;
5731 }
5732
5733 static bfa_status_t
bfa_fcdiag_queuetest_send(struct bfa_fcdiag_s * fcdiag)5734 bfa_fcdiag_queuetest_send(struct bfa_fcdiag_s *fcdiag)
5735 {
5736 u32 i;
5737 struct bfi_diag_qtest_req_s *req;
5738
5739 req = bfa_reqq_next(fcdiag->bfa, fcdiag->qtest.queue);
5740 if (!req)
5741 return BFA_STATUS_DEVBUSY;
5742
5743 /* build host command */
5744 bfi_h2i_set(req->mh, BFI_MC_DIAG, BFI_DIAG_H2I_QTEST,
5745 bfa_fn_lpu(fcdiag->bfa));
5746
5747 for (i = 0; i < BFI_LMSG_PL_WSZ; i++)
5748 req->data[i] = QTEST_PAT_DEFAULT;
5749
5750 bfa_trc(fcdiag, fcdiag->qtest.queue);
5751 /* ring door bell */
5752 bfa_reqq_produce(fcdiag->bfa, fcdiag->qtest.queue, req->mh);
5753 return BFA_STATUS_OK;
5754 }
5755
5756 static void
bfa_fcdiag_queuetest_comp(struct bfa_fcdiag_s * fcdiag,bfi_diag_qtest_rsp_t * rsp)5757 bfa_fcdiag_queuetest_comp(struct bfa_fcdiag_s *fcdiag,
5758 bfi_diag_qtest_rsp_t *rsp)
5759 {
5760 struct bfa_diag_qtest_result_s *res = fcdiag->qtest.result;
5761 bfa_status_t status = BFA_STATUS_OK;
5762 int i;
5763
5764 /* Check timer, should still be active */
5765 if (!fcdiag->qtest.timer_active) {
5766 bfa_trc(fcdiag, fcdiag->qtest.timer_active);
5767 return;
5768 }
5769
5770 /* update count */
5771 fcdiag->qtest.count--;
5772
5773 /* Check result */
5774 for (i = 0; i < BFI_LMSG_PL_WSZ; i++) {
5775 if (rsp->data[i] != ~(QTEST_PAT_DEFAULT)) {
5776 res->status = BFA_STATUS_DATACORRUPTED;
5777 break;
5778 }
5779 }
5780
5781 if (res->status == BFA_STATUS_OK) {
5782 if (fcdiag->qtest.count > 0) {
5783 status = bfa_fcdiag_queuetest_send(fcdiag);
5784 if (status == BFA_STATUS_OK)
5785 return;
5786 else
5787 res->status = status;
5788 } else if (fcdiag->qtest.all > 0 &&
5789 fcdiag->qtest.queue < (BFI_IOC_MAX_CQS - 1)) {
5790 fcdiag->qtest.count = QTEST_CNT_DEFAULT;
5791 fcdiag->qtest.queue++;
5792 status = bfa_fcdiag_queuetest_send(fcdiag);
5793 if (status == BFA_STATUS_OK)
5794 return;
5795 else
5796 res->status = status;
5797 }
5798 }
5799
5800 /* Stop timer when we comp all queue */
5801 if (fcdiag->qtest.timer_active) {
5802 bfa_timer_stop(&fcdiag->qtest.timer);
5803 fcdiag->qtest.timer_active = 0;
5804 }
5805 res->queue = fcdiag->qtest.queue;
5806 res->count = QTEST_CNT_DEFAULT - fcdiag->qtest.count;
5807 bfa_trc(fcdiag, res->count);
5808 bfa_trc(fcdiag, res->status);
5809 fcdiag->qtest.status = res->status;
5810 fcdiag->qtest.cbfn(fcdiag->qtest.cbarg, fcdiag->qtest.status);
5811 fcdiag->qtest.lock = 0;
5812 }
5813
5814 static void
bfa_fcdiag_loopback_comp(struct bfa_fcdiag_s * fcdiag,struct bfi_diag_lb_rsp_s * rsp)5815 bfa_fcdiag_loopback_comp(struct bfa_fcdiag_s *fcdiag,
5816 struct bfi_diag_lb_rsp_s *rsp)
5817 {
5818 struct bfa_diag_loopback_result_s *res = fcdiag->lb.result;
5819
5820 res->numtxmfrm = be32_to_cpu(rsp->res.numtxmfrm);
5821 res->numosffrm = be32_to_cpu(rsp->res.numosffrm);
5822 res->numrcvfrm = be32_to_cpu(rsp->res.numrcvfrm);
5823 res->badfrminf = be32_to_cpu(rsp->res.badfrminf);
5824 res->badfrmnum = be32_to_cpu(rsp->res.badfrmnum);
5825 res->status = rsp->res.status;
5826 fcdiag->lb.status = rsp->res.status;
5827 bfa_trc(fcdiag, fcdiag->lb.status);
5828 fcdiag->lb.cbfn(fcdiag->lb.cbarg, fcdiag->lb.status);
5829 fcdiag->lb.lock = 0;
5830 bfa_fcdiag_set_busy_status(fcdiag);
5831 }
5832
5833 static bfa_status_t
bfa_fcdiag_loopback_send(struct bfa_fcdiag_s * fcdiag,struct bfa_diag_loopback_s * loopback)5834 bfa_fcdiag_loopback_send(struct bfa_fcdiag_s *fcdiag,
5835 struct bfa_diag_loopback_s *loopback)
5836 {
5837 struct bfi_diag_lb_req_s *lb_req;
5838
5839 lb_req = bfa_reqq_next(fcdiag->bfa, BFA_REQQ_DIAG);
5840 if (!lb_req)
5841 return BFA_STATUS_DEVBUSY;
5842
5843 /* build host command */
5844 bfi_h2i_set(lb_req->mh, BFI_MC_DIAG, BFI_DIAG_H2I_LOOPBACK,
5845 bfa_fn_lpu(fcdiag->bfa));
5846
5847 lb_req->lb_mode = loopback->lb_mode;
5848 lb_req->speed = loopback->speed;
5849 lb_req->loopcnt = loopback->loopcnt;
5850 lb_req->pattern = loopback->pattern;
5851
5852 /* ring door bell */
5853 bfa_reqq_produce(fcdiag->bfa, BFA_REQQ_DIAG, lb_req->mh);
5854
5855 bfa_trc(fcdiag, loopback->lb_mode);
5856 bfa_trc(fcdiag, loopback->speed);
5857 bfa_trc(fcdiag, loopback->loopcnt);
5858 bfa_trc(fcdiag, loopback->pattern);
5859 return BFA_STATUS_OK;
5860 }
5861
5862 /*
5863 * cpe/rme intr handler
5864 */
5865 void
bfa_fcdiag_intr(struct bfa_s * bfa,struct bfi_msg_s * msg)5866 bfa_fcdiag_intr(struct bfa_s *bfa, struct bfi_msg_s *msg)
5867 {
5868 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5869
5870 switch (msg->mhdr.msg_id) {
5871 case BFI_DIAG_I2H_LOOPBACK:
5872 bfa_fcdiag_loopback_comp(fcdiag,
5873 (struct bfi_diag_lb_rsp_s *) msg);
5874 break;
5875 case BFI_DIAG_I2H_QTEST:
5876 bfa_fcdiag_queuetest_comp(fcdiag, (bfi_diag_qtest_rsp_t *)msg);
5877 break;
5878 case BFI_DIAG_I2H_DPORT:
5879 bfa_dport_req_comp(&fcdiag->dport,
5880 (struct bfi_diag_dport_rsp_s *)msg);
5881 break;
5882 case BFI_DIAG_I2H_DPORT_SCN:
5883 bfa_dport_scn(&fcdiag->dport,
5884 (struct bfi_diag_dport_scn_s *)msg);
5885 break;
5886 default:
5887 bfa_trc(fcdiag, msg->mhdr.msg_id);
5888 WARN_ON(1);
5889 }
5890 }
5891
5892 /*
5893 * Loopback test
5894 *
5895 * @param[in] *bfa - bfa data struct
5896 * @param[in] opmode - port operation mode
5897 * @param[in] speed - port speed
5898 * @param[in] lpcnt - loop count
5899 * @param[in] pat - pattern to build packet
5900 * @param[in] *result - pt to bfa_diag_loopback_result_t data struct
5901 * @param[in] cbfn - callback function
5902 * @param[in] cbarg - callback functioin arg
5903 *
5904 * @param[out]
5905 */
5906 bfa_status_t
bfa_fcdiag_loopback(struct bfa_s * bfa,enum bfa_port_opmode opmode,enum bfa_port_speed speed,u32 lpcnt,u32 pat,struct bfa_diag_loopback_result_s * result,bfa_cb_diag_t cbfn,void * cbarg)5907 bfa_fcdiag_loopback(struct bfa_s *bfa, enum bfa_port_opmode opmode,
5908 enum bfa_port_speed speed, u32 lpcnt, u32 pat,
5909 struct bfa_diag_loopback_result_s *result, bfa_cb_diag_t cbfn,
5910 void *cbarg)
5911 {
5912 struct bfa_diag_loopback_s loopback;
5913 struct bfa_port_attr_s attr;
5914 bfa_status_t status;
5915 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5916
5917 if (!bfa_iocfc_is_operational(bfa))
5918 return BFA_STATUS_IOC_NON_OP;
5919
5920 /* if port is PBC disabled, return error */
5921 if (bfa_fcport_is_pbcdisabled(bfa)) {
5922 bfa_trc(fcdiag, BFA_STATUS_PBC);
5923 return BFA_STATUS_PBC;
5924 }
5925
5926 if (bfa_fcport_is_disabled(bfa) == BFA_FALSE) {
5927 bfa_trc(fcdiag, opmode);
5928 return BFA_STATUS_PORT_NOT_DISABLED;
5929 }
5930
5931 /*
5932 * Check if input speed is supported by the port mode
5933 */
5934 if (bfa_ioc_get_type(&bfa->ioc) == BFA_IOC_TYPE_FC) {
5935 if (!(speed == BFA_PORT_SPEED_1GBPS ||
5936 speed == BFA_PORT_SPEED_2GBPS ||
5937 speed == BFA_PORT_SPEED_4GBPS ||
5938 speed == BFA_PORT_SPEED_8GBPS ||
5939 speed == BFA_PORT_SPEED_16GBPS ||
5940 speed == BFA_PORT_SPEED_AUTO)) {
5941 bfa_trc(fcdiag, speed);
5942 return BFA_STATUS_UNSUPP_SPEED;
5943 }
5944 bfa_fcport_get_attr(bfa, &attr);
5945 bfa_trc(fcdiag, attr.speed_supported);
5946 if (speed > attr.speed_supported)
5947 return BFA_STATUS_UNSUPP_SPEED;
5948 } else {
5949 if (speed != BFA_PORT_SPEED_10GBPS) {
5950 bfa_trc(fcdiag, speed);
5951 return BFA_STATUS_UNSUPP_SPEED;
5952 }
5953 }
5954
5955 /*
5956 * For CT2, 1G is not supported
5957 */
5958 if ((speed == BFA_PORT_SPEED_1GBPS) &&
5959 (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id))) {
5960 bfa_trc(fcdiag, speed);
5961 return BFA_STATUS_UNSUPP_SPEED;
5962 }
5963
5964 /* For Mezz card, port speed entered needs to be checked */
5965 if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type)) {
5966 if (bfa_ioc_get_type(&bfa->ioc) == BFA_IOC_TYPE_FC) {
5967 if (!(speed == BFA_PORT_SPEED_1GBPS ||
5968 speed == BFA_PORT_SPEED_2GBPS ||
5969 speed == BFA_PORT_SPEED_4GBPS ||
5970 speed == BFA_PORT_SPEED_8GBPS ||
5971 speed == BFA_PORT_SPEED_16GBPS ||
5972 speed == BFA_PORT_SPEED_AUTO))
5973 return BFA_STATUS_UNSUPP_SPEED;
5974 } else {
5975 if (speed != BFA_PORT_SPEED_10GBPS)
5976 return BFA_STATUS_UNSUPP_SPEED;
5977 }
5978 }
5979 /* check to see if fcport is dport */
5980 if (bfa_fcport_is_dport(bfa)) {
5981 bfa_trc(fcdiag, fcdiag->lb.lock);
5982 return BFA_STATUS_DPORT_ENABLED;
5983 }
5984 /* check to see if there is another destructive diag cmd running */
5985 if (fcdiag->lb.lock) {
5986 bfa_trc(fcdiag, fcdiag->lb.lock);
5987 return BFA_STATUS_DEVBUSY;
5988 }
5989
5990 fcdiag->lb.lock = 1;
5991 loopback.lb_mode = opmode;
5992 loopback.speed = speed;
5993 loopback.loopcnt = lpcnt;
5994 loopback.pattern = pat;
5995 fcdiag->lb.result = result;
5996 fcdiag->lb.cbfn = cbfn;
5997 fcdiag->lb.cbarg = cbarg;
5998 memset(result, 0, sizeof(struct bfa_diag_loopback_result_s));
5999 bfa_fcdiag_set_busy_status(fcdiag);
6000
6001 /* Send msg to fw */
6002 status = bfa_fcdiag_loopback_send(fcdiag, &loopback);
6003 return status;
6004 }
6005
6006 /*
6007 * DIAG queue test command
6008 *
6009 * @param[in] *bfa - bfa data struct
6010 * @param[in] force - 1: don't do ioc op checking
6011 * @param[in] queue - queue no. to test
6012 * @param[in] *result - pt to bfa_diag_qtest_result_t data struct
6013 * @param[in] cbfn - callback function
6014 * @param[in] *cbarg - callback functioin arg
6015 *
6016 * @param[out]
6017 */
6018 bfa_status_t
bfa_fcdiag_queuetest(struct bfa_s * bfa,u32 force,u32 queue,struct bfa_diag_qtest_result_s * result,bfa_cb_diag_t cbfn,void * cbarg)6019 bfa_fcdiag_queuetest(struct bfa_s *bfa, u32 force, u32 queue,
6020 struct bfa_diag_qtest_result_s *result, bfa_cb_diag_t cbfn,
6021 void *cbarg)
6022 {
6023 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6024 bfa_status_t status;
6025 bfa_trc(fcdiag, force);
6026 bfa_trc(fcdiag, queue);
6027
6028 if (!force && !bfa_iocfc_is_operational(bfa))
6029 return BFA_STATUS_IOC_NON_OP;
6030
6031 /* check to see if there is another destructive diag cmd running */
6032 if (fcdiag->qtest.lock) {
6033 bfa_trc(fcdiag, fcdiag->qtest.lock);
6034 return BFA_STATUS_DEVBUSY;
6035 }
6036
6037 /* Initialization */
6038 fcdiag->qtest.lock = 1;
6039 fcdiag->qtest.cbfn = cbfn;
6040 fcdiag->qtest.cbarg = cbarg;
6041 fcdiag->qtest.result = result;
6042 fcdiag->qtest.count = QTEST_CNT_DEFAULT;
6043
6044 /* Init test results */
6045 fcdiag->qtest.result->status = BFA_STATUS_OK;
6046 fcdiag->qtest.result->count = 0;
6047
6048 /* send */
6049 if (queue < BFI_IOC_MAX_CQS) {
6050 fcdiag->qtest.result->queue = (u8)queue;
6051 fcdiag->qtest.queue = (u8)queue;
6052 fcdiag->qtest.all = 0;
6053 } else {
6054 fcdiag->qtest.result->queue = 0;
6055 fcdiag->qtest.queue = 0;
6056 fcdiag->qtest.all = 1;
6057 }
6058 status = bfa_fcdiag_queuetest_send(fcdiag);
6059
6060 /* Start a timer */
6061 if (status == BFA_STATUS_OK) {
6062 bfa_timer_start(bfa, &fcdiag->qtest.timer,
6063 bfa_fcdiag_queuetest_timeout, fcdiag,
6064 BFA_DIAG_QTEST_TOV);
6065 fcdiag->qtest.timer_active = 1;
6066 }
6067 return status;
6068 }
6069
6070 /*
6071 * DIAG PLB is running
6072 *
6073 * @param[in] *bfa - bfa data struct
6074 *
6075 * @param[out]
6076 */
6077 bfa_status_t
bfa_fcdiag_lb_is_running(struct bfa_s * bfa)6078 bfa_fcdiag_lb_is_running(struct bfa_s *bfa)
6079 {
6080 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6081 return fcdiag->lb.lock ? BFA_STATUS_DIAG_BUSY : BFA_STATUS_OK;
6082 }
6083
6084 /*
6085 * D-port
6086 */
6087 #define bfa_dport_result_start(__dport, __mode) do { \
6088 (__dport)->result.start_time = ktime_get_real_seconds(); \
6089 (__dport)->result.status = DPORT_TEST_ST_INPRG; \
6090 (__dport)->result.mode = (__mode); \
6091 (__dport)->result.rp_pwwn = (__dport)->rp_pwwn; \
6092 (__dport)->result.rp_nwwn = (__dport)->rp_nwwn; \
6093 (__dport)->result.lpcnt = (__dport)->lpcnt; \
6094 } while (0)
6095
6096 static bfa_boolean_t bfa_dport_send_req(struct bfa_dport_s *dport,
6097 enum bfi_dport_req req);
6098 static void
bfa_cb_fcdiag_dport(struct bfa_dport_s * dport,bfa_status_t bfa_status)6099 bfa_cb_fcdiag_dport(struct bfa_dport_s *dport, bfa_status_t bfa_status)
6100 {
6101 if (dport->cbfn != NULL) {
6102 dport->cbfn(dport->cbarg, bfa_status);
6103 dport->cbfn = NULL;
6104 dport->cbarg = NULL;
6105 }
6106 }
6107
6108 static void
bfa_dport_sm_disabled(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)6109 bfa_dport_sm_disabled(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6110 {
6111 bfa_trc(dport->bfa, event);
6112
6113 switch (event) {
6114 case BFA_DPORT_SM_ENABLE:
6115 bfa_fcport_dportenable(dport->bfa);
6116 if (bfa_dport_send_req(dport, BFI_DPORT_ENABLE))
6117 bfa_sm_set_state(dport, bfa_dport_sm_enabling);
6118 else
6119 bfa_sm_set_state(dport, bfa_dport_sm_enabling_qwait);
6120 break;
6121
6122 case BFA_DPORT_SM_DISABLE:
6123 /* Already disabled */
6124 break;
6125
6126 case BFA_DPORT_SM_HWFAIL:
6127 /* ignore */
6128 break;
6129
6130 case BFA_DPORT_SM_SCN:
6131 if (dport->i2hmsg.scn.state == BFI_DPORT_SCN_DDPORT_ENABLE) {
6132 bfa_fcport_ddportenable(dport->bfa);
6133 dport->dynamic = BFA_TRUE;
6134 dport->test_state = BFA_DPORT_ST_NOTSTART;
6135 bfa_sm_set_state(dport, bfa_dport_sm_enabled);
6136 } else {
6137 bfa_trc(dport->bfa, dport->i2hmsg.scn.state);
6138 WARN_ON(1);
6139 }
6140 break;
6141
6142 default:
6143 bfa_sm_fault(dport->bfa, event);
6144 }
6145 }
6146
6147 static void
bfa_dport_sm_enabling_qwait(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)6148 bfa_dport_sm_enabling_qwait(struct bfa_dport_s *dport,
6149 enum bfa_dport_sm_event event)
6150 {
6151 bfa_trc(dport->bfa, event);
6152
6153 switch (event) {
6154 case BFA_DPORT_SM_QRESUME:
6155 bfa_sm_set_state(dport, bfa_dport_sm_enabling);
6156 bfa_dport_send_req(dport, BFI_DPORT_ENABLE);
6157 break;
6158
6159 case BFA_DPORT_SM_HWFAIL:
6160 bfa_reqq_wcancel(&dport->reqq_wait);
6161 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6162 bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED);
6163 break;
6164
6165 default:
6166 bfa_sm_fault(dport->bfa, event);
6167 }
6168 }
6169
6170 static void
bfa_dport_sm_enabling(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)6171 bfa_dport_sm_enabling(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6172 {
6173 bfa_trc(dport->bfa, event);
6174
6175 switch (event) {
6176 case BFA_DPORT_SM_FWRSP:
6177 memset(&dport->result, 0,
6178 sizeof(struct bfa_diag_dport_result_s));
6179 if (dport->i2hmsg.rsp.status == BFA_STATUS_DPORT_INV_SFP) {
6180 dport->test_state = BFA_DPORT_ST_NO_SFP;
6181 } else {
6182 dport->test_state = BFA_DPORT_ST_INP;
6183 bfa_dport_result_start(dport, BFA_DPORT_OPMODE_AUTO);
6184 }
6185 bfa_sm_set_state(dport, bfa_dport_sm_enabled);
6186 break;
6187
6188 case BFA_DPORT_SM_REQFAIL:
6189 dport->test_state = BFA_DPORT_ST_DISABLED;
6190 bfa_fcport_dportdisable(dport->bfa);
6191 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6192 break;
6193
6194 case BFA_DPORT_SM_HWFAIL:
6195 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6196 bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED);
6197 break;
6198
6199 default:
6200 bfa_sm_fault(dport->bfa, event);
6201 }
6202 }
6203
6204 static void
bfa_dport_sm_enabled(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)6205 bfa_dport_sm_enabled(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6206 {
6207 bfa_trc(dport->bfa, event);
6208
6209 switch (event) {
6210 case BFA_DPORT_SM_START:
6211 if (bfa_dport_send_req(dport, BFI_DPORT_START))
6212 bfa_sm_set_state(dport, bfa_dport_sm_starting);
6213 else
6214 bfa_sm_set_state(dport, bfa_dport_sm_starting_qwait);
6215 break;
6216
6217 case BFA_DPORT_SM_DISABLE:
6218 bfa_fcport_dportdisable(dport->bfa);
6219 if (bfa_dport_send_req(dport, BFI_DPORT_DISABLE))
6220 bfa_sm_set_state(dport, bfa_dport_sm_disabling);
6221 else
6222 bfa_sm_set_state(dport, bfa_dport_sm_disabling_qwait);
6223 break;
6224
6225 case BFA_DPORT_SM_HWFAIL:
6226 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6227 break;
6228
6229 case BFA_DPORT_SM_SCN:
6230 switch (dport->i2hmsg.scn.state) {
6231 case BFI_DPORT_SCN_TESTCOMP:
6232 dport->test_state = BFA_DPORT_ST_COMP;
6233 break;
6234
6235 case BFI_DPORT_SCN_TESTSTART:
6236 dport->test_state = BFA_DPORT_ST_INP;
6237 break;
6238
6239 case BFI_DPORT_SCN_TESTSKIP:
6240 case BFI_DPORT_SCN_SUBTESTSTART:
6241 /* no state change */
6242 break;
6243
6244 case BFI_DPORT_SCN_SFP_REMOVED:
6245 dport->test_state = BFA_DPORT_ST_NO_SFP;
6246 break;
6247
6248 case BFI_DPORT_SCN_DDPORT_DISABLE:
6249 bfa_fcport_ddportdisable(dport->bfa);
6250
6251 if (bfa_dport_send_req(dport, BFI_DPORT_DYN_DISABLE))
6252 bfa_sm_set_state(dport,
6253 bfa_dport_sm_dynamic_disabling);
6254 else
6255 bfa_sm_set_state(dport,
6256 bfa_dport_sm_dynamic_disabling_qwait);
6257 break;
6258
6259 case BFI_DPORT_SCN_FCPORT_DISABLE:
6260 bfa_fcport_ddportdisable(dport->bfa);
6261
6262 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6263 dport->dynamic = BFA_FALSE;
6264 break;
6265
6266 default:
6267 bfa_trc(dport->bfa, dport->i2hmsg.scn.state);
6268 bfa_sm_fault(dport->bfa, event);
6269 }
6270 break;
6271 default:
6272 bfa_sm_fault(dport->bfa, event);
6273 }
6274 }
6275
6276 static void
bfa_dport_sm_disabling_qwait(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)6277 bfa_dport_sm_disabling_qwait(struct bfa_dport_s *dport,
6278 enum bfa_dport_sm_event event)
6279 {
6280 bfa_trc(dport->bfa, event);
6281
6282 switch (event) {
6283 case BFA_DPORT_SM_QRESUME:
6284 bfa_sm_set_state(dport, bfa_dport_sm_disabling);
6285 bfa_dport_send_req(dport, BFI_DPORT_DISABLE);
6286 break;
6287
6288 case BFA_DPORT_SM_HWFAIL:
6289 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6290 bfa_reqq_wcancel(&dport->reqq_wait);
6291 bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK);
6292 break;
6293
6294 case BFA_DPORT_SM_SCN:
6295 /* ignore */
6296 break;
6297
6298 default:
6299 bfa_sm_fault(dport->bfa, event);
6300 }
6301 }
6302
6303 static void
bfa_dport_sm_disabling(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)6304 bfa_dport_sm_disabling(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6305 {
6306 bfa_trc(dport->bfa, event);
6307
6308 switch (event) {
6309 case BFA_DPORT_SM_FWRSP:
6310 dport->test_state = BFA_DPORT_ST_DISABLED;
6311 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6312 break;
6313
6314 case BFA_DPORT_SM_HWFAIL:
6315 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6316 bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK);
6317 break;
6318
6319 case BFA_DPORT_SM_SCN:
6320 /* no state change */
6321 break;
6322
6323 default:
6324 bfa_sm_fault(dport->bfa, event);
6325 }
6326 }
6327
6328 static void
bfa_dport_sm_starting_qwait(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)6329 bfa_dport_sm_starting_qwait(struct bfa_dport_s *dport,
6330 enum bfa_dport_sm_event event)
6331 {
6332 bfa_trc(dport->bfa, event);
6333
6334 switch (event) {
6335 case BFA_DPORT_SM_QRESUME:
6336 bfa_sm_set_state(dport, bfa_dport_sm_starting);
6337 bfa_dport_send_req(dport, BFI_DPORT_START);
6338 break;
6339
6340 case BFA_DPORT_SM_HWFAIL:
6341 bfa_reqq_wcancel(&dport->reqq_wait);
6342 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6343 bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED);
6344 break;
6345
6346 default:
6347 bfa_sm_fault(dport->bfa, event);
6348 }
6349 }
6350
6351 static void
bfa_dport_sm_starting(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)6352 bfa_dport_sm_starting(struct bfa_dport_s *dport, enum bfa_dport_sm_event event)
6353 {
6354 bfa_trc(dport->bfa, event);
6355
6356 switch (event) {
6357 case BFA_DPORT_SM_FWRSP:
6358 memset(&dport->result, 0,
6359 sizeof(struct bfa_diag_dport_result_s));
6360 if (dport->i2hmsg.rsp.status == BFA_STATUS_DPORT_INV_SFP) {
6361 dport->test_state = BFA_DPORT_ST_NO_SFP;
6362 } else {
6363 dport->test_state = BFA_DPORT_ST_INP;
6364 bfa_dport_result_start(dport, BFA_DPORT_OPMODE_MANU);
6365 }
6366 fallthrough;
6367
6368 case BFA_DPORT_SM_REQFAIL:
6369 bfa_sm_set_state(dport, bfa_dport_sm_enabled);
6370 break;
6371
6372 case BFA_DPORT_SM_HWFAIL:
6373 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6374 bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED);
6375 break;
6376
6377 default:
6378 bfa_sm_fault(dport->bfa, event);
6379 }
6380 }
6381
6382 static void
bfa_dport_sm_dynamic_disabling(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)6383 bfa_dport_sm_dynamic_disabling(struct bfa_dport_s *dport,
6384 enum bfa_dport_sm_event event)
6385 {
6386 bfa_trc(dport->bfa, event);
6387
6388 switch (event) {
6389 case BFA_DPORT_SM_SCN:
6390 switch (dport->i2hmsg.scn.state) {
6391 case BFI_DPORT_SCN_DDPORT_DISABLED:
6392 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6393 dport->dynamic = BFA_FALSE;
6394 bfa_fcport_enable(dport->bfa);
6395 break;
6396
6397 default:
6398 bfa_trc(dport->bfa, dport->i2hmsg.scn.state);
6399 bfa_sm_fault(dport->bfa, event);
6400
6401 }
6402 break;
6403
6404 case BFA_DPORT_SM_HWFAIL:
6405 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6406 bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK);
6407 break;
6408
6409 default:
6410 bfa_sm_fault(dport->bfa, event);
6411 }
6412 }
6413
6414 static void
bfa_dport_sm_dynamic_disabling_qwait(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)6415 bfa_dport_sm_dynamic_disabling_qwait(struct bfa_dport_s *dport,
6416 enum bfa_dport_sm_event event)
6417 {
6418 bfa_trc(dport->bfa, event);
6419
6420 switch (event) {
6421 case BFA_DPORT_SM_QRESUME:
6422 bfa_sm_set_state(dport, bfa_dport_sm_dynamic_disabling);
6423 bfa_dport_send_req(dport, BFI_DPORT_DYN_DISABLE);
6424 break;
6425
6426 case BFA_DPORT_SM_HWFAIL:
6427 bfa_sm_set_state(dport, bfa_dport_sm_disabled);
6428 bfa_reqq_wcancel(&dport->reqq_wait);
6429 bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK);
6430 break;
6431
6432 case BFA_DPORT_SM_SCN:
6433 /* ignore */
6434 break;
6435
6436 default:
6437 bfa_sm_fault(dport->bfa, event);
6438 }
6439 }
6440
6441 static bfa_boolean_t
bfa_dport_send_req(struct bfa_dport_s * dport,enum bfi_dport_req req)6442 bfa_dport_send_req(struct bfa_dport_s *dport, enum bfi_dport_req req)
6443 {
6444 struct bfi_diag_dport_req_s *m;
6445
6446 /*
6447 * check for room in queue to send request now
6448 */
6449 m = bfa_reqq_next(dport->bfa, BFA_REQQ_DIAG);
6450 if (!m) {
6451 bfa_reqq_wait(dport->bfa, BFA_REQQ_PORT, &dport->reqq_wait);
6452 return BFA_FALSE;
6453 }
6454
6455 bfi_h2i_set(m->mh, BFI_MC_DIAG, BFI_DIAG_H2I_DPORT,
6456 bfa_fn_lpu(dport->bfa));
6457 m->req = req;
6458 if ((req == BFI_DPORT_ENABLE) || (req == BFI_DPORT_START)) {
6459 m->lpcnt = cpu_to_be32(dport->lpcnt);
6460 m->payload = cpu_to_be32(dport->payload);
6461 }
6462
6463 /*
6464 * queue I/O message to firmware
6465 */
6466 bfa_reqq_produce(dport->bfa, BFA_REQQ_DIAG, m->mh);
6467
6468 return BFA_TRUE;
6469 }
6470
6471 static void
bfa_dport_qresume(void * cbarg)6472 bfa_dport_qresume(void *cbarg)
6473 {
6474 struct bfa_dport_s *dport = cbarg;
6475
6476 bfa_sm_send_event(dport, BFA_DPORT_SM_QRESUME);
6477 }
6478
6479 static void
bfa_dport_req_comp(struct bfa_dport_s * dport,struct bfi_diag_dport_rsp_s * msg)6480 bfa_dport_req_comp(struct bfa_dport_s *dport, struct bfi_diag_dport_rsp_s *msg)
6481 {
6482 msg->status = cpu_to_be32(msg->status);
6483 dport->i2hmsg.rsp.status = msg->status;
6484 dport->rp_pwwn = msg->pwwn;
6485 dport->rp_nwwn = msg->nwwn;
6486
6487 if ((msg->status == BFA_STATUS_OK) ||
6488 (msg->status == BFA_STATUS_DPORT_NO_SFP)) {
6489 bfa_trc(dport->bfa, msg->status);
6490 bfa_trc(dport->bfa, dport->rp_pwwn);
6491 bfa_trc(dport->bfa, dport->rp_nwwn);
6492 bfa_sm_send_event(dport, BFA_DPORT_SM_FWRSP);
6493
6494 } else {
6495 bfa_trc(dport->bfa, msg->status);
6496 bfa_sm_send_event(dport, BFA_DPORT_SM_REQFAIL);
6497 }
6498 bfa_cb_fcdiag_dport(dport, msg->status);
6499 }
6500
6501 static bfa_boolean_t
bfa_dport_is_sending_req(struct bfa_dport_s * dport)6502 bfa_dport_is_sending_req(struct bfa_dport_s *dport)
6503 {
6504 if (bfa_sm_cmp_state(dport, bfa_dport_sm_enabling) ||
6505 bfa_sm_cmp_state(dport, bfa_dport_sm_enabling_qwait) ||
6506 bfa_sm_cmp_state(dport, bfa_dport_sm_disabling) ||
6507 bfa_sm_cmp_state(dport, bfa_dport_sm_disabling_qwait) ||
6508 bfa_sm_cmp_state(dport, bfa_dport_sm_starting) ||
6509 bfa_sm_cmp_state(dport, bfa_dport_sm_starting_qwait)) {
6510 return BFA_TRUE;
6511 } else {
6512 return BFA_FALSE;
6513 }
6514 }
6515
6516 static void
bfa_dport_scn(struct bfa_dport_s * dport,struct bfi_diag_dport_scn_s * msg)6517 bfa_dport_scn(struct bfa_dport_s *dport, struct bfi_diag_dport_scn_s *msg)
6518 {
6519 int i;
6520 uint8_t subtesttype;
6521
6522 bfa_trc(dport->bfa, msg->state);
6523 dport->i2hmsg.scn.state = msg->state;
6524
6525 switch (dport->i2hmsg.scn.state) {
6526 case BFI_DPORT_SCN_TESTCOMP:
6527 dport->result.end_time = ktime_get_real_seconds();
6528 bfa_trc(dport->bfa, dport->result.end_time);
6529
6530 dport->result.status = msg->info.testcomp.status;
6531 bfa_trc(dport->bfa, dport->result.status);
6532
6533 dport->result.roundtrip_latency =
6534 cpu_to_be32(msg->info.testcomp.latency);
6535 dport->result.est_cable_distance =
6536 cpu_to_be32(msg->info.testcomp.distance);
6537 dport->result.buffer_required =
6538 be16_to_cpu(msg->info.testcomp.numbuffer);
6539
6540 dport->result.frmsz = be16_to_cpu(msg->info.testcomp.frm_sz);
6541 dport->result.speed = msg->info.testcomp.speed;
6542
6543 bfa_trc(dport->bfa, dport->result.roundtrip_latency);
6544 bfa_trc(dport->bfa, dport->result.est_cable_distance);
6545 bfa_trc(dport->bfa, dport->result.buffer_required);
6546 bfa_trc(dport->bfa, dport->result.frmsz);
6547 bfa_trc(dport->bfa, dport->result.speed);
6548
6549 for (i = DPORT_TEST_ELOOP; i < DPORT_TEST_MAX; i++) {
6550 dport->result.subtest[i].status =
6551 msg->info.testcomp.subtest_status[i];
6552 bfa_trc(dport->bfa, dport->result.subtest[i].status);
6553 }
6554 break;
6555
6556 case BFI_DPORT_SCN_TESTSKIP:
6557 case BFI_DPORT_SCN_DDPORT_ENABLE:
6558 memset(&dport->result, 0,
6559 sizeof(struct bfa_diag_dport_result_s));
6560 break;
6561
6562 case BFI_DPORT_SCN_TESTSTART:
6563 memset(&dport->result, 0,
6564 sizeof(struct bfa_diag_dport_result_s));
6565 dport->rp_pwwn = msg->info.teststart.pwwn;
6566 dport->rp_nwwn = msg->info.teststart.nwwn;
6567 dport->lpcnt = cpu_to_be32(msg->info.teststart.numfrm);
6568 bfa_dport_result_start(dport, msg->info.teststart.mode);
6569 break;
6570
6571 case BFI_DPORT_SCN_SUBTESTSTART:
6572 subtesttype = msg->info.teststart.type;
6573 dport->result.subtest[subtesttype].start_time =
6574 ktime_get_real_seconds();
6575 dport->result.subtest[subtesttype].status =
6576 DPORT_TEST_ST_INPRG;
6577
6578 bfa_trc(dport->bfa, subtesttype);
6579 bfa_trc(dport->bfa,
6580 dport->result.subtest[subtesttype].start_time);
6581 break;
6582
6583 case BFI_DPORT_SCN_SFP_REMOVED:
6584 case BFI_DPORT_SCN_DDPORT_DISABLED:
6585 case BFI_DPORT_SCN_DDPORT_DISABLE:
6586 case BFI_DPORT_SCN_FCPORT_DISABLE:
6587 dport->result.status = DPORT_TEST_ST_IDLE;
6588 break;
6589
6590 default:
6591 bfa_sm_fault(dport->bfa, msg->state);
6592 }
6593
6594 bfa_sm_send_event(dport, BFA_DPORT_SM_SCN);
6595 }
6596
6597 /*
6598 * Dport enable
6599 *
6600 * @param[in] *bfa - bfa data struct
6601 */
6602 bfa_status_t
bfa_dport_enable(struct bfa_s * bfa,u32 lpcnt,u32 pat,bfa_cb_diag_t cbfn,void * cbarg)6603 bfa_dport_enable(struct bfa_s *bfa, u32 lpcnt, u32 pat,
6604 bfa_cb_diag_t cbfn, void *cbarg)
6605 {
6606 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6607 struct bfa_dport_s *dport = &fcdiag->dport;
6608
6609 /*
6610 * Dport is not support in MEZZ card
6611 */
6612 if (bfa_mfg_is_mezz(dport->bfa->ioc.attr->card_type)) {
6613 bfa_trc(dport->bfa, BFA_STATUS_PBC);
6614 return BFA_STATUS_CMD_NOTSUPP_MEZZ;
6615 }
6616
6617 /*
6618 * Dport is supported in CT2 or above
6619 */
6620 if (!(bfa_asic_id_ct2(dport->bfa->ioc.pcidev.device_id))) {
6621 bfa_trc(dport->bfa, dport->bfa->ioc.pcidev.device_id);
6622 return BFA_STATUS_FEATURE_NOT_SUPPORTED;
6623 }
6624
6625 /*
6626 * Check to see if IOC is down
6627 */
6628 if (!bfa_iocfc_is_operational(bfa))
6629 return BFA_STATUS_IOC_NON_OP;
6630
6631 /* if port is PBC disabled, return error */
6632 if (bfa_fcport_is_pbcdisabled(bfa)) {
6633 bfa_trc(dport->bfa, BFA_STATUS_PBC);
6634 return BFA_STATUS_PBC;
6635 }
6636
6637 /*
6638 * Check if port mode is FC port
6639 */
6640 if (bfa_ioc_get_type(&bfa->ioc) != BFA_IOC_TYPE_FC) {
6641 bfa_trc(dport->bfa, bfa_ioc_get_type(&bfa->ioc));
6642 return BFA_STATUS_CMD_NOTSUPP_CNA;
6643 }
6644
6645 /*
6646 * Check if port is in LOOP mode
6647 */
6648 if ((bfa_fcport_get_cfg_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP) ||
6649 (bfa_fcport_get_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP)) {
6650 bfa_trc(dport->bfa, 0);
6651 return BFA_STATUS_TOPOLOGY_LOOP;
6652 }
6653
6654 /*
6655 * Check if port is TRUNK mode
6656 */
6657 if (bfa_fcport_is_trunk_enabled(bfa)) {
6658 bfa_trc(dport->bfa, 0);
6659 return BFA_STATUS_ERROR_TRUNK_ENABLED;
6660 }
6661
6662 /*
6663 * Check if diag loopback is running
6664 */
6665 if (bfa_fcdiag_lb_is_running(bfa)) {
6666 bfa_trc(dport->bfa, 0);
6667 return BFA_STATUS_DIAG_BUSY;
6668 }
6669
6670 /*
6671 * Check to see if port is disable or in dport state
6672 */
6673 if ((bfa_fcport_is_disabled(bfa) == BFA_FALSE) &&
6674 (bfa_fcport_is_dport(bfa) == BFA_FALSE)) {
6675 bfa_trc(dport->bfa, 0);
6676 return BFA_STATUS_PORT_NOT_DISABLED;
6677 }
6678
6679 /*
6680 * Check if dport is in dynamic mode
6681 */
6682 if (dport->dynamic)
6683 return BFA_STATUS_DDPORT_ERR;
6684
6685 /*
6686 * Check if dport is busy
6687 */
6688 if (bfa_dport_is_sending_req(dport))
6689 return BFA_STATUS_DEVBUSY;
6690
6691 /*
6692 * Check if dport is already enabled
6693 */
6694 if (bfa_sm_cmp_state(dport, bfa_dport_sm_enabled)) {
6695 bfa_trc(dport->bfa, 0);
6696 return BFA_STATUS_DPORT_ENABLED;
6697 }
6698
6699 bfa_trc(dport->bfa, lpcnt);
6700 bfa_trc(dport->bfa, pat);
6701 dport->lpcnt = (lpcnt) ? lpcnt : DPORT_ENABLE_LOOPCNT_DEFAULT;
6702 dport->payload = (pat) ? pat : LB_PATTERN_DEFAULT;
6703 dport->cbfn = cbfn;
6704 dport->cbarg = cbarg;
6705
6706 bfa_sm_send_event(dport, BFA_DPORT_SM_ENABLE);
6707 return BFA_STATUS_OK;
6708 }
6709
6710 /*
6711 * Dport disable
6712 *
6713 * @param[in] *bfa - bfa data struct
6714 */
6715 bfa_status_t
bfa_dport_disable(struct bfa_s * bfa,bfa_cb_diag_t cbfn,void * cbarg)6716 bfa_dport_disable(struct bfa_s *bfa, bfa_cb_diag_t cbfn, void *cbarg)
6717 {
6718 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6719 struct bfa_dport_s *dport = &fcdiag->dport;
6720
6721 if (bfa_ioc_is_disabled(&bfa->ioc))
6722 return BFA_STATUS_IOC_DISABLED;
6723
6724 /* if port is PBC disabled, return error */
6725 if (bfa_fcport_is_pbcdisabled(bfa)) {
6726 bfa_trc(dport->bfa, BFA_STATUS_PBC);
6727 return BFA_STATUS_PBC;
6728 }
6729
6730 /*
6731 * Check if dport is in dynamic mode
6732 */
6733 if (dport->dynamic) {
6734 return BFA_STATUS_DDPORT_ERR;
6735 }
6736
6737 /*
6738 * Check to see if port is disable or in dport state
6739 */
6740 if ((bfa_fcport_is_disabled(bfa) == BFA_FALSE) &&
6741 (bfa_fcport_is_dport(bfa) == BFA_FALSE)) {
6742 bfa_trc(dport->bfa, 0);
6743 return BFA_STATUS_PORT_NOT_DISABLED;
6744 }
6745
6746 /*
6747 * Check if dport is busy
6748 */
6749 if (bfa_dport_is_sending_req(dport))
6750 return BFA_STATUS_DEVBUSY;
6751
6752 /*
6753 * Check if dport is already disabled
6754 */
6755 if (bfa_sm_cmp_state(dport, bfa_dport_sm_disabled)) {
6756 bfa_trc(dport->bfa, 0);
6757 return BFA_STATUS_DPORT_DISABLED;
6758 }
6759
6760 dport->cbfn = cbfn;
6761 dport->cbarg = cbarg;
6762
6763 bfa_sm_send_event(dport, BFA_DPORT_SM_DISABLE);
6764 return BFA_STATUS_OK;
6765 }
6766
6767 /*
6768 * Dport start -- restart dport test
6769 *
6770 * @param[in] *bfa - bfa data struct
6771 */
6772 bfa_status_t
bfa_dport_start(struct bfa_s * bfa,u32 lpcnt,u32 pat,bfa_cb_diag_t cbfn,void * cbarg)6773 bfa_dport_start(struct bfa_s *bfa, u32 lpcnt, u32 pat,
6774 bfa_cb_diag_t cbfn, void *cbarg)
6775 {
6776 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6777 struct bfa_dport_s *dport = &fcdiag->dport;
6778
6779 /*
6780 * Check to see if IOC is down
6781 */
6782 if (!bfa_iocfc_is_operational(bfa))
6783 return BFA_STATUS_IOC_NON_OP;
6784
6785 /*
6786 * Check if dport is in dynamic mode
6787 */
6788 if (dport->dynamic)
6789 return BFA_STATUS_DDPORT_ERR;
6790
6791 /*
6792 * Check if dport is busy
6793 */
6794 if (bfa_dport_is_sending_req(dport))
6795 return BFA_STATUS_DEVBUSY;
6796
6797 /*
6798 * Check if dport is in enabled state.
6799 * Test can only be restart when previous test has completed
6800 */
6801 if (!bfa_sm_cmp_state(dport, bfa_dport_sm_enabled)) {
6802 bfa_trc(dport->bfa, 0);
6803 return BFA_STATUS_DPORT_DISABLED;
6804
6805 } else {
6806 if (dport->test_state == BFA_DPORT_ST_NO_SFP)
6807 return BFA_STATUS_DPORT_INV_SFP;
6808
6809 if (dport->test_state == BFA_DPORT_ST_INP)
6810 return BFA_STATUS_DEVBUSY;
6811
6812 WARN_ON(dport->test_state != BFA_DPORT_ST_COMP);
6813 }
6814
6815 bfa_trc(dport->bfa, lpcnt);
6816 bfa_trc(dport->bfa, pat);
6817
6818 dport->lpcnt = (lpcnt) ? lpcnt : DPORT_ENABLE_LOOPCNT_DEFAULT;
6819 dport->payload = (pat) ? pat : LB_PATTERN_DEFAULT;
6820
6821 dport->cbfn = cbfn;
6822 dport->cbarg = cbarg;
6823
6824 bfa_sm_send_event(dport, BFA_DPORT_SM_START);
6825 return BFA_STATUS_OK;
6826 }
6827
6828 /*
6829 * Dport show -- return dport test result
6830 *
6831 * @param[in] *bfa - bfa data struct
6832 */
6833 bfa_status_t
bfa_dport_show(struct bfa_s * bfa,struct bfa_diag_dport_result_s * result)6834 bfa_dport_show(struct bfa_s *bfa, struct bfa_diag_dport_result_s *result)
6835 {
6836 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
6837 struct bfa_dport_s *dport = &fcdiag->dport;
6838
6839 /*
6840 * Check to see if IOC is down
6841 */
6842 if (!bfa_iocfc_is_operational(bfa))
6843 return BFA_STATUS_IOC_NON_OP;
6844
6845 /*
6846 * Check if dport is busy
6847 */
6848 if (bfa_dport_is_sending_req(dport))
6849 return BFA_STATUS_DEVBUSY;
6850
6851 /*
6852 * Check if dport is in enabled state.
6853 */
6854 if (!bfa_sm_cmp_state(dport, bfa_dport_sm_enabled)) {
6855 bfa_trc(dport->bfa, 0);
6856 return BFA_STATUS_DPORT_DISABLED;
6857
6858 }
6859
6860 /*
6861 * Check if there is SFP
6862 */
6863 if (dport->test_state == BFA_DPORT_ST_NO_SFP)
6864 return BFA_STATUS_DPORT_INV_SFP;
6865
6866 memcpy(result, &dport->result, sizeof(struct bfa_diag_dport_result_s));
6867
6868 return BFA_STATUS_OK;
6869 }
6870