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