xref: /openbmc/linux/drivers/scsi/bfa/bfa_svc.c (revision 973464fd)
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
plkd_validate_logrec(struct bfa_plog_rec_s * pl_rec)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
bfa_plog_add(struct bfa_plog_s * plog,struct bfa_plog_rec_s * pl_rec)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
bfa_plog_init(struct bfa_plog_s * plog)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
bfa_plog_str(struct bfa_plog_s * plog,enum bfa_plog_mid mid,enum bfa_plog_eid event,u16 misc,char * log_str)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(lp.log_entry.string_log, 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, &lp);
337 	}
338 }
339 
340 void
bfa_plog_intarr(struct bfa_plog_s * plog,enum bfa_plog_mid mid,enum bfa_plog_eid event,u16 misc,u32 * intarr,u32 num_ints)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, &lp);
364 	}
365 }
366 
367 void
bfa_plog_fchdr(struct bfa_plog_s * plog,enum bfa_plog_mid mid,enum bfa_plog_eid event,u16 misc,struct fchs_s * fchdr)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, ints, 3);
381 	}
382 }
383 
384 void
bfa_plog_fchdr_and_pl(struct bfa_plog_s * plog,enum bfa_plog_mid mid,enum bfa_plog_eid event,u16 misc,struct fchs_s * fchdr,u32 pld_w0)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, ints, 4);
399 	}
400 }
401 
402 
403 /*
404  *  fcxp_pvt BFA FCXP private functions
405  */
406 
407 static void
claim_fcxps_mem(struct bfa_fcxp_mod_s * mod)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(&mod->fcxp_req_free_q);
417 	INIT_LIST_HEAD(&mod->fcxp_rsp_free_q);
418 	INIT_LIST_HEAD(&mod->fcxp_active_q);
419 	INIT_LIST_HEAD(&mod->fcxp_req_unused_q);
420 	INIT_LIST_HEAD(&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(&fcxp->qe, &mod->fcxp_req_free_q);
430 			fcxp->req_rsp = BFA_TRUE;
431 		} else {
432 			list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q);
433 			fcxp->req_rsp = BFA_FALSE;
434 		}
435 
436 		bfa_reqq_winit(&fcxp->reqq_wqe, bfa_fcxp_qresume, 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
bfa_fcxp_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)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(minfo, seg_ptr,
472 				per_seg_fcxp * per_fcxp_sz);
473 		} else
474 			bfa_mem_dma_setup(minfo, seg_ptr,
475 				num_fcxps * per_fcxp_sz);
476 	}
477 
478 	/* kva memory */
479 	bfa_mem_kva_setup(minfo, fcxp_kva,
480 		cfg->fwcfg.num_fcxp_reqs * sizeof(struct bfa_fcxp_s));
481 }
482 
483 void
bfa_fcxp_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)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(&mod->req_wait_q);
500 	INIT_LIST_HEAD(&mod->rsp_wait_q);
501 
502 	claim_fcxps_mem(mod);
503 }
504 
505 void
bfa_fcxp_iocdisable(struct bfa_s * bfa)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(&mod->fcxp_req_unused_q, &mod->fcxp_req_free_q);
514 	list_splice_tail_init(&mod->fcxp_rsp_unused_q, &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 *
bfa_fcxp_get(struct bfa_fcxp_mod_s * fm,bfa_boolean_t req)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(&fcxp->qe, &fm->fcxp_active_q);
542 
543 	return fcxp;
544 }
545 
546 static void
bfa_fcxp_init_reqrsp(struct bfa_fcxp_s * fcxp,struct bfa_s * bfa,u8 * use_ibuf,u32 * nr_sgles,bfa_fcxp_get_sgaddr_t * r_sga_cbfn,bfa_fcxp_get_sglen_t * r_sglen_cbfn,struct list_head * r_sgpg_q,int n_sgles,bfa_fcxp_get_sgaddr_t sga_cbfn,bfa_fcxp_get_sglen_t sglen_cbfn)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
bfa_fcxp_init(struct bfa_fcxp_s * fcxp,void * caller,struct bfa_s * bfa,int nreq_sgles,int nrsp_sgles,bfa_fcxp_get_sgaddr_t req_sga_cbfn,bfa_fcxp_get_sglen_t req_sglen_cbfn,bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,bfa_fcxp_get_sglen_t rsp_sglen_cbfn)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 		&fcxp->use_ireqbuf, &fcxp->nreq_sgles, &fcxp->req_sga_cbfn,
601 		&fcxp->req_sglen_cbfn, &fcxp->req_sgpg_q,
602 		nreq_sgles, req_sga_cbfn, req_sglen_cbfn);
603 
604 	bfa_fcxp_init_reqrsp(fcxp, bfa,
605 		&fcxp->use_irspbuf, &fcxp->nrsp_sgles, &fcxp->rsp_sga_cbfn,
606 		&fcxp->rsp_sglen_cbfn, &fcxp->rsp_sgpg_q,
607 		nrsp_sgles, rsp_sga_cbfn, rsp_sglen_cbfn);
608 
609 }
610 
611 static void
bfa_fcxp_put(struct bfa_fcxp_s * fcxp)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, wqe->caller, wqe->bfa, wqe->nreq_sgles,
626 			wqe->nrsp_sgles, wqe->req_sga_cbfn,
627 			wqe->req_sglen_cbfn, wqe->rsp_sga_cbfn,
628 			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(&fcxp->qe);
636 
637 	if (fcxp->req_rsp)
638 		list_add_tail(&fcxp->qe, &mod->fcxp_req_free_q);
639 	else
640 		list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q);
641 }
642 
643 static void
bfa_fcxp_null_comp(void * bfad_fcxp,struct bfa_fcxp_s * fcxp,void * cbarg,bfa_status_t req_status,u32 rsp_len,u32 resid_len,struct fchs_s * rsp_fchs)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
__bfa_fcxp_send_cbfn(void * cbarg,bfa_boolean_t complete)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
hal_fcxp_send_comp(struct bfa_s * bfa,struct bfi_fcxp_send_rsp_s * fcxp_rsp)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(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
hal_fcxp_tx_plog(struct bfa_s * bfa,u32 reqlen,struct bfa_fcxp_s * fcxp,struct fchs_s * fchs)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(bfa->plog, BFA_PL_MID_HAL_FCXP,
728 					BFA_PL_EID_TX,
729 					reqlen + sizeof(struct fchs_s), fchs,
730 					pld_w0);
731 		} else {
732 			bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
733 					BFA_PL_EID_TX,
734 					reqlen + sizeof(struct fchs_s),
735 					fchs);
736 		}
737 	} else {
738 		bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_TX,
739 			       reqlen + sizeof(struct fchs_s), fchs);
740 	}
741 }
742 
743 static void
hal_fcxp_rx_plog(struct bfa_s * bfa,struct bfa_fcxp_s * fcxp,struct bfi_fcxp_send_rsp_s * fcxp_rsp)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(bfa->plog, BFA_PL_MID_HAL_FCXP,
753 					      BFA_PL_EID_RX,
754 					      (u16) fcxp_rsp->rsp_len,
755 					      &fcxp_rsp->fchs, pld_w0);
756 		} else {
757 			bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP,
758 				       BFA_PL_EID_RX,
759 				       (u16) fcxp_rsp->rsp_len,
760 				       &fcxp_rsp->fchs);
761 		}
762 	} else {
763 		bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_RX,
764 			       (u16) fcxp_rsp->rsp_len, &fcxp_rsp->fchs);
765 	}
766 }
767 
768 /*
769  * Handler to resume sending fcxp when space in available in cpe queue.
770  */
771 static void
bfa_fcxp_qresume(void * cbarg)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
bfa_fcxp_queue(struct bfa_fcxp_s * fcxp,struct bfi_fcxp_send_req_s * send_req)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, 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, reqi->req_tot_len, fcxp, &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 *
bfa_fcxp_req_rsp_alloc(void * caller,struct bfa_s * bfa,int nreq_sgles,int nrsp_sgles,bfa_fcxp_get_sgaddr_t req_sga_cbfn,bfa_fcxp_get_sglen_t req_sglen_cbfn,bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,bfa_fcxp_get_sglen_t rsp_sglen_cbfn,bfa_boolean_t req)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 *
bfa_fcxp_get_reqbuf(struct bfa_fcxp_s * fcxp)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
bfa_fcxp_get_reqbufsz(struct bfa_fcxp_s * fcxp)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 *
bfa_fcxp_get_rspbuf(struct bfa_fcxp_s * fcxp)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
bfa_fcxp_free(struct bfa_fcxp_s * fcxp)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
bfa_fcxp_send(struct bfa_fcxp_s * fcxp,struct bfa_rport_s * rport,u16 vf_id,u8 lp_tag,bfa_boolean_t cts,enum fc_cos cos,u32 reqlen,struct fchs_s * fchs,bfa_cb_fcxp_send_t cbfn,void * cbarg,u32 rsp_maxlen,u8 rsp_timeout)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
bfa_fcxp_abort(struct bfa_fcxp_s * fcxp)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
bfa_fcxp_req_rsp_alloc_wait(struct bfa_s * bfa,struct bfa_fcxp_wqe_s * wqe,bfa_fcxp_alloc_cbfn_t alloc_cbfn,void * alloc_cbarg,void * caller,int nreq_sgles,int nrsp_sgles,bfa_fcxp_get_sgaddr_t req_sga_cbfn,bfa_fcxp_get_sglen_t req_sglen_cbfn,bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,bfa_fcxp_get_sglen_t rsp_sglen_cbfn,bfa_boolean_t req)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(&wqe->qe, &mod->req_wait_q);
1084 	else
1085 		list_add_tail(&wqe->qe, &mod->rsp_wait_q);
1086 }
1087 
1088 void
bfa_fcxp_walloc_cancel(struct bfa_s * bfa,struct bfa_fcxp_wqe_s * wqe)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(&wqe->qe);
1096 }
1097 
1098 void
bfa_fcxp_discard(struct bfa_fcxp_s * fcxp)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
bfa_fcxp_isr(struct bfa_s * bfa,struct bfi_msg_s * msg)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, (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
bfa_fcxp_get_maxrsp(struct bfa_s * bfa)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
bfa_fcxp_res_recfg(struct bfa_s * bfa,u16 num_fcxp_fw)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(qe, &mod->fcxp_req_unused_q);
1148 		} else {
1149 			bfa_q_deq_tail(&mod->fcxp_rsp_free_q, &qe);
1150 			list_add_tail(qe, &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
bfa_lps_sm_init(struct bfa_lps_s * lps,enum bfa_lps_event event)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(lps->bfa->plog, BFA_PL_MID_LPS,
1180 				BFA_PL_EID_LOGIN, 0, "FDISC Request");
1181 		else
1182 			bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1183 				BFA_PL_EID_LOGIN, 0, "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
bfa_lps_sm_login(struct bfa_lps_s * lps,enum bfa_lps_event event)1221 bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
1222 {
1223 	bfa_trc(lps->bfa, lps->bfa_tag);
1224 	bfa_trc(lps->bfa, event);
1225 
1226 	switch (event) {
1227 	case BFA_LPS_SM_FWRSP:
1228 		if (lps->status == BFA_STATUS_OK) {
1229 			bfa_sm_set_state(lps, bfa_lps_sm_online);
1230 			if (lps->fdisc)
1231 				bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1232 					BFA_PL_EID_LOGIN, 0, "FDISC Accept");
1233 			else
1234 				bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1235 					BFA_PL_EID_LOGIN, 0, "FLOGI Accept");
1236 			/* If N2N, send the assigned PID to FW */
1237 			bfa_trc(lps->bfa, lps->fport);
1238 			bfa_trc(lps->bfa, lps->lp_pid);
1239 
1240 			if (!lps->fport && lps->lp_pid)
1241 				bfa_sm_send_event(lps, BFA_LPS_SM_SET_N2N_PID);
1242 		} else {
1243 			bfa_sm_set_state(lps, bfa_lps_sm_init);
1244 			if (lps->fdisc)
1245 				bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1246 					BFA_PL_EID_LOGIN, 0,
1247 					"FDISC Fail (RJT or timeout)");
1248 			else
1249 				bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
1250 					BFA_PL_EID_LOGIN, 0,
1251 					"FLOGI Fail (RJT or timeout)");
1252 		}
1253 		bfa_lps_login_comp(lps);
1254 		break;
1255 
1256 	case BFA_LPS_SM_OFFLINE:
1257 	case BFA_LPS_SM_DELETE:
1258 		bfa_sm_set_state(lps, bfa_lps_sm_init);
1259 		break;
1260 
1261 	case BFA_LPS_SM_SET_N2N_PID:
1262 		bfa_trc(lps->bfa, lps->fport);
1263 		bfa_trc(lps->bfa, lps->lp_pid);
1264 		break;
1265 
1266 	default:
1267 		bfa_sm_fault(lps->bfa, event);
1268 	}
1269 }
1270 
1271 /*
1272  * login pending - awaiting space in request queue
1273  */
1274 static void
bfa_lps_sm_loginwait(struct bfa_lps_s * lps,enum bfa_lps_event event)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
bfa_lps_sm_online(struct bfa_lps_s * lps,enum bfa_lps_event event)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(lps->bfa->plog, BFA_PL_MID_LPS,
1324 			BFA_PL_EID_LOGO, 0, "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(lps->bfa->plog, BFA_PL_MID_LPS,
1333 			BFA_PL_EID_FIP_FCF_CVL, 0, "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
bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s * lps,enum bfa_lps_event event)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(lps->bfa->plog, BFA_PL_MID_LPS,
1372 			BFA_PL_EID_LOGO, 0, "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(lps->bfa->plog, BFA_PL_MID_LPS,
1382 			BFA_PL_EID_FIP_FCF_CVL, 0, "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
bfa_lps_sm_logout(struct bfa_lps_s * lps,enum bfa_lps_event event)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
bfa_lps_sm_logowait(struct bfa_lps_s * lps,enum bfa_lps_event event)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
bfa_lps_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)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(minfo, lps_kva,
1464 			sizeof(struct bfa_lps_s) * BFA_LPS_MIN_LPORTS);
1465 	else
1466 		bfa_mem_kva_setup(minfo, lps_kva,
1467 			sizeof(struct bfa_lps_s) * BFA_LPS_MAX_LPORTS);
1468 }
1469 
1470 /*
1471  * bfa module attach at initialization time
1472  */
1473 void
bfa_lps_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)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(&mod->lps_free_q);
1491 	INIT_LIST_HEAD(&mod->lps_active_q);
1492 	INIT_LIST_HEAD(&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(&lps->wqe, bfa_lps_reqq_resume, lps);
1499 		list_add_tail(&lps->qe, &mod->lps_free_q);
1500 	}
1501 }
1502 
1503 /*
1504  * IOC in disabled state -- consider all lps offline
1505  */
1506 void
bfa_lps_iocdisable(struct bfa_s * bfa)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(&mod->lps_login_q, &mod->lps_active_q);
1522 }
1523 
1524 /*
1525  * Firmware login response
1526  */
1527 static void
bfa_lps_login_rsp(struct bfa_s * bfa,struct bfi_lps_login_rsp_s * rsp)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(lps, rsp->ext_status);
1568 		break;
1569 
1570 	default:
1571 		/* Nothing to do with other status */
1572 		break;
1573 	}
1574 
1575 	list_del(&lps->qe);
1576 	list_add_tail(&lps->qe, &mod->lps_active_q);
1577 	bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP);
1578 }
1579 
1580 static void
bfa_lps_no_res(struct bfa_lps_s * first_lps,u8 count)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(&lps->qe);
1598 		list_add_tail(&lps->qe, &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
bfa_lps_logout_rsp(struct bfa_s * bfa,struct bfi_lps_logout_rsp_s * rsp)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
bfa_lps_rx_cvl_event(struct bfa_s * bfa,struct bfi_lps_cvl_event_s * cvl)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
bfa_lps_reqq_resume(void * lps_arg)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
bfa_lps_free(struct bfa_lps_s * lps)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(&lps->qe);
1655 	list_add_tail(&lps->qe, &mod->lps_free_q);
1656 }
1657 
1658 /*
1659  * send login request to firmware
1660  */
1661 static void
bfa_lps_send_login(struct bfa_lps_s * lps)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(&lps->qe);
1683 	list_add_tail(&lps->qe, &mod->lps_login_q);
1684 }
1685 
1686 /*
1687  * send logout request to firmware
1688  */
1689 static void
bfa_lps_send_logout(struct bfa_lps_s * lps)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
bfa_lps_send_set_n2n_pid(struct bfa_lps_s * lps)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
bfa_lps_login_comp_cb(void * arg,bfa_boolean_t complete)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(lps->bfa->bfad, lps->uarg, lps->status);
1737 	else
1738 		bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1739 }
1740 
1741 /*
1742  * Login completion handler -- direct call for fcs, queue for others
1743  */
1744 static void
bfa_lps_login_comp(struct bfa_lps_s * lps)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(lps->bfa->bfad, lps->uarg, lps->status);
1755 	else
1756 		bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status);
1757 }
1758 
1759 /*
1760  * Indirect logout completion handler for non-fcs
1761  */
1762 static void
bfa_lps_logout_comp_cb(void * arg,bfa_boolean_t complete)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(lps->bfa->bfad, lps->uarg);
1772 	else
1773 		bfa_cb_lps_flogo_comp(lps->bfa->bfad, lps->uarg);
1774 }
1775 
1776 /*
1777  * Logout completion handler -- direct call for fcs, queue for others
1778  */
1779 static void
bfa_lps_logout_comp(struct bfa_lps_s * lps)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(lps->bfa->bfad, lps->uarg);
1789 }
1790 
1791 /*
1792  * Clear virtual link completion handler for non-fcs
1793  */
1794 static void
bfa_lps_cvl_event_cb(void * arg,bfa_boolean_t complete)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(lps->bfa->bfad, lps->uarg);
1805 }
1806 
1807 /*
1808  * Received Clear virtual link event --direct call for fcs,
1809  * queue for others
1810  */
1811 static void
bfa_lps_cvl_event(struct bfa_lps_s * lps)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(lps->bfa->bfad, lps->uarg);
1823 }
1824 
1825 
1826 
1827 /*
1828  *  lps_public BFA LPS public functions
1829  */
1830 
1831 u32
bfa_lps_get_max_vport(struct bfa_s * bfa)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  *
bfa_lps_alloc(struct bfa_s * bfa)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(&lps->qe, &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
bfa_lps_delete(struct bfa_lps_s * lps)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
bfa_lps_flogi(struct bfa_lps_s * lps,void * uarg,u8 alpa,u16 pdusz,wwn_t pwwn,wwn_t nwwn,bfa_boolean_t auth_en)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
bfa_lps_fdisc(struct bfa_lps_s * lps,void * uarg,u16 pdusz,wwn_t pwwn,wwn_t nwwn)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
bfa_lps_fdisclogo(struct bfa_lps_s * lps)1909 bfa_lps_fdisclogo(struct bfa_lps_s *lps)
1910 {
1911 	bfa_sm_send_event(lps, BFA_LPS_SM_LOGOUT);
1912 }
1913 
1914 u8
bfa_lps_get_fwtag(struct bfa_s * bfa,u8 lp_tag)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
bfa_lps_get_tag_from_pid(struct bfa_s * bfa,u32 pid)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
bfa_lps_get_base_pid(struct bfa_s * bfa)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
bfa_lps_set_n2n_pid(struct bfa_lps_s * lps,uint32_t n2n_pid)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
bfa_lps_isr(struct bfa_s * bfa,struct bfi_msg_s * m)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, msg.login_rsp);
1980 		break;
1981 
1982 	case BFI_LPS_I2H_LOGOUT_RSP:
1983 		bfa_lps_logout_rsp(bfa, msg.logout_rsp);
1984 		break;
1985 
1986 	case BFI_LPS_I2H_CVL_EVENT:
1987 		bfa_lps_rx_cvl_event(bfa, 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
bfa_fcport_aen_post(struct bfa_fcport_s * fcport,enum bfa_port_aen_event event)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(aen_entry, bfad, ++fcport->bfa->bfa_aen_seq,
2011 				  BFA_AEN_CAT_PORT, event);
2012 }
2013 
2014 /*
2015  * FC PORT state machine functions
2016  */
2017 static void
bfa_fcport_sm_uninit(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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
bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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(fcport->bfa->plog, BFA_PL_MID_HAL,
2098 				BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2099 		wwn2str(pwwn_buf, 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, 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, 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
bfa_fcport_sm_enabling(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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, BFA_PORT_LINKUP, 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(fcport->bfa->plog, BFA_PL_MID_HAL,
2165 				BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2166 		wwn2str(pwwn_buf, 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, 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, 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
bfa_fcport_sm_linkdown(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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(fcport->bfa->plog, BFA_PL_MID_HAL,
2207 				BFA_PL_EID_PORT_ST_CHANGE, 0, "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(fcport->bfa->plog, BFA_PL_MID_HAL,
2217 					BFA_PL_EID_FIP_FCF_DISC, 0,
2218 					"FIP FCF Discovery Failed");
2219 			else
2220 				bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2221 					BFA_PL_EID_FIP_FCF_DISC, 0,
2222 					"FIP FCF Discovered");
2223 		}
2224 
2225 		bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE);
2226 		wwn2str(pwwn_buf, 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, 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, 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(fcport->bfa->plog, BFA_PL_MID_HAL,
2257 				BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2258 		wwn2str(pwwn_buf, 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, 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, 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
bfa_fcport_sm_linkup(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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, BFA_PORT_LINKDOWN, BFA_FALSE);
2308 		bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2309 				BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2310 		wwn2str(pwwn_buf, 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, 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, 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, BFA_PORT_LINKDOWN, BFA_FALSE);
2323 		bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2324 				BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
2325 		wwn2str(pwwn_buf, 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, 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, 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(pwwn_buf, 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, 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, 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, BFA_PORT_LINKDOWN, BFA_FALSE);
2358 		wwn2str(pwwn_buf, 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, 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, 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, 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
bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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, 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
bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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
bfa_fcport_sm_disabling(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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(fcport->bfa->plog, BFA_PL_MID_HAL,
2507 				BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2508 		wwn2str(pwwn_buf, 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, 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
bfa_fcport_sm_disabled(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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(fcport->bfa->plog, BFA_PL_MID_HAL,
2562 				BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
2563 		wwn2str(pwwn_buf, 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, 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
bfa_fcport_sm_stopped(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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
bfa_fcport_sm_iocdown(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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
bfa_fcport_sm_iocfail(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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
bfa_fcport_sm_dport(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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
bfa_fcport_sm_ddport(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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
bfa_fcport_sm_faa_misconfig(struct bfa_fcport_s * fcport,enum bfa_fcport_sm_event event)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, BFA_PORT_LINKDOWN, BFA_FALSE);
2756 		bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
2757 			     BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
2758 		bfa_fcport_aen_post(fcport, 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, BFA_PORT_LINKDOWN, 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
bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)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, 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
bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)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
bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)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, 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
bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)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, 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
bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)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
bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)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, 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
bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s * ln,enum bfa_fcport_ln_sm_event event)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, BFA_PORT_LINKDOWN);
2927 		break;
2928 
2929 	default:
2930 		bfa_sm_fault(ln->fcport->bfa, event);
2931 	}
2932 }
2933 
2934 static void
__bfa_cb_fcport_event(void * cbarg,bfa_boolean_t complete)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
bfa_fcport_scn(struct bfa_fcport_s * fcport,enum bfa_port_linkstate event,bfa_boolean_t trunk)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
bfa_fcport_queue_cb(struct bfa_fcport_ln_s * ln,enum bfa_port_linkstate event)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
bfa_fcport_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)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(minfo, fcport_dma, FCPORT_STATS_DMA_SZ);
2993 }
2994 
2995 static void
bfa_fcport_qresume(void * cbarg)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
bfa_fcport_mem_claim(struct bfa_fcport_s * fcport)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
bfa_fcport_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)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(&fcport->stats_pending_q);
3055 	INIT_LIST_HEAD(&fcport->statsclr_pending_q);
3056 
3057 	bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport);
3058 }
3059 
3060 void
bfa_fcport_start(struct bfa_s * bfa)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
bfa_fcport_iocdisable(struct bfa_s * bfa)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
bfa_fcport_update_loop_info(struct bfa_fcport_s * fcport,struct bfa_fcport_loop_info_s * loop_info)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
bfa_fcport_update_linkinfo(struct bfa_fcport_s * fcport)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 				&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
bfa_fcport_reset_linkinfo(struct bfa_fcport_s * fcport)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
bfa_fcport_send_enable(struct bfa_fcport_s * fcport)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
bfa_fcport_send_disable(struct bfa_fcport_s * fcport)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
bfa_fcport_set_wwns(struct bfa_fcport_s * fcport)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
bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s * d,struct bfa_qos_stats_s * s)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
bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s * d,struct bfa_fcoe_stats_s * s)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
__bfa_cb_fcport_stats_get(void * cbarg,bfa_boolean_t complete)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(&ret->fcqos,
3280 							&fcport->stats->fcqos);
3281 				else {
3282 					bfa_fcport_fcoe_stats_swap(&ret->fcoe,
3283 							&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(&fcport->stats_pending_q);
3294 		fcport->stats_status = BFA_STATUS_OK;
3295 	}
3296 }
3297 
3298 static void
bfa_fcport_stats_get_timeout(void * cbarg)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(fcport, BFA_TRUE);
3312 }
3313 
3314 static void
bfa_fcport_send_stats_get(void * cbarg)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(&fcport->stats_reqq_wait,
3325 				bfa_fcport_send_stats_get, 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
__bfa_cb_fcport_stats_clr(void * cbarg,bfa_boolean_t complete)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(&fcport->statsclr_pending_q);
3359 		fcport->stats_status = BFA_STATUS_OK;
3360 	}
3361 }
3362 
3363 static void
bfa_fcport_stats_clr_timeout(void * cbarg)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(fcport, BFA_TRUE);
3377 }
3378 
3379 static void
bfa_fcport_send_stats_clear(void * cbarg)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(&fcport->stats_reqq_wait,
3390 				bfa_fcport_send_stats_clear, 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
bfa_trunk_scn(struct bfa_fcport_s * fcport,struct bfi_fcport_trunk_scn_s * scn)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(fcport->bfa->plog, BFA_PL_MID_HAL,
3457 			BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,1)");
3458 		break;
3459 	case 2:
3460 		bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3461 			BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(-,1)");
3462 		break;
3463 	case 1:
3464 		bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3465 			BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,-)");
3466 		break;
3467 	default:
3468 		bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
3469 			BFA_PL_EID_TRUNK_SCN, 0, "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, (scn->trunk_state == BFA_TRUNK_ONLINE) ?
3478 			BFA_PORT_LINKUP : BFA_PORT_LINKDOWN, BFA_TRUE);
3479 	}
3480 }
3481 
3482 static void
bfa_trunk_iocdisable(struct bfa_s * bfa)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, BFA_PORT_LINKDOWN, 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
bfa_fcport_init(struct bfa_s * bfa)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
bfa_fcport_isr(struct bfa_s * bfa,struct bfi_msg_s * msg)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, 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(&fcport->stats_pending_q) ||
3627 		    (fcport->stats_status == BFA_STATUS_ETIMER))
3628 			break;
3629 
3630 		bfa_timer_stop(&fcport->timer);
3631 		fcport->stats_status = i2hmsg.pstatsget_rsp->status;
3632 		__bfa_cb_fcport_stats_get(fcport, 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(&fcport->statsclr_pending_q) ||
3640 		    (fcport->stats_status == BFA_STATUS_ETIMER))
3641 			break;
3642 
3643 		bfa_timer_stop(&fcport->timer);
3644 		fcport->stats_status = BFA_STATUS_OK;
3645 		__bfa_cb_fcport_stats_clr(fcport, 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
bfa_fcport_event_register(struct bfa_s * bfa,void (* cbfn)(void * cbarg,enum bfa_port_linkstate event),void * cbarg)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
bfa_fcport_enable(struct bfa_s * bfa)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(&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
bfa_fcport_disable(struct bfa_s * bfa)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(&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
bfa_fcport_is_pbcdisabled(struct bfa_s * bfa)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
bfa_fcport_cfg_speed(struct bfa_s * bfa,enum bfa_port_speed speed)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(&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
bfa_fcport_get_speed(struct bfa_s * bfa)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
bfa_fcport_cfg_topology(struct bfa_s * bfa,enum bfa_port_topology topology)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
bfa_fcport_get_topology(struct bfa_s * bfa)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
bfa_fcport_get_cfg_topology(struct bfa_s * bfa)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
bfa_fcport_cfg_hardalpa(struct bfa_s * bfa,u8 alpa)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
bfa_fcport_clr_hardalpa(struct bfa_s * bfa)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
bfa_fcport_get_hardalpa(struct bfa_s * bfa,u8 * alpa)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
bfa_fcport_get_myalpa(struct bfa_s * bfa)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
bfa_fcport_cfg_maxfrsize(struct bfa_s * bfa,u16 maxfrsize)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
bfa_fcport_get_maxfrsize(struct bfa_s * bfa)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
bfa_fcport_get_rx_bbcredit(struct bfa_s * bfa)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
bfa_fcport_set_tx_bbcredit(struct bfa_s * bfa,u16 tx_bbcredit)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
bfa_fcport_get_wwn(struct bfa_s * bfa,bfa_boolean_t node)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
bfa_fcport_get_attr(struct bfa_s * bfa,struct bfa_port_attr_s * attr)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(hal_port_sm_table, 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(&fcport->bfa->ioc))
3992 			attr->port_state = BFA_PORT_ST_IOCDIS;
3993 		else if (bfa_ioc_fw_mismatch(&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
bfa_fcport_get_stats(struct bfa_s * bfa,struct bfa_cb_pending_q_s * cb)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(&fcport->statsclr_pending_q))
4016 		return BFA_STATUS_DEVBUSY;
4017 
4018 	if (list_empty(&fcport->stats_pending_q)) {
4019 		list_add_tail(&cb->hcb_qe.qe, &fcport->stats_pending_q);
4020 		bfa_fcport_send_stats_get(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(&cb->hcb_qe.qe, &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
bfa_fcport_clear_stats(struct bfa_s * bfa,struct bfa_cb_pending_q_s * cb)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(&fcport->stats_pending_q))
4043 		return BFA_STATUS_DEVBUSY;
4044 
4045 	if (list_empty(&fcport->statsclr_pending_q)) {
4046 		list_add_tail(&cb->hcb_qe.qe, &fcport->statsclr_pending_q);
4047 		bfa_fcport_send_stats_clear(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(&cb->hcb_qe.qe, &fcport->statsclr_pending_q);
4053 
4054 	return BFA_STATUS_OK;
4055 }
4056 
4057 /*
4058  * Fetch port attributes.
4059  */
4060 bfa_boolean_t
bfa_fcport_is_disabled(struct bfa_s * bfa)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(hal_port_sm_table, fcport->sm) ==
4066 		BFA_PORT_ST_DISABLED;
4067 
4068 }
4069 
4070 bfa_boolean_t
bfa_fcport_is_dport(struct bfa_s * bfa)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(hal_port_sm_table, fcport->sm) ==
4076 		BFA_PORT_ST_DPORT);
4077 }
4078 
4079 bfa_boolean_t
bfa_fcport_is_ddport(struct bfa_s * bfa)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(hal_port_sm_table, fcport->sm) ==
4085 		BFA_PORT_ST_DDPORT);
4086 }
4087 
4088 bfa_status_t
bfa_fcport_set_qos_bw(struct bfa_s * bfa,struct bfa_qos_bw_s * qos_bw)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
bfa_fcport_is_ratelim(struct bfa_s * bfa)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
bfa_fcport_cfg_faa(struct bfa_s * bfa,u8 state)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
bfa_fcport_get_ratelim_speed(struct bfa_s * bfa)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
bfa_fcport_beacon(void * dev,bfa_boolean_t beacon,bfa_boolean_t link_e2e_beacon)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
bfa_fcport_is_linkup(struct bfa_s * bfa)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
bfa_fcport_is_qos_enabled(struct bfa_s * bfa)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
bfa_fcport_is_trunk_enabled(struct bfa_s * bfa)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
bfa_fcport_cfg_bbcr(struct bfa_s * bfa,bfa_boolean_t on_off,u8 bb_scn)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(&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
bfa_fcport_get_bbcr_attr(struct bfa_s * bfa,struct bfa_bbcr_attr_s * bbcr_attr)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(&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
bfa_fcport_dportenable(struct bfa_s * bfa)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(&bfa->modules.port, BFA_TRUE);
4269 }
4270 
4271 void
bfa_fcport_dportdisable(struct bfa_s * bfa)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(&bfa->modules.port, BFA_FALSE);
4279 }
4280 
4281 static void
bfa_fcport_ddportenable(struct bfa_s * bfa)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
bfa_fcport_ddportdisable(struct bfa_s * bfa)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
bfa_rport_sm_uninit(struct bfa_rport_s * rp,enum bfa_rport_event event)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
bfa_rport_sm_created(struct bfa_rport_s * rp,enum bfa_rport_event event)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(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
bfa_rport_sm_fwcreate(struct bfa_rport_s * rp,enum bfa_rport_event event)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
bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s * rp,enum bfa_rport_event event)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(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
bfa_rport_sm_online(struct bfa_rport_s * rp,enum bfa_rport_event event)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(rp->rport_drv,
4486 						    qos_scn->old_qos_attr,
4487 						    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(rp->rport_drv,
4491 						  qos_scn->old_qos_attr,
4492 						  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
bfa_rport_sm_fwdelete(struct bfa_rport_s * rp,enum bfa_rport_event event)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
bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s * rp,enum bfa_rport_event event)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
bfa_rport_sm_offline(struct bfa_rport_s * rp,enum bfa_rport_event event)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(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
bfa_rport_sm_deleting(struct bfa_rport_s * rp,enum bfa_rport_event event)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(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(rp);
4623 		break;
4624 
4625 	default:
4626 		bfa_sm_fault(rp->bfa, event);
4627 	}
4628 }
4629 
4630 static void
bfa_rport_sm_deleting_qfull(struct bfa_rport_s * rp,enum bfa_rport_event event)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(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
bfa_rport_sm_delete_pending(struct bfa_rport_s * rp,enum bfa_rport_event event)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(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
bfa_rport_sm_offline_pending(struct bfa_rport_s * rp,enum bfa_rport_event event)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
bfa_rport_sm_iocdisable(struct bfa_rport_s * rp,enum bfa_rport_event event)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(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
__bfa_cb_rport_online(void * cbarg,bfa_boolean_t complete)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(rp->rport_drv);
4773 }
4774 
4775 static void
__bfa_cb_rport_offline(void * cbarg,bfa_boolean_t complete)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(rp->rport_drv);
4782 }
4783 
4784 static void
bfa_rport_qresume(void * cbarg)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
bfa_rport_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)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(minfo, rport_kva,
4803 		cfg->fwcfg.num_rports * sizeof(struct bfa_rport_s));
4804 }
4805 
4806 void
bfa_rport_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)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(&mod->rp_free_q);
4815 	INIT_LIST_HEAD(&mod->rp_active_q);
4816 	INIT_LIST_HEAD(&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(&rp->qe, &mod->rp_free_q);
4836 
4837 		bfa_reqq_winit(&rp->reqq_wait, bfa_rport_qresume, rp);
4838 	}
4839 
4840 	/*
4841 	 * consume memory
4842 	 */
4843 	bfa_mem_kva_curp(mod) = (u8 *) rp;
4844 }
4845 
4846 void
bfa_rport_iocdisable(struct bfa_s * bfa)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(&mod->rp_unused_q, &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 *
bfa_rport_alloc(struct bfa_rport_mod_s * mod)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(&rport->qe, &mod->rp_active_q);
4870 
4871 	return rport;
4872 }
4873 
4874 static void
bfa_rport_free(struct bfa_rport_s * rport)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(&rport->qe);
4881 	list_add_tail(&rport->qe, &mod->rp_free_q);
4882 }
4883 
4884 static bfa_boolean_t
bfa_rport_send_fwcreate(struct bfa_rport_s * rp)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(rp->bfa, (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
bfa_rport_send_fwdelete(struct bfa_rport_s * rp)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
bfa_rport_send_fwspeed(struct bfa_rport_s * rp)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
bfa_rport_isr(struct bfa_s * bfa,struct bfi_msg_s * m)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 				&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->rport_drv);
5023 		break;
5024 
5025 	default:
5026 		bfa_trc(bfa, m->mhdr.msg_id);
5027 		WARN_ON(1);
5028 	}
5029 }
5030 
5031 void
bfa_rport_res_recfg(struct bfa_s * bfa,u16 num_rport_fw)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(qe, &mod->rp_unused_q);
5041 	}
5042 }
5043 
5044 /*
5045  *  bfa_rport_api
5046  */
5047 
5048 struct bfa_rport_s *
bfa_rport_create(struct bfa_s * bfa,void * rport_drv)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
bfa_rport_online(struct bfa_rport_s * rport,struct bfa_rport_info_s * rport_info)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
bfa_rport_speed(struct bfa_rport_s * rport,enum bfa_port_speed speed)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
bfa_rport_set_lunmask(struct bfa_s * bfa,struct bfa_rport_s * rp)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->rport_tag, lp_tag);
5112 }
5113 
5114 /* Unset Rport LUN mask */
5115 void
bfa_rport_unset_lunmask(struct bfa_s * bfa,struct bfa_rport_s * rp)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
bfa_sgpg_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)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(minfo, seg_ptr,
5161 					per_seg_sgpg * sgpg_sz);
5162 		} else
5163 			bfa_mem_dma_setup(minfo, seg_ptr,
5164 					num_sgpg * sgpg_sz);
5165 	}
5166 
5167 	/* kva memory */
5168 	bfa_mem_kva_setup(minfo, sgpg_kva,
5169 		cfg->drvcfg.num_sgpgs * sizeof(struct bfa_sgpg_s));
5170 }
5171 
5172 void
bfa_sgpg_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)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(&mod->sgpg_q);
5190 	INIT_LIST_HEAD(&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(&hsgpg->qe, &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
bfa_sgpg_malloc(struct bfa_s * bfa,struct list_head * sgpg_q,int nsgpgs)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(&hsgpg->qe, sgpg_q);
5249 	}
5250 
5251 	mod->free_sgpgs -= nsgpgs;
5252 	return BFA_STATUS_OK;
5253 }
5254 
5255 void
bfa_sgpg_mfree(struct bfa_s * bfa,struct list_head * sgpg_q,int nsgpg)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(sgpg_q, &mod->sgpg_q);
5265 
5266 	if (list_empty(&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, &wqe->sgpg_q, nsgpg);
5279 		wqe->nsgpg -= nsgpg;
5280 		if (wqe->nsgpg == 0) {
5281 			list_del(&wqe->qe);
5282 			wqe->cbfn(wqe->cbarg);
5283 		}
5284 	} while (mod->free_sgpgs && !list_empty(&mod->sgpg_wait_q));
5285 }
5286 
5287 void
bfa_sgpg_wait(struct bfa_s * bfa,struct bfa_sgpg_wqe_s * wqe,int nsgpg)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(&mod->sgpg_q, &wqe->sgpg_q);
5306 		wqe->nsgpg -= mod->free_sgpgs;
5307 		mod->free_sgpgs = 0;
5308 	}
5309 
5310 	list_add_tail(&wqe->qe, &mod->sgpg_wait_q);
5311 }
5312 
5313 void
bfa_sgpg_wcancel(struct bfa_s * bfa,struct bfa_sgpg_wqe_s * wqe)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(&wqe->qe);
5320 
5321 	if (wqe->nsgpg_total != wqe->nsgpg)
5322 		bfa_sgpg_mfree(bfa, &wqe->sgpg_q,
5323 				   wqe->nsgpg_total - wqe->nsgpg);
5324 }
5325 
5326 void
bfa_sgpg_winit(struct bfa_sgpg_wqe_s * wqe,void (* cbfn)(void * cbarg),void * cbarg)5327 bfa_sgpg_winit(struct bfa_sgpg_wqe_s *wqe, void (*cbfn) (void *cbarg),
5328 		   void *cbarg)
5329 {
5330 	INIT_LIST_HEAD(&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
__bfa_cb_uf_recv(void * cbarg,bfa_boolean_t complete)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
claim_uf_post_msgs(struct bfa_uf_mod_s * ufm)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
claim_ufs(struct bfa_uf_mod_s * ufm)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(&uf->qe, &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
uf_mem_claim(struct bfa_uf_mod_s * ufm)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
bfa_uf_meminfo(struct bfa_iocfc_cfg_s * cfg,struct bfa_meminfo_s * minfo,struct bfa_s * bfa)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(minfo, seg_ptr,
5435 				per_seg_uf * BFA_PER_UF_DMA_SZ);
5436 		} else
5437 			bfa_mem_dma_setup(minfo, seg_ptr,
5438 				num_ufs * BFA_PER_UF_DMA_SZ);
5439 	}
5440 
5441 	/* kva memory */
5442 	bfa_mem_kva_setup(minfo, uf_kva, cfg->fwcfg.num_uf_bufs *
5443 		(sizeof(struct bfa_uf_s) + sizeof(struct bfi_uf_buf_post_s)));
5444 }
5445 
5446 void
bfa_uf_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)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(&ufm->uf_free_q);
5455 	INIT_LIST_HEAD(&ufm->uf_posted_q);
5456 	INIT_LIST_HEAD(&ufm->uf_unused_q);
5457 
5458 	uf_mem_claim(ufm);
5459 }
5460 
5461 static struct bfa_uf_s *
bfa_uf_get(struct bfa_uf_mod_s * uf_mod)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
bfa_uf_put(struct bfa_uf_mod_s * uf_mod,struct bfa_uf_s * uf)5471 bfa_uf_put(struct bfa_uf_mod_s *uf_mod, struct bfa_uf_s *uf)
5472 {
5473 	list_add_tail(&uf->qe, &uf_mod->uf_free_q);
5474 }
5475 
5476 static bfa_status_t
bfa_uf_post(struct bfa_uf_mod_s * ufm,struct bfa_uf_s * uf)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(&uf->qe, &ufm->uf_posted_q);
5492 	return BFA_STATUS_OK;
5493 }
5494 
5495 static void
bfa_uf_post_all(struct bfa_uf_mod_s * uf_mod)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(uf_mod, uf) != BFA_STATUS_OK)
5502 			break;
5503 	}
5504 }
5505 
5506 static void
uf_recv(struct bfa_s * bfa,struct bfi_uf_frm_rcvd_s * m)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(&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(bfa->plog, BFA_PL_MID_HAL_UF, BFA_PL_EID_RX,
5531 			       uf->data_len, (struct fchs_s *)buf);
5532 	} else {
5533 		u32 pld_w0 = *((u32 *) (buf + sizeof(struct fchs_s)));
5534 		bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_UF,
5535 				      BFA_PL_EID_RX, uf->data_len,
5536 				      (struct fchs_s *)buf, pld_w0);
5537 	}
5538 
5539 	if (bfa->fcs)
5540 		__bfa_cb_uf_recv(uf, BFA_TRUE);
5541 	else
5542 		bfa_cb_queue(bfa, &uf->hcb_qe, __bfa_cb_uf_recv, uf);
5543 }
5544 
5545 void
bfa_uf_iocdisable(struct bfa_s * bfa)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(&ufm->uf_unused_q, &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(&uf->qe);
5558 		bfa_uf_put(ufm, uf);
5559 	}
5560 }
5561 
5562 void
bfa_uf_start(struct bfa_s * bfa)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
bfa_uf_recv_register(struct bfa_s * bfa,bfa_cb_uf_recv_t ufrecv,void * cbarg)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
bfa_uf_free(struct bfa_uf_s * uf)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
bfa_uf_isr(struct bfa_s * bfa,struct bfi_msg_s * msg)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, (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
bfa_uf_res_recfg(struct bfa_s * bfa,u16 num_uf_fw)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(qe, &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
bfa_fcdiag_set_busy_status(struct bfa_fcdiag_s * fcdiag)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
bfa_fcdiag_attach(struct bfa_s * bfa,void * bfad,struct bfa_iocfc_cfg_s * cfg,struct bfa_pcidev_s * pcidev)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(&dport->reqq_wait, bfa_dport_qresume, 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
bfa_fcdiag_iocdisable(struct bfa_s * bfa)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
bfa_fcdiag_queuetest_timeout(void * cbarg)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
bfa_fcdiag_queuetest_send(struct bfa_fcdiag_s * fcdiag)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
bfa_fcdiag_queuetest_comp(struct bfa_fcdiag_s * fcdiag,bfi_diag_qtest_rsp_t * rsp)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(&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
bfa_fcdiag_loopback_comp(struct bfa_fcdiag_s * fcdiag,struct bfi_diag_lb_rsp_s * rsp)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
bfa_fcdiag_loopback_send(struct bfa_fcdiag_s * fcdiag,struct bfa_diag_loopback_s * loopback)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
bfa_fcdiag_intr(struct bfa_s * bfa,struct bfi_msg_s * msg)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 				(struct bfi_diag_lb_rsp_s *) msg);
5902 		break;
5903 	case BFI_DIAG_I2H_QTEST:
5904 		bfa_fcdiag_queuetest_comp(fcdiag, (bfi_diag_qtest_rsp_t *)msg);
5905 		break;
5906 	case BFI_DIAG_I2H_DPORT:
5907 		bfa_dport_req_comp(&fcdiag->dport,
5908 				(struct bfi_diag_dport_rsp_s *)msg);
5909 		break;
5910 	case BFI_DIAG_I2H_DPORT_SCN:
5911 		bfa_dport_scn(&fcdiag->dport,
5912 				(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
bfa_fcdiag_loopback(struct bfa_s * bfa,enum bfa_port_opmode opmode,enum bfa_port_speed speed,u32 lpcnt,u32 pat,struct bfa_diag_loopback_result_s * result,bfa_cb_diag_t cbfn,void * cbarg)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(&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);
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(&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);
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
bfa_fcdiag_queuetest(struct bfa_s * bfa,u32 force,u32 queue,struct bfa_diag_qtest_result_s * result,bfa_cb_diag_t cbfn,void * cbarg)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
bfa_fcdiag_lb_is_running(struct bfa_s * bfa)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
bfa_cb_fcdiag_dport(struct bfa_dport_s * dport,bfa_status_t bfa_status)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
bfa_dport_sm_disabled(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)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(dport->bfa);
6144 		if (bfa_dport_send_req(dport, 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(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
bfa_dport_sm_enabling_qwait(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)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, 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_FAILED);
6191 		break;
6192 
6193 	default:
6194 		bfa_sm_fault(dport->bfa, event);
6195 	}
6196 }
6197 
6198 static void
bfa_dport_sm_enabling(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)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(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_FAILED);
6225 		break;
6226 
6227 	default:
6228 		bfa_sm_fault(dport->bfa, event);
6229 	}
6230 }
6231 
6232 static void
bfa_dport_sm_enabled(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)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, 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(dport->bfa);
6247 		if (bfa_dport_send_req(dport, 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(dport->bfa);
6278 
6279 			if (bfa_dport_send_req(dport, 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(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
bfa_dport_sm_disabling_qwait(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)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, 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_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
bfa_dport_sm_disabling(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)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_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
bfa_dport_sm_starting_qwait(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)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, 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_FAILED);
6372 		break;
6373 
6374 	default:
6375 		bfa_sm_fault(dport->bfa, event);
6376 	}
6377 }
6378 
6379 static void
bfa_dport_sm_starting(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)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_FAILED);
6403 		break;
6404 
6405 	default:
6406 		bfa_sm_fault(dport->bfa, event);
6407 	}
6408 }
6409 
6410 static void
bfa_dport_sm_dynamic_disabling(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)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(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_OK);
6435 		break;
6436 
6437 	default:
6438 		bfa_sm_fault(dport->bfa, event);
6439 	}
6440 }
6441 
6442 static void
bfa_dport_sm_dynamic_disabling_qwait(struct bfa_dport_s * dport,enum bfa_dport_sm_event event)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, 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_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
bfa_dport_send_req(struct bfa_dport_s * dport,enum bfi_dport_req req)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
bfa_dport_qresume(void * cbarg)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
bfa_dport_req_comp(struct bfa_dport_s * dport,struct bfi_diag_dport_rsp_s * msg)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, msg->status);
6527 }
6528 
6529 static bfa_boolean_t
bfa_dport_is_sending_req(struct bfa_dport_s * dport)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
bfa_dport_scn(struct bfa_dport_s * dport,struct bfi_diag_dport_scn_s * msg)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
bfa_dport_enable(struct bfa_s * bfa,u32 lpcnt,u32 pat,bfa_cb_diag_t cbfn,void * cbarg)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(&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
bfa_dport_disable(struct bfa_s * bfa,bfa_cb_diag_t cbfn,void * cbarg)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(&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
bfa_dport_start(struct bfa_s * bfa,u32 lpcnt,u32 pat,bfa_cb_diag_t cbfn,void * cbarg)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
bfa_dport_show(struct bfa_s * bfa,struct bfa_diag_dport_result_s * result)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