]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/scsi/bfa/bfa_svc.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] bfa: Add support to configure trunking on Brocade adapter ports.
[mirror_ubuntu-artful-kernel.git] / drivers / scsi / bfa / bfa_svc.c
CommitLineData
a36c61f9
KG		 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
f16a1750 18#include "bfad_drv.h"
7826f304 19#include "bfad_im.h"
a36c61f9
KG		 20#include "bfa_plog.h"
21#include "bfa_cs.h"
22#include "bfa_modules.h"
a36c61f9
KG		 23
24BFA_TRC_FILE(HAL, FCXP);
3d7fc66d 25BFA_MODULE(fcdiag);
a36c61f9
KG		 26BFA_MODULE(fcxp);
27BFA_MODULE(sgpg);
28BFA_MODULE(lps);
29BFA_MODULE(fcport);
30BFA_MODULE(rport);
31BFA_MODULE(uf);
32
5fbe25c7 33/*
a36c61f9
KG		 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
a36c61f9 45
5fbe25c7 46/*
a36c61f9
KG		 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
5fbe25c7 57/*
a36c61f9
KG		 58 * BFA port state machine events
59 */
60enum 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
5fbe25c7 72/*
a36c61f9
KG		 73 * BFA port link notification state machine events
74 */
75
76enum 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
5fbe25c7 82/*
a36c61f9
KG		 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
5fbe25c7 103/*
a36c61f9
KG		 104 * forward declarations FCXP related functions
105 */
106static void __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete);
107static void hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp,
108 struct bfi_fcxp_send_rsp_s *fcxp_rsp);
109static void hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen,
110 struct bfa_fcxp_s *fcxp, struct fchs_s *fchs);
111static void bfa_fcxp_qresume(void *cbarg);
112static void bfa_fcxp_queue(struct bfa_fcxp_s *fcxp,
113 struct bfi_fcxp_send_req_s *send_req);
114
5fbe25c7 115/*
a36c61f9
KG		 116 * forward declarations for LPS functions
117 */
4507025d
KG		 118static void bfa_lps_meminfo(struct bfa_iocfc_cfg_s *cfg,
119 struct bfa_meminfo_s *minfo, struct bfa_s *bfa);
a36c61f9
KG		 120static void bfa_lps_attach(struct bfa_s *bfa, void *bfad,
121 struct bfa_iocfc_cfg_s *cfg,
a36c61f9
KG		 122 struct bfa_pcidev_s *pcidev);
123static void bfa_lps_detach(struct bfa_s *bfa);
124static void bfa_lps_start(struct bfa_s *bfa);
125static void bfa_lps_stop(struct bfa_s *bfa);
126static void bfa_lps_iocdisable(struct bfa_s *bfa);
127static void bfa_lps_login_rsp(struct bfa_s *bfa,
128 struct bfi_lps_login_rsp_s *rsp);
3fd45980 129static void bfa_lps_no_res(struct bfa_lps_s *first_lps, u8 count);
a36c61f9
KG		 130static void bfa_lps_logout_rsp(struct bfa_s *bfa,
131 struct bfi_lps_logout_rsp_s *rsp);
132static void bfa_lps_reqq_resume(void *lps_arg);
133static void bfa_lps_free(struct bfa_lps_s *lps);
134static void bfa_lps_send_login(struct bfa_lps_s *lps);
135static void bfa_lps_send_logout(struct bfa_lps_s *lps);
b704495c 136static void bfa_lps_send_set_n2n_pid(struct bfa_lps_s *lps);
a36c61f9
KG		 137static void bfa_lps_login_comp(struct bfa_lps_s *lps);
138static void bfa_lps_logout_comp(struct bfa_lps_s *lps);
139static void bfa_lps_cvl_event(struct bfa_lps_s *lps);
140
5fbe25c7 141/*
a36c61f9
KG		 142 * forward declaration for LPS state machine
143 */
144static void bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event);
145static void bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event);
146static void bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event
147 event);
148static void bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event);
b704495c
KG		 149static void bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps,
150 enum bfa_lps_event event);
a36c61f9
KG		 151static void bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event);
152static void bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event
153 event);
154
5fbe25c7 155/*
a36c61f9
KG		 156 * forward declaration for FC Port functions
157 */
158static bfa_boolean_t bfa_fcport_send_enable(struct bfa_fcport_s *fcport);
159static bfa_boolean_t bfa_fcport_send_disable(struct bfa_fcport_s *fcport);
160static void bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport);
161static void bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport);
162static void bfa_fcport_set_wwns(struct bfa_fcport_s *fcport);
163static void __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete);
164static void bfa_fcport_scn(struct bfa_fcport_s *fcport,
165 enum bfa_port_linkstate event, bfa_boolean_t trunk);
166static void bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln,
167 enum bfa_port_linkstate event);
168static void __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete);
169static void bfa_fcport_stats_get_timeout(void *cbarg);
170static void bfa_fcport_stats_clr_timeout(void *cbarg);
171static void bfa_trunk_iocdisable(struct bfa_s *bfa);
172
5fbe25c7 173/*
a36c61f9
KG		 174 * forward declaration for FC PORT state machine
175 */
176static void bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
177 enum bfa_fcport_sm_event event);
178static void bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
179 enum bfa_fcport_sm_event event);
180static void bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
181 enum bfa_fcport_sm_event event);
182static void bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
183 enum bfa_fcport_sm_event event);
184static void bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
185 enum bfa_fcport_sm_event event);
186static void bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
187 enum bfa_fcport_sm_event event);
188static void bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
189 enum bfa_fcport_sm_event event);
190static void bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
191 enum bfa_fcport_sm_event event);
192static void bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
193 enum bfa_fcport_sm_event event);
194static void bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
195 enum bfa_fcport_sm_event event);
196static void bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
197 enum bfa_fcport_sm_event event);
198static void bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
199 enum bfa_fcport_sm_event event);
200
201static void bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
202 enum bfa_fcport_ln_sm_event event);
203static void bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
204 enum bfa_fcport_ln_sm_event event);
205static void bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
206 enum bfa_fcport_ln_sm_event event);
207static void bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
208 enum bfa_fcport_ln_sm_event event);
209static void bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
210 enum bfa_fcport_ln_sm_event event);
211static void bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
212 enum bfa_fcport_ln_sm_event event);
213static void bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
214 enum bfa_fcport_ln_sm_event event);
215
216static 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
5fbe25c7 232/*
a36c61f9
KG		 233 * forward declaration for RPORT related functions
234 */
235static struct bfa_rport_s *bfa_rport_alloc(struct bfa_rport_mod_s *rp_mod);
236static void bfa_rport_free(struct bfa_rport_s *rport);
237static bfa_boolean_t bfa_rport_send_fwcreate(struct bfa_rport_s *rp);
238static bfa_boolean_t bfa_rport_send_fwdelete(struct bfa_rport_s *rp);
239static bfa_boolean_t bfa_rport_send_fwspeed(struct bfa_rport_s *rp);
240static void __bfa_cb_rport_online(void *cbarg,
241 bfa_boolean_t complete);
242static void __bfa_cb_rport_offline(void *cbarg,
243 bfa_boolean_t complete);
244
5fbe25c7 245/*
a36c61f9
KG		 246 * forward declaration for RPORT state machine
247 */
248static void bfa_rport_sm_uninit(struct bfa_rport_s *rp,
249 enum bfa_rport_event event);
250static void bfa_rport_sm_created(struct bfa_rport_s *rp,
251 enum bfa_rport_event event);
252static void bfa_rport_sm_fwcreate(struct bfa_rport_s *rp,
253 enum bfa_rport_event event);
254static void bfa_rport_sm_online(struct bfa_rport_s *rp,
255 enum bfa_rport_event event);
256static void bfa_rport_sm_fwdelete(struct bfa_rport_s *rp,
257 enum bfa_rport_event event);
258static void bfa_rport_sm_offline(struct bfa_rport_s *rp,
259 enum bfa_rport_event event);
260static void bfa_rport_sm_deleting(struct bfa_rport_s *rp,
261 enum bfa_rport_event event);
262static void bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
263 enum bfa_rport_event event);
264static void bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
265 enum bfa_rport_event event);
266static void bfa_rport_sm_iocdisable(struct bfa_rport_s *rp,
267 enum bfa_rport_event event);
268static void bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp,
269 enum bfa_rport_event event);
270static void bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp,
271 enum bfa_rport_event event);
272static void bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp,
273 enum bfa_rport_event event);
274
5fbe25c7 275/*
a36c61f9
KG		 276 * PLOG related definitions
277 */
278static int
279plkd_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
f16a1750
MZ		 292static u64
293bfa_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
a36c61f9
KG		 304static void
305bfa_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)) {
d4b671c5 314 WARN_ON(1);
a36c61f9
KG		 315 return;
316 }
317
318 tail = plog->tail;
319
320 pl_recp = &(plog->plog_recs[tail]);
321
6a18b167 322 memcpy(pl_recp, pl_rec, sizeof(struct bfa_plog_rec_s));
a36c61f9 323
f16a1750 324 pl_recp->tv = bfa_get_log_time();
a36c61f9
KG		 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
331void
332bfa_plog_init(struct bfa_plog_s *plog)
333{
6a18b167 334 memset((char *)plog, 0, sizeof(struct bfa_plog_s));
a36c61f9 335
6a18b167 336 memcpy(plog->plog_sig, BFA_PL_SIG_STR, BFA_PL_SIG_LEN);
a36c61f9
KG		 337 plog->head = plog->tail = 0;
338 plog->plog_enabled = 1;
339}
340
341void
342bfa_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) {
6a18b167 349 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
a36c61f9
KG		 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
361void
362bfa_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) {
6a18b167 373 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
a36c61f9
KG		 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++)
6a18b167 380 lp.log_entry.int_log[i] = intarr[i];
a36c61f9
KG		 381
382 lp.log_num_ints = (u8) num_ints;
383
384 bfa_plog_add(plog, &lp);
385 }
386}
387
388void
389bfa_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) {
6a18b167 398 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
a36c61f9
KG		 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
408void
409bfa_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) {
6a18b167 418 memset(&lp, 0, sizeof(struct bfa_plog_rec_s));
a36c61f9
KG		 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
a36c61f9 429
5fbe25c7 430/*
a36c61f9
KG		 431 * fcxp_pvt BFA FCXP private functions
432 */
433
434static void
4507025d 435claim_fcxps_mem(struct bfa_fcxp_mod_s *mod)
a36c61f9
KG		 436{
437 u16 i;
438 struct bfa_fcxp_s *fcxp;
439
4507025d 440 fcxp = (struct bfa_fcxp_s *) bfa_mem_kva_curp(mod);
6a18b167 441 memset(fcxp, 0, sizeof(struct bfa_fcxp_s) * mod->num_fcxps);
a36c61f9
KG		 442
443 INIT_LIST_HEAD(&mod->fcxp_free_q);
444 INIT_LIST_HEAD(&mod->fcxp_active_q);
3fd45980 445 INIT_LIST_HEAD(&mod->fcxp_unused_q);
a36c61f9
KG		 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
4507025d 460 bfa_mem_kva_curp(mod) = (void *)fcxp;
a36c61f9
KG		 461}
462
463static void
4507025d
KG		 464bfa_fcxp_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
465 struct bfa_s *bfa)
a36c61f9 466{
4507025d
KG		 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;
a36c61f9 473
4507025d 474 if (num_fcxps == 0)
a36c61f9
KG		 475 return;
476
a36c61f9 477 if (cfg->drvcfg.min_cfg)
4507025d 478 per_fcxp_sz = 2 * BFA_FCXP_MAX_IBUF_SZ;
a36c61f9 479 else
4507025d 480 per_fcxp_sz = BFA_FCXP_MAX_IBUF_SZ + BFA_FCXP_MAX_LBUF_SZ;
a36c61f9 481
4507025d
KG		 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));
a36c61f9
KG		 499}
500
501static void
502bfa_fcxp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4507025d 503 struct bfa_pcidev_s *pcidev)
a36c61f9
KG		 504{
505 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
506
a36c61f9
KG		 507 mod->bfa = bfa;
508 mod->num_fcxps = cfg->fwcfg.num_fcxp_reqs;
509
5fbe25c7 510 /*
a36c61f9
KG		 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
4507025d 519 claim_fcxps_mem(mod);
a36c61f9
KG		 520}
521
522static void
523bfa_fcxp_detach(struct bfa_s *bfa)
524{
525}
526
527static void
528bfa_fcxp_start(struct bfa_s *bfa)
529{
530}
531
532static void
533bfa_fcxp_stop(struct bfa_s *bfa)
534{
535}
536
537static void
538bfa_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
3fd45980
KG		 544 /* Enqueue unused fcxp resources to free_q */
545 list_splice_tail_init(&mod->fcxp_unused_q, &mod->fcxp_free_q);
546
a36c61f9
KG		 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
561static struct bfa_fcxp_s *
562bfa_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
574static void
575bfa_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
d4b671c5 587 WARN_ON(bfa == NULL);
a36c61f9
KG		 588
589 bfa_trc(bfa, fcxp->fcxp_tag);
590
591 if (n_sgles == 0) {
592 *use_ibuf = 1;
593 } else {
d4b671c5
JH		 594 WARN_ON(*sga_cbfn == NULL);
595 WARN_ON(*sglen_cbfn == NULL);
a36c61f9
KG		 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)
d4b671c5 607 WARN_ON(1);
a36c61f9
KG		 608 }
609
610}
611
612static void
613bfa_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
d4b671c5 621 WARN_ON(bfa == NULL);
a36c61f9
KG		 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
639static void
640bfa_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
d4b671c5 658 WARN_ON(!bfa_q_is_on_q(&mod->fcxp_active_q, fcxp));
a36c61f9
KG		 659 list_del(&fcxp->qe);
660 list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
661}
662
663static void
664bfa_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
671static 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
685static void
686hal_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;
ba816ea8 690 u16 fcxp_tag = be16_to_cpu(fcxp_rsp->fcxp_tag);
a36c61f9
KG		 691
692 bfa_trc(bfa, fcxp_tag);
693
ba816ea8 694 fcxp_rsp->rsp_len = be32_to_cpu(fcxp_rsp->rsp_len);
a36c61f9 695
5fbe25c7 696 /*
a36c61f9
KG		 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
ba816ea8 703 fcxp_rsp->residue_len = be32_to_cpu(fcxp_rsp->residue_len);
a36c61f9
KG		 704
705 fcxp = BFA_FCXP_FROM_TAG(mod, fcxp_tag);
706
d4b671c5 707 WARN_ON(fcxp->send_cbfn == NULL);
a36c61f9
KG		 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
a36c61f9
KG		 735static void
736hal_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
763static void
764hal_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
5fbe25c7 788/*
a36c61f9
KG		 789 * Handler to resume sending fcxp when space in available in cpe queue.
790 */
791static void
792bfa_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
5fbe25c7 803/*
a36c61f9
KG		 804 * Queue fcxp send request to foimrware.
805 */
806static void
807bfa_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,
3fd45980 815 bfa_fn_lpu(bfa));
a36c61f9 816
ba816ea8 817 send_req->fcxp_tag = cpu_to_be16(fcxp->fcxp_tag);
a36c61f9
KG		 818 if (rport) {
819 send_req->rport_fw_hndl = rport->fw_handle;
ba816ea8 820 send_req->max_frmsz = cpu_to_be16(rport->rport_info.max_frmsz);
a36c61f9 821 if (send_req->max_frmsz == 0)
ba816ea8 822 send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
a36c61f9
KG		 823 } else {
824 send_req->rport_fw_hndl = 0;
ba816ea8 825 send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ);
a36c61f9
KG		 826 }
827
ba816ea8 828 send_req->vf_id = cpu_to_be16(reqi->vf_id);
3fd45980 829 send_req->lp_fwtag = bfa_lps_get_fwtag(bfa, reqi->lp_tag);
a36c61f9
KG		 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
ba816ea8
JH		 835 send_req->req_len = cpu_to_be32(reqi->req_tot_len);
836 send_req->rsp_maxlen = cpu_to_be32(rspi->rsp_maxlen);
a36c61f9
KG		 837
838 /*
839 * setup req sgles
840 */
841 if (fcxp->use_ireqbuf == 1) {
85ce928d 842 bfa_alen_set(&send_req->req_alen, reqi->req_tot_len,
a36c61f9
KG		 843 BFA_FCXP_REQ_PLD_PA(fcxp));
844 } else {
845 if (fcxp->nreq_sgles > 0) {
d4b671c5 846 WARN_ON(fcxp->nreq_sgles != 1);
85ce928d
KG		 847 bfa_alen_set(&send_req->req_alen, reqi->req_tot_len,
848 fcxp->req_sga_cbfn(fcxp->caller, 0));
a36c61f9 849 } else {
d4b671c5 850 WARN_ON(reqi->req_tot_len != 0);
85ce928d 851 bfa_alen_set(&send_req->rsp_alen, 0, 0);
a36c61f9
KG		 852 }
853 }
854
855 /*
856 * setup rsp sgles
857 */
858 if (fcxp->use_irspbuf == 1) {
d4b671c5 859 WARN_ON(rspi->rsp_maxlen > BFA_FCXP_MAX_LBUF_SZ);
a36c61f9 860
85ce928d 861 bfa_alen_set(&send_req->rsp_alen, rspi->rsp_maxlen,
a36c61f9 862 BFA_FCXP_RSP_PLD_PA(fcxp));
a36c61f9
KG		 863 } else {
864 if (fcxp->nrsp_sgles > 0) {
d4b671c5 865 WARN_ON(fcxp->nrsp_sgles != 1);
85ce928d
KG		 866 bfa_alen_set(&send_req->rsp_alen, rspi->rsp_maxlen,
867 fcxp->rsp_sga_cbfn(fcxp->caller, 0));
868
a36c61f9 869 } else {
d4b671c5 870 WARN_ON(rspi->rsp_maxlen != 0);
85ce928d 871 bfa_alen_set(&send_req->rsp_alen, 0, 0);
a36c61f9
KG		 872 }
873 }
874
875 hal_fcxp_tx_plog(bfa, reqi->req_tot_len, fcxp, &reqi->fchs);
876
3fd45980 877 bfa_reqq_produce(bfa, BFA_REQQ_FCXP, send_req->mh);
a36c61f9
KG		 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
5fbe25c7 883/*
a36c61f9
KG		 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 */
906struct bfa_fcxp_s *
907bfa_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
d4b671c5 915 WARN_ON(bfa == NULL);
a36c61f9
KG		 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
5fbe25c7 929/*
a36c61f9
KG		 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 */
936void *
937bfa_fcxp_get_reqbuf(struct bfa_fcxp_s *fcxp)
938{
939 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
940 void *reqbuf;
941
d4b671c5 942 WARN_ON(fcxp->use_ireqbuf != 1);
4507025d
KG		 943 reqbuf = bfa_mem_get_dmabuf_kva(mod, fcxp->fcxp_tag,
944 mod->req_pld_sz + mod->rsp_pld_sz);
a36c61f9
KG		 945 return reqbuf;
946}
947
948u32
949bfa_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
5fbe25c7 956/*
a36c61f9
KG		 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 */
963void *
964bfa_fcxp_get_rspbuf(struct bfa_fcxp_s *fcxp)
965{
966 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
4507025d 967 void *fcxp_buf;
a36c61f9 968
d4b671c5 969 WARN_ON(fcxp->use_irspbuf != 1);
a36c61f9 970
4507025d
KG		 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;
a36c61f9
KG		 976}
977
5fbe25c7 978/*
da99dcc9 979 * Free the BFA FCXP
a36c61f9
KG		 980 *
981 * @param[in] fcxp BFA fcxp pointer
982 *
983 * @return void
984 */
985void
986bfa_fcxp_free(struct bfa_fcxp_s *fcxp)
987{
988 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
989
d4b671c5 990 WARN_ON(fcxp == NULL);
a36c61f9
KG		 991 bfa_trc(mod->bfa, fcxp->fcxp_tag);
992 bfa_fcxp_put(fcxp);
993}
994
5fbe25c7 995/*
a36c61f9
KG		 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
25985edc 1002 * @param[in] cts use Continuous sequence
a36c61f9
KG		 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 */
1016void
1017bfa_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
5fbe25c7 1029 /*
a36c61f9
KG		 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
5fbe25c7 1044 /*
a36c61f9
KG		 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
5fbe25c7 1058/*
a36c61f9
KG		 1059 * Abort a BFA FCXP
1060 *
1061 * @param[in] fcxp BFA fcxp pointer
1062 *
1063 * @return void
1064 */
1065bfa_status_t
1066bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
1067{
1068 bfa_trc(fcxp->fcxp_mod->bfa, fcxp->fcxp_tag);
d4b671c5 1069 WARN_ON(1);
a36c61f9
KG		 1070 return BFA_STATUS_OK;
1071}
1072
1073void
1074bfa_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
d4b671c5 1084 WARN_ON(!list_empty(&mod->fcxp_free_q));
a36c61f9
KG		 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
1100void
1101bfa_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
d4b671c5 1105 WARN_ON(!bfa_q_is_on_q(&mod->wait_q, wqe));
a36c61f9
KG		 1106 list_del(&wqe->qe);
1107}
1108
1109void
1110bfa_fcxp_discard(struct bfa_fcxp_s *fcxp)
1111{
5fbe25c7 1112 /*
a36c61f9
KG		 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
a36c61f9
KG		 1126void
1127bfa_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);
d4b671c5 1136 WARN_ON(1);
a36c61f9
KG		 1137 }
1138}
1139
1140u32
1141bfa_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
3fd45980
KG		 1148void
1149bfa_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}
a36c61f9 1160
5fbe25c7 1161/*
a36c61f9
KG		 1162 * BFA LPS state machine functions
1163 */
1164
5fbe25c7 1165/*
a36c61f9
KG		 1166 * Init state -- no login
1167 */
1168static void
1169bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event)
1170{
3fd45980 1171 bfa_trc(lps->bfa, lps->bfa_tag);
a36c61f9
KG		 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
5fbe25c7 1217/*
a36c61f9
KG		 1218 * login is in progress -- awaiting response from firmware
1219 */
1220static void
1221bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
1222{
3fd45980 1223 bfa_trc(lps->bfa, lps->bfa_tag);
a36c61f9
KG		 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");
b704495c
KG		 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);
a36c61f9
KG		 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:
be540a99 1257 case BFA_LPS_SM_DELETE:
a36c61f9
KG		 1258 bfa_sm_set_state(lps, bfa_lps_sm_init);
1259 break;
1260
b704495c
KG		 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
a36c61f9
KG		 1266 default:
1267 bfa_sm_fault(lps->bfa, event);
1268 }
1269}
1270
5fbe25c7 1271/*
a36c61f9
KG		 1272 * login pending - awaiting space in request queue
1273 */
1274static void
1275bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1276{
3fd45980 1277 bfa_trc(lps->bfa, lps->bfa_tag);
a36c61f9
KG		 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:
be540a99 1286 case BFA_LPS_SM_DELETE:
a36c61f9
KG		 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
5fbe25c7 1304/*
a36c61f9
KG		 1305 * login complete
1306 */
1307static void
1308bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event)
1309{
3fd45980 1310 bfa_trc(lps->bfa, lps->bfa_tag);
a36c61f9
KG		 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
b704495c
KG		 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
a36c61f9
KG		 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
8f4bfadd 1353/*
b704495c
KG		 1354 * login complete
1355 */
1356static void
1357bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1358{
3fd45980 1359 bfa_trc(lps->bfa, lps->bfa_tag);
b704495c
KG		 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
5fbe25c7 1395/*
a36c61f9
KG		 1396 * logout in progress - awaiting firmware response
1397 */
1398static void
1399bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event)
1400{
3fd45980 1401 bfa_trc(lps->bfa, lps->bfa_tag);
a36c61f9
KG		 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:
be540a99 1411 case BFA_LPS_SM_DELETE:
a36c61f9
KG		 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
5fbe25c7 1420/*
a36c61f9
KG		 1421 * logout pending -- awaiting space in request queue
1422 */
1423static void
1424bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event event)
1425{
3fd45980 1426 bfa_trc(lps->bfa, lps->bfa_tag);
a36c61f9
KG		 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:
be540a99 1436 case BFA_LPS_SM_DELETE:
a36c61f9
KG		 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
5fbe25c7 1448/*
a36c61f9
KG		 1449 * lps_pvt BFA LPS private functions
1450 */
1451
5fbe25c7 1452/*
a36c61f9
KG		 1453 * return memory requirement
1454 */
1455static void
4507025d
KG		 1456bfa_lps_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
1457 struct bfa_s *bfa)
a36c61f9 1458{
4507025d
KG		 1459 struct bfa_mem_kva_s *lps_kva = BFA_MEM_LPS_KVA(bfa);
1460
a36c61f9 1461 if (cfg->drvcfg.min_cfg)
4507025d
KG		 1462 bfa_mem_kva_setup(minfo, lps_kva,
1463 sizeof(struct bfa_lps_s) * BFA_LPS_MIN_LPORTS);
a36c61f9 1464 else
4507025d
KG		 1465 bfa_mem_kva_setup(minfo, lps_kva,
1466 sizeof(struct bfa_lps_s) * BFA_LPS_MAX_LPORTS);
a36c61f9
KG		 1467}
1468
5fbe25c7 1469/*
a36c61f9
KG		 1470 * bfa module attach at initialization time
1471 */
1472static void
1473bfa_lps_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4507025d 1474 struct bfa_pcidev_s *pcidev)
a36c61f9
KG		 1475{
1476 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa);
1477 struct bfa_lps_s *lps;
1478 int i;
1479
a36c61f9
KG		 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;
4507025d 1485 mod->lps_arr = lps = (struct bfa_lps_s *) bfa_mem_kva_curp(mod);
a36c61f9 1486
4507025d 1487 bfa_mem_kva_curp(mod) += mod->num_lps * sizeof(struct bfa_lps_s);
a36c61f9
KG		 1488
1489 INIT_LIST_HEAD(&mod->lps_free_q);
1490 INIT_LIST_HEAD(&mod->lps_active_q);
3fd45980 1491 INIT_LIST_HEAD(&mod->lps_login_q);
a36c61f9
KG		 1492
1493 for (i = 0; i < mod->num_lps; i++, lps++) {
1494 lps->bfa = bfa;
3fd45980 1495 lps->bfa_tag = (u8) i;
a36c61f9
KG		 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
1502static void
1503bfa_lps_detach(struct bfa_s *bfa)
1504{
1505}
1506
1507static void
1508bfa_lps_start(struct bfa_s *bfa)
1509{
1510}
1511
1512static void
1513bfa_lps_stop(struct bfa_s *bfa)
1514{
1515}
1516
5fbe25c7 1517/*
a36c61f9
KG		 1518 * IOC in disabled state -- consider all lps offline
1519 */
1520static void
1521bfa_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 }
3fd45980
KG		 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);
a36c61f9
KG		 1536}
1537
5fbe25c7 1538/*
a36c61f9
KG		 1539 * Firmware login response
1540 */
1541static void
1542bfa_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
3fd45980
KG		 1547 WARN_ON(rsp->bfa_tag >= mod->num_lps);
1548 lps = BFA_LPS_FROM_TAG(mod, rsp->bfa_tag);
a36c61f9
KG		 1549
1550 lps->status = rsp->status;
1551 switch (rsp->status) {
1552 case BFA_STATUS_OK:
3fd45980 1553 lps->fw_tag = rsp->fw_tag;
a36c61f9 1554 lps->fport = rsp->f_port;
b704495c
KG		 1555 if (lps->fport)
1556 lps->lp_pid = rsp->lp_pid;
a36c61f9 1557 lps->npiv_en = rsp->npiv_en;
ba816ea8 1558 lps->pr_bbcred = be16_to_cpu(rsp->bb_credit);
a36c61f9
KG		 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;
be540a99 1565 lps->pr_bbscn = rsp->bb_scn;
a36c61f9
KG		 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
3fd45980
KG		 1580 case BFA_STATUS_VPORT_MAX:
1581 if (!rsp->ext_status)
1582 bfa_lps_no_res(lps, rsp->ext_status);
1583 break;
1584
a36c61f9
KG		 1585 default:
1586 /* Nothing to do with other status */
1587 break;
1588 }
1589
3fd45980
KG		 1590 list_del(&lps->qe);
1591 list_add_tail(&lps->qe, &mod->lps_active_q);
a36c61f9
KG		 1592 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1593}
1594
3fd45980
KG		 1595static void
1596bfa_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
5fbe25c7 1620/*
a36c61f9
KG		 1621 * Firmware logout response
1622 */
1623static void
1624bfa_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
3fd45980
KG		 1629 WARN_ON(rsp->bfa_tag >= mod->num_lps);
1630 lps = BFA_LPS_FROM_TAG(mod, rsp->bfa_tag);
a36c61f9
KG		 1631
1632 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1633}
1634
5fbe25c7 1635/*
a36c61f9
KG		 1636 * Firmware received a Clear virtual link request (for FCoE)
1637 */
1638static void
1639bfa_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
3fd45980 1644 lps = BFA_LPS_FROM_TAG(mod, cvl->bfa_tag);
a36c61f9
KG		 1645
1646 bfa_sm_send_event(lps, BFA_LPS_SM_RX_CVL);
1647}
1648
5fbe25c7 1649/*
a36c61f9
KG		 1650 * Space is available in request queue, resume queueing request to firmware.
1651 */
1652static void
1653bfa_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
5fbe25c7 1660/*
a36c61f9
KG		 1661 * lps is freed -- triggered by vport delete
1662 */
1663static void
1664bfa_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
5fbe25c7 1673/*
a36c61f9
KG		 1674 * send login request to firmware
1675 */
1676static void
1677bfa_lps_send_login(struct bfa_lps_s *lps)
1678{
3fd45980 1679 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(lps->bfa);
a36c61f9
KG		 1680 struct bfi_lps_login_req_s *m;
1681
1682 m = bfa_reqq_next(lps->bfa, lps->reqq);
d4b671c5 1683 WARN_ON(!m);
a36c61f9
KG		 1684
1685 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGIN_REQ,
3fd45980 1686 bfa_fn_lpu(lps->bfa));
a36c61f9 1687
3fd45980 1688 m->bfa_tag = lps->bfa_tag;
a36c61f9 1689 m->alpa = lps->alpa;
ba816ea8 1690 m->pdu_size = cpu_to_be16(lps->pdusz);
a36c61f9
KG		 1691 m->pwwn = lps->pwwn;
1692 m->nwwn = lps->nwwn;
1693 m->fdisc = lps->fdisc;
1694 m->auth_en = lps->auth_en;
be540a99 1695 m->bb_scn = lps->bb_scn;
a36c61f9 1696
3fd45980
KG		 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);
a36c61f9
KG		 1700}
1701
5fbe25c7 1702/*
a36c61f9
KG		 1703 * send logout request to firmware
1704 */
1705static void
1706bfa_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);
d4b671c5 1711 WARN_ON(!m);
a36c61f9
KG		 1712
1713 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGOUT_REQ,
3fd45980 1714 bfa_fn_lpu(lps->bfa));
a36c61f9 1715
3fd45980 1716 m->fw_tag = lps->fw_tag;
a36c61f9 1717 m->port_name = lps->pwwn;
3fd45980 1718 bfa_reqq_produce(lps->bfa, lps->reqq, m->mh);
a36c61f9
KG		 1719}
1720
8f4bfadd 1721/*
b704495c
KG		 1722 * send n2n pid set request to firmware
1723 */
1724static void
1725bfa_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);
d4b671c5 1730 WARN_ON(!m);
b704495c
KG		 1731
1732 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_N2N_PID_REQ,
3fd45980 1733 bfa_fn_lpu(lps->bfa));
b704495c 1734
3fd45980 1735 m->fw_tag = lps->fw_tag;
b704495c 1736 m->lp_pid = lps->lp_pid;
3fd45980 1737 bfa_reqq_produce(lps->bfa, lps->reqq, m->mh);
b704495c
KG		 1738}
1739
5fbe25c7 1740/*
a36c61f9
KG		 1741 * Indirect login completion handler for non-fcs
1742 */
1743static void
1744bfa_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
5fbe25c7 1757/*
a36c61f9
KG		 1758 * Login completion handler -- direct call for fcs, queue for others
1759 */
1760static void
1761bfa_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
5fbe25c7 1775/*
a36c61f9
KG		 1776 * Indirect logout completion handler for non-fcs
1777 */
1778static void
1779bfa_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
5fbe25c7 1790/*
a36c61f9
KG		 1791 * Logout completion handler -- direct call for fcs, queue for others
1792 */
1793static void
1794bfa_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
5fbe25c7 1805/*
a36c61f9
KG		 1806 * Clear virtual link completion handler for non-fcs
1807 */
1808static void
1809bfa_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
5fbe25c7 1821/*
a36c61f9
KG		 1822 * Received Clear virtual link event --direct call for fcs,
1823 * queue for others
1824 */
1825static void
1826bfa_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
5fbe25c7 1841/*
a36c61f9
KG		 1842 * lps_public BFA LPS public functions
1843 */
1844
1845u32
1846bfa_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
5fbe25c7 1854/*
a36c61f9
KG		 1855 * Allocate a lport srvice tag.
1856 */
1857struct bfa_lps_s *
1858bfa_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
5fbe25c7 1874/*
a36c61f9
KG		 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 */
1878void
1879bfa_lps_delete(struct bfa_lps_s *lps)
1880{
1881 bfa_sm_send_event(lps, BFA_LPS_SM_DELETE);
1882}
1883
5fbe25c7 1884/*
a36c61f9
KG		 1885 * Initiate a lport login.
1886 */
1887void
1888bfa_lps_flogi(struct bfa_lps_s *lps, void *uarg, u8 alpa, u16 pdusz,
be540a99 1889 wwn_t pwwn, wwn_t nwwn, bfa_boolean_t auth_en, uint8_t bb_scn)
a36c61f9
KG		 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;
be540a99 1898 lps->bb_scn = bb_scn;
a36c61f9
KG		 1899 bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN);
1900}
1901
5fbe25c7 1902/*
a36c61f9
KG		 1903 * Initiate a lport fdisc login.
1904 */
1905void
1906bfa_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
a36c61f9 1919
5fbe25c7 1920/*
a36c61f9
KG		 1921 * Initiate a lport FDSIC logout.
1922 */
1923void
1924bfa_lps_fdisclogo(struct bfa_lps_s *lps)
1925{
1926 bfa_sm_send_event(lps, BFA_LPS_SM_LOGOUT);
1927}
1928
3fd45980
KG		 1929u8
1930bfa_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}
a36c61f9 1936
5fbe25c7 1937/*
a36c61f9
KG		 1938 * Return lport services tag given the pid
1939 */
1940u8
1941bfa_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)
3fd45980 1949 return lps->bfa_tag;
a36c61f9
KG		 1950 }
1951
1952 /* Return base port tag anyway */
1953 return 0;
1954}
1955
a36c61f9 1956
5fbe25c7 1957/*
a36c61f9
KG		 1958 * return port id assigned to the base lport
1959 */
1960u32
1961bfa_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
8f4bfadd 1968/*
b704495c
KG		 1969 * Set PID in case of n2n (which is assigned during PLOGI)
1970 */
1971void
1972bfa_lps_set_n2n_pid(struct bfa_lps_s *lps, uint32_t n2n_pid)
1973{
3fd45980 1974 bfa_trc(lps->bfa, lps->bfa_tag);
b704495c
KG		 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
5fbe25c7 1981/*
a36c61f9
KG		 1982 * LPS firmware message class handler.
1983 */
1984void
1985bfa_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) {
43ffdf4d 1993 case BFI_LPS_I2H_LOGIN_RSP:
a36c61f9
KG		 1994 bfa_lps_login_rsp(bfa, msg.login_rsp);
1995 break;
1996
43ffdf4d 1997 case BFI_LPS_I2H_LOGOUT_RSP:
a36c61f9
KG		 1998 bfa_lps_logout_rsp(bfa, msg.logout_rsp);
1999 break;
2000
43ffdf4d 2001 case BFI_LPS_I2H_CVL_EVENT:
a36c61f9
KG		 2002 bfa_lps_rx_cvl_event(bfa, msg.cvl_event);
2003 break;
2004
2005 default:
2006 bfa_trc(bfa, m->mhdr.msg_id);
d4b671c5 2007 WARN_ON(1);
a36c61f9
KG		 2008 }
2009}
2010
7826f304
KG		 2011static void
2012bfa_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
5fbe25c7 2029/*
a36c61f9
KG		 2030 * FC PORT state machine functions
2031 */
2032static void
2033bfa_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:
5fbe25c7 2040 /*
a36c61f9
KG		 2041 * Start event after IOC is configured and BFA is started.
2042 */
f3a060ca
KG		 2043 fcport->use_flash_cfg = BFA_TRUE;
2044
a36c61f9
KG		 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:
5fbe25c7 2056 /*
a36c61f9
KG		 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:
5fbe25c7 2064 /*
a36c61f9
KG		 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
2080static void
2081bfa_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:
5fbe25c7 2100 /*
a36c61f9
KG		 2101 * Already enable is in progress.
2102 */
2103 break;
2104
2105 case BFA_FCPORT_SM_DISABLE:
5fbe25c7 2106 /*
a36c61f9
KG		 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);
88166242 2115 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
a36c61f9 2116 "Base port disabled: WWN = %s\n", pwwn_buf);
7826f304 2117 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
a36c61f9
KG		 2118 break;
2119
2120 case BFA_FCPORT_SM_LINKUP:
2121 case BFA_FCPORT_SM_LINKDOWN:
5fbe25c7 2122 /*
a36c61f9
KG		 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
2138static void
2139bfa_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
d4b671c5 2156 WARN_ON(!fcport->event_cbfn);
a36c61f9
KG		 2157 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2158 break;
2159
2160 case BFA_FCPORT_SM_ENABLE:
5fbe25c7 2161 /*
a36c61f9
KG		 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);
88166242 2176 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
a36c61f9 2177 "Base port disabled: WWN = %s\n", pwwn_buf);
7826f304 2178 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
a36c61f9
KG		 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
2194static void
2195bfa_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);
d4b671c5 2208 WARN_ON(!fcport->event_cbfn);
a36c61f9
KG		 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);
88166242 2230 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
a36c61f9 2231 "Base port online: WWN = %s\n", pwwn_buf);
7826f304 2232 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ONLINE);
a36c61f9
KG		 2233 break;
2234
2235 case BFA_FCPORT_SM_LINKDOWN:
5fbe25c7 2236 /*
a36c61f9
KG		 2237 * Possible to get link down event.
2238 */
2239 break;
2240
2241 case BFA_FCPORT_SM_ENABLE:
5fbe25c7 2242 /*
a36c61f9
KG		 2243 * Already enabled.
2244 */
2245 break;
2246
2247 case BFA_FCPORT_SM_DISABLE:
2248 if (bfa_fcport_send_disable(fcport))
2249 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2250 else
2251 bfa_sm_set_state(fcport,
2252 bfa_fcport_sm_disabling_qwait);
2253
2254 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2255 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2256 wwn2str(pwwn_buf, fcport->pwwn);
88166242 2257 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
a36c61f9 2258 "Base port disabled: WWN = %s\n", pwwn_buf);
7826f304 2259 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
a36c61f9
KG		 2260 break;
2261
2262 case BFA_FCPORT_SM_STOP:
2263 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2264 break;
2265
2266 case BFA_FCPORT_SM_HWFAIL:
2267 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2268 break;
2269
2270 default:
2271 bfa_sm_fault(fcport->bfa, event);
2272 }
2273}
2274
2275static void
2276bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
2277 enum bfa_fcport_sm_event event)
2278{
2279 char pwwn_buf[BFA_STRING_32];
2280 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2281
2282 bfa_trc(fcport->bfa, event);
2283
2284 switch (event) {
2285 case BFA_FCPORT_SM_ENABLE:
5fbe25c7 2286 /*
a36c61f9
KG		 2287 * Already enabled.
2288 */
2289 break;
2290
2291 case BFA_FCPORT_SM_DISABLE:
2292 if (bfa_fcport_send_disable(fcport))
2293 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2294 else
2295 bfa_sm_set_state(fcport,
2296 bfa_fcport_sm_disabling_qwait);
2297
2298 bfa_fcport_reset_linkinfo(fcport);
2299 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2300 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2301 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2302 wwn2str(pwwn_buf, fcport->pwwn);
88166242 2303 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
a36c61f9 2304 "Base port offline: WWN = %s\n", pwwn_buf);
7826f304 2305 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
88166242 2306 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
a36c61f9 2307 "Base port disabled: WWN = %s\n", pwwn_buf);
7826f304 2308 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
a36c61f9
KG		 2309 break;
2310
2311 case BFA_FCPORT_SM_LINKDOWN:
2312 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
2313 bfa_fcport_reset_linkinfo(fcport);
2314 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2315 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2316 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
2317 wwn2str(pwwn_buf, fcport->pwwn);
7826f304 2318 if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
88166242 2319 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
a36c61f9 2320 "Base port offline: WWN = %s\n", pwwn_buf);
7826f304
KG		 2321 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
2322 } else {
88166242 2323 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
a36c61f9
KG		 2324 "Base port (WWN = %s) "
2325 "lost fabric connectivity\n", pwwn_buf);
7826f304
KG		 2326 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2327 }
a36c61f9
KG		 2328 break;
2329
2330 case BFA_FCPORT_SM_STOP:
2331 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2332 bfa_fcport_reset_linkinfo(fcport);
2333 wwn2str(pwwn_buf, fcport->pwwn);
7826f304 2334 if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
88166242 2335 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
a36c61f9 2336 "Base port offline: WWN = %s\n", pwwn_buf);
7826f304
KG		 2337 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
2338 } else {
88166242 2339 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
a36c61f9
KG		 2340 "Base port (WWN = %s) "
2341 "lost fabric connectivity\n", pwwn_buf);
7826f304
KG		 2342 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2343 }
a36c61f9
KG		 2344 break;
2345
2346 case BFA_FCPORT_SM_HWFAIL:
2347 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2348 bfa_fcport_reset_linkinfo(fcport);
2349 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
2350 wwn2str(pwwn_buf, fcport->pwwn);
7826f304 2351 if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
88166242 2352 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
a36c61f9 2353 "Base port offline: WWN = %s\n", pwwn_buf);
7826f304
KG		 2354 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
2355 } else {
88166242 2356 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
a36c61f9
KG		 2357 "Base port (WWN = %s) "
2358 "lost fabric connectivity\n", pwwn_buf);
7826f304
KG		 2359 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
2360 }
a36c61f9
KG		 2361 break;
2362
2363 default:
2364 bfa_sm_fault(fcport->bfa, event);
2365 }
2366}
2367
2368static void
2369bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
2370 enum bfa_fcport_sm_event event)
2371{
2372 bfa_trc(fcport->bfa, event);
2373
2374 switch (event) {
2375 case BFA_FCPORT_SM_QRESUME:
2376 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2377 bfa_fcport_send_disable(fcport);
2378 break;
2379
2380 case BFA_FCPORT_SM_STOP:
2381 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2382 bfa_reqq_wcancel(&fcport->reqq_wait);
2383 break;
2384
2385 case BFA_FCPORT_SM_ENABLE:
2386 bfa_sm_set_state(fcport, bfa_fcport_sm_toggling_qwait);
2387 break;
2388
2389 case BFA_FCPORT_SM_DISABLE:
5fbe25c7 2390 /*
a36c61f9
KG		 2391 * Already being disabled.
2392 */
2393 break;
2394
2395 case BFA_FCPORT_SM_LINKUP:
2396 case BFA_FCPORT_SM_LINKDOWN:
5fbe25c7 2397 /*
a36c61f9
KG		 2398 * Possible to get link events when doing back-to-back
2399 * enable/disables.
2400 */
2401 break;
2402
2403 case BFA_FCPORT_SM_HWFAIL:
2404 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2405 bfa_reqq_wcancel(&fcport->reqq_wait);
2406 break;
2407
2408 default:
2409 bfa_sm_fault(fcport->bfa, event);
2410 }
2411}
2412
2413static void
2414bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport,
2415 enum bfa_fcport_sm_event event)
2416{
2417 bfa_trc(fcport->bfa, event);
2418
2419 switch (event) {
2420 case BFA_FCPORT_SM_QRESUME:
2421 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
2422 bfa_fcport_send_disable(fcport);
2423 if (bfa_fcport_send_enable(fcport))
2424 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2425 else
2426 bfa_sm_set_state(fcport,
2427 bfa_fcport_sm_enabling_qwait);
2428 break;
2429
2430 case BFA_FCPORT_SM_STOP:
2431 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2432 bfa_reqq_wcancel(&fcport->reqq_wait);
2433 break;
2434
2435 case BFA_FCPORT_SM_ENABLE:
2436 break;
2437
2438 case BFA_FCPORT_SM_DISABLE:
2439 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
2440 break;
2441
2442 case BFA_FCPORT_SM_LINKUP:
2443 case BFA_FCPORT_SM_LINKDOWN:
5fbe25c7 2444 /*
a36c61f9
KG		 2445 * Possible to get link events when doing back-to-back
2446 * enable/disables.
2447 */
2448 break;
2449
2450 case BFA_FCPORT_SM_HWFAIL:
2451 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2452 bfa_reqq_wcancel(&fcport->reqq_wait);
2453 break;
2454
2455 default:
2456 bfa_sm_fault(fcport->bfa, event);
2457 }
2458}
2459
2460static void
2461bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
2462 enum bfa_fcport_sm_event event)
2463{
2464 char pwwn_buf[BFA_STRING_32];
2465 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2466 bfa_trc(fcport->bfa, event);
2467
2468 switch (event) {
2469 case BFA_FCPORT_SM_FWRSP:
2470 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2471 break;
2472
2473 case BFA_FCPORT_SM_DISABLE:
5fbe25c7 2474 /*
a36c61f9
KG		 2475 * Already being disabled.
2476 */
2477 break;
2478
2479 case BFA_FCPORT_SM_ENABLE:
2480 if (bfa_fcport_send_enable(fcport))
2481 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2482 else
2483 bfa_sm_set_state(fcport,
2484 bfa_fcport_sm_enabling_qwait);
2485
2486 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2487 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2488 wwn2str(pwwn_buf, fcport->pwwn);
88166242 2489 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
a36c61f9 2490 "Base port enabled: WWN = %s\n", pwwn_buf);
7826f304 2491 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
a36c61f9
KG		 2492 break;
2493
2494 case BFA_FCPORT_SM_STOP:
2495 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2496 break;
2497
2498 case BFA_FCPORT_SM_LINKUP:
2499 case BFA_FCPORT_SM_LINKDOWN:
5fbe25c7 2500 /*
a36c61f9
KG		 2501 * Possible to get link events when doing back-to-back
2502 * enable/disables.
2503 */
2504 break;
2505
2506 case BFA_FCPORT_SM_HWFAIL:
2507 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2508 break;
2509
2510 default:
2511 bfa_sm_fault(fcport->bfa, event);
2512 }
2513}
2514
2515static void
2516bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
2517 enum bfa_fcport_sm_event event)
2518{
2519 char pwwn_buf[BFA_STRING_32];
2520 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
2521 bfa_trc(fcport->bfa, event);
2522
2523 switch (event) {
2524 case BFA_FCPORT_SM_START:
5fbe25c7 2525 /*
a36c61f9
KG		 2526 * Ignore start event for a port that is disabled.
2527 */
2528 break;
2529
2530 case BFA_FCPORT_SM_STOP:
2531 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
2532 break;
2533
2534 case BFA_FCPORT_SM_ENABLE:
2535 if (bfa_fcport_send_enable(fcport))
2536 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2537 else
2538 bfa_sm_set_state(fcport,
2539 bfa_fcport_sm_enabling_qwait);
2540
2541 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2542 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2543 wwn2str(pwwn_buf, fcport->pwwn);
88166242 2544 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
a36c61f9 2545 "Base port enabled: WWN = %s\n", pwwn_buf);
7826f304 2546 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
a36c61f9
KG		 2547 break;
2548
2549 case BFA_FCPORT_SM_DISABLE:
5fbe25c7 2550 /*
a36c61f9
KG		 2551 * Already disabled.
2552 */
2553 break;
2554
2555 case BFA_FCPORT_SM_HWFAIL:
2556 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
2557 break;
2558
2559 default:
2560 bfa_sm_fault(fcport->bfa, event);
2561 }
2562}
2563
2564static void
2565bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
2566 enum bfa_fcport_sm_event event)
2567{
2568 bfa_trc(fcport->bfa, event);
2569
2570 switch (event) {
2571 case BFA_FCPORT_SM_START:
2572 if (bfa_fcport_send_enable(fcport))
2573 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2574 else
2575 bfa_sm_set_state(fcport,
2576 bfa_fcport_sm_enabling_qwait);
2577 break;
2578
2579 default:
5fbe25c7 2580 /*
a36c61f9
KG		 2581 * Ignore all other events.
2582 */
2583 ;
2584 }
2585}
2586
5fbe25c7 2587/*
a36c61f9
KG		 2588 * Port is enabled. IOC is down/failed.
2589 */
2590static void
2591bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
2592 enum bfa_fcport_sm_event event)
2593{
2594 bfa_trc(fcport->bfa, event);
2595
2596 switch (event) {
2597 case BFA_FCPORT_SM_START:
2598 if (bfa_fcport_send_enable(fcport))
2599 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
2600 else
2601 bfa_sm_set_state(fcport,
2602 bfa_fcport_sm_enabling_qwait);
2603 break;
2604
2605 default:
5fbe25c7 2606 /*
a36c61f9
KG		 2607 * Ignore all events.
2608 */
2609 ;
2610 }
2611}
2612
5fbe25c7 2613/*
a36c61f9
KG		 2614 * Port is disabled. IOC is down/failed.
2615 */
2616static void
2617bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
2618 enum bfa_fcport_sm_event event)
2619{
2620 bfa_trc(fcport->bfa, event);
2621
2622 switch (event) {
2623 case BFA_FCPORT_SM_START:
2624 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
2625 break;
2626
2627 case BFA_FCPORT_SM_ENABLE:
2628 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
2629 break;
2630
2631 default:
5fbe25c7 2632 /*
a36c61f9
KG		 2633 * Ignore all events.
2634 */
2635 ;
2636 }
2637}
2638
5fbe25c7 2639/*
a36c61f9
KG		 2640 * Link state is down
2641 */
2642static void
2643bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
2644 enum bfa_fcport_ln_sm_event event)
2645{
2646 bfa_trc(ln->fcport->bfa, event);
2647
2648 switch (event) {
2649 case BFA_FCPORT_LN_SM_LINKUP:
2650 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2651 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2652 break;
2653
2654 default:
2655 bfa_sm_fault(ln->fcport->bfa, event);
2656 }
2657}
2658
5fbe25c7 2659/*
a36c61f9
KG		 2660 * Link state is waiting for down notification
2661 */
2662static void
2663bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
2664 enum bfa_fcport_ln_sm_event event)
2665{
2666 bfa_trc(ln->fcport->bfa, event);
2667
2668 switch (event) {
2669 case BFA_FCPORT_LN_SM_LINKUP:
2670 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2671 break;
2672
2673 case BFA_FCPORT_LN_SM_NOTIFICATION:
2674 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
2675 break;
2676
2677 default:
2678 bfa_sm_fault(ln->fcport->bfa, event);
2679 }
2680}
2681
5fbe25c7 2682/*
a36c61f9
KG		 2683 * Link state is waiting for down notification and there is a pending up
2684 */
2685static void
2686bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
2687 enum bfa_fcport_ln_sm_event event)
2688{
2689 bfa_trc(ln->fcport->bfa, event);
2690
2691 switch (event) {
2692 case BFA_FCPORT_LN_SM_LINKDOWN:
2693 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2694 break;
2695
2696 case BFA_FCPORT_LN_SM_NOTIFICATION:
2697 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
2698 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP);
2699 break;
2700
2701 default:
2702 bfa_sm_fault(ln->fcport->bfa, event);
2703 }
2704}
2705
5fbe25c7 2706/*
a36c61f9
KG		 2707 * Link state is up
2708 */
2709static void
2710bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
2711 enum bfa_fcport_ln_sm_event event)
2712{
2713 bfa_trc(ln->fcport->bfa, event);
2714
2715 switch (event) {
2716 case BFA_FCPORT_LN_SM_LINKDOWN:
2717 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2718 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2719 break;
2720
2721 default:
2722 bfa_sm_fault(ln->fcport->bfa, event);
2723 }
2724}
2725
5fbe25c7 2726/*
a36c61f9
KG		 2727 * Link state is waiting for up notification
2728 */
2729static void
2730bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
2731 enum bfa_fcport_ln_sm_event event)
2732{
2733 bfa_trc(ln->fcport->bfa, event);
2734
2735 switch (event) {
2736 case BFA_FCPORT_LN_SM_LINKDOWN:
2737 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2738 break;
2739
2740 case BFA_FCPORT_LN_SM_NOTIFICATION:
2741 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up);
2742 break;
2743
2744 default:
2745 bfa_sm_fault(ln->fcport->bfa, event);
2746 }
2747}
2748
5fbe25c7 2749/*
a36c61f9
KG		 2750 * Link state is waiting for up notification and there is a pending down
2751 */
2752static void
2753bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
2754 enum bfa_fcport_ln_sm_event event)
2755{
2756 bfa_trc(ln->fcport->bfa, event);
2757
2758 switch (event) {
2759 case BFA_FCPORT_LN_SM_LINKUP:
2760 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_up_nf);
2761 break;
2762
2763 case BFA_FCPORT_LN_SM_NOTIFICATION:
2764 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
2765 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2766 break;
2767
2768 default:
2769 bfa_sm_fault(ln->fcport->bfa, event);
2770 }
2771}
2772
5fbe25c7 2773/*
a36c61f9
KG		 2774 * Link state is waiting for up notification and there are pending down and up
2775 */
2776static void
2777bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
2778 enum bfa_fcport_ln_sm_event event)
2779{
2780 bfa_trc(ln->fcport->bfa, event);
2781
2782 switch (event) {
2783 case BFA_FCPORT_LN_SM_LINKDOWN:
2784 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
2785 break;
2786
2787 case BFA_FCPORT_LN_SM_NOTIFICATION:
2788 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
2789 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN);
2790 break;
2791
2792 default:
2793 bfa_sm_fault(ln->fcport->bfa, event);
2794 }
2795}
2796
a36c61f9
KG		 2797static void
2798__bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete)
2799{
2800 struct bfa_fcport_ln_s *ln = cbarg;
2801
2802 if (complete)
2803 ln->fcport->event_cbfn(ln->fcport->event_cbarg, ln->ln_event);
2804 else
2805 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2806}
2807
5fbe25c7 2808/*
a36c61f9
KG		 2809 * Send SCN notification to upper layers.
2810 * trunk - false if caller is fcport to ignore fcport event in trunked mode
2811 */
2812static void
2813bfa_fcport_scn(struct bfa_fcport_s *fcport, enum bfa_port_linkstate event,
2814 bfa_boolean_t trunk)
2815{
2816 if (fcport->cfg.trunked && !trunk)
2817 return;
2818
2819 switch (event) {
2820 case BFA_PORT_LINKUP:
2821 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP);
2822 break;
2823 case BFA_PORT_LINKDOWN:
2824 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
2825 break;
2826 default:
d4b671c5 2827 WARN_ON(1);
a36c61f9
KG		 2828 }
2829}
2830
2831static void
2832bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_port_linkstate event)
2833{
2834 struct bfa_fcport_s *fcport = ln->fcport;
2835
2836 if (fcport->bfa->fcs) {
2837 fcport->event_cbfn(fcport->event_cbarg, event);
2838 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
2839 } else {
2840 ln->ln_event = event;
2841 bfa_cb_queue(fcport->bfa, &ln->ln_qe,
2842 __bfa_cb_fcport_event, ln);
2843 }
2844}
2845
2846#define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \
2847 BFA_CACHELINE_SZ))
2848
2849static void
4507025d
KG		 2850bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
2851 struct bfa_s *bfa)
a36c61f9 2852{
4507025d
KG		 2853 struct bfa_mem_dma_s *fcport_dma = BFA_MEM_FCPORT_DMA(bfa);
2854
2855 bfa_mem_dma_setup(minfo, fcport_dma, FCPORT_STATS_DMA_SZ);
a36c61f9
KG		 2856}
2857
2858static void
2859bfa_fcport_qresume(void *cbarg)
2860{
2861 struct bfa_fcport_s *fcport = cbarg;
2862
2863 bfa_sm_send_event(fcport, BFA_FCPORT_SM_QRESUME);
2864}
2865
2866static void
4507025d 2867bfa_fcport_mem_claim(struct bfa_fcport_s *fcport)
a36c61f9 2868{
4507025d 2869 struct bfa_mem_dma_s *fcport_dma = &fcport->fcport_dma;
a36c61f9 2870
4507025d
KG		 2871 fcport->stats_kva = bfa_mem_dma_virt(fcport_dma);
2872 fcport->stats_pa = bfa_mem_dma_phys(fcport_dma);
2873 fcport->stats = (union bfa_fcport_stats_u *)
2874 bfa_mem_dma_virt(fcport_dma);
a36c61f9
KG		 2875}
2876
5fbe25c7 2877/*
a36c61f9
KG		 2878 * Memory initialization.
2879 */
2880static void
2881bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4507025d 2882 struct bfa_pcidev_s *pcidev)
a36c61f9
KG		 2883{
2884 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
2885 struct bfa_port_cfg_s *port_cfg = &fcport->cfg;
2886 struct bfa_fcport_ln_s *ln = &fcport->ln;
f16a1750 2887 struct timeval tv;
a36c61f9 2888
a36c61f9
KG		 2889 fcport->bfa = bfa;
2890 ln->fcport = fcport;
2891
4507025d 2892 bfa_fcport_mem_claim(fcport);
a36c61f9
KG		 2893
2894 bfa_sm_set_state(fcport, bfa_fcport_sm_uninit);
2895 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
2896
5fbe25c7 2897 /*
a36c61f9
KG		 2898 * initialize time stamp for stats reset
2899 */
f16a1750 2900 do_gettimeofday(&tv);
a36c61f9
KG		 2901 fcport->stats_reset_time = tv.tv_sec;
2902
5fbe25c7 2903 /*
a36c61f9
KG		 2904 * initialize and set default configuration
2905 */
2906 port_cfg->topology = BFA_PORT_TOPOLOGY_P2P;
2907 port_cfg->speed = BFA_PORT_SPEED_AUTO;
2908 port_cfg->trunked = BFA_FALSE;
2909 port_cfg->maxfrsize = 0;
2910
2911 port_cfg->trl_def_speed = BFA_PORT_SPEED_1GBPS;
2912
37ea0558
KG		 2913 INIT_LIST_HEAD(&fcport->stats_pending_q);
2914 INIT_LIST_HEAD(&fcport->statsclr_pending_q);
2915
a36c61f9
KG		 2916 bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport);
2917}
2918
2919static void
2920bfa_fcport_detach(struct bfa_s *bfa)
2921{
2922}
2923
5fbe25c7 2924/*
a36c61f9
KG		 2925 * Called when IOC is ready.
2926 */
2927static void
2928bfa_fcport_start(struct bfa_s *bfa)
2929{
2930 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_START);
2931}
2932
5fbe25c7 2933/*
a36c61f9
KG		 2934 * Called before IOC is stopped.
2935 */
2936static void
2937bfa_fcport_stop(struct bfa_s *bfa)
2938{
2939 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_STOP);
2940 bfa_trunk_iocdisable(bfa);
2941}
2942
5fbe25c7 2943/*
a36c61f9
KG		 2944 * Called when IOC failure is detected.
2945 */
2946static void
2947bfa_fcport_iocdisable(struct bfa_s *bfa)
2948{
2949 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
2950
2951 bfa_sm_send_event(fcport, BFA_FCPORT_SM_HWFAIL);
2952 bfa_trunk_iocdisable(bfa);
2953}
2954
2955static void
2956bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
2957{
2958 struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
2959 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
2960
2961 fcport->speed = pevent->link_state.speed;
2962 fcport->topology = pevent->link_state.topology;
2963
2964 if (fcport->topology == BFA_PORT_TOPOLOGY_LOOP)
2965 fcport->myalpa = 0;
2966
2967 /* QoS Details */
6a18b167
JH		 2968 fcport->qos_attr = pevent->link_state.qos_attr;
2969 fcport->qos_vc_attr = pevent->link_state.vc_fcf.qos_vc_attr;
a36c61f9 2970
5fbe25c7 2971 /*
a36c61f9
KG		 2972 * update trunk state if applicable
2973 */
2974 if (!fcport->cfg.trunked)
2975 trunk->attr.state = BFA_TRUNK_DISABLED;
2976
2977 /* update FCoE specific */
ba816ea8 2978 fcport->fcoe_vlan = be16_to_cpu(pevent->link_state.vc_fcf.fcf.vlan);
a36c61f9
KG		 2979
2980 bfa_trc(fcport->bfa, fcport->speed);
2981 bfa_trc(fcport->bfa, fcport->topology);
2982}
2983
2984static void
2985bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport)
2986{
2987 fcport->speed = BFA_PORT_SPEED_UNKNOWN;
2988 fcport->topology = BFA_PORT_TOPOLOGY_NONE;
be540a99 2989 fcport->bbsc_op_state = BFA_FALSE;
a36c61f9
KG		 2990}
2991
5fbe25c7 2992/*
a36c61f9
KG		 2993 * Send port enable message to firmware.
2994 */
2995static bfa_boolean_t
2996bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
2997{
2998 struct bfi_fcport_enable_req_s *m;
2999
5fbe25c7 3000 /*
a36c61f9
KG		 3001 * Increment message tag before queue check, so that responses to old
3002 * requests are discarded.
3003 */
3004 fcport->msgtag++;
3005
5fbe25c7 3006 /*
a36c61f9
KG		 3007 * check for room in queue to send request now
3008 */
3009 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3010 if (!m) {
3011 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3012 &fcport->reqq_wait);
3013 return BFA_FALSE;
3014 }
3015
3016 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_ENABLE_REQ,
3fd45980 3017 bfa_fn_lpu(fcport->bfa));
a36c61f9
KG		 3018 m->nwwn = fcport->nwwn;
3019 m->pwwn = fcport->pwwn;
3020 m->port_cfg = fcport->cfg;
3021 m->msgtag = fcport->msgtag;
ba816ea8 3022 m->port_cfg.maxfrsize = cpu_to_be16(fcport->cfg.maxfrsize);
f3a060ca 3023 m->use_flash_cfg = fcport->use_flash_cfg;
a36c61f9
KG		 3024 bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa);
3025 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo);
3026 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi);
3027
5fbe25c7 3028 /*
a36c61f9
KG		 3029 * queue I/O message to firmware
3030 */
3fd45980 3031 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, m->mh);
a36c61f9
KG		 3032 return BFA_TRUE;
3033}
3034
5fbe25c7 3035/*
a36c61f9
KG		 3036 * Send port disable message to firmware.
3037 */
3038static bfa_boolean_t
3039bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
3040{
3041 struct bfi_fcport_req_s *m;
3042
5fbe25c7 3043 /*
a36c61f9
KG		 3044 * Increment message tag before queue check, so that responses to old
3045 * requests are discarded.
3046 */
3047 fcport->msgtag++;
3048
5fbe25c7 3049 /*
a36c61f9
KG		 3050 * check for room in queue to send request now
3051 */
3052 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3053 if (!m) {
3054 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3055 &fcport->reqq_wait);
3056 return BFA_FALSE;
3057 }
3058
3059 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_DISABLE_REQ,
3fd45980 3060 bfa_fn_lpu(fcport->bfa));
a36c61f9
KG		 3061 m->msgtag = fcport->msgtag;
3062
5fbe25c7 3063 /*
a36c61f9
KG		 3064 * queue I/O message to firmware
3065 */
3fd45980 3066 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, m->mh);
a36c61f9
KG		 3067
3068 return BFA_TRUE;
3069}
3070
3071static void
3072bfa_fcport_set_wwns(struct bfa_fcport_s *fcport)
3073{
f7f73812
MZ		 3074 fcport->pwwn = fcport->bfa->ioc.attr->pwwn;
3075 fcport->nwwn = fcport->bfa->ioc.attr->nwwn;
a36c61f9
KG		 3076
3077 bfa_trc(fcport->bfa, fcport->pwwn);
3078 bfa_trc(fcport->bfa, fcport->nwwn);
3079}
3080
3081static void
3082bfa_fcport_send_txcredit(void *port_cbarg)
3083{
3084
3085 struct bfa_fcport_s *fcport = port_cbarg;
3086 struct bfi_fcport_set_svc_params_req_s *m;
3087
5fbe25c7 3088 /*
a36c61f9
KG		 3089 * check for room in queue to send request now
3090 */
3091 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3092 if (!m) {
3093 bfa_trc(fcport->bfa, fcport->cfg.tx_bbcredit);
3094 return;
3095 }
3096
3097 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ,
3fd45980 3098 bfa_fn_lpu(fcport->bfa));
ba816ea8 3099 m->tx_bbcredit = cpu_to_be16((u16)fcport->cfg.tx_bbcredit);
be540a99 3100 m->bb_scn = fcport->cfg.bb_scn;
a36c61f9 3101
5fbe25c7 3102 /*
a36c61f9
KG		 3103 * queue I/O message to firmware
3104 */
3fd45980 3105 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, m->mh);
a36c61f9
KG		 3106}
3107
3108static void
3109bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d,
3110 struct bfa_qos_stats_s *s)
3111{
3112 u32 *dip = (u32 *) d;
50444a34 3113 __be32 *sip = (__be32 *) s;
a36c61f9
KG		 3114 int i;
3115
3116 /* Now swap the 32 bit fields */
3117 for (i = 0; i < (sizeof(struct bfa_qos_stats_s)/sizeof(u32)); ++i)
ba816ea8 3118 dip[i] = be32_to_cpu(sip[i]);
a36c61f9
KG		 3119}
3120
3121static void
3122bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d,
3123 struct bfa_fcoe_stats_s *s)
3124{
3125 u32 *dip = (u32 *) d;
50444a34 3126 __be32 *sip = (__be32 *) s;
a36c61f9
KG		 3127 int i;
3128
3129 for (i = 0; i < ((sizeof(struct bfa_fcoe_stats_s))/sizeof(u32));
3130 i = i + 2) {
f16a1750 3131#ifdef __BIG_ENDIAN
ba816ea8
JH		 3132 dip[i] = be32_to_cpu(sip[i]);
3133 dip[i + 1] = be32_to_cpu(sip[i + 1]);
a36c61f9 3134#else
ba816ea8
JH		 3135 dip[i] = be32_to_cpu(sip[i + 1]);
3136 dip[i + 1] = be32_to_cpu(sip[i]);
a36c61f9
KG		 3137#endif
3138 }
3139}
3140
3141static void
3142__bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
3143{
37ea0558
KG		 3144 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
3145 struct bfa_cb_pending_q_s *cb;
3146 struct list_head *qe, *qen;
3147 union bfa_fcport_stats_u *ret;
a36c61f9
KG		 3148
3149 if (complete) {
37ea0558
KG		 3150 struct timeval tv;
3151 if (fcport->stats_status == BFA_STATUS_OK)
3152 do_gettimeofday(&tv);
3153
3154 list_for_each_safe(qe, qen, &fcport->stats_pending_q) {
3155 bfa_q_deq(&fcport->stats_pending_q, &qe);
3156 cb = (struct bfa_cb_pending_q_s *)qe;
3157 if (fcport->stats_status == BFA_STATUS_OK) {
3158 ret = (union bfa_fcport_stats_u *)cb->data;
3159 /* Swap FC QoS or FCoE stats */
3160 if (bfa_ioc_get_fcmode(&fcport->bfa->ioc))
3161 bfa_fcport_qos_stats_swap(&ret->fcqos,
3162 &fcport->stats->fcqos);
3163 else {
3164 bfa_fcport_fcoe_stats_swap(&ret->fcoe,
3165 &fcport->stats->fcoe);
3166 ret->fcoe.secs_reset =
a36c61f9 3167 tv.tv_sec - fcport->stats_reset_time;
37ea0558 3168 }
a36c61f9 3169 }
37ea0558
KG		 3170 bfa_cb_queue_status(fcport->bfa, &cb->hcb_qe,
3171 fcport->stats_status);
a36c61f9 3172 }
37ea0558 3173 fcport->stats_status = BFA_STATUS_OK;
a36c61f9 3174 } else {
37ea0558 3175 INIT_LIST_HEAD(&fcport->stats_pending_q);
a36c61f9
KG		 3176 fcport->stats_status = BFA_STATUS_OK;
3177 }
3178}
3179
3180static void
3181bfa_fcport_stats_get_timeout(void *cbarg)
3182{
3183 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3184
3185 bfa_trc(fcport->bfa, fcport->stats_qfull);
3186
3187 if (fcport->stats_qfull) {
3188 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3189 fcport->stats_qfull = BFA_FALSE;
3190 }
3191
3192 fcport->stats_status = BFA_STATUS_ETIMER;
37ea0558 3193 __bfa_cb_fcport_stats_get(fcport, BFA_TRUE);
a36c61f9
KG		 3194}
3195
3196static void
3197bfa_fcport_send_stats_get(void *cbarg)
3198{
3199 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3200 struct bfi_fcport_req_s *msg;
3201
3202 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3203
3204 if (!msg) {
3205 fcport->stats_qfull = BFA_TRUE;
3206 bfa_reqq_winit(&fcport->stats_reqq_wait,
3207 bfa_fcport_send_stats_get, fcport);
3208 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3209 &fcport->stats_reqq_wait);
3210 return;
3211 }
3212 fcport->stats_qfull = BFA_FALSE;
3213
6a18b167 3214 memset(msg, 0, sizeof(struct bfi_fcport_req_s));
a36c61f9 3215 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_GET_REQ,
3fd45980
KG		 3216 bfa_fn_lpu(fcport->bfa));
3217 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, msg->mh);
a36c61f9
KG		 3218}
3219
3220static void
3221__bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
3222{
37ea0558
KG		 3223 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3224 struct bfa_cb_pending_q_s *cb;
3225 struct list_head *qe, *qen;
a36c61f9
KG		 3226
3227 if (complete) {
f16a1750 3228 struct timeval tv;
a36c61f9 3229
5fbe25c7 3230 /*
a36c61f9
KG		 3231 * re-initialize time stamp for stats reset
3232 */
f16a1750 3233 do_gettimeofday(&tv);
a36c61f9 3234 fcport->stats_reset_time = tv.tv_sec;
37ea0558
KG		 3235 list_for_each_safe(qe, qen, &fcport->statsclr_pending_q) {
3236 bfa_q_deq(&fcport->statsclr_pending_q, &qe);
3237 cb = (struct bfa_cb_pending_q_s *)qe;
3238 bfa_cb_queue_status(fcport->bfa, &cb->hcb_qe,
3239 fcport->stats_status);
3240 }
3241 fcport->stats_status = BFA_STATUS_OK;
a36c61f9 3242 } else {
37ea0558 3243 INIT_LIST_HEAD(&fcport->statsclr_pending_q);
a36c61f9
KG		 3244 fcport->stats_status = BFA_STATUS_OK;
3245 }
3246}
3247
3248static void
3249bfa_fcport_stats_clr_timeout(void *cbarg)
3250{
3251 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3252
3253 bfa_trc(fcport->bfa, fcport->stats_qfull);
3254
3255 if (fcport->stats_qfull) {
3256 bfa_reqq_wcancel(&fcport->stats_reqq_wait);
3257 fcport->stats_qfull = BFA_FALSE;
3258 }
3259
3260 fcport->stats_status = BFA_STATUS_ETIMER;
37ea0558 3261 __bfa_cb_fcport_stats_clr(fcport, BFA_TRUE);
a36c61f9
KG		 3262}
3263
3264static void
3265bfa_fcport_send_stats_clear(void *cbarg)
3266{
3267 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
3268 struct bfi_fcport_req_s *msg;
3269
3270 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
3271
3272 if (!msg) {
3273 fcport->stats_qfull = BFA_TRUE;
3274 bfa_reqq_winit(&fcport->stats_reqq_wait,
3275 bfa_fcport_send_stats_clear, fcport);
3276 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
3277 &fcport->stats_reqq_wait);
3278 return;
3279 }
3280 fcport->stats_qfull = BFA_FALSE;
3281
6a18b167 3282 memset(msg, 0, sizeof(struct bfi_fcport_req_s));
a36c61f9 3283 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_CLEAR_REQ,
3fd45980
KG		 3284 bfa_fn_lpu(fcport->bfa));
3285 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, msg->mh);
a36c61f9
KG		 3286}
3287
5fbe25c7 3288/*
a36c61f9
KG		 3289 * Handle trunk SCN event from firmware.
3290 */
3291static void
3292bfa_trunk_scn(struct bfa_fcport_s *fcport, struct bfi_fcport_trunk_scn_s *scn)
3293{
3294 struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
3295 struct bfi_fcport_trunk_link_s *tlink;
3296 struct bfa_trunk_link_attr_s *lattr;
3297 enum bfa_trunk_state state_prev;
3298 int i;
3299 int link_bm = 0;
3300
3301 bfa_trc(fcport->bfa, fcport->cfg.trunked);
d4b671c5
JH		 3302 WARN_ON(scn->trunk_state != BFA_TRUNK_ONLINE &&
3303 scn->trunk_state != BFA_TRUNK_OFFLINE);
a36c61f9
KG		 3304
3305 bfa_trc(fcport->bfa, trunk->attr.state);
3306 bfa_trc(fcport->bfa, scn->trunk_state);
3307 bfa_trc(fcport->bfa, scn->trunk_speed);
3308
5fbe25c7 3309 /*
a36c61f9
KG		 3310 * Save off new state for trunk attribute query
3311 */
3312 state_prev = trunk->attr.state;
3313 if (fcport->cfg.trunked && (trunk->attr.state != BFA_TRUNK_DISABLED))
3314 trunk->attr.state = scn->trunk_state;
3315 trunk->attr.speed = scn->trunk_speed;
3316 for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3317 lattr = &trunk->attr.link_attr[i];
3318 tlink = &scn->tlink[i];
3319
3320 lattr->link_state = tlink->state;
3321 lattr->trunk_wwn = tlink->trunk_wwn;
3322 lattr->fctl = tlink->fctl;
3323 lattr->speed = tlink->speed;
ba816ea8 3324 lattr->deskew = be32_to_cpu(tlink->deskew);
a36c61f9
KG		 3325
3326 if (tlink->state == BFA_TRUNK_LINK_STATE_UP) {
3327 fcport->speed = tlink->speed;
3328 fcport->topology = BFA_PORT_TOPOLOGY_P2P;
3329 link_bm |= 1 << i;
3330 }
3331
3332 bfa_trc(fcport->bfa, lattr->link_state);
3333 bfa_trc(fcport->bfa, lattr->trunk_wwn);
3334 bfa_trc(fcport->bfa, lattr->fctl);
3335 bfa_trc(fcport->bfa, lattr->speed);
3336 bfa_trc(fcport->bfa, lattr->deskew);
3337 }
3338
3339 switch (link_bm) {
3340 case 3:
3341 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3342 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,1)");
3343 break;
3344 case 2:
3345 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3346 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(-,1)");
3347 break;
3348 case 1:
3349 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3350 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,-)");
3351 break;
3352 default:
3353 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3354 BFA_PL_EID_TRUNK_SCN, 0, "Trunk down");
3355 }
3356
5fbe25c7 3357 /*
a36c61f9
KG		 3358 * Notify upper layers if trunk state changed.
3359 */
3360 if ((state_prev != trunk->attr.state) ||
3361 (scn->trunk_state == BFA_TRUNK_OFFLINE)) {
3362 bfa_fcport_scn(fcport, (scn->trunk_state == BFA_TRUNK_ONLINE) ?
3363 BFA_PORT_LINKUP : BFA_PORT_LINKDOWN, BFA_TRUE);
3364 }
3365}
3366
3367static void
3368bfa_trunk_iocdisable(struct bfa_s *bfa)
3369{
3370 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3371 int i = 0;
3372
5fbe25c7 3373 /*
a36c61f9
KG		 3374 * In trunked mode, notify upper layers that link is down
3375 */
3376 if (fcport->cfg.trunked) {
3377 if (fcport->trunk.attr.state == BFA_TRUNK_ONLINE)
3378 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_TRUE);
3379
3380 fcport->trunk.attr.state = BFA_TRUNK_OFFLINE;
3381 fcport->trunk.attr.speed = BFA_PORT_SPEED_UNKNOWN;
3382 for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) {
3383 fcport->trunk.attr.link_attr[i].trunk_wwn = 0;
3384 fcport->trunk.attr.link_attr[i].fctl =
3385 BFA_TRUNK_LINK_FCTL_NORMAL;
3386 fcport->trunk.attr.link_attr[i].link_state =
3387 BFA_TRUNK_LINK_STATE_DN_LINKDN;
3388 fcport->trunk.attr.link_attr[i].speed =
3389 BFA_PORT_SPEED_UNKNOWN;
3390 fcport->trunk.attr.link_attr[i].deskew = 0;
3391 }
3392 }
3393}
3394
5fbe25c7 3395/*
a36c61f9
KG		 3396 * Called to initialize port attributes
3397 */
3398void
3399bfa_fcport_init(struct bfa_s *bfa)
3400{
3401 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3402
5fbe25c7 3403 /*
a36c61f9
KG		 3404 * Initialize port attributes from IOC hardware data.
3405 */
3406 bfa_fcport_set_wwns(fcport);
3407 if (fcport->cfg.maxfrsize == 0)
3408 fcport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc);
3409 fcport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
3410 fcport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
3411
43ffdf4d
KG		 3412 if (bfa_fcport_is_pbcdisabled(bfa))
3413 bfa->modules.port.pbc_disabled = BFA_TRUE;
3414
d4b671c5
JH		 3415 WARN_ON(!fcport->cfg.maxfrsize);
3416 WARN_ON(!fcport->cfg.rx_bbcredit);
3417 WARN_ON(!fcport->speed_sup);
a36c61f9
KG		 3418}
3419
5fbe25c7 3420/*
a36c61f9
KG		 3421 * Firmware message handler.
3422 */
3423void
3424bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
3425{
3426 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3427 union bfi_fcport_i2h_msg_u i2hmsg;
3428
3429 i2hmsg.msg = msg;
3430 fcport->event_arg.i2hmsg = i2hmsg;
3431
3432 bfa_trc(bfa, msg->mhdr.msg_id);
3433 bfa_trc(bfa, bfa_sm_to_state(hal_port_sm_table, fcport->sm));
3434
3435 switch (msg->mhdr.msg_id) {
3436 case BFI_FCPORT_I2H_ENABLE_RSP:
f3a060ca
KG		 3437 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag) {
3438
3439 if (fcport->use_flash_cfg) {
3440 fcport->cfg = i2hmsg.penable_rsp->port_cfg;
3441 fcport->cfg.maxfrsize =
3442 cpu_to_be16(fcport->cfg.maxfrsize);
3443 fcport->cfg.path_tov =
3444 cpu_to_be16(fcport->cfg.path_tov);
3445 fcport->cfg.q_depth =
3446 cpu_to_be16(fcport->cfg.q_depth);
3447
3448 if (fcport->cfg.trunked)
3449 fcport->trunk.attr.state =
3450 BFA_TRUNK_OFFLINE;
3451 else
3452 fcport->trunk.attr.state =
3453 BFA_TRUNK_DISABLED;
3454 fcport->use_flash_cfg = BFA_FALSE;
3455 }
3456
a36c61f9 3457 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
f3a060ca 3458 }
a36c61f9
KG		 3459 break;
3460
3461 case BFI_FCPORT_I2H_DISABLE_RSP:
3462 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
3463 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
3464 break;
3465
3466 case BFI_FCPORT_I2H_EVENT:
3467 if (i2hmsg.event->link_state.linkstate == BFA_PORT_LINKUP)
3468 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
3469 else
3470 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKDOWN);
3471 break;
3472
3473 case BFI_FCPORT_I2H_TRUNK_SCN:
3474 bfa_trunk_scn(fcport, i2hmsg.trunk_scn);
3475 break;
3476
3477 case BFI_FCPORT_I2H_STATS_GET_RSP:
3478 /*
3479 * check for timer pop before processing the rsp
3480 */
37ea0558
KG		 3481 if (list_empty(&fcport->stats_pending_q) ||
3482 (fcport->stats_status == BFA_STATUS_ETIMER))
a36c61f9
KG		 3483 break;
3484
3485 bfa_timer_stop(&fcport->timer);
3486 fcport->stats_status = i2hmsg.pstatsget_rsp->status;
37ea0558 3487 __bfa_cb_fcport_stats_get(fcport, BFA_TRUE);
a36c61f9
KG		 3488 break;
3489
3490 case BFI_FCPORT_I2H_STATS_CLEAR_RSP:
3491 /*
3492 * check for timer pop before processing the rsp
3493 */
37ea0558
KG		 3494 if (list_empty(&fcport->statsclr_pending_q) ||
3495 (fcport->stats_status == BFA_STATUS_ETIMER))
a36c61f9
KG		 3496 break;
3497
3498 bfa_timer_stop(&fcport->timer);
3499 fcport->stats_status = BFA_STATUS_OK;
37ea0558 3500 __bfa_cb_fcport_stats_clr(fcport, BFA_TRUE);
a36c61f9
KG		 3501 break;
3502
3503 case BFI_FCPORT_I2H_ENABLE_AEN:
3504 bfa_sm_send_event(fcport, BFA_FCPORT_SM_ENABLE);
3505 break;
3506
3507 case BFI_FCPORT_I2H_DISABLE_AEN:
3508 bfa_sm_send_event(fcport, BFA_FCPORT_SM_DISABLE);
3509 break;
3510
3511 default:
d4b671c5 3512 WARN_ON(1);
a36c61f9
KG		 3513 break;
3514 }
3515}
3516
5fbe25c7 3517/*
a36c61f9
KG		 3518 * Registered callback for port events.
3519 */
3520void
3521bfa_fcport_event_register(struct bfa_s *bfa,
3522 void (*cbfn) (void *cbarg,
3523 enum bfa_port_linkstate event),
3524 void *cbarg)
3525{
3526 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3527
3528 fcport->event_cbfn = cbfn;
3529 fcport->event_cbarg = cbarg;
3530}
3531
3532bfa_status_t
3533bfa_fcport_enable(struct bfa_s *bfa)
3534{
3535 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3536
43ffdf4d
KG		 3537 if (bfa_fcport_is_pbcdisabled(bfa))
3538 return BFA_STATUS_PBC;
3539
a36c61f9
KG		 3540 if (bfa_ioc_is_disabled(&bfa->ioc))
3541 return BFA_STATUS_IOC_DISABLED;
3542
3543 if (fcport->diag_busy)
3544 return BFA_STATUS_DIAG_BUSY;
3545
3546 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_ENABLE);
3547 return BFA_STATUS_OK;
3548}
3549
3550bfa_status_t
3551bfa_fcport_disable(struct bfa_s *bfa)
3552{
43ffdf4d
KG		 3553 if (bfa_fcport_is_pbcdisabled(bfa))
3554 return BFA_STATUS_PBC;
a36c61f9
KG		 3555
3556 if (bfa_ioc_is_disabled(&bfa->ioc))
3557 return BFA_STATUS_IOC_DISABLED;
3558
3559 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DISABLE);
3560 return BFA_STATUS_OK;
3561}
3562
43ffdf4d
KG		 3563/* If PBC is disabled on port, return error */
3564bfa_status_t
3565bfa_fcport_is_pbcdisabled(struct bfa_s *bfa)
3566{
3567 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3568 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
3569 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
3570
3571 if (cfgrsp->pbc_cfg.port_enabled == BFI_PBC_PORT_DISABLED) {
3572 bfa_trc(bfa, fcport->pwwn);
3573 return BFA_STATUS_PBC;
3574 }
3575 return BFA_STATUS_OK;
3576}
3577
5fbe25c7 3578/*
a36c61f9
KG		 3579 * Configure port speed.
3580 */
3581bfa_status_t
3582bfa_fcport_cfg_speed(struct bfa_s *bfa, enum bfa_port_speed speed)
3583{
3584 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3585
3586 bfa_trc(bfa, speed);
3587
3588 if (fcport->cfg.trunked == BFA_TRUE)
3589 return BFA_STATUS_TRUNK_ENABLED;
3590 if ((speed != BFA_PORT_SPEED_AUTO) && (speed > fcport->speed_sup)) {
3591 bfa_trc(bfa, fcport->speed_sup);
3592 return BFA_STATUS_UNSUPP_SPEED;
3593 }
3594
a714134a
KG		 3595 /* For Mezz card, port speed entered needs to be checked */
3596 if (bfa_mfg_is_mezz(fcport->bfa->ioc.attr->card_type)) {
3597 if (bfa_ioc_get_type(&fcport->bfa->ioc) == BFA_IOC_TYPE_FC) {
3598 /* For CT2, 1G is not supported */
3599 if ((speed == BFA_PORT_SPEED_1GBPS) &&
3600 (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)))
3601 return BFA_STATUS_UNSUPP_SPEED;
3602
3603 /* Already checked for Auto Speed and Max Speed supp */
3604 if (!(speed == BFA_PORT_SPEED_1GBPS ||
3605 speed == BFA_PORT_SPEED_2GBPS ||
3606 speed == BFA_PORT_SPEED_4GBPS ||
3607 speed == BFA_PORT_SPEED_8GBPS ||
3608 speed == BFA_PORT_SPEED_16GBPS ||
3609 speed == BFA_PORT_SPEED_AUTO))
3610 return BFA_STATUS_UNSUPP_SPEED;
3611 } else {
3612 if (speed != BFA_PORT_SPEED_10GBPS)
3613 return BFA_STATUS_UNSUPP_SPEED;
3614 }
3615 }
3616
a36c61f9
KG		 3617 fcport->cfg.speed = speed;
3618
3619 return BFA_STATUS_OK;
3620}
3621
5fbe25c7 3622/*
a36c61f9
KG		 3623 * Get current speed.
3624 */
3625enum bfa_port_speed
3626bfa_fcport_get_speed(struct bfa_s *bfa)
3627{
3628 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3629
3630 return fcport->speed;
3631}
3632
5fbe25c7 3633/*
a36c61f9
KG		 3634 * Configure port topology.
3635 */
3636bfa_status_t
3637bfa_fcport_cfg_topology(struct bfa_s *bfa, enum bfa_port_topology topology)
3638{
3639 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3640
3641 bfa_trc(bfa, topology);
3642 bfa_trc(bfa, fcport->cfg.topology);
3643
3644 switch (topology) {
3645 case BFA_PORT_TOPOLOGY_P2P:
3646 case BFA_PORT_TOPOLOGY_LOOP:
3647 case BFA_PORT_TOPOLOGY_AUTO:
3648 break;
3649
3650 default:
3651 return BFA_STATUS_EINVAL;
3652 }
3653
3654 fcport->cfg.topology = topology;
3655 return BFA_STATUS_OK;
3656}
3657
5fbe25c7 3658/*
a36c61f9
KG		 3659 * Get current topology.
3660 */
3661enum bfa_port_topology
3662bfa_fcport_get_topology(struct bfa_s *bfa)
3663{
3664 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3665
3666 return fcport->topology;
3667}
3668
3669bfa_status_t
3670bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
3671{
3672 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3673
3674 bfa_trc(bfa, alpa);
3675 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3676 bfa_trc(bfa, fcport->cfg.hardalpa);
3677
3678 fcport->cfg.cfg_hardalpa = BFA_TRUE;
3679 fcport->cfg.hardalpa = alpa;
3680
3681 return BFA_STATUS_OK;
3682}
3683
3684bfa_status_t
3685bfa_fcport_clr_hardalpa(struct bfa_s *bfa)
3686{
3687 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3688
3689 bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
3690 bfa_trc(bfa, fcport->cfg.hardalpa);
3691
3692 fcport->cfg.cfg_hardalpa = BFA_FALSE;
3693 return BFA_STATUS_OK;
3694}
3695
3696bfa_boolean_t
3697bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa)
3698{
3699 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3700
3701 *alpa = fcport->cfg.hardalpa;
3702 return fcport->cfg.cfg_hardalpa;
3703}
3704
3705u8
3706bfa_fcport_get_myalpa(struct bfa_s *bfa)
3707{
3708 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3709
3710 return fcport->myalpa;
3711}
3712
3713bfa_status_t
3714bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
3715{
3716 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3717
3718 bfa_trc(bfa, maxfrsize);
3719 bfa_trc(bfa, fcport->cfg.maxfrsize);
3720
3721 /* with in range */
3722 if ((maxfrsize > FC_MAX_PDUSZ) || (maxfrsize < FC_MIN_PDUSZ))
3723 return BFA_STATUS_INVLD_DFSZ;
3724
3725 /* power of 2, if not the max frame size of 2112 */
3726 if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1)))
3727 return BFA_STATUS_INVLD_DFSZ;
3728
3729 fcport->cfg.maxfrsize = maxfrsize;
3730 return BFA_STATUS_OK;
3731}
3732
3733u16
3734bfa_fcport_get_maxfrsize(struct bfa_s *bfa)
3735{
3736 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3737
3738 return fcport->cfg.maxfrsize;
3739}
3740
3741u8
3742bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa)
3743{
3744 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3745
3746 return fcport->cfg.rx_bbcredit;
3747}
3748
3749void
be540a99 3750bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit, u8 bb_scn)
a36c61f9
KG		 3751{
3752 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3753
3754 fcport->cfg.tx_bbcredit = (u8)tx_bbcredit;
be540a99
KG		 3755 fcport->cfg.bb_scn = bb_scn;
3756 if (bb_scn)
3757 fcport->bbsc_op_state = BFA_TRUE;
a36c61f9
KG		 3758 bfa_fcport_send_txcredit(fcport);
3759}
3760
5fbe25c7 3761/*
a36c61f9
KG		 3762 * Get port attributes.
3763 */
3764
3765wwn_t
3766bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node)
3767{
3768 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3769 if (node)
3770 return fcport->nwwn;
3771 else
3772 return fcport->pwwn;
3773}
3774
3775void
3776bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr)
3777{
3778 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3779
6a18b167 3780 memset(attr, 0, sizeof(struct bfa_port_attr_s));
a36c61f9
KG		 3781
3782 attr->nwwn = fcport->nwwn;
3783 attr->pwwn = fcport->pwwn;
3784
f7f73812
MZ		 3785 attr->factorypwwn = bfa->ioc.attr->mfg_pwwn;
3786 attr->factorynwwn = bfa->ioc.attr->mfg_nwwn;
a36c61f9 3787
6a18b167 3788 memcpy(&attr->pport_cfg, &fcport->cfg,
a36c61f9
KG		 3789 sizeof(struct bfa_port_cfg_s));
3790 /* speed attributes */
3791 attr->pport_cfg.speed = fcport->cfg.speed;
3792 attr->speed_supported = fcport->speed_sup;
3793 attr->speed = fcport->speed;
3794 attr->cos_supported = FC_CLASS_3;
3795
3796 /* topology attributes */
3797 attr->pport_cfg.topology = fcport->cfg.topology;
3798 attr->topology = fcport->topology;
3799 attr->pport_cfg.trunked = fcport->cfg.trunked;
3800
3801 /* beacon attributes */
3802 attr->beacon = fcport->beacon;
3803 attr->link_e2e_beacon = fcport->link_e2e_beacon;
a36c61f9
KG		 3804
3805 attr->pport_cfg.path_tov = bfa_fcpim_path_tov_get(bfa);
3806 attr->pport_cfg.q_depth = bfa_fcpim_qdepth_get(bfa);
3807 attr->port_state = bfa_sm_to_state(hal_port_sm_table, fcport->sm);
be540a99 3808 attr->bbsc_op_status = fcport->bbsc_op_state;
43ffdf4d
KG		 3809
3810 /* PBC Disabled State */
3811 if (bfa_fcport_is_pbcdisabled(bfa))
3812 attr->port_state = BFA_PORT_ST_PREBOOT_DISABLED;
3813 else {
3814 if (bfa_ioc_is_disabled(&fcport->bfa->ioc))
3815 attr->port_state = BFA_PORT_ST_IOCDIS;
3816 else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc))
3817 attr->port_state = BFA_PORT_ST_FWMISMATCH;
a714134a
KG		 3818 else if (bfa_ioc_is_acq_addr(&fcport->bfa->ioc))
3819 attr->port_state = BFA_PORT_ST_ACQ_ADDR;
43ffdf4d 3820 }
a36c61f9
KG		 3821
3822 /* FCoE vlan */
3823 attr->fcoe_vlan = fcport->fcoe_vlan;
3824}
3825
3826#define BFA_FCPORT_STATS_TOV 1000
3827
5fbe25c7 3828/*
a36c61f9
KG		 3829 * Fetch port statistics (FCQoS or FCoE).
3830 */
3831bfa_status_t
37ea0558 3832bfa_fcport_get_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb)
a36c61f9
KG		 3833{
3834 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3835
37ea0558
KG		 3836 if (bfa_ioc_is_disabled(&bfa->ioc))
3837 return BFA_STATUS_IOC_DISABLED;
a36c61f9 3838
37ea0558
KG		 3839 if (!list_empty(&fcport->statsclr_pending_q))
3840 return BFA_STATUS_DEVBUSY;
a36c61f9 3841
37ea0558
KG		 3842 if (list_empty(&fcport->stats_pending_q)) {
3843 list_add_tail(&cb->hcb_qe.qe, &fcport->stats_pending_q);
3844 bfa_fcport_send_stats_get(fcport);
3845 bfa_timer_start(bfa, &fcport->timer,
3846 bfa_fcport_stats_get_timeout,
3847 fcport, BFA_FCPORT_STATS_TOV);
3848 } else
3849 list_add_tail(&cb->hcb_qe.qe, &fcport->stats_pending_q);
a36c61f9 3850
a36c61f9
KG		 3851 return BFA_STATUS_OK;
3852}
3853
5fbe25c7 3854/*
a36c61f9
KG		 3855 * Reset port statistics (FCQoS or FCoE).
3856 */
3857bfa_status_t
37ea0558 3858bfa_fcport_clear_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb)
a36c61f9
KG		 3859{
3860 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3861
37ea0558 3862 if (!list_empty(&fcport->stats_pending_q))
a36c61f9 3863 return BFA_STATUS_DEVBUSY;
a36c61f9 3864
37ea0558
KG		 3865 if (list_empty(&fcport->statsclr_pending_q)) {
3866 list_add_tail(&cb->hcb_qe.qe, &fcport->statsclr_pending_q);
3867 bfa_fcport_send_stats_clear(fcport);
3868 bfa_timer_start(bfa, &fcport->timer,
3869 bfa_fcport_stats_clr_timeout,
3870 fcport, BFA_FCPORT_STATS_TOV);
3871 } else
3872 list_add_tail(&cb->hcb_qe.qe, &fcport->statsclr_pending_q);
a36c61f9 3873
a36c61f9
KG		 3874 return BFA_STATUS_OK;
3875}
3876
5fbe25c7 3877/*
a36c61f9
KG		 3878 * Fetch port attributes.
3879 */
3880bfa_boolean_t
3881bfa_fcport_is_disabled(struct bfa_s *bfa)
3882{
3883 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3884
3885 return bfa_sm_to_state(hal_port_sm_table, fcport->sm) ==
3886 BFA_PORT_ST_DISABLED;
3887
3888}
3889
3890bfa_boolean_t
3891bfa_fcport_is_ratelim(struct bfa_s *bfa)
3892{
3893 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3894
3895 return fcport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE;
3896
3897}
3898
a714134a
KG		 3899/*
3900 * Enable/Disable FAA feature in port config
3901 */
3902void
3903bfa_fcport_cfg_faa(struct bfa_s *bfa, u8 state)
3904{
3905 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3906
3907 bfa_trc(bfa, state);
3908 fcport->cfg.faa_state = state;
3909}
3910
5fbe25c7 3911/*
a36c61f9
KG		 3912 * Get default minimum ratelim speed
3913 */
3914enum bfa_port_speed
3915bfa_fcport_get_ratelim_speed(struct bfa_s *bfa)
3916{
3917 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3918
3919 bfa_trc(bfa, fcport->cfg.trl_def_speed);
3920 return fcport->cfg.trl_def_speed;
3921
3922}
a36c61f9 3923
3d7fc66d
KG		 3924void
3925bfa_fcport_beacon(void *dev, bfa_boolean_t beacon,
3926 bfa_boolean_t link_e2e_beacon)
3927{
3928 struct bfa_s *bfa = dev;
3929 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3930
3931 bfa_trc(bfa, beacon);
3932 bfa_trc(bfa, link_e2e_beacon);
3933 bfa_trc(bfa, fcport->beacon);
3934 bfa_trc(bfa, fcport->link_e2e_beacon);
3935
3936 fcport->beacon = beacon;
3937 fcport->link_e2e_beacon = link_e2e_beacon;
3938}
3939
a36c61f9
KG		 3940bfa_boolean_t
3941bfa_fcport_is_linkup(struct bfa_s *bfa)
3942{
3943 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3944
3945 return (!fcport->cfg.trunked &&
3946 bfa_sm_cmp_state(fcport, bfa_fcport_sm_linkup)) ||
3947 (fcport->cfg.trunked &&
3948 fcport->trunk.attr.state == BFA_TRUNK_ONLINE);
3949}
3950
3951bfa_boolean_t
3952bfa_fcport_is_qos_enabled(struct bfa_s *bfa)
3953{
3954 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3955
3956 return fcport->cfg.qos_enabled;
3957}
3958
be540a99
KG		 3959bfa_boolean_t
3960bfa_fcport_is_trunk_enabled(struct bfa_s *bfa)
3961{
3962 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
3963
3964 return fcport->cfg.trunked;
3965}
3966
5fbe25c7 3967/*
a36c61f9
KG		 3968 * Rport State machine functions
3969 */
5fbe25c7 3970/*
a36c61f9
KG		 3971 * Beginning state, only online event expected.
3972 */
3973static void
3974bfa_rport_sm_uninit(struct bfa_rport_s *rp, enum bfa_rport_event event)
3975{
3976 bfa_trc(rp->bfa, rp->rport_tag);
3977 bfa_trc(rp->bfa, event);
3978
3979 switch (event) {
3980 case BFA_RPORT_SM_CREATE:
3981 bfa_stats(rp, sm_un_cr);
3982 bfa_sm_set_state(rp, bfa_rport_sm_created);
3983 break;
3984
3985 default:
3986 bfa_stats(rp, sm_un_unexp);
3987 bfa_sm_fault(rp->bfa, event);
3988 }
3989}
3990
3991static void
3992bfa_rport_sm_created(struct bfa_rport_s *rp, enum bfa_rport_event event)
3993{
3994 bfa_trc(rp->bfa, rp->rport_tag);
3995 bfa_trc(rp->bfa, event);
3996
3997 switch (event) {
3998 case BFA_RPORT_SM_ONLINE:
3999 bfa_stats(rp, sm_cr_on);
4000 if (bfa_rport_send_fwcreate(rp))
4001 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4002 else
4003 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4004 break;
4005
4006 case BFA_RPORT_SM_DELETE:
4007 bfa_stats(rp, sm_cr_del);
4008 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4009 bfa_rport_free(rp);
4010 break;
4011
4012 case BFA_RPORT_SM_HWFAIL:
4013 bfa_stats(rp, sm_cr_hwf);
4014 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4015 break;
4016
4017 default:
4018 bfa_stats(rp, sm_cr_unexp);
4019 bfa_sm_fault(rp->bfa, event);
4020 }
4021}
4022
5fbe25c7 4023/*
a36c61f9
KG		 4024 * Waiting for rport create response from firmware.
4025 */
4026static void
4027bfa_rport_sm_fwcreate(struct bfa_rport_s *rp, enum bfa_rport_event event)
4028{
4029 bfa_trc(rp->bfa, rp->rport_tag);
4030 bfa_trc(rp->bfa, event);
4031
4032 switch (event) {
4033 case BFA_RPORT_SM_FWRSP:
4034 bfa_stats(rp, sm_fwc_rsp);
4035 bfa_sm_set_state(rp, bfa_rport_sm_online);
4036 bfa_rport_online_cb(rp);
4037 break;
4038
4039 case BFA_RPORT_SM_DELETE:
4040 bfa_stats(rp, sm_fwc_del);
4041 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
4042 break;
4043
4044 case BFA_RPORT_SM_OFFLINE:
4045 bfa_stats(rp, sm_fwc_off);
4046 bfa_sm_set_state(rp, bfa_rport_sm_offline_pending);
4047 break;
4048
4049 case BFA_RPORT_SM_HWFAIL:
4050 bfa_stats(rp, sm_fwc_hwf);
4051 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4052 break;
4053
4054 default:
4055 bfa_stats(rp, sm_fwc_unexp);
4056 bfa_sm_fault(rp->bfa, event);
4057 }
4058}
4059
5fbe25c7 4060/*
a36c61f9
KG		 4061 * Request queue is full, awaiting queue resume to send create request.
4062 */
4063static void
4064bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4065{
4066 bfa_trc(rp->bfa, rp->rport_tag);
4067 bfa_trc(rp->bfa, event);
4068
4069 switch (event) {
4070 case BFA_RPORT_SM_QRESUME:
4071 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4072 bfa_rport_send_fwcreate(rp);
4073 break;
4074
4075 case BFA_RPORT_SM_DELETE:
4076 bfa_stats(rp, sm_fwc_del);
4077 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4078 bfa_reqq_wcancel(&rp->reqq_wait);
4079 bfa_rport_free(rp);
4080 break;
4081
4082 case BFA_RPORT_SM_OFFLINE:
4083 bfa_stats(rp, sm_fwc_off);
4084 bfa_sm_set_state(rp, bfa_rport_sm_offline);
4085 bfa_reqq_wcancel(&rp->reqq_wait);
4086 bfa_rport_offline_cb(rp);
4087 break;
4088
4089 case BFA_RPORT_SM_HWFAIL:
4090 bfa_stats(rp, sm_fwc_hwf);
4091 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4092 bfa_reqq_wcancel(&rp->reqq_wait);
4093 break;
4094
4095 default:
4096 bfa_stats(rp, sm_fwc_unexp);
4097 bfa_sm_fault(rp->bfa, event);
4098 }
4099}
4100
5fbe25c7 4101/*
a36c61f9
KG		 4102 * Online state - normal parking state.
4103 */
4104static void
4105bfa_rport_sm_online(struct bfa_rport_s *rp, enum bfa_rport_event event)
4106{
4107 struct bfi_rport_qos_scn_s *qos_scn;
4108
4109 bfa_trc(rp->bfa, rp->rport_tag);
4110 bfa_trc(rp->bfa, event);
4111
4112 switch (event) {
4113 case BFA_RPORT_SM_OFFLINE:
4114 bfa_stats(rp, sm_on_off);
4115 if (bfa_rport_send_fwdelete(rp))
4116 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4117 else
4118 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
4119 break;
4120
4121 case BFA_RPORT_SM_DELETE:
4122 bfa_stats(rp, sm_on_del);
4123 if (bfa_rport_send_fwdelete(rp))
4124 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4125 else
4126 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4127 break;
4128
4129 case BFA_RPORT_SM_HWFAIL:
4130 bfa_stats(rp, sm_on_hwf);
4131 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4132 break;
4133
4134 case BFA_RPORT_SM_SET_SPEED:
4135 bfa_rport_send_fwspeed(rp);
4136 break;
4137
4138 case BFA_RPORT_SM_QOS_SCN:
4139 qos_scn = (struct bfi_rport_qos_scn_s *) rp->event_arg.fw_msg;
4140 rp->qos_attr = qos_scn->new_qos_attr;
4141 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_flow_id);
4142 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_flow_id);
4143 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_priority);
4144 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_priority);
4145
4146 qos_scn->old_qos_attr.qos_flow_id =
ba816ea8 4147 be32_to_cpu(qos_scn->old_qos_attr.qos_flow_id);
a36c61f9 4148 qos_scn->new_qos_attr.qos_flow_id =
ba816ea8 4149 be32_to_cpu(qos_scn->new_qos_attr.qos_flow_id);
a36c61f9
KG		 4150
4151 if (qos_scn->old_qos_attr.qos_flow_id !=
4152 qos_scn->new_qos_attr.qos_flow_id)
4153 bfa_cb_rport_qos_scn_flowid(rp->rport_drv,
4154 qos_scn->old_qos_attr,
4155 qos_scn->new_qos_attr);
4156 if (qos_scn->old_qos_attr.qos_priority !=
4157 qos_scn->new_qos_attr.qos_priority)
4158 bfa_cb_rport_qos_scn_prio(rp->rport_drv,
4159 qos_scn->old_qos_attr,
4160 qos_scn->new_qos_attr);
4161 break;
4162
4163 default:
4164 bfa_stats(rp, sm_on_unexp);
4165 bfa_sm_fault(rp->bfa, event);
4166 }
4167}
4168
5fbe25c7 4169/*
a36c61f9
KG		 4170 * Firmware rport is being deleted - awaiting f/w response.
4171 */
4172static void
4173bfa_rport_sm_fwdelete(struct bfa_rport_s *rp, enum bfa_rport_event event)
4174{
4175 bfa_trc(rp->bfa, rp->rport_tag);
4176 bfa_trc(rp->bfa, event);
4177
4178 switch (event) {
4179 case BFA_RPORT_SM_FWRSP:
4180 bfa_stats(rp, sm_fwd_rsp);
4181 bfa_sm_set_state(rp, bfa_rport_sm_offline);
4182 bfa_rport_offline_cb(rp);
4183 break;
4184
4185 case BFA_RPORT_SM_DELETE:
4186 bfa_stats(rp, sm_fwd_del);
4187 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4188 break;
4189
4190 case BFA_RPORT_SM_HWFAIL:
4191 bfa_stats(rp, sm_fwd_hwf);
4192 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4193 bfa_rport_offline_cb(rp);
4194 break;
4195
4196 default:
4197 bfa_stats(rp, sm_fwd_unexp);
4198 bfa_sm_fault(rp->bfa, event);
4199 }
4200}
4201
4202static void
4203bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4204{
4205 bfa_trc(rp->bfa, rp->rport_tag);
4206 bfa_trc(rp->bfa, event);
4207
4208 switch (event) {
4209 case BFA_RPORT_SM_QRESUME:
4210 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4211 bfa_rport_send_fwdelete(rp);
4212 break;
4213
4214 case BFA_RPORT_SM_DELETE:
4215 bfa_stats(rp, sm_fwd_del);
4216 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4217 break;
4218
4219 case BFA_RPORT_SM_HWFAIL:
4220 bfa_stats(rp, sm_fwd_hwf);
4221 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4222 bfa_reqq_wcancel(&rp->reqq_wait);
4223 bfa_rport_offline_cb(rp);
4224 break;
4225
4226 default:
4227 bfa_stats(rp, sm_fwd_unexp);
4228 bfa_sm_fault(rp->bfa, event);
4229 }
4230}
4231
5fbe25c7 4232/*
a36c61f9
KG		 4233 * Offline state.
4234 */
4235static void
4236bfa_rport_sm_offline(struct bfa_rport_s *rp, enum bfa_rport_event event)
4237{
4238 bfa_trc(rp->bfa, rp->rport_tag);
4239 bfa_trc(rp->bfa, event);
4240
4241 switch (event) {
4242 case BFA_RPORT_SM_DELETE:
4243 bfa_stats(rp, sm_off_del);
4244 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4245 bfa_rport_free(rp);
4246 break;
4247
4248 case BFA_RPORT_SM_ONLINE:
4249 bfa_stats(rp, sm_off_on);
4250 if (bfa_rport_send_fwcreate(rp))
4251 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4252 else
4253 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4254 break;
4255
4256 case BFA_RPORT_SM_HWFAIL:
4257 bfa_stats(rp, sm_off_hwf);
4258 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4259 break;
4260
4261 default:
4262 bfa_stats(rp, sm_off_unexp);
4263 bfa_sm_fault(rp->bfa, event);
4264 }
4265}
4266
5fbe25c7 4267/*
a36c61f9
KG		 4268 * Rport is deleted, waiting for firmware response to delete.
4269 */
4270static void
4271bfa_rport_sm_deleting(struct bfa_rport_s *rp, enum bfa_rport_event event)
4272{
4273 bfa_trc(rp->bfa, rp->rport_tag);
4274 bfa_trc(rp->bfa, event);
4275
4276 switch (event) {
4277 case BFA_RPORT_SM_FWRSP:
4278 bfa_stats(rp, sm_del_fwrsp);
4279 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4280 bfa_rport_free(rp);
4281 break;
4282
4283 case BFA_RPORT_SM_HWFAIL:
4284 bfa_stats(rp, sm_del_hwf);
4285 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4286 bfa_rport_free(rp);
4287 break;
4288
4289 default:
4290 bfa_sm_fault(rp->bfa, event);
4291 }
4292}
4293
4294static void
4295bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
4296{
4297 bfa_trc(rp->bfa, rp->rport_tag);
4298 bfa_trc(rp->bfa, event);
4299
4300 switch (event) {
4301 case BFA_RPORT_SM_QRESUME:
4302 bfa_stats(rp, sm_del_fwrsp);
4303 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4304 bfa_rport_send_fwdelete(rp);
4305 break;
4306
4307 case BFA_RPORT_SM_HWFAIL:
4308 bfa_stats(rp, sm_del_hwf);
4309 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4310 bfa_reqq_wcancel(&rp->reqq_wait);
4311 bfa_rport_free(rp);
4312 break;
4313
4314 default:
4315 bfa_sm_fault(rp->bfa, event);
4316 }
4317}
4318
5fbe25c7 4319/*
a36c61f9
KG		 4320 * Waiting for rport create response from firmware. A delete is pending.
4321 */
4322static void
4323bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
4324 enum bfa_rport_event event)
4325{
4326 bfa_trc(rp->bfa, rp->rport_tag);
4327 bfa_trc(rp->bfa, event);
4328
4329 switch (event) {
4330 case BFA_RPORT_SM_FWRSP:
4331 bfa_stats(rp, sm_delp_fwrsp);
4332 if (bfa_rport_send_fwdelete(rp))
4333 bfa_sm_set_state(rp, bfa_rport_sm_deleting);
4334 else
4335 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull);
4336 break;
4337
4338 case BFA_RPORT_SM_HWFAIL:
4339 bfa_stats(rp, sm_delp_hwf);
4340 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4341 bfa_rport_free(rp);
4342 break;
4343
4344 default:
4345 bfa_stats(rp, sm_delp_unexp);
4346 bfa_sm_fault(rp->bfa, event);
4347 }
4348}
4349
5fbe25c7 4350/*
a36c61f9
KG		 4351 * Waiting for rport create response from firmware. Rport offline is pending.
4352 */
4353static void
4354bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
4355 enum bfa_rport_event event)
4356{
4357 bfa_trc(rp->bfa, rp->rport_tag);
4358 bfa_trc(rp->bfa, event);
4359
4360 switch (event) {
4361 case BFA_RPORT_SM_FWRSP:
4362 bfa_stats(rp, sm_offp_fwrsp);
4363 if (bfa_rport_send_fwdelete(rp))
4364 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete);
4365 else
4366 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull);
4367 break;
4368
4369 case BFA_RPORT_SM_DELETE:
4370 bfa_stats(rp, sm_offp_del);
4371 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending);
4372 break;
4373
4374 case BFA_RPORT_SM_HWFAIL:
4375 bfa_stats(rp, sm_offp_hwf);
4376 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
4377 break;
4378
4379 default:
4380 bfa_stats(rp, sm_offp_unexp);
4381 bfa_sm_fault(rp->bfa, event);
4382 }
4383}
4384
5fbe25c7 4385/*
a36c61f9
KG		 4386 * IOC h/w failed.
4387 */
4388static void
4389bfa_rport_sm_iocdisable(struct bfa_rport_s *rp, enum bfa_rport_event event)
4390{
4391 bfa_trc(rp->bfa, rp->rport_tag);
4392 bfa_trc(rp->bfa, event);
4393
4394 switch (event) {
4395 case BFA_RPORT_SM_OFFLINE:
4396 bfa_stats(rp, sm_iocd_off);
4397 bfa_rport_offline_cb(rp);
4398 break;
4399
4400 case BFA_RPORT_SM_DELETE:
4401 bfa_stats(rp, sm_iocd_del);
4402 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4403 bfa_rport_free(rp);
4404 break;
4405
4406 case BFA_RPORT_SM_ONLINE:
4407 bfa_stats(rp, sm_iocd_on);
4408 if (bfa_rport_send_fwcreate(rp))
4409 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate);
4410 else
4411 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull);
4412 break;
4413
4414 case BFA_RPORT_SM_HWFAIL:
4415 break;
4416
4417 default:
4418 bfa_stats(rp, sm_iocd_unexp);
4419 bfa_sm_fault(rp->bfa, event);
4420 }
4421}
4422
4423
4424
5fbe25c7 4425/*
a36c61f9
KG		 4426 * bfa_rport_private BFA rport private functions
4427 */
4428
4429static void
4430__bfa_cb_rport_online(void *cbarg, bfa_boolean_t complete)
4431{
4432 struct bfa_rport_s *rp = cbarg;
4433
4434 if (complete)
4435 bfa_cb_rport_online(rp->rport_drv);
4436}
4437
4438static void
4439__bfa_cb_rport_offline(void *cbarg, bfa_boolean_t complete)
4440{
4441 struct bfa_rport_s *rp = cbarg;
4442
4443 if (complete)
4444 bfa_cb_rport_offline(rp->rport_drv);
4445}
4446
4447static void
4448bfa_rport_qresume(void *cbarg)
4449{
4450 struct bfa_rport_s *rp = cbarg;
4451
4452 bfa_sm_send_event(rp, BFA_RPORT_SM_QRESUME);
4453}
4454
4455static void
4507025d
KG		 4456bfa_rport_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
4457 struct bfa_s *bfa)
a36c61f9 4458{
4507025d
KG		 4459 struct bfa_mem_kva_s *rport_kva = BFA_MEM_RPORT_KVA(bfa);
4460
a36c61f9
KG		 4461 if (cfg->fwcfg.num_rports < BFA_RPORT_MIN)
4462 cfg->fwcfg.num_rports = BFA_RPORT_MIN;
4463
4507025d
KG		 4464 /* kva memory */
4465 bfa_mem_kva_setup(minfo, rport_kva,
4466 cfg->fwcfg.num_rports * sizeof(struct bfa_rport_s));
a36c61f9
KG		 4467}
4468
4469static void
4470bfa_rport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4507025d 4471 struct bfa_pcidev_s *pcidev)
a36c61f9
KG		 4472{
4473 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4474 struct bfa_rport_s *rp;
4475 u16 i;
4476
4477 INIT_LIST_HEAD(&mod->rp_free_q);
4478 INIT_LIST_HEAD(&mod->rp_active_q);
3fd45980 4479 INIT_LIST_HEAD(&mod->rp_unused_q);
a36c61f9 4480
4507025d 4481 rp = (struct bfa_rport_s *) bfa_mem_kva_curp(mod);
a36c61f9
KG		 4482 mod->rps_list = rp;
4483 mod->num_rports = cfg->fwcfg.num_rports;
4484
d4b671c5
JH		 4485 WARN_ON(!mod->num_rports ||
4486 (mod->num_rports & (mod->num_rports - 1)));
a36c61f9
KG		 4487
4488 for (i = 0; i < mod->num_rports; i++, rp++) {
6a18b167 4489 memset(rp, 0, sizeof(struct bfa_rport_s));
a36c61f9
KG		 4490 rp->bfa = bfa;
4491 rp->rport_tag = i;
4492 bfa_sm_set_state(rp, bfa_rport_sm_uninit);
4493
5fbe25c7 4494 /*
a36c61f9
KG		 4495 * - is unused
4496 */
4497 if (i)
4498 list_add_tail(&rp->qe, &mod->rp_free_q);
4499
4500 bfa_reqq_winit(&rp->reqq_wait, bfa_rport_qresume, rp);
4501 }
4502
5fbe25c7 4503 /*
a36c61f9
KG		 4504 * consume memory
4505 */
4507025d 4506 bfa_mem_kva_curp(mod) = (u8 *) rp;
a36c61f9
KG		 4507}
4508
4509static void
4510bfa_rport_detach(struct bfa_s *bfa)
4511{
4512}
4513
4514static void
4515bfa_rport_start(struct bfa_s *bfa)
4516{
4517}
4518
4519static void
4520bfa_rport_stop(struct bfa_s *bfa)
4521{
4522}
4523
4524static void
4525bfa_rport_iocdisable(struct bfa_s *bfa)
4526{
4527 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4528 struct bfa_rport_s *rport;
4529 struct list_head *qe, *qen;
4530
3fd45980
KG		 4531 /* Enqueue unused rport resources to free_q */
4532 list_splice_tail_init(&mod->rp_unused_q, &mod->rp_free_q);
4533
a36c61f9
KG		 4534 list_for_each_safe(qe, qen, &mod->rp_active_q) {
4535 rport = (struct bfa_rport_s *) qe;
4536 bfa_sm_send_event(rport, BFA_RPORT_SM_HWFAIL);
4537 }
4538}
4539
4540static struct bfa_rport_s *
4541bfa_rport_alloc(struct bfa_rport_mod_s *mod)
4542{
4543 struct bfa_rport_s *rport;
4544
4545 bfa_q_deq(&mod->rp_free_q, &rport);
4546 if (rport)
4547 list_add_tail(&rport->qe, &mod->rp_active_q);
4548
4549 return rport;
4550}
4551
4552static void
4553bfa_rport_free(struct bfa_rport_s *rport)
4554{
4555 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(rport->bfa);
4556
d4b671c5 4557 WARN_ON(!bfa_q_is_on_q(&mod->rp_active_q, rport));
a36c61f9
KG		 4558 list_del(&rport->qe);
4559 list_add_tail(&rport->qe, &mod->rp_free_q);
4560}
4561
4562static bfa_boolean_t
4563bfa_rport_send_fwcreate(struct bfa_rport_s *rp)
4564{
4565 struct bfi_rport_create_req_s *m;
4566
5fbe25c7 4567 /*
a36c61f9
KG		 4568 * check for room in queue to send request now
4569 */
4570 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4571 if (!m) {
4572 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4573 return BFA_FALSE;
4574 }
4575
4576 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_CREATE_REQ,
3fd45980 4577 bfa_fn_lpu(rp->bfa));
a36c61f9 4578 m->bfa_handle = rp->rport_tag;
ba816ea8 4579 m->max_frmsz = cpu_to_be16(rp->rport_info.max_frmsz);
a36c61f9 4580 m->pid = rp->rport_info.pid;
3fd45980 4581 m->lp_fwtag = bfa_lps_get_fwtag(rp->bfa, (u8)rp->rport_info.lp_tag);
a36c61f9
KG		 4582 m->local_pid = rp->rport_info.local_pid;
4583 m->fc_class = rp->rport_info.fc_class;
4584 m->vf_en = rp->rport_info.vf_en;
4585 m->vf_id = rp->rport_info.vf_id;
4586 m->cisc = rp->rport_info.cisc;
4587
5fbe25c7 4588 /*
a36c61f9
KG		 4589 * queue I/O message to firmware
4590 */
3fd45980 4591 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh);
a36c61f9
KG		 4592 return BFA_TRUE;
4593}
4594
4595static bfa_boolean_t
4596bfa_rport_send_fwdelete(struct bfa_rport_s *rp)
4597{
4598 struct bfi_rport_delete_req_s *m;
4599
5fbe25c7 4600 /*
a36c61f9
KG		 4601 * check for room in queue to send request now
4602 */
4603 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4604 if (!m) {
4605 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait);
4606 return BFA_FALSE;
4607 }
4608
4609 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_DELETE_REQ,
3fd45980 4610 bfa_fn_lpu(rp->bfa));
a36c61f9
KG		 4611 m->fw_handle = rp->fw_handle;
4612
5fbe25c7 4613 /*
a36c61f9
KG		 4614 * queue I/O message to firmware
4615 */
3fd45980 4616 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh);
a36c61f9
KG		 4617 return BFA_TRUE;
4618}
4619
4620static bfa_boolean_t
4621bfa_rport_send_fwspeed(struct bfa_rport_s *rp)
4622{
4623 struct bfa_rport_speed_req_s *m;
4624
5fbe25c7 4625 /*
a36c61f9
KG		 4626 * check for room in queue to send request now
4627 */
4628 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT);
4629 if (!m) {
4630 bfa_trc(rp->bfa, rp->rport_info.speed);
4631 return BFA_FALSE;
4632 }
4633
4634 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_SET_SPEED_REQ,
3fd45980 4635 bfa_fn_lpu(rp->bfa));
a36c61f9
KG		 4636 m->fw_handle = rp->fw_handle;
4637 m->speed = (u8)rp->rport_info.speed;
4638
5fbe25c7 4639 /*
a36c61f9
KG		 4640 * queue I/O message to firmware
4641 */
3fd45980 4642 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh);
a36c61f9
KG		 4643 return BFA_TRUE;
4644}
4645
4646
4647
5fbe25c7 4648/*
a36c61f9
KG		 4649 * bfa_rport_public
4650 */
4651
5fbe25c7 4652/*
a36c61f9
KG		 4653 * Rport interrupt processing.
4654 */
4655void
4656bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
4657{
4658 union bfi_rport_i2h_msg_u msg;
4659 struct bfa_rport_s *rp;
4660
4661 bfa_trc(bfa, m->mhdr.msg_id);
4662
4663 msg.msg = m;
4664
4665 switch (m->mhdr.msg_id) {
4666 case BFI_RPORT_I2H_CREATE_RSP:
4667 rp = BFA_RPORT_FROM_TAG(bfa, msg.create_rsp->bfa_handle);
4668 rp->fw_handle = msg.create_rsp->fw_handle;
4669 rp->qos_attr = msg.create_rsp->qos_attr;
d4b671c5 4670 WARN_ON(msg.create_rsp->status != BFA_STATUS_OK);
a36c61f9
KG		 4671 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
4672 break;
4673
4674 case BFI_RPORT_I2H_DELETE_RSP:
4675 rp = BFA_RPORT_FROM_TAG(bfa, msg.delete_rsp->bfa_handle);
d4b671c5 4676 WARN_ON(msg.delete_rsp->status != BFA_STATUS_OK);
a36c61f9
KG		 4677 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
4678 break;
4679
4680 case BFI_RPORT_I2H_QOS_SCN:
4681 rp = BFA_RPORT_FROM_TAG(bfa, msg.qos_scn_evt->bfa_handle);
4682 rp->event_arg.fw_msg = msg.qos_scn_evt;
4683 bfa_sm_send_event(rp, BFA_RPORT_SM_QOS_SCN);
4684 break;
4685
4686 default:
4687 bfa_trc(bfa, m->mhdr.msg_id);
d4b671c5 4688 WARN_ON(1);
a36c61f9
KG		 4689 }
4690}
4691
3fd45980
KG		 4692void
4693bfa_rport_res_recfg(struct bfa_s *bfa, u16 num_rport_fw)
4694{
4695 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa);
4696 struct list_head *qe;
4697 int i;
a36c61f9 4698
3fd45980
KG		 4699 for (i = 0; i < (mod->num_rports - num_rport_fw); i++) {
4700 bfa_q_deq_tail(&mod->rp_free_q, &qe);
4701 list_add_tail(qe, &mod->rp_unused_q);
4702 }
4703}
a36c61f9 4704
5fbe25c7 4705/*
a36c61f9
KG		 4706 * bfa_rport_api
4707 */
4708
4709struct bfa_rport_s *
4710bfa_rport_create(struct bfa_s *bfa, void *rport_drv)
4711{
4712 struct bfa_rport_s *rp;
4713
4714 rp = bfa_rport_alloc(BFA_RPORT_MOD(bfa));
4715
4716 if (rp == NULL)
4717 return NULL;
4718
4719 rp->bfa = bfa;
4720 rp->rport_drv = rport_drv;
f7f73812 4721 memset(&rp->stats, 0, sizeof(rp->stats));
a36c61f9 4722
d4b671c5 4723 WARN_ON(!bfa_sm_cmp_state(rp, bfa_rport_sm_uninit));
a36c61f9
KG		 4724 bfa_sm_send_event(rp, BFA_RPORT_SM_CREATE);
4725
4726 return rp;
4727}
4728
a36c61f9
KG		 4729void
4730bfa_rport_online(struct bfa_rport_s *rport, struct bfa_rport_info_s *rport_info)
4731{
d4b671c5 4732 WARN_ON(rport_info->max_frmsz == 0);
a36c61f9 4733
5fbe25c7 4734 /*
a36c61f9
KG		 4735 * Some JBODs are seen to be not setting PDU size correctly in PLOGI
4736 * responses. Default to minimum size.
4737 */
4738 if (rport_info->max_frmsz == 0) {
4739 bfa_trc(rport->bfa, rport->rport_tag);
4740 rport_info->max_frmsz = FC_MIN_PDUSZ;
4741 }
4742
6a18b167 4743 rport->rport_info = *rport_info;
a36c61f9
KG		 4744 bfa_sm_send_event(rport, BFA_RPORT_SM_ONLINE);
4745}
4746
a36c61f9
KG		 4747void
4748bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed)
4749{
d4b671c5
JH		 4750 WARN_ON(speed == 0);
4751 WARN_ON(speed == BFA_PORT_SPEED_AUTO);
a36c61f9
KG		 4752
4753 rport->rport_info.speed = speed;
4754 bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
4755}
4756
a36c61f9 4757
5fbe25c7 4758/*
a36c61f9
KG		 4759 * SGPG related functions
4760 */
4761
5fbe25c7 4762/*
a36c61f9
KG		 4763 * Compute and return memory needed by FCP(im) module.
4764 */
4765static void
4507025d
KG		 4766bfa_sgpg_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
4767 struct bfa_s *bfa)
a36c61f9 4768{
4507025d
KG		 4769 struct bfa_sgpg_mod_s *sgpg_mod = BFA_SGPG_MOD(bfa);
4770 struct bfa_mem_kva_s *sgpg_kva = BFA_MEM_SGPG_KVA(bfa);
4771 struct bfa_mem_dma_s *seg_ptr;
4772 u16 nsegs, idx, per_seg_sgpg, num_sgpg;
4773 u32 sgpg_sz = sizeof(struct bfi_sgpg_s);
4774
a36c61f9
KG		 4775 if (cfg->drvcfg.num_sgpgs < BFA_SGPG_MIN)
4776 cfg->drvcfg.num_sgpgs = BFA_SGPG_MIN;
4507025d
KG		 4777 else if (cfg->drvcfg.num_sgpgs > BFA_SGPG_MAX)
4778 cfg->drvcfg.num_sgpgs = BFA_SGPG_MAX;
a36c61f9 4779
4507025d
KG		 4780 num_sgpg = cfg->drvcfg.num_sgpgs;
4781
4782 nsegs = BFI_MEM_DMA_NSEGS(num_sgpg, sgpg_sz);
4783 per_seg_sgpg = BFI_MEM_NREQS_SEG(sgpg_sz);
4784
4785 bfa_mem_dma_seg_iter(sgpg_mod, seg_ptr, nsegs, idx) {
4786 if (num_sgpg >= per_seg_sgpg) {
4787 num_sgpg -= per_seg_sgpg;
4788 bfa_mem_dma_setup(minfo, seg_ptr,
4789 per_seg_sgpg * sgpg_sz);
4790 } else
4791 bfa_mem_dma_setup(minfo, seg_ptr,
4792 num_sgpg * sgpg_sz);
4793 }
a36c61f9 4794
4507025d
KG		 4795 /* kva memory */
4796 bfa_mem_kva_setup(minfo, sgpg_kva,
4797 cfg->drvcfg.num_sgpgs * sizeof(struct bfa_sgpg_s));
4798}
a36c61f9
KG		 4799
4800static void
4801bfa_sgpg_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4507025d 4802 struct bfa_pcidev_s *pcidev)
a36c61f9
KG		 4803{
4804 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
a36c61f9
KG		 4805 struct bfa_sgpg_s *hsgpg;
4806 struct bfi_sgpg_s *sgpg;
4807 u64 align_len;
4507025d
KG		 4808 struct bfa_mem_dma_s *seg_ptr;
4809 u32 sgpg_sz = sizeof(struct bfi_sgpg_s);
4810 u16 i, idx, nsegs, per_seg_sgpg, num_sgpg;
a36c61f9
KG		 4811
4812 union {
4813 u64 pa;
4814 union bfi_addr_u addr;
4815 } sgpg_pa, sgpg_pa_tmp;
4816
4817 INIT_LIST_HEAD(&mod->sgpg_q);
4818 INIT_LIST_HEAD(&mod->sgpg_wait_q);
4819
4820 bfa_trc(bfa, cfg->drvcfg.num_sgpgs);
4821
4507025d
KG		 4822 mod->free_sgpgs = mod->num_sgpgs = cfg->drvcfg.num_sgpgs;
4823
4824 num_sgpg = cfg->drvcfg.num_sgpgs;
4825 nsegs = BFI_MEM_DMA_NSEGS(num_sgpg, sgpg_sz);
4826
4827 /* dma/kva mem claim */
4828 hsgpg = (struct bfa_sgpg_s *) bfa_mem_kva_curp(mod);
4829
4830 bfa_mem_dma_seg_iter(mod, seg_ptr, nsegs, idx) {
4831
4832 if (!bfa_mem_dma_virt(seg_ptr))
4833 break;
4834
4835 align_len = BFA_SGPG_ROUNDUP(bfa_mem_dma_phys(seg_ptr)) -
4836 bfa_mem_dma_phys(seg_ptr);
4837
4838 sgpg = (struct bfi_sgpg_s *)
4839 (((u8 *) bfa_mem_dma_virt(seg_ptr)) + align_len);
4840 sgpg_pa.pa = bfa_mem_dma_phys(seg_ptr) + align_len;
4841 WARN_ON(sgpg_pa.pa & (sgpg_sz - 1));
4842
4843 per_seg_sgpg = (seg_ptr->mem_len - (u32)align_len) / sgpg_sz;
4844
4845 for (i = 0; num_sgpg > 0 && i < per_seg_sgpg; i++, num_sgpg--) {
4846 memset(hsgpg, 0, sizeof(*hsgpg));
4847 memset(sgpg, 0, sizeof(*sgpg));
4848
4849 hsgpg->sgpg = sgpg;
4850 sgpg_pa_tmp.pa = bfa_sgaddr_le(sgpg_pa.pa);
4851 hsgpg->sgpg_pa = sgpg_pa_tmp.addr;
4852 list_add_tail(&hsgpg->qe, &mod->sgpg_q);
4853
4854 sgpg++;
4855 hsgpg++;
4856 sgpg_pa.pa += sgpg_sz;
4857 }
a36c61f9
KG		 4858 }
4859
4507025d 4860 bfa_mem_kva_curp(mod) = (u8 *) hsgpg;
a36c61f9
KG		 4861}
4862
4863static void
4864bfa_sgpg_detach(struct bfa_s *bfa)
4865{
4866}
4867
4868static void
4869bfa_sgpg_start(struct bfa_s *bfa)
4870{
4871}
4872
4873static void
4874bfa_sgpg_stop(struct bfa_s *bfa)
4875{
4876}
4877
4878static void
4879bfa_sgpg_iocdisable(struct bfa_s *bfa)
4880{
4881}
4882
a36c61f9
KG		 4883bfa_status_t
4884bfa_sgpg_malloc(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpgs)
4885{
4886 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4887 struct bfa_sgpg_s *hsgpg;
4888 int i;
4889
a36c61f9
KG		 4890 if (mod->free_sgpgs < nsgpgs)
4891 return BFA_STATUS_ENOMEM;
4892
4893 for (i = 0; i < nsgpgs; i++) {
4894 bfa_q_deq(&mod->sgpg_q, &hsgpg);
d4b671c5 4895 WARN_ON(!hsgpg);
a36c61f9
KG		 4896 list_add_tail(&hsgpg->qe, sgpg_q);
4897 }
4898
4899 mod->free_sgpgs -= nsgpgs;
4900 return BFA_STATUS_OK;
4901}
4902
4903void
4904bfa_sgpg_mfree(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpg)
4905{
4906 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4907 struct bfa_sgpg_wqe_s *wqe;
4908
a36c61f9 4909 mod->free_sgpgs += nsgpg;
d4b671c5 4910 WARN_ON(mod->free_sgpgs > mod->num_sgpgs);
a36c61f9
KG		 4911
4912 list_splice_tail_init(sgpg_q, &mod->sgpg_q);
4913
4914 if (list_empty(&mod->sgpg_wait_q))
4915 return;
4916
5fbe25c7 4917 /*
a36c61f9
KG		 4918 * satisfy as many waiting requests as possible
4919 */
4920 do {
4921 wqe = bfa_q_first(&mod->sgpg_wait_q);
4922 if (mod->free_sgpgs < wqe->nsgpg)
4923 nsgpg = mod->free_sgpgs;
4924 else
4925 nsgpg = wqe->nsgpg;
4926 bfa_sgpg_malloc(bfa, &wqe->sgpg_q, nsgpg);
4927 wqe->nsgpg -= nsgpg;
4928 if (wqe->nsgpg == 0) {
4929 list_del(&wqe->qe);
4930 wqe->cbfn(wqe->cbarg);
4931 }
4932 } while (mod->free_sgpgs && !list_empty(&mod->sgpg_wait_q));
4933}
4934
4935void
4936bfa_sgpg_wait(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe, int nsgpg)
4937{
4938 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4939
d4b671c5
JH		 4940 WARN_ON(nsgpg <= 0);
4941 WARN_ON(nsgpg <= mod->free_sgpgs);
a36c61f9
KG		 4942
4943 wqe->nsgpg_total = wqe->nsgpg = nsgpg;
4944
5fbe25c7 4945 /*
a36c61f9
KG		 4946 * allocate any left to this one first
4947 */
4948 if (mod->free_sgpgs) {
5fbe25c7 4949 /*
a36c61f9
KG		 4950 * no one else is waiting for SGPG
4951 */
d4b671c5 4952 WARN_ON(!list_empty(&mod->sgpg_wait_q));
a36c61f9
KG		 4953 list_splice_tail_init(&mod->sgpg_q, &wqe->sgpg_q);
4954 wqe->nsgpg -= mod->free_sgpgs;
4955 mod->free_sgpgs = 0;
4956 }
4957
4958 list_add_tail(&wqe->qe, &mod->sgpg_wait_q);
4959}
4960
4961void
4962bfa_sgpg_wcancel(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe)
4963{
4964 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa);
4965
d4b671c5 4966 WARN_ON(!bfa_q_is_on_q(&mod->sgpg_wait_q, wqe));
a36c61f9
KG		 4967 list_del(&wqe->qe);
4968
4969 if (wqe->nsgpg_total != wqe->nsgpg)
4970 bfa_sgpg_mfree(bfa, &wqe->sgpg_q,
4971 wqe->nsgpg_total - wqe->nsgpg);
4972}
4973
4974void
4975bfa_sgpg_winit(struct bfa_sgpg_wqe_s *wqe, void (*cbfn) (void *cbarg),
4976 void *cbarg)
4977{
4978 INIT_LIST_HEAD(&wqe->sgpg_q);
4979 wqe->cbfn = cbfn;
4980 wqe->cbarg = cbarg;
4981}
4982
5fbe25c7 4983/*
a36c61f9
KG		 4984 * UF related functions
4985 */
4986/*
4987 *****************************************************************************
4988 * Internal functions
4989 *****************************************************************************
4990 */
4991static void
4992__bfa_cb_uf_recv(void *cbarg, bfa_boolean_t complete)
4993{
4994 struct bfa_uf_s *uf = cbarg;
4995 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(uf->bfa);
4996
4997 if (complete)
4998 ufm->ufrecv(ufm->cbarg, uf);
4999}
5000
5001static void
4507025d 5002claim_uf_post_msgs(struct bfa_uf_mod_s *ufm)
a36c61f9
KG		 5003{
5004 struct bfi_uf_buf_post_s *uf_bp_msg;
a36c61f9
KG		 5005 u16 i;
5006 u16 buf_len;
5007
4507025d 5008 ufm->uf_buf_posts = (struct bfi_uf_buf_post_s *) bfa_mem_kva_curp(ufm);
a36c61f9
KG		 5009 uf_bp_msg = ufm->uf_buf_posts;
5010
5011 for (i = 0, uf_bp_msg = ufm->uf_buf_posts; i < ufm->num_ufs;
5012 i++, uf_bp_msg++) {
6a18b167 5013 memset(uf_bp_msg, 0, sizeof(struct bfi_uf_buf_post_s));
a36c61f9
KG		 5014
5015 uf_bp_msg->buf_tag = i;
5016 buf_len = sizeof(struct bfa_uf_buf_s);
ba816ea8 5017 uf_bp_msg->buf_len = cpu_to_be16(buf_len);
a36c61f9 5018 bfi_h2i_set(uf_bp_msg->mh, BFI_MC_UF, BFI_UF_H2I_BUF_POST,
3fd45980 5019 bfa_fn_lpu(ufm->bfa));
85ce928d 5020 bfa_alen_set(&uf_bp_msg->alen, buf_len, ufm_pbs_pa(ufm, i));
a36c61f9
KG		 5021 }
5022
5fbe25c7 5023 /*
a36c61f9
KG		 5024 * advance pointer beyond consumed memory
5025 */
4507025d 5026 bfa_mem_kva_curp(ufm) = (u8 *) uf_bp_msg;
a36c61f9
KG		 5027}
5028
5029static void
4507025d 5030claim_ufs(struct bfa_uf_mod_s *ufm)
a36c61f9
KG		 5031{
5032 u16 i;
5033 struct bfa_uf_s *uf;
5034
5035 /*
5036 * Claim block of memory for UF list
5037 */
4507025d 5038 ufm->uf_list = (struct bfa_uf_s *) bfa_mem_kva_curp(ufm);
a36c61f9
KG		 5039
5040 /*
5041 * Initialize UFs and queue it in UF free queue
5042 */
5043 for (i = 0, uf = ufm->uf_list; i < ufm->num_ufs; i++, uf++) {
6a18b167 5044 memset(uf, 0, sizeof(struct bfa_uf_s));
a36c61f9
KG		 5045 uf->bfa = ufm->bfa;
5046 uf->uf_tag = i;
4507025d
KG		 5047 uf->pb_len = BFA_PER_UF_DMA_SZ;
5048 uf->buf_kva = bfa_mem_get_dmabuf_kva(ufm, i, BFA_PER_UF_DMA_SZ);
a36c61f9
KG		 5049 uf->buf_pa = ufm_pbs_pa(ufm, i);
5050 list_add_tail(&uf->qe, &ufm->uf_free_q);
5051 }
5052
5fbe25c7 5053 /*
a36c61f9
KG		 5054 * advance memory pointer
5055 */
4507025d 5056 bfa_mem_kva_curp(ufm) = (u8 *) uf;
a36c61f9
KG		 5057}
5058
5059static void
4507025d 5060uf_mem_claim(struct bfa_uf_mod_s *ufm)
a36c61f9 5061{
4507025d
KG		 5062 claim_ufs(ufm);
5063 claim_uf_post_msgs(ufm);
a36c61f9
KG		 5064}
5065
5066static void
4507025d
KG		 5067bfa_uf_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
5068 struct bfa_s *bfa)
a36c61f9 5069{
4507025d
KG		 5070 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5071 struct bfa_mem_kva_s *uf_kva = BFA_MEM_UF_KVA(bfa);
5072 u32 num_ufs = cfg->fwcfg.num_uf_bufs;
5073 struct bfa_mem_dma_s *seg_ptr;
5074 u16 nsegs, idx, per_seg_uf = 0;
5075
5076 nsegs = BFI_MEM_DMA_NSEGS(num_ufs, BFA_PER_UF_DMA_SZ);
5077 per_seg_uf = BFI_MEM_NREQS_SEG(BFA_PER_UF_DMA_SZ);
5078
5079 bfa_mem_dma_seg_iter(ufm, seg_ptr, nsegs, idx) {
5080 if (num_ufs >= per_seg_uf) {
5081 num_ufs -= per_seg_uf;
5082 bfa_mem_dma_setup(minfo, seg_ptr,
5083 per_seg_uf * BFA_PER_UF_DMA_SZ);
5084 } else
5085 bfa_mem_dma_setup(minfo, seg_ptr,
5086 num_ufs * BFA_PER_UF_DMA_SZ);
5087 }
a36c61f9 5088
4507025d
KG		 5089 /* kva memory */
5090 bfa_mem_kva_setup(minfo, uf_kva, cfg->fwcfg.num_uf_bufs *
5091 (sizeof(struct bfa_uf_s) + sizeof(struct bfi_uf_buf_post_s)));
a36c61f9
KG		 5092}
5093
5094static void
5095bfa_uf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
4507025d 5096 struct bfa_pcidev_s *pcidev)
a36c61f9
KG		 5097{
5098 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5099
a36c61f9
KG		 5100 ufm->bfa = bfa;
5101 ufm->num_ufs = cfg->fwcfg.num_uf_bufs;
5102 INIT_LIST_HEAD(&ufm->uf_free_q);
5103 INIT_LIST_HEAD(&ufm->uf_posted_q);
3fd45980 5104 INIT_LIST_HEAD(&ufm->uf_unused_q);
a36c61f9 5105
4507025d 5106 uf_mem_claim(ufm);
a36c61f9
KG		 5107}
5108
5109static void
5110bfa_uf_detach(struct bfa_s *bfa)
5111{
5112}
5113
5114static struct bfa_uf_s *
5115bfa_uf_get(struct bfa_uf_mod_s *uf_mod)
5116{
5117 struct bfa_uf_s *uf;
5118
5119 bfa_q_deq(&uf_mod->uf_free_q, &uf);
5120 return uf;
5121}
5122
5123static void
5124bfa_uf_put(struct bfa_uf_mod_s *uf_mod, struct bfa_uf_s *uf)
5125{
5126 list_add_tail(&uf->qe, &uf_mod->uf_free_q);
5127}
5128
5129static bfa_status_t
5130bfa_uf_post(struct bfa_uf_mod_s *ufm, struct bfa_uf_s *uf)
5131{
5132 struct bfi_uf_buf_post_s *uf_post_msg;
5133
5134 uf_post_msg = bfa_reqq_next(ufm->bfa, BFA_REQQ_FCXP);
5135 if (!uf_post_msg)
5136 return BFA_STATUS_FAILED;
5137
6a18b167 5138 memcpy(uf_post_msg, &ufm->uf_buf_posts[uf->uf_tag],
a36c61f9 5139 sizeof(struct bfi_uf_buf_post_s));
3fd45980 5140 bfa_reqq_produce(ufm->bfa, BFA_REQQ_FCXP, uf_post_msg->mh);
a36c61f9
KG		 5141
5142 bfa_trc(ufm->bfa, uf->uf_tag);
5143
5144 list_add_tail(&uf->qe, &ufm->uf_posted_q);
5145 return BFA_STATUS_OK;
5146}
5147
5148static void
5149bfa_uf_post_all(struct bfa_uf_mod_s *uf_mod)
5150{
5151 struct bfa_uf_s *uf;
5152
5153 while ((uf = bfa_uf_get(uf_mod)) != NULL) {
5154 if (bfa_uf_post(uf_mod, uf) != BFA_STATUS_OK)
5155 break;
5156 }
5157}
5158
5159static void
5160uf_recv(struct bfa_s *bfa, struct bfi_uf_frm_rcvd_s *m)
5161{
5162 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5163 u16 uf_tag = m->buf_tag;
a36c61f9 5164 struct bfa_uf_s *uf = &ufm->uf_list[uf_tag];
4507025d
KG		 5165 struct bfa_uf_buf_s *uf_buf;
5166 uint8_t *buf;
a36c61f9
KG		 5167 struct fchs_s *fchs;
5168
4507025d
KG		 5169 uf_buf = (struct bfa_uf_buf_s *)
5170 bfa_mem_get_dmabuf_kva(ufm, uf_tag, uf->pb_len);
5171 buf = &uf_buf->d[0];
5172
ba816ea8
JH		 5173 m->frm_len = be16_to_cpu(m->frm_len);
5174 m->xfr_len = be16_to_cpu(m->xfr_len);
a36c61f9
KG		 5175
5176 fchs = (struct fchs_s *)uf_buf;
5177
5178 list_del(&uf->qe); /* dequeue from posted queue */
5179
5180 uf->data_ptr = buf;
5181 uf->data_len = m->xfr_len;
5182
d4b671c5 5183 WARN_ON(uf->data_len < sizeof(struct fchs_s));
a36c61f9
KG		 5184
5185 if (uf->data_len == sizeof(struct fchs_s)) {
5186 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_UF, BFA_PL_EID_RX,
5187 uf->data_len, (struct fchs_s *)buf);
5188 } else {
5189 u32 pld_w0 = *((u32 *) (buf + sizeof(struct fchs_s)));
5190 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_UF,
5191 BFA_PL_EID_RX, uf->data_len,
5192 (struct fchs_s *)buf, pld_w0);
5193 }
5194
5195 if (bfa->fcs)
5196 __bfa_cb_uf_recv(uf, BFA_TRUE);
5197 else
5198 bfa_cb_queue(bfa, &uf->hcb_qe, __bfa_cb_uf_recv, uf);
5199}
5200
5201static void
5202bfa_uf_stop(struct bfa_s *bfa)
5203{
5204}
5205
5206static void
5207bfa_uf_iocdisable(struct bfa_s *bfa)
5208{
5209 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5210 struct bfa_uf_s *uf;
5211 struct list_head *qe, *qen;
5212
3fd45980
KG		 5213 /* Enqueue unused uf resources to free_q */
5214 list_splice_tail_init(&ufm->uf_unused_q, &ufm->uf_free_q);
5215
a36c61f9
KG		 5216 list_for_each_safe(qe, qen, &ufm->uf_posted_q) {
5217 uf = (struct bfa_uf_s *) qe;
5218 list_del(&uf->qe);
5219 bfa_uf_put(ufm, uf);
5220 }
5221}
5222
5223static void
5224bfa_uf_start(struct bfa_s *bfa)
5225{
5226 bfa_uf_post_all(BFA_UF_MOD(bfa));
5227}
5228
5fbe25c7 5229/*
25985edc 5230 * Register handler for all unsolicted receive frames.
a36c61f9
KG		 5231 *
5232 * @param[in] bfa BFA instance
5233 * @param[in] ufrecv receive handler function
5234 * @param[in] cbarg receive handler arg
5235 */
5236void
5237bfa_uf_recv_register(struct bfa_s *bfa, bfa_cb_uf_recv_t ufrecv, void *cbarg)
5238{
5239 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa);
5240
5241 ufm->ufrecv = ufrecv;
5242 ufm->cbarg = cbarg;
5243}
5244
5fbe25c7 5245/*
a36c61f9
KG		 5246 * Free an unsolicited frame back to BFA.
5247 *
5248 * @param[in] uf unsolicited frame to be freed
5249 *
5250 * @return None
5251 */
5252void
5253bfa_uf_free(struct bfa_uf_s *uf)
5254{
5255 bfa_uf_put(BFA_UF_MOD(uf->bfa), uf);
5256 bfa_uf_post_all(BFA_UF_MOD(uf->bfa));
5257}
5258
5259
5260
5fbe25c7 5261/*
a36c61f9
KG		 5262 * uf_pub BFA uf module public functions
5263 */
5264void
5265bfa_uf_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
5266{
5267 bfa_trc(bfa, msg->mhdr.msg_id);
5268
5269 switch (msg->mhdr.msg_id) {
5270 case BFI_UF_I2H_FRM_RCVD:
5271 uf_recv(bfa, (struct bfi_uf_frm_rcvd_s *) msg);
5272 break;
5273
5274 default:
5275 bfa_trc(bfa, msg->mhdr.msg_id);
d4b671c5 5276 WARN_ON(1);
a36c61f9
KG		 5277 }
5278}
5279
3fd45980
KG		 5280void
5281bfa_uf_res_recfg(struct bfa_s *bfa, u16 num_uf_fw)
5282{
5283 struct bfa_uf_mod_s *mod = BFA_UF_MOD(bfa);
5284 struct list_head *qe;
5285 int i;
a36c61f9 5286
3fd45980
KG		 5287 for (i = 0; i < (mod->num_ufs - num_uf_fw); i++) {
5288 bfa_q_deq_tail(&mod->uf_free_q, &qe);
5289 list_add_tail(qe, &mod->uf_unused_q);
5290 }
5291}
3d7fc66d
KG		 5292
5293/*
5294 * BFA fcdiag module
5295 */
5296#define BFA_DIAG_QTEST_TOV 1000 /* msec */
5297
5298/*
5299 * Set port status to busy
5300 */
5301static void
5302bfa_fcdiag_set_busy_status(struct bfa_fcdiag_s *fcdiag)
5303{
5304 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(fcdiag->bfa);
5305
5306 if (fcdiag->lb.lock)
5307 fcport->diag_busy = BFA_TRUE;
5308 else
5309 fcport->diag_busy = BFA_FALSE;
5310}
5311
5312static void
5313bfa_fcdiag_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo,
5314 struct bfa_s *bfa)
5315{
5316}
5317
5318static void
5319bfa_fcdiag_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
5320 struct bfa_pcidev_s *pcidev)
5321{
5322 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5323 fcdiag->bfa = bfa;
5324 fcdiag->trcmod = bfa->trcmod;
5325 /* The common DIAG attach bfa_diag_attach() will do all memory claim */
5326}
5327
5328static void
5329bfa_fcdiag_iocdisable(struct bfa_s *bfa)
5330{
5331 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5332 bfa_trc(fcdiag, fcdiag->lb.lock);
5333 if (fcdiag->lb.lock) {
5334 fcdiag->lb.status = BFA_STATUS_IOC_FAILURE;
5335 fcdiag->lb.cbfn(fcdiag->lb.cbarg, fcdiag->lb.status);
5336 fcdiag->lb.lock = 0;
5337 bfa_fcdiag_set_busy_status(fcdiag);
5338 }
5339}
5340
5341static void
5342bfa_fcdiag_detach(struct bfa_s *bfa)
5343{
5344}
5345
5346static void
5347bfa_fcdiag_start(struct bfa_s *bfa)
5348{
5349}
5350
5351static void
5352bfa_fcdiag_stop(struct bfa_s *bfa)
5353{
5354}
5355
5356static void
5357bfa_fcdiag_queuetest_timeout(void *cbarg)
5358{
5359 struct bfa_fcdiag_s *fcdiag = cbarg;
5360 struct bfa_diag_qtest_result_s *res = fcdiag->qtest.result;
5361
5362 bfa_trc(fcdiag, fcdiag->qtest.all);
5363 bfa_trc(fcdiag, fcdiag->qtest.count);
5364
5365 fcdiag->qtest.timer_active = 0;
5366
5367 res->status = BFA_STATUS_ETIMER;
5368 res->count = QTEST_CNT_DEFAULT - fcdiag->qtest.count;
5369 if (fcdiag->qtest.all)
5370 res->queue = fcdiag->qtest.all;
5371
5372 bfa_trc(fcdiag, BFA_STATUS_ETIMER);
5373 fcdiag->qtest.status = BFA_STATUS_ETIMER;
5374 fcdiag->qtest.cbfn(fcdiag->qtest.cbarg, fcdiag->qtest.status);
5375 fcdiag->qtest.lock = 0;
5376}
5377
5378static bfa_status_t
5379bfa_fcdiag_queuetest_send(struct bfa_fcdiag_s *fcdiag)
5380{
5381 u32 i;
5382 struct bfi_diag_qtest_req_s *req;
5383
5384 req = bfa_reqq_next(fcdiag->bfa, fcdiag->qtest.queue);
5385 if (!req)
5386 return BFA_STATUS_DEVBUSY;
5387
5388 /* build host command */
5389 bfi_h2i_set(req->mh, BFI_MC_DIAG, BFI_DIAG_H2I_QTEST,
5390 bfa_fn_lpu(fcdiag->bfa));
5391
5392 for (i = 0; i < BFI_LMSG_PL_WSZ; i++)
5393 req->data[i] = QTEST_PAT_DEFAULT;
5394
5395 bfa_trc(fcdiag, fcdiag->qtest.queue);
5396 /* ring door bell */
5397 bfa_reqq_produce(fcdiag->bfa, fcdiag->qtest.queue, req->mh);
5398 return BFA_STATUS_OK;
5399}
5400
5401static void
5402bfa_fcdiag_queuetest_comp(struct bfa_fcdiag_s *fcdiag,
5403 bfi_diag_qtest_rsp_t *rsp)
5404{
5405 struct bfa_diag_qtest_result_s *res = fcdiag->qtest.result;
5406 bfa_status_t status = BFA_STATUS_OK;
5407 int i;
5408
5409 /* Check timer, should still be active */
5410 if (!fcdiag->qtest.timer_active) {
5411 bfa_trc(fcdiag, fcdiag->qtest.timer_active);
5412 return;
5413 }
5414
5415 /* update count */
5416 fcdiag->qtest.count--;
5417
5418 /* Check result */
5419 for (i = 0; i < BFI_LMSG_PL_WSZ; i++) {
5420 if (rsp->data[i] != ~(QTEST_PAT_DEFAULT)) {
5421 res->status = BFA_STATUS_DATACORRUPTED;
5422 break;
5423 }
5424 }
5425
5426 if (res->status == BFA_STATUS_OK) {
5427 if (fcdiag->qtest.count > 0) {
5428 status = bfa_fcdiag_queuetest_send(fcdiag);
5429 if (status == BFA_STATUS_OK)
5430 return;
5431 else
5432 res->status = status;
5433 } else if (fcdiag->qtest.all > 0 &&
5434 fcdiag->qtest.queue < (BFI_IOC_MAX_CQS - 1)) {
5435 fcdiag->qtest.count = QTEST_CNT_DEFAULT;
5436 fcdiag->qtest.queue++;
5437 status = bfa_fcdiag_queuetest_send(fcdiag);
5438 if (status == BFA_STATUS_OK)
5439 return;
5440 else
5441 res->status = status;
5442 }
5443 }
5444
5445 /* Stop timer when we comp all queue */
5446 if (fcdiag->qtest.timer_active) {
5447 bfa_timer_stop(&fcdiag->qtest.timer);
5448 fcdiag->qtest.timer_active = 0;
5449 }
5450 res->queue = fcdiag->qtest.queue;
5451 res->count = QTEST_CNT_DEFAULT - fcdiag->qtest.count;
5452 bfa_trc(fcdiag, res->count);
5453 bfa_trc(fcdiag, res->status);
5454 fcdiag->qtest.status = res->status;
5455 fcdiag->qtest.cbfn(fcdiag->qtest.cbarg, fcdiag->qtest.status);
5456 fcdiag->qtest.lock = 0;
5457}
5458
5459static void
5460bfa_fcdiag_loopback_comp(struct bfa_fcdiag_s *fcdiag,
5461 struct bfi_diag_lb_rsp_s *rsp)
5462{
5463 struct bfa_diag_loopback_result_s *res = fcdiag->lb.result;
5464
5465 res->numtxmfrm = be32_to_cpu(rsp->res.numtxmfrm);
5466 res->numosffrm = be32_to_cpu(rsp->res.numosffrm);
5467 res->numrcvfrm = be32_to_cpu(rsp->res.numrcvfrm);
5468 res->badfrminf = be32_to_cpu(rsp->res.badfrminf);
5469 res->badfrmnum = be32_to_cpu(rsp->res.badfrmnum);
5470 res->status = rsp->res.status;
5471 fcdiag->lb.status = rsp->res.status;
5472 bfa_trc(fcdiag, fcdiag->lb.status);
5473 fcdiag->lb.cbfn(fcdiag->lb.cbarg, fcdiag->lb.status);
5474 fcdiag->lb.lock = 0;
5475 bfa_fcdiag_set_busy_status(fcdiag);
5476}
5477
5478static bfa_status_t
5479bfa_fcdiag_loopback_send(struct bfa_fcdiag_s *fcdiag,
5480 struct bfa_diag_loopback_s *loopback)
5481{
5482 struct bfi_diag_lb_req_s *lb_req;
5483
5484 lb_req = bfa_reqq_next(fcdiag->bfa, BFA_REQQ_DIAG);
5485 if (!lb_req)
5486 return BFA_STATUS_DEVBUSY;
5487
5488 /* build host command */
5489 bfi_h2i_set(lb_req->mh, BFI_MC_DIAG, BFI_DIAG_H2I_LOOPBACK,
5490 bfa_fn_lpu(fcdiag->bfa));
5491
5492 lb_req->lb_mode = loopback->lb_mode;
5493 lb_req->speed = loopback->speed;
5494 lb_req->loopcnt = loopback->loopcnt;
5495 lb_req->pattern = loopback->pattern;
5496
5497 /* ring door bell */
5498 bfa_reqq_produce(fcdiag->bfa, BFA_REQQ_DIAG, lb_req->mh);
5499
5500 bfa_trc(fcdiag, loopback->lb_mode);
5501 bfa_trc(fcdiag, loopback->speed);
5502 bfa_trc(fcdiag, loopback->loopcnt);
5503 bfa_trc(fcdiag, loopback->pattern);
5504 return BFA_STATUS_OK;
5505}
5506
5507/*
5508 * cpe/rme intr handler
5509 */
5510void
5511bfa_fcdiag_intr(struct bfa_s *bfa, struct bfi_msg_s *msg)
5512{
5513 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5514
5515 switch (msg->mhdr.msg_id) {
5516 case BFI_DIAG_I2H_LOOPBACK:
5517 bfa_fcdiag_loopback_comp(fcdiag,
5518 (struct bfi_diag_lb_rsp_s *) msg);
5519 break;
5520 case BFI_DIAG_I2H_QTEST:
5521 bfa_fcdiag_queuetest_comp(fcdiag, (bfi_diag_qtest_rsp_t *)msg);
5522 break;
5523 default:
5524 bfa_trc(fcdiag, msg->mhdr.msg_id);
5525 WARN_ON(1);
5526 }
5527}
5528
5529/*
5530 * Loopback test
5531 *
5532 * @param[in] *bfa - bfa data struct
5533 * @param[in] opmode - port operation mode
5534 * @param[in] speed - port speed
5535 * @param[in] lpcnt - loop count
5536 * @param[in] pat - pattern to build packet
5537 * @param[in] *result - pt to bfa_diag_loopback_result_t data struct
5538 * @param[in] cbfn - callback function
5539 * @param[in] cbarg - callback functioin arg
5540 *
5541 * @param[out]
5542 */
5543bfa_status_t
5544bfa_fcdiag_loopback(struct bfa_s *bfa, enum bfa_port_opmode opmode,
5545 enum bfa_port_speed speed, u32 lpcnt, u32 pat,
5546 struct bfa_diag_loopback_result_s *result, bfa_cb_diag_t cbfn,
5547 void *cbarg)
5548{
5549 struct bfa_diag_loopback_s loopback;
5550 struct bfa_port_attr_s attr;
5551 bfa_status_t status;
5552 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5553
5554 if (!bfa_iocfc_is_operational(bfa))
5555 return BFA_STATUS_IOC_NON_OP;
5556
5557 /* if port is PBC disabled, return error */
5558 if (bfa_fcport_is_pbcdisabled(bfa)) {
5559 bfa_trc(fcdiag, BFA_STATUS_PBC);
5560 return BFA_STATUS_PBC;
5561 }
5562
5563 if (bfa_fcport_is_disabled(bfa) == BFA_FALSE) {
5564 bfa_trc(fcdiag, opmode);
5565 return BFA_STATUS_PORT_NOT_DISABLED;
5566 }
5567
fb778b06
KG		 5568 /*
5569 * Check if input speed is supported by the port mode
5570 */
5571 if (bfa_ioc_get_type(&bfa->ioc) == BFA_IOC_TYPE_FC) {
5572 if (!(speed == BFA_PORT_SPEED_1GBPS ||
5573 speed == BFA_PORT_SPEED_2GBPS ||
5574 speed == BFA_PORT_SPEED_4GBPS ||
5575 speed == BFA_PORT_SPEED_8GBPS ||
5576 speed == BFA_PORT_SPEED_16GBPS ||
5577 speed == BFA_PORT_SPEED_AUTO)) {
5578 bfa_trc(fcdiag, speed);
5579 return BFA_STATUS_UNSUPP_SPEED;
5580 }
5581 bfa_fcport_get_attr(bfa, &attr);
5582 bfa_trc(fcdiag, attr.speed_supported);
5583 if (speed > attr.speed_supported)
5584 return BFA_STATUS_UNSUPP_SPEED;
5585 } else {
5586 if (speed != BFA_PORT_SPEED_10GBPS) {
5587 bfa_trc(fcdiag, speed);
5588 return BFA_STATUS_UNSUPP_SPEED;
5589 }
5590 }
3d7fc66d
KG		 5591
5592 /* For Mezz card, port speed entered needs to be checked */
5593 if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type)) {
5594 if (bfa_ioc_get_type(&bfa->ioc) == BFA_IOC_TYPE_FC) {
5595 if ((speed == BFA_PORT_SPEED_1GBPS) &&
5596 (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)))
5597 return BFA_STATUS_UNSUPP_SPEED;
5598 if (!(speed == BFA_PORT_SPEED_1GBPS ||
5599 speed == BFA_PORT_SPEED_2GBPS ||
5600 speed == BFA_PORT_SPEED_4GBPS ||
5601 speed == BFA_PORT_SPEED_8GBPS ||
5602 speed == BFA_PORT_SPEED_16GBPS ||
5603 speed == BFA_PORT_SPEED_AUTO))
5604 return BFA_STATUS_UNSUPP_SPEED;
5605 } else {
5606 if (speed != BFA_PORT_SPEED_10GBPS)
5607 return BFA_STATUS_UNSUPP_SPEED;
5608 }
5609 }
5610
5611 /* check to see if there is another destructive diag cmd running */
5612 if (fcdiag->lb.lock) {
5613 bfa_trc(fcdiag, fcdiag->lb.lock);
5614 return BFA_STATUS_DEVBUSY;
5615 }
5616
5617 fcdiag->lb.lock = 1;
5618 loopback.lb_mode = opmode;
5619 loopback.speed = speed;
5620 loopback.loopcnt = lpcnt;
5621 loopback.pattern = pat;
5622 fcdiag->lb.result = result;
5623 fcdiag->lb.cbfn = cbfn;
5624 fcdiag->lb.cbarg = cbarg;
5625 memset(result, 0, sizeof(struct bfa_diag_loopback_result_s));
5626 bfa_fcdiag_set_busy_status(fcdiag);
5627
5628 /* Send msg to fw */
5629 status = bfa_fcdiag_loopback_send(fcdiag, &loopback);
5630 return status;
5631}
5632
5633/*
5634 * DIAG queue test command
5635 *
5636 * @param[in] *bfa - bfa data struct
5637 * @param[in] force - 1: don't do ioc op checking
5638 * @param[in] queue - queue no. to test
5639 * @param[in] *result - pt to bfa_diag_qtest_result_t data struct
5640 * @param[in] cbfn - callback function
5641 * @param[in] *cbarg - callback functioin arg
5642 *
5643 * @param[out]
5644 */
5645bfa_status_t
5646bfa_fcdiag_queuetest(struct bfa_s *bfa, u32 force, u32 queue,
5647 struct bfa_diag_qtest_result_s *result, bfa_cb_diag_t cbfn,
5648 void *cbarg)
5649{
5650 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5651 bfa_status_t status;
5652 bfa_trc(fcdiag, force);
5653 bfa_trc(fcdiag, queue);
5654
5655 if (!force && !bfa_iocfc_is_operational(bfa))
5656 return BFA_STATUS_IOC_NON_OP;
5657
5658 /* check to see if there is another destructive diag cmd running */
5659 if (fcdiag->qtest.lock) {
5660 bfa_trc(fcdiag, fcdiag->qtest.lock);
5661 return BFA_STATUS_DEVBUSY;
5662 }
5663
5664 /* Initialization */
5665 fcdiag->qtest.lock = 1;
5666 fcdiag->qtest.cbfn = cbfn;
5667 fcdiag->qtest.cbarg = cbarg;
5668 fcdiag->qtest.result = result;
5669 fcdiag->qtest.count = QTEST_CNT_DEFAULT;
5670
5671 /* Init test results */
5672 fcdiag->qtest.result->status = BFA_STATUS_OK;
5673 fcdiag->qtest.result->count = 0;
5674
5675 /* send */
5676 if (queue < BFI_IOC_MAX_CQS) {
5677 fcdiag->qtest.result->queue = (u8)queue;
5678 fcdiag->qtest.queue = (u8)queue;
5679 fcdiag->qtest.all = 0;
5680 } else {
5681 fcdiag->qtest.result->queue = 0;
5682 fcdiag->qtest.queue = 0;
5683 fcdiag->qtest.all = 1;
5684 }
5685 status = bfa_fcdiag_queuetest_send(fcdiag);
5686
5687 /* Start a timer */
5688 if (status == BFA_STATUS_OK) {
5689 bfa_timer_start(bfa, &fcdiag->qtest.timer,
5690 bfa_fcdiag_queuetest_timeout, fcdiag,
5691 BFA_DIAG_QTEST_TOV);
5692 fcdiag->qtest.timer_active = 1;
5693 }
5694 return status;
5695}
5696
5697/*
5698 * DIAG PLB is running
5699 *
5700 * @param[in] *bfa - bfa data struct
5701 *
5702 * @param[out]
5703 */
5704bfa_status_t
5705bfa_fcdiag_lb_is_running(struct bfa_s *bfa)
5706{
5707 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa);
5708 return fcdiag->lb.lock ? BFA_STATUS_DIAG_BUSY : BFA_STATUS_OK;
5709}
Ubuntu Artful kernel mirror