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