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