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