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